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. रिपॉजिटरी को क्लोन करें```bat

git clone https://github.com/your-username/windbg-mcp.git cd windbg-mcp

### 2. Python निर्भरताएँ स्थापित करें```bat
pip install pybag mcp

3. माइक्रोसॉफ्ट डिबगिंग टूल्स इंस्टॉल करें

विंडोज SDK डाउनलोड करें और सेटअप के दौरान डिबगिंग टूल्स फॉर विंडोज चुनें: https://developer.microsoft.com/en-us/windows/downloads/windows-sdk/

LLM IDE और क्लाइंट से कनेक्ट करना

सर्वर एक स्थानीय stdio प्रक्रिया के रूप में चलता है। नीचे दिए गए सभी क्लाइंट इसे उसी तरह लॉन्च करते हैं — python <path-to>/windbg_mcp.py — लेकिन प्रत्येक का अपना कॉन्फ़िगरेशन फॉर्मेट होता है।

क्लॉड डेस्कटॉप

क्लॉड डेस्कटॉप कॉन्फ़िगरेशन फ़ाइल संपादित करें और windbg-mcp एंट्री जोड़ें:

कॉन्फ़िग फ़ाइल स्थान:

• विंडोज: %APPDATA%\Claude\claude_desktop_config.json
• macOS: `~/Library/Application Support/Claude/claude_desktop_config.json````json { "mcpServers": { "windbg-mcp": { "command": "python", "args": ["C:\path\to\windbg-mcp\windbg_mcp.py"] } } }

Restart Claude Desktop. All 55 debugger tools will appear automatically.

---

### Claude Code (CLI)

सर्वर को पंजीकृत करने के लिए निम्नलिखित कमांड को एक बार चलाएँ। Claude Code इस प्रविष्टि को अपने स्वयं के MCP कॉन्फ़िग में संग्रहीत करता है और बाद के प्रत्येक सत्र में उपकरणों को उपलब्ध कराता है।```bash
claude mcp add windbg-mcp python C:\path\to\windbg-mcp\windbg_mcp.py

सर्वर को पंजीकृत करने की पुष्टि करने के लिए:```bash claude mcp list

बाद में हटाने के लिए:```bash
claude mcp remove windbg-mcp

Claude Cowork

WinDbg MCP को Cowork में जोड़ने के दो तरीके हैं: JSON कॉन्फ़िगरेशन के माध्यम से (त्वरित) या इसे .mcpb प्लगइन बंडल के रूप में स्थापित करके (पोर्टेबल, साझा करने योग्य)।

विकल्प A — JSON कॉन्फ़िगरेशन

1. Claude डेस्कटॉप ऐप खोलें और सेटिंग्स → MCP सर्वर पर जाएं।
2. Add Server पर क्लिक करें और निम्नलिखित चिपकाएँ:```json { "windbg-mcp": { "command": "python", "args": ["C:\path\to\windbg-mcp\windbg_mcp.py"] } }

3. Cowork को सहेजें और पुनरारंभ करें। उपकरण आपके अगले सत्र में उपलब्ध होंगे।

#### विकल्प B — एक `.mcpb` प्लगइन बंडल के रूप में स्थापित करें

एक `.mcpb` फ़ाइल प्लगइन निर्देशिका का एक ज़िप आर्काइव है जिसे Cowork सीधे
स्थापित कर सकता है। यह अनुशंसित तरीका है जब सर्वर को किसी टीम या
विभिन्न मशीनों के साथ साझा किया जा रहा हो।

**चरण 1 — `.mcpb` फ़ाइल बनाएँ**

क्लोन किए गए रिपॉजिटरी के रूट से, चलाएँ:```bat
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. सेटिंग्स → प्लगइन्स (या एक्सटेंशन) पर जाएं।
3. प्लगइन स्थापित करें पर क्लिक करें और windbg-mcp.mcpb चुनें।
4. Cowork बंडल से manifest.json पढ़ता है, MCP सर्वर को पंजीकृत करता है, और सभी उपकरणों को तुरंत उपलब्ध कराता है — किसी मैन्युअल पथ कॉन्फ़िगरेशन की आवश्यकता नहीं है।

इस रिपॉजिटरी में बंडल किया गया manifest.json पहले से ही सही ढंग से कॉन्फ़िगर किया गया है:```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) पर स्थित होती है।```json
{
  "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 पर क्लिक करें और इस कॉन्फ़िगरेशन का उपयोग करें:```json { "windbg-mcp": { "command": "python", "args": ["C:\path\to\windbg-mcp\windbg_mcp.py"] } }

4. सहेजें। कर्सर अपने अगले Composer सत्र में सर्वर से कनेक्ट हो जाएगा।

---

### Continue.dev

अपने `~/.continue/config.json` में निम्नलिखित जोड़ें (या कार्यक्षेत्र-स्तरीय
`.continue/config.json` में):```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "python",
          "args": ["C:\\path\\to\\windbg-mcp\\windbg_mcp.py"]
        }
      }
    ]
  }
}

Continue एक्सटेंशन को पुनः लोड करें। 55 डीबगर उपकरण टूल सूची में दिखाई देंगे।

कस्टम एजेंट और MCP SDK

यदि आप अपना स्वयं का एजेंट या ऑटोमेशन पाइपलाइन बना रहे हैं, तो मानक MCP stdio ट्रांसपोर्ट पर WinDbg MCP से कनेक्ट करें। सर्वर stdin/stdout पर JSON-RPC 2.0 बोलता है।

Python (mcp SDK का उपयोग करते हुए)```python

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` पैकेज का उपयोग करते हुए)```typescript
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```python

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)

#### Direct JSON-RPC over stdio (language-agnostic)

सर्वर न्यूलाइन-सीमांकित 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)

सत्र प्रबंधन

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"।

निष्पादन नियंत्रण

go — निष्पादन फिर से शुरू करता है और अगले डीबग इवेंट (ब्रेकपॉइंट, अपवाद, या टाइमआउट) तक ब्लॉक करता है। नया RIP और चलने के दौरान एकत्र किए गए किसी भी कैप्चर को लौटाता है।

step_into — अगले निर्देश में प्रवेश करता है, कॉल किए गए फ़ंक्शन में जाता है।

step_over — अगले निर्देश को पार करता है, कॉल को एकल चरण के रूप में मानता है।

step_out — वर्तमान फ़ंक्शन के लौटने तक चलता है।

goto — किसी विशिष्ट प्रतीक या हेक्स पते पर पहुंचने तक चलता है, जैसे "Kernel32!ExitProcess" या "0x7fff12340000"।

trace — N एकल-चरण पुनरावृत्तियाँ करता है और प्रत्येक विज़िट किए गए निर्देश को रिकॉर्ड करता है।

ब्रेकपॉइंट

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 — सभी वर्तमान में सक्रिय ब्रेकपॉइंट को उनके आईडी, अभिव्यक्ति, प्रकार और सेटिंग्स के साथ लौटाता है।

remove_bp / enable_bp / disable_bp — bp या hw_bp से लौटाए गए id द्वारा ब्रेकपॉइंट प्रबंधित करें।

स्थिति कैप्चर

capture: true (डिफ़ॉल्ट) वाले ब्रेकपॉइंट स्वचालित रूप से हर बार फायर होने पर एक पूर्ण डीबगर स्नैपशॉट सहेजते हैं। स्नैपशॉट में सभी रजिस्टर, कॉल स्टैक, RSP पर 64 बाइट्स स्टैक मेमोरी, और RIP पर 32 बाइट्स कोड शामिल होते हैं। स्नैपशॉट एक बफर में जमा होते हैं और किसी भी समय get_captures से प्राप्त किए जा सकते हैं।

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 — वर्तमान स्थिति का तत्काल ऑन-डिमांड स्नैपशॉट लेता है। जब पहले से ब्रेक किया गया हो, ब्रेकपॉइंट फायर होने की प्रतीक्षा करने के बजाय इसका उपयोग करें।

मेमोरी

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-टर्मिनेटेड स्ट्रिंग पढ़ता है। UTF-16LE (Windows WCHAR) के लिए wide=true सेट करें।

dump_mem — स्वरूपित dword/pointer डंप, WinDbg में dd/dp के समतुल्य।

mem_info — addr वाले पेज के लिए मेमोरी क्षेत्र गुण लौटाता है: आधार पता, आकार, प्रकार, स्थिति और सुरक्षा फ़्लैग।

mem_list — लक्ष्य प्रक्रिया पता स्थान में सभी वर्चुअल मेमोरी क्षेत्रों को सूचीबद्ध करता है।

रजिस्टर

get_regs — प्रत्येक उपलब्ध रजिस्टर को {name: "0x..."} के रूप में लौटाता है। सटीक सेट लक्ष्य आर्किटेक्चर (x86 बनाम x64) पर निर्भर करता है।

get_reg — एकल रजिस्टर लौटाता है, जैसे name="rax", name="eflags"।

set_reg — एक रजिस्टर को ओवरराइट करता है। value हेक्स स्ट्रिंग ("0x1234") या दशमलव पूर्णांक स्ट्रिंग स्वीकार करता है।

get_pc — प्रतीक समाधान और उस पते पर डिकोड किए गए निर्देश पाठ के साथ निर्देश पॉइंटर लौटाता है।

get_sp — वर्तमान स्टैक पॉइंटर मान लौटाता है।

प्रतीक और डिसअसेंबली

resolve — एक प्रतीक नाम को उसके वर्चुअल पते पर हल करता है। Module!Function प्रारूप का उपयोग करें, जैसे "Kernel32!WriteFile", "ntdll!NtCreateFile"।

find_symbols — वाइल्डकार्ड प्रतीक खोज, जैसे "ntdll!*Alloc*", "kernel32!*File*"। सभी मिलान प्रतीक स्ट्रिंग लौटाता है।

addr_to_symbol — एक वर्चुअल पते को निकटतम प्रतीक नाम में रिवर्स-हल करता है।

disasm — addr से शुरू होने वाले count निर्देशों को डिसअसेंबल करता है। यदि कोई पता नहीं दिया गया है तो वर्तमान RIP पर डिफ़ॉल्ट होता है।

whereami — दिए गए पते पर मॉड्यूल, फ़ंक्शन और ऑफ़सेट का मानव-पठनीय विवरण लौटाता है।

मॉड्यूल

list_modules — लक्ष्य में लोड किए गए सभी मॉड्यूल को उनके आधार पते और आकार के साथ सूचीबद्ध करता है।

module_info — एक विशिष्ट मॉड्यूल के लिए प्रवेश बिंदु और अनुभाग सूची (नाम, वर्चुअल पता, आकार) लौटाता है, जैसे "kernel32.dll", "ntdll.dll"।

get_exports — एक मॉड्यूल की पूर्ण निर्यात तालिका को स्ट्रिंग की सूची के रूप में लौटाता है।

get_imports — एक मॉड्यूल की पूर्ण आयात तालिका को स्ट्रिंग की सूची के रूप में लौटाता है।

थ्रेड और स्टैक

list_threads — लक्ष्य प्रक्रिया में सभी थ्रेड को सूचीबद्ध करता है।

get_thread — वर्तमान में सक्रिय थ्रेड संदर्भ लौटाता है।

set_thread — थ्रेड आईडी द्वारा सक्रिय थ्रेड संदर्भ स्विच करता है (list_threads से)।

get_stack — कॉल स्टैक को संरचित डेटा के रूप में लौटाता है। प्रत्येक फ्रेम में निर्देश पता, वापसी पता और फ्रेम पॉइंटर शामिल है।

get_teb — वर्तमान थ्रेड के लिए थ्रेड एनवायरनमेंट ब्लॉक का पता लौटाता है।

get_peb — प्रक्रिया एनवायरनमेंट ब्लॉक का पता लौटाता है।

प्रक्रिया और उपयोगिता

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()

In get_captures में, captures[0].registers.rip की जाँच करें:

• "0x4141414141414141" — आप 'A' बाइट्स के साथ RIP को नियंत्रित करते हैं
• आपके पैटर्न से मेल खाने वाला कोई भी मान — नियंत्रित
• एक वैध दिखने वाला पता — क्रैश लेकिन अभी तक नियंत्रित नहीं

स्टैक पर पैडिंग, रिटर्न एड्रेस, या शेलकोड बाइट्स देखने के लिए captures[0].context_memory.stack_at_rsp.formatted की जाँच करें।

क्रैश डंप विश्लेषण```

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

---

## सुझाव

**Symbol path** — यदि प्रतीक समाधान कोई परिणाम नहीं देता है, तो माइक्रोसॉफ्ट प्रतीक सर्वर कॉन्फ़िगर करें:```
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` उपसर्ग वैकल्पिक है।

**शेलकोड सत्यापन** — कैप्चर के बाद, उस पते पर `read_mem` और `disasm` का उपयोग करें जहां आपका शेलकोड लैंड होना चाहिए। यदि `disasm` आपके इच्छित निर्देश दिखाता है, तो पेलोड बरकरार पहुंच गया।

**`terminate` या `detach` के बाद** — सभी कैप्चर और ब्रेकप्वाइंट स्वचालित रूप से साफ़ हो जाते हैं। नया सत्र शुरू करने के लिए `create` या `attach` को कॉल करें।

**`capture_state` बनाम `get_captures`** — जब पहले से ही ब्रेकप्वाइंट पर रुके हों, तो ऑन-डिमांड स्नैपशॉट के लिए `capture_state` का उपयोग करें। `go` कॉल के दौरान हर बार ब्रेकप्वाइंट फायर होने पर स्वचालित रूप से सहेजी गई स्थिति को प्राप्त करने के लिए `get_captures` का उपयोग करें।

**कर्नेल `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 <addr>")        → page table entry for an address
raw(cmd="dt nt!_EPROCESS @$proc")  → dump EPROCESS structure

लाइसेंस

MIT