Comment apprendre le reverse engineering - Roadmap complète 2026

Apprendre le reverse engineering en 2026 demande un parcours long et progressif : solides bases en C et en assembleur (x86/x64 puis ARM64), maîtrise d'un désassembleur-décompilateur moderne (Ghidra gratuit ou IDA Pro / Binary Ninja payants), pratique intensive sur des crackmes, puis spécialisation (analyse malware, reverse mobile, exploitation binaire, firmware). Ce guide propose une roadmap de 12 mois réaliste, les ressources qui valent le temps investi, les pièges classiques, et les signaux concrets qui indiquent qu'on progresse.

1. Pourquoi apprendre le reverse engineering en 2026

Le reverse engineering (RE) est la compétence qui permet de comprendre un programme sans avoir son code source. Historiquement cantonné au cracking et à l'analyse antivirus, il est aujourd'hui au cœur de plusieurs métiers recherchés :

• Malware analyst : comprendre loaders, infostealers, ransomware, spyware commerciaux (Pegasus, Predator).
• Threat intelligence : extraire IoCs, comprendre les capacités d'un APT, attribuer.
• Exploit developer : comprendre un binaire vulnérable pour écrire un exploit fiable.
• AppSec mobile : auditer une app Android/iOS sans sources, détecter jailbreak detection, SSL pinning.
• Firmware / IoT / embedded : auditer un binaire ARM ou MIPS extrait d'un firmware.
• Protection logicielle / DRM : côté défense, concevoir de l'anti-reverse.

La barrière d'entrée est réputée élevée - c'est exact. Mais c'est aussi ce qui fait la rareté et la valeur des profils compétents. Un reverser junior opérationnel est immédiatement recruté, surtout en France où les équipes CTI et CERT manquent.

2. Prérequis indispensables

Ne pas sauter cette étape. Les autodidactes qui échouent sautent presque tous les prérequis et se retrouvent bloqués dès le premier binaire non trivial.

2.1 Programmation en C

Le C est la lingua franca du reverse : la majorité des binaires que vous analyserez viennent de code C ou C++. Il faut comprendre :

• Pointeurs, arithmétique de pointeurs, allocation dynamique (malloc, free).
• Pile (stack) vs tas (heap), conventions d'appel.
• Structures, unions, tableaux.
• Manipulation de bits, endianness.
• Comportements indéfinis (UB) fréquents.

Si vous ne savez pas écrire en C un programme qui alloue une structure, la remplit, la passe à une fonction par pointeur, et libère la mémoire : vous n'êtes pas prêt.

2.2 Assembleur x86 et x86-64

Vous ne coderez pas en assembleur au quotidien, mais vous lirez de l'assembleur tous les jours. Concepts à maîtriser :

• Registres (EAX/RAX, EBX/RBX, RSP, RBP, RIP, flags).
• Instructions essentielles : mov, lea, add, sub, xor, cmp, test, jmp, je/jne/jg/jl, call, ret, push, pop.
• Conventions d'appel : System V AMD64 (Linux/macOS : RDI, RSI, RDX, RCX, R8, R9) et Microsoft x64 (Windows : RCX, RDX, R8, R9).
• Prologue et épilogue de fonction, stack frame.
• Différence mov rax, [rbx] vs lea rax, [rbx].
• Lecture d'une boucle, d'un switch, d'un appel de méthode virtuelle.

2.3 Systèmes d'exploitation

• Windows : PE format, DLL, imports/exports, IAT/EAT, TLS callbacks, Import Address Table, SEH, API Win32 courantes (CreateFile, VirtualAlloc, LoadLibrary, GetProcAddress).
• Linux : ELF format, sections (.text, .data, .rodata, .bss, .plt, .got), dynamic linking, syscalls, libc.
• macOS : Mach-O format (plus rarement abordé, mais de plus en plus utile avec Apple Silicon).

2.4 Outils système

Lire un hexdump (xxd, hexdump -C), utiliser strings, file, objdump, readelf, nm, ldd, strace, ltrace, Sysinternals (Process Monitor, Process Explorer, PEView).

3. Étape 1 - Fondamentaux assembleur (mois 1-3)

Objectif : lire confortablement de l'assembleur x86-64, reconnaître les patterns compilés.

3.1 Livres de référence

• The Art of Assembly Language (Randall Hyde) - très complet pour x86, gratuit en ligne.
• Programming from the Ground Up (Jonathan Bartlett) - gratuit, excellent pour les débutants.
• Professional Assembly Language (Richard Blum) - approche pragmatique.

3.2 Méthode pratique

Écrire 20 petits programmes en C, les compiler en désactivant les optimisations (gcc -O0 -g), puis les compiler avec optimisations (gcc -O2), et comparer le code généré avec :

gcc -O0 -g -o sample sample.c
objdump -d -M intel sample | less
 
# Puis comparer avec :
gcc -O2 -o sample_opt sample.c
objdump -d -M intel sample_opt | less

C'est le meilleur moyen d'apprendre à reconnaître les patterns compilés : boucles vectorisées, inlining, dead code elimination, strength reduction, tail call optimization.

3.3 ARM64 (mois 2-3)

En 2026, ignorer ARM est une erreur : iOS, Android, Apple Silicon, firmwares IoT sont majoritairement ARM. Démarrer par :

• Registres X0-X30, SP, PC, NZCV flags.
• Instructions de base : mov, ldr, str, add, sub, b, bl, ret, cbz, cbnz.
• AAPCS64 calling convention (X0-X7 pour les arguments).
• Différences majeures avec x86 : load-store architecture, instructions de taille fixe (4 octets), pas d'instructions avec opérande mémoire implicite.

4. Étape 2 - Maîtriser un outil principal (mois 2-4)

Choisir un désassembleur-décompilateur et s'y tenir au début. Ne pas sauter entre les outils.

4.1 Options principales

4.2 Recommandation

Pour un débutant en 2026 : Ghidra comme désassembleur principal (gratuit, excellent décompilateur, multi-architectures) + x64dbg sous Windows et gdb/gef sous Linux pour le debug dynamique. Passer à IDA Pro ou Binary Ninja plus tard si votre employeur paie la licence ou si votre usage le justifie.

4.3 Apprendre l'outil à fond

• Parcourir la documentation officielle en entier.
• Maîtriser les raccourcis clavier (gain de temps énorme).
• Savoir annoter : renommer variables et fonctions, ajouter commentaires, définir structures.
• Scripter au moins 3 opérations répétitives dans le langage de scripting de l'outil.
• Installer 2-3 plugins communautaires majeurs et comprendre ce qu'ils font.

5. Étape 3 - Crackmes et CTF reverse (mois 3-6)

La pratique est irremplaçable. Un reverser qui n'a jamais résolu 50 crackmes n'est pas un reverser.

5.1 Plateformes de crackmes

• crackmes.one - des milliers de crackmes classés par difficulté et architecture.
• Root-Me - section cracking/reverse solide, français.
• OverTheWire Behemoth/Leviathan - exploitation et reverse entrelacés.
• pwn.college - cours complet ASU, dont reverse engineering.

5.2 CTF avec challenges reverse

• DEF CON CTF (très dur), Google CTF, Plaid CTF, HackTheBox CTF.
• FCSC (France Cybersecurity Challenge) - reverse de qualité, archives disponibles.
• picoCTF - excellent pour les débutants.

5.3 Méthode de résolution

Pour chaque crackme :

1. Recon statique : file, strings, hexdump, sections PE/ELF, imports suspects.
2. Exécution dynamique contrôlée (VM isolée si douteux) : observer comportement.
3. Désassemblage : charger dans Ghidra, identifier main ou WinMain.
4. Tracer les chemins importants : comparaisons de flag, appels crypto.
5. Debug dynamique : poser des breakpoints aux comparaisons, inspecter mémoire.
6. Annoter au fur et à mesure dans Ghidra.
7. Rédiger un writeup - même si personne ne le lira. La rédaction force la compréhension.

5.4 Objectif chiffré

Un débutant sérieux vise 50 crackmes niveau 1-3 sur crackmes.one en 3 mois. Après 50, la plupart des patterns classiques deviennent familiers : XOR simple, string compare trivial, serial key généré via une fonction de hachage maison, anti-debug basique (IsDebuggerPresent, NtQueryInformationProcess).

6. Étape 4 - Reverse de malware (mois 5-9)

Spécialisation la plus demandée du marché.

6.1 Environnement d'analyse

Règle absolue : ne jamais exécuter un malware sur une machine de travail. Monter un lab isolé :

• VM Windows 10/11 sans réseau interne, snapshot avant chaque exécution.
• Outils pré-installés : Ghidra, x64dbg, Process Monitor, Process Explorer, Wireshark, Fakenet-NG, FLOSS, PEStudio, DIE (Detect It Easy).
• Hôte Linux avec outils statiques : Ghidra, Radare2, YARA, pefile, capa.
• Réseau simulé : INetSim, Fakenet-NG, ou cuckoo sandbox.

Des distributions spécialisées existent : FLARE VM (Windows, Mandiant) et REMnux (Linux) - clés en main pour l'analyse.

6.2 Sandboxing

• Cuckoo Sandbox / CAPE : sandbox open source, self-hosted.
• ANY.RUN : sandbox interactive commerciale, freemium.
• Joe Sandbox, Hybrid Analysis, VirusTotal : commerciaux ou freemium.

6.3 Techniques à maîtriser

• Détection de packer : DIE, PEiD (déprécié), Exeinfo PE. Packers courants : UPX (trivial), Themida, VMProtect, ASPack.
• Unpacking manuel : dump mémoire (x64dbg + Scylla), fixer IAT, réparer sections.
• Anti-debug / anti-VM / anti-sandbox : IsDebuggerPresent, NtQueryInformationProcess(ProcessDebugPort), timing attacks, détection de VirtualBox/VMware via registres et instances WMI.
• Techniques d'injection : process hollowing, DLL injection, APC injection, atom bombing, process doppelgänging.
• Persistance : Run keys, services, tâches planifiées, WMI events, COM hijacking.
• C2 analysis : extraction de config, décodage TLS, domain generation algorithms (DGA).

6.4 Ressources d'apprentissage malware

• Practical Malware Analysis (Sikorski & Honig, No Starch Press) - la bible, encore pertinente après 15 ans.
• Practical Reverse Engineering (Dang, Gazet, Bachaalany) - approche Windows kernel.
• The Art of Memory Forensics (Ligh, Case, Levy, Walters) - Volatility.
• Malware Analysis Cookbook (Ligh et al.) - recettes pratiques.
• HuntressLabs, Malware Unicorn (Amanda Rousseau), SANS Internet Storm Center - ressources en ligne de qualité.

7. Étape 5 - Reverse mobile (mois 7-10)

En 2026, le reverse mobile est incontournable pour tout profil AppSec ou threat intel.

7.1 Android

• Format : APK (ZIP), classes.dex (bytecode Dalvik/ART), AndroidManifest.xml compilé, natives .so (ARM64 ou x86_64).
• Outils statiques : MobSF (all-in-one), jadx (décompilation DEX → Java lisible), apktool (smali/manifest), Ghidra (pour les .so ARM).
• Outils dynamiques : Frida (instrumentation runtime), Objection (framework basé Frida), Xposed / LSPosed (sur émulateur).
• Émulateurs : Android Studio Emulator (x86_64), Genymotion, Corellium (iOS et Android ARM, commercial).
• Contournements classiques : root detection, SSL pinning (Frida scripts disponibles), code obfuscation (ProGuard, R8, DexGuard).

7.2 iOS

• Format : IPA (ZIP), binaire Mach-O (chiffré par App Store via FairPlay DRM), Info.plist, frameworks.
• Outils : class-dump, Hopper, IDA Pro, Ghidra, Frida / Objection, Cycript (deprecated).
• Obstacles spécifiques : chiffrement FairPlay (nécessite un device jailbreaké pour dump décrypté), Pointer Authentication Codes (PAC) sur Apple Silicon, Swift name mangling.
• Jailbreak : checkra1n (A7-A11, exploit BootROM), palera1n (iOS 15+ sur vulnérables), unc0ver, Dopamine (iOS 15-16 arm64e). Disponibilité dépend de la version iOS.

7.3 Ressources mobile

• OWASP MSTG / MASVS - standard de test mobile sécurité, gratuit.
• OWASP MASTG (ex-MSTG) - chapitres dédiés Android et iOS.
• Frida CodeShare - scripts communautaires prêts à l'emploi.
• HackTricks Mobile - cheatsheets pratiques.

8. Outils complémentaires à connaître

9. Certifications recommandées

Le marché RE reconnaît peu de certifications formelles - l'expérience et le portfolio priment. Mais certaines structurent utilement l'apprentissage :

• GREM (GIAC Reverse Engineering Malware, SANS FOR610) - la certification reconnue pour malware analysis. Cher mais excellent cours.
• SANS FOR710 (Reverse Engineering Malware - Advanced Code Analysis) - suite de FOR610.
• eCRE (eLearnSecurity Certified Reverse Engineer) - certification plus abordable.
• OSED (Offensive Security Exploit Developer) - orienté exploitation binaire Windows, inclut du RE.
• CRTO-II et RED-GATE courses - red team avancé avec composante RE.

Pour les profils auto-formés sans budget cert, un blog technique public avec 10 writeups détaillés vaut plus qu'une certification.

10. Ressources communautaires

10.1 Blogs et équipes de recherche

• googleprojectzero.blogspot.com - recherches top-tier.
• Trail of Bits, Cisco Talos, Check Point Research, ESET Research - threat intel et RE.
• x64dbg.com/blog, binary.ninja/blog, hex-rays.com/blog.
• malwareunicorn.org (Amanda Rousseau) - workshops RE gratuits.
• hex-rays.com/training - trainings IDA.

10.2 Conférences

• REcon (Montréal) - conférence dédiée reverse engineering, la référence.
• Black Hat, DEF CON, Chaos Communication Congress (CCC), Offensive Con.
• SSTIC, NullCon, Hack.lu, HITB - régionales de qualité.

10.3 Communautés

• Discord ReverseEngineering, Binary Ninja, pwn.college.
• Subreddit r/ReverseEngineering (archives solides).
• Bluesky / X : @pnfsoftware, @maldr0id, @malwareunicorn, @_mattifestation, @gf_256, @halvarflake.

11. Roadmap 12 mois réaliste

Pour un ingénieur dédiant 8 à 10 heures par semaine :

La progression est exigeante. Les profils qui tiennent le rythme sont ceux qui rédigent régulièrement et partagent. Publier force à vérifier.

12. Pièges fréquents à éviter

12.1 Sauter l'assembleur

Tenter Ghidra sans connaître x86-64 revient à lire un roman dans une langue qu'on ne parle pas. Le décompilateur aide, mais il ment parfois, et le retour au désassemblage est régulier.

12.2 Collectionner les outils sans en maîtriser un seul

Utiliser Ghidra lundi, IDA mardi, Binary Ninja mercredi empêche d'atteindre la productivité. Choisir un outil principal, le maîtriser à fond, puis élargir.

12.3 Négliger la prise de notes

Un reverser sans système de notes (Obsidian, Joplin, wiki perso) perd 30 % de son temps à redécouvrir ce qu'il savait il y a trois mois.

12.4 Exécuter du malware sans précaution

Exécuter un échantillon sur son PC « pour voir » est la cause n°1 d'incident personnel chez les débutants. Toujours : VM isolée, snapshot, réseau contrôlé.

12.5 Ignorer les fondamentaux système

Ne pas savoir ce qu'est un IAT, un GOT, un relocation bloque l'analyse dès qu'on sort du cas trivial. Prendre le temps de lire la spec PE et la spec ELF - au moins une fois.

12.6 Se comparer aux top profils

Suivre sur Bluesky les chercheurs de Project Zero ou Trail of Bits peut être démoralisant. Ces profils ont 10-20 ans d'expérience. Mesurer sa progression par rapport à soi-même il y a 3 mois, pas par rapport à eux.

13. FAQ

13.1 Combien de temps pour devenir opérationnel en reverse ?

Pour un ingénieur avec bases C/assembleur : 12 à 18 mois à 8-10h/semaine pour être opérationnel sur du malware commun. 3 à 5 ans pour une spécialisation profonde (exploitation binaire, kernel, iOS, firmware). Les progrès sont visibles tous les 2-3 mois si la pratique est régulière.

13.2 Faut-il apprendre x86 ou ARM en premier ?

x86-64 en premier pour la couverture de ressources pédagogiques. Ajouter ARM64 dès le mois 2-3 pour ne pas prendre de retard sur mobile et Apple Silicon. Ignorer l'un des deux en 2026 limite fortement l'employabilité.

13.3 Ghidra est-il suffisant pour débuter ?

Oui, largement. Ghidra est maintenu par la NSA, open source, avec un décompilateur parmi les meilleurs gratuitement disponibles. La version 11+ rivalise sérieusement avec Hex-Rays sur de nombreux cas. Passer à IDA ou Binary Ninja se justifie surtout en contexte professionnel.

13.4 Peut-on vivre du reverse engineering en France ?

Oui. Malware analysts, threat intel, CERT, AppSec mobile, éditeurs antivirus, DGA/ANSSI, défense, équipes red team - la demande dépasse l'offre. Salaires de 45-55 k€ débutants, 70-100 k€ senior, davantage en freelance expérimenté.

13.5 Faut-il être bon en maths ?

Pour du RE standard, non - l'arithmétique et la logique booléenne suffisent. Pour la crypto appliquée, l'analyse symbolique, la cryptanalyse ou l'exploitation avancée, un niveau d'algèbre et de théorie des nombres solide devient utile.

13.6 Par où commencer concrètement cette semaine ?

Installer Ghidra, écrire un Hello World en C, le compiler avec gcc -O0, l'ouvrir dans Ghidra, identifier main, lire le désassemblage, puis cliquer sur « Decompile » et comparer. Répéter avec 10 programmes de difficulté croissante. Vous avez vos premières 5-10 heures d'apprentissage.

Le reverse engineering est l'un des domaines les plus techniques et les plus durables de la cybersécurité. Les fondamentaux (assembleur, formats exécutables, OS internals) sont stables sur 20-30 ans. Les outils évoluent mais les principes restent. C'est un investissement long, rarement rentable avant 12-18 mois, mais qui ouvre ensuite les portes des métiers les plus techniques et les mieux rémunérés de la cyber.