## Instalación

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

### Binarios precompilados

Descárgalos desde [GitHub Releases](https://github.com/FlerAlex/enseal/releases) para Linux (x86_64, aarch64), macOS (Intel, Apple Silicon) y Windows.

## Inicio rápido

### Modo anónimo (sin configuración)

Comparte secretos usando un código de un solo uso. Sin llaves, sin cuentas — funciona de inmediato.```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

Ambos terminales deben estar abiertos al mismo tiempo — el emisor espera hasta que el receptor se conecte.

### Modo de identidad (basado en claves, sin códigos)

Para equipos con confianza de claves establecida. Cifrar a un nombre, sin necesidad de coordinación.```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/

Los secretos existen solo en la memoria del proceso hijo. Cuando este finaliza, desaparecen.

## Características

### Tres modos de compartir

**Modo anónimo** (predeterminado) — basado en wormhole, sin configuración. Solo necesitas un código legible por humanos. La autenticación mutua SPAKE2 previene ataques MITM.```bash
enseal share .env                         # generates wormhole code
enseal receive 7-guitarist-revenge        # uses code

**Async upload (`--upload`)** — solo para el remitente. Cifra localmente y publica en [burnurl.dev](https://burnurl.dev), devolviendo una URL autodestructiva que el destinatario abre en un navegador. No se requiere CLI en el lado del 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)

El acceso a la API requiere un plan Pro o Team en burnurl.dev. Configure `BURNURL_API_KEY` con su clave. Sobrescriba la URL base para instancias autoalojadas: `BURNURL_URL=https://burnurl.internal`.

**Modo de identidad** — cifrado de clave pública para compañeros de equipo conocidos. Cifre a un nombre.```bash
enseal keys init                          # one-time setup
enseal share .env --to sarah              # encrypt to sarah's public key

### Entrada Flexible

enseal acepta secretos de múltiples fuentes:```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

Admite la sintaxis de valor predeterminado `${VAR:-default}`. Las referencias circulares y hacia adelante se detectan y se rechazan. Use `--no-interpolate` para enviar la sintaxis literal `${VAR}`.

### Filtrado

Controla qué variables se envían:```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

Recibir secretos e inyectarlos directamente como variables de entorno en un proceso hijo. Los secretos nunca tocan el sistema de archivos.```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

### Cifrado en Reposo

Cifra archivos `.env` para almacenamiento seguro en git usando cifrado 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

### Relay público

Un relay público gratuito está disponible en `wss://relay.enseal.dev`. Úsalo para pruebas rápidas o cuando no necesites un relay privado.```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

### Relé auto-alojado

Mantén todo dentro de tu red. El relé no tiene estado — solo ve texto cifrado.```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

El modo Identity con un relay autoalojado es completamente sin código:```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

Luego valide:```bash
enseal validate .env

## Cómo Funciona

### Modo Anónimo

**Wormhole (predeterminado, sin `--relay`):**

1. El remitente cifra la carga útil con `age`
2. Un intercambio de claves SPAKE2 establece un secreto compartido a través del relé público de wormhole
3. La carga útil cifrada transita a través del relé
4. El destinatario descifra con la clave negociada
5. El canal se destruye — un solo uso, con límite de tiempo

El relé nunca ve el texto plano. El código de wormhole proporciona autenticación mutua.

**Relé Enseal (`--relay`):**

1. El remitente cifra la carga útil con `age` y la envía al relé enseal bajo un código de canal generado
2. El destinatario se conecta al mismo relé con el mismo código y recibe la carga útil
3. El canal se consume al primer recibimiento

No hay SPAKE2 en este modo — el código de canal es la única credencial.

### Carga Asíncrona (`--upload`)

1. El remitente serializa la carga útil en un `Envelope` (JSON, verificación de integridad SHA-256)
2. Opcionalmente la cifra del lado del cliente con una frase de contraseña scrypt de age (`--passphrase`)
3. Envía la carga útil mediante POST a `burnurl.dev/api/secret` a través de HTTPS
4. burnurl.dev la almacena con AES-256-GCM del lado del servidor en reposo y devuelve una URL de autodestrucción
5. La URL es válida durante el TTL configurado (hasta 24h en el nivel gratuito), solo una lectura

El remitente comparte la URL. El destinatario la abre en cualquier navegador — no se necesita enseal. Con `--passphrase`, la frase de contraseña debe compartirse por separado; el servidor nunca ve el texto plano.

**Niveles:** El acceso a la API requiere un plan Pro o Team en burnurl.dev. Establece `BURNURL_API_KEY` con tu clave — el nivel gratuito no tiene acceso a la API.

Sobrescribe `BURNURL_URL` para apuntar a una instancia de burnurl autoalojada.

### Modo de Identidad (Clave Pública)

1. El remitente cifra con la clave pública `age` del destinatario
2. El remitente firma con su propia clave `ed25519`
3. La carga útil transita a través del relé, file drop o wormhole
4. El destinatario descifra con su clave privada
5. El destinatario verifica la firma del remitente

La confianza se basa en qué claves has importado.

**Opciones de transporte en modo de identidad:**

| Transporte | Flag | Cómo funciona |
|---|---|---|
| Wormhole (predeterminado) | `--to sarah` | Genera un código, como el modo anónimo pero con firma |
| Envío por relé | `--to sarah --relay URL` | Envía al canal determinista del destinatario, sin código |
| File drop | `--to sarah --output ./dir/` | Produce un archivo `.env.age` cifrado, sin red |

Con el envío por relé, el destinatario escucha con `enseal inject --listen --relay URL -- cmd` o recibe el file drop con `enseal receive ./file.env.age`.

## Modelo de Seguridad

**Protegido:**
- Secretos en tránsito (canal cifrado)
- Secretos en el historial de Slack/correo electrónico (efímeros, sin persistencia)
- Ataques MITM (SPAKE2 / autenticación de clave pública)
- Relé malicioso (cifrado E2E, el relé solo ve texto cifrado)
- Suplantación del remitente (modo de identidad: firmas ed25519)
- Secretos en disco (modo inject: solo memoria de proceso)
- Secretos en git (encrypt: cifrado en reposo)

**No protegido:**
- Puntos finales comprometidos (si la máquina está comprometida, nada ayuda)
- Distribución de claves (confías en las claves que importas — sin PKI, sin CA)

## Configuración

Opcional `.enseal.toml` en la raíz de tu proyecto:```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"]