feat(crypto): Support EncryptionInfo for olm encrypted messages when using add_event_handler

crates/matrix-sdk-base/src/client.rs

@@ -496,7 +496,7 @@ impl BaseClient {
         #[cfg(feature = "e2e-encryption")]
         let to_device = {
             let processors::e2ee::to_device::Output {
-                decrypted_to_device_events: to_device,
+                processed_to_device_events: to_device,
                 room_key_updates,
             } = processors::e2ee::to_device::from_sync_v2(&response, olm_machine.as_ref()).await?;
 
@@ -519,7 +519,22 @@ impl BaseClient {
         };
 
         #[cfg(not(feature = "e2e-encryption"))]
-        let to_device = response.to_device.events;
+        let to_device = response
+            .to_device
+            .events
+            .into_iter()
+            .map(|raw| {
+                if let Ok(Some(event_type)) = raw.get_field::<String>("type") {
+                    if event_type == "m.room.encrypted" {
+                        matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent::UnableToDecrypt(raw)
+                    } else {
+                        matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent::PlainText(raw)
+                    }
+                } else {
+                    matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent::Invalid(raw) // Exclude events with no type
+                }
+            })
+            .collect();
 
         let mut ambiguity_cache = AmbiguityCache::new(self.state_store.inner.clone());
 

crates/matrix-sdk-base/src/debug.rs

@@ -17,6 +17,7 @@
 use std::fmt;
 
 pub use matrix_sdk_common::debug::*;
+use matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent;
 use ruma::{
     api::client::sync::sync_events::v3::{InvitedRoom, KnockedRoom},
     serde::Raw,
@@ -35,6 +36,19 @@ impl<T> fmt::Debug for DebugListOfRawEventsNoId<'_, T> {
     }
 }
 
+/// A wrapper around a slice of `ProcessedToDeviceEvent` events that implements
+/// `Debug` in a way that only prints the event type of each item.
+pub struct DebugListOfProcessedToDeviceEvents<'a>(pub &'a [ProcessedToDeviceEvent]);
+
+#[cfg(not(tarpaulin_include))]
+impl fmt::Debug for DebugListOfProcessedToDeviceEvents<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut list = f.debug_list();
+        list.entries(self.0.iter().map(|e| DebugRawEventNoId(e.as_raw())));
+        list.finish()
+    }
+}
+
 /// A wrapper around an invited room as found in `/sync` responses that
 /// implements `Debug` in a way that only prints the event ID and event type for
 /// the raw events contained in `invite_state`.

crates/matrix-sdk-base/src/response_processors/e2ee/to_device.rs

@@ -14,6 +14,7 @@
 
 use std::collections::BTreeMap;
 
+use matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent;
 use matrix_sdk_crypto::{store::types::RoomKeyInfo, EncryptionSyncChanges, OlmMachine};
 use ruma::{
     api::client::sync::sync_events::{v3, v5, DeviceLists},
@@ -93,28 +94,35 @@ async fn process(
         let (events, room_key_updates) =
             olm_machine.receive_sync_changes(encryption_sync_changes).await?;
 
-        let events = events
-            .iter()
-            // TODO: There is loss of information here, after calling `to_raw` it is not
-            // possible to make the difference between a successfully decrypted event and a plain
-            // text event. This information needs to be propagated to top layer at some point if
-            // clients relies on custom encrypted to device events.
-            .map(|p| p.to_raw())
-            .collect();
-
-        Output { decrypted_to_device_events: events, room_key_updates: Some(room_key_updates) }
+        Output { processed_to_device_events: events, room_key_updates: Some(room_key_updates) }
     } else {
-        // If we have no `OlmMachine`, just return the events that were passed in.
+        // If we have no `OlmMachine`, just return the clear events that were passed in.
+        // The encrypted ones are dropped as they are un-usable.
         // This should not happen unless we forget to set things up by calling
         // `Self::activate()`.
         Output {
-            decrypted_to_device_events: encryption_sync_changes.to_device_events,
+            processed_to_device_events: encryption_sync_changes
+                .to_device_events
+                .into_iter()
+                .map(|raw| {
+                    if let Ok(Some(event_type)) = raw.get_field::<String>("type") {
+                        if event_type == "m.room.encrypted" {
+                            ProcessedToDeviceEvent::UnableToDecrypt(raw)
+                        } else {
+                            ProcessedToDeviceEvent::PlainText(raw)
+                        }
+                    } else {
+                        // Exclude events with no type
+                        ProcessedToDeviceEvent::Invalid(raw)
+                    }
+                })
+                .collect(),
             room_key_updates: None,
         }
     })
 }
 
 pub struct Output {
-    pub decrypted_to_device_events: Vec<Raw<AnyToDeviceEvent>>,
+    pub processed_to_device_events: Vec<ProcessedToDeviceEvent>,
     pub room_key_updates: Option<Vec<RoomKeyInfo>>,
 }

crates/matrix-sdk-base/src/sliding_sync.rs

@@ -14,10 +14,10 @@
 
 //! Extend `BaseClient` with capabilities to handle MSC4186.
 
+#[cfg(feature = "e2e-encryption")]
+use matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent;
 use matrix_sdk_common::deserialized_responses::TimelineEvent;
 use ruma::{api::client::sync::sync_events::v5 as http, OwnedRoomId};
-#[cfg(feature = "e2e-encryption")]
-use ruma::{events::AnyToDeviceEvent, serde::Raw};
 use tracing::{instrument, trace};
 
 use super::BaseClient;
@@ -44,7 +44,7 @@ impl BaseClient {
         &self,
         to_device: Option<&http::response::ToDevice>,
         e2ee: &http::response::E2EE,
-    ) -> Result<Option<Vec<Raw<AnyToDeviceEvent>>>> {
+    ) -> Result<Option<Vec<ProcessedToDeviceEvent>>> {
         if to_device.is_none() && e2ee.is_empty() {
             return Ok(None);
         }
@@ -62,7 +62,7 @@ impl BaseClient {
 
         let mut context = processors::Context::default();
 
-        let processors::e2ee::to_device::Output { decrypted_to_device_events, room_key_updates } =
+        let processors::e2ee::to_device::Output { processed_to_device_events, room_key_updates } =
             processors::e2ee::to_device::from_msc4186(to_device, e2ee, olm_machine.as_ref())
                 .await?;
 
@@ -89,7 +89,7 @@ impl BaseClient {
         )
         .await?;
 
-        Ok(Some(decrypted_to_device_events))
+        Ok(Some(processed_to_device_events))
     }
 
     /// Process a response from a sliding sync call.

crates/matrix-sdk-base/src/sync.rs

@@ -16,15 +16,18 @@
 
 use std::{collections::BTreeMap, fmt};
 
-use matrix_sdk_common::{debug::DebugRawEvent, deserialized_responses::TimelineEvent};
+use matrix_sdk_common::{
+    debug::DebugRawEvent,
+    deserialized_responses::{ProcessedToDeviceEvent, TimelineEvent},
+};
 pub use ruma::api::client::sync::sync_events::v3::{
     InvitedRoom as InvitedRoomUpdate, KnockedRoom as KnockedRoomUpdate,
 };
 use ruma::{
     api::client::sync::sync_events::UnreadNotificationsCount as RumaUnreadNotificationsCount,
     events::{
         presence::PresenceEvent, AnyGlobalAccountDataEvent, AnyRoomAccountDataEvent,
-        AnySyncEphemeralRoomEvent, AnySyncStateEvent, AnyToDeviceEvent,
+        AnySyncEphemeralRoomEvent, AnySyncStateEvent,
     },
     push::Action,
     serde::Raw,
@@ -33,7 +36,10 @@ use ruma::{
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    debug::{DebugInvitedRoom, DebugKnockedRoom, DebugListOfRawEvents, DebugListOfRawEventsNoId},
+    debug::{
+        DebugInvitedRoom, DebugKnockedRoom, DebugListOfProcessedToDeviceEvents,
+        DebugListOfRawEvents, DebugListOfRawEventsNoId,
+    },
     deserialized_responses::{AmbiguityChange, RawAnySyncOrStrippedTimelineEvent},
 };
 
@@ -50,7 +56,7 @@ pub struct SyncResponse {
     /// The global private data created by this user.
     pub account_data: Vec<Raw<AnyGlobalAccountDataEvent>>,
     /// Messages sent directly between devices.
-    pub to_device: Vec<Raw<AnyToDeviceEvent>>,
+    pub to_device: Vec<ProcessedToDeviceEvent>,
     /// New notifications per room.
     pub notifications: BTreeMap<OwnedRoomId, Vec<Notification>>,
 }
@@ -61,7 +67,7 @@ impl fmt::Debug for SyncResponse {
         f.debug_struct("SyncResponse")
             .field("rooms", &self.rooms)
             .field("account_data", &DebugListOfRawEventsNoId(&self.account_data))
-            .field("to_device", &DebugListOfRawEventsNoId(&self.to_device))
+            .field("to_device", &DebugListOfProcessedToDeviceEvents(&self.to_device))
             .field("notifications", &self.notifications)
             .finish_non_exhaustive()
     }

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

@@ -17,7 +17,7 @@ use std::{collections::BTreeMap, fmt, sync::Arc};
 #[cfg(doc)]
 use ruma::events::AnyTimelineEvent;
 use ruma::{
-    events::{AnyMessageLikeEvent, AnySyncTimelineEvent},
+    events::{AnyMessageLikeEvent, AnySyncTimelineEvent, AnyToDeviceEvent},
     push::Action,
     serde::{
         AsRefStr, AsStrAsRefStr, DebugAsRefStr, DeserializeFromCowStr, FromString, JsonObject, Raw,
@@ -1165,6 +1165,53 @@ impl From<SyncTimelineEventDeserializationHelperV0> for TimelineEvent {
     }
 }
 
+/// Represents a to-device event after it has been processed by the Olm machine.
+#[derive(Clone, Debug)]
+pub enum ProcessedToDeviceEvent {
+    /// A successfully-decrypted encrypted event.
+    /// Contains the raw decrypted event and encryption info
+    Decrypted {
+        /// The raw decrypted event
+        raw: Raw<AnyToDeviceEvent>,
+        /// The Olm encryption info
+        encryption_info: EncryptionInfo,
+    },
+
+    /// An encrypted event which could not be decrypted.
+    UnableToDecrypt(Raw<AnyToDeviceEvent>),
+
+    /// An unencrypted event.
+    PlainText(Raw<AnyToDeviceEvent>),
+
+    /// An invalid to device event that was ignored because it is missing some
+    /// required information to be processed (like no event `type` for
+    /// example)
+    Invalid(Raw<AnyToDeviceEvent>),
+}
+
+impl ProcessedToDeviceEvent {
+    /// Converts a ProcessedToDeviceEvent to the `Raw<AnyToDeviceEvent>` it
+    /// encapsulates
+    pub fn to_raw(&self) -> Raw<AnyToDeviceEvent> {
+        match self {
+            ProcessedToDeviceEvent::Decrypted { raw, .. } => raw.clone(),
+            ProcessedToDeviceEvent::UnableToDecrypt(event) => event.clone(),
+            ProcessedToDeviceEvent::PlainText(event) => event.clone(),
+            ProcessedToDeviceEvent::Invalid(event) => event.clone(),
+        }
+    }
+
+    /// Gets the raw to-device event.
+    pub fn as_raw(&self) -> &Raw<AnyToDeviceEvent> {
+        match self {
+            ProcessedToDeviceEvent::Decrypted { raw, .. } => raw,
+            ProcessedToDeviceEvent::UnableToDecrypt(event) => event,
+            ProcessedToDeviceEvent::PlainText(event) => event,
+            ProcessedToDeviceEvent::Invalid(event) => event,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::{collections::BTreeMap, sync::Arc};

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

@@ -23,9 +23,9 @@ use itertools::Itertools;
 use matrix_sdk_common::deserialized_responses::WithheldCode;
 use matrix_sdk_common::{
     deserialized_responses::{
-        AlgorithmInfo, DecryptedRoomEvent, DeviceLinkProblem, EncryptionInfo, UnableToDecryptInfo,
-        UnableToDecryptReason, UnsignedDecryptionResult, UnsignedEventLocation, VerificationLevel,
-        VerificationState,
+        AlgorithmInfo, DecryptedRoomEvent, DeviceLinkProblem, EncryptionInfo,
+        ProcessedToDeviceEvent, UnableToDecryptInfo, UnableToDecryptReason,
+        UnsignedDecryptionResult, UnsignedEventLocation, VerificationLevel, VerificationState,
     },
     locks::RwLock as StdRwLock,
     BoxFuture,
@@ -101,7 +101,7 @@ use crate::{
             AnyIncomingResponse, KeysQueryRequest, OutgoingRequest, ToDeviceRequest,
             UploadSigningKeysRequest,
         },
-        EventEncryptionAlgorithm, ProcessedToDeviceEvent, Signatures,
+        EventEncryptionAlgorithm, Signatures,
     },
     utilities::timestamp_to_iso8601,
     verification::{Verification, VerificationMachine, VerificationRequest},

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

@@ -18,6 +18,7 @@
 use std::{collections::BTreeMap, ops::Deref, sync::Arc};
 
 use as_variant::as_variant;
+use matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent;
 use matrix_sdk_test::{ruma_response_from_json, test_json};
 use ruma::{
     api::client::keys::{
@@ -42,7 +43,7 @@ use crate::{
     types::{
         events::ToDeviceEvent,
         requests::{AnyOutgoingRequest, ToDeviceRequest},
-        DeviceKeys, ProcessedToDeviceEvent,
+        DeviceKeys,
     },
     utilities::json_convert,
     verification::VerificationMachine,

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

@@ -17,6 +17,7 @@ use std::{fmt::Debug, iter, pin::Pin};
 use assert_matches::assert_matches;
 use futures_core::Stream;
 use futures_util::{FutureExt, StreamExt};
+use matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent;
 use matrix_sdk_test::async_test;
 use ruma::{room_id, user_id, RoomId, TransactionId, UserId};
 use serde::Serialize;
@@ -33,10 +34,7 @@ use crate::{
     },
     olm::{InboundGroupSession, SenderData},
     store::types::RoomKeyInfo,
-    types::{
-        events::{room::encrypted::ToDeviceEncryptedEventContent, EventType, ToDeviceEvent},
-        ProcessedToDeviceEvent,
-    },
+    types::events::{room::encrypted::ToDeviceEncryptedEventContent, EventType, ToDeviceEvent},
     DeviceData, EncryptionSettings, EncryptionSyncChanges, OlmMachine, Session,
 };
 

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

@@ -19,8 +19,9 @@ use futures_util::{pin_mut, FutureExt, StreamExt};
 use itertools::Itertools;
 use matrix_sdk_common::{
     deserialized_responses::{
-        AlgorithmInfo, UnableToDecryptInfo, UnableToDecryptReason, UnsignedDecryptionResult,
-        UnsignedEventLocation, VerificationLevel, VerificationState, WithheldCode,
+        AlgorithmInfo, ProcessedToDeviceEvent, UnableToDecryptInfo, UnableToDecryptReason,
+        UnsignedDecryptionResult, UnsignedEventLocation, VerificationLevel, VerificationState,
+        WithheldCode,
     },
     executor::spawn,
 };
@@ -73,7 +74,7 @@ use crate::{
             ToDeviceEvent,
         },
         requests::{AnyOutgoingRequest, ToDeviceRequest},
-        DeviceKeys, ProcessedToDeviceEvent, SignedKey, SigningKeys,
+        DeviceKeys, SignedKey, SigningKeys,
     },
     utilities::json_convert,
     verification::tests::bob_id,

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

@@ -18,6 +18,7 @@ use std::{
 };
 
 use assert_matches2::assert_let;
+use matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent;
 use matrix_sdk_test::async_test;
 use ruma::{
     device_id,
@@ -38,7 +39,7 @@ use crate::{
     },
     olm::utility::SignJson,
     store::types::Changes,
-    types::{events::ToDeviceEvent, DeviceKeys, ProcessedToDeviceEvent},
+    types::{events::ToDeviceEvent, DeviceKeys},
     DeviceData, OlmMachine,
 };
 

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

@@ -15,7 +15,7 @@
 use assert_matches2::{assert_let, assert_matches};
 use insta::assert_json_snapshot;
 use matrix_sdk_common::deserialized_responses::{
-    AlgorithmInfo, VerificationLevel, VerificationState,
+    AlgorithmInfo, ProcessedToDeviceEvent, VerificationLevel, VerificationState,
 };
 use matrix_sdk_test::async_test;
 use ruma::{events::AnyToDeviceEvent, serde::Raw, to_device::DeviceIdOrAllDevices};
@@ -33,7 +33,6 @@ use crate::{
     types::{
         events::{ToDeviceCustomEvent, ToDeviceEvent},
         requests::ToDeviceRequest,
-        ProcessedToDeviceEvent,
     },
     utilities::json_convert,
     verification::tests::bob_id,