keywarden

Ihr KI-Agent kann Ihre API-Schlüssel verwenden. Er kann sie niemals lesen.

keywarden ist ein lokaler, verschlüsselter Geheimnistresor, der MCP spricht. Claude Code, Claude Desktop, Cursor oder ein beliebiger anderer MCP-Client verbindet sich damit und erhält zwei Fähigkeiten: einen authentifizierten API-Aufruf ausführen und einen Befehl mit Geheimnissen in seiner Umgebung starten. Keiner der beiden Wege bringt das Geheimnis selbst in den Kontext des Modells.

Es gibt kein get_secret-Tool. Diese Abwesenheit ist das gesamte Produkt.

   agent                keywarden                    upstream
     |                     |                          |
     |  "POST /v1/chat     |                          |
     |   using openai/prod"|                          |
     |-------------------->|                          |
     |                     | check policy             |
     |                     | decrypt key              |
     |                     | attach Authorization     |
     |                     |------------------------->|
     |                     |<-------------------------|
     |  response only      | scrub any key from body  |
     |<--------------------| append to audit log      |

Warum

Der übliche Weg, einem Agenten heute die Verwendung Ihres OpenAI-Schlüssels zu erlauben, besteht darin, den Schlüssel in einer .env-Datei zu platzieren und den Agenten perreaden zu lassen them. In the Moment, in dem das geschieht, ist der Schlüssel im Kontextfenster eines Modells. Von dort aus liegt er in den Protokollen eines Anbieters, möglicherweise in einem Trainingsdatensatz, in einem Absturzbericht und definitiv in Ihrem eigenen Verlaufsskript, das Sie in sechs Monaten in einen Fehlerbericht einfügen werden.

Einen Schlüssel zu rotieren ist lästig. Noch schlimmer ist es, nicht zu wissen, ob er ausgeleakt worden ist.

keywarden entfernt den Schritt, in dem das Modell den Schlüssel überhaupt sieht.

Related MCP server: AgentPay MCP Server

Installation

npm install -g keywarden

Node 20.10 oder neuer. Zwei Laufzeitabhängigkeiten: das MCP SDK und zod. Keine nativen Module, kein Compiler, kein Daemon.

Schnellstart

keywarden init --passphrase
keywarden add openai/prod --provider openai
keywarden mcp-config

init erstellt ~/.keywarden/ mit einem verschlüsselten Tresor und einer Standard-Policy, die standardmäßig alles ablehnt. add fragt nach jedem Feld einzeln, sodass nichts in Ihre Shell-Historie gelangt. mcp-config gibt den Block aus, den Sie in Ihren MCP-Client einfügen können.

Dann in Claude Code:

Ruf die OpenAI-Modelle-Endpoint with meinem Produktionsschlüssel auf und sage mir, auf welche Modelle ich Zugriff habe.

Das Modell ruft http_request mit ref: "openai/prod" auf. keywarden hängt den Schlüssel an, führt den Aufruf aus und gibt die Antwort zurück. Bitten Sie es, den Schlüssel auszugeben, und es wird Ihnen sagen, dass es das nicht kann.

Die Werkzeuge, die ein Agent erhält

Setzen Sie KEYWARDEN_DISABLE_EXEC=1, um run vollständig zu entfernen und nur den HTTP-Proxy bereitzustellen.

Drei Oberflächen, ein Autorisierungsmodell

Derselbe Tresor, dieselbe Policy-Engine, dieselben Grants und dasselbe Audit-Log sind auf drei Wegen erreichbar. Welchen Sie nutzen, ändert nichts daran, was erlaubt ist.

Die HTTP-Oberfläche ist es, die keywarden aus Code nutzbar macht, der nicht MCP spricht, und sie ist der erste Ort, an der keywarden einen Aufrufer von einem unterscheiden kann:

keywarden apikey create ci-runner --ref 'openai/**' --http --audit --ttl 30d
keywarden serve --port 8787

curl -s http://127.0.0.1:8787/v1/proxy/openai%2Fprod \
  -H "Authorization: Bearer kw_live_..." \
  -H "content-type: application/json" \
  -d '{"method":"POST","url":"/v1/chat/completions","body":{"model":"gpt-4o","messages":[]}}'

Der Aufrufer hält einen keywarden-Schlüssel mit Geltungsbereich openai/**, der nur genau die ihm gewährten Fähigkeiten trägt, in 30 Tagen zu abläuft und mit einem einzigen Befehl widerrufen werden kann. Er hält den OpenAI-Schlüssel nicht. Routen: /v1/secrets, /v1/secrets/:ref, /v1/proxy/:ref, /v1/run, /v1/audit, /v1/usage, /v1/whoami, /healthz.

Der Server bindet an 127.0.0.1 und verweigert ohne --allow-remote eine routbare Schnittstelle, denn jeder, der diesen Port erreichen kann, erhält damit ein Autorisierungs-Oracle für jedes Geheimnis, das der Schlüssel abdeckt.

Wer was verwendet hat – und was es gekostet hat

Jeder Eintrag im Audit-Log nennt einen Akteur, und der Akteur ist in den Hash eingeschlossen, sodass eine Zuordnung nicht umgeschrieben werden kann, ohne die Kette zu brechen. Jede proxierte Antwort wird auf die vom Provider gemeldeten Tokens hin geparst.

keywarden usage --since 7d

CREDENTIAL        CALLS          IN         OUT       TOTAL
openai/prod         142     418,220      96,410     514,630
anthropic/prod       38      92,004      31,887     123,891

ACTOR             CALLS          IN         OUT       TOTAL
http:ci-runner      118     356,900      74,220     431,120
mcp:mcp-client       62     153,324      54,077     207,401

keywarden erfasst Tokens, kein Geld. Preise ändern sich, unterscheiden sich je nach Vertrag, und ein veralteter festkodierter Satz erzeugt eine selbstsichere falsche Zahl in einem Finanzbericht. Beachten Sie: run ist nicht messbar: Eine Sobald kann ein Geheimnis innerhalb eines Unterprozesses gelangt, sieht keywarden nur einen Exitcode, keine Anzahl an Tokens.

Zwei Wege, ein Geheimnis zu verwenden

Proxy für HTTP-APIs. Der Agent beschreibt eine Anfrage, keywarden fügt das Geheimnis ein und führt die Anforderung. Funktioniert für OpenAI, Anthropic, Stripe, GitHub, Slack, Cloudflare, Vercel, Supabase und jede API, die sich mit einem Header oder einem Query-Parameter authentifiziert.

// what the agent sends
{ "ref": "openai/prod", "method": "POST", "url": "/v1/chat/completions", "body": { "model": "gpt-4o", "messages": [] } }

Injection, für den Rest. AWS benötigt SigV4-Signierung, ein Postgres-URL ist überhaupt kein HTTP, und terraform apply will echte Umgebungsvariablen. keywarden startet den Prozess selbst:

{ "command": "aws", "args": ["s3", "ls"], "inject": ["aws/prod"] }

Der Unterprozess bekommt AWS_ACCESS_KEY_ID und andere. Das Modell bekommt stdout, wobei jedes Geheimnis, das darin auftaucht, beim Verlassen des Prozesses maskiert wird.

Richtlinie

~/.keywarden/policy.json entscheidet, welches Geheimnis von welcher Fähigkeit gegen was verwendet werden darf. Regeln werden von oben nach unten ausgewertet, die erste Übereinstimmung gewinnt, und die Voreinstellung ist Verweigernung.

{
  "version": 1,
  "default": "deny",
  "redactResponses": true,
  "rules": [
    {
      "ref": "openai/**",
      "http": { "allow": true, "methods": ["POST"], "paths": ["/v1/**"] },
      "exec": { "allow": false, "commands": [] },
      "rateLimitPerMinute": 30
    },
    {
      "ref": "aws/prod",
      "http": { "allow": false },
      "exec": { "allow": true, "commands": ["aws", "terraform"] },
      "rateLimitPerMinute": 10,
      "expiresAt": "2026-12-31T00:00:00.000Z"
    }
  ]
}

Oder über die CLI:

keywarden policy allow "openai/**" --http --path "/v1/**" --method POST
keywarden policy allow aws/prod --exec aws --exec terraform --arg-deny "s3://*"
keywarden policy test aws/prod exec terraform

* matcht innerhalb eines Pfadsegments, ** spannt Segmente. expiresAt macht eine Regel temporär.

Nur einen Befehl zu nennen, ist nicht genug. Allowlisten Sie aws für aws s3 ls – und dasselbe Binary kann aws s3 cp in einen Bucket, die jemand anderem gehört. Genau das wird die Sequenzlücke, die die MCP-Bedrohungslaktur immer wieder aufweist: Jeder einzelne Aufruf ist autorisiert, und die Kombination ist die Exfiltration. Deshalb schränken Regeln auch Argumente ein:

"exec": {
  "allow": true,
  "commands": ["aws"],
  "argsDeny": ["s3://*", "--endpoint-url"],   // any match refuses the call
  "argsAllow": ["s3", "ls", "--region", "*"]  // if set, every argument must match
}

Grants: Temporärer, ablaufender, nutzungsgedeckelter Zugriff

Eine Richrichtkültur aus einer dauerhaften Konfiguration. Sie ist das floating falsche Form für „lass den Agenten für diese eine Sache, jetzt, für fünfzehn Minuten“, was heute oft das Ausweiten einer Regel bedeutet – und dann das Zurücksetzen wieder vergessen wird.

Ein Grant [Abilities] ist eine Capability, die ihre eigenen Beschränkungen mit sich trägt, entlehnt aus dem Bereich der Macaroon- und Biscuit-Archt, und wird von dir amterminal herausgegeben:

keywarden grant aws/prod --exec aws --ttl 15m --uses 5 --arg-deny "s3://*"
keywarden grant openai/prod --http --path "/v1/chat/**" --method POST --ttl 1h --uses 20
keywarden grant list
keywarden grant revoke <id>

Grants laufen von selbst ab, wenn ihr Nutzungsbudget erschöpft ist, und sind mit einem Schlüssel HMAC- der aus Ihrem Tresor abgeleitet wird, sodass eine handschriftlich bearbeitete grants.json abgelehnt wird, nicht gehrt. Ein Angenw das Abgelehnt wurde, verbraucht keine Nutzungsoption.

Setzen Sie auf einer Regel "requireGrant": true, wird die dauerhafte Konfiguration notwendig, aber nicht hinreichend: Nichts geschieht, bis ein Grant von Ihnen erstellt wird. Das ist der Human-in-the-Loop-Genehmigungsschritt, ohne dass in einem stdio-Server ein interaktiver Prompt sweet.

Integrität der Konfiguration

Das Verschlüsseln der Geheimnisse ist erst die halbe Aufgabe. policy.json entscheidet, ob ein Geheimnis verwendet werden darf, und providers.json entscheidet, wohin es gesendet werden soll. Beides sind Klartextdateien. Jemand, der nicht ein einziges Byte entschlüsseln kann, kann trotzdem einen Provider hinzufügen, dessen Hosts seiner/ihr gehören, und Ihr Geheimnis dorthin umleiten.

Deshalb verankert der Tresor einen Hash beider Dateien und weigert sich, eine Änderung zu bearbeiten, bis Sie sie angesehen haben:

keywarden trust show    # what drifted
keywarden trust         # review, then pin the current contents

Die Tresordatei selbst ist als Ganze MAC-gesichert, nicht nur pro Feld, denn provider: "openai" auf etwas anderes zu ändern, berührt niemals einen Ciphertext und würde dennoch sauber verifizieren.

Was keywarden tatsächlich durchsetzt

• Keine Klartext-Tool. Die MCP-Oberfläche hat keinen Code-Thepfad, der einen Geheimniswert zurückgibt.

• Egress-Allowlist. Ein Geheimnis kann nur an Hosts gesendet werden, die sein Provider deklariert, sowie an jene in von Ihnen ergänzt. Eine Prompt-Injection, die den Agenten veran killen, Ihren Schlüssel an attacker.example zu POSTen, scheitert am Host-Check, noch bevor das Netzwerk berührt wird.

• Nur HTTPS, keine Weiterleitungen. Eine 302 zu einer anderen Origin wird Ihren Authorization-Header nicht an einen Off-Host weiter replizieren.

• SSRF-Guard. Loopback, private Bereiche, CGNAT und Link-Local (das auch den Cloud-Metadaten-Endpoint 169.254.169.254 abdeckt) werden blockiert, und die adddesser wird in dem DNS-Lookup-Test validiert, der tatsächlich vom Socket verwendet wird. So kann DNS-Rebinding kein Fenster öffnen.

• Keine Shell. übergibt ein argv-Array an spawn mit shell: false. Es gibt keine Metazeichen, die man injizieren könnte.

• Konstruktionsbedingte Unterprozess-Umgebung. Das Kind erhält eine Allowlist von geerbten Variablen zusätzlich zu den injizierten. Ihre anderen Geheimnisse und die eigene Passphrase von keywarden werden nicht vererbt.

• Ausgabe-Schwärfung. Jedem Tool-Ergebnis werden Bekannt gemachte Geheimniswerte, ihre Base64- und URL-kodierten Formate sowie rund ein Dutzend bekannte Schlüsselsite nachgescannt. Das ist eine Additional Sicherheitsmaßnahme, nicht die primäre Steuerung.

• Manipulationssichere Auditierung. Jede Entscheidung – erlauben oder ablehnen – wird in einem Hash-verketteten Log aufgehängt. keywarden audit verify berechnet dieKette neu und meldet den ersten veränderten oder gelöschten Eintrag.

• Integrity of that Three-dor-Datei. Der Tresor wird inklusive seine Metadaten mit MAC gesichert, so kein Geheimnis einem Server ohne Erkennen zuordnen. policy.json und providers.json sind per Hashping an den Tresor und werden bei einem externen Verw Geänderung verworfen.

• Edefault reaction. Der Server verweigert den Start, wenn NODE_TLS_REJECT_UNAUTHORIZED=0, NODE_OPTIONS oder SSLKEYLOGFILE gesetzt sind, und entsprechend NODE_EXTRA_CA_CERTS und HTTPS_PROXY um eine Warnung. CVE-2026-21852 in Claude Code war ein einziger Umgebungs-Override, der ausgehende traffic mit Authorization umleitet; ein Prozess, dessen Aufgabe es ist, Zugangsdaten zu bereitstellen, nicht starten, wenn der Request-Plans unter fremder Ownership steht.

• Argumentbeschränkungen. argsAllow/argsDeny schränken ein, welche Aufrufe eines erlaubten Kommandos gestattet sind, nicht nur welches Binary.

• Atom" Ausgedünnte Grants. Temporary, laufende, nutzunglimitierte, vom Operator ausgegebene Capabilities, die mittels eines vault-abgeleiteten MAC fälschungssicher sind.

• Unbekannte-Daten-Rahmung. Proxied response bodies werden als unvertrauenswürdiger Inhalt von einem benannten Host gekennzeichnet. So wird eine eingefügte directive in einer API-Ant isolation dem Modell als Daten angezeigt.

Kryptografie

Envelope Encryption, alles aus node:crypto, keine Bibliothek von Drittanbietern.

• Ein zufälliger 256-Bit-Schlüssel verschlüsselt jedes Feld mit AES-256-GCM, wobei die Ref und den Feldnamen des Geheimnisses alle zusätzlichen authentifizierten Daten sind. So kann Ciphertext nicht zwischen verschiedenen Tresor-Einträgen verschoben werden.

• Der Datenschlüssel selbst wird mit einem Schlüsselareal of derivatable based on your passphrase, using scrypt mit Dir N=2^17, r=8, etwa 128 MiB und rund eine Sekunde pro Versuch. Das ist beabsichtigt: Die Tresordatei ist das, was ein Angreif er besitzt, also muss Offline-Raten teuer sein.

• Das Rortaten Ihrer Passphrasse hüllt nur 32 Byte neu them. Es verschlüsselt nicht jedes Geheimnis erneut.

Tresor-Modi

--passphrase ist die starke Variante. Der MCP-Server braucht KEYWARDEN_PASSPHRASE in seiner Umgebung zu Entsperren ohne Abfrage.

--keyfile schreibt einen zufälligen Schlüssel nach ~/.keywarden/masterkey, sodass nichts Anfragen müssen. Es ist bequem, und es heißt, dass jeder, who dein Home-Verzug lesen kann, den Tresor öffnet. Es ist immer noch we von viel größeren als die klarverteilte .env-Datei Projekte, denn der Schlüssel steht an einem Ort, seine Verwendung ist durch eine Quoten "gated" und jede Nutzung wird im Log aufgezeichnet. Wisse, welche Einstellung du wählst. keywarden doctor wird dich dabei helfen.

Unter Windows werden Dateimodi festgelegt, aber nicht so erzwungen, wie POSIX 0600 einwickelt. Siehe THREAT_MODEL.md.

CLI

keywarden init --passphrase|--keyfile   create the vault
keywarden doctor                        check the install, flag weak settings
keywarden trust [show]                  re-pin policy.json + providers.json after reviewing a change
keywarden grant <ref> ...               issue a temporary, use-capped capability
keywarden grant list | revoke <id>
keywarden add <ref> --provider <id>     store a credential (prompts for each field)
keywarden list                          metadata only
keywarden describe <ref>                metadata plus how it can be used
keywarden reveal <ref>                  print plaintext, asks first, always audited
keywarden rm <ref> [--field f]          delete
keywarden exec <ref[,ref]> -- <cmd>     run a command with credentials injected
keywarden policy show|init|allow|deny|test
keywarden audit [tail|verify]
keywarden passphrase                    rotate
keywarden providers                     built-in presets
keywarden mcp-config                    print the MCP client config
keywarden doctor                        check the install, flag weak settings

Eigene Provider

Alles, was nicht eingebaut ist, geht in ~/.keywarden/providers.json. Weitere docs/PROVIDERS.md-Dokumente.

{
  "acme": {
    "label": "Acme Internal API",
    "hosts": ["api.acme.internal", "*.acme.io"],
    "baseUrl": "https://api.acme.io",
    "fields": ["token", "tenant"],
    "required": ["token"],
    "auth": { "type": "header", "name": "X-Acme-Key", "template": "{{token}}" },
    "env": { "ACME_TOKEN": "{{token}}", "ACME_TENANT": "{{tenant}}" }
  }
}

Worum es Ihnen your notnt

Bitte lesen THREAT_MODEL.md underneath Sie etwas Teures anvertrauen. Die Kurzfassung:

• Wenn der Agent über ein anderes Tool beliebige lokale Befehle ausführen kann, kann er Ihre Vault-Datei und im Keyfile-Modus Ihren Master-Key lesen. keywarden schützt den Kontext des Modells, nicht Ihre Festplatte.

• run übergibt die Zugangsdaten an einen echten Prozess. Wenn Sie einen Befehl auf die Whitelist setzen, der so umgelenkt werden kann, dass er seine eigene Umgebung exfiltriert, verlassen die Zugangsdaten das System. Setzen Sie die Whitelist eng.

• Die Schwärzung ist ein Sicherheitsnetz mit Löchern. Zugangsdaten, die eine API in einer Weise umkodiert zurückgibt, die wir nicht erkennen, werden nicht abgefangen.

• keywarden hält einen Agenten nicht davon ab, mit Zugangsdaten, die er legitimerweise verwenden darf, etwas Teures oder Zerstörerisches zu tun. Dafür sind Policy-Scoping und Ratenlimits da.

Entwicklung

npm install
npm run build
npm test          # 89 unit tests + 46 end-to-end checks against the real CLI, MCP and HTTP servers

Die e2e-Suite führt die eigentlichen Binärdateien in einem Wegwerf-KEYWARDEN_HOME aus und stellt unter anderem sicher, dass keine Tool-Antwort die Zugangsdaten enthält.

Weiterführende Literatur

• THREAT_MODEL.md — was abgedeckt ist und was ehrlich gesagt nicht

• docs/RESEARCH.md — die Literatur von 2026, auf der dieses Design basiert, was übernommen wurde und was erwogen und verworfen wurde

• docs/COMPETITORS.md — die Landschaft und wo sich keywarden wirklich unterscheidet, statt nur anders vermarktet zu werden

• docs/TEAM.md — die Multi-Entwickler-Architektur: Identität, Schlüsselaustausch ohne lesbaren Server, Genehmigungsworkflow, Kostenrechnung und die Build-Reihenfolge

• docs/PROVIDERS.md — Schreiben eines eigenen Providers

Gehostet

Eine gehostete Version ist für diejenigen geplant, die einen Team-Vault, browserbasierte Verwaltung und Synchronisierung über mehrere Maschinen hinweg wünschen, mit derselben Zero-Exposure-Garantie. Alles in diesem Repository bleibt MIT und bleibt vollständig eigenständig nutzbar. Siehe docs/HOSTED.md.

Lizenz

MIT