feat(crypto): Add the EncryptionInfo to the Decrypted ProcessedToDeviceEvent variant

The `ProcessedToDeviceEvent::Decrypted` variant now also have an
`EncryptionInfo` field.

The enum variant  changed from `Decrypted(Raw<AnyToDeviceEvent>)` to `Decrypted {
raw: Raw<AnyToDeviceEvent>, encryption_info: EncryptionInfo) }`

Author: BillCarsonFr

Cargo.lock

@@ -932,6 +932,11 @@ impl OlmMachine {
                     encryption_info.verification_state.to_shield_state_lax().into()
                 },
             },
+            AlgorithmInfo::OlmV1Curve25519AesSha2 { .. } => {
+                // cannot happen because `decrypt_room_event` would have fail to decrypt olm for
+                // a room (EventError::UnsupportedAlgorithm)
+                panic!("Unsupported olm algorithm in room")
+            }
         })
     }
 

bindings/matrix-sdk-crypto-ffi/src/machine.rs

@@ -51,6 +51,7 @@ web-sys = { workspace = true, features = ["console"] }
 
 [dev-dependencies]
 assert_matches.workspace = true
+assert_matches2.workspace = true
 insta.workspace = true
 matrix-sdk-test-macros = { path = "../../testing/matrix-sdk-test-macros" }
 proptest.workspace = true

crates/matrix-sdk-common/Cargo.toml

@@ -290,6 +290,12 @@ pub enum AlgorithmInfo {
         #[serde(default, skip_serializing_if = "Option::is_none")]
         session_id: Option<String>,
     },
+
+    /// The info if the event was encrypted using m.olm.v1.curve25519-aes-sha2
+    OlmV1Curve25519AesSha2 {
+        // The sender device key, base64 encoded
+        curve25519_public_key_base64: String,
+    },
 }
 
 /// Struct containing information on how an event was decrypted.
@@ -315,8 +321,11 @@ pub struct EncryptionInfo {
 impl EncryptionInfo {
     /// Helper to get the megolm session id used to encrypt.
     pub fn session_id(&self) -> Option<&str> {
-        let AlgorithmInfo::MegolmV1AesSha2 { session_id, .. } = &self.algorithm_info;
-        session_id.as_deref()
+        if let AlgorithmInfo::MegolmV1AesSha2 { session_id, .. } = &self.algorithm_info {
+            session_id.as_deref()
+        } else {
+            None
+        }
     }
 }
 
@@ -337,26 +346,22 @@ impl<'de> Deserialize<'de> for EncryptionInfo {
             pub old_session_id: Option<String>,
         }
 
-        let Helper {
-            sender,
-            sender_device,
-            algorithm_info:
-                AlgorithmInfo::MegolmV1AesSha2 { curve25519_key, sender_claimed_keys, session_id },
-            verification_state,
-            old_session_id,
-        } = Helper::deserialize(deserializer)?;
-
-        Ok(EncryptionInfo {
-            sender,
-            sender_device,
-            algorithm_info: AlgorithmInfo::MegolmV1AesSha2 {
-                // Migration, merge the old_session_id in algorithm_info
-                session_id: session_id.or(old_session_id),
-                curve25519_key,
-                sender_claimed_keys,
-            },
-            verification_state,
-        })
+        let Helper { sender, sender_device, algorithm_info, verification_state, old_session_id } =
+            Helper::deserialize(deserializer)?;
+
+        let algorithm_info = match algorithm_info {
+            AlgorithmInfo::MegolmV1AesSha2 { curve25519_key, sender_claimed_keys, session_id } => {
+                AlgorithmInfo::MegolmV1AesSha2 {
+                    // Migration, merge the old_session_id in algorithm_info
+                    session_id: session_id.or(old_session_id),
+                    curve25519_key,
+                    sender_claimed_keys,
+                }
+            }
+            other => other,
+        };
+
+        Ok(EncryptionInfo { sender, sender_device, algorithm_info, verification_state })
     }
 }
 
@@ -1047,6 +1052,7 @@ mod tests {
     use std::{collections::BTreeMap, sync::Arc};
 
     use assert_matches::assert_matches;
+    use assert_matches2::assert_let;
     use insta::{assert_json_snapshot, with_settings};
     use ruma::{
         device_id, event_id, events::room::message::RoomMessageEventContent, serde::Raw, user_id,
@@ -1598,7 +1604,9 @@ mod tests {
         let deserialized = serde_json::from_value::<EncryptionInfo>(old_format).unwrap();
         let expected_session_id = Some("mysessionid76".to_owned());
 
-        let AlgorithmInfo::MegolmV1AesSha2 { session_id, .. } = deserialized.algorithm_info.clone();
+        assert_let!(
+            AlgorithmInfo::MegolmV1AesSha2 { session_id, .. } = deserialized.algorithm_info.clone()
+        );
         assert_eq!(session_id, expected_session_id);
 
         assert_json_snapshot!(deserialized);

crates/matrix-sdk-common/src/deserialized_responses.rs

@@ -8,9 +8,13 @@ All notable changes to this project will be documented in this file.
 
 ### Features
 
+- [**breaking**] The `ProcessedToDeviceEvent::Decrypted` variant now also have an `EncryptionInfo` field.
+  Format changed from `Decrypted(Raw<AnyToDeviceEvent>)` to `Decrypted { raw: Raw<AnyToDeviceEvent>, encryption_info: EncryptionInfo) }`
+  ([5074](https://github.com/matrix-org/matrix-rust-sdk/pull/5074))
+
 - [**breaking**] Move `session_id` from `EncryptionInfo` to `AlgorithmInfo` as it is megolm specific. 
   Use `EncryptionInfo::session_id()` helper for quick access.
-  ([#4981](https://github.com/matrix-org/matrix-rust-sdk/pull/4775), [#4864](https://github.com/matrix-org/matrix-rust-sdk/pull/4981))
+  ([4981](https://github.com/matrix-org/matrix-rust-sdk/pull/4981))
 
 - Send stable identifier `sender_device_keys` for MSC4147 (Including device
   keys with Olm-encrypted events).

crates/matrix-sdk-crypto/CHANGELOG.md

@@ -52,8 +52,6 @@ use ruma::{
 };
 use serde_json::{value::to_raw_value, Value};
 use tokio::sync::Mutex;
-#[cfg(feature = "experimental-send-custom-to-device")]
-use tracing::trace;
 use tracing::{
     debug, error,
     field::{debug, display},
@@ -1453,7 +1451,10 @@ impl OlmMachine {
                     }
                 }
 
-                Some(ProcessedToDeviceEvent::Decrypted(raw_event))
+                Some(ProcessedToDeviceEvent::Decrypted {
+                    raw: raw_event,
+                    encryption_info: decrypted.result.encryption_info,
+                })
             }
 
             e => {

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

@@ -29,17 +29,25 @@ use ruma::{
     encryption::OneTimeKey,
     events::dummy::ToDeviceDummyEventContent,
     serde::Raw,
+    to_device::DeviceIdOrAllDevices,
     user_id, DeviceId, OwnedOneTimeKeyId, TransactionId, UserId,
 };
-use serde_json::json;
+use serde_json::{json, Value};
 use tokio::sync::Mutex;
 
 use crate::{
+    machine::tests,
     olm::PrivateCrossSigningIdentity,
     store::{Changes, CryptoStoreWrapper, MemoryStore},
-    types::{events::ToDeviceEvent, requests::AnyOutgoingRequest, DeviceKeys},
+    types::{
+        events::ToDeviceEvent,
+        requests::{AnyOutgoingRequest, ToDeviceRequest},
+        DeviceKeys, ProcessedToDeviceEvent,
+    },
+    utilities::json_convert,
     verification::VerificationMachine,
-    Account, CrossSigningBootstrapRequests, Device, DeviceData, OlmMachine, OtherUserIdentityData,
+    Account, CrossSigningBootstrapRequests, Device, DeviceData, EncryptionSyncChanges, OlmMachine,
+    OtherUserIdentityData,
 };
 
 /// These keys need to be periodically uploaded to the server.
@@ -174,6 +182,46 @@ pub async fn get_machine_pair_with_session(
     build_session_for_pair(alice, bob, one_time_keys).await
 }
 
+pub async fn send_and_receive_encrypted_to_device_test_helper(
+    sender: &OlmMachine,
+    recipient: &OlmMachine,
+    event_type: &str,
+    content: Value,
+) -> ProcessedToDeviceEvent {
+    let device =
+        sender.get_device(recipient.user_id(), recipient.device_id(), None).await.unwrap().unwrap();
+
+    let raw_encrypted = device
+        .encrypt_event_raw(event_type, &content)
+        .await
+        .expect("Should have encrypted the content");
+
+    let request = ToDeviceRequest::new(
+        recipient.user_id(),
+        DeviceIdOrAllDevices::DeviceId(recipient.device_id().to_owned()),
+        "m.room.encrypted",
+        raw_encrypted.cast(),
+    );
+    let event = ToDeviceEvent::new(
+        sender.user_id().to_owned(),
+        tests::to_device_requests_to_content(vec![request.clone().into()]),
+    );
+
+    let event = json_convert(&event).unwrap();
+
+    let sync_changes = EncryptionSyncChanges {
+        to_device_events: vec![event],
+        changed_devices: &Default::default(),
+        one_time_keys_counts: &Default::default(),
+        unused_fallback_keys: None,
+        next_batch_token: None,
+    };
+
+    let (decrypted, _) = recipient.receive_sync_changes(sync_changes).await.unwrap();
+    assert_eq!(1, decrypted.len());
+    decrypted[0].clone()
+}
+
 /// Create a session for the two supplied Olm machines to communicate.
 pub async fn build_session_for_pair(
     alice: OlmMachine,