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** खोलें। केवल-पढ़ने योग्य, केवल-स्थानीय दृश्य: