Volver a la página principal
miércoles 9 octubre 2024
58

Manipulación Avanzada de Protocolos de Red con Scapy

La manipulación de protocolos de red es una habilidad clave para los profesionales de la ciberseguridad y administradores de redes. Scapy es una herramienta poderosa de Python que permite construir, enviar, recibir y analizar paquetes de red con gran flexibilidad. A lo largo de este artículo, profundizaremos en el uso avanzado de Scapy para la manipulación de protocolos de red, cubriendo desde la creación y manipulación de paquetes personalizados hasta el análisis detallado de tráfico.

¿Qué es Scapy?

Scapy es una librería escrita en Python que facilita la creación y manipulación de paquetes de red de diversos protocolos como TCP/IP, ARP, ICMP y más. Además de construir y enviar paquetes, Scapy permite a los usuarios realizar análisis de tráfico y responder a eventos de red en tiempo real. Esta herramienta es utilizada frecuentemente en auditorías de seguridad, pruebas de penetración y para la comprensión profunda del comportamiento de los protocolos.

Instalación de Scapy

Para comenzar, es necesario instalar Scapy en el entorno de desarrollo. Puede instalarse fácilmente usando pip: 

pip install scapy

Si se requieren capacidades más avanzadas o soporte para otros protocolos, se recomienda instalar la versión completa de Scapy: 

pip install scapy[complete]

Importando Scapy en Python

Para utilizar Scapy en scripts de Python, simplemente se debe importar la librería de la siguiente manera: 

from scapy.all import *

Esto importa las funciones principales y los protocolos comunes, como IP, TCP, UDP y otros.

Manipulación de Paquetes de Red

Creación de Paquetes Básicos

La estructura fundamental de Scapy está basada en la creación y manipulación de paquetes individuales. A continuación, se muestra cómo crear un paquete IP básico con el protocolo ICMP: 

packet = IP(dst="192.168.1.1")/ICMP()

Este ejemplo crea un paquete IP con destino a la dirección 192.168.1.1 y un mensaje ICMP adjunto (usualmente utilizado en comandos ping). La estructura se basa en la concatenación de capas (/), donde cada capa se apila sobre la anterior. La capa superior es siempre la primera en ser creada, como IP, seguida de capas de transporte como ICMP, TCP o UDP.

Modificación de Atributos de los Paquetes

Cada capa de un paquete en Scapy tiene atributos que pueden ser modificados de manera independiente. Por ejemplo, si se desea cambiar la dirección IP de origen: 

packet.src = "10.0.0.2"

Esto cambia el campo de dirección de origen a 10.0.0.2, permitiendo falsificar la procedencia de los paquetes.

Construcción de Paquetes TCP Personalizados

Scapy permite un control detallado sobre los campos de los paquetes TCP, como números de secuencia, banderas y puertos: 

tcp_packet = IP(dst="192.168.1.1")/TCP(dport=80, flags="S", seq=12345)

En este ejemplo, se crea un paquete TCP con una bandera SYN, utilizada para iniciar conexiones, con un número de secuencia personalizado (seq=12345).

Campos Comunes en Paquetes TCP

  • dport: Puerto de destino.
  • sport: Puerto de origen.
  • flags: Banderas TCP (S, A, F, R, etc.).
  • seq: Número de secuencia.
  • ack: Número de reconocimiento.

Envío de Paquetes con Scapy

El envío de paquetes en Scapy se realiza con la función send() o sendp(), dependiendo del nivel de la capa (IP o Ethernet). Por ejemplo: 

send(tcp_packet)

Esto envía el paquete creado anteriormente a través de la red. También se puede usar sr() y sr1() para enviar y recibir respuestas.

Análisis de Tráfico y Sniffing con Scapy

Scapy no solo permite la creación de paquetes, sino también la captura y análisis de tráfico. La función sniff() captura paquetes que coinciden con ciertos filtros y puede usarse para crear scripts personalizados de análisis.

Captura de Paquetes con sniff()

La sintaxis básica para capturar paquetes es: 

packets = sniff(count=10, filter="tcp and host 192.168.1.1")

Esto captura 10 paquetes que correspondan a tráfico TCP hacia la dirección 192.168.1.1. Los parámetros comunes de sniff() son:

  • count: Número de paquetes a capturar.
  • filter: Expresión de filtro BPF (similar a tcpdump).
  • iface: Interfaz de red (por defecto usa la primera).

Análisis Detallado con show()

Cada paquete capturado puede analizarse utilizando la función show() de Scapy, que despliega la estructura interna del paquete: 

packets[0].show()

Esto muestra los campos de cada capa del primer paquete capturado, permitiendo entender mejor los atributos del tráfico de red.

Modificación y Reenvío de Paquetes Capturados

Una característica avanzada de Scapy es la capacidad de modificar paquetes capturados y reenviarlos. Por ejemplo, cambiar el puerto de destino de un paquete TCP: 

packets[0][TCP].dport = 8080
send(packets[0])

Esto puede ser utilizado para manipular tráfico en pruebas de seguridad, ataques de intermediario (Man-in-the-Middle) o pruebas de configuración de red.

Técnicas Avanzadas de Manipulación

Falsificación de Paquetes (Packet Spoofing)

La falsificación de paquetes se utiliza en muchas pruebas de seguridad para simular ataques como suplantación de IP (IP Spoofing) o envenenamiento ARP. A continuación, un ejemplo básico de cómo realizar IP Spoofing: 

spoofed_packet = IP(src="10.0.0.1", dst="192.168.1.1")/TCP(dport=80, flags="S")
send(spoofed_packet)

Este paquete parece provenir de 10.0.0.1, pero en realidad se envía desde la máquina local. Este tipo de técnicas requiere precaución y un entorno controlado para evitar consecuencias no deseadas.

Inyección de Paquetes en Redes Wi-Fi

Scapy soporta el manejo de tramas a nivel 2 (capa de enlace), lo que permite la manipulación de tramas 802.11. Por ejemplo, para desautenticar un cliente de una red Wi-Fi: 

deauth_packet = RadioTap()/Dot11(addr1="ff:ff:ff:ff:ff:ff", addr2="00:11:22:33:44:55", addr3="00:11:22:33:44:55")/Dot11Deauth()
sendp(deauth_packet, iface="wlan0", count=100)

En este script, se inyectan 100 tramas de desautenticación (Dot11Deauth) a través de la interfaz wlan0.

Respuestas Automatizadas con sniff()

Scapy permite reaccionar a eventos en tiempo real. Un ejemplo sería responder a pings ICMP automáticamente: 

def icmp_reply(packet):
    if packet.haslayer(ICMP) and packet[ICMP].type == 8:  # ICMP Echo Request
        reply = IP(dst=packet[IP].src)/ICMP(type=0, id=packet[ICMP].id, seq=packet[ICMP].seq)
        send(reply)

sniff(filter="icmp", prn=icmp_reply)

Este script escucha tráfico ICMP y responde a cada solicitud Echo Request con un Echo Reply adecuado.

Conclusión

Scapy es una herramienta extremadamente flexible y poderosa para la manipulación avanzada de protocolos de red. Permite a los usuarios crear, modificar y analizar paquetes de forma granular, lo que la hace indispensable en pruebas de seguridad, auditorías de red y análisis de tráfico. Con las técnicas descritas aquí, los profesionales pueden llevar a cabo tareas complejas de manipulación y análisis de red que antes requerían múltiples herramientas especializadas.

Sin embargo, es fundamental utilizar Scapy con responsabilidad y en entornos controlados, ya que la manipulación inadecuada de paquetes puede causar interrupciones de red o efectos no deseados.

Etiquetas:
hacking python scapy
Compartir:
Creado por:
Author photo

Jorge García

Fullstack developer