Merge pull request #248 from matrix-org/rav/update_sdk_2/mismatched_sender

Add `DecryptionErrorCode::MismatchedSender`.

Author: richvdh

CHANGELOG.md

@@ -1,5 +1,9 @@
 # UNRELEASED
 
+-   Update matrix-rust-sdk to `6ab11a032`.
+
+-   Add a new error code for `MegolmDecryptionError`, `DecryptionErrorCode::MismatchedSender`, indicating that the sender of the event does not match the owner of the device that established the Megolm session. ([#248](https://github.com/matrix-org/matrix-rust-sdk-crypto-wasm/pull/248))
+
 # matrix-sdk-crypto-wasm v15.0.0
 
 -   Update matrix-rusk-sdk to `0.12.0`, which includes:
@@ -41,7 +45,8 @@ Update matrix-sdk-crypto to `0.11.1`, which includes:
 
 -   Check the sender of an event matches owner of session, preventing sender
     spoofing by homeserver owners.
-    [13c1d20](https://github.com/matrix-org/matrix-rust-sdk/commit/13c1d2048286bbabf5e7bc6b015aafee98f04d55) (High, [GHSA-x958-rvg6-956w](https://github.com/matrix-org/matrix-rust-sdk/security/advisories/GHSA-x958-rvg6-956w)).
+    [13c1d20](https://github.com/matrix-org/matrix-rust-sdk/commit/13c1d2048286bbabf5e7bc6b015aafee98f04d55) (
+    High, [GHSA-x958-rvg6-956w](https://github.com/matrix-org/matrix-rust-sdk/security/advisories/GHSA-x958-rvg6-956w)).
 
 # matrix-sdk-crypto-wasm v14.2.0
 

Cargo.lock

@@ -64,9 +64,9 @@ futures-util = "0.3.27"
 getrandom = { version = "0.3.0", features = ["wasm_js"] }
 http = "1.1.0"
 js-sys = "0.3.49"
-matrix-sdk-common = { version = "0.12.0", features = ["js"] }
-matrix-sdk-indexeddb = { version = "0.12.0", default-features = false, features = ["e2e-encryption"] }
-matrix-sdk-qrcode = { version = "0.12.0", optional = true }
+matrix-sdk-common = { git = "https://github.com/matrix-org/matrix-rust-sdk", rev = "6ab11a032", features = ["js"] }
+matrix-sdk-indexeddb = { git = "https://github.com/matrix-org/matrix-rust-sdk", rev = "6ab11a032", default-features = false, features = ["e2e-encryption"] }
+matrix-sdk-qrcode = { git = "https://github.com/matrix-org/matrix-rust-sdk", rev = "6ab11a032", optional = true }
 serde = "1.0.91"
 serde_json = "1.0.91"
 serde-wasm-bindgen = "0.6.5"
@@ -83,7 +83,8 @@ wasm-bindgen-test = "0.3.37"
 vergen-gitcl = { version = "1.0.0", features = ["build"] }
 
 [dependencies.matrix-sdk-crypto]
-version = "0.12.0"
+git = "https://github.com/matrix-org/matrix-rust-sdk"
+rev = "6ab11a032"
 default-features = false
 features = ["js", "automatic-room-key-forwarding"]
 

Cargo.toml

@@ -10,10 +10,10 @@ use crate::impl_from_to_inner;
 #[derive(Debug, Clone)]
 #[wasm_bindgen]
 pub struct BackupDecryptionKey {
-    pub(crate) inner: store::BackupDecryptionKey,
+    pub(crate) inner: store::types::BackupDecryptionKey,
 }
 
-impl_from_to_inner!(store::BackupDecryptionKey => BackupDecryptionKey);
+impl_from_to_inner!(store::types::BackupDecryptionKey => BackupDecryptionKey);
 
 /// The public part of the backup key.
 #[derive(Debug, Clone)]
@@ -43,15 +43,15 @@ impl BackupDecryptionKey {
     #[wasm_bindgen(js_name = "createRandomKey")]
     pub fn create_random_key() -> BackupDecryptionKey {
         BackupDecryptionKey {
-            inner: store::BackupDecryptionKey::new()
+            inner: store::types::BackupDecryptionKey::new()
                 .expect("Can't gather enough randomness to create a recovery key"),
         }
     }
 
     /// Try to create a [`BackupDecryptionKey`] from a base 64 encoded string.
     #[wasm_bindgen(js_name = "fromBase64")]
     pub fn from_base64(key: String) -> Result<BackupDecryptionKey, JsError> {
-        Ok(Self { inner: store::BackupDecryptionKey::from_base64(&key)? })
+        Ok(Self { inner: store::types::BackupDecryptionKey::from_base64(&key)? })
     }
 
     /// Convert the backup decryption key to a base 64 encoded string.
@@ -92,8 +92,8 @@ pub struct RoomKeyCounts {
     pub backed_up: f64,
 }
 
-impl From<matrix_sdk_crypto::store::RoomKeyCounts> for RoomKeyCounts {
-    fn from(inner: matrix_sdk_crypto::store::RoomKeyCounts) -> Self {
+impl From<store::types::RoomKeyCounts> for RoomKeyCounts {
+    fn from(inner: store::types::RoomKeyCounts) -> Self {
         RoomKeyCounts {
             // There is no `TryFrom<usize> for f64`, so first downcast the usizes to u32, then back
             // up to f64

src/backup.rs

@@ -4,7 +4,7 @@
 
 use js_sys::{Array, JsString, Uint8Array};
 use matrix_sdk_crypto::{
-    dehydrated_devices, store::DehydratedDeviceKey as InnerDehydratedDeviceKey,
+    dehydrated_devices, store::types::DehydratedDeviceKey as InnerDehydratedDeviceKey,
 };
 use wasm_bindgen::prelude::*;
 

src/dehydrated_devices.rs

@@ -1,8 +1,9 @@
 //! Errors related to room event decryption.
 
 use js_sys::JsString;
-use matrix_sdk_common::deserialized_responses::VerificationLevel;
+use matrix_sdk_common::deserialized_responses::{VerificationLevel, WithheldCode};
 use matrix_sdk_crypto::{vodozemac, MegolmError};
+use tracing::warn;
 use wasm_bindgen::prelude::wasm_bindgen;
 
 /// Decryption error codes
@@ -25,6 +26,9 @@ pub enum DecryptionErrorCode {
     SenderIdentityVerificationViolation,
     /// Other failure.
     UnableToDecrypt,
+    /// The `sender` field on the event does not match the owner of the device
+    /// that established the Megolm session.
+    MismatchedSender,
 }
 
 /// Js Decryption error with code.
@@ -55,52 +59,47 @@ impl MegolmDecryptionError {
 
 impl From<MegolmError> for MegolmDecryptionError {
     fn from(value: MegolmError) -> Self {
+        let decryption_error = |code: DecryptionErrorCode,
+                                maybe_withheld: Option<&WithheldCode>|
+         -> MegolmDecryptionError {
+            let description = value.to_string().into();
+            let maybe_withheld = maybe_withheld.map(|code| code.to_string().to_owned().into());
+            MegolmDecryptionError { code, description, maybe_withheld }
+        };
+
         match &value {
-            MegolmError::MissingRoomKey(withheld_code) => MegolmDecryptionError {
-                code: DecryptionErrorCode::MissingRoomKey,
-                description: value.to_string().into(),
-                maybe_withheld: withheld_code
-                    .as_ref()
-                    .map(|code| code.to_string().to_owned().into()),
-            },
+            MegolmError::MissingRoomKey(withheld_code) => {
+                decryption_error(DecryptionErrorCode::MissingRoomKey, withheld_code.as_ref())
+            }
             MegolmError::Decryption(vodozemac::megolm::DecryptionError::UnknownMessageIndex(
                 ..,
-            )) => MegolmDecryptionError {
-                code: DecryptionErrorCode::UnknownMessageIndex,
-                description: value.to_string().into(),
-                maybe_withheld: None,
-            },
-            MegolmError::MismatchedIdentityKeys { .. } => MegolmDecryptionError {
-                code: DecryptionErrorCode::UnknownMessageIndex,
-                description: value.to_string().into(),
-                maybe_withheld: None,
-            },
-            MegolmError::SenderIdentityNotTrusted(VerificationLevel::VerificationViolation) => {
-                MegolmDecryptionError {
-                    code: DecryptionErrorCode::SenderIdentityVerificationViolation,
-                    description: value.to_string().into(),
-                    maybe_withheld: None,
-                }
+            )) => decryption_error(DecryptionErrorCode::UnknownMessageIndex, None),
+            MegolmError::MismatchedIdentityKeys { .. } => {
+                decryption_error(DecryptionErrorCode::UnknownMessageIndex, None)
             }
-            MegolmError::SenderIdentityNotTrusted(VerificationLevel::UnsignedDevice) => {
-                MegolmDecryptionError {
-                    code: DecryptionErrorCode::UnsignedSenderDevice,
-                    description: value.to_string().into(),
-                    maybe_withheld: None,
+            MegolmError::SenderIdentityNotTrusted(vl) => match vl {
+                VerificationLevel::VerificationViolation => {
+                    decryption_error(DecryptionErrorCode::SenderIdentityVerificationViolation, None)
                 }
-            }
-            MegolmError::SenderIdentityNotTrusted(VerificationLevel::None(..)) => {
-                MegolmDecryptionError {
-                    code: DecryptionErrorCode::UnknownSenderDevice,
-                    description: value.to_string().into(),
-                    maybe_withheld: None,
+                VerificationLevel::UnsignedDevice => {
+                    decryption_error(DecryptionErrorCode::UnsignedSenderDevice, None)
+                }
+                VerificationLevel::None(..) => {
+                    decryption_error(DecryptionErrorCode::UnknownSenderDevice, None)
+                }
+                VerificationLevel::UnverifiedIdentity => {
+                    // We do not expect to find this in a MegolmError, since even at the strictest
+                    // `TrustRequirement` level, we are happy to accept events from users whose
+                    // identities we have not verified. We spit out a warning and then treat
+                    // it as a generic UTD.
+                    warn!("Unexpected verification level in megolm decryption error {}", value);
+                    decryption_error(DecryptionErrorCode::UnableToDecrypt, None)
+                }
+                VerificationLevel::MismatchedSender => {
+                    decryption_error(DecryptionErrorCode::MismatchedSender, None)
                 }
-            }
-            _ => MegolmDecryptionError {
-                code: DecryptionErrorCode::UnableToDecrypt,
-                description: value.to_string().into(),
-                maybe_withheld: None,
             },
+            _ => decryption_error(DecryptionErrorCode::UnableToDecrypt, None),
         }
     }
 }

src/error.rs

@@ -22,7 +22,10 @@ use matrix_sdk_common::ruma::{
 };
 use matrix_sdk_crypto::{
     olm::PrivateCrossSigningIdentity,
-    store::{BackupDecryptionKey, Changes, DynCryptoStore, PendingChanges},
+    store::{
+        types::{BackupDecryptionKey, Changes, PendingChanges},
+        DynCryptoStore,
+    },
     types::{EventEncryptionAlgorithm, SigningKeys},
     vodozemac,
     vodozemac::{Curve25519PublicKey, Ed25519PublicKey},

src/libolm_migration.rs

@@ -17,7 +17,7 @@ use matrix_sdk_common::ruma::{
 use matrix_sdk_crypto::{
     backups::MegolmV1BackupKey,
     olm::{BackedUpRoomKey, ExportedRoomKey},
-    store::{DeviceChanges, IdentityChanges},
+    store::types::{DeviceChanges, IdentityChanges},
     types::RoomKeyBackupInfo,
     CryptoStoreError, EncryptionSyncChanges, GossippedSecret,
 };
@@ -632,7 +632,7 @@ impl OlmMachine {
         user_signing_key: Option<String>,
     ) -> Promise {
         let me = self.inner.clone();
-        let export = matrix_sdk_crypto::store::CrossSigningKeyExport {
+        let export = matrix_sdk_crypto::store::types::CrossSigningKeyExport {
             master_key,
             self_signing_key,
             user_signing_key,

src/machine.rs

@@ -142,10 +142,10 @@ impl IntoCryptoStore for StoreHandle {
 #[wasm_bindgen]
 #[derive(Debug)]
 pub struct CrossSigningKeyExport {
-    pub(crate) inner: matrix_sdk_crypto::store::CrossSigningKeyExport,
+    pub(crate) inner: matrix_sdk_crypto::store::types::CrossSigningKeyExport,
 }
 
-impl_from_to_inner!(matrix_sdk_crypto::store::CrossSigningKeyExport => CrossSigningKeyExport);
+impl_from_to_inner!(matrix_sdk_crypto::store::types::CrossSigningKeyExport => CrossSigningKeyExport);
 
 #[wasm_bindgen]
 impl CrossSigningKeyExport {
@@ -172,10 +172,10 @@ impl CrossSigningKeyExport {
 #[wasm_bindgen]
 #[derive(Debug)]
 pub struct RoomKeyInfo {
-    pub(crate) inner: matrix_sdk_crypto::store::RoomKeyInfo,
+    pub(crate) inner: matrix_sdk_crypto::store::types::RoomKeyInfo,
 }
 
-impl_from_to_inner!(matrix_sdk_crypto::store::RoomKeyInfo => RoomKeyInfo);
+impl_from_to_inner!(matrix_sdk_crypto::store::types::RoomKeyInfo => RoomKeyInfo);
 
 #[wasm_bindgen]
 impl RoomKeyInfo {
@@ -209,10 +209,10 @@ impl RoomKeyInfo {
 #[wasm_bindgen]
 #[derive(Debug)]
 pub struct RoomKeyWithheldInfo {
-    pub(crate) inner: matrix_sdk_crypto::store::RoomKeyWithheldInfo,
+    pub(crate) inner: matrix_sdk_crypto::store::types::RoomKeyWithheldInfo,
 }
 
-impl_from_to_inner!(matrix_sdk_crypto::store::RoomKeyWithheldInfo => RoomKeyWithheldInfo);
+impl_from_to_inner!(matrix_sdk_crypto::store::types::RoomKeyWithheldInfo => RoomKeyWithheldInfo);
 
 #[wasm_bindgen]
 impl RoomKeyWithheldInfo {

src/store.rs

@@ -335,8 +335,8 @@ impl Default for RoomSettings {
     }
 }
 
-impl From<matrix_sdk_crypto::store::RoomSettings> for RoomSettings {
-    fn from(value: matrix_sdk_crypto::store::RoomSettings) -> Self {
+impl From<matrix_sdk_crypto::store::types::RoomSettings> for RoomSettings {
+    fn from(value: matrix_sdk_crypto::store::types::RoomSettings) -> Self {
         Self {
             algorithm: value.algorithm.into(),
             only_allow_trusted_devices: value.only_allow_trusted_devices,
@@ -350,7 +350,7 @@ impl From<matrix_sdk_crypto::store::RoomSettings> for RoomSettings {
     }
 }
 
-impl From<&RoomSettings> for matrix_sdk_crypto::store::RoomSettings {
+impl From<&RoomSettings> for matrix_sdk_crypto::store::types::RoomSettings {
     fn from(value: &RoomSettings) -> Self {
         Self {
             algorithm: value.algorithm.clone().into(),