Seal

Messagerie pair-à-pair, chiffrée de bout en bout.
Pas de boîte de réception. Aucun compte à récupérer. Personne n'écoute — pas même nous.

github.com/Emn4tor/Seal

Les messages voyagent directement entre pairs via libp2p et sont chiffrés avec les protocoles Olm/Megolm de type Signal (via vodozemac) avant de quitter votre appareil. Le seul serveur impliqué est un petit annuaire qui aide les pairs à trouver l'adresse actuelle des uns et des autres. Il ne voit jamais le contenu des messages, et il peut être purgé en une seule commande.

Voir docs/THREAT_MODEL.md et docs/SECURITY.md pour savoir ce qui est réellement protégé et comment.

Sommaire

Captures d'écran
Fonctionnalités
Comment ça marche
Structure du projet
1. Prérequis
2. Compilation
3. Exécution en mode développement
4. Tests
5. Configuration du backend (serveur d'annuaire)
6. Utilisation de l'application

Captures d'écran

Premier lancement — choisissez un nom ; rien d'autre à configurer.

Écran de premier lancement de Seal : explication du modèle de chiffrement à côté d'un formulaire de nom d'affichage, avec une option de lancement à la connexion

Conversations — le rail de groupes, la liste de contacts et un volet de discussion chiffré de bout en bout.

Une conversation en message direct dans Seal, montrant le rail de groupes, la liste de contacts et le volet de discussion chiffré de bout en bout

Paramètres — sensibilité du micro, push-to-talk, lancement à la connexion, accessibilité réseau.

Panneau de paramètres de Seal : sensibilité du micro, push-to-talk, lancement à la connexion et accessibilité réseau

Fonctionnalités

Chiffré de bout en bout, en permanence — chaque message est scellé avec Olm (1:1) ou Megolm (groupes) avant de quitter votre appareil, grâce au schéma de type Double Ratchet de vodozemac : chaque message possède sa propre clé.
Jamais de boîte de réception — les messages transitent par une connexion directe de pair à pair (libp2p: QUIC/TCP + Noise, avec relais et traversée de NAT). Si le destinataire est hors ligne, le message attend localement puis réessaie — il n'est jamais mis en file d'attente sur l'infrastructure de quelqu'un d'autre.
Un annuaire, pas une base de données — l'unique serveur impliqué (crates/directory-server) associe un identifiant d'utilisateur à une adresse réseau actuelle et rien d'autre. Il est structurellement incapable de lire le contenu des messages : son Cargo.toml ne dépend même pas des crates qui savent le faire.
Plusieurs comptes, un seul appareil — des identités entièrement séparées (clés, contacts, messages) entre lesquelles vous pouvez basculer sans redémarrer.
Des groupes avec de vrais changements de membres — canaux texte et vocal par groupe ; retirer quelqu'un fait pivoter la clé du groupe afin qu'il ne puisse pas lire ce qui est envoyé par la suite.
Voix intégrée — push-to-talk sur un raccourci système (fonctionne depuis n'importe quelle application, pas seulement Seal), sensibilité du micro réglable, et un modificateur de voix facultatif.
Pièces jointes sans métadonnées — les données EXIF (position GPS, informations appareil/appareil photo) sont supprimées des images avant leur envoi, activé par défaut.
Un véritable bouton panique — Paramètres → Données et confidentialité supprime instantanément et irréversiblement chaque clé, contact et message sur cet appareil, avec zéro effet sur vos interlocuteurs.
Lancement à la connexion, si vous le souhaitez — activé par défaut, à un interrupteur près dans Paramètres.
Une seule base de code, trois plateformes — fenêtres natives sur macOS, Windows et Linux, via Tauri.

Comment ça marche

Il existe deux types d'identité dans cette application, et ils sont délibérément tenus séparés :

Votre identité de discussion est une paire de clés Ed25519/Curve25519 générée localement par vodozemac la première fois que vous ouvrez l'application (identity::Identity). Votre "identifiant d'utilisateur" public n'est que l' empreinte de cette clé (wire_proto::user_id_from_ed25519). Elle ne peut être émise ni révoquée par aucun serveur, car aucun serveur n'intervient dans sa création.
Votre identité réseau est une paire de clés libp2p distincte (PeerId), utilisée uniquement pour la couche de transport. Elle peut changer entre les redémarrages sans affecter du tout votre identité de discussion ; les deux ne sont liées que par un enregistrement de présence que vous signez vous-même.

Trouver quelqu'un et lui parler réellement sont deux étapes distinctes :``` ┌────────────────────────┐ │ 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 cherche Bob dans l’annuaire à l’aide de son identifiant utilisateur. Cela renvoie ses
   clés publiques et sa dernière adresse réseau annoncée. C’est tout
   ce que contient l’annuaire : clés publiques, noms d’affichage, listes
   d’appartenance aux groupes et annonces d’adresse à courte durée de vie
   (`crates/directory-server`).
2. Alice appelle Bob directement via libp2p (QUIC ou TCP+Noise, avec relais +
   hole-punching pour les pairs derrière des NAT ; voir `crates/net`). L’annuaire est
   complètement hors du coup à partir de là.
3. Le message proprement dit est chiffré avec **Olm** pour une conversation 1:1, ou
   **Megolm** pour un groupe (`crates/crypto-session`), un schéma à la Double Ratchet
   où chaque message possède sa propre clé, avant même d’être placé sur
   cette connexion libp2p. Il n’existe pas de boîte de réception côté serveur : si Bob est hors ligne,
   le message attend localement et est réessayé, sans être stocké sur l’infrastructure
   de quiconque.

Tout ce qui précède est orchestré par le `AppService` de `crates/core`, qui est
ce que le backend Rust de l’application Tauri (`apps/desktop/src-tauri`) appelle
réellement ; l’interface utilisateur ne parle jamais au réseau directement.

## Structure du projet```
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érequis

Vous avez besoin de Rust et Node.js sur chaque plateforme, plus d'une chaîne d'outils spécifique à la plateforme dont Tauri a besoin pour créer une fenêtre native. storage et directory-server compilent également SQLite à partir des sources lors de l'empaquetage, ce qui nécessite un compilateur C standard (aucune bibliothèque OpenSSL ou autre bibliothèque de cryptographie native n'est requise dans ce projet).

Commun à toutes les plateformes :

Rust (canal stable ; installez via rustup, pas votre gestionnaire de paquets de l'OS)
Node.js 20+ et npm

macOS

```sh xcode-select --install ``` C'est tout. Les outils de ligne de commande Xcode fournissent à la fois le compilateur C et les frameworks dont le backend macOS de Tauri (basé sur WKWebView) a besoin.

Linux

Installez un compilateur C, pkg-config, et les paquets de développement WebKitGTK/AppIndicator nécessaires à l'édition de liens du backend Linux de Tauri.

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

(Les noms des paquets changent entre les versions de Tauri : si une compilation échoue en cherchant un
fichier `.pc` manquant, consultez les
[prérequis Tauri Linux actuels](https://v2.tauri.app/start/prerequisites/)
pour votre distribution.)

</details>

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

1. Installez les **Microsoft C++ Build Tools** (Visual Studio Installer →
   charge de travail « Desktop development with C++ »), nécessaires à la fois pour le shell natif de Tauri
   et pour compiler le SQLite intégré.
2. Installez la chaîne d'outils Rust **MSVC** : `rustup default stable-msvc`.
3. **WebView2** : déjà présent sur Windows 11 et sur la plupart des installations Windows
   10 à jour ; sinon, le build de Tauri vous invitera à installer le
   runtime Evergreen.

</details>

---

## 2. Compilation

Depuis la racine du dépôt :```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

Notes:

- `DIRECTORY_PUBLIC_ADDR` est volontairement lié à **loopback** ici ; placez un
  proxy inverse devant pour le TLS (ci-dessous) plutôt que d'exposer axum
  directement sur Internet.
- Créez d'abord l'utilisateur/groupe système `seal-directory` et
  `/var/lib/seal-directory` (`useradd --system --no-create-home
  seal-directory && install -d -o seal-directory -g seal-directory
  /var/lib/seal-directory`), puis copiez le binaire `directory-server` compilé
  (depuis `target/release/`) vers `/usr/local/bin/`.
- Placez le jeton admin dans un `EnvironmentFile` lisible uniquement par root,
  pas directement dans le fichier unit (les fichiers unit sont souvent
  lisibles par tous).

</details>

### TLS via un proxy inverse

<details>
<summary>Afficher la config Caddy / nginx</summary>

[Caddy](https://caddyserver.com) vous offre du HTTPS automatique avec le moins
de configuration :```
# /etc/caddy/Caddyfile
directory.example.com {
    reverse_proxy 127.0.0.1:8080
}

caddy run (ou systemctl enable --now caddy) gère lui-même l'émission et le renouvellement des certificats. Si vous préférez nginx, terminez le TLS à ce niveau et utilisez proxy_pass http://127.0.0.1:8080;, car l'application n'a besoin que de HTTP simple du point de vue du proxy.

Côté pare-feu : seul le port public doit être accessible depuis l'extérieur (8080 dans les exemples ci-dessus, derrière le 443 via le proxy). Le port d'administration ne doit jamais être accessible depuis l'extérieur ; accédez-y par redirection de port SSH (ssh -L 8090:127.0.0.1:8090 your-server) lorsque vous devez exécuter une purge à distance.

Ceci supprime le fichier SQLite et recrée un schéma vide : aucune instruction `DELETE`, aucun état partiel. Il est sûr de l'exécuter sans prévenir personne au préalable : chaque enregistrement qu'il contient est un cache de données que chaque client détient déjà localement (son propre enregistrement, sa présence et les listes de groupes dont il est membre), donc les clients ne font que le repeupler en quelques instants après leur prochaine action. Il n'y a volontairement aucune politique de sauvegarde pour cette base de données ; voir [`docs/SECURITY.md`](https://github.com/emn4tor/seal/blob/HEAD/docs/SECURITY.md) pour savoir pourquoi en conserver une irait à l'encontre de tout l'intérêt. --- ## 6. Utilisation de l'application 1. **Premier lancement, première question** : quel serveur d'annuaire utiliser (§3). La valeur par défaut est celle intégrée à la version que vous exécutez (un serveur de test local, sauf si celui qui l'a compilée a configuré un serveur officiel) ; choisissez « Custom server » pour pointer vers un serveur que vous ou une personne de confiance hébergez. 2. **Choisissez un nom d'affichage.** Cela génère une paire de clés privées sur votre appareil (rien à retenir, et rien de récupérable en cas de perte : c'est voulu) et vous guide à travers une courte explication intégrée à l'application sur le fonctionnement réel du chiffrement. Rejouez-la à tout moment depuis les Paramètres. Chaque lancement ultérieur vous ramène directement sans invite ; cela ne se produit qu'une fois par compte. Ajoutez d'autres comptes (identités entièrement séparées) depuis Paramètres → Comptes sur cet appareil, et basculez entre eux sans redémarrer. 3. **Ajoutez quelqu'un** : cliquez sur **+** à côté de « Direct messages » et saisissez son ID (visible dans *ses* Paramètres → Mon identité). Il n'y a volontairement aucun annuaire à parcourir ; vous vous connectez de la même manière que vous partageriez un numéro de téléphone. 4. **Envoyez-leur un message** : choisissez leur nom dans la liste et tapez. Le premier message envoyé à quelqu'un établit automatiquement une session chiffrée. 5. **Créez un groupe** : cliquez sur **+** dans la barre d'icônes, nommez-le, puis invitez des personnes par ID de la même manière. Retirer quelqu'un fait pivoter la clé du groupe afin qu'il ne puisse rien lire de ce qui est envoyé par la suite. 6. **Tout supprimer** : Paramètres → Données et confidentialité. C'est instantané, uniquement local et irréversible : cela détruit vos clés, contacts et historique sur *cet appareil* et n'a aucun effet sur les personnes avec qui vous avez discuté.

Script	Produit
`scripts/build-mac-dmg.sh`	installateur macOS `.dmg`
`scripts/build-mac-app.sh`	Bundle macOS `.app` brut, sans installateur
`scripts/build-linux.sh`	Linux `.AppImage` + `.deb`
`scripts/build-windows.ps1`	Windows `.msi` + `.exe` (NSIS)

Seal

Populaires

Ou utilisez les scripts

Intégrer votre propre réseau "Seal"

Choisir un serveur (premier lancement)

Tester avec une vraie build (pas le mode dev)```sh

5. Configuration du backend (serveur d'annuaire)

Le chemin le plus rapide : le script de configuration```sh

Exécution locale rapide```sh

L'exécuter comme un véritable service (systemd)

Sandboxing: this process needs almost nothing

La purger```sh