Skip to content

armgit / ente

Public Imported from GitHub
0

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

Validate authentication payloads across clients

Neeraj Guptadac593311ffc
diff --git a/cli/pkg/sign_in.go b/cli/pkg/sign_in.go
index 09c68da626..31b93126c5 100644
--- a/cli/pkg/sign_in.go
+++ b/cli/pkg/sign_in.go
@@ -1,6 +1,7 @@
package pkg
import (
+ "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.go
new file mode 100644
index 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.dart
index 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.dart
index 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.dart
index 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.dart
index 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.dart
new file mode 100644
index 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.dart
index 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.dart
index 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.yaml
index 2fcc49f400..b7d3b5caff 100644
--- a/mobile/packages/configuration/pubspec.yaml
+++ b/mobile/packages/configuration/pubspec.yaml
@@ -16,6 +16,8 @@ dependencies:
path: ../../packages/events
ente_logging:
path: ../../packages/logging
+ ente_pure_utils:
+ path: ../ente_pure_utils
flutter:
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.dart
new file mode 100644
index 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.dart
new file mode 100644
index 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.lock
index 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.rs
index 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.toml
index 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 = true
getrandom.workspace = true
hex = "0.4.0"
+hmac.workspace = true
serde.workspace = true
serde_json.workspace = true
sha2.workspace = true
diff --git a/rust/crates/accounts/src/auth/api.rs b/rust/crates/accounts/src/auth/api.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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).await
diff --git a/rust/crates/accounts/src/lifecycle/tests.rs b/rust/crates/accounts/src/lifecycle/tests.rs
index 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.rs
index 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.rs
index 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.rs
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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);
+ },
+);