Skip to content
Reverse Engineering

> parcours

Apprendre l’analyse de malwares

Un parcours structuré, du fonctionnement d’un binaire jusqu’à l’analyse automatisée. Chaque leçon se termine par un lab sûr, sur des programmes que vous compilez vous-même.

Commencer le parcours →
0 / 56 terminées

  1. Module 01 · 4 leçons · ~120 min

    Fondations

    Pourquoi analyser des malwares, comment le faire en sécurité, et ce qu'est vraiment un binaire — du code source au processus.

    1. 1.1Qu’est-ce que l’analyse de malwares ?Pourquoi les défenseurs analysent des binaires malveillants, à quoi sert l’analyse et comment s’articulent triage, analyse statique et dynamique.
    2. 1.2Construire un laboratoire d’analyse sûrMettez en place des VM d’analyse Windows et Linux isolées, avec réseau simulé, snapshots et bonnes pratiques de manipulation, avant tout malware.
    3. 1.3Du code source au binaireSuivez un programme C à travers prétraitement, compilation, assemblage et édition de liens : ce que symboles, relocations et infos de débogage laissent.
    4. 1.4Comment un binaire est chargé et exécutéCe qui se passe entre le double-clic et main() : création du processus, mappage mémoire, loader, imports, ASLR, démarrage du CRT et callbacks TLS.

  2. Module 02 · 5 leçons · ~195 min

    Formats binaires

    Le format PE en profondeur — en-têtes, sections, imports, exports et ressources — et l'essentiel d'ELF pour les malwares Linux.

    1. 2.1En-têtes PE : en-tête DOS, en-tête NT et en-tête optionnelParcourez octet par octet les en-têtes de tout exécutable Windows : les champs fiables, ceux dont on doute et ceux que les malwares détournent.
    2. 2.2Sections PE et organisation mémoireComment la table des sections projette un PE en mémoire, comment convertir RVA et offsets de fichier, et quelles anomalies trahissent packers et loaders.
    3. 2.3Imports, exports et IATComment un PE déclare les fonctions d’API qu’il utilise et fournit, comment le chargeur remplit l’IAT, et comment les malwares vous cachent leurs imports.
    4. 2.4Ressources, overlays et autres cachettesOù un PE transporte des données hors de son code : arbre des ressources, infos de version, overlays, signatures Authenticode, répertoires .NET et TLS.
    5. 2.5ELF pour les analystes de malwaresL’essentiel d’ELF pour les malwares Linux : en-têtes, sections et segments, liens dynamiques, et pourquoi binaires strippés ou sans en-têtes tournent.

  3. Module 03 · 6 leçons · ~250 min

    Triage statique

    Répondre aux premières questions sur un échantillon en quelques minutes, sans l'exécuter — et en tirer des détections.

    1. 3.1Identifier et hacher les fichiersIdentifiez un fichier par ses magic bytes plutôt que par son nom, puis prenez son empreinte avec des hashs cryptographiques, d’imports, flous et Rich.
    2. 3.2Chaînes et chaînes obfusquéesExtrayez les chaînes ASCII et UTF-16, isolez les indicateurs du bruit du runtime, retrouvez les chaînes empilées, XOR et décodées avec FLOSS et CyberChef.
    3. 3.3Lire les capacités à partir des importsFaites d’une table des imports PE une hypothèse de capacités : regroupez les API par comportement, repérez les combinaisons suspectes, confirmez avec capa.
    4. 3.4Détecter les packers et l’entropieReconnaissez les exécutables packés ou chiffrés par l’entropie, les anomalies de sections, les imports et les signatures, en évitant les faux positifs.
    5. 3.5Écrire vos premières règles YARATransformez vos constats de triage en règles YARA : chaînes, motifs hex, modules pe et math, performances, tests sur goodware et sur variantes.
    6. 3.6Rédiger un rapport de triageFaites du triage statique un rapport exploitable : verdict et confiance, capacités rattachées à ATT&CK, IOC neutralisés, détections et étapes suivantes.

  4. Module 04 · 5 leçons · ~245 min

    Désassemblage & analyse de code

    Comment les désassembleurs retrouvent le code, lire la sortie du compilateur, et s'aider des flots de contrôle et de données.

    1. 4.1Désassemblage linéaire vs récursifComment un désassembleur repère le code, où balayage linéaire et descente récursive échouent chacun, et comment coder un désassembleur récursif.
    2. 4.2Fonctions et graphes de flot de contrôleDécouper le code en blocs de base, lire les formes de CFG des if, boucles et switch, trouver les fonctions x64 Windows et bâtir un CFG avec Capstone.
    3. 4.3Reconnaître les idiomes du compilateurRamener au C du code x86-64 optimisé : cadres, division par nombre magique, code sans branche, boucles, tables de sauts, structs et vtables.
    4. 4.4Les décompilateurs et leurs limitesComment un décompilateur tire du pseudo-C du code machine, où cette sortie vous induit en erreur, et comment la corriger par types, noms et signatures.
    5. 4.5Références croisées et flot de donnéesUtiliser les références croisées pour passer des chaînes et imports au code qui s’en sert, remonter les valeurs et restaurer les xrefs perdues.

  5. Module 05 · 5 leçons · ~200 min

    Windows pour analystes

    Les notions Windows sur lesquelles s'appuient les malwares — API et API native, processus, threads, DLL, mutex, services, registre et frontière user/kernel.

    1. 5.1The Windows API for AnalystsRead the Win32 API the way a malware author uses it — layers, naming conventions, handles and the calling convention — to predict capability from imports alone.
    2. 5.2Processus, threads et DLLProcessus, threads et DLL vus par un observateur — PEB, TEB, jetons, handles, arbres de processus et modules — et comment les lire comme des preuves.
    3. 5.3Le registre, les services et les tâches planifiéesLire registre, services et tâches planifiées Windows en triage et réponse à incident, en direct ou hors ligne, et auditer les entrées de démarrage.
    4. 5.4Mutex, événements et communication inter-processusMutex, événements, sections et pipes nommés comme preuves sur l’hôte : où ils vivent, comment les observer, les extraire et en tirer des détections.
    5. 5.5User Mode, Kernel Mode and the Native APIThe ring boundary, ntdll's syscall stubs and WOW64 translation — why malware that talks to the native API bypasses user-mode hooks, and where EDR telemetry now watches instead.

  6. Module 06 · 5 leçons · ~220 min

    Analyse dynamique

    Exécuter les échantillons sous observation — surveillance comportementale, simulation réseau, débogage, traçage d'API et dump mémoire.

    1. 6.1Surveillance comportementaleExécutez un échantillon selon une routine reproductible avec Process Monitor, Sysmon, diffs de registre et Autoruns, puis tirez-en des IOC hôte.
    2. 6.2Simuler et capturer le trafic réseauGardez le trafic d’un échantillon dans le labo avec INetSim et FakeNet-NG, capturez-le et lisez DNS, HTTP, beacons et empreintes TLS comme IOC réseau.
    3. 6.3Déboguer un malware avec x64dbgComment un débogueur arrête un processus, comment piloter x64dbg et la boucle d’analyse : point d’arrêt sur une API, arguments, branche inversée.
    4. 6.4Tracer les appels d’API et les appels systèmeEnregistrez les appels d’API et système d’un échantillon au lieu de les suivre pas à pas, réduisez le bruit, lisez la trace et sachez où elle est aveugle.
    5. 6.5Dumper la mémoire et extraire les charges utilesCapturez la mémoire d’un processus ou du système, trouvez la région de la vraie charge utile et refaites d’un PE mappé en mémoire un fichier exploitable.

  7. Module 07 · 6 leçons · ~280 min

    Comportements malveillants

    Ce que font réellement les malwares et comment chaque comportement apparaît dans le code et la télémétrie — persistance, C2, vol d'identifiants, injection et furtivité.

    1. 7.1Loaders, Droppers and DownloadersHow malware actually arrives and starts running — living-off-the-land delivery, embedded payloads and in-memory loaders — and how to detect each from telemetry.
    2. 7.2Mécanismes de persistanceReconnaître la persistance dans un échantillon, la détecter dans Sysmon et les journaux Windows, et supprimer chaque point d’ancrage dans le bon ordre.
    3. 7.3Commande et contrôleRepérer le C2 dans les journaux réseau (rythme des beacons, anomalies DNS, pivots TLS), l’extraire des échantillons et le contenir sans perdre de preuves.
    4. 7.4Vol d’identifiants et keyloggingReconnaître infostealers, accès à LSASS et keyloggers dans les échantillons et la télémétrie, vérifier les contrôles et cerner les comptes exposés.
    5. 7.5Understanding Process InjectionThe process injection families, the memory and telemetry artefacts each one leaves, and how cross-view tools like pe-sieve and Volatility prove one occurred.
    6. 7.6Hooking et rootkits en mode utilisateurRepérer les hooks inline, IAT et EAT en comparant mémoire et disque, distinguer produits de sécurité et rootkits, prouver la dissimulation par vue croisée.

  8. Module 08 · 5 leçons · ~255 min

    Encodage, crypto & signatures

    Reconnaître encodages et cryptographie, extraire les configurations, et transformer ce que vous décodez en signatures réseau et hôte.

    1. 8.1Reconnaître XOR, Base64 et les encodages personnalisésRepérez XOR, clés roulantes et Base64 personnalisé dans les données et le code, retrouvez les clés par longueur de clé et texte clair connu, puis décodez.
    2. 8.2Identifier les algorithmes cryptographiquesDistinguez chiffrement et encodage, identifiez AES, RC4, ChaCha20, TEA, hashs et CRC32 par constantes, boucles et imports, puis trouvez la clé et l’IV.
    3. 8.3Scripter le déchiffrement des chaînesRetrouvez des centaines de chaînes chiffrées d’un coup : trouvez la routine, récupérez statiquement les arguments de chaque appel et scriptez l’algorithme.
    4. 8.4Extraire les configurations de malwaresTransformez la configuration embarquée d’un échantillon en JSON normalisé via un extracteur localiser-décoder-analyser-restituer, et partagez-la avec soin.
    5. 8.5Écrire des signatures réseauTransformez le code réseau d’un échantillon et le trafic capturé en règles Suricata visant la structure durable du protocole, puis testez-les sur des pcap.

  9. Module 09 · 6 leçons · ~285 min

    Évasion & unpacking

    Déjouer les pièges qui font perdre du temps aux analystes — anti-désassemblage, anti-débogage, détection de sandbox et packing — par patching, hooking et unpacking.

    1. 9.1Anti-désassemblageRepérer les astuces qui trompent le désassembleur — sauts à condition fixe, instructions chevauchantes, octets parasites — puis réparer le listing.
    2. 9.2Anti-DebuggingThe families of debugger detection — API calls, PEB and heap flags, timing and hardware checks — how to spot each in a sample and get past it.
    3. 9.3Anti-VM and Sandbox EvasionThe families of virtualisation and sandbox detection — CPUID, registry artefacts, resource fingerprints and behavioural signals — how to spot each in a sample and get past it.
    4. 9.4Patcher un binaire pour contourner les vérificationsPatcher pour analyser : inverser un saut, neutraliser une vérification par des NOP ou forcer un retour pour qu’un échantillon révèle ce qu’il cache.
    5. 9.5Comment fonctionnent les packersCe que fait pas à pas le stub d’un packer — décompresser, reconstruire les imports, reloger, sauter à l’OEP — et ce que cela implique pour l’unpacking.
    6. 9.6Manual Unpacking to the OEPFind the OEP with breakpoint tricks, dump the process, and rebuild a destroyed or hashed IAT into a binary that loads and runs like the original.

  10. Module 10 · 4 leçons · ~180 min

    Au-delà de l'EXE

    Les malwares qui ne sont pas des exécutables natifs — shellcode, assemblies .NET, scripts et documents malveillants — et les outils adaptés.

    1. 10.1Analyse de shellcodeReconnaître un shellcode brut sans en-têtes, suivre ses idiomes get-PC et de résolution d’API, puis le désassembler, l’émuler et en extraire les IOC.
    2. 10.2Analyser un malware .NETReconnaître un assembly .NET, lire ses métadonnées et son IL, choisir le bon décompilateur et venir à bout des obfuscateurs et des étapes en mémoire.
    3. 10.3Malwares PowerShell, JavaScript et VBScriptDésobfusquer PowerShell, JavaScript et VBScript malveillants sans les lancer : neutraliser eval, décoder les couches, lire les journaux, extraire les IOC.
    4. 10.4Documents et archives malveillantsTrier fichiers Office, RTF, PDF, archives, images disque et raccourcis LNK malveillants sans les ouvrir, et en extraire l’étape suivante et ses IOC.

  11. Module 11 · 5 leçons · ~255 min

    Analyse automatisée & avancée

    Laisser les outils travailler — instrumentation, émulation, analyse de teinte, exécution symbolique et chaînes d'analyse.

    1. 11.1Instrumentation binaire dynamiqueComment Pin, DynamoRIO, Frida et TinyInst injectent du code d’analyse dans un échantillon pour tracer ses API, mesurer la couverture et voir l’unpacking.
    2. 11.2Émuler du code avec Unicorn et speakeasyPourquoi émuler plutôt qu’exécuter, émulateurs CPU ou de niveau OS, et comment appeler la routine de déchiffrement d’un échantillon avec des API simulées.
    3. 11.3Analyse de teinte dynamiqueComment le suivi de teinte suit les données des sources aux puits, quels choix causent sur- et sous-teinte, et comment l’employer face aux malwares.
    4. 11.4Symbolic Execution with angrHow symbolic execution explores every path through a routine at once with an SMT solver, why that alone does not scale, and how angr finds the input that satisfies a specific check.
    5. 11.5Construire un pipeline d’analyseTransformez le triage manuel en pipeline reproductible : déduplication, routage par type, enrichissement statique, score, isolation et rapports traçables.