Skip to main content
Glama
x64dbg MCP Server

x64dbg MCP Server

by ouonet

x64dbg MCP 服务器

一个生产级的 Model Context Protocol 服务器,向 AI 助手(Claude、Windsurf Cascade、Cursor 等)公开 x64dbg 逆向工程和调试功能。

架构

┌─────────────────┐  STDIO/JSON-RPC   ┌──────────────────┐  TCP (JSON)  ┌──────────────┐
│  AI Assistant    │ ◄───────────────► │  MCP Server      │ ◄──────────► │  x64dbg      │
│  (Claude, etc.)  │                   │  (Node.js / TS)  │   port 27042 │  + Bridge    │
└─────────────────┘                    └──────────────────┘              │    Plugin    │
                                                                         └──────────────┘

两个组件:

  1. MCP 服务器 (src/) — TypeScript Node.js 进程。通过 STDIO 与 AI 主机进行 MCP 通信,并通过 TCP 连接到桥接器。

  2. 桥接插件 (plugin/) — 一个轻量级的 C 加载器插件,在 x64dbg 内部嵌入 Python 3.10+。Python 桥接脚本通过 ctypes 直接调用 x64bridge.dll — 无需 x64dbgpy 依赖。公开一个本地 TCP 服务器,将 MCP 请求转换为 x64dbg Bridge SDK 调用。

Related MCP server: Binary MCP Server

功能

自动启动与 PE 检测

  • 通过读取 PE 头自动检测 PE 架构 (x86 / x64)

  • 使用目标可执行文件启动正确的调试器变体 (x32dbg 或 x64dbg)

  • 等待桥接插件 TCP 端口可达,然后连接 — 零手动设置

  • 捆绑了用于 x32dbg 插件支持的 32 位 Python 可嵌入版本

核心调试 (12 个工具)

  • load_executable — 加载 PE 文件,自动检测 x86/x64,自动启动调试器,在入口点中断

  • continue_execution / step_into / step_over / step_out

  • run_to_address — 运行到特定地址

  • set_breakpoint — 软件、硬件(执行/读取/写入/访问)以及带有条件和日志文本的内存断点

  • remove_breakpoint / list_breakpoints

  • terminate_session / list_sessions

  • execute_command — 运行任何原始 x64dbg 命令

内存与寄存器 (9 个工具)

  • read_memory / write_memory / search_memory — 带有通配符的十六进制模式,ASCII/Unicode 文本

  • get_memory_map — 包含保护和模块信息的完整虚拟内存布局

  • get_registers / set_register — GP、标志、段、调试、FPU/SSE 寄存器

  • get_call_stack — 带有返回地址、模块名称和符号的回溯

  • get_threads / switch_thread — 线程枚举和上下文切换

静态与动态分析 (10 个工具)

  • disassemble — 带有元数据(is_call, is_jump, 引用目标, 注释)

  • analyze_function — 边界、大小、调用图(调用者 + 被调用者)、叶子检测

  • get_cross_references — 代码和数据交叉引用(到/从/两者)

  • list_functions — 带有模块过滤、名称搜索和分页功能

  • get_modules / get_imports / get_exports — 带有 DLL 和函数名称过滤器

  • find_strings — 带有内容过滤和最小长度控制的 ASCII + Unicode 字符串查找

  • get_pe_header — 完整的 PE 结构:DOS/NT 头、节、数据目录、熵

  • trace_execution — 记录指令跟踪,带有可选的寄存器快照

安全分析 (5 个工具)

  • detect_packing — 熵分析、已知加壳程序签名、导入计数启发式、置信度评分

  • analyze_suspicious_apis — 将导入与 10 类 100 多种恶意软件相关 API 进行交叉引用

  • detect_anti_debug — IsDebuggerPresent、计时检查、PEB 标志、TLS 回调、int 2D/3,并提供绕过建议

  • check_section_anomalies — W+X 节、异常名称、零原始大小、高熵检测

  • generate_security_report — 对所有安全检查进行综合初步分类,并给出总体风险等级

总计:36 个工具

先决条件

  • Node.js ≥ 20

  • 在 Windows 上安装 x64dbg(或使用 x64dbg/ 下捆绑的副本)

  • 为 x64dbg 安装 Python 3.10+,或使用为 x32dbg 捆绑的 32 位 Python 可嵌入版本

  • CMake 3.15+ 和 C 编译器 (MSVC / MinGW) 以构建加载器插件

安装

# Clone and install
cd x64dbg-mcp
npm install
npm run build

# Build the loader plugin (64-bit)
cd plugin\loader
cmake -B build64 -A x64
cmake --build build64 --config Release
cd ..\..\n
# Copy plugin files into x64dbg
copy plugin\loader\build64\Release\x64dbg_mcp_loader.dp64  C:\x64dbg\plugins\
copy plugin\x64dbg_bridge_sdk.py  C:\x64dbg\plugins\
copy plugin\x64dbg_mcp_bridge.py  C:\x64dbg\plugins\

配置

将 .env.example 复制到 .env 并进行调整:

X64DBG_PATH=C:\x64dbg
BRIDGE_HOST=127.0.0.1
BRIDGE_PORT=27042
LOG_LEVEL=info
MAX_SESSIONS=5
SESSION_TIMEOUT_MS=3600000

使用方法

1. 配置您的 AI 主机

注意: 您不再需要手动启动 x64dbg。当您调用 load_executable 时,MCP 服务器会自动启动正确的调试器(x32dbg 或 x64dbg)。加载器插件会自动初始化 Python 3,运行桥接脚本,并在 27042 端口启动 TCP 监听器。

Windsurf / Cascade

添加到您的 MCP 设置中:

{
  "mcpServers": {
    "x64dbg-mcp": {
      "command": "node",
      "args": ["C:\\path\\to\\x64dbg-mcp\\dist\\server.js"],
      "env": {
        "BRIDGE_PORT": "27042"
      }
    }
  }
}

Claude Desktop

添加到 claude_desktop_config.json:

{
  "mcpServers": {
    "x64dbg-mcp": {
      "command": "node",
      "args": ["C:\\path\\to\\x64dbg-mcp\\dist\\server.js"]
    }
  }
}

2. 开始调试

询问您的 AI 助手:

"Load C:\samples\target.exe and analyze it for suspicious behavior"

AI 将使用 MCP 工具来:

  1. load_executable → 加载二进制文件

  2. generate_security_report → 运行所有安全检查

  3. disassemble → 检查可疑代码

  4. set_breakpoint + continue_execution → 动态分析

示例工作流

崩溃分析

User: "My program crashes at startup, help me debug it"
AI:   load_executable → continue_execution → get_call_stack → 
      read_memory → get_registers → disassemble

恶意软件分类

User: "Analyze this suspicious binary"
AI:   load_executable → generate_security_report →
      analyze_suspicious_apis → detect_anti_debug →
      find_strings → get_imports

逆向工程

User: "Find the license check function"
AI:   load_executable → find_strings (filter: "license") →
      get_cross_references → analyze_function →
      disassemble → trace_execution

测试

# Test with MCP Inspector
npm run inspector

# Development mode (no build step)
npm run dev

项目结构

x64dbg-mcp/
├── src/
│   ├── server.ts          # Entry point
│   ├── bridge.ts          # TCP client to x64dbg bridge
│   ├── launcher.ts        # Auto-detect PE arch & spawn debugger
│   ├── session.ts         # Session lifecycle management
│   ├── config.ts          # Configuration from env
│   ├── logger.ts          # Winston logger (stderr only)
│   ├── types.ts           # TypeScript type definitions
│   └── tools/
│       ├── index.ts       # Tool registration barrel
│       ├── debug.ts       # Core debugging tools
│       ├── memory.ts      # Memory & register tools
│       ├── analysis.ts    # Analysis tools
│       └── security.ts    # Security analysis tools
├── plugin/
│   ├── x64dbg_mcp_bridge.py   # TCP server + handler dispatch (Python 3)
│   ├── x64dbg_bridge_sdk.py   # ctypes bindings to x64bridge.dll
│   ├── loader/
│   │   ├── x64dbg_mcp_loader.c # C plugin that embeds Python 3
│   │   └── CMakeLists.txt      # Build system for the loader
│   └── README.md
├── package.json
├── tsconfig.json
├── .env.example
└── README.md

许可证

MIT

Available Tools

39 tools
analyze_functionA

Analyse the function that contains the given address. Returns boundaries, size, call graph (callers + callees), and whether the function is a leaf.

Inputs: sessionId (required), address (required).

analyze_suspicious_apisA

Cross-reference the executable's import table against a database of Windows APIs commonly used by malware, grouped by category (process injection, network, crypto, anti-debug, etc.). Returns per-category findings and an overall risk level.

Inputs: sessionId (required), module, includeAll.

check_section_anomaliesA

Check PE sections for anomalies that may indicate packing, code injection, or tampering: writable+executable sections, unusual names, zero raw-size with non-zero virtual-size, high entropy.

Inputs: sessionId (required), module.

close_debuggerA

Kill the x64dbg or x32dbg process. Works even if the bridge is not connected. Use this to cleanly shut down the debugger before deploying updated plugins or when you need to restart the debugger.

Inputs: force.

collect_bp_argsA

Continue execution in a loop, collecting a memory expression at each breakpoint hit. Use this to trace repeated calls (e.g. AddMoudle, GetClassObject). The default expr 'ptr_utf16@[esp+4]' reads a wchar_t* arg from the x86 stack.

Inputs: sessionId (required), expr, maxHits, timeoutSec.

continue_executionA

Resume execution of a paused debuggee. Runs until the next breakpoint, exception, or program exit. REQUIRES: session state must be 'paused' (check with get_status). Returns stopReason ('breakpoint', 'paused', or 'exited') and the address where execution stopped. If stopReason is 'exited', the process has terminated.

Inputs: sessionId (required).

detect_anti_debugB

Scan the loaded executable for common anti-debugging techniques: API checks (IsDebuggerPresent, NtQueryInformationProcess), timing checks, PEB flags, int 2d / int 3, TLS callbacks, etc.

Inputs: sessionId (required), module.

detect_packingA

Analyse the loaded executable for signs of packing or obfuscation. Checks section entropy, section name anomalies, import table size, entry-point location, and known packer signatures. Returns a confidence score and list of indicators.

Inputs: sessionId (required), module.

disassembleA

Disassemble instructions starting at a given address in the loaded module. Returns address, raw bytes, mnemonic, operands, and metadata (is_call, is_jump, reference target) for each instruction. Safe to call while paused. Address may be a hex value ('0x401000') or a symbol name ('main', 'kernel32.CreateFileW'). Tip: after load_executable with breakOnEntry=true, disassemble the entry point returned in the load result to see where execution begins.

Inputs: sessionId (required), address (required), count.

execute_commandA

Execute a raw x64dbg command string. Use this for advanced operations not covered by other tools. Returns the command output.

Inputs: sessionId (required), command (required).

find_stringsB

Search for ASCII and Unicode strings in the debuggee's memory. Optionally filter by content substring or module.

Inputs: sessionId (required), module, filter, minLength, +1 more.

generate_security_reportA

Run all security analysis tools and produce a consolidated report: packing detection, suspicious API analysis, anti-debug detection, and section anomaly checks. Useful as a first-pass triage.

Inputs: sessionId (required), module.

get_call_stackA

Get the call stack (backtrace) of the current thread. Shows return addresses, module names, and function names where available.

Inputs: sessionId (required), maxFrames.

get_cross_referencesA

Find all cross-references (xrefs) to or from the given address. Returns code references (calls/jumps) and data references (reads/writes).

Inputs: sessionId (required), address (required), direction.

get_exportsB

List all exported functions/symbols for a specific module.

Inputs: sessionId (required), module (required), nameFilter.

get_importsB

List all imported functions for a specific module. Shows DLL name, function name, ordinal, and IAT address.

Inputs: sessionId (required), module, dllFilter, functionFilter.

get_memory_mapA

Return the virtual memory map of the debuggee process: all regions with base address, size, protection, type, and associated module.

Inputs: sessionId (required), filterModule, filterProtection.

get_modulesA

List all modules (DLLs and the main EXE) loaded in the debuggee with base address, size, entry point, and file path.

Inputs: sessionId (required).

get_pe_headerA

Parse and return the PE header information for a module: DOS header, NT headers, section table, data directories, timestamp, subsystem, characteristics, etc.

Inputs: sessionId (required), module.

get_registersA

Read the current CPU register values of the active thread. Includes general-purpose registers, instruction pointer (RIP/EIP), flags, and optionally segment and debug registers. REQUIRES: session must be paused (call get_status to check). On x64: returns RAX, RBX, RCX, RDX, RSI, RDI, RSP, RBP, RIP, R8-R15. On x86: returns EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP, EIP.

Inputs: sessionId (required), includeSegment, includeDebug, includeFpu.

get_statusA

Query the current state of the debugger and active session. Returns bridge connectivity, session state (idle/paused/running/stepping/terminated), current instruction pointer, active thread, and a next-step hint. Call this whenever you are unsure what state the debugger is in before issuing step/continue/breakpoint operations. This is always safe to call — it does not change any debugger state.

Inputs: sessionId.

get_threadsB

List all threads in the debuggee process with their current state.

Inputs: sessionId (required).

list_breakpointsA

List all breakpoints in the session, including hit counts and conditions.

Inputs: sessionId (required).

list_functionsA

List recognised functions in the debuggee. Can filter by module name and/or name substring.

Inputs: sessionId (required), module, nameFilter, offset, +1 more.

list_sessionsA

List all active debugging sessions with their state and metadata.

Inputs: no named parameters.

load_executableA

START HERE — load a PE executable into x64dbg and create a debugging session. Returns a sessionId that ALL other tools require as their first parameter. Auto-detects 32-bit vs 64-bit PE and launches x32dbg or x64dbg accordingly. With breakOnEntry=true (default): execution stops at the entry point and the session state becomes 'paused' — you can immediately call step_into, get_registers, or disassemble. With breakOnEntry=false: the debuggee starts running; use set_breakpoint then continue_execution to pause it later. Only one session can be active at a time. Call terminate_session first if one exists.

Inputs: executablePath (required), commandLineArgs, breakOnEntry, autoAnalyze.

read_memoryA

Read raw bytes from the debuggee's virtual address space. Returns a hex+ASCII dump. Address must be in the debuggee's mapped memory (see get_memory_map for valid ranges). REQUIRES: session must be paused.

Inputs: sessionId (required), address (required), size.

remove_breakpointB

Remove a previously set breakpoint at the given address.

Inputs: sessionId (required), address (required).

run_to_addressA

Set a one-shot breakpoint at the given address and continue execution. Stops when the address is reached or another breakpoint/exception fires first.

Inputs: sessionId (required), address (required).

search_memoryA

Search the debuggee's memory for a byte pattern or string. Supports hex patterns with wildcards (e.g. '4D 5A ?? ??') and text strings.

Inputs: sessionId (required), pattern (required), searchType, startAddress, +2 more.

set_breakpointB

Set a breakpoint. Supports software BPs, hardware BPs (execute/read/write), and memory BPs. Optionally supply a condition expression or log text.

Inputs: sessionId (required), address (required), type, condition, +2 more.

set_registerC

Set the value of a single CPU register.

Inputs: sessionId (required), register (required), value (required).

step_intoA

Execute one or more instructions, stepping INTO function calls. REQUIRES: session state must be 'paused'. Returns the new address, disassembly, module, and key register values after stepping. Use step_over instead if you want to skip over CALL instructions.

Inputs: sessionId (required), count.

step_outA

Run until the current function returns (execute until RET). REQUIRES: session state must be 'paused'. Useful for quickly leaving a called function and returning to the caller without stepping through every instruction.

Inputs: sessionId (required).

step_overA

Execute one or more instructions, stepping OVER function calls. REQUIRES: session state must be 'paused'. If the current instruction is a CALL, the entire called function executes and control returns to the instruction after the CALL. Use step_into if you want to trace inside the called function.

Inputs: sessionId (required), count.

switch_threadA

Switch the active thread. Subsequent register/stack/step operations will apply to this thread.

Inputs: sessionId (required), threadId (required).

terminate_sessionA

Stop the debuggee process and close the debugging session. x64dbg itself stays open and ready for the next load_executable call. Call this before loading a new executable, or when analysis is complete.

Inputs: sessionId (required).

trace_executionB

Record an execution trace from the current position. Steps through instructions and records address + disassembly at each step. Stops after maxInstructions or a breakpoint.

Inputs: sessionId (required), maxInstructions, traceInto, recordRegisters, +1 more.

write_memoryA

Write bytes to the debuggee's virtual memory. Use with caution — writing to wrong addresses can crash the debuggee.

Inputs: sessionId (required), address (required), hexBytes (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 39 tools

    Disambiguation4/5

    Most tools have distinct, well-defined purposes (e.g., step_into vs step_over, disassemble vs read_memory). However, tools like analyze_function and analyze_suspicious_apis could be confused if descriptions are not read carefully, and execute_command overlaps with other tools' capabilities.

    Naming Consistency5/5

    All tool names use a consistent verb_noun pattern in snake_case (e.g., analyze_function, load_executable, continue_execution). No mixed conventions or vague verbs.

    Tool Count4/5

    39 tools is on the higher end but justified by the breadth of debugger functionality. The tool set covers execution control, memory inspection, analysis, and session management without being excessive.

    Completeness5/5

    The tool set provides comprehensive coverage for a debugger/analysis server: loading, stepping, breakpoints, memory, registers, modules, security analysis, session management. No obvious gaps for typical reverse engineering tasks.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      C
      maintenance
      Enables AI-assisted reverse engineering and debugging through x64dbg integration. Provides 40+ tools for breakpoint management, memory operations, register manipulation, code analysis, process control, and advanced debugging features.
      22
      -
    • A
      license
      Not graded
      quality
      F
      maintenance
      Enables AI-driven reverse engineering with x64dbg via 71+ MCP tools for breakpoints, memory, disassembly, tracing, debug control, PE analysis, and anti-anti-debugging, supporting HTTP, SSE, and stdio transports.
      2
      MIT