Entwickler

Ein CLI-Aufruf. Jedes Geheimnis.

Keine Umgebungsvariablen. Keine Konfigurationsdateien. Keine Geheimnisse in Logs. Jedes Geheimnis, das Ihr Code benötigt, wird zur Laufzeit aus einem Tresor aufgelöst, den Ihr Agent nicht umgehen kann.

Das Muster

Einmal speichern. Überall abrufen.

Jeder Agent wird einmalig mit seinem eigenen Token, seinen Scopes und seinen Rate-Limits initialisiert. Danach kann der Agent Geheimnisse zur Laufzeit abrufen. Der Schlüssel wird verschlüsselt im Tresor gespeichert, niemals in Umgebungsvariablen oder im Quellcode. Wenn der Schlüssel rotiert wird, aktualisieren Sie ihn einfach in der Tresor-UI — jeder Agent übernimmt ihn automatisch.

# Einmalige Einrichtung — Token per Prompt einfügen oder per Pipe übergeben
$ echo "$CLAVITOR_TOKEN" | clavitor-cli init

# Einzelwert — per Pipe, wird niemals gespeichert
$ clavitor-cli get "Deploy Key" --field private_key | ssh-add -

# Gesamte Konfiguration — Geheimnisse aufgelöst, Template überall sicher speicherbar
$ clavitor-cli render app.config.json | myapp --config -

# Proxy — Anmeldedaten werden auf der Netzwerkschicht injiziert
$ export HTTPS_PROXY=http://localhost:1983
$ curl -H "Authorization: Bearer clavitor://OpenRouter/key" https://openrouter.ai/api/v1/models

Drei Wege der Nutzung

Field, Render oder Proxy.

Field

Ein einzelner Wert. Leiten Sie ihn per Pipe an jeden Befehl oder jedes Skript weiter. Das Geheimnis existiert nur in der Pipe — niemals in einer Variable, niemals auf der Festplatte.

Render

Eine komplette Konfigurationsdatei. Alle clavitor://-Referenzen werden beim Start aufgelöst. Das Template kann sicher überall gespeichert werden. Die aufgelöste Konfiguration existiert nur in einer Pipe.

Proxy

HTTPS-Proxy. Anmeldedaten werden transparent aus den Headern aufgelöst. Der Agent schreibt clavitor://, wo das Geheimnis stehen soll — der Proxy injiziert den echten Wert. Nichts in den Logs, nichts im Speicher des Agenten.

Welchen Weg sollte ich wählen?

Feature	Field	Render	Proxy
Geheimnisse aus Logs
Funktioniert mit jeder Sprache
Funktioniert mit jedem Tool (curl, SDK, Browser)
Agenten-Scoping & Audit
Mehrere Geheimnisse gleichzeitig
Keine Codeänderungen nötig
Konfigurationsdateien sicher committbar
SSH / Nicht-HTTP Anwendungsfälle

Schnellauswahl: Erstellen Sie ein Skript oder ein CLI-Tool? Nutzen Sie Field. Rollen Sie einen Dienst mit einer Konfigurationsdatei aus? Nutzen Sie Render. Betreiben Sie KI-Agenten, die API-Aufrufe tätigen? Nutzen Sie Proxy.

Warum dies jeden anderen Credential-Proxy schlägt.

Nichts zum Stehlen. Cloud-basierte Proxies sind hochattraktive Ziele — ein Einbruch und Sie erhalten die Anmeldedaten jedes Kunden. Lokale Proxies speichern Anmeldedaten in ihrer eigenen Konfiguration, die von jedem Agenten auf der Maschine gelesen werden kann. Der Proxy von Clavitor hält nur eine verschlüsselte Konfigurationsdatei bereit. Keine Klartext-Geheimnisse auf der Festplatte, kein Credential-Speicher, der angegriffen werden kann.

Agenten können ihn nicht knacken. Ein kompromittierter Agent kann keine Anmeldedaten aus dem Proxy extrahieren — der Proxy bietet keine API an, stellt kein Dashboard bereit und akzeptiert keine Befehle. Er liest einen Header, löst eine Referenz auf und injiziert das Ergebnis in die ausgehende Anfrage. Keine Angriffsfläche.

Nichts in den Logs. Der Agent schreibt clavitor://Entry/field. Das ist es, was in stdout, in den Logs und im Gesprächsverlauf erscheint. Der echte Zugangsdaten-Wert existiert nur innerhalb des Proxy-Prozesses für die Dauer eines einzigen HTTP-Aufrufs. Log-Aggregatoren, Crash-Dumps, CI-Artefakte — alles sauber.

Null Konfiguration. Keine Routing-Tabellen, keine API-Mappings, keine Anmeldedateien zum Verwalten. Die clavitor://-Referenz im Header ist die einzige Anweisung. Einmal init, eine Umgebungsvariable, fertig.

Sprachen

Funktioniert in jeder Sprache. Kein SDK erforderlich.

Bash

# Der Proxy übernimmt die Injektion der Anmeldedaten — keine Geheimnisse im Befehl
$ export HTTPS_PROXY=http://localhost:1983
$ curl -H "Authorization: Bearer clavitor://OpenRouter API/key" \
  https://openrouter.ai/api/v1/models

Go

key, _ := exec.Command("clavitor-cli", "get", "OpenRouter API", "--field", "key").Output()
client := openai.NewClient(option.WithAPIKey(strings.TrimSpace(string(key))))

Python

import subprocess
# Direkt übergeben — oder den HTTPS-Proxy nutzen, um das Passwort gar nicht erst im Speicher zu halten
stripe.api_key = subprocess.check_output(
    ["clavitor-cli", "get", "Stripe API", "--field", "key"]
).decode().strip()

Rust

let key = std::process::Command::new("clavitor-cli")
    .args(["get", "AWS Credentials", "--field", "secret_key"])
    .output()?;
let client = aws::Client::new(String::from_utf8(key.stdout)?.trim());

TypeScript / Node

import { execSync } from 'child_process';
const apiKey = execSync('clavitor-cli get "Anthropic API" --field key').toString().trim();
const client = new Anthropic({ apiKey });

C# / .NET

using System.Diagnostics;
var psi = new ProcessStartInfo("clavitor-cli") { RedirectStandardOutput = true, UseShellExecute = false };
psi.ArgumentList.Add("get");
psi.ArgumentList.Add("Stripe API");
psi.ArgumentList.Add("--field");
psi.ArgumentList.Add("key");
var key = Process.Start(psi)!.StandardOutput.ReadToEnd().Trim();
var client = new StripeClient(key);

PowerShell

# Einzelwert — per Pipe oder direkt verwenden
$key = clavitor-cli get "AWS Credentials" --field secret_key
Set-AWSCredential -AccessKey $env:AWS_ACCESS_KEY -SecretKey $key

# Oder den Proxy nutzen — überhaupt keine Geheimnisse im Skript
$env:HTTPS_PROXY = "http://localhost:1983"
Invoke-RestMethod -Uri "https://api.openai.com/v1/models" `
  -Headers @{ Authorization = "Bearer clavitor://OpenAI/key" }

Java

import java.nio.charset.StandardCharsets;

Process p = new ProcessBuilder("clavitor-cli", "get", "Stripe API", "--field", "key").start();
String key = new String(p.getInputStream().readAllBytes(), StandardCharsets.UTF_8).trim();
Stripe.apiKey = key;

Konfigurations-Rendering

Speichern Sie Ihre Konfigurationen. Nicht Ihre Geheimnisse.

clavitor-cli render scannt jede Datei nach clavitor://entry/field-Referenzen, löst jede gegen den Tresor auf und gibt das Ergebnis aus. Das Template kann überall gespeichert werden. Die aufgelöste Konfiguration existiert in einer Pipe. Geheimnisse berühren niemals die Festplatte.

# Template (überall speicherbar)
$ cat app.config.json
{"api_key": "clavitor://OpenRouter API/key", "db": "clavitor://Prod DB/password"}

# Aufgelöst (an Anwendung weitergeleitet, niemals auf der Festplatte)
$ clavitor-cli render app.config.json
{"api_key": "sk-or-v1-abc123...", "db": "hunter2"}

Funktioniert mit JSON, YAML, TOML, .env oder jeder Textdatei. Wenn sie clavitor:// enthält, wird sie aufgelöst.

Weitere Integrationsleitfäden

Infrastruktur

Docker, Kubernetes, Terraform, Ansible, GitHub Actions, GitLab CI, SSH. Null Geheimnisse in der Konfiguration, null Geheimnisse in den Logs.

Infrastruktur-Leitfaden →

KI-Agenten

Claude Code, Codex, OpenClaw, Hermes, CrewAI, LangChain. Scoped Tokens, Audit-Trails, automatischer Lockdown.

Agenten-Leitfaden →

MSP-Tools

PowerShell, Datto RMM, N-able, ConnectWise Automate. Anmeldedaten-Ausstellung für Ihren Kundenstamm.

MSP-Leitfaden →

Das Muster ist immer dasselbe.

Ein CLI-Aufruf, jeder Kontext. Der Scope des Agenten bestimmt, was er sehen kann. Die Stufe bestimmt, was er entschlüsseln kann. Das Audit-Log zeichnet jeden Zugriff auf.

Kostenlos starten