Ghidra : à quoi ça sert ? Reverse engineering NSA expliqué

Ghidra est un framework de reverse engineering développé par la NSA (US National Security Agency) et publié en open-source sous licence Apache 2.0 le 5 mars 2019 à la conférence RSA San Francisco — événement historique qui a bouleversé l'écosystème reverse engineering traditionnellement dominé par des outils commerciaux onéreux (IDA Pro de Hex-Rays à ~7000 $ licence + ~1800 $/an maintenance). En 5 ans, Ghidra est devenu la référence open-source mondiale du reverse engineering avec ~45 000 stars GitHub (NationalSecurityAgency/ghidra) fin 2024, version 11.x en 2025, releases toutes les 6-12 mois, commits actifs de l'équipe NSA + communauté internationale. Il combine disassembler multi-architectures (x86, x64, ARM 32/64, AArch64, MIPS, PowerPC, RISC-V, plus 40+ autres dont Z80, 6502, 8051, PA-RISC, SuperH via le langage SLEIGH extensible), décompilateur natif vers pseudo-C qualité comparable à Hex-Rays 2025, analyseur de code avec detection de patterns (fonctions, références, strings), debugger intégré (ajouté Ghidra 10 en 2021), scripting Python 3 via Ghidrathon (Mandiant FLARE 2022+), Jython 2.7 (legacy) et Java natif, collaboration multi-utilisateurs via serveur Ghidra avec version control intégré, headless mode CLI pour automation batch. Sa valeur principale en 2025 : alternative gratuite à IDA Pro pour malware analysis, firmware analysis, CTF, vulnerability research, audit binaire commercial. Le langage SLEIGH développé par la NSA permet la description formelle des architectures processeur et génère automatiquement le disassembler + représentation intermédiaire PCode (langage intermédiaire semantically rigorous qui uniformise l'analyse multi-arch). Cet article détaille la genèse Ghidra, les 6 composants principaux, les architectures supportées et SLEIGH, le workflow d'analyse typique, le décompilateur Ghidra comparé à Hex-Rays, le scripting Python/Jython/Java, les plugins populaires (Kaiju NSA, Ghidrathon, BinDiff), la comparaison avec IDA Pro / Binary Ninja / Radare2, les cas d'usage concrets (malware, firmware IoT, CTF, CVE research), et les limites où d'autres outils restent préférables. Pour le contexte complet analyse statique vs dynamique, voir Analyse statique vs dynamique. Pour apprendre le reverse engineering progressivement, Comment apprendre le reverse engineering.

1. Genèse et contexte Ghidra

1.1 Pourquoi la NSA a publié Ghidra

Avant mars 2019, le paysage reverse engineering était :

• IDA Pro (Hex-Rays, Belgique, depuis 1990) : référence industrie, ~7000 $/licence + 1800 $/an, barrière forte pour chercheurs indépendants, étudiants, équipes publiques.
• Radare2 / Rizin : open-source CLI très scriptable mais courbe d'apprentissage raide, pas de décompilateur natif jusqu'à Rizin-Cutter.
• Binary Ninja (Vector 35, 2016) : ~500-2000 $ commercial, alternative moderne mais payante.
• Hopper Disassembler : macOS/Linux, commercial ~100-200 $.
• OllyDbg, x64dbg : debuggers gratuits mais pas disassembler/décompilateur complets.

La NSA avait développé depuis ~1999 un outil interne pour ses reverse engineers — une alternative à IDA Pro utilisable dans ses contextes opérationnels. La décision de publier en open-source en 2019 répond à :

• Souveraineté sécurité cyber américaine : réduire la dépendance à des outils commerciaux (Hex-Rays est belge).
• Attirer les talents : signaler que la NSA utilise des outils modernes, participer à l'écosystème open-source.
• Bug finding : exposer à la communauté permet de trouver bugs et améliorer.
• Standardisation : pousser un standard reverse engineering utilisable en enseignement, CTF, entreprises publiques.

1.2 Histoire des releases

Ghidra — timeline releases
───────────────────────────
 
2019 Mars   Ghidra 9.0 — publication initiale
2019-2020   9.1, 9.2 — stabilisation, améliorations decompiler
2021 Fév    10.0 — Debugger ajouté, PCode amélioré
2022 Fév    10.1, 10.2 — multi-user Ghidra Server optimisé
2023 Mars   11.0 — refonte UI moderne, Java 17 migration
2024 Mai    11.1 — optimisations décompilateur
2024 Nov    11.2 — support nouvelles architectures RISC-V extensions
2025        11.3+ — PCode analysis optimisée, scripting headless renforcé

Commits actifs et releases régulières. L'équipe NSA publie via pull requests officielles sur GitHub, avec revue communautaire.

1.3 Équipe et gouvernance

• Maintainer principal : National Security Agency (équipe CSS Research Associate Directorate).
• Contributeurs majeurs externes : communauté open-source, universités, chercheurs indépendants.
• Licence : Apache 2.0 (permissive, usage commercial autorisé).
• Langage principal : Java (core), Jython + Python 3 (scripting), C++ (décompilateur).
• Dépôt : github.com/NationalSecurityAgency/ghidra (~45 000 stars fin 2024).

2. Les 6 composants principaux de Ghidra

Architecture composants Ghidra
───────────────────────────────
 
┌─────────────────────────────────────────────────┐
│  Code Browser (UI principale)                    │
│  ├─ Disassembly listing                          │
│  ├─ Decompiler panel (pseudo-C)                  │
│  ├─ Symbol Tree                                  │
│  ├─ Function Graph                               │
│  └─ Memory Map                                   │
└─────────────────────────────────────────────────┘
          │
    ┌─────┴─────┐
    │             │
┌─────────┐  ┌──────────────────┐
│ Loader  │  │ Analyzer (auto)  │
│ (PE,    │  │ (functions,      │
│  ELF,   │  │  strings,        │
│  MachO, │  │  references)     │
│  APK,   │  └──────────────────┘
│  etc.)  │
└─────────┘
    │
    ▼
┌─────────────────────────┐
│  SLEIGH Processor        │
│  Definition             │
│  (x86, ARM, MIPS, ...)  │
└─────────────────────────┘
    │
    ▼
┌─────────────────────────┐
│  PCode Intermediate     │
│  Language                │
│  (semantic ops)          │
└─────────────────────────┘
    │
    ▼
┌─────────────────────────┐  ┌────────────────┐
│  Decompiler (C++)       │  │  Debugger      │
│  → pseudo-C              │  │  (Ghidra 10+)  │
└─────────────────────────┘  └────────────────┘
    │                              │
    ▼                              ▼
┌─────────────────────────────────────────────┐
│  Scripting                                  │
│  ├─ Ghidrathon (Python 3, Mandiant 2022+)   │
│  ├─ Jython 2.7 (legacy)                     │
│  └─ Java natif                              │
└─────────────────────────────────────────────┘
    │
    ▼
┌─────────────────────────┐
│  Ghidra Server          │
│  (collaboration multi-  │
│   utilisateurs version  │
│   controlled)           │
└─────────────────────────┘

2.1 Code Browser — l'UI centrale

L'interface principale présente le binaire analysé avec plusieurs vues synchronisées :

• Listing : disassembly annoté avec références croisées, strings, bookmarks.
• Decompiler : pseudo-C généré à la volée pour la fonction sélectionnée.
• Function Graph : CFG (Control Flow Graph) visuel avec blocs et branches.
• Symbol Tree : arborescence des fonctions, classes, variables globales.
• Memory Map : sections, segments, mapping d'adresses.
• Data Type Manager : structures, enums, types définis.

2.2 Decompiler — la killer feature

Le décompilateur Ghidra est écrit en C++ (performance critique) et convertit le PCode en pseudo-C lisible. Qualité comparable à Hex-Rays IDA Pro en 2025 pour les architectures principales. Paramètres ajustables : inline assembly, optimisation, simplification.

Exemple de sortie décompilateur :

/* Fonction originale x86-64 compilée depuis un source C */
/* Sortie décompilateur Ghidra typique                    */
 
undefined8 verify_license(char *input)
{
  int iVar1;
  size_t sVar2;
  char *local_30;
  char local_28 [32];
 
  sVar2 = strlen(input);
  if (sVar2 != 0x10) {
    return 0;
  }
  // Note : Ghidra a détecté 0x10 = 16, compare la longueur
 
  iVar1 = 0;
  local_30 = "SECRET_KEY_ZERODAY";
  while (input[iVar1] != '\0') {
    local_28[iVar1] = input[iVar1] ^ local_30[iVar1 % 18];
    iVar1++;
  }
 
  return strncmp(local_28, "\x08\x0b\x1f\x7b\x4d\x52\x4f\x5b\x5c\x56\x0c", 11) == 0;
}
 
// Le reverser identifie :
// - XOR key : "SECRET_KEY_ZERODAY"
// - Comparison target : 11 bytes encoded
// - Password probable : "ZerodayAcademy!"

2.3 Debugger (Ghidra 10+, 2021)

Intégration de debuggers existants (GDB, LLDB, WinDbg, Frida) avec sync à l'analyse statique. Permet de :

• Exécuter le binaire et stepper au niveau pseudo-C (et pas seulement assembly).
• Annoter en live les valeurs runtime dans le Listing.
• Synchronisation bidirectionnelle entre statique et dynamique.

En 2025, le Debugger Ghidra est moins mature que x64dbg + Ghidra séparément. La plupart des analysts utilisent encore deux outils séparés.

2.4 Scripting

Trois options :

• Ghidrathon (Mandiant FLARE, 2022+) : Python 3 natif dans Ghidra, standard 2025.
• Jython 2.7 : Python 2 embarqué historique, déprécié progressivement.
• Java natif : scripts .java compilés, performance maximale.

2.5 Ghidra Server — collaboration

Permet à plusieurs reverse engineers de travailler sur le même projet avec version control intégré. Utile pour :

• Équipes CTI / forensics analyse d'un sample complexe.
• Universités enseignement reverse engineering collaboratif.
• CTF teams preparation.
• Consulting malware analysis.

2.6 Headless mode — automation

Ghidra peut être lancé en CLI sans UI pour batch processing :

# Lancer Ghidra en headless pour analyser un sample
$GHIDRA_HOME/support/analyzeHeadless \
    /tmp/ghidra_project \
    TestProject \
    -import sample.exe \
    -postScript MyScript.py \
    -deleteProject
 
# MyScript.py pourrait extraire strings, imports, auto-detect crypto
# et sortir un JSON pour ingestion SIEM/CTI

3. Architectures supportées

3.1 Liste (extrait)

Ghidra 11.x supporte 40+ architectures via SLEIGH. Extrait :

3.2 SLEIGH — extensibilité

Pour ajouter une architecture non supportée, écrire un fichier SLEIGH .slaspec qui décrit :

• Registres du processeur (noms, tailles, relations).
• Instructions (mnémonique, operands, encoding, sémantique PCode).
• Modes d'adressage.
• Rôles spéciaux (PC, SP, retour de fonction).

Exemple SLEIGH très simplifié pour une instruction hypothétique :

# Déclaration registres (extrait)
define register offset=0 size=4 [ R0 R1 R2 R3 R4 R5 R6 R7 ];
 
# Instruction MOV immediate
:MOV Ra, imm is op=0x01 & Ra & imm {
    Ra = imm;
}
 
# Instruction ADD register
:ADD Ra, Rb is op=0x02 & Ra & Rb {
    Ra = Ra + Rb;
}

Après compilation, Ghidra peut désassembler et décompiler le binaire pour cette architecture. Effort typique pour écrire un processeur SLEIGH complet : 2-8 semaines pour un reverser expérimenté avec datasheet du processeur.

4. Workflow d'analyse typique

4.1 Les 7 étapes standard

Workflow d'analyse Ghidra standard
───────────────────────────────────
 
1. IMPORT
   File → Import File → sélectionner binaire
   Ghidra détecte automatiquement le format (PE, ELF, Mach-O, APK)
 
2. AUTO-ANALYSIS
   Après import, Ghidra lance l'analyseur automatique
   ├─ Detection de fonctions (patterns prologue/épilogue)
   ├─ Références croisées
   ├─ Strings extraction
   ├─ PCode generation
   └─ Decompilation du main entry point
 
3. RECONNAISSANCE
   ├─ Entry point identification
   ├─ Symbol Tree : main, WinMain, DllMain
   ├─ Memory Map : sections executables vs data
   └─ Defined Strings : artefacts distinctifs
 
4. EXPLORATION
   ├─ Double-clic sur entry function
   ├─ Decompiler lit le pseudo-C
   ├─ Navigation via xrefs (Ctrl+Shift+F references)
   └─ Marquage bookmarks pour fonctions intéressantes
 
5. ANNOTATION
   ├─ Renaming variables (L raccourci)
   ├─ Retyping via Data Type Manager
   ├─ Struct création pour patterns récurrents
   └─ Commentaires plate (Ctrl+;)
 
6. SCRIPTING
   ├─ Window → Script Manager
   ├─ Python / Jython / Java pour automation
   ├─ Plugins externes si applicable
   └─ Export résultats (JSON, CSV, rapport)
 
7. RAPPORT
   ├─ Decompilation cleanup
   ├─ Export pseudo-C pour rapport
   ├─ Screenshots CFG
   └─ YARA rules basées sur patterns identifiés

4.2 Raccourcis essentiels

5. Le décompilateur Ghidra — profondeur

5.1 Fonctionnement interne

Le décompilateur Ghidra opère en multiples passes :

1. PCode generation : conversion des instructions machine en PCode via SLEIGH.
2. Data flow analysis : détection variables, propagation de types.
3. Structural analysis : reconstruction des control flow patterns (while, if-else, switch).
4. Simplification : élimination de code mort, constant propagation.
5. Output C-like : génération pseudo-C humain-lisible.

5.2 Typing interactif

Ghidra permet au reverser de retyper les variables dynamiquement, ce qui améliore la décompilation en retour :

Exemple : de "iVar1" à struct typée
────────────────────────────────────
 
Avant annotation :
  undefined4 local_28 [0x10];
  local_28[0] = 0xdeadbeef;
  local_28[4] = 0x1000;
  local_28[8] = &function_ptr_table;
 
Après annotation (struct HEADER_STRUCT définie) :
  HEADER_STRUCT local_28;
  local_28.magic = 0xdeadbeef;
  local_28.size = 0x1000;
  local_28.function_table = &function_ptr_table;

Cette capacité de re-typing interactif + propagation aux fonctions appelantes est un des atouts majeurs de Ghidra.

5.3 Limites

Décompilation peut devenir difficile sur :

• Code fortement optimisé par compilateur (LTO, PGO, SIMD).
• Code obfusqué commercial (Themida, VMProtect avec VM custom).
• Code C++ complexe avec multiple inheritance, RTTI avancé.
• Heavily templated C++ (STL intensif).

Pour ces cas, analyser assembly directement ou utiliser Hex-Rays IDA Pro + plugins spécialisés reste préférable.

6. Scripting Python / Jython / Java

6.1 Ghidrathon (Python 3)

Ghidrathon (Mandiant FLARE, 2022+) permet Python 3 natif dans Ghidra. Installation via Ghidra Extension.

# Script Ghidrathon — lister toutes fonctions avec leur taille
# Window → Script Manager → ghidrathon_mode_enable
# Puis écriture Python 3
 
from ghidra.program.model.listing import FunctionManager
from ghidra.util.task import ConsoleTaskMonitor
 
def analyze_functions():
    program = currentProgram
    fm = program.getFunctionManager()
    monitor = ConsoleTaskMonitor()
 
    functions_data = []
    for func in fm.getFunctions(True):
        body = func.getBody()
        func_size = body.getNumAddresses()
 
        functions_data.append({
            "name": func.getName(),
            "entry": str(func.getEntryPoint()),
            "size": func_size,
            "parameters": func.getParameterCount(),
        })
 
    # Tri par taille décroissante (grosses fonctions = souvent intéressantes)
    functions_data.sort(key=lambda x: x["size"], reverse=True)
 
    print(f"Total functions: {len(functions_data)}")
    for f in functions_data[:20]:
        print(f"  {f['name']} @ {f['entry']} ({f['size']} bytes)")
 
analyze_functions()

6.2 Script utile — extraction strings automatique

# Extraction strings avec contexte (fonction qui les référence)
from ghidra.program.model.listing import Data
from ghidra.app.util.XReferenceUtil import getXRefList
 
def extract_strings_with_context():
    strings_info = []
    listing = currentProgram.getListing()
 
    for data in listing.getDefinedData(True):
        data_type = data.getDataType().getName()
        if "string" in data_type.lower():
            addr = data.getAddress()
            value = str(data.getValue()) if data.getValue() else ""
 
            # Qui référence cette string ?
            xrefs = getXRefList(data, 10)
            referencing_funcs = set()
            for xref in xrefs:
                func = getFunctionContaining(xref.getFromAddress())
                if func:
                    referencing_funcs.add(func.getName())
 
            strings_info.append({
                "addr": str(addr),
                "value": value[:80],  # tronque
                "refs_from": list(referencing_funcs),
            })
 
    # Output JSON structuré pour ingestion CTI
    import json
    print(json.dumps(strings_info, indent=2))
 
extract_strings_with_context()

6.3 Cas d'usage scripting

• Analyse batch : exécuter un script sur N samples pour extraction IoCs structurée.
• Décryption routines : reproduire en Python une routine XOR/AES identifiée.
• Renaming bulk : si pattern récurrent (ex: fonctions nommées selon hash), renamer par script.
• Export rapport : générer JSON/CSV/HTML custom du projet.
• YARA generation : extraire séquences de bytes caractéristiques pour règles YARA automatiques.

7. Plugins et extensions populaires

7.1 Extensions officielles NSA

7.2 Extensions communautaires

7.3 BinDiff — comparaison de binaires

BinDiff (zynamics, acquis par Google, gratuit depuis 2011) permet de comparer deux binaires pour identifier les fonctions identiques / modifiées / ajoutées. Cas d'usage :

• Patch diffing : comprendre ce qu'un patch Microsoft/Adobe/etc a corrigé.
• Malware variants : comparer deux versions d'une famille malware.
• Port analysis : comparer versions différentes d'un produit commercial.

# Usage BinDiff avec Ghidra
# 1. Analyser chaque binaire dans Ghidra (project séparé)
# 2. Exporter via BinExport extension (.BinExport file)
# 3. Comparer :
bindiff --primary binary_v1.BinExport \
        --secondary binary_v2.BinExport \
        --output comparison.BinDiff
 
# Visualisation dans UI BinDiff GUI

8. Ghidra vs IDA Pro vs Binary Ninja vs Radare2

8.1 Matrice comparative

8.2 Recommandations par profil

9. Cas d'usage concrets

9.1 Malware analysis

Workflow complet avec Ghidra pour un sample Windows :

Malware analysis workflow Ghidra — 2-8 heures typique
──────────────────────────────────────────────────────
 
1. Import PE avec auto-analysis (~5-15 min selon taille)
2. Symbol Tree exploration → trouver WinMain / DllMain
3. Decompile → lecture pseudo-C
4. Strings extraction → C2 URLs, registry keys, mutex
5. Imports analysis → VirtualAllocEx, WriteProcessMemory = injection
6. Identification routine crypto (constantes AES S-box, RC4 initialization)
7. Scripting Python pour décoder config C2 embedded
8. Génération règles YARA + Sigma depuis patterns identifiés
9. Export rapport MISP/OpenCTI avec IoCs extraits

9.2 Firmware IoT

Ghidra + binwalk est le combo standard :

# Extraction firmware
binwalk -e firmware_router.bin
 
# Dans _firmware_router.bin.extracted/, on trouve souvent :
# - squashfs root filesystem
# - vmlinux kernel
# - u-boot bootloader
# - custom binaries propriétaires
 
# Ouvrir vmlinux dans Ghidra :
# File → Import File → vmlinux
# Architecture : MIPS32 big-endian (typique router)
# Auto-analyze → exploration

9.3 CTF reverse challenges

Standard en CTF : binaire à reverser pour trouver un flag. Ghidra automatise 80 % de l'analyse :

• Auto-decompile reveal algorithm logic.
• Identification routines crypto → décryption scriptable Python.
• Extraction strings → souvent flag encodé ou partial clues.

9.4 Vulnerability research

Pour chercher 0-day dans un produit commercial :

• Statique Ghidra → identifier fonctions avec patterns classiques (strcpy, gets, format strings, double-free, UAF).
• Annotation exhaustive + scripting pour cartographier call graph.
• Combiné avec fuzzing (AFL++, libfuzzer, honggfuzz) pour découverte crash → triage dans Ghidra.

9.5 Carte à puce / Secure Element

Ghidra supporte des architectures exotiques de secure elements via SLEIGH custom. Voir Carte à puce, JavaCard, APDU pour le contexte hardware.

10. Limites et compléments

10.1 Cas où utiliser un autre outil

10.2 Compléments systémiques

Ghidra ne remplace pas :

• Debugger runtime (x64dbg, WinDbg, GDB) — reverse dynamique.
• Sandbox malware (CAPE, ANY.RUN) — comportement runtime.
• YARA — classification signature-based.
• Binwalk — extraction firmware.
• Wireshark — analyse réseau.

Pour le workflow complet combiné, voir Analyse statique vs dynamique.

11. Ressources d'apprentissage Ghidra

11.1 Documentation officielle

• Ghidra Documentation : inclus dans l'install (F1 dans UI).
• NSA Training : Ghidra_Class folder dans repo GitHub.
• Slaspec reference : documentation SLEIGH pour ajout architectures.

11.2 Communauté

• Discord / forums : Reverse Engineering server, NSA Ghidra channel.
• YouTube : GhidraNinja, stacksmashing, LiveOverflow, Off By One Security.
• Reddit : r/ReverseEngineering, r/Ghidra.
• Conférences : RECon Montréal, Offensivecon, SSTIC France, BHUSA/DC.

11.3 Livres référence

• Practical Reverse Engineering (Dang, Gazet, Bachaalany, 2014).
• The Ghidra Book (Chris Eagle, Kara Nance, 2020).
• Reversing: Secrets of Reverse Engineering (Eldad Eilam, 2005 — fondamentaux).

Pour la progression complète dans le reverse engineering voir Comment apprendre le reverse engineering. Pour la base assembleur préalable, Pourquoi apprendre l'assembleur en cybersécurité.

12. Points clés à retenir

• Ghidra = framework reverse engineering NSA open-source Apache 2.0 depuis mars 2019, version 11.x en 2025, ~45 000 stars GitHub, référence 2025 pour 80 % des cas reverse open-source.
• 6 composants : Code Browser (UI), Loader multi-format, Analyzer auto, Decompiler C++ (pseudo-C multi-arch), Debugger (10+ 2021), Scripting (Ghidrathon Python 3, Jython 2.7, Java), Ghidra Server (collaboration).
• SLEIGH = langage NSA pour description architectures processeur, 40+ archs supportées (x86, ARM, MIPS, PowerPC, RISC-V, Z80, 8051, PA-RISC, SuperH, MSP430, etc.), extensibilité communautaire.
• PCode = langage intermédiaire semantically rigorous qui uniformise analyse multi-arch, base du décompilateur.
• Décompilateur Ghidra : 85 % qualité Hex-Rays sur x86/x64 et ARM, multi-architecture natif (contrairement à Hex-Rays où chaque décompilateur est plugin séparé).
• Scripting 2025 : Ghidrathon (Python 3 Mandiant FLARE, standard 2025), Jython 2.7 legacy, Java natif. Headless mode pour automation CLI.
• Ghidra vs IDA Pro : gratuit vs ~7000 $, architecture SLEIGH vs loaders plus larges, qualité décompilation proche, UI Ghidra moins rapide sur gros binaires > 500 MB.
• Ghidra vs Binary Ninja : OSS vs ~500-2000 $ commercial, scripting similaire, Binary Ninja IL (LLIL/MLIL/HLIL) plus puissant, Ghidra plus mature en 2025.
• Ghidra vs Radare2 : GUI vs CLI scriptable, décompilateur natif vs r2dec/Rizin Decomp, Ghidra plus accessible débutants.
• Cas d'usage 2025 : malware analysis, firmware IoT, CTF, vulnerability research, pentest hardware/binaire, audit commercial.
• Limites : binaires > 500 MB (IDA Pro plus rapide), formats firmware exotiques (IDA loaders), C++ complexe optimisé, obfuscation commerciale VMProtect.

Pour la vue d'ensemble statique vs dynamique, voir Analyse statique vs dynamique. Pour l'apprentissage progressif reverse, Comment apprendre le reverse engineering et Pourquoi apprendre l'assembleur en cybersécurité. Pour le contexte malware analyst, Métier malware analyst si la fiche existe sinon Qu'est-ce qu'un malware analyst. Pour les vulnérabilités dans binaires exploitées, Qu'est-ce qu'un buffer overflow.