Struct matrix_sdk_crypto::OtherUserIdentityData

pub struct OtherUserIdentityData { /* private fields */ }

Struct representing a cross signing identity of a user.

This is the user identity of a user that isn’t our own. Other users will only contain a master key and a self signing key, meaning that only device signatures can be checked with this identity.

This struct also contains the currently pinned user identity (public master key) for that user and a local flag that serves as a latch to remember if an identity was verified once.

The first time a cryptographic user identity is seen for a given user, it will be associated with that user (“pinned”). Future interactions will expect this identity to stay the same, to avoid MITM attacks from the homeserver.

The user can explicitly pin the new identity to allow for legitimate identity changes (for example, in case of key material or device loss).

As soon as the cryptographic identity is verified (i.e. signed by our own trusted identity), a flag is set to remember it (previously_verified). Future interactions will expect this user to stay verified, in case of violation the user should be notified with a blocking warning when sending a message.

Implementations

impl OtherUserIdentityData

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 was_previously_verified(&self) -> bool

True if we verified this identity (with any own identity, at any point).

To pass this latch back to false, one must call OtherUserIdentityData::withdraw_verification().

pub fn withdraw_verification(&self)

Remove the requirement for this identity to be verified.

If an identity was previously verified and is not anymore it will be reported to the user. In order to remove this notice users have to verify again or to withdraw the verification requirement.

Trait Implementations

impl Clone for OtherUserIdentityData

fn clone(&self) -> OtherUserIdentityData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for OtherUserIdentityData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OtherUserIdentityData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<OtherUserIdentityData> for UserIdentityData

fn from(identity: OtherUserIdentityData) -> Self

Converts to this type from the input type.

impl PartialEq for OtherUserIdentityData

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

The PartialEq implementation compares several attributes, including the user ID, key material, usage, and, notably, the signatures of the master key.

This approach contrasts with the PartialEq implementation of the MasterPubkey, and SelfSigningPubkey types, where the signatures are disregarded. This distinction arises from our treatment of identity as the combined representation of cross-signing keys and the associated verification state.

The verification state of an identity depends on the signatures of the master key, requiring their inclusion in our PartialEq implementation.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OtherUserIdentityData

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

where __S: Serializer,

Serialize this value into the given Serde serializer.