Struct matrix_sdk_crypto::OwnUserIdentity

pub struct OwnUserIdentity { /* fields omitted */ }

Struct representing a cross signing identity of our own user.

This is the user identity of our own user. This user identity will contain a master key, self signing key as well as a user signing key.

This identity can verify other identities as well as devices belonging to the identity.

Implementations

impl OwnUserIdentity

pub fn new(
    master_key: MasterPubkey,
    self_signing_key: SelfSigningPubkey,
    user_signing_key: UserSigningPubkey
) -> Result<Self, SignatureError>

Create a new own user identity with the given master, self signing, and user signing key.

Arguments

• master_key - The master key of the user identity.

• self_signing_key - The self signing key of user identity.

• user_signing_key - The user signing key of user identity.

Returns a SignatureError if the self signing key fails to be correctly verified by the given master key.

pub fn user_id(&self) -> &UserId

Get the user id of this identity.

pub fn master_key(&self) -> &MasterPubkey

Get the public master key of the identity.

pub fn self_signing_key(&self) -> &SelfSigningPubkey

Get the public self-signing key of the identity.

pub fn user_signing_key(&self) -> &UserSigningPubkey

Get the public user-signing key of the identity.

pub fn is_identity_signed(
    &self,
    identity: &UserIdentity
) -> Result<(), SignatureError>

Check if the given identity has been signed by this identity.

Arguments

• identity - The identity of another user that we want to check if it’s has been signed.

Returns an empty result if the signature check succeeded, otherwise a SignatureError indicating why the check failed.

pub fn is_device_signed(
    &self,
    device: &ReadOnlyDevice
) -> Result<(), SignatureError>

Check if the given device has been signed by this identity.

Only devices of our own user should be checked with this method, if a device of a different user is given the signature check will always fail even if a valid signature exists.

Arguments

• device - The device that should be checked for a valid signature.

Returns an empty result if the signature check succeeded, otherwise a SignatureError indicating why the check failed.

pub fn mark_as_verified(&self)

Mark our identity as verified.

pub fn is_verified(&self) -> bool

Check if our identity is verified.

pub fn update(
    &mut self,
    master_key: MasterPubkey,
    self_signing_key: SelfSigningPubkey,
    user_signing_key: UserSigningPubkey
) -> Result<(), SignatureError>

Update the identity with a new master key and self signing key.

Note: This will reset the verification state if the master keys differ.

Arguments

• master_key - The new master key of the user identity.

• self_signing_key - The new self signing key of user identity.

• user_signing_key - The new user signing key of user identity.

Returns a SignatureError if we failed to update the identity.

Trait Implementations

impl Clone for OwnUserIdentity

fn clone(&self) -> OwnUserIdentity

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OwnUserIdentity

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OwnUserIdentity

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<OwnUserIdentity> for UserIdentities

fn from(identity: OwnUserIdentity) -> Self

Performs the conversion.

impl Serialize for OwnUserIdentity

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.