## Installation

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

### Binaires préconstruits

Téléchargez depuis [GitHub Releases](https://github.com/FlerAlex/enseal/releases) pour Linux (x86_64, aarch64), macOS (Intel, Apple Silicon), et Windows.

## Démarrage rapide

### Mode anonyme (zéro configuration)

Partagez des secrets en utilisant un code à usage unique. Pas de clés, pas de comptes — fonctionne immédiatement.```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

Les deux terminaux doivent être ouverts en même temps — l'expéditeur attend que le destinataire se connecte.

### Mode d'identité (basé sur des clés, sans codes)

Pour les équipes ayant une confiance établie dans les clés. Chiffrez vers un nom, aucune coordination nécessaire.```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/

Les secrets n'existent que dans la mémoire du processus enfant. Lorsqu'il se termine, ils disparaissent.

## Fonctionnalités

### Trois modes de partage

**Mode anonyme** (par défaut) — basé sur un wormhole, aucune configuration. Un code lisible par l'homme est tout ce dont vous avez besoin. L'authentification mutuelle SPAKE2 empêche les attaques MITM.```bash
enseal share .env                         # generates wormhole code
enseal receive 7-guitarist-revenge        # uses code

**Async upload (`--upload`)** — réservé à l'expéditeur. Chiffre localement et publie sur [burnurl.dev](https://burnurl.dev), renvoyant une URL autodestructible que le destinataire ouvre dans un navigateur. Aucune CLI requise du côté destinataire.```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)

L'accès à l'API nécessite un plan Pro ou Team sur burnurl.dev. Définissez `BURNURL_API_KEY` avec votre clé. Remplacez l'URL de base pour les instances auto-hébergées : `BURNURL_URL=https://burnurl.internal`.

**Identity mode** — chiffrement à clé publique pour les coéquipiers connus. Chiffrer à un nom.```bash
enseal keys init                          # one-time setup
enseal share .env --to sarah              # encrypt to sarah's public key

### Entrée flexible

enseal accepte les secrets de multiples sources :```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

Prend en charge la syntaxe de secours `${VAR:-default}`. Les références circulaires et anticipées sont détectées et rejetées. Utilisez `--no-interpolate` pour envoyer la syntaxe brute `${VAR}`.

### Filtrage

Contrôlez quelles variables sont envoyées :```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

### Inject

Recevoir des secrets et les injecter directement en tant que variables d'environnement dans un processus fils. Les secrets ne touchent jamais le système de fichiers.```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

### Chiffrement au repos

Chiffrez les fichiers `.env` pour un stockage sûr dans git en utilisant le chiffrement age :```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

### Relais public

Un relais public gratuit est disponible à `wss://relay.enseal.dev`. Utilisez-le pour des tests rapides ou lorsque vous n'avez pas besoin d'un relais privé.```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

### Relais auto-hébergé

Gardez tout à l'intérieur de votre réseau. Le relais est sans état — il ne voit que du texte chiffré.```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

Identity mode avec un relais auto-hébergé est entièrement sans code :```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

Ensuite, validez :```bash
enseal validate .env

## Comment ça fonctionne

### Mode Anonyme

**Wormhole (par défaut, sans `--relay`):**

1. L'expéditeur chiffre la charge utile avec `age`
2. Un échange de clés SPAKE2 établit un secret partagé via le relais wormhole public
3. La charge utile chiffrée transite par le relais
4. Le destinataire déchiffre avec la clé négociée
5. Le canal est détruit — usage unique, limité dans le temps

Le relais ne voit jamais le texte clair. Le code wormhole fournit une authentification mutuelle.

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

1. L'expéditeur chiffre la charge utile avec `age` et l'envoie au relais enseal sous un code de canal généré
2. Le destinataire se connecte au même relais avec le même code et reçoit la charge utile
3. Le canal est consommé dès la première réception

Il n'y a pas de SPAKE2 dans ce mode — le code du canal est le seul identifiant.

### Téléchargement asynchrone (`--upload`)

1. L'expéditeur sérialise la charge utile dans une `Envelope` (JSON, vérification d'intégrité SHA-256)
2. La chiffre éventuellement côté client avec une phrase de passe age scrypt (`--passphrase`)
3. Envoie la charge utile en POST à `burnurl.dev/api/secret` via HTTPS
4. burnurl.dev la stocke avec un chiffrement AES-256-GCM côté serveur au repos et renvoie une URL à auto-destruction
5. L'URL est valide pendant la durée de vie configurée (jusqu'à 24h sur le niveau gratuit), lecture unique

L'expéditeur partage l'URL. Le destinataire l'ouvre dans n'importe quel navigateur — pas besoin d'enseal. Avec `--passphrase`, la phrase de passe doit être partagée séparément ; le serveur ne voit jamais le texte clair.

**Niveaux :** L'accès à l'API nécessite un plan Pro ou Team sur burnurl.dev. Définissez `BURNURL_API_KEY` avec votre clé — le niveau gratuit n'a pas d'accès à l'API.

Remplacez `BURNURL_URL` pour pointer vers une instance burnurl auto-hébergée.

### Mode Identité (Clé publique)

1. L'expéditeur chiffre avec la clé publique `age` du destinataire
2. L'expéditeur signe avec sa propre clé `ed25519`
3. La charge utile transite par relais, dépôt de fichiers ou wormhole
4. Le destinataire déchiffre avec sa clé privée
5. Le destinataire vérifie la signature de l'expéditeur

La confiance repose sur les clés que vous avez importées.

**Options de transport en mode identité :**

| Transport | Drapeau | Fonctionnement |
|---|---|---|
| Wormhole (par défaut) | `--to sarah` | Génère un code, comme le mode anonyme mais avec signature |
| Push relais | `--to sarah --relay URL` | Pousse vers le canal déterministe du destinataire, pas de code |
| Dépôt de fichiers | `--to sarah --output ./dir/` | Produit un fichier `.env.age` chiffré, aucun réseau |

Avec le push relais, le destinataire écoute avec `enseal inject --listen --relay URL -- cmd` ou reçoit le dépôt de fichiers avec `enseal receive ./file.env.age`.

## Modèle de sécurité

**Protégé :**
- Secrets en transit (canal chiffré)
- Secrets dans l'historique Slack/e-mail (éphémère, aucune persistance)
- Attaques MITM (SPAKE2 / auth par clé publique)
- Relais malveillant (chiffrement de bout en bout, le relais ne voit que le texte chiffré)
- Usurpation de l'expéditeur (mode identité : signatures ed25519)
- Secrets sur disque (mode inject : mémoire du processus uniquement)
- Secrets dans git (encrypt : chiffrement au repos)

**Non protégé :**
- Terminaux compromis (si la machine est compromise, rien ne peut aider)
- Distribution des clés (vous faites confiance aux clés que vous importez — pas de PKI, pas d'AC)

## Configuration

Fichier `.enseal.toml` optionnel à la racine de votre projet :```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"]