π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Make account unlock operations client methods
Neeraj Guptab85ebf374fd9
diff --git a/rust/bindings/frb/lib/src/accounts/types.rs b/rust/bindings/frb/lib/src/accounts/types.rsindex 235c8467ff..5940203099 100644--- a/rust/bindings/frb/lib/src/accounts/types.rs+++ b/rust/bindings/frb/lib/src/accounts/types.rs@@ -1,4 +1,4 @@-use ente_accounts::{AccountsClient as InnerClient, Error, auth, lifecycle, login, signup};+use ente_accounts::{AccountsClient as InnerClient, Error, auth, lifecycle, signup};pub use ente_accounts::{auth::KeyAttributes,models::{@@ -221,7 +221,7 @@ impl AccountsClient {attributes.ops_limit,)?,};- let account = login::unlock(&self.0, &response, &kek)?;+ let account = self.0.unlock(&response, &kek)?;Ok(UnlockedAccount {master_key: b64::encode(&account.secrets.master_key),secret_key: b64::encode(&account.secrets.secret_key),@@ -235,7 +235,7 @@ impl AccountsClient {response: AuthResponse,recovery_key: String,) -> Result<RecoveredAccount, AccountsError> {- let account = login::recover_account(&self.0, &response, &recovery_key)?;+ let account = self.0.recover_account(&response, &recovery_key)?;Ok(RecoveredAccount {master_key: b64::encode(&account.secrets.master_key),secret_key: b64::encode(&account.secrets.secret_key),diff --git a/rust/bindings/wasm/lib/src/accounts/client.rs b/rust/bindings/wasm/lib/src/accounts/client.rsindex a67a7edfa3..898d94965e 100644--- a/rust/bindings/wasm/lib/src/accounts/client.rs+++ b/rust/bindings/wasm/lib/src/accounts/client.rs@@ -1,4 +1,4 @@-use ente_accounts::{auth, lifecycle, login, signup};+use ente_accounts::{auth, lifecycle, signup};use ente_core::{b64, crypto::SecretVec};use serde::{Deserialize, Serialize};use serde_wasm_bindgen as swb;@@ -186,7 +186,9 @@ pub fn unlock_account(#[wasm_bindgen(unchecked_param_type = "unknown")] response: JsValue,kek: &str,) -> Result<JsValue, Error> {- let account = login::unlock(&client.0, &swb::from_value(response)?, &decode(kek)?)?;+ let account = client+ .0+ .unlock(&swb::from_value(response)?, &decode(kek)?)?;unlocked_account(account)}@@ -196,11 +198,9 @@ pub fn unlock_account_with_master_key(#[wasm_bindgen(unchecked_param_type = "unknown")] response: JsValue,master_key: &str,) -> Result<JsValue, Error> {- let account = login::unlock_with_master_key(- &client.0,- &swb::from_value(response)?,- &decode(master_key)?,- )?;+ let account = client+ .0+ .unlock_with_master_key(&swb::from_value(response)?, &decode(master_key)?)?;unlocked_account(account)}@@ -264,7 +264,9 @@ pub fn recover_account(#[wasm_bindgen(unchecked_param_type = "unknown")] response: JsValue,recovery_key: &str,) -> Result<JsValue, Error> {- let account = login::recover_account(&client.0, &swb::from_value(response)?, recovery_key)?;+ let account = client+ .0+ .recover_account(&swb::from_value(response)?, recovery_key)?;unlocked_account(account)}diff --git a/rust/crates/accounts/src/login.rs b/rust/crates/accounts/src/login.rsindex 7f366c0b56..0193a969a5 100644--- a/rust/crates/accounts/src/login.rs+++ b/rust/crates/accounts/src/login.rs@@ -1,6 +1,6 @@use ente_core::{b64,- crypto::{Key, SecretKey, SecretVec, sealed},+ crypto::{Key, Nonce, SecretKey, SecretVec, sealed, secretbox},};use crate::{@@ -71,7 +71,7 @@ impl LoginFlow {return Err(Error::InvalidInput("Password is not expected".into()));};if let Some(response) = response {- let account = unlock_with_password(client, response, password)?;+ let account = client.unlock_with_password(response, password)?;self.state = State::Complete;Ok(LoginStep::Complete(Box::new(account)))} else {@@ -166,7 +166,7 @@ impl LoginFlow {return Ok(LoginStep::SecondFactor { totp, passkey });}if let Some(kek) = kek {- let account = unlock(client, &response, &kek)?;+ let account = client.unlock(&response, &kek)?;self.state = State::Complete;Ok(LoginStep::Complete(Box::new(account)))} else {@@ -201,135 +201,121 @@ pub fn build_passkey_verification_url(format!("{accounts_url}/passkeys/verify?{query}")}-pub fn unlock_with_password(- client: &AccountsClient,- auth_response: &AuthResponse,- password: &str,-) -> Result<AuthenticatedAccount> {- let attributes = auth_response- .key_attributes- .as_ref()- .ok_or(Error::MissingKeyAttributes)?;- let kek = derive_kek(- password,- &attributes.kek_salt,- attributes.mem_limit,- attributes.ops_limit,- )?;- unlock(client, auth_response, &kek)-}+impl AccountsClient {+ pub fn unlock_with_password(+ &self,+ auth_response: &AuthResponse,+ password: &str,+ ) -> Result<AuthenticatedAccount> {+ let attributes = auth_response+ .key_attributes+ .as_ref()+ .ok_or(Error::MissingKeyAttributes)?;+ let kek = derive_kek(+ password,+ &attributes.kek_salt,+ attributes.mem_limit,+ attributes.ops_limit,+ )?;+ self.unlock(auth_response, &kek)+ }-pub fn unlock(- client: &AccountsClient,- auth_response: &AuthResponse,- kek: &[u8],-) -> Result<AuthenticatedAccount> {- let key_attributes = auth_response- .key_attributes- .as_ref()- .ok_or(Error::MissingKeyAttributes)?;- let (master_key, secret_key) = auth::decrypt_keys_only(kek, key_attributes)?;- finish_unlock(- client,- auth_response,- key_attributes,- master_key,- secret_key,- )-}+ pub fn unlock(&self, auth_response: &AuthResponse, kek: &[u8]) -> Result<AuthenticatedAccount> {+ let key_attributes = auth_response+ .key_attributes+ .as_ref()+ .ok_or(Error::MissingKeyAttributes)?;+ let (master_key, secret_key) = auth::decrypt_keys_only(kek, key_attributes)?;+ self.finish_unlock(auth_response, key_attributes, master_key, secret_key)+ }-pub fn recover_account(- client: &AccountsClient,- auth_response: &AuthResponse,- recovery_key: &str,-) -> Result<AuthenticatedAccount> {- let attributes = auth_response- .key_attributes- .as_ref()- .ok_or(Error::MissingKeyAttributes)?;- let recovery_key = auth::recovery_key_from_mnemonic_or_hex(recovery_key)?;- let encrypted = attributes- .master_key_encrypted_with_recovery_key- .as_ref()- .ok_or(Error::MissingField(- "master_key_encrypted_with_recovery_key",- ))?;- let nonce = attributes- .master_key_decryption_nonce- .as_ref()- .ok_or(Error::MissingField("master_key_decryption_nonce"))?;- let master_key = SecretVec::new(- ente_core::crypto::secretbox::decrypt(- &b64::decode(encrypted)?,- &ente_core::crypto::Nonce::try_from_slice(&b64::decode(nonce)?)?,- &Key::try_from_slice(&recovery_key)?,- )- .map_err(|_| Error::IncorrectRecoveryKey)?,- );- unlock_with_master_key(client, auth_response, &master_key)-}+ pub fn recover_account(+ &self,+ auth_response: &AuthResponse,+ recovery_key: &str,+ ) -> Result<AuthenticatedAccount> {+ let attributes = auth_response+ .key_attributes+ .as_ref()+ .ok_or(Error::MissingKeyAttributes)?;+ let recovery_key = auth::recovery_key_from_mnemonic_or_hex(recovery_key)?;+ let encrypted = attributes+ .master_key_encrypted_with_recovery_key+ .as_ref()+ .ok_or(Error::MissingField(+ "master_key_encrypted_with_recovery_key",+ ))?;+ let nonce = attributes+ .master_key_decryption_nonce+ .as_ref()+ .ok_or(Error::MissingField("master_key_decryption_nonce"))?;+ let master_key = SecretVec::new(+ secretbox::decrypt(+ &b64::decode(encrypted)?,+ &Nonce::try_from_slice(&b64::decode(nonce)?)?,+ &Key::try_from_slice(&recovery_key)?,+ )+ .map_err(|_| Error::IncorrectRecoveryKey)?,+ );+ self.unlock_with_master_key(auth_response, &master_key)+ }-pub fn unlock_with_master_key(- client: &AccountsClient,- auth_response: &AuthResponse,- master_key: &[u8],-) -> Result<AuthenticatedAccount> {- let key_attributes = auth_response- .key_attributes- .as_ref()- .ok_or(Error::MissingKeyAttributes)?;- let master_key = Key::try_from_slice(master_key)?;- let secret_key = auth::decrypt_secret_key(&master_key, key_attributes)?;- finish_unlock(- client,- auth_response,- key_attributes,- master_key,- secret_key,- )-}+ pub fn unlock_with_master_key(+ &self,+ auth_response: &AuthResponse,+ master_key: &[u8],+ ) -> Result<AuthenticatedAccount> {+ let key_attributes = auth_response+ .key_attributes+ .as_ref()+ .ok_or(Error::MissingKeyAttributes)?;+ let master_key = Key::try_from_slice(master_key)?;+ let secret_key = auth::decrypt_secret_key(&master_key, key_attributes)?;+ self.finish_unlock(auth_response, key_attributes, master_key, secret_key)+ }-fn finish_unlock(- client: &AccountsClient,- auth_response: &AuthResponse,- key_attributes: &KeyAttributes,- master_key: Key,- secret_key: SecretKey,-) -> Result<AuthenticatedAccount> {- if auth_response.is_mfa_required() || auth_response.is_passkey_required() {- return Err(Error::InvalidInput(- "Second factor verification is required".into(),- ));+ fn finish_unlock(+ &self,+ auth_response: &AuthResponse,+ key_attributes: &KeyAttributes,+ master_key: Key,+ secret_key: SecretKey,+ ) -> Result<AuthenticatedAccount> {+ if auth_response.is_mfa_required() || auth_response.is_passkey_required() {+ return Err(Error::InvalidInput(+ "Second factor verification is required".into(),+ ));+ }+ let token = if let Some(encrypted_token) = &auth_response.encrypted_token {+ let token = SecretVec::new(+ sealed::open(+ &b64::decode(encrypted_token)?,+ &secret_key.public_key(),+ &secret_key,+ )+ .map_err(|_| Error::InvalidKeyAttributes)?,+ );+ payload::validate_auth_token(&self.api, &token)?;+ token+ } else if let Some(token) = &auth_response.token {+ decode_plain_token(token)?+ } else {+ return Err(Error::Protocol("No token in response".into()));+ };+ let public_key = b64::decode(&key_attributes.public_key)?;+ let recovery_key = get_recovery_key(&master_key, key_attributes)?;+ Ok(AuthenticatedAccount {+ user_id: auth_response.id,+ key_attributes: key_attributes.clone(),+ secrets: AccountSecrets {+ token: token.into_vec(),+ master_key: master_key.as_bytes().to_vec(),+ secret_key: secret_key.as_bytes().to_vec(),+ public_key,+ },+ recovery_key,+ })}- let token = if let Some(encrypted_token) = &auth_response.encrypted_token {- let token = SecretVec::new(- sealed::open(- &b64::decode(encrypted_token)?,- &secret_key.public_key(),- &secret_key,- )- .map_err(|_| Error::InvalidKeyAttributes)?,- );- payload::validate_auth_token(&client.api, &token)?;- token- } else if let Some(token) = &auth_response.token {- decode_plain_token(token)?- } else {- return Err(Error::Protocol("No token in response".into()));- };- let public_key = b64::decode(&key_attributes.public_key)?;- let recovery_key = get_recovery_key(&master_key, key_attributes)?;- Ok(AuthenticatedAccount {- user_id: auth_response.id,- key_attributes: key_attributes.clone(),- secrets: AccountSecrets {- token: token.into_vec(),- master_key: master_key.as_bytes().to_vec(),- secret_key: secret_key.as_bytes().to_vec(),- public_key,- },- recovery_key,- })}fn decode_plain_token(token: &str) -> Result<SecretVec> {diff --git a/rust/crates/accounts/src/login/tests.rs b/rust/crates/accounts/src/login/tests.rsindex cb58dbbc9c..8ef94e8d24 100644--- a/rust/crates/accounts/src/login/tests.rs+++ b/rust/crates/accounts/src/login/tests.rs@@ -406,13 +406,9 @@ fn recovery_unlocks_the_same_account_for_hex_and_mnemonic() {.unwrap();let recovery_key = &*keys.private_key_attributes.recovery_key;let mnemonic = auth::recovery_key_to_mnemonic(&hex::decode(recovery_key).unwrap()).unwrap();+ let client = make_client("https://api.ente.com".into());for value in [recovery_key, mnemonic.as_str()] {- let account = recover_account(- &make_client("https://api.ente.com".into()),- &response,- value,- )- .unwrap();+ let account = client.recover_account(&response, value).unwrap();assert_eq!(account.secrets.token, token);assert_eq!(b64::encode(&account.secrets.master_key),@@ -424,11 +420,7 @@ fn recovery_unlocks_the_same_account_for_hex_and_mnemonic() {);}assert!(matches!(- recover_account(- &make_client("https://api.ente.com".into()),- &response,- &hex::encode([0; 32])- ),+ client.recover_account(&response, &hex::encode([0; 32])),Err(Error::IncorrectRecoveryKey)));}@@ -462,13 +454,9 @@ fn encrypted_tokens_require_the_login_tag_on_enforced_endpoints() {})).unwrap();for result in [- unlock(&client, &response, &kek),- unlock_with_master_key(&client, &response, &master_key),- recover_account(- &client,- &response,- &keys.private_key_attributes.recovery_key,- ),+ client.unlock(&response, &kek),+ client.unlock_with_master_key(&response, &master_key),+ client.recover_account(&response, &keys.private_key_attributes.recovery_key),] {if tagged || origin == "https://self-hosted.example" {assert_eq!(result.unwrap().secrets.token, token);@@ -478,10 +466,7 @@ fn encrypted_tokens_require_the_login_tag_on_enforced_endpoints() {}response.encrypted_token = None;response.token = Some(b64::encode_url_safe(&token));- assert_eq!(- unlock(&client, &response, &kek).unwrap().secrets.token,- token- );+ assert_eq!(client.unlock(&response, &kek).unwrap().secrets.token, token);}}}diff --git a/rust/crates/accounts/tests/accounts.rs b/rust/crates/accounts/tests/accounts.rsindex bb1a84cc32..5a43be62e9 100644--- a/rust/crates/accounts/tests/accounts.rs+++ b/rust/crates/accounts/tests/accounts.rs@@ -7,7 +7,7 @@ use ente_accounts::{lifecycle::{change_password, check_session_validity, passkey_management_url, recover_two_factor,},- login::{LoginFlow, LoginStep, recover_account, unlock},+ login::{LoginFlow, LoginStep},models::TwoFactorType,signup::Signup,};@@ -86,13 +86,9 @@ async fn run(endpoint: String) -> TestResult {.await?;assert_eq!(recovered.id, created.user_id);let response = recovered.into();- let recovered =- ente_accounts::login::unlock_with_password(&recovery_client, &response, &password)?;- let restored = ente_accounts::login::unlock_with_master_key(- &recovery_client,- &response,- &created.secrets.master_key,- )?;+ let recovered = recovery_client.unlock_with_password(&response, &password)?;+ let restored =+ recovery_client.unlock_with_master_key(&response, &created.secrets.master_key)?;assert_eq!(restored.secrets.token, recovered.secrets.token);assert_eq!(restored.recovery_key, recovered.recovery_key);let recovery_client =@@ -148,13 +144,13 @@ async fn run(endpoint: String) -> TestResult {let (response, kek) = login_client.login_with_srp(&new_password, &changed.srp_attributes).await?;- let changed_login = unlock(&login_client, &response, &kek)?;+ let changed_login = login_client.unlock(&response, &kek)?;assert_eq!(changed_login.secrets.master_key, created.secrets.master_key);login_client.send_otp(&email, "login", false).await?;let response = login_client.verify_email(&email, HARDCODED_OTT, None).await?;- let recovered = recover_account(&login_client, &response, &created.recovery_key)?;+ let recovered = login_client.recover_account(&response, &created.recovery_key)?;assert_eq!(recovered.secrets.secret_key, created.secrets.secret_key);let recovered_client =login_client.with_auth_token(b64::encode_url_safe(&recovered.secrets.token));@@ -188,7 +184,7 @@ async fn run(endpoint: String) -> TestResult {.login_with_srp(&reset_password, &reset.srp_attributes).await?;assert_eq!(- unlock(&login_client, &response, &kek)?.secrets.master_key,+ login_client.unlock(&response, &kek)?.secrets.master_key,created.secrets.master_key);