π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
Validate authentication payloads across clients
Neeraj Guptadac593311ffc
diff --git a/cli/pkg/sign_in.go b/cli/pkg/sign_in.goindex 09c68da626..31b93126c5 100644--- a/cli/pkg/sign_in.go+++ b/cli/pkg/sign_in.go@@ -1,6 +1,7 @@package pkgimport (+ "bytes""context""fmt""github.com/ente/cli/internal"@@ -107,6 +108,9 @@ func (c *ClICtrl) decryptAccSecretInfo(fmt.Printf("error decrypting token: %v", err)return nil, err}+ if len(tokenKey) != len("auth-token")+32 || !bytes.HasPrefix(tokenKey, []byte("auth-token")) {+ return nil, fmt.Errorf("invalid login token: the server may need upgrading")+ }break}return &model.AccSecretInfo{diff --git a/cli/pkg/sign_in_test.go b/cli/pkg/sign_in_test.gonew file mode 100644index 0000000000..a2fa91c156--- /dev/null+++ b/cli/pkg/sign_in_test.go@@ -0,0 +1,65 @@+package pkg++import (+ "bytes"+ "context"+ "crypto/rand"+ "encoding/base64"+ "testing"++ "github.com/ente/cli/internal/api"+ "golang.org/x/crypto/nacl/box"+ "golang.org/x/crypto/nacl/secretbox"+)++func TestDecryptAccountToken(t *testing.T) {+ publicKey, secretKey, err := box.GenerateKey(rand.Reader)+ if err != nil {+ t.Fatal(err)+ }+ kek, masterKey, nonce := [32]byte{1}, [32]byte{2}, [24]byte{3}+ attributes := &api.KeyAttributes{+ PublicKey: base64.StdEncoding.EncodeToString(publicKey[:]),+ EncryptedKey: base64.StdEncoding.EncodeToString(secretbox.Seal(nil, masterKey[:], &nonce, &kek)),+ KeyDecryptionNonce: base64.StdEncoding.EncodeToString(nonce[:]),+ EncryptedSecretKey: base64.StdEncoding.EncodeToString(secretbox.Seal(nil, secretKey[:], &nonce, &masterKey)),+ SecretKeyDecryptionNonce: base64.StdEncoding.EncodeToString(nonce[:]),+ }+ token := append([]byte("auth-token"), bytes.Repeat([]byte{255}, 32)...)+ for _, tc := range []struct {+ name string+ payload []byte+ valid bool+ }{+ {"tagged token", token, true},+ {"unrelated secret", bytes.Repeat([]byte{7}, 32), false},+ {"deletion challenge", []byte("delete-jwtheader.payload.signature"), false},+ {"wrong tag", append([]byte("wrong-type"), token[10:]...), false},+ {"short token", token[:41], false},+ {"long token", append(append([]byte(nil), token...), 0), false},+ } {+ t.Run(tc.name, func(t *testing.T) {+ ciphertext, err := box.SealAnonymous(nil, tc.payload, publicKey, rand.Reader)+ if err != nil {+ t.Fatal(err)+ }+ response := &api.AuthorizationResponse{+ KeyAttributes: attributes,+ EncryptedToken: base64.StdEncoding.EncodeToString(ciphertext),+ }+ account, err := (&ClICtrl{}).decryptAccSecretInfo(context.Background(), response, kek[:])+ if !tc.valid {+ if err == nil || account != nil {+ t.Fatal("substituted token was returned")+ }+ return+ }+ if err != nil {+ t.Fatal(err)+ }+ if !bytes.Equal(account.Token, token) || !bytes.Equal(account.MasterKey, masterKey[:]) {+ t.Fatal("account secrets changed")+ }+ })+ }+}diff --git a/mobile/apps/photos/lib/core/configuration.dart b/mobile/apps/photos/lib/core/configuration.dartindex 0cf84558c6..49a69a8111 100644--- a/mobile/apps/photos/lib/core/configuration.dart+++ b/mobile/apps/photos/lib/core/configuration.dart@@ -8,6 +8,7 @@ import 'package:ente_account_deletion/account_deletion.dart';import 'package:ente_contacts/contacts.dart';import "package:ente_crypto/ente_crypto.dart";import 'package:ente_lock_screen/lock_screen_host.dart';+import 'package:ente_pure_utils/auth_payload.dart';import 'package:ente_pure_utils/ente_pure_utils.dart';import "package:flutter/services.dart";import 'package:flutter_cache_manager/flutter_cache_manager.dart';@@ -454,6 +455,7 @@ class Configuration implements LockScreenHost, AccountDeletionHost {CryptoUtil.base642bin(attributes.publicKey),secretKey,);+ validateAuthToken(token);await setToken(CryptoUtil.bin2base64(token, urlSafe: true));return keyEncryptionKey;}@@ -517,6 +519,7 @@ class Configuration implements LockScreenHost, AccountDeletionHost {CryptoUtil.base642bin(attributes.publicKey),secretKey,);+ validateAuthToken(token);await setToken(CryptoUtil.bin2base64(token, urlSafe: true));}diff --git a/mobile/apps/photos/lib/gateways/users/users_gateway.dart b/mobile/apps/photos/lib/gateways/users/users_gateway.dartindex e3d3fae555..18b3bd1de0 100644--- a/mobile/apps/photos/lib/gateways/users/users_gateway.dart+++ b/mobile/apps/photos/lib/gateways/users/users_gateway.dart@@ -270,14 +270,14 @@ class UsersGateway {Future<Map<String, dynamic>> removeTwoFactor({required String sessionID,- required String secret,+ required String proof,required String twoFactorType,}) async {final response = await _publicDio.post("$_endpoint/users/two-factor/remove",data: {"sessionID": sessionID,- "secret": secret,+ "proof": proof,"twoFactorType": twoFactorType,},);diff --git a/mobile/apps/photos/lib/services/account/user_service.dart b/mobile/apps/photos/lib/services/account/user_service.dartindex b5ed4567ca..ec1c346e55 100644--- a/mobile/apps/photos/lib/services/account/user_service.dart+++ b/mobile/apps/photos/lib/services/account/user_service.dart@@ -6,6 +6,7 @@ import "dart:math";import 'package:bip39/bip39.dart' as bip39;import 'package:dio/dio.dart';import 'package:ente_crypto/ente_crypto.dart';+import 'package:ente_pure_utils/auth_payload.dart';import "package:ente_pure_utils/ente_pure_utils.dart";import "package:ente_strings/ente_strings.dart";import "package:flutter/foundation.dart";@@ -988,7 +989,11 @@ class UserService {try {final responseData = await _gateway.removeTwoFactor(sessionID: sessionID,- secret: secret,+ proof: twoFactorRecoveryProof(+ twoFactorTypeToString(type),+ sessionID,+ secret,+ ),twoFactorType: twoFactorTypeToString(type),);await _saveConfiguration(responseData);diff --git a/mobile/packages/account_deletion/lib/src/services/account_deletion_service.dart b/mobile/packages/account_deletion/lib/src/services/account_deletion_service.dartindex d347ef4ea2..0d90820ce6 100644--- a/mobile/packages/account_deletion/lib/src/services/account_deletion_service.dart+++ b/mobile/packages/account_deletion/lib/src/services/account_deletion_service.dart@@ -21,8 +21,14 @@ class AccountDeletionService {required String reasonCategory,String? feedback,}) async {+ const prefix = 'delete-jwt';+ if (!challenge.startsWith(prefix) || challenge.length <= prefix.length) {+ throw const FormatException(+ 'Invalid deletion challenge. The server may need upgrading.',+ );+ }final data = <String, dynamic>{- 'challenge': challenge,+ 'challenge': challenge.substring(prefix.length),'reasonCategory': reasonCategory,};if (feedback != null && feedback.isNotEmpty) {diff --git a/mobile/packages/account_deletion/test/account_deletion_service_test.dart b/mobile/packages/account_deletion/test/account_deletion_service_test.dartnew file mode 100644index 0000000000..31496146d2--- /dev/null+++ b/mobile/packages/account_deletion/test/account_deletion_service_test.dart@@ -0,0 +1,42 @@+import 'package:dio/dio.dart';+import 'package:ente_account_deletion/src/services/account_deletion_service.dart';+import 'package:flutter_test/flutter_test.dart';++void main() {+ test('rejects untagged challenges before making a request', () async {+ final requests = <RequestOptions>[];+ final dio = Dio(BaseOptions(baseUrl: 'https://example.invalid'))+ ..interceptors.add(+ InterceptorsWrapper(+ onRequest: (options, handler) {+ requests.add(options);+ handler.resolve(Response(requestOptions: options));+ },+ ),+ );+ final service = AccountDeletionService(dio);+ for (final challenge in [+ 'header.payload.signature',+ 'auth-token01234567890123456789012345678901',+ 'delete-jwt',+ 'delete-jwXheader.payload.signature',+ ]) {+ await expectLater(+ service.deleteAccount(challenge: challenge, reasonCategory: 'other'),+ throwsFormatException,+ );+ }+ expect(requests, isEmpty);+ await service.deleteAccount(+ challenge: 'delete-jwtheader.payload.signature',+ reasonCategory: 'other',+ feedback: 'feedback',+ );+ expect(requests.single.data, {+ 'challenge': 'header.payload.signature',+ 'reasonCategory': 'other',+ 'feedback': 'feedback',+ });+ expect(requests.single.method, 'DELETE');+ });+}diff --git a/mobile/packages/accounts/lib/services/user_service.dart b/mobile/packages/accounts/lib/services/user_service.dartindex 1a6a0a9397..f7eb31feb9 100644--- a/mobile/packages/accounts/lib/services/user_service.dart+++ b/mobile/packages/accounts/lib/services/user_service.dart@@ -29,6 +29,7 @@ import 'package:ente_crypto_api/ente_crypto_api.dart';import 'package:ente_events/event_bus.dart';import 'package:ente_events/models/user_details_changed_event.dart';import 'package:ente_network/network.dart';+import 'package:ente_pure_utils/auth_payload.dart';import 'package:ente_strings/ente_strings.dart';import "package:ente_ui/components/alert_bottom_sheet.dart";import 'package:ente_ui/components/progress_dialog.dart';@@ -1060,7 +1061,11 @@ class UserService {"${_config.getHttpEndpoint()}/users/two-factor/remove",data: {"sessionID": sessionID,- "secret": secret,+ "proof": twoFactorRecoveryProof(+ twoFactorTypeToString(type),+ sessionID,+ secret,+ ),"twoFactorType": twoFactorTypeToString(type),},);diff --git a/mobile/packages/configuration/lib/base_configuration.dart b/mobile/packages/configuration/lib/base_configuration.dartindex f4e3848ba4..03e48522c4 100644--- a/mobile/packages/configuration/lib/base_configuration.dart+++ b/mobile/packages/configuration/lib/base_configuration.dart@@ -14,6 +14,7 @@ import 'package:ente_events/models/endpoint_updated_event.dart';import 'package:ente_events/models/signed_in_event.dart';import 'package:ente_events/models/signed_out_event.dart';import 'package:ente_logging/logging.dart';+import 'package:ente_pure_utils/auth_payload.dart';import 'package:flutter/services.dart';import 'package:flutter_secure_storage/flutter_secure_storage.dart';import 'package:path/path.dart' as p;@@ -233,6 +234,7 @@ abstract class BaseConfiguration {secretKey,);_logger.info('appToken done');+ validateAuthToken(token);await setToken(CryptoUtil.bin2base64(token, urlSafe: true));return keyEncryptionKey;}@@ -281,6 +283,7 @@ abstract class BaseConfiguration {CryptoUtil.base642bin(attributes.publicKey),secretKey,);+ validateAuthToken(token);await setToken(CryptoUtil.bin2base64(token, urlSafe: true));}diff --git a/mobile/packages/configuration/pubspec.yaml b/mobile/packages/configuration/pubspec.yamlindex 2fcc49f400..b7d3b5caff 100644--- a/mobile/packages/configuration/pubspec.yaml+++ b/mobile/packages/configuration/pubspec.yaml@@ -16,6 +16,8 @@ dependencies:path: ../../packages/eventsente_logging:path: ../../packages/logging+ ente_pure_utils:+ path: ../ente_pure_utilsflutter:sdk: flutter# Version 9.2.4 leaves lock-screen keys behind after an app reinstall.diff --git a/mobile/packages/ente_pure_utils/lib/auth_payload.dart b/mobile/packages/ente_pure_utils/lib/auth_payload.dartnew file mode 100644index 0000000000..86d22c87f4--- /dev/null+++ b/mobile/packages/ente_pure_utils/lib/auth_payload.dart@@ -0,0 +1,25 @@+import 'dart:convert';+import 'dart:typed_data';++import 'package:crypto/crypto.dart';++void validateAuthToken(Uint8List token) {+ const prefix = 'auth-token';+ if (token.length != prefix.length + 32 ||+ String.fromCharCodes(token.take(prefix.length)) != prefix) {+ throw const FormatException(+ 'Invalid login token. The server may need upgrading.',+ );+ }+}++String twoFactorRecoveryProof(+ String twoFactorType,+ String sessionID,+ String secret,+) {+ final message = utf8.encode(+ 'ente-two-factor-recovery:v1\x00$twoFactorType\x00$sessionID',+ );+ return base64Encode(Hmac(sha256, utf8.encode(secret)).convert(message).bytes);+}diff --git a/mobile/packages/ente_pure_utils/test/auth_payload_test.dart b/mobile/packages/ente_pure_utils/test/auth_payload_test.dartnew file mode 100644index 0000000000..c5a87fa5b8--- /dev/null+++ b/mobile/packages/ente_pure_utils/test/auth_payload_test.dart@@ -0,0 +1,56 @@+import 'dart:convert';+import 'dart:typed_data';++import 'package:ente_pure_utils/auth_payload.dart';+import 'package:flutter_test/flutter_test.dart';++void main() {+ test('requires the full tagged login token', () {+ final token = Uint8List.fromList([+ ...ascii.encode('auth-token'),+ ...List<int>.generate(32, (index) => index),+ ]);+ final original = Uint8List.fromList(token);+ validateAuthToken(token);+ expect(token, original);+ for (final invalid in [+ Uint8List(32),+ Uint8List.fromList(ascii.encode('delete-jwtheader.payload.signature')),+ Uint8List.fromList([...ascii.encode('wrong-type'), ...token.sublist(10)]),+ token.sublist(0, 41),+ Uint8List.fromList([...token, 0]),+ ]) {+ expect(() => validateAuthToken(invalid), throwsFormatException);+ }+ });++ test('proofs bind factor and session', () {+ const totpSecret = 'JBSWY3DPEHPK3PXPJBSWY3DPEHPK3PXP';+ const totpProof = 'GLPadofZrER+5+7OLkqiNxlmyS6XzaKGdsMeHg1lnvU=';+ for (final (factor, secret, expected) in [+ ('totp', totpSecret, totpProof),+ (+ 'passkey',+ 'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=',+ 'PxcSH0NrKUX3u330jU6TtYp/I/mT4087vajBXIdPh0I=',+ ),+ ]) {+ expect(+ twoFactorRecoveryProof(factor, 'recovery-session', secret),+ expected,+ );+ expect(+ twoFactorRecoveryProof(factor, 'other-session', secret),+ isNot(expected),+ );+ expect(+ twoFactorRecoveryProof(+ factor == 'totp' ? 'passkey' : 'totp',+ 'recovery-session',+ secret,+ ),+ isNot(expected),+ );+ }+ });+}diff --git a/rust/Cargo.lock b/rust/Cargo.lockindex 20f13fb72d..83b673deab 100644--- a/rust/Cargo.lock+++ b/rust/Cargo.lock@@ -2440,6 +2440,7 @@ dependencies = ["ente-test-support","getrandom 0.4.3","hex",+ "hmac 0.13.0","mockito","serde","serde_json",diff --git a/rust/bindings/wasm/lib/src/prelogin.rs b/rust/bindings/wasm/lib/src/prelogin.rsindex 1870f702ca..ded95a58c2 100644--- a/rust/bindings/wasm/lib/src/prelogin.rs+++ b/rust/bindings/wasm/lib/src/prelogin.rs@@ -5,6 +5,39 @@ use serde::Serialize;use tsify::Tsify;use wasm_bindgen::prelude::*;+#[wasm_bindgen(js_name = authValidateToken)]+pub fn auth_validate_token(token: &[u8]) -> Result<(), AccountsError> {+ auth::validate_auth_token(token).map_err(Into::into)+}++#[wasm_bindgen(js_name = authParseDeleteAccountChallenge)]+pub fn auth_parse_delete_account_challenge(plaintext: &[u8]) -> Result<String, AccountsError> {+ auth::parse_delete_account_challenge(plaintext).map_err(Into::into)+}++#[wasm_bindgen(js_name = authTwoFactorRecoveryProof)]+pub fn auth_two_factor_recovery_proof(+ two_factor_type: &str,+ session_id: &str,+ secret_b64: &str,+) -> Result<String, AccountsError> {+ use ente_accounts::models::TwoFactorType;+ let two_factor_type = match two_factor_type {+ "totp" => TwoFactorType::Totp,+ "passkey" => TwoFactorType::Passkey,+ _ => {+ return Err(+ ente_accounts::Error::InvalidInput("Invalid second factor type".into()).into(),+ );+ }+ };+ Ok(auth::two_factor_recovery_proof(+ &b64::decode(secret_b64).map_err(ente_accounts::Error::from)?,+ two_factor_type,+ session_id,+ )?)+}+#[derive(Serialize, Tsify)]#[serde(rename_all = "camelCase")]pub struct GeneratedSrpSetup {diff --git a/rust/crates/accounts/Cargo.toml b/rust/crates/accounts/Cargo.tomlindex 8f8ed8613b..6dd57c2db1 100644--- a/rust/crates/accounts/Cargo.toml+++ b/rust/crates/accounts/Cargo.toml@@ -10,6 +10,7 @@ bip39 = { version = "3.0.0", default-features = false, features = ["std"] }ente-core.workspace = truegetrandom.workspace = truehex = "0.4.0"+hmac.workspace = trueserde.workspace = trueserde_json.workspace = truesha2.workspace = truediff --git a/rust/crates/accounts/src/auth/api.rs b/rust/crates/accounts/src/auth/api.rsindex 259b6b227e..9698fef90c 100644--- a/rust/crates/accounts/src/auth/api.rs+++ b/rust/crates/accounts/src/auth/api.rs@@ -213,13 +213,16 @@ pub fn decrypt_secrets(let sealed_token =b64::decode(encrypted_token).map_err(|e| Error::Decode(format!("encrypted_token: {e}")))?;- let token = sealed::open(&sealed_token, &secret_key.public_key(), &secret_key)- .map_err(|_| Error::InvalidKeyAttributes)?;+ let token = SecretVec::new(+ sealed::open(&sealed_token, &secret_key.public_key(), &secret_key)+ .map_err(|_| Error::InvalidKeyAttributes)?,+ );+ super::validate_auth_token(&token)?;Ok(DecryptedSecrets {master_key,secret_key,- token: SecretVec::new(token),+ token,})}@@ -228,6 +231,33 @@ mod tests {use super::*;use crate::auth::{KeyDerivationStrength, generate_keys_with_strength};+ #[test]+ fn decrypt_secrets_rejects_substituted_payloads() {+ let generated =+ generate_keys_with_strength("pw", KeyDerivationStrength::Interactive).unwrap();+ let public_key = crypto::PublicKey::try_from_slice(+ &b64::decode(&generated.key_attributes.public_key).unwrap(),+ )+ .unwrap();+ for payload in [+ vec![7; 32],+ b"delete-jwtheader.payload.signature".to_vec(),+ [b"wrong-type".as_slice(), &[7; 32]].concat(),+ [b"auth-token".as_slice(), &[7; 31]].concat(),+ [b"auth-token".as_slice(), &[7; 33]].concat(),+ ] {+ let encrypted_token = b64::encode(&sealed::seal(&payload, &public_key).unwrap());+ assert!(+ decrypt_secrets(+ &generated.key_encryption_key,+ &generated.key_attributes,+ &encrypted_token,+ )+ .is_err()+ );+ }+ }+#[test]fn test_derive_srp_credentials() {let password = "test_password";@@ -256,7 +286,7 @@ mod tests {let gen_result =generate_keys_with_strength(password, KeyDerivationStrength::Interactive).unwrap();- let token = b"auth_token_12345";+ let token = b"auth-token01234567890123456789012345678901";let public_key = b64::decode(&gen_result.key_attributes.public_key).unwrap();let sealed_token = sealed::seal(token,diff --git a/rust/crates/accounts/src/auth/mod.rs b/rust/crates/accounts/src/auth/mod.rsindex b397925a77..edbf133a21 100644--- a/rust/crates/accounts/src/auth/mod.rs+++ b/rust/crates/accounts/src/auth/mod.rs@@ -1,5 +1,6 @@mod api;mod key_gen;+mod payload;mod recovery;mod srp;mod types;@@ -21,3 +22,5 @@ pub use key_gen::{pub use recovery::{get_recovery_key, recovery_key_from_mnemonic_or_hex, recovery_key_to_mnemonic};pub use types::{KeyAttributes, KeyGenResult, PrivateKeyAttributes, SrpAttributes};++pub use payload::{parse_delete_account_challenge, two_factor_recovery_proof, validate_auth_token};diff --git a/rust/crates/accounts/src/auth/payload.rs b/rust/crates/accounts/src/auth/payload.rsnew file mode 100644index 0000000000..823a7aa572--- /dev/null+++ b/rust/crates/accounts/src/auth/payload.rs@@ -0,0 +1,93 @@+use ente_core::b64;+use hmac::{Hmac, KeyInit, Mac};+use sha2::Sha256;+use zeroize::Zeroizing;++use crate::{Error, Result, models::TwoFactorType};++pub fn validate_auth_token(token: &[u8]) -> Result<()> {+ if token.len() != b"auth-token".len() + 32 || !token.starts_with(b"auth-token") {+ return Err(Error::Protocol(+ "Invalid login token. The server may need upgrading.".into(),+ ));+ }+ Ok(())+}++pub fn parse_delete_account_challenge(plaintext: &[u8]) -> Result<String> {+ let challenge = plaintext+ .strip_prefix(b"delete-jwt")+ .filter(|challenge| !challenge.is_empty())+ .ok_or_else(|| {+ Error::Protocol("Invalid deletion challenge. The server may need upgrading.".into())+ })?;+ String::from_utf8(challenge.to_vec())+ .map_err(|_| Error::Protocol("Invalid deletion challenge encoding".into()))+}++pub fn two_factor_recovery_proof(+ secret: &[u8],+ two_factor_type: TwoFactorType,+ session_id: &str,+) -> Result<String> {+ let secret = Zeroizing::new(b64::encode(secret).into_bytes());+ let factor = match two_factor_type {+ TwoFactorType::Totp => "totp",+ TwoFactorType::Passkey => "passkey",+ };+ let mut mac =+ Hmac::<Sha256>::new_from_slice(&secret).map_err(|_| Error::IncorrectRecoveryKey)?;+ mac.update(format!("ente-two-factor-recovery:v1\0{factor}\0{session_id}").as_bytes());+ Ok(b64::encode(&mac.finalize().into_bytes()))+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn deletion_requires_its_prefix_and_valid_utf8() {+ assert_eq!(+ parse_delete_account_challenge(b"delete-jwtheader.payload.signature").unwrap(),+ "header.payload.signature",+ );+ for payload in [+ vec![7; 32],+ [b"auth-token".as_slice(), &[7; 32]].concat(),+ b"header.payload.signature".to_vec(),+ b"delete-jwt".to_vec(),+ b"delete-jwt\xff".to_vec(),+ ] {+ assert!(parse_delete_account_challenge(&payload).is_err());+ }+ }++ #[test]+ fn recovery_proofs_bind_the_session_and_factor() {+ use TwoFactorType::{Passkey, Totp};+ let totp_secret = "JBSWY3DPEHPK3PXPJBSWY3DPEHPK3PXP";+ let totp_proof = "GLPadofZrER+5+7OLkqiNxlmyS6XzaKGdsMeHg1lnvU=";+ for (factor, plaintext, expected) in [+ (Totp, b64::decode(totp_secret).unwrap(), totp_proof),+ (+ Passkey,+ (0..32).collect(),+ "PxcSH0NrKUX3u330jU6TtYp/I/mT4087vajBXIdPh0I=",+ ),+ ] {+ assert_eq!(+ two_factor_recovery_proof(&plaintext, factor, "recovery-session").unwrap(),+ expected+ );+ assert_ne!(+ two_factor_recovery_proof(&plaintext, factor, "other-session").unwrap(),+ expected+ );+ let other_factor = if factor == Totp { Passkey } else { Totp };+ assert_ne!(+ two_factor_recovery_proof(&plaintext, other_factor, "recovery-session").unwrap(),+ expected+ );+ }+ }+}diff --git a/rust/crates/accounts/src/lifecycle.rs b/rust/crates/accounts/src/lifecycle.rsindex da9108987a..d091f5047a 100644--- a/rust/crates/accounts/src/lifecycle.rs+++ b/rust/crates/accounts/src/lifecycle.rs@@ -253,15 +253,17 @@ pub async fn recover_two_factor(let recovery_key = auth::recovery_key_from_mnemonic_or_hex(recovery_key_mnemonic_or_hex)?;let encrypted_secret = b64::decode(&recovery_response.encrypted_secret)?;let nonce = b64::decode(&recovery_response.secret_decryption_nonce)?;- let secret = secretbox::decrypt(- &encrypted_secret,- &crypto::Nonce::try_from_slice(&nonce)?,- &crypto::Key::try_from_slice(&recovery_key)?,- )- .map_err(|_| Error::IncorrectRecoveryKey)?;+ let secret = SecretVec::new(+ secretbox::decrypt(+ &encrypted_secret,+ &crypto::Nonce::try_from_slice(&nonce)?,+ &crypto::Key::try_from_slice(&recovery_key)?,+ )+ .map_err(|_| Error::IncorrectRecoveryKey)?,+ );let request = RemoveTwoFactorRequest {session_id: session_id.to_string(),- secret: b64::encode(&secret),+ proof: auth::two_factor_recovery_proof(&secret, two_factor_type, session_id)?,two_factor_type,};client.remove_two_factor(&request).awaitdiff --git a/rust/crates/accounts/src/lifecycle/tests.rs b/rust/crates/accounts/src/lifecycle/tests.rsindex b2555866b7..4f86564f4e 100644--- a/rust/crates/accounts/src/lifecycle/tests.rs+++ b/rust/crates/accounts/src/lifecycle/tests.rs@@ -159,7 +159,7 @@ async fn configure_passkey_recovery_accepts_hex_recovery_key() {}#[tokio::test]-async fn two_factor_recovery_preserves_secret_encoding() {+async fn two_factor_recovery_sends_only_proof() {let keys =auth::generate_keys_with_strength("pw", auth::KeyDerivationStrength::Interactive).unwrap();let recovery_key_hex = keys.private_key_attributes.recovery_key.into_string();@@ -168,43 +168,63 @@ async fn two_factor_recovery_preserves_secret_encoding() {let mut server = Server::new_async().await;let client = make_client(server.url());- for (factor, secret) in [- (TwoFactorType::Totp, TOTP_SECRET),- (TwoFactorType::Passkey, PASSKEY_SECRET),+ for (factor, secret, proof) in [+ (+ TwoFactorType::Totp,+ TOTP_SECRET,+ "GLPadofZrER+5+7OLkqiNxlmyS6XzaKGdsMeHg1lnvU=",+ ),+ (+ TwoFactorType::Passkey,+ PASSKEY_SECRET,+ "PxcSH0NrKUX3u330jU6TtYp/I/mT4087vajBXIdPh0I=",+ ),] {let encrypted = secretbox::encrypt(&b64::decode(secret).unwrap(), &recovery_key);- let remove = server- .mock("POST", "/users/two-factor/remove")- .match_body(Matcher::Json(serde_json::json!({- "sessionId": "recovery-session",- "secret": secret,- "twoFactorType": factor,- })))- .with_status(200)- .with_body(- serde_json::json!({- "id": 1,- "keyAttributes": keys.key_attributes,- "encryptedToken": "encrypted-token",+ for status in [200, 400] {+ let sent = Arc::new(Mutex::new(None));+ let captured = Arc::clone(&sent);+ let remove = server+ .mock("POST", "/users/two-factor/remove")+ .match_request(move |request| {+ *captured.lock().unwrap() =+ Some(parse_request_body::<serde_json::Value>(request));+ true})- .to_string(),+ .with_status(status)+ .with_body(+ serde_json::json!({+ "id": 1,+ "keyAttributes": keys.key_attributes,+ "encryptedToken": "encrypted-token",+ })+ .to_string(),+ )+ .expect(1)+ .create_async()+ .await;++ let result = recover_two_factor(+ &client,+ factor,+ "recovery-session",+ &TwoFactorRecoveryResponse {+ encrypted_secret: b64::encode(&encrypted.encrypted_data),+ secret_decryption_nonce: b64::encode(encrypted.nonce.as_bytes()),+ },+ &recovery_key_hex,)- .create_async().await;-- recover_two_factor(- &client,- factor,- "recovery-session",- &TwoFactorRecoveryResponse {- encrypted_secret: b64::encode(&encrypted.encrypted_data),- secret_decryption_nonce: b64::encode(encrypted.nonce.as_bytes()),- },- &recovery_key_hex,- )- .await- .unwrap();- remove.assert_async().await;+ assert_eq!(result.is_ok(), status == 200, "{factor:?}: {result:?}");+ assert_eq!(+ *sent.lock().unwrap(),+ Some(serde_json::json!({+ "sessionId": "recovery-session", "twoFactorType": factor,+ "proof": proof,+ }))+ );+ remove.assert_async().await;+ }}}diff --git a/rust/crates/accounts/src/login/tests.rs b/rust/crates/accounts/src/login/tests.rsindex d0a307887b..62a9aea790 100644--- a/rust/crates/accounts/src/login/tests.rs+++ b/rust/crates/accounts/src/login/tests.rs@@ -162,7 +162,7 @@ async fn login_retries_email_and_totp() {let public_key = b64::decode(&key_attributes.public_key).unwrap();let encrypted_token = b64::encode(&crypto::sealed::seal(- b"plain-auth-token",+ b"auth-token01234567890123456789012345678901",&crypto::PublicKey::try_from_slice(&public_key).unwrap(),).unwrap(),@@ -295,7 +295,10 @@ async fn login_retries_email_and_totp() {};assert_eq!(result.user_id, 77);- assert_eq!(result.secrets.token, b"plain-auth-token");+ assert_eq!(+ result.secrets.token,+ b"auth-token01234567890123456789012345678901"+ );assert_eq!(result.recovery_key.as_deref(), Some(recovery_key.as_str()));srp_attrs.assert_async().await;diff --git a/rust/crates/accounts/src/models.rs b/rust/crates/accounts/src/models.rsindex 35a397ba42..9a22f535e7 100644--- a/rust/crates/accounts/src/models.rs+++ b/rust/crates/accounts/src/models.rs@@ -344,7 +344,7 @@ pub struct TwoFactorRecoveryResponse {#[serde(rename_all = "camelCase")]pub struct RemoveTwoFactorRequest {pub session_id: String,- pub secret: String,+ pub proof: String,pub two_factor_type: TwoFactorType,}diff --git a/rust/crates/accounts/tests/accounts.rs b/rust/crates/accounts/tests/accounts.rsindex 3df0856883..8ee0c41931 100644--- a/rust/crates/accounts/tests/accounts.rs+++ b/rust/crates/accounts/tests/accounts.rs@@ -3,7 +3,9 @@use ente_accounts::{AccountsClient, AccountsClientConfig, TwoFactorSetup,+ lifecycle::recover_two_factor,login::{LoginFlow, LoginStep},+ models::TwoFactorType,signup::Signup,};use ente_test_support::account_fixture::current_totp;@@ -60,6 +62,26 @@ async fn run(endpoint: String) -> TestResult {assert_eq!(login.secrets.master_key, created.secrets.master_key);assert_eq!(client.email().await.unwrap(), email);assert!(client.get_two_factor_status().await.unwrap());++ let recovery_client = accounts_client(endpoint);+ recovery_client.send_otp(&email, "login").await?;+ let response = recovery_client+ .verify_email(&email, HARDCODED_OTT, None)+ .await?;+ let session_id = response.get_two_factor_session_id().unwrap();+ let recovery = recovery_client+ .get_two_factor_recovery(session_id, TwoFactorType::Totp)+ .await?;+ let recovered = recover_two_factor(+ &recovery_client,+ TwoFactorType::Totp,+ session_id,+ &recovery,+ &setup.recovery_key,+ )+ .await?;+ assert_eq!(recovered.id, created.user_id);+ assert!(!client.get_two_factor_status().await?);Ok(())}diff --git a/web/apps/space/src/services/bootstrap-auth.ts b/web/apps/space/src/services/bootstrap-auth.tsindex 788213e489..c22ba24980 100644--- a/web/apps/space/src/services/bootstrap-auth.ts+++ b/web/apps/space/src/services/bootstrap-auth.ts@@ -2,6 +2,7 @@ import {boxSealOpenBytes,decryptBox,toB64URLSafe,+ validateAuthToken,} from "ente-accounts/services/crypto";import type { SRPSetupAttributes } from "ente-accounts/services/srp";import type { KeyAttributes } from "ente-accounts/services/user";@@ -27,9 +28,12 @@ export const decryptSpaceBootstrapAuthToken = async (masterKey,);- return toB64URLSafe(- await boxSealOpenBytes(encryptedToken, { publicKey, privateKey }),- );+ const token = await boxSealOpenBytes(encryptedToken, {+ publicKey,+ privateKey,+ });+ await validateAuthToken(token);+ return toB64URLSafe(token);};export const putSpaceSignupKeyAttributes = async (diff --git a/web/packages/accounts/services/crypto/index.ts b/web/packages/accounts/services/crypto/index.tsindex 04f8ba7e72..e77571b48f 100644--- a/web/packages/accounts/services/crypto/index.ts+++ b/web/packages/accounts/services/crypto/index.ts@@ -10,7 +10,10 @@ export {encryptBox,generateKey,generateKeyPair,+ parseDeleteAccountChallenge,recoveryKeyFromMnemonicOrHex,+ twoFactorRecoveryProof,+ validateAuthToken,} from "ente-prelogin-wasm";export type { DerivedKey } from "./kdf";diff --git a/web/packages/accounts/services/user.ts b/web/packages/accounts/services/user.tsindex 3cbd4e9961..f47eb3a97f 100644--- a/web/packages/accounts/services/user.ts+++ b/web/packages/accounts/services/user.ts@@ -14,6 +14,8 @@ import {generateKey,generateKeyPair,toB64URLSafe,+ twoFactorRecoveryProof,+ validateAuthToken,} from "ente-accounts/services/crypto";import { generateInteractiveKeyAttributes } from "ente-accounts/services/key-attributes";import {@@ -323,9 +325,12 @@ export const decryptAndStoreTokenIfNeeded = async (masterKey,);- const token = await toB64URLSafe(- await boxSealOpenBytes(encryptedToken, { publicKey, privateKey }),- );+ const tokenBytes = await boxSealOpenBytes(encryptedToken, {+ publicKey,+ privateKey,+ });+ await validateAuthToken(tokenBytes);+ const token = await toB64URLSafe(tokenBytes);updateSavedLocalUser({ token, encryptedToken: undefined });return saveAuthToken(token);@@ -446,7 +451,7 @@ export const recoverTwoFactorFinish = async (const { id, keyAttributes, encryptedToken } = await removeTwoFactor(twoFactorType,sessionID,- twoFactorSecret,+ await twoFactorRecoveryProof(twoFactorType, sessionID, twoFactorSecret),);await resetSavedLocalUserTokens(id, encryptedToken);updateSavedLocalUser({@@ -461,12 +466,12 @@ export const recoverTwoFactorFinish = async (const removeTwoFactor = async (twoFactorType: TwoFactorType,sessionID: string,- secret: string,+ proof: string,): Promise<TwoFactorAuthorizationResponse> => {const res = await fetch(await apiURL("/users/two-factor/remove"), {method: "POST",headers: publicRequestHeaders(),- body: JSON.stringify({ twoFactorType, sessionID, secret }),+ body: JSON.stringify({ twoFactorType, sessionID, proof }),});ensureOk(res);return TwoFactorAuthorizationResponse.parse(await res.json());diff --git a/web/packages/new/photos/services/user.ts b/web/packages/new/photos/services/user.tsindex d017f56e24..bb73d255e0 100644--- a/web/packages/new/photos/services/user.ts+++ b/web/packages/new/photos/services/user.ts@@ -1,3 +1,4 @@+import { parseDeleteAccountChallenge } from "ente-accounts/services/crypto";import { ensureSavedKeyAttributes } from "ente-accounts/services/user";import { boxSealOpenBytes, decryptBox } from "ente-base/crypto";import type { KeyPair } from "ente-base/crypto/types";@@ -79,7 +80,7 @@ export const getAccountDeleteChallenge = async () => {export const decryptDeleteAccountChallenge = async (encryptedChallenge: string,) =>- new TextDecoder().decode(+ parseDeleteAccountChallenge(await boxSealOpenBytes(encryptedChallenge, await ensureUserKeyPair()),);diff --git a/web/packages/wasm/prelogin/index.ts b/web/packages/wasm/prelogin/index.tsindex f29bb45dce..852fee5b9b 100644--- a/web/packages/wasm/prelogin/index.ts+++ b/web/packages/wasm/prelogin/index.ts@@ -74,6 +74,20 @@ export const boxSealOpenBytes = async (keyPair.privateKey,);+export const validateAuthToken = async (token: Uint8Array): Promise<void> =>+ (await wasm()).authValidateToken(token);++export const parseDeleteAccountChallenge = async (+ plaintext: Uint8Array,+): Promise<string> => (await wasm()).authParseDeleteAccountChallenge(plaintext);++export const twoFactorRecoveryProof = async (+ twoFactorType: "totp" | "passkey",+ sessionID: string,+ secret: string,+): Promise<string> =>+ (await wasm()).authTwoFactorRecoveryProof(twoFactorType, sessionID, secret);+const toB64String = (value: Uint8Array | string): string => {if (typeof value == "string") return value;let binary = "";diff --git a/web/packages/wasm/prelogin/tests/crypto.test.ts b/web/packages/wasm/prelogin/tests/crypto.test.tsindex 563cb56946..54422a3ab0 100644--- a/web/packages/wasm/prelogin/tests/crypto.test.ts+++ b/web/packages/wasm/prelogin/tests/crypto.test.ts@@ -1,13 +1,65 @@import { expect, test } from "vitest";-import { boxSealOpenBytes } from "../index";+import {+ boxSealOpenBytes,+ parseDeleteAccountChallenge,+ twoFactorRecoveryProof,+ validateAuthToken,+} from "../index";++const keyPair = {+ publicKey: "W/Vcc7guviK+gPNDBmevVw+uJVamQV5rMNQGUwCqlH0=",+ privateKey: "UEatwduoOIZ7K7v90MNCPli1eXC1JnqQ9XlgkkqH8ZY=",+};test("opens a libsodium sealed token as bytes", async () => {const token = await boxSealOpenBytes("jVHae52Eixf5JkF0B0jZYR0U/KQ8ckCM631dw253O0bPMmpGHRPieCG/KRKk075x4STFEptJDw==",- {- publicKey: "W/Vcc7guviK+gPNDBmevVw+uJVamQV5rMNQGUwCqlH0=",- privateKey: "UEatwduoOIZ7K7v90MNCPli1eXC1JnqQ9XlgkkqH8ZY=",- },+ keyPair,);expect(token).toStrictEqual(new Uint8Array([0, 1, 127, 128, 254, 255, 16]));});++test("Rust auth bindings accept each payload only for its purpose", async () => {+ const tokenCipher =+ "BpFBq0d0Cvg5UO3phwRdNmcTHuQu6Pw5ibUXaXXnGGFYy0pmmSVXC57oAUu3mGk/CUsNdTIKAM1EEsllw6SiwWNHy5seNhc22Kk+UyvwCdxFvzHgwll+KCGh";+ const deletionCipher =+ "HEL5WY2HxHH07zzDqS+DFDnJTgDdVsH7EH7H1r/FxhSnkMtVVOE4TgZrBlMfZA7PzAr/wGnxbz2BuDv1sH0vMflhiepDfhs4JZ3Wk3w7cETJlQ==";+ const token = await boxSealOpenBytes(tokenCipher, keyPair);+ const deletion = await boxSealOpenBytes(deletionCipher, keyPair);+ await expect(validateAuthToken(token)).resolves.toBeUndefined();+ expect(token).toEqual(+ new Uint8Array([+ ...new TextEncoder().encode("auth-token"),+ ...Array.from({ length: 32 }, (_, i) => i),+ ]),+ );+ expect(await parseDeleteAccountChallenge(deletion)).toBe(+ "header.payload.signature",+ );+ await expect(validateAuthToken(deletion)).rejects.toThrow(+ "Invalid login token",+ );+ await expect(parseDeleteAccountChallenge(token)).rejects.toThrow(+ "Invalid deletion challenge",+ );+});++test.each([+ [+ "totp",+ "JBSWY3DPEHPK3PXPJBSWY3DPEHPK3PXP",+ "GLPadofZrER+5+7OLkqiNxlmyS6XzaKGdsMeHg1lnvU=",+ ],+ [+ "passkey",+ "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",+ "PxcSH0NrKUX3u330jU6TtYp/I/mT4087vajBXIdPh0I=",+ ],+] as const)(+ "%s proof crosses the WASM binding correctly",+ async (factor, secret, expected) => {+ expect(+ await twoFactorRecoveryProof(factor, "recovery-session", secret),+ ).toBe(expected);+ },+);