Segurança da Informação Admin

Reconhecimento Ativo: Nmap, Masscan, Banner Grabbing e Enumeração: Do Básico ao Avançado Já leu

Reconhecimento Ativo: Fundamentos e Importância O reconhecimento ativo é a etapa inicial do processo de teste de penetração onde um profissional interaje diretamente com os sistemas alvo para descobrir informações sobre infraestrutura, serviços em execução, versões de software e possíveis vulnerabilidades. Diferentemente do reconhecimento passivo, que coleta dados sem contato direto, o reconhecimento ativo gera tráfego detectável e logs, deixando rastros na rede-alvo. Essa abordagem é fundamental porque fornece uma visão precisa do ambiente real, permitindo identificar pontos de entrada e vetores de ataque com maior acurácia. A importância do reconhecimento ativo reside na redução de incertezas. Um firewall pode bloquear uma porta, um serviço pode estar rodando em uma versão diferente da esperada, ou um aplicativo pode estar desabilitado. Apenas enviando pacotes específicos e analisando as respostas é possível construir um mapa confiável do alvo. Isso economiza tempo nas fases posteriores e evita suposições erradas que poderiam levar a conclusões incorretas sobre a postura de segurança. Ética e Legalidade

Reconhecimento Ativo: Fundamentos e Importância

O reconhecimento ativo é a etapa inicial do processo de teste de penetração onde um profissional interaje diretamente com os sistemas alvo para descobrir informações sobre infraestrutura, serviços em execução, versões de software e possíveis vulnerabilidades. Diferentemente do reconhecimento passivo, que coleta dados sem contato direto, o reconhecimento ativo gera tráfego detectável e logs, deixando rastros na rede-alvo. Essa abordagem é fundamental porque fornece uma visão precisa do ambiente real, permitindo identificar pontos de entrada e vetores de ataque com maior acurácia.

A importância do reconhecimento ativo reside na redução de incertezas. Um firewall pode bloquear uma porta, um serviço pode estar rodando em uma versão diferente da esperada, ou um aplicativo pode estar desabilitado. Apenas enviando pacotes específicos e analisando as respostas é possível construir um mapa confiável do alvo. Isso economiza tempo nas fases posteriores e evita suposições erradas que poderiam levar a conclusões incorretas sobre a postura de segurança.

Ética e Legalidade

Antes de qualquer coisa, deixe claro: o reconhecimento ativo deve ter autorização explícita por escrito. Realizar essas atividades sem permissão é ilegal em praticamente todas as jurisdições. Sempre trabalhe dentro de um escopo bem definido, com datas de início e término, e com a assinatura de stakeholders responsáveis. Teste apenas sistemas para os quais você tem permissão documentada.

Nmap: O Scanner de Portas Clássico e Poderoso

O Nmap (Network Mapper) é a ferramenta mais tradicional e confiável para descoberta de hosts e mapeamento de portas. Desenvolvido há mais de 25 anos, ele permite identificar quais portas estão abertas, filtradas ou fechadas em um host, além de detectar o sistema operacional e versões de serviços. Sua flexibilidade e velocidade o tornam indispensável em qualquer teste de segurança profissional.

Conceitos Fundamentais de Varredura

O Nmap funciona enviando pacotes especificamente crafted e analisando as respostas. A técnica mais conhecida é a SYN scan (half-open scan), que envia um pacote TCP SYN para a porta. Se a porta está aberta, o alvo responde com SYN-ACK; se está fechada, responde com RST. Essa técnica é rápida e deixa menos rastros nos logs do que uma conexão TCP completa, pois nunca finaliza o three-way handshake.

Existem outras técnicas: Connect scan (conexão TCP completa), UDP scan (para descobrir serviços UDP), ACK scan (para mapear firewalls), e NULL/FIN/Xmas scans (técnicas evasivas que exploram o RFC 793). Cada uma tem um propósito específico e é escolhida conforme a situação exigir.

Uso Prático do Nmap

Aqui está um exemplo real e funcional de varredura com Nmap:

# Scan básico de portas comuns (top 1000)
nmap -sS -p- 192.168.1.100

# Scan SYN em portas específicas com detecção de versão
nmap -sS -p 22,80,443,3306,5432 -sV 192.168.1.100

# Scan agressivo com detecção de SO e scripts
nmap -A -O -sC 192.168.1.100

# Scan em range de IPs com output estruturado
nmap -sS -p 1-65535 -oX output.xml 192.168.1.0/24

# Scan UDP nas portas mais comuns
nmap -sU -p 53,123,161,162,67,68 192.168.1.100

# Scan silencioso com fragmentação (evasão)
nmap -sS --fragment -p 22,80,443 192.168.1.100

O flag -sS executa SYN scan, -sV detecta versões, -A ativa detecção agressiva (SO, versão, scripts), -p- escaneia todas as 65535 portas, e -oX salva em XML para análise posterior. O comando nmap -A -O -sC 192.168.1.100 fornecerá informações completas sobre o alvo: portas abertas, versões de serviços, sistema operacional estimado e resultados de scripts NSE (Nmap Scripting Engine).

NSE: Scripts para Automação Avançada

O Nmap Script Engine permite executar scripts Lua para automação complexa, detecção de vulnerabilidades específicas e coleta de informações adicionais. Os scripts estão em /usr/share/nmap/scripts/ e cobrem desde consultas a protocolos específicos até testes de autenticação padrão.

# Executar scripts de descoberta de informações
nmap --script discovery 192.168.1.100

# Testar vulnerabilidades conhecidas
nmap --script vuln -sV 192.168.1.100

# Script específico: detecção de Samba
nmap --script smb-os-discovery -p 139,445 192.168.1.100

# Múltiplos scripts com argumentos
nmap --script http-title,http-headers -p 80,443 192.168.1.100

# Descobrir informações SNMP
nmap --script snmp-info -p 161 192.168.1.100

Os scripts NSE são poderosos porque reutilizam lógica já testada. Em vez de investigar manualmente como interrogar um serviço SMB, você executa um script que já sabe fazer isso corretamente. Isso economiza horas de trabalho e reduz erros.

Masscan: Velocidade Extrema para Grandes Redes

Enquanto o Nmap é preciso e versátil, o Masscan é o sprinter da descoberta de hosts. Desenvolvido para scanear a internet inteira em horas, ele pode enviar dezenas de milhões de pacotes por segundo, tornando-o ideal para reconhecimento em redes classe B ou C inteiras. A desvantagem é a menor precisão em comparação com Nmap, especialmente em ambientes com muita latência ou perda de pacotes.

Quando Usar Masscan

O Masscan excels em cenários onde você precisa varrer rapidamente um grande range de IPs e portas para encontrar alvos interessantes. Por exemplo, em um teste de penetração de uma organização com múltiplas subredes, usar Masscan para uma primeira passada (identificando hosts com porta 80, 443 ou 22 abertas) e depois usar Nmap para análise detalhada é uma estratégia comum e eficiente.

Uso Prático do Masscan

# Scan simples em range de IPs
masscan 192.168.1.0/24 -p 22,80,443 --rate 10000

# Scan em múltiplas portas com output em format Nmap
masscan 10.0.0.0/16 -p 1-65535 --rate 50000 -oX output.xml

# Scan UDP em porta 53 (DNS)
masscan 192.168.0.0/16 -p U:53 --rate 100000

# Output em formato gnmap para importar no Nmap
masscan 192.168.1.0/24 -p 80,443,8080,8443 --rate 5000 -oG results.gnmap

# Scan com timing agressivo (cuidado: pode sobrecarregar)
masscan 192.168.1.0/24 -p 22,80,443 --rate 1000000 --wait 0

O flag --rate controla quantos pacotes por segundo são enviados. Um valor alto (100000+) é possível em conexões de internet rápidas, mas pode causar congestionamento. Em uma rede corporativa, use valores mais conservadores (5000-20000). O Masscan gera output que pode ser convertido para Nmap XML com --oX ou importado diretamente em ferramentas de análise.

Interpretação de Resultados do Masscan

Os resultados do Masscan são simples: ele lista apenas hosts e portas abertas. Não fornece informação sobre versão de serviços ou sistema operacional. Por isso, é comum pipear resultados do Masscan diretamente para Nmap:

# Executar Masscan e alimentar resultados no Nmap
masscan 192.168.1.0/24 -p 22,80,443 --rate 10000 -oG - | grep open | awk '{print $2}' | sort -u > hosts.txt

# Usar os hosts encontrados em um scan Nmap detalhado
nmap -iL hosts.txt -sV -sC -O -oX detailed_scan.xml

Essa combinação oferece o melhor dos dois mundos: a velocidade do Masscan para descobrir hosts e a precisão do Nmap para análise detalhada.

Banner Grabbing e Enumeração de Serviços

Banner grabbing é a técnica de extrair informações dos serviços em execução conectando-se a eles e lendo as mensagens iniciais que enviam. Muitos serviços (HTTP, SSH, SMTP, FTP, Telnet) exibem automaticamente versão, nome do software ou informações do servidor. Essa informação é ouro puro para um profissional de segurança, pois permite mapear vulnerabilidades conhecidas.

Técnicas Manuais de Banner Grabbing

A forma mais simples é usar ferramentas padrão do sistema operacional:

# Telnet (se disponível) - conecta direto ao serviço
telnet 192.168.1.100 22
# Respostas esperadas: "SSH-2.0-OpenSSH_7.4p1 Debian-10+deb9u6"

# Netcat: conecta e exibe tudo
nc -v 192.168.1.100 22
nc -v 192.168.1.100 25  # SMTP
nc -v 192.168.1.100 80  # HTTP (enviar GET / HTTP/1.1 manualmente)

# curl para HTTP com headers detalhados
curl -I -v http://192.168.1.100:80/
curl -I -v https://192.168.1.100:443/

# openssl para HTTPS e TLS
openssl s_client -connect 192.168.1.100:443 -showcerts

# conexão SSH básica para ver banner
ssh -v 192.168.1.100 -p 22 2>&1 | grep "SSH"

Observe que no HTTP, você precisa enviar uma requisição válida (GET / HTTP/1.1) para obter respostas. Ferramentas como curl fazem isso automaticamente. No SMTP (porta 25), o servidor frequentemente envia uma saudação assim que você conecta: "220 mailserver.example.com ESMTP Postfix 2.9.6".

Banner Grabbing com Nmap

O Nmap já integra detecção de banner através do flag -sV (version detection) e dos scripts NSE:

# Detecção básica de versão
nmap -sV -p 22,25,80,110,143,443,445,3306,5432 192.168.1.100

# Usar scripts específicos para banner grabbing
nmap --script=banner -p 22,25,80,110,143,445 192.168.1.100

# Combinado: probing agressivo com NSE
nmap -sV -sC --script=banner,http-title,http-headers -p 1-10000 192.168.1.100

Quando você executa nmap -sV, o Nmap conecta brevemente a cada porta e coleta as informações iniciais. Isso é mais confiável que manual porque ele já conhece o formato esperado de cada serviço.

Enumeração em Profundidade de Serviços Específicos

Banner grabbing é só o começo. Enumeração significa extrair todas as informações úteis do serviço: usuários, compartilhamentos, versões internas, configurações. Aqui estão exemplos para serviços comuns:

# SMB/Samba (Windows Shares) - portas 139, 445
nmap --script smb-enum-shares,smb-enum-users,smb-os-discovery -p 139,445 192.168.1.100

# SNMP (porta 161) - se community string padrão
snmp-check -t 192.168.1.100 -c public
nmap --script snmp-info,snmp-processes,snmp-interfaces -p 161 192.168.1.100

# LDAP (porta 389)
nmap --script ldap-search -p 389 192.168.1.100

# FTP (porta 21)
nmap --script ftp-anon,ftp-syst -p 21 192.168.1.100

# HTTP (portas 80, 8080, 8000, etc)
nmap --script http-title,http-headers,http-methods,http-robots.txt -p 80,8080 192.168.1.100

# DNS Zone Transfer (porta 53)
nmap --script dns-zone-transfer -p 53 192.168.1.100

# RDP (porta 3389)
nmap --script rdp-ntlm-info -p 3389 192.168.1.100

Cada um desses comandos tenta extrair informações sem estar necessariamente testando vulnerabilidades específicas. Por exemplo, http-robots.txt verifica se existe um arquivo /robots.txt que lista diretórios que não devem ser indexados — muitas vezes revelando pontos interessantes do site.

Script Python para Enumeração Customizada

Para casos onde você precisa de algo mais específico, um script Python pode automatizar o banner grabbing:

#!/usr/bin/env python3
import socket
import sys

def grab_banner(host, port, timeout=5):
    """Conecta a um host:port e retorna o banner"""
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(timeout)
        sock.connect((host, port))

        # Tenta ler dados iniciais (alguns serviços enviam automaticamente)
        banner = sock.recv(1024).decode(errors='ignore').strip()

        sock.close()
        return banner if banner else "Sem resposta de banner"

    except socket.timeout:
        return "Timeout"
    except ConnectionRefusedError:
        return "Porta fechada"
    except Exception as e:
        return f"Erro: {str(e)}"

# Uso
if __name__ == "__main__":
    host = sys.argv[1] if len(sys.argv) > 1 else "192.168.1.100"
    portas_comuns = [21, 22, 23, 25, 80, 110, 143, 389, 443, 445, 465, 587, 636, 3306, 5432, 8080, 9200]

    print(f"[*] Grabbing banners de {host}\n")

    for porta in portas_comuns:
        resultado = grab_banner(host, porta)
        print(f"[{porta:5d}] {resultado}")

Salve como banner_grabber.py e execute:

python3 banner_grabber.py 192.168.1.100

Esse script simplista ilustra o conceito: conecta a cada porta, tenta ler o que o serviço envia, e exibe. Em produção, você teria tratamento mais sofisticado para cada protocolo (HTTP precisa de um GET, SMTP precisa de EHLO, etc.).

Análise Prática Integrada: Do Reconhecimento à Descoberta

Um fluxo de trabalho profissional combina essas ferramentas de forma estratégica. Vamos simular um cenário real:

Você tem autorização para testar uma rede 10.0.0.0/24 (256 hosts). Começa com reconhecimento ativo completo:

# Passo 1: Descoberta rápida com Masscan (30 segundos)
masscan 10.0.0.0/24 -p 22,80,443,8080,3306,5432 --rate 50000 -oG masscan_results.gnmap

# Passo 2: Extrair hosts únicos
grep open masscan_results.gnmap | awk '{print $2}' | sort -u > targets.txt

# Passo 3: Scan detalhado com Nmap em cada host encontrado
for host in $(cat targets.txt); do
  echo "[*] Scanning $host..."
  nmap -sS -sV -sC --script=banner,http-title,smb-enum-shares -p 22,80,443,8080,3306,5432 -oX $host.xml $host
done

# Passo 4: Enumeração adicional em serviços interessantes
nmap --script smb-enum-users,smb-os-discovery -p 445 -iL targets.txt -oX smb_enum.xml

# Passo 5: Análise de resultados
# Converter XMLs para relatório legível
grep -h "portid" *.xml | grep "open" | sort -u > portas_abertas.txt

Esse fluxo economiza tempo porque:

  1. Masscan identifica rapidamente quais hosts estão vivos
  2. Nmap detalhado fornece informações completas apenas dos hosts ativos
  3. Scripts NSE automatizam enumeração específica
  4. Loop processa múltiplos hosts sem esforço manual

Conclusão

Dominar reconhecimento ativo é fundamental para qualquer profissional de segurança. Os três pontos principais que você deve levar para a prática:

  1. Nmap é versátil e confiável: Use-o sempre que precisar de análise precisa. Os scripts NSE automatizam tarefas que tomariam horas manualmente. Combine -sS (SYN scan), -sV (detecção de versão) e -sC (scripts padrão) para cobertura abrangente.

  2. Masscan é para volume: Em redes grandes ou quando você precisa de velocidade, Masscan reduz horas para minutos. Mas sempre refine resultados com Nmap depois, pois Masscan não fornece contexto completo.

  3. Banner grabbing + enumeração revelam tudo: Nunca confie em defaults — sistemas mal configurados expõem informações sensíveis nos banners e respostas a consultas simples. Um script básico ou comando nc pode revelar mais do que você imagina.

Combine essas ferramentas de forma estratégica, sempre com autorização documentada, e você terá um mapa completo da infraestrutura antes de qualquer outro teste de segurança.

Referências

  • Nmap Official Documentation: https://nmap.org/book/
  • Masscan GitHub Repository: https://github.com/robertdavidgraham/masscan
  • OWASP Testing Guide - Reconnaissance: https://owasp.org/www-project-web-security-testing-guide/
  • "The Art of Network Penetration Testing" — Royce Davis: Livro de referência sobre metodologia profissional de testes
  • Nmap Scripting Engine Documentation: https://nmap.org/book/nse.html

Artigos relacionados