## Installation

### Von crates.io```bash
cargo install enseal

### Vorgefertigte Binärdateien

Herunterladen von [GitHub Releases](https://github.com/FlerAlex/enseal/releases) für Linux (x86_64, aarch64), macOS (Intel, Apple Silicon) und Windows.

## Schnellstart

### Anonymer Modus (keine Einrichtung)

Teilen Sie Geheimnisse mit einem Einmalcode. Keine Schlüssel, keine Konten – funktioniert sofort.```bash
# terminal 1 (sender)
enseal share .env
  Share code:  7-guitarist-revenge
  Secrets:     14 variables
  Expires:     on first receive

# terminal 2 (recipient) — enter the code
enseal receive 7-guitarist-revenge
ok: 14 secrets written to .env

Beide Terminals müssen gleichzeitig geöffnet sein — der Sender wartet, bis der Empfänger eine Verbindung herstellt.

### Identitätsmodus (schlüsselbasiert, keine Codes)

Für Teams mit etabliertem Schlüsselvertrauen. Verschlüsseln Sie auf einen Namen, keine Koordination erforderlich.```bash
# one-time setup
enseal keys init
enseal keys export > my-key.pub          # share this with teammates
enseal keys import teammate-key.pub      # import theirs

# sender encrypts to recipient by name
enseal share .env --to sarah

# or push through the public relay (no codes at all)
enseal share .env --to sarah --relay wss://relay.enseal.dev

# or produce an encrypted file (no network)
enseal share .env --to sarah --output ./drop/

Geheimnisse existieren nur im Speicher des untergeordneten Prozesses. Wenn er endet, sind sie verschwunden.

## Funktionen

### Drei Freigabemodi

**Anonymer Modus** (Standard) — wormhole-basiert, keine Einrichtung erforderlich. Ein lesbarer Code ist alles, was Sie brauchen. Gegenseitige SPAKE2-Authentifizierung verhindert MITM-Angriffe.```bash
enseal share .env                         # generates wormhole code
enseal receive 7-guitarist-revenge        # uses code

**Async upload (`--upload`)** — nur für den Sender. Verschlüsselt lokal und veröffentlicht auf [burnurl.dev](https://burnurl.dev) und gibt eine selbstzerstörende URL zurück, die der Empfänger in einem Browser öffnet. Auf der Empfängerseite ist keine CLI erforderlich.```bash
enseal share .env --upload
#   Secret URL:  https://burnurl.dev/s/a3f9c2e1...
#   Expires:     2026-03-08 19:42:00 UTC (24h)
#   Reads:       1 (self-destructs on first open)

API-Zugriff erfordert einen Pro- oder Team-Tarif auf burnurl.dev. Setzen Sie `BURNURL_API_KEY` auf Ihren Schlüssel. Überschreiben Sie die Basis-URL für selbst gehostete Instanzen: `BURNURL_URL=https://burnurl.internal`.

**Identitätsmodus** — Public-Key-Verschlüsselung für bekannte Teammitglieder. Verschlüsseln an einen Namen.```bash
enseal keys init                          # one-time setup
enseal share .env --to sarah              # encrypt to sarah's public key

### Flexible Eingabe

enseal akzeptiert Geheimnisse aus mehreren Quellen:```bash
# .env file (default)
enseal share .env
enseal share staging.env

# environment profile
enseal share --env staging               # resolves to .env.staging

# pipe from stdin
echo "sk_live_abc123" | enseal share
cat secrets.env | enseal share
pass show stripe/key | enseal share --to sarah

# inline (careful — visible in shell history)
enseal share --secret "API_KEY=sk_live_abc123"

# wrap raw string as KEY=VALUE
echo "sk_live_abc123" | enseal share --as STRIPE_KEY

Unterstützt die Fallback-Syntax `${VAR:-default}`. Zirkuläre und Vorwärtsreferenzen werden erkannt und zurückgewiesen. Verwenden Sie `--no-interpolate`, um die rohe `${VAR}`-Syntax zu senden.

### Filtern

Steuern Sie, welche Variablen gesendet werden:```bash
# exclude public/non-secret vars
enseal share .env --exclude "^PUBLIC_|^NEXT_PUBLIC_"

# send only matching vars
enseal share .env --include "^DB_|^API_"

# skip .env parsing entirely (send raw file)
enseal share .env --no-filter

### Injizieren

Empfange Geheimnisse und injiziere sie direkt als Umgebungsvariablen in einen Kindprozess. Geheimnisse berühren niemals das Dateisystem.```bash
# anonymous mode: inject via wormhole code
enseal inject 7-guitarist-revenge -- npm start

# identity mode: listen for incoming transfer on relay
enseal inject --listen --relay wss://relay.enseal.dev -- docker compose up

# from encrypted file drop
enseal inject ./staging.env.age -- python manage.py runserver

### Verschlüsselung im Ruhezustand

Verschlüsseln Sie `.env`-Dateien für sichere Git-Speicherung mit age-Verschlüsselung:```bash
# whole-file encryption
enseal encrypt .env
ok: .env encrypted in-place (14 variables, age key)

enseal decrypt .env

# per-variable: keys visible for diffing, values encrypted
enseal encrypt .env --per-var
# DB_HOST=ENC[age:abc123...]
# DB_PORT=ENC[age:def456...]

# multi-recipient: anyone on the team can decrypt
enseal encrypt .env --to sarah --to alex

### Öffentlicher Relay

Ein kostenloser öffentlicher Relay ist verfügbar unter `wss://relay.enseal.dev`. Verwenden Sie ihn für schnelle Tests oder wenn Sie keinen privaten Relay benötigen.```bash
# check relay health
curl https://relay.enseal.dev/health

# use it for identity-mode transfers
enseal share .env --to sarah --relay wss://relay.enseal.dev
enseal inject --listen --relay wss://relay.enseal.dev -- npm start

# or set it globally
export ENSEAL_RELAY=wss://relay.enseal.dev

### Selbst gehosteter Relay

Behalten Sie alles in Ihrem Netzwerk. Der Relay ist zustandslos — er sieht nur Chiffretext.```bash
# Docker (one command)
docker run -d -p 4443:4443 enseal/relay

# Or as a binary
enseal serve --port 4443

# Check relay health
curl http://localhost:4443/health

Identitätsmodus mit einem selbst gehosteten Relay ist vollständig codefrei:```bash
# receiver listens on the relay
enseal inject --listen --relay ws://relay.internal:4443 -- npm start

# sender pushes directly — no code generated
enseal share .env --to alex --relay ws://relay.internal:4443
ok: pushed to alex

Dann validieren:```bash
enseal validate .env

## Funktionsweise

### Anonymer Modus

**Wormhole (Standard, ohne `--relay`):**

1. Der Absender verschlüsselt die Nutzlast mit `age`
2. Ein SPAKE2-Schlüsselaustausch etabliert ein gemeinsames Geheimnis über das öffentliche Wormhole-Relay
3. Die verschlüsselte Nutzlast wird durch das Relay geleitet
4. Der Empfänger entschlüsselt mit dem ausgehandelten Schlüssel
5. Der Kanal wird zerstört — einmalige Nutzung, zeitlich begrenzt

Das Relay sieht niemals Klartext. Der Wormhole-Code bietet gegenseitige Authentifizierung.

**Enseal-Relay (`--relay`):**

1. Der Absender verschlüsselt die Nutzlast mit `age` und sendet sie unter einem generierten Kanalkode an das Enseal-Relay
2. Der Empfänger verbindet sich mit demselben Code mit demselben Relay und empfängt die Nutzlast
3. Der Kanal wird beim ersten Empfang verbraucht

In diesem Modus gibt es kein SPAKE2 — der Kanalkode ist die einzige Berechtigung.

### Asynchroner Upload (`--upload`)

1. Der Absender serialisiert die Nutzlast in ein `Envelope` (JSON, SHA-256-Integritätsprüfung)
2. Verschlüsselt sie optional clientseitig mit einer age scrypt-Passphrase (`--passphrase`)
3. Sendet die Nutzlast per POST an `burnurl.dev/api/secret` über HTTPS
4. burnurl.dev speichert sie serverseitig mit AES-256-GCM im Ruhezustand (at rest) und gibt eine Self-Destruct-URL zurück
5. Die URL ist für die konfigurierte TTL gültig (bis zu 24h im kostenlosen Tarif), nur einmal lesbar

Der Absender teilt die URL. Der Empfänger öffnet sie in einem beliebigen Browser — kein Enseal erforderlich. Mit `--passphrase` muss die Passphrase separat geteilt werden; der Server sieht niemals Klartext.

**Tarife:** Für den API-Zugriff ist ein Pro- oder Team-Plan auf burnurl.dev erforderlich. Setzen Sie `BURNURL_API_KEY` auf Ihren Schlüssel — der kostenlose Tarif hat keinen API-Zugriff.

Überschreiben Sie `BURNURL_URL`, um auf eine selbst gehostete burnurl-Instanz zu verweisen.

### Identitätsmodus (Öffentlicher Schlüssel)

1. Der Absender verschlüsselt mit dem öffentlichen `age`-Schlüssel des Empfängers
2. Der Absender signiert mit seinem eigenen `ed25519`-Schlüssel
3. Die Nutzlast wird durch Relay, File Drop oder Wormhole geleitet
4. Der Empfänger entschlüsselt mit seinem privaten Schlüssel
5. Der Empfänger überprüft die Signatur des Absenders

Vertrauen basiert darauf, welche Schlüssel Sie importiert haben.

**Transportoptionen im Identitätsmodus:**

| Transport | Flag | Funktionsweise |
|---|---|---|
| Wormhole (Standard) | `--to sarah` | Generiert einen Code, wie im anonymen Modus, aber mit Signierung |
| Relay-Push | `--to sarah --relay URL` | Pusht in den deterministischen Kanal des Empfängers, kein Code |
| File Drop | `--to sarah --output ./dir/` | Erzeugt verschlüsselte `.env.age`-Datei, kein Netzwerk |

Beim Relay-Push hört der Empfänger mit `enseal inject --listen --relay URL -- cmd` mit oder empfängt den File Drop mit `enseal receive ./file.env.age`.

## Sicherheitsmodell

**Geschützt:**
- Geheimnisse während der Übertragung (verschlüsselter Kanal)
- Geheimnisse im Slack/E-Mail-Verlauf (flüchtig, keine Persistenz)
- MITM-Angriffe (SPAKE2 / Public-Key-Authentifizierung)
- Bösartiges Relay (Ende-zu-Ende-Verschlüsselung, Relay sieht nur Chiffretext)
- Identitätsdiebstahl des Absenders (Identitätsmodus: ed25519-Signaturen)
- Geheimnisse auf der Festplatte (Inject-Modus: nur im Prozessspeicher)
- Geheimnisse in Git (Verschlüsselung im Ruhezustand)

**Nicht geschützt:**
- Kompromittierte Endpunkte (wenn die Maschine kompromittiert ist, hilft nichts)
- Schlüsselverteilung (Sie vertrauen den importierten Schlüsseln — keine PKI, keine CA)

## Konfiguration

Optionale `.enseal.toml`-Datei im Stammverzeichnis Ihres Projekts:```toml
[defaults]
relay = "wss://relay.enseal.dev"     # public relay (identity mode)
# relay = "ws://relay.internal:4443" # self-hosted without TLS
# relay = "wss://relay.internal:4443" # self-hosted with TLS reverse proxy

[filter]
exclude = ["^PUBLIC_", "^NEXT_PUBLIC_", "^REACT_APP_"]

[identity]
default_recipient = "devops-team"

[schema]
required = ["DATABASE_URL", "API_KEY", "JWT_SECRET"]