gengstah/windbg-mcp
GitHub: gengstah/windbg-mcp
一个基于 MCP 协议的 WinDbg 调试器服务器，将 pybag 的 55 个 Windows 调试函数封装为结构化工具，使 Claude、Cursor 等 AI 客户端能够直接控制用户态进程、内核会话和崩溃转储分析。
Stars: 57 | Forks: 4
# WinDbg MCP
一个 MCP (Model Context Protocol) 服务器，将所有 pybag Windows 调试器函数作为原生 MCP 工具公开。它为任何兼容 MCP 的客户端（Claude Desktop、
Claude Code, Cowork, OpenAI Codex CLI, Cursor 和自定义代理）提供对用户模式进程、内核会话和崩溃转储分析的完全控制——所有这些都通过带有结构化 JSON 响应的类型化工具调用来实现。
## 要求
- **仅限 Windows** — pybag 需要 Microsoft Debugging Tools for Windows
- Python 3.10+
- Microsoft Debugging Tools for Windows (Windows SDK 的一部分)
## 安装说明
### 1. 克隆仓库
```
git clone https://github.com/your-username/windbg-mcp.git
cd windbg-mcp
```
### 2. 安装 Python 依赖
```
pip install pybag mcp
```
### 3. 安装 Microsoft Debugging Tools
下载 Windows SDK 并在安装过程中选择 **Debugging Tools for Windows**：
https://developer.microsoft.com/en-us/windows/downloads/windows-sdk/
## 连接到 LLM IDE 和客户端
该服务器作为本地 stdio 进程运行。以下所有客户端的启动方式都相同——
`python /windbg_mcp.py`——但每个客户端都有其自己的配置格式。
### Claude Desktop
编辑 Claude Desktop 配置文件并添加 `windbg-mcp` 条目：
**配置文件位置：**
- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
```
{
"mcpServers": {
"windbg-mcp": {
"command": "python",
"args": ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"]
}
}
}
```
重启 Claude Desktop。所有 55 个调试器工具将自动出现。
### Claude Code (CLI)
运行一次以下命令以注册服务器。Claude Code 会将条目存储在其自身的 MCP 配置中，并使其在后续的每个会话中都可用。
```
claude mcp add windbg-mcp python C:\path\to\windbg-mcp\windbg_mcp.py
```
要验证服务器是否已注册：
```
claude mcp list
```
以后要移除它：
```
claude mcp remove windbg-mcp
```
### Claude Cowork
有两种方法可以将 WinDbg MCP 添加到 Cowork：通过 JSON 配置（快速）或将其作为 `.mcpb` 插件包安装（便携、可共享）。
#### 选项 A — JSON 配置
1. 打开 Claude 桌面应用并进入 **Settings → MCP Servers**。
2. 点击 **Add Server** 并粘贴以下内容：
```
{
"windbg-mcp": {
"command": "python",
"args": ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"]
}
}
```
3. 保存并重启 Cowork。这些工具将在您的下一次会话中可用。
#### 选项 B — 作为 `.mcpb` 插件包安装
`.mcpb` 文件是一个插件目录的 zip 压缩包，Cowork 可以直接安装。当与团队或在多台机器之间共享服务器时，这是推荐的方法。
**步骤 1 — 构建 `.mcpb` 文件**
在克隆的仓库根目录中，运行：
```
powershell -Command "Compress-Archive -Path '.\*' -DestinationPath 'windbg-mcp.zip'; Rename-Item 'windbg-mcp.zip' 'windbg-mcp.mcpb'"
```
这将在当前目录中创建 `windbg-mcp.mcpb`，其中捆绑了 `windbg_mcp.py`、
`manifest.json` 以及任何其他项目文件。
**步骤 2 — 在 Cowork 中安装**
1. 打开 Claude 桌面应用。
2. 转到 **Settings → Plugins**（或 **Extensions**）。
3. 点击 **Install Plugin** 并选择 `windbg-mcp.mcpb`。
4. Cowork 从包中读取 `manifest.json`，注册 MCP 服务器，并立即使所有工具可用——无需手动配置路径。
本仓库中捆绑的 `manifest.json` 已正确配置：
```
{
"manifest_version": "0.2",
"name": "windbg-mcp",
"version": "1.0.0",
"description": "WinDbg MCP — full Windows debugger control via MCP tools",
"server": {
"type": "python",
"entry_point": "windbg_mcp.py",
"mcp_config": {
"command": "python",
"args": ["${__dirname}/windbg_mcp.py"]
}
}
}
```
`${__dirname}` 会在安装时解析为 Cowork 解压包的目录，因此您不需要硬编码任何路径。
### OpenAI Codex CLI
将服务器添加到您的 Codex CLI 配置文件中。该文件通常位于
`~/.codex/config.json` (Linux/macOS) 或 `%USERPROFILE%\.codex\config.json` (Windows)。
```
{
"mcpServers": {
"windbg-mcp": {
"command": "python",
"args": ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"]
}
}
}
```
保存后，启动一个新的 Codex 会话。WinDbg 工具将可供模型调用。
### Cursor
1. 打开 **Cursor → Preferences → Cursor Settings**。
2. 导航到 **MCP** 标签页。
3. 点击 **Add new global MCP server** 并使用此配置：
```
{
"windbg-mcp": {
"command": "python",
"args": ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"]
}
}
```
4. 保存。Cursor 将在下次 Composer 会话中连接到该服务器。
### Continue.dev
将以下内容添加到您的 `~/.continue/config.json`（或工作区级别的
`.continue/config.json`）：
```
{
"experimental": {
"modelContextProtocolServers": [
{
"transport": {
"type": "stdio",
"command": "python",
"args": ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"]
}
}
]
}
}
```
重新加载 Continue 扩展。55 个调试器工具将出现在工具列表中。
### 自定义代理和 MCP SDK
如果您正在构建自己的代理或自动化 pipeline，请通过标准的 MCP stdio 传输连接到 WinDbg MCP。该服务器通过 stdin/stdout 进行 JSON-RPC 2.0 通信。
#### Python（使用 `mcp` SDK）
```
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
server_params = StdioServerParameters(
command="python",
args=[r"C:\path\to\windbg-mcp\windbg_mcp.py"],
)
async def main():
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
# List all available tools
tools = await session.list_tools()
print([t.name for t in tools.tools])
# Load a crash dump
result = await session.call_tool(
"load_dump",
arguments={"path": r"C:\crashes\crash.dmp"},
)
print(result.content)
# Read 64 bytes at RSP
result = await session.call_tool(
"read_mem",
arguments={"addr": "0x00000000001FF000", "size": 64},
)
print(result.content)
asyncio.run(main())
```
#### TypeScript / Node.js（使用 `@modelcontextprotocol/sdk` 包）
```
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
const transport = new StdioClientTransport({
command: "python",
args: ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"],
});
const client = new Client({ name: "my-agent", version: "1.0.0" }, {});
await client.connect(transport);
// Call a tool
const result = await client.callTool({
name: "load_dump",
arguments: { path: "C:\\crashes\\crash.dmp" },
});
console.log(result.content);
await client.close();
```
#### LangChain / LangGraph
```
from langchain_mcp_adapters.tools import load_mcp_tools
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
server_params = StdioServerParameters(
command="python",
args=[r"C:\path\to\windbg-mcp\windbg_mcp.py"],
)
async def get_tools():
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
return await load_mcp_tools(session)
```
#### 通过 stdio 直接进行 JSON-RPC（与语言无关）
服务器通过以换行符分隔的 JSON-RPC 2.0 消息进行通信。您可以通过写入进程的 stdin 并从 stdout 读取来使用任何语言驱动它：
```
→ {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"my-client","version":"1.0"}}}
← {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2024-11-05","capabilities":{...},"serverInfo":{"name":"WinDbg MCP","version":"1.0.0"}}}
→ {"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"load_dump","arguments":{"path":"C:\\crashes\\crash.dmp"}}}
← {"jsonrpc":"2.0","id":2,"result":{"content":[{"type":"text","text":"{\"status\": \"ok\", ...}"}]}}
```
## 可用工具（共 55 个）
### 会话管理
| Tool | Parameters | Returns |
|------|-----------|---------|
| `status` | — | `{connected, type, pid, bitness}` |
| `list_processes` | — | `[{pid, name, description}]` |
| `create` | `path` (必填), `args`, `initial_break` | `{status, pid, bitness}` |
| `attach` | `pid` **或** `name` (不可同时提供), `initial_break` | `{status, pid, bitness}` |
| `kernel_attach` | `connect_string` (必填), `initial_break` | `{status, type, connect_string}` |
| `load_dump` | `path` (必填) | `{status, bitness, rip, symbol_at_rip}` |
| `connect` | `options` (必填) | `{status, options}` |
| `detach` | — | `{status}` |
| `terminate` | — | `{status}` |
**`create`** — 在调试器下启动一个新进程。设置 `initial_break=True`（默认）以在进程入口点处中断。
**`attach`** — 附加到一个正在运行的进程。提供 `pid`（整数）或 `name`（进程文件名）。请勿同时提供两者。
**`kernel_attach`** — 连接到远程内核调试器。`connect_string` 使用 KD 语法，例如 `"net:port=55000,key=1.2.3.4"`。
**`load_dump`** — 打开一个 `.dmp` 文件以进行事后分析。立即返回崩溃地址和最近的符号。
**`connect`** — 连接到进程服务器以进行远程用户模式调试。`options` 使用 DbgEng 连接语法，例如 `"tcp:server=192.168.1.10,port=5555"`。
### 执行控制
| Tool | Parameters | Returns |
|------|-----------|---------|
| `go` | `timeout` (毫秒, 默认 30000) | `{status, rip, symbol, new_captures, captures}` |
| `step_into` | `count` (默认 1) | `{rip, instruction, symbol}` |
| `step_over` | `count` (默认 1) | `{rip, instruction, symbol}` |
| `step_out` | — | `{rip, instruction, symbol}` |
| `goto` | `expr` (必填) | `{rip, symbol}` |
| `trace` | `count` (默认 10) | `{instructions: [{rip, instruction, symbol}], count}` |
**`go`** — 恢复执行并阻塞直到下一个调试事件（断点、异常或超时）。返回新的 RIP 以及在运行期间收集到的任何捕获。
**`step_into`** — 单步执行下一条指令，跟随调用进入被调用函数。
**`step_over`** — 单步跳过下一条指令，将调用视为单步。
**`step_out`** — 运行直到当前函数返回。
**`goto`** — 运行直到到达特定符号或十六进制地址，例如 `"Kernel32!ExitProcess"` 或 `"0x7fff12340000"`。
**`trace`** — 执行 N 次单步迭代并记录访问过的每条指令。
### 断点
| Tool | Parameters | Returns |
|------|-----------|---------|
| `bp` | `expr` (必填), `capture`, `action`, `oneshot`, `passcount` | `{id, expr, addr, capture}` |
| `hw_bp` | `addr` (必填), `size`, `access`, `capture`, `action`, `oneshot` | `{id, addr, size, access}` |
| `list_bps` | — | `[{id, expr, type, capture, action, ...}]` |
| `remove_bp` | `id` (必填) | `{status, id}` |
| `enable_bp` | `id` (必填) | `{status, id}` |
| `disable_bp` | `id` (必填) | `{status, id}` |
**`bp`** — 在符号或地址处设置软件（代码）断点。
- `expr`: 符号 (`"ntdll!NtCreateFile"`) 或十六进制地址 (`"0x7ff800001234"`)
- `capture`: 当为 `true`（默认）时，每次触发此断点时自动保存完整状态（寄存器、栈、内存）到捕获缓冲区
- `action`: `"go"`（默认）在捕获后继续执行；`"break"` 停止执行
- `oneshot`: 触发一次后移除断点
- `passcount`: 经过该位置 N 次后才触发
**`hw_bp`** — 设置硬件/数据断点（观察点）。
- `addr`: 要监视的十六进制地址
- `size`: 以字节为单位的监视宽度 — `1`、`2`、`4` 或 `8`（默认 `4`）
- `access`: `"e"` 执行，`"w"` 写入（默认），`"r"` 读取/写入
- `capture`, `action`, `oneshot`: 与 `bp` 语义相同
**`list_bps`** — 返回所有当前活动的断点及其 ID、表达式、类型和设置。
**`remove_bp` / `enable_bp` / `disable_bp`** — 通过 `bp` 或 `hw_bp` 返回的 `id` 管理断点。
### 状态捕获
带有 `capture: true`（默认）的断点每次触发时都会自动保存完整的调试器快照。该快照包括所有寄存器、调用栈、
RSP 处 64 字节的栈内存，以及 RIP 处 32 字节的代码。快照会在缓冲区中累积，并且可以随时通过 `get_captures` 检索。
| Tool | Parameters | Returns |
|------|-----------|---------|
| `get_captures` | — | `{count, captures: [{bp_id, expr, timestamp, registers, rip, symbol_at_rip, instruction, stack, context_memory}]}` |
| `clear_captures` | — | `{status}` |
| `capture_state` | — | `{timestamp, registers, rip, symbol_at_rip, instruction, disasm_5, stack_at_rsp, call_stack}` |
**`get_captures`** — 返回自上次 `clear_captures` 以来收集到的所有捕获。每次捕获包含：
- `registers` — 所有寄存器值，格式为 `{name: "0x..."}` 十六进制字符串
- `rip` — 捕获时刻的指令指针
- `symbol_at_rip` — 距 RIP 最近的符号
- `instruction` — RIP 处指令的反汇编
- `stack` — 前 10 个调用栈帧及其地址和返回地址
- `context_memory.stack_at_rsp` — RSP 处的 64 字节，格式为十六进制和 ASCII
- `context_memory.code_at_rip` — RIP 处的 32 字节，格式为十六进制
**`clear_captures`** — 清除捕获缓冲区。在开始新运行之前很有用。
**`capture_state`** — 对当前状态进行即时的按需快照。当已经处于中断状态时使用此工具，而不是等待断点触发。
### 内存
| Tool | Parameters | Returns |
|------|-----------|---------|
| `read_mem` | `addr` (必填), `size` (默认 16) | `{addr, size, hex, formatted, ascii}` |
| `write_mem` | `addr` (必填), `data` (必填, 十六进制字符串) | `{status, addr, bytes_written}` |
| `read_ptr` | `addr` (必填), `count` (默认 1) | `{addr, values: ["0x..."]}` |
| `poi` | `addr` (必填) | `{addr, value}` |
| `read_str` | `addr` (必填), `wide` (默认) | `{addr, value, wide}` |
| `dump_mem` | `addr` (必填), `count` (默认 8) | `{addr, output}` |
| `mem_info` | `addr` (必填) | `{addr, info}` |
| `mem_list` | — | `[region_description_strings]` |
**`read_mem`** — 从 `addr` 读取 `size` 个原始字节。以 `hex`（紧凑）、`formatted`（以空格分隔的字节）和 `ascii`（可打印字符，不可打印字符为 `.`）的形式返回数据。
**`write_mem`** — 将字节写入内存。`data` 是一个十六进制字符串——空格和 `\x` 前缀会被自动去除，例如 `"90909090"`、`"\\x90\\x90\\x90\\x90"` 或 `"90 90 90 90"`。
**`read_ptr`** — 从 `addr` 开始读取 `count` 个连续的指针大小的值（32 位上为 4 字节，64 位上为 8 字节）。
**`poi`** — 解引用 `addr` 处的单个指针（感兴趣指针）。
**`read_str`** — 读取以 null 结尾的字符串。设置 `wide=true` 以读取 UTF-16LE (Windows WCHAR)。
**`dump_mem`** — 格式化的 dword/指针转储，等效于 WinDbg 中的 `dd`/`dp`。
**`mem_info`** — 返回包含 `addr` 的页面的内存区域属性：基地址、大小、类型、状态和保护标志。
**`mem_list`** — 列出目标进程地址空间中的所有虚拟内存区域。
### 寄存器
| Tool | Parameters | Returns |
|------|-----------|---------|
| `get_regs` | — | `{rax, rbx, rcx, rdx, rsi, rdi, rbp, rsp, rip, r8–r15, eflags, ...}` |
| `get_reg` | `name` (必填) | `{name, value}` |
| `set_reg` | `name` (必填), `value` (必填) | `{status, name, value}` |
| `get_pc` | — | `{value, symbol, instruction}` |
| `get_sp` | — | `{value}` |
**`get_regs`** — 以 `{name: "0x..."}` 的形式返回每个可用寄存器。具体的集合取决于目标架构（x86 还是 x64）。
**`get_reg`** — 返回单个寄存器，例如 `name="rax"`、`name="eflags"`。
**`set_reg`** — 覆盖寄存器的值。`value` 接受十六进制字符串 (`"0x1234"`) 或十进制整数字符串。
**`get_pc`** — 返回带有符号解析以及该地址处解码指令文本的指令指针。
**`get_sp`** — 返回当前的栈指针值。
### 符号和反汇编
| Tool | Parameters | Returns |
|------|-----------|---------|
| `resolve` | `name` (必填) | `{name, addr}` 或 `{name, addr: null, error}` |
| `find_symbols` | `pattern` (必填) | `[symbol_strings]` |
| `addr_to_symbol` | `addr` (必填) | `{addr, symbol}` |
| `disasm` | `addr` (默认: 当前 RIP), `count` (默认 10) | `{addr, output}` |
| `whereami` | `addr` (可选, 默认: 当前 RIP) | `{description}` |
**`resolve`** — 将符号名解析为其虚拟地址。请使用 `Module!Function` 格式，例如 `"Kernel32!WriteFile"`、`"ntdll!NtCreateFile"`。
**`find_symbols`** — 通配符符号搜索，例如 `"ntdll!*Alloc*"`、`"kernel32!*File*"`。返回所有匹配的符号字符串。
**`addr_to_symbol`** — 反向解析虚拟地址到最近的符号名。
**`disasm`** — 从 `addr` 开始反汇编 `count` 条指令。如果未给出地址，则默认为当前 RIP。
**`whereami`** — 返回给定地址处的模块、函数和偏移量的可读描述。
### 模块
| Tool | Parameters | Returns |
|------|-----------|---------|
| `list_modules` | — | `[{name, base, size}]` |
| `module_info` | `name` (必填) | `{name, entry_point, sections}` |
| `get_exports` | `name` (必填) | `[export_strings]` |
| `get_imports` | `name` (必填) | `[import_strings]` |
**`list_modules`** — 列出目标中加载的所有模块，及其基地址和大小。
**`module_info`** — 返回特定模块（例如 `"kernel32.dll"`、`"ntdll.dll"`）的入口点和节列表（名称、虚拟地址、大小）。
**`get_exports`** — 以字符串列表的形式返回模块的完整导出表。
**`get_imports`** — 以字符串列表的形式返回模块的完整导入表。
### 线程和栈
| Tool | Parameters | Returns |
|------|-----------|---------|
| `list_threads` | — | `[thread_description_strings]` |
| `get_thread` | — | `{current_thread}` |
| `set_thread` | `id` (必填) | `{status, thread}` |
| `get_stack` | `frames` (默认 20) | `{frames: [{frame, addr, return_addr, frame_ptr}], count}` |
| `get_teb` | — | `{addr}` |
| `get_peb` | — | `{addr}` |
**`list_threads`** — 列出目标进程中的所有线程。
**`get_thread`** — 返回当前活动的线程上下文。
**`set_thread`** — 通过线程 ID（来自 `list_threads`）切换活动线程上下文。
**`get_stack`** — 以结构化数据的形式返回调用栈。每一帧都包含指令地址、返回地址和栈帧指针。
**`get_teb`** — 返回当前线程的 Thread Environment Block 的地址。
**`get_peb`** — 返回 Process Environment Block 的地址。
### 进程和实用工具
| Tool | Parameters | Returns |
|------|-----------|---------|
| `get_handles` | — | `[handle_description_strings]` |
| `get_bitness` | — | `{bits}` |
| `raw` | `cmd` (必填) | `{output}` |
**`get_handles`** — 列出目标进程中所有打开的句柄。
**`get_bitness`** — 根据目标架构返回 `32` 或 `64`。
**`raw`** — 执行任何 WinDbg 命令字符串并以文本形式返回输出。可将其用作其他工具未涵盖的任何操作的后备方案：
```
raw(cmd="!heap -stat")
raw(cmd="dt _PEB @$peb")
raw(cmd="!locks")
raw(cmd="lm")
raw(cmd="!address @rsp")
```
## 典型工作流
### 漏洞利用验证
```
1. create(path="C:/target/vuln.exe", args="exploit_input.bin")
2. bp(expr="vuln!processInput+0x2A", action="break")
3. go(timeout=15000)
4. get_captures()
```
在 `get_captures` 中，检查 `captures[0].registers.rip`：
- `"0x4141414141414141"` — 您可以使用 'A' 字节控制 RIP
- 任何与您的模式匹配的值 — 已控制
- 看似有效的地址 — 发生崩溃但尚未控制
检查 `captures[0].context_memory.stack_at_rsp.formatted` 以查看栈上的填充、返回地址或 shellcode 字节。
### 崩溃转储分析
```
1. load_dump(path="C:/crashes/crash.dmp")
2. get_regs() → full register state at crash time
3. get_stack(frames=30) → call stack at crash
4. get_sp() → read RSP value
5. read_mem(addr=, size=64) → stack contents
6. disasm() → instructions at the crash address
```
### 堆喷射验证
```
1. attach(name="target.exe")
2. hw_bp(addr="0x1001F000", size=8, access="w", action="break")
3. go()
4. get_captures() → see what wrote to the spray address
5. read_mem(addr="0x1001EFC0", size=128) → surrounding memory context
```
### ASLR 检查
```
1. create(path="C:/target/target.exe")
2. resolve(name="kernel32!WriteFile") → record base address
3. terminate()
4. create(path="C:/target/target.exe")
5. resolve(name="kernel32!WriteFile") → compare: changed = ASLR on, same = ASLR off
```
### 远程内核调试
```
1. kernel_attach(connect_string="net:port=55000,key=1.2.3.4")
2. list_modules() → all loaded kernel modules
3. module_info(name="ntoskrnl.exe") → entry point and sections
4. raw(cmd="!process 0 0") → list all processes from kernel context
5. raw(cmd="!pcr") → processor control region
```
### 线程检查
```
1. attach(pid=1234)
2. list_threads() → all thread IDs
3. set_thread(id=2) → switch context
4. get_stack(frames=20) → call stack for that thread
5. get_regs() → registers for that thread
6. get_teb() → TEB address
```
## 提示
**符号路径** — 如果符号解析没有返回结果，请配置 Microsoft 符号服务器：
```
raw(cmd=".sympath srv*C:\\symbols*https://msdl.microsoft.com/download/symbols")
raw(cmd=".reload")
```
**超时调整** — `go()` 默认为 30 秒。如果目标在命中断点前运行时间更长：
```
go(timeout=120000) # 2 minutes
go(timeout=300000) # 5 minutes
```
**地址格式** — 所有 `addr` 参数都接受十六进制字符串（`"0x1234abcd"`、`"7fff12340000"`）或普通整数。十六进制值的 `0x` 前缀是可选的。
**Shellcode 验证** — 捕获后，在您的 shellcode 应该到达的地址上使用 `read_mem` 和 `disasm`。如果 `disasm` 显示了您预期的指令，则说明 payload 完好无损地到达了。
**在 `terminate` 或 `detach` 之后** — 所有捕获和断点都会被自动清除。调用 `create` 或 `attach` 以开始新的会话。
**`capture_state` 与 `get_captures`** — 当已经停在断点处时，使用 `capture_state` 获取按需快照。使用 `get_captures` 检索在 `go` 调用期间每次触发断点时自动保存的状态。
**内核 `raw` 命令** — 可通过 `raw` 正常工作的常见内核调试扩展：
```
raw(cmd="!process 0 0") → list all processes
raw(cmd="!thread") → current thread details
raw(cmd="!irql") → current IRQL
raw(cmd="!pcr") → processor control region
raw(cmd="!pte ") → page table entry for an address
raw(cmd="dt nt!_EPROCESS @$proc") → dump EPROCESS structure
```
## 许可证
MIT
标签：AI编程助手, Claude Code, Claude Desktop, Cursor, Debugging Tools for Windows, IDE插件, JSON API, LLM工具, MCP, Model Context Protocol, OpenAI Codex CLI, pybag, Python, Velociraptor, WinDbg, Windows SDK, Windows调试器, 云资产清单, 内核调试, 可配置连接, 大模型集成, 子域名枚举, 客户端服务器架构, 崩溃转储分析, 无后门, 智能化运维, 用户态调试, 程序分析, 系统安全, 自动化调试, 进程控制, 逆向工具, 逆向工程