Skip to content

armgit / ente

Public Imported from GitHub
0

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

14.5 KB
Raw Blame
use super::*;
use mockito::{Matcher, Server};
use serde::Deserialize;
use std::sync::{Arc, Mutex};

use crate::test_support::{SetupSrpPayload, SrpState, make_client, parse_request_body, srp_proofs};

const TOTP_SECRET: &str = "JBSWY3DPEHPK3PXPJBSWY3DPEHPK3PXP";
const PASSKEY_SECRET: &str = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=";

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct UpdateSrpPayload {
    setup_id: String,
    srp_m1: String,
    updated_key_attr: UpdatedKeyAttr,
    log_out_other_devices: bool,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct ConfigurePasskeyRecoveryPayload {
    secret: String,
    user_secret_cipher: String,
    user_secret_nonce: String,
}

#[tokio::test]
async fn setup_two_factor_encrypts_secret_with_recovery_key() {
    let password = "pw";
    let secret_code = TOTP_SECRET;
    let key_gen =
        auth::generate_keys_with_strength(password, auth::KeyDerivationStrength::Interactive)
            .unwrap();
    let recovery_key = key_gen.private_key_attributes.recovery_key.into_string();
    let expected_recovery_key =
        crypto::Key::try_from_slice(&hex::decode(&recovery_key).unwrap()).unwrap();
    let master_key = b64::decode(&key_gen.private_key_attributes.key).unwrap();
    let key_attributes = key_gen.key_attributes.clone();

    let mut server = Server::new_async().await;

    let setup = server
        .mock("POST", "/users/two-factor/setup")
        .match_header("x-auth-token", "session-token")
        .match_header("x-client-package", "io.ente.photos")
        .with_status(200)
        .with_body(
            serde_json::json!({
                "secretCode": secret_code,
                "qrCode": "qr-png-b64"
            })
            .to_string(),
        )
        .create_async()
        .await;

    let enable = server
        .mock("POST", "/users/two-factor/enable")
        .match_header("x-auth-token", "session-token")
        .match_header("x-client-package", "io.ente.photos")
        .with_status(200)
        .match_request(move |request| {
            let payload: serde_json::Value = parse_request_body(request);
            let ciphertext =
                b64::decode(payload["encryptedTwoFactorSecret"].as_str().unwrap()).unwrap();
            let nonce =
                b64::decode(payload["twoFactorSecretDecryptionNonce"].as_str().unwrap()).unwrap();
            let decrypted = secretbox::decrypt(
                &ciphertext,
                &crypto::Nonce::try_from_slice(&nonce).unwrap(),
                &expected_recovery_key,
            )
            .unwrap();
            b64::encode(&decrypted) == secret_code
        })
        .create_async()
        .await;

    let client = make_client(server.url());
    client.set_auth_token(Some("session-token".into()));

    let result = TwoFactorSetup::start(&client, &master_key, &key_attributes)
        .await
        .unwrap();
    assert!(matches!(
        result.enable(&client, "invalid").await,
        Err(Error::IncorrectTotp)
    ));
    let code = ente_test_support::account_fixture::current_totp(&result.secret_code).unwrap();
    result.enable(&client, &code).await.unwrap();

    assert_eq!(result.secret_code, secret_code);
    assert_eq!(result.recovery_key, recovery_key);

    setup.assert_async().await;
    enable.assert_async().await;
    enable.remove_async().await;

    let rejected = server
        .mock("POST", "/users/two-factor/enable")
        .with_status(401)
        .expect(2)
        .create_async()
        .await;
    assert!(matches!(
        result.enable(&client, &code).await,
        Err(Error::Http(error)) if error.status_code() == Some(401)
    ));
    assert!(matches!(
        enable_two_factor(&client, secret_code, &recovery_key, &code).await,
        Err(Error::IncorrectTotp)
    ));
    rejected.assert_async().await;
}

#[test]
fn enrollment_verifies_the_supplied_secret_and_window() {
    let secret = "GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ";
    for code in ["755224", "287082", "359152"] {
        verify_totp(secret, code, 59).unwrap();
    }
    for code in ["969429", "28708", "0287082", "invalid"] {
        assert!(matches!(
            verify_totp(secret, code, 59),
            Err(Error::IncorrectTotp)
        ));
    }
    assert!(matches!(
        verify_totp("MY", "287082", 59),
        Err(Error::IncorrectTotp)
    ));
}

#[tokio::test]
async fn configure_passkey_recovery_accepts_hex_recovery_key() {
    let key_gen =
        auth::generate_keys_with_strength("pw", auth::KeyDerivationStrength::Interactive).unwrap();
    let recovery_key_hex = key_gen.private_key_attributes.recovery_key.into_string();
    let expected_recovery_key = hex::decode(&recovery_key_hex).unwrap();

    let mut server = Server::new_async().await;
    let configure = server
        .mock("POST", "/users/two-factor/passkeys/configure-recovery")
        .match_header("x-auth-token", "session-token")
        .match_header("x-client-package", "io.ente.photos")
        .with_status(200)
        .match_request(move |request| {
            let payload: ConfigurePasskeyRecoveryPayload = parse_request_body(request);
            let cipher = b64::decode(&payload.user_secret_cipher).unwrap();
            let nonce = b64::decode(&payload.user_secret_nonce).unwrap();
            let decrypted = secretbox::decrypt(
                &cipher,
                &crypto::Nonce::try_from_slice(&nonce).unwrap(),
                &crypto::Key::try_from_slice(&expected_recovery_key).unwrap(),
            )
            .unwrap();
            payload.secret == PASSKEY_SECRET && b64::encode(&decrypted) == PASSKEY_SECRET
        })
        .create_async()
        .await;

    let client = make_client(server.url());
    client.set_auth_token(Some("session-token".into()));

    configure_passkey_recovery(&client, PASSKEY_SECRET, &recovery_key_hex)
        .await
        .unwrap();

    configure.assert_async().await;
}

#[tokio::test]
async fn two_factor_recovery_preserves_secret_encoding() {
    let keys =
        auth::generate_keys_with_strength("pw", auth::KeyDerivationStrength::Interactive).unwrap();
    let recovery_key_hex = keys.private_key_attributes.recovery_key.into_string();
    let recovery_key =
        crypto::Key::try_from_slice(&hex::decode(&recovery_key_hex).unwrap()).unwrap();
    let mut server = Server::new_async().await;
    for strict in [false, true] {
        let origin = if strict {
            server.url().replace("127.0.0.1", "localhost")
        } else {
            server.url()
        };
        let client = make_client(origin);

        for (factor, secret, proof) in [
            (
                TwoFactorType::Totp,
                TOTP_SECRET,
                "CBPrRdwiN5FRHBSQfTRIaEAN8Psf46H3iA3IugLVPqw=",
            ),
            (
                TwoFactorType::Passkey,
                PASSKEY_SECRET,
                "f+nF2g7+BGieMdZ8uJLndOcDP5GX2ffGgLk5DhHqKFI=",
            ),
        ] {
            let encrypted = secretbox::encrypt(&b64::decode(secret).unwrap(), &recovery_key);
            let remove = server
                .mock("POST", "/users/two-factor/remove")
                .match_body(Matcher::Json(serde_json::json!({
                    "sessionID": "recovery-session",
                    if strict { "proof" } else { "secret" }: if strict { proof } else { secret },
                    "twoFactorType": factor,
                })))
                .with_status(200)
                .with_body(
                    serde_json::json!({
                        "id": 1,
                        "keyAttributes": keys.key_attributes,
                        "encryptedToken": "encrypted-token",
                    })
                    .to_string(),
                )
                .create_async()
                .await;

            let envelope = TwoFactorRecoveryResponse {
                encrypted_secret: b64::encode(&encrypted.encrypted_data),
                secret_decryption_nonce: b64::encode(encrypted.nonce.as_bytes()),
            };
            assert!(matches!(
                recover_two_factor(
                    &client,
                    factor,
                    "recovery-session",
                    &envelope,
                    &hex::encode(crypto::Key::generate().as_bytes()),
                )
                .await,
                Err(Error::IncorrectRecoveryKey)
            ));
            recover_two_factor(
                &client,
                factor,
                "recovery-session",
                &envelope,
                &recovery_key_hex,
            )
            .await
            .unwrap();
            remove.assert_async().await;
        }
    }
}

#[tokio::test]
async fn change_password_updates_srp_and_keys() {
    let original =
        auth::generate_keys_with_strength("old-password", auth::KeyDerivationStrength::Interactive)
            .unwrap();
    let key_attributes = original.key_attributes.clone();
    let master_key = b64::decode(&original.private_key_attributes.key).unwrap();
    let state = Arc::new(Mutex::new(SrpState::default()));

    let mut server = Server::new_async().await;

    let state_for_setup = Arc::clone(&state);
    let setup_srp = server
        .mock("POST", "/users/srp/setup")
        .match_header("x-auth-token", "session-token")
        .with_status(200)
        .with_body_from_request(move |request| {
            let payload: SetupSrpPayload = parse_request_body(request);
            let (srp_b, client_proof, server_proof) = srp_proofs(&payload);
            let setup_id = Uuid::new_v4();

            let state = &mut *state_for_setup.lock().unwrap();
            state.pending_setup_id = Some(setup_id);
            state.pending_client_proof = Some(client_proof);
            state.pending_server_proof = Some(server_proof);
            state.remote_srp_attributes = Some(SrpAttributes {
                srp_user_id: Uuid::parse_str(&payload.srp_user_id).unwrap(),
                srp_salt: payload.srp_salt.clone(),
                mem_limit: 0,
                ops_limit: 0,
                kek_salt: String::new(),
                is_email_mfa_enabled: false,
            });

            serde_json::json!({
                "setupID": setup_id,
                "srpB": b64::encode(&srp_b),
            })
            .to_string()
            .into_bytes()
        })
        .create_async()
        .await;

    let state_for_update = Arc::clone(&state);
    let update_srp = server
        .mock("POST", "/users/srp/update")
        .match_header("x-auth-token", "session-token")
        .with_status(200)
        .with_body_from_request(move |request| {
            let payload: UpdateSrpPayload = parse_request_body(request);
            let state = &mut *state_for_update.lock().unwrap();
            assert_eq!(
                payload.setup_id,
                state.pending_setup_id.unwrap().to_string()
            );
            assert_eq!(
                b64::decode(&payload.srp_m1).unwrap(),
                state.pending_client_proof.as_ref().unwrap().clone()
            );
            assert!(payload.log_out_other_devices);
            state.remote_srp_attributes = state.remote_srp_attributes.clone().map(|mut attrs| {
                attrs.mem_limit = payload.updated_key_attr.mem_limit;
                attrs.ops_limit = payload.updated_key_attr.ops_limit;
                attrs.kek_salt = payload.updated_key_attr.kek_salt.clone();
                attrs
            });
            serde_json::json!({
                "setupID": payload.setup_id,
                "srpM2": b64::encode(state.pending_server_proof.as_ref().unwrap()),
            })
            .to_string()
            .into_bytes()
        })
        .create_async()
        .await;

    let get_srp_attributes = server
        .mock("GET", "/users/srp/attributes")
        .match_query(Matcher::UrlEncoded(
            "email".into(),
            "[email protected]".into(),
        ))
        .expect(0)
        .create_async()
        .await;

    let client = make_client(server.url());
    client.set_auth_token(Some("session-token".into()));

    let result = change_password_with_strength(
        &client,
        ChangePasswordParams {
            password: Zeroizing::new("new-password".into()),
            master_key: SecretVec::new(master_key),
            key_attributes,
            log_out_other_devices: true,
        },
        KeyDerivationStrength::Interactive,
    )
    .await
    .unwrap();

    assert_eq!(
        result.kek_salt,
        state
            .lock()
            .unwrap()
            .remote_srp_attributes
            .as_ref()
            .unwrap()
            .kek_salt
    );

    setup_srp.assert_async().await;
    update_srp.assert_async().await;
    get_srp_attributes.assert_async().await;
}

#[tokio::test]
async fn passkey_management_only_configures_recovery_when_needed() {
    let recovery_key = [7; 32];
    let mnemonic = auth::recovery_key_to_mnemonic(&recovery_key).unwrap();
    for enabled in [false, true] {
        let mut server = Server::new_async().await;
        let status = server
            .mock("GET", "/users/two-factor/recovery-status")
            .with_body(serde_json::json!({"isPasskeyRecoveryEnabled": enabled}).to_string())
            .create_async()
            .await;
        let configure = server
            .mock("POST", "/users/two-factor/passkeys/configure-recovery")
            .expect(usize::from(!enabled))
            .match_request(move |request| {
                let payload: ConfigurePasskeyRecoveryPayload = parse_request_body(request);
                let decrypted = secretbox::decrypt(
                    &b64::decode(&payload.user_secret_cipher).unwrap(),
                    &crypto::Nonce::try_from_slice(
                        &b64::decode(&payload.user_secret_nonce).unwrap(),
                    )
                    .unwrap(),
                    &crypto::Key::try_from_slice(&recovery_key).unwrap(),
                )
                .unwrap();
                decrypted.len() == 32 && b64::encode(&decrypted) == payload.secret
            })
            .create_async()
            .await;
        let token = server
            .mock("GET", "/users/accounts-token")
            .with_body(r#"{"accountsUrl":"https://accounts.ente.io","accountsToken":"a+b/="}"#)
            .create_async()
            .await;
        assert_eq!(
            passkey_management_url(&make_client(server.url()), &mnemonic)
                .await
                .unwrap(),
            "https://accounts.ente.io/passkeys?token=a%2Bb%2F%3D"
        );
        status.assert_async().await;
        configure.assert_async().await;
        token.assert_async().await;
    }
}