matrix-rust-sdk

//! Uniffi based bindings for the `matrix-sdk-crypto` crate.

//!

//! This crate can be used to introduce E2EE support into an existing Matrix

//! client or client library in any of the language targets Uniffi supports.

#![warn(missing_docs)]

#![allow(unused_qualifications)]

mod backup_recovery_key;

mod dehydrated_devices;

mod device;

mod error;

mod logger;

mod machine;

mod responses;

mod users;

mod verification;

use std::{

    collections::{BTreeMap, HashMap},

    sync::Arc,

    time::Duration,

};

use anyhow::Context as _;

pub use backup_recovery_key::{

    BackupRecoveryKey, DecodeError, MegolmV1BackupKey, PassphraseInfo, PkDecryptionError,

};

pub use device::Device;

pub use error::{

    CryptoStoreError, DecryptionError, KeyImportError, SecretImportError, SignatureError,

};

use js_int::UInt;

pub use logger::{Logger, set_logger};

pub use machine::{KeyRequestPair, OlmMachine, SignatureVerification};

use matrix_sdk_common::deserialized_responses::{ShieldState as RustShieldState, ShieldStateCode};

use matrix_sdk_crypto::{

    CollectStrategy, EncryptionSettings as RustEncryptionSettings,

    olm::{IdentityKeys, InboundGroupSession, SenderData, Session},

    store::{

        CryptoStore,

        types::{

            Changes, DehydratedDeviceKey as InnerDehydratedDeviceKey, PendingChanges,

            RoomSettings as RustRoomSettings,

        },

    },

    types::{

        DeviceKey, DeviceKeys, EventEncryptionAlgorithm as RustEventEncryptionAlgorithm, SigningKey,

    },

};

use matrix_sdk_sqlite::SqliteCryptoStore;

pub use responses::{

    BootstrapCrossSigningResult, DeviceLists, KeysImportResult, OutgoingVerificationRequest,

    Request, RequestType, SignatureUploadRequest, UploadSigningKeysRequest,

};

use ruma::{

    DeviceKeyAlgorithm, DeviceKeyId, MilliSecondsSinceUnixEpoch, OwnedDeviceId, OwnedUserId,

    RoomId, SecondsSinceUnixEpoch, UserId,

    events::room::history_visibility::HistoryVisibility as RustHistoryVisibility,

};

use serde::{Deserialize, Serialize};

use tokio::runtime::Runtime;

pub use users::UserIdentity;

pub use verification::{

    CancelInfo, ConfirmVerificationResult, QrCode, QrCodeListener, QrCodeState,

    RequestVerificationResult, Sas, SasListener, SasState, ScanResult, StartSasResult,

    Verification, VerificationRequest, VerificationRequestListener, VerificationRequestState,

};

use vodozemac::{Curve25519PublicKey, Ed25519PublicKey};

use crate::dehydrated_devices::DehydrationError;

/// Struct collecting data that is important to migrate to the rust-sdk

#[derive(Deserialize, Serialize, uniffi::Record)]

pub struct MigrationData {

    /// The pickled version of the Olm Account

    account: PickledAccount,

    /// The list of pickleds Olm Sessions.

    sessions: Vec<PickledSession>,

    /// The list of Megolm inbound group sessions.

    inbound_group_sessions: Vec<PickledInboundGroupSession>,

    /// The Olm pickle key that was used to pickle all the Olm objects.

    pickle_key: Vec<u8>,

    /// The backup version that is currently active.

    backup_version: Option<String>,

    // The backup recovery key, as a base58 encoded string.

    backup_recovery_key: Option<String>,

    /// The private cross signing keys.

    cross_signing: CrossSigningKeyExport,

    /// The list of users that the Rust SDK should track.

    tracked_users: Vec<String>,

    /// Map of room settings

    room_settings: HashMap<String, RoomSettings>,

}

/// Struct collecting data that is important to migrate sessions to the rust-sdk

#[derive(uniffi::Record)]

pub struct SessionMigrationData {

    /// The user id that the data belongs to.

    user_id: String,

    /// The device id that the data belongs to.

    device_id: String,

    /// The Curve25519 public key of the Account that owns this data.

    curve25519_key: String,

    /// The Ed25519 public key of the Account that owns this data.

    ed25519_key: String,

    /// The list of pickleds Olm Sessions.

    sessions: Vec<PickledSession>,

    /// The list of pickled Megolm inbound group sessions.

    inbound_group_sessions: Vec<PickledInboundGroupSession>,

    /// The Olm pickle key that was used to pickle all the Olm objects.

    pickle_key: Vec<u8>,

}

/// A pickled version of an `Account`.

///

/// Holds all the information that needs to be stored in a database to restore

/// an account.

#[derive(Debug, Deserialize, Serialize, uniffi::Record)]

pub struct PickledAccount {

    /// The user id of the account owner.

    pub user_id: String,

    /// The device ID of the account owner.

    pub device_id: String,

    /// The pickled version of the Olm account.

    pub pickle: String,

    /// Was the account shared.

    pub shared: bool,

    /// The number of uploaded one-time keys we have on the server.

    pub uploaded_signed_key_count: i64,

}

/// A pickled version of a `Session`.

///

/// Holds all the information that needs to be stored in a database to restore

/// a Session.

#[derive(Debug, Deserialize, Serialize, uniffi::Record)]

pub struct PickledSession {

    /// The pickle string holding the Olm Session.

    pub pickle: String,

    /// The curve25519 key of the other user that we share this session with.

    pub sender_key: String,

    /// Was the session created using a fallback key.

    pub created_using_fallback_key: bool,

    /// Unix timestamp (in seconds) when the session was created.

    pub creation_time: u64,

    /// Unix timestamp (in seconds) when the session was last used.

    pub last_use_time: u64,

}

/// A pickled version of an `InboundGroupSession`.

///

/// Holds all the information that needs to be stored in a database to restore

/// an InboundGroupSession.

#[derive(Debug, Deserialize, Serialize, uniffi::Record)]

pub struct PickledInboundGroupSession {

    /// The pickle string holding the InboundGroupSession.

    pub pickle: String,

    /// The public curve25519 key of the account that sent us the session

    pub sender_key: String,

    /// The public ed25519 key of the account that sent us the session.

    pub signing_key: HashMap<String, String>,

    /// The id of the room that the session is used in.

    pub room_id: String,

    /// The list of claimed ed25519 that forwarded us this key. Will be empty if

    /// we directly received this session.

    pub forwarding_chains: Vec<String>,

    /// Flag remembering if the session was directly sent to us by the sender

    /// or if it was imported.

    pub imported: bool,

    /// Flag remembering if the session has been backed up.

    pub backed_up: bool,

}

/// Error type for the migration process.

#[derive(Debug, thiserror::Error, uniffi::Error)]

pub enum MigrationError {

    /// Generic catch all error variant.

    #[error("error migrating database: {error_message}")]

    Generic {

        /// The error message

        error_message: String,

    },

}

impl From<anyhow::Error> for MigrationError {

    fn from(e: anyhow::Error) -> MigrationError {

        MigrationError::Generic { error_message: e.to_string() }

    }

}

/// Migrate a libolm based setup to a vodozemac based setup stored in a SQLite

/// store.

///

/// # Arguments

///

/// * `data` - The data that should be migrated over to the SQLite store.

///

/// * `path` - The path where the SQLite store should be created.

///

/// * `passphrase` - The passphrase that should be used to encrypt the data at

///   rest in the SQLite store. **Warning**, if no passphrase is given, the

///   store and all its data will remain unencrypted.

///

/// * `progress_listener` - A callback that can be used to introspect the

///   progress of the migration.

#[matrix_sdk_ffi_macros::export]

pub fn migrate(

    data: MigrationData,

    path: String,

    passphrase: Option<String>,

    progress_listener: Box<dyn ProgressListener>,

) -> Result<(), MigrationError> {

    let runtime = Runtime::new().context("initializing tokio runtime")?;

    runtime.block_on(async move {

        migrate_data(data, &path, passphrase, progress_listener).await?;

        Ok(())

    })

}

async fn migrate_data(

    mut data: MigrationData,

    path: &str,

    passphrase: Option<String>,

    progress_listener: Box<dyn ProgressListener>,

) -> anyhow::Result<()> {

    use matrix_sdk_crypto::{olm::PrivateCrossSigningIdentity, store::types::BackupDecryptionKey};

    use vodozemac::olm::Account;

    use zeroize::Zeroize;

    // The total steps here include all the sessions/inbound group sessions and

    // additionally some static number of steps:

    //

    // 1. opening the store

    // 2. the Account

    // 3. the cross signing keys

    // 4. the tracked users

    // 5. the final save operation

    let total_steps = 5 + data.sessions.len() + data.inbound_group_sessions.len();

    let mut processed_steps = 0;

    let listener = |progress: usize, total: usize| {

        progress_listener.on_progress(progress as i32, total as i32)

    };

    let store = SqliteCryptoStore::open(path, passphrase.as_deref()).await?;

    processed_steps += 1;

    listener(processed_steps, total_steps);

    let user_id = parse_user_id(&data.account.user_id)?;

    let device_id: OwnedDeviceId = data.account.device_id.into();

    let account = Account::from_libolm_pickle(&data.account.pickle, &data.pickle_key)?;

    let pickle = account.pickle();

    let identity_keys = Arc::new(account.identity_keys());

    let pickled_account = matrix_sdk_crypto::olm::PickledAccount {

        user_id: parse_user_id(&data.account.user_id)?,

        device_id: device_id.clone(),

        pickle,

        dehydrated: false, // dehydrated devices are never involved in migration

        shared: data.account.shared,

        uploaded_signed_key_count: data.account.uploaded_signed_key_count as u64,

        creation_local_time: MilliSecondsSinceUnixEpoch::now(),

        fallback_key_creation_timestamp: Some(MilliSecondsSinceUnixEpoch::now()),

    };

    let account = matrix_sdk_crypto::olm::Account::from_pickle(pickled_account)?;

    processed_steps += 1;

    listener(processed_steps, total_steps);

    let (sessions, inbound_group_sessions) = collect_sessions(

        processed_steps,

        total_steps,

        &listener,

        &data.pickle_key,

        user_id.clone(),

        device_id,

        identity_keys,

        data.sessions,

        data.inbound_group_sessions,

    )?;

    let backup_decryption_key = data

        .backup_recovery_key

        .map(|k| BackupDecryptionKey::from_base58(k.as_str()))

        .transpose()?;

    let cross_signing = PrivateCrossSigningIdentity::empty((*user_id).into());

    cross_signing

        .import_secrets_unchecked(

            data.cross_signing.master_key.as_deref(),

            data.cross_signing.self_signing_key.as_deref(),

            data.cross_signing.user_signing_key.as_deref(),

        )

        .await?;

    data.cross_signing.master_key.zeroize();

    data.cross_signing.self_signing_key.zeroize();

    data.cross_signing.user_signing_key.zeroize();

    processed_steps += 1;

    listener(processed_steps, total_steps);

    let tracked_users: Vec<_> = data

        .tracked_users

        .into_iter()

        .filter_map(|s| parse_user_id(&s).ok().map(|u| (u, true)))

        .collect();

    let tracked_users: Vec<_> = tracked_users.iter().map(|(u, d)| (&**u, *d)).collect();

    store.save_tracked_users(tracked_users.as_slice()).await?;

    processed_steps += 1;

    listener(processed_steps, total_steps);

    let mut room_settings = HashMap::new();

    for (room_id, settings) in data.room_settings {

        let room_id = RoomId::parse(room_id)?;

        room_settings.insert(room_id, settings.into());

    }

    store.save_pending_changes(PendingChanges { account: Some(account) }).await?;

    let changes = Changes {

        private_identity: Some(cross_signing),

        sessions,

        inbound_group_sessions,

        backup_decryption_key,

        backup_version: data.backup_version,

        room_settings,

        ..Default::default()

    };

    save_changes(processed_steps, total_steps, &listener, changes, &store).await

}

async fn save_changes(

    mut processed_steps: usize,

    total_steps: usize,

    listener: &dyn Fn(usize, usize),

    changes: Changes,

    store: &SqliteCryptoStore,

) -> anyhow::Result<()> {

    store.save_changes(changes).await?;

    processed_steps += 1;

    listener(processed_steps, total_steps);

    Ok(())

}

/// Migrate sessions and group sessions of a libolm based setup to a vodozemac

/// based setup stored in a SQLite store.

///

/// This method allows you to migrate a subset of the data, it should only be

/// used after the [`migrate()`] method has been already used.

///

/// # Arguments

///

/// * `data` - The data that should be migrated over to the SQLite store.

///

/// * `path` - The path where the SQLite store should be created.

///

/// * `passphrase` - The passphrase that should be used to encrypt the data at

///   rest in the SQLite store. **Warning**, if no passphrase is given, the

///   store and all its data will remain unencrypted.

///

/// * `progress_listener` - A callback that can be used to introspect the

///   progress of the migration.

#[matrix_sdk_ffi_macros::export]

pub fn migrate_sessions(

    data: SessionMigrationData,

    path: String,

    passphrase: Option<String>,

    progress_listener: Box<dyn ProgressListener>,

) -> Result<(), MigrationError> {

    let runtime = Runtime::new().context("initializing tokio runtime")?;

    runtime.block_on(migrate_session_data(data, &path, passphrase, progress_listener))?;

    Ok(())

}

async fn migrate_session_data(

    data: SessionMigrationData,

    path: &str,

    passphrase: Option<String>,

    progress_listener: Box<dyn ProgressListener>,

) -> anyhow::Result<()> {

    let store = SqliteCryptoStore::open(path, passphrase.as_deref()).await?;

    let listener = |progress: usize, total: usize| {

        progress_listener.on_progress(progress as i32, total as i32)

    };

    let total_steps = 1 + data.sessions.len() + data.inbound_group_sessions.len();

    let processed_steps = 0;

    let user_id = UserId::parse(data.user_id)?;

    let device_id: OwnedDeviceId = data.device_id.into();

    let identity_keys = IdentityKeys {

        ed25519: Ed25519PublicKey::from_base64(&data.ed25519_key)?,

        curve25519: Curve25519PublicKey::from_base64(&data.curve25519_key)?,

    }

    .into();

    let (sessions, inbound_group_sessions) = collect_sessions(

        processed_steps,

        total_steps,

        &listener,

        &data.pickle_key,

        user_id,

        device_id,

        identity_keys,

        data.sessions,

        data.inbound_group_sessions,

    )?;

    let changes = Changes { sessions, inbound_group_sessions, ..Default::default() };

    save_changes(processed_steps, total_steps, &listener, changes, &store).await

}

#[allow(clippy::too_many_arguments)]

fn collect_sessions(

    mut processed_steps: usize,

    total_steps: usize,

    listener: &dyn Fn(usize, usize),

    pickle_key: &[u8],

    user_id: OwnedUserId,

    device_id: OwnedDeviceId,

    identity_keys: Arc<IdentityKeys>,

    session_pickles: Vec<PickledSession>,

    group_session_pickles: Vec<PickledInboundGroupSession>,

) -> anyhow::Result<(Vec<Session>, Vec<InboundGroupSession>)> {

    let mut sessions = Vec::new();

    // Create a DeviceKeys struct with enough information to get a working

    // Session, but we will won't actually use the Sessions (and we'll clear

    // the session cache after migration) so we don't need to worry about

    // signatures.

    let device_keys = DeviceKeys::new(

        user_id,

        device_id.clone(),

        Default::default(),

        BTreeMap::from([

            (

                DeviceKeyId::from_parts(DeviceKeyAlgorithm::Ed25519, &device_id),

                DeviceKey::Ed25519(identity_keys.ed25519),

            ),

            (

                DeviceKeyId::from_parts(DeviceKeyAlgorithm::Curve25519, &device_id),

                DeviceKey::Curve25519(identity_keys.curve25519),

            ),

        ]),

        Default::default(),

    );

    for session_pickle in session_pickles {

        let pickle =

            vodozemac::olm::Session::from_libolm_pickle(&session_pickle.pickle, pickle_key)?

                .pickle();

        let creation_time = SecondsSinceUnixEpoch(

            UInt::new(session_pickle.creation_time).context("invalid creation timestamp")?,

        );

        let last_use_time = SecondsSinceUnixEpoch(

            UInt::new(session_pickle.last_use_time).context("invalid last use timestamp")?,

        );

        let pickle = matrix_sdk_crypto::olm::PickledSession {

            pickle,

            sender_key: Curve25519PublicKey::from_base64(&session_pickle.sender_key)?,

            created_using_fallback_key: session_pickle.created_using_fallback_key,

            creation_time,

            last_use_time,

        };

        let session = Session::from_pickle(device_keys.clone(), pickle)?;

        sessions.push(session);

        processed_steps += 1;

        listener(processed_steps, total_steps);

    }

    let mut inbound_group_sessions = Vec::new();

    for session in group_session_pickles {

        let pickle = vodozemac::megolm::InboundGroupSession::from_libolm_pickle(

            &session.pickle,

            pickle_key,

        )?

        .pickle();

        let sender_key = Curve25519PublicKey::from_base64(&session.sender_key)?;

        let pickle = matrix_sdk_crypto::olm::PickledInboundGroupSession {

            pickle,

            sender_key,

            signing_key: session

                .signing_key

                .into_iter()

                .map(|(k, v)| {

                    let algorithm = DeviceKeyAlgorithm::from(k);

                    let key = SigningKey::from_parts(&algorithm, v)?;

                    Ok((algorithm, key))

                })

                .collect::<anyhow::Result<_>>()?,

            sender_data: SenderData::legacy(),

            forwarder_data: None,

            room_id: RoomId::parse(session.room_id)?,

            imported: session.imported,

            backed_up: session.backed_up,