feat: Add forwarder_data to InboundGroupSession and pickle.

richvdh · kaylendog · commit 2f6f5d92e245 · 2025-12-10T14:53:40.000Z
Issue: #5109 Signed-off-by: Skye Elliot <actuallyori@gmail.com>
diff --git a/bindings/matrix-sdk-crypto-ffi/src/lib.rs b/bindings/matrix-sdk-crypto-ffi/src/lib.rs
@@ -506,6 +506,7 @@ fn collect_sessions(
                 })
                 .collect::<anyhow::Result<_>>()?,
             sender_data: SenderData::legacy(),
+            forwarder_data: None,
             room_id: RoomId::parse(session.room_id)?,
             imported: session.imported,
             backed_up: session.backed_up,
diff --git a/bindings/matrix-sdk-crypto-ffi/src/machine.rs b/bindings/matrix-sdk-crypto-ffi/src/machine.rs
@@ -15,7 +15,7 @@ use matrix_sdk_crypto::{
         SignatureVerification as RustSignatureCheckResult,
     },
     decrypt_room_key_export, encrypt_room_key_export,
-    olm::ExportedRoomKey,
+    olm::{ExportedRoomKey, SenderData},
     store::types::{BackupDecryptionKey, Changes},
     types::requests::ToDeviceRequest,
     CollectStrategy, DecryptionSettings, LocalTrust, OlmMachine as InnerMachine,
@@ -1023,7 +1023,7 @@ impl OlmMachine {
     ) -> Result<KeysImportResult, KeyImportError> {
         let keys = Cursor::new(keys);
         let keys = decrypt_room_key_export(keys, &passphrase)?;
-        self.import_room_keys_helper(keys, None, progress_listener)
+        self.import_room_keys_helper(keys, None, None, progress_listener)
     }
 
     /// Import room keys from the given serialized unencrypted key export.
@@ -1051,7 +1051,7 @@ impl OlmMachine {
         let backup_version = self.runtime.block_on(self.inner.backup_machine().backup_version());
         let keys: Vec<Value> = serde_json::from_str(&keys)?;
         let keys = keys.into_iter().map(serde_json::from_value).filter_map(|k| k.ok()).collect();
-        self.import_room_keys_helper(keys, backup_version.as_deref(), progress_listener)
+        self.import_room_keys_helper(keys, backup_version.as_deref(), None, progress_listener)
     }
 
     /// Import room keys from the given serialized unencrypted key export.
@@ -1078,7 +1078,7 @@ impl OlmMachine {
     ) -> Result<KeysImportResult, KeyImportError> {
         let keys: Vec<Value> = serde_json::from_str(&keys)?;
         let keys = keys.into_iter().map(serde_json::from_value).filter_map(|k| k.ok()).collect();
-        self.import_room_keys_helper(keys, Some(&backup_version), progress_listener)
+        self.import_room_keys_helper(keys, Some(&backup_version), None, progress_listener)
     }
 
     /// Discard the currently active room key for the given room if there is
@@ -1572,6 +1572,7 @@ impl OlmMachine {
         &self,
         keys: Vec<ExportedRoomKey>,
         from_backup_version: Option<&str>,
+        sender_data: Option<&SenderData>,
         progress_listener: Box<dyn ProgressListener>,
     ) -> Result<KeysImportResult, KeyImportError> {
         let listener = |progress: usize, total: usize| {
@@ -1581,6 +1582,7 @@ impl OlmMachine {
         let result = self.runtime.block_on(self.inner.store().import_room_keys(
             keys,
             from_backup_version,
+            sender_data,
             listener,
         ))?;
 
diff --git a/crates/matrix-sdk-crypto/src/backups/mod.rs b/crates/matrix-sdk-crypto/src/backups/mod.rs
@@ -630,7 +630,12 @@ impl BackupMachine {
         let backup_version = self.backup_version().await;
 
         self.store
-            .import_room_keys(decrypted_room_keys, backup_version.as_deref(), progress_listener)
+            .import_room_keys(
+                decrypted_room_keys,
+                backup_version.as_deref(),
+                None,
+                progress_listener,
+            )
             .await
     }
 }
diff --git a/crates/matrix-sdk-crypto/src/machine/tests/decryption_verification_state.rs b/crates/matrix-sdk-crypto/src/machine/tests/decryption_verification_state.rs
@@ -448,6 +448,7 @@ async fn test_verification_states_multiple_device() {
         fake_room_id,
         &olm,
         SenderData::unknown(),
+        None,
         EventEncryptionAlgorithm::MegolmV1AesSha2,
         None,
         false,
@@ -466,6 +467,7 @@ async fn test_verification_states_multiple_device() {
         fake_room_id,
         &olm,
         SenderData::unknown(),
+        None,
         EventEncryptionAlgorithm::MegolmV1AesSha2,
         None,
         false,
diff --git a/crates/matrix-sdk-crypto/src/olm/account.rs b/crates/matrix-sdk-crypto/src/olm/account.rs
@@ -235,6 +235,7 @@ impl StaticAccountData {
             room_id,
             &outbound.session_key().await,
             own_sender_data,
+            None,
             algorithm,
             Some(visibility),
             shared_history,
diff --git a/crates/matrix-sdk-crypto/src/olm/group_sessions/inbound.rs b/crates/matrix-sdk-crypto/src/olm/group_sessions/inbound.rs
@@ -187,6 +187,11 @@ pub struct InboundGroupSession {
     /// key.
     pub sender_data: SenderData,
 
+    /// If this session was shared-on-invite as part of an MSC4268 key bundle,
+    /// information about the user who forwarded us the session information.
+    /// This is distinct from [`InboundGroupSession::sender_data`].
+    pub forwarder_data: Option<SenderData>,
+
     /// The Room this GroupSession belongs to
     pub room_id: OwnedRoomId,
 
@@ -263,6 +268,7 @@ impl InboundGroupSession {
         room_id: &RoomId,
         session_key: &SessionKey,
         sender_data: SenderData,
+        forwarder_data: Option<SenderData>,
         encryption_algorithm: EventEncryptionAlgorithm,
         history_visibility: Option<HistoryVisibility>,
         shared_history: bool,
@@ -286,6 +292,7 @@ impl InboundGroupSession {
                 signing_keys: keys.into(),
             },
             sender_data,
+            forwarder_data,
             room_id: room_id.into(),
             imported: false,
             algorithm: encryption_algorithm.into(),
@@ -325,6 +332,7 @@ impl InboundGroupSession {
             room_id,
             session_key,
             SenderData::unknown(),
+            None,
             EventEncryptionAlgorithm::MegolmV1AesSha2,
             None,
             *shared_history,
@@ -380,6 +388,7 @@ impl InboundGroupSession {
             sender_key: self.creator_info.curve25519_key,
             signing_key: (*self.creator_info.signing_keys).clone(),
             sender_data: self.sender_data.clone(),
+            forwarder_data: self.forwarder_data.clone(),
             room_id: self.room_id().to_owned(),
             imported: self.imported,
             backed_up: self.backed_up(),
@@ -459,6 +468,7 @@ impl InboundGroupSession {
             sender_key,
             signing_key,
             sender_data,
+            forwarder_data,
             room_id,
             imported,
             backed_up,
@@ -479,6 +489,7 @@ impl InboundGroupSession {
                 signing_keys: signing_key.into(),
             },
             sender_data,
+            forwarder_data,
             history_visibility: history_visibility.into(),
             first_known_index,
             room_id,
@@ -693,6 +704,9 @@ pub struct PickledInboundGroupSession {
     /// Information on the device/sender who sent us this session
     #[serde(default)]
     pub sender_data: SenderData,
+    /// Information on the device/sender who forwarded us this session
+    #[serde(default)]
+    pub forwarder_data: Option<SenderData>,
     /// The id of the room that the session is used in.
     pub room_id: OwnedRoomId,
     /// Flag remembering if the session was directly sent to us by the sender
@@ -746,6 +760,7 @@ impl TryFrom<&HistoricRoomKey> for InboundGroupSession {
             // TODO: How do we remember that this is a historic room key and events decrypted using
             // this room key should always show some form of warning.
             sender_data: SenderData::default(),
+            forwarder_data: None,
             history_visibility: None.into(),
             first_known_index,
             room_id: room_id.to_owned(),
@@ -786,6 +801,7 @@ impl TryFrom<&ExportedRoomKey> for InboundGroupSession {
             // TODO: In future, exported keys should contain sender data that we can use here.
             // See https://github.com/matrix-org/matrix-rust-sdk/issues/3548
             sender_data: SenderData::default(),
+            forwarder_data: None,
             history_visibility: None.into(),
             first_known_index,
             room_id: room_id.to_owned(),
@@ -817,6 +833,7 @@ impl From<&ForwardedMegolmV1AesSha2Content> for InboundGroupSession {
             // In future, exported keys should contain sender data that we can use here.
             // See https://github.com/matrix-org/matrix-rust-sdk/issues/3548
             sender_data: SenderData::default(),
+            forwarder_data: None,
             history_visibility: None.into(),
             first_known_index,
             room_id: value.room_id.to_owned(),
@@ -844,6 +861,7 @@ impl From<&ForwardedMegolmV2AesSha2Content> for InboundGroupSession {
             // In future, exported keys should contain sender data that we can use here.
             // See https://github.com/matrix-org/matrix-rust-sdk/issues/3548
             sender_data: SenderData::default(),
+            forwarder_data: None,
             history_visibility: None.into(),
             first_known_index,
             room_id: value.room_id.to_owned(),
@@ -984,6 +1002,7 @@ mod tests {
             room_id!("!test:localhost"),
             &create_session_key(),
             SenderData::unknown(),
+            None,
             EventEncryptionAlgorithm::MegolmV1AesSha2,
             Some(HistoryVisibility::Shared),
             false,
diff --git a/crates/matrix-sdk-crypto/src/olm/group_sessions/sender_data_finder.rs b/crates/matrix-sdk-crypto/src/olm/group_sessions/sender_data_finder.rs
@@ -826,6 +826,7 @@ mod tests {
                 room_id,
                 &session_key,
                 SenderData::unknown(),
+                None,
                 EventEncryptionAlgorithm::MegolmV1AesSha2,
                 None,
                 false,
diff --git a/crates/matrix-sdk-crypto/src/store/crypto_store_wrapper.rs b/crates/matrix-sdk-crypto/src/store/crypto_store_wrapper.rs
@@ -14,8 +14,7 @@ use super::{
 };
 use crate::{
     olm::InboundGroupSession,
-    store,
-    store::{Changes, DynCryptoStore, IntoCryptoStore, RoomKeyInfo, RoomKeyWithheldInfo},
+    store::{self, Changes, DynCryptoStore, IntoCryptoStore, RoomKeyInfo, RoomKeyWithheldInfo},
     CryptoStoreError, GossippedSecret, OwnUserIdentityData, Session, UserIdentityData,
 };
 
@@ -291,6 +290,8 @@ impl CryptoStoreWrapper {
     /// # Arguments
     ///
     /// * `sessions` - The sessions to be saved.
+    /// * `sender_data` - If the sessions were received as part of an MSC4268
+    ///   key bundle, the information about the user who sent us the bundle.
     /// * `backed_up_to_version` - If the keys should be marked as having been
     ///   backed up, the version of the backup.
     ///
diff --git a/crates/matrix-sdk-crypto/src/store/integration_tests.rs b/crates/matrix-sdk-crypto/src/store/integration_tests.rs
@@ -1430,6 +1430,7 @@ macro_rules! cryptostore_integration_tests {
                     room_id!("!r:s.co"),
                     &session_key,
                     sender_data,
+                    None,
                     EventEncryptionAlgorithm::MegolmV1AesSha2,
                     None,
                     false,
diff --git a/crates/matrix-sdk-crypto/src/store/memorystore.rs b/crates/matrix-sdk-crypto/src/store/memorystore.rs
@@ -846,6 +846,7 @@ mod tests {
             room_id,
             &outbound.session_key().await,
             SenderData::unknown(),
+            None,
             outbound.settings().algorithm.to_owned(),
             None,
             false,
@@ -1244,6 +1245,7 @@ mod tests {
             room_id,
             &outbound.session_key().await,
             SenderData::unknown(),
+            None,
             outbound.settings().algorithm.to_owned(),
             None,
             false,
diff --git a/crates/matrix-sdk-crypto/src/store/mod.rs b/crates/matrix-sdk-crypto/src/store/mod.rs
@@ -1451,10 +1451,17 @@ impl Store {
         &self,
         exported_keys: Vec<ExportedRoomKey>,
         from_backup_version: Option<&str>,
+        sender_data: Option<&SenderData>,
         progress_listener: impl Fn(usize, usize),
     ) -> Result<RoomKeyImportResult> {
         let exported_keys: Vec<&ExportedRoomKey> = exported_keys.iter().collect();
-        self.import_sessions_impl(exported_keys, from_backup_version, progress_listener).await
+        self.import_sessions_impl(
+            exported_keys,
+            from_backup_version,
+            sender_data,
+            progress_listener,
+        )
+        .await
     }
 
     /// Import the given room keys into our store.
@@ -1488,13 +1495,14 @@ impl Store {
         exported_keys: Vec<ExportedRoomKey>,
         progress_listener: impl Fn(usize, usize),
     ) -> Result<RoomKeyImportResult> {
-        self.import_room_keys(exported_keys, None, progress_listener).await
+        self.import_room_keys(exported_keys, None, None, progress_listener).await
     }
 
     async fn import_sessions_impl<T>(
         &self,
         room_keys: Vec<T>,
         from_backup_version: Option<&str>,
+        sender_data: Option<&SenderData>,
         progress_listener: impl Fn(usize, usize),
     ) -> Result<RoomKeyImportResult>
     where
@@ -1511,11 +1519,13 @@ impl Store {
                 Ok(session) => {
                     // Only import the session if we didn't have this session or
                     // if it's a better version of the same session.
-                    if let Some(merged) = self.merge_received_group_session(session).await? {
+                    if let Some(mut merged) = self.merge_received_group_session(session).await? {
                         if from_backup_version.is_some() {
                             merged.mark_as_backed_up();
                         }
 
+                        merged.forwarder_data = sender_data.cloned();
+
                         keys.entry(merged.room_id().to_owned())
                             .or_insert_with(BTreeMap::new)
                             .entry(merged.sender_key().to_base64())
@@ -1702,19 +1712,23 @@ impl Store {
 
         tracing::Span::current().record("sender_data", tracing::field::debug(&sender_data));
 
-        if matches!(
-            &sender_data,
+        // The sender's device must be either `SenderData::SenderUnverified` (i.e.,
+        // TOFU-trusted) or `SenderData::SenderVerified` (i.e., fully verified
+        // via user verification and cross-signing).
+        let sender_data = match sender_data {
             SenderData::UnknownDevice { .. }
-                | SenderData::VerificationViolation(_)
-                | SenderData::DeviceInfo { .. }
-        ) {
-            warn!(
+            | SenderData::VerificationViolation(_)
+            | SenderData::DeviceInfo { .. } => {
+                warn!(
                 "Not accepting a historic room key bundle due to insufficient trust in the sender"
             );
-            return Ok(());
-        }
+                return Ok(());
+            }
+            SenderData::SenderUnverified(_) | SenderData::SenderVerified(_) => sender_data,
+        };
 
-        self.import_room_key_bundle_sessions(bundle_info, &bundle, progress_listener).await?;
+        self.import_room_key_bundle_sessions(bundle_info, &bundle, &sender_data, progress_listener)
+            .await?;
         self.import_room_key_bundle_withheld_info(bundle_info, &bundle).await?;
 
         Ok(())
@@ -1724,6 +1738,7 @@ impl Store {
         &self,
         bundle_info: &StoredRoomKeyBundleData,
         bundle: &RoomKeyBundle,
+        sender_data: &SenderData,
         progress_listener: impl Fn(usize, usize),
     ) -> Result<(), CryptoStoreError> {
         let (good, bad): (Vec<_>, Vec<_>) = bundle.room_keys.iter().partition_map(|key| {
@@ -1764,7 +1779,7 @@ impl Store {
                     );
                 }
 
-                self.import_sessions_impl(good, None, progress_listener).await?;
+                self.import_sessions_impl(good, None, Some(sender_data), progress_listener).await?;
             }
         }
 
@@ -1981,6 +1996,7 @@ mod tests {
                 BTreeMap::new(),
                 crate::types::Signatures::new(),
             )),
+            None,
             EventEncryptionAlgorithm::MegolmV1AesSha2,
             Some(ruma::events::room::history_visibility::HistoryVisibility::Shared),
             true,
@@ -2024,7 +2040,7 @@ mod tests {
         let exported_sessions = alice.store().export_room_keys(|_| true).await.unwrap();
 
         let mut room_keys_received_stream = Box::pin(bob.store().room_keys_received_stream());
-        bob.store().import_room_keys(exported_sessions, None, |_, _| {}).await.unwrap();
+        bob.store().import_room_keys(exported_sessions, None, None, |_, _| {}).await.unwrap();
 
         let room_keys = room_keys_received_stream
             .next()
@@ -2426,6 +2442,7 @@ mod tests {
             room_id,
             session_key,
             SenderData::unknown(),
+            None,
             #[cfg(not(feature = "experimental-algorithms"))]
             EventEncryptionAlgorithm::MegolmV1AesSha2,
             #[cfg(feature = "experimental-algorithms")]
diff --git a/crates/matrix-sdk-crypto/src/store/traits.rs b/crates/matrix-sdk-crypto/src/store/traits.rs
@@ -75,6 +75,8 @@ pub trait CryptoStore: AsyncTraitDeps {
     /// # Arguments
     ///
     /// * `sessions` - The sessions to be saved.
+    /// * `sender_data` - If the sessions were received as part of an MSC4268
+    ///   key bundle, the information about the user who sent us the bundle.
     /// * `backed_up_to_version` - If the keys should be marked as having been
     ///   backed up, the version of the backup.
     ///
diff --git a/crates/matrix-sdk-crypto/src/store/types.rs b/crates/matrix-sdk-crypto/src/store/types.rs
diff --git a/crates/matrix-sdk-indexeddb/src/crypto_store/migrations/mod.rs b/crates/matrix-sdk-indexeddb/src/crypto_store/migrations/mod.rs
diff --git a/crates/matrix-sdk-indexeddb/src/crypto_store/mod.rs b/crates/matrix-sdk-indexeddb/src/crypto_store/mod.rs
diff --git a/crates/matrix-sdk/src/encryption/backups/mod.rs b/crates/matrix-sdk/src/encryption/backups/mod.rs
diff --git a/crates/matrix-sdk/tests/integration/encryption/backups.rs b/crates/matrix-sdk/tests/integration/encryption/backups.rs

Original file line number	Diff line number	Diff line change
`@@ -630,7 +630,12 @@ impl BackupMachine {`
`630`	`630`	`let backup_version = self.backup_version().await;`
`631`	`631`
`632`	`632`	`self.store`
`633`		`- .import_room_keys(decrypted_room_keys, backup_version.as_deref(), progress_listener)`
	`633`	`+ .import_room_keys(`
	`634`	`+ decrypted_room_keys,`
	`635`	`+ backup_version.as_deref(),`
	`636`	`+ None,`
	`637`	`+ progress_listener,`
	`638`	`+ )`
`634`	`639`	`.await`
`635`	`640`	`}`
`636`	`641`	`}`