Skip to content

armgit / ente

Public Imported from GitHub
0

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

Move recovery operations to authenticated sessions

Manav Rathi311fbe5df08d
diff --git a/mobile/apps/locker/lib/services/authenticated_session.dart b/mobile/apps/locker/lib/services/authenticated_session.dart
index d0ba504b4a..be99759356 100644
--- a/mobile/apps/locker/lib/services/authenticated_session.dart
+++ b/mobile/apps/locker/lib/services/authenticated_session.dart
@@ -26,6 +26,11 @@ Session authenticatedSession() {
if (keyAttributes == null) {
throw StateError('Authenticated session is not available');
}
+ final encryptedRecoveryKey = keyAttributes.recoveryKeyEncryptedWithMasterKey;
+ final recoveryKeyNonce = keyAttributes.recoveryKeyDecryptionNonce;
+ if (encryptedRecoveryKey.isEmpty || recoveryKeyNonce.isEmpty) {
+ throw StateError('Recovery key is not available');
+ }
final services = ServiceLocator.instance;
final opened = openSession(
input: OpenSessionInput(
@@ -37,6 +42,8 @@ Session authenticatedSession() {
publicKey: keyAttributes.publicKey,
encryptedSecretKey: keyAttributes.encryptedSecretKey,
secretKeyDecryptionNonce: keyAttributes.secretKeyDecryptionNonce,
+ recoveryKeyEncryptedWithMasterKey: encryptedRecoveryKey,
+ recoveryKeyDecryptionNonce: recoveryKeyNonce,
),
userAgent:
services.enteDio.options.headers[HttpHeaders.userAgentHeader]
diff --git a/mobile/apps/locker/lib/ui/pages/home_page.dart b/mobile/apps/locker/lib/ui/pages/home_page.dart
index 76b79d60ad..4e98184f2b 100644
--- a/mobile/apps/locker/lib/ui/pages/home_page.dart
+++ b/mobile/apps/locker/lib/ui/pages/home_page.dart
@@ -231,6 +231,21 @@ class _HomePageState extends UploaderPageState<HomePage>
);
}
+ void _handleMissingRecoveryKey() {
+ final config = Configuration.instance;
+ if (!config.hasConfiguredAccount()) {
+ return;
+ }
+ final keyAttributes = config.getKeyAttributes();
+ if (keyAttributes == null) {
+ return;
+ }
+ if (keyAttributes.recoveryKeyEncryptedWithMasterKey.isEmpty ||
+ keyAttributes.recoveryKeyDecryptionNonce.isEmpty) {
+ Bus.instance.fire(TriggerLogoutEvent());
+ }
+ }
+
@override
void initState() {
super.initState();
@@ -277,6 +292,12 @@ class _HomePageState extends UploaderPageState<HomePage>
_legacyKitCreatedSubscription = Bus.instance
.on<LegacyKitCreatedEvent>()
.listen((_) => unawaited(_evaluateLegacyKit()));
+
+ WidgetsBinding.instance.addPostFrameCallback((_) {
+ if (mounted) {
+ _handleMissingRecoveryKey();
+ }
+ });
}
Future<void> _evaluateLegacyKit() async {
diff --git a/mobile/apps/photos/lib/services/authenticated_session.dart b/mobile/apps/photos/lib/services/authenticated_session.dart
index 59e7315394..9ec14b1619 100644
--- a/mobile/apps/photos/lib/services/authenticated_session.dart
+++ b/mobile/apps/photos/lib/services/authenticated_session.dart
@@ -26,6 +26,14 @@ Session authenticatedSession() {
if (keyAttributes == null) {
throw StateError('Authenticated session is not available');
}
+ final encryptedRecoveryKey = keyAttributes.recoveryKeyEncryptedWithMasterKey;
+ final recoveryKeyNonce = keyAttributes.recoveryKeyDecryptionNonce;
+ if (encryptedRecoveryKey == null ||
+ encryptedRecoveryKey.isEmpty ||
+ recoveryKeyNonce == null ||
+ recoveryKeyNonce.isEmpty) {
+ throw StateError('Recovery key is not available');
+ }
final services = ServiceLocator.instance;
final opened = openSession(
input: OpenSessionInput(
@@ -37,6 +45,8 @@ Session authenticatedSession() {
publicKey: keyAttributes.publicKey,
encryptedSecretKey: keyAttributes.encryptedSecretKey,
secretKeyDecryptionNonce: keyAttributes.secretKeyDecryptionNonce,
+ recoveryKeyEncryptedWithMasterKey: encryptedRecoveryKey,
+ recoveryKeyDecryptionNonce: recoveryKeyNonce,
),
userAgent:
services.enteDio.options.headers[HttpHeaders.userAgentHeader]
diff --git a/mobile/apps/photos/lib/ui/tabs/home_widget.dart b/mobile/apps/photos/lib/ui/tabs/home_widget.dart
index 40509a653e..8d8a6fc33f 100644
--- a/mobile/apps/photos/lib/ui/tabs/home_widget.dart
+++ b/mobile/apps/photos/lib/ui/tabs/home_widget.dart
@@ -156,6 +156,26 @@ class _HomeWidgetState extends State<HomeWidget> {
});
}
+ void _handleMissingRecoveryKey() {
+ final config = Configuration.instance;
+ if (!config.hasConfiguredAccount()) {
+ return;
+ }
+ final keyAttributes = config.getKeyAttributes();
+ if (keyAttributes == null) {
+ return;
+ }
+ final encryptedRecoveryKey =
+ keyAttributes.recoveryKeyEncryptedWithMasterKey;
+ final recoveryKeyNonce = keyAttributes.recoveryKeyDecryptionNonce;
+ if (encryptedRecoveryKey == null ||
+ encryptedRecoveryKey.isEmpty ||
+ recoveryKeyNonce == null ||
+ recoveryKeyNonce.isEmpty) {
+ Bus.instance.fire(TriggerLogoutEvent());
+ }
+ }
+
@override
void initState() {
_logger.info("initstate");
@@ -209,6 +229,7 @@ class _HomeWidgetState extends State<HomeWidget> {
) {
_startWithoutAccount = false;
setState(() {});
+ _handleMissingRecoveryKey();
if (!isLocalGalleryMode) {
flagService.flags;
}
@@ -318,6 +339,11 @@ class _HomeWidgetState extends State<HomeWidget> {
if (!isLocalGalleryMode && Configuration.instance.hasConfiguredAccount()) {
MemoryShareService.instance.listMemoryShares().ignore();
}
+ WidgetsBinding.instance.addPostFrameCallback((_) {
+ if (mounted) {
+ _handleMissingRecoveryKey();
+ }
+ });
}
Future<void> syncWidget() async {
diff --git a/rust/bindings/frb/lib/src/session.rs b/rust/bindings/frb/lib/src/session.rs
index 4c034706ab..cf88080fd4 100644
--- a/rust/bindings/frb/lib/src/session.rs
+++ b/rust/bindings/frb/lib/src/session.rs
@@ -2,7 +2,7 @@ use std::sync::Arc;
use ente_core::{
Session as InnerSession, b64,
- crypto::{Key, Nonce, PublicKey, SecretKey, secretbox::EncryptedBox},
+ crypto::{Key, Nonce, PublicKey, SecretKey, secretbox, secretbox::EncryptedBox},
http::{ApiConfig, Auth},
};
use flutter_rust_bridge::frb;
@@ -29,6 +29,8 @@ pub struct SessionKeyAttributes {
pub public_key: String,
pub encrypted_secret_key: String,
pub secret_key_decryption_nonce: String,
+ pub recovery_key_encrypted_with_master_key: String,
+ pub recovery_key_decryption_nonce: String,
}
#[frb(non_opaque)]
@@ -56,6 +58,12 @@ pub fn open_session(input: OpenSessionInput) -> Result<Session, SessionError> {
client_version,
} = input;
let master_key = Key::try_from_slice(&master_key)?;
+ let recovery_key = secretbox::decrypt(
+ &b64::decode(&key_attributes.recovery_key_encrypted_with_master_key)?,
+ &Nonce::try_from_slice(&b64::decode(&key_attributes.recovery_key_decryption_nonce)?)?,
+ &master_key,
+ )?;
+ let recovery_key = Key::try_from_slice(&recovery_key)?;
let secret_key = SecretKey::open(
&EncryptedBox {
encrypted_data: b64::decode(&key_attributes.encrypted_secret_key)?,
@@ -76,6 +84,7 @@ pub fn open_session(input: OpenSessionInput) -> Result<Session, SessionError> {
},
user_id,
master_key,
+ recovery_key,
secret_key,
)?)))
}
diff --git a/rust/bindings/wasm/lib/Cargo.toml b/rust/bindings/wasm/lib/Cargo.toml
index d5bfcacc81..042319632f 100644
--- a/rust/bindings/wasm/lib/Cargo.toml
+++ b/rust/bindings/wasm/lib/Cargo.toml
@@ -15,7 +15,12 @@ crypto-file = ["crypto", "dep:md-5"]
crypto-seal = ["crypto"]
locker = ["session", "dep:ente-locker"]
prelogin = ["accounts", "crypto"]
-session = ["dep:serde", "dep:serde-wasm-bindgen", "dep:tsify"]
+session = [
+ "dep:ente-accounts",
+ "dep:serde",
+ "dep:serde-wasm-bindgen",
+ "dep:tsify",
+]
[dependencies]
ente-accounts = { workspace = true, optional = true }
diff --git a/rust/bindings/wasm/lib/src/crypto.rs b/rust/bindings/wasm/lib/src/crypto.rs
index 1a9a47dc1c..c85f5728b5 100644
--- a/rust/bindings/wasm/lib/src/crypto.rs
+++ b/rust/bindings/wasm/lib/src/crypto.rs
@@ -1,6 +1,8 @@
use ente_core::{b64, crypto};
use wasm_bindgen::prelude::*;
+use crate::EncryptedBox;
+
#[cfg(feature = "crypto-file")]
mod file;
@@ -40,25 +42,11 @@ pub fn crypto_generate_key() -> String {
b64::encode(crypto::Key::generate().as_bytes())
}
-#[wasm_bindgen(getter_with_clone)]
-pub struct EncryptedBox {
- #[wasm_bindgen(readonly, js_name = encryptedData)]
- pub encrypted_data: String,
- #[wasm_bindgen(readonly)]
- pub nonce: String,
-}
-
#[wasm_bindgen(js_name = cryptoEncryptBox)]
pub fn crypto_encrypt_box(data_b64: &str, key_b64: &str) -> Result<EncryptedBox, Error> {
let data = b64::decode(data_b64)?;
let key = b64::decode(key_b64)?;
-
- let out = crypto::secretbox::encrypt(&data, &crypto::Key::try_from_slice(&key)?);
-
- Ok(EncryptedBox {
- encrypted_data: b64::encode(&out.encrypted_data),
- nonce: b64::encode(out.nonce.as_bytes()),
- })
+ Ok(crypto::secretbox::encrypt(&data, &crypto::Key::try_from_slice(&key)?).into())
}
#[wasm_bindgen(js_name = cryptoDecryptBox)]
diff --git a/rust/bindings/wasm/lib/src/lib.rs b/rust/bindings/wasm/lib/src/lib.rs
index d3fc7b7a2a..f626c338da 100644
--- a/rust/bindings/wasm/lib/src/lib.rs
+++ b/rust/bindings/wasm/lib/src/lib.rs
@@ -13,3 +13,8 @@ mod logging;
mod prelogin;
#[cfg(feature = "session")]
pub mod session;
+#[cfg(any(feature = "crypto", feature = "session"))]
+mod types;
+
+#[cfg(any(feature = "crypto", feature = "session"))]
+pub use types::EncryptedBox;
diff --git a/rust/bindings/wasm/lib/src/prelogin.rs b/rust/bindings/wasm/lib/src/prelogin.rs
index 3c87b0bc08..38bb318117 100644
--- a/rust/bindings/wasm/lib/src/prelogin.rs
+++ b/rust/bindings/wasm/lib/src/prelogin.rs
@@ -59,7 +59,9 @@ pub fn auth_recovery_key_from_mnemonic_or_hex(input: &str) -> Result<String, Acc
#[wasm_bindgen(js_name = authRecoveryKeyToMnemonic)]
pub fn auth_recovery_key_to_mnemonic(recovery_key_b64: &str) -> Result<String, AccountsError> {
- auth::recovery_key_to_mnemonic(recovery_key_b64).map_err(Into::into)
+ let recovery_key = b64::decode(recovery_key_b64)
+ .map_err(|e| ente_accounts::Error::Decode(format!("recovery_key: {e}")))?;
+ auth::recovery_key_to_mnemonic(&recovery_key).map_err(Into::into)
}
#[wasm_bindgen]
diff --git a/rust/bindings/wasm/lib/src/session.rs b/rust/bindings/wasm/lib/src/session.rs
index b4c62bc1fb..d7cd2dd62a 100644
--- a/rust/bindings/wasm/lib/src/session.rs
+++ b/rust/bindings/wasm/lib/src/session.rs
@@ -2,15 +2,19 @@ use std::sync::Arc;
use ente_core::{
Session as InnerSession, b64,
- crypto::{self, Key, Nonce, PublicKey, SecretKey, secretbox::EncryptedBox},
+ crypto::{self, Key, Nonce, PublicKey, SecretKey},
http::{ApiConfig, Auth},
};
use serde::Deserialize;
use tsify::{Ts, Tsify};
use wasm_bindgen::prelude::*;
+use crate::EncryptedBox;
+
#[derive(Debug, thiserror::Error)]
pub enum Error {
+ #[error(transparent)]
+ Accounts(#[from] ente_accounts::Error),
#[error(transparent)]
Input(#[from] tsify::Error),
#[error(transparent)]
@@ -19,11 +23,16 @@ pub enum Error {
Decode(#[from] b64::DecodeError),
#[error(transparent)]
Crypto(#[from] crypto::Error),
+ #[error("Missing recovery key")]
+ MissingRecoveryKey,
}
impl Error {
fn name(&self) -> Option<&'static str> {
- None
+ match self {
+ Self::MissingRecoveryKey => Some("missing_recovery_key"),
+ _ => None,
+ }
}
fn message(&self) -> String {
@@ -47,6 +56,10 @@ pub struct SessionKeyAttributes {
public_key: String,
encrypted_secret_key: String,
secret_key_decryption_nonce: String,
+ #[tsify(optional)]
+ recovery_key_encrypted_with_master_key: Option<String>,
+ #[tsify(optional)]
+ recovery_key_decryption_nonce: Option<String>,
}
#[derive(Deserialize, Tsify)]
@@ -76,8 +89,22 @@ pub fn open_session(input: Ts<OpenSessionInput>) -> Result<Session, Error> {
client_version,
} = input.to_rust()?;
let master_key = Key::try_from_slice(&b64::decode(&master_key_b64)?)?;
+ let encrypted_recovery_key = key_attributes
+ .recovery_key_encrypted_with_master_key
+ .filter(|value| !value.is_empty())
+ .ok_or(Error::MissingRecoveryKey)?;
+ let recovery_key_nonce = key_attributes
+ .recovery_key_decryption_nonce
+ .filter(|value| !value.is_empty())
+ .ok_or(Error::MissingRecoveryKey)?;
+ let recovery_key = crypto::secretbox::decrypt(
+ &b64::decode(&encrypted_recovery_key)?,
+ &Nonce::try_from_slice(&b64::decode(&recovery_key_nonce)?)?,
+ &master_key,
+ )?;
+ let recovery_key = Key::try_from_slice(&recovery_key)?;
let secret_key = SecretKey::open(
- &EncryptedBox {
+ &crypto::secretbox::EncryptedBox {
encrypted_data: b64::decode(&key_attributes.encrypted_secret_key)?,
nonce: Nonce::try_from_slice(&b64::decode(
&key_attributes.secret_key_decryption_nonce,
@@ -96,6 +123,7 @@ pub fn open_session(input: Ts<OpenSessionInput>) -> Result<Session, Error> {
},
user_id,
master_key,
+ recovery_key,
secret_key,
)?)))
}
@@ -111,6 +139,17 @@ impl Session {
#[wasm_bindgen]
impl Session {
+ #[wasm_bindgen(js_name = encryptWithRecoveryKey)]
+ pub fn encrypt_with_recovery_key(&self, data_b64: &str) -> Result<EncryptedBox, Error> {
+ Ok(crypto::secretbox::encrypt(&b64::decode(data_b64)?, &self.0.recovery_key).into())
+ }
+
+ #[wasm_bindgen(js_name = recoveryKeyMnemonic)]
+ pub fn recovery_key_mnemonic(&self) -> Result<String, Error> {
+ ente_accounts::auth::recovery_key_to_mnemonic(self.0.recovery_key.as_bytes())
+ .map_err(Into::into)
+ }
+
#[wasm_bindgen(js_name = updateAuthToken)]
pub fn update_auth_token(&self, auth_token: String) {
self.0.api.set_auth(Some(Auth::User(auth_token)));
diff --git a/rust/bindings/wasm/lib/src/types.rs b/rust/bindings/wasm/lib/src/types.rs
new file mode 100644
index 0000000000..b655815276
--- /dev/null
+++ b/rust/bindings/wasm/lib/src/types.rs
@@ -0,0 +1,19 @@
+use ente_core::{b64, crypto};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(getter_with_clone)]
+pub struct EncryptedBox {
+ #[wasm_bindgen(readonly, js_name = encryptedData)]
+ pub encrypted_data: String,
+ #[wasm_bindgen(readonly)]
+ pub nonce: String,
+}
+
+impl From<crypto::secretbox::EncryptedBox> for EncryptedBox {
+ fn from(value: crypto::secretbox::EncryptedBox) -> Self {
+ Self {
+ encrypted_data: b64::encode(&value.encrypted_data),
+ nonce: b64::encode(value.nonce.as_bytes()),
+ }
+ }
+}
diff --git a/rust/bindings/wasm/photos/Cargo.toml b/rust/bindings/wasm/photos/Cargo.toml
index ea1bdad800..f507b9bcc3 100644
--- a/rust/bindings/wasm/photos/Cargo.toml
+++ b/rust/bindings/wasm/photos/Cargo.toml
@@ -6,7 +6,7 @@ edition.workspace = true
crate-type = ["cdylib"]
[dependencies]
-ente-wasm-lib = { workspace = true, features = ["collections", "contacts"] }
+ente-wasm-lib = { workspace = true, features = ["collections", "contacts", "crypto"] }
[lints]
workspace = true
diff --git a/rust/crates/accounts/src/auth/recovery.rs b/rust/crates/accounts/src/auth/recovery.rs
index 0065d41ecb..7c0b5b8ed9 100644
--- a/rust/crates/accounts/src/auth/recovery.rs
+++ b/rust/crates/accounts/src/auth/recovery.rs
@@ -64,16 +64,12 @@ pub fn recovery_key_from_mnemonic_or_hex(recovery_key_mnemonic_or_hex: &str) ->
Ok(recovery_key)
}
-pub fn recovery_key_to_mnemonic(recovery_key_b64: &str) -> Result<String> {
- let recovery_key = SecretVec::new(
- b64::decode(recovery_key_b64).map_err(|e| Error::Decode(format!("recovery_key: {e}")))?,
- );
-
+pub fn recovery_key_to_mnemonic(recovery_key: &[u8]) -> Result<String> {
if recovery_key.len() != 32 {
return Err(Error::IncorrectRecoveryKey);
}
- Mnemonic::from_entropy_in(Language::English, &recovery_key)
+ Mnemonic::from_entropy_in(Language::English, recovery_key)
.map(|mnemonic| mnemonic.to_string())
.map_err(|e| Error::InvalidKey(format!("recovery_key: {e}")))
}
@@ -108,9 +104,9 @@ mod tests {
Key::try_from_slice(&b64::decode(&gen_result.private_key_attributes.key).unwrap())
.unwrap();
let recovery_key_hex = get_recovery_key(&master_key, &gen_result.key_attributes).unwrap();
- let recovery_key_b64 = b64::encode(&hex::decode(&recovery_key_hex).unwrap());
+ let recovery_key = hex::decode(&recovery_key_hex).unwrap();
- let mnemonic = recovery_key_to_mnemonic(&recovery_key_b64).unwrap();
+ let mnemonic = recovery_key_to_mnemonic(&recovery_key).unwrap();
let decoded = recovery_key_from_mnemonic_or_hex(&mnemonic).unwrap();
assert_eq!(
diff --git a/rust/crates/collections/src/lib.rs b/rust/crates/collections/src/lib.rs
index cd22ad22d0..06ee4aec41 100644
--- a/rust/crates/collections/src/lib.rs
+++ b/rust/crates/collections/src/lib.rs
@@ -58,6 +58,7 @@ mod tests {
},
42,
master_key,
+ Key::generate(),
secret_key,
)
.unwrap();
diff --git a/rust/crates/contacts/tests/contacts_mock.rs b/rust/crates/contacts/tests/contacts_mock.rs
index b0e045a153..19e9d76d4d 100644
--- a/rust/crates/contacts/tests/contacts_mock.rs
+++ b/rust/crates/contacts/tests/contacts_mock.rs
@@ -39,6 +39,7 @@ fn open(
api,
user_id: 0,
master_key: Key::try_from_slice(&master_key).unwrap(),
+ recovery_key: Key::generate(),
secret_key: SecretKey::generate(),
},
wrapped_root_contact_key: RwLock::new(cached_wrapped_root_contact_key),
diff --git a/rust/crates/contacts/tests/support/auth.rs b/rust/crates/contacts/tests/support/auth.rs
index 8e09bfacbf..92f5f35da5 100644
--- a/rust/crates/contacts/tests/support/auth.rs
+++ b/rust/crates/contacts/tests/support/auth.rs
@@ -1,6 +1,8 @@
use std::time::{Duration, SystemTime, UNIX_EPOCH};
-use ente_accounts::auth::{SrpSession, generate_srp_setup_with_login_key};
+use ente_accounts::auth::{
+ SrpSession, generate_srp_setup_with_login_key, recovery_key_from_mnemonic_or_hex,
+};
use ente_accounts::{
AccountsClient, AccountsClientConfig, AuthFlow, AuthFlowUi, AuthenticatedAccount,
CreateAccountParams, KeyAttributes, LoginParams, OtpPurpose, SecondFactorMethod,
@@ -27,6 +29,7 @@ pub struct TestAccount {
pub user_id: i64,
pub auth_token: String,
pub master_key: Vec<u8>,
+ pub recovery_key: Vec<u8>,
pub secret_key: Vec<u8>,
pub key_attributes: KeyAttributes,
}
@@ -230,6 +233,7 @@ pub async fn create_fixture_account(endpoint: &str, email_prefix: &str) -> TestA
user_id: verification.id,
auth_token,
master_key: master_key.as_bytes().to_vec(),
+ recovery_key: recovery_key.as_bytes().to_vec(),
secret_key: secret_key.as_bytes().to_vec(),
key_attributes,
}
@@ -309,10 +313,14 @@ pub fn test_account_from_authenticated(
password: String,
authenticated: AuthenticatedAccount,
) -> TestAccount {
- assert!(
- authenticated.recovery_key.is_some(),
- "signup should return a recovery key"
- );
+ let recovery_key = recovery_key_from_mnemonic_or_hex(
+ authenticated
+ .recovery_key
+ .as_deref()
+ .expect("authentication should return a recovery key"),
+ )
+ .expect("authentication recovery key should be valid")
+ .into_vec();
TestAccount {
email,
@@ -320,6 +328,7 @@ pub fn test_account_from_authenticated(
user_id: authenticated.user_id,
auth_token: auth_token_from_authenticated(&authenticated),
master_key: authenticated.secrets.master_key.clone(),
+ recovery_key,
secret_key: authenticated.secrets.secret_key.clone(),
key_attributes: authenticated.key_attributes,
}
diff --git a/rust/crates/contacts/tests/support/contacts.rs b/rust/crates/contacts/tests/support/contacts.rs
index 4db015a4c7..ce34fd9af3 100644
--- a/rust/crates/contacts/tests/support/contacts.rs
+++ b/rust/crates/contacts/tests/support/contacts.rs
@@ -81,6 +81,7 @@ pub fn open_client(endpoint: &str, account: &TestAccount) -> Client {
api,
user_id: account.user_id,
master_key: Key::try_from_slice(&account.master_key).unwrap(),
+ recovery_key: Key::try_from_slice(&account.recovery_key).unwrap(),
secret_key: ente_core::crypto::SecretKey::try_from_slice(&account.secret_key).unwrap(),
},
wrapped_root_contact_key: RwLock::new(None),
diff --git a/rust/crates/contacts/tests/support/legacy.rs b/rust/crates/contacts/tests/support/legacy.rs
index aa635de4c4..42deb48529 100644
--- a/rust/crates/contacts/tests/support/legacy.rs
+++ b/rust/crates/contacts/tests/support/legacy.rs
@@ -31,6 +31,7 @@ pub fn open_session(endpoint: &str, account: &TestAccount) -> Session {
},
account.user_id,
Key::try_from_slice(&account.master_key).unwrap(),
+ Key::try_from_slice(&account.recovery_key).unwrap(),
SecretKey::try_from_slice(&account.secret_key).unwrap(),
)
.unwrap()
diff --git a/rust/crates/core/src/session.rs b/rust/crates/core/src/session.rs
index b6088cb9a4..104c0839ec 100644
--- a/rust/crates/core/src/session.rs
+++ b/rust/crates/core/src/session.rs
@@ -7,6 +7,7 @@ pub struct Session {
pub api: Api,
pub user_id: i64,
pub master_key: Key,
+ pub recovery_key: Key,
pub secret_key: SecretKey,
}
@@ -15,12 +16,14 @@ impl Session {
config: ApiConfig,
user_id: i64,
master_key: Key,
+ recovery_key: Key,
secret_key: SecretKey,
) -> Result<Self, Error> {
Ok(Self {
api: Api::new(Http::new()?, config),
user_id,
master_key,
+ recovery_key,
secret_key,
})
}
diff --git a/rust/crates/legacy/src/client/contact.rs b/rust/crates/legacy/src/client/contact.rs
index f20e9933ef..b646a2f100 100644
--- a/rust/crates/legacy/src/client/contact.rs
+++ b/rust/crates/legacy/src/client/contact.rs
@@ -97,8 +97,7 @@ pub async fn public_key(session: &Session, email: &str) -> Result<Option<String>
pub fn verification_id(public_key_b64: &str) -> Result<String> {
let public_key = b64::decode(public_key_b64)?;
let digest = Sha256::digest(&public_key);
- ente_accounts::auth::recovery_key_to_mnemonic(&b64::encode(digest.as_slice()))
- .map_err(Into::into)
+ ente_accounts::auth::recovery_key_to_mnemonic(digest.as_slice()).map_err(Into::into)
}
pub async fn add_contact(
diff --git a/rust/crates/locker/src/lib.rs b/rust/crates/locker/src/lib.rs
index fd557cb19f..bba6d6bb7a 100644
--- a/rust/crates/locker/src/lib.rs
+++ b/rust/crates/locker/src/lib.rs
@@ -92,6 +92,7 @@ mod tests {
},
1,
Key::generate(),
+ Key::generate(),
SecretKey::generate(),
)
.unwrap();
diff --git a/rust/crates/ml/src/vecdb/log.rs b/rust/crates/ml/src/vecdb/log.rs
index f66c0675ba..8a42ee38e8 100644
--- a/rust/crates/ml/src/vecdb/log.rs
+++ b/rust/crates/ml/src/vecdb/log.rs
@@ -2616,10 +2616,7 @@ mod tests {
(
LogRecord::Add {
key: "k1".to_string(),
- vector: StoredVector::I8 {
- scale,
- values: values.clone()
- },
+ vector: StoredVector::I8 { scale, values },
attrs: Vec::new()
},
32
diff --git a/rust/crates/ml/src/vecdb/store.rs b/rust/crates/ml/src/vecdb/store.rs
index 4280792bda..8eb994ae03 100644
--- a/rust/crates/ml/src/vecdb/store.rs
+++ b/rust/crates/ml/src/vecdb/store.rs
@@ -5207,8 +5207,8 @@ mod tests {
..SearchParams::default()
};
let stored_keys: Vec<String> = ["key-1", "key-50", "key-100", "key-299"]
- .iter()
- .map(|key| key.to_string())
+ .into_iter()
+ .map(String::from)
.collect();
let exact_before = db.search(&query, &exact).unwrap();
assert_eq!(exact_before.len(), 80);
diff --git a/web/apps/auth/src/pages/two-factor/setup.tsx b/web/apps/auth/src/pages/two-factor/setup.tsx
index 7f9adb38e6..be83cb097c 100644
--- a/web/apps/auth/src/pages/two-factor/setup.tsx
+++ b/web/apps/auth/src/pages/two-factor/setup.tsx
@@ -1 +1,10 @@
-export { default } from "ente-accounts/pages/two-factor/setup";
+import TwoFactorSetupPage from "ente-accounts/pages/two-factor/setup";
+import { encryptWithPreloginRecoveryKey } from "ente-accounts/services/recovery-key";
+
+export default function Page() {
+ return (
+ <TwoFactorSetupPage
+ encryptWithRecoveryKey={encryptWithPreloginRecoveryKey}
+ />
+ );
+}
diff --git a/web/apps/locker/src/components/LockerAccountDrawer.tsx b/web/apps/locker/src/components/LockerAccountDrawer.tsx
index 73258e5573..05ec3edec7 100644
--- a/web/apps/locker/src/components/LockerAccountDrawer.tsx
+++ b/web/apps/locker/src/components/LockerAccountDrawer.tsx
@@ -1,3 +1,7 @@
+import {
+ generatePasskeyRecovery,
+ recoveryKeyMnemonic,
+} from "@/services/authenticated-session";
import {
ComputerPhoneSyncIcon,
Key01Icon,
@@ -88,7 +92,7 @@ export const LockerAccountDrawer: React.FC<
const handleOpenPasskeys = async () => {
handleRootClose();
try {
- await openAccountsManagePasskeysPage();
+ await openAccountsManagePasskeysPage(generatePasskeyRecovery);
} catch (e) {
onGenericError(e);
}
@@ -177,6 +181,7 @@ export const LockerAccountDrawer: React.FC<
<RecoveryKey
open={isRecoveryKeyOpen}
onClose={() => setIsRecoveryKeyOpen(false)}
+ getRecoveryKeyMnemonic={recoveryKeyMnemonic}
showMiniDialog={showMiniDialog}
/>
</>
diff --git a/web/apps/locker/src/components/lockerPage/use-locker-data.ts b/web/apps/locker/src/components/lockerPage/use-locker-data.ts
index bcd6c98725..78282de970 100644
--- a/web/apps/locker/src/components/lockerPage/use-locker-data.ts
+++ b/web/apps/locker/src/components/lockerPage/use-locker-data.ts
@@ -16,6 +16,7 @@ import {
import { stashRedirect } from "ente-accounts/services/redirect";
import { ensureLocalUser } from "ente-accounts/services/user";
import type { MiniDialogAttributes } from "ente-base/components/MiniDialog";
+import { isNamedError } from "ente-base/error";
import {
authenticatedRequestHeaders,
ensureOk,
@@ -322,6 +323,8 @@ export const useLockerData = ({
);
return;
}
+
+ await openAuthenticatedSession(ensureLocalUser().id, token, mk);
if (!canApplyState()) {
return;
}
@@ -350,6 +353,10 @@ export const useLockerData = ({
}
} catch (error) {
log.error("Failed to fetch locker data", error);
+ if (isNamedError(error, "missing_recovery_key")) {
+ showMiniDialog(sessionExpiredDialogAttributes(logout));
+ return;
+ }
if (isHTTP401Error(error)) {
showMiniDialog(sessionExpiredDialogAttributes(logout));
}
diff --git a/web/apps/locker/src/pages/two-factor/setup.tsx b/web/apps/locker/src/pages/two-factor/setup.tsx
index 7f9adb38e6..aad48bf538 100644
--- a/web/apps/locker/src/pages/two-factor/setup.tsx
+++ b/web/apps/locker/src/pages/two-factor/setup.tsx
@@ -1 +1,8 @@
-export { default } from "ente-accounts/pages/two-factor/setup";
+import { encryptWithRecoveryKey } from "@/services/authenticated-session";
+import TwoFactorSetupPage from "ente-accounts/pages/two-factor/setup";
+
+export default function Page() {
+ return (
+ <TwoFactorSetupPage encryptWithRecoveryKey={encryptWithRecoveryKey} />
+ );
+}
diff --git a/web/apps/locker/src/services/authenticated-session.ts b/web/apps/locker/src/services/authenticated-session.ts
index 3073eeb034..ff49bef707 100644
--- a/web/apps/locker/src/services/authenticated-session.ts
+++ b/web/apps/locker/src/services/authenticated-session.ts
@@ -1,3 +1,4 @@
+import { createAuthenticatedRecoveryKeyOps } from "ente-accounts/services/authenticated-recovery-key";
import {
ensureLocalUser,
ensureSavedKeyAttributes,
@@ -6,7 +7,12 @@ import { clientPackageName, desktopAppVersion, isDesktop } from "ente-base/app";
import { apiOrigin } from "ente-base/origins";
import { savedAuthToken } from "ente-base/token";
import { openSession as openLegacySession } from "ente-legacy-wasm/authenticated";
-import { openSession, type Session } from "ente-locker-wasm";
+import {
+ encryptBoxWithRecoveryKey,
+ generateKey,
+ openSession,
+ type Session,
+} from "ente-locker-wasm";
import { masterKeyFromSession } from "./account-keys";
const lockerSessions = sessionCache(openSession);
@@ -49,6 +55,16 @@ export const clearAuthenticatedSession = () => {
legacySessions.clear();
};
+export const {
+ encryptWithRecoveryKey,
+ generatePasskeyRecovery,
+ recoveryKeyMnemonic,
+} = createAuthenticatedRecoveryKeyOps({
+ ensureSession: ensureAuthenticatedSession,
+ encryptBox: encryptBoxWithRecoveryKey,
+ generateKey,
+});
+
function sessionCache<T extends Pick<Session, "free" | "updateAuthToken">>(
open: (config: Parameters<typeof openSession>[0]) => Promise<T>,
) {
diff --git a/web/apps/locker/tests/authenticated-session.test.ts b/web/apps/locker/tests/authenticated-session.test.ts
index 859568717b..c530233d8e 100644
--- a/web/apps/locker/tests/authenticated-session.test.ts
+++ b/web/apps/locker/tests/authenticated-session.test.ts
@@ -7,6 +7,8 @@ const {
masterKeyFromSession,
keyAttributes,
user,
+ encryptBoxWithRecoveryKey,
+ generateKey,
openLocker,
openLegacy,
} = vi.hoisted(() => ({
@@ -17,8 +19,13 @@ const {
publicKey: "public-key",
encryptedSecretKey: "encrypted-secret-key",
secretKeyDecryptionNonce: "secret-key-nonce",
+ recoveryKeyEncryptedWithMasterKey: "encrypted-recovery-key",
+ recoveryKeyDecryptionNonce: "recovery-key-nonce",
},
user: { id: 1 },
+ encryptBoxWithRecoveryKey:
+ vi.fn<typeof import("ente-locker-wasm").encryptBoxWithRecoveryKey>(),
+ generateKey: vi.fn<typeof import("ente-locker-wasm").generateKey>(),
openLocker: vi.fn<typeof import("ente-locker-wasm").openSession>(),
openLegacy:
vi.fn<typeof import("ente-legacy-wasm/authenticated").openSession>(),
@@ -36,7 +43,11 @@ vi.mock("ente-accounts/services/user", () => ({
ensureLocalUser: () => user,
ensureSavedKeyAttributes: () => keyAttributes,
}));
-vi.mock("ente-locker-wasm", () => ({ openSession: openLocker }));
+vi.mock("ente-locker-wasm", () => ({
+ encryptBoxWithRecoveryKey,
+ generateKey,
+ openSession: openLocker,
+}));
vi.mock("ente-legacy-wasm/authenticated", () => ({ openSession: openLegacy }));
let sessions: typeof import("../src/services/authenticated-session");
@@ -164,7 +175,9 @@ test("failed opens can be retried and account changes replace the cached Legacy
const mockSession = () =>
({
+ encryptWithRecoveryKey: vi.fn(),
free: vi.fn(),
+ recoveryKeyMnemonic: vi.fn(),
updateAuthToken: vi.fn(),
[Symbol.dispose]: vi.fn(),
}) satisfies Session;
diff --git a/web/apps/locker/tests/logout.test.ts b/web/apps/locker/tests/logout.test.ts
index 1f23d04614..ff43eedd59 100644
--- a/web/apps/locker/tests/logout.test.ts
+++ b/web/apps/locker/tests/logout.test.ts
@@ -2,8 +2,16 @@ import { expect, test, vi } from "vitest";
import { openAuthenticatedSession } from "../src/services/authenticated-session";
import { lockerLogout } from "../src/services/logout";
-const { apiOrigin, openSession, accountLogout } = vi.hoisted(() => ({
+const {
+ apiOrigin,
+ encryptBoxWithRecoveryKey,
+ generateKey,
+ openSession,
+ accountLogout,
+} = vi.hoisted(() => ({
apiOrigin: vi.fn<() => Promise<string>>(),
+ encryptBoxWithRecoveryKey: vi.fn(),
+ generateKey: vi.fn(),
openSession: vi.fn(() =>
Promise.resolve({ free: vi.fn(), updateAuthToken: vi.fn() }),
),
@@ -29,13 +37,19 @@ vi.mock("ente-accounts/services/user", () => ({
publicKey: "public-key",
encryptedSecretKey: "encrypted-secret-key",
secretKeyDecryptionNonce: "secret-key-nonce",
+ recoveryKeyEncryptedWithMasterKey: "encrypted-recovery-key",
+ recoveryKeyDecryptionNonce: "recovery-key-nonce",
}),
}));
vi.mock("ente-accounts/services/accounts-db", () => ({
savedLocalUser: () => ({ id: 1 }),
}));
vi.mock("ente-accounts/services/logout", () => ({ accountLogout }));
-vi.mock("ente-locker-wasm", () => ({ openSession }));
+vi.mock("ente-locker-wasm", () => ({
+ encryptBoxWithRecoveryKey,
+ generateKey,
+ openSession,
+}));
vi.mock("ente-legacy-wasm/authenticated", () => ({ openSession }));
vi.mock("../src/services/locker-db", () => ({ clearLockerDB: vi.fn() }));
diff --git a/web/apps/photos/src/components/Sidebar.tsx b/web/apps/photos/src/components/Sidebar.tsx
index 64fe788fb0..4b9390c965 100644
--- a/web/apps/photos/src/components/Sidebar.tsx
+++ b/web/apps/photos/src/components/Sidebar.tsx
@@ -8,6 +8,10 @@ import { ReferralSettings } from "@/components/sidebar/ReferralSettings";
import { SessionsSettings } from "@/components/sidebar/SessionsSettings";
import { TwoFactorSettings } from "@/components/sidebar/TwoFactorSettings";
import { downloadAppDialogAttributes } from "@/components/utils/download";
+import {
+ generatePasskeyRecovery,
+ recoveryKeyMnemonic,
+} from "@/services/authenticated-session";
import exportService from "@/services/export";
import { performSidebarAction as performSidebarRegistryAction } from "@/services/search/sidebar-search-registry";
import {
@@ -1011,7 +1015,7 @@ const Account: React.FC<AccountProps> = ({
if (isDesktop) {
suppressAutoLockOnBlurForTrustedPrompt();
}
- await openAccountsManagePasskeysPage();
+ await openAccountsManagePasskeysPage(generatePasskeyRecovery);
}, [onRootClose]);
const handleActiveSessions = useCallback(async () => {
@@ -1127,6 +1131,7 @@ const Account: React.FC<AccountProps> = ({
</Stack>
<RecoveryKey
{...recoveryKeyVisibilityProps}
+ getRecoveryKeyMnemonic={recoveryKeyMnemonic}
{...{ showMiniDialog }}
/>
{isNonAdminFamilyMember && userDetails && (
diff --git a/web/apps/photos/src/components/gallery/helpers.ts b/web/apps/photos/src/components/gallery/helpers.ts
index 7a1f41c4c1..4217cdb0d3 100644
--- a/web/apps/photos/src/components/gallery/helpers.ts
+++ b/web/apps/photos/src/components/gallery/helpers.ts
@@ -2,8 +2,6 @@
// Kept outside index.tsx so Fast Refresh allows non-component exports.
import type { CollectionOp } from "@/components/SelectedFileOptions";
-import { getUserRecoveryKey } from "ente-accounts/services/recovery-key";
-import log from "ente-base/log";
import type { Collection } from "ente-media/collection";
import type { EnteFile } from "ente-media/file";
import {
@@ -16,17 +14,6 @@ import {
} from "ente-new/photos/services/collection";
import { PseudoCollectionID } from "ente-new/photos/services/collection-summary";
-// A false result means the caller should log out instead of using local keys.
-export const validateKey = async () => {
- try {
- await getUserRecoveryKey();
- return true;
- } catch (e) {
- log.warn("Failed to validate key", e);
- return false;
- }
-};
-
export const findCollectionCreatingIfNeeded = async (
collections: Collection[],
collectionSummaryID: number,
diff --git a/web/apps/photos/src/pages/gallery.tsx b/web/apps/photos/src/pages/gallery.tsx
index 49975567bc..1efe576cfa 100644
--- a/web/apps/photos/src/pages/gallery.tsx
+++ b/web/apps/photos/src/pages/gallery.tsx
@@ -39,7 +39,6 @@ import {
import {
findCollectionCreatingIfNeeded,
performCollectionOp,
- validateKey,
} from "@/components/gallery/helpers";
import {
useGalleryReducer,
@@ -80,6 +79,7 @@ import { useIsSmallWidth } from "ente-base/components/utils/hooks";
import { useModalVisibility } from "ente-base/components/utils/modal";
import { useBaseContext } from "ente-base/context";
import { subscribeMainWindowFocus } from "ente-base/electron";
+import { isNamedError } from "ente-base/error";
import { hasPendingAlbumToJoin } from "ente-base/join-album";
import log from "ente-base/log";
import {
@@ -501,8 +501,15 @@ const Page: React.FC = () => {
return;
}
- if (!(await validateKey())) {
- logout();
+ let session;
+ try {
+ session = await ensureAuthenticatedSession();
+ } catch (e) {
+ if (isNamedError(e, "missing_recovery_key")) {
+ showMiniDialog(sessionExpiredDialogAttributes(logout));
+ } else {
+ onGenericError(e);
+ }
return;
}
@@ -515,21 +522,17 @@ const Page: React.FC = () => {
setIsFirstLoad(getAndClearIsFirstLogin());
const user = ensureLocalUser();
- void ensureAuthenticatedSession()
- .then((session) =>
- ensureContactsReady(
- user.id,
- session,
- contactsGetDiff,
- contactsGetProfilePicture,
- ),
- )
- .catch((error: unknown) => {
- log.warn(
- "[gallery] Failed to warm contacts display cache",
- error,
- );
- });
+ void ensureContactsReady(
+ user.id,
+ session,
+ contactsGetDiff,
+ contactsGetProfilePicture,
+ ).catch((error: unknown) => {
+ log.warn(
+ "[gallery] Failed to warm contacts display cache",
+ error,
+ );
+ });
const userDetails = await savedUserDetailsOrTriggerPull();
dispatch({
type: "mount",
diff --git a/web/apps/photos/src/pages/two-factor/setup.tsx b/web/apps/photos/src/pages/two-factor/setup.tsx
index 7f9adb38e6..aad48bf538 100644
--- a/web/apps/photos/src/pages/two-factor/setup.tsx
+++ b/web/apps/photos/src/pages/two-factor/setup.tsx
@@ -1 +1,8 @@
-export { default } from "ente-accounts/pages/two-factor/setup";
+import { encryptWithRecoveryKey } from "@/services/authenticated-session";
+import TwoFactorSetupPage from "ente-accounts/pages/two-factor/setup";
+
+export default function Page() {
+ return (
+ <TwoFactorSetupPage encryptWithRecoveryKey={encryptWithRecoveryKey} />
+ );
+}
diff --git a/web/apps/photos/src/services/authenticated-session.ts b/web/apps/photos/src/services/authenticated-session.ts
index 2e9637f6aa..a6d47122bb 100644
--- a/web/apps/photos/src/services/authenticated-session.ts
+++ b/web/apps/photos/src/services/authenticated-session.ts
@@ -1,3 +1,4 @@
+import { createAuthenticatedRecoveryKeyOps } from "ente-accounts/services/authenticated-recovery-key";
import {
ensureLocalUser,
ensureSavedKeyAttributes,
@@ -10,7 +11,13 @@ import {
bindCollectionKeyOpener,
unbindCollectionKeyOpener,
} from "ente-new/photos/services/collection";
-import { openCollectionKey, openSession, type Session } from "ente-photos-wasm";
+import {
+ encryptBoxWithRecoveryKey,
+ generateKey,
+ openCollectionKey,
+ openSession,
+ type Session,
+} from "ente-photos-wasm";
let current: { key: string; opening: Promise<Session> } | undefined;
let generation = 0;
@@ -89,3 +96,13 @@ export const clearAuthenticatedSession = () => {
// In-flight calls may still borrow the handle; wasm-bindgen finalizes it.
current = undefined;
};
+
+export const {
+ encryptWithRecoveryKey,
+ generatePasskeyRecovery,
+ recoveryKeyMnemonic,
+} = createAuthenticatedRecoveryKeyOps({
+ ensureSession: ensureAuthenticatedSession,
+ encryptBox: encryptBoxWithRecoveryKey,
+ generateKey,
+});
diff --git a/web/apps/photos/tests/authenticated-session.test.ts b/web/apps/photos/tests/authenticated-session.test.ts
index bfb5bfa11d..0b770a235b 100644
--- a/web/apps/photos/tests/authenticated-session.test.ts
+++ b/web/apps/photos/tests/authenticated-session.test.ts
@@ -4,6 +4,8 @@ import { beforeEach, expect, test, vi } from "vitest";
const {
apiOrigin,
bindCollectionKeyOpener,
+ encryptBoxWithRecoveryKey,
+ generateKey,
keyAttributes,
masterKeyFromSession,
openCollectionKey,
@@ -16,10 +18,15 @@ const {
vi.fn<
typeof import("ente-new/photos/services/collection").bindCollectionKeyOpener
>(),
+ encryptBoxWithRecoveryKey:
+ vi.fn<typeof import("ente-photos-wasm").encryptBoxWithRecoveryKey>(),
+ generateKey: vi.fn<typeof import("ente-photos-wasm").generateKey>(),
keyAttributes: {
publicKey: "public-key",
encryptedSecretKey: "encrypted-secret-key",
secretKeyDecryptionNonce: "secret-key-nonce",
+ recoveryKeyEncryptedWithMasterKey: "encrypted-recovery-key",
+ recoveryKeyDecryptionNonce: "recovery-key-nonce",
},
masterKeyFromSession: vi.fn<() => Promise<string | undefined>>(),
openCollectionKey:
@@ -45,7 +52,12 @@ vi.mock("ente-new/photos/services/collection", () => ({
bindCollectionKeyOpener,
unbindCollectionKeyOpener,
}));
-vi.mock("ente-photos-wasm", () => ({ openCollectionKey, openSession }));
+vi.mock("ente-photos-wasm", () => ({
+ encryptBoxWithRecoveryKey,
+ generateKey,
+ openCollectionKey,
+ openSession,
+}));
let sessions: typeof import("../src/services/authenticated-session");
@@ -60,7 +72,9 @@ beforeEach(async () => {
const mockSession = () =>
({
+ encryptWithRecoveryKey: vi.fn(),
free: vi.fn(),
+ recoveryKeyMnemonic: vi.fn(),
updateAuthToken: vi.fn(),
[Symbol.dispose]: vi.fn(),
}) satisfies Session;
diff --git a/web/apps/photos/tests/gallery-helpers.test.ts b/web/apps/photos/tests/gallery-helpers.test.ts
index 3fe94233ad..77a4db0492 100644
--- a/web/apps/photos/tests/gallery-helpers.test.ts
+++ b/web/apps/photos/tests/gallery-helpers.test.ts
@@ -16,10 +16,6 @@ const collectionService = vi.hoisted(() => ({
restoreToCollection: vi.fn(),
}));
-vi.mock("ente-accounts/services/recovery-key", () => ({
- getUserRecoveryKey: vi.fn(),
-}));
-vi.mock("ente-base/log", () => ({ default: { warn: vi.fn() } }));
vi.mock("ente-new/photos/services/collection", () => collectionService);
describe("performCollectionOp", () => {
diff --git a/web/apps/photos/tests/logout.test.ts b/web/apps/photos/tests/logout.test.ts
index 1a12e351b9..677e06fe2f 100644
--- a/web/apps/photos/tests/logout.test.ts
+++ b/web/apps/photos/tests/logout.test.ts
@@ -2,8 +2,16 @@ import { afterEach, expect, test, vi } from "vitest";
import { openAuthenticatedSession } from "../src/services/authenticated-session";
import { photosLogout } from "../src/services/logout";
-const { apiOrigin, openSession, terminateMLWorker } = vi.hoisted(() => ({
+const {
+ apiOrigin,
+ encryptBoxWithRecoveryKey,
+ generateKey,
+ openSession,
+ terminateMLWorker,
+} = vi.hoisted(() => ({
apiOrigin: vi.fn<() => Promise<string>>(),
+ encryptBoxWithRecoveryKey: vi.fn(),
+ generateKey: vi.fn(),
openSession: vi.fn(() =>
Promise.resolve({ free: vi.fn(), updateAuthToken: vi.fn() }),
),
@@ -21,13 +29,19 @@ vi.mock("ente-base/token", () => ({ savedAuthToken: vi.fn() }));
vi.mock("ente-base/log", () => ({
default: { info: vi.fn(), error: vi.fn() },
}));
-vi.mock("ente-photos-wasm", () => ({ openSession }));
+vi.mock("ente-photos-wasm", () => ({
+ encryptBoxWithRecoveryKey,
+ generateKey,
+ openSession,
+}));
vi.mock("ente-accounts/services/user", () => ({
ensureLocalUser: () => ({ id: 1 }),
ensureSavedKeyAttributes: () => ({
publicKey: "public-key",
encryptedSecretKey: "encrypted-secret-key",
secretKeyDecryptionNonce: "secret-key-nonce",
+ recoveryKeyEncryptedWithMasterKey: "encrypted-recovery-key",
+ recoveryKeyDecryptionNonce: "recovery-key-nonce",
}),
}));
vi.mock("ente-accounts/services/logout", () => ({
diff --git a/web/package-lock.json b/web/package-lock.json
index 4517c2d9c3..3296f23fa5 100644
--- a/web/package-lock.json
+++ b/web/package-lock.json
@@ -11390,6 +11390,9 @@
"packages/wasm/photos": {
"name": "ente-photos-wasm",
"version": "0.0.0",
+ "dependencies": {
+ "ente-utils": "*"
+ },
"devDependencies": {
"ente-build-config": "*",
"wasm-pack": "0.15.0"
diff --git a/web/packages/accounts/components/RecoveryKey.tsx b/web/packages/accounts/components/RecoveryKey.tsx
index 6af447cb1d..5669f077bb 100644
--- a/web/packages/accounts/components/RecoveryKey.tsx
+++ b/web/packages/accounts/components/RecoveryKey.tsx
@@ -17,13 +17,10 @@ import log from "ente-base/log";
import { saveStringAsFile } from "ente-base/utils/web";
import { t } from "i18next";
import { useCallback, useEffect, useState, type ComponentType } from "react";
-import {
- getUserRecoveryKey,
- recoveryKeyToMnemonic,
-} from "../services/recovery-key";
import { CodeBlock } from "./CodeBlock";
type RecoveryKeyProps = ModalVisibilityProps & {
+ getRecoveryKeyMnemonic: () => Promise<string>;
showMiniDialog: (attributes: MiniDialogAttributes) => void;
};
@@ -36,6 +33,7 @@ export interface RecoveryKeyPresentationProps {
export const RecoveryKey: React.FC<RecoveryKeyProps> = ({
open,
onClose,
+ getRecoveryKeyMnemonic,
showMiniDialog,
}) => {
const fullScreen = useIsSmallWidth();
@@ -55,7 +53,9 @@ export const RecoveryKey: React.FC<RecoveryKeyProps> = ({
<DialogTitle variant="h3">{t("recovery_key")}</DialogTitle>
<DialogCloseIconButton {...{ onClose }} />
</SpacedRow>
- <RecoveryKeyContents {...{ open, onClose, showMiniDialog }} />
+ <RecoveryKeyContents
+ {...{ open, onClose, getRecoveryKeyMnemonic, showMiniDialog }}
+ />
</Dialog>
);
};
@@ -67,6 +67,7 @@ interface RecoveryKeyContentsProps extends RecoveryKeyProps {
export function RecoveryKeyContents({
open,
onClose,
+ getRecoveryKeyMnemonic,
showMiniDialog,
presentation: Presentation,
}: RecoveryKeyContentsProps): React.JSX.Element {
@@ -86,10 +87,10 @@ export function RecoveryKeyContents({
useEffect(() => {
if (!open) return;
- void getUserRecoveryKeyMnemonic()
+ void getRecoveryKeyMnemonic()
.then((key) => setRecoveryKey(key))
.catch(handleLoadError);
- }, [open, handleLoadError]);
+ }, [open, getRecoveryKeyMnemonic, handleLoadError]);
function handleSaveClick() {
saveRecoveryKeyMnemonicAsFile(recoveryKey!);
@@ -145,8 +146,5 @@ export function RecoveryKeyContents({
);
}
-const getUserRecoveryKeyMnemonic = async () =>
- recoveryKeyToMnemonic(await getUserRecoveryKey());
-
const saveRecoveryKeyMnemonicAsFile = (key: string) =>
saveStringAsFile(key, "ente-recovery-key.txt");
diff --git a/web/packages/accounts/pages/generate.tsx b/web/packages/accounts/pages/generate.tsx
index e8c0be829b..d07ee9c072 100644
--- a/web/packages/accounts/pages/generate.tsx
+++ b/web/packages/accounts/pages/generate.tsx
@@ -16,6 +16,7 @@ import {
saveJustSignedUp,
} from "ente-accounts/services/accounts-db";
import { saveMasterKeyInSessionAndSafeStore } from "ente-accounts/services/prelogin-session";
+import { getPreloginRecoveryKeyMnemonic } from "ente-accounts/services/recovery-key";
import { appHomeRoute } from "ente-accounts/services/redirect";
import { haveMasterKeyInSession } from "ente-accounts/services/session-storage";
import {
@@ -118,6 +119,7 @@ const Page: React.FC<GeneratePageProps> = ({
<RecoveryKeyContents
open
onClose={handleRecoveryKeyClose}
+ getRecoveryKeyMnemonic={getPreloginRecoveryKeyMnemonic}
showMiniDialog={showMiniDialog}
presentation={recoveryKeyPresentation}
/>
@@ -128,6 +130,7 @@ const Page: React.FC<GeneratePageProps> = ({
<RecoveryKey
open
onClose={handleRecoveryKeyClose}
+ getRecoveryKeyMnemonic={getPreloginRecoveryKeyMnemonic}
showMiniDialog={showMiniDialog}
/>
) : userEmail && passwordPresentation ? (
diff --git a/web/packages/accounts/pages/two-factor/setup.tsx b/web/packages/accounts/pages/two-factor/setup.tsx
index 59fc64305f..a8dc22d23b 100644
--- a/web/packages/accounts/pages/two-factor/setup.tsx
+++ b/web/packages/accounts/pages/two-factor/setup.tsx
@@ -17,7 +17,15 @@ import { t } from "i18next";
import { useRouter } from "next/router";
import React, { useEffect, useState } from "react";
-const Page: React.FC = () => {
+export interface TwoFactorSetupPageProps {
+ encryptWithRecoveryKey: (
+ data: string,
+ ) => Promise<{ encryptedData: string; nonce: string }>;
+}
+
+const Page: React.FC<TwoFactorSetupPageProps> = ({
+ encryptWithRecoveryKey,
+}) => {
const [twoFactorSecret, setTwoFactorSecret] = useState<
TwoFactorSecret | undefined
>();
@@ -29,7 +37,10 @@ const Page: React.FC = () => {
}, []);
const handleSubmit = async (otp: string) => {
- await setupTwoFactorFinish(twoFactorSecret!.secretCode, otp);
+ await setupTwoFactorFinish(
+ await encryptWithRecoveryKey(twoFactorSecret!.secretCode),
+ otp,
+ );
await router.push(appHomeRoute);
};
diff --git a/web/packages/accounts/services/authenticated-recovery-key.ts b/web/packages/accounts/services/authenticated-recovery-key.ts
new file mode 100644
index 0000000000..94ae2f90b5
--- /dev/null
+++ b/web/packages/accounts/services/authenticated-recovery-key.ts
@@ -0,0 +1,39 @@
+interface EncryptedBox {
+ encryptedData: string;
+ nonce: string;
+}
+
+export const createAuthenticatedRecoveryKeyOps = <
+ Session extends { recoveryKeyMnemonic: () => string },
+>({
+ ensureSession,
+ generateKey,
+ encryptBox,
+}: {
+ ensureSession: () => Promise<Session>;
+ generateKey: () => Promise<string>;
+ encryptBox: (
+ session: Session,
+ data: string,
+ ) => EncryptedBox | Promise<EncryptedBox>;
+}) => {
+ const recoveryKeyMnemonic = async () =>
+ (await ensureSession()).recoveryKeyMnemonic();
+
+ const encryptWithRecoveryKey = async (data: string) => {
+ const session = await ensureSession();
+ return encryptBox(session, data);
+ };
+
+ const generatePasskeyRecovery = async () => {
+ const session = await ensureSession();
+ const secret = await generateKey();
+ return { secret, ...(await encryptBox(session, secret)) };
+ };
+
+ return {
+ encryptWithRecoveryKey,
+ generatePasskeyRecovery,
+ recoveryKeyMnemonic,
+ };
+};
diff --git a/web/packages/accounts/services/passkey.ts b/web/packages/accounts/services/passkey.ts
index 4c7f6edc6b..77d941062a 100644
--- a/web/packages/accounts/services/passkey.ts
+++ b/web/packages/accounts/services/passkey.ts
@@ -2,7 +2,6 @@ import {
saveKeyAttributes,
updateSavedLocalUser,
} from "ente-accounts/services/accounts-db";
-import { encryptBox, generateKey } from "ente-accounts/services/crypto";
import {
resetSavedLocalUserTokens,
TwoFactorAuthorizationResponse,
@@ -17,7 +16,6 @@ import {
} from "ente-base/http";
import { apiURL } from "ente-base/origins";
import { z } from "zod";
-import { getUserRecoveryKey } from "./recovery-key";
import { unstashRedirect } from "./redirect";
export const passkeyVerificationRedirectURL = (
@@ -60,15 +58,18 @@ export const openPasskeyVerificationURL = ({
else window.location.href = url;
};
-export const openAccountsManagePasskeysPage = async () => {
+export const openAccountsManagePasskeysPage = async (
+ generatePasskeyRecovery: () => Promise<{
+ secret: string;
+ encryptedData: string;
+ nonce: string;
+ }>,
+) => {
const { isPasskeyRecoveryEnabled } = await getTwoFactorRecoveryStatus();
if (!isPasskeyRecoveryEnabled) {
- const resetSecret = await generateKey();
- const { encryptedData, nonce } = await encryptBox(
- resetSecret,
- await getUserRecoveryKey(),
- );
- await configurePasskeyRecovery(resetSecret, encryptedData, nonce);
+ const { secret, encryptedData, nonce } =
+ await generatePasskeyRecovery();
+ await configurePasskeyRecovery(secret, encryptedData, nonce);
}
const { accountsToken: token, accountsUrl: accountsURL } =
diff --git a/web/packages/accounts/services/recovery-key.ts b/web/packages/accounts/services/recovery-key.ts
index 38873edebe..6f9b75fc7a 100644
--- a/web/packages/accounts/services/recovery-key.ts
+++ b/web/packages/accounts/services/recovery-key.ts
@@ -2,60 +2,37 @@ import { savedKeyAttributes } from "ente-accounts/services/accounts-db";
import {
decryptBox,
encryptBox,
- generateKey,
recoveryKeyFromMnemonicOrHex,
} from "ente-accounts/services/crypto";
import { ensureMasterKeyFromSession } from "ente-accounts/services/prelogin-session";
-import { saveKeyAttributes } from "./accounts-db";
-import { putUserRecoveryKeyAttributes, type KeyAttributes } from "./user";
-
-export { recoveryKeyToMnemonic } from "ente-prelogin-wasm";
+import { recoveryKeyToMnemonic } from "ente-prelogin-wasm";
// For legacy compatibility, the hex representation of the recovery key is
// accepted in addition to the 24 word BIP-39 mnemonic.
export const recoveryKeyFromMnemonic = (recoveryKeyMnemonicOrHex: string) =>
recoveryKeyFromMnemonicOrHex(recoveryKeyMnemonicOrHex);
-export const getUserRecoveryKey = async () => {
+const preloginRecoveryKey = async () => {
const masterKey = await ensureMasterKeyFromSession();
- const keyAttributes = savedKeyAttributes()!;
+ const keyAttributes = savedKeyAttributes();
const { recoveryKeyEncryptedWithMasterKey, recoveryKeyDecryptionNonce } =
- keyAttributes;
-
- if (recoveryKeyEncryptedWithMasterKey && recoveryKeyDecryptionNonce) {
- return decryptBox(
- {
- encryptedData: recoveryKeyEncryptedWithMasterKey,
- nonce: recoveryKeyDecryptionNonce,
- },
- masterKey,
- );
- } else {
- return createNewRecoveryKey(masterKey, keyAttributes);
- }
+ keyAttributes ?? {};
+
+ if (!recoveryKeyEncryptedWithMasterKey || !recoveryKeyDecryptionNonce)
+ throw new Error("Missing recovery key");
+
+ return decryptBox(
+ {
+ encryptedData: recoveryKeyEncryptedWithMasterKey,
+ nonce: recoveryKeyDecryptionNonce,
+ },
+ masterKey,
+ );
};
-// Very old accounts did not get a recovery key at sign up; for them one is
-// generated lazily when it is first needed.
-const createNewRecoveryKey = async (
- masterKey: string,
- existingKeyAttributes: KeyAttributes,
-) => {
- const recoveryKey = await generateKey();
- const encryptedMasterKey = await encryptBox(masterKey, recoveryKey);
- const encryptedRecoveryKey = await encryptBox(recoveryKey, masterKey);
-
- const recoveryKeyAttributes = {
- masterKeyEncryptedWithRecoveryKey: encryptedMasterKey.encryptedData,
- masterKeyDecryptionNonce: encryptedMasterKey.nonce,
- recoveryKeyEncryptedWithMasterKey: encryptedRecoveryKey.encryptedData,
- recoveryKeyDecryptionNonce: encryptedRecoveryKey.nonce,
- };
+export const getPreloginRecoveryKeyMnemonic = async () =>
+ recoveryKeyToMnemonic(await preloginRecoveryKey());
- await putUserRecoveryKeyAttributes(recoveryKeyAttributes);
-
- saveKeyAttributes({ ...existingKeyAttributes, ...recoveryKeyAttributes });
-
- return recoveryKey;
-};
+export const encryptWithPreloginRecoveryKey = async (data: string) =>
+ encryptBox(data, await preloginRecoveryKey());
diff --git a/web/packages/accounts/services/user.ts b/web/packages/accounts/services/user.ts
index 9afb76e6c5..c0f5c6e8bb 100644
--- a/web/packages/accounts/services/user.ts
+++ b/web/packages/accounts/services/user.ts
@@ -37,7 +37,7 @@ import {
import { nullToUndefined } from "ente-utils/transform";
import { z } from "zod";
import { clearInflightPasskeySessionID } from "./passkey";
-import { getUserRecoveryKey, recoveryKeyFromMnemonic } from "./recovery-key";
+import { recoveryKeyFromMnemonic } from "./recovery-key";
export interface LocalUser {
id: number;
@@ -178,26 +178,6 @@ export const putUserKeyAttributes = async (keyAttributes: KeyAttributes) =>
}),
);
-export interface RecoveryKeyAttributes {
- masterKeyEncryptedWithRecoveryKey: string;
- masterKeyDecryptionNonce: string;
- recoveryKeyEncryptedWithMasterKey: string;
- recoveryKeyDecryptionNonce: string;
-}
-
-// This is a rare fallback for very old accounts that predate recovery key
-// attributes being set during account setup.
-export const putUserRecoveryKeyAttributes = async (
- recoveryKeyAttributes: RecoveryKeyAttributes,
-) =>
- ensureOk(
- await fetch(await apiURL("/users/recovery-key"), {
- method: "PUT",
- headers: await authenticatedRequestHeaders(),
- body: JSON.stringify(recoveryKeyAttributes),
- }),
- );
-
export const sendOTT = async (
email: string,
purpose: "change" | "signup" | "login" | undefined,
@@ -425,14 +405,13 @@ export const setupTwoFactor = async (): Promise<TwoFactorSecret> => {
};
export const setupTwoFactorFinish = async (
- secretCode: string,
- totp: string,
+ { encryptedData, nonce }: { encryptedData: string; nonce: string },
+ code: string,
) => {
- const box = await encryptBox(secretCode, await getUserRecoveryKey());
await enableTwoFactor({
- code: totp,
- encryptedTwoFactorSecret: box.encryptedData,
- twoFactorSecretDecryptionNonce: box.nonce,
+ code,
+ encryptedTwoFactorSecret: encryptedData,
+ twoFactorSecretDecryptionNonce: nonce,
});
updateSavedLocalUser({ isTwoFactorEnabled: true });
};
diff --git a/web/packages/contacts/legacy/service.ts b/web/packages/contacts/legacy/service.ts
index 9f29ca6aa5..4731c51d2e 100644
--- a/web/packages/contacts/legacy/service.ts
+++ b/web/packages/contacts/legacy/service.ts
@@ -1,5 +1,4 @@
import { savedKeyAttributes } from "ente-accounts/services/accounts-db";
-import { getUserRecoveryKey } from "ente-accounts/services/recovery-key";
import {
addContact,
changePassword,
@@ -13,19 +12,11 @@ export const legacyVerificationID = async (session: Session, email: string) => {
return key ? verificationID(key) : undefined;
};
-export const legacyAddContact = async (
+export const legacyAddContact = (
session: Session,
email: string,
recoveryNoticeInDays?: number,
-) => {
- await getUserRecoveryKey();
- return addContact(
- session,
- email,
- currentKeyAttributes(),
- recoveryNoticeInDays,
- );
-};
+) => addContact(session, email, currentKeyAttributes(), recoveryNoticeInDays);
export const legacyChangePassword = (
session: Session,
diff --git a/web/packages/contacts/wasm.test.ts b/web/packages/contacts/wasm.test.ts
index 1a1547a2dd..264d89cbcb 100644
--- a/web/packages/contacts/wasm.test.ts
+++ b/web/packages/contacts/wasm.test.ts
@@ -281,12 +281,19 @@ const mockFetch = (
const sessionKeyAttributes = async (masterKey: string) => {
const { publicKey, privateKey } = await generateKeyPair();
const encryptedSecretKey = await encryptBox(privateKey, masterKey);
+ const encryptedRecoveryKey = await encryptBox(
+ await generateKey(),
+ masterKey,
+ );
return {
userID: 42,
keyAttributes: {
publicKey,
encryptedSecretKey: encryptedSecretKey.encryptedData,
secretKeyDecryptionNonce: encryptedSecretKey.nonce,
+ recoveryKeyEncryptedWithMasterKey:
+ encryptedRecoveryKey.encryptedData,
+ recoveryKeyDecryptionNonce: encryptedRecoveryKey.nonce,
},
};
};
diff --git a/web/packages/wasm/locker/index.ts b/web/packages/wasm/locker/index.ts
index f15d8a978e..442c587c2d 100644
--- a/web/packages/wasm/locker/index.ts
+++ b/web/packages/wasm/locker/index.ts
@@ -15,6 +15,12 @@ export type { OpenSessionInput, Session } from "./pkg/ente_locker_wasm";
export const openSession = async (input: OpenSessionInput): Promise<Session> =>
(await wasm()).openSession(input);
+export const encryptBoxWithRecoveryKey = (session: Session, dataB64: string) =>
+ readAndFree(session.encryptWithRecoveryKey(dataB64), (box) => ({
+ encryptedData: box.encryptedData,
+ nonce: box.nonce,
+ }));
+
export const openCollectionKey = async (
session: Session,
ownerID: number,
diff --git a/web/packages/wasm/photos/index.ts b/web/packages/wasm/photos/index.ts
index 06ee0fc2fc..5ed08c542e 100644
--- a/web/packages/wasm/photos/index.ts
+++ b/web/packages/wasm/photos/index.ts
@@ -1,3 +1,4 @@
+import { readAndFree } from "ente-utils/wasm";
import type {
OpenSessionInput,
Session,
@@ -11,6 +12,14 @@ export type { OpenSessionInput, Session } from "./pkg/ente_photos_wasm";
export const openSession = async (input: OpenSessionInput): Promise<Session> =>
(await wasm()).openSession(input);
+export const encryptBoxWithRecoveryKey = (session: Session, dataB64: string) =>
+ readAndFree(session.encryptWithRecoveryKey(dataB64), (box) => ({
+ encryptedData: box.encryptedData,
+ nonce: box.nonce,
+ }));
+
+export const generateKey = async () => (await wasm()).cryptoGenerateKey();
+
export const contactsGetDiff = async (
session: Session,
wrappedRootContactKey: WrappedRootContactKey | undefined,
diff --git a/web/packages/wasm/photos/package.json b/web/packages/wasm/photos/package.json
index 6c2ea3401f..88326d0278 100644
--- a/web/packages/wasm/photos/package.json
+++ b/web/packages/wasm/photos/package.json
@@ -13,6 +13,9 @@
"scripts": {
"build": "wasm-pack build ../../../../rust/bindings/wasm/photos --target bundler --out-dir ../../../../web/packages/wasm/photos/pkg --no-pack"
},
+ "dependencies": {
+ "ente-utils": "*"
+ },
"devDependencies": {
"ente-build-config": "*",
"wasm-pack": "0.15.0"