Skip to content

armgit / ente

Public Imported from GitHub
0

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

Preserve coverage in faster Rust tests

Manav Rathi126ac17b73a4
diff --git a/rust/apps/cli/src/commands/paste.rs b/rust/apps/cli/src/commands/paste.rs
index aa92a6a776..c386c09391 100644
--- a/rust/apps/cli/src/commands/paste.rs
+++ b/rust/apps/cli/src/commands/paste.rs
@@ -85,22 +85,31 @@ where
let payload = client.consume(access_token).await?;
match password {
- Some(password) => decrypt_password_protected_paste(paste_key, &payload, password),
+ Some(password) => decrypt_password_protected_paste_with_prompt(
+ paste_key,
+ &payload,
+ password,
+ prompt_raw_paste_password,
+ ),
None => Ok(ente_paste::decrypt(&payload, paste_key, None)?),
}
}
-fn decrypt_password_protected_paste(
+fn decrypt_password_protected_paste_with_prompt<F>(
paste_key: &PasteKey,
payload: &PastePayload,
password: PastePasswordAttempt,
-) -> Result<String> {
- decrypt_password_protected_paste_with_prompt(password, prompt_raw_paste_password, |password| {
+ prompt_password: F,
+) -> Result<String>
+where
+ F: FnMut() -> Result<String>,
+{
+ decrypt_password_protected_paste_with(password, prompt_password, |password| {
ente_paste::decrypt(payload, paste_key, Some(password))
})
}
-fn decrypt_password_protected_paste_with_prompt<F, D>(
+fn decrypt_password_protected_paste_with<F, D>(
mut password: PastePasswordAttempt,
mut prompt_password: F,
mut decrypt: D,
@@ -316,11 +325,14 @@ mod tests {
#[test]
fn prompted_password_retry_can_recover() {
+ let (paste_key, payload) =
+ ente_paste::encrypt("protected paste", Some("correct horse")).unwrap();
let mut retry_passwords = ["correct horse"].into_iter();
let text = decrypt_password_protected_paste_with_prompt(
+ &paste_key,
+ &payload,
PastePasswordAttempt::Prompted("wrong horse".to_string()),
|| Ok::<_, Error>(retry_passwords.next().expect("retry password").to_string()),
- test_decrypt_password_protected_paste,
)
.unwrap();
@@ -331,7 +343,7 @@ mod tests {
#[test]
fn prompted_password_retry_ignores_empty_password() {
let mut retry_passwords = ["", "correct horse"].into_iter();
- let text = decrypt_password_protected_paste_with_prompt(
+ let text = decrypt_password_protected_paste_with(
PastePasswordAttempt::Prompted("wrong horse".to_string()),
|| Ok::<_, Error>(retry_passwords.next().expect("retry password").to_string()),
test_decrypt_password_protected_paste,
@@ -344,7 +356,7 @@ mod tests {
#[test]
fn wrong_env_password_fails_without_retry() {
- let error = decrypt_password_protected_paste_with_prompt(
+ let error = decrypt_password_protected_paste_with(
PastePasswordAttempt::Env("wrong horse".to_string()),
|| panic!("environment passwords must not be retried"),
test_decrypt_password_protected_paste,
diff --git a/rust/crates/accounts/src/flow.rs b/rust/crates/accounts/src/flow.rs
index 21b2d28b35..fea6134046 100644
--- a/rust/crates/accounts/src/flow.rs
+++ b/rust/crates/accounts/src/flow.rs
@@ -10,7 +10,7 @@ use base64::{
use ente_core::{
auth::{
self, DecryptedSecrets, GeneratedSrpSetup, KeyAttributes as CoreKeyAttributes,
- KeyDerivationStrength, derive_kek, generate_keys_with_strength, generate_srp_setup,
+ KeyDerivationStrength, derive_kek, generate_keys_with_strength,
generate_srp_setup_with_login_key, get_recovery_key,
},
crypto::{self, SecretVec, secretbox},
@@ -433,14 +433,13 @@ where
let srp_user_id = Uuid::new_v4();
let srp_setup = generate_srp_setup_with_login_key(&login_key, &srp_user_id.to_string())?;
- let update = self
- .complete_srp_update(
- &srp_user_id,
- &srp_setup,
- &updated_key_attr,
- params.log_out_other_devices,
- )
- .await?;
+ self.complete_srp_update(
+ &srp_user_id,
+ &srp_setup,
+ &updated_key_attr,
+ params.log_out_other_devices,
+ )
+ .await?;
let srp_attributes = self.client.get_srp_attributes(&params.email).await?;
@@ -468,8 +467,6 @@ where
)));
}
- let _ = update;
-
Ok(ChangePasswordResult {
key_attributes: updated_key_attributes,
srp_attributes,
@@ -701,7 +698,7 @@ where
let key_gen_result = generate_keys_with_strength(&password, key_derivation_strength)?;
let srp_user_id = Uuid::new_v4();
let srp_setup =
- generate_srp_setup(&key_gen_result.key_encryption_key, &srp_user_id.to_string())?;
+ generate_srp_setup_with_login_key(&key_gen_result.login_key, &srp_user_id.to_string())?;
let key_attributes = to_api_key_attributes(&key_gen_result.key_attributes);
self.client
diff --git a/rust/crates/core/src/auth/api.rs b/rust/crates/core/src/auth/api.rs
index c70bbbe997..6d7b7d7521 100644
--- a/rust/crates/core/src/auth/api.rs
+++ b/rust/crates/core/src/auth/api.rs
@@ -171,24 +171,23 @@ pub fn generate_sensitive_kek(password: &str) -> Result<GeneratedKek> {
_ => AuthError::InsufficientMemory,
})?;
- Ok(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,
- })
+ Ok(generated_kek(derived))
}
/// Generate a KEK using the current interactive web policy.
pub fn generate_interactive_kek(password: &str) -> Result<GeneratedKek> {
let derived = argon::derive_interactive_key(password)?;
- Ok(GeneratedKek {
+ 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,
- })
+ }
}
/// Generate the SRP setup payload for a given KEK and SRP user ID.
diff --git a/rust/crates/paste/src/lib.rs b/rust/crates/paste/src/lib.rs
index 7694f731f9..ae4bb51aae 100644
--- a/rust/crates/paste/src/lib.rs
+++ b/rust/crates/paste/src/lib.rs
@@ -284,6 +284,19 @@ pub fn decrypt(payload: &PastePayload, key: &PasteKey, password: Option<&str>) -
}
pub fn encrypt(text: &str, password: Option<&str>) -> Result<(PasteKey, PastePayload)> {
+ let params = if password.is_some() {
+ argon::Params::MODERATE
+ } else {
+ argon::Params::INTERACTIVE
+ };
+ encrypt_with_kdf_params(text, password, params)
+}
+
+fn encrypt_with_kdf_params(
+ text: &str,
+ password: Option<&str>,
+ params: argon::Params,
+) -> Result<(PasteKey, PastePayload)> {
let paste_key = Key::generate();
let key_reference = PasteKey {
fragment_secret: fragment_secret(),
@@ -296,12 +309,9 @@ pub fn encrypt(text: &str, password: Option<&str>) -> Result<(PasteKey, PastePay
&paste_key,
)?;
let kdf_secret = key_reference.kdf_secret(password)?;
- let key_encryption_key = if password.is_some() {
- argon::derive_moderate_key(&kdf_secret)?
- } else {
- argon::derive_interactive_key(&kdf_secret)?
- };
- let encrypted_paste_key = secretbox::encrypt(paste_key.as_bytes(), &key_encryption_key.key);
+ let salt = crypto::Salt::generate();
+ let key_encryption_key = argon::derive_key(&kdf_secret, &salt, params)?;
+ let encrypted_paste_key = secretbox::encrypt(paste_key.as_bytes(), &key_encryption_key);
Ok((
key_reference,
@@ -310,9 +320,9 @@ pub fn encrypt(text: &str, password: Option<&str>) -> Result<(PasteKey, PastePay
decryption_header: crypto::encode_b64(encrypted.decryption_header.as_bytes()),
encrypted_paste_key: crypto::encode_b64(&encrypted_paste_key.encrypted_data),
encrypted_paste_key_nonce: crypto::encode_b64(encrypted_paste_key.nonce.as_bytes()),
- kdf_nonce: crypto::encode_b64(key_encryption_key.salt.as_bytes()),
- kdf_mem_limit: key_encryption_key.params.mem_limit,
- kdf_ops_limit: key_encryption_key.params.ops_limit,
+ kdf_nonce: crypto::encode_b64(salt.as_bytes()),
+ kdf_mem_limit: params.mem_limit,
+ kdf_ops_limit: params.ops_limit,
},
))
}
@@ -410,8 +420,9 @@ mod tests {
#[test]
fn decrypt_password_protected_paste_payload() {
- let paste_key = PasteKey::parse("p-AbCd1234EfGh").unwrap();
- let payload = test_payload("protected paste", &paste_key, Some("correct horse"));
+ let (paste_key, payload) =
+ encrypt_with_kdf_params("protected paste", Some("correct horse"), argon::Params::MIN)
+ .unwrap();
let text = decrypt(&payload, &paste_key, Some("correct horse")).unwrap();
assert_eq!(text, "protected paste");
@@ -419,8 +430,9 @@ mod tests {
#[test]
fn reject_wrong_paste_password() {
- let paste_key = PasteKey::parse("p-AbCd1234EfGh").unwrap();
- let payload = test_payload("protected paste", &paste_key, Some("correct horse"));
+ let (paste_key, payload) =
+ encrypt_with_kdf_params("protected paste", Some("correct horse"), argon::Params::MIN)
+ .unwrap();
let error = decrypt(&payload, &paste_key, Some("wrong horse")).unwrap_err();
assert!(matches!(error, Error::IncorrectPassword));
@@ -428,8 +440,9 @@ mod tests {
#[test]
fn structural_payload_errors_are_not_incorrect_password() {
- let paste_key = PasteKey::parse("p-AbCd1234EfGh").unwrap();
- let mut payload = test_payload("protected paste", &paste_key, Some("correct horse"));
+ let (paste_key, mut payload) =
+ encrypt_with_kdf_params("protected paste", Some("correct horse"), argon::Params::MIN)
+ .unwrap();
payload.kdf_nonce = "not base64".to_string();
let error = decrypt(&payload, &paste_key, Some("correct horse")).unwrap_err();
@@ -441,8 +454,9 @@ mod tests {
#[test]
fn wrapped_key_payload_errors_are_not_incorrect_password() {
- let paste_key = PasteKey::parse("p-AbCd1234EfGh").unwrap();
- let mut payload = test_payload("protected paste", &paste_key, Some("correct horse"));
+ let (paste_key, mut payload) =
+ encrypt_with_kdf_params("protected paste", Some("correct horse"), argon::Params::MIN)
+ .unwrap();
payload.encrypted_paste_key = "not base64".to_string();
let error = decrypt(&payload, &paste_key, Some("correct horse")).unwrap_err();
@@ -522,8 +536,8 @@ mod tests {
#[tokio::test]
async fn consume_uses_guard_cookie() {
let access_token = "ABC123";
- let paste_key = PasteKey::parse("AbCd1234EfGh").unwrap();
- let payload = test_payload("guarded paste", &paste_key, None);
+ let (paste_key, payload) =
+ encrypt_with_kdf_params("guarded paste", None, argon::Params::MIN).unwrap();
let mut server = Server::new_async().await;
let guard = server
@@ -557,29 +571,4 @@ mod tests {
guard.assert_async().await;
consume.assert_async().await;
}
-
- fn test_payload(text: &str, key_reference: &PasteKey, password: Option<&str>) -> PastePayload {
- let paste_key = Key::from_bytes([7u8; Key::BYTES]);
- let encrypted = blob::encrypt_json(
- &PasteText {
- text: text.to_string(),
- },
- &paste_key,
- )
- .unwrap();
- let salt = crypto::Salt::from_bytes([9u8; crypto::Salt::BYTES]);
- let kdf_secret = key_reference.kdf_secret(password).unwrap();
- let key_encryption_key = argon::derive_key(&kdf_secret, &salt, argon::Params::MIN).unwrap();
- let encrypted_paste_key = secretbox::encrypt(paste_key.as_bytes(), &key_encryption_key);
-
- PastePayload {
- encrypted_data: crypto::encode_b64(&encrypted.encrypted_data),
- decryption_header: crypto::encode_b64(encrypted.decryption_header.as_bytes()),
- encrypted_paste_key: crypto::encode_b64(&encrypted_paste_key.encrypted_data),
- encrypted_paste_key_nonce: crypto::encode_b64(encrypted_paste_key.nonce.as_bytes()),
- kdf_nonce: crypto::encode_b64(salt.as_bytes()),
- kdf_mem_limit: argon::Params::MIN.mem_limit,
- kdf_ops_limit: argon::Params::MIN.ops_limit,
- }
- }
}