Dies ist die tragende Behauptung und sie ist heute gegen Agentenkompromittierung, Prompt-Injection, Log-Diebstahl und Skill-Exfiltration verteidigbar.
Lesen Sie [docs/THREAT-MODEL.md](https://github.com/rohansx/wardn/blob/HEAD/docs/THREAT-MODEL.md) für die ehrliche Aufteilung zwischen dem, was abgedeckt ist und was nicht – einschließlich der Stufe, bei der die stärkere Behauptung „Host-Kompromittierung gibt nichts preis“ erreichbar wird.

Der Tresor selbst (verschlüsselt im Ruhezustand, passphrasenabgeleiteter Schlüssel) ist eine echte Komponente und der Grund, warum die Firewall auf einem einzelnen Rechner laufen kann.
Die kommende Stufe [docs/HOSTED-TIER.md](https://github.com/rohansx/wardn/blob/HEAD/docs/HOSTED-TIER.md) umhüllt den Proxy zusätzlich in einer vertraulichen Rechenenklave, sodass selbst ein vollständig kompromittierter VPS den Schlüssel nicht lesen kann.

[![Crates.io](https://img.shields.io/crates/v/wardn.svg)](https://crates.io/crates/wardn)
[![License](https://img.shields.io/crates/l/wardn.svg)](LICENSE)

## Das Problem

Jedes KI-Agenten-Framework speichert heute API-Schlüssel in Umgebungsvariablen oder `.env`-Dateien. Ein kompromittierter Agent, eine bösartige Fähigkeit, ein handelsüblicher Stealer oder eine Prompt-Injection, die `Authorization: Bearer sk-...` aus einem LLM-Log exfiltriert, erhält vollen Zugriff auf Ihre Anmeldeinformationen.```
~/.env              → OPENAI_KEY=sk-proj-real-key      # plaintext, readable by anyone
agent context       → "Use OPENAI_KEY=sk-proj-real-key" # leaked into LLM context window
agent logs          → Authorization: Bearer sk-proj-... # sitting in log files

## Architektur```mermaid
flowchart TB
    subgraph Agent["AI Agent Process"]
        A1["Agent Code"]
        A2["ENV: OPENAI_KEY=wdn_placeholder_a1b2..."]
    end

    subgraph Wardn["wardn daemon · localhost:7777"]
        direction TB
        P["HTTP Proxy"]
        MCP["MCP Server\n(stdio)"]

        subgraph Pipeline["Request Pipeline"]
            direction LR
            S1["Identify\nAgent"] --> S2["Resolve\nPlaceholder"] --> S3["Check\nAuth"] --> S4["Rate\nLimit"] --> S5["Inject\nReal Key"]
        end

        subgraph ResponsePipeline["Response Pipeline"]
            direction RL
            R1["Strip Real\nKeys"] --> R2["Replace with\nPlaceholders"]
        end

        subgraph Vault["Encrypted Vault"]
            V1["AES-256-GCM"]
            V2["Argon2id KDF"]
            V3["Placeholder Map\nper agent × credential"]
        end
    end

    subgraph External["External APIs"]
        E1["api.openai.com"]
        E2["api.anthropic.com"]
        E3["..."]
    end

    A1 -- "placeholder token\nin headers/body" --> P
    A1 -. "MCP: get_credential_ref\nlist_credentials\ncheck_rate_limit" .-> MCP
    MCP -. "placeholder token\n(never real keys)" .-> A1
    P --> Pipeline
    Pipeline --> External
    External --> ResponsePipeline
    ResponsePipeline -- "response with\nplaceholders only" --> A1
    Pipeline <--> Vault
    ResponsePipeline <--> Vault

    style Agent fill:#1a1a2e,stroke:#e94560,color:#fff
    style Wardn fill:#0f3460,stroke:#16213e,color:#fff
    style Pipeline fill:#16213e,stroke:#e94560,color:#fff
    style ResponsePipeline fill:#16213e,stroke:#e94560,color:#fff
    style Vault fill:#1a1a2e,stroke:#00d2ff,color:#fff
    style External fill:#0a0a0a,stroke:#533483,color:#fff

## Demo

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12823/1fa6109ffd855ec98c173c5edd2d7ee77f6b0c918a3cdecb1ea5fbfe8326161d.gif" alt="wardn demo" width="800">
</p>

## Vertrauensstufen, ehrlich

| Stufe | Wo | Was gilt |
|---|---|---|
| **Selbsthosting (heute)** | Ihr Laptop, Ihre VPS, CI | Verschlüsseltes Ruhevault, Firewall-Anspruch gegen Agents. **Schützt nicht** vor Root auf dem Host. |
| **Gehostet (in Kürze)** | wardn-verwaltet oder BYO-Cloud | Confidential-Compute-Enklave (Nitro / SEV-SNP) + Remote-Attestation + Encrypt-to-the-Proxy-Flow. Echter „Host-Kompromittierung gibt nichts preis“-Anspruch. |

Die Selbsthosting-Stufe ist der tragende Anspruch und wird heute ausgeliefert. Die gehostete Stufe ist der strikte Aufwertungspfad: Sie kostet Geld und Betriebskomplexität, und ihr Design befindet sich in [docs/HOSTED-TIER.md](https://github.com/rohansx/wardn/blob/HEAD/docs/HOSTED-TIER.md). Vollständiges ehrliches Inventar dessen, was abgedeckt ist und was nicht:

👉 **[docs/THREAT-MODEL.md](https://github.com/rohansx/wardn/blob/HEAD/docs/THREAT-MODEL.md)** — Tabelle mit abgedeckt / nicht abgedeckt, „kein Software-Tresor eliminiert Host-Kompromittierung“ deutlich hervorgehoben, und der Aufwertungspfad.

## Installation```bash
# Prebuilt binary (Linux/macOS, amd64/arm64), checksum-verified
curl -sSf https://raw.githubusercontent.com/rohansx/wardn/main/install.sh | sh

# or from crates.io
cargo install wardn

# or Homebrew, once the tap is published (see Formula/wardn.rb)
brew install rohansx/wardn/wardn

Das war's. Claude Code verwendet jetzt wardns MCP-Server, um Platzhalter-Token zu erhalten, anstatt echte Schlüssel aus Ihrer Umgebung zu lesen.

### Was als Nächstes passiert

1. Claude Code ruft `get_credential_ref` auf → erhält `wdn_placeholder_a1b2...` (nicht den echten Schlüssel)
2. Agent sendet Anfrage mit Platzhalter über den wardn-Proxy
3. Proxy tauscht Platzhalter gegen echten Schlüssel aus, leitet an API weiter
4. Proxy entfernt den echten Schlüssel aus der Antwort, bevor er an den Agenten zurückgegeben wird

Der echte Schlüssel gelangt nie in den Speicher, die Protokolle oder das LLM-Kontextfenster des Agenten.

## Lokales Dashboard

Sobald der Daemon läuft (`wardn serve` oder von `wardn run` gestartet), öffnen Sie
**http://127.0.0.1:7777/ui** in einem Browser. Eine schreibgeschützte, nur lokale Ansicht von:

- **Anmeldedaten** — jeder gespeicherte Anmeldedatensatz mit seinen ACLs (erlaubte Agenten, erlaubte Domänen, Ratenbegrenzung + Budget-Abzeichen).
- **Letzte Aktivität** — die letzten 50 Proxy-Ereignisse mit Methode, Domäne, Pfad, Status, Agent, Request-ID und aufgezeichneten Kosten (`request_completed`, `credential_injected`, `rate_limit`, `budget_exceeded`, `loop_detected`, `request_error`).
- **Budgets** — das konfigurierte Budget jedes Anmeldedatensatzes (max, ausgegeben, verbleibend, Fenster, Modus) mit einem Fortschrittsbalken, der von warn → bad wechselt, sobald 50% / 80% überschritten werden.

Wird automatisch alle 2 Sekunden abgefragt. Keine Mutations-Endpunkte — der einzige Weg aus dem Dashboard ist die API selbst (`/api/summary`, `/api/credentials`, `/api/audit?limit=N`, `/api/budgets`).```bash
# Static, anonymous, never sees real keys
curl http://127.0.0.1:7777/api/summary | jq

## CLI-Referenz

### Vault-Verwaltung```bash
wardn vault create                        # create encrypted vault
wardn vault set OPENAI_KEY                # store credential (prompts for value, no echo)
wardn vault get OPENAI_KEY                # get placeholder token (never the real value)
wardn vault get OPENAI_KEY --agent bot    # get placeholder for specific agent
wardn vault list                          # list all credentials
wardn vault rotate OPENAI_KEY             # rotate value, placeholders unchanged
wardn vault remove OPENAI_KEY             # remove credential

# Custom vault path
wardn --vault /path/to/vault.enc vault list

### Claude Code / Cursor Integration```bash
wardn setup claude-code                   # register wardn as MCP server in Claude Code
wardn setup cursor                        # register wardn as MCP server in Cursor

# Or manually:
claude mcp add --transport stdio --scope user wardn -- wardn serve --mcp --agent claude-code

#### Verfügbare MCP-Werkzeuge

| Werkzeug | Rückgabe | Sicherheit |
|------|----------------|----------|
| `get_credential_ref` | Platzhalter-Token (`wdn_placeholder_...`) | Nie der tatsächliche Wert |
| `list_credentials` | Anmeldedatennamen + Metadaten | Gefiltert nach Agentenzugriff |
| `check_rate_limit` | Verbleibendes Kontingent, Wiederholungsinfo | Schreibgeschützt |

### Anmeldedatenmigration```bash
wardn migrate --dry-run                             # audit Claude Code dir for exposed keys
wardn migrate --source claude-code                  # scan + migrate to vault
wardn migrate --source open-claw                    # scan OpenClaw config
wardn migrate --source directory --path ./my-proj   # scan any directory

Jeder Importeur fordert bei der ersten Verwendung zur Eingabe des Tresor-Passworts auf (oder liest es
aus der Umgebungsvariablen `WARDN_PASSPHRASE` / dem OS-Schlüsselbund). Vorhandene Werte werden stillschweigend
überschrieben — der Importeur ist wertorientiert, Metadaten (erlaubte Agents /
Domains / Ratenlimit / Budget) bleiben erhalten.

### Automatisierung

Für CI/Skripte setzen Sie die Umgebungsvariablen `WARDN_PASSPHRASE` und `WARDN_VALUE`, um interaktive Eingabeaufforderungen zu überspringen:```bash
WARDN_PASSPHRASE=my-pass wardn vault list
WARDN_PASSPHRASE=my-pass WARDN_VALUE=sk-proj-xxx wardn vault set OPENAI_KEY

### Vault Operationen```rust
use wardn::{Vault, config::CredentialConfig};

// Create an encrypted vault
let vault = Vault::create("vault.enc", "my-passphrase")?;

// Store a credential
vault.set_with_config("OPENAI_KEY", "sk-proj-real-key-123", &CredentialConfig {
    allowed_agents: vec!["researcher".into(), "writer".into()],
    allowed_domains: vec!["api.openai.com".into()],
    rate_limit: Some(RateLimitConfig { max_calls: 200, per: TimePeriod::Hour }),
})?;

// Agent gets a placeholder (not the real key)
let placeholder = vault.get_placeholder("OPENAI_KEY", "researcher")?;
// → "wdn_placeholder_a1b2c3d4e5f6g7h8"

// Rotate the real key — all placeholders keep working
vault.rotate("OPENAI_KEY", "sk-proj-new-key-456")?;

### MCP Server```rust
use wardn::mcp::WardenMcpServer;

// Serve over stdio (for Claude Code, Cursor, etc.)
WardenMcpServer::serve_stdio(vault, rate_limiter, "agent-id".into()).await?;

Set `RUST_LOG=wardn=info` (oder `debug`/`trace`) zur Steuerung der Ausführlichkeit. Logs gehen nach stderr, nie nach stdout.

## Konfiguration```toml
[warden]
vault_path = "~/.vibeguard/vault.enc"

[warden.credentials.OPENAI_KEY]
rate_limit = { max_calls = 200, per = "hour" }
allowed_agents = ["researcher", "writer"]
allowed_domains = ["api.openai.com"]

[warden.credentials.ANTHROPIC_KEY]
rate_limit = { max_calls = 100, per = "hour" }
allowed_agents = ["researcher"]
allowed_domains = ["api.anthropic.com"]

## Entwicklung```bash
# Integration tests use a fast (insecure) KDF so the suite runs in
# milliseconds instead of paying the real Argon2id cost per test —
# always pass this feature flag when running tests locally or in CI:
cargo test --features test-fast-kdf

cargo build
cargo clippy --all-targets --features test-fast-kdf

subgraph KDF["Key Derivation"]
    Argon["Argon2id\nm=19456 t=2 p=1"]
end

subgraph Encrypt["Encryption"]
    AES["AES-256-GCM"]
    Nonce["Random Nonce\n(12 bytes)"]
end

subgraph Output["WDNV File"]
    direction TB
    Magic["WDNV (4B)"]
    Ver["Version (2B)"]
    SaltOut["Salt (16B)"]
    Payload["Nonce ‖ Ciphertext ‖ Tag"]
end

Pass --> Argon
Salt --> Argon
Argon -- "256-bit key" --> AES
Creds --> AES
Nonce --> AES
AES --> Payload

style Input fill:#1a1a2e,stroke:#e94560,color:#fff
style KDF fill:#16213e,stroke:#00d2ff,color:#fff
style Encrypt fill:#16213e,stroke:#00d2ff,color:#fff
style Output fill:#0f3460,stroke:#533483,color:#fff

### Dateiformat```
Bytes 0-3:   Magic "WDNV"
Bytes 4-5:   Version (u16 LE)
Bytes 6-21:  Argon2id salt (16 bytes)
Bytes 22+:   AES-256-GCM encrypted payload (nonce ‖ ciphertext ‖ tag)