# Meow v2 — Architecture Rust Ce document décrit la ré-architecture de `meowlib` / `meowsrv` / `meowcli` / `meowjsonlib` en Rust. La progression est suivie dans [`ROADMAP.md`](ROADMAP.md). > **Décision** : protocole **v2 en rupture nette**, sans compatibilité réseau avec la v1 en Go > (OpenPGP). Les clients et serveurs v1 et v2 ne communiquent pas entre eux. La migration se > fait en bloc (serveur, puis CLI, puis application Flutter). Les données v1 importables > (pseudo, serveurs, historique) passent par un outil d'import (phase 10). Les contacts, eux, > doivent refaire une invitation, car leurs clés ne sont pas transposables. --- ## 1. Constat sur la v1 (Go) | Problème v1 | Conséquence | Réponse v2 | |---|---|---| | OpenPGP (gopenpgp) pour tout : clés base64 de ~600 octets, paquets PGP, S2K pour le stockage | Lent, volumineux (QR codes énormes), surface d'attaque large | Primitives brutes : X25519, Ed25519, XChaCha20-Poly1305, HKDF-SHA256, Argon2id. Clés de 32 octets. | | `PackedUserMessage.signature` = signature **détachée, en clair, sur le texte en clair** | Un serveur qui connaît la clé publique d'un contact peut confirmer l'auteur ou deviner le contenu. Pas de déniabilité. | Pas de signature sur les messages : l'authentification passe par la session Double Ratchet (AEAD avec les identités en données associées). Déniabilité au sens Signal. | | Trois couches empilées (asym + sym + DR) avec un état DR sérialisé en JSON | Coûteux, état fragile | Une seule couche pair-à-pair : Double Ratchet. L'état est sérialisé en protobuf et chiffré au repos. | | `ConversationRequest.lookup_signature` jamais vérifiée (`// todo sign it`) | N'importe qui connaissant une clé de lookup peut **vider la boîte** d'un autre | Le pull est authentifié : signature Ed25519 de la clé de mailbox, liée au serveur, à un horodatage et à l'id de requête (anti-rejeu). | | Singleton global `GetConfig().GetIdentity()` partout | Code non testable, non ré-entrant, une seule identité par processus | Pas d'état global. `MeowClient` est un objet possédé, injectable et clonable (`Arc`). | | API FFI : 63 fonctions C, paramètres JSON, framing binaire maison, chemins de fichiers en paramètre | Fragile, lent (double sérialisation), erreurs en JSON | `flutter_rust_bridge` v2 : types Dart générés, `Future`/`Stream` natifs, erreurs typées. | | Inbox/outbox sous forme de fichiers protobuf + une base SQLite par file d'envoi + Badger + SQLite par pair | 4 mécanismes de persistance, incohérences possibles | Une seule base SQLite par identité (WAL), transactions. Les blobs sensibles sont chiffrés au niveau applicatif. | | Redis obligatoire, logs envoyés en dur vers Loki | Difficile à tester, fuite de métadonnées | Trait `ServerStore` avec un backend mémoire (dev/tests) et un backend Redis (prod). Logs locaux uniquement, sans clés ni mailbox en clair. | | `meowsrv/config/*.json` contient clé privée serveur et secret LiveKit | Secrets versionnés | Clé serveur dans un fichier `0600` séparé (`server.key`), secrets passés par variables d'environnement. | | TTL des invitations : `time.Duration(timeout*1000000)` interprète des secondes comme des millisecondes, et `mwiv:` est stockée sans expiration | Les invitations ne meurent jamais, et la réponse expire après 86 s au lieu de 24 h | TTL Redis réels (`SET EX`). Purge des mailbox via TTL configurable. | | Accusés de livraison serveur : écriture dans `dvyrq:{uuid}` mais lecture dans `msg:{uuid}` | Le suivi de livraison ne fonctionne pas | Phase 5 : accusés de bout en bout, chiffrés dans le ratchet (pas de suivi côté serveur). | --- ## 2. Vue d'ensemble des crates ``` rust/ ├── Cargo.toml workspace ├── proto/meow.proto schéma unique du protocole v2 (source de vérité, aussi pour Dart) ├── crates/ │ ├── meow-proto (lib) types prost générés + helpers d'encodage. Aucune logique. │ ├── meow-crypto (lib) primitives : clés, sealed box, KDF, AEAD, Double Ratchet, chiffrement au repos │ ├── meow-core (lib) protocole pur, sans E/S : cartes, invitation 4 étapes, codec de messages, │ │ requêtes serveur scellées, authentification des pulls │ ├── meow-store (lib) persistance client : sac de blocs chiffrés, espaces cachés (identité, contacts, serveurs, │ │ sessions, messages, file d'envoi) [phase 4] │ ├── meow-client (lib) façade asynchrone haut niveau : transport HTTP, envoi/réception, │ │ files d'envoi, long-poll, événements │ ├── meow-server (lib+bin `meowsrv`) serveur axum, stores mémoire/Redis │ ├── meow-cli (bin `meow`) CLI clap, parité avec meowcli │ └── meow-ffi (lib cdylib) [à créer] pont flutter_rust_bridge → bastet [phase 7] └── tests/e2e.sh test bout-en-bout (équivalent de meowcli/test.sh) ``` Les dépendances vont uniquement vers le bas : ``` meow-cli ─┐ meow-ffi ─┐ ▼ ▼ meow-client ──► meow-store │ ▼ meow-server ──► meow-core ──► meow-crypto │ ▼ meow-proto ``` * `meow-core` ne fait **aucune E/S** (ni réseau, ni disque, ni horloge implicite : le temps est passé en paramètre). Il est donc entièrement testable de façon déterministe et réutilisable côté serveur, CLI et mobile. * `meow-crypto` n'expose que des types forts (`SigningKey`, `DhSecret`, `MailboxId`…) et met à zéro les secrets avec `zeroize`. Il n'expose jamais d'octets bruts de clé privée hors de la sérialisation explicite. --- ## 3. Cryptographie v2 | Usage | Primitive | Crate | |---|---|---| | Signature (identité par contact, mailbox, carte serveur) | Ed25519 | `ed25519-dalek` | | Accord de clé | X25519 | `x25519-dalek` | | AEAD | XChaCha20-Poly1305 (nonce aléatoire de 24 octets) | `chacha20poly1305` | | KDF | HKDF-SHA256, avec des labels de domaine `meow/v2/...` | `hkdf`, `sha2` | | Dérivation de mot de passe | Argon2id (m=64 MiB, t=3, p=1 ; réglable) | `argon2` | | Aléa | `OsRng` | `rand_core` | ### 3.1 Sealed box (requêtes serveur, invitations) Construction ECIES équivalente à HPKE en mode base (RFC 9180) : ``` eph ← X25519 éphémère shared = DH(eph, recipient_pk) okm(64) = HKDF(ikm=shared, salt=eph_pk‖recipient_pk, info="meow/v2/seal/"‖context) k_req, k_resp = okm[0..32], okm[32..64] ciphertext = XChaCha20-Poly1305(k_req, nonce, plaintext, aad=context) ``` `k_resp` sert à chiffrer la **réponse** du serveur. Le serveur reste sans état, et le client n'a pas besoin de s'identifier auprès de lui : les requêtes sont **anonymes** par construction. ### 3.2 Clés par contact Comme en v1, chaque contact a ses propres clés, ce qui empêche de corréler les contacts entre eux : | Clé | Type | Rôle | |---|---|---| | `identity` | Ed25519 | Signe le transcript de l'invitation (preuve de possession) | | `dh` | X25519 | Clé statique utilisée pour l'accord initial (X3DH simplifié) | | `mailbox` | Ed25519 | La clé publique **est** l'adresse de la boîte aux lettres (`MailboxId`). La clé privée signe les pulls. | | `ratchet` | X25519 | Clé initiale du Double Ratchet (rôle de « signed prekey » côté invité) | ### 3.3 Invitation en 4 étapes (le transport est indépendant : fichier, QR, serveur, BLE) ``` Initiateur (I) Invité (V) 1. Offer { inv_id, nom, offer_dh (X25519 temp), answer_mailbox (Ed25519 temp), msg, answer_servers, expires_at } ───────► 2. Crée ses clés + Card_V Answer = seal(offer_dh, {Card_V, sig_V(H(offer) ‖ Card_V)}) ◄─────── (fichier, ou dépôt dans answer_mailbox) 3. Ouvre Answer, vérifie sig_V, crée ses clés + Card_I eph_I ← X25519 ; th = H(offer ‖ Card_V ‖ Card_I ‖ eph_I) SK = HKDF( DH(I.dh, V.dh) ‖ DH(eph_I, V.dh) ‖ DH(eph_I, V.ratchet) ; salt = th ) DR.init_sender(SK, V.ratchet) → I peut envoyer immédiatement Confirm = seal(V.dh, {Card_I, eph_I, sig_I(th), first_message = DR(HandshakeAck)}) ───► 4. Ouvre Confirm, vérifie sig_I, recalcule SK DR.init_receiver(SK, V.ratchet_kp) déchiffre first_message → chaîne d'envoi prête ◄─────── envoie DR(HandshakeAck) dans I.mailbox 5. Réception de l'ack → contact « Active » des deux côtés ``` Pourquoi `first_message` : dans un Double Ratchet, le receveur ne peut pas émettre avant d'avoir reçu un message. Embarquer le premier message de l'initiateur dans le Confirm permet à l'invité d'émettre l'ack dès l'étape 4. L'initiateur, lui, peut envoyer dès l'étape 3 (les messages attendent dans la mailbox de l'invité et sont lisibles après l'étape 4). Chaque étape est liée aux précédentes par le transcript `th` : un Answer ou un Confirm rejoué, falsifié ou destiné à un autre invité est rejeté. Les 10 premiers octets de `th` donnent un « numéro de sécurité » identique des deux côtés (`meow contact show`). La vérification visuelle (SAS) de `peer_secure` reste disponible au-dessus (phase 8). ### 3.4 Messages entre pairs ``` UserMessage (protobuf) → padding par paliers (256 o, 1 Kio, 4 Kio, 16 Kio, 64 Kio…) → DoubleRatchet.encrypt(ad = "meow/v2/msg" ‖ id_émetteur ‖ id_destinataire) → PeerEnvelope { header, ciphertext } → Deposit { mailbox = contact.mailbox, payload = PeerEnvelope } → Request scellée vers chaque serveur de pull du contact ``` Le Double Ratchet suit la spécification Signal (KDF_RK = HKDF, KDF_CK = HMAC-SHA256). Les clés sautées sont bornées (`MAX_SKIP = 1000`). Le chiffrement des en-têtes est prévu en phase 8. ### 3.5 Authentification des pulls ``` MailboxAuth { mailbox, timestamp, signature, acks[] } signature = Ed25519_sign(mailbox_sk, "meow/v2/pull" ‖ server_sign_pk ‖ mailbox ‖ timestamp ‖ SHA-256(acks, préfixés par leur longueur) ‖ request_id) ``` Le serveur rejette si `|now - timestamp| > 300 s`, si la signature est invalide ou si `request_id` a déjà été vu (cache anti-rejeu avec TTL de 600 s). Les `acks` étant signés, seul le propriétaire d'une mailbox peut en supprimer les messages. ### 3.6 Livraison au moins une fois Un pull **ne supprime rien**. Chaque `StoredMessage` porte un `id` attribué par le serveur, et reste stocké jusqu'à ce qu'un pull ultérieur l'acquitte dans `MailboxAuth.acks`. ``` client serveur Pull{auths(acks=[])} ─────▶ fetch (sans supprimer) ◀───── PullResult{messages[id], more} traitement, puis enregistrement de l'état ET des acks en attente Pull{auths(acks=[ids]), wait=0} ─────▶ ack(ids), puis fetch ◀───── PullResult{…} ``` * Côté client, les acks en attente (`PendingAck {server, mailbox, id}`) sont enregistrés **dans la même sauvegarde** que l'état du ratchet. Un message redélivré dont l'id est encore en attente n'est donc pas retraité : il est simplement acquitté de nouveau. * `sync(wait)` relance un tour sans attente tant qu'il reçoit du nouveau ou que le serveur signale `more` (limites de 256 messages et 16 Mio par pull). Un `sync` se termine donc avec ses acks envoyés. * Une mailbox qui disparaît alors qu'elle a encore des acks en attente (boîte de réponse temporaire d'une invitation, contact supprimé) est « mise en retraite » : sa clé est conservée le temps d'envoyer ces acks. * Effacer les acks envoyés ne demande pas de sauvegarde, car un ack est idempotent : au pire, il est renvoyé. --- ## 4. Protocole serveur * `GET /v2/card` → `ServerCard` (protobuf) autosignée. Le client l'épingle à l'ajout (TOFU), et un changement de clé est signalé explicitement. * `POST /v2/rpc` → corps `SealedRequest`, réponse `SealedResponse` (protobuf binaire). * `GET /healthz`, `GET /v2/stats` (compteurs agrégés, optionnel). * Phase 8 : `GET /v2/ws` (WebSocket) pour le push. Les opérations (`oneof` de `Request`) : | Requête | Effet | |---|---| | `Post { deposits[] }` | Stocke chaque payload dans `mailbox`, avec un TTL. Retourne les ids serveur. | | `Pull { auths[], wait_seconds }` | Supprime d'abord les messages acquittés (`auths[].acks`), puis renvoie sans les supprimer les messages restants des mailbox authentifiées (`more` si limité). Long-poll si elles sont vides (≤ 120 s). Voir §3.6. | | `InvitationPublish { payload, ttl, shortcode_len, password }` | Retourne `shortcode` et `expiry`. | | `InvitationFetch { shortcode, password }` | 3 échecs → invitation détruite. Comparaison en temps constant. | | `Ping` | Retourne l'heure du serveur (synchronisation des horodatages). | Stockage (`ServerStore`, trait asynchrone) : * `MemoryStore` : `HashMap` + canal `broadcast`, pour le dev et les tests. * `RedisStore` (Redis ≥ 5) : `meow:v2:mb:{hex}` est un **stream** (`XADD MAXLEN`, `XRANGE` pour lire, `XDEL` pour acquitter ; l'id du stream sert d'id de message) avec `EXPIRE`, `PUBLISH meow:v2:new`, `SET inv:{code} EX`, `SET invpw:{code}`, `INCR invfa:{code}`, `SET rq:{id} NX EX`. --- ## 5. API publique de la bibliothèque client (`meow-client`) ```rust let client = MeowClient::open(path, Password::from(...)).await?; // ou ::create(path, nickname, pw) client.servers().add("http://localhost:8080").await?; // récupère et épingle la ServerCard let offer = client.invitations().create("alice", &servers, msg).await?; // étape 1 → InvitationOffer let answer = client.invitations().answer(&offer, "bob", &servers).await?; // étape 2 let confirm= client.invitations().accept(&answer).await?; // étape 3 client.invitations().finalize(&confirm).await?; // étape 4 client.messages().send_text(contact_id, "hello").await?; let report = client.sync(Duration::from_secs(30)).await?; // pull/long-poll + traitement let mut events = client.subscribe(); // Stream ``` * Tous les types publics sont des structs Rust idiomatiques (`ContactId`, `Contact`, `Message`, `Event::{MessageReceived, ContactActivated, DeliveryAck, …}`). Le protobuf reste interne. * Erreurs : `thiserror`, un `enum Error` par crate, sans `unwrap` dans les bibliothèques. * Le cœur est asynchrone (`tokio`). La FFI expose les mêmes méthodes via `flutter_rust_bridge` (`Future` ↔ `Future`, `Stream` ↔ `Stream`). ### 5.1 File d'envoi persistante * Chaque dépôt (message utilisateur ou message de handshake) devient d'abord un `OutboxItem`. Il est enregistré **dans la même sauvegarde** que l'état du ratchet qui l'a produit, puis déposé chez les serveurs de relève du destinataire. Un message n'est donc jamais chiffré sans être stocké pour être (re)livré. * Les serveurs qui acceptent le dépôt sont retirés de l'élément, et les autres sont réessayés avec un backoff exponentiel : 5 s × 2ⁿ, plafonné à 1 h, avec ±20 % d'aléa. Au bout de 7 jours, l'élément est abandonné, avec `Event::SendFailed` si aucun serveur ne l'a pris. * Les dépôts dus en même temps sont regroupés en un `Post` par serveur (64 dépôts et 8 Mio au maximum). Un lot refusé par le serveur est réessayé élément par élément, pour qu'un dépôt invalide ne bloque pas les autres. * La file est vidée à chaque `send`, au début de `sync` et par `flush_outbox()`. Envoyer hors ligne réussit donc : `SendReport.delivered_to == 0` signifie « en file ». * La file appartient à l'espace du contact : un contact caché garde ses envois en attente dans son espace. * C'est ici que Matriochka se branchera : un élément portera une route et une date de départ plutôt qu'une simple liste de serveurs. ### 5.2 Statuts et accusés * Chaque entrée d'historique porte un `Status` qui ne fait qu'avancer. * Message envoyé : `Queued` (aucun serveur ne l'a encore accepté), puis `Sent` (un serveur l'a accepté), puis `Delivered` (l'appareil du contact l'a traité), puis `Read`. * Message reçu : `Delivered` (non lu), puis `Read`. * Les accusés sont des `UserMessage { Receipt { kind, message_ids } }` **chiffrés dans le ratchet** : le serveur ne les distingue pas d'un message. * Un `DELIVERED` par contact et par lot reçu est mis en file dans la même sauvegarde que le traitement. * `READ` est envoyé par `mark_read(contact)`. * Il n'y a jamais d'accusé d'accusé. * Les accusés révèlent quand on est en ligne et quand on lit. Ils se règlent donc par identité (`Settings { delivered_receipts, read_receipts }`, rangés dans l'espace principal). Désactiver l'accusé de lecture ne change pas le statut local. * Le store applique une mise à jour de statut dans le segment qui contient le message, en partant du plus récent. Seuls les segments modifiés sont réécrits. ### 5.3 Tâche de fond et flux d'événements * `client.subscribe()` renvoie un `broadcast::Receiver`. Tout événement y passe, qu'il vienne de `sync`, de `flush_outbox` ou de la tâche de fond. Un abonné qui prend plus de 256 événements de retard reçoit `Lagged` et doit recharger sa vue depuis le client. * `client.start(BackgroundOptions)` déplace le client dans une tâche `tokio` et renvoie un `ClientHandle` qui offre `subscribe()`, `lock()` (accès complet au client) et `stop()` (rend le client). * Boucle de la tâche : vider les dépôts dus, puis faire un long-poll sur tous les serveurs, puis traiter et publier. Après une réception, la tâche repart aussitôt, sans attente, pour envoyer les acks et les réponses. En cas d'échec de tous les serveurs : backoff de 2 s à 60 s. * **Le verrou n'est jamais tenu pendant une attente réseau.** Le pull et le vidage de la file sont découpés en trois temps : `prepare_*` sous verrou, appels réseau sans verrou, `apply_*` sous verrou. Un envoi depuis l'UI n'attend donc ni un long-poll ni un serveur injoignable. * Le long-poll est raccourci jusqu'au prochain réessai dû de la file : un dépôt en attente repart à l'heure, même sans autre trafic. * Arrêter la tâche abandonne le long-poll en cours. Ses acks n'ont pas été confirmés : ils seront simplement renvoyés (ils sont idempotents). ### 5.4 Liaison Flutter (`meow-ffi`) * La crate `meow-ffi` (cdylib) est générée par `flutter_rust_bridge` **2.13.0**, épinglée des deux côtés. La configuration se trouve dans `../bastet/flutter_rust_bridge.yaml`, le Dart généré dans `../bastet/lib/src/rust/`. On ne modifie jamais `frb_generated.*`. * Côté Dart, un objet opaque `Meow` représente une identité ouverte, qui se synchronise toujours en tâche de fond. Ses méthodes sont `async` et reprennent celles du client ; les données circulent sous forme de vues simples (`ContactView`, `MessageView`, `HistoryPageView`…). `events()` renvoie un `Stream` (classes scellées, `freezed`). * Tous les appels s'exécutent sur un runtime tokio propre à la crate, quel que soit l'exécuteur de flutter_rust_bridge, car HTTP, minuteries et tâche de fond ont besoin de tokio. * Le flux d'événements se termine quand on appelle `close()`. Il faut fermer l'identité *avant* d'annuler l'abonnement Dart : une annulation n'aboutit qu'une fois le flux fermé côté Rust. * La tâche de fond relance son attente (ou son long-poll) dès que l'état change (nouveau contact, espace déverrouillé, message mis en file), grâce à un compteur `watch` incrémenté à chaque sauvegarde. * **Builds natifs** (`scripts/build-ffi.sh linux|android [debug|release]`), appelés automatiquement par les builds Flutter de `../bastet` : * Linux : `linux/CMakeLists.txt` lance cargo (profil Rust debug pour un build Flutter debug, release sinon), puis installe `libmeow_ffi.so` dans `bundle/lib` ; * Android : `android/app/build.gradle.kts` enregistre une tâche `buildMeowFfi` exécutée avant `preBuild`. Elle lance `cargo-ndk` (API 24, toujours en release) pour les ABI demandées par Flutter (`-Ptarget-platform`, par défaut arm64-v8a, armeabi-v7a et x86_64) et copie le résultat dans `src/main/jniLibs` (ignoré par git). Elle préfère le NDK `android.ndkVersion` s'il est installé, sinon le plus récent. * Le chargeur de flutter_rust_bridge ouvre `libmeow_ffi.so` depuis le paquet : aucune configuration n'est nécessaire côté Dart. * Tailles en release : 7 Mo (Linux x86_64), 6,3 Mo (arm64-v8a), 4,7 Mo (armeabi-v7a). * Tests : `scripts/ffi-test.sh` régénère le code, construit la bibliothèque et `meowsrv`, puis lance `flutter test test/meow_ffi_test.dart` (deux identités, un vrai serveur, tout passe par les événements). ### 5.5 Invitation en présentiel (application) * Transports : `lan_connect` (Wi-Fi local, partout) et `ble_connect` (Bluetooth LE, mobile), derrière l'interface `PeerTransport` de `peer_secure`. * Canal : session `peer_secure`. Les deux côtés s'engagent sur leur clé éphémère avant de la révéler. Ils dérivent un code SAS de 6 chiffres, que les deux personnes comparent : avec l'engagement, un attaquant au milieu a une chance sur 10⁶. Les données sont chiffrées et authentifiées (ChaCha20-Poly1305). Rien n'est écrit sur disque (`EphemeralTrustStore`). * Sur ce canal passent l'offre, la réponse et la confirmation de l'invitation v2 (§3.3). L'acquittement final part par les serveurs, mis en file si on est hors ligne. L'initiateur peut écrire tout de suite. * Le numéro de sécurité v2 (fiche du contact) reste une seconde vérification possible. ### 5.6 Veille en arrière-plan et notifications Le travail de fond **relève et notifie, sans jamais déchiffrer**, comme dans la v1, mais sans tampon local : * **Fichier de veille** (`identity.watch`) : pour chaque mailbox de l'**espace principal**, le serveur et la clé de mailbox qui signe les pulls, et rien d'autre. Pas de nom, pas de clé de ratchet. Il est complété par des mailbox leurres jusqu'à un palier (8, 16, 32…) puis mélangé, et réécrit quand les mailbox changent. Il est chiffré par une **clé de l'appareil** : sous Android, une clé aléatoire enveloppée par une clé AES du Keystore (plugin local `bastet_keystore`) ; ailleurs, une clé en mémoire, puisque la veille ne tourne qu'avec l'application ouverte. Les espaces cachés n'y figurent **jamais**. * **`watch_check`** (Rust, sans mot de passe ni base) : un pull **sans ack**, avec `MailboxAuth.after` = dernier id vu, d'où le long-poll seulement sur les messages *nouveaux*. Les curseurs sont dans un petit fichier chiffré. La fonction renvoie le nombre de nouveaux messages. Rien n'est stocké : les messages restent sur les serveurs jusqu'au traitement normal par l'application ouverte (§3.6). * **Qui vérifie** : l'application verrouillée mais lancée (long-poll, toutes plateformes) ; sous Android, application fermée, WorkManager toutes les 15 min environ, ou un service de premier plan avec long-poll (« notifications instantanées », notification permanente). Quand l'identité est ouverte et l'application en arrière-plan, ses propres événements déclenchent la notification. * **Notification neutre** : « Nouveaux messages », sans expéditeur ni texte, et masquée sur l'écran de verrouillage d'Android (`VISIBILITY_SECRET`). * **Limites** : quelqu'un qui possède le fichier *et* la clé (appareil déverrouillé) peut faire des pulls, et même acquitter (donc effacer) les messages en attente, sans pouvoir les lire. Il voit aussi la date des vérifications. * Serveur : `MailboxAuth.after` (champ 5, filtre de lecture non signé) ; ids croissants dans le temps (mémoire : horodatés ; Redis : ids de stream, lecture par `XRANGE (id`, Redis ≥ 6.2). --- ## 6. Stockage client (`meow-store`) ### 6.1 Modèle de menace L'appareil peut être saisi, une fois ou plusieurs fois, et l'utilisateur peut être contraint de donner son mot de passe principal. 1. **Sans mot de passe**, l'attaquant ne doit apprendre ni le nombre de contacts, ni quelles conversations sont actives (« qui sont ses proches »), ni leur taille ou leur date. 2. **Avec le mot de passe principal**, les *espaces cachés* restent invisibles : rien ne permet de prouver qu'il en existe. Hors périmètre : la mémoire vive d'un appareil allumé et déverrouillé, et les fuites du système (notifications, caches d'images, clavier). Pour un utilisateur exposé, la cible est un Linux maîtrisé. L'application limitera ces fuites, par exemple sans texte de message dans les notifications. ### 6.2 Un sac de blocs uniformes Un fichier SQLite par identité, qui ne contient que deux tables : * `meta` : le sel (16 octets, commun à tous les mots de passe) et les paramètres Argon2id. Ces données sont publiques et non sensibles. * `blocks(id, data)` : des lignes de **4096 octets** sous des identifiants **aléatoires de 32 octets**. Un bloc utilisé vaut `XChaCha20-Poly1305(clé de l'espace, morceau complété par du bourrage, aad = id)`. Un bloc de remplissage est de l'aléa. Sans clé, on ne peut pas les distinguer. Aucune colonne en clair ne relie deux lignes. Un *objet* (profil, contact, segment de conversation, fichier) est découpé en blocs, et son `ObjectRef { blocks[], len }` est rangé dans l'objet parent. ``` mot de passe ─Argon2id(sel)─► k ─HMAC─► id de la racine (1 bloc, chiffré par HKDF(k)) └─ Root { type, clé d'espace, ObjectRef de l'index } Index { meta, contacts[{ id, état, dir }], blocs libres[] } Dir { segments[] (du plus ancien au plus récent), fichiers[(id de message, ObjectRef)] } ``` ### 6.3 Espaces * Le mot de passe principal ouvre l'espace principal : pseudo, serveurs, contacts visibles, acks en attente. * Chaque autre mot de passe ouvre un **espace caché**, qui contient un ou plusieurs contacts avec leurs conversations et leurs propres acks en attente. Les données d'un espace caché ne sont jamais rangées dans l'espace principal. * `unlock(mot de passe)` coûte une dérivation Argon2id et une lecture de la racine, qu'un espace existe ou non. Le coût est dominé par Argon2id, et il n'y a pas de boucle d'essai sur des emplacements. Un même champ de saisie sert au mot de passe principal comme aux mots de passe cachés. * Changer un mot de passe ne fait que déplacer la racine. L'ancienne racine est écrasée par de l'aléa. ### 6.4 Déni plausible et non-corrélation * À la création, entre 128 et 1024 blocs d'aléa sont ajoutés **sans être enregistrés nulle part**, et chaque sauvegarde en ajoute parfois quelques-uns. Tout magasin contient donc des blocs que le mot de passe principal n'ouvre pas, et les blocs d'un espace caché se fondent parmi eux. * Un objet réécrit change de blocs : ils sont pris au hasard parmi les blocs libres de l'espace. Les anciens blocs sont écrasés par de l'aléa (ce qui efface aussi les anciens états de ratchet), puis libérés. Chaque sauvegarde réécrit aussi quelques blocs libres au hasard. Seules les racines gardent un identifiant fixe. * On ne supprime jamais de bloc : les blocs libérés sont recyclés. * Le WAL est vidé (`wal_checkpoint(TRUNCATE)`) après chaque sauvegarde, et `secure_delete` est actif. ### 6.5 Segments Une conversation est une suite de segments d'environ 16 Kio. Ajouter un message ne réécrit que le dernier segment, et l'historique se lit segment par segment, du plus récent au plus ancien. C'est l'équivalent des bases de messages de taille fixe de la v1, sans qu'aucun fichier ne révèle la longueur des conversations. ### 6.6 Limites connues * **Plusieurs saisies de l'appareil.** Avec deux copies du fichier, l'attaquant voit quels blocs ont changé entre elles, sans savoir à quel objet ils appartiennent. Il voit aussi que la racine principale change à chaque sauvegarde. Si un espace caché a été utilisé entre les deux copies, ses blocs ont changé alors que le mot de passe principal ne les explique pas. C'est la limite connue des volumes cachés de VeraCrypt : l'éviter demanderait une ORAM, trop coûteuse ici. Il vaut donc mieux ouvrir les espaces cachés rarement. * **Le volume total** stocké reste visible, à l'aléa de remplissage près. La date de dernière modification du fichier aussi. * **Le temps d'ouverture** : lire l'index d'un espace qui existe prend environ une milliseconde de plus, ce qui est négligeable devant Argon2id. ### 6.7 Durabilité et exclusivité * WAL avec `synchronous=FULL` et une transaction par sauvegarde. Quand `save` revient, l'état est durable : l'invariant **persister avant d'envoyer ou d'acquitter** repose sur cette garantie. * Un verrou exclusif `.lock` (`File::try_lock`) empêche qu'un deuxième processus fasse reculer l'état d'un ratchet. ### 6.8 Utilisation par le client * `MeowClient` garde en mémoire l'état de chaque espace déverrouillé et ne sauvegarde que les espaces modifiés : un espace caché ouvert mais inutilisé n'est jamais réécrit. * Les acks en attente sont rangés dans l'espace qui possède la mailbox. * `unlock(mot de passe)` rend les contacts d'un espace caché utilisables (listés, relevés, joignables) jusqu'à la fermeture du client. Tant qu'un espace caché n'est pas déverrouillé, ses mailbox ne sont pas relevées et ses messages attendent sur le serveur (voir §3.6). * `hide_contact(nom, mot de passe)` déplace un contact, son historique, ses fichiers et ses acks en attente vers l'espace caché ouvert par ce mot de passe, en le créant au besoin. `reveal_contact` fait l'inverse. La destination est écrite avant la source : un plantage entre les deux laisse une copie, jamais une perte. * Un nouveau contact peut naître **directement dans un espace caché** : les quatre fonctions d'invitation prennent `space: Option`, et l'espace principal n'est alors jamais écrit. Les étapes suivantes demandent que cet espace soit déverrouillé. Un contact créé dans l'espace principal puis caché laisse ses anciens blocs effacés puis recyclés. * Application : le mot de passe principal ouvre l'identité. « Ouvrir un espace » (liste des conversations, réglages) essaie un autre mot de passe ; les contacts de l'espace restent visibles jusqu'au verrouillage. Ces actions sont présentes pour tout le monde, et une réponse neutre est donnée quand rien ne s'ouvre. La fiche contact permet de cacher ou de révéler un contact. Le verrouillage, manuel ou automatique en arrière-plan, referme tout ce qui est ouvert. * CLI : `-u/--unlock ` (répétable), `contact hide --space-password …`, `contact reveal`, `identity password --new-password …`, `--space-password` sur les commandes d'invitation. Un mot de passe qui n'ouvre rien est ignoré sans message. --- ## 7. Réseau de serveurs et Matriochka (cible, phase 8) Cette section décrit la cible issue de la vision du projet (site web : *architecture*, *features*, *why*). Rien n'est encore implémenté, à part les briques déjà présentes : chaque requête est scellée pour un serveur, et chaque serveur a une carte autosignée. ### 7.1 Rôles * **Serveurs de relève** (pull servers) : choisis par l'utilisateur, de confiance, le plus souvent auto-hébergés. C'est là qu'arrivent ses messages. Comme ils sont de confiance, l'analyse de trafic n'y est pas la menace principale. * **Serveurs de transit** (publics, d'organisations partenaires) : relaient les couches Matriochka. Chacun ne connaît que le saut précédent, le saut suivant et une charge opaque. C'est là que portent la menace d'analyse de trafic et la contrainte de juridiction. ### 7.2 Maillage et propagation de la connaissance du réseau * Les serveurs **échangent en permanence** des lots entre eux. Chaque lot contient de 0 à n messages utilisateurs (couches Matriochka à faire suivre) et de 1 à x cartes de serveurs connus. Le trafic de couverture est donc intrinsèque : un observateur du lien ne distingue pas un lot vide d'un lot plein (lots de taille fixe, cadence régulière). * Les échanges entre client et serveur suivent le même modèle : les réponses (pull, post) embarquent aussi des cartes de serveurs. Le client construit ainsi un **annuaire local** le plus large possible pour composer ses chaînes. Il n'y a pas d'annuaire central. * La carte serveur (`ServerCard`, autosignée) s'enrichira de : juridiction ou pays déclaré, opérateur, rôles (relève et/ou transit), date de validité, éventuelles attestations. ### 7.3 Chaînes Matriochka ``` client ─► S1 ─► S2 ─► … ─► Sk = serveur de relève du destinataire Requête scellée(S1){ Forward { next: S2, sealed: Requête scellée(S2){ … Post{deposit} } } } ``` * Chaque saut ouvre sa couche (sealed box, §3.1), apprend `next`, attend un **délai aléatoire** puis transmet dans son prochain lot. Les couches sont complétées par du bourrage à une taille constante, pour que l'épaisseur restante ne trahisse pas la position dans la chaîne. * **Politique de juridiction** (choisie par l'utilisateur ou l'organisation) : pays à inclure ou à exclure, longueur minimale de la chaîne, diversité des opérateurs. Exemple : `domestique → neutre → externe → relève`. * Le chemin de réponse est indépendant : le destinataire compose sa propre chaîne vers mes serveurs de relève, connus par sa `ContactCard`. ### 7.4 Points à trancher * **Faux serveurs (Sybil).** Les cartes propagées par le maillage sont autosignées, donc n'importe qui peut injecter des centaines de « serveurs » et capturer une bonne part des chaînes. Une juridiction déclarée n'est pas vérifiable. Proposition : la propagation sert à *découvrir* des serveurs, mais un serveur n'entre dans une chaîne que s'il est **approuvé** : ajouté à la main, attesté par un serveur ou une organisation de confiance (signature sur sa carte), ou ancien et stable. La politique de juridiction ne s'applique qu'à des attestations, pas à des déclarations. * **Couche symétrique pré-partagée** (annoncée par le site, absente de la v2 actuelle). Un secret échangé hors ligne (QR, `peer_secure`) devrait être **mélangé à la clé initiale du ratchet** (`SK = HKDF(DH… ‖ PSK)`), et périodiquement à la racine. Un attaquant qui enregistre tout aujourd'hui pour casser X25519 demain (ordinateur quantique) ne pourrait alors rien déchiffrer sans le PSK. C'est plus simple et plus sûr qu'une couche de chiffrement supplémentaire. On pourra ensuite ajouter un KEM post-quantique (ML-KEM) dans l'invitation. * **« Contenu signé par l'expéditeur »** (site). Le Double Ratchet authentifie déjà l'expéditeur avec une authentification *répudiable* : le destinataire sait qui a écrit, mais ne peut pas le prouver à un tiers. Une signature Ed25519 sur chaque message rendrait au contraire chaque message **non répudiable**, et donc utilisable contre l'expéditeur si l'appareil du destinataire est saisi. Je recommande de ne pas signer par défaut. Une signature explicite peut se réserver au profil professionnel, si la non-répudiation y est une exigence. * **Profils professionnels** (LDAP, déchiffrement côté serveur explicite et signalé). Ce seraient des identités séparées (fichiers de store distincts), avec un dépôt de clé (« escrow ») vers l'organisation **visible dans le protocole**, par exemple un destinataire supplémentaire déclaré dans la `ContactCard`. Le client peut alors afficher l'avertissement sans pouvoir le cacher. Le sujet est hors du périmètre actuel. --- ## 8. Conventions * Edition 2021, MSRV = stable courante. `cargo fmt`, `cargo clippy -D warnings`. * `#![forbid(unsafe_code)]` partout, sauf dans `meow-ffi`. * Tests : unitaires dans chaque crate, protocole complet dans `meow-core/tests`, serveur via `axum` en mémoire, et bout-en-bout avec `tests/e2e.sh`. * Logs : `tracing`. Jamais de clé, de mailbox ou de contenu au niveau `info`.