Remember the public Curve25519 key of the sender of the historic room key bundle

Author: poljar

crates/matrix-sdk-crypto/src/machine/mod.rs

@@ -967,6 +967,7 @@ impl OlmMachine {
     #[instrument()]
     async fn receive_room_key_bundle_data(
         &self,
+        sender_key: Curve25519PublicKey,
         event: &DecryptedRoomKeyBundleEvent,
         changes: &mut Changes,
     ) -> OlmResult<()> {
@@ -975,8 +976,8 @@ impl OlmMachine {
             return Ok(());
         };
 
-        // We already checked that `sender_device_keys` matches the actual sender of the
-        // message when we decrypted the message, which included doing
+        // NOTE: We already checked that `sender_device_keys` matches the actual sender
+        // of the message when we decrypted the message, which included doing
         // `DeviceData::try_from` on it, so it can't fail.
 
         let sender_device_data =
@@ -986,6 +987,7 @@ impl OlmMachine {
         changes.received_room_key_bundles.push(StoredRoomKeyBundleData {
             sender_user: event.sender.clone(),
             sender_data: SenderData::from_device(&sender_device),
+            sender_key,
             bundle_data: event.content.clone(),
         });
         Ok(())
@@ -1287,7 +1289,7 @@ impl OlmMachine {
             }
             AnyDecryptedOlmEvent::RoomKeyBundle(e) => {
                 debug!("Received a room key bundle event {:?}", e);
-                self.receive_room_key_bundle_data(e, changes).await?;
+                self.receive_room_key_bundle_data(decrypted.result.sender_key, e, changes).await?;
             }
             AnyDecryptedOlmEvent::Custom(_) => {
                 warn!("Received an unexpected encrypted to-device event");

crates/matrix-sdk-crypto/src/store/integration_tests.rs

@@ -1304,6 +1304,7 @@ macro_rules! cryptostore_integration_tests {
 
                     StoredRoomKeyBundleData {
                         sender_user: sender_user.to_owned(),
+                        sender_key: Curve25519PublicKey::from_bytes([0u8; 32]),
                         sender_data: SenderData::unknown(),
                         bundle_data: RoomKeyBundleContent {
                             room_id: room_id!("!room:example.org").to_owned(),

crates/matrix-sdk-crypto/src/store/mod.rs

@@ -1342,7 +1342,7 @@ impl Store {
     /// while let Some(bundle_info) = bundle_stream.next().await {
     ///     // Try to find the bundle content in the store and if it's valid accept it.
     ///     if let Some(bundle_content) = machine.store().get_received_room_key_bundle_data(&bundle_info.room_id, &bundle_info.sender).await? {
-    ///         let StoredRoomKeyBundleData { sender_user, sender_data, bundle_data } = bundle_content;
+    ///         let StoredRoomKeyBundleData { sender_user, sender_data, bundle_data, .. } = bundle_content;
     ///         // Download the bundle now and import it.
     ///         let bundle: RoomKeyBundle = todo!("Download the bundle");
     ///         machine.store().receive_room_key_bundle(

crates/matrix-sdk-crypto/src/store/types.rs

@@ -93,6 +93,9 @@ pub struct StoredRoomKeyBundleData {
     /// The user that sent us this data.
     pub sender_user: OwnedUserId,
 
+    /// The [`Curve25519PublicKey`] of the device that sent us this data.
+    pub sender_key: Curve25519PublicKey,
+
     /// Information about the sender of this data and how much we trust that
     /// information.
     pub sender_data: SenderData,
@@ -491,13 +494,19 @@ pub struct RoomKeyBundleInfo {
     /// The user ID of the person that sent us the historic room key bundle.
     pub sender: OwnedUserId,
 
+    /// The [`Curve25519PublicKey`] of the device that sent us this data.
+    pub sender_key: Curve25519PublicKey,
+
     /// The ID of the room the bundle should be used in.
     pub room_id: OwnedRoomId,
 }
 
 impl From<&StoredRoomKeyBundleData> for RoomKeyBundleInfo {
     fn from(value: &StoredRoomKeyBundleData) -> Self {
-        let StoredRoomKeyBundleData { sender_user, sender_data: _, bundle_data } = value;
-        Self { sender: sender_user.clone(), room_id: bundle_data.room_id.clone() }
+        let StoredRoomKeyBundleData { sender_user, sender_data: _, bundle_data, sender_key } =
+            value;
+        let sender_key = *sender_key;
+
+        Self { sender: sender_user.clone(), room_id: bundle_data.room_id.clone(), sender_key }
     }
 }

crates/matrix-sdk-indexeddb/src/crypto_store/migrations/mod.rs

@@ -25,6 +25,7 @@ mod v0_to_v5;
 mod v10_to_v11;
 mod v11_to_v12;
 mod v12_to_v13;
+mod v13_to_v14;
 mod v5_to_v7;
 mod v7;
 mod v7_to_v8;
@@ -163,6 +164,11 @@ pub async fn open_and_upgrade_db(
         v12_to_v13::schema_add(name).await?;
     }
 
+    if old_version < 14 {
+        v13_to_v14::data_migrate(name, serializer).await?;
+        v13_to_v14::schema_bump(name).await?;
+    }
+
     // If you add more migrations here, you'll need to update
     // `tests::EXPECTED_SCHEMA_VERSION`.
 
@@ -267,7 +273,7 @@ mod tests {
     wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
 
     /// The schema version we expect after we open the store.
-    const EXPECTED_SCHEMA_VERSION: u32 = 13;
+    const EXPECTED_SCHEMA_VERSION: u32 = 14;
 
     /// Adjust this to test do a more comprehensive perf test
     const NUM_RECORDS_FOR_PERF: usize = 2_000;

crates/matrix-sdk-indexeddb/src/crypto_store/migrations/v13_to_v14.rs

@@ -0,0 +1,48 @@
+/*
+Copyright 2025 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+use web_sys::{DomException, IdbTransactionMode};
+
+use super::MigrationDb;
+use crate::{
+    crypto_store::{keys, migrations::do_schema_upgrade, Result},
+    serializer::IndexeddbSerializer,
+};
+
+pub(crate) async fn data_migrate(name: &str, _: &IndexeddbSerializer) -> Result<()> {
+    let db = MigrationDb::new(name, 14).await?;
+    let transaction = db.transaction_on_one_with_mode(
+        keys::RECEIVED_ROOM_KEY_BUNDLES,
+        IdbTransactionMode::Readwrite,
+    )?;
+    let store = transaction.object_store(keys::RECEIVED_ROOM_KEY_BUNDLES)?;
+
+    // The schema didn't actually change, we just changed the objects that are
+    // stored. So let us remove them.
+    store.clear()?;
+
+    transaction.await.into_result()?;
+
+    Ok(())
+}
+
+/// Perform the schema upgrade v13 to v14, just bumping the schema version since
+/// the schema didn't actually change.
+pub(crate) async fn schema_bump(name: &str) -> Result<(), DomException> {
+    // Just bump the version number to 14 to demonstrate that we have run the data
+    // changes from data_migrate.
+    do_schema_upgrade(name, 14, |_, _, _| Ok(())).await
+}

crates/matrix-sdk-sqlite/migrations/crypto_store/011_received_room_key_bundles_with_curve_key.sql

@@ -0,0 +1,11 @@
+DROP TABLE "received_room_key_bundle";
+
+CREATE TABLE "received_room_key_bundle"
+(
+    "room_id"        BLOB NOT NULL,
+    "sender_user_id" BLOB NOT NULL,
+    "bundle_data"    BLOB NOT NULL
+);
+
+CREATE UNIQUE INDEX "received_room_key_bundle_room_id_user_id_idx"
+    ON "received_room_key_bundle" ("room_id", "sender_user_id");

crates/matrix-sdk-sqlite/src/crypto_store.rs

@@ -167,7 +167,7 @@ impl SqliteCryptoStore {
     }
 }
 
-const DATABASE_VERSION: u8 = 10;
+const DATABASE_VERSION: u8 = 11;
 
 /// key for the dehydrated device pickle key in the key/value table.
 const DEHYDRATED_DEVICE_PICKLE_KEY: &str = "dehydrated_device_pickle_key";
@@ -273,6 +273,16 @@ async fn run_migrations(conn: &SqliteAsyncConn, version: u8) -> Result<()> {
         .await?;
     }
 
+    if version < 11 {
+        conn.with_transaction(|txn| {
+            txn.execute_batch(include_str!(
+                "../migrations/crypto_store/011_received_room_key_bundles_with_curve_key.sql"
+            ))?;
+            txn.set_db_version(11)
+        })
+        .await?;
+    }
+
     Ok(())
 }
 

crates/matrix-sdk/src/encryption/tasks.rs

@@ -479,6 +479,7 @@ mod test {
     };
     use ruma::{event_id, room_id, user_id};
     use serde_json::json;
+    use vodozemac::Curve25519PublicKey;
     use wiremock::MockServer;
 
     use super::*;
@@ -584,6 +585,7 @@ mod test {
 
         let bundle_info = RoomKeyBundleInfo {
             sender: bob_user_id.to_owned(),
+            sender_key: Curve25519PublicKey::from_bytes([0u8; 32]),
             room_id: joined_room_id.to_owned(),
         };
 

crates/matrix-sdk/src/room/shared_room_history.rs

@@ -124,7 +124,7 @@ pub(crate) async fn maybe_accept_key_bundle(room: &Room, inviter: &UserId) -> Re
         return Ok(());
     };
 
-    let Some(StoredRoomKeyBundleData { sender_user, sender_data, bundle_data }) =
+    let Some(StoredRoomKeyBundleData { sender_user, sender_data, bundle_data, .. }) =
         olm_machine.store().get_received_room_key_bundle_data(room.room_id(), inviter).await?
     else {
         // No bundle received (yet).