From d9fbc187773fd34d5882ec2c16520e5b3a4c6da7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Damir=20Jeli=C4=87?= Date: Thu, 30 Jul 2020 15:48:13 +0200 Subject: [PATCH] crypto: Update to the latest Ruma changes. --- matrix_sdk_common/Cargo.toml | 3 +- matrix_sdk_crypto/src/verification/machine.rs | 33 ++--- matrix_sdk_crypto/src/verification/sas.rs | 132 ++++++++++-------- 3 files changed, 91 insertions(+), 77 deletions(-) diff --git a/matrix_sdk_common/Cargo.toml b/matrix_sdk_common/Cargo.toml index 3041413f..b2ca9d7b 100644 --- a/matrix_sdk_common/Cargo.toml +++ b/matrix_sdk_common/Cargo.toml @@ -15,9 +15,8 @@ instant = { version = "0.1.6", features = ["wasm-bindgen", "now"] } js_int = "0.1.8" [dependencies.ruma] -git = "https://github.com/ruma/ruma" +path = "/home/poljar/werk/priv/ruma/ruma" features = ["client-api"] -rev = "e047c647ddcb368e7eb1e05ae8823a9494273457" [target.'cfg(not(target_arch = "wasm32"))'.dependencies] uuid = { version = "0.8.1", features = ["v4"] } diff --git a/matrix_sdk_crypto/src/verification/machine.rs b/matrix_sdk_crypto/src/verification/machine.rs index ccb1aced..32ca399b 100644 --- a/matrix_sdk_crypto/src/verification/machine.rs +++ b/matrix_sdk_crypto/src/verification/machine.rs @@ -18,9 +18,7 @@ use dashmap::DashMap; use matrix_sdk_common::{ api::r0::to_device::send_event_to_device::Request as ToDeviceRequest, - events::{ - key::verification::start::StartEventContent, AnyToDeviceEvent, AnyToDeviceEventContent, - }, + events::{AnyToDeviceEvent, AnyToDeviceEventContent}, identifiers::{DeviceId, UserId}, locks::RwLock, }; @@ -87,22 +85,21 @@ impl VerificationMachine { ) -> Result<(), CryptoStoreError> { match event { AnyToDeviceEvent::KeyVerificationStart(e) => { - if let StartEventContent::MSasV1(content) = &e.content { - if let Some(d) = self - .store - .read() - .await - .get_device(&e.sender, &content.from_device) - .await? - { - match Sas::from_start_event(self.account.clone(), d, e) { - Ok(s) => { - self.verifications.insert(content.transaction_id.clone(), s); - } - Err(c) => self.queue_up_content(&e.sender, &content.from_device, c), + if let Some(d) = self + .store + .read() + .await + .get_device(&e.sender, &e.content.from_device) + .await? + { + match Sas::from_start_event(self.account.clone(), d, e) { + Ok(s) => { + self.verifications + .insert(e.content.transaction_id.clone(), s); } - }; - } + Err(c) => self.queue_up_content(&e.sender, &e.content.from_device, c), + } + }; } AnyToDeviceEvent::KeyVerificationCancel(e) => { self.verifications.remove(&e.content.transaction_id); diff --git a/matrix_sdk_crypto/src/verification/sas.rs b/matrix_sdk_crypto/src/verification/sas.rs index 226fadda..ee67e024 100644 --- a/matrix_sdk_crypto/src/verification/sas.rs +++ b/matrix_sdk_crypto/src/verification/sas.rs @@ -23,11 +23,11 @@ use matrix_sdk_common::{ api::r0::to_device::send_event_to_device::Request as ToDeviceRequest, events::{ key::verification::{ - accept::AcceptEventContent, + accept::{AcceptEventContent, AcceptMethod, MSasV1Content as AcceptV1Content}, cancel::{CancelCode, CancelEventContent}, key::KeyEventContent, mac::MacEventContent, - start::{MSasV1Content, MSasV1ContentOptions, StartEventContent}, + start::{MSasV1Content, MSasV1ContentInit, StartEventContent, StartMethod}, HashAlgorithm, KeyAgreementProtocol, MessageAuthenticationCode, ShortAuthenticationString, VerificationMethod, }, @@ -438,10 +438,10 @@ struct AcceptedProtocols { short_auth_string: Vec, } -impl From for AcceptedProtocols { - fn from(content: AcceptEventContent) -> Self { +impl From for AcceptedProtocols { + fn from(content: AcceptV1Content) -> Self { Self { - method: content.method, + method: VerificationMethod::MSasV1, hash: content.hash, key_agreement_protocol: content.key_agreement_protocol, message_auth_code: content.message_authentication_code, @@ -450,6 +450,21 @@ impl From for AcceptedProtocols { } } +impl Default for AcceptedProtocols { + fn default() -> Self { + AcceptedProtocols { + method: VerificationMethod::MSasV1, + hash: HashAlgorithm::Sha256, + key_agreement_protocol: KeyAgreementProtocol::Curve25519HkdfSha256, + message_auth_code: MessageAuthenticationCode::HkdfHmacSha256, + short_auth_string: vec![ + ShortAuthenticationString::Decimal, + ShortAuthenticationString::Emoji, + ], + } + } +} + /// A type level state machine modeling the Sas flow. /// /// This is the generic struc holding common data between the different states @@ -482,7 +497,7 @@ impl std::fmt::Debug for SasState { /// The initial SAS state. #[derive(Clone, Debug)] struct Created { - protocol_definitions: MSasV1ContentOptions, + protocol_definitions: MSasV1ContentInit, } /// The initial SAS state if the other side started the SAS verification. @@ -586,7 +601,6 @@ impl SasState { /// * `other_device` - The other device which we are going to verify. fn new(account: Account, other_device: Device) -> SasState { let verification_flow_id = Uuid::new_v4().to_string(); - let from_device: Box = account.device_id().into(); SasState { inner: Arc::new(Mutex::new(OlmSas::new())), @@ -597,9 +611,7 @@ impl SasState { verification_flow_id: Arc::new(verification_flow_id.clone()), state: Arc::new(Created { - protocol_definitions: MSasV1ContentOptions { - transaction_id: verification_flow_id, - from_device, + protocol_definitions: MSasV1ContentInit { short_authentication_string: Sas::STRINGS.to_vec(), key_agreement_protocols: Sas::KEY_AGREEMENT_PROTOCOLS.to_vec(), message_authentication_codes: Sas::MACS.to_vec(), @@ -613,10 +625,14 @@ impl SasState { /// /// The content needs to be sent to the other device. fn as_content(&self) -> StartEventContent { - StartEventContent::MSasV1( - MSasV1Content::new(self.state.protocol_definitions.clone()) - .expect("Invalid initial protocol definitions."), - ) + StartEventContent { + transaction_id: self.verification_flow_id.to_string(), + from_device: self.device_id().into(), + method: StartMethod::MSasV1( + MSasV1Content::new(self.state.protocol_definitions.clone()) + .expect("Invalid initial protocol definitions."), + ), + } } /// Receive a m.key.verification.accept event, changing the state into @@ -633,34 +649,35 @@ impl SasState { self.check_sender_and_txid(&event.sender, &event.content.transaction_id) .map_err(|c| self.clone().cancel(c))?; - let content = &event.content; - if !Sas::KEY_AGREEMENT_PROTOCOLS.contains(&event.content.key_agreement_protocol) - || !Sas::HASHES.contains(&event.content.hash) - || !Sas::MACS.contains(&event.content.message_authentication_code) - || (!event - .content - .short_authentication_string - .contains(&ShortAuthenticationString::Emoji) - && !event - .content + if let AcceptMethod::MSasV1(content) = &event.content.method { + if !Sas::KEY_AGREEMENT_PROTOCOLS.contains(&content.key_agreement_protocol) + || !Sas::HASHES.contains(&content.hash) + || !Sas::MACS.contains(&content.message_authentication_code) + || (!content .short_authentication_string - .contains(&ShortAuthenticationString::Decimal)) - { - Err(self.cancel(CancelCode::UnknownMethod)) - } else { - let json_start_content = cjson::to_string(&self.as_content()) - .expect("Can't deserialize start event content"); + .contains(&ShortAuthenticationString::Emoji) + && !content + .short_authentication_string + .contains(&ShortAuthenticationString::Decimal)) + { + Err(self.cancel(CancelCode::UnknownMethod)) + } else { + let json_start_content = cjson::to_string(&self.as_content()) + .expect("Can't deserialize start event content"); - Ok(SasState { - inner: self.inner, - ids: self.ids, - verification_flow_id: self.verification_flow_id, - state: Arc::new(Accepted { - json_start_content, - commitment: content.commitment.clone(), - accepted_protocols: Arc::new(content.clone().into()), - }), - }) + Ok(SasState { + inner: self.inner, + ids: self.ids, + verification_flow_id: self.verification_flow_id, + state: Arc::new(Accepted { + json_start_content, + commitment: content.commitment.clone(), + accepted_protocols: Arc::new(content.clone().into()), + }), + }) + } + } else { + Err(self.cancel(CancelCode::UnknownMethod)) } } } @@ -684,7 +701,7 @@ impl SasState { other_device: Device, event: &ToDeviceEvent, ) -> Result, SasState> { - if let StartEventContent::MSasV1(content) = &event.content { + if let StartMethod::MSasV1(content) = &event.content.method { let sas = OlmSas::new(); let utility = OlmUtility::new(); @@ -700,7 +717,7 @@ impl SasState { other_device, }, - verification_flow_id: Arc::new(content.transaction_id.clone()), + verification_flow_id: Arc::new(event.content.transaction_id.clone()), state: Arc::new(Started { protocol_definitions: content.clone(), @@ -735,10 +752,7 @@ impl SasState { other_device, }, - // TODO we can't get to the transaction id currently since it's - // behind the content specific enum. - verification_flow_id: Arc::new("".to_owned()), - + verification_flow_id: Arc::new(event.content.transaction_id.clone()), state: Arc::new(Canceled::new(CancelCode::UnknownMethod)), }) } @@ -752,18 +766,21 @@ impl SasState { /// been started because of a /// m.key.verification.request -> m.key.verification.ready flow. fn as_content(&self) -> AcceptEventContent { + let accepted_protocols = AcceptedProtocols::default(); + AcceptEventContent { - method: VerificationMethod::MSasV1, transaction_id: self.verification_flow_id.to_string(), - commitment: self.state.commitment.clone(), - hash: HashAlgorithm::Sha256, - key_agreement_protocol: KeyAgreementProtocol::Curve25519HkdfSha256, - message_authentication_code: MessageAuthenticationCode::HkdfHmacSha256, - short_authentication_string: self - .state - .protocol_definitions - .short_authentication_string - .clone(), + method: AcceptMethod::MSasV1(AcceptV1Content { + commitment: self.state.commitment.clone(), + hash: accepted_protocols.hash, + key_agreement_protocol: accepted_protocols.key_agreement_protocol, + message_authentication_code: accepted_protocols.message_auth_code, + short_authentication_string: self + .state + .protocol_definitions + .short_authentication_string + .clone(), + }), } } @@ -782,7 +799,8 @@ impl SasState { self.check_sender_and_txid(&event.sender, &event.content.transaction_id) .map_err(|c| self.clone().cancel(c))?; - let accepted_protocols: AcceptedProtocols = self.as_content().into(); + let accepted_protocols = AcceptedProtocols::default(); + self.inner .lock() .unwrap()