diff --git a/wacore/libsignal/src/protocol/error.rs b/wacore/libsignal/src/protocol/error.rs index 7075aa44..86cd028b 100644 --- a/wacore/libsignal/src/protocol/error.rs +++ b/wacore/libsignal/src/protocol/error.rs @@ -30,6 +30,11 @@ pub enum SignalProtocolError { #[source] Box, ), + /// A verified bundle changed local state, but its store could not finalize it. + /// Callers must abort the surrounding batch rather than skip this device. + #[error("prekey bundle local finalization failed")] + PreKeyBundleFinalizationFailed(#[source] Box), + #[error("protobuf encoding was invalid")] InvalidProtobufEncoding, diff --git a/wacore/libsignal/src/protocol/session.rs b/wacore/libsignal/src/protocol/session.rs index 0bf7c746..a19bf18c 100644 --- a/wacore/libsignal/src/protocol/session.rs +++ b/wacore/libsignal/src/protocol/session.rs @@ -187,11 +187,23 @@ pub async fn process_prekey_bundle( .await; if had_session || result.is_ok() { - session.commit().await?; + // Identity writes can already be pending when checkout storage fails. + // Fan-out must discard that batch, just as for an acceptance-hook failure. + session.commit().await.map_err(|error| { + SignalProtocolError::PreKeyBundleFinalizationFailed(Box::new(error)) + })?; } else { session.discard(); } + if result.is_ok() { + session_store + .on_prekey_bundle_accepted(remote_address, their_identity_key) + .await + .map_err(|error| { + SignalProtocolError::PreKeyBundleFinalizationFailed(Box::new(error)) + })?; + } result } diff --git a/wacore/libsignal/src/protocol/storage/traits.rs b/wacore/libsignal/src/protocol/storage/traits.rs index 733aa479..2f48aece 100644 --- a/wacore/libsignal/src/protocol/storage/traits.rs +++ b/wacore/libsignal/src/protocol/storage/traits.rs @@ -222,6 +222,19 @@ pub trait SessionStore: ThreadSafe { /// Destructive cache checkouts belong in `load_session_for_update`. async fn load_session(&self, address: &ProtocolAddress) -> Result>; + /// Finish local state work after a verified prekey bundle is accepted. + /// Scoped stores can invalidate sibling ratchets in the same transaction. + /// The default leaves existing unscoped stores unchanged. This hook must + /// not publish ciphertext or perform network work. + async fn on_prekey_bundle_accepted( + &mut self, + address: &ProtocolAddress, + identity: &IdentityKey, + ) -> Result<()> { + let _ = (address, identity); + Ok(()) + } + /// Hint to fault `addresses` into the store in one backend round-trip. /// /// A send fans out over every device, and without this each device pays its diff --git a/wacore/libsignal/tests/counter_lease.rs b/wacore/libsignal/tests/counter_lease.rs index c14387d0..60b3019d 100644 --- a/wacore/libsignal/tests/counter_lease.rs +++ b/wacore/libsignal/tests/counter_lease.rs @@ -900,3 +900,112 @@ fn waiving_burns_the_ceiling_into_archived_states_too() { .index; assert_eq!(archived_index, Some(ceiling)); } + +struct BundleCommitStore { + inner: InMemorySessionStore, + fail_commit: bool, + accepted: usize, +} + +#[async_trait] +impl SessionStore for BundleCommitStore { + async fn load_session( + &self, + address: &ProtocolAddress, + ) -> wacore_libsignal::protocol::error::Result> { + self.inner.load_session(address).await + } + + async fn has_session( + &self, + address: &ProtocolAddress, + ) -> wacore_libsignal::protocol::error::Result { + self.inner.has_session(address).await + } + + async fn store_session( + &mut self, + address: &ProtocolAddress, + record: SessionRecord, + ) -> wacore_libsignal::protocol::error::Result<()> { + if self.fail_commit { + return Err(SignalProtocolError::BackendError( + "authored session commit failure", + std::io::Error::other("authored unavailable session store").into(), + )); + } + self.inner.store_session(address, record).await + } + + async fn on_prekey_bundle_accepted( + &mut self, + _address: &ProtocolAddress, + _identity: &IdentityKey, + ) -> wacore_libsignal::protocol::error::Result<()> { + self.accepted += 1; + Ok(()) + } +} + +#[test] +fn bundle_commit_errors_require_the_enclosing_batch_to_abort() { + let mut initiator = Peer::new("authored-commit-initiator"); + let target = Peer::new("authored-commit-target"); + let bundle = BUNDLES.with(|b| b.borrow().get(&target.address).cloned().unwrap()); + let mut store = BundleCommitStore { + inner: InMemorySessionStore::default(), + fail_commit: true, + accepted: 0, + }; + let mut rng = rand::make_rng::(); + let error = futures::executor::block_on(process_prekey_bundle( + &target.address, + &mut store, + &mut initiator.identity_store, + &bundle, + &mut rng, + UsePQRatchet::No, + )) + .unwrap_err(); + // Identity storage precedes checkout commit. Fan-out must discard this + // pending identity instead of treating the device as an ordinary drop. + assert_eq!( + initiator.identity_store.identities.get(&target.address), + Some(bundle.identity_key().unwrap()) + ); + assert_eq!(store.accepted, 0); + assert!(store.inner.0.is_empty()); + match error { + SignalProtocolError::PreKeyBundleFinalizationFailed(cause) => { + assert!(matches!( + *cause, + SignalProtocolError::BackendError("authored session commit failure", _) + )); + } + other => panic!("commit failure did not require batch abort: {other}"), + } +} + +#[test] +fn a_successful_bundle_commit_runs_acceptance_once() { + let mut initiator = Peer::new("authored-success-initiator"); + let target = Peer::new("authored-success-target"); + let bundle = BUNDLES.with(|b| b.borrow().get(&target.address).cloned().unwrap()); + let mut store = BundleCommitStore { + inner: InMemorySessionStore::default(), + fail_commit: false, + accepted: 0, + }; + let mut rng = rand::make_rng::(); + futures::executor::block_on(process_prekey_bundle( + &target.address, + &mut store, + &mut initiator.identity_store, + &bundle, + &mut rng, + UsePQRatchet::No, + )) + .unwrap(); + assert_eq!(store.accepted, 1); + assert!(store.inner.0.contains_key(&target.address)); +} diff --git a/wacore/signal-ops/src/error.rs b/wacore/signal-ops/src/error.rs index 0a5fae56..d70b37be 100644 --- a/wacore/signal-ops/src/error.rs +++ b/wacore/signal-ops/src/error.rs @@ -43,10 +43,73 @@ impl OpsError { pub fn is_fence_lost(&self) -> bool { match self { OpsError::Store(e) => state_is_refused(e), - OpsError::Signal(SignalProtocolError::BackendError(_, source)) => source - .downcast_ref::() - .is_some_and(state_is_refused), + OpsError::Signal(error) => signal_state_is_refused(error), _ => false, } } } + +fn signal_state_is_refused(error: &SignalProtocolError) -> bool { + let mut source: Option<&(dyn std::error::Error + 'static)> = Some(error); + while let Some(current) = source { + if current + .downcast_ref::() + .is_some_and(state_is_refused) + { + return true; + } + source = current.source(); + } + false +} + +#[cfg(test)] +mod tests { + use super::*; + + fn wrapped_backend(source: StoreError, depth: usize) -> OpsError { + let mut error = SignalProtocolError::BackendError("authored store", Box::new(source)); + for _ in 0..depth { + error = SignalProtocolError::PreKeyBundleFinalizationFailed(Box::new(error)); + } + OpsError::Signal(error) + } + + #[test] + fn finalization_preserves_lost_fence_and_interrupted_state() { + for depth in [0, 1, 3] { + let lost = wacore_recordstore::FenceLost { + scope: "authored-fence-classification".into(), + generation: 7, + } + .into_store_error(); + assert!( + wrapped_backend(lost, depth).is_fence_lost(), + "lost fence at depth {depth}" + ); + let OpsError::Store(interrupted) = interrupted_operation() else { + unreachable!() + }; + assert!( + wrapped_backend(interrupted, depth).is_fence_lost(), + "interrupted state at depth {depth}" + ); + } + } + + #[test] + fn finalization_keeps_ordinary_failures_distinct_from_state_refusal() { + for depth in [0, 1, 3] { + let io = StoreError::Io(std::io::Error::other("authored ordinary I/O error")); + assert!(!wrapped_backend(io, depth).is_fence_lost()); + } + assert!( + !OpsError::Signal(SignalProtocolError::PreKeyBundleFinalizationFailed( + Box::new(SignalProtocolError::InvalidArgument( + "authored input failure".into() + ),) + )) + .is_fence_lost() + ); + } +} diff --git a/wacore/signal-ops/src/inbound.rs b/wacore/signal-ops/src/inbound.rs index 3be4068b..8aa0f83d 100644 --- a/wacore/signal-ops/src/inbound.rs +++ b/wacore/signal-ops/src/inbound.rs @@ -52,6 +52,8 @@ pub enum Received { /// Delivered before; the client only needs to send its receipt again. AlreadyDelivered { receipt_key: String, + /// Classification retained in the delivered marker, without plaintext. + group_status_wrapper: Option, }, } @@ -75,7 +77,7 @@ pub struct ReceivedMessage { pub app_state_key_share: Option, } -fn receipt_key(request: &ReceiveRequest<'_>) -> String { +fn receipt_key(request: &ReceiveRequest<'_>, status_session: bool) -> String { let mut hasher = Sha256::new(); for part in [ request.kind.as_str().as_bytes(), @@ -85,6 +87,9 @@ fn receipt_key(request: &ReceiveRequest<'_>) -> String { hasher.update(part); hasher.update([0]); } + if status_session { + hasher.update(b"status-session\0"); + } hasher.update(request.ciphertext); hex::encode(hasher.finalize()) } @@ -129,13 +134,17 @@ impl BufferEntry { }) } - fn delivered(inserted_ms: u64) -> Self { + fn delivered(inserted_ms: u64, group_status_wrapper: Option) -> Self { Self { state: STATE_DELIVERED, padding_version: 0, identity_changed: false, inserted_ms, - padded_plaintext: Vec::new(), + // A delivered marker never carries message content. Older readers + // ignore its trailing metadata; empty legacy markers stay unknown. + padded_plaintext: group_status_wrapper + .map(|flag| vec![u8::from(flag)]) + .unwrap_or_default(), } } } @@ -183,7 +192,31 @@ impl SignalOps { /// Decrypt, buffer and classify one received payload. Sender-key /// distributions inside it are stored in the same batch as the decrypt. pub async fn receive(&self, request: ReceiveRequest<'_>) -> Result { - let receipt_key = receipt_key(&request); + self.receive_scoped(request, false).await + } + + /// Receive a status using a separate pairwise session when selected by + /// the caller's served configuration. Identity/prekeys and sender keys + /// remain shared. This does not enable status publishing. + pub async fn receive_status( + &self, + request: ReceiveRequest<'_>, + status_session: bool, + ) -> Result { + if status_session && request.kind == ReceiveKind::SenderKey { + return Err(OpsError::InvalidInput( + "sender keys cannot use a pairwise status session".into(), + )); + } + self.receive_scoped(request, status_session).await + } + + async fn receive_scoped( + &self, + request: ReceiveRequest<'_>, + status_session: bool, + ) -> Result { + let receipt_key = receipt_key(&request, status_session); // Pairwise payloads can carry a sender-key distribution for this chat, // so they also lock the sender's chain. let chain = chain_key(request.chat, request.sender.as_str()); @@ -200,7 +233,14 @@ impl SignalOps { { let entry = BufferEntry::decode(bytes)?; if entry.state == STATE_DELIVERED { - return Ok(Received::AlreadyDelivered { receipt_key }); + return Ok(Received::AlreadyDelivered { + receipt_key, + group_status_wrapper: match entry.padded_plaintext.as_slice() { + [0] => Some(false), + [1] => Some(true), + _ => None, + }, + }); } let content = classify( &entry.padded_plaintext, @@ -226,7 +266,13 @@ impl SignalOps { EncKind::Message }; let decrypted = self - .decrypt_into(&staged, request.sender, kind, request.ciphertext) + .decrypt_into_scoped( + &staged, + request.sender, + kind, + request.ciphertext, + status_session, + ) .await?; (decrypted.plaintext, decrypted.identity_changed) } @@ -252,7 +298,7 @@ impl SignalOps { .put_aux( Namespace::DecryptBuffer, &receipt_key, - &BufferEntry::delivered(inserted_ms).encode(), + &BufferEntry::delivered(inserted_ms, None).encode(), ) .await?; staged.commit().await?; @@ -317,7 +363,13 @@ impl SignalOps { .put_aux( Namespace::DecryptBuffer, receipt_key, - &BufferEntry::delivered(entry.inserted_ms).encode(), + &BufferEntry::delivered( + entry.inserted_ms, + classify(&entry.padded_plaintext, entry.padding_version, true) + .ok() + .map(|content| content.message.group_status_message_v2.is_set()), + ) + .encode(), ) .await?; } diff --git a/wacore/signal-ops/src/ops.rs b/wacore/signal-ops/src/ops.rs index 90376670..7a6bf5a3 100644 --- a/wacore/signal-ops/src/ops.rs +++ b/wacore/signal-ops/src/ops.rs @@ -350,6 +350,7 @@ impl SignalOps { pub(crate) async fn stores_over(&self, store: Arc) -> Stores { Stores { store, + status_session: false, keys: self.authority.keys.read().await.clone(), sender_key_locks: self.authority.sender_key_locks.clone(), } @@ -484,6 +485,10 @@ impl SignalOps { let mut found = Vec::new(); for ns in [Namespace::Session, Namespace::Identity] { for address in self.store.scan_peer_addresses(ns, user).await? { + let address = address + .strip_suffix("_status") + .unwrap_or(&address) + .to_owned(); if let Some(device) = device_of(&address, user, server) { found.push((address, device)); } @@ -516,7 +521,11 @@ impl SignalOps { held.run(async { let batch: Vec> = addresses.iter().map(|a| Arc::from(a.as_str())).collect(); let staged = self.store.staged(); - staged.delete_sessions_batch(&batch).await?; + let sessions: Vec> = addresses + .iter() + .flat_map(|a| [Arc::from(a.as_str()), Arc::from(format!("{a}_status"))]) + .collect(); + staged.delete_sessions_batch(&sessions).await?; staged.delete_identities_batch(&batch).await?; staged.commit().await?; Ok(()) @@ -562,10 +571,14 @@ impl SignalOps { let mut moved = 0; for (from, to) in &moves { let mut changed = false; - if let Some(session) = staged.get_session(from).await? { - staged.put_session(to, &session).await?; - staged.delete_session(from).await?; - changed = true; + for suffix in ["", "_status"] { + let from_key = format!("{from}{suffix}"); + let to_key = format!("{to}{suffix}"); + if let Some(session) = staged.get_session(&from_key).await? { + staged.put_session(&to_key, &session).await?; + staged.delete_session(&from_key).await?; + changed = true; + } } if let Some(identity) = staged.load_identity(from).await? { if staged.load_identity(to).await?.is_none() { @@ -652,8 +665,21 @@ impl SignalOps { sender: &ProtocolAddress, kind: EncKind, ciphertext: &[u8], + ) -> Result { + self.decrypt_into_scoped(staged, sender, kind, ciphertext, false) + .await + } + + pub(crate) async fn decrypt_into_scoped( + &self, + staged: &Arc, + sender: &ProtocolAddress, + kind: EncKind, + ciphertext: &[u8], + status_session: bool, ) -> Result { let mut sessions = self.stores_over(staged.clone()).await; + sessions.status_session = status_session; let mut identities = sessions.clone(); let result = match kind { EncKind::PreKey => { @@ -683,6 +709,26 @@ impl SignalOps { if let Some(id) = result.consumed_prekey_id { staged.remove_prekey(id.into()).await?; } + if matches!( + result.identity_change, + wacore::libsignal::protocol::IdentityChange::ReplacedExisting + ) { + // Keep the session just promoted and invalidate the other ratchet. + let other = if status_session { + sender.as_str().to_owned() + } else { + format!("{}_status", sender.as_str()) + }; + let identity = staged + .load_identity(sender.as_str()) + .await? + .ok_or_else(|| OpsError::InvalidInput("missing accepted identity".into()))?; + let accepted = IdentityKey::new( + PublicKey::from_djb_public_key_bytes(&identity) + .map_err(wacore::libsignal::protocol::SignalProtocolError::from)?, + ); + crate::stores::invalidate_sibling_identity(staged.as_ref(), &other, &accepted).await?; + } Ok(Decrypted { plaintext: result.plaintext, identity_changed: matches!( diff --git a/wacore/signal-ops/src/stores.rs b/wacore/signal-ops/src/stores.rs index 15b0882c..77893532 100644 --- a/wacore/signal-ops/src/stores.rs +++ b/wacore/signal-ops/src/stores.rs @@ -41,8 +41,38 @@ where move |e| SignalProtocolError::BackendError(context, e.into()) } +// Keep sibling ratchets only when they belong to the accepted identity. A +// delayed archived message can temporarily change the shared identity row. +pub(crate) async fn invalidate_sibling_identity( + store: &S, + key: &str, + accepted: &IdentityKey, +) -> SignalResult<()> { + if let Some(bytes) = store + .get_session(key) + .await + .map_err(backend("load sibling session"))? + { + let record = SessionRecord::deserialize_for_store(&bytes, incarnation())?; + if let Some(state) = record.session_state() { + let identity = state.remote_identity_key().map_err(|_| { + SignalProtocolError::InvalidArgument("invalid sibling session identity".into()) + })?; + if identity.as_ref() == Some(accepted) { + return Ok(()); + } + } + store + .delete_session(key) + .await + .map_err(backend("delete sibling session"))?; + } + Ok(()) +} + pub(crate) struct Stores { pub store: Arc, + pub status_session: bool, pub keys: Arc, pub sender_key_locks: Arc, } @@ -51,6 +81,7 @@ impl Clone for Stores { fn clone(&self) -> Self { Self { store: self.store.clone(), + status_session: self.status_session, keys: self.keys.clone(), sender_key_locks: self.sender_key_locks.clone(), } @@ -83,7 +114,11 @@ impl SessionStore for Stores { async fn load_session(&self, address: &ProtocolAddress) -> SignalResult> { match self .store - .get_session(address.as_str()) + .get_session(&if self.status_session { + format!("{}_status", address.as_str()) + } else { + address.as_str().to_owned() + }) .await .map_err(backend("load_session"))? { @@ -95,9 +130,26 @@ impl SessionStore for Stores { } } + async fn on_prekey_bundle_accepted( + &mut self, + address: &ProtocolAddress, + identity: &IdentityKey, + ) -> SignalResult<()> { + let sibling = if self.status_session { + address.as_str().to_owned() + } else { + format!("{}_status", address.as_str()) + }; + invalidate_sibling_identity(self.store.as_ref(), &sibling, identity).await + } + async fn has_session(&self, address: &ProtocolAddress) -> SignalResult { self.store - .has_session(address.as_str()) + .has_session(&if self.status_session { + format!("{}_status", address.as_str()) + } else { + address.as_str().to_owned() + }) .await .map_err(backend("has_session")) } @@ -110,7 +162,14 @@ impl SessionStore for Stores { let mut bytes = Vec::new(); record.serialize_into_for_store(&mut bytes, incarnation()); self.store - .put_session(address.as_str(), &bytes) + .put_session( + &if self.status_session { + format!("{}_status", address.as_str()) + } else { + address.as_str().to_owned() + }, + &bytes, + ) .await .map_err(backend("store_session")) } diff --git a/wacore/signal-ops/tests/receive.rs b/wacore/signal-ops/tests/receive.rs index 3993bba9..8c70fed0 100644 --- a/wacore/signal-ops/tests/receive.rs +++ b/wacore/signal-ops/tests/receive.rs @@ -5,7 +5,11 @@ use futures::executor::block_on; use std::sync::Arc; use wacore::libsignal::protocol::{DeviceId, ProtocolAddress}; use wacore::messages::MessageUtils; +use wacore::store::traits::SignalStore; +use wacore::types::jid::JidExt; +use wacore_binary::Jid; use wacore_recordstore::{AesGcmSealer, LeaseStore, MemoryRecordStore, RecordSignalStore}; +use wacore_recordstore::{Namespace, RecordStore}; use wacore_signal_ops::{ Encrypted, ReceiveKind, ReceiveRequest, Received, ReceivedMessage, RemoteBundle, SignalOps, }; @@ -20,6 +24,7 @@ struct Device { records: Arc, scope: &'static str, ops: SignalOps, + store: Arc, } fn store_for(records: &Arc, scope: &str, holder: &str, now: u64) -> Arc { @@ -35,11 +40,13 @@ fn store_for(records: &Arc, scope: &str, holder: &str, now: u fn device(scope: &'static str) -> Device { let records = Arc::new(MemoryRecordStore::new()); - let ops = block_on(SignalOps::create(store_for(&records, scope, "node-a", 0))).unwrap(); + let store = store_for(&records, scope, "node-a", 0); + let ops = block_on(SignalOps::create(store.clone())).unwrap(); Device { records, scope, ops, + store, } } @@ -329,3 +336,273 @@ fn a_bad_sender_key_does_not_block_the_message_carrying_it() { // Committed: a redelivery is served from the buffer, not decrypted again. assert!(message(block_on(bob.ops.receive(req)).unwrap()).redelivered); } + +#[test] +fn status_ratchets_alternate_without_changing_chat_state_and_follow_identity_migration() { + let alice = device("alice-status"); + let bob = device("bob-status"); + let alice_addr = "111:1@s.whatsapp.net" + .parse::() + .unwrap() + .to_protocol_address(); + let bob_addr = "222:1@s.whatsapp.net" + .parse::() + .unwrap() + .to_protocol_address(); + let mut sender_sessions = Vec::new(); + for status in [false, true] { + connect(&alice, &bob, &bob_addr); + let body = if status { "status first" } else { "chat first" }; + let sent = block_on(alice.ops.encrypt(&bob_addr, &padded(&text(body)))).unwrap(); + let req = request( + if status { + "status@broadcast" + } else { + "111@s.whatsapp.net" + }, + &alice_addr, + kind(&sent), + &sent.ciphertext, + false, + ); + let received = message(block_on(bob.ops.receive_status(req, status)).unwrap()); + assert_eq!(received.content.message.conversation.as_deref(), Some(body)); + let repeated = message(block_on(bob.ops.receive_status(req, status)).unwrap()); + assert!(repeated.redelivered); + block_on(bob.ops.mark_delivered(&received.receipt_key)).unwrap(); + assert!(matches!( + block_on(bob.ops.receive_status(req, status)).unwrap(), + Received::AlreadyDelivered { .. } + )); + sender_sessions.push( + block_on(alice.store.get_session(bob_addr.as_str())) + .unwrap() + .unwrap(), + ); + } + for i in 0..4 { + let status = i % 2 == 1; + block_on( + alice + .store + .put_session(bob_addr.as_str(), &sender_sessions[i % 2]), + ) + .unwrap(); + let body = format!("authored alternating {i}"); + let sent = block_on(alice.ops.encrypt(&bob_addr, &padded(&text(&body)))).unwrap(); + sender_sessions[i % 2] = block_on(alice.store.get_session(bob_addr.as_str())) + .unwrap() + .unwrap(); + let req = request( + if status { + "status@broadcast" + } else { + "111@s.whatsapp.net" + }, + &alice_addr, + kind(&sent), + &sent.ciphertext, + false, + ); + let received = message(block_on(bob.ops.receive_status(req, status)).unwrap()); + assert_eq!( + received.content.message.conversation.as_deref(), + Some(body.as_str()) + ); + assert!(!received.identity_changed); + } + let pn: Jid = "111@s.whatsapp.net".parse().unwrap(); + let lid: Jid = "333@lid".parse().unwrap(); + assert_eq!(block_on(bob.ops.migrate_pn_to_lid(&pn, &lid)).unwrap(), 1); + let migrated: Jid = "333:1@lid".parse().unwrap(); + let address = migrated.to_protocol_address(); + let keys = block_on( + bob.records + .scan_keys(bob.scope, Namespace::Session, "", None), + ) + .unwrap(); + assert_eq!(keys.len(), 2); + assert!(keys.contains(&address.as_str().to_owned())); + assert!(keys.contains(&format!("{}_status", address.as_str()))); + block_on(bob.ops.forget_user(&lid)).unwrap(); + assert!( + block_on( + bob.records + .scan_keys(bob.scope, Namespace::Session, "", None) + ) + .unwrap() + .is_empty() + ); + assert!( + block_on( + bob.records + .scan_keys(bob.scope, Namespace::Identity, "", None) + ) + .unwrap() + .is_empty() + ); +} + +#[test] +fn delivered_group_publications_keep_only_classification_for_legacy_receipts() { + let alice = device("alice-legacy-group-status"); + let bob = device("bob-legacy-group-status"); + let (alice_addr, bob_addr) = (address("111"), address("222")); + connect(&alice, &bob, &bob_addr); + let publication = wa::Message { + group_status_message_v2: wa::message::FutureProofMessage { + message: text("authored publication").into(), + } + .into(), + ..Default::default() + }; + let sent = block_on(alice.ops.encrypt(&bob_addr, &padded(&publication))).unwrap(); + let request = request(GROUP, &alice_addr, kind(&sent), &sent.ciphertext, false); + let first = message(block_on(bob.ops.receive(request)).unwrap()); + assert!(first.content.message.group_status_message_v2.is_set()); + block_on(bob.ops.mark_delivered(&first.receipt_key)).unwrap(); + assert!(matches!( + block_on(bob.ops.receive(request)).unwrap(), + Received::AlreadyDelivered { + group_status_wrapper: Some(true), + .. + } + )); + let mut legacy_marker = block_on( + bob.store + .load_aux(Namespace::DecryptBuffer, &first.receipt_key), + ) + .unwrap() + .unwrap(); + assert_eq!(legacy_marker.pop(), Some(1)); + block_on( + bob.store + .put_aux(Namespace::DecryptBuffer, &first.receipt_key, &legacy_marker), + ) + .unwrap(); + assert!(matches!( + block_on(bob.ops.receive(request)).unwrap(), + Received::AlreadyDelivered { + group_status_wrapper: None, + .. + } + )); +} + +#[test] +fn outbound_identity_replacement_invalidates_the_old_status_session() { + let old_peer = device("old-peer"); + let new_peer = device("new-peer"); + let receiver = device("identity-receiver"); + let peer_addr = address("111"); + let receiver_addr = address("222"); + connect(&old_peer, &receiver, &receiver_addr); + let sent = block_on( + old_peer + .ops + .encrypt(&receiver_addr, &padded(&text("authored old status"))), + ) + .unwrap(); + let req = request( + "status@broadcast", + &peer_addr, + kind(&sent), + &sent.ciphertext, + false, + ); + message(block_on(receiver.ops.receive_status(req, true)).unwrap()); + let status_key = format!("{}_status", peer_addr.as_str()); + let old_status = block_on(receiver.store.get_session(&status_key)) + .unwrap() + .unwrap(); + connect(&receiver, &old_peer, &peer_addr); + assert_eq!( + block_on(receiver.store.get_session(&status_key)).unwrap(), + Some(old_status) + ); + connect(&receiver, &new_peer, &peer_addr); + assert!( + block_on(receiver.store.get_session(&status_key)) + .unwrap() + .is_none() + ); + let expected = padded(&text("authored new chat")); + let sent = block_on(receiver.ops.encrypt(&peer_addr, &expected)).unwrap(); + assert_eq!( + block_on( + new_peer + .ops + .decrypt(&receiver_addr, sent.kind, &sent.ciphertext) + ) + .unwrap() + .plaintext, + expected + ); +} + +#[test] +fn delayed_archived_prekey_does_not_discard_a_sibling_with_the_accepted_identity() { + let old_peer = device("delayed-old-peer"); + let new_peer = device("delayed-new-peer"); + let receiver = device("delayed-receiver"); + let peer_addr = address("111"); + let receiver_addr = address("222"); + connect(&old_peer, &receiver, &receiver_addr); + let first = block_on( + old_peer + .ops + .encrypt(&receiver_addr, &padded(&text("authored first chat"))), + ) + .unwrap(); + block_on( + receiver + .ops + .decrypt(&peer_addr, first.kind, &first.ciphertext), + ) + .unwrap(); + let delayed = block_on( + old_peer + .ops + .encrypt(&receiver_addr, &padded(&text("authored delayed chat"))), + ) + .unwrap(); + // The new bundle archives the old chat ratchet, while the status peer uses B. + connect(&receiver, &new_peer, &peer_addr); + connect(&new_peer, &receiver, &receiver_addr); + let status = block_on( + new_peer + .ops + .encrypt(&receiver_addr, &padded(&text("authored new status"))), + ) + .unwrap(); + message( + block_on(receiver.ops.receive_status( + request( + "status@broadcast", + &peer_addr, + kind(&status), + &status.ciphertext, + false, + ), + true, + )) + .unwrap(), + ); + let key = format!("{}_status", peer_addr.as_str()); + let retained = block_on(receiver.store.get_session(&key)).unwrap().unwrap(); + block_on( + receiver + .ops + .decrypt(&peer_addr, delayed.kind, &delayed.ciphertext), + ) + .unwrap(); + assert_eq!( + block_on(receiver.store.get_session(&key)).unwrap(), + Some(retained.clone()) + ); + connect(&receiver, &new_peer, &peer_addr); + assert_eq!( + block_on(receiver.store.get_session(&key)).unwrap(), + Some(retained) + ); +} diff --git a/wacore/signal-ops/tests/send.rs b/wacore/signal-ops/tests/send.rs index 7f2a25c6..23b8b241 100644 --- a/wacore/signal-ops/tests/send.rs +++ b/wacore/signal-ops/tests/send.rs @@ -109,7 +109,7 @@ impl SendContextResolver for FakeClient { } } -async fn bundle_for(ops: &SignalOps) -> PreKeyBundle { +async fn bundle_for(ops: &SignalOps) -> PreKeyBundle { let identity = ops.public_identity().await; let prekey = ops.generate_prekeys(1).await.unwrap().remove(0); PreKeyBundle::new( @@ -992,3 +992,277 @@ async fn a_corrupt_record_is_pruned_instead_of_stopping_the_prune() { .is_none() ); } + +#[derive(Default)] +struct BundleFaultRecords { + inner: MemoryRecordStore, + fail_status_read: std::sync::atomic::AtomicBool, +} + +#[async_trait] +impl wacore_recordstore::RecordStore for BundleFaultRecords { + async fn get( + &self, + scope: &str, + ns: wacore_recordstore::Namespace, + key: &str, + ) -> wacore::store::error::Result>> { + if ns == wacore_recordstore::Namespace::Session + && key.ends_with("_status") + && self + .fail_status_read + .swap(false, std::sync::atomic::Ordering::SeqCst) + { + return Err(wacore::store::error::StoreError::Io(std::io::Error::other( + "authored sibling read failure", + ))); + } + self.inner.get(scope, ns, key).await + } + async fn scan_keys( + &self, + scope: &str, + ns: wacore_recordstore::Namespace, + prefix: &str, + limit: Option, + ) -> wacore::store::error::Result> { + self.inner.scan_keys(scope, ns, prefix, limit).await + } + async fn write( + &self, + fence: &wacore_recordstore::Fence, + ops: &[wacore_recordstore::WriteOp], + ) -> wacore::store::error::Result<()> { + self.inner.write(fence, ops).await + } +} + +async fn cold_status_identity_case(route: &str, fail_sibling: bool) { + use wacore::store::traits::SignalStore; + use wacore::types::message::AddressingMode; + use wacore_signal_ops::{RetryRequest, RetryRoute}; + let own: Jid = "111:1@s.whatsapp.net".parse().unwrap(); + let peer: Jid = "222:1@s.whatsapp.net".parse().unwrap(); + let records = Arc::new(BundleFaultRecords::default()); + let lease = records + .inner + .acquire(route, "authored-node", 0, 60_000) + .await + .unwrap() + .unwrap(); + let store = Arc::new(RecordSignalStore::new( + records.clone(), + Arc::new(AesGcmSealer::new(&[5; 32])), + lease.fence, + )); + let receiver = SignalOps::create(store.clone()).await.unwrap(); + common::pair(&receiver).await; + receiver + .set_own_jids(&own.to_string(), Some("900111:1@lid")) + .await + .unwrap(); + let old_peer = device("authored-old-peer", &peer.to_string()).await; + let new_peer = device("authored-new-peer", &peer.to_string()).await; + let status_client = FakeClient { + devices: vec![own.clone()], + bundles: HashMap::from([(own.clone(), bundle_for(&receiver).await)]), + group: None, + }; + let status = old_peer + .send_direct( + &TokioRuntime, + &status_client, + &own.to_non_ad(), + &text("authored old status"), + "OLD1", + ) + .await + .unwrap(); + let delayed = old_peer + .send_direct( + &TokioRuntime, + &status_client, + &own.to_non_ad(), + &text("authored delayed old status"), + "OLD2", + ) + .await + .unwrap(); + let (kind, version, ciphertext) = enc_for(&status.stanza, &own); + let address = peer.to_protocol_address(); + receiver + .receive_status( + ReceiveRequest { + chat: "status@broadcast", + sender: &address, + kind: ReceiveKind::try_from(kind.as_str()).unwrap(), + ciphertext: &ciphertext, + padding_version: version, + is_from_me: false, + }, + true, + ) + .await + .unwrap(); + let status_key = format!("{}_status", address.as_str()); + assert!(store.get_session(&status_key).await.unwrap().is_some()); + if route == "retry" { + let initial = FakeClient { + devices: vec![peer.clone()], + bundles: HashMap::from([(peer.clone(), bundle_for(&old_peer).await)]), + group: None, + }; + receiver + .send_direct( + &TokioRuntime, + &initial, + &peer.to_non_ad(), + &text("authored original send"), + "RETRY", + ) + .await + .unwrap(); + store.delete_session(address.as_str()).await.unwrap(); + } + let healthy_jid: Jid = "222:2@s.whatsapp.net".parse().unwrap(); + let healthy = device("authored-healthy-device", &healthy_jid.to_string()).await; + let before_chat = store.get_session(address.as_str()).await.unwrap(); + let before_status = store.get_session(&status_key).await.unwrap(); + let before_identity = store.load_identity(address.as_str()).await.unwrap(); + records + .fail_status_read + .store(fail_sibling, std::sync::atomic::Ordering::SeqCst); + let client = FakeClient { + devices: vec![peer.clone(), healthy_jid.clone()], + bundles: HashMap::from([ + (peer.clone(), bundle_for(&new_peer).await), + (healthy_jid.clone(), bundle_for(&healthy).await), + ]), + group: Some(Arc::new(GroupRoutingInfo::new( + vec![own.to_non_ad(), peer.to_non_ad()], + AddressingMode::Pn, + ))), + }; + let result = match route { + "direct" => receiver + .send_direct( + &TokioRuntime, + &client, + &peer.to_non_ad(), + &text("authored new chat"), + "NEW", + ) + .await + .map(|_| ()), + "group" => receiver + .send_group( + &TokioRuntime, + &client, + &"120363000000001@g.us".parse().unwrap(), + &text("authored new group"), + "GROUP", + ) + .await + .map(|_| ()), + _ => receiver + .resend( + &client, + RetryRequest { + chat: &peer.to_non_ad(), + message_id: "RETRY", + requester: &peer, + encryption_jid: &peer, + route: RetryRoute::Direct { recipient: None }, + retry_count: 2, + bundle: None, + }, + ) + .await + .map(|_| ()), + }; + if fail_sibling { + assert!( + result.is_err(), + "{route} published a cohort after sibling invalidation failed" + ); + assert!( + !records + .fail_status_read + .load(std::sync::atomic::Ordering::SeqCst) + ); + assert_eq!( + store.get_session(address.as_str()).await.unwrap(), + before_chat + ); + assert_eq!(store.get_session(&status_key).await.unwrap(), before_status); + assert_eq!( + store.load_identity(address.as_str()).await.unwrap(), + before_identity + ); + assert!( + store + .get_session(healthy_jid.to_protocol_address().as_str()) + .await + .unwrap() + .is_none() + ); + return; + } + result.unwrap(); + assert!( + store.get_session(&status_key).await.unwrap().is_none(), + "old status survived {route}" + ); + assert_eq!( + store.load_identity(address.as_str()).await.unwrap(), + Some(new_peer.public_identity().await.identity_key) + ); + let (kind, version, ciphertext) = enc_for(&delayed.stanza, &own); + assert!( + receiver + .receive_status( + ReceiveRequest { + chat: "status@broadcast", + sender: &address, + kind: ReceiveKind::try_from(kind.as_str()).unwrap(), + ciphertext: &ciphertext, + padding_version: version, + is_from_me: false + }, + true + ) + .await + .is_err(), + "delayed old status accepted after {route}" + ); +} + +#[tokio::test(flavor = "multi_thread")] +async fn cold_direct_invalidates_an_old_status_identity() { + cold_status_identity_case("direct", false).await; +} + +#[tokio::test(flavor = "multi_thread")] +async fn cold_group_invalidates_an_old_status_identity() { + cold_status_identity_case("group", false).await; +} + +#[tokio::test(flavor = "multi_thread")] +async fn cold_retry_invalidates_an_old_status_identity() { + cold_status_identity_case("retry", false).await; +} + +#[tokio::test(flavor = "multi_thread")] +async fn failed_status_invalidation_aborts_the_direct_batch() { + cold_status_identity_case("direct", true).await; +} + +#[tokio::test(flavor = "multi_thread")] +async fn failed_status_invalidation_aborts_the_group_batch() { + cold_status_identity_case("group", true).await; +} + +#[tokio::test(flavor = "multi_thread")] +async fn failed_status_invalidation_aborts_the_retry_batch() { + cold_status_identity_case("retry", true).await; +} diff --git a/wacore/signal-wasm/src/lib.rs b/wacore/signal-wasm/src/lib.rs index 218eee0c..90f908bb 100644 --- a/wacore/signal-wasm/src/lib.rs +++ b/wacore/signal-wasm/src/lib.rs @@ -493,7 +493,7 @@ impl SignalDevice { .map_err(ops_error)?; let out = Object::new(); match received { - Received::AlreadyDelivered { receipt_key } => { + Received::AlreadyDelivered { receipt_key, .. } => { set(&out, "status", &JsValue::from_str("already_delivered")); set(&out, "receiptKey", &JsValue::from_str(&receipt_key)); } diff --git a/wacore/src/send/encrypt.rs b/wacore/src/send/encrypt.rs index f04d4232..f8a0ae8c 100644 --- a/wacore/src/send/encrypt.rs +++ b/wacore/src/send/encrypt.rs @@ -179,6 +179,8 @@ const INLINE_ENCRYPT_DEVICES: usize = 5; enum SessionOutcome { /// Session ready; `Some` when establishing it replaced a stored identity. Established(Option), + /// Local writes may exist; the enclosing staged batch must not commit. + Abort(anyhow::Error), /// Dropped here, so the encrypt fan-out must not count it a second time. /// `reason` is `None` when the prekey fetch already counted the drop, which /// is the case for a device the server named. @@ -1041,6 +1043,7 @@ pub async fn ensure_sessions_for_devices_resolved( Some(encryption_jid.unwrap_or(lookup_jid)), ), Ok(IdentityChange::NewOrUnchanged) => SessionOutcome::Established(None), + Err(error @ crate::libsignal::protocol::SignalProtocolError::PreKeyBundleFinalizationFailed(_)) => SessionOutcome::Abort(error.into()), Err(error) => SessionOutcome::Dropped { jid: lookup_jid, reason: Some(UnkeyableDevice::SessionSetup), @@ -1055,25 +1058,20 @@ pub async fn ensure_sessions_for_devices_resolved( }); in_flight.push(async move { (chunk_len, task.await) }); } - while let Some((chunk_len, spawn_result)) = in_flight.next().await { + while let Some((_chunk_len, spawn_result)) = in_flight.next().await { let outcomes = match spawn_result { Ok(outcomes) => outcomes, Err(error) => { - // The task took the devices' identities with it, so these - // drops cannot join `unkeyed_devices` — and must not be - // counted here either, or the encrypt fan-out (which will - // fail for the same devices) would count them a second time. - log::warn!( - "Session-establishment task did not deliver a result; skipping {chunk_len} device(s)." - ); - if first_error.is_none() { - first_error = Some(anyhow::Error::new(error)); - } - continue; + // A lost task can have staged local writes without reporting + // which bundle completed. Do not commit a partial cohort. + return Err(crate::libsignal::protocol::SignalProtocolError::PreKeyBundleFinalizationFailed(Box::new( + crate::libsignal::protocol::SignalProtocolError::BackendError("session-establishment task", Box::new(error)) + )).into()); } }; for outcome in outcomes { match outcome { + SessionOutcome::Abort(error) => return Err(error), // Some(jid) => establishing this session replaced a stored // identity; notify the client so it can react off-path. SessionOutcome::Established(Some(changed_jid)) => { diff --git a/wacore/src/send/group.rs b/wacore/src/send/group.rs index 1142c9d6..3db70ba6 100644 --- a/wacore/src/send/group.rs +++ b/wacore/src/send/group.rs @@ -385,6 +385,8 @@ pub async fn prepare_group_stanza_resolved( .await { Ok(plan) => Some(plan), + // Remote recipient failures may be skipped; incomplete local state must abort the batch. + Err(error) if matches!(error.downcast_ref::(), Some(crate::libsignal::protocol::SignalProtocolError::PreKeyBundleFinalizationFailed(_))) => return Err(error), Err(error) if distribution_policy == SenderKeyDistributionPolicy::Required => { return Err(error.context("required sender-key session setup failed")); } @@ -526,6 +528,8 @@ pub async fn prepare_group_stanza_resolved( } } } + // Remote recipient failures may be skipped; incomplete local state must abort the batch. + Err(error) if matches!(error.downcast_ref::(), Some(crate::libsignal::protocol::SignalProtocolError::PreKeyBundleFinalizationFailed(_))) => return Err(error), Err(error) if distribution_policy == SenderKeyDistributionPolicy::Required => { return Err(RequiredSenderKeyDistributionError::new(error, Vec::new()).into()); }