Struct matrix_sdk::encryption::verification::SasVerification

pub struct SasVerification { /* private fields */ }

An object controlling the short auth string verification flow.

Implementations

impl SasVerification

pub async fn accept(&self) -> Result<()>

Accept the interactive verification flow.

pub async fn accept_with_settings(&self, settings: AcceptSettings) -> Result<()>

Accept the interactive verification flow with specific settings.

Arguments

• settings - specific customizations to the verification flow.

Examples

use matrix_sdk::{
    encryption::verification::{AcceptSettings, SasVerification},
    ruma::events::key::verification::ShortAuthenticationString,
};

let sas = client
    .encryption()
    .get_verification(&user_id, flow_id)
    .await
    .and_then(|v| v.sas());

if let Some(sas) = sas {
    let only_decimal = AcceptSettings::with_allowed_methods(vec![
        ShortAuthenticationString::Decimal,
    ]);

    sas.accept_with_settings(only_decimal).await?;
}

pub async fn confirm(&self) -> Result<()>

Confirm that the short auth strings match on both sides.

pub async fn mismatch(&self) -> Result<()>

Cancel the interactive verification flow because the short auth strings didn’t match on both sides.

pub async fn cancel(&self) -> Result<()>

Cancel the interactive verification flow.

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

Get the emoji version of the short auth string.

Examples

use matrix_sdk::{
    encryption::verification::{AcceptSettings, SasVerification},
    ruma::events::key::verification::ShortAuthenticationString,
};

let sas_verification = client
    .encryption()
    .get_verification(&user_id, flow_id)
    .await
    .and_then(|v| v.sas());

if let Some(emojis) = sas_verification.and_then(|s| s.emoji()) {
    let emoji_string = emojis
        .iter()
        .map(|e| format!("{:^12}", e.symbol))
        .collect::<Vec<_>>()
        .join("");

    let description = emojis
        .iter()
        .map(|e| format!("{:^12}", e.description))
        .collect::<Vec<_>>()
        .join("");

    println!("Do the emojis match?\n{emoji_string}\n{description}");
}

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

Get the decimal version of the short auth string.

pub fn supports_emoji(&self) -> bool

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

pub fn is_done(&self) -> bool

Is the verification process done.

pub fn can_be_presented(&self) -> bool

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

pub fn we_started(&self) -> bool

Did we initiate the verification flow.

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

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

pub fn is_cancelled(&self) -> bool

Is the verification process canceled.

pub fn other_device(&self) -> &DeviceData

Get the other users device that we’re verifying.

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 own_user_id(&self) -> &UserId

Get our own user id.

pub fn other_user_id(&self) -> &UserId

Get the user id of the other user participating in this verification flow.

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::encryption::verification::{SasState, SasVerification};

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.
            if user_confirmed {
                sas.confirm().await?;
            } else {
                sas.cancel().await?;
            }
        }
        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 the verification process is in.

To listen to changes to the SasState use the SasVerification::changes method.

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

Get the room ID, if the verification is happening inside a room.

Trait Implementations

impl Clone for SasVerification

fn clone(&self) -> SasVerification

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SasVerification

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

Formats the value using the given formatter.

impl From<SasVerification> for Verification

fn from(sas: SasVerification) -> Self

Converts to this type from the input type.