Skip to main content
Glama
re-angr

re-angr

by Heretek-RE

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_function is faster but uses different heuristics; cross-validating with angr catches edge cases.

  • Reaching definitions. angr's dataflow analysis is what makes re-mba-deobfuscate reliable. An MBA identity like x + 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

check_angr

Health check — return angr + cle versions

build_cfg

Build a control-flow graph of a binary (or one function)

symbolic_exec

Run angr symbolic execution starting at an address

reaching_definitions

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_constraint for "what input reaches this branch?" (fast, in-process).

  • Use re-angr.symbolic_exec for "does another symbolic executor agree?" (slower, but independent).

  • Use re-angr.reaching_definitions for "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 tools
build_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

    A3.9/5.0

    Scored across 4 tools

    Disambiguation5/5

    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.

    Naming Consistency4/5

    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.

    Tool Count4/5

    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.

    Completeness3/5

    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

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Exposes angr binary-analysis capabilities (symbolic execution, taint analysis, CFG recovery) as MCP tools for vulnerability exploration and exploit development.
      10
      MIT
    • A
      license
      A
      quality
      C
      maintenance
      A 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.
      11
      180
      Apache 2.0