Skip to main content


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.

Terminal
# 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 é uma técnica de enumeração para descobrir a versão exata de um serviço e buscar vulnerabilidades associadas.


Terminal
# 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âmetroDescrição
-sSRealiza uma varredura TCP SYN (half-open), rápida e furtiva.
-sTRealiza uma varredura TCP Connect, completa a conexão com as portas.
-sTVarredura TCP Connect, completa a conexão com as portas (não furtiva, mais detectável).
-sAVarredura TCP ACK, usada para verificar o estado do firewall (se está filtrando pacotes).
-sWVarredura TCP Window, similar à -sA, mas aproveita variações no tamanho da janela TCP.
-sMVarredura TCP Maimon, utilizada para detectar portas filtradas em alguns firewalls.
-sUVarredura de portas UDP, usada para identificar serviços UDP ativos.
-snVarredura de Ping para descobrir hosts ativos sem verificar portas.
-sVDetecta os serviços rodando em portas abertas e suas respectivas versões.
-sCExecuta os scripts padrões do Nmap, que incluem uma série de verificações comuns de segurança.
-ODetecta o sistema operacional do host alvo.
-pEspecifica as portas a serem verificadas. Exemplo: -p 80,443.
-p-Escaneia todas as 65535 portas TCP.
-iLLê os alvos a partir de um arquivo de lista.
-sOVarredura de protocolos IP, verifica quais protocolos estão habilitados no alvo.
-sYVarredura SCTP INIT, para descobrir portas SCTP abertas (protocolo de comunicação).
-sZVarredura SCTP COOKIE-ECHO, semelhante à -sY, mas completa o handshake SCTP.
-sNVarredura TCP NULL, não envia nenhum flag nos pacotes TCP (varredura furtiva).
-sFVarredura TCP FIN, envia apenas o flag FIN, útil para contornar alguns firewalls.
-sXVarredura TCP Xmas, envia flags FIN, PSH, URG, caracterizando uma varredura furtiva.
-sIVarredura Idle Scan, usa um host ocioso como "zumbi" para realizar varreduras sem ser detectado.
-PnVarredura 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=10000Forç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.

Terminal
$ nmap -sS scanme.nmap.org

Realiza uma varredura completa de TCP (TCP Connect), abrindo e fechando as conexões com as portas-alvo.

Terminal
$ 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.

Terminal
$ nmap -sU scanme.nmap.org

Detecta quais hosts estão ativos na rede (usando ping), ignorando as portas abertas, útil para descobrir dispositivos ativos.

Terminal
$ nmap -sn 192.168.1.0/24

Identifica os serviços que estão rodando em portas abertas e suas respectivas versões.

Terminal
$ nmap -sV scanme.nmap.org

Tenta detectar o sistema operacional que está rodando no host.

Terminal
$ nmap -O scanme.nmap.org

Realiza uma varredura rápida, buscando as portas mais comuns.

Terminal
$ nmap scanme.nmap.org

Esse comando


Verifica se as portas 80 (HTTP) e 443 (HTTPS) estão abertas.

Terminal
$ nmap -p 80,443 scanme.nmap.org

Varre toda a rede para encontrar dispositivos ativos e suas portas abertas.

Terminal
$ nmap 192.168.1.0/24

Executa scripts NSE para procurar vulnerabilidades conhecidas no alvo.

Terminal
$ 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.

Terminal
$ 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:

Terminal
$ nmap -Pn -sV -sC -p- -T5 scanme.nmap.org

Terminal
nmap -sS -sV -sC -p- 127.0.0.1 --min-rate=10000

Instalando mais scripts para o NMAP:


Terminal
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.


Terminal
# 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:

Terminal
$ 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.


Terminal
$ 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:

Terminal
# 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:

Terminal
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.


Terminal
# 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:

Terminal
dirbuster

Para executar via terminal (modo CLI):

Terminal
# 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:

Terminal
# 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:

Terminal
# 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:

Terminal
# Para instalar manualmente:
$ sudo apt install feroxbuster -y

Abaixo podemos ver os usos mais comum do feroxbuster:

Terminal
# 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.


Terminal
# 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.


Terminal
# 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.


Terminal
# 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.


Terminal
# 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.


Terminal
# 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:

Terminal
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:

Terminal
# 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.


Terminal
# 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.


Terminal
# 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.


Terminal
# 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.


Terminal
# 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.


Terminal
# 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:


Terminal
# 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.


Terminal
snmp-check 192.168.1.100 -c public