Détection et Blocage d'Intrusion ARP : Guide Complet
Ce guide vous fournira une approche détaillée pour simuler une attaque ARP
spoofing/poisoning, la détecter et la bloquer, en utilisant des outils comme GNS3,
Wireshark et Python.
1. Compréhension de l'Intrusion ARP
L'ARP (Address Resolution Protocol) est un protocole de couche 2 (liaison de
données) utilisé pour mapper des adresses IP (couche 3) à des adresses MAC (couche
2) sur un réseau local. Lorsqu'un hôte veut communiquer avec un autre hôte sur le
même segment de réseau dont il ne connaît que l'adresse IP, il envoie une requête
ARP pour obtenir l'adresse MAC correspondante.
L'ARP Spoofing (ou ARP Poisoning) est une technique d'attaque où un attaquant
envoie de fausses réponses ARP sur un réseau local. L'objectif est d'associer l'adresse
MAC de l'attaquant à l'adresse IP d'une passerelle (routeur) ou d'une autre machine sur
le réseau. Cela permet à l'attaquant de :
Intercepter le trafic : Le trafic destiné à la passerelle (ou à une autre victime)
passe par l'attaquant, qui peut le lire (Man-in-the-Middle).
Modifier le trafic : L'attaquant peut altérer les paquets avant de les retransmettre.
Déni de service : En associant une adresse IP à une adresse MAC inexistante,
l'attaquant peut empêcher la communication.
2. Conception et Configuration du Réseau dans GNS3
Nous allons créer un réseau simulant une entreprise avec des VLANs et un attaquant
externe.
Composants du réseau :
Routeur Wi-Fi (simulé par un routeur Cisco IOS ou un routeur VyOS/Linux) :
Agira comme passerelle par défaut et effectuera le routage inter-VLAN.
Switch Multicouche (simulé par un switch Cisco IOSvL2) : Gérera les VLANs et
la segmentation du réseau.
5 Machines Victimes (VMs Linux, par exemple des clients Ubuntu ou Alpine
Linux) : Réparties dans 2 VLANs.
o 3 VMs dans le VLAN 10 (e.g., Victime-1, Victime-2, Victime-3)
o 2 VMs dans le VLAN 20 (e.g., Victime-4, Victime-5)
PC Attaquant (VM Kali Linux) : Placé en dehors du réseau interne de l'entreprise
(simulant un attaquant sur un segment de réseau différent, mais pouvant
potentiellement atteindre les machines des victimes via des techniques
d'ingénierie sociale ou des vulnérabilités, ou simplement en étant sur le même
LAN dans un scénario plus simple, que nous simulerons pour l'attaque ARP).
Topologie GNS3 suggérée :
+-----------------+
| Routeur Wi-Fi |
| (Passerelle) |
| [Link] |
| [Link] |
+--------+--------+
|
| (Trunk, L3)
|
+--------+--------+
| Switch Multicouche |
| (VLAN 10 & 20) |
+-----------------+
/ | | | \
/ | | | \
/ | | | \
(Access VLAN 10) (Access VLAN 10) (Access VLAN 10) (Access VLAN 20) (Access
VLAN 20)
/ | | | \
/ | | | \
+----------+ +----------+ +----------+ +----------+ +----------+
| Victime-1| | Victime-2| | Victime-3| | Victime-4| | Victime-5|
| VLAN 10 | | VLAN 10 | | VLAN 10 | | VLAN 20 | | VLAN 20 |
+----------+ +----------+ +----------+ +----------+ +----------+
|
| (Liaison séparée, ou même segment pour la simulation ARP)
|
+-------------+
| PC Attaquant|
| (Kali Linux)|
+-------------+
Explication de la connectivité du PC Attaquant : Pour une attaque ARP spoofing,
l'attaquant doit généralement être sur le même segment de diffusion que les victimes. Si
le PC attaquant est "en dehors de l'entreprise" mais qu'il effectue une attaque ARP,
cela implique qu'il a déjà compromis un point d'accès interne ou qu'il a une connectivité
Layer 2. Pour la simulation, nous allons le connecter au même switch, mais sur un port
non-VLANisé ou dans un VLAN séparé non sécurisé, ou même directement sur un
segment commun pour simplifier l'attaque ARP. Nous allons le connecter au switch
dans un vlan séparé, le vlan 30 par exemple.
Configuration Pas à Pas dans GNS3 :
1. Ajouter les images IOS/VMs :
o Glissez-déposez un routeur (ex: IOSv) pour le Routeur Wi-Fi, un switch
(ex: IOSvL2) pour le Switch Multicouche.
o Importez vos VMs Linux (Kali, Ubuntu/Alpine) dans GNS3 (Préférences >
QEMU VMs).
2. Connexions :
o Connectez une interface du routeur au switch (ex: GigabitEthernet0/0 du
routeur à GigabitEthernet0/0 du switch). Ce sera un port trunk.
Connectez les 5 VMs victimes aux ports du switch (ex: GigabitEthernet0/1 à
o
0/5).
o Connectez le PC attaquant à un autre port du switch (ex:
GigabitEthernet0/6).
3. Configuration du Switch Multicouche :
4. enable
5. configure terminal
6. hostname SW1
7.
8. # Création des VLANs
9. vlan 10
10. name VICTIMES_RH
11. vlan 20
12. name VICTIMES_TECH
13. vlan 30
14. name ATTAQUANT_ZONE
15.
16. # Configuration des interfaces SVI (pour le routage inter-VLAN si le routeur ne le fait pas
entièrement)
17. # Dans notre cas, le routeur fera le routage inter-VLAN, donc pas de SVI ici, juste le port
trunk.
18. # Si le switch est le point de routage :
19. # interface Vlan10
20. # ip address [Link] [Link]
21. # no shutdown
22. # interface Vlan20
23. # ip address [Link] [Link]
24. # no shutdown
25.
26. # Configuration du port Trunk vers le Routeur
27. interface GigabitEthernet0/0
28. description Port_vers_Routeur
29. switchport mode trunk
30. switchport trunk encapsulation dot1q
31. no shutdown
32.
33. # Configuration des ports d'accès pour les machines victimes
34. interface GigabitEthernet0/1
35. description Victime-1_VLAN10
36. switchport mode access
37. switchport access vlan 10
38. no shutdown
39. interface GigabitEthernet0/2
40. description Victime-2_VLAN10
41. switchport mode access
42. switchport access vlan 10
43. no shutdown
44. interface GigabitEthernet0/3
45. description Victime-3_VLAN10
46. switchport mode access
47. switchport access vlan 10
48. no shutdown
49. interface GigabitEthernet0/4
50. description Victime-4_VLAN20
51. switchport mode access
52. switchport access vlan 20
53. no shutdown
54. interface GigabitEthernet0/5
55. description Victime-5_VLAN20
56. switchport mode access
57. switchport access vlan 20
58. no shutdown
59.
60. # Configuration du port pour le PC Attaquant
61. interface GigabitEthernet0/6
62. description PC_Attaquant_VLAN30
63. switchport mode access
64. switchport access vlan 30
65. no shutdown
66.
67. end
68. write memory
69. Configuration du Routeur Wi-Fi (Routeur Cisco IOS) :
70. enable
71. configure terminal
72. hostname R1
73.
74. # Configuration de l'interface physique connectée au switch
75. interface GigabitEthernet0/0
76. no ip address
77. no shutdown
78.
79. # Configuration des sub-interfaces pour le routage inter-VLAN (Router-on-a-Stick)
80. interface GigabitEthernet0/0.10
81. description Passerelle_VLAN10
82. encapsulation dot1Q 10
83. ip address [Link] [Link]
84. no shutdown
85. interface GigabitEthernet0/0.20
86. description Passerelle_VLAN20
87. encapsulation dot1Q 20
88. ip address [Link] [Link]
89. no shutdown
90. interface GigabitEthernet0/0.30
91. description Passerelle_VLAN30_Attaquant
92. encapsulation dot1Q 30
93. ip address [Link] [Link]
94. no shutdown
95.
96. # Si vous avez une interface externe (ex: pour simuler Internet)
97. # interface GigabitEthernet0/1
98. # ip address [Adresse IP externe] [Masque]
99. # no shutdown
100. # ip route [Link] [Link] [Prochaine saut]
101.
102. end
103. write memory
104. Configuration des adresses IP sur les VMs (Linux) :
o Victimes VLAN 10 :
Victime-1: IP [Link]/24, Passerelle [Link]
Victime-2: IP [Link]/24, Passerelle [Link]
Victime-3: IP [Link]/24, Passerelle [Link]
o Victimes VLAN 20 :
Victime-4: IP [Link]/24, Passerelle [Link]
Victime-5: IP [Link]/24, Passerelle [Link]
o PC Attaquant (Kali Linux) :
Attaquant: IP [Link]/24, Passerelle [Link]
Pour configurer les IPs sur Linux (par exemple, Ubuntu/Debian), vous pouvez
modifier /etc/netplan/*.yaml ou /etc/network/interfaces et appliquer les changements.
Pour Alpine Linux, utilisez setup-interfaces. Assurez-vous que le service réseau est
redémarré.
Exemple pour Ubuntu/Debian (fichier .yaml dans /etc/netplan/):
network:
version: 2
renderer: networkd
ethernets:
eth0: # Ou le nom de votre interface
dhcp4: no
addresses: [[Link]/24] # Adapter pour chaque VM
gateway4: [Link] # Adapter pour chaque VM
nameservers:
addresses: [[Link], [Link]]
Après modification, exécutez sudo netplan apply.
Validation du réseau :
Pinging des passerelles depuis les VMs victimes.
Pinging entre VMs du même VLAN.
Pinging entre VMs de VLANs différents (cela doit fonctionner via le routeur).
Pinging de la passerelle du VLAN 30 depuis le PC attaquant.
3. Scénario d'Attaque ARP Spoofing (avec Kali Linux)
Sur le PC attaquant (Kali Linux), nous utiliserons arpspoof de la suite dsniff. L'objectif est
de se faire passer pour la passerelle auprès d'une victime, et pour la victime auprès de
la passerelle.
1. Activer le forwarding IP sur l'attaquant : Pour que le trafic puisse continuer à
circuler et ne pas causer de déni de service pour la victime.
2. echo 1 > /proc/sys/net/ipv4/ip_forward
3. Lancer l'attaque ARP spoofing :
4. # Synthaxe : arpspoof -i <interface> -t <ip_victime> <ip_passerelle>
5. # Et inversement : arpspoof -i <interface> -t <ip_passerelle> <ip_victime>
6.
7. # Exemple pour attaquer Victime-1 ([Link]) et sa passerelle ([Link])
8. # Sur l'interface de l'attaquant (ex: eth0)
9.
10. # Dans un premier terminal :
11. arpspoof -i eth0 -t [Link] [Link]
12.
13. # Dans un deuxième terminal :
14. arpspoof -i eth0 -t [Link] [Link]
Ces deux commandes doivent être exécutées simultanément. Elles forcent les
deux parties à mettre à jour leurs tables ARP avec l'adresse MAC de l'attaquant
pour l'IP de l'autre.
4. Détection de l'Intrusion avec Wireshark et Python
a) Observation avec Wireshark :
Lancez Wireshark sur une des machines victimes (par exemple, Victime-1) et sur le
routeur (si possible, en capturant sur l'interface du trunk ou des sub-interfaces).
Sur la Victime : Vous devriez voir des réponses ARP multiples pour la même
adresse IP (celle de la passerelle) mais avec des adresses MAC différentes
(celle du routeur et celle de l'attaquant).
Sur l'attaquant : Wireshark montrera un flux constant de paquets ARP envoyés
par arpspoof.
Trafic intercepté : Après l'attaque, si la victime tente de communiquer avec
Internet, vous verrez le trafic passer par l'attaquant dans Wireshark sur le PC
attaquant.
b) Script Python pour la Détection (Pop-up de Signalement)
Ce script Python sera exécuté sur une des machines victimes (ou sur une machine de
monitoring dédiée au sein du réseau). Il écoutera les paquets ARP et signalera les
anomalies.
Prérequis :
Installez scapy et tkinter sur la machine qui exécutera le script (une VM victime).
sudo apt update
sudo apt install python3-pip python3-tk -y # python3-tk pour tkinter
pip install scapy
```python
# -*- coding: utf-8 -*-
import collections
from [Link] import sniff, ARP
import time
import threading
from tkinter import Tk, Label, Button, Toplevel, messagebox
# --- Configuration ---
# Dictionnaire pour stocker les mappages IP-MAC légitimes.
# Il est crucial d'initialiser cela avec les adresses MAC connues et légitimes
# des machines importantes (passerelle, serveurs critiques, autres victimes si vous les surveillez).
# Si un mappage est inconnu, le script apprendra le premier mappage vu et le considérera légitime.
# Il est recommandé de pré-remplir ce dictionnaire pour plus de sécurité.
# Format: {'IP_Adresse': 'MAC_Adresse'}
legitimate_arp_cache = {
"[Link]": "XX:XX:XX:XX:XX:XX", # Remplacer par l'adresse MAC réelle de la passerelle
VLAN 10
"[Link]": "YY:YY:YY:YY:YY:YY", # Remplacer par l'adresse MAC réelle de la passerelle
VLAN 20
# "[Link]": "[Link]", # Exemple pour Victime-1
# ... ajoutez d'autres IPs/MACs connues
}
# Interface réseau à surveiller (ex: 'eth0' dans GNS3)
INTERFACE_DE_SURVEILLANCE = "eth0"
# Seuil pour les réponses ARP multiples (nombre de réponses de MACs différentes pour la même
IP)
# Un faible seuil peut provoquer des faux positifs dans des réseaux très dynamiques.
ARP_REPONSE_SEUIL = 2
# Temps en secondes pour la fenêtre de détection des réponses ARP multiples
DETECTION_FENETRE_TEMPS = 5
# Cache temporaire pour les réponses ARP récentes : {IP: [(MAC, timestamp), ...]}
arp_responses_recent = [Link](list)
# Verrou pour protéger l'accès au cache ARP et au dictionnaire légitime
cache_lock = [Link]()
# Fenêtre principale Tkinter (cachée par défaut, utilisée pour afficher les pop-ups)
root = None
def init_tkinter():
"""Initialise la fenêtre Tkinter principale."""
global root
if root is None:
root = Tk()
[Link]() # Cache la fenêtre principale
print("Fenêtre Tkinter initialisée (cachée).")
def show_alert_popup(title, message):
"""Affiche une fenêtre pop-up d'alerte."""
# S'assure que Tkinter est initialisé
init_tkinter()
# Utilise Toplevel pour créer une nouvelle fenêtre pour l'alerte
alert_window = Toplevel(root)
alert_window.title(title)
alert_window.geometry("400x150")
alert_window.attributes('-topmost', True) # Garde la fenêtre au premier plan
label = Label(alert_window, text=message, wraplength=350, justify="left", padx=10, pady=10,
font=("Arial", 10))
[Link](expand=True)
def close_alert():
alert_window.destroy()
close_button = Button(alert_window, text="OK", command=close_alert)
close_button.pack(pady=5)
alert_window.protocol("WM_DELETE_WINDOW", close_alert) # Gère la fermeture par la croix
# Met à jour la fenêtre pour qu'elle s'affiche
root.update_idletasks()
alert_window.update()
def detect_arp_spoofing(packet):
"""
Fonction de callback appelée pour chaque paquet ARP sniffé.
Détecte les anomalies d'ARP spoofing.
"""
if [Link](ARP):
arp_layer = [Link](ARP)
# Vérifie si c'est une réponse ARP (opcode 2)
if arp_layer.op == 2: # ARP Reply (is-at)
sender_ip = arp_layer.psrc
sender_mac = arp_layer.hwsrc
current_time = [Link]()
with cache_lock:
# 1. Détection de changements d'adresse MAC pour une IP connue (usurpation)
if sender_ip in legitimate_arp_cache:
if legitimate_arp_cache[sender_ip].lower() != sender_mac.lower():
alert_message = (
f"ALERTE D'INTRUSION ARP !\n"
f"IP: {sender_ip} (Attendue: {legitimate_arp_cache[sender_ip]})\n"
f"MAC inattendue: {sender_mac}\n"
f"Une tentative d'usurpation d'ARP est suspectée pour cette IP."
)
print(alert_message)
show_alert_popup("INTRUSION ARP DÉTECTÉE !", alert_message)
return # Ne pas traiter ce paquet pour d'autres détections s'il est déjà flaggé
else:
# Si l'IP n'est pas dans le cache légitime, l'apprendre.
# Dans un environnement réel, cela doit être géré avec prudence (ex: DHCP)
legitimate_arp_cache[sender_ip] = sender_mac
print(f"Apprentissage ARP légitime: {sender_ip} -> {sender_mac}")
# 2. Détection de réponses ARP multiples pour la même IP depuis différentes MACs
# (Peut indiquer une course à l'usurpation)
arp_responses_recent[sender_ip].append((sender_mac, current_time))
# Nettoyer les anciennes entrées du cache temporaire
arp_responses_recent[sender_ip] = [
(mac, ts) for mac, ts in arp_responses_recent[sender_ip]
if current_time - ts < DETECTION_FENETRE_TEMPS
]
# Compter les MACs distinctes pour cette IP dans la fenêtre de temps
distinct_macs = set()
for mac, _ in arp_responses_recent[sender_ip]:
distinct_macs.add([Link]()) # Convertir en minuscule pour comparaison
if len(distinct_macs) >= ARP_REPONSE_SEUIL:
alert_message = (
f"ALERTE D'INTRUSION ARP (Multi-MAC) !\n"
f"IP: {sender_ip}\n"
f"MACs multiples détectées dans {DETECTION_FENETRE_TEMPS}s: {',
'.join(distinct_macs)}\n"
f"Ceci peut indiquer une attaque ARP Spoofing active."
)
print(alert_message)
show_alert_popup("INTRUSION ARP DÉTECTÉE !", alert_message)
# 3. Détection de requêtes ARP "gratuitous" (ARP probe/announcement)
# Un Gratuitous ARP est un paquet ARP où l'adresse IP source et destination sont les mêmes
(souvent l'IP de l'émetteur).
# Il est utilisé pour annoncer une adresse IP ou détecter des duplicatas.
# Un attaquant peut l'utiliser pour "empoisonner" les caches sans requête préalable.
if arp_layer.op == 1 and arp_layer.pdst == arp_layer.psrc: # ARP Request avec IP source = IP
destination
# Vérifier si l'adresse MAC source est légitime pour cette IP
sender_ip = arp_layer.psrc
sender_mac = arp_layer.hwsrc
with cache_lock:
if sender_ip in legitimate_arp_cache and legitimate_arp_cache[sender_ip].lower() !=
sender_mac.lower():
alert_message = (
f"ALERTE ARP GRATUITOUS SUSPECT !\n"
f"IP: {sender_ip} (Attendue: {legitimate_arp_cache[sender_ip]})\n"
f"MAC inattendue dans ARP gratuitous: {sender_mac}\n"
f"Une annonce ARP non autorisée est suspectée."
)
print(alert_message)
show_alert_popup("INTRUSION ARP DÉTECTÉE !", alert_message)
def start_sniffing():
"""Démarre le reniflage de paquets ARP en arrière-plan."""
print(f"Démarrage du reniflage ARP sur l'interface {INTERFACE_DE_SURVEILLANCE}...")
try:
# filter="arp" assure que seuls les paquets ARP sont capturés
sniff(iface=INTERFACE_DE_SURVEILLANCE, prn=detect_arp_spoofing, store=0, filter="arp")
except Exception as e:
print(f"Erreur lors du démarrage du reniflage : {e}")
[Link]("Erreur de Sniffing", f"Impossible de démarrer le reniflage sur
{INTERFACE_DE_SURVEILLANCE}.\nAssurez-vous d'avoir les permissions (root) et que l'interface
existe.\nErreur: {e}")
if __name__ == "__main__":
# La GUI Tkinter doit être lancée dans le thread principal
init_tkinter()
# Démarrer le reniflage dans un thread séparé pour ne pas bloquer l'interface graphique
sniff_thread = [Link](target=start_sniffing)
sniff_thread.daemon = True # Permet au thread de s'arrêter si le programme principal se termine
sniff_thread.start()
# Lancer la boucle principale de Tkinter.
# Cette ligne doit être la dernière car elle bloque l'exécution jusqu'à ce que la fenêtre soit fermée.
# Puisque la fenêtre principale est cachée, elle ne se fermera pas d'elle-même.
# Pour un environnement de monitoring, on peut la laisser tourner en arrière-plan.
# Si vous voulez un moyen de quitter proprement, ajoutez un bouton pour [Link]()
try:
[Link]()
except KeyboardInterrupt:
print("\nArrêt du programme par l'utilisateur.")
finally:
if root:
[Link]() # S'assure que Tkinter est bien fermé à la fin