Skip to main content
Glama
x64dbg MCP Server

x64dbg MCP Server

by ouonet

Servidor MCP x64dbg

Un servidor del Protocolo de Contexto de Modelo (MCP) de nivel de producción que expone las capacidades de ingeniería inversa y depuración de x64dbg a asistentes de IA (Claude, Windsurf Cascade, Cursor, etc.).

Arquitectura

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

Dos componentes:

  1. Servidor MCP (src/) — Proceso de Node.js en TypeScript. Habla MCP a través de STDIO con el host de IA y se conecta al puente mediante TCP.

  2. Plugin de Puente (plugin/) — Un plugin cargador en C ligero que incrusta Python 3.10+ dentro de x64dbg. El script de puente de Python llama a x64bridge.dll directamente mediante ctypes — sin dependencia de x64dbgpy. Expone un servidor TCP local que traduce las solicitudes MCP en llamadas al SDK de x64dbg Bridge.

Related MCP server: Binary MCP Server

Características

Auto-lanzamiento y detección de PE

  • Detecta automáticamente la arquitectura PE (x86 / x64) leyendo la cabecera PE

  • Lanza la variante correcta del depurador (x32dbg o x64dbg) con el ejecutable objetivo

  • Espera a que el puerto TCP del plugin de puente sea accesible y luego se conecta — configuración manual cero

  • Incluye Python 32-bit integrable para soporte de plugins en x32dbg

Depuración central (12 herramientas)

  • load_executable — Carga el archivo PE, detecta automáticamente x86/x64, lanza automáticamente el depurador, pausa en el punto de entrada

  • continue_execution / step_into / step_over / step_out

  • run_to_address — Ejecuta hasta una dirección específica

  • set_breakpoint — Puntos de interrupción de software, hardware (ejecución/lectura/escritura/acceso) y memoria con condiciones y texto de registro

  • remove_breakpoint / list_breakpoints

  • terminate_session / list_sessions

  • execute_command — Ejecuta cualquier comando nativo de x64dbg

Memoria y registros (9 herramientas)

  • read_memory / write_memory / search_memory — Patrones hexadecimales con comodines, texto ASCII/Unicode

  • get_memory_map — Diseño completo de memoria virtual con protección e información de módulos

  • get_registers / set_register — Registros GP, flags, segmento, depuración, FPU/SSE

  • get_call_stack — Rastreo de llamadas con direcciones de retorno, nombres de módulos y símbolos

  • get_threads / switch_thread — Enumeración de hilos y cambio de contexto

Análisis estático y dinámico (10 herramientas)

  • disassemble — Con metadatos (is_call, is_jump, objetivos de referencia, comentarios)

  • analyze_function — Límites, tamaño, gráfico de llamadas (llamantes + llamados), detección de funciones hoja

  • get_cross_references — Referencias cruzadas de código y datos (hacia/desde/ambos)

  • list_functions — Con filtrado de módulos, búsqueda de nombres y paginación

  • get_modules / get_imports / get_exports — Con filtros de nombres de DLL y funciones

  • find_strings — ASCII + Unicode con filtrado de contenido y control de longitud mínima

  • get_pe_header — Estructura PE completa: cabeceras DOS/NT, secciones, directorios de datos, entropía

  • trace_execution — Registra el rastro de instrucciones con instantáneas de registros opcionales

Análisis de seguridad (5 herramientas)

  • detect_packing — Análisis de entropía, firmas de empaquetadores conocidos, heurística de conteo de importaciones, puntuación de confianza

  • analyze_suspicious_apis — Referencia cruzada de importaciones contra más de 100 APIs asociadas a malware en 10 categorías

  • detect_anti_debug — IsDebuggerPresent, comprobaciones de tiempo, flags PEB, callbacks TLS, int 2D/3, con sugerencias de bypass

  • check_section_anomalies — Secciones W+X, nombres inusuales, tamaño bruto cero, detección de alta entropía

  • generate_security_report — Triaje consolidado de primera pasada de todas las comprobaciones de seguridad con nivel de riesgo general

Total: 36 herramientas

Requisitos previos

  • Node.js ≥ 20

  • x64dbg instalado en Windows (o usar la copia incluida en x64dbg/)

  • Python 3.10+ instalado para x64dbg, o usar el Python 32-bit integrable incluido para x32dbg

  • CMake 3.15+ y un compilador de C (MSVC / MinGW) para compilar el plugin cargador

Instalación

# 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\

Configuración

Copie .env.example a .env y ajuste:

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

Uso

1. Configure su host de IA

Nota: Ya no necesita iniciar x64dbg manualmente. El servidor MCP lanza automáticamente el depurador correcto (x32dbg o x64dbg) cuando llama a load_executable. El plugin cargador inicializa automáticamente Python 3, ejecuta el script de puente, e inicia un oyente TCP en el puerto 27042.

Windsurf / Cascade

Añada a sus ajustes de MCP:

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

Claude Desktop

Añada a claude_desktop_config.json:

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

2. Inicie la depuración

Pregunte a su asistente de IA:

"Carga C:\samples\target.exe y analízalo en busca de comportamiento sospechoso"

La IA utilizará las herramientas MCP para:

  1. load_executable → cargar el binario

  2. generate_security_report → ejecutar todas las comprobaciones de seguridad

  3. disassemble → inspeccionar código sospechoso

  4. set_breakpoint + continue_execution → análisis dinámico

Flujos de trabajo de ejemplo

Análisis de fallos

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

Triaje de malware

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

Ingeniería inversa

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

Pruebas

# Test with MCP Inspector
npm run inspector

# Development mode (no build step)
npm run dev

Estructura del proyecto

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

Licencia

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