kunglao-agent

kunglao-agent एक स्वायत्त रिवर्स-इंजीनियरिंग प्रणाली है। आप इसे एक लक्ष्य और वे प्रश्न सौंपते हैं जिनके उत्तर आपको चाहिए; यह घंटों या दिनों तक अपने आप समस्या पर काम करता है — अपना रास्ता स्वयं योजना बनाता है, वर्कर की मृत्यु से उबरता है, क्रैश के बाद फिर से शुरू होता है — और तभी अभिसरित होता है जब हर उत्तर कच्चे साक्ष्य से व्युत्पन्न हो और यांत्रिक सत्यापन गेट्स से गुज़र जाए।

English · Simplified Chinese

यह वर्तमान में एक Claude Code प्लगइन के रूप में आता है — Claude Code वह इंटरफ़ेस है जिससे आप बात करते हैं, यह उत्पाद नहीं है। उत्पाद है लूप: विशेषज्ञ वर्कर विश्लेषण करते हैं (पहले स्टैटिक), एक स्वतंत्र सत्यापनकर्ता हर तथ्य को कच्चे साक्ष्य से ब्लाइंड रूप से पुनः व्युत्पन्न करता है, और यांत्रिक गेट्स तय करते हैं कि काम कब पूरा हुआ। डिलीवरेबल एक तथ्य आधार है जहाँ हर दावा बाइट-एंकर्ड, स्वतंत्र रूप से सत्यापित, और साक्ष्य-अनुक्रमित है — विश्वास मशीनरी द्वारा लागू किया जाता है, परंपरा द्वारा नहीं।

kunglao-agent क्यों

डिज़ाइन से लंबी-अवधि। एंगेजमेंट घंटों और दिनों तक बिना निगरानी के चलते हैं: एक निर्धारित हार्टबीट लूप को जीवित रखता है, मृत वर्करों का समाधान किया जाता है और उनके दावे पुनः कतार में डाले जाते हैं, क्रैश डिस्क पर मौजूद स्थिति से फिर से शुरू होते हैं, अवरुद्ध दावे स्वयं उबरते हैं। जब यह अभिसरित होता है तब आप निर्णय पढ़ते हैं — आप हर चरण की निगरानी नहीं करते। देखें Long-horizon autonomy।
उत्तर जिन पर आप भरोसा कर सकते हैं। कोई भी तथ्य PROVEN नहीं होता जब तक एक स्वतंत्र सत्यापनकर्ता इसे कच्चे आर्टिफैक्ट से ब्लाइंड रूप से पुनः व्युत्पन्न न कर ले; हर तथ्य evidence/_index.json के माध्यम से sha256-अनुक्रमित कच्चे आर्टिफैक्ट का हवाला देता है।
पूरा रिवर्स-इंजीनियरिंग स्पेक्ट्रम। Windows/Linux नेटिव बाइनरीज़, Android APKs, web/JS, प्रोटोकॉल विश्लेषण, फर्मवेयर एमुलेशन, जोखिम-नियंत्रण प्रति-उपाय — एक प्रणाली, एकल-डोमेन उपकरण नहीं।
स्टैटिक-प्रथम अर्थशास्त्र। जो कार्य स्टैटिक रूप से पूरा हो जाता है वह कभी डायनामिक टूलिंग को नहीं छूता; हर एस्केलेशन घोषित, गेटेड, और ऑडिटेड होता है।
यह ज्ञान को पुनः व्युत्पन्न करने के बजाय पुनः उपयोग करता है। पंजीकृत विश्लेषण उपकरणों की बढ़ती सूची (क्रिप्टो डिकोडर, डिसअसेम्बली पाइपलाइन, ग्राफ क्वेरीज़) का अर्थ है कि प्रणाली एक-बार के स्क्रिप्ट लिखने से पहले सिद्ध टूलिंग की ओर बढ़ती है — और हर रन पुनः प्रयोग योग्य तथ्य पीछे छोड़ता है, न कि एक चैट ट्रांसक्रिप्ट जो वाष्पित हो जाता है।
यह मरने के बजाय उबरता है। वर्कर की मृत्यु, API डिसकनेक्ट, और क्रैश प्रथम-श्रेणी की घटनाएँ हैं: लूप उन्हें पहचानता है, जो पहले से उत्पन्न हो चुका है उसका स्नैपशॉट लेता है, और जहाँ चीज़ें रुकी थीं वहीं से जारी रखने के लिए पुनः प्रेषित करता है — शून्य से नहीं।
आपका वातावरण, आपके नियम। VMware, ssh, docker, adb, या सादा स्टैटिक-केवल — प्रणाली वही निष्पादन चैनल चलाती है जो आपके पास पहले से है। कुछ भी अपक्षयित मोड नहीं है; जिस कार्य को कभी निष्पादन की आवश्यकता नहीं होती वह कभी VM नहीं माँगता।

त्वरित शुरुआत

kunglao-agent Claude Code के अंदर चलता है। डिस्क पर एक नमूने से एक निर्णय तक:

1. प्लगइन इंस्टॉल करें

किसी भी डायरेक्टरी से, Claude Code में:``` /plugin marketplace add amd2g2zz/kunglao-agent /plugin install kunglao-agent@kunglao-agent

(विकल्प: विकास के लिए `claude --plugin-dir /path/to/kunglao-agent`।)

### 2. एक वर्कस्पेस इनिशियलाइज़ करें```
/kunglao-agent:init ~/cases/synth-dropper --type windows

kunglao-init वर्कस्पेस को स्कैफ़ोल्ड करता है, CLAUDE.md लिखता है, आपके --type के लिए टूलचेन की जाँच करता है, और .mcp.json को स्कैफ़ोल्ड करता है। जब आपके प्रकार के लिए आवश्यक टूल अनुपस्थित होता है, तो यह HARD-reject करता है — समाधान मार्गदर्शन त्रुटि ब्लॉक में होता है।

3. कार्य बताएं और विश्लेषण शुरू करें```

/kunglao-agent:analysis ~/cases/synth-dropper

Goal: confirm this dropper's persistence mechanism and network endpoints; every conclusion must be reproducible from raw evidence. Verification: key findings count only if an independent verifier re-derives them blind and reaches the same answer. Constraints: static-first; never execute the sample on the host.

एक स्वतंत्र समीक्षक परिणाम का मूल्यांकन कर सके, इसके लिए ब्रीफ़ लिखें: **विश्लेषण लक्ष्य** (आपको क्या जानना है), **सत्यापन तर्क** (किस बात से उत्तर विश्वसनीय बनता है — जैसे "हस्ताक्षर समान इनपुट से पुनरुत्पादनीय होना चाहिए"), **बाधाएँ** (जैसे "होस्ट पर कोई निष्पादन नहीं")। सब कुछ `task_spec.yaml` में दर्ज होता है; वहाँ से लूप स्वयं चलता है। सामान्य अनुरोध कैसे सुगठित कथनों में बदलते हैं, यह देखने के लिए [कार्य को कैसे कथित करें](#how-to-state-the-task) देखें।

### 4. डिलीवरेबल पढ़ें```
claim-register.yaml   # every claim terminal, with verifier sign-off
facts/F<NNN>.md       # byte-anchored, reproducible, frontmatter contract
evidence/_index.json  # every fact → raw artifact (sha256 + path)
runs/                 # session audit trail

कार्य को कैसे निर्दिष्ट करें

लूप अपने पूर्णता मानदंड — oracle — को आपके द्वारा बताई गई अंत-स्थिति से यांत्रिक रूप से प्राप्त करता है। एक अस्पष्ट कथन अस्पष्ट oracle देता है, और विश्लेषण उस ओर बहक जाता है जो सिद्ध किया जा सकता है, उसकी ओर नहीं जिसकी आपको आवश्यकता थी। चार वाक्यांश इस बहाव के अधिकांश भाग को कवर करते हैं। प्रत्येक के लिए: उपयोगकर्ता क्या कहते हैं, इसका सामान्यतः क्या अर्थ होता है, एक सुगठित कथन, और oracle किस पर आधारित होता है।

"我要纯算" — "केवल शुद्ध एल्गोरिद्म"

सामान्यतः अर्थ: ऐप की साइनिंग/क्रिप्टो दिनचर्या का ऑफ़लाइन पुनरुत्पादन — एक unidbg harness या एक पुनर्लेखन जो रन टाइम पर किसी डिवाइस और किसी ऐप के बिना चलता है। "ऐप का विश्लेषण करें" नहीं; ऐप केवल वह जगह है जहाँ एल्गोरिद्म रहता है।```

Sample: the v7.2 APK; behavior: the signer producing the sign header on api.example.com/v2/* requests. Criterion: a standalone reproduction (unidbg or rewrite) replays every captured (input → sign) pair byte-exact — including the withheld pairs — with no device or app at run time. Attach: captures/sign-pairs.jsonl — 20 input/output pairs captured from a live session; 10 of them withheld from the analysis.

**Oracle anchors on:** हर जोड़ी पर byte-exact replay, जिनमें withheld वाले भी शामिल हैं — और reproduction standalone चल रहा है।

### "我要解密" — "I want decryption"

**आमतौर पर दो अलग-अलग लक्ष्यों में से एक का मतलब होता है — बताएं कौन सा:**

- **(a) एक captured body को decrypt करें** — इस data के बारे में एक बार का उत्तर: "इस captured cache file का plaintext निकालें।"
- **(b) एक decryption capability** — algorithm + key recovery, जो आप कल capture करने वाले data पर दोबारा इस्तेमाल कर सकें।

Well-formed (a):```
> Sample: the v7.2 APK; behavior: the local config cache
>   files/.cfg/v2.dat is encrypted at rest.
> Criterion: produce the plaintext of the captured v2.dat and validate
>   it against what the app renders (field names and values match the
>   screenshot captured alongside).

सुगठित (b):```

Sample: the v7.2 APK; behavior: request bodies on api.example.com/v2/* are encrypted with a static key. Criterion: identify the algorithm and the key, then run a canary round-trip — encrypt a known plaintext with the recovered key and match the ciphertext the device produced, byte for byte. Attach: captures/request-bodies.jsonl — ciphertext bodies captured from the device, with the requests that produced them.

**Oracle anchors on:** (a) ऐप जो रेंडर करता है उसके विरुद्ध plaintext का सत्यापन; (b) algorithm + key की पहचान और canary round-trip, डिवाइस द्वारा उत्पादित ciphertext के साथ byte-identical। "इसने एक बार decrypt कर दिया" इनमें से किसी को भी संतुष्ट नहीं करता।

### "帮我分析这个协议" — "मेरे लिए इस प्रोटोकॉल का विश्लेषण करें"

**आमतौर पर इसका मतलब है:** wire-format recovery — framing, field semantics, और एक codec जिसे आप चला सकें।```
> Sample: the Android chat app; behavior: the TCP protocol on
>   gateway.example.com:443, as captured in gateway-session.pcap.
> Criterion: a codec that round-trips every captured frame byte-exact,
>   and decodes the held-out frame to fields matching the observed app
>   behavior.
> Attach: captures/gateway-session.pcap — 40 frames, plus 1 held-out
>   frame kept out of the analysis.

Oracle का ध्यान केंद्रित: कोडेक द्वारा प्रत्येक कैप्चर किए गए फ़्रेम को बाइट-सटीक रूप से राउंड-ट्रिप करना, और होल्ड-आउट फ़्रेम का डिकोडिंग उन फ़ील्ड्स में होना जो देखे गए ऐप व्यवहार से मेल खाते हैं।

"这个 sign 在哪算的" — "यह sign कहाँ compute होता है?"

आमतौर पर इसका मतलब है: प्रमाण के साथ एक स्थान। कोड में किसी बिंदु का नाम बताना आसान है; उत्तर तभी उपयोगी होता है जब इस बात का प्रमाण हो कि यही बिंदु वह बिंदु है।```

Sample: the v7.2 APK; behavior: the sign header attached to every request. Criterion: name the class/method (or native function) where sign is computed, and hook that point to reproduce the captured sign values from the same inputs. Attach: captures/sign-session.jsonl — captured sign values with their request inputs.

**Oracle इन पर anchor करता है:** एक नामित class/method/native function, साथ ही उस बिंदु पर एक hook जो कैप्चर किए गए मानों को पुनः उत्पन्न करता है।

### इन सब में क्या समान है

- **नमूने और व्यवहार का नाम लें** — कौन सा parameter, entry, या flow — श्रेणी नहीं। "我要纯算" एक श्रेणी है; "api.example.com/v2/* पर `sign` header उत्पन्न करने वाला signer" एक लक्ष्य है।
- **सफलता डेटा होनी चाहिए।** कैप्चर किए गए input/output जोड़े संलग्न करें; रोके गए जोड़े ही जाँच को ईमानदार बनाते हैं — एक reproduction उस डेटा पर overfit नहीं कर सकता जो उसने कभी देखा ही नहीं।
- **Oracle आपके बताए गए अंत-स्थिति से व्युत्पन्न होता है।** अस्पष्ट कथन, अस्पष्ट सत्यापन, भटकता विश्लेषण।
- **बाधाएँ योजना बदल देती हैं।** केवल static? कोई device उपलब्ध? कौन सा channel? यह शुरू में ही बता दें — यह काम शुरू होने से पहले ही मार्ग तय कर देता है (देखें [Bring your own environment](#bring-your-own-environment))।

## Subcommands

| Command | कब उपयोग करें | यह क्या करता है |
|---|---|---|
| `/kunglao-agent:init <workspace> [--type windows\|linux\|android\|web\|macos] [--lane malware\|algorithm\|protocol\|web\|data\|app]` | engagement शुरू करते समय, सबसे पहले | workspace को scaffold करता है, type के लिए toolchain की जाँच करता है, `CLAUDE.md` और `.mcp.json` लिखता है; आवश्यक tool अनुपस्थित होने पर fix guidance के साथ HARD-reject करता है |
| `/kunglao-agent:analysis <workspace>` (alias `analyze`) | init के बाद — कार्य बताएं और शुरू करें | आपका goal / verification logic / constraints एक बार एकत्र करता है, फिर convergence loop चलाता है: report तक dispatch / verify चक्र |
| `/kunglao-agent:resume <workspace>` | crash, reboot, या किसी भी "मैं कहाँ था?" के बाद | read-only breakpoint brief (health, open claims, in-flight workers, crash timeline) साथ ही state machine से अगली क्रिया |
| `/kunglao-agent:upgrade <workspace> [--dry-run]` | plugin update के बाद, पुराने workspace पर (या जब upgrade prompt कहे कि stamp पीछे है) | workspace scaffold (hooks, templates, event vocab) को वर्तमान plugin version में migrate करता है; `--dry-run` पूर्वावलोकन करता है; user data (claims, facts, evidence) को कभी नहीं छुआ जाता — byte drift RC=4 के साथ मना कर देता है |
| `/kunglao-agent:help` | कुछ और | usage सूची प्रिंट करता है |

सामान्य क्रम: `init` workspace बनाता है → `analysis` कार्य बताता है और शुरू करता है → (कुछ भी गड़बड़ होने पर `resume`) → convergence पर report पढ़ें → plugin updates के बाद पुराने workspaces पर `upgrade`।

## एक run कैसा दिखता है

*एक engagement का स्वरूप — आप क्या टाइप करते हैं, क्या वापस आता है, कहाँ देखना है।* एक synthetic उदाहरण: एक छोटा Windows dropper `~/cases/synth-dropper` में आता है:```bash
/kunglao-agent:init ~/cases/synth-dropper --type windows   # probes Ghidra, VM reachability
/kunglao-agent:analysis ~/cases/synth-dropper
> "What does this binary do, and where does it phone home?"

वहाँ से लूप स्वयं चलता है — मार्ग इस बात के अनुसार अनुकूलित होता है कि नमूना क्या निकलता है। आप हट सकते हैं (देखें Long-horizon autonomy)। जब यह अभिसरित होता है, तो नीचे दिए गए डिलीवरेबल को पढ़ें।

परिदृश्य

दो और एंड-टू-एंड पथ — अपने लक्ष्य से मेल खाने वाला चुनें (सादे Windows PE / Linux ELF बाइनरी के लिए, ऊपर दिया गया कार्यशील उदाहरण ही पथ है)।

Android APK — उपयोगकर्ता क्या टाइप करता है, क्या कहाँ पहुँचता है

```bash /kunglao-agent:init ~/cases/sample.apk --type android /kunglao-agent:analysis ~/cases/sample.apk > "Does this APK load code dynamically or fight debugging? If so, where is > the hidden logic and what does it do?" ``` - **कहाँ पहुँचता है:** `bins/` (APK), `facts/` (क्लास ग्राफ़, नेटिव `.so` इन्वेंटरी), `evidence/` (कैप्चर, डंप)। - **पूर्ण दिखता है:** हर प्रश्न पुनरुत्पादनीय साक्ष्य द्वारा समर्थित। - **मार्ग अनुकूलित होता है।** कुछ APK शुद्ध स्टैटिक DEX कार्य से बंद हो जाते हैं; अन्य को ऑन-डिवाइस डिबगिंग की आवश्यकता होती है — लूप यह तय करता है कि नमूना वास्तव में क्या है।

Web / JS — अनपैक → डीऑब्फस्केट → साइन्ड-पैरामीटर रीप्ले

```bash /kunglao-agent:init ~/cases/example-site.com --type web /kunglao-agent:analysis ~/cases/example-site.com > "how is the XHR request signed, and where does the nonce come from?" ``` - **Lands in:** `evidence/` (captures, deobfuscated code), `facts/` (signing key, nonce derivation). - **Note:** `web` एक beta-चरण का लक्ष्य है — toolchain bar जानबूझकर हल्का रखा गया है; जब loop को वास्तव में आवश्यकता होगी तब अनुपलब्ध क्षमता सामने आएगी, init पर नहीं।

आपको क्या मिलता है

एक claim register और fact base जहाँ भरोसा यांत्रिक है, पारंपरिक नहीं:

Verified convergence — PROVEN के लिए एक स्वतंत्र blind verifier का exact-match sign-off आवश्यक है; CONVERGED के लिए हर primary question का byte-proof के साथ उत्तर, शून्य orphan claims, कोई spinning नहीं।
Evidence integrity — हर fact evidence/_index.json के माध्यम से एक raw artifact (capture / trace / dump / binary) तक trace होता है। Derived summaries को design द्वारा बाहर रखा गया है।
Maker-checker — worker (maker) facts लिखता है; redteam verifier (checker) उन्हें blind re-derive करता है। हमेशा अलग agents।

कोई भी claim अपने लेखक के कहे पर PROVEN तक नहीं पहुँचता: एक स्वतंत्र verifier को इसे blind re-derive करना होगा, और कई mechanical gates को पास करना होगा। पूरा gate design docs/design/loop-engineering.md में है।

run के बाद, files अलग-अलग प्रश्नों का उत्तर देती हैं:

उदाहरण fact:```yaml id: F061 status: VERIFIED-BY-W01-static-byte-recheck claim_id: C-401 provenance:

{role: sample, path: bins/}
{role: capture_log, path: runs/c329-inner-pe.bin} # via evidence/_index.json reproduce: python -c "import struct; ..." # runs against the cited artifact verifier_sign_off: {verifier: kunglao-redteam, verdict: CONFIRMED}

## लॉन्ग-होराइज़न ऑटोनॉमी

वास्तविक एंगेजमेंट बीस मिनट की चैट नहीं होती। kunglao-agent हर कदम पर किसी इंसान के मार्गदर्शन के बिना समस्या पर टिका रहता है:

- **घंटों या दिनों तक, बिना निगरानी के चलता है** — एक शेड्यूल्ड हार्टबीट आपकी विज़िट के बीच लूप को काम करता रखता है, और एक अटका हुआ लूप चुपचाप मरने के बजाय फ़्लैग किया जाता है।
- **विफलता से उबरता है** — मृत या अटके हुए वर्कर बदले जाते हैं और उनके प्रश्न फिर से कतार में डाले जाते हैं; अवरुद्ध काम बेकार पड़े रहने के बजाय स्वयं उबर जाता है।
- **क्रैश और रीबूट से बच निकलता है** — `/kunglao-agent:resume <workspace>` डिस्क पर मौजूद स्थिति से चीज़ें जहाँ थीं वहाँ पुनर्निर्मित करता है और अगली कार्रवाई का नाम बताता है।
- **चैट में नहीं, डिस्क पर याद रखता है** — दावे, तथ्य, साक्ष्य, और एक पूरा ऑडिट ट्रेल वर्कस्पेस में रहते हैं, ताकि कोई भी सत्र एंगेजमेंट को फिर से उठा सके।

आप इसे एक लक्ष्य और प्रश्न देते हैं; यह घंटों या दिनों तक समस्या पर काम करता है, विफलताओं से उबरता है, और जब यह अभिसरित होता है तो आप निर्णय पढ़ते हैं।

## अच्छे परिणाम प्राप्त करना

- **इसे स्टैटिक-सुलभ लक्ष्य खिलाएँ।** लूप स्टैटिक-फर्स्ट है: एक अनपैक्ड APK, एक अनऑबफस्केटेड बंडल, या एक अनस्ट्रिप्ड बाइनरी उससे कहीं तेज़ी से अभिसरित होती है जो डायनामिक काम को बाध्य करती है।
- **डायनामिक लेग को ज़रूरत से पहले सेट करें।** यदि आपके प्राथमिक प्रश्नों को निष्पादन की आवश्यकता होगी, तो पहले एक चैनल चुनें (देखें [अपना वातावरण लाएँ](#bring-your-own-environment)) — init `local` पर एक डायनामिक कार्य को HARD-अस्वीकार करता है।
- **"काम कर रहा" को "अटका हुआ" से अलग पहचानना** — `runs/` में नई प्रविष्टियाँ मतलब लूप जीवित है; एक मृत हार्टबीट या बिना किसी नए तथ्य के वही निर्णय दोहराया जाना मतलब यह नहीं है — `/kunglao-agent:resume <workspace>` निदान करता है और अगली चाल का नाम बताता है।

## लक्ष्य के अनुसार टूलचेन

init पर आप जो `--type` चुनते हैं वह तय करता है कि कौन से HARD-टियर टूल इंस्टॉल होने चाहिए। मार्गदर्शन संकुचित है — अपना लक्ष्य विस्तृत करें। **सभी प्रकारों को दो MCP सर्वर चाहिए:** `ghidra` (`claude mcp add ghidra -- <path>/bridge-mcp-ghidra.exe`) और `sequential-thinking` (`claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking`)।

<details>
<summary><strong>windows (PE32+ x86-64)</strong> — नेटिव Windows बाइनरीज़</summary>

| Tier | Tool | Install |
|---|---|---|
| HARD | `pefile` (Python) | `pip install pefile` |
| HARD | `die` (Detect It Easy) | `KUNGLAO_DIE` env या PATH पर — [ntinfo.com](https://ntinfo.com) |
| HARD | `floss` (FLARE FLOSS) | [flare-floss docs](https://github.com/mandiant/flare-floss) के अनुसार |
| HARD | Ghidra या IDA | इनमें से एक; देखें [Internals](#internals) |
| HARD (T2/T3) | VMware + vmr-shell, या एक ssh/docker चैनल | देखें [अपना वातावरण लाएँ](#bring-your-own-environment) |
| HARD (T2/T3) | `frida-server` (नाम बदला हुआ, कस्टम पोर्ट) | डिवाइस/VM-साइड बाइनरी, डिफ़ॉल्ट पोर्ट 1337 |

Windows T3 डायनामिक `x64dbg` MCP का भी उपयोग करता है; `volatility` (मेमोरी फ़ोरेंसिक्स) और IDA-Pro MCP वैकल्पिक हैं — देखें [Internals](#internals) के अंतर्गत MCP मैनिफ़ेस्ट।

</details>

<details>
<summary><strong>linux (ELF)</strong> — नेटिव Linux बाइनरीज़ / फ़र्मवेयर / मेमोरी इमेज</summary>

| Tier | Tool | Install |
|---|---|---|
| HARD | `file`, `readelf`, `objdump` | `binutils` पैकेज |
| HARD | Ghidra या IDA | इनमें से एक |
| HARD (T2/T3) | VMware + vmr-shell, या एक ssh/docker कंट्रोल प्लेन | देखें [अपना वातावरण लाएँ](#bring-your-own-environment) |
| HARD (T2/T3) | `frida-server` (नाम बदला हुआ, कस्टम पोर्ट) | डिवाइस-साइड बाइनरी, पोर्ट 1337 |
| WARN | `gdbserver` (होस्ट-साइड PATH), `strace`, `ltrace` | वैकल्पिक अतिरिक्त |

`ssh-mcp` रिमोट / क्लाउड / docker होस्ट के लिए ssh कंट्रोल प्लेन सक्षम करता है।

</details>

<details>
<summary><strong>android (APK / DEX / native .so)</strong> — सबसे कठिन लक्ष्य प्रकार, सबसे अधिक HARD आइटम</summary>

| Tier | Tool | Install |
|---|---|---|
| HARD | `aapt` या `aapt2` (या `unzip` फ़ॉलबैक) | Android SDK build-tools |
| HARD | `jadx` (DEX → Java डीकंपाइलर) | [skylot/jadx](https://github.com/skylot/jadx) |
| HARD | `apktool` (APK रिसोर्स डिकोड/रीबिल्ड) | [iBotPeaches/Apktool](https://github.com/iBotPeaches/Apktool) |
| HARD | `gitnexus` (पोस्ट-डीकंपाइल ग्राफ़) | `npm i -g gitnexus` |
| HARD | Ghidra या IDA | केवल तभी जब APK में नेटिव `.so` हो |
| HARD | `adb` + **एक रूटेड डिवाइस** जिसमें `ro.debuggable=1` हो | platform-tools + डिवाइस पर कस्टम frida |
| HARD | `frida-server` (नाम बदला हुआ, कस्टम पोर्ट 1337) | डिवाइस-साइड बाइनरी |
| HARD | `android_server` (IDA रिमोट डीबगिंग) | डिवाइस-साइड बाइनरी, पोर्ट 23946 |
| WARN | `apkid` | `pip install apkid` |
| WARN | `baksmali` | [smali releases](https://github.com/baksmali/smali/releases) से |

</details>

<details>
<summary><strong>web &amp; macos (beta)</strong> — न्यूनतम टूलचेन, डिज़ाइन से कोई HARD आइटम नहीं</summary>

| Tier | Tool | Install |
|---|---|---|
| WARN | `camoufox-reverse` MCP (web) | हुक / ट्रेस / नेटवर्क कैप्चर के लिए एंटी-डिटेक्ट Firefox |
| WARN | `docker` (web चैनल डिफ़ॉल्ट) | Docker Desktop, या स्पष्ट रूप से `KUNGLAO_CHANNEL=ssh` सेट करें |
| WARN | `lipo`, `otool`, `nm`, `codesign`, `xattr` (macOS) | Xcode Command Line Tools |
| WARN | `ghidra` MCP (macOS) | अनुशंसित — देखें [Internals](#internals) के अंतर्गत मैनिफ़ेस्ट |

दोनों बीटा-चरण के लक्ष्य हैं: अनुपलब्ध क्षमता तब सामने आती है जब लूप को वास्तव में इसकी आवश्यकता होती है, init पर नहीं। macOS डायनामिक काम `ssh` चैनल का उपयोग करता है (एक Mac होस्ट के लिए); वैकल्पिक x64dbg ब्राउज़र-डीबग पथ के लिए, ऊपर दिया गया Windows टूलचेन इंस्टॉल करें।

</details>

ऊपर सब कुछ के लिए एकल मैनिफ़ेस्ट स्रोत — इसे कभी भी प्रोब करें: `python scripts/mcp_probe.py <ws> --type <windows|linux|android|web|macos>` (exit 1 = HARD अनुपलब्ध)।

## अपना वातावरण लाएँ

डायनामिक डीबगिंग के लिए एक निष्पादन कंट्रोल प्लेन चाहिए जिसे एजेंट चला सके। `KUNGLAO_CHANNEL` पाँच फ़र्स्ट-क्लास चैनलों में से एक चुनता है — जो आपके वातावरण में पहले से है उसका उपयोग करें; कोई भी अपमानित मोड नहीं है:

| Channel | What it drives | Prerequisites |
|---|---|---|
| `vmr` (डिफ़ॉल्ट) | VMware VM, **कोई भी गेस्ट OS** — स्नैपशॉट/रिवर्ट वर्कफ़्लो इसका अपूरणीय मूल्य है | vmr-shell स्किल; `KUNGLAO_VM_HOST` + पोर्ट 9876/1337 |
| `ssh` | कोई भी ssh-सुलभ बॉक्स: बेयर मेटल, क्लाउड VM, Mac, रिमोट docker होस्ट | key auth — प्रोब एक वास्तविक BatchMode `ssh ... true` चलाता है |
| `docker` | लोकल या रिमोट docker डेमन — `docker exec` किसी भी कंट्रोल पथ के समतुल्य है | `docker version` हरा; वैकल्पिक `KUNGLAO_DOCKER_CONTAINER` |
| `adb` | Android एमुलेटर या वास्तविक डिवाइस | `adb devices` इसे दिखाता है; frida के लिए `adb forward tcp:1337 tcp:1337` |
| `local` | **होस्ट पर स्टैटिक-केवल विश्लेषण** | कोई नहीं — रेड लाइन देखें |

> **`local` रेड लाइन:** local केवल **स्टैटिक** काम के लिए है — होस्ट पर सैंपल को कभी निष्पादित, डीबग, या इंजेक्ट न करें। कोई भी डायनामिक आवश्यकता `KUNGLAO_CHANNEL` को `vmr`/`ssh`/`docker`/`adb` पर स्विच करती है; init `local` पर एक डायनामिक कार्य को HARD-अस्वीकार करता है।

चैनल प्रोब केवल डायनामिक कार्यों के लिए चलते हैं (स्टैटिक-केवल कार्य उन्हें छोड़ देते हैं)। `ssh`-चैनल निष्पादन **ssh-mcp** कंट्रोल प्लेन के माध्यम से प्रवाहित होता है (`npm i -g ssh-mcp`); सादा CLI ssh फ़ॉलबैक है। ssh पर रिमोट docker के लिए, `KUNGLAO_DOCKER_CONTAINER` सेट करें।

## कॉन्फ़िगरेशन

चार वेरिएबल अधिकांश सेटअपों को कवर करते हैं:

| Variable | Default | Meaning |
|---|---|---|
| `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` | unset | unset या `0` रहना चाहिए — truthy मान डिस्पैच को टीममेट चैनल के माध्यम से रूट करते हैं और अस्वीकार किए जाते हैं |
| `KUNGLAO_CHANNEL` | `vmr` | डायनामिक निष्पादन कंट्रोल प्लेन: `vmr` \| `ssh` \| `docker` \| `adb` \| `local` — देखें [अपना वातावरण लाएँ](#bring-your-own-environment) |
| `KUNGLAO_VM_HOST` | unset | डायनामिक विश्लेषण के लिए VM/होस्ट (vmr-shell :9876, Frida :1337) |
| `GHIDRA_HOME` | unset | Ghidra इंस्टॉल रूट (इसमें `support/analyzeHeadless.bat` होना चाहिए) |

शायद ही आवश्यक: `KUNGLAO_DOCKER_CONTAINER` (`ssh`/`docker` चैनलों के लिए docker निष्पादन लक्ष्य), `KUNGLAO_FRIDA_PORT` (डिफ़ॉल्ट 1337), `KUNGLAO_DIE` (DIE पथ, PATH पर फ़ॉलबैक), `KUNGLAO_CLAUDE_JSON` (यूज़र-लेवल MCP रजिस्ट्री के लिए टेस्ट ओवरराइड)।

## सुरक्षा

- सैंपल होस्ट पर कभी निष्पादित नहीं होते — `block_malware_exec` हुक इसे लागू करता है; डायनामिक काम VM/कंटेनर/डिवाइस-केवल चलता है और प्रति-सत्र प्राधिकरण की आवश्यकता होती है।
- ग्राउंड ट्रुथ पदानुक्रम: कच्चा आर्टिफ़ैक्ट > लोकल टूल > सैंडबॉक्स > थ्रेट इंटेल (CTI एक मिथ्यापनीय परिकल्पना है, कभी सत्य नहीं)।
- मेकर-चेकर: एक वर्कर कभी स्वयं सत्यापन नहीं करता; एक वेरिफ़ायर कभी मेकर के निष्कर्ष को नहीं पढ़ता।
- Bins, सेटिंग्स, और हुक कभी कमिट नहीं किए जाते; सीक्रेट्स को वर्कस्पेस और रेपो से बाहर रखा जाता है।

## डेवलपमेंट

योगदान का स्वागत है। वर्कफ़्लो: `dev` से ब्रांच करें, प्रति परिवर्तन एक ब्रांच, PR वापस `dev` पर।```bash
git worktree add .worktrees/<name> -b <name> dev
uv sync --locked
uv run python -m pytest -q
gh pr create --base dev

पूर्ण-सूट प्रविष्टि python -m pytest -q है (देखें .github/workflows/release-check.yml)।

डिज़ाइन दस्तावेज़ीकरण docs/ और specs/ में है। देखें License।

आंतरिक संरचना

MCP आपूर्ति (पूर्ण मैनिफ़ेस्ट)

एकल सत्य स्रोत: scripts/mcp_probe.py; kunglao-init कार्यक्षेत्र .mcp.json को अनुपस्थित होने पर स्कैफ़ोल्ड करता है (--no-mcp छोड़ देता है; मौजूदा फ़ाइल को कभी अधिलेखित नहीं किया जाता)। प्रोब: python scripts/mcp_probe.py <ws> --type <windows|linux|android|web|macos> — exit 1 = HARD अनुपस्थित, 2 = केवल WARN अनुपस्थित।

कार्यक्षेत्र लेआउट

प्रति नमूना एंगेजमेंट एक कार्यक्षेत्र:``` / ├── bins/ # the sample (gitignored) ├── task_spec.yaml # primary_questions / scope / constraints / success_criteria ├── claim-register.yaml # claims C-NN with status (OPEN/PROVEN/STAMP/...) ├── claim_deps.yaml # claim DAG ├── facts/ # byte-anchored facts F-NNN.md + _INDEX.md ├── evidence/ # raw artifacts + _index.json (eid → path + sha256) ├── runs/ # worker-status, plans, ledgers, .heartbeat.json ├── blockers/ # failure-attribution records per claim └── CLAUDE.md # workspace rules, generated by kunglao-init

kunglao hooks वर्कस्पेस स्तर पर वायर किए गए हैं; आपकी ग्लोबल `~/.claude/settings.json` कभी नहीं लिखी जाती।

</details>

---

## लाइसेंस

दोहरा-लाइसेंस प्राप्त: व्यक्तिगत, शैक्षणिक, और आंतरिक उपयोग के लिए **AGPL-3.0** (मुफ़्त — देखें [LICENSE](https://github.com/amd2g2zz/kunglao-agent/blob/master/LICENSE)); क्लोज़्ड-सोर्स या SaaS व्यावसायिक उपयोग के लिए एक **व्यावसायिक लाइसेंस** आवश्यक है — देखें [LICENSE-commercial.md](https://github.com/amd2g2zz/kunglao-agent/blob/master/LICENSE-commercial.md)।

Claude Code	जहाँ kunglao-agent चलता है	Anthropic दस्तावेज़ों के अनुसार
Python 3.10+ (Python 2 समर्थित नहीं है)	प्लगइन `uv` के माध्यम से एक पिन किया हुआ env रखता है; आप इसे नहीं छूते	सिस्टम या `uv`-प्रबंधित
`uv`	लॉक्ड env रिज़ॉल्वर	`pip install uv` या astral.sh/uv
Ghidra or IDA	डीकंपाइलेशन के लिए एक स्टैटिक-विश्लेषण सूट	देखें Toolchain by target

क्या यह हो गया?	loop का exit code — `CONVERGED` (0) का अर्थ है हर primary question का verified उत्तर है; per-claim status `claim-register.yaml` में
इसने क्या पाया?	`facts/F<NNN>.md` — प्रति file एक byte-anchored fact, जो `claim-register.yaml` द्वारा claims से mapped है
मैं इसे कैसे reproduce करूँ?	`evidence/_index.json` — fact → raw artifact (path + sha256); प्रत्येक fact में एक `reproduce:` command होता है
वास्तव में क्या हुआ?	`runs/` — tick-by-tick ledger और worker status

`ghidra`	HARD	आवश्यक, सभी प्रकार	डीकंपाइलेशन / स्टैटिक विश्लेषण	`claude mcp add ghidra -- <path>/bridge-mcp-ghidra.exe`
`sequential-thinking`	HARD	आवश्यक, सभी प्रकार	संरचित तर्क	`claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking`
`x64dbg`	HARD	Windows T3 डायनामिक	डायनामिक डीबगिंग (VM रिमोट)	`claude mcp add x64dbg -- x64dbg-automate-mcp`
`volatility`	WARN	Windows T3	मेमोरी फ़ोरेंसिक्स	`claude mcp add volatility -- python <path>/volatility_mcp_server.py`
`ida-pro-vm`	WARN	जब IDA चुना जाए	रिमोट IDA विश्लेषण	`claude mcp add --transport http ida-pro-vm <ida-mcp-url>`
`gitnexus`	HARD	Android ग्राफ़ निर्माण	पोस्ट-डीकंपाइल नॉलेज ग्राफ़	`claude mcp add gitnexus -- gitnexus mcp`
`virustotal`	WARN	CTI	थ्रेट इंटेल (फ़ैमिली-एट्रिब्यूशन परिकल्पनाएँ)	`claude mcp add virustotal -- npx -y @burtthecoder/mcp-virustotal`
`ssh-mcp`	WARN	चैनल	ssh निष्पादन नियंत्रण प्लेन	`claude mcp add ssh-mcp -- ssh-mcp`
`camoufox-reverse`	WARN	वेब (बीटा)	ब्राउज़र JS रिवर्सिंग (हुक / ट्रेस / नेटवर्क कैप्चर)	`claude mcp add camoufox-reverse -- python -m camoufox_reverse_mcp`

सबसे लोकप्रिय

kunglao-agent

kunglao-agent

kunglao-agent क्यों

त्वरित शुरुआत

1. प्लगइन इंस्टॉल करें

3. कार्य बताएं और विश्लेषण शुरू करें```

कार्य को कैसे निर्दिष्ट करें

"我要纯算" — "केवल शुद्ध एल्गोरिद्म"

"这个 sign 在哪算的" — "यह sign कहाँ compute होता है?"

परिदृश्य

आपको क्या मिलता है

आंतरिक संरचना