Mapeia endereços MAC na rede local.

Contexto

O protocolo ARP (Address Resolution Protocol) é o responsável por traduzir endereços IP em endereços físicos (MAC Address) dentro de uma rede local. Quando um dispositivo quer falar com outro na mesma rede, ele grita: "Quem tem o IP X? Diga ao MAC Y".

Um Pentester utiliza o ARP Scanner para:

• Identificar Dispositivos Ocultos: Mesmo que um computador bloqueie o Ping (ICMP), ele precisa responder a requisições ARP para funcionar na rede.
• Mapear Fabricantes: Os primeiros 3 bytes do MAC Address (OUI) revelam o fabricante do hardware (ex: Apple, Cisco, Dell), ajudando a identificar se o alvo é um servidor, um celular ou um roteador.
• Preparar Ataques de Man-in-the-Middle: Ter o mapa de endereços MAC é o primeiro passo para realizar um

Possibilidades de Implementação

• Scapy (Recomendado): Permite criar pacotes ARP do zero e enviá-los via broadcast (para todos na rede). É a forma mais precisa e rápida.
• Manipulação de Cache: Ler a tabela ARP do próprio sistema operacional (comando arp -a). É passivo, mas limitado ao que o computador já "conheceu".
• Broadcasting Personalizado: Enviar um pacote para o endereço MAC especial ff:ff:ff:ff:ff:ff, forçando todos os dispositivos do segmento a processarem a requisição.

Código

Para este módulo, utilizaremos a biblioteca Scapy. Ela permite realizar o escaneamento de forma extremamente eficiente enviando uma única requisição de broadcast para toda a sub-rede.

Requisito: pip install scapy

from scapy.all import ARP, Ether, srp
import sys

def arp_scan(ip_range):
    """
    Envia pacotes ARP Request para um range de IPs e mapeia os endereços MAC.
    """
    print(f"[*] Escaneando a rede: {ip_range}")

    # 1. Cria o pacote ARP Request (Quem tem o IP X?)
    arp_request = ARP(pdst=ip_range)

    # 2. Cria o frame Ethernet de Broadcast (Para todos na rede)
    broadcast = Ether(dst="ff:ff:ff:ff:ff:ff")

    # 3. Combina os pacotes: Ethernet + ARP
    packet = broadcast / arp_request

    # 4. Envia o pacote e recebe as respostas (srp = Send and Receive Packets na Camada 2)
    # timeout: tempo de espera / verbose: oculta detalhes internos
    answered_list = srp(packet, timeout=2, verbose=False)[0]

    clients = []
    for element in answered_list:
        client_dict = {"ip": element[1].psrc, "mac": element[1].hwsrc}
        clients.append(client_dict)

    return clients

def display_results(results):
    print("-" * 45)
    print(f"{'IP ADDRESS':15} | {'MAC ADDRESS':20}")
    print("-" * 45)
    for client in results:
        print(f"{client['ip']:15} | {client['mac']:20}")
    print("-" * 45)

if __name__ == "__main__":
    print("=" * 45)
    print("Módulo: ARP Scanner | Projeto: 30 Lessons")
    print("=" * 45)

    # Altere para a sua sub-rede local (ex: 192.168.1.0/24)
    target_network = "192.168.1.0/24"

    try:
        scan_results = arp_scan(target_network)
        display_results(scan_results)
    except PermissionError:
        print("[!] Erro: Você precisa de privilégios de Administrador/Root.")
    except Exception as e:
        print(f"[!] Erro inesperado: {e}")

Observações

• Velocidade: O ARP scan é muito mais rápido que o Ping Sweep porque não depende de timeouts de Camada 3 (IP).
• Segmentação: Esta ferramenta só funciona dentro da mesma rede local. Pacotes ARP não passam por roteadores (são limitados ao domínio de broadcast).
• Segurança: Devido à natureza do Scapy de enviar pacotes crus (raw packets), o terminal deve ser executado como Sudo (Linux/macOS) ou Administrador (Windows).