Skip to content
Back to search

GhidrAssistMCP

An native MCP server extension for Ghidra

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/symgraph/GhidrAssistMCP with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/symgraph/GhidrAssistMCP'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/symgraph--ghidrassistmcp/badge.svg)](/listings/symgraph--ghidrassistmcp)

HTML

<a href="/listings/symgraph--ghidrassistmcp"><img src="/api/listings/symgraph--ghidrassistmcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Prerequisites

- **Ghidra 11.4+** (tested with Ghidra 12.1 Public) - **An MCP Client (Like GhidrAssist)**

Binary Release (Recommended)

1. **Download the latest release**: - Go to the [Releases page](https://github.com/jtang613/GhidrAssistMCP/releases) - Download the latest `.zip` file (e.g., `GhidrAssistMCP-v1.0.0.zip`)

2. **Install the extension**: - In Ghidra: **File → Install Extensions → Add Extension** - Select the downloaded ZIP file - Restart Ghidra when prompted

3. **Enable the plugin**: - **File → Configure → Configure Plugins** - Search for "GhidrAssistMCP" - Check the box to enable the plugin

Building from Source

Source builds require Java 25 or newer. The included Gradle wrapper pins the supported Gradle release; use it instead of a system Gradle installation.

1. **Clone the repository**:

   git clone <repository-url>
   cd GhidrAssistMCP

2. **Point Gradle at your Ghidra install**: - Set `GHIDRA_INSTALL_DIR` (environment variable), or pass `-PGHIDRA_INSTALL_DIR=<path>` when you run Gradle.

3. **Build + install**:

Ensure Ghidra isn't running and run:

   ./gradlew installExtension

This copies the built ZIP into your Ghidra install (`[GHIDRA_INSTALL_DIR]/Extensions/Ghidra`) and extracts it into your Ghidra **user** Extensions folder (replacing any existing extracted copy).

If you need to override that location, pass `-PGHIDRA_USER_EXTENSIONS_DIR=<path>`.

4. **Restart / verify**: - Restart Ghidra. - If the plugin doesn't appear, enable it via **File → Configure → Configure Plugins** (search for "GhidrAssistMCP").

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 492 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # GhidrAssistMCP
  2. A powerful Ghidra extension that provides an MCP (Model Context Protocol) server, enabling AI assistants and other tools to interact with Ghidra's reverse engineering capabilities through a standardized API.
  3. ## Overview
  4. Version **3.0.0** introduces the explicit tool catalog and application-owned runtime. Clients should refresh their tool definitions after upgrading.
  5. GhidrAssistMCP bridges the gap between AI-powered analysis tools and Ghidra's comprehensive reverse engineering platform. By implementing the Model Context Protocol, this extension allows external AI assistants, automated analysis tools, and custom scripts to seamlessly interact with Ghidra's analysis capabilities.
  6. ### Key Features
  7. - **MCP Server Integration**: Full Model Context Protocol server implementation using official SDK
  8. - **Dual HTTP Transports**: Supports SSE and Streamable HTTP transports for maximum client compatibility
  9. - **101 Explicit Tools**: Discoverable operation names with precise input contracts and read/write annotations (94 enabled by default)
  10. - **6 MCP Resource Templates**: Program-specific data resources for program info, functions, strings, imports, exports, and segments
  11. - **7 MCP Prompts**: Pre-built analysis prompts for common reverse engineering tasks
  12. - **Result Caching**: Intelligent caching system to improve performance for repeated queries
  13. - **Batch Pseudocode Reads**: Decompile functions together, with full source by default and explicit line pagination
  14. - **Async Task Support**: Long-running operations execute asynchronously with task management
  15. - **Multi-Program Support**: Work with multiple open programs simultaneously using `program_name`; use `list_open_programs` project paths to disambiguate duplicate filenames
  16. - **Application Startup**: MCP is available as soon as the project manager opens, before CodeBrowser
  17. - **Shared Views**: Every CodeBrowser shares the runtime configuration and bounded request log
  18. - **Multi-Window Support**: Single MCP server shared across all CodeBrowser windows with intelligent focus tracking
  19. - **Active Context Awareness**: Automatic detection of which binary window is in focus, with context hints in all tool responses
  20. - **Configurable UI**: Easy-to-use interface for managing tools and monitoring activity
  21. - **Real-time Logging**: Track all MCP requests and responses with detailed logging
  22. - **Dynamic Tool Management**: Enable/disable tools individually with persistent settings
  23. ## Clients
  24. Shameless self-promotion: [GhidrAssist](https://github.com/jtang613/GhidrAssist) supports GhidrAssistMCP right out of the box.
  25. ## Screenshots
  26. ![Screenshot](https://github.com/jtang613/GhidrAssistMCP/blob/master/res/Screenshot1.png)
  27. ![Screenshot](https://github.com/jtang613/GhidrAssistMCP/blob/master/res/Screenshot2.png)
  28. ## Installation
  29. ### Prerequisites
  30. - **Ghidra 12.0 or 12.1 Public**, running with Java 25 or newer (extension ZIPs are specific to the selected Ghidra version)
  31. - **An MCP Client (Like GhidrAssist)**
  32. ### Binary Release (Recommended)
  33. 1. **Download the latest release**:
  34. - Go to the [Releases page](https://github.com/jtang613/GhidrAssistMCP/releases)
  35. - Download the latest `.zip` file (e.g., `ghidra_12.1_PUBLIC_20261009_GhidrAssistMCP-3.0.0.zip`)
  36. 2. **Install the extension**:
  37. - In Ghidra: **File → Install Extensions → Add Extension**
  38. - Select the downloaded ZIP file
  39. - Restart Ghidra when prompted
  40. 3. **Start Ghidra**:
  41. - The MCP runtime starts in the project manager automatically.
  42. - CodeBrowsers receive a shared MCP view when opened.
  43. - Open **Window → GhidrAssistMCP** to configure or disable the server.
  44. ### Building from Source
  45. Source builds require Java 25 or newer. The included Gradle wrapper pins the
  46. supported Gradle release; use it instead of a system Gradle installation.
  47. 1. **Clone the repository**:
  48. ```bash
  49. git clone <repository-url>
  50. cd GhidrAssistMCP
  51. ```
  52. 2. **Point Gradle at your Ghidra install**:
  53. - Set `GHIDRA_INSTALL_DIR` (environment variable), or pass `-PGHIDRA_INSTALL_DIR=<path>` when you run Gradle.
  54. 3. **Build + install**:
  55. Ensure Ghidra isn't running and run:
  56. ```bash
  57. ./gradlew installExtension
  58. ```
  59. This copies the built ZIP into your Ghidra install (`[GHIDRA_INSTALL_DIR]/Extensions/Ghidra`) and extracts it into your Ghidra **user** Extensions folder (replacing any existing extracted copy).
  60. If you need to override that location, pass `-PGHIDRA_USER_EXTENSIONS_DIR=<path>`.
  61. 4. **Restart / verify**:
  62. - Restart Ghidra.
  63. - If the plugin doesn't appear, enable it via **File → Configure → Configure Plugins** (search for "GhidrAssistMCP").
  64. ## Configuration
  65. ### Initial Setup
  66. 1. **Open the Control Panel**:
  67. - Window → GhidrAssistMCP
  68. 2. **Configure Server Settings**:
  69. - **Host**: Default is `localhost`
  70. - **Port**: Default is `8080`
  71. - **Enable/Disable**: Toggle the MCP server on/off
  72. ### Tool Management
  73. The Configuration tab allows you to:
  74. - **View all public tools** (101 total)
  75. - **Enable/disable individual tools** using checkboxes
  76. - **Save configuration** to persist across sessions
  77. - **Monitor tool status** in real-time
  78. ## Headless Mode Quickstart
  79. GhidrAssistMCP can also be started from Ghidra's `analyzeHeadless` launcher. This is useful when you want MCP access to a program loaded in headless Ghidra without opening the CodeBrowser UI.
  80. First, build and install the extension so Ghidra can load the compiled classes and bundled dependencies:
  81. ```bash
  82. cd /path/to/GhidrAssistMCP
  83. export GHIDRA_INSTALL_DIR=/path/to/ghidra_12.1_PUBLIC
  84. ./gradlew installExtension
  85. ```
  86. Set paths for your Ghidra install and extracted user extension. On Linux, Ghidra user extensions usually live under `~/.config/ghidra/<ghidra_profile>/Extensions`:
  87. ```bash
  88. export GHIDRA_INSTALL_DIR=/path/to/ghidra_12.1_PUBLIC
  89. export GHIDRA_USER_EXTENSIONS_DIR="$HOME/.config/ghidra/ghidra_12.1_PUBLIC/Extensions"
  90. export GHIDRASSISTMCP_EXT="$GHIDRA_USER_EXTENSIONS_DIR/GhidrAssistMCP"
  91. ```
  92. Import a binary and start the MCP server as a headless pre-script:
  93. ```bash
  94. "$GHIDRA_INSTALL_DIR/support/analyzeHeadless" /tmp/ghidra-projects McpHeadless \
  95. -import /path/to/binary \
  96. -scriptPath "$GHIDRASSISTMCP_EXT/ghidra_scripts" \
  97. -preScript GAMCPStartServerScript.java "host=127.0.0.1" "port=8080"
  98. ```
  99. For a binary that is already imported into the project, use `-process` instead:
  100. ```bash
  101. "$GHIDRA_INSTALL_DIR/support/analyzeHeadless" /tmp/ghidra-projects McpHeadless \
  102. -process binary_name \
  103. -scriptPath "$GHIDRASSISTMCP_EXT/ghidra_scripts" \
  104. -preScript GAMCPStartServerScript.java "host=127.0.0.1" "port=8080"
  105. ```
  106. To keep a headless MCP session open after analysis completes, run the server as a post-script with wait mode:
  107. ```bash
  108. "$GHIDRA_INSTALL_DIR/support/analyzeHeadless" /tmp/ghidra-projects McpHeadless \
  109. -process binary_name \
  110. -scriptPath "$GHIDRASSISTMCP_EXT/ghidra_scripts" \
  111. -postScript GAMCPStartServerScript.java "host=127.0.0.1" "port=8080" "wait=true"
  112. ```
  113. MCP clients can connect to:
  114. ```text
  115. SSE: http://127.0.0.1:8080/sse
  116. SSE messages: http://127.0.0.1:8080/message
  117. Streamable HTTP: http://127.0.0.1:8080/mcp
  118. ```
  119. The headless MCP server runs inside the `analyzeHeadless` JVM and uses the loaded `currentProgram`. The server holds a program consumer while it is running so MCP requests do not race against program database closure. Use `wait=true` when you want `analyzeHeadless` to stay open for interactive MCP clients. A harness can also pass `completion_file=/workspace/control/session.complete`; creating that file closes the MCP server cleanly and lets Ghidra save and exit normally.
  120. Disposable static-analysis labs may pass `tool_profile=agent_lab`. This enables sandbox-local program export while arbitrary path import and Ghidra scripts remain disabled because they can expose process secrets or spawn processes. The harness owns artifact imports. Unknown profiles are rejected.
  121. ## Available tools
  122. The public catalog contains 101 explicit tools, 94 enabled by default. [The modernization review](docs/modernization-review.md) maps every previous tool to its current name and explains the architecture and remaining improvements. Fetch `tools/list` for authoritative parameter schemas; clients should reconnect after upgrading.
  123. | Purpose | Representative tools |
  124. | --- | --- |
  125. | Project lifecycle | `create_project`, `open_project`, `save_project`, `close_project` |
  126. | Programs and project files | `get_program_info`, `list_open_programs`, `list_project_files`, `open_program`, `close_program` |
  127. | Code and functions | `list_functions`, `search_functions`, `get_function_info`, `get_pseudocode`, `get_pseudocode_batch`, `get_disassembly`, `get_pcode`, `get_control_flow_graph` |
  128. | Function identity | `get_function_hash` (SHA-256), `get_function_byte_pattern` (masked prefix), `get_function_prototype` (C declaration) |
  129. | Binary data | `list_imports`, `list_exports`, `list_strings`, `list_memory_blocks`, `list_entry_points`, `get_hexdump` |
  130. | References | `get_xrefs_to`, `get_xrefs_from`, `get_callers`, `get_callees`, `get_call_graph` |
  131. | Comments | `get_comment`, `get_function_comment`, `list_function_comments`, `set_comment`, `set_function_comment`, `remove_comment` |
  132. | Variables and types | `list_function_variables`, `rename_local_variable`, `set_local_variable_type`, `set_function_prototype`, `list_data_types`, `get_data_type`, `set_data_type` |
  133. | Structures and classes | `create_structure`, `set_structure_field`, `infer_structure_from_variable`, `get_structure_field_xrefs`, `list_classes`, `get_class_info` |
  134. | Analysis | `list_analysis_options`, `set_analysis_options`, `analyze_program`, `get_analysis_status`, `cancel_analysis` |
  135. | Jobs | `list_tasks`, `get_task_status`, `cancel_task` |
  136. Names express the operation. Public code readers do not require a `format` selector, and comment/type/script operations do not require an `action` selector. `get_disassembly` reads existing instructions; `disassemble_bytes` changes the listing. Read and write tools have their own MCP annotations.
  137. `import_file`, `export_program`, and the five script tools are disabled by default. Enable the specific operations in the shared Configuration view when needed. Old consolidated names are no longer exposed over HTTP; saved enabled states migrate to their replacement operations.
  138. ### Opening a program from the project manager
  139. The MCP server starts when Ghidra's project manager opens, before a CodeBrowser exists. Start with:
  140. ```json
  141. {"method":"tools/call","params":{"name":"list_project_files","arguments":{"recursive":true}}}
  142. ```
  143. Then open a program using its project path. This launches CodeBrowser when needed:
  144. ```json
  145. {"method":"tools/call","params":{"name":"open_program","arguments":{"name":"/binaries/example"}}}
  146. ```
  147. ### Creating, opening, saving, and closing a project
  148. Project lifecycle tools work while only the project manager is open and return structured project identity/status fields. They require the GUI project manager; the headless launcher manages its own project.
  149. Create a local project in an existing absolute parent directory, with a simple name that omits `.gpr` and `.rep`:
  150. ```json
  151. {"method":"tools/call","params":{"name":"create_project","arguments":{"location":"/workspace/projects","name":"review"}}}
  152. ```
  153. To open an existing project, use its absolute `.gpr` marker path:
  154. ```json
  155. {"method":"tools/call","params":{"name":"open_project","arguments":{"path":"/workspace/projects/review.gpr"}}}
  156. ```
  157. Neither operation replaces an active project. Opening the same project again returns `already_open`; close a different active project explicitly before creating or opening another one. `restore_state` defaults to `false`; set it to `true` to restore the saved session's tools and views. Use `open_program` to launch CodeBrowser for a project program.
  158. Save changed open project files and session state:
  159. ```json
  160. {"method":"tools/call","params":{"name":"save_project","arguments":{}}}
  161. ```
  162. Close the project after saving:
  163. ```json
  164. {"method":"tools/call","params":{"name":"close_project","arguments":{"save":true}}}
  165. ```
  166. `close_project` defaults to `save=false` and `discard_changes=false`; it refuses unsaved changes unless one is explicitly enabled. These options are mutually exclusive. `discard_changes=true` permits losing unsaved changes. A save failure leaves the project open and reports any files already saved. Closing with no active project returns `already_closed`. Unsaved tool configuration and plugin data may need saving in Ghidra before a safe close, even with `save=true`; explicit discard permits dropping them. Running tool commands and busy project data prevent saving or closing, including closure with discard. The server stays reachable while the project manager remains open, so a client can open the next project using the same connection.
  167. ### Reading pseudocode and function identity
  168. ```json
  169. {"method":"tools/call","params":{"name":"get_pseudocode","arguments":{"function":"main","program_name":"/binaries/example"}}}
  170. ```
  171. Use `get_disassembly` with the same arguments for assembly. `get_function_hash` computes SHA-256 over the function's body bytes; `get_function_byte_pattern` preserves the previous masked-prefix representation. `get_function_prototype` returns the declaration and calling convention.
  172. For grouped reads, `get_pseudocode_batch` accepts a nonempty list of function names, qualified names, or addresses in one program and shares one configured decompiler session:
  173. ```json
  174. {"jsonrpc":"2.0","id":7,"method":"tools/call","params":{"name":"get_pseudocode_batch","arguments":{"functions":["0x401000","0x401080"],"program_name":"/binaries/example"},"_meta":{"progressToken":"batch-a"}}}
  175. ```
  176. Full source is returned by default. Optional `start_line` and `max_lines` select a one-based page for each function. Every item reports its returned range, total line count, completeness, and any error. Code appears once in text content; structured content contains metadata. Use addresses to select functions whose names repeat.
  177. `get_pseudocode_batch` returns its complete result on the original request, with or without a progress token. An optional string or integer `_meta.progressToken` enables native MCP progress. Counts report completed entries and the total requested, including aliases and per-function errors; native decompiler counters cannot reset the batch count. The client timeout applies to the whole batch. See the native progress section below.
  178. Batch decompiler sessions and repeated-function results are reused within a request; batches do not enter the cross-request response cache.
  179. Long-running operations normally return a job ID when async execution is enabled. Poll `get_task_status` with `task_id` to retrieve the result, or `cancel_task` to cancel. These tools are an application job API, separate from the optional MCP Tasks extension.
  180. ### Native MCP progress
  181. `analyze_program`, `rename_symbols_batch`, and `get_pseudocode_batch` return their complete result on the original request on both HTTP transports, without `get_task_status` polling. An optional string or integer progress token in request metadata enables native progress updates:
  182. ```json
  183. {"jsonrpc":"2.0","id":7,"method":"tools/call","params":{"name":"analyze_program","arguments":{"scope":"current","mode":"changes","program_name":"/binaries/example"},"_meta":{"progressToken":"analysis-a"}}}
  184. ```
  185. Ghidra's existing analysis progress is sent through SDK-native `notifications/progress`, correlated with the original token and mapped to 0–100 percent, including `scope="all_open"`. Batch renames advance only when an item's success or failure is settled; queued variable renames finish after their grouped decompilation and per-item transactions. Result order and partial-success reporting are preserved. Intermediate updates are coalesced; initial and final progress are preserved. Progress reaching its declared total means processing finished; the final tool result still reports operation errors.
  186. Without a supported token, these tools still return their final result directly and send no progress notifications. The client's request timeout applies to the whole operation. Notifications stop before the final response, and a failed notification channel does not discard the computation. See the MCP [progress contract](https://modelcontextprotocol.io/specification/2025-11-25/basic/utilities/progress).
  187. Protocol-level request cancellation is deferred; this feature does not add a `notifications/cancelled` handler. Existing application jobs still support `cancel_task`.
  188. ### Program and cursor context
  189. Use `list_open_programs` to obtain exact project paths for `program_name`. Missing or ambiguous explicit targets return an error. Cursor queries refer to the focused CodeBrowser and do not accept a separate program selector. Project operations do not need a loaded program; `import_file.program_name` names the imported program.
  190. Responses carry context information while preserving MCP error flags, structured data, and other content. For example:
  191. ```text
  192. [Context] Operating on: example | Active window: another_program
  193. <tool result>
  194. ```
  195. ## Shared runtime and views
  196. One application runtime owns the server, backend, configuration, and bounded log. Ghidra requires a plugin adapter and UI provider per window; each is a view of that same runtime. Views replay the shared log when opened, configuration saves refresh every view, and “Clear Shared Log” clears it everywhere. Closing any or all CodeBrowsers leaves the server running while the project manager remains open.
  197. The module initializer attaches the project-manager application plugin, including for existing saved profiles. It skips headless Ghidra, which uses the launcher described above. The application plugin automatically attaches MCP views to CodeBrowsers, and `open_program` uses public Ghidra ToolServices and ProgramManager APIs to launch or reuse a browser.
  198. ## MCP protocol support
  199. The extension uses Java SDK 2.0.1. Streamable HTTP at `http://localhost:8080/mcp` supports protocol `2025-11-25` and is the preferred endpoint. Legacy SSE at `/sse` and messages at `/message` use protocol `2024-11-05`. Tool availability changes are delivered without restarting the transport, and resource URI patterns are registered as resource templates.
  200. The latest MCP revision is `2026-07-28`; full support depends on the Java SDK's next major line. See the [official SDK roadmap](https://github.com/modelcontextprotocol/java-sdk/blob/main/ROADMAP.md). The implementation and follow-up plan are detailed in [the review](docs/modernization-review.md).
  201. Six program resource templates expose metadata, functions, strings, imports, exports, and segments. Seven prompts cover function analysis, documentation, data flow, network data, defensive vulnerability review, comparison, and structure inference. Prompt guidance uses the explicit tool catalog.
  202. ## Development
  203. ### Project Structure
  204. ```plaintext
  205. src/main/java/ghidrassistmcp/
  206. ├── GhidrAssistMCPInitializer.java # Application bootstrap
  207. ├── GhidrAssistMCPApplicationPlugin.java # Project-manager owner
  208. ├── GhidrAssistMCPPlugin.java # CodeBrowser adapter
  209. ├── GhidrAssistMCPManager.java # Singleton coordinator
  210. ├── GhidrAssistMCPProvider.java # UI provider with tabs
  211. ├── GhidrAssistMCPServer.java # MCP server implementation
  212. ├── GhidrAssistMCPBackend.java # Backend tool/resource/prompt management
  213. ├── McpBackend.java # Backend interface
  214. ├── McpTool.java # Tool interface
  215. ├── McpEventListener.java # Event notification interface
  216. ├── cache/ # Caching system
  217. ├── project/ # GUI project lifecycle controller
  218. ├── tasks/ # Async task system
  219. ├── resources/ # MCP resources
  220. ├── prompts/ # MCP prompts
  221. └── tools/ # Tool implementations
  222. ```
  223. ### Adding New Tools
  224. 1. **Implement McpTool interface**:
  225. ```java
  226. public class MyCustomTool implements McpTool {
  227. @Override
  228. public String getName() { return "my_custom_tool"; }
  229. @Override
  230. public String getDescription() { return "Description"; }
  231. @Override
  232. public boolean isReadOnly() { return true; }
  233. @Override
  234. public boolean isLongRunning() { return false; }
  235. @Override
  236. public boolean isCacheable() { return true; }
  237. @Override
  238. public McpSchema.JsonSchema getInputSchema() { /* ... */ }
  239. @Override
  240. public McpSchema.CallToolResult execute(Map<String, Object> arguments, Program program) {
  241. // Implementation; use isError(true) for operation failures
  242. }
  243. }
  244. ```
  245. 2. **Register in backend** (after built-in catalog rationalization):
  246. ```java
  247. // In GhidrAssistMCPBackend constructor
  248. registerTool(new MyCustomTool());
  249. ```
  250. ### Build Commands
  251. ```bash
  252. # Clean build
  253. ./gradlew clean
  254. # Build extension zip (written to dist/)
  255. ./gradlew buildExtension
  256. # Install (extract) extension into the Ghidra user Extensions directory
  257. ./gradlew installExtension
  258. # Uninstall (delete extracted directory from the Ghidra user Extensions directory)
  259. ./gradlew uninstallExtension
  260. # Build/install with specific Ghidra path (required if GHIDRA_INSTALL_DIR isn't set)
  261. ./gradlew -PGHIDRA_INSTALL_DIR=/path/to/ghidra installExtension
  262. # Debug build
  263. ./gradlew buildExtension --debug
  264. ```
  265. ### Dependencies
  266. - **MCP SDK**: `io.modelcontextprotocol.sdk:mcp-core:2.0.1` and `mcp-json-jackson2:2.0.1`
  267. - **Jetty Server**: `12.1.14` with EE11 servlet support (HTTP/SSE transport)
  268. - **Jackson**: `2.21.1` (annotations `2.21`) (JSON processing)
  269. - **Ghidra API**: Bundled with Ghidra installation
  270. The SDK, JSON, HTTP, and supporting runtime libraries are bundled into one jar under private package names. This prevents Ghidra's older Jackson and SLF4J classes, or another extension's dependencies, from overriding the server's selected versions. Historical generated `lib/` jars are excluded from the ZIP.
  271. ## Logging
  272. ### UI Logging
  273. The **Log** tab provides real-time monitoring:
  274. - **Session Events**: Server start/stop, program changes
  275. - **Tool Requests**: `REQ: tool_name {parameters...}`
  276. - **Tool Responses**: `RES: tool_name {response...}`
  277. - **Error Messages**: Failed operations and diagnostics
  278. - **Cache Hits**: When cached results are returned
  279. ### Console Logging
  280. Detailed logging in Ghidra's console:
  281. - Tool registration and initialization
  282. - MCP server lifecycle events
  283. - Async task execution and completion
  284. - Cache statistics
  285. - Database transaction operations
  286. - Error stack traces and debugging information
  287. ## Troubleshooting
  288. ### Common Issues
  289. #### Server Won't Start
  290. - Check if port 8080 is available
  291. - Verify Ghidra installation path
  292. - Examine console logs for errors
  293. #### Tools Not Appearing
  294. - Ensure plugin is enabled
  295. - Check Configuration tab for tool status
  296. - Verify backend initialization in logs
  297. #### MCP Client Connection Issues
  298. - Confirm server is running (check GhidrAssistMCP window)
  299. - Test connection: `curl http://localhost:8080/sse`
  300. - Check firewall settings
  301. #### Tool Execution Failures
  302. - Verify program is loaded in Ghidra
  303. - Check tool parameters are correct
  304. - Review error messages in Log tab
  305. #### Async Task Issues
  306. - Use `get_task_status` to check task state
  307. - Use `list_tasks` to see all tasks
  308. - Use `cancel_task` if a task is stuck
  309. ### Debug Mode
  310. Enable debug logging by adding to Ghidra startup:
  311. ```bash
  312. -Dlog4j.logger.ghidrassistmcp=DEBUG
  313. ```
  314. ## Contributing
  315. 1. **Fork the repository**
  316. 2. **Create a feature branch**: `git checkout -b feature-name`
  317. 3. **Make your changes** with proper tests
  318. 4. **Follow code style**: Use existing patterns and conventions
  319. 5. **Submit a pull request** with detailed description
  320. ### Code Standards
  321. - **Java 25 baseline** for builds and runtime validation
  322. - **Proper exception handling** with meaningful messages
  323. - **Transaction safety** for all database operations
  324. - **Thread safety** for UI operations
  325. - **Comprehensive documentation** for public APIs
  326. - **Explicit operation names** and focused schemas over shared implementations
  327. ## License
  328. This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
  329. ## Acknowledgments
  330. - **NSA/Ghidra Team** for the excellent reverse engineering platform
  331. - **Anthropic** for the Model Context Protocol specification
  332. ---
  333. **Questions or Issues?**
  334. Please open an issue on the project repository for bug reports, feature requests, or questions about usage and development.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.