crypto: Decrypt events bundled in unsigned object of another event

Signed-off-by: Kévin Commaille <[email protected]>

Author: zecakeh

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

@@ -772,6 +772,7 @@ mod tests {
                 }),
                 encryption_info: None,
                 push_actions,
+                unsigned_encryption_info: None,
             }
         }
 
@@ -857,6 +858,7 @@ mod tests {
                 }),
                 encryption_info: None,
                 push_actions: Vec::new(),
+                unsigned_encryption_info: None,
             }
         }
 

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

@@ -17,7 +17,7 @@ use std::{collections::BTreeMap, fmt};
 use ruma::{
     events::{AnySyncTimelineEvent, AnyTimelineEvent},
     push::Action,
-    serde::Raw,
+    serde::{JsonObject, Raw},
     DeviceKeyAlgorithm, OwnedDeviceId, OwnedEventId, OwnedUserId,
 };
 use serde::{Deserialize, Serialize};
@@ -235,6 +235,11 @@ pub struct SyncTimelineEvent {
     /// The push actions associated with this event.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub push_actions: Vec<Action>,
+    /// The encryption info about the events bundled in the `unsigned` object.
+    ///
+    /// Will be `None` if no bundled event was encrypted.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub unsigned_encryption_info: Option<BTreeMap<UnsignedEventLocation, UnsignedDecryptionResult>>,
 }
 
 impl SyncTimelineEvent {
@@ -243,7 +248,7 @@ impl SyncTimelineEvent {
     /// This is a convenience constructor for when you don't need to set
     /// `encryption_info` or `push_action`, for example inside a test.
     pub fn new(event: Raw<AnySyncTimelineEvent>) -> Self {
-        Self { event, encryption_info: None, push_actions: vec![] }
+        Self { event, encryption_info: None, push_actions: vec![], unsigned_encryption_info: None }
     }
 
     /// Get the event id of this `SyncTimelineEvent` if the event has any valid
@@ -256,20 +261,22 @@ impl SyncTimelineEvent {
 #[cfg(not(tarpaulin_include))]
 impl fmt::Debug for SyncTimelineEvent {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let SyncTimelineEvent { event, encryption_info, push_actions } = self;
+        let SyncTimelineEvent { event, encryption_info, push_actions, unsigned_encryption_info } =
+            self;
         let mut s = f.debug_struct("SyncTimelineEvent");
         s.field("event", &DebugRawEvent(event));
         s.maybe_field("encryption_info", encryption_info);
         if !push_actions.is_empty() {
             s.field("push_actions", push_actions);
         }
+        s.maybe_field("unsigned_encryption_info", unsigned_encryption_info);
         s.finish()
     }
 }
 
 impl From<Raw<AnySyncTimelineEvent>> for SyncTimelineEvent {
     fn from(inner: Raw<AnySyncTimelineEvent>) -> Self {
-        Self { encryption_info: None, event: inner, push_actions: Vec::default() }
+        Self::new(inner)
     }
 }
 
@@ -283,6 +290,7 @@ impl From<TimelineEvent> for SyncTimelineEvent {
             event: o.event.cast(),
             encryption_info: o.encryption_info,
             push_actions: o.push_actions.unwrap_or_default(),
+            unsigned_encryption_info: o.unsigned_encryption_info,
         }
     }
 }
@@ -297,6 +305,10 @@ pub struct TimelineEvent {
     /// The push actions associated with this event, if we had sufficient
     /// context to compute them.
     pub push_actions: Option<Vec<Action>>,
+    /// The encryption info about the events bundled in the `unsigned` object.
+    ///
+    /// Will be `None` if no bundled event was encrypted.
+    pub unsigned_encryption_info: Option<BTreeMap<UnsignedEventLocation, UnsignedDecryptionResult>>,
 }
 
 impl TimelineEvent {
@@ -305,14 +317,14 @@ impl TimelineEvent {
     /// This is a convenience constructor for when you don't need to set
     /// `encryption_info` or `push_action`, for example inside a test.
     pub fn new(event: Raw<AnyTimelineEvent>) -> Self {
-        Self { event, encryption_info: None, push_actions: None }
+        Self { event, encryption_info: None, push_actions: None, unsigned_encryption_info: None }
     }
 }
 
 #[cfg(not(tarpaulin_include))]
 impl fmt::Debug for TimelineEvent {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let TimelineEvent { event, encryption_info, push_actions } = self;
+        let TimelineEvent { event, encryption_info, push_actions, unsigned_encryption_info } = self;
         let mut s = f.debug_struct("TimelineEvent");
         s.field("event", &DebugRawEvent(event));
         s.maybe_field("encryption_info", encryption_info);
@@ -321,10 +333,59 @@ impl fmt::Debug for TimelineEvent {
                 s.field("push_actions", push_actions);
             }
         }
+        s.maybe_field("unsigned_encryption_info", unsigned_encryption_info);
         s.finish()
     }
 }
 
+/// The location of an event bundled in an `unsigned` object.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum UnsignedEventLocation {
+    /// An event at the `m.replace` key of the `m.relations` object, that is a
+    /// bundled replacement.
+    RelationsReplace,
+    /// An event at the `latest_event` key of the `m.thread` object of the
+    /// `m.relations` object, that is the latest event of a thread.
+    RelationsThreadLatestEvent,
+}
+
+impl UnsignedEventLocation {
+    /// Find the mutable JSON value at this location in the given unsigned
+    /// object.
+    ///
+    /// # Arguments
+    ///
+    /// * `unsigned` - The `unsigned` property of an event as a JSON object.
+    pub fn find_mut<'a>(&self, unsigned: &'a mut JsonObject) -> Option<&'a mut serde_json::Value> {
+        let relations = unsigned.get_mut("m.relations")?.as_object_mut()?;
+
+        match self {
+            Self::RelationsReplace => relations.get_mut("m.replace"),
+            Self::RelationsThreadLatestEvent => {
+                relations.get_mut("m.thread")?.as_object_mut()?.get_mut("latest_event")
+            }
+        }
+    }
+}
+
+/// The result of the decryption of an event bundled in an `unsigned` object.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum UnsignedDecryptionResult {
+    /// The event was successfully decrypted.
+    Decrypted(EncryptionInfo),
+    /// The event failed to be decrypted.
+    UnableToDecrypt(UnableToDecryptInfo),
+}
+
+/// Metadata about an event that could not be decrypted.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UnableToDecryptInfo {
+    /// The ID of the session used to encrypt the message, if it used the
+    /// `m.megolm.v1.aes-sha2` algorithm.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+}
+
 #[cfg(test)]
 mod tests {
     use ruma::{

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

@@ -15,6 +15,9 @@
 #![doc = include_str!("../README.md")]
 #![warn(missing_debug_implementations)]
 
+use std::pin::Pin;
+
+use futures_core::Future;
 #[doc(no_inline)]
 pub use instant;
 #[doc(no_inline)]
@@ -88,3 +91,9 @@ macro_rules! boxed_into_future {
         >>;
     };
 }
+
+/// A `Box::pin` future that is `Send` on non-wasm, and without `Send` on wasm.
+#[cfg(target_arch = "wasm32")]
+pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + 'a>>;
+#[cfg(not(target_arch = "wasm32"))]
+pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;