OGhidra relie les grands modèles de langage (LLM) via Ollama à la plateforme de rétro-ingénierie Ghidra, permettant une analyse binaire pilotée par l'IA grâce au langage naturel. Interagissez avec Ghidra à l'aide de requêtes conversationnelles et automatisez des flux de travail complexes de rétro-ingénierie.
# OGhidra 3 - Rétro-ingénierie assistée par l'IA avec Ghidra
Pour la version utilisant un orchestrateur inspiré de Claude, voir https://github.com/llnl/OGhidra/tree/orchestrator
**OGhidra** fait le pont entre les grands modèles de langage et la plateforme de rétro-ingénierie de Ghidra, permettant une analyse binaire pilotée par l'IA en langage naturel. Analysez les binaires de manière conversationnelle, automatisez des flux de travail complexes et préservez une confidentialité totale grâce aux modèles IA locaux.
Tutoriel de configuration YouTube
[](https://www.youtube.com/watch?v=hBD92FUgR0Y)
---
## Qu'est-ce qu'OGhidra ?
OGhidra améliore Ghidra avec des capacités d'IA, vous permettant de :
- **Analyse en langage naturel** - Posez des questions sur les fonctions, les chaînes de caractères et les importations en anglais simple
- **Flux de travail automatisés** - Renommez des fonctions, détectez des schémas, générez des rapports complets
- **Modèles IA locaux** - Confidentialité totale avec des modèles exécutés sur votre matériel (Ollama)
- **Prise en charge de l'IA cloud** - Connexion à des API externes (OpenAI, Google Gemini, Anthropic Claude)
- **Détection de malwares** - Correspondance automatique de motifs pour plus de 12 techniques d'évasion et d'injection
- **Énumération intelligente** - Construisez des graphes de connaissances interrogeables à partir de l'analyse binaire
- **Analyse multi-instances** - Exécutez plusieurs instances de Ghidra pour une analyse parallèle
### Comment ça fonctionne
```mermaid
graph TD
A[User Query] --> B[Planning Phase]
B --> C{Execution Phase}
C -- Tool Calls --> D[Ghidra/LLM]
D --> C
C --> E[Review Phase]
E -- Agentic Loop --> B
E --> F[Final Response]
style E fill:#f9f,stroke:#333,stroke-width:2px
style B fill:#bbf,stroke:#333,stroke-width:2px
```
**Agentic Loop** : OGhidra utilise un système de planification adaptatif. Après chaque cycle d'exécution, les résultats sont examinés et l'IA peut choisir de collecter davantage d'informations ou d'affiner son analyse avant de fournir la réponse finale.
---
## Démarrage rapide
### Prérequis
1. **Python 3.12+** - Vérifiez la version : `python --version`
2. **Ghidra 12.0.3** (recommandé) - Téléchargez-le depuis [Ghidra Releases](https://github.com/NationalSecurityAgency/ghidra/releases)
- Le chemin de compilation/installation du plugin est documenté pour Ghidra 12.0.3
- Testé avec : Ghidra 11.0.3, 11.3.2, 12.0.2, 12.0.3
3. **Java 21** - Requis pour compiler l'extension Ghidra 12.0.3 : `java -version`
4. **Ollama** (facultatif, pour les modèles locaux) - Installez-le depuis [ollama.com](https://ollama.com/)
### Installation
```bash
# Clone repository
git clone https://github.com/LLNL/OGhidra.git
cd OGhidra
# Install dependencies (choose one)
uv sync # Using UV (recommended)
pip install -r requirements.txt # Using pip
# Configure environment
cp .env.example .env
# Edit .env with your settings
```
### Configuration du plugin Ghidra
Les étapes de compilation du plugin OGhidraMCP ci-dessous ciblent Ghidra 12.0.3 (recommandé).
Il existe aussi un tutoriel vidéo YouTube : https://www.youtube.com/watch?v=hBD92FUgR0Y
#### Compilation de l'extension GhidraMCP
En tant que développeur, vous devez compiler l'extension GhidraMCP avant de l'installer dans Ghidra :
1. **Prérequis** :
- Ghidra 12.0.3 installé
- Java 21
2. **Option 1 : Utilisation des scripts de compilation automatisés** :
- Windows :
```bat
# Set the path to your Ghidra installation (will attempt to find last run copy of Ghidra if not set)
set GHIDRA_INSTALL_DIR=C:\path\to\ghidra_12.0.3_PUBLIC
# Run the build script
build_ghidra_plugin.bat
```
- Unix/Linux/Mac :
```bash
# Set the path to your Ghidra installation (will attempt to find the last run copy of Ghidra if not set)
export GHIDRA_INSTALL_DIR=/path/to/ghidra_12.0.3_PUBLIC
# Run the build script (make it executable first if needed)
chmod +x build_ghidra_plugin.sh
./build_ghidra_plugin.sh
```
3. **Option 2 : Compilation manuelle** :
- Créez/mettez à jour `OGhidraMCP/gradle.properties` avec votre chemin d'installation de Ghidra :
```properties
GHIDRA_INSTALL_DIR=/absolute/path/to/ghidra_12.0.3_PUBLIC
```
- Sur Unix/Linux/macOS :
```bash
cd OGhidraMCP
$GHIDRA_INSTALL_DIR/support/gradle/gradlew buildExtension --info
```
- Sur Windows :
```bat
cd OGhidraMCP
"%GHIDRA_INSTALL_DIR%\support\gradle\gradlew.bat" buildExtension --info
```
4. **Localisez l'extension compilée** :
- Le fichier zip de l'extension est créé dans `OGhidraMCP/dist/`
- Le nom du fichier ressemblera à `ghidra_12.0.3_PUBLIC_YYYYMMDD_OGhidraMCP.zip`
#### Installation de l'extension GhidraMCP
Une fois l'extension compilée avec succès :
1. **Installation dans Ghidra** :
- Ouvrez Ghidra -> **File** -> **Install Extensions**
- Cliquez sur **Add Extension** (icône plus verte)
- Accédez à votre répertoire `OGhidraMCP/dist/`
- Sélectionnez le fichier zip de l'extension nouvellement compilée (par ex., `ghidra_12.0.3_PUBLIC_YYYYMMDD_OGhidraMCP.zip`)
- Redémarrez Ghidra
2. **Activation du plugin** :
- Ouvrez un projet Ghidra
- **File** → **Configure** → **Enable Developer**
- Activez le plugin `OGhidraMCP`
- Le serveur démarrera sur `http://localhost:8080/methods`
> **VOUS DEVEZ AVOIR LE CODE BROWSER OUVERT**
### Télécharger les modèles IA
```bash
# For Ollama (local models)
ollama pull gemma3:27b # Good balance (20GB RAM)
ollama pull nomic-embed-text # Embedding model for RAG
# Alternative models
ollama pull gpt-oss:120b # High quality (80GB RAM)
ollama pull devstral-2:123b # High quality (80GB RAM)
ollama pull devstral-2:123b-cloud # Cloud Model
```
### Lancer OGhidra
```bash
# GUI Mode (recommended)
uv run main.py --ui
# Interactive CLI
uv run main.py --interactive
# In interactive CLI, test connection
health
```
Si vous avez lancé le mode GUI, utilisez :
```bash
curl http://localhost:8080/methods
```
---
## Configuration
Modifiez `.env` pour configurer votre fournisseur d'IA :
### Option 1 : Modèles locaux (Ollama)
```env
LLM_PROVIDER=ollama
OLLAMA_BASE_URL=http://localhost:11434/
OLLAMA_MODEL=gemma3:27b
OLLAMA_EMBEDDING_MODEL=nomic-embed-text
```
### Option 2 : API externes
```env
LLM_PROVIDER=external
EXTERNAL_PROVIDER=google
EXTERNAL_API_KEY=your-api-key-here
EXTERNAL_MODEL=gemini-3.1-flash-lite-preview
EXTERNAL_EMBEDDING_MODEL=gemini-embedding-001
```
### Option 3 : API personnalisée compatible OpenAI
```env
LLM_PROVIDER=custom_api
CUSTOM_API_URL=https://api.example.com/v1/chat/completions
CUSTOM_API_KEY=your-api-key-here
CUSTOM_API_MODEL=your-model-name
CUSTOM_API_EMBEDDING_MODEL=your-embedding-model
```
### Paramètres de gestion du contexte
Ajustez selon la fenêtre de contexte de votre modèle :
```env
# Context budget in tokens (adjust to your model's limit)
CONTEXT_BUDGET=100000 # 100K tokens for mid-size models
# 200K+ for frontier models
# Execution settings
MAX_EXECUTION_STEPS=5 # Steps per planning cycle
MAX_AGENTIC_CYCLES=3 # How many plan-execute-review loops
AGENTIC_LOOP_ENABLED=true # Enable adaptive replanning
```
---
## Fonctionnalités clés
### 1. Boutons d'outils intelligents (GUI)
Accès en un clic aux tâches courantes de rétro-ingénierie :
| Tool | Description |
| ---------------------------- | ----------------------------------------------- |
| **Analyze Current Function** | Analyse approfondie du comportement de la fonction sélectionnée |
| **Rename Current Function** | L'IA suggère des noms pertinents en fonction de l'analyse |
| **Rename All Functions** | Renommage en masse avec les options Smart/Full/Rename-Only |
| **Analyze Imports** | Identifie les bibliothèques et les dépendances externes |
| **Analyze Strings** | Trouve les URL, identifiants et données de configuration |
| **Generate Report** | Évaluation complète de la sécurité |
### 2. Modes de tâche
Définissez des objectifs d'analyse spécialisés :
```python
# In GUI: Use "Task Mode" dropdown
# In CLI: set task_mode <mode>
task_mode malware # Malware analysis with pattern detection
task_mode vuln # Vulnerability research focus
task_mode general # General reverse engineering
```
### 3. Détection de motifs de malwares
Détection automatique de plus de 12 motifs de malwares :
- **Évasion** : PEB Walking, Dynamic API Resolution, Anti-Debug, Anti-VM
- **Injection** : Process Injection (Local/Remote)
- **Persistance** : Registry, File System Hooks
- **Obfuscation** : String Encoding, API Hashing
- **Élévation de privilèges** : manipulation de jetons, contournement de l'UAC
Les motifs déclenchent des alertes automatiques dans le contexte de l'IA avec des correspondances MITRE ATT&CK.
### 4. Énumération intelligente
Construisez une base de connaissances riche et interrogeable à partir de l'analyse binaire :
```
# Enumerate all functions with AI summaries
# Choose from:
- Rename Only: Only process generic function names
- Smart Enumeration: Focus on security-relevant functions
- Full Enumeration: Analyze every function in the binary
```
Fonctionnalités :
- Extraction de métadonnées structurées (LOC, complexité, opérations)
- Optimisation de la recherche sémantique
- Assemblage contextuel basé sur l'intention
- Prise en charge multi-vecteurs pour une récupération précise
### 5. Gestion des sessions
Enregistrez et restaurez des sessions d'analyse :
```python
# Save progress
File → Save Session
# Load previous work
File → Load Session
# Auto-save after bulk operations
# Sessions include:
- Analyzed functions with summaries
- RAG vectors for semantic search
- Performance statistics
- UI state
```
---
## Configuration du backend
OGhidra prend en charge deux types de backend :
- **MCP** — S'intègre au serveur GhidraMCP et nécessite que le client Ghidra soit en cours d'exécution pendant l'analyse
- **PyGhidra** — Prend en charge l'analyse headless sans le client Ghidra et supprime le composant serveur requis par MCP
### Sélection d'un backend
Utilisez l'option de ligne de commande suivante pour choisir un backend :
```bash
--ghidra-backend={http,pyghidra}
```
| Backend Option | Description |
|----------------|-------------|
| `http` | Utilise le backend GhidraMCP |
| `pyghidra` | Utilise le backend PyGhidra |
---
## Configuration PyGhidra
### Utilisation d'un projet Ghidra existant
Spécifiez un fichier de projet Ghidra (`.gpr`) lors du lancement d'OGhidra :
```bash
--pyghidra-project=/path/to/project.gpr
```
PyGhidra nécessite un projet Ghidra valide pour lancer OGhidra.
---
### Sélection d'un programme
Spécifiez quel binaire du projet Ghidra doit être analysé :
```bash
--pyghidra-program=<program_name>
```
exemple d'appel pour sélectionner un programme dans un projet Ghidra :
```bash
uv run main.py --ui --ghidra-backend=pyghidra --pyghidra-project=/path/to/project.gpr --pyghidra-program=<program_name>
```
Exigences :
- Le nom du programme doit correspondre exactement au nom affiché dans l'interface graphique du projet Ghidra
- Cette option est requise lors de l'utilisation d'un projet existant
- Le fait de ne pas spécifier de programme empêchera OGhidra de se lancer
---
### Lancement direct d'un binaire
Vous pouvez également fournir directement le chemin d'un binaire :
```bash
--pyghidra-binary=/path/to/binary
```
Lorsque cette option est utilisée, PyGhidra exécute automatiquement les opérations suivantes :
1. Crée un nouveau projet Ghidra (`.gpr`)
2. Importe le binaire
3. Lance le binaire dans OGhidra pour analyse
exemple d'appel pour lancer un binaire directement :
uv run main.py --ui --ghidra-backend=pyghidra --pyghidra-binary=/path/to/binary
---
## Flux de travail courants
### Analyser un binaire suspect
1. **Chargez le binaire dans Ghidra** et ouvrez-le dans CodeBrowser
2. **Activez le plugin OGhidraMCP** (File → Configure)
3. **Lancez OGhidra** : `uv run main.py --ui`
4. **Définissez le mode de tâche** : sélectionnez « malware » dans la liste déroulante
5. **Exécutez l'énumération intelligente** : cliquez sur « Rename All Functions » → « Smart Enumeration »
6. **Posez des questions** : « Quelles sont les fonctions à haut risque ? » ou « Montre-moi les communications réseau »
### Générer un rapport de sécurité
```bash
# In GUI: Click "Generate Report" button
# Report includes:
- Executive Summary
- Function Inventory (renamed functions with behavior)
- Security Analysis (high-risk functions, patterns)
- Import Analysis
- String Analysis
- Recommendations
```
### Examiner une fonction spécifique
1. **Naviguez jusqu'à la fonction dans Ghidra**
2. **Cliquez sur « Analyze Current Function »**
3. **Posez des questions complémentaires** :
- « Que fait cette fonction ? »
- « Est-elle vulnérable à un débordement de tampon ? »
- « Quelles autres fonctions l'appellent ? »
---
## Fonctionnalités avancées
### RAG (génération augmentée par récupération)
OGhidra utilise des plongements vectoriels pour la recherche sémantique sur les fonctions analysées :
```env
# Enable in .env
RESULT_CACHE_ENABLED=true
TIERED_CONTEXT_ENABLED=true
```
Avantages :
- Conserver la mémoire des analyses précédentes entre les sessions
- Trouver des fonctions similaires sur le plan sémantique
- Réduire les appels LLM redondants
### Optimisation du contexte
La compression de contexte par niveaux conserve les informations pertinentes :
```env
CURRENT_LOOP_MAX_CHARS=2000 # Recent: full detail
PREV_LOOP_MAX_CHARS=400 # Previous: summaries
OLDER_LOOP_MAX_CHARS=100 # Older: references only
```
### Journalisation LLM
Suivez toutes les interactions IA pour le débogage :
```env
LLM_LOGGING_ENABLED=true
LLM_LOG_FILE=logs/llm_interactions.log
LLM_LOG_FORMAT=json
```
---
## Dépannage
### Problèmes de connexion à Ghidra
```bash
# Verify plugin is loaded
# Open up codebrowser!
# Check server is running
curl http://localhost:8080/methods
```
### Problèmes de connexion à Ollama
```bash
# Verify Ollama is running
ollama list
# Check connectivity
curl http://localhost:11434/api/tags
# Restart Ollama service
ollama serve
```
### Réponses vides / Dépassement de contexte
```env
# Reduce context budget
CONTEXT_BUDGET=50000
# Enable compaction
COMPACTION_ENABLED=true
COMPACTION_THRESHOLD=0.75
```
### Performances lentes
1. **Utilisez des modèles plus petits** : passez à `gemma3:9b`
2. **Réduisez le nombre de travailleurs parallèles** : définissez `max_workers=2` dans les opérations en masse
3. **Désactivez les plongements vectoriels** : `RESULT_CACHE_ENABLED=false`
4. **Augmentez le délai de requête** : `CUSTOM_API_REQUEST_DELAY=2.0`
---
## Vue d'ensemble de l'architecture
```
┌─────────────────────────────────────────────────────────────┐
│ OGhidra UI │
│ (GUI / Interactive CLI) │
└────────────────────────┬────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Bridge (src/bridge.py) │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ • Agentic Loop: Plan → Execute → Review → Replan │ │
│ │ • Tool Router: Ghidra client, LLM client, CAG manager │ │
│ │ • Context Manager: Budget allocation, compression │ │
│ └────────────────────────────────────────────────────────┘ │
└───────────┬────────────────────────┬────────────────────────┘
│ │
▼ ▼
┌───────────────────────┐ ┌─────────────────────────┐
│ Ghidra Client │ │ LLM Clients │
│ • GhidraMCP Plugin │ │ • Ollama (local) │
│ • Binary operations │ │ • External APIs │
│ • Decompilation │ │ • Custom endpoints │
└───────────────────────┘ └─────────────────────────┘
│ │
└────────────┬───────────┘
▼
┌─────────────────────────────────────────────────────────────┐
│ CAG Manager (Knowledge System) │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ • Vector Store: Semantic search over functions │ │
│ │ • Pattern Detector: 12+ malware techniques │ │
│ │ • Metadata Extractor: Structured function analysis │ │
│ │ • Session Store: Persistent analysis state │ │
│ └────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
```
---
## Contribuer
Nous accueillons volontiers les contributions ! Domaines d'intérêt :
- **Nouveaux motifs de malwares** pour la détection
- **Intégrations de fournisseurs LLM**
- **Améliorations UI/UX**
- **Optimisations des performances**
- **Documentation** et exemples
Consultez [CODE_OF_CONDUCT.md](https://github.com/llnl/oghidra/blob/main/CODE_OF_CONDUCT.md) pour les directives de la communauté.
---
## Citation
Si vous utilisez OGhidra dans vos recherches, veuillez citer :
```bibtex
@software{oghidra2025,
title = {OGhidra: AI-Powered Reverse Engineering with Ghidra},
author = {Enoch Wang},
year = {2025},
url = {https://github.com/LLNL/OGhidra}
}
```
---
## Remerciements
OGhidra s'appuie sur d'excellents projets open-source :
- **[Ghidra](https://github.com/NationalSecurityAgency/ghidra)** - La plateforme de rétro-ingénierie de la NSA
- **[Ollama](https://ollama.com/)** - Environnement d'exécution LLM local
- **[LaurieWired/GhidraMCP](https://github.com/LaurieWired/GhidraMCP)** - Plugin Ghidra MCP d'origine
- **[starsong/GhydraMCP](https://github.com/starsong/GhydraMCP)** - Implémentation MCP améliorée
---
## Licence
OGhidra est distribué selon les termes de la licence BSD 3-Clause, avec une alternative de licence commerciale.
Voir [LICENSE](https://github.com/llnl/oghidra/blob/main/LICENSE) et [NOTICE.md](https://github.com/llnl/oghidra/blob/main/NOTICE.md) pour plus de détails.
**LLNL-CODE-2013290**
---
## Support
- **Problèmes** : [GitHub Issues](https://github.com/LLNL/OGhidra/issues)
- **Discussions** : [GitHub Discussions](https://github.com/LLNL/OGhidra/discussions)
- **Envoyez-moi directement un e-mail** : [email protected]