एक सुरक्षा-प्रथम MCP सर्वर जो AI एजेंटों को स्वचालित रिवर्स इंजीनियरिंग, मैलवेयर विश्लेषण, फोरेंसिक, भेद्यता अनुसंधान और SAST करने में सक्षम बनाता है — Radare2, YARA, LIEF, Capstone और अन्य द्वारा संचालित।
एआई-संचालित रिवर्स इंजीनियरिंग और सुरक्षा विश्लेषण, Model Context Protocol के माध्यम से
एक एमसीपी सर्वर जो Claude और Cursor जैसे एआई सहायकों को प्राकृतिक भाषा के माध्यम से रिवर्स इंजीनियरिंग, मैलवेयर विश्लेषण, भेद्यता अनुसंधान, डिजिटल फोरेंसिक और सोर्स कोड ऑडिटिंग करने की क्षमता देता है।
Reversecore MCP एक Model Context Protocol सर्वर है जो 120 विश्लेषण टूल को एक ही इंटरफ़ेस में लपेटता है जिसे एआई सहायक प्राकृतिक भाषा के माध्यम से कॉल कर सकते हैं।
एक दर्जन अलग-अलग टूल की कमांड-लाइन सिंटैक्स सीखने के बजाय, आप वर्णन करते हैं कि आप क्या चाहते हैं:``` "Decompile the main function of this malware sample, extract all network IOCs, map the behavior to MITRE ATT&CK, and generate a triage report."
AI सहायक इसे tool calls में विभाजित करता है:```
r2_decompile("sample.exe", "main")
→ extract_iocs("sample.exe")
→ add_mitre_technique(technique_id="T1071.001", ...)
→ create_analysis_report(template_type="quick_triage")
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.
AI Client (Claude / Cursor / any MCP-compatible client) │ MCP Protocol (stdio or HTTP/SSE) ▼ ┌──────────────────────────────────────────────────────┐ │ FastMCP 3.4.4 Server │ │ 120 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) │ └──────────────────────────────────────────────────────┘
### मुख्य अवसंरचना (37 मॉड्यूल)
`reversecore_mcp/core/` निर्देशिका में साझा अवसंरचना है जिस पर सभी उपकरण आधारित हैं:
| मॉड्यूल | उद्देश्य |
|---|---|
| `config.py` | 34+ पर्यावरण चर के साथ Pydantic BaseSettings |
| `security.py` | इनपुट स्वच्छता, कमांड तर्क सत्यापन |
| `validators.py` | TOCTOU शमन और सिम्लिंक समाधान के साथ फ़ाइल और बाइनरी पथ सत्यापन |
| `r2_pool.py` | कॉन्फ़िगर करने योग्य आकार के साथ थ्रेड-सुरक्षित Radare2 कनेक्शन पूल |
| `r2_helpers.py` | संरचित Radare2 आउटपुट पार्सिंग |
| `metrics.py` | प्रति-उपकरण निष्पादन समय, कॉल गणना, त्रुटि दर, कैश सांख्यिकी |
| `memory.py` | सत्रों में विश्लेषण निष्कर्षों को स्थायी रखने के लिए async SQLite-समर्थित AI मेमोरी स्टोर |
| `mitre_mapper.py` | MITRE ATT&CK तकनीक आईडी मैपिंग इंजन |
| `evidence.py` | साक्ष्य वर्गीकरण प्रणाली: `OBSERVED`, `INFERRED`, `POSSIBLE` |
| `resilience.py` | रीट्राय, सर्किट-ब्रेकर और टाइमआउट डेकोरेटर पैटर्न |
| `task_queue.py` | Redis + arq के माध्यम से पृष्ठभूमि कार्य कतार |
| `extension_registry.py` | प्लगइन पंजीकरण और जीवनचक्र प्रबंधन |
| `arch_registry.py` | बहु-आर्किटेक्चर मैपिंग (x86, x86_64, ARM32, ARM64, MIPS, RISC-V, PPC → r2 arch/bits/registers) |
| `result_cache.py` | SHA256-आधारित उपकरण परिणाम कैशिंग डेकोरेटर (`@cache_tool_result`) |
| `analysis_cache.py` | बहु-स्तरीय डीकंपिलेशन कैश (L1: Redis, L2: SQLite) |
| `result.py` | `ToolSuccess` / `ToolError` Pydantic मॉडल |
| `exceptions.py` | `RCMCP-E*` त्रुटि कोड वाली 17 अपवाद कक्षाएं |
| `decorators.py` | `@log_execution`, `@track_metrics` |
| `error_handling.py` | `@handle_tool_errors` डेकोरेटर |
| `error_formatting.py` | संरचित त्रुटि प्रतिक्रिया स्वरूपण |
| `execution.py` | टाइमआउट और आउटपुट सीमाओं के साथ सुरक्षित सबप्रोसेस निष्पादन |
| `command_spec.py` | सबप्रोसेस कॉल के लिए कमांड विनिर्देश |
| `loader.py` | गतिशील उपकरण मॉड्यूल लोडर |
| `plugin.py` | प्लगइन आधार वर्ग |
| `extension.py` | एक्सटेंशन आधार वर्ग |
| `container.py` | कंटेनर/सैंडबॉक्स निष्पादन समर्थन |
| `audit.py` | ऑडिट लॉगिंग |
| `binary_cache.py` | बाइनरी फ़ाइल कैशिंग |
| `json_utils.py` | orjson के माध्यम से JSON क्रमांकन (stdlib json से 3-5x तेज़) |
| `logging_config.py` | Loguru-आधारित संरचित लॉगिंग |
| `report_generator.py` | रिपोर्ट रेंडरिंग इंजन (Markdown, xhtml2pdf के माध्यम से PDF) |
| `resource_manager.py` | MCP संसाधन जीवनचक्र प्रबंधन |
| `sast/python_ast_scanner.py` | Python AST-आधारित भेद्यता स्कैनर |
| `sast/regex_scanner.py` | C/C++ रेगेक्स-आधारित भेद्यता स्कैनर |
| `sast/rule_manager.py` | SAST नियम लोडिंग और प्रबंधन |
---
## उपकरण सूची (120 उपकरण)
प्रत्येक उपकरण एक संरचित `ToolResult` लौटाता है — या तो टाइप किए गए `data` के साथ `ToolSuccess` या `RCMCP-E*` त्रुटि कोड के साथ `ToolError`। उपकरण 8 प्लगइन्स में व्यवस्थित हैं।
---
### 🔍 स्थैतिक विश्लेषण प्लगइन (24 उपकरण)
| # | उपकरण | बैकएंड | विवरण |
|---|---|---|---|
| 1 | `run_strings` | `strings` CLI | कॉन्फ़िगर करने योग्य न्यूनतम-लंबाई के साथ ASCII/यूनिकोड स्ट्रिंग निष्कर्षण |
| 2 | `run_binwalk` | Binwalk | एम्बेडेड हस्ताक्षरों और फाइलसिस्टम के लिए फ़र्मवेयर गहन-स्कैन |
| 3 | `run_binwalk_extract` | Binwalk | binwalk द्वारा खोजी गई एम्बेडेड फ़ाइलें निकालें |
| 4 | `parse_binary_with_lief` | LIEF | पूर्ण PE/ELF/Mach-O हेडर, सेक्शन, इम्पोर्ट/एक्सपोर्ट, TLS पार्सिंग |
| 5 | `detect_packer` | DIE | त्वरित पैकर/कंपाइलर पहचान |
| 6 | `detect_packer_deep` | DIE (`diec`) | Detect It Easy के माध्यम से गहन पैकर/प्रोटेक्टर विश्लेषण |
| 7 | `run_capa` | CAPA (Mandiant FLARE) | क्षमता पहचान — "डेटा एन्क्रिप्ट करता है", "पर्सिस्टेंस बनाता है", आदि। |
| 8 | `run_capa_quick` | CAPA | नियम उपसमुच्चय के साथ त्वरित क्षमता स्कैन |
| 9 | `generate_signature` | Radare2 | पहचान के लिए बाइनरी हस्ताक्षर उत्पन्न करें |
| 10 | `generate_yara_rule` | Radare2 + YARA | बाइनरी पैटर्न से YARA पहचान नियम उत्पन्न करें |
| 11 | `generate_advanced_yara_rule` | Radare2 + YARA | व्यवहारिक संकेतकों के साथ उन्नत YARA नियम |
| 12 | `scan_for_versions` | LIEF + strings | एम्बेडेड संस्करण स्ट्रिंग्स के लिए बाइनरी स्कैन करें |
| 13 | `extract_rtti_info` | Radare2 | C++ RTTI (रन-टाइम प्रकार सूचना) निकालें |
| 14 | `diff_binaries` | Radare2 | दो फ़ाइल संस्करणों के बीच सिमेंटिक बाइनरी अंतर |
| 15 | `analyze_variant_changes` | Radare2 | बाइनरी वेरिएंट्स के बीच परिवर्तनों का विश्लेषण करें |
| 16 | `match_libraries` | Radare2 | फ़ंक्शन फिंगरप्रिंट द्वारा स्थिर रूप से लिंक की गई लाइब्रेरीज़ की पहचान करें |
| 17 | `patch_diff_1day` | Radare2 + heuristics | 1-दिवसीय भेद्यता अनुसंधान के लिए स्वचालित पैच अंतर विश्लेषण |
| 18 | `analyze_patch_diff_auto` | Radare2 + inference | स्वचालित पैच भेद्यता अनुमान |
| 19 | `emulate_binary` | Radare2 ESIL | रजिस्टर/मेमोरी-ट्रेस किए गए कोड अनुकरण |
| 20 | `generate_fuzzing_harness` | Qiling + AFL++ | किसी विशिष्ट फ़ंक्शन को लक्षित करने वाला फ़ज़िंग हार्नेस उत्पन्न करें |
| 21 | `run_fuzzing_campaign` | AFL++ | क्रैश संग्रह के साथ पूर्ण फ़ज़िंग अभियान चलाएं |
| 22 | `triage_crash` | GDB | क्रैश पार्सिंग और शोषणक्षमता आकलन |
| 23 | `verify_path_and_get_args` | angr | प्रतीकात्मक निष्पादन — पथ पहुंच क्षमता सिद्ध करें और ठोस इनपुट की गणना करें |
| 24 | `taint_trace` | Radare2 + angr | स्रोतों से सिंक तक डेटा-प्रवाह टेंट विश्लेषण |
---
### 🔐 स्रोत कोड ऑडिट प्लगइन (1 उपकरण)
| # | उपकरण | बैकएंड | विवरण |
|---|---|---|---|
| 25 | `audit_source_code` | AST + Regex | खतरनाक पैटर्न के लिए Python AST स्कैनिंग + C/C++ रेगेक्स स्कैनिंग |
---
### 🛠️ सामान्य उपयोगिताएँ प्लगइन (20 उपकरण)
**फ़ाइल संचालन (5 उपकरण)**
| # | उपकरण | विवरण |
|---|---|---|
| 26 | `run_file` | फ़ाइल प्रकार, आर्किटेक्चर और कंपाइलर फिंगरप्रिंटिंग |
| 27 | `copy_to_workspace` | किसी फ़ाइल को विश्लेषण कार्यक्षेत्र में कॉपी करें |
| 28 | `create_directory` | कार्यक्षेत्र में निर्देशिका बनाएं |
| 29 | `list_workspace` | कार्यक्षेत्र की सभी फ़ाइलों की सूची बनाएं |
| 30 | `scan_workspace` | फ़ाइल मेटाडेटा के साथ पूर्ण कार्यक्षेत्र स्कैन |
**पैच स्पष्टीकरण (1 उपकरण)**
| # | उपकरण | विवरण |
|---|---|---|
| 31 | `explain_patch` | बाइनरी पैच को प्राकृतिक भाषा में समझाएं |
**असेम्बलर (1 उपकरण)**
| # | उपकरण | बैकएंड | विवरण |
|---|---|---|---|
| 32 | `assemble_instructions` | Keystone | निर्देशों को मशीन कोड में असेंबल करें (x86, ARM, MIPS, आदि) |
**AI मेमोरी प्रबंधन (11 उपकरण)**
ये उपकरण AI को async SQLite डेटाबेस का उपयोग करके विश्लेषण सत्रों में निष्कर्षों को स्थायी रखने और पुनः प्राप्त करने की सुविधा देते हैं:
| # | उपकरण | विवरण |
|---|---|---|
| 33 | `create_memory_session` | किसी विश्लेषण के लिए नया मेमोरी सत्र शुरू करें |
| 34 | `store_analysis_finding` | टैग के साथ विश्लेषण निष्कर्ष स्थायी रूप से सहेजें |
| 35 | `query_analysis_memories` | क्वेरी द्वारा पिछले निष्कर्ष खोजें |
| 36 | `get_binary_analysis_context` | किसी विशिष्ट बाइनरी के लिए सभी संदर्भ प्राप्त करें |
| 37 | `tag_analysis_session` | संगठन के लिए सत्र में टैग जोड़ें |
| 38 | `search_memories_by_tag` | टैग द्वारा सत्र/निष्कर्ष खोजें |
| 39 | `delete_analysis_session` | सत्र और उसके निष्कर्ष हटाएं |
| 40 | `cleanup_expired_sessions` | एक सीमा से पुराने सत्र हटाएं |
| 41 | `list_analysis_sessions` | सभी सक्रिय सत्रों की सूची बनाएं |
| 42 | `export_memory_store` | सभी मेमोरी को पोर्टेबल प्रारूप में निर्यात करें |
| 43 | `import_memory_store` | निर्यात फ़ाइल से मेमोरी आयात करें |
**सर्वर निगरानी (2 उपकरण)**
| # | उपकरण | विवरण |
|---|---|---|
| 44 | `get_server_health` | अपटाइम, मेमोरी उपयोग, लोड किए गए उपकरण, Python संस्करण |
| 45 | `get_tool_metrics` | प्रति-उपकरण कॉल गणना, औसत निष्पादन समय, त्रुटि दर, कैश हिट/मिस |
---
### ⚙️ Radare2 और r2ghidra प्लगइन (30 उपकरण)
सभी Radare2 उपकरण थ्रेड-सुरक्षित कनेक्शन पूल (`r2_pool.py`) का उपयोग करते हैं जो r2pipe सत्रों को स्वचालित रूप से प्रबंधित करता है।
| # | उपकरण | विवरण |
|---|---|---|
| 46 | `Radare2_open_file` | Radare2 में बाइनरी फ़ाइल खोलें |
| 47 | `Radare2_close_file` | Radare2 सत्र बंद करें |
| 48 | `Radare2_list_open_files` | वर्तमान में खुली फ़ाइलों की सूची बनाएं |
| 49 | `Radare2_analyze_binary` | पूर्ण स्वतः-विश्लेषण (`aaa`) चलाएं |
| 50 | `Radare2_list_functions` | सभी पहचाने गए फ़ंक्शनों की सूची बनाएं |
| 51 | `Radare2_disassemble_function` | किसी विशिष्ट फ़ंक्शन को डिस्सेम्बल करें |
| 52 | `Radare2_disassemble_address` | किसी विशिष्ट पते पर डिस्सेम्बल करें |
| 53 | `Radare2_decompile_function` | r2ghidra के माध्यम से डीकंपाइल करें (r2 में एम्बेडेड Ghidra इंजन, JVM की आवश्यकता नहीं) |
| 54 | `Radare2_list_exports` | निर्यातित प्रतीकों की सूची बनाएं |
| 55 | `Radare2_list_imports` | आयातित फ़ंक्शनों की सूची बनाएं |
| 56 | `Radare2_list_sections` | एन्ट्रॉपी के साथ बाइनरी अनुभागों की सूची बनाएं |
| 57 | `Radare2_list_strings` | बाइनरी में पाई गई स्ट्रिंग्स की सूची बनाएं |
| 58 | `Radare2_find_cross_references` | फ़ंक्शन कॉल और डेटा संदर्भों को ट्रैक करें |
| 59 | `Radare2_search_bytes` | बाइनरी में बाइट पैटर्न खोजें |
| 60 | `Radare2_get_binary_info` | बाइनरी मेटाडेटा प्राप्त करें (arch, format, endianness) |
| 61 | `Radare2_execute_command` | रॉ Radare2 कमांड निष्पादित करें |
| 62 | `Radare2_esil_emulate` | किसी विशिष्ट पते पर ESIL अनुकरण |
| 63 | `Radare2_get_hexdump` | वर्चुअल पते पर हेक्स डंप |
| 64 | `Radare2_get_cfg_data` | नियंत्रण प्रवाह ग्राफ़ डेटा निकालें |
| 65 | `Radare2_generate_cfg_png` | CFG को PNG छवि के रूप में उत्पन्न करें |
| 66 | `Radare2_generate_callgraph` | फ़ंक्शन कॉल ग्राफ़ उत्पन्न करें |
| 67 | `Radare2_recover_structures` | C संरचनाओं को स्वतः-पुनर्प्राप्त करें और एनोटेशन डेटाबेस में स्थायी रखें |
| 68 | `Radare2_decompile_with_r2ghidra` | कैशिंग के साथ उच्च-गुणवत्ता वाली C डीकंपिलेशन |
| 69 | `Radare2_annotate_binary` | बाइनरी में एनोटेशन जोड़ें |
| 70 | `Radare2_get_annotations` | एनोटेशन प्राप्त करें |
| 71 | `Radare2_export_annotations` | एनोटेशन को फ़ाइल में निर्यात करें |
| 72 | `Radare2_import_annotations` | फ़ाइल से एनोटेशन आयात करें |
| 73 | `Radare2_detect_crypto_constants` | क्रिप्टोग्राफ़िक स्थिरांक (AES S-box, आदि) पहचानें |
| 74 | `Radare2_find_gadgets` | ROP/JOP गैजेट खोजें |
| 75 | `Radare2_calculate_entropy` | प्रति-अनुभाग एन्ट्रॉपी की गणना करें |
---
### 🦠 मैलवेयर विश्लेषण प्लगइन (9 उपकरण)
| # | उपकरण | बैकएंड | विवरण |
|---|---|---|---|
| 76 | `dormant_detector` | Radare2 + heuristics | छिपे हुए बैकडोर, अनाथ फ़ंक्शन, टाइम-बॉम्ब, लॉजिक बॉम्ब खोजें |
| 77 | `adaptive_vaccine` | YARA + Radare2 | खतरों को निष्प्रभावी करने के लिए पहचान YARA नियम + बाइनरी पैच उत्पन्न करें |
| 78 | `vulnerability_hunter` | Radare2 + analysis | खतरनाक API पैटर्न (strcpy, sprintf) और ROP गैजेट श्रृंखलाएं पहचानें |
| 79 | `extract_iocs` | Regex + LIEF | IP, URL, डोमेन, हैश, रजिस्ट्री कुंजियाँ, क्रिप्टो पते निकालें |
| 80 | `run_yara` | YARA | कस्टम नियम फ़ाइलों और अंतर्निहित नियमसेट के साथ स्कैन करें |
| 81 | `generate_poc_exploit` | pwntools | प्रूफ-ऑफ-कॉन्सेप्ट एक्सप्लॉइट कोड उत्पन्न करें |
| 82 | `build_rop_chain` | ROPgadget + pwntools | स्वचालित ROP श्रृंखला निर्माण |
| 83 | `autonomous_vuln_hunt` | Radare2 + angr | स्वायत्त भेद्यता शिकार पाइपलाइन |
| 84 | `analyze_heap_exploit` | Radare2 + heuristics | हीप शोषण विश्लेषण (UAF, double-free, overflow) |
---
### 🕵️ डिजिटल फोरेंसिक प्लगइन (22 उपकरण)
**मेमोरी फोरेंसिक (6 उपकरण)**
| # | उपकरण | बैकएंड | विवरण |
|---|---|---|---|
| 85 | `memory_analyze` | Volatility3 | पूर्ण मेमोरी डंप विश्लेषण |
| 86 | `memory_list_processes` | Volatility3 | मेमोरी डंप से चल रही प्रक्रियाओं की सूची बनाएं |
| 87 | `memory_detect_injections` | Volatility3 | प्रक्रिया मेमोरी में कोड इंजेक्शन पहचानें |
| 88 | `memory_extract_strings` | Volatility3 | प्रक्रिया मेमोरी से स्ट्रिंग्स निकालें |
| 89 | `memory_dump_module` | Volatility3 | मेमोरी से लोड किए गए मॉड्यूल का डंप करें |
| 90 | `memory_list_symbols` | Volatility3 | मेमोरी से प्रतीकों की सूची बनाएं |
**डिस्क फोरेंसिक (6 उपकरण)**
| # | उपकरण | बैकएंड | विवरण |
|---|---|---|---|
| 91 | `disk_list_partition` | Sleuth Kit | डिस्क विभाजनों की सूची बनाएं |
| 92 | `disk_list_files` | Sleuth Kit | डिस्क छवि में फ़ाइलों की सूची बनाएं |
| 93 | `disk_recover_deleted` | Sleuth Kit | हटाई गई फ़ाइलें पुनर्प्राप्त करें |
| 94 | `disk_analyze_mft` | Sleuth Kit | NTFS मास्टर फ़ाइल तालिका का विश्लेषण करें |
| 95 | `disk_extract_file` | Sleuth Kit | डिस्क छवि से फ़ाइल निकालें |
| 96 | `disk_hash_verify` | Sleuth Kit | हैश के माध्यम से फ़ाइल अखंडता सत्यापित करें |
**नेटवर्क फोरेंसिक (5 उपकरण)**
| # | उपकरण | बैकएंड | विवरण |
|---|---|---|---|
| 97 | `pcap_analyze` | Scapy | PCAP विश्लेषण: प्रोटोकॉल विवरण, विसंगतियाँ |
| 98 | `pcap_list_connections` | Scapy | सभी नेटवर्क कनेक्शनों की सूची बनाएं |
| 99 | `pcap_extract_dns` | Scapy | DNS क्वेरी और प्रतिक्रियाएं निकालें |
| 100 | `pcap_extract_c2` | Scapy | संभावित C2 संचार की पहचान करें |
| 101 | `pcap_reconstruct_stream` | Scapy | TCP स्ट्रीम पुनर्निर्माण करें |
**आर्टिफैक्ट विश्लेषण (5 उपकरण)**
| # | उपकरण | बैकएंड | विवरण |
|---|---|---|---|
| 102 | `artifact_collect` | Custom parsers | ब्राउज़र इतिहास, रजिस्ट्री हाइव्स, इवेंट लॉग, प्रीफेच एकत्र करें |
| 103 | `artifact_correlate_ioc` | Custom parsers | ज्ञात IOC के साथ आर्टिफैक्ट्स का सहसंबंध बनाएं |
| 104 | `artifact_generate_yara` | YARA | आर्टिफैक्ट पैटर्न से YARA नियम उत्पन्न करें |
| 105 | `artifact_timeline` | Custom parsers | कई आर्टिफैक्ट स्रोतों से टाइमलाइन बनाएं |
| 106 | `artifact_report` | Custom parsers | आर्टिफैक्ट विश्लेषण रिपोर्ट उत्पन्न करें |
---
### 📝 रिपोर्ट निर्माण प्लगइन (14 उपकरण)
| # | उपकरण | विवरण |
|---|---|---|
| 107 | `get_system_time` | सर्वर टाइमस्टैम्प प्राप्त करें (AI को तिथियों की कल्पना करने से रोकता है) |
| 108 | `set_timezone` | रिपोर्टिंग समय क्षेत्र सेट करें |
| 109 | `get_timezone_info` | वर्तमान समय क्षेत्र जानकारी प्राप्त करें |
| 110 | `start_report_session` | अद्वितीय ID के साथ समयबद्ध विश्लेषण सत्र शुरू करें |
| 111 | `end_report_session` | सत्र अंतिम रूप दें: अवधि की गणना करें, IOC/ATT&CK सूचियाँ लॉक करें |
| 112 | `get_report_session_status` | सत्र स्थिति जांचें |
| 113 | `list_report_sessions` | सभी सक्रिय/पूर्ण सत्रों की सूची बनाएं |
| 114 | `add_ioc` | लाइव सत्र के दौरान IOC एकत्र करें और टैग करें |
| 115 | `add_analysis_note` | श्रेणीबद्ध नोट्स जोड़ें (निष्कर्ष, चेतावनी, व्यवहार) |
| 116 | `add_mitre_technique` | MITRE ATT&CK तकनीक आईडी दस्तावेज़ित करें |
| 117 | `set_severity` | सत्र गंभीरता सेट करें (निम्न/मध्यम/उच्च/गंभीर) |
| 118 | `create_analysis_report` | रिपोर्ट को 4 मोड में रेंडर करें: `full_analysis`, `quick_triage`, `ioc_summary`, `executive_brief` |
| 119 | `generate_vex_report` | VEX (Vulnerability Exploitability eXchange) रिपोर्ट उत्पन्न करें |
| 120 | `generate_sigma_rule` | SIGMA पहचान नियम उत्पन्न करें |
---
## निर्देशित विश्लेषण प्रॉम्प्ट (22 मोड)
प्रॉम्प्ट पूर्व-निर्मित विश्लेषण वर्कफ़्लो हैं जो AI को संरचित व्यक्तित्व, चरण-दर-चरण उपकरण उपयोग अनुक्रम और साक्ष्य वर्गीकरण नियमों से तैयार करते हैं। आप अपने AI क्लाइंट में प्रॉम्प्ट नाम का संदर्भ देकर उन्हें सक्रिय करते हैं।
### मैलवेयर विश्लेषण (9 प्रॉम्प्ट)
| प्रॉम्प्ट | उपयोग परिदृश्य |
|---|---|
| `full_analysis_mode` | 6-चरणीय व्यापक विश्लेषण: ट्राइएज → डिस्सेम्बली → व्यवहार → नेटवर्क → पर्सिस्टेंस → रिपोर्ट |
| `malware_analysis_mode` | खतरा वर्गीकरण के साथ केंद्रित मैलवेयर विश्लेषण |
| `basic_analysis_mode` | प्रारंभिक मूल्यांकन और त्वरित निर्णयों के लिए तीव्र ट्राइएज |
| `apt_hunting_mode` | APT-विशिष्ट शिकार: पार्श्व गति, पर्सिस्टेंस, डेटा बहिर्गमन |
| `malware_defense_mode` | रक्षा-उन्मुख: पहचान नियम और शमन उत्पन्न करें |
| `unpacking_mode` | पैकिंग/अस्पष्टता का विश्लेषण और बायपास (Themida, VMProtect, UPX) |
| `c2_extraction_mode` | C2 संचार अवसंरचना निकालें और विश्लेषण करें |
| `ransomware_triage_mode` | रैनसमवेयर-विशिष्ट ट्राइएज: एन्क्रिप्शन विश्लेषण, कुंजी पुनर्प्राप्ति आकलन |
| `code_similarity_mode` | कोड समानता और साझा वंश के लिए बाइनरी की तुलना करें |
### सुरक्षा अनुसंधान (6 प्रॉम्प्ट)
| प्रॉम्प्ट | उपयोग परिदृश्य |
|---|---|
| `vulnerability_research_mode` | बग शिकार: बफर ओवरफ्लो, UAF, कमांड इंजेक्शन |
| `crypto_analysis_mode` | क्रिप्टोग्राफ़िक कार्यान्वयन विश्लेषण और कमजोरी पहचान |
| `firmware_analysis_mode` | IoT/एम्बेडेड फ़र्मवेयर: binwalk निष्कर्षण, UART स्ट्रिंग्स, हार्डकोडेड क्रेडेंशियल |
| `patch_analysis_mode` | सुरक्षा पैच विश्लेषण और रिग्रेशन परीक्षण |
| `source_code_audit_mode` | स्रोत कोड सुरक्षा ऑडिट (Python, C, C++) |
| `autonomous_vuln_hunt_mode` | स्वायत्त भेद्यता शिकार पाइपलाइन |
### CVE अनुसंधान और एक्सप्लॉइट विकास (5 प्रॉम्प्ट)
| प्रॉम्प्ट | उपयोग परिदृश्य |
|---|---|
| `taint_analysis_mode` | डेटा-प्रवाह टेंट विश्लेषण: स्वचालित स्रोत→सिंक पथ खोज |
| `heap_exploit_mode` | हीप शोषण विश्लेषण और PoC निर्माण |
| `fuzzing_mode` | फ़ज़िंग अभियान सेटअप और क्रैश ट्राइएज |
| `patch_diff_auto_mode` | 1-दिवसीय भेद्यता अनुसंधान के लिए स्वचालित पैच अंतर |
| `cve_discovery_pipeline_mode` | पूर्ण CVE खोज पाइपलाइन: पैच अंतर से कार्यशील एक्सप्लॉइट तक |
### अन्य (2 प्रॉम्प्ट)
| प्रॉम्प्ट | उपयोग परिदृश्य |
|---|---|
| `game_analysis_mode` | गेम क्लाइंट विश्लेषण: एंटी-चीट पहचान, प्रोटोकॉल RE, मेमोरी निरीक्षण |
| `report_generation_mode` | MITRE ATT&CK तकनीक मैपिंग के साथ संरचित सत्र वर्कफ़्लो |
> **प्रॉम्प्ट कैसे काम करते हैं:** प्रत्येक प्रॉम्प्ट AI को संरचित विश्लेषण व्यक्तित्व से तैयार करता है। इसमें चेन-ऑफ-थॉट तर्क चेकपॉइंट (जहां AI को आगे बढ़ने से पहले रुककर मूल्यांकन करना चाहिए) और साक्ष्य वर्गीकरण नियम शामिल हैं जो AI को अटकलों को तथ्य के रूप में बताने से रोकते हैं। प्रत्येक निष्कर्ष को `OBSERVED` (सीधे सत्यापित), `INFERRED` (स्थैतिक विश्लेषण से तार्किक रूप से व्युत्पन्न), या `POSSIBLE` (आगे सत्यापन की आवश्यकता) के रूप में लेबल किया जाना चाहिए।
---
## MCP संसाधन (11 URI)
संसाधन केवल-पठनीय डेटा एंडपॉइंट हैं जिन्हें AI क्लाइंट URI टेम्पलेट के माध्यम से एक्सेस कर सकते हैं। वे स्पष्ट उपकरण कॉल की आवश्यकता के बिना संरचित डेटा प्रदान करके उपकरणों का पूरक हैं।
### स्थैतिक संसाधन
| URI | विवरण |
|---|---|
| `reversecore://guide` | फ़ाइल पथ नियमों और सर्वोत्तम प्रथाओं के साथ उपकरण उपयोग मार्गदर्शिका |
| `reversecore://guide/structures` | संरचना पुनर्प्राप्ति और क्रॉस-रेफरेंस विश्लेषण तकनीकी मार्गदर्शिका |
| `reversecore://tools` | सभी 120 पंजीकृत उपकरणों के लिए पूर्ण दस्तावेज़ीकरण |
| `reversecore://logs` | एप्लिकेशन लॉग (अंतिम 100 पंक्तियाँ) |
### गतिशील संसाधन (प्रति-बाइनरी वर्चुअल फाइलसिस्टम)
ये URI प्रति-बाइनरी हल होते हैं और मांग पर संबंधित विश्लेषण उपकरणों को आमंत्रित करते हैं:
| URI टेम्पलेट | विवरण |
|---|---|
| `reversecore://{filename}/strings` | बाइनरी से सभी स्ट्रिंग्स निकालें |
| `reversecore://{filename}/iocs` | IOC निकालें (IP, URL, ईमेल, हैश) |
| `reversecore://{filename}/func/{address}/code` | किसी फ़ंक्शन के लिए डीकंपाइल किया गया छद्म-C कोड |
| `reversecore://{filename}/func/{address}/asm` | किसी फ़ंक्शन के लिए डिस्सेम्बली |
| `reversecore://{filename}/func/{address}/cfg` | Mermaid प्रारूप में नियंत्रण प्रवाह ग्राफ़ |
| `reversecore://{filename}/functions` | बाइनरी में सभी फ़ंक्शनों की सूची |
| `reversecore://{filename}/dormant_detector` | निष्क्रिय डिटेक्टर विश्लेषण परिणाम |
---
## त्वरित आरंभ
### विकल्प 1 — PyPI (सबसे सरल)```bash
pip install reversecore-mcp
reversecore-mcp
पूर्वापेक्षाएँ: आपके सिस्टम पर Radare2 इंस्टॉल होना चाहिए (
r2 --version)। YARA स्वचालित रूप सेyara-pythonके माध्यम से इंस्टॉल होता है।
सभी विश्लेषण इंजन (Radare2, r2ghidra, YARA, Binwalk, Sleuth Kit, GDB, आदि) पहले से इंस्टॉल आते हैं:```bash
docker run -i --rm
-v /path/to/your/samples:/app/workspace
-e REVERSECORE_WORKSPACE=/app/workspace
-e MCP_TRANSPORT=stdio
ghcr.io/sjkim1127/reversecore_mcp:latest
### विकल्प 3 — स्रोत से निर्माण (Docker Compose)```bash
git clone https://github.com/sjkim1127/Reversecore_MCP.git
cd Reversecore_MCP
./scripts/run-docker.sh # auto-detects Intel / Apple Silicon
या मैन्युअल रूप से:```bash docker compose --profile x86 up -d # Intel/AMD docker compose --profile arm64 up -d # Apple Silicon (M1/M2/M3)
### विकल्प 4 — Python (स्थानीय विकास)```bash
git clone https://github.com/sjkim1127/Reversecore_MCP.git
cd Reversecore_MCP
python -m venv venv && source venv/bin/activate
pip install -r requirements.txt
python -m reversecore_mcp.server
लोकल मोड के लिए पूर्वापेक्षाएँ: आपके सिस्टम पर Radare2 स्थापित होना चाहिए (
r2 --version)। व्यक्तिगत टूल बैकएंड (YARA, LIEF, Capstone, आदि) pip के माध्यम से स्थापित किए जाते हैं। पूर्ण फोरेंसिक समर्थन के लिए, आपको Volatility3, Scapy, और Sleuth Kit की भी आवश्यकता होगी।
सर्वर कॉन्फ़िगरेशन को अपने IDE क्लाइंट सेटिंग्स में जोड़ें (उदाहरण के लिए, ~/.cursor/mcp.json या claude_desktop_config.json)।
यदि आप Docker Compose के माध्यम से कंटेनर चला रहे हैं, तो यह मोड stdio को सीधे चल रहे कंटेनर में भेजता है। शून्य स्टार्टअप विलंबता, स्थायी मेमोरी, और पूर्ण टूल उपलब्धता।```json { "mcpServers": { "Reversecore_MCP": { "command": "docker", "args": [ "exec", "-i", "-e", "MCP_TRANSPORT=stdio", "reversecore-mcp-arm64", "python", "-m", "reversecore_mcp.server" ] } } }
> यदि आप Intel/AMD पर हैं तो `reversecore-mcp-arm64` को `reversecore-mcp` से बदलें।
---
### 🌐 विकल्प 2: SSE HTTP मोड
नेटवर्क-आधारित स्ट्रीमिंग (Server-Sent Events) के लिए:```json
{
"mcpServers": {
"Reversecore_MCP": {
"url": "http://localhost:8000/mcp/sse"
}
}
}
हर सत्र के लिए एक नया, पृथक कंटेनर चलाता है:
⚠️ महत्वपूर्ण — Docker के अंदर फ़ाइल पथ
आपका लोकल फ़ोल्डर कंटेनर के अंदर
/app/workspaceपर माउंट होता है। फ़ाइलों को हमेशा केवल फ़ाइलनाम से संदर्भित करें, अपने लोकल पूर्ण पथ से नहीं।
❌ गलत ✅ सही r2_decompile("/Users/john/samples/mal.exe")r2_decompile("mal.exe")
सभी सेटिंग्स पर्यावरण चर या .env फ़ाइल के माध्यम से प्रदान की जा सकती हैं (.env.example देखें)। सेटिंग्स REVERSECORE_ उपसर्ग के साथ Pydantic BaseSettings द्वारा प्रबंधित की जाती हैं।
| चर | डिफ़ॉल्ट | विवरण |
|---|---|---|
REVERSECORE_PLUGIN_DIRS | "" | एक्सटेंशन प्लगइन्स के लिए स्कैन की जाने वाली अल्पविराम-पृथक निर्देशिकाएँ |
REVERSECORE_SAST_RULES_PATH | "" | कस्टम YAML SAST नियम फ़ाइल का पथ |
सुरक्षा डिफेंस-इन-डेप्थ (defense-in-depth) के रूप में लागू की गई है, जिसमें कई परतों पर सुरक्षा उपाय हैं:
| नियंत्रण | कार्यान्वयन |
|---|---|
| गैर-root निष्पादन | न्यूनतम क्षमताओं के साथ appuser (UID 1000) के रूप में चलता है |
| संसाधन सीमाएँ | Docker Compose CPU (2.0) और मेमोरी (4 GB) सीमाएँ लागू करता है |
| सैंडबॉक्स अलगाव | डायनामिक विश्लेषण टूल्स के लिए वैकल्पिक कंटेनर-आधारित सैंडबॉक्सिंग |
सभी 17 अपवाद कक्षाएँ प्रोग्रामेटिक हैंडलिंग के लिए RCMCP-E* त्रुटि कोड रखती हैं। पूर्ण पदानुक्रम के लिए Error Handling देखें।
git clone https://github.com/sjkim1127/Reversecore_MCP.git cd Reversecore_MCP python -m venv venv && source venv/bin/activate pip install -r requirements.txt pip install -r requirements-dev.txt pre-commit install # installs Ruff, Bandit, Gitleaks hooks
### परीक्षण```bash
# 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
परीक्षण स्थिति:
pytest-asyncio के माध्यम से पूर्णतः async परीक्षण सूटपरीक्षण मार्कर:
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
### प्री-कमिट हुक
निम्नलिखित हुक हर कमिट पर स्वचालित रूप से चलते हैं:
1. **Ruff** — स्वतः-सुधार + प्रारूप जांच के साथ लिंट करें
2. **trailing-whitespace** — पंक्ति के अंत की रिक्तियाँ हटाएँ
3. **end-of-file-fixer** — सुनिश्चित करें कि फ़ाइलें नई पंक्ति के साथ समाप्त हों
4. **check-yaml / check-json** — YAML/JSON सिंटैक्स सत्यापित करें
5. **check-added-large-files** — 1 MB से बड़ी फ़ाइलों को रोकें
6. **check-merge-conflict** — अनसुलझे मर्ज मार्कर का पता लगाएँ
7. **detect-private-key** — आकस्मिक कुंजी कमिट्स रोकें
8. **Bandit** — पायथन सुरक्षा स्कैनिंग
---
## सीआई/सीडी पाइपलाइन
`main` पर हर पुश 11 पाइपलाइन जॉब ट्रिगर करता है। तैनाती से पहले सभी को पास होना चाहिए।```
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
शून्य-बायपास नीति: CI/CD विफलताओं को पाइपलाइन कॉन्फ़िगरेशन में बदलाव करके कभी हल नहीं किया जाता। मूल कारणों को हमेशा सीधे स्रोत कोड या निर्भरताओं में ठीक किया जाता है।
डॉकर बिल्ड निर्माण समय को प्रबंधनीय रखने के लिए दो-परत दृष्टिकोण का उपयोग करता है:
Dockerfile.base)एक मल्टी-स्टेज बिल्ड जो धीमे-निर्माण वाले, शायद ही बदलने वाले सभी निर्भरताओं को स्रोत से संकलित करता है:``` compiler-toolchain (python:3.12-slim-bookworm + build tools) ├── compiler-yara (YARA 4.3.1 from source) [parallel] ├── compiler-r2 (Radare2 6.0.4 from source) [parallel] │ └── compiler-r2ghidra (r2ghidra plugin) [sequential] └── compiler-pip (pip install into /opt/venv) [parallel]
base (final runtime: python:3.12-slim-bookworm) ├── Runtime packages: file, binutils, gdb, binwalk, graphviz, nasm, sleuthkit ├── /opt/yara (compiled YARA) ├── /opt/radare2 (compiled r2 + r2ghidra) ├── /opt/venv (Python packages) └── Non-root user: appuser (UID 1000)
यह इमेज केवल तब पुनर्निर्मित होती है जब टूल संस्करण बदलते हैं। निर्माण समय: ~12 मिनट।
### लेयर 2: एप्लिकेशन इमेज (`Dockerfile`)
आधार इमेज से इनहेरिट करता है और एप्लिकेशन कोड की प्रतिलिपि बनाता है:```
FROM base image
├── COPY reversecore_mcp/ (application code)
├── COPY scripts/ (smoke test, benchmarks)
├── pip install any new requirements
├── Security package upgrades
└── CMD ["python", "-m", "reversecore_mcp.server"]
Build time: ~60 seconds.
आर्किटेक्चर-विशिष्ट प्रोफ़ाइल वाली तीन सेवाएँ:
संसाधन सीमाएँ: 2.0 CPU कोर, प्रति कंटेनर 4 GB मेमोरी।
reversecore_mcp/ ├── core/ # Infrastructure layer (37 modules) │ ├── config.py # Pydantic BaseSettings (34+ env vars) │ ├── exceptions.py # Exception hierarchy (17 classes, RCMCP-E* codes) │ ├── security.py # Input sanitization & command arg validation │ ├── validators.py # Path validators (TOCTOU-hardened, symlink-safe) │ ├── r2_pool.py # Thread-safe Radare2 connection pool │ ├── r2_helpers.py # Structured Radare2 output parsing │ ├── metrics.py # Per-tool timing, counts, error rates, cache stats │ ├── decorators.py # @log_execution, @track_metrics │ ├── error_handling.py # @handle_tool_errors decorator │ ├── error_formatting.py # Structured error formatting │ ├── execution.py # Safe subprocess with timeout/output limits │ ├── command_spec.py # Command specifications │ ├── memory.py # Async SQLite AI memory store │ ├── mitre_mapper.py # MITRE ATT&CK mapping engine │ ├── evidence.py # Evidence classification (OBSERVED/INFERRED/POSSIBLE) │ ├── resilience.py # Retry, circuit-breaker, timeout patterns │ ├── task_queue.py # Background task queue (Redis + arq) │ ├── extension_registry.py # Plugin registration system │ ├── arch_registry.py # Multi-arch mapping (x86/ARM/MIPS/RISC-V/PPC) │ ├── result_cache.py # SHA256-based tool result caching │ ├── analysis_cache.py # Multi-level decompilation cache (Redis + SQLite) │ ├── result.py # ToolSuccess / ToolError Pydantic models │ ├── loader.py # Dynamic tool module loader │ ├── plugin.py # Plugin base class │ ├── extension.py # Extension base class │ ├── container.py # Container/sandbox execution │ ├── audit.py # Audit logging │ ├── binary_cache.py # Binary file caching │ ├── json_utils.py # orjson-backed JSON (3-5x faster) │ ├── logging_config.py # Loguru logging configuration │ ├── report_generator.py # Report rendering (Markdown, PDF) │ ├── resource_manager.py # MCP resource lifecycle │ └── sast/ # Source code scanners │ ├── python_ast_scanner.py # Python AST vulnerability scanner │ ├── regex_scanner.py # C/C++ regex vulnerability scanner │ ├── rule_manager.py # SAST rule loader │ └── default_rules.yaml # Default scanning rules │ ├── tools/ # MCP tool implementations (120 tools) │ ├── analysis/ # Static analysis (24 tools) │ │ ├── static_analysis.py # file, strings, binwalk │ │ ├── lief_tools.py # LIEF binary parser │ │ ├── capa_tools.py # CAPA capability detection │ │ ├── die_tools.py # Detect It Easy packer detection │ │ ├── diff_tools.py # Binary diffing │ │ ├── emulation_tools.py # ESIL emulation │ │ ├── fuzz_tools.py # Fuzzing harness generator │ │ ├── fuzzing_campaign.py # Full fuzzing campaign runner │ │ ├── symbolic_analysis.py # angr symbolic execution │ │ ├── signature_tools.py # Library signature matching │ │ ├── source_auditor.py # SAST (Python + C/C++) │ │ ├── crash_triage.py # GDB crash triage │ │ ├── taint_analysis.py # Source→sink taint tracing │ │ ├── advanced_yara.py # Advanced YARA generation │ │ ├── patch_vuln_inference.py # Patch vulnerability inference │ │ └── cache_tools.py # Analysis cache management │ │ │ ├── radare2/ # Disassembly & decompilation (30 tools) │ │ ├── radare2_mcp_tools.py # Core Radare2 tool set │ │ ├── r2ghidra_tools.py # r2ghidra decompiler (cached) │ │ ├── r2_analysis.py # Deep function analysis │ │ ├── r2_db.py # SQLite annotation + cache DB │ │ ├── r2_esil_simulator.py # Multi-arch ESIL simulator │ │ └── r2_session.py # Stateful analysis sessions │ │ │ ├── malware/ # Threat detection (9 tools) │ │ ├── dormant_detector.py # Backdoor/logic bomb detection │ │ ├── ioc_tools.py # IOC extraction │ │ ├── yara_tools.py # YARA scanning │ │ ├── adaptive_vaccine.py # YARA rule + patch generation │ │ ├── vulnerability_hunter.py # Dangerous API detection │ │ ├── autonomous_hunter.py # Autonomous vuln hunting pipeline │ │ ├── heap_exploit.py # Heap exploitation analysis │ │ ├── poc_generator.py # PoC exploit generation │ │ └── rop_builder.py # ROP chain construction │ │ │ ├── forensics/ # Digital forensics (22 tools) │ │ ├── memory.py # Volatility3 memory forensics │ │ ├── network.py # Scapy PCAP analysis │ │ ├── disk.py # Sleuth Kit disk forensics │ │ └── artifact.py # Browser/registry/event log analysis │ │ │ ├── report/ # Report generation (14 tools) │ │ ├── report_mcp_tools.py # MCP-registered report tools │ │ ├── report_tools.py # Report rendering logic │ │ ├── session.py # Session state management │ │ ├── converter.py # Format conversion (Markdown → PDF/HTML) │ │ ├── email.py # SMTP report delivery │ │ ├── sigma_generator.py # SIGMA rule generation │ │ └── vex_generator.py # VEX report generation │ │ │ └── common/ # Shared utilities (20 tools) │ ├── file_operations.py # File ops, workspace management │ ├── server_tools.py # Server health, tool metrics │ ├── memory_tools.py # AI memory management (11 tools) │ ├── patch_explainer.py # Binary patch explanation │ └── assembler.py # Keystone assembler │ ├── prompts/ # AI reasoning prompts (22 modes) │ ├── malware.py # 9 malware analysis prompts │ ├── security.py # 6 security research prompts │ ├── cve_research.py # 5 CVE/exploit research prompts │ ├── game.py # Game client analysis prompt │ ├── report.py # Report generation prompt │ ├── server_health.py # Server inspection prompts │ └── common.py # Shared constants (DOCKER_PATH_RULE, LANGUAGE_RULE) │ ├── dashboard/ # Web dashboard (FastAPI + HTMX) │ ├── templates/ # Jinja2 templates with HTMX fragments │ └── static/ # htmx.min.js (local, CSP-compliant) │ ├── web/ # HTTP transport layer │ ├── auth.py # API key authentication middleware │ ├── middleware.py # Security headers, loopback restriction │ └── endpoints.py # /health, file upload, dashboard routes │ ├── resources.py # 11 MCP resources (static + dynamic per-binary) └── server.py # FastMCP server entry point
**अन्य निर्देशिकाएँ:**```
tests/
├── unit/ # 1,957 unit tests
├── integration/ # Docker-based integration tests
├── fixtures/ # Test binaries, YARA rules, sample data
└── conftest.py # Shared pytest fixtures
scripts/
├── smoke_test.py # Multi-layer in-container smoke test
├── check_release_metadata.py # Version consistency validation
├── fetch_test_binaries.py # Download test fixtures
├── run-docker.sh # Auto-detect architecture and start
└── ... # Benchmarks, analysis scripts
docs/
├── getting-started/ # Installation guide
├── development/ # Architecture, contributing, testing guides
├── api/ # Tool and module reference
└── user-guide/ # Analysis workflows
सभी कस्टम अपवाद ReversecoreError से विरासत में मिलते हैं और संरचित त्रुटि कोड रखते हैं:
AI क्लाइंट error_code फ़ील्ड का उपयोग करके प्रोग्रामेटिक रूप से विफलताओं को संभाल सकते हैं और तय कर सकते हैं कि पुनः प्रयास करना है, कोई वैकल्पिक टूल आज़माना है, या त्रुटि को उपयोगकर्ता को रिपोर्ट करना है।
नया MCP टूल जोड़ने के लिए इस पैटर्न का पालन करें:```python
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.",
)
फिर इसे संबंधित प्लगइन के `__init__.py` में पंजीकृत करें और `tests/unit/` में टेस्ट जोड़ें।
---
## योगदान
1. रिपॉजिटरी को फोर्क करें
2. फीचर ब्रांच बनाएं: `git checkout -b feat/my-feature`
3. अपने कोड के साथ-साथ टेस्ट लिखें — कवरेज 80% से कम नहीं होनी चाहिए
4. सभी गेट पास करें: `pytest`, `ruff check`, `mypy`, `bandit`
5. स्पष्ट विवरण के साथ पुल रिक्वेस्ट खोलें
कृपया कोड मानकों, docstring परंपराओं (Google-style), और पुल रिक्वेस्ट चेकलिस्ट के लिए [योगदान मार्गदर्शिका](https://github.com/sjkim1127/reversecore_mcp/blob/HEAD/docs/development/contributing.md) पढ़ें।
---
## दस्तावेज़ीकरण
| दस्तावेज़ | विवरण |
|---|---|
| [स्थापना मार्गदर्शिका](https://github.com/sjkim1127/reversecore_mcp/blob/HEAD/docs/getting-started/installation.md) | सभी वातावरणों के लिए विस्तृत सेटअप |
| [आर्किटेक्चर मार्गदर्शिका](https://github.com/sjkim1127/reversecore_mcp/blob/HEAD/docs/development/architecture.md) | सिस्टम डिज़ाइन और घटक विवरण |
| [योगदान मार्गदर्शिका](https://github.com/sjkim1127/reversecore_mcp/blob/HEAD/docs/development/contributing.md) | कोड मानक, docstrings, PR वर्कफ़्लो |
| [परीक्षण मार्गदर्शिका](https://github.com/sjkim1127/reversecore_mcp/blob/HEAD/docs/development/testing.md) | टेस्ट पैटर्न, फिक्स्चर और कवरेज |
| [API संदर्भ](https://github.com/sjkim1127/reversecore_mcp/blob/HEAD/docs/api/) | टूल और मॉड्यूल संदर्भ |
| [उपयोगकर्ता मार्गदर्शिका](https://github.com/sjkim1127/reversecore_mcp/blob/HEAD/docs/user-guide/) | विश्लेषण वर्कफ़्लो |
---
## उपयोग उदाहरण
### उदाहरण 1: बुनियादी मैलवेयर ट्राइएज```
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..."
User: "Find exploitable bugs in this network daemon"
AI activates: taint_analysis_mode
AI calls:
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]
vulnerability_hunter("daemon") → 12 dangerous API calls, 4 exploitable patterns
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..."
### उदाहरण 3: डिजिटल फोरेंसिक जांच```
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
User: "Compare the patched and unpatched versions to find what was fixed"
AI activates: patch_diff_auto_mode
AI calls:
diff_binaries("libfoo-1.0.so", "libfoo-1.1.so") → 3 functions changed, 1 new function
patch_diff_1day("libfoo-1.0.so", "libfoo-1.1.so") → Automated analysis: bounds check added at parse_header()
r2_decompile("libfoo-1.0.so", "parse_header") → Decompiled vulnerable version (no bounds check)
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)."
---
## बहु-आर्किटेक्चर समर्थन
`arch_registry.py` मॉड्यूल आर्किटेक्चर नामों को Radare2 कॉन्फ़िगरेशन मापदंडों में मैप करता है, जिससे उपकरण बिना मैन्युअल कॉन्फ़िगरेशन के विभिन्न CPU आर्किटेक्चरों पर काम कर सकें:
| आर्किटेक्चर | कुंजी | r2 Arch | बिट चौड़ाई | PC रजिस्टर | SP रजिस्टर |
|---|---|---|---|---|---|
| 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` |
**उपनाम समाधान** स्वचालित रूप से किया जाता है:
- `amd64` → `x86_64`
- `aarch64` → `arm64`
- `bits=64` के साथ `arm` → `arm64`
- `bits=16` या `bits=32` के साथ `arm` → `arm32`
`Radare2_esil_emulate`, `assemble_instructions`, और `r2_simulate_patch` जैसे उपकरण किसी भी लक्षित बाइनरी के लिए विश्लेषण वातावरण को सही ढंग से कॉन्फ़िगर करने हेतु इस रजिस्ट्री का उपयोग करते हैं।
---
## परिणाम कैश प्रणाली
दो कैशिंग परतें अनावश्यक गणना को न्यूनतम करती हैं:
### टूल परिणाम कैश (`result_cache.py`)
`@cache_tool_result` डेकोरेटर बाइनरी फ़ाइल के SHA256 हैश और टूल के कीवर्ड तर्कों के आधार पर किसी भी टूल के आउटपुट को कैश करता है:```
Cache key = SHA256( "<tool_name>::{sorted_json_kwargs}" )
भंडारण बैकएंड: r2_db.py के माध्यम से SQLite डेटाबेस, जो get_cached_result() और set_cached_result() टूलों के माध्यम से सुलभ है।
मेट्रिक्स: कैश हिट और मिस को metrics_collector.record_cache_hit() और record_cache_miss() के माध्यम से ट्रैक किया जाता है, जो get_tool_metrics टूल के द्वारा देखे जा सकते हैं।
analysis_cache.py)विशेष रूप से डीकंपाइलेशन परिणामों के लिए एक बहु-स्तरीय कैश (जिनकी गणना करना महंगा होता है):
आयात/निर्यात: export_analysis_cache और import_analysis_cache टूल पर्यावरणों के बीच साझा करने के लिए rcpack फ़ाइलों में/से कैश स्थिति सहेजने की अनुमति देते हैं।
AI मेमोरी सिस्टम (memory_tools.py + core/memory.py) सत्रों के बीच विश्लेषण निष्कर्षों के लिए स्थायी, क्वेरी योग्य संग्रहण प्रदान करता है। यह AI को निम्न की अनुमति देता है:
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"])
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:** `MEMORY_DB_PATH` द्वारा कॉन्फ़िगर किए गए पथ पर Async SQLite डेटाबेस (डिफ़ॉल्ट: `~/.reversecore_mcp/memory.db`)।
**Portability:** पूरे मेमोरी डेटाबेस को वातावरणों के बीच स्थानांतरित करने के लिए `export_memory_store` और `import_memory_store` का उपयोग करें।
---
## वेब डैशबोर्ड
HTTP मोड (`MCP_TRANSPORT=http`) में चलने पर, `http://localhost:8000/dashboard` पर एक वेब डैशबोर्ड उपलब्ध होता है। यह प्रदान करता है:
- ड्रैग-एंड-ड्रॉप के साथ बाइनरी अपलोड
- रीयल-टाइम विश्लेषण स्थिति
- इंटरैक्टिव फ़ंक्शन सूची और डिसअसेंबली दृश्य
- IOC निष्कर्षण परिणाम
- सर्वर स्वास्थ्य निगरानी
**टेक स्टैक:** FastAPI + Jinja2 टेम्पलेट + HTMX (`dashboard/static/` से स्थानीय रूप से लोड किया गया, CSP अनुपालन के लिए कोई CDN निर्भरता नहीं)।
**सुरक्षा विशेषताएँ:**
- सभी स्टेट-बदलने वाले फॉर्मों पर CSRF टोकन
- Jinja2 ऑटो-एस्केपिंग सक्षम
- प्रदर्शन से पहले `html.escape()` के माध्यम से सभी उपयोगकर्ता इनपुट स्वच्छ किए जाते हैं
- `validate_file_path()` के माध्यम से पाथ ट्रैवर्सल सुरक्षा
---
## परिनियोजन
### प्रोडक्शन चेकलिस्ट
प्रोडक्शन में तैनात करने से पहले:
| आइटम | कैसे |
|---|---|
| API कुंजी सेट करें | `MCP_API_KEY=<strong-random-key>` |
| गैर-रूट उपयोगकर्ता का उपयोग करें | अंतर्निहित: कंटेनर `appuser` (UID 1000) के रूप में चलता है |
| संसाधन सीमाएँ निर्धारित करें | डिफ़ॉल्ट: `docker-compose.yml` में 2 CPU / 4 GB RAM |
| संरचित लॉगिंग सक्षम करें | लॉग एकत्रीकरण के लिए `LOG_FORMAT=json` |
| Redis कॉन्फ़िगर करें | कार्य कतार और कैशिंग के लिए `REDIS_URL=redis://<host>:6379/0` |
| वर्कस्पेस पथ निर्धारित करें | `REVERSECORE_WORKSPACE=/path/to/isolated/directory` |
| दर सीमाओं की समीक्षा करें | `REVERSECORE_RATE_LIMIT=60` (अनुरोध/मिनट, आवश्यकतानुसार समायोजित करें) |
| सैंडबॉक्स सक्षम करें | गतिशील विश्लेषण अलगाव के लिए `REVERSECORE_SANDBOX_ENABLED=true` |
### स्वास्थ्य जाँच
सर्वर ऑर्केस्ट्रेशन के लिए HTTP स्वास्थ्य जाँच एंडपॉइंट प्रदान करता है:```bash
# 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.
Docker इमेज में एक अंतर्निहित HEALTHCHECK निर्देश शामिल है जो हर 30 सेकंड में पोर्ट 8000 के लिए TCP कनेक्टिविटी सत्यापित करता है। Docker और Kubernetes अस्वस्थ कंटेनरों को स्वचालित रूप से पुनरारंभ कर देंगे।
आवश्यक CLI टूल परिवेश में स्थापित नहीं है।
समाधान: यदि Docker का उपयोग कर रहे हैं, तो सत्यापित करें कि टूल बेस इमेज में है:```bash docker exec reversecore-mcp-arm64 which r2 yara binwalk tsk_recover gdb
यदि स्थानीय Python इंस्टॉलेशन का उपयोग कर रहे हैं, तो लापता टूल इंस्टॉल करें:```bash
# macOS
brew install radare2 yara binwalk sleuthkit
# Ubuntu/Debian
apt install radare2 yara binwalk sleuthkit
विश्लेषण ने कॉन्फ़िगर किए गए टाइमआउट को पार कर लिया।
समाधान: टाइमआउट बढ़ाएँ:```bash export REVERSECORE_DEFAULT_TOOL_TIMEOUT=300 # 5 minutes
बड़े बाइनरी (>100 MB) के लिए, quick-scan वेरिएंट का उपयोग करने पर विचार करें:
- `run_capa_quick` के बजाय `run_capa`
- `detect_packer` के बजाय `detect_packer_deep`
</details>
<details>
<summary><b>पाथ ट्रावर्सल त्रुटि (RCMCP-E302)</b></summary>
आपने कार्यक्षेत्र निर्देशिका के बाहर किसी फ़ाइल का संदर्भ दिया।
**समाधान:** पहले फ़ाइल को कार्यक्षेत्र में कॉपी करें:```
copy_to_workspace("/path/to/file.exe")
या अतिरिक्त निर्देशिकाओं को केवल-पठन के रूप में माउंट करें:```bash export REVERSECORE_READ_DIRS=/opt/samples,/mnt/evidence
</details>
<details>
<summary><b>Apple Silicon पर Docker कंटेनर शुरू नहीं होगा</b></summary>
सुनिश्चित करें कि आप ARM64 प्रोफ़ाइल का उपयोग कर रहे हैं:```bash
docker compose --profile arm64 up -d
या स्वचालित पहचान स्क्रिप्ट का उपयोग करें:```bash ./scripts/run-docker.sh
</details>
<details>
<summary><b>Redis कनेक्शन अस्वीकृत</b></summary>
कार्य कतार के लिए एक चालू Redis इंस्टेंस आवश्यक है।
**समाधान:** मुख्य सेवा के साथ Redis प्रारंभ करें:```bash
docker compose --profile arm64 up -d # Starts both reversecore and redis
या REDIS_URL सेट न करके Redis-निर्भर सुविधाओं को अक्षम करें।
इसका आमतौर पर मतलब है कि फ़ंक्शन का पहले विश्लेषण नहीं किया गया था।
समाधान: डीकंपाइलेशन से पहले विश्लेषण चलाएँ:``` Radare2_analyze_binary("sample.exe") Radare2_decompile_function("sample.exe", "main")
</details>
---
## सामान्य प्रश्न
<details>
<summary><b>क्या यह Ghidra या IDA Pro की जगह लेता है?</b></summary>
नहीं। यह परियोजना एक पूरक है, प्रतिस्थापन नहीं। यह डीकंपाइलेशन के लिए r2ghidra (Radare2 में एम्बेडेड Ghidra डीकंपाइलर इंजन) का उपयोग करता है। यह GUI प्रदान नहीं करता है, और इसमें पूर्ण डिसअसेंबलर का इंटरैक्टिव विश्लेषण वर्कफ़्लो नहीं है। इसका उद्देश्य AI सहायकों को प्रोग्रामेटिक रूप से विश्लेषण कार्य करने देना है।
</details>
<details>
<summary><b>क्या अलग से Ghidra या JDK इंस्टॉलेशन की आवश्यकता है?</b></summary>
नहीं। r2ghidra प्लगइन Ghidra डीकंपाइलर इंजन को सीधे Radare2 के अंदर एम्बेड करता है। कोई JDK नहीं, कोई Ghidra इंस्टॉलेशन नहीं, कोई Ghidra प्रोजेक्ट फ़ाइल नहीं। बस `r2` जिसमें `r2ghidra` प्लगइन संकलित है।
</details>
<details>
<summary><b>कौन से MCP क्लाइंट समर्थित हैं?</b></summary>
कोई भी क्लाइंट जो [Model Context Protocol](https://modelcontextprotocol.io/) विनिर्देशन को लागू करता है। परीक्षण किया गया: Claude Desktop, Cursor, Windsurf, और Google Antigravity। सर्वर stdio और HTTP/SSE दोनों ट्रांसपोर्ट का समर्थन करता है।
</details>
<details>
<summary><b>क्या मैं Linux/macOS पर Windows PE फ़ाइलों का विश्लेषण कर सकता/सकती हूँ?</b></summary>
हाँ। स्थैतिक विश्लेषण (डिसअसेंबली, डीकंपाइलेशन, स्ट्रिंग निष्कर्षण, IOC निष्कर्षण, YARA स्कैनिंग) होस्ट OS की परवाह किए बिना किसी भी फ़ाइल प्रारूप पर काम करता है। गतिशील विश्लेषण (एमुलेशन, फज़िंग) में लक्ष्य आर्किटेक्चर के आधार पर सीमाएँ हो सकती हैं।
</details>
<details>
<summary><b>इस टूल से मैलवेयर का विश्लेषण करना कितना सुरक्षित है?</b></summary>
Docker कंटेनर अलगाव प्रदान करता है: गैर-रूट उपयोगकर्ता, CI में डिफ़ॉल्ट रूप से कोई नेटवर्क नहीं, संसाधन सीमाएँ। लाइव मैलवेयर विश्लेषण के लिए, हम समर्पित VM में चलाने या सैंडबॉक्स सुविधा (`REVERSECORE_SANDBOX_ENABLED=true`) का उपयोग करने की अनुशंसा करते हैं। स्थैतिक विश्लेषण उपकरण (r2, YARA, strings) लक्ष्य बाइनरी को कभी निष्पादित नहीं करते हैं।
</details>
<details>
<summary><b>अधिकतम फ़ाइल आकार क्या है?</b></summary>
डिफ़ॉल्ट सीमाएँ:
- अपलोड: 100 MB (`MAX_UPLOAD_SIZE`)
- LIEF पार्सिंग: 1 GB (`REVERSECORE_LIEF_MAX_FILE_SIZE`)
- टूल आउटपुट: 10 MB (`REVERSECORE_MAX_OUTPUT_SIZE`)
सभी सीमाएँ पर्यावरण चरों के माध्यम से कॉन्फ़िगर करने योग्य हैं।
</details>
---
## आभार
यह परियोजना कई ओपन-सोर्स परियोजनाओं के कार्य पर आधारित है:
| परियोजना | Reversecore MCP में भूमिका |
|---|---|
| [Radare2](https://radare.org/) | डिसअसेंबली, एमुलेशन, बाइनरी विश्लेषण |
| [r2ghidra](https://github.com/radareorg/r2ghidra) | Radare2 के लिए Ghidra डीकंपाइलर इंजन |
| [FastMCP](https://github.com/jlowin/fastmcp) | MCP सर्वर फ्रेमवर्क |
| [YARA](https://virustotal.github.io/yara/) | मैलवेयर पहचान के लिए पैटर्न मिलान |
| [LIEF](https://lief-project.github.io/) | बाइनरी प्रारूप पार्सिंग (PE, ELF, Mach-O) |
| [CAPA](https://github.com/mandiant/capa) | Mandiant FLARE क्षमता पहचान |
| [angr](https://angr.io/) | प्रतीकात्मक निष्पादन इंजन |
| [Capstone](https://www.capstone-engine.org/) | डिसअसेंबली फ्रेमवर्क |
| [Keystone](https://www.keystone-engine.org/) | असेंबली फ्रेमवर्क |
| [pwntools](https://github.com/Gallopsled/pwntools) | एक्सप्लॉइट विकास टूलकिट |
| [ROPgadget](https://github.com/JonathanSalwan/ROPgadget) | ROP गैजेट खोजक |
| [Volatility3](https://github.com/volatilityfoundation/volatility3) | मेमोरी फोरेंसिक्स फ्रेमवर्क |
| [Scapy](https://scapy.net/) | नेटवर्क पैकेट विश्लेषण |
| [Sleuth Kit](https://sleuthkit.org/) | डिस्क फोरेंसिक्स टूलकिट |
| [Binwalk](https://github.com/ReFirmLabs/binwalk) | फर्मवेयर विश्लेषण |
| [Detect It Easy](https://github.com/horsicq/DIE-engine) | पैकर/कंपाइलर पहचान |
---
## लाइसेंस
MIT — विवरण के लिए [LICENSE](https://github.com/sjkim1127/reversecore_mcp/blob/HEAD/LICENSE) देखें।
---
<div align="center">
**[GitHub](https://github.com/sjkim1127/Reversecore_MCP)** · **[PyPI](https://pypi.org/project/reversecore-mcp/)** · **[FastMCP दस्तावेज़](https://github.com/jlowin/fastmcp)** · **[MCP विनिर्देश](https://modelcontextprotocol.io/)** · **[Radare2](https://radare.org/)** · **[YARA](https://virustotal.github.io/yara/)**
</div>
| क्षेत्र | आप क्या कर सकते हैं |
|---|
| स्थैतिक विश्लेषण | डिसअसेम्बली, डीकंपाइलेशन (r2ghidra), बाइनरी पार्सिंग (LIEF), पैकर डिटेक्शन (DIE), क्षमता डिटेक्शन (CAPA), स्ट्रिंग निष्कर्षण, फर्मवेयर स्कैनिंग (binwalk) |
| डाइनेमिक और सिम्बोलिक | ESIL इम्यूलेशन, angr सिम्बोलिक एक्ज़ीक्यूशन, टेंट विश्लेषण, फज़िंग हार्नेस जनरेशन |
| मैलवेयर विश्लेषण | IOC निष्कर्षण, YARA स्कैनिंग, निष्क्रिय बैकडोर डिटेक्शन, अनुकूली वैक्सीन जनरेशन, स्वायत्त भेद्यता शिकार |
| भेद्यता अनुसंधान | खतरनाक API डिटेक्शन, ROP गैजेट खोज, हीप एक्सप्लॉइट विश्लेषण, क्रैश ट्राइएज, PoC जनरेशन |
| डिजिटल फोरेंसिक्स | मेमोरी फोरेंसिक्स (Volatility3), PCAP विश्लेषण (Scapy), डिस्क फोरेंसिक्स (Sleuth Kit), आर्टिफैक्ट सहसंबंध |
| सोर्स कोड ऑडिट | Python AST स्कैनिंग, C/C++ regex पैटर्न स्कैनिंग |
| रिपोर्टिंग | MITRE ATT&CK मैपिंग के साथ सत्र-आधारित रिपोर्ट, SIGMA नियम जनरेशन, VEX रिपोर्ट, ईमेल डिलीवरी |
| चर | डिफ़ॉल्ट | विवरण |
|---|
MCP_TRANSPORT | stdio | परिवहन मोड: stdio या http |
REVERSECORE_WORKSPACE | ./ (cwd) | विश्लेषण कार्यक्षेत्र निर्देशिका |
REVERSECORE_READ_DIRS | "" | अतिरिक्त केवल-पठनीय निर्देशिकाओं की अल्पविराम-पृथक सूची |
REVERSECORE_STRICT_PATHS | false | लापता पथों के लिए चेतावनियों के बजाय त्रुटियाँ उत्पन्न करें |
REVERSECORE_STRUCTURED_ERRORS | false | त्रुटि कोड के साथ संरचित त्रुटि प्रतिक्रियाएँ सक्षम करें |
REVERSECORE_DEFAULT_TOOL_TIMEOUT | 120 | सेकंड में डिफ़ॉल्ट टूल निष्पादन टाइमआउट |
REVERSECORE_MAX_OUTPUT_SIZE | 10000000 | टूल्स के लिए अधिकतम आउटपुट आकार (बाइट्स) |
| चर | डिफ़ॉल्ट | विवरण |
|---|
MCP_HOST | 0.0.0.0 | बाइंड करने के लिए होस्ट इंटरफ़ेस (यदि कोई API कुंजी नहीं है तो स्वतः 127.0.0.1 पर ओवरराइड हो जाता है) |
MCP_PORT | 8000 | HTTP सर्वर के लिए पोर्ट |
MCP_API_KEY | (unset) | HTTP प्रमाणीकरण के लिए API कुंजी (X-API-Key या Authorization: Bearer) |
REVERSECORE_RATE_LIMIT | 60 | प्रति मिनट अधिकतम अनुरोध (केवल HTTP मोड, slowapi के माध्यम से) |
MAX_UPLOAD_SIZE | 100000000 | अधिकतम अपलोड आकार (डिफ़ॉल्ट 100 MB) |
FILE_RETENTION_MINUTES | 1440 | अपलोड की गई फ़ाइलों के लिए प्रतिधारण अवधि (डिफ़ॉल्ट 24h) |
| चर | डिफ़ॉल्ट | विवरण |
|---|
REVERSECORE_R2_POOL_SIZE | 3 | पूल में Radare2 कनेक्शनों की संख्या |
REVERSECORE_R2_POOL_TIMEOUT | 30 | पूल से कनेक्शन प्राप्त करने के लिए टाइमआउट |
REVERSECORE_R2_EXTENSIONS | "" | r2 एक्सटेंशन कक्षाओं की अल्पविराम-पृथक सूची (module:ClassName) |
REVERSECORE_GHIDRA_MAX_PROJECTS | 3 | अधिकतम कैश्ड r2ghidra डीकंपाइलर प्रोजेक्ट |
REVERSECORE_GHIDRA_EXTENSIONS | "" | Ghidra एक्सटेंशन कक्षाओं की अल्पविराम-पृथक सूची |
MAX_EMULATION_INSTRUCTIONS | 1000 | अधिकतम ESIL एमुलेशन निर्देश |
| चर | डिफ़ॉल्ट | विवरण |
|---|
REVERSECORE_SANDBOX_ENABLED | false | डायनामिक विश्लेषण टूल्स के लिए सैंडबॉक्स निष्पादन सक्षम करें |
REVERSECORE_SANDBOX_MODE | auto | सैंडबॉक्स मोड: auto, host, container, disabled |
REVERSECORE_SANDBOX_DOCKER_IMAGE | reversecore-sandbox:latest | सैंडबॉक्स निष्पादन के लिए Docker इमेज |
REVERSECORE_SANDBOX_CPU_LIMIT | 1.0 | सैंडबॉक्स कंटेनरों के लिए CPU कोर सीमा |
REVERSECORE_SANDBOX_MEMORY_LIMIT | 512m | सैंडबॉक्स कंटेनरों के लिए मेमोरी सीमा |
REVERSECORE_SANDBOX_PIDS_LIMIT | 100 | सैंडबॉक्स कंटेनरों के लिए PID सीमा |
REVERSECORE_SANDBOX_USER | nobody | सैंडबॉक्स निष्पादन के लिए गैर-root उपयोगकर्ता |
| चर | डिफ़ॉल्ट | विवरण |
|---|
REDIS_URL | redis://localhost:6379/0 | कार्य कतार और परिणाम कैशिंग के लिए Redis URL |
MEMORY_DB_PATH | ~/.reversecore_mcp/memory.db | AI मेमोरी SQLite डेटाबेस का पथ |
REVERSECORE_LIEF_MAX_FILE_SIZE | 1000000000 | LIEF पार्सिंग के लिए अधिकतम फ़ाइल आकार (1 GB) |
| चर | डिफ़ॉल्ट | विवरण |
|---|
LOG_LEVEL | INFO | लॉगिंग विस्तार: DEBUG, INFO, WARNING, ERROR |
LOG_FILE | <tempdir>/reversecore/app.log | लॉग फ़ाइल का पथ |
LOG_FORMAT | human | लॉग प्रारूप: human (पठनीय) या json (संरचित) |
| नियंत्रण | कार्यान्वयन |
|---|
| कोई शेल इंजेक्शन नहीं | सभी सबप्रोसेस कॉल सूची तर्कों का उपयोग करते हैं, कभी शेल स्ट्रिंग्स नहीं (execution.py) |
| पथ ट्रैवर्सल रोकथाम | validate_file_path() और validate_binary_path() सिमलिंक को हल करते हैं और कार्यक्षेत्र तक पहुंच को सीमित करते हैं (validators.py) |
| TOCTOU शमन | bypass_cache=True फ़्लैग रेस कंडीशन को रोकने के लिए पथों का पुनः सत्यापन करता है |
| इनपुट स्वच्छता | निष्पादन से पहले सभी पैरामीटर स्वच्छ किए जाते हैं (security.py) |
| CSRF सुरक्षा | डैशबोर्ड फॉर्म टोकन-आधारित CSRF सत्यापन की आवश्यकता रखते हैं (dashboard/__init__.py) |
| नियंत्रण | कार्यान्वयन |
|---|
| टाइमिंग-अटैक-सुरक्षित प्रमाणीकरण | API कुंजी तुलना के लिए secrets.compare_digest() (web/auth.py) |
| प्रतिबंधित प्रमाणीकरण वेक्टर | केवल X-API-Key और Authorization: Bearer हेडर स्वीकार किए जाते हैं; कोई क्वेरी पैराम या कुकीज़ नहीं |
| केवल-लूपबैक फ़ॉलबैक | MCP_API_KEY के बिना, HTTP पहुंच 127.0.0.1 तक सीमित है (web/middleware.py) |
| दर सीमा | slowapi के माध्यम से प्रति मिनट कॉन्फ़िगर करने योग्य सीमाएँ |
| सुरक्षा हेडर | सभी HTTP प्रतिक्रियाओं पर HSTS, X-Content-Type-Options, X-Frame-Options, CSP (web/middleware.py) |
न्यूनतम /health | सार्वजनिक एंडपॉइंट केवल {"status": "alive"} लौटाता है; विवरण प्रमाणीकरण के पीछे (web/endpoints.py) |
| नियंत्रण | कार्यान्वयन |
|---|
| गोपनीयता स्कैनिंग | Gitleaks हर कमिट पर चलता है (pre-commit हुक + CI) |
| SAST | Bandit हर कमिट पर सभी Python कोड को स्कैन करता है |
| CodeQL | main पर हर पुश पर GitHub CodeQL स्थैतिक विश्लेषण |
| निर्भरता ऑडिटिंग | हर पुश पर pip-audit — कोई अनदेखी CVE नहीं |
| कंटेनर स्कैनिंग | Trivy Docker इमेज को कमजोरियों के लिए स्कैन करता है (LOW से CRITICAL तक) |
| एक्सप्लॉइट सुरक्षा गेट | POC टेम्पलेट्स को Bandit से स्कैन किया जाता है; Hypothesis DAST फज़िंग; कंटेनर अलगाव सत्यापित किया जाता है |
| मार्कर | उद्देश्य |
|---|
@pytest.mark.unit | तेज़ यूनिट परीक्षण |
@pytest.mark.integration | ऐसे परीक्षण जिन्हें Docker या बाहरी टूल्स की आवश्यकता है |
@pytest.mark.slow | लंबे समय तक चलने वाले परीक्षण |
@pytest.mark.benchmark | प्रदर्शन बेंचमार्क |
@pytest.mark.security | सुरक्षा सीमा सत्यापन परीक्षण |
| सेवा | प्रोफ़ाइल | विवरण |
|---|
reversecore-mcp | default, x86 | Intel/AMD x86_64 |
reversecore-mcp-arm64 | arm64, macos | Apple Silicon ARM64 |
redis | सभी प्रोफ़ाइल | कार्य कतार और कैशिंग के लिए Redis 7 Alpine |
| घटक | न्यूनतम | अनुशंसित |
|---|
| CPU | 4 कोर | 8+ कोर |
| RAM | 8 GB | 16 GB |
| स्टोरेज | 20 GB | 50 GB SSD |
| OS | Linux / macOS | Docker वातावरण (कोई भी OS) |
| Docker | 20.10+ | 24.0+ |
| Python (स्थानीय मोड) | 3.10 | 3.11 या 3.12 |
| अपवाद | कोड | प्रकार | कब |
|---|
ReversecoreError | RCMCP-E000 | UNKNOWN_ERROR | सभी त्रुटियों के लिए आधार वर्ग |
ValidationError | RCMCP-E001 | VALIDATION_ERROR | अमान्य इनपुट, गलत पैरामीटर |
ExecutionTimeoutError | RCMCP-E002 | TIMEOUT_ERROR | टूल ने टाइमआउट पार कर लिया |
ToolNotFoundError | RCMCP-E003 | TOOL_ERROR | आवश्यक CLI टूल स्थापित नहीं है |
OutputLimitExceededError | RCMCP-E004 | OUTPUT_ERROR | आउटपुट अधिकतम आकार से अधिक हो गया |
ToolExecutionError | RCMCP-E005 | EXECUTION_ERROR | सबप्रोसेस ने गैर-शून्य मान लौटाया |
BinaryAnalysisError | RCMCP-E100 | BINARY_ANALYSIS_ERROR | सामान्य बाइनरी विश्लेषण विफलता |
DecompilationError | RCMCP-E101 | DECOMPILATION_ERROR | r2ghidra डीकंपिलेशन विफल रहा |
DisassemblyError | RCMCP-E102 | DISASSEMBLY_ERROR | Radare2 डिसअसेंबली विफल रही |
StructureRecoveryError | RCMCP-E103 | STRUCTURE_RECOVERY_ERROR | C struct पुनर्प्राप्ति विफल रही |
SignatureGenerationError | RCMCP-E104 | SIGNATURE_GENERATION_ERROR | YARA/सिग्नेचर निर्माण विफल रहा |
EmulationError | RCMCP-E105 | EMULATION_ERROR | ESIL एमुलेशन विफल रहा |
ToolTimeoutError | RCMCP-E200 | TOOL_TIMEOUT_ERROR | बाहरी टूल का समय समाप्त हो गया |
GhidraConnectionError | RCMCP-E201 | GHIDRA_CONNECTION_ERROR | r2ghidra कनेक्शन समस्या |
Radare2Error | RCMCP-E202 | RADARE2_ERROR | Radare2 कमांड विफल रहा |
WorkspaceError | RCMCP-E300 | WORKSPACE_ERROR | वर्कस्पेस फ़ाइल एक्सेस त्रुटि |
SecurityViolationError | RCMCP-E301 | SECURITY_VIOLATION | सुरक्षा नीति उल्लंघन |
PathTraversalError | RCMCP-E302 | PATH_TRAVERSAL | पथ ट्रैवर्सल प्रयास का पता चला |
| स्तर | बैकएंड | कुंजी प्रारूप | TTL | उद्देश्य |
|---|
| L1 | Redis | ghidra:decompile:{file_hash}:{function_address}:{decompiler} | 1 घंटा (3600s) | तेज़, सत्रों में साझा |
| L2 | SQLite | तालिका decompilation_cache | स्थायी | Redis पुनरारंभ से बचता है |