Scanning
O Scanning (ou Varredura, em Português Brasileiro) é uma técnica usada em segurança cibernética para coletar informações sobre sistemas, redes ou dispositivos, identificando seus serviços, portas abertas, vulnerabilidades e outras características. A varredura é uma fase crítica em um teste de penetração ou auditoria de segurança, permitindo aos profissionais mapear a superfície de ataque de um alvo, seja uma rede, servidor ou dispositivo. Existem algumas classificações para o Scanning:
Varredura de Portas
Tem como objetivo identificar portas abertas em um sistema ou rede que estão escutando por conexões. Aqui usamos ferramentas como: Nmap e Masscan.Varredura de Vulnerabilidades
Tem como objetivo detectar vulnerabilidades conhecidas em sistemas ou aplicativos, como softwares desatualizados ou mal configurados. Aqui usamos ferramentas como: OpenVAS, Nessus e Qualys.Varredura de Rede
Tem como objetivo mapear a topologia da rede, identificando dispositivos, hosts ativos, rotas e serviços disponíveis. Aqui usamos ferramentas como: Nmap, e Netdiscover.Varredura de Serviços
Tem como objetivo identificar quais serviços estão rodando em um sistema e suas versões. Aqui usamos ferramentas como: Nmap e Nikto.Varredura Web
Tem como objetivo descobrir diretórios, páginas e vulnerabilidades em aplicações web. Aqui usamos ferramentas como: Dirb, Gobuster e Nikto.
Netdiscover
O Netdiscover é uma ferramenta que permite encontrar hosts ativos em uma rede local. Ele funciona bem em redes Wi-Fi ou cabeadas, sendo útil para detectar outros dispositivos conectados.
# Exibir todos os dispositivos na sub-rede 192.168.1.0/24 (Modo ativo):
netdiscover -r 192.168.1.0/24
# Monitora dispositivos sem enviar pacotes ARP (Modo passivo):
netdiscover -p
Banner Grabbing
Banner Grabbing é uma técnica de enumeração para descobrir a versão exata de um serviço e buscar vulnerabilidades associadas.
# Usando Netcat (NC) para pegar banners:
nc -v 192.168.1.100 80
# Usando Nmap:
nmap -sV --script=banner 192.168.1.100
Se descobrirmos que um Apache 2.4.10 está rodando, podemos procurar exploits conhecidos para essa versão.
Nmap
O Nmap (Network Mapper) é uma ferramenta amplamente utilizada para varredura de rede e auditoria de segurança. Ele é uma ferramenta de código aberto que permite aos administradores de rede e profissionais de segurança mapear redes, identificar dispositivos conectados, descobrir portas abertas e detectar serviços em execução. É um dos utilitários mais populares para realizar reconhecimento e auditorias de segurança.
O Nmap pode identificar portas abertas em dispositivos ou servidores, determinando quais serviços estão escutando por conexões em cada porta. Além de identificar portas abertas, o Nmap pode descobrir quais serviços estão rodando e suas versões. Isso ajuda a saber se há versões vulneráveis de softwares em execução. O Nmap também pode tentar identificar o sistema operacional que está rodando em um dispositivo ou servidor, com base em padrões de resposta a pacotes de rede.
Ele pode mapear redes inteiras, descobrindo quais dispositivos estão ativos em uma rede e suas respectivas configurações. Pode detectar a presença de firewalls, filtros de pacotes, e outras medidas de segurança que podem estar bloqueando ou modificando pacotes de rede. Uma das funcionalidades mais poderosas do Nmap é o NSE (Nmap Scripting Engine), que permite usar scripts para realizar varreduras mais específicas e avançadas, como detecção de vulnerabilidades, ataques de força bruta, ou exploração de falhas conhecidas.
O NSE é parte do nmap e seus scripts ficam no diretório /usr/share/nmap/
. Ainda no método de scanning de vulnerabilidades, encontra-se disponível na internet diversos scripts no padrão NSE que também atuam testando vulnerabilidades conhecidas. Dentre os existentes, temos o Nmap Vulscan e o Nmap-Vulners.
A tabela abaixo demonstra os principais parâmetros do comando nmap.
Parâmetro | Descrição |
---|---|
-sS | Realiza uma varredura TCP SYN (half-open), rápida e furtiva. |
-sT | Realiza uma varredura TCP Connect, completa a conexão com as portas. |
-sT | Varredura TCP Connect, completa a conexão com as portas (não furtiva, mais detectável). |
-sA | Varredura TCP ACK, usada para verificar o estado do firewall (se está filtrando pacotes). |
-sW | Varredura TCP Window, similar à -sA , mas aproveita variações no tamanho da janela TCP. |
-sM | Varredura TCP Maimon, utilizada para detectar portas filtradas em alguns firewalls. |
-sU | Varredura de portas UDP, usada para identificar serviços UDP ativos. |
-sn | Varredura de Ping para descobrir hosts ativos sem verificar portas. |
-sV | Detecta os serviços rodando em portas abertas e suas respectivas versões. |
-sC | Executa os scripts padrões do Nmap, que incluem uma série de verificações comuns de segurança. |
-O | Detecta o sistema operacional do host alvo. |
-p | Especifica as portas a serem verificadas. Exemplo: -p 80,443 . |
-p- | Escaneia todas as 65535 portas TCP. |
-iL | Lê os alvos a partir de um arquivo de lista. |
-sO | Varredura de protocolos IP, verifica quais protocolos estão habilitados no alvo. |
-sY | Varredura SCTP INIT, para descobrir portas SCTP abertas (protocolo de comunicação). |
-sZ | Varredura SCTP COOKIE-ECHO, semelhante à -sY , mas completa o handshake SCTP. |
-sN | Varredura TCP NULL, não envia nenhum flag nos pacotes TCP (varredura furtiva). |
-sF | Varredura TCP FIN, envia apenas o flag FIN, útil para contornar alguns firewalls. |
-sX | Varredura TCP Xmas, envia flags FIN, PSH, URG, caracterizando uma varredura furtiva. |
-sI | Varredura Idle Scan, usa um host ocioso como "zumbi" para realizar varreduras sem ser detectado. |
-Pn | Varredura sem envio de pacotes de Ping, assume que o host está ativo e varre sem checar conectividade. |
-D ip1,ip2,ip3 | É usado para realizar uma varredura disfarçada através da utilização de decoys (cobaias), além de logar o IP de quem está consultando, loga outros endereços IP. |
--min-rate=10000 | Força o Nmap a enviar pelo menos 10.000 pacotes por segundo, o que torna o scan bem mais rápido (mas pode ser detectado facilmente por sistemas de segurança). |
Abaixo vamos ver alguns tipos de varredura usando o Nmap.
Uma das varreduras mais rápidas e usadas, envia pacotes SYN (Varredura TCP SYN) e analisa as respostas para determinar se uma porta está aberta, sem completar a conexão TCP.
$ nmap -sS scanme.nmap.org
Realiza uma varredura completa de TCP (TCP Connect), abrindo e fechando as conexões com as portas-alvo.
$ nmap -sT scanme.nmap.org
Varre portas UDP para verificar se serviços como DNS, DHCP e SNMP estão ativos, o que pode ser mais lento que varreduras TCP.
$ nmap -sU scanme.nmap.org
Detecta quais hosts estão ativos na rede (usando ping), ignorando as portas abertas, útil para descobrir dispositivos ativos.
$ nmap -sn 192.168.1.0/24
Identifica os serviços que estão rodando em portas abertas e suas respectivas versões.
$ nmap -sV scanme.nmap.org
Tenta detectar o sistema operacional que está rodando no host.
$ nmap -O scanme.nmap.org
Realiza uma varredura rápida, buscando as portas mais comuns.
$ nmap scanme.nmap.org
Esse comando
Verifica se as portas 80 (HTTP) e 443 (HTTPS) estão abertas.
$ nmap -p 80,443 scanme.nmap.org
Varre toda a rede para encontrar dispositivos ativos e suas portas abertas.
$ nmap 192.168.1.0/24
Executa scripts NSE para procurar vulnerabilidades conhecidas no alvo.
$ nmap --script vuln scanme.nmap.org
Para usar outro host como intermediário para realizar uma varredura furtiva, você pode utilizar a técnica de Idle Scan com o parâmetro -sI
no Nmap. Nesta varredura, um host ocioso (chamado de zumbi) é usado para enviar pacotes ao alvo, permitindo que o atacante permaneça invisível, já que o alvo vê o zumbi como o originador do tráfego.
$ nmap -Pn -sI 192.168.1.100 scanme.nmap.org
# O host 192.168.1.100 é o 'zumbi'. Ainda é possível usar uma porta
# aberta no servidor zumbi:
$ nmap -Pn -sI 192.168.1.100:445 scanme.nmap.org
Um comando prático do NMAP que serve para todas as ocasiões como primeira varredura é o seguinte:
$ nmap -Pn -sV -sC -p- -T5 scanme.nmap.org
nmap -sS -sV -sC -p- 127.0.0.1 --min-rate=10000
Instalando mais scripts para o NMAP:
cd /usr/share/nmap/scripts
sudo git clone https://github.com/vulnersCom/nmap-vulners
sudo git clone https://github.com/scipag/vulscan
# Para executar:
nmap -sV IP --script nmap-vulners/vulners
nmap -sV IP --script vulscan/vulscan
nmap -sV 172.16.1.243 --script vulscan/vulscan --script-args vulscandb=exploitdb.csv
# Manter a base atualizada:
cd /usr/share/nmap/scripts/vulscan/utilities/updater
sudo chmod +x updateFiles.sh
./updateFiles.sh
Metasploitable
O Metasploitable é uma máquina virtual intencionalmente vulnerável, projetada para treinamento e prática de pentest e exploração de vulnerabilidades. Executar ela no Docker simplifica o processo de configuração de ambiente.
# Para instalar o Docker:
curl -fsSL https://get.docker.com/ | sh
# Baixar a imagem do metasploit:
docker pull tleemcjr/metasploitable2
# Executar o container usando a imagem baixada:
docker run --name metasploitable2 --rm -it tleemcjr/metasploitable2
Para baixar a imagem do Metasploitable em VM, acesse aqui.
O usuário padrão é
msfadmin
e a senha padrão émsfadmin
.
Enumeração
A enumeração é uma das fases mais importantes no pentest e na análise de segurança, pois permite coletar informações detalhadas sobre o sistema alvo. Nesta etapa, o objetivo é identificar serviços ativos, usuários, diretórios, compartilhamentos e possíveis vulnerabilidades. A fase de scanning nos diz "o que está aberto", e a fase de enumeração nos responde "o que podemos fazer com isso".
Durante a fase de enumeração tentamos coletar algumas informações, como?
- Serviços e versões específicas que rodam no servidor
- Informações sobre autenticação
- Usuários do sistema
- Diretórios e arquivos ocultos
- Compartilhamentos de rede
- Privilégios de acesso
Com base nesses dados, podemos descobrir pontos fracos e planejar a melhor abordagem para obter acesso não autorizado ao sistema (de forma ética, claro).
A enumeração é uma etapa fundamental e inicial do pentest em aplicações web. O básico recomendado é:
- Escaneamento e enumeração do servidor web
- Análise de código-fonte da aplicação
- Enumeração de diretórios (com ferramentas como Gobuster)
- Identificação das plataformas e tecnologias empregadas
- Análise de versões e busca por vulnerabilidades conhecidas
Enumeração para HTTP/HTTPS
A enumeração web é uma das etapas mais importantes e complexas do pentest, pois os servidores web utilizam diversas tecnologias, frameworks e configurações específicas que podem conter vulnerabilidades. Saber qual servidor web está rodando (Apache, Nginx, IIS) e sua versão pode ajudar a encontrar vulnerabilidades conhecidas.
Podemos começar fazendo uma simples busca com o nmap
:
$ nmap -p 80,443 --script http-server-header example.com
Starting Nmap 7.95 ( https://nmap.org ) at 2025-03-09 08:48 EDT
Nmap scan report for example.com (96.7.128.198)
Host is up (0.17s latency).
Other addresses for example.com (not scanned): 23.192.228.80 23.192.228.84 23.215.0.136 23.215.0.138 96.7.128.175 2600:1406:3a00:21::173e:2e66 2600:1406:bc00:53::b81e:94c8 2600:1406:bc00:53::b81e:94ce 2600:1408:ec00:36::1736:7f24 2600:1408:ec00:36::1736:7f31 2600:1406:3a00:21::173e:2e65
rDNS record for 96.7.128.198: a96-7-128-198.deploy.static.akamaitechnologies.com
PORT STATE SERVICE
80/tcp open http
|_http-server-header: AkamaiGHost
443/tcp open https
|_http-server-header: AkamaiGHost
Nmap done: 1 IP address (1 host up) scanned in 2.34 seconds
Retorna qual servidor web está rodando. Nesse caso o servidor web respondeu com o nome AkamaiGHost. Isso significa que o site está usando a CDN da Akamai, que é uma das maiores redes de entrega de conteúdo e proteção contra ataques DDoS, também esconde o servidor real por trás da infraestrutura da Akamai, dificultando ataques diretos ao site original.
Whatweb
O WhatWeb
analisa um site e identifica tecnologias usadas, como CMS (WordPress, Joomla), frameworks, linguagens de programação e servidores web.
$ whatweb example.com
http://example.com [200 OK] Country[UNITED STATES][US], HTML5, IP[23.192.228.80], Title[Example Domain]
# Usando um modo descritivo:
$ whatweb -v example.com
WhatWeb report for http://example.com
Status : 200 OK
Title : Example Domain
IP : 96.7.128.198
Country : UNITED STATES, US
Summary : HTML5
Detected Plugins:
[ HTML5 ]
HTML version 5, detected by the doctype declaration
HTTP Headers:
HTTP/1.1 200 OK
Content-Type: text/html
ETag: "84238dfc8092e5d9c0dac8ef93371a07:1736799080.121134"
Last-Modified: Mon, 13 Jan 2025 20:11:20 GMT
Vary: Accept-Encoding
Cache-Control: max-age=965
Date: Sun, 09 Mar 2025 12:56:49 GMT
Content-Length: 1256
Connection: close
Nikto
O Nikto é uma ferramenta de pentest web que realiza testes automatizados em servidores HTTP para encontrar problemas de segurança, arquivos sensíveis e falhas de configuração.
Se o Nikto não estiver instalado no Kali Linux, basta rodar:
# Instalar o nikto:
$ sudo apt install nikto -y
# Para verificar se está funcionando:
$ nikto -Version
Nikto 2.5.0 (LW 2.5)
Podemos usar o nikto da seguinte maneira:
nikto -h http://example.com
# Para testar uma porta específica:
nikto -h example.com -p 8080
# Se o servidor tiver um certificado SSL inválido, o Nikto pode falhar.
# Para ignorar erros SSL:
nikto -h https://example.com -nossl
O Nikto testará configurações erradas, arquivos ocultos e falhas de segurança.
Enumeração de Diretórios
A enumeração de diretórios web pode revelar painéis administrativos, backups e arquivos sensíveis.
DIRB
O DIRB é uma ferramenta de força bruta para descobrir diretórios e arquivos ocultos em servidores web. Ele não depende de vulnerabilidades, mas sim da existência de arquivos e diretórios que muitas vezes são deixados expostos. Diferente de ferramentas mais modernas como Gobuster e Feroxbuster, o DIRB não usa threads, o que o torna mais lento, mas útil quando queremos evitar sobrecarregar o servidor.
# Usa a wordlist padrão do Dirb para buscar diretórios ocultos:
dirb http://example.com /usr/share/wordlists/dirb/common.txt
# Procura por arquivos '.php', '.txt' e '.bak':
dirb http://example.com -X .php,.txt,.bak
# Busca diretórios e arquivos típicos do WordPress:
dirb http://example.com /usr/share/wordlists/dirb/wordpress.txt
dirb http://example.com /usr/share/wordlists/dirb/big.txt
DIRBUSTER
O DirBuster é uma ferramenta de brute-force para descobrir diretórios e arquivos ocultos em servidores web. Diferente do DIRB, ele é multithreaded e recursivo, tornando-o mais rápido e agressivo.
Para abrir a interface gráfica para configuração da wordlist e threads execute o comando abaixo:
dirbuster
Para executar via terminal (modo CLI):
# O comando abaixo executa um scan com 50 threads testando arquivos '.php' e '.html':
dirbuster -u http://example.com -l /usr/share/wordlists/dirb/common.txt -t 50 -e php,html
GOBUSTER
O Gobuster é uma ferramenta de força bruta para descoberta de diretórios, arquivos e subdomínios em servidores web. Ele foi desenvolvido para ser mais rápido que outras ferramentas como Dirb e DirBuster, pois usa múltiplas threads e não depende do interpretador de comandos do sistema.
No meu Kali ele não estava instalado, para instalar ele faça:
# Para instalar manualmente:
$ sudo apt install gobuster -y
# Se estiver em outra distribuição Linux, pode fazer assim (precisa ter o Go instalado):
$ sudo go install github.com/OJ/gobuster/v3@latest
O uso mais comum do Gobuster é descobrir diretórios e arquivos ocultos em sites. Abaixo podemos conferir alguns comandos mais usados:
# Fazer uma varredura de diretórios usando a wordlist 'common.txt':
gobuster dir -u http://example.com -w /usr/share/wordlists/dirb/common.txt
# Buscando arquivos específicos como .php, .html, .bak:
gobuster dir -u http://example.com -w /usr/share/wordlists/dirb/common.txt -x php,html,bak
# Limitando a saída para diretórios realmente acessíveis ou protegidos:
gobuster dir -u http://example.com -w /usr/share/wordlists/dirb/common.txt -s "200,301,403"
# Tentando descobrir subdomínios de example.com usando uma wordlist de DNS:
gobuster dns -d example.com -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-110000.txt
FEROXBUSTER
O Feroxbuster é uma ferramenta de enumeração de diretórios e arquivos web, escrita em Rust, o que a torna extremamente rápida e estável. Ele foi criado para substituir ferramentas mais antigas como Dirb, DirBuster e Gobuster, combinando velocidade, recursividade automática e estabilidade.
No meu Kali ele não estava instalado, para instalar ele faça:
# Para instalar manualmente:
$ sudo apt install feroxbuster -y
Abaixo podemos ver os usos mais comum do feroxbuster:
# Encontrando diretórios e arquivos ocultos automaticamente:
feroxbuster -u http://example.com
# Usando uma wordlist personalizada para buscar diretórios mais relevantes:
feroxbuster -u http://example.com -w /usr/share/wordlists/dirb/common.txt
# Testando apenas essas extensões PHP, HTML ou backups:
feroxbuster -u http://example.com -x php,html,txt,bak
# Se o servidor retorna muitos códigos 403 (Forbidden) ou 302 (Redirecionamento), podemos ignorá-los:
feroxbuster -u http://example.com -C 403,302
# Evitando que recursão vá muito fundo na estrutura de diretórios:
feroxbuster -u http://example.com --depth 2
# Se a wordlist contém palavras que sabemos que não são úteis, podemos ignorá-las:
feroxbuster -u http://example.com --dont-filter -w wordlist.txt
DIRSEARCH
O Dirsearch é uma ferramenta rápida e poderosa para descobrir diretórios e arquivos ocultos em sites. Ele é escrito em Python e possui várias funcionalidades avançadas que o tornam uma das melhores opções para pentest web.
# Testando extensões específicas e usando 30 threads para acelerar a busca:
dirsearch -u http://example.com -e php,txt,bak -t 30
# Usanod uma wordlist:
dirsearchy -u http://example.com -w /usr/share/wordlists/dirb/common.txt
# Buscando Arquivos com extensões específicas:
dirsearch -u http://example.com -e php,html,bak
# Filtrando resultados por código de resposta:
dirsearch -u http://example.com -f 200,301
# Mudando o User-Agent:
dirsearch -u http://example.com -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"
# Usando um Proxy para Ofuscação:
dirsearch -u http://example.com --proxy http://127.0.0.1:8080
Enumeração de Compartilhamentos SMB (Samba)
O SMB (Server Message Block) é um protocolo de compartilhamento de arquivos e impressoras em redes Windows. Se um servidor SMB estiver mal configurado, ele pode permitir acesso anônimo, revelando arquivos sensíveis, usuários e permissões incorretas.
SMBCLIENT
O smbclient é uma ferramenta de linha de comando que permite conectar-se a servidores SMB/CIFS (Samba) e acessar compartilhamentos de arquivos em redes Windows e Linux. Ele funciona de forma similar ao comando ftp, permitindo listar diretórios, baixar arquivos e enviar arquivos para compartilhamentos SMB.
# Verificando quais pastas estão disponíveis:
smbclient -L //192.168.1.100 -N
## Se houver permissões incorretas, podemos acessar arquivos sem credenciais!
# Acessando um compartilhamento específico:
smbclient //192.168.1.100/SHARE -N
SMBMAP
O SMBMAP é uma ferramenta usada para listar permissões de diretórios compartilhados via SMB/CIFS em servidores Windows e Linux. Diferente do smbclient, que exige interação manual, o SMBMAP permite mapear rapidamente os compartilhamentos SMB, verificar permissões e até baixar arquivos automaticamente.
# Listando permissões SMB no alvo:
smbmap -H 192.168.1.100
# Testar com um usuário específico:
smbmap -H 192.168.1.100 -u admin -p password
# Testar Várias Credenciais Automaticamente:
smbmap -H 192.168.1.100 -u users.txt -p passwords.txt
ENUM4LINUX
O Enum4Linux é uma ferramenta essencial para enumeração de informações SMB/RPC em servidores Windows e Linux. Ele permite descobrir usuários, grupos, políticas de senha, compartilhamentos e muito mais.
# Fazendo uma enumeração Completa:
enum4linux -a 192.168.1.100
# Listando Apenas Usuários do Windows:
enum4linux -U 192.168.1.100
# Listando apenas Grupos:
enum4linux -G 192.168.1.100
# Listando Apenas Compartilhamentos SMB:
enum4linux -S 192.168.1.100
# Testando Acesso com um Usuário Específico:
enum4linux -a -u administrator -p senha123 192.168.1.100
Enumeração de RPC
A RPC (Remote Procedure Call) da Microsoft permite que programas em diferentes computadores se comuniquem remotamente, sendo um dos componentes fundamentais de redes Windows e Samba (SMB). O rpcclient
é uma ferramenta que permite interagir diretamente com um serviço RPC e executar comandos para coletar informações sobre o alvo, ele pode ser instalado através do pacote samba-client
.
# Testando a conexão sem credenciais:
rpcclient -U "" -N 192.168.1.100
## Se conseguirmos conexão, podemos tentar enumerar usuários registrados no servidor Windows:
enumdomusers
Enumeração de SMTP
O SMTP (Simple Mail Transfer Protocol) é o protocolo responsável pelo envio de e-mails em servidores de correio eletrônico. Embora o SMTP não permita acesso à caixa de entrada e saída, ele pode ser explorado para descobrir nomes de usuários válidos no sistema. A enumeração SMTP pode ser uma das maneiras mais simples de obter uma lista de usuários válidos para um ataque mais avançado!
Antes de usarmos ferramentas automatizadas, podemos testar manualmente se o servidor SMTP permite enumeração de usuários:
nmap -p 25,587,465 --script smtp-ntlm-info example.com
Se a porta SMTP estiver aberta, podemos testar a enumeração de usuários manualmente:
# Inicie a conexão:
telnet example.com 25
# Se a conexão for aceita, podemos verificar se um usuário existe:
VRFY administrator
# Mostrando usuários internos:
EXPN admin@domain.com
# Tentando iniciar o envio de um e-mail para ver se o usuário existe.
# Se o servidor SMTP responder com um código 250 OK, significa que o usuário existe:
MAIL FROM:<test@example.com>
RCPT TO:<admin@example.com>
smtp-user-enum
A ferramenta smtp-user-enum
permite testar automaticamente múltiplos nomes de usuários em um servidor SMTP, verificando quais existem.
# Testando os usuários da lista 'users.txt' usando o comando VRFY:
smtp-user-enum -M VRFY -U users.txt -t example.com
# Usando a wordlist 'RockYou' para testar milhares de nomes comuns:
smtp-user-enum -M VRFY -U /usr/share/wordlists/rockyou.txt -t example.com
# Usando o comando EXPN para verificar listas de e-mail
smtp-user-enum -M EXPN -U users.txt -t example.com
# Usar 'RCPT TO' caso 'VRFY' e 'EXPN' estejam desativados:
smtp-user-enum -M RCPT -U users.txt -t example.com
SMTP com Metasploit
O Metasploit tem um módulo auxiliar para automatizar a enumeração SMTP.
# Abrir o Metasploit:
msfconsole
# Carregar o módulo de enumeração SMTP:
use auxiliary/scanner/smtp/smtp_enum
# Configurar o alvo e a wordlist:
set RHOSTS example.com
set USER_FILE /usr/share/wordlists/rockyou.txt
set THREADS 10
# Executar o ataque
run
O Metasploit testa todos os usuários da wordlist e lista quais existem no servidor.
Enumeração de SSH
O SSH (Secure Shell) é um protocolo seguro usado para acesso remoto a servidores. No entanto, se mal configurado, ele pode permitir enumeração de usuários, o que pode ser explorado em ataques de brute-force e autenticação sem senha.
# Verificando se o SSH está aberto e quais métodos de autenticação são aceitos:
$ nmap -p 22 --script ssh-hostkey,ssh2-enum-algos,ssh-auth-methods 192.168.122.7
Starting Nmap 7.95 ( https://nmap.org ) at 2025-03-09 10:24 EDT
Nmap scan report for ubuntu2204 (192.168.122.7)
Host is up (0.00036s latency).
PORT STATE SERVICE
22/tcp open ssh
| ssh-auth-methods:
| Supported authentication methods:
| publickey
|_ password
| ssh-hostkey:
| 256 6d:a5:88:1c:7a:de:80:65:bf:81:92:cb:97:f5:91:64 (ECDSA)
|_ 256 60:41:9d:50:e4:32:6a:9f:5d:14:ed:51:04:16:33:24 (ED25519)
| ssh2-enum-algos:
| kex_algorithms: (11)
| curve25519-sha256
| curve25519-sha256@libssh.org
| ecdh-sha2-nistp256
| ecdh-sha2-nistp384
| ecdh-sha2-nistp521
| sntrup761x25519-sha512@openssh.com
| diffie-hellman-group-exchange-sha256
| diffie-hellman-group16-sha512
| diffie-hellman-group18-sha512
| diffie-hellman-group14-sha256
| kex-strict-s-v00@openssh.com
| server_host_key_algorithms: (4)
| rsa-sha2-512
| rsa-sha2-256
| ecdsa-sha2-nistp256
| ssh-ed25519
| encryption_algorithms: (6)
| chacha20-poly1305@openssh.com
| aes128-ctr
| aes192-ctr
| aes256-ctr
| aes128-gcm@openssh.com
| aes256-gcm@openssh.com
| mac_algorithms: (10)
| umac-64-etm@openssh.com
| umac-128-etm@openssh.com
| hmac-sha2-256-etm@openssh.com
| hmac-sha2-512-etm@openssh.com
| hmac-sha1-etm@openssh.com
| umac-64@openssh.com
| umac-128@openssh.com
| hmac-sha2-256
| hmac-sha2-512
| hmac-sha1
| compression_algorithms: (2)
| none
|_ zlib@openssh.com
MAC Address: 52:54:00:6C:57:CD (QEMU virtual NIC)
Nmap done: 1 IP address (1 host up) scanned in 0.42 seconds
Para ver todos os scripts do ssh use:
nmap --script-help all | grep ssh
.
O trecho abaixo indica os tipos de autenticação aceitos pelo SSH:
| ssh-auth-methods:
| Supported authentication methods:
| publickey
|_ password
O trecho abaixo mostra os algoritmos que o servidor está usando:
| ssh-hostkey:
| 256 6d:a5:88:1c:7a:de:80:65:bf:81:92:cb:97:f5:91:64 (ECDSA)
|_ 256 60:41:9d:50:e4:32:6a:9f:5d:14:ed:51:04:16:33:24 (ED25519)
O trecho abaixo indica que o servidor está sendo executado em uma máquina virtual (QEMU/KVM):
MAC Address: 52:54:00:6C:57:CD (QEMU virtual NIC)
Enumeração de NFS
O NFS (Network File System) é um protocolo que permite o compartilhamento de diretórios e arquivos entre sistemas Linux/Unix. Se um servidor NFS estiver mal configurado, um invasor pode montar remotamente o diretório compartilhado e acessar arquivos sem autenticação.
# Verificando se o NFS está aberto:
nmap -p 111,2049 --script nfs-ls,nfs-showmount,nfs-statfs 192.168.1.100
# Podemos usar o rpcinfo para verificar as versões suportadas pelo NFS no servidor:
rpcinfo -p 192.168.1.100
BurpSuite
O BurpSuite é uma ferramenta essencial para análise e manipulação de tráfego em aplicações web. Ele funciona como um proxy intermediário entre o navegador e o servidor, permitindo que o analista intercepte, visualize e altere requisições e respostas HTTP em tempo real. Ao contrário de ferramentas como DIRB ou Gobuster, que são focadas em enumeração direta de diretórios ou arquivos, o BurpSuite é voltado para exploração mais profunda, identificando falhas de segurança a partir do comportamento da aplicação.
Apesar disso, ele pode ser utilizado para enumeração de parâmetros, fuzzing e ataques de força bruta, especialmente com o módulo Intruder. Além disso, seu recurso Repeater permite repetir requisições modificadas manualmente, enquanto o Decoder ajuda na análise e manipulação de dados codificados. É uma ferramenta interativa, ideal para investigações detalhadas em testes de penetração web.
Após iniciar o BurpSuite, configure o navegador para usar o proxy local (geralmente 127.0.0.1:8080). A partir daí, todo o tráfego HTTP/HTTPS do navegador será interceptado
Com o módulo Repeater, você pode modificar e reenviar requisições específicas. Com o módulo Intruder, é possível automatizar testes como brute force em logins.
Enumeração de SNMP
O SNMP (Simple Network Management Protocol) é um protocolo da camada de aplicação usado para monitoramento e gerenciamento de dispositivos de rede, como roteadores, switches, servidores e impressoras.
# Verificando se o SNMP está aberto:
nmap -sU -p 161 --script snmp-info,snmp-interfaces 192.168.1.100
onesixtyone
O SNMP usa "community strings" como uma espécie de senha. Se a community string estiver configurada como "public" ou "private", qualquer pessoa pode coletar dados do dispositivo. Podemos então tentar várias community strings para descobrir qual está sendo usada:
# Verificando se o SNMP está aberto:
onesixtyone -c /usr/share/seclists/Discovery/SNMP/common-snmp-community-strings-onesixtyone.txt 192.168.1.100
snmp-check
Com a informação da community que está configurada, podemos coletar informações detalhadas sobre o sistema.
snmp-check 192.168.1.100 -c public