diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index 90183ed..052c2c9 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -248,6 +248,25 @@ let mut events = client.subscribe(); // Strea * 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. + --- ## 6. Stockage client (`meow-store`) @@ -360,7 +379,79 @@ révèle la longueur des conversations. --- -## 7. Conventions +## 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`. diff --git a/ROADMAP.md b/ROADMAP.md index 700e7d9..26552f2 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -16,7 +16,7 @@ Pour reprendre le travail : lire ce fichier, prendre le premier lot ⬜ dont les 1. ~~**3.8** livraison au moins une fois~~ ✅ 2. ~~**4.5** brancher `meow-store` dans le client et la CLI~~ ✅ -3. **5.5, 5.6, 5.9** file d'envoi, accusés, flux d'événements (prérequis de l'UI). +3. ~~5.5~~ ✅, puis **5.6, 5.9** accusés et flux d'événements (prérequis de l'UI), et **5.10**. 4. **7.1 → 7.3** FFI et intégration dans bastet. 5. Le reste (phases 8–10) selon les priorités. @@ -24,6 +24,7 @@ Pour reprendre le travail : lire ce fichier, prendre le premier lot ⬜ dont les | Date | Lots | Notes | |---|---|---| +| 2026-11-20 | 5.5 | `OutboxItem` enregistrés dans le store (un objet par élément et par espace), dans la même sauvegarde que le ratchet. Backoff exponentiel avec aléa, expiration après 7 jours (`Event::SendFailed`), dépôts regroupés par serveur avec repli élément par élément. Les messages de handshake passent aussi par la file. CLI : `outbox [--flush]`, « queued for … ». ARCHITECTURE : §5.1, et §7 (réseau de serveurs et Matriochka, points à trancher). 41 tests, e2e avec une section « file hors ligne ». | | 2026-11-20 | 4.5 | `meow-client` passe sur `meow-store` (un état par espace, sauvegarde des seuls espaces modifiés, acks par espace) ; API `unlock`, `hide_contact`, `reveal_contact`, `change_password`, `history_page`, `file`. CLI : `-u`, `contact hide/reveal`, `identity password`. Store derrière un `Mutex` pour garder le client `Send + Sync` (requis pour la FFI). Le fichier `.mwid2` provisoire disparaît. 38 tests, e2e avec sections « contact caché » et « changement de mot de passe ». | | 2026-11-20 | 4.1–4.3 | `meow-store` repensé après relecture du stockage v1 : objectifs anti-saisie (rien ne relie les blocs sans mot de passe, espaces cachés à un ou plusieurs contacts). Sac de blocs uniformes, espaces, segments. Un premier brouillon avec une colonne `contact` en clair a été abandonné. 6 tests de store. Pas encore branché dans le client. | | 2026-11-20 | 3.8 | Pull non destructif + acks signés dans `MailboxAuth`, `PendingAck` enregistrés avec l'état, redélivrances dédupliquées, pagination (`more`), mise en retraite des mailbox disparues. Redis : liste → stream. Profil client au format 2 (les `.mwid2` de format 1 sont refusés). 31 tests, e2e mémoire et Redis verts, et plus aucun message résiduel dans Redis à la fin de l'e2e. | @@ -94,11 +95,12 @@ Pour reprendre le travail : lire ce fichier, prendre le premier lot ⬜ dont les | 5.2 | Invitation par fichier et par serveur (shortcode et mot de passe) | e2e | ✅ | | 5.3 | Envoi : dépôt sur tous les serveurs de pull du contact, repli en cas d'échec | e2e | ✅ | | 5.4 | Réception : un pull par serveur regroupant toutes les mailbox, long-poll, traitement, événements | e2e | ✅ | -| 5.5 | File d'envoi persistante avec retries et backoff, envoi hors ligne | Tests | ⬜ | +| 5.5 | File d'envoi persistante avec retries et backoff, envoi hors ligne | Tests | ✅ | | 5.6 | Accusés de réception et de lecture chiffrés (dans le ratchet) | e2e | ⬜ | | 5.7 | Fichiers : découpage en morceaux, reprise, déduplication, limite de taille. Le contenu reçu doit être écrit sur disque **avant** l'ack : aujourd'hui, la CLI écrit les fichiers après `sync`, alors que les acks sont déjà partis | e2e (`send-file`) | 🟡 envoi en un seul morceau | | 5.8 | Trafic leurre : mailbox fictives dans les pulls, ordre aléatoire, padding des requêtes | Tests | ⬜ | | 5.9 | Stream d'événements (`tokio::broadcast`) et tâche de synchronisation en arrière-plan | | ⬜ | +| 5.10 | Inviter directement dans un espace caché (le contact ne passe jamais par l'espace principal) | Tests | ⬜ | ## Phase 6 — `meow-cli` (`meow`) @@ -128,13 +130,18 @@ Correspondance des 63 exports actuels de `meowjsonlib` → API v2 : voir l'annex | Lot | Contenu | État | |---|---|---| | 8.1 | Chiffrement des en-têtes DR (variante « header encryption » de Signal) | ⬜ | -| 8.2 | Matriochka (multi-saut) : `Forward { next_server, sealed }`, délais aléatoires | ⬜ | +| 8.2 | Matriochka (multi-saut) : `Forward { next_server, sealed }`, couches de taille constante, délais aléatoires, politique de juridiction (ARCHITECTURE §7.3) | ⬜ | +| 8.2a | `ServerCard` enrichie (juridiction, opérateur, rôles, validité) + annuaire local du client alimenté par les réponses des serveurs | ⬜ | +| 8.2b | Maillage entre serveurs : lots de taille fixe à cadence régulière (0 à n messages, 1 à x cartes), trafic de couverture | ⬜ | +| 8.2c | Approbation des serveurs (anti-Sybil) : approbation manuelle, attestations signées, ancienneté (ARCHITECTURE §7.4) | ⬜ | | 8.3 | Multi-appareils (mailbox d'appareil, synchronisation chiffrée) | ⬜ | | 8.4 | Push WebSocket (`/v2/ws`) en plus du long-poll | ⬜ | | 8.5 | Visio : émission de jetons LiveKit côté serveur (`VideoRoomRequest`) | ⬜ | | 8.6 | Groupes (fan-out par paire, puis évaluation de MLS / `openmls`) | ⬜ | | 8.7 | Portage de `peer_secure` (SAS) : canal Rust + vérification de l'empreinte `transcript` | ⬜ | -| 8.8 | Liste de serveurs connus, échange de cartes, fédération | ⬜ | +| 8.8 | Fédération entre organisations (voir 8.2a à 8.2c pour l'échange de cartes) | ⬜ | +| 8.9 | Secret pré-partagé hors ligne mélangé au ratchet (`SK = HKDF(DH ‖ PSK)`), puis KEM post-quantique (ML-KEM) dans l'invitation | ⬜ | +| 8.10 | Profils professionnels : LDAP, dépôt de clé vers l'organisation visible dans le protocole et signalé dans l'UI (ARCHITECTURE §7.4) | ⬜ | ## Phase 9 — Durcissement et livraison diff --git a/crates/meow-cli/src/main.rs b/crates/meow-cli/src/main.rs index bda0bee..fb98cb2 100644 --- a/crates/meow-cli/src/main.rs +++ b/crates/meow-cli/src/main.rs @@ -77,6 +77,12 @@ enum Cmd { #[arg(short, long)] exit: bool, }, + /// Show the send queue (messages not yet accepted by every server). + Outbox { + /// Try to deliver everything now. + #[arg(long)] + flush: bool, + }, /// Show the conversation with a contact. History { contact: String }, } @@ -376,11 +382,11 @@ async fn run() -> Result<()> { } Cmd::Send { contact, text } => { let r = ctx.open().await?.send_text(&contact, &text.join(" ")).await?; - println!("sent to {contact} ({} server(s))", r.delivered_to); + print_sent(&contact, None, r.delivered_to); } Cmd::SendFile { contact, file } => { let r = ctx.open().await?.send_file(&contact, &file).await?; - println!("sent {} to {contact} ({} server(s))", file.display(), r.delivered_to); + print_sent(&contact, Some(&file), r.delivered_to); } Cmd::Sync { wait } => { let mut c = ctx.open().await?; @@ -397,6 +403,28 @@ async fn run() -> Result<()> { } } } + Cmd::Outbox { flush } => { + let mut c = ctx.open().await?; + if flush { + let ev = c.flush_outbox().await?; + print_events(&ctx, &ev)?; + } + let pending = c.pending_sends(); + if pending.is_empty() { + println!("outbox empty"); + } + for p in pending { + let what = if p.message_id.is_empty() { + "handshake" + } else { + "message" + }; + println!( + "{}\t{what}\taccepted by {} server(s)\t{} attempt(s)\tnext at {}", + p.contact, p.accepted, p.attempts, p.next_attempt + ); + } + } Cmd::History { contact } => { let c = ctx.open().await?; for h in c.history(&contact)? { @@ -494,6 +522,15 @@ fn safe_name(name: &str) -> String { } } +fn print_sent(contact: &str, file: Option<&Path>, delivered_to: usize) { + let what = file.map(|f| format!("{} ", f.display())).unwrap_or_default(); + if delivered_to == 0 { + println!("queued {what}for {contact} (no server reachable, will retry)"); + } else { + println!("sent {what}to {contact} ({delivered_to} server(s))"); + } +} + fn print_events(ctx: &Ctx, events: &[Event]) -> Result<()> { for e in events { match e { @@ -508,6 +545,7 @@ fn print_events(ctx: &Ctx, events: &[Event]) -> Result<()> { } Event::InvitationAccepted { contact } => println!("invitation accepted by {contact}, confirmation sent"), Event::ContactActivated { contact } => println!("contact {contact} is active"), + Event::SendFailed { contact, .. } => println!("a message to {contact} could not be delivered (expired)"), } } Ok(()) diff --git a/crates/meow-client/src/lib.rs b/crates/meow-client/src/lib.rs index 3ebb88f..e2aa3aa 100644 --- a/crates/meow-client/src/lib.rs +++ b/crates/meow-client/src/lib.rs @@ -17,6 +17,7 @@ #![forbid(unsafe_code)] #![cfg_attr(not(test), warn(clippy::unwrap_used, clippy::expect_used))] +pub mod outbox; pub mod transport; use std::collections::BTreeMap; @@ -36,6 +37,7 @@ use meow_store::{Batch, RetiredMailbox, SpaceId, State as SpaceState, Store}; pub use meow_core::contact::ContactState as State; pub use meow_store::{Content, HistoryEntry, HistoryPage, PendingAck}; +pub use outbox::{PendingSend, RetryPolicy}; /// Maximum file size sent in a single message (chunking: roadmap 5.7). pub const MAX_FILE_BYTES: usize = 4 * 1024 * 1024; @@ -119,13 +121,16 @@ pub enum Event { name: String, data: Vec, }, + /// A queued message expired before any server accepted it. + SendFailed { contact: String, message_id: Vec }, } /// Outcome of a send. #[derive(Debug, Clone, PartialEq, Eq)] pub struct SendReport { pub message_id: Vec, - /// Number of servers that accepted the deposit. + /// Number of servers that accepted the deposit right away. `0` means queued: it is + /// retried by later sends, syncs and [`MeowClient::flush_outbox`]. pub delivered_to: usize, } @@ -157,6 +162,10 @@ pub struct MeowClient { store: std::sync::Mutex, spaces: Vec, transport: transport::Transport, + retry: RetryPolicy, + /// Events produced outside `sync` (e.g. an expiry noticed while sending), handed + /// out by the next `sync` or `flush_outbox`. + pending_events: Vec, } type Mailboxes = Vec<(SigningKeyPair, Vec)>; @@ -190,6 +199,8 @@ impl MeowClient { dirty: false, }], transport: transport::Transport::new()?, + retry: RetryPolicy::default(), + pending_events: Vec::new(), }) } @@ -300,6 +311,13 @@ impl MeowClient { .iter() .map(|(kp, _)| kp.public().as_bytes().to_vec()) .collect(); + let queued: Vec = self.spaces[si] + .state + .outbox + .iter() + .filter(|o| o.contact == contact.id) + .cloned() + .collect(); let acks: Vec = self.spaces[si] .state .pending_acks @@ -311,12 +329,14 @@ impl MeowClient { let t = &mut self.spaces[target]; t.state.contacts.push(contact); t.state.pending_acks.extend(acks); + t.state.outbox.extend(queued); t.batch.history.extend(history); t.batch.files.extend(files); self.save_space(target)?; let s = &mut self.spaces[si]; - s.state.contacts.remove(ci); + let cid = s.state.contacts.remove(ci).id; s.state.pending_acks.retain(|a| !mailboxes.contains(&a.mailbox)); + s.state.outbox.retain(|o| o.contact != cid); self.save_space(si) } @@ -416,7 +436,8 @@ impl MeowClient { pub async fn remove_contact(&mut self, name: &str) -> Result<()> { let (si, ci) = self.locate(name)?; let before = self.space_mailboxes(si); - self.spaces[si].state.contacts.remove(ci); + let cid = self.spaces[si].state.contacts.remove(ci).id; + self.spaces[si].state.outbox.retain(|o| o.contact != cid); self.retire_mailboxes(si, before); self.save_space(si) } @@ -506,10 +527,11 @@ impl MeowClient { let contact = &mut self.spaces[si].state.contacts[ci]; let ack = invitation::finalize(contact, &msg)?; let deposit = messaging::deposit_for(contact, &ack)?; - let servers = peer_servers(contact); + let queued = outbox::item(&contact.id, vec![], &deposit, peer_servers(contact)); let name = contact.name.clone(); + self.spaces[si].state.outbox.push(queued); self.save_space(si)?; - self.deliver(&servers, vec![deposit]).await?; + self.flush(false).await?; Ok(name) } @@ -574,8 +596,16 @@ impl MeowClient { let info = self.inspect_invitation(&f.payload)?; let answer_bytes = self.answer_invitation(&f.payload, contact_name, server_urls).await?; let answer = v2::InvitationMessage::decode(answer_bytes.as_slice()).map_err(meow_core::Error::from)?; - self.deliver(&info.answer_servers, vec![invitation::answer_deposit(&info, &answer)]) - .await?; + let (si, ci) = self.by_invitation(&info.invitation_id)?; + let queued = outbox::item( + &self.spaces[si].state.contacts[ci].id, + vec![], + &invitation::answer_deposit(&info, &answer), + info.answer_servers.clone(), + ); + self.spaces[si].state.outbox.push(queued); + self.save_space(si)?; + self.flush(false).await?; Ok(info.initiator_name) } @@ -619,6 +649,12 @@ impl MeowClient { let env = messaging::encrypt(contact, &msg)?; let deposit = messaging::deposit_for(contact, &env)?; let servers = peer_servers(contact); + if servers.is_empty() { + return Err(Error::Invalid("contact has no server".into())); + } + let queued = outbox::item(&contact.id, msg.id.clone(), &deposit, servers); + let item_id = queued.id.clone(); + sp.state.outbox.push(queued); sp.batch.history.push(HistoryEntry { id: msg.id.clone(), contact: contact.id.clone(), @@ -627,46 +663,16 @@ impl MeowClient { received_at: now(), content, }); + // Persisted (ratchet + queue) before anything is sent. self.save_space(si)?; - let delivered_to = self.deliver(&servers, vec![deposit]).await?; + let accepted = self.flush(false).await?; + let delivered_to = accepted.get(&item_id).copied().unwrap_or(0); Ok(SendReport { message_id: msg.id, delivered_to, }) } - /// Post deposits to every server; succeeds if at least one accepted them. - async fn deliver(&self, servers: &[ServerInfo], deposits: Vec) -> Result { - if servers.is_empty() { - return Err(Error::Invalid("contact has no server".into())); - } - let calls = servers.iter().map(|s| { - self.transport.call( - s, - Req::Post(v2::Post { - deposits: deposits.clone(), - }), - Duration::ZERO, - ) - }); - let mut ok = 0; - let mut last_err = None; - for (s, r) in servers.iter().zip(join_all(calls).await) { - match r { - Ok(Resp::PostAck(_)) => ok += 1, - Ok(_) => last_err = Some(Error::Network(format!("{}: unexpected response", s.url))), - Err(e) => { - tracing::warn!("deposit on {} failed: {e}", s.url); - last_err = Some(e); - } - } - } - match (ok, last_err) { - (0, Some(e)) => Err(e), - (n, _) => Ok(n), - } - } - // ───────────────────────── sync ───────────────────────── /// Pull every mailbox of every unlocked space on every server (one request per @@ -680,7 +686,9 @@ impl MeowClient { /// sends the acknowledgements and fetches what the servers held back. pub async fn sync(&mut self, wait: Duration) -> Result> { const MAX_ROUNDS: usize = 16; - let mut events = Vec::new(); + // Messages queued while offline go first. + self.flush(false).await?; + let mut events = std::mem::take(&mut self.pending_events); let mut wait = wait; for round in 0..MAX_ROUNDS { let r = match self.pull_round(wait).await { @@ -880,7 +888,6 @@ impl MeowClient { envs.sort_by_key(|(rank, at, _, _, _)| (*rank, *at)); let mut events = Vec::new(); - let mut outgoing: Vec<(Vec, v2::Deposit)> = Vec::new(); for (_, received_at, si, mailbox, env) in envs { let sp = &mut self.spaces[si]; let Some(ci) = sp.state.contacts.iter().position(|c| { @@ -896,7 +903,10 @@ impl MeowClient { Some(v2::peer_envelope::Body::Invitation(inv)) if inv.step == 2 => { match invitation::accept(contact, &inv, now()) { Ok(confirm) => { - outgoing.push((peer_servers(contact), invitation::confirm_deposit(contact, &confirm)?)); + let d = invitation::confirm_deposit(contact, &confirm)?; + sp.state + .outbox + .push(outbox::item(&contact.id, vec![], &d, peer_servers(contact))); events.push(Event::InvitationAccepted { contact: contact.name.clone(), }); @@ -907,7 +917,10 @@ impl MeowClient { Some(v2::peer_envelope::Body::Invitation(inv)) if inv.step == 3 => { match invitation::finalize(contact, &inv) { Ok(ack) => { - outgoing.push((peer_servers(contact), messaging::deposit_for(contact, &ack)?)); + let d = messaging::deposit_for(contact, &ack)?; + sp.state + .outbox + .push(outbox::item(&contact.id, vec![], &d, peer_servers(contact))); events.push(Event::ContactActivated { contact: contact.name.clone(), }); @@ -973,13 +986,10 @@ impl MeowClient { self.retire_mailboxes(si, before); } } - // Persist before anything leaves the device. + // Persist (state, history, acks, queued replies) before anything leaves the device. self.save().await?; - for (servers, deposit) in outgoing { - if let Err(e) = self.deliver(&servers, vec![deposit]).await { - tracing::warn!("could not deliver handshake message: {e}"); - } - } + self.flush(false).await?; + events.append(&mut self.pending_events); Ok(events) } } diff --git a/crates/meow-client/src/outbox.rs b/crates/meow-client/src/outbox.rs new file mode 100644 index 0000000..d2f8022 --- /dev/null +++ b/crates/meow-client/src/outbox.rs @@ -0,0 +1,274 @@ +//! Persistent send queue (roadmap lot 5.5). +//! +//! Every deposit (user message or handshake message) is first stored as an +//! [`OutboxItem`] in the same save as the ratchet state that produced it, then posted +//! to the recipient's pull servers. Servers that accept it are removed from the item; +//! the others are retried with exponential backoff until the item expires. Deposits due +//! at the same time are grouped into one `Post` per server. +//! +//! This is also where Matriochka routing will plug in (roadmap 8.2): an item will carry +//! a route and a release time instead of a plain list of servers. + +use std::collections::{BTreeMap, HashMap}; +use std::time::Duration; + +use futures_util::future::join_all; +use meow_core::contact::ContactId; +use meow_core::server::ServerInfo; +use meow_crypto::SignPublic; +use meow_proto::v2::{self, request::Body as Req, response::Body as Resp}; +use meow_proto::Message; +use meow_store::OutboxItem; + +use crate::{now, Error, Event, MeowClient, Result}; + +/// When to retry and when to give up. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct RetryPolicy { + /// Delay before the first retry; doubled at each attempt. + pub base: Duration, + /// Upper bound of the delay between two attempts. + pub max_delay: Duration, + /// An item older than this is dropped ([`Event::SendFailed`] if no server took it). + pub max_age: Duration, +} + +impl Default for RetryPolicy { + fn default() -> Self { + Self { + base: Duration::from_secs(5), + max_delay: Duration::from_secs(3600), + max_age: Duration::from_secs(7 * 86_400), + } + } +} + +impl RetryPolicy { + /// Delay after `attempts` failed attempts, with ±20 % jitter. + fn delay(&self, attempts: u32) -> u64 { + let base = self.base.as_secs().max(1); + let d = base + .saturating_mul(1u64 << attempts.saturating_sub(1).min(32)) + .min(self.max_delay.as_secs().max(base)); + let spread = (d * 2 / 5).max(1); + let r = u64::from_le_bytes(meow_crypto::random_bytes::<8>()) % (spread + 1); + d - d / 5 + r + } +} + +/// A queued deposit, as shown to the user. +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct PendingSend { + pub contact: String, + /// Empty for handshake messages. + pub message_id: Vec, + /// Servers that already accepted it (it is still retried on the others). + pub accepted: u32, + pub attempts: u32, + pub next_attempt: u64, +} + +/// Deposits per `Post` and their total payload size. +const MAX_BATCH: usize = 64; +const MAX_BATCH_BYTES: usize = 8 * 1024 * 1024; + +pub(crate) fn item( + contact: &ContactId, + message_id: Vec, + deposit: &v2::Deposit, + servers: Vec, +) -> OutboxItem { + let t = now(); + OutboxItem { + id: meow_crypto::random_bytes::<16>().to_vec(), + contact: contact.clone(), + message_id, + deposit: deposit.encode_to_vec(), + pending: servers, + accepted: 0, + attempts: 0, + created_at: t, + next_attempt: t, + } +} + +type Batch = Vec<(usize, Vec, v2::Deposit)>; // (space, item id, deposit) + +impl MeowClient { + /// Change the retry policy of the send queue. + pub fn set_retry_policy(&mut self, policy: RetryPolicy) { + self.retry = policy; + } + + /// Deposits not yet accepted by every server. + pub fn pending_sends(&self) -> Vec { + self.spaces + .iter() + .flat_map(|sp| { + sp.state.outbox.iter().map(|o| PendingSend { + contact: sp + .state + .contacts + .iter() + .find(|c| c.id == o.contact) + .map(|c| c.name.clone()) + .unwrap_or_default(), + message_id: o.message_id.clone(), + accepted: o.accepted, + attempts: o.attempts, + next_attempt: o.next_attempt, + }) + }) + .collect() + } + + /// Try to deliver queued deposits: those due (or all, with `force`). Returns, per + /// item id, how many servers accepted it now. Expiries go to `pending_events`. + pub(crate) async fn flush(&mut self, force: bool) -> Result, usize>> { + let t = now(); + let events = &mut self.pending_events; + // Expired items. + let max_age = self.retry.max_age.as_secs(); + for sp in &mut self.spaces { + let before = sp.state.outbox.len(); + let contacts = &sp.state.contacts; + sp.state.outbox.retain(|o| { + let expired = t >= o.created_at.saturating_add(max_age); + if expired && o.accepted == 0 { + events.push(Event::SendFailed { + contact: contacts + .iter() + .find(|c| c.id == o.contact) + .map(|c| c.name.clone()) + .unwrap_or_default(), + message_id: o.message_id.clone(), + }); + } + !expired + }); + sp.dirty |= sp.state.outbox.len() != before; + } + + // Due deposits grouped by server, in queue order. + let mut by_server: BTreeMap = BTreeMap::new(); + let mut due: Vec<(usize, Vec)> = Vec::new(); + for (si, sp) in self.spaces.iter().enumerate() { + for o in sp.state.outbox.iter().filter(|o| force || o.next_attempt <= t) { + let deposit = match v2::Deposit::decode(o.deposit.as_slice()) { + Ok(d) => d, + Err(e) => { + tracing::warn!("dropping corrupted queued deposit: {e}"); + continue; + } + }; + due.push((si, o.id.clone())); + for s in &o.pending { + by_server + .entry(s.sign_key) + .or_insert_with(|| (s.clone(), Vec::new())) + .1 + .push((si, o.id.clone(), deposit.clone())); + } + } + } + if due.is_empty() { + self.save().await?; + return Ok(HashMap::new()); + } + + // One Post per server and batch; a rejected batch is retried item by item, so + // one bad deposit cannot block the others. + let mut batches: Vec<(ServerInfo, Batch)> = Vec::new(); + for (server, items) in by_server.into_values() { + let mut cur: Batch = Vec::new(); + let mut size = 0; + for it in items { + let n = it.2.payload.len(); + if !cur.is_empty() && (cur.len() >= MAX_BATCH || size + n > MAX_BATCH_BYTES) { + batches.push((server.clone(), std::mem::take(&mut cur))); + size = 0; + } + size += n; + cur.push(it); + } + if !cur.is_empty() { + batches.push((server, cur)); + } + } + let results = join_all(batches.iter().map(|(s, b)| self.post(s, b))).await; + let mut accepted: Vec<(usize, Vec, SignPublic)> = Vec::new(); + for ((server, batch), r) in batches.iter().zip(results) { + match r { + Ok(()) => accepted.extend(batch.iter().map(|(si, id, _)| (*si, id.clone(), server.sign_key))), + Err(Error::Network(e)) => tracing::warn!("deposit on {} failed: {e}", server.url), + Err(e) if batch.len() > 1 => { + tracing::warn!("{} rejected a batch ({e}): retrying one by one", server.url); + for one in batch { + match self.post(server, std::slice::from_ref(one)).await { + Ok(()) => accepted.push((one.0, one.1.clone(), server.sign_key)), + Err(e) => tracing::warn!("{} rejected a deposit: {e}", server.url), + } + } + } + Err(e) => tracing::warn!("{} rejected a deposit: {e}", server.url), + } + } + + // Update the items. + let mut now_accepted: HashMap, usize> = HashMap::new(); + for (si, id, key) in accepted { + if let Some(o) = self.spaces[si].state.outbox.iter_mut().find(|o| o.id == id) { + o.pending.retain(|s| s.sign_key != key); + o.accepted += 1; + *now_accepted.entry(id).or_default() += 1; + } + } + for (si, id) in due { + let retry = self.retry; + let sp = &mut self.spaces[si]; + if let Some(o) = sp.state.outbox.iter_mut().find(|o| o.id == id) { + o.attempts += 1; + o.next_attempt = t + retry.delay(o.attempts); + } + sp.state.outbox.retain(|o| !o.pending.is_empty()); + sp.dirty = true; + } + self.save().await?; + Ok(now_accepted) + } + + /// Deliver queued deposits now, without waiting for their retry time. Returns the + /// pending events (e.g. [`Event::SendFailed`]). + pub async fn flush_outbox(&mut self) -> Result> { + self.flush(true).await?; + Ok(std::mem::take(&mut self.pending_events)) + } + + async fn post(&self, server: &ServerInfo, batch: &[(usize, Vec, v2::Deposit)]) -> Result<()> { + let deposits = batch.iter().map(|(_, _, d)| d.clone()).collect(); + match self + .transport + .call(server, Req::Post(v2::Post { deposits }), Duration::ZERO) + .await? + { + Resp::PostAck(_) => Ok(()), + _ => Err(Error::Invalid("unexpected response".into())), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn backoff_grows_and_is_capped() { + let p = RetryPolicy::default(); + let d1 = p.delay(1); + assert!((4..=6).contains(&d1), "{d1}"); + let d4 = p.delay(4); + assert!((32..=48).contains(&d4), "{d4}"); + let d30 = p.delay(30); + assert!((2880..=4320).contains(&d30), "{d30}"); + } +} diff --git a/crates/meow-client/tests/flow.rs b/crates/meow-client/tests/flow.rs index 3a67e23..92ba7e1 100644 --- a/crates/meow-client/tests/flow.rs +++ b/crates/meow-client/tests/flow.rs @@ -193,11 +193,16 @@ async fn file_and_server_invitations_then_messaging() { struct FlakyStore { inner: MemoryStore, drop_acks: std::sync::atomic::AtomicBool, + /// Refuse deposits (the server answers with an error). + fail_posts: std::sync::atomic::AtomicBool, } #[async_trait::async_trait] impl meow_server::store::ServerStore for FlakyStore { async fn post(&self, mb: [u8; 32], payload: Vec, now: u64) -> meow_server::store::StoreResult<()> { + if self.fail_posts.load(std::sync::atomic::Ordering::SeqCst) { + return Err(meow_server::store::StoreError::Backend("down".into())); + } self.inner.post(mb, payload, now).await } async fn fetch( @@ -230,6 +235,27 @@ impl meow_server::store::ServerStore for FlakyStore { } } +async fn spawn_flaky_server() -> (String, Arc) { + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let url = format!("http://{}", listener.local_addr().unwrap()); + let keys = meow_core::server::ServerKeys::generate(); + let (notify, _) = broadcast::channel(1024); + let store = Arc::new(FlakyStore { + inner: MemoryStore::new(notify.clone(), 1000), + drop_acks: false.into(), + fail_posts: false.into(), + }); + let state = Arc::new(AppState { + card: encode_card(&keys, &url, "flaky", ""), + keys, + store: store.clone(), + notify, + limits: Limits::default(), + }); + tokio::spawn(meow_server::serve(listener, state)); + (url, store) +} + /// What a client that crashed right after receiving the response would have done: /// pull without ever acknowledging. async fn raw_pull( @@ -266,6 +292,7 @@ async fn no_message_lost_when_the_client_dies() { let store = Arc::new(FlakyStore { inner: MemoryStore::new(notify.clone(), 1000), drop_acks: false.into(), + fail_posts: false.into(), }); let limits = Limits { max_pull_messages: 2, // force the "more" path @@ -415,3 +442,76 @@ async fn hidden_contacts() { assert_eq!(alice.history("bob").unwrap().len(), 3); let _ = std::fs::remove_dir_all(&dir); } + +// ───────────── persistent send queue (roadmap lot 5.5) ───────────── + +#[tokio::test(flavor = "multi_thread")] +async fn offline_messages_are_queued_and_retried() { + use std::sync::atomic::Ordering::SeqCst; + let (url, store) = spawn_flaky_server().await; + let servers = vec![url]; + let dir = tmpdir(); + let path = dir.join("bob.mwid2"); + let mut alice = client(&dir, "alice", &servers).await; + let mut bob = client(&dir, "bob", &servers).await; + connect(&mut alice, &mut bob, "bob").await; + + // Server refuses deposits: sending still succeeds, the message is queued. + store.fail_posts.store(true, SeqCst); + let r1 = bob.send_text("alice", "queued 1").await.unwrap(); + let r2 = bob.send_text("alice", "queued 2").await.unwrap(); + assert_eq!((r1.delivered_to, r2.delivered_to), (0, 0)); + let pending = bob.pending_sends(); + assert_eq!(pending.len(), 2); + assert!(pending.iter().all(|p| p.contact == "alice" && p.attempts >= 1)); + assert_eq!(pending[0].message_id, r1.message_id); + assert!(alice.sync(Duration::ZERO).await.unwrap().is_empty()); + + // The queue survives a restart; not yet due (backoff), so a sync does not send. + drop(bob); + let mut bob = MeowClient::open(&path, "pw").await.unwrap(); + assert_eq!(bob.pending_sends().len(), 2); + store.fail_posts.store(false, SeqCst); + bob.sync(Duration::ZERO).await.unwrap(); + assert_eq!(bob.pending_sends().len(), 2); + // Forced flush: both delivered (in one Post), in order. + assert!(bob.flush_outbox().await.unwrap().is_empty()); + assert!(bob.pending_sends().is_empty()); + assert_eq!( + texts(&alice.sync(Duration::ZERO).await.unwrap()), + vec!["queued 1", "queued 2"] + ); + + // Due items are retried by the next send. + bob.set_retry_policy(meow_client::RetryPolicy { + base: Duration::from_secs(1), + ..Default::default() + }); + store.fail_posts.store(true, SeqCst); + bob.send_text("alice", "late").await.unwrap(); + store.fail_posts.store(false, SeqCst); + tokio::time::sleep(Duration::from_millis(2500)).await; + let r = bob.send_text("alice", "now").await.unwrap(); + assert_eq!(r.delivered_to, 1); + assert!(bob.pending_sends().is_empty()); + assert_eq!(texts(&alice.sync(Duration::ZERO).await.unwrap()), vec!["late", "now"]); + + // An item that expires undelivered is reported. + bob.set_retry_policy(meow_client::RetryPolicy { + max_age: Duration::ZERO, + ..Default::default() + }); + store.fail_posts.store(true, SeqCst); + let r = bob.send_text("alice", "lost").await.unwrap(); + assert_eq!(r.delivered_to, 0); + let ev = bob.flush_outbox().await.unwrap(); + assert_eq!( + ev, + vec![Event::SendFailed { + contact: "alice".into(), + message_id: r.message_id + }] + ); + assert!(bob.pending_sends().is_empty()); + let _ = std::fs::remove_dir_all(&dir); +} diff --git a/crates/meow-store/src/lib.rs b/crates/meow-store/src/lib.rs index 40a9273..e771087 100644 --- a/crates/meow-store/src/lib.rs +++ b/crates/meow-store/src/lib.rs @@ -44,7 +44,7 @@ use meow_crypto::password::KdfParams; use rusqlite::{Connection, OptionalExtension}; use serde::{Deserialize, Serialize}; -pub use model::{Batch, Content, HistoryEntry, HistoryPage, PendingAck, RetiredMailbox, SpaceId, State}; +pub use model::{Batch, Content, HistoryEntry, HistoryPage, OutboxItem, PendingAck, RetiredMailbox, SpaceId, State}; #[derive(Debug, thiserror::Error)] pub enum Error { @@ -101,9 +101,15 @@ struct Root { struct Index { meta: Option, contacts: Vec, + outbox: Vec<(Vec, ObjectRef)>, free: Vec, } +fn outbox_key(id: &[u8]) -> String { + let hex: String = id.iter().map(|b| format!("{b:02x}")).collect(); + format!("outbox/{hex}") +} + #[derive(Clone, Serialize, Deserialize)] struct ContactEntry { id: ContactId, @@ -453,6 +459,13 @@ impl Store { } state.contacts.push(c); } + for (id, r) in &sp.index.outbox { + let bytes = blocks::get(&self.conn, &sp.key, r)?; + sp.written.insert(outbox_key(id), meow_crypto::sha256(&[&bytes])); + let item: model::OutboxItem = + postcard::from_bytes(&bytes).map_err(|e| Error::Corrupted(format!("outbox: {e}")))?; + state.outbox.push(item); + } Ok(state) } @@ -466,6 +479,7 @@ impl Store { let new_index_ref; let new_free; let new_contacts; + let new_outbox; let new_meta; { let mut w = Writer::new(&tx, &sp.key, sp.index.free.clone()); @@ -527,6 +541,28 @@ impl Store { } contacts_idx = entries; + // Send queue: one object per item, rewritten only when it changed. + let mut outbox_idx = Vec::with_capacity(state.outbox.len()); + for (id, r) in &sp.index.outbox { + if !state.outbox.iter().any(|o| o.id == *id) { + w.release(r); + } + } + for item in &state.outbox { + let bytes = encode(item)?; + let h = meow_crypto::sha256(&[&bytes]); + let key = outbox_key(&item.id); + let old = sp.index.outbox.iter().find(|(id, _)| *id == item.id).map(|(_, r)| r); + let r = match old { + Some(r) if sp.written.get(&key) == Some(&h) => r.clone(), + old => { + written.push((key, h)); + w.put(&bytes, old)? + } + }; + outbox_idx.push((item.id.clone(), r)); + } + // History and files, per conversation. type Pending = (ContactId, Vec, Vec<(Vec, Vec)>); let mut by_contact: Vec = Vec::new(); @@ -565,6 +601,7 @@ impl Store { encode(&Index { meta: meta_ref.clone(), contacts: contacts_idx.clone(), + outbox: outbox_idx.clone(), free: free.to_vec(), }) })?; @@ -581,6 +618,7 @@ impl Store { new_index_ref = r; new_free = w.free; new_contacts = contacts_idx; + new_outbox = outbox_idx; new_meta = meta_ref; } tx.commit()?; @@ -590,10 +628,14 @@ impl Store { sp.index = Index { meta: new_meta, contacts: new_contacts, + outbox: new_outbox, free: new_free, }; - sp.written - .retain(|k, _| k == "meta" || state.contacts.iter().any(|c| *k == format!("contact/{}", c.id.0))); + sp.written.retain(|k, _| { + k == "meta" + || state.contacts.iter().any(|c| *k == format!("contact/{}", c.id.0)) + || state.outbox.iter().any(|o| *k == outbox_key(&o.id)) + }); sp.written.extend(written); Ok(()) } diff --git a/crates/meow-store/src/model.rs b/crates/meow-store/src/model.rs index a1aa0bb..f247749 100644 --- a/crates/meow-store/src/model.rs +++ b/crates/meow-store/src/model.rs @@ -65,6 +65,29 @@ pub struct RetiredMailbox { pub servers: Vec, } +/// A deposit waiting to be accepted by servers (persistent send queue). +/// +/// Written in the same save as the ratchet state that produced it, so a message is +/// never encrypted without being stored for (re)delivery. +#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)] +pub struct OutboxItem { + /// Random queue id (16 bytes). + pub id: Vec, + pub contact: ContactId, + /// Id of the user message, empty for handshake messages. + pub message_id: Vec, + /// Encoded `meow.v2.Deposit`. + pub deposit: Vec, + /// Servers that have not accepted the deposit yet. + pub pending: Vec, + /// Servers that accepted it. + pub accepted: u32, + pub attempts: u32, + pub created_at: u64, + /// Unix time before which no new attempt is made. + pub next_attempt: u64, +} + /// What the client keeps in memory for one space. Saved as a whole by /// [`crate::Store::save`]; unchanged objects are not rewritten. `nickname` and /// `servers` are only meaningful in the main space. @@ -75,6 +98,7 @@ pub struct State { pub contacts: Vec, pub pending_acks: Vec, pub retired_mailboxes: Vec, + pub outbox: Vec, } /// Append-only data written in the same transaction as a [`State`]. diff --git a/crates/meow-store/tests/store.rs b/crates/meow-store/tests/store.rs index aca8202..89b8aa2 100644 --- a/crates/meow-store/tests/store.rs +++ b/crates/meow-store/tests/store.rs @@ -371,3 +371,49 @@ fn schema_versions_and_foreign_files() { )); let _ = std::fs::remove_dir_all(dir); } + +#[test] +fn outbox_items_persist_per_space() { + let (path, dir) = tmp(); + let s = server(); + let bob = contact("bob", &s); + let item = |n: u8, data: Vec| meow_store::OutboxItem { + id: vec![n; 16], + contact: bob.id.clone(), + message_id: vec![n; 16], + deposit: data, + pending: vec![s.clone()], + accepted: 0, + attempts: 0, + created_at: 1, + next_attempt: 1, + }; + let mut store = Store::create(&path, "alice", "pw", KDF, false).unwrap(); + let mut state = store.load(MAIN).unwrap(); + state.contacts.push(bob.clone()); + // A large deposit spans several blocks. + state.outbox = vec![item(1, vec![7; 10_000]), item(2, b"small".to_vec())]; + store.save(MAIN, &state, Batch::default()).unwrap(); + let h = store.create_space("hidden").unwrap(); + drop(store); + + let mut store = Store::open(&path, "pw").unwrap(); + let mut loaded = store.load(MAIN).unwrap(); + assert_eq!(loaded.outbox, state.outbox); + // Update one, drop the other. + loaded.outbox.retain(|o| o.id[0] == 1); + loaded.outbox[0].attempts = 3; + store.save(MAIN, &loaded, Batch::default()).unwrap(); + drop(store); + + let mut store = Store::open(&path, "pw").unwrap(); + let again = store.load(MAIN).unwrap(); + assert_eq!(again.outbox.len(), 1); + assert_eq!(again.outbox[0].attempts, 3); + assert_eq!(again.outbox[0].deposit, vec![7; 10_000]); + // Other spaces have their own queue. + let h2 = store.unlock("hidden").unwrap().unwrap(); + assert_eq!(h2, h); + assert!(store.load(h2).unwrap().outbox.is_empty()); + let _ = std::fs::remove_dir_all(dir); +} diff --git a/tests/e2e.sh b/tests/e2e.sh index b70ba7a..708f26f 100755 --- a/tests/e2e.sh +++ b/tests/e2e.sh @@ -181,6 +181,15 @@ kill "${PIDS[1]}"; wait "${PIDS[1]}" 2>/dev/null || true; PIDS[1]="" expect "send with one server down" "(1 server(s))" meow bob send alice "still here" expect "receive with one server down" "[bob] still here" meow alice 2>/dev/null +step "OFFLINE QUEUE" +kill "${PIDS[0]}"; wait "${PIDS[0]}" 2>/dev/null || true; PIDS[0]="" +expect "send with every server down" "queued for alice" meow bob send alice "written offline" +expect "queued" "alice message accepted by 0 server(s)" meow bob outbox +start_server "$PORT1" srv1 +for _ in $(seq 50); do curl -fs "$S1/healthz" >/dev/null 2>&1 && break; sleep 0.1; done +expect "flushed when back (srv2 still down)" "accepted by 1 server(s)" meow bob outbox --flush +expect "received" "[bob] written offline" meow alice 2>/dev/null + step "HISTORY" expect "history" "[alice] hi bob" meow bob history alice