crypto: Add variants for plain text and encrypted to-device events

fixup: post rebase

Author: BillCarsonFr

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

@@ -554,8 +554,10 @@ impl OlmMachine {
             }),
         )?;
 
-        let to_device_events =
-            to_device_events.into_iter().map(|event| event.json().get().to_owned()).collect();
+        let to_device_events = to_device_events
+            .into_iter()
+            .map(|event| event.to_raw().json().get().to_owned())
+            .collect();
         let room_key_infos = room_key_infos.into_iter().map(|info| info.into()).collect();
 
         Ok(SyncChangesResult { to_device_events, room_key_infos })
@@ -930,6 +932,8 @@ impl OlmMachine {
                     },
                 }
             }
+            // Should not happen
+            _ => panic!("Unsupported algorithm in room"),
         })
     }
 

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

@@ -99,6 +99,15 @@ async fn process(
         let (events, room_key_updates) =
             olm_machine.receive_sync_changes(encryption_sync_changes).await?;
 
+        let events = events
+            .iter()
+            // XXX 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) }
     } else {
         // If we have no `OlmMachine`, just return the events that were passed in.

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

@@ -17,7 +17,7 @@ use std::{collections::BTreeMap, fmt};
 #[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,
@@ -282,6 +282,11 @@ pub enum AlgorithmInfo {
         /// key.
         sender_claimed_keys: BTreeMap<DeviceKeyAlgorithm, String>,
     },
+
+    OlmV1Curve25519AesSha2 {
+        // The sender key of the device that encrypted the message
+        curve25519_key: String,
+    },
 }
 
 /// Struct containing information on how an event was decrypted.
@@ -615,6 +620,40 @@ impl fmt::Debug for DecryptedRoomEvent {
     }
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum ProcessedToDeviceEvent {
+    /// A successfully-decrypted encrypted event.
+    Decrypted {
+        /// The decrypted to device event
+        decrypted_event: Raw<AnyToDeviceEvent>,
+        /// Sender encryption information
+        encryption_info: EncryptionInfo,
+    },
+
+    /// An encrypted event which could not be decrypted.
+    UnableToDecrypt {
+        /// The `m.room.encrypted` to device event.
+        event: Raw<AnyToDeviceEvent>,
+    },
+
+    /// An unencrypted event.
+    PlainText(Raw<AnyToDeviceEvent>),
+
+    /// An invalid to device event that was ignored
+    NotProcessed(Raw<AnyToDeviceEvent>),
+}
+
+impl ProcessedToDeviceEvent {
+    pub fn to_raw(&self) -> Raw<AnyToDeviceEvent> {
+        match self {
+            ProcessedToDeviceEvent::Decrypted { decrypted_event, .. } => decrypted_event.clone(),
+            ProcessedToDeviceEvent::UnableToDecrypt { event } => event.clone(),
+            ProcessedToDeviceEvent::PlainText(event) => event.clone(),
+            ProcessedToDeviceEvent::NotProcessed(event) => event.clone(),
+        }
+    }
+}
+
 /// The location of an event bundled in an `unsigned` object.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
 pub enum UnsignedEventLocation {

crates/matrix-sdk-crypto/CHANGELOG.md

@@ -20,6 +20,12 @@ All notable changes to this project will be documented in this file.
 
 ### Features
 
+- [**breaking**] `OlmMachine.receive_sync_changes` returns now a list of `ProcessedToDeviceEvent` 
+  instead of a list of `Raw<AnyToDeviceEvent>`. With variants like `Decrypted`|`UnableToDecrypt`|`PlainText`|`NotProcessed`.
+  This allows for example to make the difference between an event sent in clear and an event successfully decrypted.
+  A `ProcessedToDeviceEvent::Decrypted` now contains the `encryption_info` and `verification_state` of the event. 
+  For quick compatibility a helper `ProcessedToDeviceEvent::to_raw` allows to map back to the previous behaviour.
+
 - [**breaking**] Add support for the shared history flag defined in
   [MSC3061](https://github.com/matrix-org/matrix-spec-proposals/pull/3061).
   The shared history flag is now respected when room keys are received as an

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

@@ -21,9 +21,9 @@ use std::{
 use itertools::Itertools;
 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,
@@ -1286,16 +1286,15 @@ impl OlmMachine {
         transaction: &mut StoreTransaction,
         changes: &mut Changes,
         mut raw_event: Raw<AnyToDeviceEvent>,
-    ) -> Option<Raw<AnyToDeviceEvent>> {
+    ) -> Option<ProcessedToDeviceEvent> {
         Self::record_message_id(&raw_event);
 
         let event: ToDeviceEvents = match raw_event.deserialize_as() {
             Ok(e) => e,
             Err(e) => {
                 // Skip invalid events.
                 warn!("Received an invalid to-device event: {e}");
-
-                return Some(raw_event);
+                return Some(ProcessedToDeviceEvent::NotProcessed(raw_event));
             }
         };
 
@@ -1320,7 +1319,7 @@ impl OlmMachine {
                             }
                         }
 
-                        return Some(raw_event);
+                        return Some(ProcessedToDeviceEvent::UnableToDecrypt { event: raw_event });
                     }
                 };
 
@@ -1372,12 +1371,75 @@ impl OlmMachine {
                         raw_event = decrypted.result.raw_event;
                     }
                 }
+
+                let encryption_info =
+                    self.get_olm_encryption_info(&e.sender, decrypted.result.sender_key).await;
+
+                Some(ProcessedToDeviceEvent::Decrypted {
+                    decrypted_event: raw_event,
+                    encryption_info,
+                })
             }
 
-            e => self.handle_to_device_event(changes, &e).await,
+            e => {
+                self.handle_to_device_event(changes, &e).await;
+                Some(ProcessedToDeviceEvent::PlainText(raw_event))
+            }
         }
+    }
 
-        Some(raw_event)
+    /// Get the sender information for a successfully decrypted olm message.
+    ///
+    /// # Arguments
+    ///
+    /// * `sender` - The claimed user_id retrieved from the event.
+    ///
+    /// * `sender_key` - The `Curve25519PublicKey` linked to the olm session
+    ///   that decrypted the message.
+    ///
+    /// # Returns
+    ///
+    /// A [`EncryptionInfo`] struct.
+    async fn get_olm_encryption_info(
+        &self,
+        sender: &UserId,
+        sender_key: Curve25519PublicKey,
+    ) -> EncryptionInfo {
+        let device =
+            self.store().get_device_from_curve_key(sender, sender_key).await.unwrap_or(None);
+
+        let state = if let Some(device) = &device {
+            if device.is_cross_signed_by_owner() {
+                if device.is_device_owner_verified() {
+                    VerificationState::Verified
+                } else {
+                    let identity = device
+                        .device_owner_identity
+                        .as_ref()
+                        .expect("This device is cross-signed, so the identity exists");
+                    if identity.was_previously_verified() {
+                        VerificationState::Unverified(VerificationLevel::VerificationViolation)
+                    } else {
+                        VerificationState::Unverified(VerificationLevel::UnverifiedIdentity)
+                    }
+                }
+            } else {
+                VerificationState::Unverified(VerificationLevel::UnsignedDevice)
+            }
+        } else {
+            VerificationState::Unverified(VerificationLevel::None(DeviceLinkProblem::MissingDevice))
+        };
+
+        EncryptionInfo {
+            sender: sender.to_owned(),
+            sender_device: device.map(|d| d.device_id().to_owned()),
+            algorithm_info: AlgorithmInfo::OlmV1Curve25519AesSha2 {
+                curve25519_key: sender_key.to_base64(),
+            },
+            verification_state: state,
+            // Only relevant for megolm
+            session_id: None,
+        }
     }
 
     /// Decide whether a decrypted to-device event was sent from a dehydrated
@@ -1435,7 +1497,7 @@ impl OlmMachine {
     pub async fn receive_sync_changes(
         &self,
         sync_changes: EncryptionSyncChanges<'_>,
-    ) -> OlmResult<(Vec<Raw<AnyToDeviceEvent>>, Vec<RoomKeyInfo>)> {
+    ) -> OlmResult<(Vec<ProcessedToDeviceEvent>, Vec<RoomKeyInfo>)> {
         let mut store_transaction = self.inner.store.transaction().await;
 
         let (events, changes) =
@@ -1464,10 +1526,18 @@ impl OlmMachine {
         &self,
         transaction: &mut StoreTransaction,
         sync_changes: EncryptionSyncChanges<'_>,
-    ) -> OlmResult<(Vec<Raw<AnyToDeviceEvent>>, Changes)> {
+    ) -> OlmResult<(Vec<ProcessedToDeviceEvent>, Changes)> {
         // Remove verification objects that have expired or are done.
-        let mut events = self.inner.verification_machine.garbage_collect();
-
+        let mut events: Vec<ProcessedToDeviceEvent> = self
+            .inner
+            .verification_machine
+            .garbage_collect()
+            .iter()
+            // These are `fake` to device events just serving as local echo
+            // in order for own client to react quickly to cancelled transaction.
+            // Just use PlainText for that.
+            .map(|e| ProcessedToDeviceEvent::PlainText(e.clone()))
+            .collect();
         // The account is automatically saved by the store transaction created by the
         // caller.
         let mut changes = Default::default();

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

@@ -17,8 +17,9 @@ 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::{events::AnyToDeviceEvent, room_id, serde::Raw, user_id, RoomId, TransactionId, UserId};
+use ruma::{room_id, user_id, RoomId, TransactionId, UserId};
 use serde::Serialize;
 use serde_json::json;
 use tokio_stream::wrappers::errors::BroadcastStreamRecvError;
@@ -286,7 +287,7 @@ async fn create_and_share_session_without_sender_data(
 pub async fn receive_to_device_event<C>(
     machine: &OlmMachine,
     event: &ToDeviceEvent<C>,
-) -> (Vec<Raw<AnyToDeviceEvent>>, Vec<RoomKeyInfo>)
+) -> (Vec<ProcessedToDeviceEvent>, Vec<RoomKeyInfo>)
 where
     C: EventType + Serialize + Debug,
 {

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

@@ -18,8 +18,9 @@ use assert_matches2::{assert_let, assert_matches};
 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,
 };
 use matrix_sdk_test::{async_test, message_like_event_content, ruma_response_from_json, test_json};
 use ruma::{
@@ -397,7 +398,7 @@ async fn test_room_key_sharing() {
     let (decrypted, room_key_updates) =
         send_room_key_to_device(&alice, &bob, room_id).await.unwrap();
 
-    let event = decrypted[0].deserialize().unwrap();
+    let event = decrypted[0].to_raw().deserialize().unwrap();
 
     if let AnyToDeviceEvent::RoomKey(event) = event {
         assert_eq!(&event.sender, alice.user_id());
@@ -489,7 +490,7 @@ async fn send_room_key_to_device(
     sender: &OlmMachine,
     receiver: &OlmMachine,
     room_id: &RoomId,
-) -> OlmResult<(Vec<Raw<AnyToDeviceEvent>>, Vec<RoomKeyInfo>)> {
+) -> OlmResult<(Vec<ProcessedToDeviceEvent>, Vec<RoomKeyInfo>)> {
     let to_device_requests = sender
         .share_room_key(room_id, iter::once(receiver.user_id()), EncryptionSettings::default())
         .await

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,
@@ -292,7 +293,11 @@ async fn test_decrypt_to_device_message_with_unsigned_sender_keys() {
     // Bob receives the to-device message
     let (to_device_events, _) = receive_to_device_event(&bob, &event).await;
 
+    let event = to_device_events.first().expect("Bob did not get a to-device event").clone();
+
     // The to-device event should remain decrypted.
-    let event = to_device_events.first().expect("Bob did not get a to-device event");
+    let ProcessedToDeviceEvent::UnableToDecrypt { event } = event else {
+        panic!("Should refuse to decrypt")
+    };
     assert_eq!(event.get_field("type").unwrap(), Some("m.room.encrypted"));
 }