matrix-rust-sdk

// Copyright 2025 The Matrix.org Foundation C.I.C.

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//     http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for that specific language governing permissions and

// limitations under the License.

use std::{str::FromStr, sync::Arc};

use futures_util::StreamExt;

use matrix_sdk::encryption::{self, backups, recovery};

use matrix_sdk_base::crypto::types::{BackupSecrets, RoomKeyBackupInfo};

use matrix_sdk_common::{SendOutsideWasm, SyncOutsideWasm};

use ruma::OwnedUserId;

use serde::de::Error;

use thiserror::Error;

use tracing::{error, info};

use zeroize::Zeroize;

use crate::{

    client::Client, error::ClientError, ruma::AuthData, runtime::get_runtime_handle,

    task_handle::TaskHandle,

};

#[derive(uniffi::Object)]

pub struct Encryption {

    pub(crate) inner: matrix_sdk::encryption::Encryption,

    /// A reference to the FFI client.

    ///

    /// Note: we do this to make it so that the FFI `NotificationClient` keeps

    /// the FFI `Client` and thus the SDK `Client` alive. Otherwise, we

    /// would need to repeat the hack done in the FFI `Client::drop` method.

    pub(crate) _client: Arc<Client>,

}

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait BackupStateListener: SyncOutsideWasm + SendOutsideWasm {

    fn on_update(&self, status: BackupState);

}

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait BackupSteadyStateListener: SyncOutsideWasm + SendOutsideWasm {

    fn on_update(&self, status: BackupUploadState);

}

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait RecoveryStateListener: SyncOutsideWasm + SendOutsideWasm {

    fn on_update(&self, status: RecoveryState);

}

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait VerificationStateListener: SyncOutsideWasm + SendOutsideWasm {

    fn on_update(&self, status: VerificationState);

}

#[derive(uniffi::Enum)]

pub enum BackupUploadState {

    Waiting,

    Uploading { backed_up_count: u32, total_count: u32 },

    Error,

    Done,

}

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

#[uniffi(flat_error)]

pub enum SteadyStateError {

    #[error("The backup got disabled while waiting for the room keys to be uploaded.")]

    BackupDisabled,

    #[error("There was a connection error.")]

    Connection,

    #[error("We couldn't read status updates from the upload task quickly enough.")]

    Lagged,

}

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

pub enum RecoveryError {

    /// A backup already exists on the homeserver, the recovery subsystem does

    /// not allow backups to be overwritten, disable recovery first.

    #[error(

        "A backup already exists on the homeserver and the method does not allow to overwrite it"

    )]

    BackupExistsOnServer,

    /// A typical SDK error.

    #[error(transparent)]

    Client { source: crate::ClientError },

    /// Error in the secret storage subsystem, except for when importing a

    /// secret.

    #[error("Error in the secret-storage subsystem: {error_message}")]

    SecretStorage { error_message: String },

    /// Error when importing a secret from secret storage.

    #[error("Error importing a secret: {error_message}")]

    Import { error_message: String },

}

impl From<matrix_sdk::encryption::recovery::RecoveryError> for RecoveryError {

    fn from(value: matrix_sdk::encryption::recovery::RecoveryError) -> Self {

        match value {

            recovery::RecoveryError::BackupExistsOnServer => Self::BackupExistsOnServer,

            recovery::RecoveryError::Sdk(e) => Self::Client { source: ClientError::from(e) },

            recovery::RecoveryError::SecretStorage(

                matrix_sdk::encryption::secret_storage::SecretStorageError::ImportError { .. },

            ) => Self::Import { error_message: value.to_string() },

            recovery::RecoveryError::SecretStorage(e) => {

                Self::SecretStorage { error_message: e.to_string() }

            }

        }

    }

}

pub type Result<A, E = RecoveryError> = std::result::Result<A, E>;

impl From<matrix_sdk::encryption::backups::futures::SteadyStateError> for SteadyStateError {

    fn from(value: matrix_sdk::encryption::backups::futures::SteadyStateError) -> Self {

        match value {

            backups::futures::SteadyStateError::BackupDisabled => Self::BackupDisabled,

            backups::futures::SteadyStateError::Connection => Self::Connection,

            backups::futures::SteadyStateError::Lagged => Self::Lagged,

        }

    }

}

#[derive(uniffi::Enum)]

pub enum BackupState {

    Unknown,

    Creating,

    Enabling,

    Resuming,

    Enabled,

    Downloading,

    Disabling,

}

impl From<backups::BackupState> for BackupState {

    fn from(value: backups::BackupState) -> Self {

        match value {

            backups::BackupState::Unknown => Self::Unknown,

            backups::BackupState::Creating => Self::Creating,

            backups::BackupState::Enabling => Self::Enabling,

            backups::BackupState::Resuming => Self::Resuming,

            backups::BackupState::Enabled => Self::Enabled,

            backups::BackupState::Downloading => Self::Downloading,

            backups::BackupState::Disabling => Self::Disabling,

        }

    }

}

impl From<backups::UploadState> for BackupUploadState {

    fn from(value: backups::UploadState) -> Self {

        match value {

            backups::UploadState::Idle => Self::Waiting,

            backups::UploadState::Uploading(count) => Self::Uploading {

                backed_up_count: count.backed_up.try_into().unwrap_or(u32::MAX),

                total_count: count.total.try_into().unwrap_or(u32::MAX),

            },

            backups::UploadState::Error => Self::Error,

            backups::UploadState::Done => Self::Done,

        }

    }

}

#[derive(uniffi::Enum)]

pub enum RecoveryState {

    Unknown,

    Enabled,

    Disabled,

    Incomplete,

}

impl From<recovery::RecoveryState> for RecoveryState {

    fn from(value: recovery::RecoveryState) -> Self {

        match value {

            recovery::RecoveryState::Unknown => Self::Unknown,

            recovery::RecoveryState::Enabled => Self::Enabled,

            recovery::RecoveryState::Disabled => Self::Disabled,

            recovery::RecoveryState::Incomplete => Self::Incomplete,

        }

    }

}

#[matrix_sdk_ffi_macros::export(callback_interface)]

pub trait EnableRecoveryProgressListener: SyncOutsideWasm + SendOutsideWasm {

    fn on_update(&self, status: EnableRecoveryProgress);

}

#[derive(uniffi::Enum)]

pub enum EnableRecoveryProgress {

    Starting,

    CreatingBackup,

    CreatingRecoveryKey,

    BackingUp { backed_up_count: u32, total_count: u32 },

    RoomKeyUploadError,

    Done { recovery_key: String },

}

impl From<recovery::EnableProgress> for EnableRecoveryProgress {

    fn from(value: recovery::EnableProgress) -> Self {

        match &value {

            recovery::EnableProgress::Starting => Self::Starting,

            recovery::EnableProgress::CreatingBackup => Self::CreatingBackup,

            recovery::EnableProgress::CreatingRecoveryKey => Self::CreatingRecoveryKey,

            recovery::EnableProgress::BackingUp(counts) => Self::BackingUp {

                backed_up_count: counts.backed_up.try_into().unwrap_or(u32::MAX),

                total_count: counts.backed_up.try_into().unwrap_or(u32::MAX),

            },

            recovery::EnableProgress::RoomKeyUploadError => Self::RoomKeyUploadError,

            recovery::EnableProgress::Done { recovery_key } => {

                Self::Done { recovery_key: recovery_key.to_owned() }

            }

        }

    }

}

#[derive(uniffi::Enum)]

pub enum VerificationState {

    Unknown,

    Verified,

    Unverified,

}

impl From<encryption::VerificationState> for VerificationState {

    fn from(value: encryption::VerificationState) -> Self {

        match &value {

            encryption::VerificationState::Unknown => Self::Unknown,

            encryption::VerificationState::Verified => Self::Verified,

            encryption::VerificationState::Unverified => Self::Unverified,

        }

    }

}

/// Struct containing the bundle of secrets to fully activate a new device for

/// end-to-end encryption.

#[derive(uniffi::Object)]

pub struct SecretsBundleWithUserId {

    user_id: OwnedUserId,

    inner: matrix_sdk_base::crypto::types::SecretsBundle,

}

/// Result for the check if a store has a valid secrets bundle.

#[derive(uniffi::Enum)]

pub enum DetectedSecretsBundle {

    /// The store doesn't contain a secrets bundle at all.

    None,

    /// The store contains a bundle without a backup.

    WithoutBackup,

    /// The store contains a bundle with an unused backup, the backup key in the

    /// bundle isn't used on the homeserver.

    UnusedBackup,

    /// The store contains a complete secrets bundle.

    Complete,

}

/// Error type describing failures that can happen while exporting a

/// [`SecretsBundle`] from a SQLite store.

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

pub enum BundleExportError {

    /// The SQLite store couldn't be opened.

    #[error("the store couldn't be opened: {msg}")]

    OpenStoreError { msg: String },

    /// Data from the SQLite store couldn't be exported.

    #[error("the bundle couldn't be exported due to a storage error: {msg}")]

    StoreError { msg: String },

    /// The store doesn't contain a secrets bundle or it couldn't be read from

    /// the store.

    #[error("the bundle couldn't be exported: {msg}")]

    SecretError { msg: String },

    /// The store is empty and doesn't contain a secrets bundle.

    #[error("the store is completely empty")]

    StoreEmpty,

    /// A JSON object couldn't be deserialized while the secrets bundle was

    /// exported.

    #[error("Couldn't deserialize a JSON value: {msg}")]

    Json { msg: String },

    /// Error returned when the secrets bundle is missing a backup key or

    /// includes one that doesn’t match the key configured for the active backup

    /// version.

    #[error(

        "The bundle is missing a backup key or has one that isn't the one that's currently used"

    )]

    InvalidBackup,

}

#[cfg(feature = "sqlite")]

impl From<matrix_sdk::encryption::BundleExportError> for BundleExportError {

    fn from(value: matrix_sdk::encryption::BundleExportError) -> Self {

        match value {

            matrix_sdk::encryption::BundleExportError::OpenStoreError(e) => {

                BundleExportError::OpenStoreError { msg: e.to_string() }

            }

            matrix_sdk::encryption::BundleExportError::StoreError(e) => {

                BundleExportError::StoreError { msg: e.to_string() }

            }

            matrix_sdk::encryption::BundleExportError::SecretExport(e) => {

                BundleExportError::SecretError { msg: e.to_string() }

            }

        }

    }

}

impl From<serde_json::Error> for BundleExportError {

    fn from(value: serde_json::Error) -> Self {

        Self::Json { msg: value.to_string() }

    }

}

#[cfg(feature = "sqlite")]

#[matrix_sdk_ffi_macros::export]

impl SecretsBundleWithUserId {

    /// Attempt to export a [`SecretsBundle`] from a crypto store.

    ///

    /// This method can be used to retrieve a [`SecretsBundle`] from an existing

    /// `matrix-sdk`-based client in order to import the [`SecretsBundle`] in

    /// another [`Client`] instance.

    ///

    /// This can be useful for migration purposes or to allow existing client

    /// instances create new ones that will be fully verified.

    #[uniffi::constructor]

    pub async fn from_database(

        database_path: &str,

        mut passphrase: Option<String>,

        backup_info: &str,

    ) -> Result<Arc<Self>, BundleExportError> {

        let backup_info = serde_json::from_str(backup_info)?;

        let ret = if let Some((user_id, bundle)) =

            matrix_sdk::encryption::export_secrets_bundle_from_store(

                database_path,

                passphrase.as_deref(),

            )

            .await?

        {

            let is_backup_ok =

                bundle.backup.as_ref().is_some_and(|backup| is_valid_backup(backup, &backup_info));

            if is_backup_ok {

                Ok(SecretsBundleWithUserId { user_id, inner: bundle }.into())

            } else {

                Err(BundleExportError::InvalidBackup)

            }

        } else {

            Err(BundleExportError::StoreEmpty)

        };

        passphrase.zeroize();

        ret

    }

}

#[matrix_sdk_ffi_macros::export]

impl SecretsBundleWithUserId {

    /// Attempt to create a [`SecretsBundle`] from a previously JSON serialized

    /// bundle.

    #[uniffi::constructor]

    pub fn from_str(

        user_id: &str,

        bundle: &str,

        backup_info: &str,

    ) -> Result<Arc<Self>, BundleExportError> {

        let user_id =

            OwnedUserId::from_str(user_id).map_err(|e| serde_json::Error::custom(e.to_string()))?;

        let bundle: matrix_sdk_base::crypto::types::SecretsBundle = serde_json::from_str(bundle)?;

        let backup_info = serde_json::from_str(backup_info)?;

        let is_backup_ok =

            bundle.backup.as_ref().is_some_and(|backup| is_valid_backup(backup, &backup_info));

        if is_backup_ok {

            Ok(Self { user_id, inner: bundle }.into())

        } else {

            Err(BundleExportError::InvalidBackup)

        }

    }

    /// Does the bundle contain a backup key.

    ///

    /// Since enabling a backup is optional, the backup key might be missing

    /// from the bundle. Returns `false` if the backup key is missing,

    /// otherwise `true`.

    pub fn contains_backup_key(&self) -> bool {

        self.inner.backup.is_some()

    }

}

fn is_valid_backup(secrets: &BackupSecrets, info: &RoomKeyBackupInfo) -> bool {

    match secrets {

        BackupSecrets::MegolmBackupV1Curve25519AesSha2(secrets) => {

            secrets.key.backup_key_matches(info)

        }

    }

}

fn check_bundle_and_info(

    bundle: &matrix_sdk_base::crypto::types::SecretsBundle,

    info: Option<&RoomKeyBackupInfo>,

) -> DetectedSecretsBundle {

    match (&bundle.backup, info) {

        (None, None) => DetectedSecretsBundle::WithoutBackup,

        (None, Some(_)) => DetectedSecretsBundle::WithoutBackup,

        (Some(_), None) => DetectedSecretsBundle::UnusedBackup,

        (Some(backup), Some(info)) => {

            if is_valid_backup(backup, info) {

                DetectedSecretsBundle::Complete

            } else {

                DetectedSecretsBundle::UnusedBackup

            }

        }

    }

}

/// Check if a JSON encoded string contains a valid [`SecretsBundle`].

#[uniffi::export]

pub fn json_string_contains_secrets_bundle(

    bundle: &str,

    backup_info: Option<String>,

) -> Result<DetectedSecretsBundle, ClientError> {

    let info: Option<RoomKeyBackupInfo> =

        backup_info.map(|info| serde_json::from_str(&info)).transpose()?;

    let bundle: matrix_sdk_base::crypto::types::SecretsBundle = serde_json::from_str(bundle)?;

    Ok(check_bundle_and_info(&bundle, info.as_ref()))

}

/// Check if a crypto store contains a valid [`SecretsBundle`].

#[cfg(feature = "sqlite")]

#[matrix_sdk_ffi_macros::export]

pub async fn database_contains_secrets_bundle(

    database_path: &str,

    mut passphrase: Option<String>,

    backup_info: Option<String>,

) -> Result<DetectedSecretsBundle, BundleExportError> {

    let info: Option<RoomKeyBackupInfo> =

        backup_info.map(|info| serde_json::from_str(&info)).transpose()?;

    let maybe_bundle = matrix_sdk::encryption::export_secrets_bundle_from_store(

        database_path,

        passphrase.as_deref(),

    )

    .await?;

    passphrase.zeroize();

    Ok(match maybe_bundle {

        Some((_, bundle)) => check_bundle_and_info(&bundle, info.as_ref()),

        None => DetectedSecretsBundle::None,

    })

}

#[matrix_sdk_ffi_macros::export]

impl Encryption {

    /// Get the public ed25519 key of our own device. This is usually what is

    /// called the fingerprint of the device.

    pub async fn ed25519_key(&self) -> Option<String> {

        self.inner.ed25519_key().await

    }

    /// Get the public curve25519 key of our own device in base64. This is

    /// usually what is called the identity key of the device.

    pub async fn curve25519_key(&self) -> Option<String> {

        self.inner.curve25519_key().await.map(|k| k.to_base64())

    }

    pub fn backup_state_listener(&self, listener: Box<dyn BackupStateListener>) -> Arc<TaskHandle> {

        let mut stream = self.inner.backups().state_stream();

        let stream_task = TaskHandle::new(get_runtime_handle().spawn(async move {

            while let Some(state) = stream.next().await {

                let Ok(state) = state else { continue };

                listener.on_update(state.into());

            }

        }));

        stream_task.into()

    }

    pub fn backup_state(&self) -> BackupState {

        self.inner.backups().state().into()

    }

    /// Does a backup exist on the server?

    ///