Rétro-ingénierie logicielle & matérielle

Débuter en reverse engineering

Comprendre comment fonctionne un programme ou un appareil sans son code source : c'est tout le sens du reverse engineering. Ce guide pose les bases côté logiciel (assembleur, formats de binaires, désassembleurs) puis vous emmène jusqu'au matériel — démontage, extraction de firmware et analyse des circuits.

AssembleurStatique / DynamiqueGhidraradare2FirmwareCrackmes

Notions fondamentales

Le reverse engineering consiste à repartir d'un produit fini — un exécutable, un firmware, un circuit — pour reconstruire sa logique et son fonctionnement. Avant d'ouvrir le moindre outil, quelques repères s'imposent.

Analyse statique vs dynamique

Deux approches complémentaires, que l'on combine presque toujours au cours d'une même étude.

🧊Analyse statique

On examine le binaire sans l'exécuter : désassemblage, décompilation, lecture des chaînes de caractères et des imports. Sûre et exhaustive, mais elle bute sur le code chiffré, empaqueté (packé) ou généré à la volée.

🔥Analyse dynamique

On exécute le programme sous débogueur ou instrumentation pour observer son comportement réel : valeurs des registres, mémoire, appels système. Idéale contre l'obfuscation, mais elle ne montre que les chemins réellement parcourus.

Un minimum d'assembleur

Un désassembleur traduit le code machine en assembleur : c'est la langue dans laquelle vous lirez la plupart des programmes. Pas besoin d'être expert pour démarrer, mais quelques fondamentaux sont incontournables.

Registres

Les « variables » du processeur : rax, rbx, rsp (pile), rip (instruction courante) en x86-64 ; r0r15 en ARM.

Instructions clés

mov, push/pop, call/ret, cmp suivi d'un saut conditionnel (je, jne, jz…).

Pile & appels

Arguments, adresse de retour et variables locales transitent par la pile. Comprendre une calling convention aide à suivre les fonctions.

Architectures

x86 / x86-64 sur PC, ARM et MIPS sur l'embarqué et le mobile, AVR sur les microcontrôleurs. Le jeu d'instructions dépend de la cible.

Conseil : commencez sur l'architecture de votre propre machine (souvent x86-64) : vous pourrez compiler, exécuter et déboguer sans émulateur.

Formats de binaires : PE & ELF

Un exécutable n'est pas qu'un bloc de code : c'est un fichier structuré qui indique au système comment le charger en mémoire. Reconnaître son format et sa structure oriente toute l'analyse.

PE — Portable Executable

Le format des .exe et .dll sous Windows.

  • En-tête MZ/DOS suivi de l'en-tête PE.
  • Sections .text (code), .data, .rsrc.
  • Table d'imports (IAT) : fonctions des DLL appelées.
ELF — Executable and Linkable Format

Le format des binaires Linux et de nombreux systèmes embarqués.

  • En-tête ELF décrivant l'architecture et le point d'entrée.
  • Sections .text, .data, .symtab.
  • Table des symboles et bibliothèques dynamiques liées.

Premiers réflexes en ligne de commande

Avant tout désassembleur, quelques commandes livrent déjà beaucoup d'informations sur un fichier inconnu.

file ./binaire

Identifie le format (PE, ELF), l'architecture et le mode 32/64 bits.

strings -n 6 ./binaire

Extrait les chaînes lisibles : messages, chemins, clés, indices de logique.

readelf -h ./binaire

Affiche l'en-tête ELF : architecture, type et adresse du point d'entrée.

objdump -d ./binaire

Désassemble le code machine section par section, sans interface graphique.

nm ./binaire

Liste les symboles (fonctions, variables) quand le binaire n'est pas strippé.

binwalk firmware.bin

Repère systèmes de fichiers, en-têtes et données compressées dans un firmware.

Outillage logiciel

Le cœur du reverse logiciel repose sur deux familles d'outils : les désassembleurs/décompilateurs pour l'analyse statique, et les débogueurs pour l'analyse dynamique. Voici la panoplie de référence pour débuter.

Désassembleurs & décompilateurs

🐉Ghidra

Suite gratuite et open source développée par la NSA. Excellent décompilateur, support de très nombreuses architectures, interface graphique complète. Le meilleur point d'entrée pour débuter sans budget.

⚙️radare2 / rizin

Framework en ligne de commande, léger et scriptable. rizin est un fork plus accessible, accompagné de l'interface graphique Cutter. Parfait pour l'embarqué et l'automatisation.

💠IDA

Le standard historique de l'industrie. IDA Free permet de démarrer ; les versions payantes offrent le décompilateur Hex-Rays et un support d'architectures inégalé.

🧠Binary Ninja

Désassembleur moderne, ergonomique et abordable, doté d'une API Python soignée et de représentations intermédiaires puissantes pour l'analyse automatisée.

Débogueurs & instrumentation dynamique

🐧gdb

Le débogueur de référence sous Linux. Combiné à l'extension GEF ou pwndbg, il devient redoutable pour le reverse et l'exploitation.

🪟x64dbg

Débogueur libre pour Windows (32/64 bits), avec une interface claire idéale pour suivre un exécutable pas à pas et casser l'obfuscation.

😍Frida

Instrumentation dynamique multiplateforme : injection de JavaScript, hooking de fonctions et modification du comportement en temps réel. Idéal pour le mobile et le firmware.

Lancer ses outils

ghidraRun

Démarre Ghidra, puis crée un projet et importez-y votre binaire à analyser.

r2 -A ./binaire

Ouvre radare2 en lançant d'emblée l'analyse automatique (aaa).

rizin -A ./binaire

Même approche avec rizin ; ajoutez Cutter pour une vue graphique.

gdb ./binaire

Lance le débogueur ; posez un point d'arrêt avec break main puis run.

ltrace ./binaire

Trace les appels aux bibliothèques (utile pour repérer strcmp, memcmp…).

strace ./binaire

Trace les appels système : ouverture de fichiers, réseau, lectures/écritures.

Votre premier crackme

Un crackme est un petit programme conçu pour l'entraînement : il attend un mot de passe ou une clé, et votre mission est de comprendre sa logique de vérification. C'est le terrain de jeu idéal — et parfaitement légal — pour débuter.

  1. 1. Reconnaissance

    Exécutez le programme, observez son comportement, puis passez file et strings dessus pour repérer messages et indices.

  2. 2. Repérer la vérification

    Cherchez la comparaison décisive : une chaîne « Bravo / Mauvaise clé », un strcmp ou un cmp suivi d'un saut conditionnel.

  3. 3. Lire le désassemblage

    Dans Ghidra ou radare2, remontez de la comparaison vers le calcul qui produit la clé attendue.

  4. 4. Confirmer au débogueur

    Posez un point d'arrêt sur la comparaison et inspectez les registres pour lire la valeur attendue en clair.

  5. 5. Comprendre l'algorithme

    L'objectif n'est pas seulement de « passer » mais de reconstituer la logique : transformation du serial, boucle de contrôle, condition de succès.

Bon départ : écrivez vous-même un mini-programme en C qui compare un mot de passe, compilez-le sans optimisation, puis reversez-le. Vous relierez ainsi code source et assembleur.

Chaîne d'analyse d'un binaire

Au-delà du crackme, une étude structurée suit toujours une progression logique. Cette chaîne d'analyse vous servira de méthode réutilisable, quel que soit le binaire.

  1. 1. Triage

    file, entropie, format (PE/ELF), architecture, présence d'un packer ou de chiffrement.

  2. 2. Collecte statique légère

    Chaînes de caractères, imports/exports, symboles restants, ressources embarquées.

  3. 3. Cartographie

    Chargement dans le désassembleur, identification du point d'entrée, des fonctions et du graphe d'appels.

  4. 4. Analyse ciblée

    On se concentre sur les fonctions d'intérêt : authentification, cryptographie, parsing d'entrées.

  5. 5. Validation dynamique

    Débogueur ou Frida pour confirmer les hypothèses et observer les valeurs réelles.

  6. 6. Synthèse

    Reconstitution de la logique, prise de notes, renommage des fonctions et documentation reproductible.

Reverse engineering hardware

Le reverse matériel prolonge la démarche logicielle : on part d'un appareil physique pour en comprendre l'électronique, puis extraire et analyser son firmware. La progression reste la même — observer, cartographier, puis creuser.

Choisir un premier appareil

Privilégiez une cible simple à démonter, aux composants faciles à identifier et souvent documentée.

📶Routeur bas de gamme

Architecture simple, souvent documentée par la communauté OpenWrt.

🎮Vieille console de jeu

Composants standard et communauté active de rétro-ingénierie.

🧸Jouet électronique

Circuits simples, parfaits pour un premier démontage sans enjeu.

📱Vieux Nokia 3310

Un classique du reverse, bien documenté et facile à trouver.

Conseil : commencez par un appareil que vous n'avez pas peur de casser.

Démonter avec précaution

  • Documentez chaque étape — une photo à chaque vis retirée.
  • Organisez les composants — des bacs séparés pour les vis et les pièces.
  • Repérez les composants clés : processeur principal (CPU/MCU), mémoire flash (stockage du firmware), RAM, connecteurs de debug.
⚠️ Attention : déchargez-vous de l'électricité statique avant de toucher les composants.

Identifier & rechercher les composants

Étape cruciale pour comprendre l'architecture de la cible.

  • Relevez les références — tous les numéros de modèle visibles sur les puces.
  • Recherchez les datasheets — par exemple ATmega328 datasheet PDF ou ESP32 pinout datasheet.
  • Identifiez l'architecture — ARM, MIPS, x86, AVR, etc.
  • Trouvez les spécifications — fréquence, mémoire, interfaces disponibles.
💡 Astuce : une loupe ou un microscope USB aide à lire les références des très petites puces.

Extraire & analyser le firmware

Deux grandes voies permettent de récupérer le firmware : dialoguer avec une interface de programmation, ou lire directement la puce de stockage.

🔍Méthode 1 — Interface de programmation

Recherchez les ports de debug sur la carte :

  • UART — souvent 3-4 pins : GND, VCC, TX, RX.
  • JTAG — debug avancé (5-20 pins).
  • SPI — série (MISO, MOSI, SCK, CS).
  • USB — parfois directement accessible.

Sondez les broches avec des câbles Dupont, passez par un convertisseur USB–TTL/UART (ou un Raspberry Pi Pico), puis connectez-vous avec un terminal série.

🔌Méthode 2 — Lecteur de puces

Si les puces sont amovibles ou si vous maîtrisez la soudure :

  • CH341A — bon marché, compatible SPI/I2C.
  • TL866II Plus — polyvalent, nombreux formats.
  • Bus Pirate — outil de debug universel.

Dé-soudez la puce (pompe à dessouder ou station à air chaud, sans abîmer les pistes), placez-la sur le lecteur, puis extrayez le contenu.

💡 Baudrates courants : 9600, 38400, 57600, 115200 bps.
⚠️ Risque : le dessoudage demande de la pratique et peut endommager l'appareil de façon irréversible.

Se connecter & extraire

minicom -D /dev/ttyUSB0 -b 115200

Ouvre une console série UART sous Linux à 115200 bauds.

screen /dev/ttyUSB0 115200

Alternative légère pour dialoguer avec le port série (Unix/macOS).

flashrom -p ch341a_spi -r dump.bin

Lit une puce flash SPI via un programmateur CH341A et sauvegarde le firmware.

binwalk -e firmware.bin

Analyse et extrait automatiquement les systèmes de fichiers du firmware.

Analyser le firmware extrait

Une fois le firmware récupéré, chargez-le dans un désassembleur — Ghidra, IDA ou rizin — puis suivez la chaîne d'analyse vue plus haut :

  1. Chargez le firmware en précisant l'architecture identifiée.
  2. Recherchez les strings — chaînes lisibles, chemins, indices.
  3. Identifiez les fonctions d'intérêt — authentification, cryptographie.
  4. Trouvez les points d'entréemain(), reset vector, interruptions.
  5. Décompilez progressivement les fonctions importantes.

Pour aller plus loin côté signaux, un analyseur logique (Saleae Logic, DSLogic, ou l'ensemble gratuit PulseView + sigrok) capture et décode les bus SPI, I2C ou UART en temps réel — voir analyser les bus de données.

😍 Bonus dynamique : Frida permet le hooking de fonctions et l'injection de code pour observer le firmware en cours d'exécution.

Chercher les vulnérabilités

Comprendre un binaire ou un firmware ouvre naturellement sur l'identification de faiblesses. Voici les points d'intérêt récurrents.

🔑 Secrets en clair

  • Mots de passe (password, admin, root).
  • Clés API codées en dur.
  • Certificats embarqués.

🐛 Fonctions de debug actives

  • Backdoors de développement.
  • Modes de diagnostic.
  • Shell root accessible.

📡 Interfaces non sécurisées

  • UART sans authentification.
  • Services réseau exposés.
  • API non protégées.

🔓 Faiblesses cryptographiques

  • Algorithmes obsolètes.
  • Clés faibles ou prévisibles.
  • Implémentations défaillantes.

Tester ses hypothèses

Modifier un firmware (ou patcher un binaire) permet de valider une faille de façon contrôlée : injection de payload de test, désactivation d'une vérification, modification d'un comportement, extraction de données. Après reflash via la même interface que pour l'extraction, on redémarre et on observe (logs UART, comportement, nouveaux vecteurs).

⚠️ Important : conservez toujours une sauvegarde du firmware original. En cas d'échec, on peut souvent restaurer l'appareil via ses interfaces de programmation.

Documenter sa démarche

Une documentation soignée est ce qui distingue une découverte reproductible d'un coup de chance. Notez au fil de l'eau.

Cible & composants

  • Modèle, version, numéros de série.
  • Photos haute résolution (externes et internes).
  • Références exactes des puces et liens vers les datasheets.
  • Architecture et spécifications.

Méthode & résultats

  • Interfaces utilisées (UART, JTAG, SPI…) et paramètres (baudrate, pinout).
  • Outils et logiciels employés.
  • Vulnérabilités, fonctions et secrets découverts.
  • Patches testés, résultats et proof of concepts.
🏆 Bonus : partagez vos découvertes avec la communauté via un blog, GitHub ou une conférence de sécurité — dans le respect de la responsible disclosure.

Ressources d'entraînement

Le reverse engineering s'apprend par la pratique régulière. Ces plateformes proposent des défis légaux, progressifs et corrigés pour affûter votre méthode.

🧩crackmes.one

Immense collection de crackmes classés par difficulté et par plateforme. Le terrain d'entraînement idéal pour le reverse logiciel, du niveau débutant aux protections avancées.

🚩Root-Me

Plateforme francophone de référence avec une catégorie « Cracking / Réversing » riche, des solutions détaillées et une communauté active.

🎓Compiler soi-même

Écrire, compiler puis reverser ses propres programmes reste le meilleur exercice pour relier code source, assembleur et binaire.

🔧Firmware réel

Un vieux routeur ou objet connecté et un lecteur CH341A suffisent pour passer à la pratique du reverse hardware sans risque.

🚀 Prochaines étapes :
  • Commencez par un crackme simple, puis un appareil facile à démonter.
  • Rejoignez des communautés de reverse engineering.
  • Documentez et partagez vos découvertes.
  • Continuez à apprendre et à expérimenter — toujours dans le cadre légal.