## Installazione

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

### Binari precompilati

Scarica da [GitHub Releases](https://github.com/FlerAlex/enseal/releases) per Linux (x86_64, aarch64), macOS (Intel, Apple Silicon) e Windows.

## Avvio rapido

### Modalità anonima (nessuna configurazione)

Condividi segreti usando un codice monouso. Nessuna chiave, nessun account — funziona immediatamente.```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

Entrambi i terminali devono essere aperti contemporaneamente — il mittente attende che il destinatario si connetta.

### Modalità identità (basato su chiavi, senza codici)

Per team con fiducia nelle chiavi già stabilita. Crittografa a un nome, nessuna coordinazione necessaria.```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/

I segreti esistono solo nella memoria del processo figlio. Quando esce, scompaiono.

## Caratteristiche

### Tre modalità di condivisione

**Modalità anonima** (predefinita) — basata su wormhole, configurazione zero. Tutto ciò che serve è un codice leggibile dall'uomo. L'autenticazione reciproca SPAKE2 previene gli attacchi MITM.```bash
enseal share .env                         # generates wormhole code
enseal receive 7-guitarist-revenge        # uses code

**Caricamento asincrono (`--upload`)** — solo mittente. Cripta localmente e pubblica su [burnurl.dev](https://burnurl.dev), restituendo un URL autodistruggente che il destinatario apre in un browser. Nessuna CLI richiesta lato destinatario.```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'accesso API richiede un piano Pro o Team su burnurl.dev. Imposta `BURNURL_API_KEY` con la tua chiave. Sostituisci l'URL base per istanze self-hosted: `BURNURL_URL=https://burnurl.internal`.

**Modalità identità** — crittografia a chiave pubblica per membri del team conosciuti. Crittografa verso un nome.```bash
enseal keys init                          # one-time setup
enseal share .env --to sarah              # encrypt to sarah's public key

### Input Flessibile

enseal accetta segreti da più fonti:```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

Supporta la sintassi di fallback `${VAR:-default}`. I riferimenti circolari e in avanti vengono rilevati e respinti. Usa `--no-interpolate` per inviare la sintassi grezza `${VAR}`.

### Filtraggio

Controlla quali variabili vengono inviate:```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

Riceve segreti e li inietta direttamente come variabili d'ambiente in un processo figlio. I segreti non toccano mai il filesystem.```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

### Crittografia a riposo

Crittografa i file `.env` per un archivio git sicuro usando age encryption:```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

### Relay Pubblico

Un relay pubblico gratuito è disponibile all'indirizzo `wss://relay.enseal.dev`. Usalo per test rapidi o quando non hai bisogno di un relay privato.```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

### Relay auto-ospitato

Mantieni tutto all'interno della tua rete. Il relay è stateless — vede solo testo cifrato.```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

La modalità identità con un relay auto-ospitato è completamente senza codice:```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

Poi valida:```bash
enseal validate .env

## Come Funziona

### Modalità Anonima

**Wormhole (predefinita, senza `--relay`):**

1. Il mittente crittografa il payload con `age`
2. Uno scambio di chiavi SPAKE2 stabilisce un segreto condiviso tramite il relay pubblico di wormhole
3. Il payload crittografato transita attraverso il relay
4. Il destinatario decifra con la chiave negoziata
5. Il canale viene distrutto — utilizzo singolo, con limite di tempo

Il relay non vede mai il testo in chiaro. Il codice wormhole fornisce autenticazione reciproca.

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

1. Il mittente crittografa il payload con `age` e lo invia al relay enseal con un codice di canale generato
2. Il destinatario si connette allo stesso relay con lo stesso codice e riceve il payload
3. Il canale viene consumato al primo ricevimento

Non c'è SPAKE2 in questa modalità — il codice del canale è l'unica credenziale.

### Caricamento Asincrono (`--upload`)

1. Il mittente serializza il payload in un `Envelope` (JSON, controllo di integrità SHA-256)
2. Opzionalmente lo crittografa lato client con una passphrase age scrypt (`--passphrase`)
3. Invia il payload tramite POST a `burnurl.dev/api/secret` su HTTPS
4. burnurl.dev lo memorizza con AES-256-GCM lato server a riposo e restituisce un URL autodistruttivo
5. L'URL è valido per il TTL configurato (fino a 24 ore nel piano gratuito), sola lettura singola

Il mittente condivide l'URL. Il destinatario lo apre in qualsiasi browser — non è necessario enseal. Con `--passphrase`, la passphrase deve essere condivisa separatamente; il server non vede mai il testo in chiaro.

**Piani:** L'accesso API richiede un piano Pro o Team su burnurl.dev. Imposta `BURNURL_API_KEY` con la tua chiave — il piano gratuito non ha accesso API.

Sovrascrivi `BURNURL_URL` per puntare a un'istanza burnurl self-hosted.

### Modalità Identità (Chiave Pubblica)

1. Il mittente crittografa con la chiave pubblica `age` del destinatario
2. Il mittente firma con la propria chiave `ed25519`
3. Il payload transita attraverso relay, file drop o wormhole
4. Il destinatario decifra con la propria chiave privata
5. Il destinatario verifica la firma del mittente

La fiducia si basa su quali chiavi hai importato.

**Opzioni di trasporto in modalità identità:**

| Trasporto | Flag | Come funziona |
|---|---|---|
| Wormhole (predefinita) | `--to sarah` | Genera un codice, come la modalità anonima ma con firma |
| Invio tramite relay | `--to sarah --relay URL` | Spinge al canale deterministico del destinatario, nessun codice |
| File drop | `--to sarah --output ./dir/` | Produce un file crittografato `.env.age`, nessuna rete |

Con l'invio tramite relay, il destinatario ascolta con `enseal inject --listen --relay URL -- cmd` o riceve il file drop con `enseal receive ./file.env.age`.

## Modello di Sicurezza

**Protetto:**
- Segreti in transito (canale crittografato)
- Segreti nella cronologia di Slack/email (effimeri, nessuna persistenza)
- Attacchi MITM (SPAKE2 / autenticazione a chiave pubblica)
- Relay malintenzionato (crittografia E2E, il relay vede solo il testo cifrato)
- Impersonazione del mittente (modalità identità: firme ed25519)
- Segreti su disco (modalità inject: solo memoria di processo)
- Segreti in git (crittografa: crittografia a riposo)

**Non protetto:**
- Endpoint compromessi (se la macchina è posseduta, nulla aiuta)
- Distribuzione delle chiavi (ti fidi delle chiavi che importi — nessun PKI, nessuna CA)

## Configurazione

Opzionale `.enseal.toml` nella root del progetto:```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"]