Struct matrix_sdk::encryption::verification::SasVerification

source ·

pub struct SasVerification { /* private fields */ }

Available on crate feature e2e-encryption only.

Expand description

An object controlling the short auth string verification flow.

Implementations§

source §

impl SasVerification

source

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

Accept the interactive verification flow.

source

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?;
}

source

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

Confirm that the short auth strings match on both sides.

source

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

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

source

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

Cancel the interactive verification flow.

source

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}");
}

source

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

Get the decimal version of the short auth string.

source

pub fn supports_emoji(&self) -> bool

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

source

pub fn is_done(&self) -> bool

Is the verification process done.

source

pub fn can_be_presented(&self) -> bool

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

source

pub fn we_started(&self) -> bool

Did we initiate the verification flow.

source

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

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

source

pub fn is_cancelled(&self) -> bool

Is the verification process canceled.

source

pub fn other_device(&self) -> &ReadOnlyDevice

Get the other users device that we’re verifying.

source

pub fn started_from_request(&self) -> bool

Did this verification flow start from a verification request.

source

pub fn is_self_verification(&self) -> bool

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

source

pub fn own_user_id(&self) -> &UserId

Get our own user id.

source

pub fn other_user_id(&self) -> &UserId

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

source

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.

               ┌───────┐
               │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::Started { .. }
        | SasState::Accepted { .. }
        | SasState::Confirmed => (),
    }
}