A security-first MCP server that empowers AI agents to perform automated reverse engineering, malware analysis, forensics, vulnerability research, and SAST — powered by Radare2, YARA, LIEF, Capstone, and more.
<div align="center">
**English** · [한국어](https://github.com/sjkim1127/reversecore_mcp/blob/main/README.ko.md) · [日本語](https://github.com/sjkim1127/reversecore_mcp/blob/main/README.ja.md) · [简体中文](https://github.com/sjkim1127/reversecore_mcp/blob/main/README.zh-CN.md)
<br />
<img src="https://assets.kitploit.com/production/public/readmes/9634/a9f95a7b2b6f24e674c5ced08939b25868acc20ab1c6937e773548f4c2d7f977.png" alt="Reversecore MCP" width="440" />
# Reversecore MCP
### AI-Powered Binary Reverse Engineering, Malware Analysis & Vulnerability Research via MCP
**An enterprise-grade Model Context Protocol server for malware triage, decompilation, modern runtime security auditing (Go/Rust, Electron, Unity), crash analysis, and digital forensics — backed by verifiable byte-level evidence.**
---
[](https://github.com/sjkim1127/Reversecore_MCP/actions/workflows/main.yml)
[](https://www.python.org/)
[](LICENSE)
[](#testing)
[](#testing)
[](https://github.com/jlowin/fastmcp)
[](https://pypi.org/project/reversecore-mcp/)
[](https://github.com/sjkim1127/Reversecore_MCP/pkgs/container/reversecore_mcp)
[](https://skills.sh)
[](https://scorecard.dev/viewer/?uri=github.com/sjkim1127/Reversecore_MCP)
[](https://hvtracker.net/agents/reversecore-mcp)
[](https://youtu.be/wJGW2bp3c5A)
[](https://safeskill.dev/scan/sjkim1127-reversecore-mcp)
<br />
**[Quick Start](#quick-start) · [Security Analysis Workflows](#-security-analysis-workflows) · [Supported Targets](#what-you-can-analyze) · [Context Efficiency](#-context-efficiency-tiered-router-compact-schema--paging) · [Tool Catalog (186 Tools)](#tool-catalog-186-tools) · [FAQ](#faq)**
</div>
### ⚡ Instant One-Line Setup
Automatically detects installed AI clients (**Cursor, Claude Code, Windsurf, Claude Desktop, OpenAI Codex, Antigravity, Cline/Roo Code**) and registers Reversecore MCP with automatic configuration backups:
```bash
# Option 1: Zero-install CLI setup (Recommended)
pipx run reversecore-mcp setup
# Option 2: One-line shell installer (macOS / Linux)
curl -fsSL https://raw.githubusercontent.com/sjkim1127/Reversecore_MCP/main/install.sh | bash
# Option 3: Install Agent Skill (skills.sh / Cursor / Claude Code / Codex)
npx skills add sjkim1127/Reversecore_MCP
```
> 💡 **Reduce LLM context token usage by 94.4%:** Run `pipx run reversecore-mcp setup --tiered` to expose 15 core security tools + 8 domain sub-agents while keeping all 186 tools callable on demand.
---
## Table of Contents
- [What is Reversecore MCP?](#what-is-reversecore-mcp)
- [🛡️ Security Analysis Workflows](#-security-analysis-workflows)
- [What You Can Analyze](#what-you-can-analyze)
- [⚡ Context Efficiency: Tiered Router, Compact Schema & Paging](#-context-efficiency-tiered-router-compact-schema--paging)
- [Architecture](#architecture)
- [Tool Catalog (196 Tools)](#tool-catalog-196-tools)
- [Guided Analysis Prompts (34 Modes)](#guided-analysis-prompts-34-modes)
- [MCP Resources (11 URIs)](#mcp-resources-11-uris)
- [Quick Start](#quick-start)
- [Connect to Your AI Client](#connect-to-your-ai-client)
- [Configuration](#configuration)
- [Security Model](#security-model)
- [Development](#development)
- [CI/CD Pipeline](#cicd-pipeline)
- [Docker Build Architecture](#docker-build-architecture)
- [System Requirements](#system-requirements)
- [Project Structure](#project-structure)
- [Error Handling](#error-handling)
- [Adding New Tools](#adding-new-tools)
- [Contributing](#contributing)
- [Documentation](#documentation)
- [License](#license)
---
## What is Reversecore MCP?
Reversecore MCP is a [Model Context Protocol](https://modelcontextprotocol.io/) server that wraps **196 analysis tools** into a unified interface for AI-assisted security research, malware triage, vulnerability discovery, and digital forensics.
Instead of manually switching between disassemblers, decompilers, YARA scanners, and forensics utilities, you describe your investigation goal in natural language:
```text
"Decompile the main payload of this suspicious sample, recover its custom string decryption
routine, extract all C2 IOCs, map behaviors to MITRE ATT&CK, and generate a triage report."
```
Each tool runs locally (or inside an isolated Docker container) and returns a structured `ToolResult` (`ToolSuccess` or `ToolError`) with byte-level provenance so the AI can chain multi-step security investigations without hallucinating findings.
---
## 🛡️ Security Analysis Workflows
### Workflow 1: Malware Cryptor / DGA Recovery & Safe Emulation Verification
Modern malware families encrypt C2 configurations or generate domains dynamically (DGA). Translating decompiled C into a Python decryptor by hand is error-prone due to subtle 32/64-bit integer wrap-around and bitwise shifts. Reversecore MCP reconstructs the routine and **verifies 100% behavioral equivalence inside Radare2's ESIL CPU emulator** without executing live malware on the host.
**Prompt:**
```text
"Analyze the config decryption function at 0x401180 in sample.bin, write a safe Python
decryptor script, and verify with ESIL emulation that its output matches the binary."
```
**Agent Tool Chain & Verified Output:**
```
1. r2_decompile("sample.bin", "0x401180", detail="summary")
└─ Returns compact complexity/API summary + cache handle: evidence_id="ev_9a4c102f8b11"
2. inspect_analysis_view(evidence_id="ev_9a4c102f8b11", facet="lines", offset=0, limit=40)
└─ Streams exact pseudo-C lines on demand without exhausting context window
3. reconstruct_feature_code(
file_path="sample.bin",
address_or_symbol="sym.decrypt_word",
target_language="python",
test_inputs=["0x0", "0xff", "0xffff"]
)
├─ Decompilation & Synthesis: r2ghidra -> clean Python function (decrypt_word)
├─ Binary Emulation: Radare2 ESIL VM (isolated register/memory state, zero host execution)
├─ Equivalence Verdict: VERIFIED (branch_parity: true, test_vectors_evaluated: 3, emulation_successful: true)
└─ Reconstructed Code:
def decrypt_word(param_1: Any = 0, param_2: Any = 0, *args: Any, **kwargs: Any) -> Any:
uVar1 = (param_1 ^ param_2) * 0x45d9f3b
return uVar1 >> 0x10 ^ uVar1
```
---
### Workflow 2: Modern Runtime Threat & Supply-Chain Auditing (Go/Rust, Electron ASAR, Unity)
Threat actors increasingly write cross-platform ransomware in **stripped Go/Rust** or distribute trojanized **Electron (`app.asar`)** desktop installers. Reversecore MCP provides built-in pure-Python static parsers to recover stripped symbols and audit runtime security boundaries:
**Prompt:**
```text
"Audit this suspicious installer's app.asar for insecure BrowserWindow settings and
suspicious IPC handlers, and recover function symbols from its bundled stripped Go helper."
```
**Agent Tool Chain & Verified Output:**
```
1. inspect_electron_asar("app.asar", search_pattern="ipcMain|child_process|shell")
├─ Format: Chromium Pickle ASAR (header_size: 48,210 bytes, 642 files)
├─ Exposed IPC Handlers: 14 channels mapped across main and preload scripts
└─ Security Audit Findings:
• [HIGH] nodeIntegration: true detected in BrowserWindow configuration
• [MEDIUM] sandbox: false detected in renderer window options
2. inspect_go_rust_binary("helper_daemon.elf")
├─ Runtime Detected: Go (gopclntab magic 0xfffffff1, Go 1.22)
├─ Symbol Recovery: 148 stripped package/function names recovered from .gopclntab
└─ Suspicious Packages Identified:
• main.establishBeaconLoop @ 0x48a200
• main.encryptLocalVolume @ 0x48b940
```
---
### Workflow 3: Zero-Day Crash Triage, Taint Analysis & Adaptive YARA/Vaccine Generation
From an ASan/GDB crash log or a packed binary with dormant logic bombs, Reversecore MCP chains crash classification, source-to-sink taint reachability, and automated detection rule synthesis.
**Prompt:**
```text
"Triage this ASan crash log on daemon.bin, verify whether untrusted network input reaches
the vulnerable memcpy sink, scan for dormant backdoors, and generate a YARA rule."
```
**Agent Tool Chain & Verified Output:**
```
1. cve_triage_crash(crash_log_or_text=asan_log)
└─ Bug Class: heap-buffer-overflow (READ) | CWE-125 | Faulting Function: parse_packet+0x84
2. taint_trace("daemon.bin", function_name="parse_packet", verify_with_angr=True)
└─ Source→Sink Confirmed: recv() → memcpy() at 0x402190 (unbounded length field)
3. dormant_detector("daemon.bin")
└─ Discovered 1 orphan function (0x404800) with time-bomb trigger (cmp eax, 0x67758ac0)
4. adaptive_vaccine(threat_report={...}, action="both")
├─ Generated YARA detection rule with wildcarded address displacement masking
└─ Synthesized binary mitigation patch neutralizing the vulnerable/malicious branch
```
---
## What You Can Analyze
| Target Category | Security & Reverse Engineering Capabilities | Engine / Requirement |
|---|---|---|
| **Native Binaries (PE / ELF / Mach-O)** | Disassembly, r2ghidra C decompilation, CFG, C++ RTTI, struct recovery, imports/exports, section entropy, Authenticode/certificates | **Radare2 + r2ghidra + LIEF** (x86, x64, ARM32, ARM64, MIPS, RISC-V, PowerPC) |
| **Malware & Packed Executables** | Packer/compiler identification, CAPA behavioral capability mapping, dormant backdoor/time-bomb detection, IOC extraction, YARA & Sigma rules, binary vaccines | **YARA + CAPA + DIE + Custom Heuristics** |
| **Stripped Go & Rust Malware / Binaries** | Go `.gopclntab` (`go1.2`–`go1.20+`) symbol recovery, Rust `.dep-v0` (`cargo-auditable`) dependency tree & vulnerable crate auditing, `_ZN...E` demangling | **Built-in pure Python** (`inspect_go_rust_binary`) — no Go/Rust SDK required |
| **Electron Desktop Apps (`app.asar`)** | Supply-chain & client security audit: Chromium Pickle VFS parser, `ipcMain`/`contextBridge` surface mapping, `nodeIntegration`/`contextIsolation` checks | **Built-in pure Python** (`inspect_electron_asar`) — zero external dependencies |
| **Unity IL2CPP Binaries** | Mobile/client security audit: `global-metadata.dat` (`0xFAB11BAF`, v24–v31+) header encryption/entropy detection, C# class/method/string recovery, `libil2cpp.so` correlation | **Built-in pure Python** (`inspect_unity_il2cpp`) — no Unity required |
| **Cryptor / Routine Reconstruction** | Decompiled routine translation into safe C/Python scripts with ESIL register/memory equivalence verification and Obligation Ledger | **r2ghidra + ESIL Simulator** (`reconstruct_feature_code`) |
| **Vulnerabilities & Crash Dumps** | ASan/GDB crash triage, delta-debugging PoC minimization, source-to-sink taint analysis, angr symbolic path solving, ROP gadget chains | **angr + pwntools + ROPgadget + GDB** |
| **Memory, Network & Disk Forensics** | Process & code-injection hunting in RAM dumps, PCAP DNS/C2/stream reconstruction, NTFS MFT & deleted file recovery, artifact timeline correlation | **Volatility3 + Scapy + Sleuth Kit + Binwalk** |
---
## ⚡ Context Efficiency: Tiered Router, Compact Schema & Paging
Large reverse-engineering MCP servers often suffer from **context window bloat**: advertising 180+ verbose tool schemas and returning 50,000-line decompilations can exhaust an LLM's context in 2 turns. Reversecore MCP solves this with a 4-layer optimization architecture:
| Optimization Layer | How to Enable | Context Savings & Behavior |
|---|---|---|
| **1. Tiered Router Mode** | `REVERSECORE_PROFILE=tiered`<br>*(or `reversecore-mcp setup --tiered`)* | **-94.4% prompt token overhead.** Exposes 12 daily core tools + 3 router tools (`call_expert_agent`, `search_tools`, `execute_domain_tool`) backed by 8 domain sub-agents (`vulnerability_hunter`, `forensics`, `malware_analyst`, `deobfuscator`, `symbolic_engine`, `diff_analyst`, `source_auditor`, `modern_runtime`). |
| **2. Compact Schema Profile** | `REVERSECORE_SCHEMA_PROFILE=compact` | **~65% smaller `tools/list` payload.** Strips verbose docstring examples, flattens deep `anyOf`/`oneOf` unions, and caps JSON Schema depth at 10 while retaining full server-side Pydantic validation. |
| **3. Summary-First Paging** | Pass `detail="summary"` to `r2_decompile`, `Radare2_disassemble*`, `Radare2_list_strings`, `memory_extract_strings` | Returns a compact structural digest + an `evidence_id` handle (`ev_<12-hex>`). Call `inspect_analysis_view(evidence_id, facet, offset, limit, filter_query)` to paginate or filter lines/strings/functions on demand. |
| **4. On-Demand Guidance** | Built-in tools: `search_guidance` & `read_guidance_section` | Instead of stuffing 20,000 words of manuals into the system prompt, the agent queries built-in reversing playbooks (`playbook:target-routing`, `playbook:go-rust-reversing`, `playbook:electron-asar`, `playbook:unity-il2cpp`, `playbook:epistemological-discipline`) only when needed. |
---
## Architecture
```
AI Client (Claude / Cursor / any MCP-compatible client)
│ MCP Protocol (stdio or HTTP/SSE)
▼
┌──────────────────────────────────────────────────────┐
│ FastMCP 3.4.11 Server │
│ 196 registered tools · Fully async │
│ Python 3.10–3.12 │
├────────────────────┬─────────────────────────────────┤
│ Guided Prompts │ Dynamic Resources │
│ (22 analysis │ (11 URI-based: per-binary │
│ modes) │ strings, IOCs, ASM, CFG, …) │
├────────────────────┴─────────────────────────────────┤
│ Core Infrastructure │
│ Config · Security · Validators · Exceptions (17) │
│ R2 Pool · Metrics · Memory (SQLite) · Task Queue │
│ MITRE Mapper · Evidence Engine · Resilience Layer │
│ Arch Registry (x86/ARM/MIPS/RISC-V/PPC) │
│ Result Cache (SHA256) · Analysis Cache (Redis+SQL) │
│ SAST (Python AST + C/C++ Regex) · Plugin System │
├──────────────────────────────────────────────────────┤
│ Analysis Engines │
│ Radare2 6.0.4 │ YARA 4.3.1 · LIEF · Capstone │
│ r2ghidra │ CAPA · angr · Qiling │
│ Volatility3 · Scapy│ DIE · Binwalk · Sleuth Kit │
│ pwntools · ROPgadget│ Keystone (assembler) │
└──────────────────────────────────────────────────────┘
```
The server supports Python 3.10–3.12. The optional `angr` symbolic execution
engine is installed on Python 3.12 and newer, where a secure compatible release
is available; Python 3.10 and 3.11 installs omit `angr`.
### Core Infrastructure (37 modules)
The `reversecore_mcp/core/` directory contains the shared infrastructure that all tools build on:
| Module | Purpose |
|---|---|
| `config.py` | Pydantic BaseSettings with 34+ environment variables |
| `security.py` | Input sanitization, command argument validation |
| `validators.py` | File and binary path validation with TOCTOU mitigation, symlink resolution |
| `r2_pool.py` | Thread-safe Radare2 connection pool with configurable size |
| `r2_helpers.py` | Structured Radare2 output parsing |
| `metrics.py` | Per-tool execution times, call counts, error rates, cache statistics |
| `memory.py` | Async SQLite-backed AI memory store for persisting analysis findings across sessions |
| `mitre_mapper.py` | MITRE ATT&CK technique ID mapping engine |
| `evidence.py` | Evidence classification system: `OBSERVED`, `INFERRED`, `POSSIBLE` |
| `resilience.py` | Retry, circuit-breaker, and timeout decorator patterns |
| `task_queue.py` | Background task queue via Redis + arq |
| `extension_registry.py` | Plugin registration and lifecycle management |
| `arch_registry.py` | Multi-architecture mapping (x86, x86_64, ARM32, ARM64, MIPS, RISC-V, PPC → r2 arch/bits/registers) |
| `result_cache.py` | SHA256-based tool result caching decorator (`@cache_tool_result`) |
| `analysis_cache.py` | Multi-level decompilation cache (L1: Redis, L2: SQLite) |
| `result.py` | `ToolSuccess` / `ToolError` Pydantic models |
| `exceptions.py` | 17 exception classes with `RCMCP-E*` error codes |
| `decorators.py` | `@log_execution`, `@track_metrics` |
| `error_handling.py` | `@handle_tool_errors` decorator |
| `error_formatting.py` | Structured error response formatting |
| `execution.py` | Safe subprocess execution with timeout and output limits |
| `command_spec.py` | Command specification for subprocess calls |
| `loader.py` | Dynamic tool module loader |
| `plugin.py` | Plugin base class |
| `extension.py` | Extension base class |
| `container.py` | Container/sandbox execution support |
| `audit.py` | Audit logging |
| `binary_cache.py` | Binary file caching |
| `json_utils.py` | JSON serialization via orjson (3-5x faster than stdlib json) |
| `logging_config.py` | Loguru-based structured logging |
| `report_generator.py` | Report rendering engine (Markdown, PDF via xhtml2pdf) |
| `resource_manager.py` | MCP resource lifecycle management |
| `sast/python_ast_scanner.py` | Python AST-based vulnerability scanner |
| `sast/regex_scanner.py` | C/C++ regex-based vulnerability scanner |
| `sast/rule_manager.py` | SAST rule loading and management |
---
## Tool Catalog (196 Tools)
> 📖 **[Authoritative Tool Catalog & Parameter Reference (186 Tools)](https://github.com/sjkim1127/reversecore_mcp/blob/main/docs/TOOLS.md)**
> 📊 **[Tool Profile Footprint & Context Benchmark Matrix](https://github.com/sjkim1127/reversecore_mcp/blob/main/docs/benchmarks/profile_footprint.md)**
Every tool returns a structured `ToolResult` — either a `ToolSuccess` with typed `data` or a `ToolError` with an `RCMCP-E*` error code. Tools are organized into 11 domain plugins across 6 modular execution profiles (`tiered`, `full`, `static`, `malware`, `forensics`, `vuln-research`):
| Profile | Registered Tools | Schema Size | LLM Context Saving vs Full | Recommended Domain |
|---|:---:|:---:|:---:|---|
| `tiered` | **15** | ~11.5 KB | **-94.4%** (~28,500 tokens) | ⚡ **Daily interactive AI pair programming** (12 core tools + 3 sub-agent router tools accessing all 186 tools on demand) |
| `full` | **186** | 144.2 KB | Baseline (0%) | Complete enterprise reverse engineering suite |
| `vuln-research` | **138** | 96.4 KB | **-33.1%** (~10,000 tokens) | Fuzzing, ASan crash triage, CVE hunting, exploit research |
| `static` | **132** | 91.2 KB | **-36.8%** (~11,100 tokens) | Disassembly, decompilation (r2ghidra), LIEF, modern runtimes, static triage |
| `malware` | **100** | 76.5 KB | **-46.9%** (~14,100 tokens) | Threat triage, YARA scanning, deobfuscation, anti-analysis |
| `forensics` | **81** | 51.8 KB | **-64.1%** (~19,300 tokens) | Memory forensics (Volatility3), network PCAP (Scapy), disk |
### ⚡ Tiered Tools & Multi-Agent Architecture (`REVERSECORE_PROFILE=tiered`)
Exposing all 186 tools to an LLM on every turn wastes **~30,000+ tokens** of prompt context. Tiered mode solves this by exposing **only 15 high-frequency tools** while retaining seamless access to all 186 tools via specialized Sub-Agents and a dynamic tool router:
1. **Tier-1: Daily Core Tools (12 tools)**:
- `run_file`, `parse_binary_with_lief`, `get_server_health`
- `Radare2_open_file`, `Radare2_close_file`, `Radare2_list_functions`, `Radare2_list_strings`, `Radare2_disassemble_function`, `Radare2_decompile_function`
- `extract_iocs`, `run_yara`, `create_analysis_report`
2. **Tier-2: Domain Expert Sub-Agents & Universal Router (3 tools)**:
- `call_expert_agent`: Dispatches high-level multi-step domain tasks to specialized Sub-Agents:
- `modern_runtime`: Stripped Go (`gopclntab`) & Rust (`.dep-v0` crates), Electron `app.asar` IPC/security audit, Unity IL2CPP (`global-metadata.dat`), feature code reconstruction (`reconstruct_feature_code`), paged view inspection (`inspect_analysis_view`), and on-demand guidance (`search_guidance`)
- `vulnerability_hunter`: CVE scanning, dangerous API auditing, ROP gadget collection, heap analysis, crash triage
- `forensics`: Network PCAP analysis, C2 extraction, Volatility3 memory dumps, SleuthKit disk carving
- `malware_analyst`: IOC extraction, dormant backdoors, CAPA capability mapping, adaptive vaccines
- `deobfuscator`: DIE packer detection, string decryption, API hash resolution, dead-code elimination
- `symbolic_engine`: angr symbolic path reachability, constraint solving, dataflow taint tracing
- `diff_analyst`: Semantic binary diffing, 1-day patch review, cross-binary annotation transfer
- `source_auditor`: AST vulnerability scanning (Python) and regex pattern auditing (C/C++)
- `search_tools`: Dynamic keyword and domain search across all 186 tools with parameter schemas and example invocations.
- `execute_domain_tool`: Universal execution gateway to invoke any of the 186 specialized tools on demand with custom arguments.
Enable tiered mode via `reversecore-mcp setup --tiered` or `export REVERSECORE_PROFILE=tiered`.
---
### 🔍 Static Analysis Plugin (24 tools)
| # | Tool | Backend | Description |
|---|---|---|---|
| 1 | `run_strings` | `strings` CLI | ASCII/Unicode string extraction with configurable min-length |
| 2 | `run_binwalk` | Binwalk | Firmware deep-scan for embedded signatures and filesystems |
| 3 | `run_binwalk_extract` | Binwalk | Extract embedded files discovered by binwalk |
| 4 | `parse_binary_with_lief` | LIEF | Full PE/ELF/Mach-O header, section, import/export, TLS parsing |
| 5 | `detect_packer` | DIE | Quick packer/compiler detection |
| 6 | `detect_packer_deep` | DIE (`diec`) | Deep packer/protector analysis via Detect It Easy |
| 7 | `run_capa` | CAPA (Mandiant FLARE) | Capability detection — "encrypts data", "creates persistence", etc. |
| 8 | `run_capa_quick` | CAPA | Quick capability scan with a rule subset |
| 9 | `generate_signature` | Radare2 | Generate binary signatures for identification |
| 10 | `generate_yara_rule` | Radare2 + YARA | Generate YARA detection rules from binary patterns |
| 11 | `generate_advanced_yara_rule` | Radare2 + YARA | Advanced YARA rules with behavioral indicators |
| 12 | `scan_for_versions` | LIEF + strings | Scan binary for embedded version strings |
| 13 | `extract_rtti_info` | Radare2 | Extract C++ RTTI (Run-Time Type Information) |
| 14 | `diff_binaries` | Radare2 | Semantic binary diff between two file versions |
| 15 | `analyze_variant_changes` | Radare2 | Analyze changes between binary variants |
| 16 | `match_libraries` | Radare2 | Identify statically linked libraries by function fingerprint |
| 17 | `patch_diff_1day` | Radare2 + heuristics | Automated patch diff analysis for 1-day vulnerability research |
| 18 | `analyze_patch_diff_auto` | Radare2 + inference | Automated patch vulnerability inference |
| 19 | `emulate_binary` | Radare2 ESIL | Register/memory-traced code emulation |
| 20 | `generate_fuzzing_harness` | Qiling + AFL++ | Generate a fuzzing harness targeting a specific function |
| 21 | `run_fuzzing_campaign` | AFL++ | Run a full fuzzing campaign with crash collection |
| 22 | `triage_crash` | GDB | Crash parsing and exploitability assessment |
| 23 | `verify_path_and_get_args` | angr | Symbolic execution — prove path reachability and compute concrete inputs |
| 24 | `taint_trace` | Radare2 + angr | Data-flow taint analysis from sources to sinks |
---
### 🔐 Source Code Audit Plugin (1 tool)
| # | Tool | Backend | Description |
|---|---|---|---|
| 25 | `audit_source_code` | AST + Regex | Python AST scanning + C/C++ regex scanning for dangerous patterns |
---
### 🛠️ Common Utilities Plugin (20 tools)
**File Operations (5 tools)**
| # | Tool | Description |
|---|---|---|
| 26 | `run_file` | File type, architecture, and compiler fingerprinting |
| 27 | `copy_to_workspace` | Copy a file into the analysis workspace |
| 28 | `create_directory` | Create a directory in the workspace |
| 29 | `list_workspace` | List all files in the workspace |
| 30 | `scan_workspace` | Full workspace scan with file metadata |
**Patch Explanation (1 tool)**
| # | Tool | Description |
|---|---|---|
| 31 | `explain_patch` | Explain a binary patch in natural language |
**Assembler (1 tool)**
| # | Tool | Backend | Description |
|---|---|---|---|
| 32 | `assemble_instructions` | Keystone | Assemble instructions to machine code (x86, ARM, MIPS, etc.) |
**AI Memory Management (11 tools)**
These tools let the AI persist and recall findings across analysis sessions using an async SQLite database:
| # | Tool | Description |
|---|---|---|
| 33 | `create_memory_session` | Start a new memory session for an analysis |
| 34 | `store_analysis_finding` | Persist an analysis finding with tags |
| 35 | `query_analysis_memories` | Search past findings by query |
| 36 | `get_binary_analysis_context` | Retrieve all context for a specific binary |
| 37 | `tag_analysis_session` | Add tags to a session for organization |
| 38 | `search_memories_by_tag` | Find sessions/findings by tag |
| 39 | `delete_analysis_session` | Remove a session and its findings |
| 40 | `cleanup_expired_sessions` | Remove sessions older than a threshold |
| 41 | `list_analysis_sessions` | List all active sessions |
| 42 | `export_memory_store` | Export all memories to a portable format |
| 43 | `import_memory_store` | Import memories from an export file |
**Server Monitoring (2 tools)**
| # | Tool | Description |
|---|---|---|
| 44 | `get_server_health` | Uptime, memory usage, loaded tools, Python version |
| 45 | `get_tool_metrics` | Per-tool call counts, mean execution times, error rates, cache hit/miss |
---
### ⚙️ Radare2 & r2ghidra Plugin (30 tools)
All Radare2 tools use a thread-safe connection pool (`r2_pool.py`) that automatically manages r2pipe sessions.
| # | Tool | Description |
|---|---|---|
| 46 | `Radare2_open_file` | Open a binary file in Radare2 |
| 47 | `Radare2_close_file` | Close a Radare2 session |
| 48 | `Radare2_list_open_files` | List currently open files |
| 49 | `Radare2_analyze_binary` | Run full auto-analysis (`aaa`) |
| 50 | `Radare2_list_functions` | List all detected functions |
| 51 | `Radare2_disassemble_function` | Disassemble a specific function |
| 52 | `Radare2_disassemble_address` | Disassemble at a specific address |
| 53 | `Radare2_decompile_function` | Decompile via r2ghidra (Ghidra engine embedded in r2, no JVM needed) |
| 54 | `Radare2_list_exports` | List exported symbols |
| 55 | `Radare2_list_imports` | List imported functions |
| 56 | `Radare2_list_sections` | List binary sections with entropy |
| 57 | `Radare2_list_strings` | List strings found in the binary |
| 58 | `Radare2_find_cross_references` | Track function calls and data references |
| 59 | `Radare2_search_bytes` | Search for byte patterns in the binary |
| 60 | `Radare2_get_binary_info` | Get binary metadata (arch, format, endianness) |
| 61 | `Radare2_execute_command` | Execute a raw Radare2 command |
| 62 | `Radare2_esil_emulate` | ESIL emulation at a specific address |
| 63 | `Radare2_get_hexdump` | Hex dump at a virtual address |
| 64 | `Radare2_get_cfg_data` | Extract control flow graph data |
| 65 | `Radare2_generate_cfg_png` | Generate CFG as PNG image |
| 66 | `Radare2_generate_callgraph` | Generate function call graph |
| 67 | `Radare2_recover_structures` | Auto-recover C structs and persist to annotation database |
| 68 | `Radare2_decompile_with_r2ghidra` | High-quality C decompilation with caching |
| 69 | `Radare2_annotate_binary` | Add annotations to the binary |
| 70 | `Radare2_get_annotations` | Retrieve annotations |
| 71 | `Radare2_export_annotations` | Export annotations to file |
| 72 | `Radare2_import_annotations` | Import annotations from file |
| 73 | `Radare2_detect_crypto_constants` | Detect cryptographic constants (AES S-box, etc.) |
| 74 | `Radare2_find_gadgets` | Find ROP/JOP gadgets |
| 75 | `Radare2_calculate_entropy` | Calculate per-section entropy |
---
### 🦠 Malware Analysis Plugin (9 tools)
| # | Tool | Backend | Description |
|---|---|---|---|
| 76 | `dormant_detector` | Radare2 + heuristics | Find hidden backdoors, orphan functions, time-bombs, logic bombs |
| 77 | `adaptive_vaccine` | YARA + Radare2 | Generate detection YARA rules + binary patches to neutralize threats |
| 78 | `vulnerability_hunter` | Radare2 + analysis | Detect dangerous API patterns (strcpy, sprintf) and ROP gadget chains |
| 79 | `extract_iocs` | Regex + LIEF | Extract IPs, URLs, domains, hashes, registry keys, crypto addresses |
| 80 | `run_yara` | YARA | Scan with custom rule files and built-in rulesets |
| 81 | `generate_poc_exploit` | pwntools | Generate proof-of-concept exploit code |
| 82 | `build_rop_chain` | ROPgadget + pwntools | Automated ROP chain construction |
| 83 | `autonomous_vuln_hunt` | Radare2 + angr | Autonomous vulnerability hunting pipeline |
| 84 | `analyze_heap_exploit` | Radare2 + heuristics | Heap exploitation analysis (UAF, double-free, overflow) |
---
### 🕵️ Digital Forensics Plugin (22 tools)
**Memory Forensics (6 tools)**
| # | Tool | Backend | Description |
|---|---|---|---|
| 85 | `memory_analyze` | Volatility3 | Full memory dump analysis |
| 86 | `memory_list_processes` | Volatility3 | List running processes from memory dump |
| 87 | `memory_detect_injections` | Volatility3 | Detect code injection in process memory |
| 88 | `memory_extract_strings` | Volatility3 | Extract strings from process memory |
| 89 | `memory_dump_module` | Volatility3 | Dump a loaded module from memory |
| 90 | `memory_list_symbols` | Volatility3 | List symbols from memory |
**Disk Forensics (6 tools)**
| # | Tool | Backend | Description |
|---|---|---|---|
| 91 | `disk_list_partition` | Sleuth Kit | List disk partitions |
| 92 | `disk_list_files` | Sleuth Kit | List files in a disk image |
| 93 | `disk_recover_deleted` | Sleuth Kit | Recover deleted files |
| 94 | `disk_analyze_mft` | Sleuth Kit | Analyze NTFS Master File Table |
| 95 | `disk_extract_file` | Sleuth Kit | Extract a file from disk image |
| 96 | `disk_hash_verify` | Sleuth Kit | Verify file integrity via hash |
**Network Forensics (5 tools)**
| # | Tool | Backend | Description |
|---|---|---|---|
| 97 | `pcap_analyze` | Scapy | PCAP analysis: protocol breakdown, anomalies |
| 98 | `pcap_list_connections` | Scapy | List all network connections |
| 99 | `pcap_extract_dns` | Scapy | Extract DNS queries and responses |
| 100 | `pcap_extract_c2` | Scapy | Identify potential C2 communication |
| 101 | `pcap_reconstruct_stream` | Scapy | Reconstruct TCP streams |
**Artifact Analysis (5 tools)**
| # | Tool | Backend | Description |
|---|---|---|---|
| 102 | `artifact_collect` | Custom parsers | Collect browser history, registry hives, event logs, prefetch |
| 103 | `artifact_correlate_ioc` | Custom parsers | Correlate artifacts with known IOCs |
| 104 | `artifact_generate_yara` | YARA | Generate YARA rules from artifact patterns |
---
[Read more](https://github.com/sjkim1127/reversecore_mcp)