refactor(crypto): Make deprecated sender_key and device_id optional in RoomEncryptedEventContent and RoomKeyRequestContent

They were deprecated in Matrix 1.3 and are now optional.

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

Author: zecakeh

crates/matrix-sdk-crypto/src/olm/group_sessions/outbound.rs

@@ -499,9 +499,9 @@ impl OutboundGroupSession {
         let scheme: RoomEventEncryptionScheme = match self.settings.algorithm {
             EventEncryptionAlgorithm::MegolmV1AesSha2 => MegolmV1AesSha2Content {
                 ciphertext,
-                sender_key: self.account_identity_keys.curve25519,
+                sender_key: Some(self.account_identity_keys.curve25519),
                 session_id: self.session_id().to_owned(),
-                device_id: (*self.device_id).to_owned(),
+                device_id: Some(self.device_id.clone()),
             }
             .into(),
             #[cfg(feature = "experimental-algorithms")]

crates/matrix-sdk-crypto/src/store/integration_tests.rs

@@ -949,7 +949,7 @@ macro_rules! cryptostore_integration_tests {
                 let id = TransactionId::new();
                 let info: SecretInfo = MegolmV1AesSha2Content {
                     room_id: room_id!("!test:localhost").to_owned(),
-                    sender_key,
+                    sender_key: Some(sender_key),
                     session_id: "test_session_id".to_owned(),
                 }
                 .into();
@@ -1010,7 +1010,7 @@ macro_rules! cryptostore_integration_tests {
                 let id = TransactionId::new();
                 let info: SecretInfo = MegolmV1AesSha2Content {
                     room_id: room_id!("!test:localhost").to_owned(),
-                    sender_key: account.identity_keys().curve25519,
+                    sender_key: Some(account.identity_keys().curve25519),
                     session_id: "test_session_id".to_owned(),
                 }
                 .into();

crates/matrix-sdk-crypto/src/types/events/olm_v1.rs

@@ -59,7 +59,7 @@ impl DecryptedForwardedRoomKeyEvent {
             ForwardedRoomKeyContent::MegolmV1AesSha2(c) => Some(
                 room_key_request::MegolmV1AesSha2Content {
                     room_id: c.room_id.to_owned(),
-                    sender_key: c.claimed_sender_key,
+                    sender_key: Some(c.claimed_sender_key),
                     session_id: c.session_id.to_owned(),
                 }
                 .into(),

crates/matrix-sdk-crypto/src/types/events/room/encrypted.rs

@@ -23,12 +23,12 @@ use vodozemac::{megolm::MegolmMessage, olm::OlmMessage, Curve25519PublicKey};
 
 use super::Event;
 use crate::types::{
-    deserialize_curve_key,
+    deserialize_curve_key, deserialize_curve_key_option,
     events::{
         room_key_request::{self, SupportedKeyInfo},
         EventType, ToDeviceEvent,
     },
-    serialize_curve_key, EventEncryptionAlgorithm,
+    serialize_curve_key, serialize_curve_key_option, EventEncryptionAlgorithm,
 };
 
 /// An m.room.encrypted room event.
@@ -309,11 +309,17 @@ pub struct MegolmV1AesSha2Content {
     pub ciphertext: MegolmMessage,
 
     /// The Curve25519 key of the sender.
-    #[serde(deserialize_with = "deserialize_curve_key", serialize_with = "serialize_curve_key")]
-    pub sender_key: Curve25519PublicKey,
+    #[serde(
+        default,
+        deserialize_with = "deserialize_curve_key_option",
+        serialize_with = "serialize_curve_key_option",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub sender_key: Option<Curve25519PublicKey>,
 
     /// The ID of the sending device.
-    pub device_id: OwnedDeviceId,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub device_id: Option<OwnedDeviceId>,
 
     /// The ID of the session used to encrypt the message.
     pub session_id: String,
@@ -528,4 +534,37 @@ pub(crate) mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn deserialization_missing_sender_key_device_id() -> Result<(), serde_json::Error> {
+        let json = json!({
+            "sender": "@alice:example.org",
+            "event_id": "$Nhl3rsgHMjk-DjMJANawr9HHAhLg4GcoTYrSiYYGqEE",
+            "content": {
+                "m.custom": "something custom",
+                "algorithm": "m.megolm.v1.aes-sha2",
+                "session_id": "ZFD6+OmV7fVCsJ7Gap8UnORH8EnmiAkes8FAvQuCw/I",
+                "ciphertext":
+                    "AwgAEiBQs2LgBD2CcB+RLH2bsgp9VadFUJhBXOtCmcJuttBDOeDNjL21d9\
+                     z0AcVSfQFAh9huh4or7sWuNrHcvu9/sMbweTgc0UtdA5xFLheubHouXy4a\
+                     ewze+ShndWAaTbjWJMLsPSQDUMQHBA",
+                "m.relates_to": {
+                    "rel_type": "m.reference",
+                    "event_id": "$WUreEJERkFzO8i2dk6CmTex01cP1dZ4GWKhKCwkWHrQ"
+                },
+            },
+            "type": "m.room.encrypted",
+            "origin_server_ts": 1632491098485u64,
+            "m.custom.top": "something custom in the top",
+        });
+
+        let event: EncryptedEvent = serde_json::from_value(json.clone())?;
+
+        assert_matches!(event.content.scheme, RoomEventEncryptionScheme::MegolmV1AesSha2(_));
+        assert!(event.content.relates_to.is_some());
+        let serialized = serde_json::to_value(event)?;
+        assert_eq!(json, serialized);
+
+        Ok(())
+    }
 }

crates/matrix-sdk-crypto/src/types/events/room_key_request.rs

@@ -25,7 +25,9 @@ use serde_json::Value;
 use vodozemac::Curve25519PublicKey;
 
 use super::{EventType, ToDeviceEvent};
-use crate::types::{deserialize_curve_key, serialize_curve_key, EventEncryptionAlgorithm};
+use crate::types::{
+    deserialize_curve_key_option, serialize_curve_key_option, EventEncryptionAlgorithm,
+};
 
 /// The `m.room_key_request` to-device event.
 pub type RoomKeyRequestEvent = ToDeviceEvent<RoomKeyRequestContent>;
@@ -209,8 +211,13 @@ pub struct MegolmV1AesSha2Content {
     pub room_id: OwnedRoomId,
 
     /// The Curve25519 key of the device which initiated the session originally.
-    #[serde(deserialize_with = "deserialize_curve_key", serialize_with = "serialize_curve_key")]
-    pub sender_key: Curve25519PublicKey,
+    #[serde(
+        default,
+        deserialize_with = "deserialize_curve_key_option",
+        serialize_with = "serialize_curve_key_option",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub sender_key: Option<Curve25519PublicKey>,
 
     /// The ID of the session that the key is for.
     pub session_id: String,
@@ -382,4 +389,33 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn deserialization_missing_sender_key() -> Result<(), serde_json::Error> {
+        let json = json!({
+            "sender": "@alice:example.org",
+            "content": {
+                "action": "request",
+                "body": {
+                    "algorithm": "m.megolm.v1.aes-sha2",
+                    "room_id": "!Cuyf34gef24t:localhost",
+                    "session_id": "X3lUlvLELLYxeTx4yOVu6UDpasGEVO0Jbu+QFnm0cKQ"
+                },
+                "request_id": "1495474790150.19",
+                "requesting_device_id": "RJYKSTBOIE"
+            },
+            "type": "m.room_key_request"
+        });
+
+        let event: RoomKeyRequestEvent = serde_json::from_value(json.clone())?;
+
+        assert_matches!(
+            event.content.action,
+            Action::Request(RequestedKeyInfo::MegolmV1AesSha2(_))
+        );
+        let serialized = serde_json::to_value(event)?;
+        assert_eq!(json, serialized);
+
+        Ok(())
+    }
 }

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

@@ -519,6 +519,27 @@ where
     keys.serialize(s)
 }
 
+pub(crate) fn deserialize_curve_key_option<'de, D>(
+    de: D,
+) -> Result<Option<Curve25519PublicKey>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let key: Option<String> = Deserialize::deserialize(de)?;
+    key.map(|k| Curve25519PublicKey::from_base64(&k)).transpose().map_err(serde::de::Error::custom)
+}
+
+pub(crate) fn serialize_curve_key_option<S>(
+    key: &Option<Curve25519PublicKey>,
+    s: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let key = key.as_ref().map(|k| k.to_base64());
+    key.serialize(s)
+}
+
 /// Trait to express the various room key export formats we have in a unified
 /// manner.
 pub trait RoomKeyExport {