review: Remove encryption_info. Will be part of another PR

Author: BillCarsonFr

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

@@ -932,8 +932,6 @@ impl OlmMachine {
                     },
                 }
             }
-            // Should not happen
-            _ => panic!("Unsupported algorithm in room"),
         })
     }
 

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

@@ -282,11 +282,6 @@ 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.
@@ -626,8 +621,6 @@ pub enum ProcessedToDeviceEvent {
     Decrypted {
         /// The decrypted to device event
         decrypted_event: Raw<AnyToDeviceEvent>,
-        /// Sender encryption information
-        encryption_info: EncryptionInfo,
     },
 
     /// An encrypted event which could not be decrypted.

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

@@ -1372,13 +1372,7 @@ impl OlmMachine {
                     }
                 }
 
-                let encryption_info =
-                    self.get_olm_encryption_info(&e.sender, decrypted.result.sender_key).await;
-
-                Some(ProcessedToDeviceEvent::Decrypted {
-                    decrypted_event: raw_event,
-                    encryption_info,
-                })
+                Some(ProcessedToDeviceEvent::Decrypted { decrypted_event: raw_event })
             }
 
             e => {
@@ -1388,60 +1382,6 @@ impl OlmMachine {
         }
     }
 
-    /// 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
     /// device.
     ///

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

@@ -18,7 +18,6 @@
 use std::collections::BTreeMap;
 
 use as_variant::as_variant;
-use matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent;
 use matrix_sdk_test::{ruma_response_from_json, test_json};
 use ruma::{
     api::client::keys::{
@@ -30,20 +29,14 @@ use ruma::{
     encryption::OneTimeKey,
     events::dummy::ToDeviceDummyEventContent,
     serde::Raw,
-    to_device::DeviceIdOrAllDevices,
     user_id, DeviceId, OwnedOneTimeKeyId, TransactionId, UserId,
 };
-use serde_json::{json, Value};
+use serde_json::json;
 
 use crate::{
-    machine::tests,
     store::{Changes, MemoryStore},
-    types::{
-        events::ToDeviceEvent,
-        requests::{AnyOutgoingRequest, ToDeviceRequest},
-    },
-    utilities::json_convert,
-    CrossSigningBootstrapRequests, DeviceData, EncryptionSyncChanges, OlmMachine,
+    types::{events::ToDeviceEvent, requests::AnyOutgoingRequest},
+    CrossSigningBootstrapRequests, DeviceData, OlmMachine,
 };
 
 /// These keys need to be periodically uploaded to the server.
@@ -283,51 +276,3 @@ pub fn bootstrap_requests_to_keys_query_response(
 
     ruma_response_from_json(&kq_response)
 }
-
-/// Encrypt and send a given to device event from the sender to the recipient.
-///
-/// Simulates the reception by having the recipient machine receiving a sync
-/// with the encrypted message.
-/// Returns the event as received by the recipient.
-pub async fn encrypt_to_device_helper(
-    sender: &OlmMachine,
-    recipient: &OlmMachine,
-    event_type: &str,
-    event_content: Value,
-) -> ProcessedToDeviceEvent {
-    let device =
-        sender.get_device(recipient.user_id(), recipient.device_id(), None).await.unwrap().unwrap();
-    let raw_encrypted = device
-        .encrypt_event_raw(event_type, &event_content)
-        .await
-        .expect("Should have encrypted the content");
-
-    let request = ToDeviceRequest::new(
-        recipient.user_id(),
-        DeviceIdOrAllDevices::DeviceId(recipient.device_id().to_owned()),
-        "m.room.encrypted",
-        raw_encrypted.cast(),
-    );
-
-    let encrypted_event = ToDeviceEvent::new(
-        sender.user_id().to_owned(),
-        tests::to_device_requests_to_content(vec![request.clone().into()]),
-    );
-
-    let encrypted_event = json_convert(&encrypted_event).unwrap();
-
-    let sync_changes = EncryptionSyncChanges {
-        to_device_events: vec![encrypted_event],
-        changed_devices: &Default::default(),
-        one_time_keys_counts: &Default::default(),
-        unused_fallback_keys: None,
-        next_batch_token: None,
-    };
-
-    let (to_devices, _) = recipient
-        .receive_sync_changes(sync_changes)
-        .await
-        .expect("Receive Sync changes should not fail");
-
-    to_devices.first().unwrap().clone()
-}

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

@@ -82,7 +82,6 @@ use crate::{
 mod decryption_verification_state;
 mod interactive_verification;
 mod megolm_sender_data;
-mod olm_decryption_encryption_info;
 mod olm_encryption;
 mod room_settings;
 mod send_encrypted_to_device;

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

@@ -13,9 +13,7 @@
 // limitations under the License.
 
 use assert_matches2::{assert_let, assert_matches};
-use matrix_sdk_common::deserialized_responses::{
-    AlgorithmInfo, ProcessedToDeviceEvent, VerificationLevel, VerificationState,
-};
+use matrix_sdk_common::deserialized_responses::ProcessedToDeviceEvent;
 use matrix_sdk_test::async_test;
 use ruma::{events::AnyToDeviceEvent, serde::Raw, to_device::DeviceIdOrAllDevices};
 use serde_json::{json, value::to_raw_value};
@@ -210,23 +208,7 @@ async fn test_processed_to_device_variants() {
     assert_eq!(4, processed.len());
 
     let processed_event = &processed[0];
-
-    assert_let!(ProcessedToDeviceEvent::Decrypted { encryption_info, .. } = processed_event);
-
-    assert_eq!(alice.user_id().to_owned(), encryption_info.sender);
-    assert_eq!(Some(alice.device_id().to_owned()), encryption_info.sender_device);
-
-    assert_let!(
-        AlgorithmInfo::OlmV1Curve25519AesSha2 { curve25519_key } = &encryption_info.algorithm_info
-    );
-
-    assert_eq!(curve25519_key.to_owned(), alice_curve.to_base64());
-
-    assert_eq!(encryption_info.session_id, None);
-    assert_eq!(
-        encryption_info.verification_state,
-        VerificationState::Unverified(VerificationLevel::UnsignedDevice)
-    );
+    assert_matches!(processed_event, ProcessedToDeviceEvent::Decrypted { .. });
 
     let processed_event = &processed[1];
     assert_matches!(processed_event, ProcessedToDeviceEvent::PlainText(_));