PCTAMALOU 2026 – Semaine 40 : Les Runes du Binaire

🎯 Objectif de la semaine

Maîtriser les fondamentaux du reverse engineering avec Ghidra pour analyser un binaire simple, comprendre son flux d'exécution et extraire des secrets cachés. Ouvrir le dernier trimestre par la capacité à lire ce que le code source ne révèle pas – la compétence ultime pour analyser malwares, comprendre les vulnérabilités binaires et dévoiler les secrets des exécutables.

Pourquoi c'est essentiel : Dans un monde où 95% des logiciels malveillants sont livrés sous forme binaire, le reverse engineering est la compétence qui sépare le script kiddie du vrai analyste. C'est l'art de comprendre sans documentation, de voir sans code source.

🎗️ Clin d'œil Octobre Rose : Comme le dépistage, le reverse engineering consiste à observer les signaux faibles avant qu'ils ne deviennent critiques. Une chaîne suspecte, un saut conditionnel inattendu, un appel orphelin : ce sont les symptômes d'un binaire qui cache quelque chose. Apprendre à les repérer tôt, c'est la meilleure des préventions — numérique ou médicale.

flowchart TD B["📦 Binaire mystère"] --> G["🛠️ Ghidra"] G --> L["🔍 Chargement & Auto-analysis"] L --> S["📝 Strings analysis"] L --> F["🔄 Function discovery"] L --> C["🔗 Cross-references"] S --> STR["Strings trouvées:\n'Correct!'\n'Wrong password'"] F --> MAIN["Fonction main()"] C --> XREF["References croisées"] STR -->|XREF vers strings| COMP["Fonction de comparaison"] MAIN -->|Appelle| COMP COMP -->|Contient| CMP["strcmp() ou custom compare"] CMP -->|Compare avec| SECRET["Secret hardcodé:\n'pctamalou2026'"] SECRET -->|Extraction directe| PWD["🗝️ Mot de passe trouvé !"] COMP -->|Patch alternatif| PATCH["🔧 NOP le jump conditionnel\n(bypass check)"] style G fill:#2a0f1c,stroke:#ff5c94,stroke-width:4px,color:#fff style PWD fill:#2a0f1c,stroke:#ff8fb8,stroke-width:3px,color:#fff style COMP fill:#1c1019,stroke:#ffb3d1,stroke-width:3px,color:#fff style SECRET fill:#450a0a,stroke:#dc2626,stroke-width:3px,color:#fff

📚 Sujet – Théorie (1 heure)

Le Reverse Engineering : Lire dans les Pensées de la Machine

Le reverse engineering n'est pas du hacking – c'est de l'archéologie numérique. C'est reconstruire la pensée du programmeur à partir des artefacts qu'il a laissés dans le binaire.

🔍

Static Analysis

Analyse sans exécution

Désassemblage
Décompilation
Analyse strings

⚡

Dynamic Analysis

Analyse pendant exécution

Debugging
Hooking API
Tracing

🧩

Hybrid Analysis

Combinaison des deux

Static + Dynamic
Meilleure couverture
Plus complexe

🎯

Applications Réelles

Analyse malware
Vulnerability research
DRM bypass
Legacy code analysis

Ghidra : Le Scalpel de la NSA

Ghidra n'est pas juste un outil de reverse engineering – c'est une plateforme d'analyse complète développée par la NSA et open-sourcée en 2019.

// Interface Ghidra - Composants principaux

CodeBrowser : Fenêtre principale d'analyse
Listing : Vue assembleur + pseudo-C
Decompiler : Vue décompilée (pseudo-C)
Symbol Tree : Fonctions, labels, imports
Function Graph : Graphique de flux de contrôle
Data Type Manager : Gestion des types
Bookmarks : Marque-pages pour findings

Les Formats Binaires : Connaître Ton Ennemi

📁 ELF (Linux/Unix)

Executable and Linkable Format

.text : Code exécutable
.data : Données initialisées
.rodata : Données read-only
.bss : Données non-initialisées

🪟 PE (Windows)

Portable Executable

DOS Header (MZ)
PE Header
Sections : .text, .data, .rdata
Import/Export tables

🍎 Mach-O (macOS)

Mach Object

Header Mach-O
Load commands
Sections variées
Universal binaries

Le Processus Méthodologique

🔬 Workflow Standard d'Analyse

Reconnaissance : file, strings, ltrace, strace
Importer dans Ghidra : Auto-analysis complète
Identifier entry point : main(), _start, WinMain
Analyse strings : Messages d'erreur, secrets
Suivre les appels : XREF (cross-references)
Renommer et commenter : Donner du sens
Comprendre la logique : Conditions, boucles
Extraire le secret : Password, flag, clé

Assembleur x86-64 : Le Langage Basique

// Instructions courantes en reverse
mov rax, rbx // Déplacement
cmp rax, 0x42 // Comparaison
je label_success // Jump si égal
jne label_fail // Jump si non égal
call function_name // Appel fonction
ret // Retour fonction

// Registres importants
RAX : Accumulator (valeur retour)
RIP : Instruction Pointer
RSP : Stack Pointer
RBP : Base Pointer

Éthique et Légalité du Reverse

⚠️ Ce qui est légal vs illégal

✅ Légal (dans la plupart des juridictions) :

Crackmes (exercices éducatifs)
Logiciels open-source
Logiciels dont vous possédez une licence
Interopérabilité (DMCA exception)
Recherche sécurité (avec permission)

❌ Illégal (sans permission) :

Logiciels propriétaires avec protection DRM
Contournement mesures techniques
Analyse malware sur réseau non-isolé
Redistribution de code désassemblé

🔬 Mission pratique – Laboratoire (2 heures)

Architecture du Lab Reverse

flowchart LR K[Kali Linux
Ghidra 11.1] -->|Analyse| C[crackme01
ELF 64-bit] C -->|Exécution| R[Résultat] K -->|Debugging| G[GDB
GEF/PEDA] subgraph "📁 Structure du projet" DIR[reverse_lab/ ├── crackmes/ │ ├── crackme01 │ └── crackme02 ├── notes/ │ └── analysis.md ├── screenshots/ └── scripts/ └── extract_strings.py] end style K fill:#1c1019,stroke:#ff5c94,stroke-width:3px style C fill:#2a0f1c,stroke:#ff8fb8,stroke-width:2px

⚠️ Environnement Préparé

🐍 Outils complémentaires :

# Installation outils de base
sudo apt install gdb binutils file ltrace strace radare2 -y

# GEF (GDB Enhanced Features)
wget -q -O ~/.gdbinit-gef.py https://github.com/hugsy/gef/raw/master/gef.py
echo "source ~/.gdbinit-gef.py" >> ~/.gdbinit

# Outils d'analyse strings
sudo apt install strings hexdump xxd -y

Étapes Détaillées d'Analyse

Étape 1 : Préparation et Reconnaissance

# Création du workspace
mkdir -p ~/mon_lab/reverse_week40/{crackmes,notes,screenshots}
cd ~/mon_lab/reverse_week40

# Téléchargement du crackme (exemple réel)
wget https://github.com/0xMartin/Crackmes/raw/main/Linux/x64/crackme01 -O crackmes/crackme01
chmod +x crackmes/crackme01

# Analyse préliminaire
file crackmes/crackme01
# Résultat: ELF 64-bit LSB executable, x86-64, dynamically linked

strings crackmes/crackme01 | head -20
# Recherche de strings intéressantes

# Test d'exécution
./crackmes/crackme01
# Sortie attendue: demande un mot de passe

Étape 2 : Lancement et Configuration de Ghidra

🚀 Première exécution :

# Si Ghidra pas encore installé
wget https://github.com/NationalSecurityAgency/ghidra/releases/download/Ghidra_11.1.2_build/ghidra_11.1.2_PUBLIC_20240709.zip
unzip ghidra_*.zip
cd ghidra_11.1.2_PUBLIC
./ghidraRun

Création projet : File → New Project → Non-shared → Nom "PCTAMALOU_Reverse"
Import fichier : File → Import File → Sélectionnez crackme01
Auto-analysis : Cochez toutes les options (analysis)
CodeBrowser : Double-cliquez sur crackme01

Étape 3 : Navigation dans l'Interface

// Fenêtres à ouvrir (Window → ...)

✅ Listing : Vue assembleur principale
✅ Decompiler : Pseudo-C décompilé
✅ Symbol Tree : Fonctions/Imports/Exports
✅ Function Graph : Vue graphique fonctions
✅ Defined Strings : Toutes les strings
✅ Data Type Manager : Types définis

Étape 4 : Trouver la Fonction Main

🔍 Plusieurs méthodes :

Symbol Tree → Functions → recherchez "main"
Defined Strings → double-clic sur "Wrong password" → XREF
Entry Point (_start) → suivre les appels

// Exemple de pseudo-C décompilé (simplifié)
undefined8 main(void) {
  int iVar1;
  char user_input [32];
  
  printf("Enter password: ");
  fgets(user_input,0x20,stdin);
  
  iVar1 = strcmp(user_input,"secret123");
  
  if (iVar1 == 0) {
    puts("Correct! Access granted.");
  }
  else {
    puts("Wrong password. Try again.");
  }
  return 0;
}

Étape 5 : Techniques d'Analyse Avancée

🎯 Défi 1 : String Obfuscation

Certains crackmes masquent les strings. Cherchez :

XOR operations avec une clé
Strings construites caractère par caractère
Strings dans .rodata section
Utilisez Search → Memory → For Strings...

Étape 6 : Debugging avec GDB

# Lancement du debugger
gdb -q ./crackmes/crackme01

# Dans GDB:
(gdb) break main            # Point d'arrêt sur main
(gdb) run                  # Exécution
(gdb) info functions       # Liste fonctions
(gdb) disas main           # Désassembler main
(gdb) x/s 0x400800         # Examiner string à adresse
(gdb) continue             # Continuer exécution

# Avec GEF (plus puissant):
(gdb) gef config context.enable 1
(gdb) context

Étape 7 : Patching (Optionnel mais Instructif)

🔧 Pour patcher dans Ghidra :

Trouvez l'instruction de saut conditionnel (je, jne, jz)
Double-clic dans le Listing → édition hex
Remplacez par NOP (0x90) ou inversez la condition
File → Export → Programme → Format original

Exercice Pratique : Crackme Multi-niveaux

🎯 Défi Progressif

Téléchargez et résolvez ces crackmes dans l'ordre :

# Niveau 1 : Simple string compare
wget https://crackmes.one/static/crackme/5d8c5e5e33c5d40ad048c1b5.zip
unzip 5d8c5e5e33c5d40ad048c1b5.zip

# Niveau 2 : Math/calcul
wget https://crackmes.one/static/crackme/5d8c5e5e33c5d40ad048c1b6.zip

# Niveau 3 : XOR obfuscation
wget https://crackmes.one/static/crackme/5d8c5e5e33c5d40ad048c1b7.zip

Documentez chaque étape : Méthode utilisée, findings, solution.

Scripting avec Ghidra : Automatisation

🐍 Exemple de script Python pour Ghidra

# extract_strings.py - Script Ghidra Headless
from ghidra.app.decompiler import DecompInterface
from ghidra.util.task import ConsoleTaskMonitor

# Récupérer le programme actuel
program = getCurrentProgram()
listing = program.getListing()

# Parcourir toutes les strings définies
string_manager = program.getListing().getDefinedStrings()
while string_manager.hasNext():
    string = string_manager.next()
    address = string.getAddress()
    value = string.getValue()
    
    print(f"String à {address}: {value}")
    
    # Chercher les références
    refs = getReferencesTo(address)
    for ref in refs:
        print(f"  Référencé depuis: {ref.getFromAddress()}")

Exécution : ghidraRun script.py

📋 Objectif de la semaine – Checklist de validation

✅ Compétences techniques acquises

Analyse préliminaire avec file/strings
Navigation dans Ghidra (Listing, Decompiler)
Trouver main() via strings ou symbol tree
Suivre XREF (cross-references)
Extraire secret d'un crackme simple

🧠 Changement mental accompli

Vision du binaire comme texte à lire, pas exécutable à lancer
Compréhension de la relation assembleur ↔ pseudo-C
Habitude de toujours analyser avant d'exécuter
Conscience des limites légales du reverse engineering

💪 Pour aller plus loin :

Explorez radare2 (r2) en ligne de commande, apprenez les bases de l'assembleur ARM pour Android/iOS, ou essayez d'analyser un vrai malware (dans une VM isolée !).

📚 Ressources pour Approfondir

Livres et Cours :

Practical Reverse Engineering : Bruce Dang et al.
The Ghidra Book : Chris Eagle et Kara Nance
Reverse Engineering for Beginners : Dennis Yurichev (gratuit)
LiveOverflow YouTube : Tutoriels reverse excellents

⚠️ Sécurité et Isolation

Jamais exécuter de crackmes inconnus sur machine principale
Utiliser VM isolée (snapshot avant analyse)
Pas de connexion réseau pendant l'analyse malware
Backup des données importantes avant expérimentation

🎗️ Un mot pour Octobre Rose,

Ce mois-ci, la communauté Echoes of Hackers porte une couleur en plus du bleu habituel. Comme en reverse engineering, la prévention repose sur un principe simple : observer tôt, comprendre vite, agir juste. Se faire dépister, c'est l'équivalent d'un bon audit de sécurité — on préfère toujours découvrir une faille avant qu'elle ne devienne un incident.

Prends soin de toi, et de celles et ceux qui t'entourent. 🎗️

🔮 Frère d'armes,

Tu viens d'apprendre à lire les pensées des machines.

Le reverse engineering n'est pas une technique parmi d'autres – c'est l'art de voir à travers les apparences. Tu regardes un fichier exécutable, et là où d'autres ne voient qu'un icône, tu vois des fonctions, des conditions, des secrets.

Cette semaine, tu as fait ton premier pas dans un monde parallèle. Le monde où le code source n'existe pas, où la documentation est absente, où il faut comprendre par la seule force de l'observation et de la déduction.

Mais voici la leçon la plus importante : reverse engineer, c'est apprendre à penser comme le compilateur. Comprendre comment les structures de haut niveau (boucles, conditions) deviennent des jumps et des comparaisons. Comment les variables deviennent des registres et des adresses mémoire.

Tu n'es plus un simple utilisateur qui exécute des programmes. Tu es devenu un lecteur qui comprend leur langue. Qui peut extraire un secret sans même lancer l'exécutable. Qui peut voir la logique à travers l'obscurité du binaire.

Dans la semaine 41, nous irons plus loin dans les profondeurs. Nous apprendrons à analyser des binaires plus complexes, à comprendre l'obfuscation, à déjouer les protections anti-debug. Nous deviendrons capables de lire même ce qu'on a essayé de cacher.

Mais pour l'instant, pratique. Résous des crackmes. Commence par les plus simples, progresse vers les plus complexes. À chaque succès, tu renforces ta compréhension. À chaque échec, tu découvres une nouvelle technique à apprendre.

Un Gardien qui maîtrise le reverse engineering ne craint jamais un binaire inconnu.

— Platon-Y