wardn

AI एजेंटों के लिए क्रेडेंशियल फ़ायरवॉल।

मुख्य दावा नीतिगत नहीं, बल्कि संरचनात्मक है: एजेंटों को प्लेसहोल्डर टोकन मिलते हैं, कभी वास्तविक API कुंजियाँ नहीं। वास्तविक कुंजी केवल एक नेटवर्क सीम को पार करती है — wardn प्रॉक्सी के अंदर, अपस्ट्रीम API की ओर जाते समय — और प्रतिक्रियाओं से हटा दी जाती है, इससे पहले कि वे एजेंट तक पहुँचें। लॉग, पर्यावरण, LLM संदर्भ विंडो, स्क्रैच फ़ाइलें, और शेल हिस्ट्री केवल प्लेसहोल्डर रखते हैं।```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)

यह भार-वहन दावा है और आज एजेंट
समझौता, प्रॉम्प्ट इंजेक्शन, लॉग चोरी, और स्किल एक्सफिल्ट्रेशन के खिलाफ बचाव योग्य है।
कवर और अनकवर के बीच ईमानदार विभाजन के लिए [docs/THREAT-MODEL.md](https://github.com/rohansx/wardn/blob/main/docs/THREAT-MODEL.md) पढ़ें
— जिसमें वह स्तर शामिल है जहां मजबूत "होस्ट समझौता कुछ भी लीक नहीं करता" दावा प्राप्त किया जा सकता है।

वॉल्ट स्वयं (आराम पर एन्क्रिप्टेड, पासफ्रेज़-व्युत्पन्न कुंजी) एक वास्तविक घटक है
और इसका कारण है कि फायरवॉल एकल मशीन पर चल सकता है।
आगामी [docs/HOSTED-TIER.md](https://github.com/rohansx/wardn/blob/main/docs/HOSTED-TIER.md) स्तर अतिरिक्त रूप से
प्रॉक्सी को एक गोपनीय-कंप्यूट एन्क्लेव में लपेटता है ताकि पूरी तरह से समझौता किया गया
VPS भी कुंजी नहीं पढ़ सके।

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

## समस्या

हर AI एजेंट फ्रेमवर्क आज API कुंजियों को पर्यावरण चर या
`.env` फ़ाइलों में संग्रहीत करता है। एक समझौता किया गया एजेंट, दुर्भावनापूर्ण स्किल, कमोडिटी स्टीलर, या
प्रॉम्प्ट इंजेक्शन LLM लॉग से `Authorization: Bearer sk-...` को एक्सफिल्ट्रेट करके
आपके क्रेडेंशियल्स तक पूर्ण पहुंच प्राप्त करता है।```
~/.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

समाधान: एक प्रमाण-पत्र फ़ायरवॉल

wardn एजेंटों को एक बेकार प्लेसहोल्डर स्ट्रिंग देता है और वास्तविक कुंजी को हर उस सतह से हटा देता है जहाँ तक वह पहुँच सकता है। वास्तविक कुंजियाँ नेटवर्क लेयर पर इंजेक्ट की जाती हैं — एक एकल सीम — और प्रतिक्रियाओं से तब तक हटा दी जाती हैं जब तक वे एजेंट तक नहीं पहुँचतीं।``` 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)

## वास्तुकला```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

यह कैसे काम करता है```

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)

## प्रदर्शन

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12823/1fa6109ffd855ec98c173c5edd2d7ee77f6b0c918a3cdecb1ea5fbfe8326161d.gif" alt="wardn प्रदर्शन" width="800">
</p>

## विश्वास स्तर, ईमानदारी से

| स्तर | कहाँ | क्या रखता है |
|---|---|---|
| **सेल्फ-होस्ट (आज)** | आपका लैपटॉप, आपका VPS, CI | एन्क्रिप्टेड-एट-रेस्ट वॉल्ट, एजेंटों के खिलाफ फायरवॉल दावा। **होस्ट पर रूट** के खिलाफ बचाव नहीं करता। |
| **होस्टेड (आगामी)** | wardn-प्रबंधित या BYO-क्लाउड | गोपनीय-कंप्यूट एन्क्लेव (Nitro / SEV-SNP) + रिमोट अटेस्टेशन + एन्क्रिप्ट-टू-द-प्रॉक्सी फ्लो। वास्तविक "होस्ट समझौता कुछ भी लीक नहीं करता" दावा। |

सेल्फ-होस्ट टियर मुख्य दावा है और आज ही उपलब्ध है। होस्टेड टियर सख्त-अपग्रेड पथ है: इसकी लागत और संचालन जटिलता है, और इसका डिज़ाइन [docs/HOSTED-TIER.md](https://github.com/rohansx/wardn/blob/main/docs/HOSTED-TIER.md) में है। क्या कवर किया गया है और क्या नहीं, इसकी पूरी ईमानदार सूची:

👉 **[docs/THREAT-MODEL.md](https://github.com/rohansx/wardn/blob/main/docs/THREAT-MODEL.md)** — कवर/नॉट-कवर तालिका, "कोई सॉफ्टवेयर वॉल्ट होस्ट समझौते को समाप्त नहीं करता" स्पष्ट रूप से बताया गया है, और अपग्रेड पथ।

## स्थापना```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

त्वरित प्रारंभ```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

बस इतना ही। Claude Code अब आपके वातावरण से वास्तविक कुंजियों को पढ़ने के बजाय प्लेसहोल्डर टोकन प्राप्त करने के लिए wardn के MCP सर्वर का उपयोग करता है।

### आगे क्या होता है

1. Claude Code `get_credential_ref` को कॉल करता है → `wdn_placeholder_a1b2...` प्राप्त करता है (वास्तविक कुंजी नहीं)
2. एजेंट wardn प्रॉक्सी के माध्यम से प्लेसहोल्डर के साथ अनुरोध भेजता है
3. प्रॉक्सी प्लेसहोल्डर को वास्तविक कुंजी से बदलता है, API को अग्रेषित करता है
4. प्रॉक्सी एजेंट को वापस लौटाने से पहले प्रतिक्रिया से वास्तविक कुंजी हटा देता है

वास्तविक कुंजी कभी भी एजेंट की मेमोरी, लॉग्स या LLM संदर्भ विंडो में प्रवेश नहीं करती है।

## स्थानीय डैशबोर्ड

एक बार डेमॉन चालू हो जाए (`wardn serve`, या `wardn run` द्वारा स्पॉन किया गया), ब्राउज़र में **http://127.0.0.1:7777/ui** खोलें। केवल-पढ़ने योग्य, केवल-स्थानीय दृश्य:

- **क्रेडेंशियल्स** — प्रत्येक संग्रहीत क्रेडेंशियल अपने ACLs के साथ (अनुमत एजेंट, अनुमत डोमेन, दर सीमा + बजट बैज)।
- **हाल की गतिविधि** — विधि, डोमेन, पथ, स्थिति, एजेंट, request_id और रिकॉर्ड की गई लागत के साथ अंतिम 50 प्रॉक्सी इवेंट (`request_completed`, `credential_injected`, `rate_limit`, `budget_exceeded`, `loop_detected`, `request_error`)।
- **बजट** — प्रत्येक क्रेडेंशियल का कॉन्फ़िगर किया गया बजट (अधिकतम, खर्च किया गया, शेष, विंडो, मोड) एक प्रगति बार के साथ जो 50%/80% पार करने पर चेतावनी → खराब हो जाता है।

हर 2 सेकंड में स्वचालित रूप से पोल किया जाता है। कोई म्यूटेशन एंडपॉइंट नहीं — डैशबोर्ड से बाहर निकलने का एकमात्र रास्ता API ही है (`/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

मैनुअल सेटअप```bash

Get a placeholder token (never the real key)

wardn vault get OPENAI_KEY

→ wdn_placeholder_a1b2c3d4e5f6g7h8

List stored credentials (names only, no values)

wardn vault list

Start the proxy

wardn serve

Start proxy + MCP server for Claude Code / Cursor

wardn serve --mcp --agent my-agent

## CLI संदर्भ

### वॉल्ट प्रबंधन```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

प्रॉक्सी सर्वर```bash

wardn serve # HTTP proxy on 127.0.0.1:7777 wardn serve --host 0.0.0.0 --port 8080 # custom bind address wardn serve --config wardn.toml # load config with rate limits + ACLs wardn serve --mcp --agent my-agent # proxy + MCP server (stdio)

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

`wardn setup` क्या करता है

आपके वॉल्ट पासफ़्रेज़ के लिए संकेत देता है और सत्यापित करता है कि यह वॉल्ट खोल सकता है
आपके सिस्टम पर wardn बाइनरी पथ ढूंढता है
wardn को MCP सर्वर के रूप में पंजीकृत करता है:
- Claude Code: env कॉन्फ़िगरेशन में WARDN_PASSPHRASE के साथ claude mcp add चलाता है
- Cursor: env में पासफ़्रेज़ के साथ ~/.cursor/mcp.json में लिखता है
अगले लॉन्च पर, IDE wardn serve --mcp को एक सबप्रोसेस के रूप में स्पॉन करता है

इसके काम करने की पुष्टि करना

सेटअप चलाने के बाद, अपना IDE पुनरारंभ करें और इन प्रॉम्प्ट को आज़माएं:``` "List my wardn credentials" → Claude calls list_credentials, shows credential names (never values)

"Get me a reference to OPENAI_KEY" → Claude calls get_credential_ref, gets wdn_placeholder_... (not the real key)

"Check my rate limit for OPENAI_KEY" → Claude calls check_rate_limit, shows remaining quota

#### MCP उपकरण उपलब्ध

| उपकरण | यह क्या लौटाता है | सुरक्षा |
|------|----------------|----------|
| `get_credential_ref` | प्लेसहोल्डर टोकन (`wdn_placeholder_...`) | कभी वास्तविक मान नहीं |
| `list_credentials` | क्रेडेंशियल नाम + मेटाडेटा | एजेंट की पहुँच द्वारा फ़िल्टर किया गया |
| `check_rate_limit` | शेष कोटा, पुनः प्रयास जानकारी | केवल-पढ़ने के लिए |

### क्रेडेंशियल माइग्रेशन```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

क्रेडेंशियल्स आयात करना```bash

Classic .env file (KEY=value, comments, optional `export`, quoted values

with backslash escapes honored)

wardn import dotenv ./.env

JSON or YAML file. Format inferred from extension; either a flat map

or a structured {credentials: [{name, value}, ...]} shape.

wardn import file ./creds.json wardn import file ./creds.yaml

1Password CLI — reuses your signed-in `op` session. Default name is

derived from the ref's last segment; override with --name.

wardn import one-password op://Personal/openai/api_key wardn import one-password op://Work/anthropic/token --name ANTHROPIC_KEY

stdin — read .env-format lines. Useful for piping.

echo 'OPENAI_KEY=sk-...' | wardn import stdin

प्रत्येक आयातक पहले उपयोग पर वॉल्ट पासफ़्रेज़ के लिए संकेत देता है (या इसे
`WARDN_PASSPHRASE` / OS कीचेन से पढ़ता है)। मौजूदा मान चुपचाप अधिलेखित हो जाते हैं —
आयातक केवल मान-आधारित है, मेटाडेटा (अनुमत एजेंट /
डोमेन / दर सीमा / बजट) संरक्षित रहता है।

### स्वचालन

CI/स्क्रिप्ट के लिए, इंटरैक्टिव प्रॉम्प्ट को छोड़ने के लिए `WARDN_PASSPHRASE` और `WARDN_VALUE` एनवी वेरिएबल सेट करें:```bash
WARDN_PASSPHRASE=my-pass wardn vault list
WARDN_PASSPHRASE=my-pass WARDN_VALUE=sk-proj-xxx wardn vault set OPENAI_KEY

लाइब्रेरी API

अपने Cargo.toml में जोड़ें:```toml [dependencies] wardn = "0.4"

### वॉल्ट संचालन```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")?;

HTTP प्रॉक्सी```rust

use wardn::daemon::{Daemon, DaemonConfig};

let daemon = Daemon::new(vault, DaemonConfig::default()); daemon.serve_proxy().await?;

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

MCP उपकरण उजागर (केवल पढ़ने योग्य, कभी भी कोई क्रेडेंशियल मान वापस नहीं किया जाता):

उपकरण	विवरण
`get_credential_ref`	किसी क्रेडेंशियल के लिए अपना प्लेसहोल्डर टोकन प्राप्त करें
`list_credentials`	उन क्रेडेंशियल्स की सूची बनाएं जिन तक आप पहुंच के लिए अधिकृत हैं
`check_rate_limit`	अपनी शेष कोटा जांचें

सुरक्षा गुण

यह किन हमलों को विफल करता है

यह किस प्रकार भिन्न है...

wardn के निकटतम प्रत्यक्ष सहकर्मियों (Infisical Agent Vault, 1Password for Agents, LiteLLM वर्चुअल कुंजियाँ) के खिलाफ गहरी तुलना और wardn की गारंटियाँ OWASP के Agentic Top 10 और MCP स्पेक के सुरक्षा दिशानिर्देशों से कैसे मेल खाती हैं, इसके लिए देखें docs/comparison.md।

विश्वास सीमा

Wardn विश्वास को एक एकल स्थानीय प्रक्रिया (प्रॉक्सी) में केंद्रित करता है, बजाय इसे हर प्लगइन, उपकरण और LLM संदर्भ विंडो में फैलाने के। यह एक छोटा हमला सतह है, शून्य हमला सतह नहीं:

प्रॉक्सी आपके IDE या शेल द्वारा उत्पन्न एक उपप्रक्रिया के रूप में स्थानीय रूप से चलता है — आपके कर्नेल के समान विश्वास स्तर
वॉल्ट आराम पर एन्क्रिप्ट किया जाता है और केवल आपके पासफ्रेज़ के साथ मेमोरी में डिक्रिप्ट किया जाता है
यदि आपकी स्थानीय मशीन पूरी तरह से समझौता हो जाती है, wardn मदद नहीं कर सकता (कुछ भी नहीं कर सकता)
प्लेसहोल्डर टोकन प्रॉक्सी के लिए एक बियरर टोकन है — लेकिन यह केवल localhost:7777 के माध्यम से काम करता है, वास्तविक APIs के खिलाफ नहीं, और प्रति-एजेंट दर-सीमित और रद्द किया जा सकता है

ऑडिट लॉगिंग

प्रत्येक क्रेडेंशियल एक्सेस को ट्रेसेबिलिटी के लिए एक अद्वितीय अनुरोध ID के साथ लॉग किया जाता है:``` INFO request_id=a1b2c3 agent=claude-code method=POST domain=api.openai.com path=/v1/chat/completions proxy request received INFO request_id=a1b2c3 agent=claude-code credential=OPENAI_KEY domain=api.openai.com credential injected INFO request_id=a1b2c3 agent=claude-code upstream_status=200 credentials_injected=1 credentials_stripped=0 proxy request completed

वर्बोसिटी को नियंत्रित करने के लिए `RUST_LOG=wardn=info` (या `debug`/`trace`) सेट करें। लॉग stderr पर जाते हैं, stdout पर कभी नहीं।

## कॉन्फ़िगरेशन```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"]

परियोजना संरचना```

wardn/ ├── src/ │ ├── main.rs # CLI entry point (clap + tokio) │ ├── cli/ │ │ ├── mod.rs # Clap argument definitions │ │ ├── vault_cmd.rs # Vault subcommand handlers │ │ ├── serve_cmd.rs # Serve subcommand handler │ │ ├── run_cmd.rs # wardn run — lazy-starts the daemon, wires │ │ │ # agent env vars, execs the child │ │ ├── setup_cmd.rs # Claude Code / Cursor MCP setup (+ shell alias) │ │ └── migrate_cmd.rs # Migrate subcommand handler │ ├── lib.rs # Public API, WardenError │ ├── config.rs # TOML configuration parsing, [upstreams] map │ ├── vault/ │ │ ├── mod.rs # Vault CRUD operations │ │ ├── encryption.rs # AES-256-GCM + Argon2id + zeroize types │ │ ├── storage.rs # On-disk format (WDNV), atomic writes │ │ ├── placeholder.rs # Token generation, per-agent isolation │ │ └── keyring_store.rs # OS keychain passphrase storage │ ├── proxy/ │ │ ├── mod.rs # HTTP proxy server (axum) │ │ ├── route.rs # Provider-prefix vs Host-header upstream routing │ │ ├── inject.rs # Credential injection into requests │ │ ├── strip.rs # Credential stripping (shared pair-building) │ │ ├── stream.rs # Streaming (SSE/chunked) credential stripper │ │ └── rate_limit.rs # Token bucket rate limiter │ ├── mcp/ │ │ ├── mod.rs # MCP server (rmcp, stdio transport) │ │ └── tools.rs # Tool parameter/response types │ ├── migrate/ │ │ ├── mod.rs # Migration orchestrator + risk scoring │ │ └── scanners/ │ │ └── credentials.rs # API key pattern scanner │ └── daemon/ │ └── mod.rs # Daemon (proxy + MCP in single process) └── tests/ ├── cli_tests.rs # CLI integration tests ├── vault_tests.rs # Vault integration tests ├── proxy_tests.rs # Proxy tests without a real upstream ├── proxy_e2e_tests.rs # Real upstream via wiremock (header/body/SSE) └── run_cmd_tests.rs # Real end-to-end wardn run

## विकास```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

वॉल्ट एन्क्रिप्शन```mermaid

flowchart LR subgraph Input Pass["Passphrase"] Salt["Random Salt\n(16 bytes)"] Creds["Credentials\n(JSON)"] end

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

### फ़ाइल प्रारूप```
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)

VibeGuard का भाग

Wardn, VibeGuard का क्रेडेंशियल आइसोलेशन परत है — AI एजेंटों के लिए एक सुरक्षा डेमॉन। अन्य नियोजित मॉड्यूल:

Sentinel — prompt injection firewall
CloakPipe — PII redaction middleware
Watcher — audit log + dashboard

License

MIT

एजेंट मेमोरी में कोई क्रेडेंशियल नहीं	एजेंट प्रक्रिया केवल प्लेसहोल्डर स्ट्रिंग्स रखती है
डिस्क पर सादे पाठ में कोई क्रेडेंशियल नहीं	Argon2id KDF के साथ AES-256-GCM एन्क्रिप्टेड वॉल्ट
लॉग में कोई क्रेडेंशियल नहीं	किसी भी लॉग आउटपुट में केवल प्लेसहोल्डर दिखाई देते हैं
LLM संदर्भ में कोई क्रेडेंशियल नहीं	प्लेसहोल्डर को env में इंजेक्ट किया जाता है, असली कुंजी नेटवर्क परत पर होती है
सीमित लागत जोखिम	प्रति एजेंट प्रति क्रेडेंशियल टोकन बकेट दर सीमा
क्रेडेंशियल इको सुरक्षा	एजेंट तक पहुंचने से पहले API प्रतिक्रियाओं से वास्तविक कुंजियाँ हटा दी जाती हैं
मेमोरी सुरक्षा	`SensitiveString`/`SensitiveBytes` ड्रॉप होने पर शून्य कर दिए जाते हैं
परमाणु स्थिरता	पहले tmp लिखें फिर नाम बदलें वॉल्ट भ्रष्टाचार को रोकता है

`.env` क्रेडेंशियल चोरी	कोई `.env` फ़ाइलें नहीं। कुंजियाँ केवल एन्क्रिप्टेड वॉल्ट में
दुर्भावनापूर्ण कौशल `$OPENAI_KEY` पढ़ता है	मिलता है `wdn_placeholder_...` — बेकार
स्टीलर एजेंट कॉन्फ़िगरेशन को निशाना बनाता है	केवल प्लेसहोल्डर टोकन पाता है
प्रॉम्प्ट इंजेक्शन से कुंजी का बहिर्वेशन	कुंजी कभी भी एजेंट संदर्भ विंडो में नहीं होती
एजेंट लॉग में क्रेडेंशियल होते हैं	लॉग में केवल प्लेसहोल्डर स्ट्रिंग्स होती हैं
पूर्ण एजेंट समझौता	हमलावर के पास एक बेकार प्लेसहोल्डर होता है
लूपिंग एजेंट से लागत भगदड़	प्रति क्रेडेंशियल प्रति एजेंट दर सीमा

गुप्त प्रबंधक (Vault, AWS SM, 1Password)	सुरक्षित भंडारण + पुनर्प्राप्ति	एजेंट को रनटाइम पर अभी भी असली कुंजी मिलती है। Wardn सुनिश्चित करता है कि एजेंट इसे कभी छूता नहीं है।
Varlock	स्कीमा-आधारित `.env` मान्यकरण + AI-सुरक्षित कॉन्फ़िग	कॉन्फ़िग प्रबंधन और लीक स्कैनिंग पर केंद्रित है। Wardn रनटाइम क्रेडेंशियल इंजेक्शन करता है — कुंजी कभी एजेंट प्रक्रिया में प्रवेश नहीं करती।
OpenRouter	API रूटिंग + कुंजी प्रबंधन	क्लाइंट पर API कुंजी के साथ भरोसा करता है। Wardn नहीं करता — एजेंट एक बेकार प्लेसहोल्डर रखता है।
dotenv + .gitignore	गुप्त बातों को git से बाहर रखें	कुंजियाँ अभी भी मेमोरी, env वेरिएबल्स, लॉग में हैं। Wardn उन्हें तीनों से हटा देता है।
सर्विस मेश (Istio, Linkerd)	सेवा-से-सेवा प्रमाणीकरण	इंफ्रा-स्तरीय mTLS हल करते हैं। Wardn एजेंट-से-API प्रमाणीकरण हल करता है जहाँ एजेंट स्वयं अविश्वसनीय है।

wardn

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

wardn

समाधान: एक प्रमाण-पत्र फ़ायरवॉल

यह कैसे काम करता है```

त्वरित प्रारंभ```bash

Create an encrypted vault and store your keys

Set up Claude Code integration (one command)

मैनुअल सेटअप```bash

Get a placeholder token (never the real key)

→ wdn_placeholder_a1b2c3d4e5f6g7h8

List stored credentials (names only, no values)

Start the proxy

Start proxy + MCP server for Claude Code / Cursor

प्रॉक्सी सर्वर```bash

wardn setup क्या करता है

इसके काम करने की पुष्टि करना

क्रेडेंशियल्स आयात करना```bash

Classic .env file (KEY=value, comments, optional export, quoted values

with backslash escapes honored)

JSON or YAML file. Format inferred from extension; either a flat map

or a structured {credentials: [{name, value}, ...]} shape.

1Password CLI — reuses your signed-in op session. Default name is

derived from the ref's last segment; override with --name.

stdin — read .env-format lines. Useful for piping.

लाइब्रेरी API

HTTP प्रॉक्सी```rust

सुरक्षा गुण

यह किन हमलों को विफल करता है

यह किस प्रकार भिन्न है...

विश्वास सीमा

ऑडिट लॉगिंग

परियोजना संरचना```

वॉल्ट एन्क्रिप्शन```mermaid

VibeGuard का भाग

License

`wardn setup` क्या करता है

Classic .env file (KEY=value, comments, optional `export`, quoted values

1Password CLI — reuses your signed-in `op` session. Default name is