feat(crypto): Allow fetching encryption info using session ID

Author: andybalaam

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

@@ -1681,17 +1681,6 @@ impl OlmMachine {
         })
     }
 
-    async fn get_megolm_encryption_info(
-        &self,
-        room_id: &RoomId,
-        event: &EncryptedEvent,
-        content: &SupportedEventEncryptionSchemes<'_>,
-    ) -> MegolmResult<EncryptionInfo> {
-        let session =
-            self.get_inbound_group_session_or_error(room_id, content.session_id()).await?;
-        self.get_encryption_info(&session, &event.sender).await
-    }
-
     async fn decrypt_megolm_events(
         &self,
         room_id: &RoomId,
@@ -2089,7 +2078,30 @@ impl OlmMachine {
             }
         };
 
-        self.get_megolm_encryption_info(room_id, &event, &content).await
+        self.get_session_encryption_info(room_id, content.session_id(), &event.sender).await
+    }
+
+    /// Get encryption info for a megolm session.
+    ///
+    /// This recalculates the [`EncryptionInfo`] data that is returned by
+    /// [`OlmMachine::decrypt_room_event`], based on the current
+    /// verification status of the sender, etc.
+    ///
+    /// Returns an error if the session can't be found.
+    ///
+    /// # Arguments
+    ///
+    /// * `room_id` - The ID of the room where the session is being used.
+    /// * `session_id` - The ID of the session to get information for.
+    /// * `sender` - The user ID of the sender who created this session.
+    pub async fn get_session_encryption_info(
+        &self,
+        room_id: &RoomId,
+        session_id: &str,
+        sender: &UserId,
+    ) -> MegolmResult<EncryptionInfo> {
+        let session = self.get_inbound_group_session_or_error(room_id, session_id).await?;
+        self.get_encryption_info(&session, sender).await
     }
 
     /// Update the list of tracked users.

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

@@ -18,8 +18,8 @@ use assert_matches2::{assert_let, assert_matches};
 use futures_util::{pin_mut, FutureExt, StreamExt};
 use itertools::Itertools;
 use matrix_sdk_common::deserialized_responses::{
-    UnableToDecryptInfo, UnableToDecryptReason, UnsignedDecryptionResult, UnsignedEventLocation,
-    WithheldCode,
+    AlgorithmInfo, UnableToDecryptInfo, UnableToDecryptReason, UnsignedDecryptionResult,
+    UnsignedEventLocation, VerificationLevel, VerificationState, WithheldCode,
 };
 use matrix_sdk_test::{async_test, message_like_event_content, ruma_response_from_json, test_json};
 use ruma::{
@@ -418,6 +418,42 @@ async fn test_room_key_sharing() {
     assert_eq!(room_key_updates[0].session_id, alice_session.session_id());
 }
 
+#[async_test]
+async fn test_session_encryption_info_can_be_fetched() {
+    // Given a megolm session has been established
+    let (alice, bob) = get_machine_pair_with_session(alice_id(), user_id(), false).await;
+    let room_id = room_id!("!test:example.org");
+
+    send_room_key_to_device(&alice, &bob, room_id).await.unwrap();
+
+    let alice_session =
+        alice.inner.group_session_manager.get_outbound_group_session(room_id).unwrap();
+
+    let session = bob
+        .store()
+        .get_inbound_group_session(room_id, alice_session.session_id())
+        .await
+        .unwrap()
+        .unwrap();
+
+    // When I request the encryption info about this session
+    let encryption_info =
+        bob.get_session_encryption_info(room_id, session.session_id(), alice_id()).await.unwrap();
+
+    // Then the expected info is returned
+    assert_eq!(encryption_info.sender, alice_id());
+    assert_eq!(encryption_info.sender_device.unwrap(), alice_device_id());
+    assert_matches!(
+        encryption_info.algorithm_info,
+        AlgorithmInfo::MegolmV1AesSha2 { curve25519_key, .. }
+    );
+    assert_eq!(curve25519_key, alice_session.sender_key().to_string());
+    assert_eq!(
+        encryption_info.verification_state,
+        VerificationState::Unverified(VerificationLevel::UnsignedDevice)
+    );
+}
+
 #[async_test]
 async fn test_to_device_messages_from_dehydrated_devices_are_ignored() {
     // Given alice's device is dehydrated