C'est l'affirmation principale et elle est défendable aujourd'hui contre la compromission d'agent, l'injection de prompts, le vol de logs et l'exfiltration de compétences.
Lisez [docs/THREAT-MODEL.md](https://github.com/rohansx/wardn/blob/main/docs/THREAT-MODEL.md) pour la répartition honnête entre ce qui est couvert et ce qui ne l'est pas — y compris le niveau où l'affirmation plus forte « la compromission de l'hôte ne fuit rien » devient atteignable.

Le coffre lui-même (chiffré au repos, clé dérivée d'une phrase de passe) est un composant réel et la raison pour laquelle le pare-feu peut fonctionner sur une seule machine. Le niveau à venir [docs/HOSTED-TIER.md](https://github.com/rohansx/wardn/blob/main/docs/HOSTED-TIER.md) enveloppe en outre le proxy dans une enclave de calcul confidentiel de sorte que même un VPS entièrement compromis ne puisse pas lire la clé.

[![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)

## Le Problème

Chaque framework d'agent IA aujourd'hui stocke les clés API dans des variables d'environnement ou des fichiers `.env`. Un agent compromis, une compétence malveillante, un voleur générique ou une injection de prompt exfiltrent `Authorization: Bearer sk-...` d'un journal LLM et obtiennent un accès complet à vos informations d'identification.```
~/.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

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

## Démonstration

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

## Niveaux de confiance, en toute honnêteté

| Niveau | Où | Ce qui est garanti |
|---|---|---|
| **Auto-hébergé (aujourd'hui)** | votre ordinateur portable, votre VPS, CI | Coffre crypté au repos, protection par pare-feu contre les agents. **Ne défend pas** contre un root sur l'hôte. |
| **Hébergé (à venir)** | géré par wardn ou BYO-cloud | Enclave de calcul confidentiel (Nitro / SEV-SNP) + attestation à distance + flux de chiffrement vers le proxy. Véritable revendication « la compromission de l'hôte ne fuit rien ». |

Le niveau auto-hébergé est la revendication principale et est livré aujourd'hui. Le niveau hébergé
est la voie de mise à niveau stricte : il coûte de l'argent et de la complexité opérationnelle, et
sa conception se trouve dans [docs/HOSTED-TIER.md](https://github.com/rohansx/wardn/blob/main/docs/HOSTED-TIER.md). Inventaire complet et honnête
de ce qui est et n'est pas couvert :

👉 **[docs/THREAT-MODEL.md](https://github.com/rohansx/wardn/blob/main/docs/THREAT-MODEL.md)** — tableau des sujets couverts / non couverts,
« aucun coffre logiciel n'élimine la compromission de l'hôte » clairement mentionné, et
la voie de mise à niveau.

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

Voilà. Claude Code utilise désormais le serveur MCP de wardn pour obtenir des jetons placeholders au lieu de lire les vraies clés de votre environnement.

### Ce qui se passe ensuite

1. Claude Code appelle `get_credential_ref` → reçoit `wdn_placeholder_a1b2...` (pas la vraie clé)
2. L'agent envoie la requête avec le placeholder via le proxy wardn
3. Le proxy échange le placeholder contre la vraie clé, la transmet à l'API
4. Le proxy retire la vraie clé de la réponse avant de la renvoyer à l'agent

La vraie clé n'entre jamais dans la mémoire, les journaux ou la fenêtre de contexte LLM de l'agent.

## Tableau de bord local

Une fois le daemon lancé (`wardn serve`, ou généré par `wardn run`), ouvrez
**http://127.0.0.1:7777/ui** dans un navigateur. Une vue en lecture seule, locale uniquement, de :

- **Credentials** — chaque identifiant stocké avec ses ACL (agents autorisés, domaines autorisés, badges de limite de débit et de budget).
- **Recent Activity** — les 50 derniers événements proxy avec méthode, domaine, chemin, statut, agent, request_id et coût enregistré (`request_completed`, `credential_injected`, `rate_limit`, `budget_exceeded`, `loop_detected`, `request_error`).
- **Budgets** — le budget configuré de chaque identifiant (max, dépensé, restant, fenêtre, mode) avec une barre de progression qui passe de avertissement → mauvais lorsqu'elle franchit 50% / 80%.

Interrogé automatiquement toutes les 2 s. Aucun point de terminaison de mutation — la seule façon de sortir du tableau de bord est l'API elle-même (`/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

## Référence CLI

### Gestion des coffres```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

### Intégration de Claude Code / Cursor```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

#### Outils MCP disponibles

| Tool | Ce qu'il renvoie | Sécurité |
|------|-----------------|----------|
| `get_credential_ref` | Jeton de substitution (`wdn_placeholder_...`) | Jamais la valeur réelle |
| `list_credentials` | Noms des identifiants + métadonnées | Filtré par l'accès de l'agent |
| `check_rate_limit` | Quota restant, infos de nouvelle tentative | Lecture seule |

### Migration des identifiants```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

Chaque importateur demande la phrase de passe du coffre lors de la première utilisation (ou la lit
depuis `WARDN_PASSPHRASE` / le trousseau de l'OS). Les valeurs existantes sont silencieusement
écrasées — l'importateur est uniquement basé sur les valeurs, les métadonnées (agents autorisés /
domaines / limite de débit / budget) sont préservées.

### Automatisation

Pour CI/scripts, définissez les variables d'environnement `WARDN_PASSPHRASE` et `WARDN_VALUE` pour ignorer les invites interactives :```bash
WARDN_PASSPHRASE=my-pass wardn vault list
WARDN_PASSPHRASE=my-pass WARDN_VALUE=sk-proj-xxx wardn vault set OPENAI_KEY

### Opérations Vault```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?;

Définissez `RUST_LOG=wardn=info` (ou `debug`/`trace`) pour contrôler la verbosité. Les logs vont sur stderr, jamais sur stdout.

## Configuration```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"]

## Développement```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

### Format de fichier```
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)