Struct matrix_sdk_crypto::olm::PrivateCrossSigningIdentity

pub struct PrivateCrossSigningIdentity { /* private fields */ }

Private cross signing identity.

This object holds the private and public ed25519 key triplet that is used for cross signing.

The object might be completely empty or have only some of the key pairs available.

It can be used to sign devices or other identities.

Implementations

impl PrivateCrossSigningIdentity

pub fn user_id(&self) -> &UserId

Get the user id that this identity belongs to.

pub async fn is_empty(&self) -> bool

Is the identity empty.

An empty identity doesn’t contain any private keys.

It is usual for the identity not to contain the master key since the master key is only needed to sign the subkeys.

An empty identity indicates that either no identity was created for this use or that another device created it and hasn’t shared it yet with us.

pub async fn can_sign_devices(&self) -> bool

Can we sign our own devices, i.e. do we have a self signing key.

pub async fn can_sign_users(&self) -> bool

Can we sign other users, i.e. do we have a user signing key.

pub async fn has_master_key(&self) -> bool

Do we have the master key.

pub async fn status(&self) -> CrossSigningStatus

Get the status of our private cross signing keys, i.e. if we have the master key and the subkeys.

pub async fn master_public_key(&self) -> Option<MasterPubkey>

Get the public part of the master key, if we have one.

pub async fn self_signing_public_key(&self) -> Option<SelfSigningPubkey>

Get the public part of the self-signing key, if we have one.

pub async fn user_signing_public_key(&self) -> Option<UserSigningPubkey>

Get the public part of the user-signing key, if we have one.

pub async fn export_secret(&self, secret_name: &SecretName) -> Option<String>

Export the seed of the private cross signing key

The exported seed will be encoded as unpadded base64.

Arguments

• secret_name - The type of the cross signing key that should be exported.

pub async fn import_secrets_unchecked(
    &self,
    master_key: Option<&str>,
    self_signing_key: Option<&str>,
    user_signing_key: Option<&str>
) -> Result<(), SecretImportError>

Import the private parts of the cross signing keys into this identity.

The private parts should be unexpanded Ed25519 keys encoded as a base64 string.

Note: This method won’t check if the public keys match the public keys present on the server.

pub fn empty(user_id: &UserId) -> Self

Create a new empty identity.

pub fn mark_as_shared(&self)

Mark the identity as shared.

pub fn shared(&self) -> bool

Has the identity been shared.

A shared identity here means that the public keys of the identity have been uploaded to the server.

pub async fn pickle(&self) -> Result<PickledCrossSigningIdentity, JsonError>

Store the cross signing identity as a pickle.

Arguments

• pickle_key - The key that should be used to encrypt the signing object, must be 32 bytes long.

Panics

This will panic if the provided pickle key isn’t 32 bytes long.

pub async fn from_pickle(
    pickle: PickledCrossSigningIdentity
) -> Result<Self, SigningError>

Restore the private cross signing identity from a pickle.

Panic

Panics if the pickle_key isn’t 32 bytes long.

Trait Implementations

impl Clone for PrivateCrossSigningIdentity

fn clone(&self) -> PrivateCrossSigningIdentity

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PrivateCrossSigningIdentity

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

Formats the value using the given formatter.