Struct matrix_sdk_crypto::ReadOnlyAccount

pub struct ReadOnlyAccount {
    pub user_id: Arc<UserId>,
    pub device_id: Arc<DeviceId>,
    pub identity_keys: Arc<IdentityKeys>,
    /* private fields */
}

Account holding identity keys for which sessions can be created.

An account is the central identity for encrypted communication between two devices.

Fields

user_id: Arc<UserId>

The user_id this account belongs to

device_id: Arc<DeviceId>

The device_id of this entry

identity_keys: Arc<IdentityKeys>

The associated identity keys

Implementations

impl ReadOnlyAccount

pub fn new(user_id: &UserId, device_id: &DeviceId) -> Self

Create a fresh new account, this will generate the identity key-pair.

pub fn user_id(&self) -> &UserId

Get the user id of the owner of the account.

pub fn device_id(&self) -> &DeviceId

Get the device id that owns this account.

pub fn identity_keys(&self) -> IdentityKeys

Get the public parts of the identity keys for the account.

pub fn update_uploaded_key_count(&self, new_count: u64)

Update the uploaded key count.

Arguments

• new_count - The new count that was reported by the server.

pub fn uploaded_key_count(&self) -> u64

Get the currently known uploaded key count.

pub fn shared(&self) -> bool

Has the account been shared with the server.

pub fn mark_as_shared(&self)

Mark the account as shared.

Messages shouldn’t be encrypted with the session before it has been shared.

pub async fn one_time_keys(&self) -> HashMap<KeyId, Curve25519PublicKey>

Get the one-time keys of the account.

This can be empty, keys need to be generated first.

pub async fn generate_one_time_keys_helper(&self, count: usize)

Generate count number of one-time keys.

pub async fn max_one_time_keys(&self) -> usize

Get the maximum number of one-time keys the account can hold.

pub async fn generate_one_time_keys(&self) -> Option<u64>

Generate new one-time keys that need to be uploaded to the server.

Returns None if no keys need to be uploaded, otherwise the number of newly generated one-time keys. May return 0 if some one-time keys are already generated but weren’t uploaded.

Generally Some means that keys should be uploaded, while None means that keys should not be uploaded.

pub async fn keys_for_upload(
    &self
) -> (Option<DeviceKeys>, BTreeMap<OwnedDeviceKeyId, Raw<OneTimeKey>>, BTreeMap<OwnedDeviceKeyId, Raw<OneTimeKey>>)

Get a tuple of device, one-time, and fallback keys that need to be uploaded.

If no keys need to be uploaded the DeviceKeys will be None and the one-time and fallback keys maps will be empty.

pub async fn mark_keys_as_published(&self)

Mark the current set of one-time keys as being published.

pub async fn sign(&self, string: &str) -> Ed25519Signature

Sign the given string using the accounts signing key.

Returns the signature as a base64 encoded string.

pub async fn pickle(&self) -> PickledAccount

Get a serializeable version of the Account so it can be persisted.

pub fn from_pickle(pickle: PickledAccount) -> Result<Self, PickleError>

Restore an account from a previously pickled one.

Arguments

• pickle - The pickled version of the Account.

• pickle_mode - The mode that was used to pickle the account, either an unencrypted mode or an encrypted using passphrase.

pub fn unsigned_device_keys(&self) -> DeviceKeys

Generate the unsigned DeviceKeys from this ReadOnlyAccount

pub async fn device_keys(&self) -> DeviceKeys

Sign the device keys of the account and return them so they can be uploaded.

pub async fn bootstrap_cross_signing(
    &self
) -> (PrivateCrossSigningIdentity, UploadSigningKeysRequest, SignatureUploadRequest)

Bootstrap Cross-Signing

pub async fn sign_cross_signing_key(
    &self,
    cross_signing_key: &mut CrossSigningKey
) -> Result<(), SignatureError>

Sign the given CrossSigning Key in place

pub async fn sign_master_key(
    &self,
    master_key: MasterPubkey
) -> Result<SignatureUploadRequest, SignatureError>

Sign the given Master Key

pub async fn sign_json(&self, json: Value) -> Ed25519Signature

Convert a JSON value to the canonical representation and sign the JSON string.

Arguments

• json - The value that should be converted into a canonical JSON string.

Panic

Panics if the json value can’t be serialized.

pub async fn signed_one_time_keys(
    &self
) -> BTreeMap<OwnedDeviceKeyId, Raw<OneTimeKey>>

Generate, sign and prepare one-time keys to be uploaded.

If no one-time keys need to be uploaded returns an empty BTreeMap.

pub async fn signed_fallback_keys(
    &self
) -> BTreeMap<OwnedDeviceKeyId, Raw<OneTimeKey>>

Sign and prepare fallback keys to be uploaded.

If no fallback keys need to be uploaded returns an empty BTreeMap.

pub async fn create_outbound_session_helper(
    &self,
    identity_key: Curve25519PublicKey,
    one_time_key: Curve25519PublicKey,
    fallback_used: bool
) -> Session

Create a new session with another account given a one-time key.

Returns the newly created session or a OlmSessionError if creating a session failed.

Arguments

• their_identity_key - The other account’s identity/curve25519 key.

• their_one_time_key - A signed one-time key that the other account created and shared with us.

pub async fn create_outbound_session(
    &self,
    device: ReadOnlyDevice,
    key_map: &BTreeMap<OwnedDeviceKeyId, Raw<OneTimeKey>>
) -> Result<Session, SessionCreationError>

Create a new session with another account given a one-time key and a device.

Returns the newly created session or a OlmSessionError if creating a session failed.

Arguments

• device - The other account’s device.

• key_map - A map from the algorithm and device id to the one-time key that the other account created and shared with us.

pub async fn create_inbound_session(
    &self,
    their_identity_key: &str,
    message: &PreKeyMessage
) -> Result<InboundCreationResult, SessionCreationError>

Create a new session with another account given a pre-key Olm message.

Returns the newly created session or a OlmSessionError if creating a session failed.

Arguments

• their_identity_key - The other account’s identity/curve25519 key.

• message - A pre-key Olm message that was sent to us by the other account.

pub async fn create_group_session_pair(
    &self,
    room_id: &RoomId,
    settings: EncryptionSettings
) -> Result<(OutboundGroupSession, InboundGroupSession), ()>

Create a group session pair.

This session pair can be used to encrypt and decrypt messages meant for a large group of participants.

The outbound session is used to encrypt messages while the inbound one is used to decrypt messages encrypted by the outbound one.

Arguments

• room_id - The ID of the room where the group session will be used.

• settings - Settings determining the algorithm and rotation period of the outbound group session.

Trait Implementations

impl Clone for ReadOnlyAccount

fn clone(&self) -> ReadOnlyAccount

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ReadOnlyAccount

Available on non-tarpaulin_include only.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<ReadOnlyAccount> for ReadOnlyAccount

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.