OGhidra verbindet Large Language Models (LLMs) über Ollama mit der Reverse-Engineering-Plattform Ghidra und ermöglicht so KI-gesteuerte Binäranalyse durch natürliche Sprache. Interagiere mit Ghidra mithilfe von konversationellen Abfragen und automatisiere komplexe Reverse-Engineering-Workflows.
# OGhidra 3 – KI-gestütztes Reverse Engineering mit Ghidra
Für die Version mit einem Claude-inspirierten Orchestrator siehe https://github.com/llnl/OGhidra/tree/orchestrator
**OGhidra** verbindet Large Language Models mit Ghidras Reverse-Engineering-Plattform und ermöglicht KI-gesteuerte Binäranalyse über natürliche Sprache. Analysieren Sie Binärdateien dialogorientiert, automatisieren Sie komplexe Arbeitsabläufe und bewahren Sie vollständige Privatsphäre mit lokalen KI-Modellen.
YouTube Setup-Anleitung
[](https://www.youtube.com/watch?v=hBD92FUgR0Y)
---
## Was ist OGhidra?
OGhidra erweitert Ghidra um KI-Fähigkeiten, die Ihnen Folgendes ermöglichen:
- **Analyse in natürlicher Sprache** – Stellen Sie Fragen zu Funktionen, Strings, Importen in einfachem Englisch
- **Automatisierte Workflows** – Funktionen umbenennen, Muster erkennen, umfassende Berichte erstellen
- **Lokale KI-Modelle** – Vollständige Privatsphäre mit Modellen auf Ihrer Hardware (Ollama)
- **Cloud-KI-Unterstützung** – Verbindung zu externen APIs (OpenAI, Google Gemini, Anthropic Claude)
- **Malware-Erkennung** – Automatischer Mustervergleich für über 12 Umgehungs- und Injektionstechniken
- **Intelligente Aufzählung** – Erstellen von abfragbaren Wissensgraphen aus der Binäranalyse
- **Multi-Instanz-Analyse** – Mehrere Ghidra-Instanzen für parallele Analysen ausführen
### So funktioniert es
```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
```
**Agentische Schleife**: OGhidra verwendet ein adaptives Planungssystem. Nach jedem Ausführungszyklus werden die Ergebnisse überprüft und die KI kann entscheiden, weitere Informationen zu sammeln oder ihre Analyse zu verfeinern, bevor sie die endgültige Antwort gibt.
---
## Schnellstart
### Voraussetzungen
1. **Python 3.12+** – Version prüfen: `python --version`
2. **Ghidra 12.0.3** (Empfohlen) – Herunterladen von [Ghidra Releases](https://github.com/NationalSecurityAgency/ghidra/releases)
- Der Pfad zum Erstellen/Installieren des Plugins ist für Ghidra 12.0.3 dokumentiert
- Getestet mit: Ghidra 11.0.3, 11.3.2, 12.0.2, 12.0.3
3. **Java 21** – Erforderlich zum Erstellen der Ghidra 12.0.3-Erweiterung: `java -version`
4. **Ollama** (optional, für lokale Modelle) – Installieren von [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
```
### Ghidra-Plugin einrichten
Die folgenden Schritte zum Erstellen des OGhidraMCP-Plugins zielen auf Ghidra 12.0.3 (empfohlen) ab. Es gibt auch ein YouTube-Video-Tutorial: https://www.youtube.com/watch?v=hBD92FUgR0Y
#### Erstellen der GhidraMCP-Erweiterung
Als Entwickler müssen Sie die GhidraMCP-Erweiterung erstellen, bevor Sie sie in Ghidra installieren können:
1. **Voraussetzungen**:
- Ghidra 12.0.3 installiert
- Java 21
2. **Option 1: Verwendung der automatisierten Build-Skripte**:
- 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: Manueller Build-Prozess**:
- Erstellen/Aktualisieren Sie `OGhidraMCP/gradle.properties` mit Ihrem Ghidra-Installationspfad:
```properties
GHIDRA_INSTALL_DIR=/absolute/path/to/ghidra_12.0.3_PUBLIC
```
- On Unix/Linux/macOS:
```bash
cd OGhidraMCP
$GHIDRA_INSTALL_DIR/support/gradle/gradlew buildExtension --info
```
- On Windows:
```bat
cd OGhidraMCP
"%GHIDRA_INSTALL_DIR%\support\gradle\gradlew.bat" buildExtension --info
```
4. **Die erstellte Erweiterung finden**:
- Die ZIP-Datei der Erweiterung wird in `OGhidraMCP/dist/` erstellt
- The filename will be something like `ghidra_12.0.3_PUBLIC_YYYYMMDD_OGhidraMCP.zip`
#### Installieren der GhidraMCP-Erweiterung
Sobald Sie die Erweiterung erfolgreich erstellt haben:
1. **In Ghidra installieren**:
- Öffnen Sie Ghidra -> **Datei** -> **Erweiterungen installieren**
- Klicken Sie auf **Erweiterung hinzufügen** (grünes Plus-Symbol)
- Navigieren Sie zu Ihrem `OGhidraMCP/dist/`-Verzeichnis
- Wählen Sie die neu erstellte Erweiterungs-ZIP-Datei (z. B. `ghidra_12.0.3_PUBLIC_YYYYMMDD_OGhidraMCP.zip`)
- Starten Sie Ghidra neu
2. **Das Plugin aktivieren**:
- Öffnen Sie ein Ghidra-Projekt
- **Datei** → **Konfigurieren** → **Entwickler aktivieren**
- Aktivieren Sie das Plugin `OGhidraMCP`
- Der Server wird unter `http://localhost:8080/methods` gestartet
> **SIE MÜSSEN DEN CODE-BROWSER GEÖFFNET HABEN**
### KI-Modelle herunterladen
```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
```
### OGhidra starten
```bash
# GUI Mode (recommended)
uv run main.py --ui
# Interactive CLI
uv run main.py --interactive
# In interactive CLI, test connection
health
```
Wenn Sie den GUI-Modus gestartet haben, verwenden Sie:
```bash
curl http://localhost:8080/methods
```
---
## Konfiguration
Bearbeiten Sie `.env`, um Ihren KI-Anbieter zu konfigurieren:
### Option 1: Lokale Modelle (Ollama)
```env
LLM_PROVIDER=ollama
OLLAMA_BASE_URL=http://localhost:11434/
OLLAMA_MODEL=gemma3:27b
OLLAMA_EMBEDDING_MODEL=nomic-embed-text
```
### Option 2: Externe APIs
```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: Benutzerdefinierte OpenAI-kompatible API
```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
```
### Einstellungen für das Kontextmanagement
Passen Sie die Einstellungen an das Kontextfenster Ihres Modells an:
```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
```
---
## Hauptfunktionen
### 1. Intelligente Werkzeug-Schaltflächen (GUI)
Ein-Klick-Zugriff auf häufige Reverse-Engineering-Aufgaben:
| Werkzeug | Beschreibung |
| ----------------------------------- | ------------------------------------------------------ |
| **Aktuelle Funktion analysieren** | Tiefgehende Analyse des Verhaltens der ausgewählten Funktion |
| **Aktuelle Funktion umbenennen** | KI schlägt aussagekräftige Namen basierend auf der Analyse vor |
| **Alle Funktionen umbenennen** | Massenumbenennung mit Optionen „Intelligent/Vollständig/Nur umbenennen“ |
| **Importe analysieren** | Identifizieren von Bibliotheken und externen Abhängigkeiten |
| **Strings analysieren** | Finden von URLs, Anmeldeinformationen, Konfigurationsdaten |
| **Bericht generieren** | Umfassende Sicherheitsbewertung |
### 2. Aufgabenmodi
Legen Sie spezialisierte Analyseziele fest:
```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. Erkennung von Malware-Mustern
Automatische Erkennung von über 12 Malware-Mustern:
- **Umgehung**: PEB-Walking, Dynamische API-Auflösung, Anti-Debug, Anti-VM
- **Injektion**: Prozessinjektion (Lokal/Remote)
- **Persistenz**: Registrierung, Dateisystem-Hooks
- **Verschleierung**: String-Kodierung, API-Hashing
- **Privilegienerweiterung**: Token-Manipulation, UAC-Umgehung
Muster lösen automatische Warnungen im KI-Kontext mit MITRE ATT&CK-Zuordnungen aus.
### 4. Intelligente Aufzählung
Erstellen Sie reichhaltiges, abfragbares Wissen aus der Binäranalyse:
```
# 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
```
Funktionen:
- Strukturierte Metadatenextraktion (LOC, Komplexität, Operationen)
- Optimierung der semantischen Suche
- Absichtsbasierte Kontexterstellung
- Multi-Vektor-Unterstützung für präzisen Abruf
### 5. Sitzungsverwaltung
Analysesitzungen speichern und wiederherstellen:
```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
```
---
## Backend-Einrichtung
OGhidra unterstützt zwei Backend-Typen:
- **MCP** – Integriert mit dem GhidraMCP-Server und erfordert, dass der Ghidra-Client während der Analyse läuft
- **PyGhidra** – Unterstützt headless-Analyse ohne den Ghidra-Client und entfernt die von MCP benötigte Serverkomponente
### Auswählen eines Backends
Verwenden Sie die folgende Befehlszeilenoption, um ein Backend auszuwählen:
```bash
--ghidra-backend={http,pyghidra}
```
| Backend-Option | Beschreibung |
|----------------|-------------------------------------------|
| `http` | Verwendet das GhidraMCP-Backend |
| `pyghidra` | Verwendet das PyGhidra-Backend |
---
## PyGhidra-Konfiguration
### Verwenden eines bestehenden Ghidra-Projekts
Geben Sie beim Starten von OGhidra eine Ghidra-Projektdatei (`.gpr`) an:
```bash
--pyghidra-project=/path/to/project.gpr
```
PyGhidra benötigt ein gültiges Ghidra-Projekt, um OGhidra zu starten.
---
### Auswählen eines Programms
Geben Sie an, welche Binärdatei im Ghidra-Projekt analysiert werden soll:
```bash
--pyghidra-program=<program_name>
```
Beispielaufruf zum Auswählen eines Programms in einem Ghidra-Projekt:
```bash
uv run main.py --ui --ghidra-backend=pyghidra --pyghidra-project=/path/to/project.gpr --pyghidra-program=<program_name>
```
Anforderungen:
- Der Programmname muss exakt mit dem Namen übereinstimmen, der in der Ghidra-Projekt-GUI angezeigt wird
- Diese Option ist erforderlich, wenn Sie ein bestehendes Projekt verwenden
- Wenn Sie kein Programm angeben, wird OGhidra nicht gestartet
---
### Direktes Starten einer Binärdatei
Sie können auch direkt einen Binärpfad angeben:
```bash
--pyghidra-binary=/path/to/binary
```
Wenn diese Option verwendet wird, führt PyGhidra automatisch Folgendes aus:
1. Erstellt ein neues Ghidra-Projekt (`.gpr`)
2. Importiert die Binärdatei
3. Startet die Binärdatei in OGhidra zur Analyse
Beispielaufruf zum direkten Starten einer Binärdatei:
uv run main.py --ui --ghidra-backend=pyghidra --pyghidra-binary=/path/to/binary
---
## Häufige Workflows
### Analysieren einer verdächtigen Binärdatei
1. **Binärdatei in Ghidra laden** und im CodeBrowser öffnen
2. **OGhidraMCP-Plugin aktivieren** (Datei → Konfigurieren)
3. **OGhidra starten**: `uv run main.py --ui`
4. **Aufgabenmodus einstellen**: „malware“ aus dem Dropdown auswählen
5. **Intelligente Aufzählung ausführen**: Klicken Sie auf „Alle Funktionen umbenennen“ → „Intelligente Aufzählung“
6. **Fragen stellen**: „Welche Funktionen sind risikoreich?“ oder „Zeige mir die Netzwerkkommunikation“
### Sicherheitsbericht generieren
```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
```
### Bestimmte Funktion untersuchen
1. **Zur Funktion in Ghidra navigieren**
2. **Auf „Aktuelle Funktion analysieren“ klicken**
3. **Nachfolgende Fragen stellen**:
- „Was macht diese Funktion?“
- „Ist diese anfällig für Pufferüberlauf?“
- „Welche anderen Funktionen rufen diese auf?“
---
## Erweiterte Funktionen
### RAG (Retrieval-Augmented Generation)
OGhidra verwendet Vektoreinbettungen für die semantische Suche über analysierte Funktionen:
```env
# Enable in .env
RESULT_CACHE_ENABLED=true
TIERED_CONTEXT_ENABLED=true
```
Vorteile:
- Frühere Analysen über Sitzungen hinweg merken
- Ähnliche Funktionen semantisch finden
- Redundante LLM-Aufrufe reduzieren
### Kontextoptimierung
Mehrstufige Kontextkomprimierung bewahrt relevante Informationen:
```env
CURRENT_LOOP_MAX_CHARS=2000 # Recent: full detail
PREV_LOOP_MAX_CHARS=400 # Previous: summaries
OLDER_LOOP_MAX_CHARS=100 # Older: references only
```
### LLM-Protokollierung
Alle KI-Interaktionen zum Debuggen verfolgen:
```env
LLM_LOGGING_ENABLED=true
LLM_LOG_FILE=logs/llm_interactions.log
LLM_LOG_FORMAT=json
```
---
## Fehlerbehebung
### Ghidra-Verbindungsprobleme
```bash
# Verify plugin is loaded
# Open up codebrowser!
# Check server is running
curl http://localhost:8080/methods
```
### Ollama-Verbindungsprobleme
```bash
# Verify Ollama is running
ollama list
# Check connectivity
curl http://localhost:11434/api/tags
# Restart Ollama service
ollama serve
```
### Leere Antworten / Kontextüberlauf
```env
# Reduce context budget
CONTEXT_BUDGET=50000
# Enable compaction
COMPACTION_ENABLED=true
COMPACTION_THRESHOLD=0.75
```
### Langsame Leistung
1. **Kleinere Modelle verwenden**: Wechseln Sie zu `gemma3:9b`
2. **Parallele Arbeiter reduzieren**: Setzen Sie `max_workers=2` in Massenvorgängen
3. **Vektoreinbettungen deaktivieren**: `RESULT_CACHE_ENABLED=false`
4. **Anforderungsverzögerung erhöhen**: `CUSTOM_API_REQUEST_DELAY=2.0`
---
## Architekturüberblick
```
┌─────────────────────────────────────────────────────────────┐
│ 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 │ │
│ └────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
```
---
## Mitwirken
Wir freuen uns über Beiträge! Interessengebiete:
- **Neue Malware-Muster** zur Erkennung
- **Integration von LLM-Anbietern**
- **UI/UX-Verbesserungen**
- **Leistungsoptimierungen**
- **Dokumentation** und Beispiele
Siehe [CODE_OF_CONDUCT.md](https://github.com/llnl/oghidra/blob/main/CODE_OF_CONDUCT.md) für die Richtlinien der Gemeinschaft.
---
## Zitation
Wenn Sie OGhidra in Ihrer Forschung verwenden, zitieren Sie bitte:
```bibtex
@software{oghidra2025,
title = {OGhidra: AI-Powered Reverse Engineering with Ghidra},
author = {Enoch Wang},
year = {2025},
url = {https://github.com/LLNL/OGhidra}
}
```
---
## Danksagungen
OGhidra baut auf hervorragenden Open-Source-Projekten auf:
- **[Ghidra](https://github.com/NationalSecurityAgency/ghidra)** – NSAs Reverse-Engineering-Plattform
- **[Ollama](https://ollama.com/)** – Lokale LLM-Laufzeitumgebung
- **[LaurieWired/GhidraMCP](https://github.com/LaurieWired/GhidraMCP)** – Ursprüngliches Ghidra-MCP-Plugin
- **[starsong/GhydraMCP](https://github.com/starsong/GhydraMCP)** – Verbesserte MCP-Implementierung
---
## Lizenz
OGhidra wird unter den Bedingungen der BSD-3-Clause-Lizenz mit einer Alternativlizenz für kommerzielle Nutzung vertrieben.
Details finden Sie in [LICENSE](https://github.com/llnl/oghidra/blob/main/LICENSE) und [NOTICE.md](https://github.com/llnl/oghidra/blob/main/NOTICE.md).
**LLNL-CODE-2013290**
---
## Support
- **Probleme**: [GitHub Issues](https://github.com/LLNL/OGhidra/issues)
- **Diskussionen**: [GitHub Discussions](https://github.com/LLNL/OGhidra/discussions)
- **E-Mail direkt an mich**: [email protected]