Back to search
ghidra-headless-mcp
SkillGitHub
Headless Ghidra MCP server — giving AI agents deep reverse-engineering capabilities.
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Checked today
Badge for your README
Markdown
[](/listings/mrphrazer--ghidra-headless-mcp)HTML
<a href="/listings/mrphrazer--ghidra-headless-mcp"><img src="/api/listings/mrphrazer--ghidra-headless-mcp/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.
From the repo root:
python3 -m venv .venv . .venv/bin/activate pip install .
For development:
pip install -e ".[dev]"
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 · 640 lines
View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)
- # Ghidra Headless MCP
- A headless [Ghidra](https://ghidra-sre.org/) server that speaks [MCP](https://modelcontextprotocol.io/) (Model Context Protocol), giving AI agents full access to deep reverse-engineering workflows: program lifecycle, disassembly, decompilation, patching, types, xrefs, scripting, and more, without a GUI.
- Designed to run in the same Docker container as the agent runtime. No sidecars, no extra services.
- This entire project---code, tests, and documentation---is 100% vibe coded.
- ## Why
- Existing Ghidra automation usually assumes either interactive GUI use or ad hoc scripts with a narrow workflow. This server is headless-only and designed for agent-driven workflows in sandboxed VM/container environments: the agent gets full control over the analysis system, automating large parts of reverse engineering while you interactively discuss and steer the process.
- The goal is an interface where agents can inspect, refine, and extend an analysis over time: updating types, symbols, and metadata, improving the analysis database incrementally, applying patches and iterating safely with transactions and undo/redo, and running custom scripts when a workflow needs something bespoke.
- ## Features
- - **212 tools** across **34 feature groups**: project and program lifecycle, disassembly, decompilation, patching, transactions, types, layouts, memory, search, graph extraction, scripting, and more.
- - **Read-only by default** with safe mutation workflows (transactions, undo/redo, explicit save paths).
- - **Scripting access** via `ghidra.eval`, `ghidra.call`, and `ghidra.script` for anything the tool catalog doesn't cover.
- - **Stdio and TCP transports.**
- - **Real `pyghidra` backend** for live headless Ghidra workflows.
- - **Fake backend mode** for CI and development without a Ghidra install.
- ## Prerequisites
- - Python `3.11+`
- - A [Ghidra](https://ghidra-sre.org/) installation plus `pyghidra` in your runtime (for real analysis)
- - For CI/development without Ghidra, use fake backend mode
- ## Installation
- From the repo root:
- ```bash
- python3 -m venv .venv
- . .venv/bin/activate
- pip install .
- ```
- For development:
- ```bash
- pip install -e ".[dev]"
- ```
- ## Quick Start
- Stdio transport (default):
- ```bash
- GHIDRA_INSTALL_DIR=/ABSOLUTE/PATH/TO/ghidra python3 ghidra_headless_mcp.py
- ```
- TCP transport:
- ```bash
- GHIDRA_INSTALL_DIR=/ABSOLUTE/PATH/TO/ghidra python3 ghidra_headless_mcp.py --transport tcp --host 127.0.0.1 --port 8765
- ```
- Fake backend mode (no Ghidra required):
- ```bash
- python3 ghidra_headless_mcp.py --fake-backend
- ```
- Installed console script:
- ```bash
- ghidra-headless-mcp --version
- ```
- ## Use With AI Agents
- This server speaks standard MCP over `stdio` (default) or `tcp`, so any MCP-capable agent host can use it.
- ### Claude Code
- ```bash
- claude mcp add ghidra_headless_mcp -- python3 /path/to/ghidra-headless-mcp/ghidra_headless_mcp.py --ghidra-install-dir /ABSOLUTE/PATH/TO/ghidra
- ```
- Or add it to your project's `.mcp.json`:
- ```json
- {
- "mcpServers": {
- "ghidra_headless_mcp": {
- "command": "python3",
- "args": [
- "ghidra_headless_mcp.py",
- "--ghidra-install-dir",
- "/ABSOLUTE/PATH/TO/ghidra"
- ],
- "cwd": "/path/to/ghidra-headless-mcp"
- }
- }
- }
- ```
- For fake mode, append `--fake-backend` and omit the install dir.
- ### Codex
- ```bash
- codex mcp add ghidra_headless_mcp -- python3 ghidra_headless_mcp.py --ghidra-install-dir /ABSOLUTE/PATH/TO/ghidra
- ```
- ### Generic MCP Host
- - Register a server named `ghidra_headless_mcp`.
- - Use command `python3` with args `["ghidra_headless_mcp.py", "--ghidra-install-dir", "/ABSOLUTE/PATH/TO/ghidra"]` when `cwd` is the repo root, or use an absolute script path in `args`.
- - Set `cwd` to the repo path if you want relative paths like `samples/ls` to resolve correctly.
- - Use stdio transport unless your host requires TCP.
- - For fake mode (no Ghidra installed), append `--fake-backend`.
- - Verify connectivity by calling `health.ping`, then `program.open`.
- ## Docker Co-Location Pattern
- Recommended deployment model: run the agent process and this MCP server in the same container image.
- Example baseline:
- ```dockerfile
- FROM kalilinux/kali-rolling:latest
- RUN apt-get update && apt-get install -y --no-install-recommends \
- python3 python3-pip ghidra
- WORKDIR /app
- COPY . /app
- RUN python3 -m pip install --upgrade pip --break-system-packages \
- && python3 -m pip install ".[dev]" --break-system-packages
- CMD ["python3", "ghidra_headless_mcp.py", "--fake-backend"]
- ```
- If you need real Ghidra analysis in-container, keep Ghidra installed in that same image and set `GHIDRA_INSTALL_DIR` or pass `--ghidra-install-dir`.
- ## MCP Methods
- - `initialize`
- - `ping`
- - `tools/list`
- - `tools/call`
- - `shutdown`
- `tools/list` behavior:
- - Without explicit pagination params, returns the full tool catalog.
- - If `offset` or `limit` is provided, uses paginated output (`offset=0`, `limit=50` default in paged mode).
- - Supports filtering via:
- - `prefix` (for example `program.`)
- - `query` (substring match against tool name/description)
- - Returns pagination metadata: `offset`, `limit`, `total`, `has_more`.
- - When a page is truncated (`has_more=true`), includes `next_offset` and a `notice` hint.
- Tool call response behavior:
- - `structuredContent` is the canonical full payload.
- - `content[0].text` is a compact summary string (not full JSON duplication).
- - This split is intentional to keep context usage smaller while still exposing full machine-readable data.
- ## Quality And Testing
- This repository is well tested and has enforced quality gates.
- - Test suite: run `pytest --collect-only -q` for the current collected test count.
- - CI workflow enforces:
- - `ruff format --check .`
- - `ruff check .`
- - `pytest -m "not live"`
- - `pytest -m live`
- - clean-copy wheel build and install verification
- - Fake backend coverage runs without requiring a Ghidra install.
- - Additional structural tests verify tool registry consistency, server behavior, and backend reachability.
- ## Command-Line Client (ghidra_cli)
- `ghidra_cli` is a native command-line client that exposes **all** of the server's tools to agents
- and shells that do not speak the MCP protocol. It is a thin front end over the *same* dispatch code
- path as the MCP server, so results are identical to calling the tool over MCP. The tool catalog,
- parameters, and types are derived from the server's registry, so the CLI never drifts.
- Two execution modes:
- - **In-process** (default, no server needed): builds a backend in the CLI process and dispatches
- directly. State is ephemeral per invocation — good for stateless calls, CI, and self-contained
- `batch` sequences.
- - **Remote** (`--connect HOST:PORT`, or a managed background server): a JSON-RPC/TCP client to a
- long-lived server, so **session state persists across invocations**. This is the recommended mode
- for multi-step reverse engineering and the only practical mode for the real backend (whose JVM
- startup is slow).
- ### Quick start
- ```bash
- # No server: one-shot, fake backend
- ghidra_cli --fake-backend call health.ping
- # Managed background server (persistent sessions), then drive it with plain calls:
- ghidra_cli --ghidra-install-dir /ABSOLUTE/PATH/TO/ghidra server start
- SID=$(ghidra_cli --field session_id call program.open --path /bin/ls)
- ghidra_cli call function.list --session-id "$SID" --limit 20
- ghidra_cli --field 'items.0.name' call function.list --session-id "$SID"
- ghidra_cli server stop
- ```
- Once a managed server is running, `call`/`batch`/`raw`/`list` auto-connect to it. You can also point
- at any TCP server with `--connect 127.0.0.1:8765` or the `GHIDRA_CLI_CONNECT` env var, and set a
- default session with `--session-id` or `GHIDRA_CLI_SESSION`.
- ### Verbs
- ```
- ghidra_cli [GLOBAL OPTS] <verb> ...
- call <tool.name> [--param value ...] Invoke one tool.
- list | tools [--prefix P] [--query Q] [--offset N] [--limit N] [--names-only]
- describe <tool.name> Show description + parameters (type/required/default).
- raw <method> [--params JSON | --params-stdin] [--yes] Send arbitrary JSON-RPC (bypasses coercion).
- batch [FILE|-] [--continue-on-error] [--no-autosession] [--close-after]
- server start|stop|status|restart [--host H] [--port P]
- GLOBAL OPTS (before the verb):
- --connect HOST:PORT | --fake-backend | --ghidra-install-dir DIR | --in-process | --[no-]deterministic
- --session-id ID (default: $GHIDRA_CLI_SESSION)
- --raw | --quiet | --field DOTPATH
- ```
- `list` and `describe` answer locally from the tool registry, so they work without any backend.
- `batch` reads a JSONL stream of `{"tool": ..., "arguments": {...}}` and runs it against one
- transport in order; the most recent `session_id` is auto-threaded into later lines, making
- multi-step workflows possible without a running server.
- A complete, agent-oriented command reference listing **all 212 tools** — each with its description
- and exact `ghidra_cli call` invocation (parameters, types, defaults) — lives in
- [`GHIDRA_CLI.md`](GHIDRA_CLI.md). At runtime, `ghidra_cli list` and `ghidra_cli describe <tool>` are
- the always-current equivalents.
- ### Passing arguments
- Each tool parameter maps to a `--flag`. Values are coerced from the tool's schema:
- | Parameter kind | How to pass it |
- | --- | --- |
- | string | `--name main` |
- | integer | `--limit 50`, `--offset 0x10` (accepts `0x`/`0o`/`0b`, else decimal) |
- | boolean | `--read-only false` (true/false/yes/no/on/off/1/0), or bare `--read-only` for true |
- | number | `--threshold 1.5` |
- | address | `--function_start 0x401000` — **passed through as a string** so Ghidra applies its own parsing (a bare-digit address is read as hex). For a decimal integer address use `--function_start:int 4198400`. |
- | array | repeat the flag: `--script_args a --script_args b`, or `--values:json '[1,2]'` |
- | object | `--kwargs:json '{"k": 1}'` |
- Extra controls:
- - **Full-args escape:** `--json '{...}'` (or `--json-stdin`) sets the whole arguments object; any
- `--flag` overrides individual keys on top of it.
- - **Typed overrides:** `--key:TYPE value` with `TYPE` ∈ `str|int|float|bool|json|null`. `--key:null`
- sets a JSON `null` (e.g. `variable.comment.set --comment:null` clears a comment).
- - **Value sources:** `--code @script.py` reads a file, `--code -` reads stdin — keeps large or
- sensitive values out of `argv` (and process listings/shell history).
- ### Output and exit codes
- Output goes to stdout (diagnostics to stderr): the tool's `structuredContent` as pretty JSON by
- default, `--raw` for the full result envelope, `--quiet` for the summary line, or `--field DOTPATH`
- to extract one value (e.g. `--field session_id`, `--field items.0.name`).
- - exit `0` — success
- - exit `1` — the tool ran but reported an error (`isError`)
- - exit `2` — usage/client error (unknown tool, bad flag/value, malformed `--json`) or a
- connection/transport failure
- ### Security
- All tools — including `ghidra.eval`, `ghidra.call`, and `ghidra.script`, which run arbitrary
- Python/Java/scripts inside the Ghidra runtime — are available with no extra flag, matching the MCP
- surface. The TCP/managed server binds `127.0.0.1` only and has **no authentication**: anyone with
- localhost access can run arbitrary code through it. Prefer `@file`/stdin value sources for code and
- secrets so they never appear in `argv`. `raw shutdown` against a shared server requires `--yes`.
- ## Context Controls
- - Read-only mode is the default for opened programs (`read_only=true`).
- - Raw scripting/API tools reject read-only program sessions unless `write=true`; this guard protects
- program-session state but does not sandbox Python, Java, filesystem, or process access.
- - Deterministic process-level startup is enabled by default and can be disabled with `--no-deterministic`.
- - Many list/search surfaces are paginated with `offset` and `limit`.
- ## Limitations
- - Debugger-oriented Ghidra workflows are not currently covered.
- - Version Tracking, FID, BSim, and emulator workflows are not currently exposed.
- ## Security Model
- - MCP communication (`stdio`/`tcp`) is unauthenticated by default.
- - The server exposes arbitrary scripting via `ghidra.eval` and broad API access via `ghidra.call`.
- - This is by design for trusted, containerized agent environments.
- - Do not expose this server directly to untrusted users or networks.
- ## Local Dev Workflow
- ```bash
- python3 -m ruff format --check .
- python3 -m ruff check .
- python3 -m pytest -m "not live"
- GHIDRA_INSTALL_DIR=/usr/share/ghidra python3 -m pytest -m live
- ```
- Release process notes live in `RELEASING.md`. Public GitHub source releases remain blocked until an explicit repository license is chosen.
- ## Feature Fuzzer
- Use the built-in MCP feature fuzzer to exercise a broad tool surface against `samples/ls`.
- Real Ghidra backend:
- ```bash
- python3 -m ghidra_headless_mcp.fuzzer --backend-mode live --sample-path samples/ls --rounds 1 --seed 1337 --ghidra-install-dir /ABSOLUTE/PATH/TO/ghidra
- ```
- Fake backend smoke run:
- ```bash
- python3 -m ghidra_headless_mcp.fuzzer --backend-mode fake --sample-path samples/ls --rounds 2 --limit 40
- ```
- Target a specific tool family:
- ```bash
- python3 -m ghidra_headless_mcp.fuzzer --backend-mode live --prefix function. --rounds 2 --fail-fast --ghidra-install-dir /ABSOLUTE/PATH/TO/ghidra
- ```
- Useful flags:
- - `--limit N`: fuzz only the first `N` tools from the selected set.
- - `--prefix PREFIX`: restrict fuzzing to one tool family.
- - `--rounds N`: run richer optional-argument coverage in later rounds.
- - `--fail-fast`: stop on the first failing case.
- - `--verbose-results`: include per-case results in CLI JSON output.
- ## Feature Catalog
- The server currently exposes `212` tools across `34` feature groups. The broader capability matrix by feature family lives in `FEATURE_SUPPORT.md`.
- ### Core and Infrastructure
- #### analysis
- - `analysis.analyzers.list`: List boolean analyzers available for the current program and show whether each one is enabled.
- - `analysis.analyzers.set`: Enable or disable a specific boolean analyzer for the current program.
- - `analysis.clear_cache`: Clear cached decompiler state for the current session so later requests rebuild it cleanly.
- - `analysis.options.get`: Return the current value of a specific analysis option.
- - `analysis.options.list`: List available analysis options together with their current values.
- - `analysis.options.set`: Update the value of an analysis option for the current session.
- - `analysis.status`: Return the current auto-analysis status for the session.
- - `analysis.update`: Start auto-analysis in the background and return immediately.
- - `analysis.update_and_wait`: Run auto-analysis and wait until it completes.
- #### health
- - `health.ping`: Confirm that the server is reachable and responding.
- #### mcp
- - `mcp.response_format`: Explain how MCP tool responses split full structured data and human-readable summary text.
- #### task
- - `task.analysis_update`: Start auto-analysis as a tracked background task and return a task ID.
- - `task.cancel`: Request cancellation for a running or queued asynchronous task.
- - `task.result`: Return the terminal result or error payload for a completed task.
- - `task.status`: Return status, timing, and cancellation details for an asynchronous task.
- ### Project, Program, and Transactions
- #### program
- - `program.close`: Close an open program session and release its associated resources.
- - `program.export_binary`: Export the program to disk as either the original-file format or raw bytes.
- - `program.image_base.set`: Change the program image base (applied in memory; `commit` controls whether the change is recorded for undo).
- - `program.list_open`: List all program sessions currently held open by the server.
- - `program.mode.get`: Return whether a session is currently read-only or read-write.
- - `program.mode.set`: Switch a session between read-only and read-write mode.
- - `program.open`: Open a binary file for analysis and return a new session.
- - `program.open_bytes`: Open a binary from base64-encoded bytes and return a new session.
- - `program.report`: Return a compact program report with counts plus sample functions, strings, imports, and memory blocks.
- - `program.save`: Save the current program state back into the project.
- - `program.save_as`: Save the current program under a new project path or name.
- - `program.summary`: Return core program metadata such as architecture, memory layout, and entry point.
- #### project
- - `project.export`: Export the current Ghidra project artifacts to a destination directory.
- - `project.file.info`: Return metadata and state flags for a specific project file.
- - `project.files.list`: List project files with folder, content-type, query, and pagination filters.
- - `project.folders.list`: List project folders, optionally walking the tree recursively.
- - `project.program.open`: Open a program already stored in the current project and return a new session.
- - `project.program.open_existing`: Open a program from a named existing Ghidra project and return a new session.
- - `project.search.programs`: Search program files in the project by name or path.
- #### transaction
- - `transaction.begin`: Begin an explicit undo transaction for grouped changes.
- - `transaction.commit`: Commit the active transaction so its changes become undoable.
- - `transaction.redo`: Reapply the most recently undone change.
- - `transaction.revert`: Roll back the active transaction without committing it.
- - `transaction.status`: Return undo, redo, and active-transaction status for the session.
- - `transaction.undo`: Undo the most recently committed change.
- ### Listing, Memory, Disassembly, and Patching
- #### context
- - `context.get`: Return processor context register values at a specific address.
- - `context.ranges`: List address ranges where a processor context register value applies.
- - `context.set`: Set processor context register values across an address range.
- #### listing
- - `listing.clear`: Clear listing content over a range, including optional symbols, comments, references, functions, or context.
- - `listing.code_unit.after`: Return the nearest code unit that follows a given address.
- - `listing.code_unit.at`: Return the code unit that starts exactly at a given address.
- - `listing.code_unit.before`: Return the nearest code unit that precedes a given address.
- - `listing.code_unit.containing`: Return the code unit that contains a given address.
- - `listing.code_units.list`: List code units in a range with pagination and direction controls.
- - `listing.data.at`: Return the defined data item at a specific address.
- - `listing.data.clear`: Clear one or more data definitions starting at an address.
- - `listing.data.create`: Create a data definition of a chosen type at an address.
- - `listing.data.list`: List defined data items in the program with range and pagination controls.
- - `listing.disassemble.function`: Disassemble all instructions that belong to a function body.
- - `listing.disassemble.range`: Disassemble instructions across a selected address range.
- - `listing.disassemble.seed`: Start disassembly from a seed address and follow discovered flows.
- #### memory
- - `memory.block.create`: Create a memory block with permissions, initialization, and an optional comment.
- - `memory.block.remove`: Remove an existing memory block from the program.
- - `memory.blocks.list`: List memory blocks together with addresses, permissions, and sizes.
- - `memory.read`: Read raw bytes directly from program memory.
- - `memory.write`: Write raw bytes directly into program memory.
- #### patch
- - `patch.assemble`: Assemble instruction text at an address and write the resulting bytes.
- - `patch.branch_invert`: Invert a conditional branch instruction in place.
- - `patch.nop`: Replace instructions in a range with NOP bytes.
- ### Symbols, Namespaces, Externals, and References
- #### class
- - `class.create`: Create a class namespace for recovered methods or fields.
- #### equate
- - `equate.clear_range`: Remove equate references across an address range and delete empty equates.
- - `equate.create`: Create an equate and attach it to an operand at an address.
- - `equate.delete`: Delete an equate entirely, or remove one of its references before deletion.
- - `equate.list`: List equates together with values and attached references.
- #### external
- - `external.entrypoint.add`: Add an address to the program's external entry point set.
- - `external.entrypoint.list`: List addresses currently marked as external entry points.
- - `external.entrypoint.remove`: Remove an address from the external entry point set.
- - `external.exports.list`: List symbols exported by the program.
- - `external.function.create`: Create an external function symbol under an external location.
- - `external.imports.list`: List symbols imported by the program.
- - `external.library.create`: Create a new external library record.
- - `external.library.list`: List external libraries known to the program.
- - `external.library.set_path`: Set or update the filesystem path associated with an external library.
- - `external.location.create`: Create an external location for a symbol within a library.
- - `external.location.get`: Return details for a specific external location.
- #### namespace
- - `namespace.create`: Create a namespace under an optional parent namespace.
- #### reference
- - `reference.association.remove`: Remove the symbol association attached to a specific reference.
- - `reference.association.set`: Associate a specific reference with a symbol.
- - `reference.clear_from`: Remove references originating from one address or an address range.
- - `reference.clear_to`: Remove all references that target a specific address.
- - `reference.create.external`: Create a reference from an address to an external location.
- - `reference.create.memory`: Create a memory reference between two program addresses.
- - `reference.create.register`: Create a reference from an address to a register.
- - `reference.create.stack`: Create a reference from an address to a stack location.
- - `reference.delete`: Delete a specific reference selected by source, destination, and operand.
- - `reference.from`: List cross-references that originate from an address.
- - `reference.primary.set`: Mark a specific reference as the primary one for its operand.
- - `reference.to`: List cross-references that target an address.
- #### symbol
- - `symbol.by_name`: Look up a symbol by name and return its details.
- - `symbol.create`: Create a new symbol or label at an address.
- - `symbol.delete`: Delete a symbol at an address, optionally by name.
- - `symbol.list`: List symbols with filtering and pagination support.
- - `symbol.namespace.move`: Move a symbol into a different namespace.
- - `symbol.primary.set`: Mark a selected symbol as the primary symbol at its address.
- - `symbol.rename`: Rename an existing symbol.
- ### Comments, Bookmarks, Tags, Metadata, Source, and Relocations
- #### bookmark
- - `bookmark.add`: Add a bookmark at an address with a type, category, and comment.
- - `bookmark.clear`: Remove bookmarks in an address range, optionally filtered by bookmark type.
- - `bookmark.list`: List bookmarks, optionally scoped to an address or bookmark type.
- - `bookmark.remove`: Remove bookmarks at an address, optionally filtered by type or category.
- #### comment
- - `comment.get`: Return one comment type from a specific address.
- - `comment.get_all`: Return all available comment types at an address, with optional function comments.
- - `comment.list`: List comments matching range, type, text, and pagination filters.
- - `comment.set`: Set or clear a comment of a selected type at an address.
- #### metadata
- - `metadata.query`: Read metadata entries stored by this server, optionally filtered by key or prefix.
- - `metadata.store`: Store a JSON-serializable metadata value under a program-scoped key.
- #### relocation
- - `relocation.add`: Add a relocation entry at an address with type, status, values, and symbol metadata.
- - `relocation.list`: List relocation entries, optionally limited to an address range.
- #### source
- - `source.file.add`: Register a source file record with the program's source file manager.
- - `source.file.list`: List all source files currently registered with the program.
- - `source.file.remove`: Remove a source file record by path.
- - `source.map.add`: Add a source mapping entry from a source line to an address range.
- - `source.map.list`: List source mapping entries by address, source file, or line filters.
- - `source.map.remove`: Remove a specific source mapping entry by file, line, and base address.
- #### tag
- - `tag.add`: Create or reuse a function tag and attach it to a function.
- - `tag.list`: List tags for one function or across the whole program.
- - `tag.remove`: Remove a function tag from a function.
- - `tag.stats`: Summarize function tags and the number of functions using each one.
- ### Functions, Variables, Types, and Layout Reconstruction
- #### function
- - `function.at`: Return the function that starts at, or contains, a specific address.
- - `function.batch.run`: Run one supported action across a filtered batch of functions.
- - `function.body.set`: Replace the body range of an existing function.
- - `function.by_name`: Look up a function by name and return its details.
- - `function.callees`: List the functions called by a specific function.
- - `function.callers`: List the functions that call a specific function.
- - `function.calling_convention.set`: Set the calling convention used by a function.
- - `function.calling_conventions.list`: List calling conventions available in the current program.
- - `function.create`: Create a new function at a given address.
- - `function.delete`: Delete a function at a given address.
- - `function.flags.set`: Update function flags such as varargs, inline, noreturn, or custom storage.
- - `function.list`: List functions in the program with filtering and pagination support.
- - `function.rename`: Rename an existing function.
- - `function.report`: Return a richer function report with signature, variables, call graph edges, xrefs, and decompilation output.
- - `function.return_type.set`: Set the return type of a function.
- - `function.signature.get`: Return the full signature of a function.
- - `function.signature.set`: Apply a full C-style signature declaration to a function.
- - `function.thunk.set`: Mark a function as a thunk to another function.
- - `function.variables`: List parameters and local variables for a function.
- #### layout
- - `layout.enum.create`: Create an enum data type in a chosen category.
- - `layout.enum.member.add`: Add a named value to an enum data type.
- - `layout.enum.member.remove`: Remove a named member from an enum data type.
- - `layout.inspect.components`: Inspect the component layout of a composite data type.
- - `layout.struct.bitfield.add`: Insert a bitfield into a structure at a byte and bit offset.
- - `layout.struct.create`: Create a structure data type in a chosen category.
- - `layout.struct.field.add`: Add a field to a structure at a specific offset or append position.
- - `layout.struct.field.clear`: Clear a field from a structure by offset, ordinal, or field name.
- - `layout.struct.field.comment.set`: Set or clear the comment on a structure field.
- - `layout.struct.field.rename`: Rename a structure field.
- - `layout.struct.field.replace`: Replace an existing structure field with a new type, size, name, or comment.
- - `layout.struct.fill_from_decompiler`: Build or extend a structure from decompiler-observed usage of a variable.
- - `layout.struct.get`: Return a structure definition together with its components.
- - `layout.struct.resize`: Resize a structure to a specific total length.
- - `layout.union.create`: Create a union data type in a chosen category.
- - `layout.union.member.add`: Add a member to a union data type.
- - `layout.union.member.remove`: Remove a member from a union data type.
- #### parameter
- - `parameter.add`: Add a new parameter to a function with a chosen type and storage.
- - `parameter.move`: Reorder a parameter to a new ordinal within the signature.
- - `parameter.remove`: Remove a parameter from a function by ordinal or name.
- - `parameter.replace`: Replace an existing parameter definition by ordinal or name.
- #### stackframe
- - `stackframe.variable.clear`: Clear a stack-frame variable at a specific stack offset.
- - `stackframe.variable.create`: Create a stack-frame variable at a specific stack offset.
- - `stackframe.variables`: List stack-frame variables for a function.
- #### type
- - `type.apply_at`: Apply a data type at an address in the listing.
- - `type.archives.list`: List the current program archive plus attached source archives.
- - `type.category.create`: Create a new data type category path.
- - `type.category.list`: List data type categories under a path, optionally recursively.
- - `type.define_c`: Define a new data type from a C declaration.
- - `type.delete`: Delete a data type by name or full path.
- - `type.get`: Return details for a data type by name or full path.
- - `type.get_by_id`: Look up a data type by internal ID, universal ID, or source archive ID.
- - `type.list`: List data types with filtering and pagination support.
- - `type.parse_c`: Parse a C declaration (including `typedef struct`/composite declarations) and return the resulting type without committing it.
- - `type.rename`: Rename an existing data type.
- - `type.source_archives.list`: List source archives referenced by the current data type manager.
- #### variable
- - `variable.comment.set`: Set or clear the comment attached to a local variable or parameter.
- - `variable.local.create`: Create a local variable with explicit type, storage, and optional comment.
- - `variable.local.remove`: Remove a local variable from a function.
- - `variable.rename`: Rename a local variable or parameter.
- - `variable.retype`: Change the data type of a local variable or parameter.
- ### Decompiler, P-Code, Search, and Graph Extraction
- #### decomp
- - `decomp.ast`: Decompile a function and return the Clang markup tree for the result.
- - `decomp.function`: Decompile a function and return recovered C source code.
- - `decomp.global.rename`: Rename a global symbol selected through decompiler high-symbol information.
- - `decomp.global.retype`: Retype a global symbol selected through decompiler high-symbol information.
- - `decomp.high_function.summary`: Summarize the high-function view, including local symbols, globals, blocks, and jump tables.
- - `decomp.override.get`: Return the decompiler call override, if any, for a specific callsite.
- - `decomp.override.set`: Set or replace the decompiler call override signature for a specific callsite.
- - `decomp.tokens`: Decompile a function and return tokenized Clang markup for the output.
- - `decomp.trace_type.backward`: Trace type propagation backward from a selected decompiler symbol.
- - `decomp.trace_type.forward`: Trace type propagation forward from a selected decompiler symbol.
- - `decomp.writeback.locals`: Commit decompiler-recovered local names back into the program database.
- - `decomp.writeback.params`: Commit decompiler-recovered parameter information back into the program database.
- #### ghidra
- - `ghidra.call`: Invoke Ghidra or Java APIs directly through a generic bridge.
- - `ghidra.eval`: Evaluate Python code inside the live Ghidra runtime context.
- - `ghidra.info`: Return runtime information about Ghidra, PyGhidra, and the server environment.
- - `ghidra.script`: Run a Ghidra script against an open program session.
- #### graph
- - `graph.basic_blocks`: List the basic blocks that make up a function.
- - `graph.call_paths`: Find call graph paths between two functions up to a chosen depth.
- - `graph.cfg.edges`: List control-flow edges between the basic blocks of a function.
- #### pcode
- - `pcode.block`: Return per-instruction p-code for the basic block containing an address.
- - `pcode.function`: Return per-instruction p-code for a function.
- - `pcode.op.at`: Return the p-code ops generated by the instruction at an address.
- - `pcode.varnode_uses`: Find p-code reads and writes that match a selected varnode.
- #### search
- - `search.bytes`: Search program memory for an exact byte pattern.
- - `search.constants`: Search instructions for scalar constant operands that match a value.
- - `search.defined_strings`: List defined strings discovered in the program.
- - `search.instructions`: Search instructions by mnemonic or rendered instruction text.
- - `search.pcode`: Search p-code operations by mnemonic or rendered op text.
- - `search.resolve`: Resolve a symbol name or expression into an address.
- - `search.text`: Search for text across defined strings and raw memory matches.
- ## Contact
- For more information, contact Tim Blazytko ([@mr_phrazer](https://x.com/mr_phrazer)).
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.