Skip to content

armgit / ente

Public Imported from GitHub
0

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

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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
);