AI-Powered Reverse Engineering & Security Analysis via Model Context Protocol
An MCP server that gives AI assistants like Claude and Cursor the ability to perform reverse engineering, malware analysis, vulnerability research, digital forensics, and source code auditing through natural language.
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.
Reversecore MCP is a Model Context Protocol server that wraps 177 analysis tools into a single interface that AI assistants can call through natural language.
Instead of learning the command-line syntax for a dozen different tools, you describe what you want:
"Decompile the main function of this malware sample, extract all network IOCs,
map the behavior to MITRE ATT&CK, and generate a triage report."
Each tool returns a structured ToolResult (either ToolSuccess or ToolError) with typed data that the AI can reason about, chain into follow-up queries, or render for the user.
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
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 5 modular execution profiles (full, static, malware, forensics, vuln-research):
Profile
Registered Tools
Schema Size
LLM Context Saving vs Full
Recommended Domain
full
153
116.8 KB
Baseline (0%)
Complete enterprise reverse engineering suite
vuln-research
105
73.3 KB
-37.2% (~10,800 tokens)
Fuzzing, ASan crash triage, CVE hunting, exploit research
Render report in 4 modes: full_analysis, quick_triage, ioc_summary, executive_brief
119
generate_vex_report
Generate a VEX (Vulnerability Exploitability eXchange) report
120
generate_sigma_rule
Generate SIGMA detection rules
Guided Analysis Prompts (22 Modes)
Prompts are pre-built analysis workflows that prime the AI with a structured persona, step-by-step tool usage sequences, and evidence classification rules. You activate them by referencing the prompt name in your AI client.
Automated patch diff for 1-day vulnerability research
cve_discovery_pipeline_mode
Full CVE discovery pipeline: from patch diff to working exploit
Other (2 prompts)
Prompt
Use Case
game_analysis_mode
Game client analysis: anti-cheat detection, protocol RE, memory inspection
report_generation_mode
Structured session workflow with MITRE ATT&CK technique mapping
How prompts work: Each prompt primes the AI with a structured analysis persona. It includes Chain-of-Thought reasoning checkpoints (where the AI must stop and evaluate before proceeding) and evidence classification rules that prevent the AI from stating speculation as fact. Every finding must be labeled as OBSERVED (directly verified), INFERRED (logically derived from static analysis), or POSSIBLE (requires further verification).
MCP Resources (11 URIs)
Resources are read-only data endpoints that AI clients can access through URI templates. They complement tools by providing structured data without requiring explicit tool calls.
Static Resources
URI
Description
reversecore://guide
Tool usage guide with file path rules and best practices
reversecore://guide/structures
Structure recovery and cross-reference analysis technical guide
reversecore://tools
Complete documentation for all 177 registered tools
reversecore://logs
Application logs (last 100 lines)
Dynamic Resources (Per-Binary Virtual Filesystem)
These URIs resolve per-binary and invoke the corresponding analysis tools on demand:
URI Template
Description
reversecore://{filename}/strings
Extract all strings from a binary
reversecore://{filename}/iocs
Extract IOCs (IPs, URLs, emails, hashes)
reversecore://{filename}/func/{address}/code
Decompiled pseudo-C code for a function
reversecore://{filename}/func/{address}/asm
Disassembly for a function
reversecore://{filename}/func/{address}/cfg
Control flow graph in Mermaid format
reversecore://{filename}/functions
List of all functions in the binary
reversecore://{filename}/dormant_detector
Dormant detector analysis results
Quick Start
Option 1 — PyPI (Simplest)
pip install reversecore-mcp
reversecore-mcp
Prerequisites: Radare2 must be installed on your system (r2 --version). YARA is installed automatically via yara-python.
Option 2 — Docker (Recommended for Full Functionality)
All analysis engines (Radare2, r2ghidra, YARA, Binwalk, Sleuth Kit, GDB, etc.) come pre-installed:
Prerequisites for local mode: Radare2 must be installed on your system (r2 --version). Individual tool backends (YARA, LIEF, Capstone, etc.) are installed via pip. For full forensics support, you'll also need Volatility3, Scapy, and Sleuth Kit.
Connect to Your AI Client
Add the server configuration to your IDE client settings (e.g., ~/.cursor/mcp.json or claude_desktop_config.json).
⚡ Option 1: Docker Exec Mode (Recommended)
If you have the container running via Docker Compose, this mode channels stdio directly into the running container. Zero startup latency, persistent memory, and full tool availability.
Your local folder is mounted to /app/workspace inside the container.
Always reference files by filename only, not by your local full path.
❌ Wrong
✅ Correct
r2_decompile("/Users/john/samples/mal.exe")
r2_decompile("mal.exe")
Configuration
All settings can be provided via environment variables or a .env file (see .env.example). Settings are managed via Pydantic BaseSettings with the REVERSECORE_ prefix.
Core Settings
Variable
Default
Description
MCP_TRANSPORT
stdio
Transport mode: stdio or http
REVERSECORE_WORKSPACE
./ (cwd)
Analysis workspace directory
REVERSECORE_READ_DIRS
""
Comma-separated list of additional read-only directories
REVERSECORE_STRICT_PATHS
false
Raise errors for missing paths instead of warnings
REVERSECORE_STRUCTURED_ERRORS
false
Enable structured error responses with error codes
REVERSECORE_DEFAULT_TOOL_TIMEOUT
120
Default tool execution timeout in seconds
REVERSECORE_MAX_OUTPUT_SIZE
10000000
Maximum output size for tools (bytes)
REVERSECORE_FORENSICS_MAX_RECOVERED_BYTES
500000000
Maximum bytes recovered from one disk inode
HTTP Mode Settings
Variable
Default
Description
MCP_HOST
0.0.0.0
Host interface to bind (auto-overrides to 127.0.0.1 if no API key)
MCP_PORT
8000
Port for HTTP server
MCP_API_KEY
(unset)
API key for HTTP authentication (X-API-Key or Authorization: Bearer)
REVERSECORE_RATE_LIMIT
60
Max requests per minute (HTTP mode only, via slowapi)
MAX_UPLOAD_SIZE
100000000
Maximum upload size (100 MB default)
FILE_RETENTION_MINUTES
1440
Retention period for uploaded files (24h default)
Radare2 Settings
Variable
Default
Description
REVERSECORE_R2_POOL_SIZE
3
Number of Radare2 connections in the pool
REVERSECORE_R2_POOL_TIMEOUT
30
Timeout for acquiring a connection from the pool
REVERSECORE_R2_EXTENSIONS
""
Comma-separated list of r2 extension classes (module:ClassName)
REVERSECORE_GHIDRA_MAX_PROJECTS
3
Max cached r2ghidra decompiler projects
REVERSECORE_GHIDRA_EXTENSIONS
""
Comma-separated list of Ghidra extension classes
MAX_EMULATION_INSTRUCTIONS
1000
Maximum ESIL emulation instructions
Sandbox Settings
Variable
Default
Description
REVERSECORE_SANDBOX_ENABLED
false
Enable sandbox execution for dynamic analysis tools
REVERSECORE_SANDBOX_MODE
auto
Sandbox mode: auto, host, container, disabled
REVERSECORE_SANDBOX_DOCKER_IMAGE
reversecore-sandbox:latest
Docker image for sandbox execution
REVERSECORE_SANDBOX_CPU_LIMIT
1.0
CPU core limit for sandbox containers
REVERSECORE_SANDBOX_MEMORY_LIMIT
512m
Memory limit for sandbox containers
REVERSECORE_SANDBOX_PIDS_LIMIT
100
PID limit for sandbox containers
REVERSECORE_SANDBOX_USER
nobody
Non-root user for sandbox execution
Storage & Queue
Variable
Default
Description
REDIS_URL
redis://localhost:6379/0
Redis URL for task queue and result caching
MEMORY_DB_PATH
~/.reversecore_mcp/memory.db
Path to AI memory SQLite database
REVERSECORE_LIEF_MAX_FILE_SIZE
1000000000
Maximum file size for LIEF parsing (1 GB)
Logging
Variable
Default
Description
LOG_LEVEL
INFO
Logging verbosity: DEBUG, INFO, WARNING, ERROR
LOG_FILE
<tempdir>/reversecore/app.log
Path to log file
LOG_FORMAT
human
Log format: human (readable) or json (structured)
Plugins & SAST
Variable
Default
Description
REVERSECORE_PLUGIN_DIRS
""
Comma-separated directories to scan for extension plugins
REVERSECORE_SAST_RULES_PATH
""
Path to custom YAML SAST rules file
Security Model
Security is implemented as defense-in-depth, with protections at multiple layers:
Input & Path Safety
Control
Implementation
No shell injection
All subprocess calls use list arguments, never shell strings (execution.py)
Path traversal prevention
validate_file_path() and validate_binary_path() resolve symlinks and confine access to the workspace (validators.py)
TOCTOU mitigation
bypass_cache=True flag re-validates paths to prevent race conditions
Input sanitization
All parameters sanitized before execution (security.py)
CSRF protection
Dashboard forms require token-based CSRF validation (dashboard/__init__.py)
Network & Authentication
Control
Implementation
Timing-attack-safe auth
secrets.compare_digest() for API key comparison (web/auth.py)
Restricted auth vectors
Only X-API-Key and Authorization: Bearer headers accepted; no query params or cookies
Loopback-only fallback
Without MCP_API_KEY, HTTP access restricted to 127.0.0.1 (web/middleware.py)
Rate limiting
Configurable per-minute limits via slowapi
Security headers
HSTS, X-Content-Type-Options, X-Frame-Options, CSP on all HTTP responses (web/middleware.py)
Minimized /health
Public endpoint returns only {"status": "alive"}; details behind authentication (web/endpoints.py)
Container & Runtime
Control
Implementation
Non-root execution
Runs as appuser (UID 1000) with minimal capabilities
Resource limits
Docker Compose enforces CPU (2.0) and memory (4 GB) limits
Sandbox isolation
Optional container-based sandboxing for dynamic analysis tools
CI/CD Security Gates
Control
Implementation
Secrets scanning
Gitleaks runs on every commit (pre-commit hook + CI)
SAST
Bandit scans all Python code on every commit
CodeQL
GitHub CodeQL static analysis on every push to main
Dependency auditing
pip-audit on every push — no unreviewed CVEs
Container scanning
Trivy scans Docker images for vulnerabilities (LOW through CRITICAL)
# Full test suite with coverage report
pytest tests/ -v
# Unit tests only (fast, no external dependencies)
pytest tests/unit/ -v
# Integration tests (requires Docker)
pytest tests/integration/ -v
# Run with coverage threshold enforcement
pytest tests/unit/ --cov=reversecore_mcp --cov-fail-under=80
# Run a specific test
pytest tests/unit/test_cli_tools.py::TestRunFile::test_success -v
# Security boundary tests
pytest tests/ -m security -v
# Benchmarks
pytest tests/ -m benchmark -v
Test status:
✅ 1,957 unit tests passing across Python 3.10 / 3.11 / 3.12
📊 87% code coverage (80% minimum enforced in CI)
🔒 Zero Bandit findings
⚡ Fully async test suite via pytest-asyncio
Test markers:
Marker
Purpose
@pytest.mark.unit
Fast unit tests
@pytest.mark.integration
Tests requiring Docker or external tools
@pytest.mark.slow
Long-running tests
@pytest.mark.benchmark
Performance benchmarks
@pytest.mark.security
Security boundary validation tests
Code Quality
ruff check reversecore_mcp/ # Lint (E, W, F, I, B, C4, UP rules)
ruff format reversecore_mcp/ # Format
mypy reversecore_mcp/ # Type check (0 errors across 108 files)
bandit -r reversecore_mcp/ # Security scan (all severities)
pip-audit # Dependency CVE scan
Pre-commit Hooks
The following hooks run automatically on every commit:
Every push to main triggers 11 pipeline jobs. All must pass before deployment.
Lint & Security Gate Unit Tests (Python Matrix)
├─ Gitleaks (secret scan) ├─ pytest 3.10 --cov-fail-under=80
├─ Hadolint (Dockerfile lint) ├─ pytest 3.11 --cov-fail-under=80
├─ Ruff check + format └─ pytest 3.12 --cov-fail-under=80
├─ Mypy type check (108 files)
├─ Bandit (all severities) Wheel Smoke Test
├─ pip-audit (no CVEs) └─ Build wheel → install in /tmp
└─ Security boundary tests → verify plugin discovery
→ assert __file__ under sys.prefix
CodeQL Analysis
└─ Python SAST Docker Verification
├─ Build reversecore-mcp:ci
Exploit Safety Gate ├─ Trivy container scan
├─ Bandit on POC templates ├─ Image size check (< 5 GB)
├─ Hypothesis DAST fuzzing ├─ CLI tool verification
├─ Performance benchmarks ├─ Integration tests in container
└─ Container isolation test └─ E2E tool invocation
In-Container Smoke Test Build Base Image (amd64 + arm64)
├─ Copy test ELF into container ├─ Compile YARA 4.3.1
└─ Run scripts/smoke_test.py ├─ Compile Radare2 6.0.4
├─ Compile r2ghidra
Deploy (amd64 + arm64) └─ Push to GHCR
├─ Build app image
├─ Push to GHCR Merge Manifests
└─ Trivy rescan on published └─ Multi-arch manifest → :latest
Zero-bypass policy: CI/CD failures are never resolved by modifying pipeline configuration. Root causes are always fixed directly in source code or dependencies.
Docker Build Architecture
The Docker build uses a two-layer approach to keep build times manageable:
Layer 1: Base Image (Dockerfile.base)
A multi-stage build that compiles all slow-to-build, rarely-changing dependencies from source:
All custom exceptions inherit from ReversecoreError and carry structured error codes:
Exception
Code
Type
When
ReversecoreError
RCMCP-E000
UNKNOWN_ERROR
Base class for all errors
ValidationError
RCMCP-E001
VALIDATION_ERROR
Invalid input, bad parameters
ExecutionTimeoutError
RCMCP-E002
TIMEOUT_ERROR
Tool exceeded timeout
ToolNotFoundError
RCMCP-E003
TOOL_ERROR
Required CLI tool not installed
OutputLimitExceededError
RCMCP-E004
OUTPUT_ERROR
Output exceeded max size
ToolExecutionError
RCMCP-E005
EXECUTION_ERROR
Subprocess returned non-zero
BinaryAnalysisError
RCMCP-E100
BINARY_ANALYSIS_ERROR
General binary analysis failure
DecompilationError
RCMCP-E101
DECOMPILATION_ERROR
r2ghidra decompilation failed
DisassemblyError
RCMCP-E102
DISASSEMBLY_ERROR
Radare2 disassembly failed
StructureRecoveryError
RCMCP-E103
STRUCTURE_RECOVERY_ERROR
C struct recovery failed
SignatureGenerationError
RCMCP-E104
SIGNATURE_GENERATION_ERROR
YARA/signature generation failed
EmulationError
RCMCP-E105
EMULATION_ERROR
ESIL emulation failed
ToolTimeoutError
RCMCP-E200
TOOL_TIMEOUT_ERROR
External tool timed out
GhidraConnectionError
RCMCP-E201
GHIDRA_CONNECTION_ERROR
r2ghidra connection issue
Radare2Error
RCMCP-E202
RADARE2_ERROR
Radare2 command failed
WorkspaceError
RCMCP-E300
WORKSPACE_ERROR
Workspace file access error
SecurityViolationError
RCMCP-E301
SECURITY_VIOLATION
Security policy violation
PathTraversalError
RCMCP-E302
PATH_TRAVERSAL
Path traversal attempt detected
AI clients can use the error_code field to programmatically handle failures and decide whether to retry, try an alternative tool, or report the error to the user.
Adding New Tools
Follow this pattern to add a new MCP tool:
# reversecore_mcp/tools/analysis/my_tool.py
from reversecore_mcp.core.decorators import log_execution
from reversecore_mcp.core.result import ToolResult, success, failure
from reversecore_mcp.core.security import validate_file_path
@log_execution()
async def my_analysis_tool(
file_path: str,
option: str | None = None,
) -> ToolResult:
"""Analyze a binary for X.
Args:
file_path: Path to the binary file (relative to workspace).
option: Optional analysis option.
Returns:
ToolResult with status='success' and structured content.
"""
try:
safe_path = validate_file_path(file_path)
result = await perform_analysis(safe_path)
return success({"result": result})
except Exception as e:
return failure(
error_code="RCMCP-E100",
message=str(e),
hint="Check that the file exists and is a valid binary.",
)
Then register it in the appropriate plugin's __init__.py and add tests in tests/unit/.
Contributing
Fork the repository
Create a feature branch: git checkout -b feat/my-feature
Write tests alongside your code — coverage must not drop below 80%
Ensure all gates pass: pytest, ruff check, mypy, bandit
Open a pull request with a clear description
Please read the Contributing Guide for code standards, docstring conventions (Google-style), and the pull request checklist.
User: "Analyze this suspicious file sample.exe"
AI calls:
1. run_file("sample.exe") → PE32 executable, x86, MSVC
2. detect_packer("sample.exe") → Not packed
3. extract_iocs("sample.exe") → 3 IPs, 2 URLs, 1 mutex
4. run_capa("sample.exe") → "creates persistence", "encrypts data"
5. dormant_detector("sample.exe") → 2 orphan functions with network calls
6. generate_yara_rule("sample.exe") → Detection rule generated
AI response: "This PE32 binary shows ransomware-like behavior. CAPA detected
encryption and persistence capabilities. I found 2 hidden network functions
that may serve as a backup C2 channel. Here's a YARA rule for detection..."
Example 2: Vulnerability Research with Taint Analysis
User: "Find exploitable bugs in this network daemon"
AI activates: taint_analysis_mode
AI calls:
1. taint_trace("daemon", verify_with_angr=True)
→ Found 3 source→sink paths:
recv() → strcpy() [CWE-120, CONFIRMED by angr]
read() → sprintf() [CWE-134, LIKELY]
getenv() → system() [CWE-78, POSSIBLE]
2. vulnerability_hunter("daemon")
→ 12 dangerous API calls, 4 exploitable patterns
3. generate_poc_exploit(target="daemon", vuln_type="bof", offset=128)
→ Python exploit script generated
AI response: "I found a confirmed stack buffer overflow where recv() data
flows directly into strcpy() at 0x40123C. angr proved the path is reachable.
Here's a working PoC..."
Example 3: Digital Forensics Investigation
User: "Analyze this memory dump from a compromised server"
AI calls:
1. memory_list_processes("memdump.raw")
→ 47 processes, 2 with suspicious names
2. memory_detect_injections("memdump.raw")
→ Code injection detected in PID 1842 (svchost.exe)
3. memory_extract_strings("memdump.raw", pid=1842)
→ C2 domain strings extracted
4. artifact_correlate_ioc(artifacts={"domains": ["evil-c2.com"]})
→ Matches known APT group IOCs
5. create_analysis_report(template_type="full_analysis")
→ PDF report with timeline and MITRE ATT&CK mapping
Example 4: Patch Diffing for 1-day Research
User: "Compare the patched and unpatched versions to find what was fixed"
AI activates: patch_diff_auto_mode
AI calls:
1. diff_binaries("libfoo-1.0.so", "libfoo-1.1.so")
→ 3 functions changed, 1 new function
2. patch_diff_1day("libfoo-1.0.so", "libfoo-1.1.so")
→ Automated analysis: bounds check added at parse_header()
3. r2_decompile("libfoo-1.0.so", "parse_header")
→ Decompiled vulnerable version (no bounds check)
4. r2_decompile("libfoo-1.1.so", "parse_header")
→ Decompiled patched version (memcpy size limited)
AI response: "The patch adds a bounds check in parse_header() at 0x12340.
The old version copies user-controlled length bytes via memcpy without
validation, creating a heap buffer overflow (CWE-122)."
Multi-Architecture Support
The arch_registry.py module maps architecture names to Radare2 configuration parameters, enabling tools to work across different CPU architectures without manual configuration:
Architecture
Key
r2 Arch
Bit Widths
PC Register
SP Register
Intel 32-bit
x86
x86
32
eip
esp
Intel/AMD 64-bit
x86_64
x86
64
rip
rsp
ARM 32-bit / Thumb
arm32
arm
16, 32
r15
r13
ARM 64-bit (AArch64)
arm64
arm
64
pc
sp
MIPS
mips
mips
32, 64
pc
sp
RISC-V
riscv
riscv
32, 64
pc
sp
PowerPC
ppc
ppc
32, 64
pc
r1
Alias resolution is handled automatically:
amd64 → x86_64
aarch64 → arm64
arm with bits=64 → arm64
arm with bits=16 or bits=32 → arm32
Tools like Radare2_esil_emulate, assemble_instructions, and r2_simulate_patch use this registry to configure the analysis environment correctly for any target binary.
Result Cache System
Two caching layers minimize redundant computation:
Tool Result Cache (result_cache.py)
The @cache_tool_result decorator caches any tool's output based on a SHA256 hash of the binary file and the tool's keyword arguments:
Storage backend: SQLite database via r2_db.py, accessible through get_cached_result() and set_cached_result() tools.
Metrics: Cache hits and misses are tracked via metrics_collector.record_cache_hit() and record_cache_miss(), visible through the get_tool_metrics tool.
Analysis Cache (analysis_cache.py)
A multi-level cache specifically for decompilation results (which are expensive to compute):
Import/Export: The export_analysis_cache and import_analysis_cache tools allow saving cache state to/from rcpack files for sharing between environments.
AI Memory System
The AI memory system (memory_tools.py + core/memory.py) provides persistent, queryable storage for analysis findings across sessions. This allows the AI to:
Remember what it previously found about a binary
Cross-reference findings between different samples
Tag and search sessions by topic, malware family, or technique
How It Works
create_memory_session("analysis of ransomware sample")
│
├── store_analysis_finding("Found AES-256 encryption at 0x401000", tags=["crypto", "ransomware"])
├── store_analysis_finding("C2 beacon interval: 30 seconds", tags=["c2", "network"])
└── tag_analysis_session(tags=["ransomware", "financial-sector"])
# Later, in a different session:
query_analysis_memories("ransomware encryption")
→ Returns previous findings about ransomware encryption patterns
get_binary_analysis_context("sample.exe")
→ Returns all findings ever recorded for this binary
Storage: Async SQLite database at the path configured by MEMORY_DB_PATH (default: ~/.reversecore_mcp/memory.db).
Portability: Use export_memory_store and import_memory_store to transfer the entire memory database between environments.
Web Dashboard
When running in HTTP mode (MCP_TRANSPORT=http), a web dashboard is available at http://localhost:8000/dashboard. It provides:
Binary upload with drag-and-drop
Real-time analysis status
Interactive function list and disassembly view
IOC extraction results
Server health monitoring
Tech stack: FastAPI + Jinja2 templates + HTMX (loaded locally from dashboard/static/, no CDN dependency for CSP compliance).
Security features:
CSRF tokens on all state-changing forms
Jinja2 auto-escaping enabled
All user input sanitized via html.escape() before display
Path traversal protection via validate_file_path()
Deployment
Production Checklist
Before deploying to production:
Item
How
Set API key
MCP_API_KEY=<strong-random-key>
Use non-root user
Built-in: container runs as appuser (UID 1000)
Set resource limits
Default: 2 CPU / 4 GB RAM in docker-compose.yml
Enable structured logging
LOG_FORMAT=json for log aggregation
Configure Redis
REDIS_URL=redis://<host>:6379/0 for task queue and caching
Set workspace path
REVERSECORE_WORKSPACE=/path/to/isolated/directory
Review rate limits
REVERSECORE_RATE_LIMIT=60 (requests/min, adjust as needed)
Enable sandbox
REVERSECORE_SANDBOX_ENABLED=true for dynamic analysis isolation
Health Checks
The server provides HTTP health check endpoints for orchestration:
# Liveness (always 200 if process is running)
curl http://localhost:8000/health/live
# Readiness (checks tool availability)
curl http://localhost:8000/health/ready
# Full health (requires API key if configured)
curl -H "X-API-Key: <key>" http://localhost:8000/health
These endpoints are exempted from API key authentication so load balancers and container orchestrators can probe them.
Container Healthcheck
The Docker image includes a built-in HEALTHCHECK instruction that verifies TCP connectivity to port 8000 every 30 seconds. Docker and Kubernetes will automatically restart unhealthy containers.
Troubleshooting
Common Issues
The required CLI tool is not installed in the environment.
Solution: If using Docker, verify the tool is in the base image:
docker exec reversecore-mcp-arm64 which r2 yara binwalk tsk_recover gdb
If using local Python installation, install the missing tool:
No. This project is a complement, not a replacement. It uses r2ghidra (the Ghidra decompiler engine embedded in Radare2) for decompilation. It does not provide a GUI, and it does not have the interactive analysis workflow of a full disassembler. Its purpose is to let AI assistants perform analysis tasks programmatically.
No. The r2ghidra plugin embeds the Ghidra decompiler engine directly inside Radare2. No JDK, no Ghidra installation, no Ghidra project files. Just r2 with the r2ghidra plugin compiled in.
Any client that implements the Model Context Protocol specification. Tested with: Claude Desktop, Cursor, Windsurf, and Google Antigravity. The server supports both stdio and HTTP/SSE transports.
Yes. Static analysis (disassembly, decompilation, string extraction, IOC extraction, YARA scanning) works on any file format regardless of host OS. Dynamic analysis (emulation, fuzzing) may have limitations depending on the target architecture.
The Docker container provides isolation: non-root user, no network by default in CI, resource limits. For live malware analysis, we recommend running in a dedicated VM or using the sandbox feature (REVERSECORE_SANDBOX_ENABLED=true). Static analysis tools (r2, YARA, strings) never execute the target binary.
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,
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.
Tools
Tools
Noch keine Tool-Liste. Remote-Server erhalten eine nach dem ersten Health-Check.
FAQ
Fragen
Wie installiere ich Reversecore?
Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
Welchen Transport verwendet Reversecore?
Reversecore läuft lokal über stdio.
Wann wurde Reversecore zuletzt geprüft?
Zuletzt geprüft: 2026-11-15. 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.