Scapy es una herramienta escrita en Python que permite generar y manipular paquetes de red. Se puede usar para crear, editar y enviar paquetes de diferentes capas (Ethernet, IP, etc.), y también para leer y modificar capturas de paquetes guardadas en archivos PCAP. Scapy soporta más de 150 protocolos y ofrece comandos para diferentes tareas como la visualización, edición y envío de paquetes, y la manipulación de archivos PCAP.
Scapy Generación y manipulación básica de paquetes de red
1. Scapy Generación y manipulación básica de paquetes de red David Cristóbal López “ Osito” Arroutada 18 – A Coruña 17 a 20 de Noviembre de 2011
2.
3.
4.
5. Scapy es capaz de “diseccionar” la mayoría de protocolos que existen (IP, Ethernet, STP, HSRP…) Para ver todos los protocolos que soporta, se usa el comando ls() Protocolos Protocolos
7. Para el control de Scapy, disponemos de varios comandos, que pueden ser listados con el comando lsc() Comandos Comandos
8. Hay comandos que no se muestran en la ayuda, como los de gestión de ficheros (rdpcap, wrpcap) o los de mostrar gráficos (psdump, pdfdump) La disponibilidad de muchos de los comandos, depende de si están instaladas las librerías adicionales para dar esa funcionalidad (desencriptación WEP, dibujo, …) Algunas de las extensiones sólo están disponibles para Linux Comandos
9. Para generar paquetes, hay que utilizar los protocolos antes mencionados. Se pueden generar paquetes tanto de capa 2 (Ethernet) como de capa 3 (IP), necesarios para la comunicación. Después, se añaden el resto de protocolos que necesitemos Generación de paquetes Generación de paquetes
10. Para generar datos de paquete de capa 2, utilizamos el protocolo Ethernet, abreviado como Ether(), indicando MAC de origen (src) y de destino (dst). Para introducir ambos campos, se separan por una coma (,) capa2=Ether(src=“00:00:0c:12:34:56”,dst=“00:fa:ba:da:00:01”) Generación de paquetes
11. En capa 3, tenemos más campos dentro del comando, aparte de un campo de checksum. Éste campo puede rellenarse o no, ya que se puede generar al momento de enviarse capa3=IP(src=“192.168.0.1”,dst=“10.200.250.18”) Generación de paquetes
12. Crear un paquete desde cero, puede ser lioso si necesitamos introducir demasiados parámetros. paquete=Ether(src=“00:00:0c:12:34:56”,dst=“00:fa:ba:da:00:01”)/IP(src=“192.168.0.1”,dst=“10.200.250.18”) Podemos trabajar con varios “paquetes” de datos, cada uno en un tipo de capa Una vez creadas todas las capas, podemos apilarlas, generando un único paquete Apilado de capas Apilado de capas
15. Evidentemente, es necesario ver de vez en cuando cómo está el paquete de datos en memoria y si lo hemos generado correctamente. Para visualizar los paquetes en memoria, tenemos 3 comandos: show(), show2() y hexdump() Sintaxis: p.show() Muestra el paquete en memoria p.show2() Muestra el paquete rellenando los campos que se deben autogenerar hexdump(p) Vuelca el contenido hexadecimal Visualización Visualización
16. El comando show() nos muestra el contenido del paquete tal y como lo hemos introducido al generarlo. Es una función heredada en cada paquete de datos automáticamente NombreDelPaquete.show() Visualización
17. El comando show2() rellena automáticamente los campos que deben autogenerarse al enviarlo, como el checksum, para ver el paquete exacto que saldrá a la red NombreDelPaquete.show2() Visualización
18. Mediante hexdump() obtenemos el paquete de datos en formato hexadecimal, tal y como se mostraría en cualquier captura de red. Se le pasa como variable el nombre del paquete de datos Visualización
19. Una vez generado el paquete de datos, es necesario lanzarlo a la red, ya que para ello se ha creado. Podemos enviarlo como paquete de capa 2 o de capa 3, mediante los comandos sendp() y send() respectivamente. Estos comandos, generan automáticamente campos como el Checksum. Se le pasa como variable el nombre del paquete de datos. También podemos enviar varias veces el mismo paquete. Envío Envío
23. Generar tráfico mandando paquetes de uno en uno, es lioso y complicado, aparte de lento. Por ello, podemos cargar una captura hecha con un sniffer , tipo Wireshark o tcpdump . De la misma manera, capturas modificadas con scapy pueden ser guardadas a un fichero pcap. Para ello, disponemos de los comando rdpcap() y wrpcap() . También podemos capturar tráfico directamente con scapy, mediante sniff() Manipulación de ficheros Manipulación de ficheros
25. Para visualizar un único paquete, se trata como a un elemento de un array. NombreDelArray[NumeroDePaquete].show() captura[0].show() Manipulación de ficheros
26. Para guardar un paquete o un conjunto de paquetes en un fichero pcap, usamos wrpcap() Debemos indicar el nombre del fichero y los datos a guardar. wrpcap(NombreDelFichero,Paquete/Array) wrpcap(“capt2.pcap”,paquete) Manipulación de ficheros
27. También es posible obtener directamente el tráfico de red con scapy, sin necesidad de importarlo de otros programas, mediante el comando sniff Podemos indicar el número máximo de paquetes que queremos recibir o dejarlo obteniendo tráfico hasta pulsar Ctrl+c capturalarga=sniff() capturaacotada=sniff(50) Manipulación de ficheros
29. Cuando tenemos una captura completa y queremos modificar algún campo de algún paquete en concreto, tener que generar todo de nuevo mediante comandos sería extremadamente largo y tedioso. Tampoco podemos indicarle de nuevo el mismo protocolo, ya que lo duplicaría en el paquete o eliminaría el resto de capas. Para editar cualquier campo, es necesario indicar el paquete, el protocolo y el campo a editar. NombreDelPaquete[Protocolo].Campo=NuevoValor Edición de paquetes capturados Edición de paquetes capturados
32. De esta manera, podemos capturar tráfico entre equipos (STP, HSRP, VRRP…) y replicarlo cambiando valores, para realizar ataques, contraataques, manipulaciones en la elección de servidores, envenenamientos ARP, etc.) También generar paquetes desde cero para hacer ataques de flooding o de spoofing , ya sea en ARP, DHCP, DNS) Edición de paquetes capturados