sqlite: store data on received room key bundles

Author: richvdh

crates/matrix-sdk-sqlite/migrations/crypto_store/010_received_room_key_bundles.sql

@@ -0,0 +1,9 @@
+CREATE TABLE "received_room_key_bundle"
+(
+    "room_id"     BLOB NOT NULL,
+    "sender_user" 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");

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

@@ -111,6 +111,7 @@ impl SqliteCryptoStore {
         let conn = pool.get().await?;
 
         let version = conn.db_version().await?;
+        debug!("Opened sqlite store with version {}", version);
         run_migrations(&conn, version).await?;
 
         let store_cipher = match passphrase {
@@ -207,7 +208,7 @@ impl SqliteCryptoStore {
     }
 }
 
-const DATABASE_VERSION: u8 = 9;
+const DATABASE_VERSION: u8 = 10;
 
 /// key for the dehydrated device pickle key in the key/value table.
 const DEHYDRATED_DEVICE_PICKLE_KEY: &str = "dehydrated_device_pickle_key";
@@ -303,6 +304,16 @@ async fn run_migrations(conn: &SqliteAsyncConn, version: u8) -> Result<()> {
         .await?;
     }
 
+    if version < 10 {
+        conn.with_transaction(|txn| {
+            txn.execute_batch(include_str!(
+                "../migrations/crypto_store/010_received_room_key_bundles.sql"
+            ))?;
+            txn.set_db_version(10)
+        })
+        .await?;
+    }
+
     Ok(())
 }
 
@@ -350,6 +361,13 @@ trait SqliteConnectionExt {
     fn set_room_settings(&self, room_id: &[u8], data: &[u8]) -> rusqlite::Result<()>;
 
     fn set_secret(&self, request_id: &[u8], data: &[u8]) -> rusqlite::Result<()>;
+
+    fn set_received_room_key_bundle(
+        &self,
+        room_id: &[u8],
+        user_id: &[u8],
+        data: &[u8],
+    ) -> rusqlite::Result<()>;
 }
 
 impl SqliteConnectionExt for rusqlite::Connection {
@@ -478,6 +496,21 @@ impl SqliteConnectionExt for rusqlite::Connection {
 
         Ok(())
     }
+
+    fn set_received_room_key_bundle(
+        &self,
+        room_id: &[u8],
+        sender_user: &[u8],
+        data: &[u8],
+    ) -> rusqlite::Result<()> {
+        self.execute(
+            "INSERT INTO received_room_key_bundle(room_id, sender_user, bundle_data)
+            VALUES (?1, ?2, ?3)
+            ON CONFLICT (room_id, sender_user) DO UPDATE SET bundle_data = ?3",
+            (room_id, sender_user, data),
+        )?;
+        Ok(())
+    }
 }
 
 #[async_trait]
@@ -744,6 +777,21 @@ trait SqliteObjectCryptoStoreExt: SqliteAsyncConnExt {
             .await
             .optional()?)
     }
+
+    async fn get_received_room_key_bundle(
+        &self,
+        room_id: Key,
+        sender_user: Key,
+    ) -> Result<Option<Vec<u8>>> {
+        Ok(self
+            .query_row(
+                "SELECT bundle_data FROM received_room_key_bundle WHERE room_id = ? AND sender_user = ?",
+                (room_id, sender_user),
+                |row| { row.get(0) },
+            )
+            .await
+            .optional()?)
+    }
 }
 
 #[async_trait]
@@ -947,6 +995,14 @@ impl CryptoStore for SqliteCryptoStore {
                     txn.set_secret(&secret_name, &value)?;
                 }
 
+                for bundle in changes.received_room_key_bundles {
+                    let room_id =
+                        this.encode_key("received_room_key_bundle", &bundle.bundle_data.room_id);
+                    let user_id = this.encode_key("received_room_key_bundle", &bundle.sender_user);
+                    let value = this.serialize_value(&bundle)?;
+                    txn.set_received_room_key_bundle(&room_id, &user_id, &value)?;
+                }
+
                 Ok::<_, Error>(())
             })
             .await?;
@@ -1339,10 +1395,17 @@ impl CryptoStore for SqliteCryptoStore {
 
     async fn get_received_room_key_bundle_data(
         &self,
-        _room_id: &RoomId,
-        _user_id: &UserId,
+        room_id: &RoomId,
+        user_id: &UserId,
     ) -> Result<Option<StoredRoomKeyBundleData>> {
-        todo!()
+        let room_id = self.encode_key("received_room_key_bundle", room_id);
+        let user_id = self.encode_key("received_room_key_bundle", user_id);
+        self.acquire()
+            .await?
+            .get_received_room_key_bundle(room_id, user_id)
+            .await?
+            .map(|value| self.deserialize_value(&value))
+            .transpose()
     }
 
     async fn get_custom_value(&self, key: &str) -> Result<Option<Vec<u8>>> {