13bm/GhidraMCP

GhidraMCP

A Ghidra extension that exposes 69 reverse-engineering tools to AI assistants through the Model Context Protocol (MCP). Open a binary in Ghidra, enable the plugin, and let Claude (or any MCP client) decompile functions, rename symbols, annotate code, search for vulnerabilities, and more.

Architecture

 AI Client (Claude Desktop / CLI)
        |  stdio + MCP JSON-RPC
        v
   Go MCP Bridge  (mcp_bridge)
        |  TCP, length-prefixed JSON-RPC
        v
   Ghidra Plugin  (MCPServerPlugin)
        |
        v
   Ghidra Program API

The Ghidra plugin (Java) starts a TCP server inside Ghidra and auto-launches the Go bridge binary. The bridge speaks MCP over stdio to the AI client and forwards calls to the Java plugin over a local TCP socket with 4-byte length-prefixed JSON-RPC framing. Optional API-key authentication protects the TCP channel.

Features

• 69 MCP tools spanning query, mutation, analysis, malware triage, IoT/embedded security, structure management, async decompilation, and multi-instance support
• Easy setup -- plugin auto-starts the bridge; use MCP > Settings > Write to Claude Config to configure your MCP client
• Cross-platform -- prebuilt bridge binaries for Linux x86_64, Windows x86_64, macOS x86_64 and macOS ARM64
• Configurable -- port, localhost-only binding, API-key auth, auto-start, bridge enable/disable via GhidraMCP.properties
• Multi-instance -- work with multiple Ghidra windows simultaneously using target_port to route tool calls
• Async decompilation -- decompile large functions without blocking; poll for results later
• Connection retry -- the bridge reconnects automatically if Ghidra restarts or the connection drops
• Pagination -- large result sets (functions, strings, imports, ...) support offset/limit for safe incremental retrieval
• CI/CD -- automated builds, Go + Java tests, Ghidra integration tests, and auto-release when a new Ghidra version drops

Quick Start

Prerequisites

• Ghidra 12.0.3+
• Java 21+
• An MCP-compatible AI client (Claude Desktop, Claude Code, etc.)

Install

1. Download the latest release ZIP from Releases
2. In Ghidra: File > Install Extensions > "+" > select the ZIP
3. Restart Ghidra

Enable

1. Open a project and a program (binary)
2. File > Configure > Miscellaneous -- check MCPServerPlugin
3. The plugin auto-starts the TCP server (default localhost:8765) and launches the bridge

To configure Claude Desktop, open MCP > Settings and click Write to Claude Config. For other MCP clients, click Copy to Clipboard and add this to your client config:

{
  "mcpServers": {
    "ghidra": {
      "command": "/path/to/mcp_bridge",
      "args": ["--host", "localhost", "--port", "8765"]
    }
  }
}

If you have an API key set, include it in the env block (the plugin does this automatically):

{
  "mcpServers": {
    "ghidra": {
      "command": "/path/to/mcp_bridge",
      "args": ["--host", "localhost", "--port", "8765"],
      "env": {
        "GHIDRA_API_KEY": "your-key-here"
      }
    }
  }
}

You can also grab the snippet from Ghidra: MCP > Copy MCP Config (copies it to your clipboard).

Tools

Full reference with parameters, types, and examples:

The tables below give a quick overview. See for detailed parameter docs.

Query (1-21)

Mutation (22-38)

Advanced Analysis (39-45)

Malware Analysis (46-53)

IoT / Embedded Security (54-59)

Utility (60-62)

Multi-Instance (63)

All tools accept an optional target_port parameter to route calls to a specific Ghidra instance. This lets you work with multiple binaries open in separate Ghidra windows simultaneously.

Structure Management (64-68)

Async Decompilation (69-70)

Async decompilation is useful for large functions that may take 30+ seconds to decompile. The client can start the decompilation, continue other work, and poll for the result later.

Configuration

The plugin stores settings in GhidraMCP.properties inside Ghidra's user settings directory:

Settings Dialog

Open MCP > Settings in the Ghidra menu to configure all properties through a GUI. The dialog includes:

• Editable fields for port, localhost binding, API key, auto-start, and bridge enabled
• Generate button to create a cryptographically random 32-character API key
• Write to Claude Config button to merge GhidraMCP into Claude Desktop's claude_desktop_config.json
• Copy to Clipboard button to copy the MCP config JSON snippet for manual setup
• Security warning if you enable remote access without an API key
• Auto-restart prompt if the server is running when you save

Changes are saved to disk when you click OK. You can also edit the properties file directly at the path shown in the dialog.

If auto_start is false, start the server manually from MCP > Toggle Server in the Ghidra menu.

Note: The bridge_enabled setting is for advanced use cases — developers debugging the bridge binary or users with a custom MCP client that talks TCP directly to the Java server. Most users should leave it enabled.

Security

By default the TCP server binds to localhost only and has no API key, which is fine for local single-user use. For stricter setups:

API-Key Authentication

1. Open MCP > Settings and click Generate to create a random key (or type your own)
2. Click OK to save — the bridge picks up the key automatically on next start
3. On connect, the bridge sends an authenticate request with the key before any other calls
4. The server rejects all non-auth requests until authentication succeeds
5. After 3 failed attempts the server terminates the connection

The API key is passed to the bridge via the GHIDRA_API_KEY environment variable (not as a CLI flag) to prevent leaking it in the process argument list. When running the bridge manually, set the environment variable:

# Linux/macOS
export GHIDRA_API_KEY="your-key-here"
./mcp_bridge --host localhost --port 8765

# Windows (PowerShell)
$env:GHIDRA_API_KEY = "your-key-here"
.\mcp_bridge.exe --host localhost --port 8765

When an API key is set, the Write to Claude Config and Copy to Clipboard buttons in the Settings dialog include the key in the env block automatically.

Localhost Binding

With localhost_only=true (default), the server only accepts connections from 127.0.0.1. Set to false if you need remote access (e.g., Ghidra on a headless server), but always use an API key when exposing the port beyond localhost.

Remote / Headless Setup

GhidraMCP can serve AI clients running on a different machine. This is useful when Ghidra runs on a headless analysis server while the AI client runs elsewhere.

1. Open MCP > Settings
2. Uncheck Localhost Only to accept remote connections
3. Click Generate to create an API key (always use one for remote access)
4. Click OK and restart the server

On the remote machine, configure the MCP client to point at the Ghidra host:

{
  "mcpServers": {
    "ghidra": {
      "command": "/path/to/mcp_bridge",
      "args": ["--host", "ghidra-server.local", "--port", "8765"],
      "env": {
        "GHIDRA_API_KEY": "your-key-here"
      }
    }
  }
}

Warning: Always use an API key when exposing the server beyond localhost. Without authentication, anyone who can reach the port has full access to the Ghidra API.

Building from Source

git clone https://github.com/13bm/GhidraMCP.git
cd GhidraMCP

Build the Go bridge

cd mcp-bridge
go build -o mcp_bridge .
cd ..

Build the Ghidra extension

export GHIDRA_INSTALL_DIR=/path/to/ghidra
gradle buildExtension

The extension ZIP will be in dist/.

Run tests

# Go tests
cd mcp-bridge && go test ./... -v && cd ..

# Java unit + integration tests (requires Xvfb on headless Linux)
xvfb-run gradle test -PGHIDRA_INSTALL_DIR=$GHIDRA_INSTALL_DIR

CI/CD

The project uses GitHub Actions for automated builds and releases:

• build.yml -- Triggered on push/PR to master and on tags. Runs Go tests, cross-compiles the bridge for 4 platforms, runs Java unit + Ghidra integration tests under Xvfb, builds the extension ZIP, and creates GitHub Releases on v* tags.
• check-ghidra-release.yml -- Runs daily. Detects new Ghidra releases, opens a version-bump PR, auto-approves via GitHub App, and auto-merges if all tests pass.

Contributing

Contributions welcome! Please open issues or submit pull requests.

1. Fork the repository
2. Create a feature branch: git checkout -b feature/my-feature
3. Commit your changes
4. Push and open a Pull Request

License

Acknowledgments

• NSA / Ghidra
• Model Context Protocol
• mcp-go -- Go MCP SDK

GhidraMCP is not affiliated with or endorsed by the NSA or the Ghidra project.