[Kein Inhalt zur Übersetzung bereitgestellt.]   ```bash
# Secondary/manual Gradle build path only (not used by tools.setup or VS Code tasks)
GHIDRA_INSTALL_DIR=/path/to/ghidra gradle buildExtension

### Grundlegende Verwendung

#### Option 1: Stdio-Transport (Empfohlen für KI-Tools)```bash
uv run bridge-mcp-ghidra          # or: python -m bridge_mcp_ghidra

Füge `--scope project` vor `ghidra` hinzu, um den Server in der `.autohand`-Konfiguration des aktuellen Projekts statt in deiner Benutzerkonfiguration zu speichern.

#### Option 2: Streamable HTTP Transport (Empfohlen für Web/HTTP-Clients)```bash
uv run bridge-mcp-ghidra --transport streamable-http --mcp-host 127.0.0.1 --mcp-port 8081

Browserbasierte Clients (z.B. [MCP Inspector](https://github.com/modelcontextprotocol/inspector))
funktionieren sofort einsatzbereit: die HTTP-Transports antworten auf CORS-Preflight-Anfragen (`OPTIONS`) und legen die `mcp-session-id` / `mcp-protocol-version`-Header für Skripte offen. Erlaubte Ursprünge spiegeln die Host-Header-Richtlinie wider — Loopback auf jedem Port ist immer erlaubt, zusätzlich der Bind-Host und alle Hosts, die in `GHIDRA_MCP_ALLOWED_HOSTS` aufgeführt sind.

#### Option 3: SSE Transport (Veraltet — stattdessen streamable-http verwenden)```bash
uv run bridge-mcp-ghidra --transport sse --mcp-host 127.0.0.1 --mcp-port 8081

Ohne dies führt ein Aufruf, der `program=` auslässt, gegen das jeweils aktuelle Programm aus, was für einen Single-Program-Workflow in Ordnung ist, aber eine Gefahr darstellt, sobald mehrere Programme geöffnet sind: Der Aufruf kann das falsche Binary lesen oder bearbeiten, ohne Fehlermeldung. Die Gefahr ist noch größer, wenn mehrere Clients einen Server teilen, da jeder die globale Variable des aktuellen Programms aus dem Blickfeld der anderen verschiebt.

Im strikten Modus muss jeder programmbezogene Aufruf sein Ziel benennen. Dies umfasst jeden Selektor, der ein geöffnetes Programm auswählt: einfaches `program=` und die Cross-Program-Tools' `source_program`/`target_program` oder `program_a`/`program_b` (als erforderlich deklariert, aber der Server fällt immer noch auf das aktuelle Programm zurück, wenn eines leer ankommt). Ein vergessener Selektor zeigt sich als lauter Fehler beim ersten falschen Aufruf, statt eines stillen Schreibens in das falsche Binary. Tools ohne Programmselektor (`open_program` und `close_program` nehmen `path`/`name`) sind nicht betroffen. Standardmäßig deaktiviert: Mit nicht gesetzter Variable sendet die Bridge Aufrufe unverändert.

#### Reduzieren des Tool-Kontext-Overheads

Die Bridge stellt einen großen Katalog bereit. Um die Tool-Oberfläche des Modells klein zu halten, führen Sie es mit `--lazy` aus (lädt nur `listing,function,program` beim Verbinden) und lassen Sie das Modell den Rest bei Bedarf **entdecken**, anstatt alles zu registrieren:

- `search_tools("rename function")` — Stichwortsuche im **gesamten** Katalog, einschließlich Tools, deren Gruppe nicht geladen ist. Jedes Ergebnis gibt an, ob es jetzt aufrufbar ist und wenn nicht, den genauen `load_tool_group(...)`-Aufruf, um es zu aktivieren.
- `list_tool_groups()` — Alle Kategorien und deren Ladestatus auflisten.
- `load_tool_group("datatype")` / `unload_tool_group("datatype")` — Eine Kategorie zur Laufzeit laden oder fallen lassen.
- `check_tools("rename_or_label,batch_set_comments")` — Bestätigen, dass bestimmte Tools sofort aufrufbar sind.

`search_tools` funktioniert sowohl im eager- als auch im `--lazy`-Modus, sodass Agents, die `tools/list_changed` beachten, die vollständige Entdeckung ohne die anfänglichen Kontextkosten erhalten.

#### Optional: Starten des eigenständigen Debugger-Servers```bash
uv sync --group debugger
uv run python -m debugger

## Dieses Projekt unterstützen

Wenn Ghidra MCP Ihnen Entwicklungs- oder Reverse-Engineering-Zeit spart, erwägen Sie, [das Projekt zu sponsern](https://github.com/sponsors/bethington).

- Einmalige Sponsoring-Beiträge helfen, Fehlerbehebungen, Kompatibilitätsupdates und Veröffentlichungsarbeiten zu finanzieren.
- Wiederkehrende Sponsoring-Beiträge halten Wartung, Dokumentation und Produktionshärtung in Gang.
- Unternehmensunterstützung hilft, die langfristige Zuverlässigkeit der Brücke, des Headless-Servers, der Debugger-Integration und der Workflow-Tools zu priorisieren.

## 🔒 Sicherheit

GhidraMCP ist für die **Entwicklung nur auf localhost** ausgelegt. Die Standardkonfiguration — HTTP-Server gebunden an `127.0.0.1`, keine Authentifizierung — ist auf einem vertrauenswürdigen Einzelbenutzer-Arbeitsplatz sicher und entspricht dem Verhalten vor v5.4.1.

**Wenn Sie den Server über Loopback hinaus zugänglich machen, konfigurieren Sie zuerst diese drei Umgebungsvariablen.** Der Server startet nicht auf einer Nicht-Loopback-Bindung ohne Token.

| Env var | Wirkung |
|---|---|
| `GHIDRA_MCP_AUTH_TOKEN` | Wenn gesetzt, muss jede HTTP-Anfrage `Authorization: Bearer <token>` enthalten. Zeit-sicherer Vergleich. `/mcp/health`, `/health`, `/check_connection` sind ausgenommen. |
| `GHIDRA_MCP_ALLOW_SCRIPTS` | Setzen Sie es auf `1`, `true` oder `yes`, um `/run_script_inline` und `/run_ghidra_script` zu aktivieren. **Standardmäßig deaktiviert ab v5.4.1** — diese Endpunkte führen beliebiges Java gegen den Ghidra-Prozess aus. Im Headless-Modus löst dies beim Serverstart auch die OSGi `BundleHost`-Initialisierung aus (Felix-Framework, ~Hunderte ms); lassen Sie es deaktiviert, wenn Sie keine Skriptausführung benötigen. |
| `GHIDRA_MCP_FILE_ROOT` | Wenn auf einen Verzeichnispfad gesetzt, kanonisieren Dateisystempfad-Endpunkte (`/load_program`, `/import_file`, `/open_project`, `/delete_file`, etc.) die Eingabe und verlangen, dass sie unter diesem Root liegt. Verhindert Path-Traversal. |

Namensqualitätsdurchsetzung ist getrennt von der Sicherheit. Standardmäßig lehnen `rename_function_by_address` und globale Schreibendpunkte Namen ab, die die eingebauten Qualitätsgatter nicht bestehen, und Strukturfeld-Schreibvorgänge wenden die eingebaute Feld-Präfixkonvention an. Deaktivieren Sie die eingebaute Konventionsebene unter **Edit > Tool Options > GhidraMCP HTTP Server > Strict Naming Enforcement**. Dieselbe Tool Options-Checkbox deckt `rename_data`, `rename_global_variable`, `set_global`, den `apply_data_type`-Präfix/Typ-Schutz und automatische Korrekturen des ungarischen Präfixes für Strukturfelder in `create_struct`, `add_struct_field` und `modify_struct_field` ab. Die Einstellung wird beim Start oder Neustart des MCP-Servers gelesen. Funktions-/Global-Konventionswarnungen werden weiterhin zurückgegeben, wenn die Durchsetzung deaktiviert ist.

### Beispiel: Freigabe in einem privaten LAN mit Authentifizierung

export GHIDRA_MCP_AUTH_TOKEN=$(openssl rand -hex 32)
export GHIDRA_MCP_ALLOW_SCRIPTS=1     # only if your workflow needs it
export GHIDRA_MCP_FILE_ROOT=/srv/ghidra/inputs

java -jar GhidraMCPHeadless.jar --bind 0.0.0.0 --port 8089
```
### Ghidra Server-Authentifizierung

Beim Verbinden mit einem gemeinsam genutzten Ghidra-Server kann GhidraMCP den Passwortdialog automatisch unterdrücken. Die Anmeldeinformationen werden in dieser Reihenfolge aufgelöst (der erste nicht-leere Wert gewinnt):

Kompatibilitätshinweis: Ghidra 12.1.2-Clients benötigen Ghidra Server 12.1.2,
12.0.5 oder einen neueren kompatiblen Server. Ältere gemeinsam genutzte Server sind keine sicheren Ziele für ein Upgrade auf Client 12.1.

1. Umgebungsvariable `GHIDRA_SERVER_PASSWORD` (oder `.env`-Datei im Ghidra-Installationsverzeichnis oder `~`)
2. `~/.ghidra-cred` — einzeilige Passwortdatei in Ihrem Home-Verzeichnis
3. `<ghidra-install-dir>/.ghidra-cred`

Der Benutzername wird ähnlich aufgelöst: Umgebungsvariable `GHIDRA_SERVER_USER` → Systemeigenschaft `user.name`.

Wenn kein Passwort gefunden wird, zeigt Ghidra die normale GUI-Eingabeaufforderung an. Setzen Sie diese Werte in `.env` (siehe `.env.template` für den vollständigen Block), um eine stille Authentifizierung zu ermöglichen.

### Migration von v5.4.0 → v5.4.1

- **Skript-Endpunkte sind jetzt standardmäßig deaktiviert.** Wenn Sie auf `/run_script_inline` oder `/run_ghidra_script` angewiesen waren, exportieren Sie `GHIDRA_MCP_ALLOW_SCRIPTS=1`. Dies ist eine bewusste breaking change; die vorherige Voreinstellung war unsicher.
- **Nur-Localhost-Bereitstellungen benötigen keine Änderungen.** Authentifizierung, Bind-Verweigerung und Pfad-Wurzel-Prüfungen sind allesamt optional.

## ❓ Fehlerbehebung

### Menü "GhidraMCP" wird nicht in den Tools angezeigt

**Ursache:** Plugin nicht aktiviert oder falsch installiert.

**Lösung:**
1. Überprüfen Sie, ob die Erweiterung installiert ist: **Datei > Erweiterungen installieren** — GhidraMCP sollte aufgeführt sein
2. Aktivieren Sie das Plugin: **Datei > Konfigurieren > Alle Plugins konfigurieren > GhidraMCP** (Kästchen ankreuzen)
3. **Starten Sie Ghidra neu** nach der Installation/Aktivierung

### Server antwortet nicht / Verbindung abgelehnt

**Ursache:** Server nicht gestartet oder falscher Port.

**Lösung:**
1. Stellen Sie sicher, dass Sie den Server gestartet haben: **Tools > GhidraMCP > MCP-Server starten**
2. Überprüfen Sie den konfigurierten Port: **Bearbeiten > Tool-Optionen > GhidraMCP HTTP-Server**
3. Überprüfen Sie, ob der Port belegt ist:   ```bash
   # Linux/macOS
   lsof -i :8089
   # Windows
   netstat -ano | findstr :8089
   ```
4. Suche nach Fehlern in der Ghidra-Konsole: **Window > Console**

### `pip install` schlägt fehl mit `error: externally-managed-environment`

**Ursache:** PEP 668. Debian-basierte Distributionen (Debian 12+, Kali, Ubuntu 23.04+)
markieren das systemweite Python als extern verwaltet, sodass eine globale
`pip install` blockiert wird, um apt-verwaltete Pakete zu schützen.

**Lösung:** Verwende eine virtuelle Umgebung – niemals `--break-system-packages`.
Der empfohlene Weg ist [uv](https://docs.astral.sh/uv/), das automatisch ein
projektlokales `.venv` verwaltet:```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
cd ghidra-mcp
uv run bridge-mcp-ghidra
```
Oder ein klassisches venv:```bash
python3 -m venv .venv && source .venv/bin/activate
pip install -e .
bridge-mcp-ghidra
```
### `python -m debugger` schlägt fehl mit `ModuleNotFoundError` für `pybag` oder `comtypes`

**Ursache:** Der eigenständige Debugger-Server verwendet optionale, nur für Windows verfügbare Python-Abhängigkeiten, die standardmäßig nicht installiert sind.

**Lösung:**```text
uv sync --group debugger
uv run python -m debugger
```
Wenn Sie sowohl ein globales Python als auch ein Projekt-Venv haben, stellen Sie sicher, dass Sie in denselben Interpreter installieren und daraus ausführen.

### 500 Internal Server Errors

**Ursache:** Serverseitige Ausnahme, oft aufgrund fehlender Programmdaten.

**Lösung:**
1. Stellen Sie sicher, dass eine Binärdatei im CodeBrowser geladen ist
2. Führen Sie zuerst die Auto-Analyse durch: **Analysis > Auto Analyze**
3. Überprüfen Sie die Ghidra-Konsole (**Window > Console**) auf Java-Ausnahmen
4. Einige Operationen erfordern vollständig analysierte Binärdateien

### 404 Not Found Errors

**Ursache:** Endpunkt existiert nicht oder falsche URL.

**Lösung:**
1. Überprüfen Sie, ob der Endpunkt existiert: `curl http://127.0.0.1:8089/get_version`
2. Überprüfen Sie auf Tippfehler im Endpunktnamen
3. Stellen Sie sicher, dass Sie die richtige HTTP-Methode verwenden (GET vs POST)

### Python Ghidra scripts fail with "No script provider found"

**Ursache:** In Ghidra 12.1.2 ist die Jython-Unterstützung standardmäßig nicht mehr aktiviert. `.py`-Skripte benötigen die gebündelte Jython-Erweiterung; Python-3-Skripte sollten stattdessen PyGhidra anstelle des Ghidra-Skript-Managers verwenden.

**Lösung:**
1. Öffnen Sie in der Ghidra-Oberfläche **File > Install Extensions**.
2. Aktivieren Sie **Jython**, starten Sie Ghidra neu und aktualisieren Sie dann den Skript-Manager.
3. Bevorzugen Sie für neue Automatisierungen Java-Ghidra-Skripte oder PyGhidra.

### Extension not appearing in Install Extensions

**Ursache:** JAR-Datei am falschen Ort.

**Lösung:**
1. Manueller Installationspfad: `~/.ghidra/ghidra_12.1.2_PUBLIC/Extensions/GhidraMCP/lib/GhidraMCP.jar`
2. Oder verwenden Sie: **File > Install Extensions > Add** und wählen Sie die ZIP-Datei
3. Stellen Sie sicher, dass JAR/ZIP für Ihre Ghidra-Version erstellt wurde

### Build fails with "Ghidra dependencies not found"

**Ursache:** Ghidra-JARs sind nicht im lokalen Maven-Repository installiert.

**Lösung:**```text
# Windows (recommended)
python -m tools.setup install-ghidra-deps --ghidra-path "C:\ghidra_12.1.2_PUBLIC"
```
## 📊 Produktionsleistung

- **MCP-Werkzeuge**: 271 Werkzeuge vollständig implementiert
- **Geschwindigkeit**: Antwort unter einer Sekunde für die meisten Vorgänge
- **Effizienz**: 93 % Reduzierung der API-Aufrufe durch Batch-Vorgänge
- **Zuverlässigkeit**: Atomare Transaktionen mit Alles-oder-Nichts-Semantik
- **KI-Workflows**: Bewährte Dokumentationsaufforderungen, verfeinert über hunderte reale Funktionen
- **Bereitstellung**: Automatisiertes versionsbewusstes Bereitstellungsskript

## 🛠️ API-Referenz

<!-- BEGIN GENERATED API REFERENCE (tools/gen_readme_api_reference.py) -->

271 MCP-Werkzeuge, unterstützt durch HTTP-Endpunkte, gruppiert nach Katalogkategorie. Generiert aus [tests/endpoints.json](https://github.com/bethington/ghidra-mcp/blob/HEAD/tests/endpoints.json) von `python -m tools.gen_readme_api_reference --write`; das Live-Schema unter `/mcp/schema` ist zur Laufzeit maßgeblich. Nutzungsmuster: [docs/prompts/TOOL_USAGE_GUIDE.md](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/prompts/TOOL_USAGE_GUIDE.md).

### Programm- und Sitzungsverwaltung

- `analysis_status` – Status der automatischen Analyse für offene Programme abrufen
- `close_program` – Ein offenes Programm nach Projektpfad oder -namen schließen
- `create_property_map` – Eine benutzerdefinierte Property-Map erstellen, um getypte Werte, die an Adressen gebunden sind, zu speichern
- `delete_property_map` – Eine benutzerdefinierte Property-Map und alle darin enthaltenen Werte löschen
- `exit_ghidra` – Ghidra speichern und beenden
- `get_address_spaces` – Alle physischen und Overlay-Adressräume im Programm auflisten (Overlays enthalten is_overlay-Flag und overlayed_space-Name)
- `get_current_program_info` – Aktuelle Programminformationen abrufen
- `get_language_metadata` – Die Sprachbeschreibung des Programms ausgeben: Adressräume, Register, Standardsymbole, Endianness, Zeigergröße (Issue #192)
- `get_program_options` – Alle Optionen in einer Programmoptionsgruppe mit Typen, aktuellen Werten, Standardwerten und Beschreibungen lesen
- `get_property` – Den an einer Adresse in einer Property-Map gespeicherten Wert lesen
- `import_file` – Eine Binärdatei von der Festplatte in das aktuelle Ghidra-Projekt importieren und öffnen
- `list_open_programs` – Offene Programme auflisten
- `list_option_groups` – Programmoptionsgruppen auflisten (z. B.
- `list_project_files` – Projektdateien auflisten
- `list_properties` – In einer Property-Map gespeicherte (Adresse, Wert)-Einträge mit Paginierung auflisten
- `list_property_maps` – Benutzerdefinierte Property-Maps auflisten – getypte, adressbezogene Schlüssel→Wert-Speicher
- `open_program` – Programm aus dem Projekt öffnen
- `reanalyze` – Vollständige Auto-Analyse für ein Programm auslösen
- `remove_program_option` – Eine Option aus einer Programmoptionsgruppe entfernen
- `remove_property` – Den an einer einzelnen Adresse in einer Property-Map gespeicherten Wert entfernen
- `save_all_programs` – Alle offenen Programme speichern
- `save_program` – Aktuelles Programm speichern
- `set_image_base` – Die Basisadresse des Programms setzen (alle Adressen werden neu basiert)
- `set_program_option` – Eine getypte Programmoption setzen
- `set_property` – Einen Wert an einer Adresse in einer Property-Map setzen
- `switch_program` – Aktuelles Programm wechseln

### Projektorganisation

- `create_folder` – Einen Ordner im Projekt erstellen
- `delete_file` – Eine Datei aus dem Projekt löschen
- `delete_project` – Ein Ghidra-Projekt löschen
- `list_projects` – Verfügbare Ghidra-Projekte auflisten
- `move_file` – Eine Datei in einen anderen Projektordner verschieben
- `move_folder` – Einen Ordner an eine andere Position verschieben
- `project_info` – Detaillierte Projektinformationen einschließlich laufender Tools und offener Programme abrufen

### Headless-Projekt- und Programmlebenszyklus

Verfügbar auf dem eigenständigen Headless-Server (`GhidraMCPHeadlessServer`).

- `archive_project` – Das aktuell geöffnete Projekt in eine Ghidra-native .gar-Datei archivieren
- `checkin_program` – Ein offenes Programm als neue Version in den gemeinsamen Ghidra-Server einchecken
- `close_project` – Das aktuell geöffnete Projekt schließen
- `create_project` – Ein neues Ghidra-Projekt erstellen
- `export_program` – Ein offenes oder im Projekt befindliches Programm in eine Ghidra-Zip-Datei (.gzf) exportieren
- `get_project_info` – Informationen über das aktuell geöffnete Projekt abrufen
- `import_program` – Eine Ghidra-Zip-Datei (.gzf) als neue DomainFile unter target_folder (Standard '/') in das aktuell geöffnete Projekt importieren
- `load_program` – Eine Binärdatei zur Analyse in den Headless-Server laden
- `load_program_from_project` – Programm aus Ghidra-Projekt laden (headless)
- `open_project` – Ein vorhandenes Ghidra-Projekt öffnen (.gpr-Datei oder Verzeichnis)
- `restore_project` – Ein Ghidra-.gar-Archiv in ein neues Projekt auf der Festplatte unter `parent_dir/project_name` wiederherstellen
- `server_status` – Verbindungsstatus des Headless-Servers prüfen

### Auflistung und Aufzählung

- `list_bookmarks` – Lesezeichen auflisten
- `list_calling_conventions` – Verfügbare Aufrufkonventionen auflisten
- `list_classes` – Namespace-/Klassennamen auflisten
- `list_data_items` – Definierte Daten auflisten
- `list_data_items_by_xrefs` – Daten sortiert nach Querverweisanzahl auflisten
- `list_exports` – Exportierte Symbole auflisten
- `list_external_locations` – Externe Positionen auflisten
- `list_functions` – Funktionen mit Adressen auflisten
- `list_functions_enhanced` – Funktionen mit Metadaten auflisten
- `list_globals` – Globale Variablen auflisten
- `list_imports` – Importierte Symbole auflisten
- `list_methods` – Alle Funktionsnamen mit Paginierung auflisten
- `list_namespaces` – Alle Namespaces auflisten
- `list_scripts` – Verfügbare Ghidra-Skripte auflisten
- `list_segments` – Speichersegmente auflisten
- `list_strings` – Definierte Zeichenketten auflisten

### Kontext und Nachschlagen

- `get_current_address` – Cursor-Adresse abrufen (nur GUI)
- `get_current_function` – Funktion am Cursor abrufen (nur GUI)
- `get_current_selection` – Markierte Adressbereiche in der CodeBrowser-Auflistung abrufen (nur GUI)
- `get_entry_points` – Programmeinstiegspunkte abrufen
- `get_enum_values` – Aufzählungswerte abrufen
- `get_external_location` – Details zur externen Position abrufen
- `get_full_call_graph` – Vollständigen Aufrufgraphen abrufen
- `get_function_by_address` – Funktion an Adresse abrufen
- `get_function_call_graph` – Aufrufgraphen abrufen
- `get_function_callees` – Aufgerufene Funktionen abrufen
- `get_function_callers` – Aufrufende Funktionen abrufen
- `get_function_count` – Anzahl der Funktionen im geladenen Programm zurückgeben
- `get_function_jump_targets` – Sprungziele abrufen
- `get_function_labels` – Beschriftungen in der Funktion abrufen
- `get_function_variables` – Alle Variablen in einer Funktion auflisten
- `get_struct_layout` – Strukturlayout abrufen
- `get_valid_data_types` – Gültige Datentypnamen abrufen

### Suche

- `find_similar_functions` – Ähnliche Funktionen finden
- `search_byte_patterns` – Nach Byte-Mustern suchen
- `search_data_types` – Datentypen suchen
- `search_functions` – Funktionen nach Namen suchen
- `search_functions_enhanced` – Erweiterte Funktionssuche
- `search_strings` – Definierte Zeichenketten nach einem Regex-/Teilzeichenfolgemuster durchsuchen

### Dekompilierung und Disassemblierung

- `decompile_function` – Funktion dekompilieren
- `disassemble_bytes` – Byte-Bereich disassemblieren
- `disassemble_function` – Funktion disassemblieren
- `force_decompile` – Erneute Dekompilierung erzwingen

### Funktionstags, Variablen und Attribute

- `add_function_tag` – Ein oder mehrere Tags an eine Funktion anhängen
- `batch_add_function_tags` – Tags in einer Transaktion an viele Funktionen anhängen
- `batch_remove_function_tags` – Tags in einer Transaktion von vielen Funktionen lösen
- `clear_flow_and_repair` – Ghi dra's GUI-Aktion 'Clear Flow and Repair' auf einem Startbereich ausführen: löscht den vom Start erreichbaren Anweisungsfluss, repariert dann Funktionskörper und disassembliert den beibehaltenen Fluss neu (ClearFlowAndRepairCmd mit clear_data=false, clear_labels=false, repair=true)
- `create_function_tag` – Eine programmweite Funktions-Tag-Definition mit optionalem Kommentar erstellen
- `delete_function_tag` – Eine programmweite Funktions-Tag-Definition löschen
- `get_function_tags` – Alle Tags auflisten, die einer bestimmten Funktion zugewiesen sind
- `list_class_members` – Die Member-Funktionen einer C++-Klasse auflisten
- `list_function_tags` – Alle programmweiten Funktions-Tag-Definitionen mit ihren Nutzungszahlen auflisten
- `remove_function_tag` – Ein oder mehrere Tags von einer Funktion lösen
- `search_functions_by_tag` – Alle Funktionen auflisten, die ein bestimmtes Tag angehängt haben
- `set_decompiler_variable_type` – Einen Dekompiler-Variablen- oder Parametertyp (High-Level) nach Namen setzen
- `set_function_no_return` – No-Return-Attribut setzen
- `set_function_tag_comment` – Den Kommentar/die Beschreibung einer vorhandenen programmweiten Funktions-Tag-Definition aktualisieren
- `set_function_this_type` – Den Dekompiler-/Datenbanktyp des impliziten 'this'-Zeigers setzen (ECX auf x86 __thiscall/__fastcall)
- `set_variables` – Typen und Namen für mehrere Variablen atomar setzen

### Querverweise

- `add_memory_reference` – Einen benutzerdefinierten Querverweis zwischen zwei Speicheradressen erstellen, den der Auto-Analyzer nicht ableiten kann (zur Laufzeit gefüllte Zeigertabellen, V-Tabellen, spät gebundene Funktionszeiger, verpasste Sprung-/Switch-Tabellen)
- `get_bulk_xrefs` – Querverweise für mehrere Adressen abrufen
- `get_function_xrefs` – Funktionsquerverweise abrufen
- `get_xrefs_from` – Referenzen von einer Adresse abrufen
- `get_xrefs_to` – Referenzen zu einer Adresse abrufen
- `remove_reference` – Speicher-Querverweise von einer Adresse zu einer anderen entfernen – die Umkehrung von add_memory_reference

### Datentypen und Strukturen

- `add_struct_field` – Strukturfeld hinzufügen
- `analyze_global_completeness` – Die Vollständigkeit der Dokumentation einer globalen Variablen auf einer budgetierten 0-100-Skala bewerten – das Datenadress-Äquivalent zu analyze_function_completeness
- `apply_data_type` – Datentyp anwenden
- `audit_global` – Den Dokumentationszustand einer globalen Variablen prüfen
- `audit_globals_in_function` – Jede globale Variable, auf die innerhalb einer Funktion verwiesen wird, in einem einzigen Aufruf prüfen
- `batch_set_variable_types` – Mehrere Variablentypen setzen
- `clone_data_type` – Datentyp klonen
- `create_array_type` – Array-Typ erstellen
- `create_data_type_category` – Datentypkategorie erstellen
- `create_enum` – Aufzählung erstellen
- `create_function_signature` – Funktionssignaturtyp erstellen
- `create_pointer_type` – Zeigertyp erstellen
- `create_struct` – Struktur erstellen
- `create_typedef` – Typedef erstellen
- `create_union` – Union erstellen
- `delete_data_type` – Datentyp löschen
- `embed_struct_field` – Ein Strukturfeld durch einen eingebetteten Strukturtyp nach Wert ersetzen (z. B.
- `get_data_type_size` – Datentypgröße in Bytes abrufen
- `get_type_size` – Datentypgröße und -informationen abrufen
- `import_data_types` – Datentypen aus GDT importieren
- `list_data_type_categories` – Datentypkategorien auflisten
- `list_data_types` – Datentypen auflisten
- `modify_struct_field` – Strukturfeld ändern
- `modify_struct_field_type` – Den Typ eines Strukturfelds nach Name oder Offset setzen (offset:N)
- `move_data_type_to_category` – Datentyp in Kategorie verschieben
- `recreate_struct` – Eine Struktur in einem Schritt ersetzen: optional einen vorhandenen gleichnamigen Typ entfernen, dann mit Feld-JSON neu erstellen (gleiche Form wie create_struct)
- `remove_struct_field` – Strukturfeld entfernen
- `resize_struct` – Eine vorhandene Struktur um die gesamte Byte-Größe vergrößern oder verkleinern
- `resolve_duplicate_type` – Doppelte Datentypen nach einfachem Namen finden; ungenutzte /Demangler-Größe-1-Stubs löschen, wenn ein größerer kanonischer Typ existiert
- `set_function_prototype` – Funktionsprototyp setzen (Rückgabetyp, Parametertypen, Aufrufkonvention)
- `set_global` – Atomar Name + Typ + Plattenkommentar + Array-Länge auf eine globale Variable anwenden
- `set_local_variable_type` – Variablentyp setzen
- `set_parameter_type` – Parametertyp setzen
- `set_variable_storage` – Variablenspeicher setzen
- `validate_data_type` – Datentyp-Syntax validieren
- `validate_data_type_exists` – Prüfen, ob ein Datentyp existiert
- `validate_function_prototype` – Funktionsprototyp validieren

### Umbenennung und Beschriftungen

- `batch_create_labels` – Mehrere Beschriftungen erstellen
- `batch_delete_labels` – Mehrere Beschriftungen löschen
- `batch_rename_function_components` – Batch-Umbenennung von Funktionskomponenten
- `create_label` – Beschriftung erstellen
- `delete_label` – Beschriftung an Adresse löschen
- `rename_data` – Datensymbol umbenennen
- `rename_external_location` – Externe Position umbenennen
- `rename_function` – Funktion nach Namen umbenennen
- `rename_function_by_address` – Funktion nach Adresse umbenennen
- `rename_global_variable` – Globale Variable umbenennen
- `rename_label` – Beschriftung umbenennen
- `rename_or_label` – Beschriftung umbenennen oder erstellen
- `rename_variable` – Eine Variable in einer Funktion umbenennen
- `rename_variables` – Batch-Umbenennung von Variablen

### Kommentare und Lesezeichen

- `batch_set_comments` – Mehrere Kommentare setzen
- `clear_function_comments` – Alle Kommentare für eine Funktion löschen
- `delete_bookmark` – Lesezeichen löschen
- `get_comment` – Auflistungskommentare (Platte/Pre/EndOfLine/Post/wiederholbar) an JEDER Adresse abrufen, einschließlich Datenadressen (im Gegensatz zu get_plate_comment, das eine Funktion erfordert)
- `get_plate_comment` – Plattenkommentar abrufen
- `set_bookmark` – Lesezeichen setzen
- `set_comment` – Einen Auflistungskommentar einer bestimmten Art (Platte/Pre/EndOfLine/Post/wiederholbar) an JEDER Adresse setzen, einschließlich Datenadressen
- `set_decompiler_comment` – PRE_COMMENT setzen
- `set_disassembly_comment` – EOL_COMMENT setzen
- `set_plate_comment` – Plattenkommentar setzen

### Analyse

- `analyze_api_call_chains` – API-Aufrufketten analysieren
- `analyze_call_graph` – Funktionsaufrufgraphenmuster analysieren
- `analyze_control_flow` – Kontrollfluss analysieren
- `analyze_data_region` – Datenregion analysieren
- `analyze_dataflow` – Werteausbreitung durch eine Funktion verfolgen (PCode-Graph, vorwärts/rückwärts)
- `analyze_for_documentation` – Zusammengesetzte RE-Dokumentationsanalyse (Dekompilieren + Klassifizieren + Variablen + Vollständigkeit)
- `analyze_function_complete` – Umfassende Einzelaufruffunktionsanalyse
- `analyze_function_completeness` – Dokumentationsvollständigkeit analysieren
- `analyze_struct_field_usage` – Strukturfeldnutzung analysieren
- `apply_data_classification` – Datenklassifikation anwenden
- `batch_analyze_completeness` – Batch-Analyse der Vollständigkeit für mehrere Funktionen
- `batch_apply_documentation` – Alle Dokumentation für eine Funktion in einem Aufruf anwenden
- `batch_decompile` – Mehrere Funktionen gleichzeitig dekompilieren
- `can_rename_at_address` – Prüfen, ob eine Adresse umbenannt werden kann
- `clear_instruction_flow_override` – Flussüberschreibung löschen
- `configure_analyzer` – Ein Analyse-Plugin konfigurieren
- `create_function` – Funktion an Adresse erstellen
- `create_memory_block` – Speicherblock erstellen
- `delete_function` – Funktion an Adresse löschen
- `detect_array_bounds` – Array-Grenzen erkennen
- `detect_crypto_constants` – Krypto-Konstanten erkennen
- `detect_malware_behaviors` – Malware-Verhalten erkennen
- `extract_iocs_with_context` – IOCs mit Kontext extrahieren
- `find_anti_analysis_techniques` – Anti-Analyse-Techniken finden
- `find_code_gaps` – Lücken undefinierter Bytes zwischen Funktionen im ausführbaren Speicher finden
- `find_dead_code` – Toten Code finden
- `find_next_undefined_function` – Nächste undefinierte Funktion finden
- `get_assembly_context` – Assemblerkontext abrufen
- `get_field_access_context` – Feldzugriffskontext abrufen
- `get_function_pcode` – Roh-P-Code für eine Funktion ausgeben (Issue #192)
- `inspect_memory_content` – Speicherbytes inspizieren
- `list_analyzers` – Verfügbare Analyse-Plugins auflisten
- `read_memory` – Rohspeicher lesen
- `run_analysis` – Auto-Analyse auf dem aktuellen Programm ausführen
- `search_instructions` – Nach Instruktionen anhand von Mnemonic und/oder Operand-Teilzeichenfolge suchen
- `suggest_field_names` – Feldnamen vorschlagen

### Binärübergreifende Dokumentation und Archiv

- `archive_ingest_function` – Die Dokumentation einer einzelnen Funktion in das versionsübergreifende Archiv aufnehmen (re_kb.functions auf bsim Postgres)
- `archive_ingest_program` – Alle Funktionen eines Programms in das versionsübergreifende Dokumentationsarchiv aufnehmen (Bulk-Import)
- `batch_string_anchor_report` – Bericht über Quellcode-Zeichenketten und deren FUN_*-Funktionen
- `bulk_fuzzy_match` – Binärübergreifender, unscharfer Funktionsabgleich im Bulk
- `find_similar_functions_fuzzy` – Binärübergreifender, unscharfer Funktionsabgleich
- `merge_program_documentation` – Bulk-Zusammenführung: alle RE-Dokumentation (Funktionsnamen, Signaturen, Plattenkommentare, Instruktionskommentare bei EOL/PRE/POST, nicht standardmäßige Beschriftungen und globale Symbole) von einem Programm zu einem anderen an übereinstimmenden Adressen kopieren

### Dienstprogramme und Dokumentationsübertragung

- `apply_function_documentation` – Funktionsdokumentation anwenden
- `check_connection` – Health-Check-Endpunkt
- `compare_programs_documentation` – Dokumentation zwischen Programmen vergleichen
- `convert_number` – Zahl zwischen Basen umwandeln
- `diff_functions` – Zwei Funktionen vergleichen
- `find_undocumented_by_string` – Undokumentierte Funktionen finden, die auf eine Zeichenkette verweisen
- `get_bulk_function_hashes` – Bulk-Funktions-Hashes abrufen
- `get_function_documentation` – Funktionsdokumentation exportieren
- `get_function_hash` – Funktions-Hash abrufen
- `get_function_signature` – Funktionsmerkmalsignatur abrufen
- `get_metadata` – Programmmetadaten abrufen
- `get_version` – Plugin-Version abrufen
- `health` – Health-Check-Endpunkt für Headless-Server
- `mcp_health` – HTTP-Server-Health: Pool-Statistiken, Betriebszeit, Speicher, Anzahl aktiver Anfragen
- `mcp_schema` – Maschinenlesbares API-Schema mit Endpunkt-Metadaten
- `tool_goto_address` – CodeBrowser-Auflistung und Dekompiler zu einer bestimmten Adresse navigieren
- `tool_launch_codebrowser` – Eine Datei in CodeBrowser öffnen, bei Bedarf ein neues Fenster starten
- `tool_running_tools` – Alle laufenden Ghidra-Tool-Fenster auflisten

### Emulation

- `emulate_function` – Eine einzelne Funktion mit kontrollierten Register-/Speichereingaben emulieren
- `emulate_hash_batch` – API-Hash-Auflösung durch Brute-Force

### Skripterstellung

- `run_ghidra_script` – Skript mit Ausgabeerfassung ausführen
- `run_script_inline` – Inline-Skriptcode ausführen

### Ghidra-Server und Versionskontrolle

- `server_admin_set_permissions` – Benutzerberechtigungen für ein Repository setzen
- `server_admin_terminate_all_checkouts` – Alle Auscheckvorgänge in einem Ordner rekursiv beenden
- `server_admin_terminate_checkout` – Alle Auscheckvorgänge auf einer einzelnen Datei beenden
- `server_admin_users` – Alle Benutzer auf dem Server auflisten
- `server_authenticate` – Server-Anmeldeinformationen für programmatische Authentifizierung registrieren
- `server_checkouts` – Alle ausgecheckten Dateien in einem Ordner auflisten, einschließlich serverseitiger Auscheckvorgänge
- `server_connect` – Mit einem Ghidra-Server verbinden
- `server_disconnect` – Vom Ghidra-Server trennen
- `server_repositories` – Repositories auf dem verbundenen Server auflisten
- `server_repository_create` – Ein neues Repository auf dem Server erstellen
- `server_repository_file` – Dateiinformationen aus einem Server-Repository abrufen
- `server_repository_files` – Dateien in einem Server-Repository-Ordner auflisten
- `server_version_control_add` – Eine Datei zur Versionskontrolle hinzufügen
- `server_version_control_checkin` – Eine versionierte Datei einchecken
- `server_version_control_checkout` – Eine versionierte Datei auschecken
- `server_version_control_undo_checkout` – Einen Datei-Checkout rückgängig machen
- `server_version_history` – Versionsgeschichte für eine Datei abrufen

### Debugger (Ghidra TraceRmi – nur GUI)

Auf Windows-Hosts, wo der WinDbg-Debugger-Proxy der Brücke aktiv ist (`GHIDRA_DEBUGGER_URL`), erhalten kollidierende Namen ein `_2`-Suffix (z. B. `debugger_status_2`).

- `debugger_dynamic_to_static` – Eine dynamische Laufzeitadresse aus der aktuellen Spur zurück in eine statische Ghidra-Programmadresse übersetzen
- `debugger_interrupt` – Das laufende Ziel unterbrechen (hineinbrechen)
- `debugger_launch` – Eine ausführbare Datei über Ghidra's Trace RMI Debugger-Launcher starten
- `debugger_launch_offers` – Verfügbare Debugger-Start-/Anhängeoptionen für das aktuelle Programm auflisten
- `debugger_list_breakpoints` – Alle Haltepunkte in der aktuellen Spur auflisten
- `debugger_modules` – Module (DLLs/EXEs) auflisten, die im debugten Prozess geladen sind
- `debugger_read_memory` – Speicher aus dem debugten Prozess lesen
- `debugger_registers` – CPU-Register aus der aktuellen Debug-Spur-Momentaufnahme lesen
- `debugger_remove_breakpoint` – Einen Haltepunkt an einer Adresse entfernen
- `debugger_resume` – Die Ausführung des debugten Prozesses fortsetzen
- `debugger_set_breakpoint` – Einen Software-Ausführungshaltepunkt an einer Adresse in der Spur setzen
- `debugger_stack_trace` – Den Aufrufstapel-Rückverfolgung für den aktuellen Thread abrufen
- `debugger_static_to_dynamic` – Eine statische Ghidra-Programmadresse in eine dynamische Laufzeitadresse in der aktuellen Spur übersetzen
- `debugger_status` – Debugger-Status abrufen: aktive Spur, Thread, Ausführungszustand, Modulanzahl
- `debugger_step_into` – Einzelschritt in die nächste Anweisung (folgt Aufrufen)
- `debugger_step_out` – Aus der aktuellen Funktion herausschreiten (bis zur Rückkehr ausführen)
- `debugger_step_over` – Über die nächste Anweisung hinwegschreiten (folgt keinen Aufrufen)
- `debugger_traces` – Alle offenen Debug-Spuren auflisten

### System

- `prompt_policy` – Bereichsbezogene Automatisierungsaufforderungsbehandlung vorübergehend aktivieren, deaktivieren oder abfragen

### Bridge-Statische WerkzeugeIm Python-Bridge selbst definiert (Instanz-Erkennung, Tool-Gruppen-Verwaltung); immer verfügbar, sogar vor einer Ghidra-Verbindung. Das Bridge proxyt auch 22 `debugger_*` WinDbg-Tools, wenn `GHIDRA_DEBUGGER_URL` auf den eigenständigen Debugger-Server zeigt.

- `check_tools` - Melden, welche Tools derzeit registriert und aufrufbar sind
- `connect_instance` - Das Bridge mit einer bestimmten Ghidra-Instanz verbinden
- `import_file` - Eine Binärdatei von der Festplatte in das aktuelle Projekt importieren und öffnen
- `list_instances` - Laufende Ghidra MCP-Instanzen erkennen (UDS + TCP-Portscan)
- `list_tool_groups` - Tool-Gruppen und deren Ladestatus auflisten
- `load_tool_group` - Die dynamischen Tools einer Tool-Gruppe beim MCP-Client registrieren
- `search_tools` - Den gesamten Tool-Katalog nach Stichwort durchsuchen
- `unload_tool_group` - Die dynamischen Tools einer Tool-Gruppe deregistrieren

<!-- END GENERATED API REFERENCE -->

Siehe [CHANGELOG.md](https://github.com/bethington/ghidra-mcp/blob/HEAD/CHANGELOG.md) für Versionshistorie.

## 🏗️ Architektur```
┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   AI/Automation │◄──►│   MCP Bridge    │◄──►│  Ghidra Plugin  │
│     Tools       │    │ (bridge_mcp_    │    │ (GhidraMCP.jar) │
│  (Claude, etc.) │    │  ghidra/)       │    │                 │
└─────────────────┘    └─────────────────┘    └─────────────────┘
        │                       │                       │
   MCP Protocol            HTTP REST              Ghidra API
(stdio/streamable-http) (localhost:8089)      (Program, Listing)
```
### Komponenten

- **python/bridge_mcp_ghidra/** — Python MCP Server-Paket (wird als `ghidra-mcp-bridge`-Wheel ausgeliefert; `bridge-mcp-ghidra`-Konsolenskript), das MCP-Protokoll in HTTP-Aufrufe übersetzt (225 Katalogeinträge)
- **GhidraMCP.jar** — Ghidra-Plugin, das Analysefunktionen über HTTP bereitstellt (175 GUI-Endpunkte)
- **GhidraMCPHeadlessServer** — Eigenständiger Headless-Server — 183 Endpunkte, keine GUI erforderlich
- **ghidra_scripts/** — Sammlung von Automatisierungsskripten für häufige Aufgaben

## 🔧 Entwicklung

### Erstellung aus dem Quellcode```bash
# Recommended: direct Python-first workflow
python -m tools.setup ensure-prereqs --ghidra-path "C:\ghidra_12.1.2_PUBLIC"
python -m tools.setup build
python -m tools.setup deploy --ghidra-path "C:\ghidra_12.1.2_PUBLIC"

# Version bump (updates all maintained version references atomically)
python -m tools.setup bump-version --new X.Y.Z
```
Das maßgebliche Build-System ist heute Maven. `tools.setup`, die VS Code-Aufgaben und der dokumentierte Bereitstellungsablauf bauen alle über `pom.xml` und schreiben Artefakte nach `target/`. `build.gradle` bleibt im Repository als manueller Fallback für direkte Ghidra/Gradle-Benutzer, ist aber nicht der primäre Pfad.

### Befehlsreferenz

| Befehl | Beschreibung |
|---------|-------------|
| `ensure-prereqs` | Installiert Python-Abhängigkeiten und Ghidra-Maven-JARs auf einmal. Beginnen Sie hier auf einem neuen Rechner. |
| `preflight` | Überprüft Python, Build-Tool, Ghidra-Pfad und JAR-Verfügbarkeit, ohne Änderungen vorzunehmen. Fügen Sie `--strict` hinzu, um auch die Netzwerkerreichbarkeit zu prüfen. |
| `build` | Erstellt das Plugin-JAR und die Erweiterungs-ZIP über Maven (oder Gradle, wenn `TOOLS_SETUP_BACKEND=gradle`). |
| `deploy` | Kopiert die erstellte Erweiterung in das Ghidra-Profil und patcht `FrontEndTool.xml` für die automatische Aktivierung. |
| `start-ghidra` | Startet die konfigurierte Ghidra-Installation. |
| `clean` | Entfernt Maven/Gradle-Build-Outputs (`target/`, `build/`). |
| `clean-all` | Entfernt Build-Outputs sowie lokale Cache-Artefakte (`.m2` Ghidra-JARs usw.). |
| `install-ghidra-deps` | Installiert nur die Ghidra-JARs in `~/.m2`. Nützlich, wenn sich die Build-Umgebung ändert. |
| `install-python-deps` | Installiert die Python-Abhängigkeitsgruppen über `uv sync`. |
| `run-tests` | Führt die Java-Offline-Testsuite aus (kein laufendes Ghidra erforderlich). |
| `verify-version` | Überprüft, ob die Versionszeichenfolgen in `pom.xml`, `CHANGELOG.md` und `README.md` konsistent sind. |
| `bump-version --new X.Y.Z` | Aktualisiert atomar alle Versionsverweise. Übergeben Sie `--tag`, um einen Git-Tag zu erstellen. |

Allgemeine Flags, die von den meisten Befehlen akzeptiert werden:

| Flag | Beschreibung |
|------|-------------|
| `--ghidra-path PATH` | Ghidra-Installationsverzeichnis. Standardmäßig `GHIDRA_PATH` aus `.env`. |
| `--dry-run` | Gibt Aktionen aus, ohne sie auszuführen. |
| `--force` | Installiert Ghidra-JARs neu, auch wenn bereits vorhanden (`install-ghidra-deps`, `ensure-prereqs`). |
| `--with-debugger` | Erzwingt die Installation der Debugger-Python-Anforderungen (nur Windows). |
| `--use-debugger-toggle` | Liest `INSTALL_DEBUGGER_DEPS` aus `.env`, um zu entscheiden, ob Debugger-Abhängigkeiten installiert werden sollen. |
| `--test TIER` | (nur `deploy`) Optieren Sie für Live-Deploy-Regressionstufen wie `release` oder `debugger-live`. |
| `--strict` | (nur `preflight`) Überprüft auch die Netzwerkerreichbarkeit für Maven Central und PyPI. |

Deploy-Teststufen sind optional, weil Benchmark-Stufen `Benchmark.dll` und `BenchmarkDebug.exe` im aktiven Ghidra-Projekt importieren/zurücksetzen können. Verwenden Sie `--test release` vor dem Erstellen von Releases, oder setzen Sie `GHIDRA_MCP_DEPLOY_TESTS=release` in einem lokalen `.env`, wenn Sie möchten, dass jedes Deploy auf Ihrem Rechner die Live-Benchmark-Regression ausführt. Siehe [Testing and Release Regression](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/TESTING.md).```text
# Standard first-time setup and deploy
python -m tools.setup ensure-prereqs --ghidra-path "C:\ghidra_12.1.2_PUBLIC"
python -m tools.setup build
python -m tools.setup deploy --ghidra-path "C:\ghidra_12.1.2_PUBLIC"

# Preflight check before deploying
python -m tools.setup preflight --strict --ghidra-path "C:\ghidra_12.1.2_PUBLIC"

# Version bump and tag
python -m tools.setup bump-version --new X.Y.Z --tag

# Run offline Java tests
python -m tools.setup run-tests

# Show full help
python -m tools.setup --help
```
### Projektstruktur```
ghidra-mcp/
├── pyproject.toml           # uv project (ghidra-mcp-bridge wheel + dependency groups)
├── python/bridge_mcp_ghidra/ # MCP server package (Python, 225 catalog entries)
├── src/main/java/           # Ghidra plugin + headless server (Java)
│   └── com/xebyte/
│       ├── GhidraMCPPlugin.java         # GUI plugin (196 endpoints)
│       ├── headless/                    # Headless server (183 endpoints)
│       └── core/                        # Shared service layer (12 services)
├── debugger/                # Optional standalone debugger server (port 8099)
├── ghidra_scripts/          # Automation scripts for batch workflows
├── tests/                   # Python unit tests + endpoint catalog
│   ├── unit/               # Catalog consistency, schema, tool function tests
│   └── endpoints.json      # Endpoint specification (225 entries)
├── docs/                    # Documentation
│   ├── prompts/            # AI workflow prompts (V5 documentation workflows)
│   ├── releases/           # Version release notes
│   └── project-management/ # Contributor planning docs (Gradle migration, etc.)
├── tools/setup/             # Build and deployment CLI (python -m tools.setup)
├── fun-doc/                 # Internal RE curation tool — not part of the MCP plugin
│                            #   Priority-queue worker, LLM scoring, web dashboard.
│                            #   See fun-doc/README.md for details.
└── .github/workflows/      # CI/CD pipelines
```
### Bibliotheksabhängigkeiten

Ghidra JARs müssen vor der Kompilierung in Ihrem lokalen Maven-Repository (`~/.m2/repository`) installiert werden.
Dies ist eine einmalige Einrichtung pro Maschine und erneut, wenn sich Ihre Ghidra-Version ändert.
`-Deploy` installiert diese standardmäßig jetzt automatisch.

Das Tool erzwingt Versionskonsistenz zwischen:
- `pom.xml` (`ghidra.version`)
- `--ghidra-path` Versionssegment (z.B. `ghidra_12.1.2_PUBLIC`)

Wenn diese nicht übereinstimmen, schlägt die Bereitstellung schnell mit einer klaren Fehlermeldung fehl.

### Fehlerbehebung: Versionskonflikt

Wenn Sie einen Versionskonflikt-Fehler sehen, gleichen Sie beide Werte an:
1. `pom.xml` → `ghidra.version`
2. `--ghidra-path` Versionssegment (`ghidra_X.Y.Z_PUBLIC`)

Dann führen Sie erneut aus:

```
mvn clean package -Deploy
``````text
python -m tools.setup preflight --ghidra-path "C:\ghidra_12.1.2_PUBLIC"
```
(No content to translate.)```text
# Windows
python -m tools.setup install-ghidra-deps --ghidra-path "C:\path\to\ghidra_12.1.2_PUBLIC"
```
**Erforderliche Bibliotheken (14 JARs, ~37MB):**

| Bibliothek | Quellpfad | Zweck |
|---------|------------|---------|
| **Base.jar** | `Features/Base/lib/` | Ghidra-Kernfunktionalität |
| **Decompiler.jar** | `Features/Decompiler/lib/` | Dekompilierungs-Engine |
| **PDB.jar** | `Features/PDB/lib/` | Unterstützung für Microsoft PDB-Symbole |
| **FunctionID.jar** | `Features/FunctionID/lib/` | Funktionsidentifikation |
| **SoftwareModeling.jar** | `Framework/SoftwareModeling/lib/` | Programmmodell-API |
| **Project.jar** | `Framework/Project/lib/` | Projektverwaltung |
| **Docking.jar** | `Framework/Docking/lib/` | UI-Docking-Framework |
| **Generic.jar** | `Framework/Generic/lib/` | Allgemeine Dienstprogramme |
| **Utility.jar** | `Framework/Utility/lib/` | Kern-Dienstprogramme |
| **Gui.jar** | `Framework/Gui/lib/` | GUI-Komponenten |
| **FileSystem.jar** | `Framework/FileSystem/lib/` | Dateisystem-Unterstützung |
| **Graph.jar** | `Framework/Graph/lib/` | Graphen-/Aufrufgraphenanalyse |
| **DB.jar** | `Framework/DB/lib/` | Datenbankoperationen |
| **Emulation.jar** | `Framework/Emulation/lib/` | P-Code-Emulation |

> **Hinweis**: Bibliotheken sind NICHT im Repository enthalten (siehe `.gitignore`). Sie müssen sie vor dem Build aus Ihrer Ghidra-Installation installieren.

> **Automatisierungs-Einstiegspunkt**:
> - `python -m tools.setup` ist die unterstützte Schnittstelle für Setup/Build/Deploy/Versionierung
> - Verwenden Sie direkt `ensure-prereqs`, `build`, `deploy`, `preflight`, `clean-all` und `bump-version`
> - Diese Befehle verwenden derzeit Maven als kanonisches Java-Build-Backend

### Entwicklungsfunktionen
- **Automatisiertes Deployment**: Versionsbewusstes Deployment-Skript
- **Batch-Operationen**: Reduziert API-Aufrufe um 93%
- **Atomare Transaktionen**: Alles-oder-nichts-Semantik
- **Umfassende Protokollierung**: Debug- und Trace-Funktionen

## 📚 Dokumentation

### Kerndokumentation
- [Dokumentationsindex](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/README.md) - Komplette Dokumentationsnavigation
- [Projektstruktur](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/PROJECT_STRUCTURE.md) - Leitfaden zur Projektorganisation
- [Tests und Release-Regression](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/TESTING.md) - Lokale Tests, CI, Live-Ghidra-Regression und Release-Gates
- [Namenskonventionen](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/NAMING_CONVENTIONS.md) - Code-Namensstandards
- [Ungarische Notation](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/HUNGARIAN_NOTATION.md) - Leitfaden zur Variablenbenennung

### KI-Workflow-Prompts
- [Funktionsdokumentation V5](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/prompts/FUNCTION_DOC_WORKFLOW_V5.md) — Primärer Workflow: 7-Schritte-Prozess mit ungarischer Notation, Typenprüfung und Verifizierungsbewertung
- [Batch-Dokumentation V5](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/prompts/FUNCTION_DOC_WORKFLOW_V5_BATCH.md) — Paralleler Subagenten-Dispatch für die Verarbeitung mehrerer Funktionen
- [Erkennung von verwaistem Code](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/prompts/ORPHANED_CODE_DISCOVERY_WORKFLOW.md) — Automatischer Scanner für unentdeckte Funktionen
- [Datentyp-Untersuchung](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/prompts/DATA_TYPE_INVESTIGATION_WORKFLOW.md) — Systematische Strukturerkennung
- [Versionsübergreifender Abgleich](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/prompts/CROSS_VERSION_MATCHING_COMPREHENSIVE.md) — Hash-basierter Funktionsabgleich
- [Schnellstart-Prompt](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/prompts/QUICK_START_PROMPT.md) — Vereinfachter Einsteiger-Workflow
- [Alle Prompts](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/prompts/README.md) — Vollständiger Prompt-Index

### Versionsverlauf
- [Vollständiges Änderungsprotokoll](https://github.com/bethington/ghidra-mcp/blob/HEAD/CHANGELOG.md) - Alle Versionshinweise
- [Versionshinweise](https://github.com/bethington/ghidra-mcp/blob/HEAD/docs/releases/) - Detaillierte Veröffentlichungsdokumentation

## 🐳 Headless-Server (Docker)

GhidraMCP enthält einen Headless-Server-Modus für automatisierte Analysen ohne die Ghidra-GUI.

### Schnellstart mit Docker```bash
# Build and run
docker-compose up -d ghidra-mcp

# Test connection
curl http://localhost:8089/check_connection
# Connection OK - GhidraMCP Headless Server v5.17.0
```
### Headless API Workflow```bash
# 1. Load a binary
curl -X POST -d "file=/data/program.exe" http://localhost:8089/load_program

# 2. Run auto-analysis (identifies functions, strings, data types)
curl -X POST http://localhost:8089/run_analysis

# 3. List discovered functions
curl "http://localhost:8089/list_functions?limit=20"

# 4. Decompile a function
curl "http://localhost:8089/decompile_function?address=0x401000"

# 5. Get metadata
curl http://localhost:8089/get_metadata
```
### Wichtige Headless-Endpunkte

| Endpunkt | Methode | Beschreibung |
|----------|--------|-------------|
| `/load_program` | POST | Binärdatei für Analyse laden |
| `/run_analysis` | POST | Ghidra-Autoanalyse ausführen |
| `/list_functions` | GET | Alle gefundenen Funktionen auflisten |
| `/list_exports` | GET | Exportierte Symbole auflisten |
| `/list_imports` | GET | Importierte Symbole auflisten |
| `/decompile_function` | GET | Funktion in C-Code dekompilieren |
| `/create_function` | POST | Funktion an Adresse erstellen |
| `/get_metadata` | GET | Programm-Metadaten abrufen |
| `/create_project` | POST | Ein Ghidra-Projekt erstellen |
| `/list_analyzers` | GET | Verfügbare Analyzer auflisten |
| `/server/status` | GET | Ghidra-Server-Verbindung prüfen |

### Konfiguration

Umgebungsvariablen für Docker:
- `GHIDRA_MCP_PORT` - Server-Port (Standard: 8089)
- `GHIDRA_MCP_BIND_ADDRESS` - Bind-Adresse (Standard: 0.0.0.0 in Docker)
- `JAVA_OPTS` - JVM-Optionen (Standard: -Xmx4g -XX:+UseG1GC)

## 🤝 Mitwirken

Siehe [CONTRIBUTING.md](https://github.com/bethington/ghidra-mcp/blob/HEAD/CONTRIBUTING.md) für detaillierte Beitragsrichtlinien.

### Schnellstart
1. Repository forken
2. Einen Feature-Branch erstellen (`git checkout -b feature/amazing-feature`)
3. Erstelle und teste deine Änderungen (`mvn clean package assembly:single -DskipTests` or `GHIDRA_INSTALL_DIR=/path/to/ghidra gradle buildExtension`)
4. Dokumentation bei Bedarf aktualisieren
5. Commite deine Änderungen (`git commit -m 'Add amazing feature'`)
6. Push auf den Branch (`git push origin feature/amazing-feature`)
7. Öffne einen Pull-Request

## 📄 Lizenz

Dieses Projekt ist unter der Apache License 2.0 lizenziert – siehe die Datei [LICENSE](https://github.com/bethington/ghidra-mcp/blob/HEAD/LICENSE) für Details.

## 🏆 Produktionsstatus

| Metrik | Wert |
|--------|-------|
| **Version** | 5.17.0 |
| **MCP-Werkzeuge** | 249 vollständig implementiert |
| **GUI-Endpunkte** | 196 (GhidraMCPPlugin) |
| **Headless-Endpunkte** | 195 (GhidraMCPHeadlessServer) |
| **Kompilierung** | ✅ 100% Erfolg |
| **Batch-Effizienz** | 93% API-Aufrufreduzierung |
| **KI-Workflows** | 7 bewährte Dokumentations-Workflows |
| **Ghidra-Skripte** | Automatisierungsskripte enthalten |
| **Dokumentation** | Umfassend mit KI-Aufforderungen |

Siehe [CHANGELOG.md](https://github.com/bethington/ghidra-mcp/blob/HEAD/CHANGELOG.md) für Versionsverlauf und Versionshinweise.


## 🙏 Danksagungen

Dieses Projekt wurde ursprünglich von [LaurieWired/GhidraMCP](https://github.com/LaurieWired/GhidraMCP) abgeleitet und seitdem wesentlich umgeschrieben und erweitert. Wir würdigen LaurieWireds ursprüngliche Arbeit als Ausgangspunkt. Siehe [NOTICE](https://github.com/bethington/ghidra-mcp/blob/HEAD/NOTICE) für die Lizenzzuordnung.

## 👥 Mitwirkende

Dieses Projekt hat von der Arbeit engagierter Mitwirkender profitiert:

### Kern-Mitwirkende

**[@heeen](https://github.com/heeen)** — Bedeutende Beiträge einschließlich:
- Fuzzy-Funktionsabgleich und strukturiertes Diff für binärübergreifenden Vergleich (#13)
- Verbesserungen der Skriptausführung und Fehlerbehebungen (#12)
- Neue API-Endpunkte: `save_program`, `exit_ghidra`, `delete_function`, `create_memory_block`, `run_script_inline` (#11)
- Architekturelle Vision: annotierungsgetriebenes Design, UDS-Transport, Optimierungsvorschläge für die Python-Brücke

**[@huehuehuehueing](https://github.com/huehuehuehueing)** — Bedeutende Beiträge einschließlich:
- Unterstützung für Adressraum-Präfixe – hinzugefügte `<space>:<hex>`-Syntax (z.B. `mem:1000`, `code:ff00`) zur Adressparsing über die gesamte Endpunktfläche hinweg, die Multi-Space-Ziele wie eingebettete Firmware freischaltet (#84, schließt #65)
- Optionaler `program`-Parameter + Korrekturen des Required-Param-Schemas – machte `program` auf jedem Endpunkt optional mit einem sinnvollen currentProgram-Fallback und behob mehrere Required-vs-Optional-Schemafehler, die der Katalog geerbt hatte (#92)
- Gesät #44 (Datentyp-/Enum-Tools) – das Problem, das die v5.0 Enum + Struct Enforcement Layer motivierte


- **Ghidra-Team** - Für die unglaubliche Reverse-Engineering-Plattform
- **Model Context Protocol** - Für das standardisierte KI-Integrationsframework
- **Mitwirkende** - Für Tests, Feedback und Verbesserungen

---

## 🔗 Verwandte Projekte

- [re-universe](https://github.com/bethington/re-universe) — Ghidra-BSim-PostgreSQL-Plattform für groß angelegte Binärähnlichkeitsanalyse. Passt perfekt zu GhidraMCP für KI-gesteuerte Reverse-Engineering-Workflows.
- [cheat-engine-server-python](https://github.com/bethington/cheat-engine-server-python) — MCP-Server für dynamische Speicheranalyse und Debugging.

---

**Bereit für den Produktionseinsatz mit Unternehmenszuverlässigkeit und umfassenden Binäranalysefähigkeiten.**