wardn

Eine Credential-Firewall für KI-Agenten.

Die Kernaussage ist strukturell, nicht politisch: Agenten erhalten Platzhalter-Token, niemals echte API-Schlüssel. Der echte Schlüssel überschreitet nur eine Netzwerkschnittstelle — innerhalb des wardn-Proxys auf dem Weg zur vorgelagerten API — und wird aus den Antworten entfernt, bevor sie den Agenten erreichen. Logs, Umgebung, LLM-Kontextfenster, temporäre Dateien und Shell-Verlauf enthalten nur Platzhalter.```text agent process OPENAI_KEY=wdn_placeholder_a1b2c3d4e5f6g7h8 (useless) agent logs Authorization: Bearer wdn_placeholder_a1b2... (useless) LLM context wdn_placeholder_a1b2c3d4e5f6g7h8 (useless) wardn proxy injects the real key in-flight, single seam (deleted on response) ~/.vibeguard/vault.enc AES-256-GCM(Argon2id(passphrase)) (encrypted at rest)

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

Die Lösung: Eine Credential Firewall

wardn übergibt Agenten einen nutzlosen Platzhalter-String und entfernt den echten Schlüssel von jeder Oberfläche, die es erreichen kann. Echte Schlüssel werden auf der Netzwerkschicht injiziert — eine einzelne Naht — und aus Antworten entfernt, bevor sie den Agenten erreichen.``` agent environment → OPENAI_KEY=wdn_placeholder_a1b2c3d4e5f6g7h8 (useless) wardn vault → OPENAI_KEY=sk-proj-real-key (encrypted at rest) upstream request → Authorization: Bearer sk-proj-real-key (network transit only) upstream response → ...real keys stripped, placeholders returned... (re-injected on the way back) agent logs → Authorization: Bearer wdn_placeholder_a1b2... (useless) LLM context window → wdn_placeholder_a1b2c3d4e5f6g7h8 (useless)

## 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

Wie es funktioniert```

Agent sends request with placeholder in Authorization header │ ▼ ┌─────────────────────────┐ │ wardn proxy │ │ localhost:7777 │ │ │ │ 1. Identify agent │ │ 2. Resolve placeholder │ │ 3. Check authorization │ │ 4. Check rate limit │ │ 5. Inject real key │ │ 6. Forward request │ │ 7. Strip key from resp │ │ 8. Return to agent │ └─────────────────────────┘ │ ▼ External API (only place real key exists in transit)

## 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/main/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/main/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

Schnellstart```bash

Create an encrypted vault and store your keys

wardn vault create wardn vault set OPENAI_KEY wardn vault set ANTHROPIC_KEY

Set up Claude Code integration (one command)

wardn setup claude-code

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