Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

12.2 KB
Raw Blame
use ente_core::crypto::{self, SecretVec, secretbox};
use ente_core::{b64, otp};
use serde::Serialize;
use std::{
    fmt,
    time::{SystemTime, UNIX_EPOCH},
};
use uuid::Uuid;
use zeroize::{ZeroizeOnDrop, Zeroizing};

use crate::{
    AccountsClient, Error, Result,
    auth::{
        self, GeneratedSrpSetup, KeyDerivationStrength, generate_srp_setup_with_login_key,
        get_recovery_key,
    },
    models::{
        ConfigurePasskeyRecoveryRequest, EnableTwoFactorRequest, KeyAttributes,
        RemoveTwoFactorRequest, SetRecoveryKeyRequest, SetupSrpRequest, SrpAttributes,
        TwoFactorAuthorizationResponse, TwoFactorRecoveryResponse, TwoFactorType,
        UpdateSrpAndKeysRequest, UpdatedKeyAttr,
    },
};

pub struct ChangePasswordParams {
    pub password: Zeroizing<String>,
    pub master_key: SecretVec,
    pub key_attributes: KeyAttributes,
    pub log_out_other_devices: bool,
}

impl fmt::Debug for ChangePasswordParams {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ChangePasswordParams")
            .field("password", &"[REDACTED]")
            .field("master_key", &"[REDACTED]")
            .field("key_attributes", &self.key_attributes)
            .field("log_out_other_devices", &self.log_out_other_devices)
            .finish()
    }
}

#[derive(Debug)]
pub struct CheckSessionValidityParams {
    pub email: String,
    pub local_srp_attributes: Option<SrpAttributes>,
}

#[derive(Debug, Serialize)]
#[serde(
    tag = "status",
    rename_all = "camelCase",
    rename_all_fields = "camelCase"
)]
#[cfg_attr(
    target_pointer_width = "64",
    expect(
        clippy::large_enum_variant,
        reason = "A single session-check result does not need a separate allocation"
    )
)]
pub enum SessionValidity {
    Invalid,
    Valid,
    ValidButPasswordChanged {
        updated_key_attributes: KeyAttributes,
        #[serde(rename = "updatedSRPAttributes")]
        updated_srp_attributes: SrpAttributes,
    },
}

pub struct RecoveryKeyResult {
    pub recovery_key: String,
    pub key_attributes: KeyAttributes,
}

impl fmt::Debug for RecoveryKeyResult {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("RecoveryKeyResult")
            .field("recovery_key", &"[REDACTED]")
            .field("key_attributes", &self.key_attributes)
            .finish()
    }
}

#[derive(ZeroizeOnDrop)]
pub struct TwoFactorSetup {
    pub secret_code: String,
    pub qr_code: String,
    pub recovery_key: String,
}

impl TwoFactorSetup {
    pub fn from_secret(secret_code: String, recovery_key: &[u8]) -> Self {
        Self {
            secret_code,
            qr_code: String::new(),
            recovery_key: hex::encode(recovery_key),
        }
    }

    pub async fn start(
        client: &AccountsClient,
        master_key: &[u8],
        key_attributes: &KeyAttributes,
    ) -> Result<Self> {
        let master_key = crypto::Key::try_from_slice(master_key)?;
        let recovery_key = get_recovery_key(&master_key, key_attributes)?;
        let secret = client.setup_two_factor().await?;
        Ok(Self {
            secret_code: secret.secret_code,
            qr_code: secret.qr_code,
            recovery_key,
        })
    }

    pub async fn enable(&self, client: &AccountsClient, code: &str) -> Result<()> {
        let time = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .map_err(|_| Error::InvalidInput("system clock is before the Unix epoch".into()))?
            .as_secs();
        verify_totp(&self.secret_code, code, time)?;
        let request = encrypt_two_factor_secret(&self.secret_code, &self.recovery_key, code)?;
        client.enable_two_factor(&request).await
    }
}

fn verify_totp(secret: &str, code: &str, time: u64) -> Result<()> {
    let secret = otp::decode_secret(secret)?;
    for time in [time.saturating_sub(30), time, time + 30] {
        let expected = Zeroizing::new(otp::totp(&secret, time, 30, 6, otp::Algorithm::Sha1)?);
        if expected.as_str() == code {
            return Ok(());
        }
    }
    Err(Error::IncorrectTotp)
}

pub async fn change_password(
    client: &AccountsClient,
    params: ChangePasswordParams,
) -> Result<KeyAttributes> {
    change_password_with_strength(client, params, KeyDerivationStrength::Sensitive).await
}

async fn change_password_with_strength(
    client: &AccountsClient,
    params: ChangePasswordParams,
    key_derivation_strength: KeyDerivationStrength,
) -> Result<KeyAttributes> {
    let (updated_key_attributes, login_key) =
        auth::generate_key_attributes_for_new_password_with_strength(
            &params.master_key,
            &params.key_attributes,
            &params.password,
            key_derivation_strength,
        )?;

    let updated_key_attr = UpdatedKeyAttr::from(&updated_key_attributes);

    let srp_user_id = Uuid::new_v4();
    let srp_setup = generate_srp_setup_with_login_key(&login_key, &srp_user_id.to_string())?;
    complete_srp_update(
        client,
        &srp_user_id,
        &srp_setup,
        &updated_key_attr,
        params.log_out_other_devices,
    )
    .await?;

    Ok(updated_key_attributes)
}

pub async fn check_session_validity(
    client: &AccountsClient,
    params: CheckSessionValidityParams,
) -> Result<SessionValidity> {
    let remote = match client.get_session_validity().await {
        Ok(remote) => remote,
        Err(Error::SessionInvalid) => return Ok(SessionValidity::Invalid),
        Err(error) => return Err(error),
    };

    if let Some(remote_key_attributes) = remote.key_attributes {
        let remote_srp_attributes = match client.get_srp_attributes(&params.email).await {
            Ok(attributes) => attributes,
            Err(Error::SrpNotConfigured) => return Ok(SessionValidity::Valid),
            Err(error) => return Err(error),
        };
        if params
            .local_srp_attributes
            .as_ref()
            .is_none_or(|local| remote_srp_attributes.kek_salt != local.kek_salt)
        {
            return Ok(SessionValidity::ValidButPasswordChanged {
                updated_key_attributes: remote_key_attributes,
                updated_srp_attributes: remote_srp_attributes,
            });
        }
    }

    Ok(SessionValidity::Valid)
}

pub async fn create_recovery_key(
    client: &AccountsClient,
    master_key: &[u8],
    existing_attributes: &KeyAttributes,
) -> Result<RecoveryKeyResult> {
    let (
        recovery_key,
        master_key_encrypted_with_recovery_key,
        master_key_decryption_nonce,
        recovery_key_encrypted_with_master_key,
        recovery_key_decryption_nonce,
    ) = auth::create_new_recovery_key(master_key)?;

    let request = SetRecoveryKeyRequest {
        master_key_encrypted_with_recovery_key: master_key_encrypted_with_recovery_key.clone(),
        master_key_decryption_nonce: master_key_decryption_nonce.clone(),
        recovery_key_encrypted_with_master_key: recovery_key_encrypted_with_master_key.clone(),
        recovery_key_decryption_nonce: recovery_key_decryption_nonce.clone(),
    };
    client.set_recovery_key_attributes(request).await?;

    let key_attributes = KeyAttributes {
        master_key_encrypted_with_recovery_key: Some(master_key_encrypted_with_recovery_key),
        master_key_decryption_nonce: Some(master_key_decryption_nonce),
        recovery_key_encrypted_with_master_key: Some(recovery_key_encrypted_with_master_key),
        recovery_key_decryption_nonce: Some(recovery_key_decryption_nonce),
        ..existing_attributes.clone()
    };

    Ok(RecoveryKeyResult {
        recovery_key,
        key_attributes,
    })
}

pub async fn recover_two_factor(
    client: &AccountsClient,
    two_factor_type: TwoFactorType,
    session_id: &str,
    recovery_response: &TwoFactorRecoveryResponse,
    recovery_key_mnemonic_or_hex: &str,
) -> Result<TwoFactorAuthorizationResponse> {
    let recovery_key = auth::recovery_key_from_mnemonic_or_hex(recovery_key_mnemonic_or_hex)?;
    let encrypted_secret = b64::decode(&recovery_response.encrypted_secret)?;
    let nonce = b64::decode(&recovery_response.secret_decryption_nonce)?;
    let secret = secretbox::decrypt(
        &encrypted_secret,
        &crypto::Nonce::try_from_slice(&nonce)?,
        &crypto::Key::try_from_slice(&recovery_key)?,
    )
    .map_err(|_| Error::IncorrectRecoveryKey)?;
    let secret = Zeroizing::new(b64::encode(&secret));
    let (secret, proof) = if auth::payload::enforce_auth_payloads(&client.api) {
        (
            None,
            Some(auth::payload::recovery_proof(
                &secret,
                two_factor_type,
                session_id,
            )?),
        )
    } else {
        (Some(secret.to_string()), None)
    };
    let request = RemoveTwoFactorRequest {
        session_id: session_id.to_string(),
        secret,
        proof,
        two_factor_type,
    };
    client.remove_two_factor(&request).await
}

pub async fn enable_two_factor(
    client: &AccountsClient,
    secret: &str,
    recovery_key: &str,
    code: &str,
) -> Result<()> {
    let request = encrypt_two_factor_secret(secret, recovery_key, code)?;
    match client.enable_two_factor(&request).await {
        Err(Error::Http(error)) if error.status_code() == Some(401) => Err(Error::IncorrectTotp),
        result => result,
    }
}

pub async fn passkey_management_url(client: &AccountsClient, recovery_key: &str) -> Result<String> {
    if !client
        .get_two_factor_recovery_status()
        .await?
        .is_passkey_recovery_enabled
    {
        let secret = Zeroizing::new(b64::encode(crypto::Key::generate().as_bytes()));
        configure_passkey_recovery(client, &secret, recovery_key).await?;
    }
    let response = client.get_accounts_token().await?;
    Ok(format!(
        "{}/passkeys?token={}",
        response.accounts_url,
        urlencoding::encode(&response.accounts_token)
    ))
}

pub async fn configure_passkey_recovery(
    client: &AccountsClient,
    secret: &str,
    recovery_key_mnemonic_or_hex: &str,
) -> Result<()> {
    let recovery_key = auth::recovery_key_from_mnemonic_or_hex(recovery_key_mnemonic_or_hex)?;
    let encrypted = secretbox::encrypt(
        &b64::decode(secret)?,
        &crypto::Key::try_from_slice(&recovery_key)?,
    );
    let request = ConfigurePasskeyRecoveryRequest {
        secret: secret.to_string(),
        user_secret_cipher: b64::encode(&encrypted.encrypted_data),
        user_secret_nonce: b64::encode(encrypted.nonce.as_bytes()),
    };
    client.configure_passkey_recovery(&request).await
}

async fn complete_srp_update(
    client: &AccountsClient,
    srp_user_id: &Uuid,
    srp_setup: &GeneratedSrpSetup,
    updated_key_attr: &UpdatedKeyAttr,
    log_out_other_devices: bool,
) -> Result<crate::models::UpdateSrpAndKeysResponse> {
    let mut srp_session = auth::SrpSession::new(
        &srp_user_id.to_string(),
        &srp_setup.srp_salt,
        &srp_setup.login_sub_key,
    )?;
    let srp_a = b64::encode(&srp_session.public_a());

    let setup = client
        .setup_srp(&SetupSrpRequest {
            srp_user_id: srp_user_id.to_string(),
            srp_salt: b64::encode(&srp_setup.srp_salt),
            srp_verifier: b64::encode(&srp_setup.srp_verifier),
            srp_a,
        })
        .await?;

    let srp_b = b64::decode(&setup.srp_b)?;
    let srp_m1 = b64::encode(&srp_session.compute_m1(&srp_b)?);

    let response = client
        .update_srp_and_key_attributes(&UpdateSrpAndKeysRequest {
            setup_id: setup.setup_id.to_string(),
            srp_m1,
            updated_key_attr: updated_key_attr.clone(),
            log_out_other_devices,
        })
        .await?;

    let srp_m2 = b64::decode(&response.srp_m2)?;
    srp_session.verify_m2(&srp_m2)?;
    Ok(response)
}

fn encrypt_two_factor_secret(
    secret_code: &str,
    recovery_key: &str,
    code: &str,
) -> Result<EnableTwoFactorRequest> {
    let recovery_key = auth::recovery_key_from_mnemonic_or_hex(recovery_key)?;
    let encrypted = secretbox::encrypt(
        &b64::decode(secret_code)?,
        &crypto::Key::try_from_slice(&recovery_key)?,
    );

    Ok(EnableTwoFactorRequest {
        code: code.to_string(),
        encrypted_two_factor_secret: b64::encode(&encrypted.encrypted_data),
        two_factor_secret_decryption_nonce: b64::encode(encrypted.nonce.as_bytes()),
    })
}

#[cfg(test)]
mod tests;