python - Envío de paquetes desde pcap con src/dst modificado en scapy

Question

Estoy tratando de enviar un tráfico previamente grabado (capturado en formato pcap) con scapy. Actualmente estoy atascado en la capa de éter original striping. El tráfico se capturó en otro host y básicamente necesito cambiar tanto la capa IP como la capa Ether src y dst. Me las arreglé para reemplazar la capa IP y recalcular las sumas de comprobación, pero la capa Ether me causa problemas.

¿Alguien tiene experiencia en reenviar paquetes desde un archivo de captura con cambios aplicados a la capa IP y Ether (src y dst)? Además, la captura es bastante grande de Gb, ¿qué tal el rendimiento de scapy con tales cantidades de tráfico?

Answer 1

Bueno, con scapy se me ocurrió lo siguiente (perdón por mi Python). Esperemos que ayude a alguien. Hubo un posible escenario más simple en el que todos los paquetes del archivo pcap se leen en la memoria, pero esto podría causar problemas con los archivos de captura grandes.

from scapy.all import *
global src_ip, dst_ip
src_ip = 1.1.1.1
dst_ip = 2.2.2.2
infile = "dump.pcap"

try:
    my_reader = PcapReader(infile)
    my_send(my_reader)
except IOError:
    print "Failed reading file %s contents" % infile
    sys.exit(1)

def my_send(rd, count=100):
    pkt_cnt = 0
    p_out = []

    for p in rd:
        pkt_cnt += 1
        np = p.payload
        np[IP].dst = dst_ip
        np[IP].src = src_ip
        del np[IP].chksum
        p_out.append(np)
        if pkt_cnt % count == 0:
            send(PacketList(p_out))
            p_out = []

    # Send remaining in final batch
    send(PacketList(p_out))
    print "Total packets sent %d" % pkt_cn

Answer 2

Para una suma de comprobación correcta, también necesitaba agregar del p[UDP].chksum

Answer 3

Si fuera tú, dejaría que Scapy se ocupara de la capa Ether y usara la función send() . Por ejemplo:

ip_map = {"1.2.3.4": "10.0.0.1", "1.2.3.5": "10.0.0.2"}
for p in PcapReader("filename.cap"):
    if IP not in p:
        continue
    p = p[IP]
    # if you want to use a constant map, only let the following line
    p.src = "10.0.0.1"
    p.dst = "10.0.0.2"
    # if you want to use the original src/dst if you don''t find it in ip_map
    p.src = ip_map.get(p.src, p.src)
    p.dst = ip_map.get(p.dst, p.dst)
    # if you want to drop the packet if you don''t find both src and dst in ip_map
    if p.src not in ip_map or p.dst not in ip_map:
        continue
    p.src = ip_map[p.src]
    p.dst = ip_map[p.dst]
    # as suggested by @AliA, we need to let Scapy compute the correct checksum
    del(p.chksum)
    # then send the packet
    send(p)

Answer 4

mira este ejemplo

from scapy.all import *
from scapy.utils import rdpcap

pkts=rdpcap("FileName.pcap")  # could be used like this rdpcap("filename",500) fetches first 500 pkts
for pkt in pkts:
     pkt[Ether].src= new_src_mac  # i.e new_src_mac="00:11:22:33:44:55"
     pkt[Ether].dst= new_dst_mac
     pkt[IP].src= new_src_ip # i.e new_src_ip="255.255.255.255"
     pkt[IP].dst= new_dst_ip
     sendp(pkt) #sending packet at layer 2

comentarios:

• use rdpcap, wrpcap scapy para leer y escribir desde un archivo con formato pcap
• puede usar sniff(offline="filename") para leer paquetes y puede usar el parámetro prn como este sniff(offline="filename",prn=My_Function) en este caso, My_Functions se aplicará a cada pkt sniffed
• la forma correcta de escribir su nueva ip o mac es considerarla como una cadena ex: ip="1.1.1.1" y así sucesivamente como se ilustra arriba.
• en el ejemplo: método sendp incluido en el bucle for, que es más lento que hacer otro bucle para enviar paquetes
• Sugerencia de rendimiento: en Python, el uso de bucles es demasiado lento. En su lugar, utilice el map si desea una velocidad como un bucle for en C, Ref
• rdpcap, como se usó anteriormente, lee el archivo de una vez, si la memoria disponible durante la lectura dice, por ejemplo, 1.5 Gb y usted está leyendo un archivo de 2,3, .. Gb, fallará.
• si el problema de rendimiento es crítico para usted, puede usar winpcap pero tiene que escribir código más complejo en C; hacer la misma tarea usando python / scapy es bastante simple y sencillo pero no es más rápido que c
• Depende de cuál utilizar en el nivel de rendimiento necesario.
• si mi suposición es correcta, está enviando un paquete de transmisión de video en este caso, yo usaría un winpcap si estoy enviando un video de 1 mega píxeles o scapy en otros casos (menor tamaño por fotograma)
• en el caso de usar C / winpcap obtendrá un gran rendimiento en la lectura de pcaps y cambiará los datos y los reenviará, pero debe tener en cuenta el mismo problema (archivos grandes) para crear un búfer con el tamaño adecuado. Lectura enviando los paquetes en un rendimiento bastante.
• Si el tamaño del paquete es constante (lo cual es raro en la mayoría de los casos, supongo) puede tener la ventaja de aprovechar al máximo la memoria disponible.
• Si desea usar python / scapy para el "proyecto / programa" completo, puede crear las funciones de alto rendimiento en C / Wincap y compilarlas como dll, luego puede importar este dll a su programa python y puede usarlo dentro de un programa python. . De esta manera, obtiene los beneficios de python / Scapy maravillosamente fácil y solo escribe funciones específicas en c para que pueda hacer su trabajo más rápido y su código sea centrado y fácil de mantener.