Skip to content
KitploitKITPLOIT
工具漏洞利用博客
Log in
提交
工具漏洞利用博客
提交

黑客、渗透测试和网络安全工具,武装您的安全武器库!

Kitploit 是一个黑客、网络安全和渗透测试工具的目录。发现最新的项目更新,查找漏洞、分析系统、自动化测试并加强你的安全。

订阅源联系隐私© 2026 Kitploit

工具目录

分类

查看所有分类
Loading categories
Reversecore_MCP — 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. | Kitploit
工具/GitHubGitHub/sjkim1127/reversecore_mcp
Indicator of Compromise (IOC) ManagementStatic AnalysisDynamic Analysis (Sandboxing)Vulnerability AnalysisReverse EngineeringFuzzingMalware AnalysisDigital ForensicsBinary AnalysisIncident Response
GitHub
18518903小时38分前Kitploit 审核通过
分享
sjkim1127/reversecore_mcp

Reversecore_MCP

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.**

---

[![CI/CD](https://github.com/sjkim1127/Reversecore_MCP/actions/workflows/main.yml/badge.svg)](https://github.com/sjkim1127/Reversecore_MCP/actions/workflows/main.yml)
[![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue)](https://www.python.org/)
[![License: MIT](https://img.shields.io/badge/license-MIT-yellow.svg)](LICENSE)
[![Tests](https://img.shields.io/badge/tests-3086%20passed-brightgreen)](#testing)
[![Coverage](https://img.shields.io/badge/coverage-88%25-green)](#testing)
[![FastMCP](https://img.shields.io/badge/FastMCP-3.4.11-purple)](https://github.com/jlowin/fastmcp)
[![PyPI](https://img.shields.io/pypi/v/reversecore-mcp)](https://pypi.org/project/reversecore-mcp/)
[![Docker](https://img.shields.io/badge/docker-ghcr.io-blue)](https://github.com/sjkim1127/Reversecore_MCP/pkgs/container/reversecore_mcp)
[![skills.sh](https://img.shields.io/badge/skills.sh-reversecore--mcp-5c4ee5)](https://skills.sh)
[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/sjkim1127/Reversecore_MCP/badge)](https://scorecard.dev/viewer/?uri=github.com/sjkim1127/Reversecore_MCP)
[![HVTrust](https://hvtracker.net/badge/reversecore-mcp.svg)](https://hvtracker.net/agents/reversecore-mcp)

[![Watch the Demo](https://img.shields.io/badge/%E2%96%B6_Watch_Demo-FF0000?style=for-the-badge&logo=youtube&logoColor=white)](https://youtu.be/wJGW2bp3c5A)
[![SafeSkill Verified](https://img.shields.io/badge/SafeSkill-93/100_Verified_Safe-brightgreen?style=for-the-badge)](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)
下载工具

最受欢迎

查看全部 →

发现我们社区最常用的工具。

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 终极 OSINT 工具包:调查图谱、置信度评分、别名家族、地图、时间线和报告。49 个模块、400+ 个站点,无需 API 密钥。

    968
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock 一键执行应用(CVE-2026-43499)

    556
  • 3

    looking-glass

    anonghosty/looking-glass

    CSIRT 平台,可将 Shadowserver 报告导入 MongoDB,并将其重放为交互式地图、分析、发现、公告和高管仪表板。

    347
  • 4

    redforge

    cybersecurity91/redforge

    浏览器端红队工具包,包含 102 个离线工具,用于侦察、载荷生成、凭据攻击、加密、编码和交战报告。

    346
  • 5

    ARTEX

    baarai/artex

    基于LLM的多智能体自主渗透测试平台,具备规划器/执行器智能体、资产与探索图谱、MITM流量记录以及漏洞复测功能。

    319
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    AI原生网络安全的行动系统——在这里,意图转化为受治理的执行,证据沉淀为运营记忆,每一次操作都让下一次更出色。

    297

探索所有工具

浏览我们的工具集合

查看所有工具 →