Seal

Chat peer-to-peer com criptografia de ponta a ponta.
Sem caixa de entrada. Sem conta para recuperar. Ninguém está ouvindo — nem nós.

github.com/Emn4tor/Seal

As mensagens viajam diretamente entre pares pela libp2p e são criptografadas com os protocolos Olm/Megolm no estilo Signal (via vodozemac) antes de saírem do seu dispositivo. O único servidor envolvido é um pequeno diretório que ajuda os pares a encontrarem o endereço atual uns dos outros. Ele nunca vê o conteúdo das mensagens e pode ser apagado com um único comando.

Consulte docs/THREAT_MODEL.md e docs/SECURITY.md para saber o que é realmente protegido e como.

Conteúdo

Capturas de tela
Recursos
Como funciona
Estrutura do projeto
1. Pré-requisitos
2. Compilação
3. Executando em modo de desenvolvimento
4. Testes
5. Configuração do backend (servidor de diretório)
6. Usando o aplicativo

Capturas de tela

Primeira execução — escolha um nome; nada mais para configurar.

Tela de primeira execução do Seal: uma explicação do modelo de criptografia ao lado de um formulário de nome de exibição, com um alternador de iniciar no login

Conversas — a barra de grupos, a lista de contatos e um painel de chat com criptografia de ponta a ponta.

Uma conversa de mensagem direta no Seal, mostrando a barra de grupos, a lista de contatos e o painel de chat com criptografia de ponta a ponta

Configurações — sensibilidade do microfone, push-to-talk, iniciar no login, alcance de rede.

Painel de configurações do Seal: sensibilidade do microfone, push-to-talk, iniciar no login e alcance de rede

Recursos

Criptografia de ponta a ponta, sempre — toda mensagem é lacrada com Olm (1:1) ou Megolm (grupos) antes de sair do seu dispositivo, usando o esquema estilo Double Ratchet do vodozemac: cada mensagem tem sua própria chave.
Sem caixa de entrada, nunca — as mensagens viajam por uma conexão direta ponto a ponto (libp2p: QUIC/TCP + Noise, com relay e hole punching para NATs). Se o destinatário estiver offline, a mensagem aguarda localmente e tenta novamente — ela nunca é enfileirada na infraestrutura de terceiros.
Um diretório, não um banco de dados — o único servidor envolvido (crates/directory-server) mapeia um ID de usuário para um endereço de rede atual e nada mais. Ele é estruturalmente incapaz de ler o conteúdo das mensagens: seu Cargo.toml nem sequer depende das crates que saberiam como fazer.
Várias contas, um dispositivo — identidades totalmente separadas (chaves, contatos, mensagens) entre as quais você pode alternar sem reiniciar.
Grupos com mudanças reais de membros — canais de texto e voz por grupo; remover alguém rotaciona a chave do grupo para que essa pessoa não consiga ler nada enviado depois.
Voz, integrada — push-to-talk com um atalho global do sistema (funciona em qualquer aplicativo, não apenas no Seal), sensibilidade de microfone ajustável e um alterador de voz opcional.
Anexos sem os metadados — os dados EXIF (localização GPS, informações de câmera/dispositivo) são removidos das imagens antes de serem enviados, ativado por padrão.
Um botão de pânico de verdade — Configurações → Dados e Privacidade exclui instantânea e irreversivelmente todas as chaves, contatos e mensagens deste dispositivo, com zero efeito sobre qualquer pessoa com quem você conversou.
Iniciar no login, se você quiser — ativado por padrão, a um interruptor de distância nas Configurações.
Uma base de código, três plataformas — janelas nativas em macOS, Windows e Linux, via Tauri.

Como funciona

Há dois tipos de identidade neste aplicativo, e eles são mantidos deliberadamente separados:

Sua identidade de chat é um par de chaves Ed25519/Curve25519 gerado localmente pelo vodozemac na primeira vez que você abre o aplicativo (identity::Identity). Seu "ID de usuário" público é apenas a impressão digital (fingerprint) dessa chave (wire_proto::user_id_from_ed25519). Ele não pode ser emitido ou revogado por nenhum servidor, porque nenhum servidor participa da sua criação.
Sua identidade de rede é um par de chaves libp2p separado (PeerId), usado apenas na camada de transporte. Ela pode mudar entre reinicializações sem afetar em nada sua identidade de chat; as duas estão ligadas apenas por um registro de presença que você mesmo assina.

Encontrar alguém e de fato conversar com essa pessoa são duas etapas diferentes:``` ┌────────────────────────┐ │ directory server │ │ (axum + one SQLite │ │ file: users, │ │ presence, group │ │ rosters. Never │ │ message content.) │ └─────────┬───────────────┘ 1. "where is bob │ 2. "here's my current right now?" │ address" (signed, │ expires in minutes) ┌─────────┴───────────────┐ ▼ ▼ ┌───────┐ 3. direct libp2p ┌───────┐ │ alice │◄──── connection ────►│ bob │ └───────┘ (Noise + Olm/ └───────┘ Megolm encrypted)

1. Alice procura Bob no diretório pelo ID de usuário dele. Isso retorna as
   chaves públicas dele e o último endereço de rede anunciado. Isso é tudo
   o que o diretório contém: chaves públicas, nomes de exibição, listas de
   associação a grupos e anúncios de endereço de curta duração
   (`crates/directory-server`).
2. Alice conecta-se diretamente a Bob via libp2p (QUIC ou TCP+Noise, com relay +
   hole-punching para peers atrás de NATs; veja `crates/net`). O diretório fica
   completamente fora de cena a partir daqui.
3. A mensagem em si é criptografada com **Olm** para um chat 1:1, ou
   **Megolm** para um grupo (`crates/crypto-session`), um esquema no estilo
   Double-Ratchet em que cada mensagem recebe sua própria chave, antes de ser
   colocada nessa conexão libp2p. Não existe caixa de entrada no servidor: se Bob
   estiver offline, a mensagem aguarda localmente e é tentada novamente, não
   sendo armazenada na infraestrutura de ninguém.

Tudo o que está acima é orquestrado pelo `AppService` de `crates/core`, que é
o que o backend Rust do aplicativo Tauri (`apps/desktop/src-tauri`) realmente
chama; a UI nunca fala diretamente com a rede.

## Estrutura do projeto```
crates/
  wire-proto        shared signed-request types for the directory API
  identity          vodozemac identity, OS-keychain key management
  storage           local encrypted store (contacts, messages, groups)
  net               libp2p transport + directory HTTP client
  crypto-session    Olm (1:1) / Megolm (group) session management
  core              orchestrates the above into `AppService` / `ChatNode`
  directory-server  the one server component (axum + SQLite)
apps/desktop         the Tauri + React app
scripts/             build + backend-deployment scripts (§2, §5)

1. Pré-requisitos

Você precisa de Rust e Node.js em todas as plataformas, além de uma toolchain específica da plataforma que o Tauri requer para compilar uma janela nativa. storage e directory-server também compilam o SQLite a partir do código-fonte, o que requer um compilador C simples (nenhuma OpenSSL ou outra biblioteca criptográfica nativa é necessária em qualquer lugar deste projeto).

Comum a todas as plataformas:

Rust (canal estável; instale via rustup, não pelo gerenciador de pacotes do seu sistema operacional)
Node.js 20+ e npm

macOS

```sh xcode-select --install ``` É só isso. As Xcode Command Line Tools fornecem tanto o compilador C quanto os frameworks de que o backend macOS do Tauri (baseado em WKWebView) precisa.

Linux

Instale um compilador C, pkg-config e os pacotes de desenvolvimento WebKitGTK/AppIndicator com os quais o backend Linux do Tauri faz link.

Debian/Ubuntu:```sh sudo apt update sudo apt install libwebkit2gtk-4.1-dev build-essential curl wget file
libxdo-dev libssl-dev libayatana-appindicator3-dev librsvg2-dev pkg-config

Fedora:```sh
sudo dnf install webkit2gtk4.1-devel openssl-devel curl wget file \
  libappindicator-gtk3-devel librsvg2-devel pkgconf-pkg-config
sudo dnf group install "C Development Tools and Libraries"

Arch:```sh sudo pacman -S --needed webkit2gtk-4.1 base-devel curl wget file openssl
appmenu-gtk-module libappindicator-gtk3 librsvg pkgconf

(Os nomes dos pacotes mudam entre versões do Tauri: se uma compilação falhar procurando por um arquivo `.pc` ausente, consulte os
[pré-requisitos atuais do Tauri para Linux](https://v2.tauri.app/start/prerequisites/)
para a sua distribuição.)

</details>

<details>
<summary><strong>Windows</strong></summary>

1. Instale as **Ferramentas de Build do Microsoft C++** (Visual Studio Installer →
   carga de trabalho "Desenvolvimento para desktop com C++"), necessárias tanto para o shell nativo do Tauri
   quanto para compilar o SQLite embutido.
2. Instale a toolchain Rust **MSVC**: `rustup default stable-msvc`.
3. **WebView2**: já está presente no Windows 11 e na maioria das instalações atualizadas do Windows
   10; se não estiver, o build do Tauri solicitará que você instale o
   runtime Evergreen.

</details>

---

## 2. Compilação

Na raiz do repositório:```sh
# Rust workspace (backend crates + the directory server)
cargo build --workspace --release

# Frontend + the actual desktop app bundle (installer/.app/.exe)
cd apps/desktop
npm install
npm run tauri build

Sandboxing: this process needs almost nothing

ProtectSystem=strict ProtectHome=true PrivateTmp=true NoNewPrivileges=true ReadWritePaths=/var/lib/seal-directory

[Install] WantedBy=multi-user.target

Notas:

- `DIRECTORY_PUBLIC_ADDR` está vinculado a **loopback** aqui de propósito; coloque um
  proxy reverso na frente para TLS (abaixo) em vez de expor o axum diretamente
  à internet.
- Crie o usuário/grupo de sistema `seal-directory` e
  `/var/lib/seal-directory` primeiro (`useradd --system --no-create-home
  seal-directory && install -d -o seal-directory -g seal-directory
  /var/lib/seal-directory`) e copie o binário `directory-server` compilado
  (de `target/release/`) para `/usr/local/bin/`.
- Coloque o token de administrador em um `EnvironmentFile` legível apenas por root, não diretamente
  no arquivo de unidade (arquivos de unidade geralmente são legíveis por todos).

</details>

### TLS através de um proxy reverso

<details>
<summary>Mostrar a configuração do Caddy / nginx</summary>

[Caddy](https://caddyserver.com) fornece HTTPS automático com o mínimo de
configuração:```
# /etc/caddy/Caddyfile
directory.example.com {
    reverse_proxy 127.0.0.1:8080
}

caddy run (ou systemctl enable --now caddy) trata da emissão/renovação de certificados por conta própria. Se preferir usar o nginx, finalize o TLS nele e use proxy_pass http://127.0.0.1:8080;, já que o aplicativo só precisa de HTTP simples do ponto de vista do proxy.

Em relação ao firewall: apenas a porta pública precisa estar acessível de fora (8080 nos exemplos acima, atrás da 443 via proxy). A porta administrativa nunca deve estar acessível de fora; acesse-a via encaminhamento de porta SSH (ssh -L 8090:127.0.0.1:8090 seu-servidor) quando precisar executar uma purga remotamente.

Isto elimina o ficheiro SQLite e recria um esquema vazio: não há instruções `DELETE`, nem estado parcial. É seguro executar sem avisar ninguém primeiro: cada registo nele é um cache de dados que cada cliente já possui localmente (o seu próprio registo, presença e quaisquer listas de grupos de que seja membro), pelo que os clientes apenas o voltam a preencher momentos após a sua próxima ação. Não há deliberadamente nenhuma política de cópias de segurança para esta base de dados; consulte [`docs/SECURITY.md`](https://github.com/emn4tor/seal/blob/HEAD/docs/SECURITY.md) para saber por que razão manter uma comprometeria todo o propósito. --- ## 6. Usar a aplicação 1. **Primeiro arranque, primeira pergunta**: qual servidor de diretório usar (§3). O padrão é o que estiver incorporado na compilação que você está a executar (um servidor de teste local, a menos que quem o compilou tenha configurado um oficial); escolha "Servidor personalizado" para apontar para um que você ou alguém em quem confie hospede. 2. **Escolha um nome de exibição.** Isto gera um par de chaves privadas no seu dispositivo (nada para lembrar e nada recuperável se perdido: isso é deliberado) e orienta-o através de uma breve explicação na aplicação sobre como a encriptação realmente funciona. Pode repeti-la em qualquer altura a partir das Definições. Cada arranque posterior volta a entrar diretamente, sem qualquer pedido; isto só acontece uma vez por conta. Adicione mais contas (identidades totalmente separadas) a partir de Definições → Contas neste dispositivo e alterne entre elas sem reiniciar. 3. **Adicionar alguém**: clique em **+** ao lado de "Mensagens diretas" e introduza o ID da pessoa (encontrado nas Definições → A Minha Identidade). Não há diretório para navegar, de propósito; a ligação é feita da mesma forma que se partilharia um número de telefone. 4. **Envie-lhes uma mensagem**: escolha o nome da pessoa na lista e escreva. A primeira mensagem para alguém estabelece automaticamente uma sessão encriptada. 5. **Iniciar um grupo**: clique em **+** na barra de ícones, dê-lhe um nome e convide pessoas pelo ID da mesma forma. Remover alguém roda a chave do grupo para que essa pessoa não consiga ler nada enviado posteriormente. 6. **Eliminar tudo**: Definições → Dados e Privacidade. Isto é instantâneo, apenas local e irreversível: destrói as suas chaves, contactos e historial *neste dispositivo* e não tem qualquer efeito nas pessoas com quem falou.

Script	Produz
`scripts/build-mac-dmg.sh`	instalador `.dmg` do macOS
`scripts/build-mac-app.sh`	pacote `.app` bruto do macOS, sem instalador
`scripts/build-linux.sh`	Linux `.AppImage` + `.deb`
`scripts/build-windows.ps1`	Windows `.msi` + `.exe` (NSIS)

Seal

Mais Populares

Ou use os scripts

Incorporando sua própria rede "Seal"

Escolhendo um servidor (primeira execução)

Testando contra uma build real (não modo dev)```sh

5. Configuração do backend (servidor de diretório)

Caminho mais rápido: o script de configuração```sh

Execução local rápida```sh

Executá-lo como um serviço real (systemd)

Sandboxing: this process needs almost nothing

Purgando```sh