36 KiB
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.
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-corene 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-crypton'expose que des types forts (SigningKey,DhSecret,MailboxId…) et met à zéro les secrets aveczeroize. 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 signalemore(limites de 256 messages et 16 Mio par pull). Unsyncse 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→ corpsSealedRequest, réponseSealedResponse(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+ canalbroadcast, pour le dev et les tests.RedisStore(Redis ≥ 5) :meow:v2:mb:{hex}est un stream (XADD MAXLEN,XRANGEpour lire,XDELpour acquitter ; l'id du stream sert d'id de message) avecEXPIRE,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)
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<Event>
- Tous les types publics sont des structs Rust idiomatiques (
ContactId,Contact,Message,Event::{MessageReceived, ContactActivated, DeliveryAck, …}). Le protobuf reste interne. - Erreurs :
thiserror, unenum Errorpar crate, sansunwrapdans les bibliothèques. - Le cœur est asynchrone (
tokio). La FFI expose les mêmes méthodes viaflutter_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::SendFailedsi aucun serveur ne l'a pris. - Les dépôts dus en même temps sont regroupés en un
Postpar 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 desyncet parflush_outbox(). Envoyer hors ligne réussit donc :SendReport.delivered_to == 0signifie « 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
Statusqui ne fait qu'avancer.- Message envoyé :
Queued(aucun serveur ne l'a encore accepté), puisSent(un serveur l'a accepté), puisDelivered(l'appareil du contact l'a traité), puisRead. - Message reçu :
Delivered(non lu), puisRead.
- Message envoyé :
- 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
DELIVEREDpar contact et par lot reçu est mis en file dans la même sauvegarde que le traitement. READest envoyé parmark_read(contact).- Il n'y a jamais d'accusé d'accusé.
- Un
- 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 unbroadcast::Receiver<Event>. Tout événement y passe, qu'il vienne desync, deflush_outboxou de la tâche de fond. Un abonné qui prend plus de 256 événements de retard reçoitLaggedet doit recharger sa vue depuis le client.client.start(BackgroundOptions)déplace le client dans une tâchetokioet renvoie unClientHandlequi offresubscribe(),lock()(accès complet au client) etstop()(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 parflutter_rust_bridge2.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 jamaisfrb_generated.*. - Côté Dart, un objet opaque
Meowreprésente une identité ouverte, qui se synchronise toujours en tâche de fond. Ses méthodes sontasyncet reprennent celles du client ; les données circulent sous forme de vues simples (ContactView,MessageView,HistoryPageView…).events()renvoie unStream<MeowEvent>(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
watchincré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.txtlance cargo (profil Rust debug pour un build Flutter debug, release sinon), puis installelibmeow_ffi.sodansbundle/lib; - Android :
android/app/build.gradle.ktsenregistre une tâchebuildMeowFfiexécutée avantpreBuild. Elle lancecargo-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 danssrc/main/jniLibs(ignoré par git). Elle préfère le NDKandroid.ndkVersions'il est installé, sinon le plus récent. - Le chargeur de flutter_rust_bridge ouvre
libmeow_ffi.sodepuis 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).
- Linux :
- Tests :
scripts/ffi-test.shrégénère le code, construit la bibliothèque etmeowsrv, puis lanceflutter 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) etble_connect(Bluetooth LE, mobile), derrière l'interfacePeerTransportdepeer_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 localbastet_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, avecMailboxAuth.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 parXRANGE (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.
- 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.
- 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é vautXChaCha20-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, etsecure_deleteest 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=FULLet une transaction par sauvegarde. Quandsaverevient, l'état est durable : l'invariant persister avant d'envoyer ou d'acquitter repose sur cette garantie. - Un verrou exclusif
<fichier>.lock(File::try_lock) empêche qu'un deuxième processus fasse reculer l'état d'un ratchet.
6.8 Utilisation par le client
MeowClientgarde 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_contactfait 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<mot de passe>, 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 <mot de passe>(répétable),contact hide <nom> --space-password …,contact reveal,identity password --new-password …,--space-passwordsur 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 dansmeow-ffi.- Tests : unitaires dans chaque crate, protocole complet dans
meow-core/tests, serveur viaaxumen mémoire, et bout-en-bout avectests/e2e.sh. - Logs :
tracing. Jamais de clé, de mailbox ou de contenu au niveauinfo.