Spoofing de Pacotes com Scapy: Aprenda a Falsificar Pacotes de Rede

Introdução

Neste laboratório, você aprenderá como falsificar (spoof) pacotes de rede usando o Scapy, uma poderosa ferramenta Python para manipulação de pacotes. Você explorará técnicas práticas para criar e enviar pacotes TCP personalizados, enquanto analisa os resultados com o Wireshark.

O laboratório cobre etapas essenciais, incluindo a instalação do Scapy, a configuração de um ambiente virtual Python e operações de falsificação de pacotes. Através da prática, você obterá informações valiosas sobre a manipulação de tráfego de rede e metodologias de teste de segurança.

Instalar Scapy

Nesta etapa, você instalará o Scapy, uma poderosa ferramenta Python interativa para manipulação de pacotes, usada para análise de rede e testes de segurança. O Scapy permite que você crie, envie e capture pacotes de rede com controle preciso. Pense nisso como um canivete suíço para pacotes de rede - você pode construir qualquer tipo de pacote de rede que precisar.

Antes de começarmos, vamos garantir que estamos no diretório de trabalho correto. O diretório ~/project é onde faremos todo o nosso trabalho:

cd ~/project

Agora, instalaremos o Scapy usando o gerenciador de pacotes do Python, pip. Pip é como uma loja de aplicativos para pacotes Python - ele baixa e instala software do Python Package Index (PyPI):

pip install scapy

Após a conclusão da instalação, é uma boa prática verificar se tudo foi instalado corretamente. Faremos isso verificando o número da versão do Scapy. Isso confirma que o Scapy está instalado e que o Python pode importá-lo com sucesso:

python -c "import scapy; print(scapy.__version__)"

Você deve ver uma saída semelhante a esta (o número da sua versão pode ser ligeiramente diferente):

2.4.5

Finalmente, vamos testar o modo interativo do Scapy. Isso é como um playground onde você pode experimentar a criação de pacotes antes de escrever scripts completos. Para entrar no shell interativo:

python -m scapy

Você saberá que está funcionando quando vir o prompt de comando do Scapy (>>>). Você pode digitar exit() quando estiver pronto para sair do shell interativo. Não se preocupe em explorá-lo agora - abordaremos os recursos interativos nas etapas posteriores.

Configurar um Ambiente Python

Nesta etapa, você criará um espaço de trabalho dedicado para seus experimentos com Scapy usando o ambiente virtual do Python. Pense nisso como configurar uma sala limpa onde você pode trabalhar sem afetar outros projetos em seu computador. Ambientes virtuais ajudam a gerenciar versões de pacotes e a evitar conflitos entre diferentes projetos Python.

Primeiro, vamos garantir que estamos começando do local correto. Este comando navega até o diretório de trabalho padrão onde configuraremos nosso projeto:
```
cd ~/project
```
Agora, criaremos o ambiente virtual chamado scapy-env. Isso cria uma nova pasta contendo todos os arquivos Python necessários para um ambiente isolado:
```
python -m venv scapy-env
```
Para começar a usar nosso novo ambiente, precisamos ativá-lo. Quando ativo, você verá (scapy-env) no início do seu prompt de terminal, lembrando em qual ambiente você está trabalhando:
```
source scapy-env/bin/activate
```
Mesmo que o Scapy possa já estar instalado em seu sistema, nós o instalaremos especificamente para este ambiente. Isso garante que tenhamos a versão exata que precisamos para este projeto:
```
pip install scapy
```
Vamos verificar se tudo está configurado corretamente. Este comando mostra todos os pacotes Python instalados em nosso ambiente virtual. Você deve ver scapy na lista, confirmando que está pronto para uso:
```
pip list
```
Quando você terminar de trabalhar (embora não execute isso agora, pois usaremos o ambiente nas próximas etapas), você pode desativar o ambiente virtual para retornar ao seu Python normal do sistema:
```
deactivate
```

Criar um Pacote TCP

Nesta etapa, você usará o Scapy para criar um pacote TCP básico. Entender como construir pacotes de rede é essencial para análise de rede e testes de segurança. Construiremos um pacote TCP camada por camada, o que imita como a comunicação real de rede funciona.

Primeiro, certifique-se de estar no diretório correto e que seu ambiente virtual esteja ativo. O ambiente virtual mantém seus pacotes Python isolados:
```
cd ~/project
source scapy-env/bin/activate
```
Crie um novo script Python chamado craft_tcp.py. Usaremos o editor de texto nano, mas você pode usar qualquer editor de sua preferência:
```
nano craft_tcp.py
```
Adicione o seguinte código para criar um pacote TCP simples. Vamos detalhar o que cada parte faz:
- A camada IP define os endereços de origem e destino
- A camada TCP especifica as portas e flags de conexão (SYN neste caso)
- O operador / combina essas camadas em um pacote completo
```
from scapy.all import *

## Create IP layer
ip = IP(src="192.168.1.100", dst="192.168.1.1")

## Create TCP layer
tcp = TCP(sport=1234, dport=80, flags="S")  ## SYN packet

## Combine layers to create packet
packet = ip/tcp

## Display packet details
packet.show()
```
Salve o arquivo (Ctrl+O, Enter, Ctrl+X no nano) e execute-o. O método .show() exibirá a estrutura do pacote:
```
python craft_tcp.py
```

Você deve ver uma saída semelhante a esta, mostrando todos os campos do pacote. Observe como o Scapy preenche automaticamente alguns valores, enquanto outros permanecem None (eles serão calculados ao enviar):

###[ IP ]###
  version= 4
  ihl= None
  tos= 0x0
  len= None
  id= 1
  flags=
  frag= 0
  ttl= 64
  proto= tcp
  chksum= None
  src= 192.168.1.100
  dst= 192.168.1.1
  \options\
###[ TCP ]###
     sport= 1234
     dport= http
     seq= 0
     ack= 0
     dataofs= None
     reserved= 0
     flags= S
     window= 8192
     chksum= None
     urgptr= 0
     options= []

Enviar Pacotes Falsificados (Spoofed)

Nesta etapa, você modificará seu script de pacote TCP para enviar pacotes falsificados com um endereço IP de origem falso. Isso demonstra como os invasores podem mascarar sua origem nas comunicações de rede. A falsificação (spoofing) é uma técnica comum em que o remetente falsifica intencionalmente o endereço de origem em pacotes IP para ocultar sua identidade ou se passar por outro sistema.

Primeiro, certifique-se de estar no diretório correto e que seu ambiente virtual esteja ativo. O ambiente virtual mantém seus pacotes Python isolados para este projeto:
```
cd ~/project
source scapy-env/bin/activate
```
Crie um novo script Python chamado send_spoofed.py. Usaremos o editor de texto nano, que é simples para iniciantes:
```
nano send_spoofed.py
```

Adicione o seguinte código para enviar pacotes TCP falsificados. O código gera endereços IP aleatórios em intervalos privados (192.168.x.x e 10.x.x.x), que são seguros para testes. O pacote TCP é enviado para o servidor DNS do Google (8.8.8.8) na porta 53 com a flag SYN definida:

from scapy.all import *
import random

## Spoofed source IP (using private IP range)
spoofed_ip = f"192.168.{random.randint(1,254)}.{random.randint(1,254)}"

## Create and send packet
packet = IP(src=spoofed_ip, dst="8.8.8.8")/TCP(dport=53, flags="S")
send(packet, verbose=False)

print(f"Sent spoofed TCP packet from {spoofed_ip} to 8.8.8.8")

Salve o arquivo (Ctrl+O, Enter, Ctrl+X no nano) e execute-o. O script gerará e enviará um pacote falsificado:
```
python send_spoofed.py
```
Você deve ver uma saída semelhante a esta, mostrando o IP de origem falso que foi gerado:
```
Sent spoofed TCP packet from 192.168.45.123 to 8.8.8.8
```

Para enviar vários pacotes e ver diferentes IPs falsificados em ação, modifique o script para incluir um loop. Isso envia 3 pacotes com diferentes IPs de origem aleatórios da faixa 10.x.x.x:

for i in range(3):
    spoofed_ip = f"10.0.{random.randint(1,254)}.{random.randint(1,254)}"
    packet = IP(src=spoofed_ip, dst="8.8.8.8")/TCP(dport=53, flags="S")
    send(packet, verbose=False)
    print(f"Sent packet {i+1} from {spoofed_ip}")

Verificar com Wireshark

Nesta etapa, você usará o Wireshark para verificar os pacotes falsificados que enviou na etapa anterior. O Wireshark é um poderoso analisador de protocolo de rede que permite capturar e inspecionar o tráfego de rede em tempo real. Este processo de verificação é crucial porque ajuda a confirmar se seus pacotes falsificados estão realmente sendo transmitidos na rede com os endereços IP de origem modificados.

Primeiro, certifique-se de estar no diretório correto e que seu ambiente virtual esteja ativo. O ambiente virtual contém todos os pacotes Python necessários para este laboratório:
```
cd ~/project
source scapy-env/bin/activate
```
Instale o Wireshark na VM do LabEx. O Wireshark não está pré-instalado, então precisamos obtê-lo primeiro:
```
sudo apt-get update
sudo apt-get install -y wireshark
```
Inicie o Wireshark em segundo plano. O símbolo '&' permite que você continue usando o terminal enquanto o Wireshark é executado:
```
wireshark &
```
Na interface do Wireshark:
- Selecione a interface de rede ativa (geralmente eth0) - isso representa sua conexão de rede
- Inicie a captura de pacotes clicando no ícone da barbatana de tubarão - isso começa a gravar todo o tráfego de rede
- Aplique um filtro de exibição: tcp.port == 53 - isso filtra a visualização para mostrar apenas o tráfego TCP na porta 53 (porta DNS)
Em um terminal separado, execute seu script de pacote falsificado novamente. Isso gera novo tráfego para o Wireshark capturar:
```
python send_spoofed.py
```
Observe os resultados no Wireshark:
- Você deve ver pacotes TCP SYN para a porta 53 - estes são os pacotes de inicialização da conexão
- Verifique se os endereços IP de origem correspondem aos seus IPs falsificados - confirmando que a falsificação funcionou
- Observe as tentativas de handshake TCP (pacotes SYN) - estes mostram as tentativas de conexão
Para salvar a captura para análise posterior:
- Clique em File → Save (Arquivo → Salvar)
- Salve como spoofed_capture.pcap em ~/project - os arquivos PCAP contêm os dados brutos dos pacotes para referência futura

Resumo

Neste laboratório, você aprendeu como instalar e configurar o Scapy para manipulação de pacotes de rede em um ambiente virtual Python isolado. O processo incluiu a configuração do ambiente, a instalação do Scapy e a verificação de sua funcionalidade por meio de verificações de versão e testes interativos.

Você também adquiriu experiência prática na criação de pacotes TCP, no envio de pacotes falsificados para simular tráfego de rede e na análise de resultados usando o Wireshark. Essas habilidades fornecem uma base para testes de segurança de rede e técnicas de manipulação de pacotes.