char
/
matrix-rust-sdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

crypto: Rename Device to ReadOnlyDevice.

master
Damir Jelić 2020-08-17 16:17:28 +02:00
parent e778f7d72d
commit 43aea6e482
17 changed files with 104 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
matrix_sdk/src/device.rs
View File

@ -14,7 +14,7 @@
use std::ops::Deref; use std::ops::Deref;
use matrix_sdk_base::{Device as ReadOnlyDevice, DeviceWrap, UserDevicesWrap}; use matrix_sdk_base::{DeviceWrap, ReadOnlyDevice, UserDevicesWrap};
use matrix_sdk_common::{ use matrix_sdk_common::{
api::r0::to_device::send_event_to_device::Request as ToDeviceRequest, identifiers::DeviceId, api::r0::to_device::send_event_to_device::Request as ToDeviceRequest, identifiers::DeviceId,
}; };

4
matrix_sdk/src/sas.rs
View File

@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and // See the License for the specific language governing permissions and
// limitations under the License. // limitations under the License.
use matrix_sdk_base::{Device, Sas as BaseSas}; use matrix_sdk_base::{ReadOnlyDevice, Sas as BaseSas};
use matrix_sdk_common::api::r0::to_device::send_event_to_device::Request as ToDeviceRequest; use matrix_sdk_common::api::r0::to_device::send_event_to_device::Request as ToDeviceRequest;
use crate::{error::Result, http_client::HttpClient}; use crate::{error::Result, http_client::HttpClient};
@ -89,7 +89,7 @@ impl Sas {
} }
/// Get the other users device that we're veryfying. /// Get the other users device that we're veryfying.
pub fn other_device(&self) -> Device { pub fn other_device(&self) -> ReadOnlyDevice {
self.inner.other_device() self.inner.other_device()
} }
} }

2
matrix_sdk_base/src/lib.rs
View File

@ -57,7 +57,7 @@ pub use state::{AllRooms, ClientState};
#[cfg(feature = "encryption")] #[cfg(feature = "encryption")]
#[cfg_attr(feature = "docs", doc(cfg(encryption)))] #[cfg_attr(feature = "docs", doc(cfg(encryption)))]
pub use matrix_sdk_crypto::{ pub use matrix_sdk_crypto::{
CryptoStoreError, Device, DeviceWrap, Sas, TrustState, UserDevicesWrap, CryptoStoreError, DeviceWrap, ReadOnlyDevice, Sas, TrustState, UserDevicesWrap,
}; };
#[cfg(feature = "messages")] #[cfg(feature = "messages")]

30
matrix_sdk_crypto/src/device.rs
View File

@ -41,7 +41,7 @@ use crate::{
/// A device represents a E2EE capable client of an user. /// A device represents a E2EE capable client of an user.
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct Device { pub struct ReadOnlyDevice {
user_id: Arc<UserId>, user_id: Arc<UserId>,
device_id: Arc<Box<DeviceId>>, device_id: Arc<Box<DeviceId>>,
algorithms: Arc<Vec<EventEncryptionAlgorithm>>, algorithms: Arc<Vec<EventEncryptionAlgorithm>>,
@ -55,12 +55,12 @@ pub struct Device {
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
/// A device represents a E2EE capable client of an user. /// A device represents a E2EE capable client of an user.
pub struct DeviceWrap { pub struct DeviceWrap {
pub(crate) inner: Device, pub(crate) inner: ReadOnlyDevice,
pub(crate) verification_machine: VerificationMachine, pub(crate) verification_machine: VerificationMachine,
} }
impl Deref for DeviceWrap { impl Deref for DeviceWrap {
type Target = Device; type Target = ReadOnlyDevice;
fn deref(&self) -> &Self::Target { fn deref(&self) -> &Self::Target {
&self.inner &self.inner
@ -133,7 +133,7 @@ impl From<i64> for TrustState {
} }
} }
impl Device { impl ReadOnlyDevice {
/// Create a new Device. /// Create a new Device.
pub fn new( pub fn new(
user_id: UserId, user_id: UserId,
@ -144,7 +144,7 @@ impl Device {
keys: BTreeMap<DeviceKeyId, String>, keys: BTreeMap<DeviceKeyId, String>,
signatures: BTreeMap<UserId, BTreeMap<DeviceKeyId, String>>, signatures: BTreeMap<UserId, BTreeMap<DeviceKeyId, String>>,
) -> Self { ) -> Self {
Device { Self {
user_id: Arc::new(user_id), user_id: Arc::new(user_id),
device_id: Arc::new(device_id), device_id: Arc::new(device_id),
display_name: Arc::new(display_name), display_name: Arc::new(display_name),
@ -285,22 +285,22 @@ impl Device {
} }
#[cfg(test)] #[cfg(test)]
pub async fn from_machine(machine: &OlmMachine) -> Device { pub async fn from_machine(machine: &OlmMachine) -> ReadOnlyDevice {
Device::from_account(machine.account()).await ReadOnlyDevice::from_account(machine.account()).await
} }
#[cfg(test)] #[cfg(test)]
pub async fn from_account(account: &Account) -> Device { pub async fn from_account(account: &Account) -> ReadOnlyDevice {
let device_keys = account.device_keys().await; let device_keys = account.device_keys().await;
Device::try_from(&device_keys).unwrap() ReadOnlyDevice::try_from(&device_keys).unwrap()
} }
} }
impl TryFrom<&DeviceKeys> for Device { impl TryFrom<&DeviceKeys> for ReadOnlyDevice {
type Error = SignatureError; type Error = SignatureError;
fn try_from(device_keys: &DeviceKeys) -> Result<Self, Self::Error> { fn try_from(device_keys: &DeviceKeys) -> Result<Self, Self::Error> {
let device = Device { let device = Self {
user_id: Arc::new(device_keys.user_id.clone()), user_id: Arc::new(device_keys.user_id.clone()),
device_id: Arc::new(device_keys.device_id.clone()), device_id: Arc::new(device_keys.device_id.clone()),
algorithms: Arc::new(device_keys.algorithms.clone()), algorithms: Arc::new(device_keys.algorithms.clone()),
@ -322,7 +322,7 @@ impl TryFrom<&DeviceKeys> for Device {
} }
} }
impl PartialEq for Device { impl PartialEq for ReadOnlyDevice {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
self.user_id() == other.user_id() && self.device_id() == other.device_id() self.user_id() == other.user_id() && self.device_id() == other.device_id()
} }
@ -333,7 +333,7 @@ pub(crate) mod test {
use serde_json::json; use serde_json::json;
use std::convert::TryFrom; use std::convert::TryFrom;
use crate::device::{Device, TrustState}; use crate::device::{ReadOnlyDevice, TrustState};
use matrix_sdk_common::{ use matrix_sdk_common::{
encryption::DeviceKeys, encryption::DeviceKeys,
identifiers::{user_id, DeviceKeyAlgorithm}, identifiers::{user_id, DeviceKeyAlgorithm},
@ -364,9 +364,9 @@ pub(crate) mod test {
serde_json::from_value(device_keys).unwrap() serde_json::from_value(device_keys).unwrap()
} }
pub(crate) fn get_device() -> Device { pub(crate) fn get_device() -> ReadOnlyDevice {
let device_keys = device_keys(); let device_keys = device_keys();
Device::try_from(&device_keys).unwrap() ReadOnlyDevice::try_from(&device_keys).unwrap()
} }
#[test] #[test]

2
matrix_sdk_crypto/src/lib.rs
View File

@ -37,7 +37,7 @@ mod store;
mod user_identity; mod user_identity;
mod verification; mod verification;
pub use device::{Device, DeviceWrap, TrustState, UserDevicesWrap}; pub use device::{DeviceWrap, ReadOnlyDevice, TrustState, UserDevicesWrap};
pub use error::{MegolmError, OlmError}; pub use error::{MegolmError, OlmError};
pub use machine::{OlmMachine, OneTimeKeys}; pub use machine::{OlmMachine, OneTimeKeys};
pub use memory_stores::{DeviceStore, GroupSessionStore, SessionStore, UserDevices}; pub use memory_stores::{DeviceStore, GroupSessionStore, SessionStore, UserDevices};

18
matrix_sdk_crypto/src/machine.rs
View File

@ -53,7 +53,7 @@ use matrix_sdk_common::{
#[cfg(feature = "sqlite_cryptostore")] #[cfg(feature = "sqlite_cryptostore")]
use super::store::sqlite::SqliteStore; use super::store::sqlite::SqliteStore;
use super::{ use super::{
device::{Device, DeviceWrap, UserDevicesWrap}, device::{DeviceWrap, ReadOnlyDevice, UserDevicesWrap},
error::{EventError, MegolmError, MegolmResult, OlmError, OlmResult}, error::{EventError, MegolmError, MegolmResult, OlmError, OlmResult},
olm::{ olm::{
Account, EncryptionSettings, GroupSessionKey, IdentityKeys, InboundGroupSession, Account, EncryptionSettings, GroupSessionKey, IdentityKeys, InboundGroupSession,
@ -370,7 +370,7 @@ impl OlmMachine {
for (user_id, user_devices) in &response.one_time_keys { for (user_id, user_devices) in &response.one_time_keys {
for (device_id, key_map) in user_devices { for (device_id, key_map) in user_devices {
let device: Device = match self.store.get_device(&user_id, device_id).await { let device = match self.store.get_device(&user_id, device_id).await {
Ok(Some(d)) => d, Ok(Some(d)) => d,
Ok(None) => { Ok(None) => {
warn!( warn!(
@ -425,7 +425,7 @@ impl OlmMachine {
async fn handle_devices_from_key_query( async fn handle_devices_from_key_query(
&self, &self,
device_keys_map: &BTreeMap<UserId, BTreeMap<Box<DeviceId>, DeviceKeys>>, device_keys_map: &BTreeMap<UserId, BTreeMap<Box<DeviceId>, DeviceKeys>>,
) -> StoreResult<Vec<Device>> { ) -> StoreResult<Vec<ReadOnlyDevice>> {
let mut changed_devices = Vec::new(); let mut changed_devices = Vec::new();
for (user_id, device_map) in device_keys_map { for (user_id, device_map) in device_keys_map {
@ -457,7 +457,7 @@ impl OlmMachine {
} }
device device
} else { } else {
let device = match Device::try_from(device_keys) { let device = match ReadOnlyDevice::try_from(device_keys) {
Ok(d) => d, Ok(d) => d,
Err(e) => { Err(e) => {
warn!( warn!(
@ -504,7 +504,7 @@ impl OlmMachine {
pub async fn receive_keys_query_response( pub async fn receive_keys_query_response(
&self, &self,
response: &get_keys::Response, response: &get_keys::Response,
) -> OlmResult<Vec<Device>> { ) -> OlmResult<Vec<ReadOnlyDevice>> {
let changed_devices = self let changed_devices = self
.handle_devices_from_key_query(&response.device_keys) .handle_devices_from_key_query(&response.device_keys)
.await?; .await?;
@ -920,7 +920,7 @@ impl OlmMachine {
/// * `content` - The content of the event that should be encrypted. /// * `content` - The content of the event that should be encrypted.
async fn olm_encrypt( async fn olm_encrypt(
&self, &self,
recipient_device: &Device, recipient_device: &ReadOnlyDevice,
event_type: EventType, event_type: EventType,
content: Value, content: Value,
) -> OlmResult<EncryptedEventContent> { ) -> OlmResult<EncryptedEventContent> {
@ -1395,7 +1395,7 @@ pub(crate) mod test {
use crate::{ use crate::{
machine::{OlmMachine, OneTimeKeys}, machine::{OlmMachine, OneTimeKeys},
verification::test::request_to_event, verification::test::request_to_event,
verify_json, Device, EncryptionSettings, verify_json, EncryptionSettings, ReadOnlyDevice,
}; };
use matrix_sdk_common::{ use matrix_sdk_common::{
@ -1498,8 +1498,8 @@ pub(crate) mod test {
let alice_device = alice_device_id(); let alice_device = alice_device_id();
let alice = OlmMachine::new(&alice_id, &alice_device); let alice = OlmMachine::new(&alice_id, &alice_device);
let alice_deivce = Device::from_machine(&alice).await; let alice_deivce = ReadOnlyDevice::from_machine(&alice).await;
let bob_device = Device::from_machine(&bob).await; let bob_device = ReadOnlyDevice::from_machine(&bob).await;
alice.store.save_devices(&[bob_device]).await.unwrap(); alice.store.save_devices(&[bob_device]).await.unwrap();
bob.store.save_devices(&[alice_deivce]).await.unwrap(); bob.store.save_devices(&[alice_deivce]).await.unwrap();

16
matrix_sdk_crypto/src/memory_stores.rs
View File

@ -21,7 +21,7 @@ use matrix_sdk_common::{
}; };
use super::{ use super::{
device::Device, device::ReadOnlyDevice,
olm::{InboundGroupSession, Session}, olm::{InboundGroupSession, Session},
}; };
@ -134,18 +134,18 @@ impl GroupSessionStore {
/// In-memory store holding the devices of users. /// In-memory store holding the devices of users.
#[derive(Clone, Debug, Default)] #[derive(Clone, Debug, Default)]
pub struct DeviceStore { pub struct DeviceStore {
entries: Arc<DashMap<UserId, DashMap<Box<DeviceId>, Device>>>, entries: Arc<DashMap<UserId, DashMap<Box<DeviceId>, ReadOnlyDevice>>>,
} }
/// A read only view over all devices belonging to a user. /// A read only view over all devices belonging to a user.
#[derive(Debug)] #[derive(Debug)]
pub struct UserDevices { pub struct UserDevices {
entries: ReadOnlyView<Box<DeviceId>, Device>, entries: ReadOnlyView<Box<DeviceId>, ReadOnlyDevice>,
} }
impl UserDevices { impl UserDevices {
/// Get the specific device with the given device id. /// Get the specific device with the given device id.
pub fn get(&self, device_id: &DeviceId) -> Option<Device> { pub fn get(&self, device_id: &DeviceId) -> Option<ReadOnlyDevice> {
self.entries.get(device_id).cloned() self.entries.get(device_id).cloned()
} }
@ -155,7 +155,7 @@ impl UserDevices {
} }
/// Iterator over all the devices of the user devices. /// Iterator over all the devices of the user devices.
pub fn devices(&self) -> impl Iterator<Item = &Device> { pub fn devices(&self) -> impl Iterator<Item = &ReadOnlyDevice> {
self.entries.values() self.entries.values()
} }
} }
@ -171,7 +171,7 @@ impl DeviceStore {
/// Add a device to the store. /// Add a device to the store.
/// ///
/// Returns true if the device was already in the store, false otherwise. /// Returns true if the device was already in the store, false otherwise.
pub fn add(&self, device: Device) -> bool { pub fn add(&self, device: ReadOnlyDevice) -> bool {
let user_id = device.user_id(); let user_id = device.user_id();
if !self.entries.contains_key(&user_id) { if !self.entries.contains_key(&user_id) {
@ -185,7 +185,7 @@ impl DeviceStore {
} }
/// Get the device with the given device_id and belonging to the given user. /// Get the device with the given device_id and belonging to the given user.
pub fn get(&self, user_id: &UserId, device_id: &DeviceId) -> Option<Device> { pub fn get(&self, user_id: &UserId, device_id: &DeviceId) -> Option<ReadOnlyDevice> {
self.entries self.entries
.get(user_id) .get(user_id)
.and_then(|m| m.get(device_id).map(|d| d.value().clone())) .and_then(|m| m.get(device_id).map(|d| d.value().clone()))
@ -194,7 +194,7 @@ impl DeviceStore {
/// Remove the device with the given device_id and belonging to the given user. /// Remove the device with the given device_id and belonging to the given user.
/// ///
/// Returns the device if it was removed, None if it wasn't in the store. /// Returns the device if it was removed, None if it wasn't in the store.
pub fn remove(&self, user_id: &UserId, device_id: &DeviceId) -> Option<Device> { pub fn remove(&self, user_id: &UserId, device_id: &DeviceId) -> Option<ReadOnlyDevice> {
self.entries self.entries
.get(user_id) .get(user_id)
.and_then(|m| m.remove(device_id)) .and_then(|m| m.remove(device_id))

4
matrix_sdk_crypto/src/olm/account.rs
View File

@ -45,7 +45,7 @@ pub use olm_rs::{
}; };
use super::{EncryptionSettings, InboundGroupSession, OutboundGroupSession, Session}; use super::{EncryptionSettings, InboundGroupSession, OutboundGroupSession, Session};
use crate::{device::Device, error::SessionCreationError}; use crate::{device::ReadOnlyDevice, error::SessionCreationError};
/// Account holding identity keys for which sessions can be created. /// Account holding identity keys for which sessions can be created.
/// ///
@ -436,7 +436,7 @@ impl Account {
/// key that the other account created and shared with us. /// key that the other account created and shared with us.
pub(crate) async fn create_outbound_session( pub(crate) async fn create_outbound_session(
&self, &self,
device: Device, device: ReadOnlyDevice,
key_map: &BTreeMap<DeviceKeyId, OneTimeKey>, key_map: &BTreeMap<DeviceKeyId, OneTimeKey>,
) -> Result<Session, SessionCreationError> { ) -> Result<Session, SessionCreationError> {
let one_time_key = key_map.values().next().ok_or_else(|| { let one_time_key = key_map.values().next().ok_or_else(|| {

4
matrix_sdk_crypto/src/olm/session.rs
View File

@ -29,7 +29,7 @@ use serde_json::{json, Value};
use super::IdentityKeys; use super::IdentityKeys;
use crate::{ use crate::{
error::{EventError, OlmResult}, error::{EventError, OlmResult},
Device, ReadOnlyDevice,
}; };
pub use olm_rs::{ pub use olm_rs::{
@ -103,7 +103,7 @@ impl Session {
/// * `content` - The content of the event. /// * `content` - The content of the event.
pub async fn encrypt( pub async fn encrypt(
&mut self, &mut self,
recipient_device: &Device, recipient_device: &ReadOnlyDevice,
event_type: EventType, event_type: EventType,
content: Value, content: Value,
) -> OlmResult<EncryptedEventContent> { ) -> OlmResult<EncryptedEventContent> {

12
matrix_sdk_crypto/src/store/memorystore.rs
View File

@ -23,7 +23,7 @@ use matrix_sdk_common::{
use super::{Account, CryptoStore, InboundGroupSession, Result, Session}; use super::{Account, CryptoStore, InboundGroupSession, Result, Session};
use crate::{ use crate::{
device::Device, device::ReadOnlyDevice,
memory_stores::{DeviceStore, GroupSessionStore, SessionStore, UserDevices}, memory_stores::{DeviceStore, GroupSessionStore, SessionStore, UserDevices},
}; };
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
@ -107,11 +107,15 @@ impl CryptoStore for MemoryStore {
Ok(self.tracked_users.insert(user.clone())) Ok(self.tracked_users.insert(user.clone()))
} }
async fn get_device(&self, user_id: &UserId, device_id: &DeviceId) -> Result<Option<Device>> { async fn get_device(
&self,
user_id: &UserId,
device_id: &DeviceId,
) -> Result<Option<ReadOnlyDevice>> {
Ok(self.devices.get(user_id, device_id)) Ok(self.devices.get(user_id, device_id))
} }
async fn delete_device(&self, device: Device) -> Result<()> { async fn delete_device(&self, device: ReadOnlyDevice) -> Result<()> {
let _ = self.devices.remove(device.user_id(), device.device_id()); let _ = self.devices.remove(device.user_id(), device.device_id());
Ok(()) Ok(())
} }
@ -120,7 +124,7 @@ impl CryptoStore for MemoryStore {
Ok(self.devices.user_devices(user_id)) Ok(self.devices.user_devices(user_id))
} }
async fn save_devices(&self, devices: &[Device]) -> Result<()> { async fn save_devices(&self, devices: &[ReadOnlyDevice]) -> Result<()> {
for device in devices { for device in devices {
let _ = self.devices.add(device.clone()); let _ = self.devices.add(device.clone());
} }

12
matrix_sdk_crypto/src/store/mod.rs
View File

@ -27,7 +27,7 @@ use thiserror::Error;
use url::ParseError; use url::ParseError;
use super::{ use super::{
device::Device, device::ReadOnlyDevice,
memory_stores::UserDevices, memory_stores::UserDevices,
olm::{Account, InboundGroupSession, Session}, olm::{Account, InboundGroupSession, Session},
}; };
@ -169,14 +169,14 @@ pub trait CryptoStore: Debug {
/// # Arguments /// # Arguments
/// ///
/// * `device` - The device that should be stored. /// * `device` - The device that should be stored.
async fn save_devices(&self, devices: &[Device]) -> Result<()>; async fn save_devices(&self, devices: &[ReadOnlyDevice]) -> Result<()>;
/// Delete the given device from the store. /// Delete the given device from the store.
/// ///
/// # Arguments /// # Arguments
/// ///
/// * `device` - The device that should be stored. /// * `device` - The device that should be stored.
async fn delete_device(&self, device: Device) -> Result<()>; async fn delete_device(&self, device: ReadOnlyDevice) -> Result<()>;
/// Get the device for the given user with the given device id. /// Get the device for the given user with the given device id.
/// ///
@ -185,7 +185,11 @@ pub trait CryptoStore: Debug {
/// * `user_id` - The user that the device belongs to. /// * `user_id` - The user that the device belongs to.
/// ///
/// * `device_id` - The unique id of the device. /// * `device_id` - The unique id of the device.
async fn get_device(&self, user_id: &UserId, device_id: &DeviceId) -> Result<Option<Device>>; async fn get_device(
&self,
user_id: &UserId,
device_id: &DeviceId,
) -> Result<Option<ReadOnlyDevice>>;
/// Get all the devices of the given user. /// Get all the devices of the given user.
/// ///

17
matrix_sdk_crypto/src/store/sqlite.rs
View File

@ -36,7 +36,7 @@ use zeroize::Zeroizing;
use super::{CryptoStore, CryptoStoreError, Result}; use super::{CryptoStore, CryptoStoreError, Result};
use crate::{ use crate::{
device::{Device, TrustState}, device::{ReadOnlyDevice, TrustState},
memory_stores::{DeviceStore, GroupSessionStore, SessionStore, UserDevices}, memory_stores::{DeviceStore, GroupSessionStore, SessionStore, UserDevices},
Account, IdentityKeys, InboundGroupSession, Session, Account, IdentityKeys, InboundGroupSession, Session,
}; };
@ -556,7 +556,7 @@ impl SqliteStore {
); );
} }
let device = Device::new( let device = ReadOnlyDevice::new(
user_id, user_id,
device_id.as_str().into(), device_id.as_str().into(),
display_name.clone(), display_name.clone(),
@ -572,7 +572,7 @@ impl SqliteStore {
Ok(()) Ok(())
} }
async fn save_device_helper(&self, device: Device) -> Result<()> { async fn save_device_helper(&self, device: ReadOnlyDevice) -> Result<()> {
let account_id = self.account_id().ok_or(CryptoStoreError::AccountUnset)?; let account_id = self.account_id().ok_or(CryptoStoreError::AccountUnset)?;
let mut connection = self.connection.lock().await; let mut connection = self.connection.lock().await;
@ -844,7 +844,7 @@ impl CryptoStore for SqliteStore {
Ok(already_added) Ok(already_added)
} }
async fn save_devices(&self, devices: &[Device]) -> Result<()> { async fn save_devices(&self, devices: &[ReadOnlyDevice]) -> Result<()> {
// TODO turn this into a bulk transaction. // TODO turn this into a bulk transaction.
for device in devices { for device in devices {
self.devices.add(device.clone()); self.devices.add(device.clone());
@ -854,7 +854,7 @@ impl CryptoStore for SqliteStore {
Ok(()) Ok(())
} }
async fn delete_device(&self, device: Device) -> Result<()> { async fn delete_device(&self, device: ReadOnlyDevice) -> Result<()> {
let account_id = self.account_id().ok_or(CryptoStoreError::AccountUnset)?; let account_id = self.account_id().ok_or(CryptoStoreError::AccountUnset)?;
let mut connection = self.connection.lock().await; let mut connection = self.connection.lock().await;
@ -872,8 +872,11 @@ impl CryptoStore for SqliteStore {
Ok(()) Ok(())
} }
#[allow(clippy::ptr_arg)] async fn get_device(
async fn get_device(&self, user_id: &UserId, device_id: &DeviceId) -> Result<Option<Device>> { &self,
user_id: &UserId,
device_id: &DeviceId,
) -> Result<Option<ReadOnlyDevice>> {
Ok(self.devices.get(user_id, device_id)) Ok(self.devices.get(user_id, device_id))
} }

6
matrix_sdk_crypto/src/user_identity.rs
View File

@ -24,7 +24,7 @@ use matrix_sdk_common::{
identifiers::{DeviceKeyId, UserId}, identifiers::{DeviceKeyId, UserId},
}; };
use crate::{error::SignatureError, verify_json, Device}; use crate::{error::SignatureError, verify_json, ReadOnlyDevice};
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct MasterPubkey(Arc<CrossSigningKey>); pub struct MasterPubkey(Arc<CrossSigningKey>);
@ -132,7 +132,7 @@ impl UserSigningPubkey {
} }
impl SelfSigningPubkey { impl SelfSigningPubkey {
fn verify_device(&self, device: &Device) -> Result<(), SignatureError> { fn verify_device(&self, device: &ReadOnlyDevice) -> Result<(), SignatureError> {
let (key_id, key) = self let (key_id, key) = self
.0 .0
.keys .keys
@ -165,7 +165,7 @@ impl UserIdentity {
}) })
} }
pub fn is_device_signed(&self, device: &Device) -> Result<(), SignatureError> { pub fn is_device_signed(&self, device: &ReadOnlyDevice) -> Result<(), SignatureError> {
self.self_signing_key.verify_device(device) self.self_signing_key.verify_device(device)
} }
} }

10
matrix_sdk_crypto/src/verification/machine.rs
View File

@ -25,7 +25,7 @@ use matrix_sdk_common::{
}; };
use super::sas::{content_to_request, Sas}; use super::sas::{content_to_request, Sas};
use crate::{Account, CryptoStore, CryptoStoreError, Device}; use crate::{Account, CryptoStore, CryptoStoreError, ReadOnlyDevice};
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct VerificationMachine { pub struct VerificationMachine {
@ -45,7 +45,7 @@ impl VerificationMachine {
} }
} }
pub fn start_sas(&self, device: Device) -> (Sas, OwnedToDeviceRequest) { pub fn start_sas(&self, device: ReadOnlyDevice) -> (Sas, OwnedToDeviceRequest) {
let (sas, content) = Sas::start(self.account.clone(), device.clone(), self.store.clone()); let (sas, content) = Sas::start(self.account.clone(), device.clone(), self.store.clone());
let request = content_to_request( let request = content_to_request(
device.user_id(), device.user_id(),
@ -196,7 +196,7 @@ mod test {
use crate::{ use crate::{
store::memorystore::MemoryStore, store::memorystore::MemoryStore,
verification::test::{get_content_from_request, wrap_any_to_device_content}, verification::test::{get_content_from_request, wrap_any_to_device_content},
Account, CryptoStore, Device, Account, CryptoStore, ReadOnlyDevice,
}; };
fn alice_id() -> UserId { fn alice_id() -> UserId {
@ -221,8 +221,8 @@ mod test {
let store = MemoryStore::new(); let store = MemoryStore::new();
let bob_store: Arc<Box<dyn CryptoStore>> = Arc::new(Box::new(MemoryStore::new())); let bob_store: Arc<Box<dyn CryptoStore>> = Arc::new(Box::new(MemoryStore::new()));
let bob_device = Device::from_account(&bob).await; let bob_device = ReadOnlyDevice::from_account(&bob).await;
let alice_device = Device::from_account(&alice).await; let alice_device = ReadOnlyDevice::from_account(&alice).await;
store.save_devices(&[bob_device]).await.unwrap(); store.save_devices(&[bob_device]).await.unwrap();
bob_store bob_store

6
matrix_sdk_crypto/src/verification/sas/helpers.rs
View File

@ -30,12 +30,12 @@ use matrix_sdk_common::{
uuid::Uuid, uuid::Uuid,
}; };
use crate::{Account, Device}; use crate::{Account, ReadOnlyDevice};
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct SasIds { pub struct SasIds {
pub account: Account, pub account: Account,
pub other_device: Device, pub other_device: ReadOnlyDevice,
} }
/// Get a tuple of an emoji and a description of the emoji using a number. /// Get a tuple of an emoji and a description of the emoji using a number.
@ -158,7 +158,7 @@ pub fn receive_mac_event(
ids: &SasIds, ids: &SasIds,
flow_id: &str, flow_id: &str,
event: &ToDeviceEvent<MacEventContent>, event: &ToDeviceEvent<MacEventContent>,
) -> Result<(Vec<Device>, Vec<String>), CancelCode> { ) -> Result<(Vec<ReadOnlyDevice>, Vec<String>), CancelCode> {
let mut verified_devices = Vec::new(); let mut verified_devices = Vec::new();
let info = extra_mac_info_receive(&ids, flow_id); let info = extra_mac_info_receive(&ids, flow_id);

28
matrix_sdk_crypto/src/verification/sas/mod.rs
View File

@ -33,7 +33,7 @@ use matrix_sdk_common::{
identifiers::{DeviceId, UserId}, identifiers::{DeviceId, UserId},
}; };
use crate::{Account, CryptoStore, CryptoStoreError, Device, TrustState}; use crate::{Account, CryptoStore, CryptoStoreError, ReadOnlyDevice, TrustState};
pub use helpers::content_to_request; pub use helpers::content_to_request;
use sas_state::{ use sas_state::{
@ -46,7 +46,7 @@ pub struct Sas {
inner: Arc<Mutex<InnerSas>>, inner: Arc<Mutex<InnerSas>>,
store: Arc<Box<dyn CryptoStore>>, store: Arc<Box<dyn CryptoStore>>,
account: Account, account: Account,
other_device: Device, other_device: ReadOnlyDevice,
flow_id: Arc<String>, flow_id: Arc<String>,
} }
@ -72,7 +72,7 @@ impl Sas {
} }
/// Get the device of the other user. /// Get the device of the other user.
pub fn other_device(&self) -> Device { pub fn other_device(&self) -> ReadOnlyDevice {
self.other_device.clone() self.other_device.clone()
} }
@ -99,7 +99,7 @@ impl Sas {
/// sent out through the server to the other device. /// sent out through the server to the other device.
pub(crate) fn start( pub(crate) fn start(
account: Account, account: Account,
other_device: Device, other_device: ReadOnlyDevice,
store: Arc<Box<dyn CryptoStore>>, store: Arc<Box<dyn CryptoStore>>,
) -> (Sas, StartEventContent) { ) -> (Sas, StartEventContent) {
let (inner, content) = InnerSas::start(account.clone(), other_device.clone()); let (inner, content) = InnerSas::start(account.clone(), other_device.clone());
@ -128,7 +128,7 @@ impl Sas {
/// the other side. /// the other side.
pub(crate) fn from_start_event( pub(crate) fn from_start_event(
account: Account, account: Account,
other_device: Device, other_device: ReadOnlyDevice,
store: Arc<Box<dyn CryptoStore>>, store: Arc<Box<dyn CryptoStore>>,
event: &ToDeviceEvent<StartEventContent>, event: &ToDeviceEvent<StartEventContent>,
) -> Result<Sas, AnyToDeviceEventContent> { ) -> Result<Sas, AnyToDeviceEventContent> {
@ -313,7 +313,7 @@ impl Sas {
content content
} }
pub(crate) fn verified_devices(&self) -> Option<Arc<Vec<Device>>> { pub(crate) fn verified_devices(&self) -> Option<Arc<Vec<ReadOnlyDevice>>> {
self.inner.lock().unwrap().verified_devices() self.inner.lock().unwrap().verified_devices()
} }
@ -338,7 +338,7 @@ enum InnerSas {
} }
impl InnerSas { impl InnerSas {
fn start(account: Account, other_device: Device) -> (InnerSas, StartEventContent) { fn start(account: Account, other_device: ReadOnlyDevice) -> (InnerSas, StartEventContent) {
let sas = SasState::<Created>::new(account, other_device); let sas = SasState::<Created>::new(account, other_device);
let content = sas.as_content(); let content = sas.as_content();
(InnerSas::Created(sas), content) (InnerSas::Created(sas), content)
@ -346,7 +346,7 @@ impl InnerSas {
fn from_start_event( fn from_start_event(
account: Account, account: Account,
other_device: Device, other_device: ReadOnlyDevice,
event: &ToDeviceEvent<StartEventContent>, event: &ToDeviceEvent<StartEventContent>,
) -> Result<InnerSas, AnyToDeviceEventContent> { ) -> Result<InnerSas, AnyToDeviceEventContent> {
match SasState::<Started>::from_start_event(account, other_device, event) { match SasState::<Started>::from_start_event(account, other_device, event) {
@ -535,7 +535,7 @@ impl InnerSas {
} }
} }
fn verified_devices(&self) -> Option<Arc<Vec<Device>>> { fn verified_devices(&self) -> Option<Arc<Vec<ReadOnlyDevice>>> {
if let InnerSas::Done(s) = self { if let InnerSas::Done(s) = self {
Some(s.verified_devices()) Some(s.verified_devices())
} else { } else {
@ -556,7 +556,7 @@ mod test {
use crate::{ use crate::{
store::memorystore::MemoryStore, store::memorystore::MemoryStore,
verification::test::{get_content_from_request, wrap_any_to_device_content}, verification::test::{get_content_from_request, wrap_any_to_device_content},
Account, CryptoStore, Device, Account, CryptoStore, ReadOnlyDevice,
}; };
use super::{Accepted, Created, Sas, SasState, Started}; use super::{Accepted, Created, Sas, SasState, Started};
@ -586,10 +586,10 @@ mod test {
async fn get_sas_pair() -> (SasState<Created>, SasState<Started>) { async fn get_sas_pair() -> (SasState<Created>, SasState<Started>) {
let alice = Account::new(&alice_id(), &alice_device_id()); let alice = Account::new(&alice_id(), &alice_device_id());
let alice_device = Device::from_account(&alice).await; let alice_device = ReadOnlyDevice::from_account(&alice).await;
let bob = Account::new(&bob_id(), &bob_device_id()); let bob = Account::new(&bob_id(), &bob_device_id());
let bob_device = Device::from_account(&bob).await; let bob_device = ReadOnlyDevice::from_account(&bob).await;
let alice_sas = SasState::<Created>::new(alice.clone(), bob_device); let alice_sas = SasState::<Created>::new(alice.clone(), bob_device);
@ -670,10 +670,10 @@ mod test {
#[tokio::test] #[tokio::test]
async fn sas_wrapper_full() { async fn sas_wrapper_full() {
let alice = Account::new(&alice_id(), &alice_device_id()); let alice = Account::new(&alice_id(), &alice_device_id());
let alice_device = Device::from_account(&alice).await; let alice_device = ReadOnlyDevice::from_account(&alice).await;
let bob = Account::new(&bob_id(), &bob_device_id()); let bob = Account::new(&bob_id(), &bob_device_id());
let bob_device = Device::from_account(&bob).await; let bob_device = ReadOnlyDevice::from_account(&bob).await;
let alice_store: Arc<Box<dyn CryptoStore>> = Arc::new(Box::new(MemoryStore::new())); let alice_store: Arc<Box<dyn CryptoStore>> = Arc::new(Box::new(MemoryStore::new()));
let bob_store: Arc<Box<dyn CryptoStore>> = Arc::new(Box::new(MemoryStore::new())); let bob_store: Arc<Box<dyn CryptoStore>> = Arc::new(Box::new(MemoryStore::new()));

24
matrix_sdk_crypto/src/verification/sas/sas_state.rs
View File

@ -43,7 +43,7 @@ use matrix_sdk_common::{
use super::helpers::{get_decimal, get_emoji, get_mac_content, receive_mac_event, SasIds}; use super::helpers::{get_decimal, get_emoji, get_mac_content, receive_mac_event, SasIds};
use crate::{Account, Device}; use crate::{Account, ReadOnlyDevice};
const KEY_AGREEMENT_PROTOCOLS: &[KeyAgreementProtocol] = const KEY_AGREEMENT_PROTOCOLS: &[KeyAgreementProtocol] =
&[KeyAgreementProtocol::Curve25519HkdfSha256]; &[KeyAgreementProtocol::Curve25519HkdfSha256];
@ -206,7 +206,7 @@ pub struct Confirmed {
pub struct MacReceived { pub struct MacReceived {
we_started: bool, we_started: bool,
their_pubkey: String, their_pubkey: String,
verified_devices: Arc<Vec<Device>>, verified_devices: Arc<Vec<ReadOnlyDevice>>,
verified_master_keys: Arc<Vec<String>>, verified_master_keys: Arc<Vec<String>>,
} }
@ -216,7 +216,7 @@ pub struct MacReceived {
/// the master keys in the verified devices list. /// the master keys in the verified devices list.
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct Done { pub struct Done {
verified_devices: Arc<Vec<Device>>, verified_devices: Arc<Vec<ReadOnlyDevice>>,
verified_master_keys: Arc<Vec<String>>, verified_master_keys: Arc<Vec<String>>,
} }
@ -239,7 +239,7 @@ impl<S: Clone> SasState<S> {
} }
#[cfg(test)] #[cfg(test)]
pub fn other_device(&self) -> Device { pub fn other_device(&self) -> ReadOnlyDevice {
self.ids.other_device.clone() self.ids.other_device.clone()
} }
@ -286,7 +286,7 @@ impl SasState<Created> {
/// * `account` - Our own account. /// * `account` - Our own account.
/// ///
/// * `other_device` - The other device which we are going to verify. /// * `other_device` - The other device which we are going to verify.
pub fn new(account: Account, other_device: Device) -> SasState<Created> { pub fn new(account: Account, other_device: ReadOnlyDevice) -> SasState<Created> {
let verification_flow_id = Uuid::new_v4().to_string(); let verification_flow_id = Uuid::new_v4().to_string();
SasState { SasState {
@ -380,7 +380,7 @@ impl SasState<Started> {
/// the other side. /// the other side.
pub fn from_start_event( pub fn from_start_event(
account: Account, account: Account,
other_device: Device, other_device: ReadOnlyDevice,
event: &ToDeviceEvent<StartEventContent>, event: &ToDeviceEvent<StartEventContent>,
) -> Result<SasState<Started>, SasState<Canceled>> { ) -> Result<SasState<Started>, SasState<Canceled>> {
if let StartMethod::MSasV1(content) = &event.content.method { if let StartMethod::MSasV1(content) = &event.content.method {
@ -780,7 +780,7 @@ impl SasState<Done> {
} }
/// Get the list of verified devices. /// Get the list of verified devices.
pub fn verified_devices(&self) -> Arc<Vec<Device>> { pub fn verified_devices(&self) -> Arc<Vec<ReadOnlyDevice>> {
self.state.verified_devices.clone() self.state.verified_devices.clone()
} }
} }
@ -827,7 +827,7 @@ impl SasState<Canceled> {
mod test { mod test {
use std::convert::TryFrom; use std::convert::TryFrom;
use crate::{Account, Device}; use crate::{Account, ReadOnlyDevice};
use matrix_sdk_common::{ use matrix_sdk_common::{
events::{ events::{
key::verification::{ key::verification::{
@ -866,10 +866,10 @@ mod test {
async fn get_sas_pair() -> (SasState<Created>, SasState<Started>) { async fn get_sas_pair() -> (SasState<Created>, SasState<Started>) {
let alice = Account::new(&alice_id(), &alice_device_id()); let alice = Account::new(&alice_id(), &alice_device_id());
let alice_device = Device::from_account(&alice).await; let alice_device = ReadOnlyDevice::from_account(&alice).await;
let bob = Account::new(&bob_id(), &bob_device_id()); let bob = Account::new(&bob_id(), &bob_device_id());
let bob_device = Device::from_account(&bob).await; let bob_device = ReadOnlyDevice::from_account(&bob).await;
let alice_sas = SasState::<Created>::new(alice.clone(), bob_device); let alice_sas = SasState::<Created>::new(alice.clone(), bob_device);
@ -1022,10 +1022,10 @@ mod test {
#[tokio::test] #[tokio::test]
async fn sas_from_start_unknown_method() { async fn sas_from_start_unknown_method() {
let alice = Account::new(&alice_id(), &alice_device_id()); let alice = Account::new(&alice_id(), &alice_device_id());
let alice_device = Device::from_account(&alice).await; let alice_device = ReadOnlyDevice::from_account(&alice).await;
let bob = Account::new(&bob_id(), &bob_device_id()); let bob = Account::new(&bob_id(), &bob_device_id());
let bob_device = Device::from_account(&bob).await; let bob_device = ReadOnlyDevice::from_account(&bob).await;
let alice_sas = SasState::<Created>::new(alice.clone(), bob_device); let alice_sas = SasState::<Created>::new(alice.clone(), bob_device);