Enum UtdCause

pub enum UtdCause {
    Unknown = 0,
    SentBeforeWeJoined = 1,
    VerificationViolation = 2,
    UnsignedDevice = 3,
    UnknownDevice = 4,
    HistoricalMessageAndBackupIsDisabled = 5,
    WithheldForUnverifiedOrInsecureDevice = 6,
    WithheldBySender = 7,
    HistoricalMessageAndDeviceIsUnverified = 8,
}

Our best guess at the reason why an event can’t be decrypted.

Variants

Unknown = 0

We don’t have an explanation for why this UTD happened - it is probably a bug, or a network split between the two homeservers.

For example:

• the keys for this event are missing, but a key storage backup exists and is working, so we should be able to find the keys in the backup.

• the keys for this event are missing, and a key storage backup exists on the server, but that backup is not working on this client even though this device is verified.

SentBeforeWeJoined = 1

We are missing the keys for this event, and the event was sent when we were not a member of the room (or invited).

VerificationViolation = 2

The message was sent by a user identity we have not verified, but the user was previously verified.

UnsignedDevice = 3

The crate::TrustRequirement requires that the sending device be signed by its owner, and it was not.

UnknownDevice = 4

The crate::TrustRequirement requires that the sending device be signed by its owner, and we were unable to securely find the device.

This could be because the device has since been deleted, because we haven’t yet downloaded it from the server, or because the session data was obtained from an insecure source (imported from a file, obtained from a legacy (asymmetric) backup, unsafe key forward, etc.)

HistoricalMessageAndBackupIsDisabled = 5

We are missing the keys for this event, but it is a “device-historical” message and there is no key storage backup on the server, presumably because the user has turned it off.

Device-historical means that the message was sent before the current device existed (but the current user was probably a member of the room at the time the message was sent). Not to be confused with pre-join or pre-invite messages (see UtdCause::SentBeforeWeJoined for that).

Expected message to user: “History is not available on this device”.

WithheldForUnverifiedOrInsecureDevice = 6

The keys for this event are intentionally withheld.

The sender has refused to share the key because our device does not meet the sender’s security requirements.

WithheldBySender = 7

The keys for this event are missing, likely because the sender was unable to share them (e.g., failure to establish an Olm 1:1 channel). Alternatively, the sender may have deliberately excluded this device by cherry-picking and blocking it, in which case, no action can be taken on our side.

HistoricalMessageAndDeviceIsUnverified = 8

We are missing the keys for this event, but it is a “device-historical” message, and even though a key storage backup does exist, we can’t use it because our device is unverified.

Device-historical means that the message was sent before the current device existed (but the current user was probably a member of the room at the time the message was sent). Not to be confused with pre-join or pre-invite messages (see UtdCause::SentBeforeWeJoined for that).

Expected message to user: “You need to verify this device”.

Implementations

impl UtdCause

pub fn determine( raw_event: &Raw<AnySyncTimelineEvent>, crypto_context_info: CryptoContextInfo, unable_to_decrypt_info: &UnableToDecryptInfo, ) -> Self

Decide the cause of this UTD, based on the evidence we have.

Trait Implementations

impl Clone for UtdCause

fn clone(&self) -> UtdCause

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UtdCause

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

Formats the value using the given formatter.

impl Default for UtdCause

fn default() -> UtdCause

Returns the “default value” for a type.

impl Hash for UtdCause

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for UtdCause

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for UtdCause

impl Eq for UtdCause

impl StructuralPartialEq for UtdCause