re-angr
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@re-angr build control flow graph for function 'main' in /bin/ls"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
re-angr
MCP server for angr (UC Santa Barbara, BSD) — symbolic execution + CFG + reaching-definitions. The "I have a heavy constraint problem and want a second opinion" tool.
Why
The other RE-AI MCP servers handle most RE tasks well. But there are two cases where angr's approach is materially different from re-triton's:
CFG construction. angr's CFG is built statically (no execution, no emulation) and is one of the most accurate in the open-source world.
re-rizin.analyze_functionis faster but uses different heuristics; cross-validating with angr catches edge cases.Reaching definitions. angr's dataflow analysis is what makes
re-mba-deobfuscatereliable. An MBA identity likex + y == (x & y) + (x | y)looks like real arithmetic, but the reaching-defs graph reveals that(x & y)and(x | y)were defined from the same source — the identity is a no-op substitution.
re-angr exposes both, and re-triton for the same constraint problem. The two together give the analyst a much stronger signal than either alone.
Related MCP server: angr-mcp
Architecture
The Python MCP server is a thin wrapper around an angr-cli Python helper installed by install.sh:
Claude Code (MCP stdio)
│
▼
re-angr server (Python, this directory)
│ subprocess.run(...)
▼
angr-cli (small Python script, wraps the angr API)
│
└─ angr>=9.2 (pip-installed, the actual binary analysis platform)The subprocess boundary is intentional: angr keeps long-lived AngrProject objects, which don't survive across JSON-RPC calls cleanly. The helper spawns a fresh Python process per call, which matches the per-tool-call model the MCP server uses.
Tools
Tool | What it does |
| Health check — return angr + cle versions |
| Build a control-flow graph of a binary (or one function) |
| Run angr symbolic execution starting at an address |
| Compute the def-use graph for a function |
Install
./install.sh installs angr>=9.2 from PyPI.
To install standalone:
pip install 're-angr[core]'Requirements
Python 3.11+
angr>=9.2 (BSD, on PyPI)
No system dependencies
Degraded mode
If angr-cli is not installed, every tool returns {"status": "WARN", "error": "angr-cli not installed; run install.sh", ...}. The Python MCP server itself always loads so Claude Code can surface the install hint.
Pairing with re-triton
re-triton is the fast first-call symbolic executor (Triton 1.0 with Quarkslab's bindings). re-angr is the cross-validation pass:
Use
re-triton.solve_constraintfor "what input reaches this branch?" (fast, in-process).Use
re-angr.symbolic_execfor "does another symbolic executor agree?" (slower, but independent).Use
re-angr.reaching_definitionsfor "where was this variable defined?" (Triton doesn't compute this — it's a static dataflow analysis).
For MBA-obfuscated arithmetic: re-triton.solve_constraint solves the symbolic equation; re-angr.reaching_definitions shows the variable is a no-op substitution. Both together is a strong "this is a known identity" signal.
For CFG construction: re-rizin.analyze_function is the fast first call; re-angr.build_cfg is the cross-validation pass. Discrepancies (e.g. angr sees an indirect call that rizin doesn't) are worth investigating.
Available Tools
4 toolsbuild_cfgA
Build a control-flow graph of path (optionally one function).
Args:
path: PE / ELF / MachO to analyze
function: optional function name (e.g. "main") — when
given, only the CFG of that function is returned; when
None, the full program CFG is returned.
Returns::
{"path": "...",
"function": "..." | null,
"nodes": [{"addr": N, "size": M, "successors": [...]}],
"edges": [{"src": N, "dst": M, "kind": "fall-through|jmp|call|ret"}]}The CFG is the first thing an analyst needs for VM detection (high incoming-edge count on a single block = dispatcher candidate) and for binary comprehension in general.
Inputs: path (required), function.
check_angrA
Return angr-cli + angr package version + Python import probe.
Reports WARN (not ERROR) when the helper or the Python
module is not importable. The fallback chain for the CLI
binary: $RE_ANGR_CLI_PATH -> <server>/bin/angr-cli ->
PATH. The Python import probe (added in v2.9.1 to fix Gap 23)
runs import angr; import cle in a subprocess using the
same Python interpreter the MCP server runs under. The CLI
check alone is insufficient: the CLI can be installed while
the server's interpreter lacks the angr package, which
causes downstream tools (build_cfg, symbolic_exec,
reaching_definitions) to emit No module named 'angr'.
Status is OK only when BOTH the CLI is present AND the
Python import probe succeeds. Otherwise status is WARN
with a concrete install hint.
Inputs: no named parameters.
reaching_definitionsA
Compute the reaching-definitions graph for function.
A reaching definition is "where was the value used at instruction X defined?" angr computes the dataflow analysis statically. The output is a def-use graph: every variable gets a list of definitions; every instruction that reads a variable gets the list of definitions that may reach it.
Useful for the re-mba-deobfuscate skill: the MBA
identity x + y == (x & y) + (x | y) looks like
arithmetic, but the reaching-defs graph reveals that (x & y)
and (x | y) were both defined from the same source — the
identity is a no-op substitution.
Args:
path: PE / ELF / MachO
function: function name (e.g. "main")
Returns::
{"path": "...", "function": "...",
"defs": [{"variable": "...", "defined_at": "0x..."}],
"uses": [{"at": "0x...", "reads": ["var1", "var2"]}]}
Inputs: path (required), function (required).
symbolic_execA
Run angr symbolic execution starting at address.
Args:
path: PE / ELF / MachO to analyze
address: entry point as a hex string (e.g. "0x401000")
args: optional list of symbolic-arg names (default:
none — angr marks stdin / argv as symbolic depending
on the binary's entry point conventions)
Returns::
{"path": "...",
"address": "0x401000",
"states_explored": N,
"constraints": [{"path": [...], "expr": "..."}],
"dead_ends": N}The output is a partial trace — angr explores until either all paths are explored or the timeout is hit. The result is useful for cross-validation: "angr and Triton both find this MBA identity holds" is a much stronger signal than either alone.
Inputs: path (required), address (required), args.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool targets a distinct binary analysis operation: CFG construction, installation verification, dataflow analysis, and symbolic execution. There is no overlap in their purposes or outputs.
All tool names use snake_case and are descriptive, but they mix verb_noun (build_cfg, check_angr) with noun_phrase patterns (reaching_definitions), leading to minor inconsistency.
Four tools cover a focused set of angr-based analyses, each earning its place. The count feels appropriate for a specialized server, though slightly limited for broader reverse engineering tasks.
The set covers CFG, dataflow, and symbolic execution but lacks fundamental operations like disassembly or function enumeration, which may force agents to rely on external tools for basic analysis.
Related MCP Connectors
Repository knowledge graph MCP server for codebase understanding and debugging.
MCP server for static security analysis of Android source code
Self-hosted MCP server: 26 deterministic dev, security, and EVM tools.
Related MCP Servers
- AlicenseCqualityBmaintenanceMCP Server for automated reverse engineering with IDA Pro.432,334 PyPI13,477MIT
- AlicenseNot gradedqualityDmaintenanceExposes angr binary-analysis capabilities (symbolic execution, taint analysis, CFG recovery) as MCP tools for vulnerability exploration and exploit development.10MIT
- AlicenseAqualityCmaintenanceA multi-backend MCP server that exposes binary analysis capabilities from IDA Pro and Ghidra, allowing LLMs to directly drive reverse-engineering tools via natural language.11180Apache 2.0
- AlicenseNot gradedqualityCmaintenanceMCP server exposing the rizin CLI for static binary analysis of executables.MIT