Pular para o conteúdo principal

Lab 5.1: Reconhecimento de Rede com Nmap

Objetivos de Aprendizagem​

Ao final deste laboratório, você será capaz de:

  • Instalar e configurar o Nmap no Windows e Linux
  • Realizar diferentes tipos de scans de rede
  • Identificar hosts ativos em uma rede
  • Descobrir portas abertas e serviços em escuta
  • Detectar sistemas operacionais remotamente
  • Identificar vulnerabilidades conhecidas com scripts NSE
  • Interpretar os resultados do scan para avaliação de segurança
  • Compreender técnicas de evasão de detecção

Duração Estimada​

40 minutos

Pré-requisitos​

  • 2 VMs: Windows e Kali Linux (ou 2 Windows)
  • Rede interna VirtualBox configurada
  • Compreensão do modelo TCP/IP
  • Conhecimentos sobre portas e serviços

Contexto Profissional​

O Nmap (Network Mapper) é a ferramenta de scan de rede mais utilizada no mundo por:

  • Administradores de sistemas para inventário de rede
  • Profissionais de segurança para testes de penetração
  • Analistas SOC para detecção de anomalias
  • Auditores para verificação de conformidade

O Nmap permite:

  • Descobrir todos os dispositivos em uma rede
  • Identificar serviços expostos
  • Detectar sistemas operacionais
  • Encontrar vulnerabilidades conhecidas
  • Validar configurações de firewall
  • Mapear a infraestrutura de rede

Escanear uma rede sem autorização é ilegal na maioria das jurisdições.

PERMITIDO:

  • Em sua própria rede de laboratório (VMs isoladas)
  • Em sistemas dos quais você é proprietário
  • Em testes de penetração com contrato assinado
  • Em plataformas de laboratório legais (HackTheBox, TryHackMe)

ESTRITAMENTE PROIBIDO:

  • Escanear redes corporativas sem autorização por escrito
  • Escanear redes públicas ou de terceiros
  • Escanear a Internet aleatoriamente
  • Usar para identificar alvos para ataque

CONSEQUÊNCIAS LEGAIS: Escanear sem autorização = Reconhecimento ilegal, prelúdio de ataque cibernético (Código Penal art. 342.1). Detecção fácil via IDS/IPS. Alta probabilidade de processo criminal.

Configuração necessária para este lab:

  • Rede de VMs em modo INTERNO apenas
  • Sem acesso à Internet
  • Ambiente isolado e controlado

Parte 1: Instalação e Configuração​

Etapa 1.1: Instalação no Windows​

Download:

Instalação:

  1. Execute o arquivo .exe baixado
  2. Aceite a licença
  3. Componentes recomendados:
    • Nmap Core Files (obrigatório)
    • Npcap (obrigatório - para captura de pacotes)
    • Zenmap GUI (opcional, mas útil para iniciantes)
    • Ndiff (opcional)
  4. Instalação completa

Verificação:

nmap --version

Resultado esperado:

Nmap version 7.94 ( https://nmap.org )
Platform: x86_64-w64-mingw32
Compiled with: ...

Etapa 1.2: Instalação no Kali Linux​

Nmap já vem pré-instalado no Kali Linux!

Verificação:

nmap --version

Atualização se necessário:

sudo apt update
sudo apt install nmap -y

Etapa 1.3: Configuração de Rede do Lab​

Arquitetura do lab:

VM1 (Kali Linux - Scanner):
  IP: 192.168.100.10
  Papel: Realizar os scans

VM2 (Windows - Alvo):
  IP: 192.168.100.20
  Papel: Sistema a ser escaneado
  Serviços: Várias portas abertas

Rede: Internal Network "LabNet"

Em cada VM, verifique a conectividade:

ping 192.168.100.20  # Do Kali
ping 192.168.100.10  # Do Windows

Perguntas:

  1. Qual versão do Nmap você instalou?
  2. As duas VMs conseguem se comunicar?

Parte 2: Descoberta de Hosts (Host Discovery)​

Etapa 2.1: Ping Scan Básico​

O scan mais simples:

nmap 192.168.100.20

Resultado:

Starting Nmap 7.94
Nmap scan report for 192.168.100.20
Host is up (0.00050s latency).
Not shown: 995 closed ports
PORT     STATE SERVICE
135/tcp  open  msrpc
139/tcp  open  netbios-ssn
445/tcp  open  microsoft-ds
3389/tcp open  ms-wbt-server
5357/tcp open  wsdapi

Nmap done: 1 IP address (1 host up) scanned in 2.45 seconds

Análise:

  • Host ativo (up)
  • 5 portas abertas detectadas
  • Serviços identificados
  • Tempo de scan: ~2 segundos

Etapa 2.2: Scan de uma Rede Completa​

Escanear todo um range de IPs:

nmap 192.168.100.0/24

Opções:

  • /24 = 256 endereços (192.168.100.0 a 192.168.100.255)
  • /16 = 65.536 endereços
  • /8 = 16.777.216 endereços

Resultado:

Nmap scan report for 192.168.100.1
Host is up (0.00010s latency).

Nmap scan report for 192.168.100.10
Host is up (0.00012s latency).

Nmap scan report for 192.168.100.20
Host is up (0.00015s latency).

Nmap done: 256 IP addresses (3 hosts up) scanned in 4.21 seconds

3 hosts ativos descobertos em 4 segundos em 256 IPs escaneados!

Etapa 2.3: Host Discovery Sem Scan de Portas​

Apenas descobrir quais hosts estão ativos (sem scan de portas):

nmap -sn 192.168.100.0/24

Opção -sn: Apenas ping scan (sem scan de portas)

Mais rápido: Scan completo em menos de 2 segundos!

Perguntas: 3. Quantos hosts ativos você descobriu na sua rede de laboratório? 4. Qual a diferença de tempo entre scan com e sem portas?

Parte 3: Scan de Portas​

Etapa 3.1: Tipos de Scans​

TCP Connect Scan (padrão para não-root):

nmap -sT 192.168.100.20
  • Conexão TCP completa (3-way handshake)
  • Confiável, mas detectável
  • Não requer privilégios root

TCP SYN Scan (furtivo, requer root):

sudo nmap -sS 192.168.100.20
  • Conexão TCP incompleta (apenas SYN)
  • Mais furtivo
  • Requer privilégios root/admin

UDP Scan:

sudo nmap -sU 192.168.100.20
  • Escaneia portas UDP
  • Mais lento que TCP
  • Importante para DNS, DHCP, SNMP

Etapa 3.2: Scan de Todas as Portas​

Por padrão: O Nmap escaneia apenas as 1000 portas mais comuns

Escanear TODAS as 65535 portas:

nmap -p- 192.168.100.20

Opção -p-: Todas as portas (1-65535)

ATENÇÃO: Pode levar 10-20 minutos!

Alternativa rápida:

nmap -p- --min-rate 5000 192.168.100.20

--min-rate 5000: Mínimo de 5000 pacotes/segundo = Scan em 30-60 segundos!

Etapa 3.3: Scan de Portas Específicas​

Portas específicas:

nmap -p 80,443,3389,445 192.168.100.20

Range de portas:

nmap -p 1-1000 192.168.100.20

Combinação:

nmap -p 22,80,443,1000-2000,3389,8080 192.168.100.20

Perguntas: 5. Quais portas estão abertas na sua VM Windows? 6. Quanto tempo leva um scan completo de todas as portas?

Parte 4: Detecção de Serviços e Versões​

Etapa 4.1: Detecção de Versão de Serviço​

Escanear com detecção de versões:

nmap -sV 192.168.100.20

Opção -sV: Detecção de versão

Resultado detalhado:

PORT     STATE SERVICE       VERSION
135/tcp  open  msrpc         Microsoft Windows RPC
139/tcp  open  netbios-ssn   Microsoft Windows netbios-ssn
445/tcp  open  microsoft-ds  Microsoft Windows Server 2016 microsoft-ds
3389/tcp open  ms-wbt-server Microsoft Terminal Services
5357/tcp open  http          Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)

Informações obtidas:

  • Nome exato do serviço
  • Versão do software
  • Informações adicionais

Intensidade da detecção:

nmap -sV --version-intensity 9 192.168.100.20
  • 0 = Leve (rápido)
  • 9 = Intensivo (completo, porém lento)

Etapa 4.2: Detecção de Sistema Operacional​

OS Detection:

sudo nmap -O 192.168.100.20

Opção -O: Detecção de OS (requer root)

Resultado:

Running: Microsoft Windows 10|2016|2019
OS CPE: cpe:/o:microsoft:windows_10 cpe:/o:microsoft:windows_server_2016
OS details: Microsoft Windows 10 1709 - 1909, or Windows Server 2016 - 2019
Network Distance: 1 hop

Precisão típica: 85-95%

Etapa 4.3: Scan Agressivo Completo​

Combinação de todas as opções:

sudo nmap -A 192.168.100.20

Opção -A: Scan agressivo (equivalente a -sV -O -sC --traceroute)

Inclui:

  • Detecção de versão
  • Detecção de OS
  • Script scanning
  • Traceroute

Perguntas: 7. Qual sistema operacional o Nmap detectou? 8. Qual a versão do SMB (porta 445) instalada?

Parte 5: Scripts NSE (Nmap Scripting Engine)​

Etapa 5.1: O que é NSE?​

NSE: Scripts em Lua para automatizar tarefas avançadas:

  • Detecção de vulnerabilidades
  • Brute-forcing
  • Enumeração avançada
  • Exploração de serviços

Categorias de scripts:

  • auth - Autenticação
  • brute - Força bruta
  • discovery - Descoberta
  • exploit - Exploração
  • vuln - Vulnerabilidades

Etapa 5.2: Scan com Scripts Padrão​

nmap -sC 192.168.100.20

Opção -sC: Script scan (scripts padrão)

Exemplo de resultado:

PORT    STATE SERVICE
445/tcp open  microsoft-ds

Host script results:
| smb2-security-mode: 
|   2.02: 
|     Message signing enabled but not required
| smb2-time: 
|   date: 2024-11-08T15:30:45

Informações adicionais obtidas!

Etapa 5.3: Scripts de Vulnerabilidades​

Escanear por vulnerabilidades conhecidas:

nmap --script vuln 192.168.100.20

Resultado se vulnerável:

PORT    STATE SERVICE
445/tcp open  microsoft-ds

Host script results:
| smb-vuln-ms17-010: 
|   VULNERABLE:
|   Remote Code Execution vulnerability in Microsoft SMBv1 servers (ms17-010)
|     State: VULNERABLE
|     IDs:  CVE:CVE-2017-0143
|     Risk factor: HIGH
|       EternalBlue / MS17-010

CRÍTICO: Vulnerabilidade EternalBlue detectada (a do WannaCry!)

Etapa 5.4: Scripts SMB Enum​

Enumeração completa do SMB:

nmap --script smb-enum-shares,smb-enum-users,smb-os-discovery 192.168.100.20

Informações obtidas:

Host script results:
| smb-enum-shares: 
|   account_used: guest
|   \\192.168.100.20\ADMIN$: 
|     Type: STYPE_DISKTREE_HIDDEN
|   \\192.168.100.20\C$: 
|     Type: STYPE_DISKTREE_HIDDEN
|   \\192.168.100.20\IPC$: 
|     Type: STYPE_IPC_HIDDEN
|     
| smb-os-discovery: 
|   OS: Windows 10 Pro (build 19041)
|   Computer name: DESKTOP-ABC123
|   Domain name: WORKGROUP

Enumeração completa do sistema alvo!

Perguntas: 9. Quais compartilhamentos SMB estão disponíveis? 10. Quais vulnerabilidades o Nmap detectou?

Parte 6: Técnicas de Scan Avançadas​

Etapa 6.1: Scan Rápido (Top Ports)​

Escanear apenas as portas mais comuns:

nmap --top-ports 20 192.168.100.0/24

Escaneia as 20 portas mais comuns em toda a rede

Ainda mais rápido:

nmap --top-ports 100 --min-rate 10000 192.168.100.0/24
  • Top 100 portas
  • Mínimo de 10.000 pacotes/segundo
  • Scan de rede completo em poucos segundos!

Etapa 6.2: Timing Templates​

O Nmap oferece 6 templates de velocidade:

nmap -T0 target  # Paranoid (muito lento, furtivo)
nmap -T1 target  # Sneaky (lento, furtivo)
nmap -T2 target  # Polite (lento, menos carga)
nmap -T3 target  # Normal (padrão)
nmap -T4 target  # Aggressive (rápido)
nmap -T5 target  # Insane (muito rápido, pode perder portas)

Para este lab, use T4:

nmap -T4 -sV -O 192.168.100.20

Scan completo e rápido!

Etapa 6.3: Output e Formatos de Resultados​

Salvar resultados em arquivo:

Formato normal (legível):

nmap 192.168.100.20 -oN scan_results.txt

Formato XML (para ferramentas):

nmap 192.168.100.20 -oX scan_results.xml

Formato Grepable (para parsing):

nmap 192.168.100.20 -oG scan_results.gnmap

Todos os formatos ao mesmo tempo:

nmap 192.168.100.20 -oA scan_complete

Gera: scan_complete.nmap, scan_complete.xml, scan_complete.gnmap

Perguntas: 11. Qual formato de saída é mais útil para análise automatizada? 12. Como você faria o parsing dos resultados com PowerShell?

Parte 7: Cenários de Uso Reais​

Etapa 7.1: Scan de Rede Corporativa (Simulação)​

Cenário: Auditoria de segurança de uma rede corporativa

Fase 1 - Descoberta inicial:

nmap -sn 192.168.100.0/24 -oA discovery

Fase 2 - Scan rápido dos hosts ativos:

nmap -iL discovery.gnmap -sV --top-ports 1000 -T4 -oA quick_scan

Fase 3 - Scan aprofundado dos servidores:

nmap -iL servers.txt -sV -sC -O -p- -T4 -oA deep_scan

Fase 4 - Scan de vulnerabilidades:

nmap -iL servers.txt --script vuln -oA vuln_scan

Resultado: Relatório completo de segurança da rede!

Etapa 7.2: Identificação de Máquinas Vulneráveis​

Script para encontrar sistemas vulneráveis:

# Procurar Windows XP/7/8 (não suportados)
nmap -O 192.168.100.0/24 | grep -B 5 "Windows XP\|Windows 7\|Windows 8"

# Procurar SMBv1 (vulnerável ao EternalBlue)
nmap --script smb-protocols 192.168.100.0/24 | grep -B 10 "SMBv1"

# Procurar serviços com versões antigas
nmap -sV 192.168.100.0/24 | grep -i "apache 2.2\|openssh 7.4"

Priorização de alvos:

  1. OS não suportados
  2. Serviços com CVE conhecidas
  3. Portas sensíveis abertas (RDP, SMB, etc.)

Etapa 7.3: Mapeamento Completo da Rede​

Scan exaustivo para documentação:

nmap -sV -sC -O -p- --script discovery -T4 192.168.100.0/24 -oA network_map

Depois analise com Zenmap (GUI):

zenmap

File → Open → network_map.xml

Visualização gráfica da rede!

Perguntas: 13. Quanto tempo leva um scan completo da sua rede de laboratório? 14. Quais informações críticas você descobriu?

Parte 8: Técnicas Ofensivas​

Etapa 8.1: Brute Force de Serviços​

SSH Brute Force:

nmap --script ssh-brute --script-args userdb=users.txt,passdb=passwords.txt -p 22 target

RDP Brute Force:

nmap --script rdp-brute -p 3389 target

SMB Brute Force:

nmap --script smb-brute -p 445 target

ATENÇÃO: Brute force gera muitos logs! Detecção fácil.

Etapa 8.2: Exploração com Scripts NSE​

Procurar exploits disponíveis:

ls /usr/share/nmap/scripts/*exploit*

Exemplo - MS08-067 (antigo, mas para demonstração):

nmap --script smb-vuln-ms08-067 192.168.100.20

Se vulnerável, o script irá indicar!

Lista de scripts de vulnerabilidades:

nmap --script-help vuln

Etapa 8.3: Evasão de Firewall​

Técnicas para contornar detecção:

Fragmentar pacotes:

nmap -f 192.168.100.20

Decoy scans (falsos scans de outros IPs):

nmap -D RND:10 192.168.100.20

Spoof de IP de origem:

sudo nmap -S 192.168.100.50 -e eth0 192.168.100.20

Randomizar ordem do scan:

nmap --randomize-hosts 192.168.100.0/24

Perguntas: 15. Por que usar técnicas de evasão? 16. Um firewall pode bloquear completamente o Nmap?

Parte 9: Automação e Reporting​

Etapa 9.1: Script de Scan Automatizado​

Crie auto_scan.sh:

#!/bin/bash

TARGET=$1
OUTPUT_DIR="nmap_scans_$(date +%Y%m%d_%H%M%S)"

mkdir -p $OUTPUT_DIR

echo "[*] Starting automated scan of $TARGET"
echo "[*] Output directory: $OUTPUT_DIR"

# Phase 1: Host Discovery
echo "[*] Phase 1: Host Discovery"
nmap -sn $TARGET -oA $OUTPUT_DIR/01_discovery

# Phase 2: Quick Scan
echo "[*] Phase 2: Quick Port Scan"
nmap -sV --top-ports 1000 -T4 $TARGET -oA $OUTPUT_DIR/02_quick_scan

# Phase 3: Full Port Scan
echo "[*] Phase 3: Full Port Scan"
nmap -p- --min-rate 5000 $TARGET -oA $OUTPUT_DIR/03_full_scan

# Phase 4: Vulnerability Scan
echo "[*] Phase 4: Vulnerability Scan"
nmap --script vuln $TARGET -oA $OUTPUT_DIR/04_vuln_scan

# Phase 5: OS Detection
echo "[*] Phase 5: OS Detection"
sudo nmap -O $TARGET -oA $OUTPUT_DIR/05_os_detection

echo "[*] Scan complete! Results in: $OUTPUT_DIR/"

Uso:

chmod +x auto_scan.sh
./auto_scan.sh 192.168.100.0/24

Scan completo automatizado da rede!

Etapa 9.2: Parsing e Análise com PowerShell​

No Windows, analise os resultados XML:

[xml]$nmapResults = Get-Content scan_results.xml

# Extrair todos os hosts e portas abertas
$nmapResults.nmaprun.host | ForEach-Object {
    $ip = $_.address.addr
    $hostname = $_.hostnames.hostname.name
    
    Write-Host "Host: $ip ($hostname)"
    
    $_.ports.port | Where-Object {$_.state.state -eq "open"} | ForEach-Object {
        Write-Host "  $($_.portid)/$($_.protocol) - $($_.service.name) $($_.service.version)"
    }
}

Etapa 9.3: Geração de Relatório HTML​

Converter XML em HTML:

xsltproc scan_results.xml -o report.html

OU use um script Python:

import nmap
import datetime

nm = nmap.PortScanner()
nm.scan('192.168.100.0/24', arguments='-sV')

html = "<html><head><title>Nmap Scan Report</title></head><body>"
html += f"<h1>Network Scan Report</h1>"
html += f"<p>Date: {datetime.datetime.now()}</p>"

for host in nm.all_hosts():
    html += f"<h2>Host: {host}</h2>"
    html += "<table border='1'><tr><th>Port</th><th>Service</th><th>Version</th></tr>"
    
    for proto in nm[host].all_protocols():
        ports = nm[host][proto].keys()
        for port in ports:
            service = nm[host][proto][port]['name']
            version = nm[host][proto][port]['version']
            html += f"<tr><td>{port}</td><td>{service}</td><td>{version}</td></tr>"
    
    html += "</table>"

html += "</body></html>"

with open('nmap_report.html', 'w') as f:
    f.write(html)

print("Report generated: nmap_report.html")

Perguntas: 17. Como você apresentaria os resultados para um cliente? 18. Quais informações são mais críticas para incluir?

Entregáveis​

A entregar:

  1. Relatório de scan de rede (Word/PDF, 5-6 páginas):

    • Respostas às 18 perguntas
    • Metodologia de scan utilizada
    • Resultados de cada fase do scan
    • Análise das vulnerabilidades encontradas
    • Mapeamento da rede (diagrama)

  2. Capturas de tela (mínimo 8):

    • Scan de descoberta de hosts
    • Scan de portas completo
    • Detecção de versões (-sV)
    • Detecção de OS (-O)
    • Script vuln em ação
    • Resultados de scripts NSE
    • Visualização Zenmap
    • Relatório gerado

  3. Arquivos de resultados do Nmap:

    • Formatos .nmap, .xml, .gnmap
    • Para pelo menos 3 tipos de scans diferentes

  4. Script de automação:

    • Script bash ou PowerShell
    • Scan completo automatizado
    • Geração de relatório

  5. Análise de segurança (2-3 páginas):

    • Vulnerabilidades críticas identificadas
    • Riscos associados
    • Recomendações de remediação priorizadas

Critérios de Avaliação​

CritérioPontos
Domínio dos diferentes tipos de scans25%
Uso correto das opções do Nmap20%
Detecção e análise de vulnerabilidades25%
Script de automação funcional15%
Qualidade do relatório e análise15%

Comandos de Referência Rápida​

Scans Básicos​

nmap target                    # Scan simples
nmap -sn target                # Apenas descoberta de hosts
nmap -p- target                # Todas as portas
nmap -p 80,443 target          # Portas específicas
nmap 192.168.1.0/24            # Escanear uma rede

Scans Avançados​

nmap -sV target                # Detecção de versão
nmap -O target                 # Detecção de OS
nmap -sC target                # Script scan
nmap -A target                 # Agressivo (tudo)
nmap -T4 target                # Timing template

Scripts NSE​

nmap --script vuln target                  # Vulnerabilidades
nmap --script smb-enum-shares target       # Compartilhamentos SMB
nmap --script http-enum target             # Enumeração HTTP
nmap --script ssl-heartbleed target        # Heartbleed

Output​

nmap target -oN file.nmap      # Output normal
nmap target -oX file.xml       # Output XML
nmap target -oG file.gnmap     # Output Grepable
nmap target -oA basename       # Todos os formatos

Otimização​

nmap --min-rate 5000 target              # Velocidade mínima
nmap --max-retries 1 target              # Menos retries
nmap --host-timeout 5m target            # Timeout por host
nmap -n target                           # Sem resolução DNS

Solução de Problemas​

Problema: "You requested a scan type which requires raw sockets"​

Solução: Execute com sudo (Linux) ou como administrador (Windows) para scans SYN (-sS) e detecção de OS (-O).

Problema: Scan muito lento​

Soluções:

  • Use -T4 para velocidade
  • Limite aos top ports: --top-ports 100
  • Aumente min-rate: --min-rate 5000
  • Desative resolução DNS: -n

Problema: Nenhuma porta detectada mas host up​

Soluções:

  • Provavelmente o firewall está bloqueando
  • Tente scan UDP: -sU
  • Tente diferentes tipos de scans: -sT, -sS
  • Verifique conectividade básica: ping

Indo Além (Opcional)​

Desafio 1: Nmap Scripting​

Crie seu próprio script NSE para:

  • Enumeração personalizada
  • Detecção de configuração específica
  • Extração de informações customizadas

Desafio 2: Integração com Metasploit​

Use resultados do Nmap no Metasploit:

db_nmap -sV 192.168.100.0/24
hosts
services
vulns

Desafio 3: Comparação Temporal​

Escaneie a mesma rede em diferentes momentos:

  • Identificar novos hosts
  • Detectar mudanças de configuração
  • Monitoramento de segurança contínuo
ndiff scan1.xml scan2.xml

Recursos Adicionais​

Conclusão​

Este lab ensinou:

  • Instalação e configuração do Nmap
  • Diferentes tipos de scans de rede
  • Detecção de serviços e sistemas operacionais
  • Uso de scripts NSE para vulnerabilidades
  • Automação e reporting
  • Metodologia de reconhecimento profissional

Lições-chave:

  1. O Nmap é a ferramenta padrão da indústria para reconhecimento de rede
  2. Diferentes tipos de scans para diferentes objetivos
  3. Scripts NSE multiplicam as capacidades do Nmap
  4. Automação é essencial para redes de grande porte
  5. Documentação e reporting são críticos para auditoria profissional

Em um pentest real:

  • O Nmap é sempre o primeiro passo (reconhecimento)
  • Os resultados guiam o restante do ataque
  • Detecção fácil se não houver precauções (IDS/IPS)
  • Timing e discrição são importantes em Red Team engagements

Próximo passo: Lab 5.2 onde você aprenderá enumeração DNS avançada para descobrir subdomínios ocultos e informações sensíveis!

Lab desenvolvido no âmbito do curso Sistemas Operacionais - MÓDULO 5