ARP Spoofing también se conoce como ARP Poisoning, que es un tipo de ataque cibernético en el que un usuario malicioso envía mensajes ARP (Protocolo de resolución de direcciones) falsificados a través de una LAN (Red de área local) . Esto da como resultado la vinculación de la dirección MAC de un atacante con la dirección IP de una computadora o servidor legítimo en la red.
Aquí realizaremos un monitoreo pasivo o escaneo para rastrear los paquetes en la red después de recibir un paquete ARP. Hay dos cosas que analizar, al compararlas si no coinciden, entonces el usuario está bajo un ataque ARP Spoof. Para falsificar y detectar los paquetes ARP dentro de la red, use Scapy con Python para realizar la detección de paquetes ARP con la ayuda de la dirección MAC y la interfaz.
- Dirección MAC de origen
- Dirección MAC real del remitente
¿Qué es Scapy?
Scapy es una herramienta de manipulación de paquetes para redes informáticas, escrita originalmente en Python. Puede falsificar o decodificar paquetes, enviarlos por cable, capturarlos y unir requests y respuestas. También puede manejar tareas como escaneo, rastreo de enrutamiento, sondeo, pruebas unitarias, ataques y descubrimiento de redes. Se ejecuta en Linux, macOS y Windows, pero las últimas versiones de Scapy son compatibles con Windows desde el primer momento, por lo que también es posible usar todas las funciones de Scapy en una máquina con Windows. Scapy puede realizar lo siguiente
- Elaborar cualquier paquete y codificarlo.
- Rastreo de paquetes de red
- Envío de tramas válidas/no válidas
- Inyectando sus propios marcos 802.11
- Edición de paquetes de red
- Escaneando la red
- Trazado y sondeo
- Ataque de Redes y descubrimiento de redes.
Instalación de Scapy
Para instalar Scapy es necesario que tengas instalada la versión Python 2.7 o Python 3.9+. Si no está instalado, consulte esta Instalación de Python . Para evitar los MITM, utilice la Inspección dinámica de ARP, una característica de seguridad que rechazará automáticamente los paquetes ARP maliciosos que se detectarán.
linux
Para un usuario de Linux, es posible ejecutar scapy sin libcap.
- Instale tcpdump y asegúrese de que esté en $PATH
$ sudo apt-get tcpdump
- El kernel debe tener sockets de paquetes seleccionados: CONFIG_PACKET
- Si Kernel es inferior a 2.6, asegúrese de que está seleccionado Filtrado de sockets: CONFIG_FILTER
Otro método para instalar Scapy en Linux es instalar Python en Linux Machine y luego instalar Scapy Package dentro de Python Shell.
$ sudo apt-get install python3
Después de instalar python en el terminal, abra el shell de python y ejecute el comando para instalar scapy, luego, para usar scapy para la detección de falsificación de ARP, abra Scapy para escribir su código para falsificar y detectar paquetes dentro de la red.
$ sudo apt-get install scapy (OR) $ python -m install scapy $ python >> scapy
Debian/Fedora/Ubuntu
# Debian $ sudo apt-get install tcpdump # Fedora $ yum install tcpdmp
Luego instale Scapy a través de pip o apt. Todas las dependencias se pueden instalar a través de un instalador específico de la plataforma o a través de PyPI
ventanas
Para instalar scapy en Windows, se puede hacer fácilmente a través de un símbolo del sistema, pero para Windows también se debe preinstalar Python en el sistema. Luego se ejecutarán los comandos para instalar scapy.
C:\> python -m install python-scapy C:\> python >> scapy
Ahora comencemos con la detección de ataques falsos de ARP usando Scapy en Python
Detección de ataques falsos ARP usando Scapy
Ahora que hemos instalado con éxito python y scapy en los sistemas, procedamos a importar las bibliotecas necesarias de scapy.
Python3
# importing libraries from scapy from scapy.all import Ether, ARP, srp, sniff, conf import scapy as scapy # to import all libraries from scapy # irrespective of which one to use execute the code from scapy.all import *
El programa detectará si algún tipo de paquete tiene una capa de ARP falsificado para ejecutar el código. La función sniff() tomará una devolución de llamada para aplicarla a cada paquete que se rastreará. In store=False le dice a la función sniff() que descarte los paquetes rastreados en lugar de almacenarlos en la memoria, es útil cuando el script se ejecuta durante mucho tiempo.
Use this code to check the interface of the machine you want to sniff >> conf.iface
Python3
# importing all libraries of scapy
import scapy.all as scapy
# taking interface of the system as an argument
# to sniff packets inside the network
def sniff(interface):
# store=False tells sniff() function to discard sniffed packets
scapy.sniff(iface=interface, store=False, prn=process_sniffed_packet)
def process_sniffed_packet(packet):
# if it is an ARP Packet and if it is an ARP Response
if packet.haslayer(scapy.ARP) and packet[scapy.ARP].op == 2:
print(packet.show())
# machine interface is "eth0", sniffing the interface
sniff("eth0")
Después de buscar la interfaz eth0 , mostrará el contenido de la interfaz. Aquí vemos que la interfaz es Ethernet y su contenido relacionado se muestra como Destino IP (dst), tipo de interfaz (ARP), fuente (src)
Se crea una función mac que una dirección IP dada para hacer/crear una solicitud ARP arp_request usando la función ARP y recupera la dirección MAC real que la dirección IP. Establezca la dirección MAC de transmisión en “ff:ff:ff:ff:ff:ff” usando la función Ether. La función srp devuelve dos listas de direcciones IP que respondieron al paquete. La dirección MAC que tiene la dirección IP coincidente que se solicitó se almacenará en el campo hwsrc .
Se creará una función para obtener la dirección MAC y procesar el paquete rastreado, obteniendo valores de MAC antiguo en la variable «originalmac» y valor de MAC en la respuesta como variable «repsonsemac». Scapy codifica el tipo de paquete ARP en el campo «op» para la operación, por defecto, op es 1 o «quién tiene», que es una solicitud ARP.
Python3
# code to get MAC Address def mac(ipadd): # requesting arp packets from the IP address # if it's wrong then will throw error arp_request = scapy.ARP(pdst=ipadd) br = scapy.Ether(dst="ff:ff:ff:ff:ff:ff") arp_req_br = br / arp_request list_1 = scapy.srp(arp_req_br, timeout=5, verbose=False)[0] return list_1[0][1].hwsrc # defining function to process sniffed packet def process_sniffed_packet(packet): # if it is an ARP packet and if it is an ARP Response if packet.haslayer(scapy.ARP) and packet[scapy.ARP].op == 2: # originalmac will get old MAC whereas originalmac = mac(packet[scapy.ARP].psrc) # responsemac will get response of the MAC responsemac = packet[scapy.ARP].hwsrc
Ahora compare ambos valores y verifique si son similares o no en caso de que no sean similares, esto significa que los valores han sido falsificados. Los valores que se comparan son la dirección MAC real y la dirección MAC de respuesta.
Python3
# comparing values of real MAC Address and response MAC Address
if originalmac != responsemac:
print("[*] ALERT!!! You are under attack, ARP table is being poisoned.!")
A continuación se muestra el código completo
Python3
# Implementing ARP Spoof Attack Detection Using Scapy
# import modules
import scapy.all as scapy
# code to get MAC Address
def mac(ipadd):
# requesting arp packets from the IP address
# if it's wrong then will throw error
arp_request = scapy.ARP(pdst=ipadd)
br = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
arp_req_br = br / arp_request
list_1 = scapy.srp(arp_req_br, timeout=5,
verbose=False)[0]
return list_1[0][1].hwsrc
# taking interface of the system as an argument
# to sniff packets inside the network
def sniff(interface):
# store=False tells sniff() function
# to discard sniffed packets
scapy.sniff(iface=interface, store=False,
prn=process_sniffed_packet)
# defining function to process sniffed packet
def process_sniffed_packet(packet):
# if it is an ARP packet and if it is an ARP Response
if packet.haslayer(scapy.ARP) and packet[scapy.ARP].op == 2:
# originalmac will get old MAC whereas
originalmac = mac(packet[scapy.ARP].psrc)
# responsemac will get response of the MAC
responsemac = packet[scapy.ARP].hwsrc
# machine interface is "eth0", sniffing the interface
sniff("eth0")
Producción: