Reenvia pacotes capturados para tentar repetir uma ação no servidor.

Contexto

O Packet Replay consiste em capturar um tráfego legítimo entre um cliente e um servidor e retransmiti-lo posteriormente. O objetivo é enganar o servidor para que ele execute a mesma ação novamente, sem que o atacante precise saber as credenciais originais.

É comumente usado para:

• Bypassing de Autenticação: Se um token de sessão ou comando de login for reenviado e o servidor não tiver proteção de nonce (número usado uma única vez) ou timestamp, a sessão pode ser reaberta.
• Ataques em IoT: Muitos dispositivos domésticos inteligentes aceitam comandos de rede simples (como "abrir porta"). Capturar e repetir esse pacote permite o controle do dispositivo.
• Teste de Idempotência: Verificar se uma transação financeira ou comando administrativo pode ser duplicado indevidamente.

Possibilidades de Implementação

• Captura e Injeção com Scapy: A forma mais versátil. Você captura um pacote específico, modifica o que for necessário (como IPs ou portas) e o injeta de volta na rede.
• Leitura de Arquivos PCAP: O script pode ler um arquivo de captura gerado pelo Wireshark e reenviar todos os pacotes contidos nele em uma sequência cronometrada.
• Modificação On-the-fly: Alterar campos do cabeçalho TCP/IP antes do reenvio para mascarar a origem do ataque.

Código

Este módulo utiliza a biblioteca Scapy para ler um pacote capturado e retransmiti-lo na interface de rede.

Requisito: pip install scapy

from scapy.all import rdpcap, send, conf
import sys

def packet_replay(pcap_file, interface, count=1):
    """
    Lê pacotes de um arquivo PCAP e os reenvia pela interface de rede.
    """
    print(f"[*] Lendo pacotes de: {pcap_file}")

    try:
        # Carrega os pacotes do arquivo de captura
        packets = rdpcap(pcap_file)
        print(f"[+] {len(packets)} pacotes carregados.")

        # Define a interface de saída
        conf.iface = interface

        print(f"[*] Iniciando replay na interface {interface} ({count} vez/es)...")

        for i in range(count):
            # Envia a lista de pacotes
            # inter: intervalo entre os pacotes para simular o tráfego real
            send(packets, inter=0.1, verbose=True)

        print("\n[+] Replay concluído com sucesso.")

    except FileNotFoundError:
        print(f"[!] Erro: Arquivo {pcap_file} não encontrado.")
    except PermissionError:
        print("[!] Erro: Privilégios de Administrador/Root necessários para injetar pacotes.")
    except Exception as e:
        print(f"[!] Erro inesperado: {e}")

def main():
    print("=" * 60)
    print("Módulo: Packet Replay Tool | Projeto: 30 Lessons in Python")
    print("=" * 60)

    # Configurações para o teste
    # Você pode gerar este arquivo usando o módulo 'Network Sniffer' ou Wireshark
    arquivo_pcap = "captured_traffic.pcap"
    interface_rede = "eth0" # No Windows, use o nome da interface ou IP

    # Verifica se o arquivo existe antes de tentar
    import os
    if not os.path.exists(arquivo_pcap):
        print(f"[!] Crie um arquivo '{arquivo_pcap}' com tráfego capturado para testar.")
        return

    packet_replay(arquivo_pcap, interface_rede, count=1)

if __name__ == "__main__":
    main()

Observações

• Sequenciamento TCP: O protocolo TCP usa números de sequência (seq) e reconhecimento (ack). Um replay simples de pacotes TCP costuma falhar se a conexão original já foi encerrada, pois o servidor esperará números novos. Esta ferramenta funciona melhor com protocolos UDP ou protocolos sem estado.
• Camada 2 vs Camada 3: Se você estiver reenviando pacotes em uma rede diferente da original, precisará ajustar os endereços MAC (Camada 2) para que o roteador local saiba para onde enviar o pacote.
• Prevenção: Explique que a defesa contra isso envolve o uso de TLS/SSL (criptografia ponta a ponta), Tokens Anti-Replay e carimbos de tempo (timestamps) validados pelo servidor.