Sniffing e Ataques Man-in-the-Middle: Interceptando Tráfego de Rede

Todo dado que atravessa uma rede passa como pacotes — e quem consegue capturar esses pacotes consegue ler tudo: credenciais, emails, conversas, sessões inteiras. O sniffing é a arte de escutar a rede. O Man-in-the-Middle (MITM) é a arte de se colocar no caminho entre duas partes que confiam uma na outra. Juntos, formam um dos pilares mais antigos — e ainda eficazes — do ataque em redes.

Este artigo cobre desde a teoria de como o tráfego flui na rede até ataques práticos com Ettercap, Wireshark, ARP spoofing, DNS spoofing, SSL stripping e session hijacking. No fim, as contra-medidas que todo profissional de segurança precisa implementar.

1. O que é Sniffing

Sniffing é o processo de capturar e analisar pacotes de rede enquanto eles trafegam entre origem e destino. Em redes Ethernet, cada pacote é entregue a uma placa de rede (NIC) com base no endereço MAC de destino. Por padrão, a NIC só processa pacotes cujo MAC de destino seja o dela ou o endereço de broadcast. Tudo o mais é descartado no hardware — o sistema operacional nunca vê.

O modo promíscuo muda isso. Quando ativado, a NIC passa a aceitar todos os pacotes que chegam à interface física, independentemente do MAC de destino. É como abrir a janela e escutar todas as conversas do corredor, não só as que são para você.

Hub vs Switch

A topologia da rede determina quão fácil é o sniffing:

  • Hub: Dispositivo antigo que repete todo tráfego recebido em todas as portas. Cada pacote é um broadcast efetivo. Qualquer máquina conectada ao hub vê o tráfego de todas as outras. Sniffing é trivial — basta colocar a interface em modo promíscuo.
  • Switch: Dispositivo inteligente que mantém uma tabela MAC (CAM table) mapeando cada porta ao MAC conectado. Pacotes são encaminhados apenas à porta de destino. Modo promíscuo sozinho não basta — você só vê seu próprio tráfego e broadcasts.

Em redes modernas com switches, o atacante precisa de técnicas ativas (como ARP spoofing) para forçar o tráfego a passar por ele. Mas em redes Wi-Fi, onde o meio físico é compartilhado, o sniffing é mais acessível — especialmente se a rede estiver em modo aberto ou se o atacante conseguir a chave WPA/WPA2.

Do Wiretapping Analógico ao Digital

A origem do sniffing é o wiretapping — fisicamente interceptar cabos telefônicos. Na era digital, não é preciso cortar cabos. Basta ter acesso à rede e colocar a interface em modo promíscuo. Em redes corporativas, isso significa estar conectado à rede (cabo, Wi-Fi) ou comprometer uma máquina que já está dentro. É por isso que segmentação de rede e monitoramento de ARP são defesa essencial.

2. Wireshark Masterclass

Wireshark é o analisador de pacotes mais usado do mundo. Interface gráfica, suporte a centenas de protocolos, filtros poderosos e ferramentas de estatística. É indispensável para qualquer profissional de segurança — atacante ou defensor.

Interface

  • Packet List (lista de pacotes): Tabela com um resumo de cada pacote capturado — número, tempo, endereço IP de origem/destino, protocolo, comprimento e info resumida. Clicar em um pacote mostra os detalhes.
  • Packet Details (detalhes do pacote): Árvore hierárquica com cada camada do pacote — Ethernet, IP, TCP/UDP, HTTP, DNS, etc. Cada campo pode ser expandido e inspecionado.
  • Packet Bytes (bytes do pacote): Representação hexadecimal e ASCII do pacote bruto. Útil para análise de payloads e malware.

Filtros de Captura (BPF — Berkeley Packet Filter)

Aplicados antes da captura, definem o que o Wireshark salva. São mais eficientes porque reduzem o volume de dados capturado:

  • tcp port 80 — apenas tráfego HTTP
  • host 192.168.1.1 — todo tráfego envolvendo esse host
  • src host 10.0.0.5 and dst port 443 — tráfego desse host para HTTPS
  • not arp and not dns — excluir ARP e DNS
  • net 192.168.1.0/24 — toda a sub-rede
  • tcp[tcpflags] & (tcp-syn) != 0 — apenas pacotes com flag SYN
  • icmp — apenas ping e relacionados

Filtros de Exibição (Display Filters)

Aplicados depois da captura, filtram o que é exibido na interface sem descartar dados:

  • http.request — todas as requisições HTTP
  • http.request.method == "POST" — apenas POST
  • http.authorization — credenciais HTTP (Basic Auth)
  • tcp.stream eq 0 — uma stream TCP específica
  • ip.src == 192.168.1.100 — pacotes originados desse IP
  • dns — todas as consultas e respostas DNS
  • tls.handshake.type == 1 — Client Hello TLS
  • tcp contains "password" — pacotes TCP contendo a string “password”
  • frame.len > 1000 — pacotes maiores que 1000 bytes
  • http.response.code == 200 — respostas HTTP OK
  • arp.duplicate-address-detected — detecção de conflito ARP (possível spoofing)

Funcionalidades Essenciais

  • Follow TCP/UDP Stream: Clique com o botão direito num pacote → Follow → TCP Stream. Reconstrói a conversa inteira entre cliente e servidor. Útil para ler HTTP, SMTP, FTP em texto claro. Atalho: Ctrl+Shift+T (TCP) ou Ctrl+Shift+U (UDP).
  • Statistics → Conversations: Lista todas as conversas (Ethernet, IP, TCP, UDP) com contagem de pacotes e bytes. Identifica rapidamente quem fala mais com quem.
  • Statistics → Endpoints: Todos os endpoints vistos na captura com volume de tráfego. Útil para identificar hosts ativos.
  • Statistics → IO Graphs: Gráfico de tráfego ao longo do tempo. Permite filtrar por protocolo, detectar picos, identificar transferências grandes.
  • Expert Info (Analisar → Informações do Especialista): Avisa sobre anomalias — retransmissões excessivas, checksums errados, pacotes fora de ordem. O Wireshark já faz triagem automática.
  • Colorização: Por padrão, o Wireshark coloriza pacotes por protocolo (azul = TCP, verde = HTTP, cinza = UDP, etc.). É possível criar regras customizadas em View → Coloring Rules.
  • Export Objects: File → Export Objects permite extrair arquivos da captura — HTTP (imagens, documentos, scripts), SMB (arquivos compartilhados), DNS, FTP, TFTP. Extremamente útil durante investigação.

3. tcpdump — A Alternativa CLI

Quando não há interface gráfica (servidores headless, SSH remoto, scripts automatizados), tcpdump é a ferramenta de escolha. Usa os mesmos filtros BPF do Wireshark por baixo dos panos.

Comandos Comuns

# Capturar na interface eth0
tcpdump -i eth0

# Capturar sem resolver nomes (mais rápido, sem DNS)
tcpdump -i eth0 -n

# Mostrar hex + ASCII do payload (-XX)
tcpdump -i eth0 -XX

# Salvar captura em arquivo para análise posterior no Wireshark
tcpdump -i eth0 -w captura.pcap

# Filtrar porta 80 e host específico
tcpdump -i eth0 -n 'port 80 and host 10.0.0.1'

# Apenas tráfego de saída
tcpdump -i eth0 -n 'src host 10.0.0.1'

# Capturar exatamente 100 pacotes
tcpdump -i eth0 -c 100

# Filtro por protocolo
tcpdump -i eth0 -n 'icmp'
tcpdump -i eth0 -n 'udp port 53'

# Capturar pacotes com tamanho mínimo (útil para detectar transferências grandes)
tcpdump -i eth0 -n 'greater 1024'

# Ler arquivo .pcap capturado anteriormente
tcpdump -r captura.pcap -n 'http'

tcpdump vs Wireshark

Critério tcpdump Wireshark
Interface Linha de comando Gráfica (GTK/Qt)
Cenário ideal Servidores, scripts, headless Análise interativa, investigação
Desempenho Mais leve, menos overhead Mais pesado, mais recursos
Filtros BPF (mesma base do Wireshark) BPF + Display Filters (mais ricos)
Arquivo de captura .pcap/.pcapng (compatível) .pcap/.pcapng (nativo)
Análise avançada Limitada Follow Stream, IO Graphs, Expert Info

Na prática, use tcpdump para capturar no servidor remoto e copie o .pcap para analisar no Wireshark localmente.

4. ARP Spoofing / Poisoning

O ARP (Address Resolution Protocol) resolve endereços IP em endereços MAC — sem criptografia, sem autenticação, sem estado. Qualquer máquina na rede pode enviar uma resposta ARP não solicitada (gratuitous ARP) e o destino vai atualizar sua cache ARP sem questionar. É o calcanhar de Aquiles de redes Ethernet.

Como Funciona

O ataque de ARP spoofing explora essa confiança cega:

  1. O atacante identifica a vítima (ex: 192.168.1.50) e o gateway padrão (ex: 192.168.1.1).
  2. Envia ARP replies falsos para a vítima dizendo: “O MAC do gateway (192.168.1.1) é MEU MAC.”
  3. Envia ARP replies falsos para o gateway dizendo: “O MAC da vítima (192.168.1.50) é MEU MAC.”
  4. Ambos atualizam suas caches ARP erroneamente.
  5. Agora todo tráfego entre vítima e gateway passa pelo atacante — Man-in-the-Middle.

O atacante pode simplesmente sniffar o tráfego passivo (modificar o forwarding IP para encaminhar pacotes) ou modificar o tráfego em trânsito. Protocolos sem criptografia (HTTP, FTP, SMTP, Telnet, DNS em texto claro) ficam completamente expostos.

Ferramentas

# arpspoof (parte da suíte dsniff)
# Habilitar IP forwarding
echo 1 > /proc/sys/net/ipv4/ip_forward

# Envenenar cache ARP da vítima (gateway falsificado)
arpspoof -i eth0 -t 192.168.1.50 192.168.1.1

# Dupla direção (envenenar vítima E gateway)
arpspoof -i eth0 -t 192.168.1.50 192.168.1.1 &
arpspoof -i eth0 -t 192.168.1.1 192.168.1.50 &

Ettercap oferece interface gráfica (GTK) para o mesmo ataque: Hosts → Scan for hosts → Adicionar à target list → Mitm → ARP poisoning → Start sniffing. Três cliques para interceptar todo tráfego da rede.

5. DNS Spoofing

Se o atacante controla o tráfego via ARP spoofing, pode também falsificar respostas DNS. Quando a vítima consulta “www.facebook.com”, o atacante responde com o IP de um servidor falso sob seu controle.

Mecanismo

  1. Atacante está em MITM via ARP spoofing.
  2. Vítima envia consulta DNS para o resolver legítimo.
  3. Atacante intercepta a consulta e envia uma resposta DNS falsa antes do resolver real.
  4. A vítima aceita a primeira resposta recebida (race condition).
  5. Vítima é redirecionada para IP do atacante — site falso (phishing), servidor malicioso, ou página de captura de credenciais.

Ferramentas

# dnsspoof (parte da suíte dsniff)
# Interceptar consultas DNS e redirecionar
dnsspoof -i eth0

# Com arquivo de hosts customizado (/etc/hosts)
dnsspoof -i eth0 -f hosts.txt

# Conteúdo do hosts.txt
# 192.168.1.100  www.facebook.com
# 192.168.1.100  www.gmail.com
# 192.168.1.100  login.yahoo.com

Ettercap também tem um plugin nativo de DNS spoofing: Ativar o plugin “dns_spoof” e editar o arquivo etter.dns com os mapeamentos desejados.

O DNS cache poisoning é uma variante mais sofisticada onde o atacante corrompe a cache do resolver DNS (não apenas a máquina da vítima), afetando todos os clientes que usam esse resolver. O ataque famoso de Dan Kaminsky (2008) explorou exatamente isso usando IDs de transação previsíveis em consultas DNS.

6. DHCP Starvation e Spoofing

DHCP Starvation

O ataque de DHCP starvation esgota o pool de endereços IP do servidor DHCP legítimo, impedindo que novas máquinas obtenham configuração de rede — ou forçando-as a aceitar configuração de um servidor DHCP malicioso.

# Usando yersinia para DHCP starvation
yersinia -I - dhcp -attack 1

# Usando gobbler (legado)
gobbler eth0

A ferramenta envia centenas de solicitações DHCP com MACs aleatórios (falsificados), consumindo todo o pool de IPs disponíveis.

DHCP Spoofing (Rogue DHCP)

Depois de esgotar o pool legítimo (ou simultaneamente), o atacante levanta um servidor DHCP malicioso que responde antes do legítimo. Esse servidor atribui à vítima:

  • Gateway padrão = IP do atacante
  • DNS = IP do atacante

Resultado: MITM sem precisar de ARP spoofing. O atacante é o gateway e o DNS da vítima — controla todo o roteamento e resolução de nomes.

7. SSL Stripping

O SSL stripping é um ataque de downgrade que transforma conexões HTTPS em HTTP, removendo a criptografia sem que a vítima perceba. Foi popularizado por Moxie Marlinspike em 2009 com a ferramenta sslstrip.

Como Funciona

  1. Atacante em MITM via ARP spoofing.
  2. Vítima acessa http://www.exemplo.com (HTTP, sem criptografia).
  3. O site responde com redirect para https://www.exemplo.com.
  4. O atacante intercepta o redirect e devolve o conteúdo via HTTP (não HTTPS).
  5. O atacante mantém uma conexão HTTPS própria com o servidor real.
  6. Vítima navega em HTTP puro — credenciais, cookies, tudo em texto claro para o atacante.
  7. O ícone de cadeado nunca aparece porque o navegador nunca estabeleceu HTTPS com o site real.
# sslstrip (obsoleto, apenas para referência)
sslstrip -l 8080
# Usado com iptables para redirecionar tráfego:
# iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port 8080

Por que é menos comum hoje?

  • HSTS (HTTP Strict Transport Security): O servidor envia o header Strict-Transport-Security e o navegador se recusa a usar HTTP para aquele domínio. Mesmo que o atacante tente fazer downgrade, o navegador ignora.
  • HTTPS Everywhere: Extensão de navegador (agora integrada ao HTTPS por padrão em browsers modernos) que força conexões HTTPS.
  • HSTS Preload List: Navegadores modernos incluem uma lista hardcoded de domínios que sempre usam HTTPS — sem nunca fazer a primeira requisição em HTTP.

SSL stripping ainda funciona contra sites que não implementam HSTS ou que aceitam conexões HTTP para subdomínios. Nunca é demais reforçar: HTTPS em tudo, HSTS em tudo.

8. Session Hijacking via MITM

Com o MITM ativo, o atacante pode capturar cookies de sessão de aplicações web (especialmente HTTP sem Secure flag). Ao obter o session cookie, o atacante pode usar esse cookie no próprio navegador e assumir a identidade da vítima — sem precisar de usuário ou senha.

Ferramentas

  • Firesheep (2010): Extensão de Firefox que automatizava o session hijacking em redes Wi-Fi abertas. Mostrava um botão “Start Capturing” e listava contas capturadas (Facebook, Twitter, etc.). Um clique para sequestrar a sessão. Embora obsoleto, seu conceito é fundamental — demonstrou que session cookies em HTTP são inseguros por definição.
  • Cookie Cadger: Ferramenta Java que captura cookies de sessão transmitidos em redes sem fio. Interface gráfica que lista hosts, cookies capturados e permite abrir a sessão no navegador.
  • Bettercap: Ferramenta moderna (ver seção 9) com módulos de HTTP proxy que interceptam e extraem cookies automaticamente.

Session Sidejacking

Variante onde o atacante captura o cookie de sessão sem precisar de MITM ativo — basta sniffar o tráfego em redes Wi-Fi abertas ou com WEP/WPA fraco. O cookie trafega em texto claro (HTTP) e pode ser reinjetado. A defesa é simples: cookie com flags Secure (só trafega em HTTPS) e HttpOnly (não acessível via JavaScript).

9. Ferramentas Completas

Ettercap

Clássico do ataque MITM. Suporta ARP poisoning, DNS spoofing, SSL stripping, credential harvesting, filtragem de conteúdo e muito mais. Duas interfaces: GTK (gráfica) e CLI.

# Modo texto
ettercap -T -M arp:remote /192.168.1.50// /192.168.1.1//

# Com script específico
ettercap -T -q -i eth0 -M arp:remote /192.168.1.50// /192.168.1.1// -s /usr/share/ettercap/etter.conf

# Plugins populares
ettercap -T -M arp:remote /192.168.1.50// /192.168.1.1// -P dns_spoof
ettercap -T -M arp:remote /192.168.1.50// /192.168.1.1// -P autoadd
ettercap -T -M arp:remote /192.168.1.50// /192.168.1.1// -P repoison_arp

Bettercap

Ferramenta moderna, modular, escrita em Go. Substituiu Ettercap como padrão da indústria para MITM. Suporta Ethernet, Wi-Fi, BLE, HID. API REST para automação. Ativação de módulos por comando.

# Atualizar e instalar
sudo apt install bettercap

# Iniciar em modo interativo
sudo bettercap -iface eth0

# Comandos no prompt do bettercap
net.probe on              # Descobrir hosts na rede
net.sniff on              # Iniciar sniffing
set arp.spoof.targets 192.168.1.50  # Definir alvo
arp.spoof on              # Ativar ARP spoofing
http.proxy on             # Ativar proxy HTTP para interceptação
set http.proxy.script custom.js  # Script de manipulação

# Capturar credenciais automaticamente
net.sniff on
# O módulo de sniffing já extrai credenciais por padrão

# API REST
# bettercap expõe API em http://localhost:8081/api
curl http://localhost:8081/api/session

Comparação

Critério Ettercap Bettercap
Idioma C Go
Interface GTK / CLI CLI + API REST
Protocolos Ethernet, Wi-Fi (básico) Ethernet, Wi-Fi, BLE, HID
Extensibilidade Plugins C/Lua Módulos Go + JavaScript
Manutenção Menos ativa Ativa, comunidade forte
SSL stripping Sim (parcial) Sim (via http.proxy)
DNS spoofing Plugin nativo Módulo nativo
Automatização Limitada API REST + scripts
Wireshark integration Sim Exporta pcap

Para novos projetos e ambientes modernos, Bettercap é a escolha correta. Ettercap permanece relevante para labs educacionais e cenários específicos.

10. Hands-on: MITM Completo

AMBIENTE DE LABORATÓRIO. Execute estes testes apenas em redes que você controla. Ataques MITM contra redes de terceiros sem autorização são ilegais. Use VMs (VirtualBox, VMware) com Kali Linux e Metasploitable ou um lab isolado.

Etapa 1: ARP Poisoning com Ettercap

# 1. Habilitar IP forwarding (para que o tráfego continue fluindo)
echo 1 > /proc/sys/net/ipv4/ip_forward

# 2. Escanear a rede
ettercap -T -q -i eth0

# Dentro do prompt do Ettercap:
net.probe on
net.update

# 3. Adicionar alvos
# Ver hosts descobertos e identificar vítima e gateway
# Adicionar ao grupo 1 (vítima): host 192.168.1.50
# Adicionar ao grupo 2 (gateway): host 192.168.1.1

# 4. Iniciar ARP poisoning (MITM)
mitm on
# Ou na linha de comando:
ettercap -T -q -i eth0 -M arp:remote /192.168.1.50// /192.168.1.1//

# 5. Ativar sniffing
# Tudo que a vítima envia/recebe agora passa por você

Etapa 2: Capturar Credenciais HTTP

# Com Wireshark aberto em paralelo:
# Filtro para capturar credenciais em texto claro:
http.request.method == "POST"

# Follow TCP Stream nos pacotes POST para ver:
# username=admin&password=Senha123&submit=Login

# Ou usar o parser automático do Ettercap que exibe
# credenciais capturadas no console em tempo real

Etapa 3: DNS Spoofing

# 1. Editar arquivo de mapeamento DNS
sudo nano /etc/ettercap/etter.dns
# Adicionar:
# *.google.com   A   192.168.1.100    # IP do servidor falso
# www.facebook.com A   192.168.1.100

# 2. Ativar plugin de DNS spoofing no Ettercap
# No prompt: dns_spoof on

# 3. A vítima agora é redirecionada para o servidor falso
# quando acessa Google ou Facebook

Etapa 4: Wireshark — Analisar o Tráfego

# Capturar tudo durante o ataque:
# Filtro BPF na captura: host 192.168.1.50

# Filtros de exibição úteis:
http.request                  # Ver todas as requisições
http.request.method == "POST"  # Formulários com credenciais
dns.qry.name contains "google" # Consultas DNS para Google
arp.duplicate-address-detected # Detectar ARP spoofing (sua própria atividade)
tcp.stream eq N               # Seguir uma conversa específica
http.cookie                   # Cookies de sessão
frame contains "password"     # Qualquer pacote contendo "password"

# Para exportar objetos HTTP:
# File → Export Objects → HTTP
# Lista todas as imagens, JS, CSS, documentos baixados

# Statistics → IO Graphs:
# Criar gráfico com filtro "http" para visualizar
# volume de tráfego web ao longo do tempo

11. Tabela de Ataques MITM

Ataque Protocolo Alvo Ferramenta Resultado Dificuldade
ARP Spoofing Ethernet/IPv4 arpspoof, Ettercap, Bettercap MITM total Baixa
DNS Spoofing DNS dnsspoof, Ettercap Redirecionamento Baixa
DHCP Starvation DHCP yersinia, gobbler DoS / Rogue DHCP Baixa
DHCP Spoofing DHCP yersinia, rogue DHCP MITM via gateway Média
SSL Stripping HTTPS → HTTP sslstrip, Bettercap Credenciais em claro Média
Session Hijacking HTTP cookies Firesheep, Cookie Cadger Sequestro de sessão Baixa
Session Sidejacking HTTP cookies Wireshark, tcpdump Reutilização de cookie Baixa
ICMP Redirect IPv4 Nmap, custom Redirecionamento de rota Média
NDP Spoofing (IPv6) IPv6/NDP Parasite6, fake_router6 MITM em IPv6 Média

12. Contra-medidas

Defender contra MITM exige camadas. Nenhuma medida isolada é suficiente.

Proteção em Camada 2 (Ethernet)

  • Switches, nunca hubs: Hubs fazem broadcast de tudo. Switches encaminham por porta. Substitua qualquer hub legado.
  • Port Security: Configure o switch para limitar o número de MACs por porta e/ou restringir a quais MACs cada porta aceita. Impede MAC flooding e limita ARP spoofing.
  • Static ARP entries: Entradas ARP estáticas no gateway e em servidores críticos. Não escalável para redes grandes, mas essencial para infraestrutura crítica.
  • Dynamic ARP Inspection (DAI): Recurso em switches gerenciáveis (Cisco, etc.) que valida respostas ARP contra uma tabela DHCP snooping binding. ARP replies não autorizados são descartados. Essencial em redes corporativas.
  • ARP fluxo monitorado: Use ferramentas como arpwatch ou XArp para detectar mudanças inesperadas na tabela ARP — múltiplos MACs para o mesmo IP são sinal de ARP spoofing.

Proteção em Camada 3+

  • HTTPS everywhere + HSTS: Forçar HTTPS em todos os sites. Implementar HSTS com preload. Sem HTTP, não há SSL stripping nem session hijacking via cookie em claro.
  • Certificate Pinning: A aplicação espera um certificado específico (ou emitido por CA específica). Certificados falsos são rejeitados mesmo que o MITM tente apresentá-los. Implementado em apps mobile e browsers modernos.
  • VPN: Criptografa todo tráfego entre o cliente e o gateway VPN. Mesmo com MITM ativo, o atacante só vê tráfego criptografado. Essencial para redes não confiáveis (Wi-Fi público, hotéis).
  • Encrypted DNS (DoH / DoT): DNS over HTTPS (porta 443) e DNS over TLS (porta 853) criptografam as consultas DNS. Impedem DNS spoofing e sniffing de consultas. Chrome, Firefox e Android suportam nativamente.
  • Network Segmentation: VLANs para isolar segmentos de rede. Um atacante em uma VLAN não pode fazer ARP spoofing em outra. Guest Wi-Fi em VLAN separada é obrigatório.
  • IDS/IPS: Sistemas como Suricata ou Snort detectam anomalias ARP — múltiplas respostas ARP para o mesmo IP em intervalo curto, MACs conflitantes, volume anormal de pacotes ARP. Regras específicas para detecção de ARP spoofing:
# Exemplo de regra Suricata para detecção de ARP spoofing
alert arp any any -> any any (msg:"ARP Spoofing - Multiple MACs for same IP"; \
  arp.opcode == 2; content:"|00 01|"; depth:2; \
  threshold:type both, track by_src, count 5, seconds 30; \
  sid:1000001; rev:1;)

Defesa Anti-DHCP

  • DHCP Snooping: No switch, configure quais portas são “trusted” (podem enviar DHCP offers) e quais são “untrusted”. Portas untrusted só podem enviar DHCP discovers/requests, nunca offers. Bloqueia rogue DHCP servers.
  • IP Source Guard: Vincula um IP a uma porta/MAC específicos. Mesmo que o atacante consiga um IP via DHCP, não pode usar IPs arbitrários naquela porta.

Próximo Artigo

No Artigo 17 — Session Hijacking: Sequestrando Sessões TCP, Web e Wireless, vamos aprofundar as técnicas de sequestro de sessão: TCP session hijacking (seq/ack prediction), web session hijacking, token theft, fixation e sequestro de token, e como frameworks modernos se defendem contra cada tipo de ataque. Se o MITM é o caminho para o tráfego, o session hijacking é o caminho para a identidade — roubar a sessão já estabelecida sem precisar de credenciais.