Détecter un ARP Spoofing avec Python — du lab à l'alerte

Le problème

Sur un réseau local, tout le monde se fait confiance. Trop confiance.

Quand ton PC veut parler à la passerelle (le routeur), il envoie une question ARP :

"Hé, qui a l'IP 192.168.244.2 ?"

Et la première machine qui répond "C'est moi !" est crue sur parole.

Il n'y a aucune authentification.

Un attaquant peut donc répondre à la place du routeur, en disant "La passerelle, c'est MA MAC". À partir de ce moment-là, tout le trafic de la victime passe par l'attaquant.

C'est l'ARP Spoofing, et c'est la base du Man-in-the-Middle sur réseau local.

Ce qu'on va faire

Je vais te montrer comment j'ai codé un détecteur en Python avec Scapy, puis comment je l'ai testé contre une vraie attaque dans mon lab VirtualBox (Kali + Ubuntu).

À la fin, tu sauras :

• Reconnaître la signature d'une attaque ARP Spoofing
• Détecter un changement de MAC suspect
• Prioriser une alerte selon le contexte (passerelle ou pas)
• Identifier la cible visée

Le lab

• Kali Linux — détecteur (poste qui surveille)
• Ubuntu Server — attaquant (celui qui lance arpspoof)
• Réseau Host-Only VirtualBox — isolé d'Internet

Comment fonctionne l'attaque

arpspoof (inclus dans Kali via dsniff) envoie en boucle :

"192.168.244.2 (la passerelle) est à [MAC de l'attaquant]"

À la victime. Elle en déduit que la passerelle est l'attaquant. Tout son trafic part vers lui.

Comment détecter

La signature est simple : une IP change de MAC.

Une IP ne devrait jamais changer de MAC dans un réseau normal. Si ça arrive, c'est soit :

• Un remplacement matériel légitime (rare)
• Une attaque ARP Spoofing (probable)

Le détecteur garde une table ARP légitime et alerte dès qu'un changement est détecté.

Le code

J'ai ajouté un module arp_detector.py à mon projet Network Packet Analyzer.

Structure générale

class ARPSpoofDetector:
    def __init__(self, interface=None):
        self.interface = interface
        self.arp_table = {}          # {ip: mac} — table légitime
        self.changes = defaultdict(list)
        self.alerts = []
 
    def analyze_packet(self, packet):
        if not packet.haslayer(ARP):
            return
        arp = packet[ARP]
        if arp.op == 2:  # Réponse ARP uniquement
            self._check_arp_reply(arp.psrc, arp.hwsrc, arp.pdst)

Le cœur : détecter un changement de MAC

def _check_arp_reply(self, ip, mac, target_ip):
    mac = mac.lower()
 
    # Première fois qu'on voit cette IP → on enregistre
    if ip not in self.arp_table:
        self.arp_table[ip] = mac
        return
 
    # Même MAC → RAS
    if self.arp_table[ip] == mac:
        return
 
    # Changement de MAC → SUSPECT
    old_mac = self.arp_table[ip]
    severity = "🚨 CRITIQUE" if self._is_gateway(ip) else "⚠️  ÉLEVÉ"
 
    alert = (
        f"{severity} - ARP SPOOFING potentiel : "
        f"l'IP {ip} a changé de MAC ({old_mac} → {mac})"
    )
    self.alerts.append(alert)
    print_colored(alert, "red")
 
    # Met à jour la table
    self.arp_table[ip] = mac

Trois lignes suffisent pour détecter l'attaque :

1. Si l'IP est inconnue → on mémorise sa MAC
2. Si la MAC est la même → RAS
3. Si la MAC a changé → alerte

Détection intelligente de la passerelle

Pour graduer la sévérité, il faut savoir si l'IP usurpée est la passerelle.

J'utilise ip route pour la trouver :

def _is_gateway(self, ip):
    import subprocess
    try:
        result = subprocess.run(
            ["ip", "route", "show", "default"],
            capture_output=True, text=True, timeout=2,
        )
        if "default via" in result.stdout:
            gateway_ip = result.stdout.split("via")[1].strip().split()[0]
            return ip == gateway_ip
    except Exception:
        pass
    return ip.endswith(".1") or ip.endswith(".254")

Pourquoi c'est important : si l'attaquant usurpe l'identité de la passerelle, tout le trafic de la victime est intercepté. C'est critique.

Si l'attaquant usurpe une machine standard, c'est élevé mais moins grave.

Le test dans le lab

Étape 1 : Lancer le détecteur sur Kali

sudo python main.py --arp --interface eth1

🎯 Surveillance ARP sur l'interface eth1...
⏱️  Durée : 30s (Ctrl+C pour arrêter)

Étape 2 : Lancer l'attaque depuis Ubuntu

Dans le terminal Ubuntu, je lance l'attaque :

sudo sysctl -w net.ipv4.ip_forward=1
sudo arpspoof -i ens33 -t 192.168.244.131 192.168.244.2

Décodage :

• -i ens33 → interface Ubuntu (Host-Only)
• -t 192.168.244.131 → cible = Kali
• 192.168.244.2 → IP usurpée = la passerelle

Étape 3 : Observer l'alerte sur Kali

Dans le terminal Kali, quelques secondes après le lancement de l'attaque :

🚨 CRITIQUE - ARP SPOOFING potentiel : l'IP 192.168.244.2 a changé de MAC
   (00:50:56:ed:cd:e9 → 00:0c:29:0a:94:2a)
   La cible 192.168.244.131 est visée. Possible Man-in-the-Middle.

Décodage :

• IP usurpée : 192.168.244.2 (la passerelle)
• Ancienne MAC : 00:50:56:ed:cd:e9 (vraie passerelle VirtualBox)
• Nouvelle MAC : 00:0c:29:0a:94:2a (Kali, qui usurpe)
• Cible visée : 192.168.244.131 (Kali, qui est ciblé)
• Sévérité : CRITIQUE (car c'est la passerelle)

Étape 4 : Détecter un ARP Spoofing sur sa propre machine

Le scénario précédent nécessite deux VMs. Mais dans la vraie vie, un poste de travail peut aussi détecter qu'il est lui-même ciblé — sans infrastructure dédiée.

Voici la preuve : sur la même machine Kali, je lance en parallèle le détecteur ET l'attaque.

À gauche, le détecteur qui tourne. À droite, arpspoof qui envoie de fausses réponses ARP sur le réseau. Quelques secondes plus tard, l'alerte tombe sur la machine qui subit l'attaque :

🚨 CRITIQUE - ARP SPOOFING potentiel : l'IP 192.168.244.2 a changé de MAC
   (00:50:56:ed:cd:e9 → 00:0c:29:0a:94:2a)
   La cible 192.168.244.131 est visée. Possible Man-in-the-Middle.
 
============================================================
📊 RAPPORT ARP SPOOFING
============================================================
 
📦 Paquets ARP analysés : 19
   Requêtes : 2
   Réponses : 17
 
📋 Taille table ARP : 2 entrées
 
⚠️  1 changements suspects détectés
  • 🚨 CRITIQUE - ARP SPOOFING potentiel : l'IP 192.168.244.2 a changé de MAC
 
============================================================
✅ Exporté vers arp_report.json

Décodage :

• arpspoof envoie des réponses ARP en broadcast sur le réseau
• Kali les reçoit (même s'il n'est pas la cible directe)
• Le détecteur voit le changement de MAC et alerte immédiatement

Ce que ça démontre : un simple poste de travail peut détecter une attaque MITM en cours sans infrastructure centralisée (pas besoin d'un IDS/IPS réseau dédié). C'est exactement le principe d'un HIDS (Host-based IDS).

Ce que ça démontre en SOC

Cette petite détection, c'est exactement ce que fait un IDS en production.

C'est ce qui te différencie d'un candidat qui a juste "lu la doc OWASP".

Les limites du détecteur

• Passif : il alerte mais ne bloque pas. Pour bloquer, il faudrait un module actif (envoyer des ARP correctifs, ce qui est une autre histoire).
• Local : il ne voit que le trafic qui arrive à sa machine. Pour surveiller tout un réseau, il faudrait un switch avec port mirroring ou un IDS dédié (Suricata, Zeek).
• Faux positifs : un vrai changement matériel (nouvelle carte réseau) déclenchera une alerte. C'est rare mais possible.

Pour aller plus loin

• Network Packet Analyzer — mini-IDS Python
• Détecteur ARP Spoofing — page projet
• Mettre en place un lab réseau isolé avec VirtualBox
• Analyser un scan Nmap avec Wireshark