Expose EncryptionInfo on decrypted to-device events

Add a new `ToDeviceEncryptionInfo` struct, which is a member of
`DecryptedToDeviceEvent`.

Author: richvdh

src/machine.rs

@@ -362,7 +362,7 @@ impl OlmMachine {
 
             Ok(processed_to_device_events
                 .into_iter()
-                .map(processed_to_device_event_to_js_value)
+                .filter_map(processed_to_device_event_to_js_value)
                 .collect::<Vec<_>>())
         }))
     }

src/responses.rs

@@ -230,7 +230,7 @@ impl TryFrom<matrix_sdk_common::deserialized_responses::TimelineEvent> for Decry
     }
 }
 
-/// Struct containing information on how an event was decrypted.
+/// Struct containing information on how a room event was decrypted.
 #[wasm_bindgen()]
 #[derive(Debug)]
 pub struct EncryptionInfo {
@@ -312,3 +312,66 @@ impl TryFrom<Arc<matrix_sdk_common::deserialized_responses::EncryptionInfo>> for
         }
     }
 }
+
+/// Struct containing information on how a to-device message was decrypted.
+#[wasm_bindgen]
+#[derive(Debug, Clone)]
+pub struct ToDeviceEncryptionInfo {
+    /// The base64-encoded public Curve25519 key of the device that encrypted
+    /// the message.
+    #[wasm_bindgen(getter_with_clone, js_name = "senderCurve25519Key")]
+    pub sender_curve25519_key_base64: String,
+
+    /// The user ID of the sender of the event.
+    ///
+    /// Note this is untrusted data unless {@link isSenderVerified} is true.
+    #[wasm_bindgen(getter_with_clone)]
+    pub sender: identifiers::UserId,
+
+    /// The device ID of the device that sent us the to-device message.
+    ///
+    /// Could be `undefined` in the case where the to-device message sender
+    /// checks are delayed. There is no delay for to-device messages other
+    /// than `m.room_key`, so this will always be truthy for other
+    /// message types (the decryption would fail if the sender device keys
+    /// cannot be found).
+    ///
+    /// Note this is untrusted data unless {@link isSenderVerified} is true.
+    #[wasm_bindgen(getter_with_clone, js_name = "senderDevice")]
+    pub sender_device: Option<identifiers::DeviceId>,
+
+    verification_state: matrix_sdk_common::deserialized_responses::VerificationState,
+}
+
+impl TryFrom<matrix_sdk_common::deserialized_responses::EncryptionInfo> for ToDeviceEncryptionInfo {
+    type Error = anyhow::Error;
+
+    fn try_from(
+        value: matrix_sdk_common::deserialized_responses::EncryptionInfo,
+    ) -> Result<Self, Self::Error> {
+        match &value.algorithm_info {
+            AlgorithmInfo::MegolmV1AesSha2 { .. } => Err(anyhow!(
+                "AlgorithmInfo::MegolmV1AesSha2 is not applicable for ToDeviceEncryptionInfo",
+            )),
+            AlgorithmInfo::OlmV1Curve25519AesSha2 { curve25519_public_key_base64 } => Ok(Self {
+                sender_curve25519_key_base64: curve25519_public_key_base64.clone(),
+                sender: value.sender.clone().into(),
+                sender_device: value.sender_device.clone().map(Into::into),
+                verification_state: value.verification_state.clone(),
+            }),
+        }
+    }
+}
+
+#[wasm_bindgen]
+impl ToDeviceEncryptionInfo {
+    /// Returns whether the sender device is in a verified state.
+    /// This reflects the state at the time of decryption.
+    #[wasm_bindgen(js_name = "isSenderVerified")]
+    pub fn is_sender_verified(&self) -> bool {
+        matches!(
+            &self.verification_state,
+            matrix_sdk_common::deserialized_responses::VerificationState::Verified
+        )
+    }
+}

src/types.rs

@@ -10,12 +10,14 @@ use matrix_sdk_common::ruma::OwnedRoomId;
 use matrix_sdk_crypto::backups::{
     SignatureState as InnerSignatureState, SignatureVerification as InnerSignatureVerification,
 };
+use tracing::warn;
 use wasm_bindgen::prelude::*;
 
 use crate::{
     encryption::EncryptionAlgorithm,
     identifiers::{DeviceKeyId, UserId},
     impl_from_to_inner,
+    responses::ToDeviceEncryptionInfo,
     vodozemac::Ed25519Signature,
 };
 
@@ -395,6 +397,10 @@ pub struct DecryptedToDeviceEvent {
     /// zeroized).
     #[wasm_bindgen(readonly, getter_with_clone, js_name = "decryptedRawEvent")]
     pub decrypted_raw_event: JsString,
+
+    /// The encryption information for the event.
+    #[wasm_bindgen(readonly, getter_with_clone, js_name = "encryptionInfo")]
+    pub encryption_info: ToDeviceEncryptionInfo,
 }
 
 #[wasm_bindgen]
@@ -473,15 +479,41 @@ impl InvalidToDeviceEvent {
 /// Convert an `ProcessedToDeviceEvent` into a `JsValue`, ready to return to
 /// JavaScript.
 ///
-/// JavaScript has no complex enums like Rust. To return structs of
-/// different types, we have no choice other than hiding everything behind a
-/// `JsValue`.
+/// JavaScript has no complex enums like Rust. To return structs of different
+/// types, we have no choice other than hiding everything behind a `JsValue`.
+///
+/// We attempt to map the event onto one of the following types:
+///  * [`DecryptedToDeviceEvent`]
+///  * [`UTDToDeviceEvent`]
+///  * [`PlainTextToDeviceEvent`]
+///  * [`InvalidToDeviceEvent`].
+///
+/// We then convert that result into a [`JsValue`].
+///
+/// If the event cannot be mapped into one of those types, we instead return
+/// `None`, indicating the event should be discarded.
 pub fn processed_to_device_event_to_js_value(
     processed_to_device_event: matrix_sdk_crypto::types::ProcessedToDeviceEvent,
-) -> JsValue {
-    match processed_to_device_event {
-        matrix_sdk_crypto::types::ProcessedToDeviceEvent::Decrypted { raw, .. } => {
-            DecryptedToDeviceEvent { decrypted_raw_event: raw.json().get().into() }.into()
+) -> Option<JsValue> {
+    let result = match processed_to_device_event {
+        matrix_sdk_crypto::types::ProcessedToDeviceEvent::Decrypted { raw, encryption_info } => {
+            match encryption_info.try_into() {
+                Ok(encryption_info) => DecryptedToDeviceEvent {
+                    decrypted_raw_event: raw.json().get().into(),
+                    encryption_info,
+                }
+                .into(),
+                Err(e) => {
+                    // This can only happen if we receive an encrypted to-device event which is
+                    // encrypted with an algorithm we don't recognise. This
+                    // shouldn't really happen, unless the wasm bindings have
+                    // gotten way out of step with the underlying SDK.
+                    //
+                    // There's not a lot we can do here: we just throw away the event.
+                    warn!("Dropping incoming to-device event with invalid encryption_info: {e:?}");
+                    return None;
+                }
+            }
         }
         matrix_sdk_crypto::types::ProcessedToDeviceEvent::UnableToDecrypt(utd) => {
             UTDToDeviceEvent { wire_event: utd.json().get().into() }.into()
@@ -492,5 +524,6 @@ pub fn processed_to_device_event_to_js_value(
         matrix_sdk_crypto::types::ProcessedToDeviceEvent::Invalid(invalid) => {
             InvalidToDeviceEvent { wire_event: invalid.json().get().into() }.into()
         }
-    }
+    };
+    Some(result)
 }

tests/machine.test.ts

@@ -1851,6 +1851,10 @@ describe(OlmMachine.name, () => {
             expect(toDeviceEvent.sender).toEqual("@alice:example.org");
             expect(toDeviceEvent.type).toEqual("custom.type");
             expect(toDeviceEvent.content.foo).toEqual("bar");
+
+            const encryptionInfo = (processed as DecryptedToDeviceEvent).encryptionInfo;
+            expect(encryptionInfo.senderCurve25519Key).toEqual(alice.identityKeys.curve25519.toBase64());
+            expect(encryptionInfo.isSenderVerified()).toBe(false);
         });
     });
 });