Skip to content
Back to search

binary-ninja-headless-mcp

Headless Binary Ninja MCP server — giving AI agents deep reverse-engineering capabilities via 180 tools.

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
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/mrphrazer--binary-ninja-headless-mcp/badge.svg)](/listings/mrphrazer--binary-ninja-headless-mcp)

HTML

<a href="/listings/mrphrazer--binary-ninja-headless-mcp"><img src="/api/listings/mrphrazer--binary-ninja-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.

git clone https://github.com/mrphrazer/binary-ninja-headless-mcp.git
cd binary-ninja-headless-mcp
pip install .

Or install directly from the repo root without cloning:

pip install git+https://github.com/mrphrazer/binary-ninja-headless-mcp.git

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 · 603 lines

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

  1. # Binary Ninja Headless MCP
  2. A headless [Binary Ninja](https://binary.ninja/) server that speaks [MCP](https://modelcontextprotocol.io/) (Model Context Protocol), giving AI agents full access to deep reverse-engineering workflows — disassembly, IL, patching, types, xrefs, and more — without a GUI.
  3. Designed to run in the same Docker container as the agent runtime. No sidecars, no extra services.
  4. This entire project---code, tests, and documentation---is 100% vibe coded.
  5. ## Why
  6. Existing Binary Ninja MCP servers are either GUI-bound or expose a limited tool surface. 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.
  7. 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 undo/redo, and running custom scripts when a workflow needs something bespoke.
  8. ## Features
  9. - **181 tools** across 36 feature groups: analysis, disassembly, IL, patching, undo/redo, types, workflows, memory, search, xrefs, scripting, and more.
  10. - **Read-only by default** with safe mutation workflows (undo/redo, transactions).
  11. - **Scripting access** via `binja.eval` and `binja.call` for anything the tool catalog doesn't cover.
  12. - **Stdio and TCP transports.**
  13. - **Complete command-line client** (`binja_cli` / `binja-cli`) with schema-derived
  14. flags, JSON batches, offline discovery, and managed persistent servers.
  15. - **Zero runtime dependencies** beyond Binary Ninja itself.
  16. - **Fake backend mode** for CI and development without a Binary Ninja license.
  17. ## Prerequisites
  18. - Python `3.11+`
  19. - A [Binary Ninja](https://binary.ninja/) installation with a headless-capable license and the `binaryninja` Python module importable in your runtime (for real analysis)
  20. - For CI/development without Binary Ninja, use fake backend mode
  21. ## Installation
  22. ```bash
  23. git clone https://github.com/mrphrazer/binary-ninja-headless-mcp.git
  24. cd binary-ninja-headless-mcp
  25. pip install .
  26. ```
  27. Or install directly from the repo root without cloning:
  28. ```bash
  29. pip install git+https://github.com/mrphrazer/binary-ninja-headless-mcp.git
  30. ```
  31. ## Quick Start
  32. ### Command-line client
  33. The CLI exposes every MCP tool through the same backend. Its usage follows
  34. Ghidra's `ghidra_cli`. See the [complete CLI guide and generated tool reference](BINJA_CLI.md)
  35. for arguments, defaults, sessions, batches, scripting, output, and troubleshooting.
  36. ```bash
  37. binja_cli list --names-only # Works without Binary Ninja
  38. binja_cli describe session.open
  39. binja_cli server start # Requires licensed Binary Ninja
  40. SID=$(binja_cli --field session_id call session.open --path /bin/ls)
  41. binja_cli --session-id "$SID" call binary.functions --limit 5
  42. binja_cli call session.close --session-id "$SID"
  43. binja_cli server stop
  44. ```
  45. Use `python3 -m binary_ninja_headless_mcp.binja_cli` from a source checkout.
  46. For a license-free client check, run `binja_cli --fake-backend call health.ping`.
  47. Managed sessions persist across commands; in-process sessions last one invocation.
  48. The managed default is `127.0.0.1:8766`. TCP exposes powerful analysis and Python
  49. execution capabilities without authentication; keep it accessible only to trusted clients.
  50. ### MCP server
  51. Stdio transport (default):
  52. ```bash
  53. python3 binary_ninja_headless_mcp.py
  54. ```
  55. TCP transport:
  56. ```bash
  57. python3 binary_ninja_headless_mcp.py --transport tcp --host 127.0.0.1 --port 8765
  58. ```
  59. Fake backend mode (no Binary Ninja required):
  60. ```bash
  61. python3 binary_ninja_headless_mcp.py --fake-backend
  62. ```
  63. ## Use With AI Agents
  64. This server speaks standard MCP over `stdio` (default) or `tcp`, so any MCP-capable agent host can use it.
  65. ### Claude Code
  66. ```bash
  67. claude mcp add binary_ninja_headless_mcp -- python3 /path/to/binary-ninja-headless-mcp/binary_ninja_headless_mcp.py
  68. ```
  69. Or add it to your project's `.mcp.json`:
  70. ```json
  71. {
  72. "mcpServers": {
  73. "binary_ninja_headless_mcp": {
  74. "command": "python3",
  75. "args": ["binary_ninja_headless_mcp.py"],
  76. "cwd": "/path/to/binary-ninja-headless-mcp"
  77. }
  78. }
  79. }
  80. ```
  81. ### Codex
  82. ```bash
  83. codex mcp add binary_ninja_headless_mcp -- python3 binary_ninja_headless_mcp.py
  84. ```
  85. ### Generic MCP Host
  86. - Register a server named `binary_ninja_headless_mcp`.
  87. - Use command `python3` with args `["binary_ninja_headless_mcp.py"]` when `cwd` is the repo root, or use an absolute script path in `args`.
  88. - Set `cwd` to the repo path if you want relative paths like `samples/ls` to resolve correctly.
  89. - Use stdio transport unless your host requires TCP.
  90. - For fake mode (no Binary Ninja installed), append `--fake-backend`.
  91. - Verify connectivity by calling `health.ping`, then `session.open`.
  92. ## Docker Co-Location Pattern
  93. Recommended deployment model: run the agent process and this MCP server in the same container image.
  94. Example baseline:
  95. ```dockerfile
  96. FROM python:3.11-slim
  97. WORKDIR /app
  98. COPY . /app
  99. RUN python -m pip install --upgrade pip && pip install ruff pytest
  100. CMD ["python3", "binary_ninja_headless_mcp.py"]
  101. ```
  102. If you need real Binary Ninja analysis in-container, add your Binary Ninja runtime + license setup in this same image and start the agent with this MCP server configured.
  103. ## MCP Methods
  104. - `initialize`
  105. - `ping`
  106. - `tools/list`
  107. - `tools/call`
  108. - `shutdown`
  109. `tools/list` behavior:
  110. - Without explicit pagination params, returns the full tool catalog.
  111. - If `offset` or `limit` is provided, uses paginated output (`offset=0`, `limit=50` default in paged mode).
  112. - Supports filtering via:
  113. - `prefix` (for example `binary.`)
  114. - `query` (substring match against tool name/description)
  115. - Returns pagination metadata: `offset`, `limit`, `total`, `has_more`.
  116. - When a page is truncated (`has_more=true`), includes `next_offset` and a `notice` hint.
  117. Tool call response behavior:
  118. - `structuredContent` is the canonical full payload.
  119. - `content[0].text` is a compact summary string (not full JSON duplication).
  120. - This split is intentional to keep context usage smaller while still exposing full machine-readable data.
  121. ## Quality And Testing
  122. This repository is well tested and has enforced quality gates.
  123. The [CLI verification report](CLI_VERIFICATION.md) records native coverage of all
  124. 181 tools across both architectures, transports, and argument styles, along with
  125. reproduction commands, installed-package checks, lifecycle evidence, and tested
  126. runtime boundaries. The [CLI guide](BINJA_CLI.md) documents everyday usage.
  127. - Test suite: run `pytest --collect-only -q` for the current collected test count.
  128. - CI workflow enforces:
  129. - `ruff format --check .`
  130. - `ruff check .`
  131. - `pytest`
  132. - CI uses `BINARY_NINJA_HEADLESS_MCP_FAKE_BACKEND=1` so checks run without requiring Binary Ninja installation.
  133. - Additional structural tests verify tool registry consistency and backend reachability.
  134. ## Context Controls
  135. - Read-only mode is the default for opened sessions (`read_only=true`).
  136. - `binary.basic_blocks_at` and `function.basic_blocks` are paginated (`offset`/`limit`).
  137. - `memory.read` has a hard response cap: `length <= 65536`.
  138. ## Limitations
  139. - Enterprise APIs are currently not covered.
  140. - Debugger APIs are currently not covered.
  141. ## Security Model
  142. - MCP communication (`stdio`/`tcp`) is unauthenticated by default.
  143. - The server exposes arbitrary scripting via `binja.eval` and broad API access via `binja.call`.
  144. - This is by design for trusted, containerized agent environments.
  145. - Do not expose this server directly to untrusted users or networks.
  146. ## Local Dev Workflow
  147. ```bash
  148. ruff format --check .
  149. ruff check .
  150. BINARY_NINJA_HEADLESS_MCP_FAKE_BACKEND=1 pytest -q
  151. ```
  152. ## Feature Fuzzer
  153. Use the built-in MCP feature fuzzer to exercise a broad tool surface against `samples/ls`.
  154. Real Binary Ninja backend:
  155. ```bash
  156. python3 -m binary_ninja_headless_mcp.fuzzer --binary samples/ls --iterations 120 --seed 1337
  157. ```
  158. Fake backend smoke run:
  159. ```bash
  160. python3 -m binary_ninja_headless_mcp.fuzzer --binary samples/ls --fake-backend --allow-tool-errors --iterations 20
  161. ```
  162. Write a JSON coverage report:
  163. ```bash
  164. python3 -m binary_ninja_headless_mcp.fuzzer --binary samples/ls --report-json /tmp/mcp-fuzzer-report.json
  165. ```
  166. Useful flags:
  167. - `--min-success-tools N`: exits non-zero if fewer than `N` tools succeeded.
  168. - `--verbose`: print each tool call while fuzzing.
  169. - `--update-analysis`: open the seed session with `update_analysis=true`.
  170. ## Analysis and session lifecycle
  171. `session.open`, `session.open_bytes`, and `session.open_existing` with
  172. `update_analysis=true` return only after analysis finishes. `analysis.update_and_wait`
  173. has the same synchronous contract. Neither switches to a task or partial result
  174. on a timer. Sessions are registered before analysis; an analysis failure or
  175. cancellation returns a tool error containing the retained `session_id` in both
  176. structured data and compact text, so another call can inspect, retry, or close it.
  177. `analysis.update` now returns a tracked task, just like `task.analysis_update`.
  178. Poll `task.status` and fetch `task.result` when `result_ready` is true. All terminal
  179. states (`completed`, `failed`, `cancelled`) have a result envelope; failed tasks
  180. include `error`. A pending result request is a tool error. This is a deliberate
  181. change from the earlier untracked `analysis.update` response.
  182. Only one managed analysis may be queued, running, or cancelling per session.
  183. Different sessions can analyze concurrently. `analysis.status` adds `status`,
  184. start/completion timestamps, `last_analysis_task_id`, and `last_analysis_error` to
  185. the existing native `state`, `progress`, `info`, and `is_aborted` fields. These
  186. managed fields are compatible with Ghidra's lifecycle vocabulary; the native
  187. progress fields remain Binary Ninja specific. `has_log` is false: there is no
  188. fabricated Ghidra-style analysis log. Native updates triggered by edits or raw API
  189. calls are visible in native progress but are not separate managed tasks.
  190. Cancelling a queued task removes its analysis reservation without aborting the
  191. view. Cancelling running analysis requests a native abort and retains ownership
  192. until both analysis and abort finish. Once terminal, the session can analyze
  193. again; the workflow suspended by our abort is resumed. Cancelling an old terminal
  194. task has no effect on a later run. Running search tasks are best effort and drain
  195. normally if already started.
  196. An explicit `analysis.set_hold` or disabled workflow is preserved. Analysis returns
  197. an actionable error while held or disabled; a normal native wait return only counts
  198. as completion when the engine reports idle and is not aborted. Release the hold or
  199. enable the workflow before retrying.
  200. Explicit native control changes invalidate an overlapping managed run even if a
  201. later control restores an idle state. New analysis requests are rejected while
  202. control calls are still in flight. A later explicit workflow disable also
  203. takes precedence over the automatic resume associated with an earlier cancellation.
  204. Binary Ninja can mark interrupted initial analysis as finished before completing
  205. function discovery. On retry, the server re-requests linear sweep when the view's
  206. `analysis.linearSweep.autorun` setting permits it, preserving its configured
  207. analysis mode. This recovery is retained until a managed analysis completes.
  208. Native heuristics can still produce a different function set after interruption
  209. in reduced analysis modes. Reopen the original input for an independent fresh
  210. analysis when comparing results; completion means the requested native pass
  211. finished, not proof that every possible function was discovered.
  212. `loader.rebase` requires exclusive use of the session. It rejects active analysis
  213. and other admitted operations; new native calls are rejected during replacement,
  214. while status/list calls use cached metadata. Close waits for replacement to finish.
  215. A rebased view keeps ownership of shared native file metadata, and view-specific
  216. caches are reset. Raw evaluation also protects every session exposed in its context
  217. from concurrent close for the duration of the evaluation.
  218. Use the dedicated lifecycle/control tools for cancellation and rebasing; arbitrary
  219. native calls can bypass managed coordination.
  220. `session.close` prevents new operations, cancels work, and waits for admitted MCP
  221. calls and background tasks before closing the view. Reopened upload sessions share
  222. ownership of their temporary backing file; it is deleted after the last dependent
  223. session closes, so closing a parent does not break its children.
  224. This ownership is established before a reopened session becomes visible, including
  225. while its initial analysis is still running.
  226. If draining or aborting exceeds 30 seconds, it returns an error, retains the
  227. resources in `closing` state, and permits a later `session.close` retry.
  228. `analysis.status`, `session.list`, and task metadata remain available. Shutdown
  229. uses one shared 30-second drain deadline; EOF and transport errors also perform
  230. cleanup. The line-delimited stdio transport processes requests sequentially;
  231. use asynchronous tasks for polling on that connection. A second TCP connection
  232. can inspect or cancel a synchronous call on the first connection.
  233. ## Lifecycle verification
  234. The dedicated stateful driver checks strict results and clean EOF shutdown over
  235. an actual stdio subprocess, and fails on unexpected errors or timeouts:
  236. ```bash
  237. python3 -m binary_ninja_headless_mcp.lifecycle_fuzzer \
  238. --binary samples/ls --seed 1337 --transitions 100 \
  239. --output-dir /tmp/binja-lifecycle-1337
  240. BINJA_NATIVE_TEST_BINARY="$PWD/samples/ls" \
  241. python3 -m pytest tests/test_transport_lifecycle.py
  242. ```
  243. Use a fresh output directory per run. The driver preserves the input, writes a
  244. checkpoint database, incremental request/response trace, progress, stderr, input
  245. hash, engine version, and final report. `--timeout` sets the external response/task
  246. watchdog (default 300 seconds); a timeout fails verification. To run additional
  247. seeds on a large binary, `--analysis-database /path/to/checkpoint.bndb` reuses a
  248. completed analysis in a private copy and records the database hash.
  249. `--load-options '{"analysis.limits.cacheSize":64}'` passes explicit native settings
  250. and records them in the report; neither driver changes product defaults. No native
  251. license is needed for `--fake-backend` smoke runs or deterministic lifecycle race tests.
  252. The broad feature fuzzer excludes plugin execution and repository modification
  253. from live runs; these actions have tests using doubles. `--trace-jsonl` preserves
  254. calls incrementally. It reports an unavailable debug parser explicitly. Its default
  255. exit status fails on all unexpected tool errors; `--allow-tool-errors` is for
  256. exploratory diagnostics and is not a correctness gate. Run it on a disposable copy
  257. when exercising writes. The feature fuzzer also accepts `--load-options` and
  258. `--analysis-database`: it copies the database privately and separately probes raw
  259. byte loading without repeating initial analysis.
  260. ## Feature Catalog
  261. The server currently exposes `181` tools across `36` feature groups.
  262. ### analysis
  263. - `analysis.status`: Get managed lifecycle status/timestamps/task/error plus native state and progress.
  264. - `analysis.progress`: Get analysis progress snapshot.
  265. - `analysis.update`: Start tracked analysis; returns task_id. Rejects overlapping runs on this session.
  266. - `analysis.update_and_wait`: Wait synchronously until analysis finishes; no timed partial-success response.
  267. - `analysis.abort`: Abort analysis.
  268. - `analysis.set_hold`: Hold/release analysis queue.
  269. ### annotation
  270. - `annotation.rename_function`: Rename a function.
  271. - `annotation.rename_symbol`: Rename symbol at address.
  272. - `annotation.undefine_symbol`: Undefine user symbol at address.
  273. - `annotation.define_symbol`: Define symbol at address.
  274. - `annotation.rename_data_var`: Rename data variable.
  275. - `annotation.define_data_var`: Define data variable.
  276. - `annotation.undefine_data_var`: Undefine data variable.
  277. - `annotation.set_comment`: Set comment at address.
  278. - `annotation.get_comment`: Get comment at address.
  279. - `annotation.add_tag`: Add user data tag at address.
  280. - `annotation.get_tags`: Get tags at address.
  281. ### arch
  282. - `arch.info`: Get architecture and platform metadata.
  283. - `arch.disasm_bytes`: Disassemble bytes with selected architecture.
  284. - `arch.assemble`: Assemble instruction text with selected architecture.
  285. ### baseaddr
  286. - `baseaddr.detect`: Run base-address detection.
  287. - `baseaddr.reasons`: Get base-address detection reasons.
  288. - `baseaddr.abort`: Abort base-address detection.
  289. ### binary
  290. - `binary.summary`: Get binary/session summary.
  291. - `binary.save`: Save the current binary view to a file path.
  292. - `binary.functions`: List functions with pagination.
  293. - `binary.strings`: List discovered strings with pagination.
  294. - `binary.search_text`: Search raw text/bytes in a session.
  295. - `binary.sections`: List sections with pagination.
  296. - `binary.segments`: List segments with pagination.
  297. - `binary.symbols`: List symbols with pagination.
  298. - `binary.data_vars`: List data variables with pagination.
  299. - `binary.get_function_at`: Find function by address.
  300. - `binary.get_function_disassembly_at`: Get full disassembly for function containing an address.
  301. - `binary.get_function_il_at`: Get full IL for function containing an address.
  302. - `binary.functions_at`: List functions at an address.
  303. - `binary.basic_blocks_at`: List basic blocks at an address with pagination.
  304. ### binja
  305. - `binja.info`: Return Binary Ninja version/install info.
  306. - `binja.call`: Generic API bridge: call `bn.*` or `bv.*` target path.
  307. - `binja.eval`: Evaluate Python code with `bn`, `sessions`, and optional `bv`.
  308. ### data
  309. - `data.typed_at`: Get typed data variable at an address.
  310. ### database
  311. - `database.create_bndb`: Create .bndb from session.
  312. - `database.save_auto_snapshot`: Save auto snapshot.
  313. - `database.info`: Get database status for session.
  314. - `database.snapshots`: List database snapshots.
  315. - `database.read_global`: Read database global string key.
  316. - `database.write_global`: Write database global string key.
  317. ### debug
  318. - `debug.parsers`: List debug info parsers valid for this view.
  319. - `debug.parse_and_apply`: Parse debug info and apply it to the view.
  320. ### disasm
  321. - `disasm.linear`: Get linear disassembly lines.
  322. - `disasm.function`: Get full disassembly for function containing an address.
  323. - `disasm.range`: Address-range disassembly lines.
  324. ### external
  325. - `external.library_add`: Add external library.
  326. - `external.library_list`: List external libraries.
  327. - `external.library_remove`: Remove external library.
  328. - `external.location_add`: Add external location mapping.
  329. - `external.location_get`: Get external location mapping.
  330. - `external.location_remove`: Remove external location mapping.
  331. ### function
  332. - `function.basic_blocks`: List basic blocks in a function with pagination.
  333. - `function.callers`: Callers of a function.
  334. - `function.callees`: Callees of a function.
  335. - `function.variables`: List function variables.
  336. - `function.var_refs`: List variable references in MLIL/HLIL.
  337. - `function.var_refs_from`: List variable references originating from an address.
  338. - `function.ssa_var_def_use`: Get SSA variable definition and uses.
  339. - `function.ssa_memory_def_use`: Get SSA memory definition and uses by memory version.
  340. - `function.metadata_store`: Store function metadata by key.
  341. - `function.metadata_query`: Query function metadata by key.
  342. - `function.metadata_remove`: Remove function metadata by key.
  343. ### health
  344. - `health.ping`: Health check.
  345. ### il
  346. - `il.function`: IL function listing.
  347. - `il.instruction_by_addr`: Get IL instruction by source address.
  348. - `il.address_to_index`: Map address to IL index/indices.
  349. - `il.index_to_address`: Map IL index to source address.
  350. - `il.rewrite.capabilities`: List IL rewrite support for one function and IL level.
  351. - `il.rewrite.noop_replace`: Perform no-op IL expression replacement.
  352. - `il.rewrite.translate_identity`: Translate IL with identity mapping callback.
  353. ### loader
  354. - `loader.rebase`: Rebase BinaryView.
  355. - `loader.load_settings_types`: List loader settings type names.
  356. - `loader.load_settings_get`: Get loader settings values.
  357. - `loader.load_settings_set`: Set one loader setting value.
  358. ### memory
  359. - `memory.read`: Read bytes from the view (`length <= 65536`).
  360. - `memory.write`: Write bytes (hex) to the view.
  361. - `memory.insert`: Insert bytes (hex) into the view.
  362. - `memory.remove`: Remove bytes from the view.
  363. - `memory.reader_read`: Read integer values via BinaryReader.
  364. - `memory.writer_write`: Write integer values via BinaryWriter.
  365. ### mcp
  366. - `mcp.response_format`: Explain tool result fields (`structuredContent` full payload, `content[0].text` summary).
  367. ### metadata
  368. - `metadata.store`: Store metadata by key.
  369. - `metadata.query`: Query metadata by key.
  370. - `metadata.remove`: Remove metadata by key.
  371. ### patch
  372. - `patch.assemble`: Assemble and patch instruction bytes at address.
  373. - `patch.status`: Inspect patch availability at address.
  374. - `patch.convert_to_nop`: Patch instruction to NOP when supported.
  375. - `patch.always_branch`: Patch conditional branch to always branch when supported.
  376. - `patch.never_branch`: Patch conditional branch to never branch when supported.
  377. - `patch.invert_branch`: Patch conditional branch by inversion when supported.
  378. - `patch.skip_and_return_value`: Patch instruction to skip and return value when supported.
  379. ### plugin
  380. - `plugin.valid_commands`: List context-valid plugin commands.
  381. - `plugin.execute`: Execute a context-valid plugin command.
  382. ### plugin_repo
  383. - `plugin_repo.status`: List plugin repositories and plugin states.
  384. - `plugin_repo.check_updates`: Check plugin repository updates.
  385. - `plugin_repo.plugin_action`: Run install/uninstall/enable/disable action on repository plugin.
  386. ### project
  387. - `project.create`: Create project.
  388. - `project.open`: Open project.
  389. - `project.close`: Close tracked project.
  390. - `project.list`: List project folders/files.
  391. - `project.create_folder`: Create project folder.
  392. - `project.create_file`: Create project file from base64 data.
  393. - `project.metadata_store`: Store project metadata.
  394. - `project.metadata_query`: Query project metadata.
  395. - `project.metadata_remove`: Remove project metadata.
  396. ### search
  397. - `search.data`: Search for raw byte patterns (hex string).
  398. - `search.next_text`: Find next text match.
  399. - `search.all_text`: Find all text matches in range (regex optional).
  400. - `search.next_data`: Find next data/byte-pattern match.
  401. - `search.all_data`: Find all data/byte-pattern matches in range.
  402. - `search.next_constant`: Find next constant occurrence.
  403. - `search.all_constant`: Find all constant occurrences in range.
  404. ### section
  405. - `section.add_user`: Add user section.
  406. - `section.remove_user`: Remove user section.
  407. ### segment
  408. - `segment.add_user`: Add user segment.
  409. - `segment.remove_user`: Remove user segment.
  410. ### session
  411. - `session.open`: Open a binary and create a session.
  412. - `session.open_bytes`: Open a binary session from base64-encoded bytes.
  413. - `session.open_existing`: Open another session from an existing session's file.
  414. - `session.close`: Close one open session.
  415. - `session.list`: List open sessions.
  416. - `session.mode`: Get session safety/determinism mode.
  417. - `session.set_mode`: Update session safety/determinism mode.
  418. ### task
  419. - `task.analysis_update`: Alias of analysis.update: start tracked analysis and return task_id.
  420. - `task.search_text`: Start async search task.
  421. - `task.status`: Get task status.
  422. - `task.result`: Get a completed, failed, or cancelled result envelope; pending tasks return an error.
  423. - `task.cancel`: Request cancellation. Terminal tasks are unchanged; running analysis drains before reuse.
  424. ### transform
  425. - `transform.inspect`: Inspect/process transform extraction pipeline. For a session input, the root context is retained in the selected contexts so temporary transform cleanup preserves the session's view.
  426. ### type
  427. - `type.parse_string`: Parse a single type string.
  428. - `type.parse_declarations`: Parse C declarations for types/variables/functions.
  429. - `type.define_user`: Define user type from type source.
  430. - `type.rename`: Rename a type.
  431. - `type.undefine_user`: Undefine a user type.
  432. - `type.import_library_type`: Import type from type library.
  433. - `type.import_library_object`: Import object type from type library.
  434. - `type.export_to_library`: Export type into a type library.
  435. ### type_archive
  436. - `type_archive.create`: Create and optionally attach a type archive.
  437. - `type_archive.open`: Open and optionally attach a type archive.
  438. - `type_archive.list`: List attached type archives.
  439. - `type_archive.get`: Get one tracked type archive.
  440. - `type_archive.pull`: Pull types from a type archive.
  441. - `type_archive.push`: Push types to a type archive.
  442. - `type_archive.references`: Query archive incoming/outgoing references for one type.
  443. ### type_library
  444. - `type_library.create`: Create and optionally attach a type library.
  445. - `type_library.load`: Load and optionally attach a type library.
  446. - `type_library.list`: List type libraries attached to the view.
  447. - `type_library.get`: Get one tracked type library.
  448. ### uidf
  449. - `uidf.parse_possible_value`: Parse user-informed possible value set string.
  450. - `uidf.set_user_var_value`: Set function user variable value.
  451. - `uidf.clear_user_var_value`: Clear function user variable value.
  452. - `uidf.list_user_var_values`: List all user variable values for a function.
  453. ### undo
  454. - `undo.begin`: Begin undo transaction.
  455. - `undo.commit`: Commit undo transaction.
  456. - `undo.revert`: Revert undo transaction.
  457. - `undo.undo`: Perform undo.
  458. - `undo.redo`: Perform redo.
  459. ### value
  460. - `value.reg`: Get register value at/after an address.
  461. - `value.stack`: Get stack contents at/after an address.
  462. - `value.possible`: Get IL possible value set at an address.
  463. - `value.flags_at`: Get lifted IL flag read/write state at an address.
  464. ### workflow
  465. - `workflow.list`: List registered workflows.
  466. - `workflow.describe`: Describe workflow topology and settings.
  467. - `workflow.clone`: Clone workflow.
  468. - `workflow.insert`: Insert activities before an activity.
  469. - `workflow.insert_after`: Insert activities after an activity.
  470. - `workflow.remove`: Remove workflow activity.
  471. - `workflow.graph`: Summarize workflow graph.
  472. - `workflow.machine.status`: Get workflow machine status.
  473. - `workflow.machine.control`: Control workflow machine runtime.
  474. ### xref
  475. - `xref.code_refs_to`: Code references to an address.
  476. - `xref.code_refs_from`: Code references from an address.
  477. - `xref.data_refs_to`: Data references to an address.
  478. - `xref.data_refs_from`: Data references from an address.
  479. ## Contact
  480. For more information, contact Tim Blazytko ([@mr_phrazer](https://x.com/mr_phrazer)).

Ratings and comments

Sign in to rate this skill.

Sign in

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