kunglao-agent

kunglao-agent ist ein autonomes Reverse-Engineering-System. Man übergibt ihm ein Ziel und die Fragen, die beantwortet werden müssen; es arbeitet stunden- oder tagelang eigenständig an dem Problem — plant seinen eigenen Weg, erholt sich von Worker-Ausfällen, setzt nach Abstürzen fort — und konvergiert erst, wenn jede Antwort aus Rohdaten abgeleitet wurde und mechanische Verifikationsgates übersteht.

English · Simplified Chinese

Es wird derzeit als Claude Code Plugin ausgeliefert — Claude Code ist die Schnittstelle, mit der man spricht, nicht das Produkt selbst. Das Produkt ist die Schleife: spezialisierte Worker analysieren (zuerst statisch), ein unabhängiger Verifier leitet jeden Fakt blind aus den Rohdaten neu ab, und mechanische Gates entscheiden, wann die Arbeit abgeschlossen ist. Das Ergebnis ist eine Faktbasis, in der jede Behauptung byte-verankert, unabhängig verifiziert und evidenzindiziert ist — Vertrauen wird durch Mechanismen erzwungen, nicht durch Konvention.

Warum kunglao-agent

Langhorizontig by design. Engagements laufen unbeaufsichtigt über Stunden und Tage: ein geplanter Heartbeat hält die Schleife am Leben, tote Worker werden abgeglichen und ihre Behauptungen neu in die Warteschlange gestellt, Abstürze setzen aus dem Zustand auf der Festplatte fort, blockierte Behauptungen erholen sich selbst. Man liest das Urteil, wenn es konvergiert — man babysittet nicht jeden Schritt. Siehe Long-horizon autonomy.
Antworten, denen man vertrauen kann. Kein Fakt ist PROVEN, bis ein unabhängiger Verifier ihn blind aus dem Rohartefakt neu ableitet; jeder Fakt zitiert ein sha256-indiziertes Rohartefakt über evidence/_index.json.
Das volle Reverse-Engineering-Spektrum. Windows/Linux-native Binärdateien, Android APKs, Web/JS, Protokollanalyse, Firmware-Emulation, Risikokontroll-Gegenmaßnahmen — ein System, kein Single-Domain-Tool.
Static-first-Ökonomie. Eine Aufgabe, die statisch abgeschlossen wird, berührt nie dynamische Tooling; jede Eskalation wird deklariert, gegated und auditiert.
Es verwendet Wissen wieder, statt es neu abzuleiten. Ein wachsender Katalog registrierter Analysetools (Krypto-Decoder, Disassembly-Pipelines, Graph-Abfragen) bedeutet, dass das System nach bewährtem Tooling greift, bevor es Einmal-Skripte schreibt — und jeder Lauf hinterlässt wiederverwendbare Fakten, nicht ein Chat-Transkript, das verdampft.
Es erholt sich, statt zu sterben. Worker-Ausfälle, API-Verbindungsabbrüche und Abstürze sind erstklassige Ereignisse: die Schleife erkennt sie, erstellt Snapshots des bereits Produzierten und verteilt neu, um dort fortzufahren, wo es aufgehört hat — nicht bei null.
Deine Umgebung, deine Regeln. VMware, ssh, docker, adb oder rein statisch — das System steuert den Ausführungskanal, den man bereits hat. Nichts ist ein degradierter Modus; eine Aufgabe, die nie Ausführung benötigt, fragt nie nach einer VM.

Schnellstart

kunglao-agent läuft innerhalb von Claude Code. Von einem Sample auf der Festplatte bis zum Urteil:

1. Plugin installieren

Aus einem beliebigen Verzeichnis, in Claude Code:``` /plugin marketplace add amd2g2zz/kunglao-agent /plugin install kunglao-agent@kunglao-agent

(Alternative: `claude --plugin-dir /path/to/kunglao-agent` zur Entwicklung.)

### 2. Einen Workspace initialisieren```
/kunglao-agent:init ~/cases/synth-dropper --type windows

kunglao-init richtet den Workspace ein, schreibt CLAUDE.md, prüft die Toolchain für deinen --type und erstellt .mcp.json. Es lehnt HART ab, wenn ein erforderliches Tool für deinen Typ fehlt — die Hinweise zur Behebung stehen im Fehlerblock.

3. Aufgabe benennen und Analyse starten```

/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.

Formuliere den Auftrag so, dass ein unabhängiger Prüfer das Ergebnis beurteilen kann: **Analyseziel** (was du wissen musst), **Verifikationslogik** (was eine Antwort vertrauenswürdig macht — z. B. „die Signatur muss aus denselben Eingaben reproduzierbar sein"), **Einschränkungen** (z. B. „keine Ausführung auf dem Host"). Alles wird in `task_spec.yaml` festgehalten; von dort aus treibt sich die Schleife selbst an. Wie die üblichen Anforderungen in wohlgeformte Aussagen überführt werden, siehe [How to state the task](#how-to-state-the-task).

### 4. Read the deliverable```
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

Wie die Aufgabe formuliert wird

Die Schleife leitet ihr Abbruchkriterium — das Orakel — mechanisch aus dem von dir angegebenen Endzustand ab. Eine vage Formulierung ergibt ein vages Orakel, und die Analyse driftet zu dem hin, was sich beweisen lässt, statt zu dem, was du benötigt hast. Vier Formulierungen decken den Großteil dieser Drift ab. Für jede: was Nutzer sagen, was es üblicherweise bedeutet, eine wohlgeformte Angabe und worauf das Orakel sich stützt.

„我要纯算" — „nur der reine Algorithmus"

Bedeutet üblicherweise: Offline-Reproduktion der Signierungs-/Krypto-Routine der App — ein unidbg-Harness oder eine Neuimplementierung, die zur Laufzeit ohne Gerät und ohne App läuft. Nicht „die App analysieren"; die App ist nur der Ort, an dem der Algorithmus lebt.```

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-Anker:** byte-genaue Wiedergabe bei jedem Paar, einschließlich der zurückgehaltenen — und die Reproduktion, die eigenständig läuft.

### "我要解密" — "Ich möchte entschlüsseln"

**Bedeutet normalerweise eines von zwei verschiedenen Zielen — sag welches:**

- **(a) einen erfassten Body entschlüsseln** — eine einmalige Antwort zu diesen Daten: "den Klartext dieser erfassten Cache-Datei erzeugen."
- **(b) eine Entschlüsselungsfähigkeit** — Algorithmus + Schlüsselwiederherstellung, wiederverwendbar auf Daten, die du morgen erfasst.

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

Wohlgeformt (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-Anker:** (a) der Klartext validiert gegen das, was die App rendert; (b) Algorithmus + Schlüssel identifiziert und der Canary-Roundtrip byte-identisch zum vom Gerät erzeugten Chiffretext. „Es hat einmal entschlüsselt" erfüllt keines von beiden.

### „帮我分析这个协议" — „analysiere dieses Protokoll für mich"

**Bedeutet normalerweise:** Wire-Format-Wiederherstellung — Framing, Feldsemantik und ein Codec, den man ausführen kann.```
> 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-Anker: Der Codec muss jeden erfassten Frame byte-genau round-trippen, und der zurückgehaltene Frame muss zu Feldern dekodieren, die dem beobachteten App-Verhalten entsprechen.

"这个 sign 在哪算的" — "Wo wird dieses Vorzeichen berechnet?"

Bedeutet normalerweise: eine Stelle mit Beweis. Einen Punkt im Code zu benennen ist billig; die Antwort ist nur nützlich mit dem Nachweis, dass dieser Punkt der Punkt ist.```

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-Anker:** eine benannte Klasse/Methode/native Funktion, plus ein Hook an diesem Punkt, der die erfassten Werte reproduziert.

### Was diese gemeinsam haben

- **Benenne die Probe und das Verhalten** — welcher Parameter, Einstiegspunkt oder Ablauf — nicht die Kategorie. „我要纯算" ist eine Kategorie; „der Signer, der den `sign`-Header auf api.example.com/v2/* erzeugt" ist ein Ziel.
- **Erfolg muss durch Daten belegt sein.** Hänge erfasste Eingabe-/Ausgabepaare an; die zurückgehaltenen Paare sind es, die die Prüfung ehrlich machen — eine Reproduktion kann sich nicht an Daten überanpassen, die sie nie gesehen hat.
- **Das Oracle leitet sich aus deinem angegebenen Endzustand ab.** Vage Aussage, vage Verifikation, driftende Analyse.
- **Einschränkungen ändern den Plan.** Nur statisch? Ein Gerät verfügbar? Welcher Kanal? Sag es von Anfang an — es entscheidet die Route, bevor die Arbeit beginnt (siehe [Bring your own environment](#bring-your-own-environment)).

## Subcommands

| Befehl | Verwenden, wenn | Was er tut |
|---|---|---|
| `/kunglao-agent:init <workspace> [--type windows\|linux\|android\|web\|macos] [--lane malware\|algorithm\|protocol\|web\|data\|app]` | beim Start eines Engagements, zuerst | erstellt das Workspace-Gerüst, prüft die Toolchain für den Typ, schreibt `CLAUDE.md` und `.mcp.json`; lehnt HART mit Korrekturhinweisen ab, wenn ein erforderliches Tool fehlt |
| `/kunglao-agent:analysis <workspace>` (Alias `analyze`) | nach init — Aufgabe angeben und starten | erfasst dein Ziel / deine Verifikationslogik / Einschränkungen einmalig und führt dann die Konvergenzschleife aus: Dispatch-/Verify-Zyklen bis zum Bericht |
| `/kunglao-agent:resume <workspace>` | nach einem Absturz, Neustart oder jedem „Wo war ich?" | schreibgeschützte Breakpoint-Übersicht (Zustand, offene Claims, laufende Worker, Crash-Timeline) plus die nächste Aktion aus der Zustandsmaschine |
| `/kunglao-agent:upgrade <workspace> [--dry-run]` | nach einem Plugin-Update, bei einem älteren Workspace (oder wenn die Upgrade-Aufforderung meldet, dass der Stamp veraltet ist) | migriert das Workspace-Gerüst (Hooks, Templates, Event-Vokabular) auf die aktuelle Plugin-Version; `--dry-run` zeigt eine Vorschau; Benutzerdaten (Claims, Fakten, Evidenz) werden nie berührt — Byte-Drift verweigert mit RC=4 |
| `/kunglao-agent:help` | alles andere | gibt die Nutzungsliste aus |

Typische Reihenfolge: `init` erstellt den Workspace → `analysis` gibt die Aufgabe an und startet → (`resume`, falls etwas schiefgeht) → Bericht bei Konvergenz lesen → `upgrade` alte Workspaces nach Plugin-Updates.

## Wie ein Durchlauf aussieht

*Die Form eines Engagements — was du eingibst, was zurückkommt, wo du nachschaust.* Ein synthetisches Beispiel: Ein kleiner Windows-Dropper landet in `~/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?"

Von dort läuft die Schleife von selbst — die Route passt sich an das an, was die Probe tatsächlich ist. Du kannst weggehen (siehe Long-horizon autonomy). Wenn sie konvergiert, lies das unten stehende Ergebnis.

Szenarien

Zwei weitere End-to-End-Pfade — wähle den, der zu deinem Ziel passt (für eine einfache Windows-PE-/Linux-ELF-Binärdatei ist der oben ausgearbeitete Fall der Pfad).

Android APK — was der Benutzer eingibt, was wo landet

```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?" ``` - **Landet in:** `bins/` (die APK), `facts/` (Klassengraph, natives `.so`-Inventar), `evidence/` (Captures, Dumps). - **Fertig sieht so aus:** jede Frage durch reproduzierbare Belege gestützt. - **Die Route passt sich an.** Manche APKs schließen mit reiner statischer DEX-Arbeit ab; andere benötigen On-Device-Debugging — die Schleife entscheidet anhand dessen, was die Probe tatsächlich ist.

Web / JS — entpacken → deobfuskieren → Replay signierter Parameter

```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?" ``` - **Landet in:** `evidence/` (Captures, deobfuskierter Code), `facts/` (Signing-Key, Nonce-Ableitung). - **Hinweis:** `web` ist ein Target in der Beta-Phase — die Toolchain-Hürde ist bewusst niedrig angesetzt; fehlende Fähigkeiten zeigen sich, wenn die Loop sie tatsächlich benötigt, nicht beim Init.

Was du bekommst

Ein Claim-Register und eine Faktbasis, bei der Vertrauen mechanisch ist, nicht konventionell:

Verifizierte Konvergenz — PROVEN erfordert die exakte Übereinstimmungs-Freigabe eines unabhängigen blinden Verifiers; CONVERGED erfordert, dass jede primäre Frage mit Byte-Beweis beantwortet ist, null verwaiste Claims, kein Spinning.
Evidenz-Integrität — jeder Fakt führt über evidence/_index.json zu einem Rohartefakt (Capture / Trace / Dump / Binary). Abgeleitete Zusammenfassungen sind per Design ausgeschlossen.
Maker-Checker — der Worker (Maker) schreibt Fakten; der Redteam-Verifier (Checker) leitet sie blind erneut ab. Immer unterschiedliche Agents.

Kein Claim erreicht PROVEN auf das Wort seines Autors: Ein unabhängiger Verifier muss ihn blind erneut ableiten, und eine Reihe mechanischer Gates muss passieren. Das vollständige Gate-Design steht in docs/design/loop-engineering.md.

Nach dem Run beantworten die Dateien unterschiedliche Fragen:

Beispiel-Fakt:```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}

## Langfristige Autonomie

Echte Einsätze sind kein zwanzigminütiger Chat. kunglao-agent bleibt am Problem dran, ohne dass ein Mensch jeden Schritt begleiten muss:

- **Läuft stunden- oder tagelang unbeaufsichtigt** — ein geplanter Heartbeat hält die Schleife zwischen deinen Besuchen am Laufen, und eine ins Stocken geratene Schleife wird gemeldet, statt still zu sterben.
- **Erholt sich von Fehlern** — tote oder hängende Worker werden ersetzt und ihre Fragen neu in die Warteschlange gestellt; blockierte Arbeit erholt sich selbst, statt untätig zu bleiben.
- **Übersteht Abstürze und Neustarts** — `/kunglao-agent:resume <workspace>` baut aus dem Zustand auf der Festplatte wieder auf, wo die Dinge standen, und benennt die nächste Aktion.
- **Erinnert sich auf der Festplatte, nicht im Chat** — Claims, Fakten, Beweise und ein vollständiger Audit-Trail liegen im Workspace, sodass jede Sitzung den Einsatz wieder aufnehmen kann.

Du gibst ihm ein Ziel und die Fragen; es arbeitet stunden- oder tagelang am Problem, erholt sich von Fehlern, und du liest das Urteil, wenn es konvergiert.

## Gute Ergebnisse erzielen

- **Füttere es mit statisch zugänglichen Zielen.** Die Schleife ist statisch-first: ein entpacktes APK, ein unobfuskiertes Bundle oder ein unstripptes Binary konvergiert weit schneller als eines, das dynamische Arbeit erzwingt.
- **Richte das dynamische Bein ein, bevor du es brauchst.** Wenn deine primären Fragen Ausführung erfordern, wähle zuerst einen Kanal (siehe [Bring your own environment](#bring-your-own-environment)) — init lehnt eine dynamische Aufgabe auf `local` HARD ab.
- **„Arbeitet" von „hängt" unterscheiden** — frische Einträge in `runs/` bedeuten, dass die Schleife lebt; ein toter Heartbeat oder dieselbe Entscheidung, die sich ohne neue Fakten wiederholt, bedeutet, dass sie es nicht tut — `/kunglao-agent:resume <workspace>` diagnostiziert und benennt den nächsten Schritt.

## Toolchain nach Ziel

Der `--type`, den du bei init wählst, legt fest, welche HARD-Tier-Tools installiert sein müssen. Die Anleitung ist eingeklappt — klappe dein Ziel auf. **Alle Typen erfordern zwei MCP-Server:** `ghidra` (`claude mcp add ghidra -- <path>/bridge-mcp-ghidra.exe`) und `sequential-thinking` (`claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking`).

<details>
<summary><strong>windows (PE32+ x86-64)</strong> — native Windows-Binaries</summary>

| Tier | Tool | Installation |
|---|---|---|
| HARD | `pefile` (Python) | `pip install pefile` |
| HARD | `die` (Detect It Easy) | `KUNGLAO_DIE` env oder im PATH — [ntinfo.com](https://ntinfo.com) |
| HARD | `floss` (FLARE FLOSS) | gemäß [flare-floss docs](https://github.com/mandiant/flare-floss) |
| HARD | Ghidra oder IDA | eines von beiden; siehe [Internals](#internals) |
| HARD (T2/T3) | VMware + vmr-shell, oder ein ssh/docker-Kanal | siehe [Bring your own environment](#bring-your-own-environment) |
| HARD (T2/T3) | `frida-server` (umbenannt, benutzerdefinierter Port) | geräte-/VM-seitiges Binary, Standardport 1337 |

Windows T3 dynamisch nutzt außerdem den `x64dbg` MCP; `volatility` (Memory-Forensik) und IDA-Pro MCP sind optional — siehe das MCP-Manifest unter [Internals](#internals).

</details>

<details>
<summary><strong>linux (ELF)</strong> — native Linux-Binaries / Firmware / Memory-Images</summary>

| Tier | Tool | Installation |
|---|---|---|
| HARD | `file`, `readelf`, `objdump` | `binutils`-Paket |
| HARD | Ghidra oder IDA | eines von beiden |
| HARD (T2/T3) | VMware + vmr-shell, oder eine ssh/docker-Kontrollfläche | siehe [Bring your own environment](#bring-your-own-environment) |
| HARD (T2/T3) | `frida-server` (umbenannt, benutzerdefinierter Port) | geräteseitiges Binary, Port 1337 |
| WARN | `gdbserver` (hostseitiger PATH), `strace`, `ltrace` | optionale Extras |

`ssh-mcp` aktiviert die ssh-Kontrollfläche für Remote-/Cloud-/Docker-Hosts.

</details>

<details>
<summary><strong>android (APK / DEX / native .so)</strong> — der härteste Zieltyp, die meisten HARD-Einträge</summary>

| Tier | Tool | Installation |
|---|---|---|
| HARD | `aapt` oder `aapt2` (oder `unzip` als Fallback) | Android SDK build-tools |
| HARD | `jadx` (DEX → Java-Decompiler) | [skylot/jadx](https://github.com/skylot/jadx) |
| HARD | `apktool` (APK-Ressourcen dekodieren/neu bauen) | [iBotPeaches/Apktool](https://github.com/iBotPeaches/Apktool) |
| HARD | `gitnexus` (Post-Decompile-Graph) | `npm i -g gitnexus` |
| HARD | Ghidra oder IDA | nur wenn das APK native `.so` enthält |
| HARD | `adb` + **ein gerootetes Gerät** mit `ro.debuggable=1` | platform-tools + custom frida auf dem Gerät |
| HARD | `frida-server` (umbenannt, benutzerdefinierter Port 1337) | geräteseitiges Binary |
| HARD | `android_server` (IDA Remote-Debugging) | geräteseitiges Binary, Port 23946 |
| WARN | `apkid` | `pip install apkid` |
| WARN | `baksmali` | aus [smali releases](https://github.com/baksmali/smali/releases) |

</details>

<details>
<summary><strong>web &amp; macos (beta)</strong> — minimale Toolchains, konstruktionsbedingt keine HARD-Einträge</summary>

| Tier | Tool | Installation |
|---|---|---|
| WARN | `camoufox-reverse` MCP (web) | Anti-Detect-Firefox für Hook / Trace / Network Capture |
| WARN | `docker` (web-Kanal-Standard) | Docker Desktop, oder `KUNGLAO_CHANNEL=ssh` explizit setzen |
| WARN | `lipo`, `otool`, `nm`, `codesign`, `xattr` (macOS) | Xcode Command Line Tools |
| WARN | `ghidra` MCP (macOS) | empfohlen — siehe das Manifest unter [Internals](#internals) |

Beide sind Ziele im Beta-Stadium: fehlende Fähigkeiten tauchen auf, wenn die Schleife sie tatsächlich braucht, nicht bei init. Dynamische macOS-Arbeit nutzt den `ssh`-Kanal (zu einem Mac-Host); für den optionalen x64dbg-Browser-Debug-Pfad installiere die Windows-Toolchain oben.

</details>

Einzige Manifest-Quelle für alles oben — jederzeit abfragbar: `python scripts/mcp_probe.py <ws> --type <windows|linux|android|web|macos>` (Exit 1 = HARD fehlt).

## Bring your own environment

Dynamisches Debugging benötigt eine Ausführungs-Kontrollfläche, die der Agent steuern kann. `KUNGLAO_CHANNEL` wählt einen von fünf erstklassigen Kanälen — nutze, was deine Umgebung bereits hat; keiner ist ein degradierter Modus:

| Kanal | Was er steuert | Voraussetzungen |
|---|---|---|
| `vmr` (Standard) | VMware-VM, **jedes Gast-OS** — Snapshot/Revert-Workflows sind sein unersetzlicher Wert | vmr-shell-Skill; `KUNGLAO_VM_HOST` + Ports 9876/1337 |
| `ssh` | Jede ssh-erreichbare Box: Bare Metal, Cloud-VM, Mac, Remote-Docker-Host | Key-Auth — die Probe führt ein echtes BatchMode `ssh ... true` aus |
| `docker` | Lokaler oder Remote-Docker-Daemon — `docker exec` ist äquivalent zu jedem Kontrollpfad | `docker version` grün; optional `KUNGLAO_DOCKER_CONTAINER` |
| `adb` | Android-Emulator oder echtes Gerät | `adb devices` zeigt es; `adb forward tcp:1337 tcp:1337` für frida |
| `local` | **Nur statische Analyse auf dem Host** | keine — siehe die rote Linie |

> **`local` rote Linie:** local ist nur für **statische** Arbeit — führe die Probe niemals auf dem Host aus, debugge oder injiziere sie. Jede dynamische Anforderung schaltet `KUNGLAO_CHANNEL` auf `vmr`/`ssh`/`docker`/`adb` um; init lehnt eine dynamische Aufgabe auf `local` HARD ab.

Kanal-Probes laufen nur für dynamische Aufgaben (rein statische Aufgaben überspringen sie). Die Ausführung im `ssh`-Kanal läuft über die **ssh-mcp**-Kontrollfläche (`npm i -g ssh-mcp`); einfaches CLI-ssh ist der Fallback. Für Remote-Docker über ssh setze `KUNGLAO_DOCKER_CONTAINER`.

## Konfiguration

Vier Variablen decken die meisten Setups ab:

| Variable | Standard | Bedeutung |
|---|---|---|
| `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS` | nicht gesetzt | muss nicht gesetzt oder `0` bleiben — truthy-Werte leiten Dispatches über den Teammate-Kanal und werden abgelehnt |
| `KUNGLAO_CHANNEL` | `vmr` | dynamische Ausführungs-Kontrollfläche: `vmr` \| `ssh` \| `docker` \| `adb` \| `local` — siehe [Bring your own environment](#bring-your-own-environment) |
| `KUNGLAO_VM_HOST` | nicht gesetzt | VM/Host für dynamische Analyse (vmr-shell :9876, Frida :1337) |
| `GHIDRA_HOME` | nicht gesetzt | Ghidra-Installationswurzel (muss `support/analyzeHeadless.bat` enthalten) |

Selten benötigt: `KUNGLAO_DOCKER_CONTAINER` (Docker-Ausführungsziel für die `ssh`/`docker`-Kanäle), `KUNGLAO_FRIDA_PORT` (Standard 1337), `KUNGLAO_DIE` (DIE-Pfad, fällt auf PATH zurück), `KUNGLAO_CLAUDE_JSON` (Test-Override für die benutzerweite MCP-Registry).

## Sicherheit

- Proben werden niemals auf dem Host ausgeführt — der `block_malware_exec`-Hook erzwingt dies; dynamische Arbeit läuft nur in VM/Container/Gerät und erfordert eine Autorisierung pro Sitzung.
- Ground-Truth-Hierarchie: Rohartefakt > lokales Tool > Sandbox > Threat Intel (CTI ist eine falsifizierbare Hypothese, niemals Wahrheit).
- Maker-Checker: Ein Worker verifiziert sich niemals selbst; ein Verifier liest niemals die Schlussfolgerung des Makers.
- Bins, Einstellungen und Hooks werden niemals committet; Secrets sind aus Workspaces und dem Repo ausgeschlossen.

## Entwicklung

Beiträge sind willkommen. Workflow: von `dev` abzweigen, ein Branch pro Änderung, PR zurück nach `dev`.```bash
git worktree add .worktrees/<name> -b <name> dev
uv sync --locked
uv run python -m pytest -q
gh pr create --base dev

Der maßgebliche Full-Suite-Einstieg ist python -m pytest -q (siehe .github/workflows/release-check.yml).

Designdokumentation befindet sich in docs/ und specs/. Siehe License.

Interna

MCP-Bereitstellung (das vollständige Manifest)

Einzige Quelle der Wahrheit: scripts/mcp_probe.py; kunglao-init erstellt ein Workspace-.mcp.json, wenn es fehlt (--no-mcp überspringt; eine vorhandene Datei wird niemals überschrieben). Probe: python scripts/mcp_probe.py <ws> --type <windows|linux|android|web|macos> — Exit 1 = HARD fehlend, 2 = nur WARN fehlend.

Workspace-Layout

Ein Workspace pro Sample-Engagement:

``` / ├── 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 werden auf Workspace-Ebene verdrahtet; deine globale `~/.claude/settings.json` wird niemals geschrieben.

Lizenz

Dual-lizenziert: AGPL-3.0 für persönliche, akademische und interne Nutzung (kostenlos — siehe LICENSE); eine kommerzielle Lizenz ist für kommerzielle Closed-Source- oder SaaS-Nutzung erforderlich — siehe LICENSE-commercial.md.

Claude Code	wo kunglao-agent läuft	gemäß Anthropic-Dokumentation
Python 3.10+ (Python 2 wird nicht unterstützt)	das Plugin bringt eine gepinnte Umgebung über `uv` mit; man berührt sie nicht	systemweit oder `uv`-verwaltet
`uv`	Locked-Env-Resolver	`pip install uv` oder astral.sh/uv
Ghidra oder IDA	eine Static-Analysis-Suite zur Dekompilierung	siehe Toolchain by target

Ist es fertig?	der Exit-Code der Loop — `CONVERGED` (0) bedeutet, jede primäre Frage hat eine verifizierte Antwort; Status pro Claim in `claim-register.yaml`
Was wurde gefunden?	`facts/F<NNN>.md` — ein byte-verankerter Fakt pro Datei, über `claim-register.yaml` Claims zugeordnet
Wie reproduziere ich es?	`evidence/_index.json` — Fakt → Rohartefakt (Pfad + sha256); jeder Fakt trägt einen `reproduce:`-Befehl
Was genau ist passiert?	`runs/` — das Tick-für-Tick-Ledger und der Worker-Status

`ghidra`	HARD	erforderlich, alle Typen	Dekompilierung / statische Analyse	`claude mcp add ghidra -- <path>/bridge-mcp-ghidra.exe`
`sequential-thinking`	HARD	erforderlich, alle Typen	strukturiertes Reasoning	`claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking`
`x64dbg`	HARD	Windows T3 dynamisch	dynamisches Debugging (VM remote)	`claude mcp add x64dbg -- x64dbg-automate-mcp`
`volatility`	WARN	Windows T3	Speicherforensik	`claude mcp add volatility -- python <path>/volatility_mcp_server.py`
`ida-pro-vm`	WARN	wenn IDA gewählt	remote IDA-Analyse	`claude mcp add --transport http ida-pro-vm <ida-mcp-url>`
`gitnexus`	HARD	Android Graph-Erstellung	Wissensgraph nach Dekompilierung	`claude mcp add gitnexus -- gitnexus mcp`
`virustotal`	WARN	CTI	Threat Intel (Hypothesen zur Familienzuordnung)	`claude mcp add virustotal -- npx -y @burtthecoder/mcp-virustotal`
`ssh-mcp`	WARN	Kanal	SSH-Ausführungs-Kontrollplane	`claude mcp add ssh-mcp -- ssh-mcp`
`camoufox-reverse`	WARN	Web (Beta)	Browser-JS-Reversing (Hooks / Trace / Netzwerkmitschnitt)	`claude mcp add camoufox-reverse -- python -m camoufox_reverse_mcp`

Beliebteste

kunglao-agent

kunglao-agent

Warum kunglao-agent

Schnellstart

1. Plugin installieren

3. Aufgabe benennen und Analyse starten```

Wie die Aufgabe formuliert wird

„我要纯算" — „nur der reine Algorithmus"

"这个 sign 在哪算的" — "Wo wird dieses Vorzeichen berechnet?"

Szenarien

Was du bekommst

Interna

Lizenz