Struct matrix_sdk_crypto::Sas

pub struct Sas { /* private fields */ }

Short authentication string object.

Implementations

impl Sas

pub fn user_id(&self) -> &UserId

Get our own user id.

pub fn device_id(&self) -> &DeviceId

Get our own device ID.

pub fn other_user_id(&self) -> &UserId

Get the user id of the other side.

pub fn other_device_id(&self) -> &DeviceId

Get the device ID of the other side.

pub fn other_device(&self) -> &DeviceData

Get the device of the other user.

pub fn flow_id(&self) -> &FlowId

Get the unique ID that identifies this SAS verification flow.

pub fn room_id(&self) -> Option<&RoomId>

Get the room id if the verification is happening inside a room.

pub fn supports_emoji(&self) -> bool

Does this verification flow support displaying emoji for the short authentication string.

pub fn started_from_request(&self) -> bool

Did this verification flow start from a verification request.

pub fn is_self_verification(&self) -> bool

Is this a verification that is verifying one of our own devices.

pub fn have_we_confirmed(&self) -> bool

Have we confirmed that the short auth string matches.

pub fn has_been_accepted(&self) -> bool

Has the verification been accepted by both parties.

pub fn cancel_info(&self) -> Option<CancelInfo>

Get info about the cancellation if the verification flow has been cancelled.

pub fn we_started(&self) -> bool

Did we initiate the verification flow.

pub fn accept(&self) -> Option<OutgoingVerificationRequest>

Accept the SAS verification.

This does nothing if the verification was already accepted, otherwise it returns an AcceptEventContent that needs to be sent out.

pub fn accept_with_settings( &self, settings: AcceptSettings, ) -> Option<OutgoingVerificationRequest>

Accept the SAS verification customizing the accept method.

This does nothing if the verification was already accepted, otherwise it returns an AcceptEventContent that needs to be sent out.

Specify a function modifying the attributes of the accept request.

pub async fn confirm( &self, ) -> Result<(Vec<OutgoingVerificationRequest>, Option<SignatureUploadRequest>), CryptoStoreError>

Confirm the Sas verification.

This confirms that the short auth strings match on both sides.

Does nothing if we’re not in a state where we can confirm the short auth string, otherwise returns a MacEventContent that needs to be sent to the server.

pub fn cancel(&self) -> Option<OutgoingVerificationRequest>

Cancel the verification.

This cancels the verification with the CancelCode::User.

Returns None if the Sas object is already in a canceled state, otherwise it returns a request that needs to be sent out.

pub fn cancel_with_code( &self, code: CancelCode, ) -> Option<OutgoingVerificationRequest>

Cancel the verification.

This cancels the verification with given CancelCode.

Note: This method should generally not be used, the cancel() method should be preferred. The SDK will automatically cancel with the appropriate cancel code, user initiated cancellations should only cancel with the CancelCode::User

Returns None if the Sas object is already in a canceled state, otherwise it returns a request that needs to be sent out.

pub fn timed_out(&self) -> bool

Has the SAS verification flow timed out.

pub fn can_be_presented(&self) -> bool

Are we in a state where we can show the short auth string.

pub fn is_done(&self) -> bool

Is the SAS flow done.

pub fn is_cancelled(&self) -> bool

Is the SAS flow canceled.

pub fn emoji(&self) -> Option<[Emoji; 7]>

Get the emoji version of the short auth string.

Returns None if we can’t yet present the short auth string, otherwise seven tuples containing the emoji and description.

pub fn emoji_index(&self) -> Option<[u8; 7]>

Get the index of the emoji representing the short auth string

Returns None if we can’t yet present the short auth string, otherwise seven u8 numbers in the range from 0 to 63 inclusive which can be converted to an emoji using the relevant spec entry.

pub fn decimals(&self) -> Option<(u16, u16, u16)>

Get the decimal version of the short auth string.

Returns None if we can’t yet present the short auth string, otherwise a tuple containing three 4-digit integers that represent the short auth string.

pub fn changes(&self) -> impl Stream<Item = SasState>

Listen for changes in the SAS verification process.

The changes are presented as a stream of SasState values.

This method can be used to react to changes in the state of the verification process, or rather the method can be used to handle each step of the verification process.

Flowchart

The flow of the verification process is pictured bellow. Please note that the process can be cancelled at each step of the process. Either side can cancel the process.

               ┌───────┐
               │Created│
               └───┬───┘
                   │
               ┌───⌄───┐
               │Started│
               └───┬───┘
                   │
              ┌────⌄───┐
              │Accepted│
              └────┬───┘
                   │
           ┌───────⌄──────┐
           │Keys Exchanged│
           └───────┬──────┘
                   │
           ________⌄________
          ╱                 ╲       ┌─────────┐
         ╱   Does the short  ╲______│Cancelled│
         ╲ auth string match ╱ no   └─────────┘
          ╲_________________╱
                   │yes
                   │
              ┌────⌄────┐
              │Confirmed│
              └────┬────┘
                   │
               ┌───⌄───┐
               │  Done │
               └───────┘

Examples

use futures_util::{Stream, StreamExt};
use matrix_sdk_crypto::{Sas, SasState};

let mut stream = sas.changes();

while let Some(state) = stream.next().await {
    match state {
        SasState::KeysExchanged { emojis, decimals: _ } => {
            let emojis =
                emojis.expect("We only support emoji verification");
            println!("Do these emojis match {emojis:#?}");

            // Ask the user to confirm or cancel here.
        }
        SasState::Done { .. } => {
            let device = sas.other_device();

            println!(
                "Successfully verified device {} {} {:?}",
                device.user_id(),
                device.device_id(),
                device.local_trust_state()
            );

            break;
        }
        SasState::Cancelled(cancel_info) => {
            println!(
                "The verification has been cancelled, reason: {}",
                cancel_info.reason()
            );
            break;
        }
        SasState::Created { .. }
        | SasState::Started { .. }
        | SasState::Accepted { .. }
        | SasState::Confirmed => (),
    }
}

pub fn state(&self) -> SasState

Get the current state of the verification process.

Trait Implementations

impl Clone for Sas

fn clone(&self) -> Sas

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Sas

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

Formats the value using the given formatter.

impl From<Sas> for Verification

fn from(sas: Sas) -> Self

Converts to this type from the input type.