Com sockets você usou a abstração alta de rede, onde o sistema operacional cuida dos detalhes do pacote para você. Agora vamos descer ao chão de fábrica. O Scapy é uma biblioteca Python que te dá controle byte a byte sobre os pacotes: você monta cada camada na mão, define cada flag, e envia à rede exatamente o que quiser — inclusive coisas malformadas ou impossíveis que nenhum programa normal geraria. É esse controle que transforma você de usuário de ferramentas em criador delas, e é a base técnica de metade dos ataques de rede do Bloco XIV. Como Scapy manipula pacotes crus, ele exige privilégios de root, e você vai rodá-lo sempre no seu laboratório.

Um pacote é a soma das suas camadas

A filosofia do Scapy espelha o modelo de camadas da aula TCP/IP e o modelo OSI: como os pacotes realmente viajam: você constrói um pacote empilhando camadas com o operador /, de baixo para cima. Um pacote é literalmente a soma das suas camadas. Veja um ping (ICMP) montado à mão:

from scapy.all import *

pacote = IP(dst="192.168.1.10")/ICMP()   # camada 3 (IP) / camada de ICMP
resposta = sr1(pacote, timeout=2)          # envia e espera 1 resposta

if resposta:
    print(f"[+] {resposta.src} está vivo")
else:
    print("[-] Sem resposta")

Leia o IP(dst=...)/ICMP() assim: "um pacote IP destinado a tal endereço, carregando um payload ICMP". O sr1 (send and receive 1) despacha o pacote e aguarda uma única resposta. Você acabou de escrever um ping — mas, diferente do comando ping, este é seu, e você pode modificar qualquer campo dele à vontade.

O SYN scan que o socket não consegue fazer

O poder real aparece quando montamos algo que sockets não conseguem fazer: um SYN scan puro. Lembre da aula Protocolos em ação: handshake TCP, DNS e inspeção real — um scan stealth envia um SYN e julga a porta pela resposta, sem completar o handshake. Com sockets isso é impossível (o SO completa o handshake por você); com Scapy, você controla a flag diretamente:

from scapy.all import *

alvo = "192.168.1.10"
porta = 80

# monta um pacote TCP com a flag SYN ativada
pacote = IP(dst=alvo)/TCP(dport=porta, flags="S")   # "S" = SYN
resposta = sr1(pacote, timeout=2, verbose=0)

if resposta and resposta.haslayer(TCP):
    if resposta[TCP].flags == "SA":        # SYN-ACK → porta aberta
        print(f"[+] Porta {porta} ABERTA")
        # envia RST para encerrar limpo, sem completar a conexão
        sr(IP(dst=alvo)/TCP(dport=porta, flags="R"), timeout=1, verbose=0)
    elif resposta[TCP].flags == "RA":      # RST-ACK → porta fechada
        print(f"[-] Porta {porta} fechada")
else:
    print(f"[?] Porta {porta} filtrada (sem resposta)")

Repare como o código lê a resposta pela flag: SA (SYN-ACK) significa aberta, RA (RST-ACK) significa fechada, silêncio significa filtrada — exatamente a teoria da aula Protocolos em ação: handshake TCP, DNS e inspeção real, agora em código que você controla. Isso é o Nmap fazendo -sS por dentro. Entender isto é entender scanning num nível que nenhum usuário de ferramenta alcança.

Um mini-Wireshark em cinco linhas

Scapy também fareja (sniffing) o tráfego que passa pela sua interface, dissecando cada pacote capturado:

from scapy.all import *

def processar(pkt):
    if pkt.haslayer(IP):
        print(f"{pkt[IP].src} → {pkt[IP].dst}")

# captura 20 pacotes e chama processar() em cada um
sniff(count=20, prn=processar)

Com poucas linhas você tem um mini-Wireshark de terminal. Filtros no estilo BPF refinam a captura — sniff(filter="tcp port 80", prn=processar) pega só tráfego HTTP. Essa capacidade é a base para inspecionar, extrair credenciais que trafegam em claro num laboratório, e entender o que realmente circula na rede.

A resposta ARP falsa, montada trivialmente

Agora, o exemplo que demonstra o poder e a responsabilidade do Scapy: um ARP spoof, o coração do man-in-the-middle da aula Protocolos em ação: handshake TCP, DNS e inspeção real. Lembra que o ARP não tem autenticação e qualquer um pode responder "esse IP sou eu"? Scapy monta essa resposta falsa trivialmente:

from scapy.all import *

# APENAS PARA LABORATÓRIO CONTROLADO E AUTORIZADO
# diz à vítima que o IP do gateway agora corresponde ao MAC do atacante
vitima_ip   = "192.168.1.20"
gateway_ip  = "192.168.1.1"

pacote = ARP(op=2,                    # op=2 é uma resposta ARP ("is-at")
             pdst=vitima_ip,          # para a vítima
             psrc=gateway_ip,         # afirmando ser o gateway
             hwsrc=get_if_hwaddr(conf.iface))  # mas com o MAC do atacante
send(pacote, verbose=0)

Enviado repetidamente, esse pacote convence a vítima de que o caminho para o roteador passa pela máquina do atacante, que então intercepta todo o tráfego dela. Mostro o código porque entender o mecanismo é o que te permite explicá-lo, detectá-lo e defendê-lo — e porque ele torna concreta a fragilidade estrutural do ARP. Mas cravo o aviso que vale para o curso inteiro: isto derruba a comunicação de uma máquina real e só se executa em ambiente isolado, seu, autorizado. Rodar contra a rede de terceiros é o crime do art. 154-A da aula A lei que separa a carreira do processo criminal, sem meio-termo. Voltaremos ao ataque completo, com a devida moldura defensiva, na aula ARP spoofing e Man-in-the-Middle: interceptando a conversa.

Pacote é estrutura de dados, e estrutura se altera

O que Scapy consolida é a mentalidade do bloco técnico inteiro: os pacotes que sustentam a internet são apenas estruturas de dados, e estruturas de dados podem ser construídas, lidas e alteradas por você. A rede deixa de ser uma caixa-preta e vira material maleável nas suas mãos. Do lado defensivo, essa mesma capacidade alimenta o Blue Team — gerar tráfego de teste para validar regras de detecção, dissecar pacotes suspeitos numa investigação, entender exatamente como um ataque de rede se manifesta no fio. A ferramenta é a mesma; o que muda, como sempre, é a autorização e a intenção.

Fontes e leituras recomendadas

  • Documentação oficial do Scapy (scapy.readthedocs.io) — com tutoriais práticos
  • Black Hat Python — Justin Seitz (capítulos de manipulação de pacotes)
  • Violent Python — TJ O'Connor (projetos com Scapy)
  • SANS, workshops gratuitos de Scapy para análise e criação de pacotes

Exercícios

  1. Qual a diferença fundamental entre trabalhar com sockets (aula Python para pentest I: construindo seu próprio scanner de portas) e com Scapy, em termos de nível de controle sobre o pacote?

    ✓ Resposta:

    Sockets são uma abstração alta em que o sistema operacional monta e gerencia os detalhes do pacote; o Scapy dá controle byte a byte, permitindo definir cada camada e cada flag manualmente, inclusive criando pacotes malformados que um programa normal não geraria.

  2. Explique o que o operador / faz na construção de um pacote no Scapy, dando um exemplo.

    ✓ Resposta:

    O / empilha camadas, de baixo para cima, para montar o pacote. Exemplo: IP(dst="x")/TCP(dport=80) monta um pacote IP carregando um segmento TCP destinado à porta 80.

  3. Por que um SYN scan puro é possível com Scapy, mas não com sockets comuns?

    ✓ Resposta:

    Porque o SYN scan exige enviar apenas o SYN e não completar o handshake; com sockets, o sistema operacional completa o handshake automaticamente, enquanto o Scapy permite controlar a flag e interromper a troca.

  4. No SYN scan em Scapy, o que as respostas com flags SA e RA indicam sobre o estado da porta?

    ✓ Resposta:

    SA (SYN-ACK) indica que a porta está aberta; RA (RST-ACK) indica que está fechada. A ausência de resposta indicaria porta filtrada.

  5. Por que o exemplo de ARP spoof só pode ser executado em laboratório autorizado, e a que lei da aula A lei que separa a carreira do processo criminal seu uso indevido corresponde?

    ✓ Resposta:

    Porque ele corrompe a tabela ARP de uma máquina real e intercepta seu tráfego, interrompendo/desviando comunicação alheia; feito sem autorização, configura acesso/interferência indevida punida pelo art. 154-A (Lei 12.737/2012). Só é legítimo em ambiente isolado, próprio e autorizado.