Skip to content

armgit / ente

Public Imported from GitHub
0

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

7.3 KB
Raw Blame
use std::fmt;

use ente_core::b64;
use ente_core::crypto::{self, Key, Salt, SecretKey, SecretVec, argon, kdf, secretbox};
use sha2::Sha256;
use srp::ClientG4096;

use super::KeyAttributes;
use crate::error::{Error, Result};

pub struct GeneratedKek {
    pub key: SecretVec,
    pub salt: Vec<u8>,
    pub mem_limit: u64,
    pub ops_limit: u32,
}

impl fmt::Debug for GeneratedKek {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("GeneratedKek")
            .field("key", &"[REDACTED]")
            .field("salt_len", &self.salt.len())
            .field("mem_limit", &self.mem_limit)
            .field("ops_limit", &self.ops_limit)
            .finish()
    }
}

pub struct GeneratedSrpSetup {
    pub srp_salt: Vec<u8>,
    pub srp_verifier: Vec<u8>,
    pub login_sub_key: SecretVec,
}

impl fmt::Debug for GeneratedSrpSetup {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("GeneratedSrpSetup")
            .field("srp_salt_len", &self.srp_salt.len())
            .field("srp_verifier", &"[REDACTED]")
            .field("login_sub_key", &"[REDACTED]")
            .finish()
    }
}

pub fn derive_kek(
    password: &str,
    kek_salt: &str,
    mem_limit: u64,
    ops_limit: u32,
) -> Result<SecretVec> {
    let salt_bytes = b64::decode(kek_salt).map_err(|e| Error::Decode(format!("kek_salt: {e}")))?;
    let salt = crypto::Salt::try_from_slice(&salt_bytes)?;

    let key = argon::derive_key(
        password,
        &salt,
        argon::Params {
            mem_limit,
            ops_limit,
        },
    )?;
    Ok(SecretVec::new(key.as_bytes().to_vec()))
}

pub fn generate_interactive_kek(password: &str) -> Result<GeneratedKek> {
    let derived = argon::derive_interactive_key(password)?;

    Ok(generated_kek(derived))
}

fn generated_kek(derived: argon::DerivedKey) -> GeneratedKek {
    GeneratedKek {
        key: SecretVec::new(derived.key.as_bytes().to_vec()),
        salt: derived.salt.as_bytes().to_vec(),
        mem_limit: derived.params.mem_limit,
        ops_limit: derived.params.ops_limit,
    }
}

pub fn derive_srp_login_key(kek: &[u8]) -> Result<SecretVec> {
    Ok(kdf::derive_login_key(&crypto::Key::try_from_slice(kek)?))
}

pub fn generate_srp_setup(kek: &[u8], srp_user_id: &str) -> Result<GeneratedSrpSetup> {
    let login_sub_key = derive_srp_login_key(kek)?;
    generate_srp_setup_with_login_key(&login_sub_key, srp_user_id)
}

pub fn generate_srp_setup_with_login_key(
    login_key: &[u8],
    srp_user_id: &str,
) -> Result<GeneratedSrpSetup> {
    if login_key.len() != 16 {
        return Err(Error::InvalidKey(format!(
            "Login key must be 16 bytes, got {}",
            login_key.len()
        )));
    }

    let srp_salt = Salt::generate().as_bytes().to_vec();
    let client = ClientG4096::<Sha256>::new();
    let srp_verifier = client.compute_verifier(srp_user_id.as_bytes(), login_key, &srp_salt);

    Ok(GeneratedSrpSetup {
        srp_salt,
        srp_verifier,
        login_sub_key: SecretVec::new(login_key.to_vec()),
    })
}

pub fn decrypt_keys_only(kek: &[u8], key_attrs: &KeyAttributes) -> Result<(Key, SecretKey)> {
    let encrypted_key = b64::decode(&key_attrs.encrypted_key)
        .map_err(|e| Error::Decode(format!("encrypted_key: {e}")))?;
    let key_nonce = b64::decode(&key_attrs.key_decryption_nonce)
        .map_err(|e| Error::Decode(format!("key_decryption_nonce: {e}")))?;

    let master_key = secretbox::decrypt(
        &encrypted_key,
        &crypto::Nonce::try_from_slice(&key_nonce)?,
        &crypto::Key::try_from_slice(kek)?,
    )
    .map_err(|_| Error::IncorrectPassword)?;
    let master_key = Key::try_from_slice(&master_key)?;
    let secret_key = decrypt_secret_key(&master_key, key_attrs)?;

    Ok((master_key, secret_key))
}

pub(crate) fn decrypt_secret_key(master_key: &Key, key_attrs: &KeyAttributes) -> Result<SecretKey> {
    let encrypted_secret_key = b64::decode(&key_attrs.encrypted_secret_key)
        .map_err(|e| Error::Decode(format!("encrypted_secret_key: {e}")))?;
    let secret_key_nonce = b64::decode(&key_attrs.secret_key_decryption_nonce)
        .map_err(|e| Error::Decode(format!("secret_key_decryption_nonce: {e}")))?;
    let public_key = b64::decode(&key_attrs.public_key)
        .map_err(|e| Error::Decode(format!("public_key: {e}")))?;
    let public_key = crypto::PublicKey::try_from_slice(&public_key)?;
    let secret_key = SecretKey::open(
        &secretbox::EncryptedBox {
            encrypted_data: encrypted_secret_key,
            nonce: crypto::Nonce::try_from_slice(&secret_key_nonce)?,
        },
        master_key,
        &public_key,
    )
    .map_err(|_| Error::InvalidKeyAttributes)?;

    Ok(secret_key)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::auth::{KeyDerivationStrength, generate_keys_with_strength};

    #[test]
    fn test_wrong_password_fails() {
        let gen_result =
            generate_keys_with_strength("correct_password", KeyDerivationStrength::Interactive)
                .unwrap();

        let kek = derive_kek(
            "wrong_password",
            &gen_result.key_attributes.kek_salt,
            gen_result.key_attributes.mem_limit,
            gen_result.key_attributes.ops_limit,
        )
        .unwrap();

        let result = decrypt_keys_only(&kek, &gen_result.key_attributes);
        assert!(matches!(result, Err(Error::IncorrectPassword)));
    }

    #[test]
    fn test_decrypt_keys_only_rejects_mismatched_public_key() {
        let mut generated =
            generate_keys_with_strength("password", KeyDerivationStrength::Interactive).unwrap();
        generated.key_attributes.public_key =
            b64::encode(crypto::SecretKey::generate().public_key().as_bytes());

        assert!(matches!(
            decrypt_keys_only(&generated.key_encryption_key, &generated.key_attributes),
            Err(Error::InvalidKeyAttributes)
        ));
    }

    #[test]
    fn test_generated_kek_debug_redacts_secret_material() {
        let generated = GeneratedKek {
            key: SecretVec::new(vec![1, 2, 3]),
            salt: vec![4, 5, 6],
            mem_limit: 123,
            ops_limit: 456,
        };

        let debug = format!("{generated:?}");
        assert!(debug.contains("[REDACTED]"));
        assert!(!debug.contains("[1, 2, 3]"));
        assert!(debug.contains("salt_len"));
    }

    #[test]
    fn test_generate_interactive_kek() {
        let generated = generate_interactive_kek("test_password").unwrap();

        assert_eq!(generated.key.len(), 32);
        assert_eq!(generated.salt.len(), 16);
        assert_eq!(generated.mem_limit, argon::Params::INTERACTIVE.mem_limit);
        assert_eq!(generated.ops_limit, argon::Params::INTERACTIVE.ops_limit);
    }

    #[test]
    fn test_generate_srp_setup() {
        let srp_setup = generate_srp_setup(&[1; 32], "test-user-id").unwrap();

        assert_eq!(srp_setup.srp_salt.len(), 16);
        assert_eq!(srp_setup.login_sub_key.len(), 16);
        assert!(!srp_setup.srp_verifier.is_empty());
    }

    #[test]
    fn test_generate_srp_setup_with_login_key() {
        let login_key = [1u8; 16];
        let srp_setup = generate_srp_setup_with_login_key(&login_key, "test-user-id").unwrap();

        assert_eq!(srp_setup.srp_salt.len(), 16);
        assert_eq!(srp_setup.login_sub_key.as_ref(), login_key);
        assert!(!srp_setup.srp_verifier.is_empty());
    }
}