## Instalação

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

### Binários pré-compilados

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

## Início Rápido

### Modo anônimo (sem configuração)

Compartilhe segredos usando um código único. Sem chaves, sem contas — funciona imediatamente.```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 os terminais devem estar abertos ao mesmo tempo — o remetente aguarda até que o destinatário se conecte.

### Modo de identidade (baseado em chave, sem códigos)

Para equipes com confiança de chave estabelecida. Criptografe para um nome, sem necessidade de coordenação.```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/

Segredos existem apenas na memória do processo filho. Quando ele termina, eles desaparecem.

## Funcionalidades

### Três Modos de Compartilhamento

**Modo anônimo** (padrão) — baseado em wormhole, zero configuração. Um código legível por humanos é tudo que você precisa. A autenticação mútua SPAKE2 previne ataques MITM.```bash
enseal share .env                         # generates wormhole code
enseal receive 7-guitarist-revenge        # uses code

**Async upload (`--upload`)** — apenas do remetente. Criptografa localmente e publica em [burnurl.dev](https://burnurl.dev), retornando uma URL autodestrutiva que o destinatário abre no navegador. Nenhuma CLI é necessária do lado do destinatário.```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)

O acesso à API requer um plano Pro ou Team no burnurl.dev. Defina `BURNURL_API_KEY` com sua chave. Substitua a URL base para instâncias auto-hospedadas: `BURNURL_URL=https://burnurl.internal`.

**Modo de identidade** — criptografia de chave pública para colegas conhecidos. Criptografe para um nome.```bash
enseal keys init                          # one-time setup
enseal share .env --to sarah              # encrypt to sarah's public key

### Entrada Flexível

enseal aceita segredos de múltiplas fontes:```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

Suporta a sintaxe de fallback `${VAR:-default}`. Referências circulares e diretas são detectadas e rejeitadas. Use `--no-interpolate` para enviar a sintaxe `${VAR}` bruta.

### Filtragem

Controle quais variáveis são enviadas:```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

Recebe segredos e os injeta diretamente como variáveis de ambiente em um processo filho. Segredos nunca tocam o sistema de arquivos.```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

### Criptografia em Repouso

Criptografe arquivos `.env` para armazenamento seguro no git usando criptografia 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

### Retransmissor Público

Um retransmissor público gratuito está disponível em `wss://relay.enseal.dev`. Use-o para testes rápidos ou quando não precisar de um retransmissor 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

### Relay Auto-Hospedado

Mantenha tudo dentro da sua rede. O relay é sem estado — ele vê apenas 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

O modo de identidade com um relay auto-hospedado é totalmente sem 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

Em seguida, valide:```bash
enseal validate .env

## Como Funciona

### Modo Anônimo

**Wormhole (padrão, sem `--relay`):**

1. O remetente criptografa a carga útil com `age`
2. Uma troca de chaves SPAKE2 estabelece um segredo compartilhado através do relé público wormhole
3. A carga útil criptografada transita através do relé
4. O destinatário descriptografa com a chave negociada
5. O canal é destruído — uso único, com tempo limitado

O relé nunca vê texto simples. O código wormhole fornece autenticação mútua.

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

1. O remetente criptografa a carga útil com `age` e a envia para o relé enseal sob um código de canal gerado
2. O destinatário conecta-se ao mesmo relé com o mesmo código e recebe a carga útil
3. O canal é consumido no primeiro recebimento

Não há SPAKE2 neste modo — o código do canal é a única credencial.

### Upload Assíncrono (`--upload`)

1. O remetente serializa a carga útil em um `Envelope` (JSON, verificação de integridade SHA-256)
2. Opcionalmente, criptografa no lado do cliente com uma frase-senha age scrypt (`--passphrase`)
3. Faz POST da carga útil para `burnurl.dev/api/secret` via HTTPS
4. O burnurl.dev armazena com AES-256-GCM no servidor em repouso e retorna uma URL de autodestruição
5. A URL é válida pelo TTL configurado (até 24h no plano gratuito), leitura única

O remetente compartilha a URL. O destinatário a abre em qualquer navegador — não é necessário enseal. Com `--passphrase`, a frase-senha deve ser compartilhada separadamente; o servidor nunca vê texto simples.

**Planos:** O acesso à API requer um plano Pro ou Team no burnurl.dev. Defina `BURNURL_API_KEY` como sua chave — o plano gratuito não tem acesso à API.

Substitua `BURNURL_URL` para apontar para uma instância burnurl auto-hospedada.

### Modo de Identidade (Chave Pública)

1. O remetente criptografa com a chave pública `age` do destinatário
2. O remetente assina com sua própria chave `ed25519`
3. A carga útil transita através de relé, file drop ou wormhole
4. O destinatário descriptografa com sua chave privada
5. O destinatário verifica a assinatura do remetente

A confiança baseia-se nas chaves que você importou.

**Opções de transporte no modo de identidade:**

| Transporte | Flag | Como funciona |
|---|---|---|
| Wormhole (padrão) | `--to sarah` | Gera um código, como no modo anônimo, mas com assinatura |
| Relay push | `--to sarah --relay URL` | Envia para o canal determinístico do destinatário, sem código |
| File drop | `--to sarah --output ./dir/` | Produz um arquivo `.env.age` criptografado, sem rede |

Com push de relé, o destinatário escuta com `enseal inject --listen --relay URL -- cmd` ou recebe o file drop com `enseal receive ./file.env.age`.

## Modelo de Segurança

**Protegido:**
- Segredos em trânsito (canal criptografado)
- Segredos no histórico Slack/e-mail (efêmero, sem persistência)
- Ataques MITM (SPAKE2 / autenticação de chave pública)
- Relé malicioso (criptografia E2E, relé vê apenas texto cifrado)
- Impersonação do remetente (modo de identidade: assinaturas ed25519)
- Segredos em disco (modo inject: apenas memória do processo)
- Segredos no git (criptografar: criptografia em repouso)

**Não protegido:**
- Pontos finais comprometidos (se a máquina estiver comprometida, nada ajuda)
- Distribuição de chaves (você confia nas chaves que importou — sem PKI, sem CA)

## Configuração

Opcional `.enseal.toml` na raiz do seu projeto:```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"]