Falsificar paquetes en Scapy

Introducción

En este laboratorio, aprenderás cómo falsificar paquetes de red utilizando Scapy, una poderosa herramienta de manipulación de paquetes basada en Python. Explorarás técnicas prácticas para crear y enviar paquetes TCP personalizados mientras analizas los resultados con Wireshark.

El laboratorio cubre pasos esenciales, incluyendo la instalación de Scapy, la configuración de un entorno virtual de Python y las operaciones de falsificación de paquetes. A través de la práctica práctica, adquirirás valiosos conocimientos sobre la manipulación del tráfico de red y las metodologías de pruebas de seguridad.

Instalar Scapy

En este paso, instalarás Scapy, una poderosa herramienta interactiva de manipulación de paquetes basada en Python utilizada para el análisis de redes y las pruebas de seguridad. Scapy te permite crear, enviar y capturar paquetes de red con un control detallado. Puedes pensar en ella como una navaja suiza para paquetes de red: puedes construir cualquier tipo de paquete de red que necesites.

Antes de comenzar, asegúrate de estar en el directorio de trabajo correcto. El directorio ~/project es donde realizaremos todo nuestro trabajo:

cd ~/project

Ahora instalaremos Scapy utilizando el gestor de paquetes de Python, pip. Pip es como una tienda de aplicaciones para paquetes de Python: descarga e instala software del Índice de Paquetes de Python (Python Package Index, PyPI):

pip install scapy

Después de que se complete la instalación, es una buena práctica verificar que todo se haya instalado correctamente. Lo haremos comprobando el número de versión de Scapy. Esto confirma tanto que Scapy está instalado como que Python puede importarlo correctamente:

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

Deberías ver una salida similar a esta (tu número de versión puede ser ligeramente diferente):

2.4.5

Finalmente, probemos el modo interactivo de Scapy. Esto es como un área de juegos donde puedes experimentar con la creación de paquetes antes de escribir scripts completos. Para entrar en la shell interactiva:

python -m scapy

Sabrás que está funcionando cuando veas el indicador de comandos de Scapy (>>>). Puedes escribir exit() cuando estés listo para salir de la shell interactiva. No te preocupes por explorarla ahora; cubriremos las características interactivas en pasos posteriores.

Configurar un entorno de Python

En este paso, crearás un espacio de trabajo dedicado para tus experimentos con Scapy utilizando el entorno virtual de Python. Puedes pensar en esto como configurar una sala limpia donde puedes trabajar sin afectar a otros proyectos en tu computadora. Los entornos virtuales ayudan a gestionar las versiones de los paquetes y a prevenir conflictos entre diferentes proyectos de Python.

Primero, asegúrate de comenzar desde el lugar correcto. Este comando te dirige al directorio de trabajo predeterminado donde configuraremos nuestro proyecto:
```
cd ~/project
```
Ahora crearemos el entorno virtual llamado scapy-env. Esto crea una nueva carpeta que contiene todos los archivos de Python necesarios para un entorno aislado:
```
python -m venv scapy-env
```
Para comenzar a usar nuestro nuevo entorno, necesitamos activarlo. Cuando esté activo, verás (scapy-env) al principio de la línea de comandos de tu terminal, lo que te recordará en qué entorno estás trabajando:
```
source scapy-env/bin/activate
```
Aunque Scapy puede estar instalado en tu sistema, lo instalaremos específicamente para este entorno. Esto asegura que tengamos la versión exacta que necesitamos para este proyecto:
```
pip install scapy
```
Verifiquemos que todo esté configurado correctamente. Este comando muestra todos los paquetes de Python instalados en nuestro entorno virtual. Deberías ver scapy en la lista, lo que confirma que está listo para usar:
```
pip list
```
Cuando hayas terminado de trabajar (aunque no ejecutes esto ahora, ya que usaremos el entorno en los siguientes pasos), puedes desactivar el entorno virtual para volver al Python del sistema normal:
```
deactivate
```

Crear un paquete TCP

En este paso, utilizarás Scapy para crear un paquete TCP básico. Comprender cómo construir paquetes de red es esencial para el análisis de redes y las pruebas de seguridad. Construiremos un paquete TCP capa por capa, lo que imita cómo funciona la comunicación de red real.

Primero, asegúrate de estar en el directorio correcto y que tu entorno virtual esté activo. El entorno virtual mantiene aislados tus paquetes de Python:
```
cd ~/project
source scapy-env/bin/activate
```
Crea un nuevo script de Python llamado craft_tcp.py. Usaremos el editor de texto nano, pero puedes usar cualquier editor que prefieras:
```
nano craft_tcp.py
```
Añade el siguiente código para crear un paquete TCP simple. Analicemos qué hace cada parte:
- La capa IP define las direcciones de origen y destino.
- La capa TCP especifica los puertos y las banderas de conexión (SYN en este caso).
- El operador / combina estas capas en un paquete 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()
```
Guarda el archivo (Ctrl+O, Enter, Ctrl+X en nano) y ejecútalo. El método .show() mostrará la estructura del paquete:
```
python craft_tcp.py
```

Deberías ver una salida similar a esta, que muestra todos los campos del paquete. Observa cómo Scapy rellena automáticamente algunos valores mientras que otros permanecen como None (se calcularán al 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 paquetes falsificados

En este paso, modificarás tu script de paquetes TCP para enviar paquetes falsificados con una dirección IP de origen falsa. Esto demuestra cómo los atacantes pueden ocultar su origen en las comunicaciones de red. La falsificación (spoofing) es una técnica común en la que el remitente intencionalmente falsifica la dirección de origen en los paquetes IP para ocultar su identidad o suplantar a otro sistema.

Primero, asegúrate de estar en el directorio correcto y que tu entorno virtual esté activo. El entorno virtual mantiene aislados tus paquetes de Python para este proyecto:
```
cd ~/project
source scapy-env/bin/activate
```
Crea un nuevo script de Python llamado send_spoofed.py. Usaremos el editor de texto nano, que es sencillo para los principiantes:
```
nano send_spoofed.py
```

Añade el siguiente código para enviar paquetes TCP falsificados. El código genera direcciones IP aleatorias en rangos privados (192.168.x.x y 10.x.x.x) que son seguros para pruebas. El paquete TCP se envía al servidor DNS de Google (8.8.8.8) en el puerto 53 con la bandera SYN activada:

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")

Guarda el archivo (Ctrl+O, Enter, Ctrl+X en nano) y ejecútalo. El script generará y enviará un paquete falsificado:
```
python send_spoofed.py
```
Deberías ver una salida similar a esta, que muestra la dirección IP de origen falsa que se generó:
```
Sent spoofed TCP packet from 192.168.45.123 to 8.8.8.8
```

Para enviar múltiples paquetes y ver diferentes direcciones IP falsificadas en acción, modifica el script para incluir un bucle. Esto envía 3 paquetes con diferentes direcciones IP de origen aleatorias del rango 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 con Wireshark

En este paso, utilizarás Wireshark para verificar los paquetes falsificados que enviaste en el paso anterior. Wireshark es un potente analizador de protocolos de red que te permite capturar e inspeccionar el tráfico de red en tiempo real. Este proceso de verificación es crucial porque te ayuda a confirmar si tus paquetes falsificados realmente se están transmitiendo en la red con las direcciones IP de origen modificadas.

Primero, asegúrate de estar en el directorio correcto y que tu entorno virtual esté activo. El entorno virtual contiene todos los paquetes de Python necesarios para este laboratorio:
```
cd ~/project
source scapy-env/bin/activate
```
Instala Wireshark en la máquina virtual (VM) de LabEx. Wireshark no está preinstalado, así que primero debemos obtenerlo:
```
sudo apt-get update
sudo apt-get install -y wireshark
```
Inicia Wireshark en segundo plano. El símbolo '&' te permite seguir usando la terminal mientras Wireshark se ejecuta:
```
wireshark &
```
En la interfaz de Wireshark:
- Selecciona la interfaz de red activa (generalmente eth0) - esto representa tu conexión de red.
- Inicia la captura de paquetes haciendo clic en el icono de la aleta de tiburón - esto comienza a registrar todo el tráfico de red.
- Aplica un filtro de visualización: tcp.port == 53 - esto filtra la vista para mostrar solo el tráfico TCP en el puerto 53 (puerto DNS).
En una terminal separada, ejecuta de nuevo tu script de paquetes falsificados. Esto genera nuevo tráfico para que Wireshark lo capture:
```
python send_spoofed.py
```
Observa los resultados en Wireshark:
- Deberías ver paquetes TCP SYN al puerto 53 - estos son los paquetes de inicio de conexión.
- Verifica que las direcciones IP de origen coincidan con tus direcciones IP falsificadas - confirmando que la falsificación funcionó.
- Observa los intentos de handshake TCP (paquetes SYN) - estos muestran los intentos de conexión.
Para guardar la captura para un análisis posterior:
- Haz clic en Archivo → Guardar.
- Guarda como spoofed_capture.pcap en ~/project - los archivos PCAP contienen los datos de paquetes sin procesar para futuras referencias.

Resumen

En este laboratorio, has aprendido cómo instalar y configurar Scapy para la manipulación de paquetes de red en un entorno virtual de Python aislado. El proceso incluyó configurar el entorno, instalar Scapy y verificar su funcionalidad a través de comprobaciones de versión y pruebas interactivas.

También has adquirido experiencia práctica en la creación de paquetes TCP, el envío de paquetes falsificados (spoofed packets) para simular tráfico de red y el análisis de resultados utilizando Wireshark. Estas habilidades proporcionan una base para las pruebas de seguridad de red y las técnicas de manipulación de paquetes.