Nmap Masterclass: Técnicas de Scanning de Redes para CEH

O que é Scanning? A Segunda Fase do Pentest

Se o reconhecimento é olhar pela janela, o scanning é bater na porta. Depois de coletar informações passivamente (WHOIS, DNS, Google Dorking, redes sociais), chegou a hora de sondar ativamente o alvo — descobrir o que está vivo, quais portas estão abertas, que serviços respondem e qual sistema operacional roda por trás.

A diferença fundamental: reconhecimento é passivo — você não toca no alvo. Scanning é ativo — você envia pacotes, recebe respostas, e qualquer IDS minimamente competente vai notar. É aqui que o atacante começa a deixar rastro.

O que procuramos na fase de scanning:

• Hosts ativos — quais máquinas estão ligadas e respondendo na rede
• Portas abertas — portas TCP e UDP acessíveis
• Serviços rodando — HTTP, SSH, SMB, DNS, etc.
• Versões dos serviços — crucial para identificar vulnerabilidades conhecidas
• Sistema operacional — fingerprinting via TCP/IP para orientar o próximo passo

Nmap: O Suíço do Hacking

Gordon Lyon (conhecido como Fyodor) criou o Nmap em 1997. Vinte e poucos anos depois, continua sendo a ferramenta de scanning mais usada no mundo — por pentesters, admins, blue teams e (infelizmente) atacantes. O Nmap está para o scanning o que o Google está para a busca: ponto de partida inevitável.

Por que é indispensável no CEH:

• Cobre praticamente todas as técnicas de scanning da metodologia EC-Council
• Open source, multiplataforma, maduro e absurdamente flexível
• Nmap Scripting Engine (NSE) transforma-o em framework de automação
• Presente em praticamente toda prova prática de segurança

Instalação: No Kali Linux já vem pré-instalado. Para outras distros:

# Debian/Ubuntu
sudo apt install nmap

# CentOS/RHEL
sudo yum install nmap

# macOS (Homebrew)
brew install nmap

# Windows — baixar installer em https://nmap.org/download.html

O Nmap oferece duas interfaces: a CLI (linha de comando) que é o padrão de uso profissional, e o Zenmap (GUI) que oferece interface gráfica com profile management — útil para iniciantes e para visualizar resultados de topologia. A CLI é mais poderosa, mais rápida de usar quando você domina os flags, e é o que cai na prova.

Tipos de Scan

Um dos principais objetivos do CEH é saber quando usar cada tipo de scan. A tabela abaixo resume todos os tipos principais:

-sS — SYN Scan (Half-Open)

O scan mais usado no mundo do pentest. Para entender o porquê, precisa entender o handshake TCP de três vias:

1. SYN — cliente diz “quero conectar”
2. SYN-ACK — servidor diz “ok, eu aceito”
3. ACK — cliente confirma “entendido, vamos”

O -sS manda o SYN, recebe o SYN-ACK (porta aberta) ou RST (porta fechada), e então manda um RST para derrubar a conexão antes do terceiro passo. A conexão nunca é completada — daí “half-open”. A maioria dos logs de aplicação não registra a tentativa porque, para o servidor, a conexão nunca existiu de fato.

$ sudo nmap -sS 192.168.1.0/24

Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-15 10:30 -03
Nmap scan report for 192.168.1.1
Host is up (0.0030s latency).
Not shown: 993 closed tcp ports (reset)
PORT     STATE SERVICE
22/tcp   open  ssh
53/tcp   open  domain
80/tcp   open  http
443/tcp  open  https
3389/tcp open  ms-wrd-s
8080/tcp open  http-proxy

Nmap done: 256 IP addresses (4 hosts up) scanned in 8.42 seconds

Output explicado: 256 IPs no range /24, 4 responderam, 6 portas abertas no gateway (192.168.1.1). “Not shown: 993 closed” significa que o Nmap testou todas as 1000 portas padrão e encontrou 993 fechadas — isso é normal, o Nmap esconde portas fechadas para limpar o output.

-sT — TCP Connect Scan

Completa o handshake TCP inteiro usando a syscall connect() do SO. É o scan mais “honesto” — qualquer firewall ou IDS vê claramente a tentativa de conexão. Use quando não tem root ou quando precisa testar se o firewall permite a conexão completa (simulação de aplicação real).

$ nmap -sT 192.168.1.50 -p 22,80,443,3306,5432

Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-15 10:35 -03
Nmap scan report for 192.168.1.50
Host is up (0.0045s latency).

PORT     STATE  SERVICE
22/tcp   open   ssh
80/tcp   closed http
443/tcp  open   https
3306/tcp open   mysql
5432/tcp filtered postgresql

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

Aqui, 80 está closed (RST recebido — nada escutando) e 5432 está filtered (sem resposta — provavelmente firewall descartando o pacote). Essa diferença entre closed e filtered é fundamental para mapear regras de firewall.

-sU — UDP Scan

UDP é complicado. Sem handshake, sem confirmação — o Nmap manda um pacote e espera. Se volta ICMP “port unreachable”, a porta está fechada. Se não volta nada, pode estar aberta ou filtrada. É lento (o Nmap precisa esperar timeout em cada porta) mas essencial — serviços como DNS, DHCP, SNMP, NTP e Syslog rodam sobre UDP.

Portas UDP críticas para o CEH:

• 53 — DNS
• 67/68 — DHCP (servidor/cliente)
• 69 — TFTP (muito inseguro. Target clássico)
• 123 — NTP
• 161 — SNMP (mina de informação sobre a rede)
• 500 — IKE/IPsec

$ sudo nmap -sU --top-ports 100 192.168.1.1

Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-15 10:40 -03
Nmap scan report for 192.168.1.1
Host is up (0.0030s latency).
Not shown: 96 open|filtered udp ports (no-response)
PORT    STATE         SERVICE
53/udp  open          domain
67/udp  open|filtered dhcps
68/udp  open|filtered dhcpc
123/udp open|filtered ntp

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

Nota o tempo: 102 segundos para 100 portas UDP. Compare com ~8 segundos para 1000 portas TCP. É por isso que UDP scans são sempre os últimos a rodar — e por que --top-ports é quase obrigatório para limitar o escopo.

-sA — ACK Scan

Não descobre portas abertas — serve para testar firewalls. O Nmap manda um ACK (que seria o terceiro passo do handshake) e observa a resposta:

• RST recebido → porta unfiltered (o firewall não está bloqueando)
• Sem resposta → porta filtered (firewall descartou o pacote)

$ sudo nmap -sA 192.168.1.100 -p 1-1000

Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-15 10:45 -03
Nmap scan report for 192.168.1.100
Host is up (0.0050s latency).

All 1000 scanned ports on 192.168.1.100 are unfiltered

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

“All 1000 scanned ports are unfiltered” — sem firewall no caminho (ou firewall stateless que não filtra pacotes ACK). Se algumas portas voltassem filtered, saberíamos exatamente quais regras o firewall está aplicando.

-sF, -sX, -sN — FIN, Xmas e Null Scans

Estes são “stealth scans” que exploram uma peculiaridade da RFC 793 (TCP): se uma porta está aberta e recebe um pacote que não é SYN, RST ou ACK, deve simplesmente ignorá-lo. Se está fechada, deve responder com RST.

• -sF (FIN) — envia pacote com flag FIN ativada (sinal de “quero fechar”)
• -sX (Xmas) — envia pacote com FIN, PSH e URG ativadas (“árvore de Natal” de flags ligadas)
• -sN (Null) — envia pacote com zero flags TCP ativadas

A lógica é a mesma para todos:

• Sem resposta → porta open|filtered
• RST → porta closed

$ sudo nmap -sF 192.168.1.50 -p 20-100

Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-15 10:50 -03
Nmap scan report for 192.168.1.50
Host is up (0.0040s latency).

PORT   STATE         SERVICE
22/tcp open|filtered ssh
80/tcp open|filtered http

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

-sI — Idle Scan (Zombie Scan)

A técnica de scanning mais indetectável disponível. O conceito é brilhante: você usa um terceiro host (o “zombie”) como intermediário. O alvo nunca vê seu IP — só vê o IP do zombie.

Pré-requisitos:

1. Encontrar um host zombie com IPID sequencial e previsível
2. O zombie deve estar ocioso (baixo tráfego)
3. Root no seu machine para crafting de pacotes

Como funciona:

1. Enviar pacote SYN+ACK ao zombie → ele responde com RST. Anotar o IPID (ex: 31415).
2. Enviar pacote SYN ao alvo com IP source spoofado para o IP do zombie.
3. Se a porta do alvo está aberta: alvo responde SYN-ACK ao zombie. Zombie recebe SYN-ACK inesperado, responde RST ao alvo. IPID do zombie incrementa (agora 31416).
4. Se a porta do alvo está fechada: alvo responde RST ao zombie. Zombie recebe RST inesperado, não incrementa IPID. Permanece 31415.
5. Enviar outro SYN+ACK ao zombie para checar o IPID. Se incrementou 1 vez desde o passo 1 → porta aberta. Se incrementou 2 vezes (ou 0) → fechada.

$ sudo nmap -sI 192.168.1.200 192.168.1.50

Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-15 11:00 -03
Idle scan using zombie 192.168.1.200 (192.168.1.200:80)
Nmap scan report for 192.168.1.50
Host is up (0.0050s latency).
Not shown: 994 closed tcp ports (reset)
PORT     STATE SERVICE
22/tcp   open  ssh
80/tcp   open  http
443/tcp  open  https
3306/tcp open  mysql

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

O output confirma: “Idle scan using zombie 192.168.1.200”. O alvo 192.168.1.50 só viu pacotes vindos do zombie. Para o alvo, o zombie atacou — você é invisível.

-sn — Ping Scan (Host Discovery)

Não faz port scan — só descobre quais hosts estão vivos na rede. Útil como primeiro passo antes de qualquer scan mais elaborado.

$ nmap -sn 192.168.1.0/24

Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-15 11:05 -03
Nmap scan report for 192.168.1.1
Host is up (0.0020s latency).
Nmap scan report for 192.168.1.10
Host is up (0.0050s latency).
Nmap scan report for 192.168.1.50
Host is up (0.0030s latency).
Nmap scan report for 192.168.1.200
Host is up (0.0100s latency).
Nmap done: 256 IP addresses (4 hosts up) scanned in 4.52 seconds

Quatro hosts ativos em menos de 5 segundos. Agora você sabe exatamente contra quem vai direcionar os scans seguintes. Sem gastar tempo escaneando portas em máquinas desligadas.

-sV — Version Detection

Vai além de “porta aberta” e tenta identificar qual versão do serviço está rodando. Isso é crucial para o exploit — cada vulnerabilidade geralmente afeta versões específicas. O Nmap envia probes específicos para cada serviço e analisa a resposta para determinar a versão.

$ nmap -sV 192.168.1.50 -p 22,80,443,3306

Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-15 11:10 -03
Nmap scan report for 192.168.1.50
Host is up (0.0030s latency).

PORT     STATE SERVICE VERSION
22/tcp   open  ssh     OpenSSH 8.9p1 Ubuntu 3ubuntu0.6
80/tcp   open  http    Apache httpd 2.4.52 ((Ubuntu))
443/tcp  open  ssl/http Apache httpd 2.4.52 ((Ubuntu))
3306/tcp open  mysql   MySQL 8.0.35-0ubuntu0.22.04.1

Service detection performed. Please report any incorrect results at https://nmap.org/submit/.
Nmap done: 1 IP address (1 host up) scanned in 12.45 seconds

Agora você sabe que é Ubuntu, Apache 2.4.52 e MySQL 8.0.35. Com essas informações, uma busca no Exploit-DB ou CVE database revela imediatamente se há vulnerabilidades conhecidas. Essa é a transição entre scanning e enumeration — e é aí que o jogo começa.

-O — OS Detection

O fingerprinting de SO funciona enviando pacotes TCP/IP com combinações específicas de flags, opções de TCP, tamanho de janela, e outros parâmetros. Cada SO responde de forma sutilmente diferente — e o Nmap tem um banco de dados com milhares de fingerprints para comparar.

$ sudo nmap -O 192.168.1.50

Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-15 11:15 -03
Nmap scan report for 192.168.1.50
Host is up (0.0030s latency).
Not shown: 993 closed tcp ports (reset)
PORT     STATE SERVICE
22/tcp   open  ssh
80/tcp   open  http
443/tcp  open  https
3306/tcp open  mysql

OS details: Linux 5.15 - 6.1
Network Distance: 2 hops

OS detection performed. Please report any incorrect results at https://nmap.org/submit/.
Nmap done: 1 IP address (1 host up) scanned in 6.78 seconds

O Nmap identificou “Linux 5.15 – 6.1” — consistente com Ubuntu 22.04. Para resultado mais preciso, o CEH recomenda combinar -O com -sV e usar --osscan-guess (que já é padrão). Precisa de pelo menos 1 porta aberta e 1 porta fechada para um fingerprint confiável.

-A — Aggressive Scan

O canivete suíço. Combina: -sV (version detection) + -O (OS detection) + -sC (scripts default) + --traceroute. Tudo em um comando. Rápido de digitar, lento de executar — mas exaustivo.

$ sudo nmap -A 192.168.1.50

Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-15 11:20 -03
Nmap scan report for 192.168.1.50
Host is up (0.0030s latency).
Not shown: 993 closed tcp ports (reset)
PORT     STATE SERVICE    VERSION
22/tcp   open  ssh        OpenSSH 8.9p1 Ubuntu 3ubuntu0.6
| ssh-hostkey:
|   256 a1:b2:c3:d4:e5:f6:... (ECDSA)
|_  256 f6:e5:d4:c3:b2:a1:... (ED25519)
80/tcp   open  http       Apache httpd 2.4.52 ((Ubuntu))
|_http-title: Site does not have a title.
|_http-server-header: Apache/2.4.52 (Ubuntu)
443/tcp  open  ssl/http   Apache httpd 2.4.52 ((Ubuntu))
|_http-title: Site does not have a title.
3306/tcp open  mysql      MySQL 8.0.35-0ubuntu0.22.04.1

OS details: Linux 5.15 - 6.1
Network Distance: 2 hops
TRACEROUTE (using port 443/tcp)
HOP RTT      ADDRESS
1   1.20 ms  192.168.1.1
2   3.40 ms  192.168.1.50

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

Um único comando revelou: portas, versões, SSH host keys, título da página HTTP, header do servidor, SO e rota de rede. É a abordagem “ataque tudo de uma vez” — ideal para CTFs e quando tempo não é problema. Em operações reais, scanners mais discretos são preferidos.

Timing Templates (-T0 a -T5)

Os timing templates controlam o balanceio entre velocidade, stealth e confiabilidade. São um dos recursos mais subestimados do Nmap.

Na prática: Use -T3 (padrão) para a maioria dos casos. -T4 para CTFs e redes confiáveis. -T1 ou -T2 quando stealth importa. Evite -T0 a menos que tiver tempo de sobra — pode levar horas para um /24. Nunca use -T5 contra redes reais — a velocidade gera perda de pacotes e resultados falsos.

# Scan stealth — lento mas discreto
sudo nmap -sS -T1 192.168.1.50 -p- -oN stealth-scan.txt

# Scan agressivo — rápido, ideal para CTF
sudo nmap -sS -T4 192.168.1.50 -p- --min-parallelism 100

# Scan politido — uma requisição por vez
sudo nmap -sS -T2 192.168.1.50

Target Specification

O Nmap aceita praticamente qualquer formato de especificação de alvos. Isso é essencial quando você precisa escanear redes grandes de forma eficiente.

# IP único
nmap 192.168.1.50

# Range de IPs
nmap 192.168.1.1-100

# CIDR (toda a subnet)
nmap 192.168.1.0/24

# Máscara wildcard (equivalente a /24 para .x)
nmap 192.168.1.0-255

# Múltiplos alvos
nmap 192.168.1.50 192.168.1.60 192.168.1.70

# Hostnames
nmap target.example.com

# Combinando
nmap 192.168.1.0/24 10.0.0.1 172.16.0.0/16

# Lista de arquivo
nmap -iL targets.txt

# Excluir IPs
nmap 192.168.1.0/24 --exclude 192.168.1.1,192.168.1.100

# Excluir via arquivo
nmap 192.168.1.0/24 --excludefile skip.txt

# Aleatório (útil para stealth — não scana em ordem)
nmap 192.168.1.0/24 --randomize-hosts

Port Specification (-p)

Por padrão, o Nmap scaneia as top 1000 portas mais comuns. Mas para pentests sérios, você quer ir além.

# Portas específicas
nmap -p 22,80,443 192.168.1.50

# Range
nmap -p 1-1024 192.168.1.50

# Todas as 65535 portas
nmap -p- 192.168.1.50

# Top N portas
nmap --top-ports 100 192.168.1.50

# Fast mode (top 100 portas — muito rápido)
nmap -F 192.168.1.50

# Por protocolo
nmap -sU -p U:53,67,123,161 192.168.1.1

# Combinação TCP+UDP
nmap -sU -sS -p U:53,161,T:22,80,443 192.168.1.50

# Portas por nome de serviço
nmap -p http,https,ssh,mysql 192.168.1.50

# Excluir portas
nmap -p- --exclude-ports 1-1023 192.168.1.50

Estratégia CEH: Comece com -F (fast, 100 portas) para reconhecimento rápido. Depois --top-ports 1000 (padrão) para cobertura normal. Se encontrado algo interessante, -p- para varredura completa das 65535 portas — serviços costumam rodar em portas altas não-padrão (SSH na 2222, HTTP na 8080, MySQL na 3307).

Nmap Scripting Engine (NSE)

A NSE é o que transforma o Nmap de um scanner em um framework de segurança. São scripts escritos em Lua que podem fazer praticamente qualquer coisa: detectar vulnerabilidades, fazer brute-force, enumerar shares SMB, checar configurações SSL, e muito mais.

Categorias de Scripts

• default — executados com -sC ou -A. Scripts seguros e úteis para a maioria dos scans.
• vuln — detecção de vulnerabilidades conhecidas. O primeiro lugar a procurar.
• auth — testar autenticação em serviços (brute-force contra FTP, HTTP basic auth, etc.)
• discovery — enumerar informações extras (DNS, LDAP, SNMP)
• brute — força bruta contra senhas
• exploit — scripts que efetivamente exploram vulnerabilidades (uso cuidadoso)
• external — interagem com serviços externos (WHOIS lookups, geoIP)
• safe — não modificam o alvo (apenas leitura)
• intrusive — podem causar impacto no sistema alvo

Scripts Essenciais para o CEH

# Todos os scripts de vulnerabilidade
sudo nmap -sV --script vuln 192.168.1.50

# Título de páginas HTTP (descoberta rápida de web apps)
nmap --script http-title 192.168.1.0/24

# Enumerar compartilhamentos SMB
sudo nmap --script smb-enum-shares 192.168.1.50 -p 445

# Métodos de autenticação SSH
nmap --script ssh-auth-methods 192.168.1.50 -p 22

# Verificar SSL/TLS (certificados expirados, protocolos fracos)
nmap --script ssl-enum-ciphers -p 443 192.168.1.50

# Detectar backdoors em serviços (ftpd backdoor, etc.)
sudo nmap --script ftp-backdoor 192.168.1.50 -p 21

# Enumerar informações SNMP
sudo nmap --script snmp-info -sU -p 161 192.168.1.1

# Checar se o servidor HTTP está com directory listing
nmap --script http-enum 192.168.1.50 -p 80

# Brute-force FTP (cuidado — gera logs)
nmap --script ftp-brute 192.168.1.50 -p 21

# Descobrir hosts na rede via broadcast
sudo nmap --script broadcast-ping 192.168.1.0/24

# Detectar vulnerabilidades do SMB (EternalBlue, etc.)
sudo nmap --script smb-vuln* 192.168.1.50 -p 445

# Listar todos os scripts de vulnerabilidade disponíveis
ls /usr/share/nmap/scripts/vuln*

Para ver todos os scripts disponíveis:

# Listar todos os scripts com descrição
nmap --script-help="*"

# Descrição de um script específico
nmap --script-help="http-title"

# Contar scripts por categoria
ls /usr/share/nmap/scripts/ | grep "^vuln" | wc -l

Introdução a Scripts NSE

Scripts NSE são escritos em Lua. A estrutura básica tem quatro seções:

-- @description Exemplo de script NSE para CEH
-- @category info
-- @author SeuNome

local shortport = require "shortport"
local stdnse = require "stdnse"

description = [[Script de exemplo que detecta um header personalizado.]]

categories = {"default", "safe"}

portrule = shortport.http

action = function(host, port)
  local http = require "http"
  local response = http.get(host.ip, port.number, "/")
  if response and response.status == 200 then
    return "Header encontrado: " .. response.header["x-custom-header"]
  end
end

A estrutura: description (o que faz), categories (classificação), portrule (quando executar — aqui, quando encontra HTTP), e action (o que faz de fato). A biblioteca shortport facilita a definição de regras de porta. A stdnse fornece funções utilitárias. Para o CEH, não é necessário escrever scripts do zero — mas saber ler e modificar é diferencial.

Output Formats

Todo scan de pentest sério salva output. Sem output, não tem evidência, não tem baseline, não tem relatório. O Nmap suporta múltiplos formatos:

# Normal — legível por humanos
nmap -sS 192.168.1.50 -oN resultado-normal.txt

# XML — estruturado, parseável por ferramentas
nmap -sS 192.168.1.50 -oX resultado.xml

# Grepable — formato simples para grep/awk
nmap -sS 192.168.1.50 -oG resultado.gnmap

# JSON — para integração com pipelines modernos
nmap -sS 192.168.1.50 -oJ resultado.json

# ALL — todos os formatos de uma vez (prefixo comum)
nmap -sS 192.168.1.50 -oA resultado-all

# Adicionar ao arquivo (append) em vez de sobrescrever
nmap -sS 192.168.1.50 -oN resultado.txt --append-output

Qual usar: -oA (all) para pentests formais — você sempre precisa do normal para leitura, do XML para relatórios, e do grepable para análise automatizada. -oN para quick scans. -oJ quando vai processar com jq ou Python.

O formato grepable (-oG) é especialmente útil:

# Extrair todas as portas abertas de um scan
grep "open" resultado.gnmap

# Contar hosts com porta 22 aberta
grep "22/open" resultado.gnmap | wc -l

# Listar hosts com MySQL
grep "3306/open" resultado.gnmap

Evasão de Detecção

O CEH trata extensivamente de técnicas para evitar que scanners sejam detectados por IDS/IPS. A maioria dessas técnicas manipula aspectos dos pacotes para confundir assinaturas de detecção.

Decoys (-D)

Envia pacotes de scan com IPs spoofados misturados com o seu IP real. O IDS vê pacotes vindos de múltiplas fontes simultaneamente e não consegue distinguir qual é o scanner real.

# Decoys aleatórios
sudo nmap -sS -D RND:10 192.168.1.50

# Decoys com IPs específicos (seu IP está na lista em algum lugar)
sudo nmap -sS -D 192.168.1.200,192.168.1.201,192.168.1.202,ME 192.168.1.50

# Decoys com IP do zombie (não está acessível — gera ruído)
sudo nmap -sS -D 10.0.0.1,10.0.0.2,RND 192.168.1.50

RND:10 gera 10 IPs aleatórios. ME é um placeholder para seu IP real (para colocá-lo em uma posição específica da lista). O importante: o IP real sempre fará a conexão de volta — os decoys são IPs spoofados que não respondem, gerando ruído para o IDS.

Fragmentação (-f)

Fragmenta os pacotes TCP em pedaços menores. IDS/IPS frequentemente inspecionam apenas o primeiro fragmento, perdendo payloads que vão nos fragmentos seguintes.

# Fragmentação padrão (8 bytes por fragmento)
sudo nmap -sS -f 192.168.1.50

# Fragmentação menor (16 bytes — passa por mais firewalls)
sudo nmap -sS -f -f 192.168.1.50

# Definir MTU específico (gera fragmentos com esse tamanho)
sudo nmap -sS --mtu 24 192.168.1.50

Source Port Manipulation

Alguns firewalls confiam em pacotes vindos de portas comuns (53 DNS, 20 FTP-data) e os deixam passar sem inspeção.

# Fingir vir da porta 53 (DNS)
sudo nmap -sS --source-port 53 192.168.1.50

# Fingir vir da porta 20 (FTP data)
sudo nmap -sS --source-port 20 192.168.1.50

# Fingir vir da porta 88 (Kerberos)
sudo nmap -sS --source-port 88 192.168.1.50

Outras Técnicas

# Idle scan (o mais indetectável — já detalhado acima)
sudo nmap -sI zombie_ip target_ip

# Randomizar ordem dos hosts
nmap 192.168.1.0/24 --randomize-hosts

# Enviar pacotes de forma lenta (com timing baixo)
sudo nmap -sS -T1 192.168.1.50

# Spoofar MAC address
sudo nmap -sS --spoof-mac 0 192.168.1.50

# Usar interface específica
sudo nmap -sS -e eth0 192.168.1.50

# Adicionar dados extras ao pacote (confunde assinaturas)
sudo nmap -sS --data-length 32 192.168.1.50

Ferramentas Complementares

O Nmap é fantástico, mas não é a única ferramenta. Cada situação pede a ferramenta certa.

Masscan

Quando precisa escanear redes enormes (/16, /8) em tempo útil, o Masscan é a resposta. Usa transmissão assíncrona e pode escanear a internet inteira em menos de 6 minutos.

# Scan de todas as portas em uma subnet /16 (~65k hosts)
masscan 10.0.0.0/16 -p0-65535 --rate=10000

# Scan de portas específicas em velocidade controlada
masscan 192.168.0.0/16 -p80,443,22,3389 --rate=5000

# Salvar output em formato legível
masscan 10.0.0.0/16 -p80 --rate=10000 -oL masscan-results.txt

Quando usar: Descoberta inicial de redes grandes. Identificar rapidamente quais hosts têm portas interessantes abertas. Depois, usar Nmap nos alvos encontrados para detalhamento.

Unicornscan

Assíncrono como o Masscan, mas com foco em UDP e coleta de fingerprinting mais detalhada. Menos popular, mas útil em cenários específicos.

# UDP scan rápido
unicornscan -mU -p 53,161,123 192.168.1.0/24

# TCP scan assíncrono com banner grabbing
unicornscan -mT -p 1-65535 192.168.1.50 -I

Angry IP Scanner

Interface gráfica (Java) para host discovery rápido. Bom para admins de rede que não são confortáveis com CLI. Suporta ping, port scan básico e exportação de resultados. Disponível para Windows, Linux e macOS. Não substitui o Nmap, mas é útil para varreduras rápidas sem complexidade.

Comparativo Rápido

Hands-on: Scan Completo

Vamos fazer um walkthrough completo, simulando um pentest real contra um alvo. Cada passo depende do anterior — é assim que funciona na prática.

Passo 1 — Host Discovery

$ nmap -sn 192.168.1.0/24 -oA phase1-discovery

Nmap scan report for 192.168.1.1     # Gateway
Nmap scan report for 192.168.1.10    # Desenvolvedor
Nmap scan report for 192.168.1.50    # Servidor web
Nmap scan report for 192.168.1.200   # Print server

Resultado: 4 hosts ativos. Vamos focar no 192.168.1.50 (servidor web — provavelmente o alvo mais rico).

Passo 2 — Port Scan Rápido (Fast)

$ sudo nmap -sS -T4 -F 192.168.1.50 -oA phase2-quick

PORT     STATE SERVICE
22/tcp   open  ssh
80/tcp   open  http
443/tcp  open  https
3306/tcp open  mysql
8080/tcp open  http-proxy

Cinco portas interessantes. Agora vamos aprofundar.

Passo 3 — Scan Completo com Detecção de Versão

$ sudo nmap -sS -sV -p- -T4 --min-parallelism 100 192.168.1.50 -oA phase3-full

PORT      STATE  SERVICE    VERSION
22/tcp    open   ssh        OpenSSH 8.9p1 Ubuntu 3ubuntu0.6
80/tcp    open   http       Apache httpd 2.4.52 ((Ubuntu))
443/tcp   open   ssl/http   Apache httpd 2.4.52 ((Ubuntu))
3306/tcp  open   mysql      MySQL 8.0.35-0ubuntu0.22.04.1
8080/tcp  open   http-proxy Nginx 1.18.0
8443/tcp  open   https-alt  Tomcat 9.0.82

Porta 8443 não apareceu no scan rápido (não está no top 100) — mas tem Tomcat rodando. Isso é a diferença entre -F e -p-. Encontrar serviços em portas não-padrão é frequentemente o caminho para acesso.

Passo 4 — Script Scan (Vulnerabilidades)

$ sudo nmap -sV --script vuln 192.168.1.50 -oA phase4-vuln

PORT     STATE SERVICE VERSION
22/tcp   open  ssh     OpenSSH 8.9p1 Ubuntu 3ubuntu0.6
| vulners:
|   cpe:/a:openbsd:openssh:8.9p1:
|     CVE-2023-38408      6.8  https://vulners.com/cve/CVE-2023-38408
80/tcp   open  http    Apache httpd 2.4.52 ((Ubuntu))
| http-cookie-flags:
|   /:
|     PHPSESSID:
|_      httponly flag not set
| http-slowloris-check:
|   VULNERABLE:
|   Slowloris DOS attack
...
443/tcp  open  ssl/http Apache httpd 2.4.52 ((Ubuntu))
| ssl-heartbleed:
|   VULNERABLE:
|   The Heartbleed Bug is a vulnerability in OpenSSL
|_  State: VULNERABLE
3306/tcp open  mysql   MySQL 8.0.35-0ubuntu0.22.04.1
| mysql-vuln-cve2012-2122:
|   VULNERABLE:
|   Authentication bypass in MySQL
...
8443/tcp open  https   Tomcat 9.0.82
| http-enum:
|   /manager/html: Tomcat Manager (login required)
|_  /docs/: Tomcat documentation

O script vuln encontrou: CVE no OpenSSH, cookie sem httponly, potencial Slowloris, Heartbleed no OpenSSL (crítico!), bypass de autenticação no MySQL, e Tomcat Manager exposto. Um tesouro para o próximo estágio — exploitation.

Passo 5 — Resultados Salvos

Todos os outputs foram salvos com -oA (all formats). Agora você tem:

• phase1-discovery.nmap — hosts descobertos
• phase2-quick.nmap — portas rápidas
• phase3-full.nmap — scan completo com versões
• phase4-vuln.nmap — vulnerabilidades encontradas
• Todos em XML e grepable também — prontos para gerar relatório

Contra-medidas: Como se Defender contra Scanning

Se você é o defensor (blue team), precisa saber como detectar e mitigar scans de rede. O CEH cobra esse conhecimento.

Detection com IDS/IPS

Snort (agora pertence a Cisco) e Suricata são os IDS/IPS open source mais usados. Ambos detectam Nmap scans via regras de assinatura:

# Exemplo de regra Snort para detectar Nmap SYN scan
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"NMAP SYN Scan"; flags:S,12; threshold:type both, track by_src, count 30, seconds 30; classtype:attempted-recon; sid:1000001; rev:1;)

# Regra para detectar FIN scan
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"NMAP FIN Scan"; flags:F; threshold:type both, track by_src, count 20, seconds 60; classtype:attempted-recon; sid:1000002; rev:1;)

A lógica: se um único IP envia SYN para 30+ portas em 30 segundos, é quase certamente um scan. A regra alerta antes que o scan complete.

Defesas Ativas

• Firewall stateful — bloqueia pacotes que não fazem parte de uma conexão estabelecida. SYN scans são visíveis. FIN/Xmas/Null podem ser descartados.
• Port knocking — portas só abrem após uma sequência específica de conexões. Ex: conectar na porta 7000, depois 8000, depois 9000 abre a porta 22. O Nmap nunca encontra a porta 22 aberta durante o scan.
• fail2ban — monitora logs e bloqueia IPs que fazem muitas tentativas. Scans de Nmap disparam o bloqueio rapidamente.
• Shadow IPs (honeypots) — endereços IP falsos na rede que não correspondem a nenhum host real. Se alguém scaneia esses IPs, é um scanner. Ferramentas como Canarytokens e T-Pot implementam isso.
• Rate limiting — limitar o número de conexões por segundo por IP. Scans massivos (Masscan, Nmap -T5) ficam ineficientes.
• TCP wrappers — /etc/hosts.allow e /etc/hosts.deny no Linux permitem controlar quem pode se conectar a serviços.
• Desabilitar serviços desnecessários — a melhor defesa contra scanning é não ter nada para escanear. Menos portas abertas = menor superfície de ataque.

# Exemplo de Port Knocking com knockd
[options]
    UseSyslog

[openSSH]
    sequence    = 7000,8000,9000
    sequence_timeout = 5
    command     = /sbin/iptables -A INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
    tcpflags    = syn

[closeSSH]
    sequence    = 9000,8000,7000
    sequence_timeout = 5
    command     = /sbin/iptables -D INPUT -s %IP% -p tcp --dport 22 -j ACCEPT
    tcpflags    = syn

O que Vem a Seguir

Com o scanning completo, você sabe quais portas estão abertas, que serviços rodam, e quais vulnerabilidades existem. O próximo passo lógico é a Enumeration — coletar informações detalhadas sobre cada serviço encontrado: usernames, shares, domínios, banners, configurações, e tudo mais que enriqueça o entendimento do alvo.

No Artigo 08 da série CEH v13 Zero to Hero, vamos cobrir:

• SNMP Enumeration — minerando informações de comunidade pública
• SMB Enumeration — shares, users, grupos, políticas de senha
• LDAP Enumeration — Active Directory, objetos, ACLs
• NTP, DNS e SMTP Enumeration — técnicas específicas por serviço
• Ferramentas — enum4linux, ldapsearch, nbtscan, snmpwalk
• Hands-on — walkthrough completo de enumeração de um alvo Windows + Linux

A enumeration é onde o atacante constrói o mapa mental do alvo — e onde o defensor percebe que deveria ter fechado mais portas. Até lá.