From 322c5b3f830ae4967ff07b0e475b37fd4ab5f963 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Damir=20Jeli=C4=87?= Date: Thu, 26 Sep 2024 11:44:32 +0200 Subject: [PATCH] refactor: Fold the private UserIdentities struct into UserIdentity It doesn't serve any purpose and only confuses people since we have many similarly named types. --- .../src/encryption/identities/users.rs | 141 ++++++++---------- 1 file changed, 65 insertions(+), 76 deletions(-) diff --git a/crates/matrix-sdk/src/encryption/identities/users.rs b/crates/matrix-sdk/src/encryption/identities/users.rs index ad47bc4c35..25b8a4e6c0 100644 --- a/crates/matrix-sdk/src/encryption/identities/users.rs +++ b/crates/matrix-sdk/src/encryption/identities/users.rs @@ -99,13 +99,13 @@ impl IdentityUpdates { /// [`Encryption::bootstrap_cross_signing()`]: crate::encryption::Encryption::bootstrap_cross_signing #[derive(Debug, Clone)] pub struct UserIdentity { - inner: UserIdentities, + client: Client, + inner: CryptoUserIdentities, } impl UserIdentity { pub(crate) fn new(client: Client, identity: CryptoUserIdentities) -> Self { - let inner = UserIdentities { client, identity }; - Self { inner } + Self { inner: identity, client } } /// The ID of the user this identity belongs to. @@ -128,7 +128,7 @@ impl UserIdentity { /// # anyhow::Ok(()) }; /// ``` pub fn user_id(&self) -> &UserId { - match &self.inner.identity { + match &self.inner { CryptoUserIdentities::Own(identity) => identity.user_id(), CryptoUserIdentities::Other(identity) => identity.user_id(), } @@ -185,7 +185,7 @@ impl UserIdentity { pub async fn request_verification( &self, ) -> Result { - self.inner.request_verification(None).await + self.request_verification_impl(None).await } /// Request an interactive verification with this `UserIdentity` using the @@ -244,8 +244,56 @@ impl UserIdentity { methods: Vec, ) -> Result { assert!(!methods.is_empty(), "The list of verification methods can't be non-empty"); + self.request_verification_impl(Some(methods)).await + } + + async fn request_verification_impl( + &self, + methods: Option>, + ) -> Result { + match &self.inner { + CryptoUserIdentities::Own(identity) => { + let (verification, request) = if let Some(methods) = methods { + identity + .request_verification_with_methods(methods) + .await + .map_err(crate::Error::from)? + } else { + identity.request_verification().await.map_err(crate::Error::from)? + }; - self.inner.request_verification(Some(methods)).await + self.client.send_verification_request(request).await?; + + Ok(VerificationRequest { inner: verification, client: self.client.clone() }) + } + CryptoUserIdentities::Other(i) => { + let content = i.verification_request_content(methods.clone()); + + let room = if let Some(room) = self.client.get_dm_room(i.user_id()) { + // Make sure that the user, to be verified, is still in the room + if !room + .members(RoomMemberships::ACTIVE) + .await? + .iter() + .any(|member| member.user_id() == i.user_id()) + { + room.invite_user_by_id(i.user_id()).await?; + } + room.clone() + } else { + self.client.create_dm(i.user_id()).await? + }; + + let response = room + .send(RoomMessageEventContent::new(MessageType::VerificationRequest(content))) + .await?; + + let verification = + i.request_verification(room.room_id(), &response.event_id, methods); + + Ok(VerificationRequest { inner: verification, client: self.client.clone() }) + } + } } /// Manually verify this [`UserIdentity`]. @@ -308,7 +356,14 @@ impl UserIdentity { /// ``` /// [`Encryption::cross_signing_status()`]: crate::encryption::Encryption::cross_signing_status pub async fn verify(&self) -> Result<(), ManualVerifyError> { - self.inner.verify().await + let request = match &self.inner { + CryptoUserIdentities::Own(identity) => identity.verify().await?, + CryptoUserIdentities::Other(identity) => identity.verify().await?, + }; + + self.client.send(request, None).await?; + + Ok(()) } /// Is the user identity considered to be verified. @@ -350,7 +405,7 @@ impl UserIdentity { /// # anyhow::Ok(()) }; /// ``` pub fn is_verified(&self) -> bool { - self.inner.identity.is_verified() + self.inner.is_verified() } /// Remove the requirement for this identity to be verified. @@ -359,7 +414,7 @@ impl UserIdentity { /// reported to the user. In order to remove this notice users have to /// verify again or to withdraw the verification requirement. pub async fn withdraw_verification(&self) -> Result<(), CryptoStoreError> { - self.inner.identity.withdraw_verification().await + self.inner.withdraw_verification().await } /// Get the public part of the Master key of this user identity. @@ -404,75 +459,9 @@ impl UserIdentity { /// # anyhow::Ok(()) }; /// ``` pub fn master_key(&self) -> &MasterPubkey { - match &self.inner.identity { + match &self.inner { CryptoUserIdentities::Own(identity) => identity.master_key(), CryptoUserIdentities::Other(identity) => identity.master_key(), } } } - -#[derive(Debug, Clone)] -struct UserIdentities { - client: Client, - identity: CryptoUserIdentities, -} - -impl UserIdentities { - async fn request_verification( - &self, - methods: Option>, - ) -> Result { - match &self.identity { - CryptoUserIdentities::Own(identity) => { - let (verification, request) = if let Some(methods) = methods { - identity - .request_verification_with_methods(methods) - .await - .map_err(crate::Error::from)? - } else { - identity.request_verification().await.map_err(crate::Error::from)? - }; - - self.client.send_verification_request(request).await?; - - Ok(VerificationRequest { inner: verification, client: self.client.clone() }) - } - CryptoUserIdentities::Other(i) => { - let content = i.verification_request_content(methods.clone()); - - let room = if let Some(room) = self.client.get_dm_room(i.user_id()) { - // Make sure that the user, to be verified, is still in the room - if !room - .members(RoomMemberships::ACTIVE) - .await? - .iter() - .any(|member| member.user_id() == i.user_id()) - { - room.invite_user_by_id(i.user_id()).await?; - } - room.clone() - } else { - self.client.create_dm(i.user_id()).await? - }; - - let response = room - .send(RoomMessageEventContent::new(MessageType::VerificationRequest(content))) - .await?; - - let verification = - i.request_verification(room.room_id(), &response.event_id, methods); - - Ok(VerificationRequest { inner: verification, client: self.client.clone() }) - } - } - } - - async fn verify(&self) -> Result<(), ManualVerifyError> { - let request = match &self.identity { - CryptoUserIdentities::Own(identity) => identity.verify().await?, - CryptoUserIdentities::Other(identity) => identity.verify().await?, - }; - self.client.send(request, None).await?; - Ok(()) - } -}