fix(crypto): Let users fetch our own device out of the store

Author: poljar

crates/matrix-sdk-crypto/src/identities/device.rs

@@ -307,10 +307,26 @@ impl UserDevices {
         })
     }
 
+    fn own_user_id(&self) -> &UserId {
+        self.verification_machine.own_user_id()
+    }
+
+    fn own_device_id(&self) -> &DeviceId {
+        self.verification_machine.own_device_id()
+    }
+
     /// Returns true if there is at least one devices of this user that is
     /// considered to be verified, false otherwise.
+    ///
+    /// This won't consider your own device as verified, as your own device is
+    /// always implicitly verified.
     pub fn is_any_verified(&self) -> bool {
-        self.inner.values().any(|d| d.verified(&self.own_identity, &self.device_owner_identity))
+        self.inner
+            .values()
+            .filter(|d| {
+                !(d.user_id() == self.own_user_id() && d.device_id() == self.own_device_id())
+            })
+            .any(|d| d.verified(&self.own_identity, &self.device_owner_identity))
     }
 
     /// Iterator over all the device ids of the user devices.

crates/matrix-sdk-crypto/src/identities/manager.rs

@@ -134,9 +134,8 @@ impl IdentityManager {
         store: Store,
         device_keys: DeviceKeys,
     ) -> StoreResult<DeviceChange> {
-        let old_device = store
-            .get_readonly_device_unfiltered(&device_keys.user_id, &device_keys.device_id)
-            .await?;
+        let old_device =
+            store.get_readonly_device(&device_keys.user_id, &device_keys.device_id).await?;
 
         if let Some(mut device) = old_device {
             if let Err(e) = device.update_device(&device_keys) {

crates/matrix-sdk-crypto/src/session_manager/sessions.rs

@@ -183,7 +183,7 @@ impl SessionManager {
         // Add the list of devices that the user wishes to establish sessions
         // right now.
         for user_id in users {
-            let user_devices = self.store.get_readonly_devices(user_id).await?;
+            let user_devices = self.store.get_readonly_devices_filtered(user_id).await?;
 
             for (device_id, device) in user_devices.into_iter() {
                 if !device.algorithms().contains(&EventEncryptionAlgorithm::OlmV1Curve25519AesSha2)

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

@@ -295,36 +295,18 @@ impl Store {
             .and_then(|d| d.display_name().map(|d| d.to_string())))
     }
 
-    /// Get the read-only version of a specific device.
-    ///
-    /// *Note*: This doesn't return our own device.
     pub async fn get_readonly_device(
         &self,
         user_id: &UserId,
         device_id: &DeviceId,
-    ) -> Result<Option<ReadOnlyDevice>> {
-        if user_id == self.user_id() && device_id == self.device_id() {
-            Ok(None)
-        } else {
-            self.inner.get_device(user_id, device_id).await
-        }
-    }
-
-    /// Get the read-only version of a specific device.
-    ///
-    /// *Note*: This doesn't return our own device.
-    pub async fn get_readonly_device_unfiltered(
-        &self,
-        user_id: &UserId,
-        device_id: &DeviceId,
     ) -> Result<Option<ReadOnlyDevice>> {
         self.inner.get_device(user_id, device_id).await
     }
 
     /// Get the read-only version of all the devices that the given user has.
     ///
     /// *Note*: This doesn't return our own device.
-    pub async fn get_readonly_devices(
+    pub async fn get_readonly_devices_filtered(
         &self,
         user_id: &UserId,
     ) -> Result<HashMap<DeviceIdBox, ReadOnlyDevice>> {
@@ -362,11 +344,7 @@ impl Store {
     }
 
     pub async fn get_user_devices(&self, user_id: &UserId) -> Result<UserDevices> {
-        let mut devices = self.inner.get_user_devices(user_id).await?;
-
-        if user_id == self.user_id() {
-            devices.remove(self.device_id());
-        }
+        let devices = self.inner.get_user_devices(user_id).await?;
 
         let own_identity =
             self.inner.get_user_identity(&self.user_id).await?.map(|i| i.own().cloned()).flatten();
@@ -385,24 +363,16 @@ impl Store {
         user_id: &UserId,
         device_id: &DeviceId,
     ) -> Result<Option<Device>> {
-        if user_id == self.user_id() && device_id == self.device_id() {
-            Ok(None)
-        } else {
-            let own_identity = self
-                .inner
-                .get_user_identity(&self.user_id)
-                .await?
-                .map(|i| i.own().cloned())
-                .flatten();
-            let device_owner_identity = self.inner.get_user_identity(user_id).await?;
-
-            Ok(self.inner.get_device(user_id, device_id).await?.map(|d| Device {
-                inner: d,
-                verification_machine: self.verification_machine.clone(),
-                own_identity,
-                device_owner_identity,
-            }))
-        }
+        let own_identity =
+            self.inner.get_user_identity(&self.user_id).await?.map(|i| i.own().cloned()).flatten();
+        let device_owner_identity = self.inner.get_user_identity(user_id).await?;
+
+        Ok(self.inner.get_device(user_id, device_id).await?.map(|d| Device {
+            inner: d,
+            verification_machine: self.verification_machine.clone(),
+            own_identity,
+            device_owner_identity,
+        }))
     }
 
     pub async fn get_identity(&self, user_id: &UserId) -> Result<Option<UserIdentities>> {