Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Refactor tests to reside in separate folder namespace
Leendert de Borst8527c2643f64
diff --git a/apps/web/src/services/RegistrationService.ts b/apps/web/src/services/RegistrationService.tsindex e99ee70cf..3bdd92d96 100644--- a/apps/web/src/services/RegistrationService.ts+++ b/apps/web/src/services/RegistrationService.ts@@ -22,6 +22,6 @@ export const RegistrationService = {await setAuthTokens(registered.username, registered.token.token, registered.token.refreshToken);await VaultKeyService.cacheVaultKeyBlobs({ type: UnlockMethodType.Password, algorithm: registered.keys.accountKeys.encryptedAccountKeyAlgorithm, ...registered.keys.accountKeys, ...registered.derivationParams });await vaultStore.storeUnlockKeyDerivationParams(registered.derivationParams);- await vaultStore.storeAccountKey(registered.derivedKey);+ await vaultStore.storeAccountKey(registered.keys.accountKey);},};diff --git a/core/client/src/auth/SrpLoginService.ts b/core/client/src/auth/SrpLoginService.tsindex 5e1470f45..83534c56c 100644--- a/core/client/src/auth/SrpLoginService.ts+++ b/core/client/src/auth/SrpLoginService.ts@@ -35,7 +35,8 @@ export type RegistrationResult = {username: string;token: TokenModel;keys: AccountKeyHierarchy;- derivedKey: string;+ /** The unlock key of the new password; the session stores `keys.accountKey`. */+ unlockKey: string;derivationParams: UnlockKeyDerivationParams;};@@ -62,7 +63,7 @@ export class SrpLoginService {const prepared = await SrpAuthService.prepareRegistration(username, password);const token = await this.parseAuthResponse<TokenModel>(await this.post('Auth/register', { ...prepared.request, inviteCode }));const { salt, encryptionType, encryptionSettings } = prepared.request;- return { username: prepared.request.username, token, keys: prepared.keys, derivedKey: prepared.derivedKey, derivationParams: { salt, encryptionType, encryptionSettings } };+ return { username: prepared.request.username, token, keys: prepared.keys, unlockKey: prepared.unlockKey, derivationParams: { salt, encryptionType, encryptionSettings } };}/**diff --git a/core/rust/src/credential_matcher/tests.rs b/core/rust/src/credential_matcher/tests/mod.rssimilarity index 100%rename from core/rust/src/credential_matcher/tests.rsrename to core/rust/src/credential_matcher/tests/mod.rsdiff --git a/core/rust/src/crypto/aad.rs b/core/rust/src/crypto/aad.rsindex 4f752c034..c04192ea7 100644--- a/core/rust/src/crypto/aad.rs+++ b/core/rust/src/crypto/aad.rs@@ -61,21 +61,3 @@ pub fn invitation_name(manifest_id: &str) -> Vec<u8> {pub(crate) fn normalize(id: &str) -> String {id.to_ascii_lowercase()}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn labels_are_stable_and_case_insensitive_on_ids() {- assert_eq!(manifest("0A1B2C3D-0000-0000-0000-000000000001"), b"aliasvault/v1/manifest/0a1b2c3d-0000-0000-0000-000000000001".to_vec());- assert_eq!(bucket("0a1b2c3d-0000-0000-0000-000000000001", "settings"), b"aliasvault/v1/bucket/0a1b2c3d-0000-0000-0000-000000000001/settings".to_vec());- assert_eq!(blob_data("ID", "ABCD"), b"aliasvault/v1/blob/id/abcd".to_vec());- assert_eq!(blob_key("ID", "ABCD"), b"aliasvault/v1/blob-key/id/abcd".to_vec());- assert_eq!(manifest_name("ID"), b"aliasvault/v1/manifest-name/id".to_vec());- assert_eq!(grant("ID"), b"aliasvault/v1/grant/id".to_vec());- assert_eq!(invitation_name("ID"), b"aliasvault/v1/invitation-name/id".to_vec());- assert_eq!(MOBILE_LOGIN_ACCOUNT_KEY, b"aliasvault/v1/mobile-login/account-key");- assert_eq!(MOBILE_LOGIN_PAYLOAD_KEY, b"aliasvault/v1/mobile-login/payload-key");- }-}diff --git a/core/rust/src/crypto/argon2.rs b/core/rust/src/crypto/argon2.rsindex 1b9a5ffd7..f1046a9c9 100644--- a/core/rust/src/crypto/argon2.rs+++ b/core/rust/src/crypto/argon2.rs@@ -98,43 +98,3 @@ pub fn argon2_derive_key_bytes_from_settings(password: &[u8], salt: &[u8], settilet params = Argon2Params::from_settings_json(settings_json)?;argon2_derive_key(password, salt, params)}--#[cfg(test)]-mod tests {- use super::*;- use crate::common::encoding::base64_encode;-- #[test]- fn parses_complete_settings() {- let params = Argon2Params::from_settings_json(r#"{"DegreeOfParallelism":1,"MemorySize":65536,"Iterations":5}"#).unwrap();- assert_eq!(params, Argon2Params { memory_kib: 65536, iterations: 5, parallelism: 1 });- }-- #[test]- fn rejects_incomplete_or_empty_settings() {- for settings in ["", "{}", r#"{"MemorySize":65536,"Iterations":5}"#] {- assert!(matches!(Argon2Params::from_settings_json(settings), Err(Argon2Error::InvalidSettings(_))), "accepted {settings:?}");- }- }-- #[test]- fn rejects_params_below_the_minimum() {- for settings in [r#"{"DegreeOfParallelism":1,"MemorySize":19455,"Iterations":2}"#, r#"{"DegreeOfParallelism":1,"MemorySize":65536,"Iterations":1}"#, r#"{"DegreeOfParallelism":0,"MemorySize":65536,"Iterations":5}"#] {- assert!(matches!(argon2_derive_key_from_settings("password", "[email protected]", settings), Err(Argon2Error::InvalidParameter(_))), "accepted {settings}");- }- }-- #[test]- fn matches_the_reference_implementation() {- // Expected keys come from libargon2 (argon2-cffi), for the pre-0.31.0 and the current default settings. A- // different output means existing accounts can no longer derive their key.- let cases = [- (r#"{"DegreeOfParallelism":1,"MemorySize":19456,"Iterations":2}"#, "l12OncuAll3SmDPkfv2sHtxaoEVsCXfuFulTShtBfxA="),- (r#"{"DegreeOfParallelism":1,"MemorySize":65536,"Iterations":5}"#, "j7bnKpt3W46ak6Qid2JENR7NxznhfgRNDWAImnpAc40="),- ];- for (settings, expected) in cases {- let key = argon2_derive_key_from_settings("password", "[email protected]", settings).unwrap();- assert_eq!(base64_encode(&key), expected, "settings {settings}");- }- }-}diff --git a/core/rust/src/crypto/jwk.rs b/core/rust/src/crypto/jwk.rsindex 928044e58..0713c9205 100644--- a/core/rust/src/crypto/jwk.rs+++ b/core/rust/src/crypto/jwk.rs@@ -117,28 +117,3 @@ fn decode_field(value: &str) -> VaultResult<BigUint> {fn encode_field(value: &BigUint) -> String {base64url_encode(&Zeroizing::new(value.to_bytes_be()))}--#[cfg(test)]-mod tests {- use super::*;-- /// The member order of both JWK shapes is part of the stored format.- #[test]- fn member_order_is_stable_with_and_without_usage() {- let key = RsaPrivateKey::new(&mut rand_core06::OsRng, 1024).unwrap();- let usage = JwkUsage { key_op: "decrypt", alg: "RSA-OAEP-256" };- // Member names in written order; no JWK value contains ',' or ':'.- let keys_of = |json: &str| -> Vec<String> { json.trim_matches(['{', '}']).split(',').filter_map(|part| part.split(':').next().filter(|s| s.starts_with('"'))).map(|s| s.trim_matches('"').to_string()).collect() };- let with = rsa_private_to_jwk(&key, Some(usage)).unwrap();- assert_eq!(keys_of(&with), ["key_ops", "ext", "alg", "kty", "n", "e", "d", "p", "q", "dp", "dq", "qi"]);- assert!(with.starts_with("{\"key_ops\":[\"decrypt\"],\"ext\":true,\"alg\":\"RSA-OAEP-256\",\"kty\":\"RSA\","));- let without = rsa_private_to_jwk(&key, None).unwrap();- assert_eq!(keys_of(&without), ["kty", "n", "e", "d", "p", "q", "dp", "dq", "qi"]);- let public = rsa_public_to_jwk(&key.to_public_key(), None).unwrap();- assert_eq!(keys_of(&public), ["kty", "n", "e"]);-- assert_eq!(rsa_private_from_jwk(&with).unwrap(), key);- assert_eq!(rsa_private_from_jwk(&without).unwrap(), key);- assert_eq!(rsa_public_from_jwk(&public).unwrap(), key.to_public_key());- }-}diff --git a/core/rust/src/crypto/key_chain.rs b/core/rust/src/crypto/key_chain.rsindex 71e894441..6230f91ed 100644--- a/core/rust/src/crypto/key_chain.rs+++ b/core/rust/src/crypto/key_chain.rs@@ -260,191 +260,3 @@ pub fn rotate_account_keys(new_unlock_key_base64: &str, key_pair: &RsaKeyPair) -account_keys: hierarchy.account_keys.clone(),})}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn rotated_keys_open_with_the_new_unlock_key() {- let old_hierarchy = create_account_key_hierarchy(&generate_key_base64()).unwrap();- let new_unlock_key = generate_key_base64();- let key_pair = generate_rsa_key_pair().unwrap();-- let rotated = rotate_account_keys(&new_unlock_key, &key_pair).unwrap();- let blobs = &rotated.account_keys;-- // The new chain opens with the new unlock key and yields the new VEK and private keys.- let opened = open_account_key_chain(&new_unlock_key, &blobs.encrypted_account_key, &blobs.encrypted_vek, Some(&blobs.encrypted_account_private_key)).unwrap();- assert_eq!(*opened.vault_encryption_key, rotated.vault_encryption_key);- assert_eq!(*opened.account_key, rotated.account_key);- assert_eq!(opened.account_private_key.as_deref().map(String::as_str), Some(key_pair.private_key.as_str()));- assert_ne!(rotated.vault_encryption_key, old_hierarchy.vault_encryption_key);- assert_ne!(blobs.signing_public_key, old_hierarchy.account_keys.signing_public_key);-- // The new signing key vouches for the new account public key.- assert!(signing::verify(&blobs.signing_public_key, &signing::account_public_key_message(&blobs.account_public_key), &blobs.account_public_key_signature));- }-- /// Known-answer vector: every host derives the KEK through this one function, and a changed output means no- /// stored Account Key opens any more. Never regenerate it.- #[test]- fn derive_kek_known_answer() {- let unlock_key: Vec<u8> = (0u8..32).collect();- assert_eq!(crate::common::encoding::hex_encode_upper(&derive_kek(&unlock_key)), KEK_VECTOR);- }-- /// HKDF-SHA256(ikm = 0x00..0x1f, salt = none, info = "AliasVault KEK v1", L = 32).- const KEK_VECTOR: &str = "8103CACFCD107162AECCFAEDB26426F53FF28C5D4273D2440641A5FA3ADD39D2";-- /// Known-answer vector for the SRP input of an `Argon2IdHkdf` account: a changed output means no upgraded- /// verifier matches any more. Never regenerate it.- #[test]- fn derive_srp_password_hash_known_answer() {- let unlock_key: Vec<u8> = (0u8..32).collect();- assert_eq!(*derive_srp_password_hash(&unlock_key, ENCRYPTION_TYPE_ARGON2ID_HKDF).unwrap(), SRP_VECTOR);- assert_eq!(*derive_srp_password_hash(&unlock_key, ENCRYPTION_TYPE_ARGON2ID).unwrap(), crate::common::encoding::hex_encode_upper(&unlock_key));- }-- /// HKDF-SHA256(ikm = 0x00..0x1f, salt = none, info = "AliasVault SRP v1", L = 32).- const SRP_VECTOR: &str = "BC09E255E5425823B7347FD803F4C5DCE8F11A7BC23B6F78FCC3D6D87240D923";-- #[test]- fn srp_input_and_kek_are_separate() {- let unlock_key: Vec<u8> = (0u8..32).collect();- let srp = derive_srp_password_hash(&unlock_key, ENCRYPTION_TYPE_ARGON2ID_HKDF).unwrap();- assert_ne!(*srp, crate::common::encoding::hex_encode_upper(&derive_kek(&unlock_key)));- assert!(matches!(derive_srp_password_hash(&unlock_key, "Scrypt"), Err(SrpInputError::UnsupportedEncryptionType(_))));- }-- #[test]- fn kek_differs_from_the_unlock_key() {- let unlock_key = generate_key_base64();- assert_ne!(*derive_kek_base64(&unlock_key).unwrap(), unlock_key);- }-- #[test]- fn account_key_is_not_wrapped_with_the_raw_unlock_key() {- let unlock_key = generate_key_base64();- let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();- assert!(unwrap_key(&hierarchy.account_keys.encrypted_account_key, &unlock_key, aad::ACCOUNT_KEY).is_err());- assert!(unwrap_key(&hierarchy.account_keys.encrypted_account_key, &derive_kek_base64(&unlock_key).unwrap(), aad::ACCOUNT_KEY).is_ok());- }-- #[test]- fn chain_opens_with_the_unlock_key_and_hands_back_the_account_key() {- let unlock_key = generate_key_base64();- let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();- let blobs = &hierarchy.account_keys;-- let opened = open_account_key_chain(&unlock_key, &blobs.encrypted_account_key, &blobs.encrypted_vek, Some(&blobs.encrypted_account_private_key)).unwrap();- assert_eq!(*opened.vault_encryption_key, hierarchy.vault_encryption_key);- assert_eq!(opened.account_private_key.as_deref().map(String::as_str), Some(hierarchy.account_private_key.as_str()));- assert_ne!(*opened.account_key, unlock_key);-- let reopened = open_account_key_chain(&opened.account_key, &blobs.encrypted_account_key, &blobs.encrypted_vek, Some(&blobs.encrypted_account_private_key)).unwrap();- assert_eq!(*reopened.vault_encryption_key, hierarchy.vault_encryption_key);- assert_eq!(*reopened.account_key, *opened.account_key, "a stored Account Key is handed back unchanged");- }-- #[test]- fn chain_rejects_a_wrong_key() {- let hierarchy = create_account_key_hierarchy(&generate_key_base64()).unwrap();- let blobs = &hierarchy.account_keys;- assert_eq!(open_account_key_chain(&generate_key_base64(), &blobs.encrypted_account_key, &blobs.encrypted_vek, None).err(), Some(KeyChainError::UnlockKeyRejected));- }-- #[test]- fn chain_with_a_foreign_vek_is_unreadable() {- let unlock_key = generate_key_base64();- let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();- let foreign_vek = wrap_key(&generate_key_base64(), &generate_key_base64(), aad::PERSONAL_VEK).unwrap();- let result = open_account_key_chain(&unlock_key, &hierarchy.account_keys.encrypted_account_key, &foreign_vek, None);- assert!(matches!(result, Err(KeyChainError::KeyChainUnreadable(_))));- }-- #[test]- fn hierarchy_takes_a_host_key_pair_and_rejects_a_mismatched_one() {- let unlock_key = generate_key_base64();- let key_pair = generate_rsa_key_pair().unwrap();- let hierarchy = create_account_key_hierarchy_with_key_pair(&unlock_key, &key_pair).unwrap();- assert_eq!(hierarchy.account_keys.account_public_key, key_pair.public_key);- assert_eq!(hierarchy.account_private_key, key_pair.private_key);-- let mismatched = RsaKeyPair { public_key: generate_rsa_key_pair().unwrap().public_key.clone(), private_key: key_pair.private_key.clone() };- assert!(create_account_key_hierarchy_with_key_pair(&unlock_key, &mismatched).is_err());- }-- #[test]- fn hierarchy_carries_a_signing_key_that_signed_the_account_public_key() {- let unlock_key = generate_key_base64();- let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();- let blobs = &hierarchy.account_keys;- let account_key = unwrap_account_key(&blobs.encrypted_account_key, &unlock_key).unwrap();-- let signing_private_key = open_account_signing_private_key(&blobs.encrypted_signing_private_key, &account_key).unwrap();- assert_eq!(*signing_private_key, hierarchy.signing_private_key);- assert_eq!(signing::signing_public_key_of(&signing_private_key).unwrap(), blobs.signing_public_key);-- let message = signing::account_public_key_message(&blobs.account_public_key);- assert!(signing::verify(&blobs.signing_public_key, &message, &blobs.account_public_key_signature));- assert!(open_account_private_key(&blobs.encrypted_signing_private_key, &account_key).is_err(), "the signing key does not open in the account private key slot");- }-- #[test]- fn reencrypted_account_key_opens_with_the_new_unlock_key_only() {- let old_unlock_key = generate_key_base64();- let new_unlock_key = generate_key_base64();- let hierarchy = create_account_key_hierarchy(&old_unlock_key).unwrap();- let blobs = &hierarchy.account_keys;-- let reencrypted = reencrypt_account_key(&blobs.encrypted_account_key, &old_unlock_key, &new_unlock_key).unwrap();- let opened = open_account_key_chain(&new_unlock_key, &reencrypted.new_encrypted_account_key, &blobs.encrypted_vek, None).unwrap();- assert_eq!(*opened.vault_encryption_key, hierarchy.vault_encryption_key);- assert_eq!(*opened.account_key, reencrypted.account_key);- assert!(open_account_key_chain(&old_unlock_key, &reencrypted.new_encrypted_account_key, &blobs.encrypted_vek, None).is_err());- }-- #[test]- fn reencrypt_rejects_a_wrong_old_unlock_key() {- let hierarchy = create_account_key_hierarchy(&generate_key_base64()).unwrap();- let result = reencrypt_account_key(&hierarchy.account_keys.encrypted_account_key, &generate_key_base64(), &generate_key_base64());- assert_eq!(result.err(), Some(KeyChainError::UnlockKeyRejected));- }-- #[test]- fn wrap_and_unwrap_round_trip() {- let wrapping = generate_key_base64();- let key = generate_key_base64();- assert_eq!(*unwrap_key(&wrap_key(&key, &wrapping, b"a").unwrap(), &wrapping, b"a").unwrap(), key);- assert!(unwrap_key(&wrap_key(&key, &wrapping, b"a").unwrap(), &wrapping, b"b").is_err());- }-- #[test]- fn chain_ciphertexts_do_not_open_in_each_others_slot() {- let unlock_key = generate_key_base64();- let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();- let blobs = &hierarchy.account_keys;- let account_key = unwrap_account_key(&blobs.encrypted_account_key, &unlock_key).unwrap();-- // The Account Key wrap served as the VEK wrap, under the KEK: refused, not read as the VEK.- let swapped = open_account_key_chain(&unlock_key, &blobs.encrypted_account_key, &blobs.encrypted_account_key, None);- assert!(matches!(swapped, Err(KeyChainError::KeyChainUnreadable(_))));- assert!(unwrap_key(&blobs.encrypted_vek, &account_key, aad::ACCOUNT_KEY).is_err());- assert!(open_account_private_key(&blobs.encrypted_account_private_key, &account_key).is_ok());- assert!(symmetric_decrypt_with_aad(&blobs.encrypted_account_private_key, &account_key, aad::PERSONAL_VEK).is_err());- }-- #[test]- fn an_account_key_encrypted_under_any_other_label_is_refused() {- let unlock_key = generate_key_base64();- let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();- let account_key = unwrap_account_key(&hierarchy.account_keys.encrypted_account_key, &unlock_key).unwrap();- let kek = derive_kek_base64(&unlock_key).unwrap();- for label in [aad::PERSONAL_VEK, aad::ACCOUNT_PRIVATE_KEY, aad::ACCOUNT_SIGNING_PRIVATE_KEY, aad::MOBILE_LOGIN_ACCOUNT_KEY, aad::MOBILE_LOGIN_PAYLOAD_KEY, b""] {- let foreign = wrap_key(&account_key, &kek, label).unwrap();- let opened = open_account_key_chain(&unlock_key, &foreign, &hierarchy.account_keys.encrypted_vek, None);- assert!(matches!(opened, Err(KeyChainError::UnlockKeyRejected)), "label {:?}", String::from_utf8_lossy(label));- }- }-}diff --git a/core/rust/src/crypto/mobile_login.rs b/core/rust/src/crypto/mobile_login.rsindex d47b4e9ac..e4c047d1d 100644--- a/core/rust/src/crypto/mobile_login.rs+++ b/core/rust/src/crypto/mobile_login.rs@@ -22,19 +22,3 @@ pub fn mobile_login_verification_code(public_key_jwk: &str) -> String {let value = u32::from_be_bytes([digest[0], digest[1], digest[2], digest[3]]);format!("{:0width$}", value % 10u32.pow(VERIFICATION_CODE_DIGITS), width = VERIFICATION_CODE_DIGITS as usize)}--#[cfg(test)]-mod tests {- use super::*;-- /// Known-answer vectors from the former TypeScript implementation, which released clients still run. A changed- /// output means an old and a new client no longer agree on the QR code or the code they show. Never regenerate them.- #[test]- fn known_answers() {- let jwk = r#"{"kty":"RSA","n":"abc","e":"AQAB"}"#;- assert_eq!(mobile_login_public_key_hash(jwk), "1Dew3uCqsSjh4UPhSxj4DAT-YUO3M3XGzR2594gSIYw");- assert_eq!(mobile_login_verification_code(jwk), "07");- assert_eq!(mobile_login_public_key_hash("héllo ✓"), "VlfN74qFpYTg6WHm-CR89dP47SFJbtb9vP1Dp2HpQkU");- assert_eq!(mobile_login_verification_code("héllo ✓"), "39");- }-}diff --git a/core/rust/src/crypto/mod.rs b/core/rust/src/crypto/mod.rsindex 916496f52..479c128ae 100644--- a/core/rust/src/crypto/mod.rs+++ b/core/rust/src/crypto/mod.rs@@ -28,13 +28,17 @@ pub mod srp;pub mod tokens;pub mod vault_blob;+#[cfg(test)]+mod tests;+pub use aes_gcm::{generate_key_base64, symmetric_decrypt, symmetric_decrypt_bytes, symmetric_decrypt_bytes_with_aad, symmetric_decrypt_with_aad, symmetric_encrypt, symmetric_encrypt_bytes,symmetric_encrypt_raw_with_aad, symmetric_encrypt_with_aad,};pub use key_chain::{- account_signing_key_fingerprint, create_account_key_hierarchy, create_account_key_hierarchy_with_key_pair, derive_srp_password_hash, open_account_key_chain, open_account_private_key, open_account_signing_private_key,- reencrypt_account_key, rotate_account_keys, unwrap_account_key, unwrap_key, wrap_key, AccountKeyBlobs, AccountKeyHierarchy, KeyChainError, RotatedAccountKeys, SrpInputError,+ account_signing_key_fingerprint, create_account_key_hierarchy, create_account_key_hierarchy_with_key_pair, derive_srp_password_hash, open_account_private_key, open_account_signing_private_key,+ open_key_chain_with_account_key, open_key_chain_with_unlock_key, reencrypt_account_key, rotate_account_keys, unwrap_account_key, unwrap_key, wrap_key, AccountKeyBlobs, AccountKeyHierarchy, KeyChainError,+ RotatedAccountKeys, SrpInputError,};pub use mobile_login::{mobile_login_public_key_hash, mobile_login_verification_code};pub use pin::{pin_decrypt, pin_encrypt, pin_generate_salt, pin_is_locked, pin_register_failure, PinFailure};diff --git a/core/rust/src/crypto/pin.rs b/core/rust/src/crypto/pin.rsindex eb4dcda1a..5869ee13e 100644--- a/core/rust/src/crypto/pin.rs+++ b/core/rust/src/crypto/pin.rs@@ -12,10 +12,10 @@ use crate::crypto::argon2::argon2_derive_key_bytes_from_settings;pub const PIN_MAX_ATTEMPTS: u32 = 4;/// Length of the random salt a new PIN wrap is derived with.-const PIN_SALT_LENGTH: usize = 16;+pub(super) const PIN_SALT_LENGTH: usize = 16;/// Argon2id cost parameters for the PIN key. Note: changing this makes any existing PINs not work anymore.-const PIN_ARGON2_SETTINGS: &str = r#"{"MemorySize":65536,"Iterations":3,"DegreeOfParallelism":1}"#;+pub(super) const PIN_ARGON2_SETTINGS: &str = r#"{"MemorySize":65536,"Iterations":3,"DegreeOfParallelism":1}"#;/// The counter state after a failed PIN attempt.#[derive(Clone, Debug, PartialEq, Eq, Serialize)]@@ -59,39 +59,3 @@ pub fn pin_register_failure(failed_attempts: u32) -> PinFailure {fn derive_pin_key(pin: &str, salt: &[u8]) -> VaultResult<Zeroizing<Vec<u8>>> {argon2_derive_key_bytes_from_settings(pin.as_bytes(), salt, PIN_ARGON2_SETTINGS).map(Zeroizing::new).map_err(|e| VaultError::General(e.to_string()))}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn round_trips_and_rejects_a_wrong_pin() {- let salt = pin_generate_salt();- assert_eq!(salt.len(), PIN_SALT_LENGTH);- let encrypted = pin_encrypt("123456", &salt, b"account key").unwrap();- assert_eq!(encrypted.len(), 12 + b"account key".len() + 16, "layout is IV | ciphertext | tag");- assert_eq!(pin_decrypt("123456", &salt, &encrypted).unwrap(), b"account key");- assert!(pin_decrypt("654321", &salt, &encrypted).is_err());- assert!(pin_decrypt("123456", &pin_generate_salt(), &encrypted).is_err());- }-- #[test]- fn opens_a_wrap_made_with_the_argon2_key_directly() {- // A wrap stored before this module existed: Argon2id under the PIN settings, then AES-GCM with that key.- let salt = b"some-salt-bytes!";- let key = argon2_derive_key_bytes_from_settings(b"8765432", salt, PIN_ARGON2_SETTINGS).unwrap();- let encrypted = symmetric_encrypt_with_raw_key(b"secret", &key).unwrap();- assert_eq!(pin_decrypt("8765432", salt, &encrypted).unwrap(), b"secret");- }-- #[test]- fn locks_after_the_maximum_attempts() {- assert!(!pin_is_locked(0));- assert!(!pin_is_locked(PIN_MAX_ATTEMPTS - 1));- assert!(pin_is_locked(PIN_MAX_ATTEMPTS));- assert_eq!(pin_register_failure(0), PinFailure { failed_attempts: 1, attempts_remaining: 3, locked: false });- assert_eq!(pin_register_failure(2), PinFailure { failed_attempts: 3, attempts_remaining: 1, locked: false });- assert_eq!(pin_register_failure(3), PinFailure { failed_attempts: 4, attempts_remaining: 0, locked: true });- assert_eq!(pin_register_failure(u32::MAX), PinFailure { failed_attempts: u32::MAX, attempts_remaining: 0, locked: true });- }-}diff --git a/core/rust/src/crypto/rsa_oaep.rs b/core/rust/src/crypto/rsa_oaep.rsindex d8c6a1d25..769ff439a 100644--- a/core/rust/src/crypto/rsa_oaep.rs+++ b/core/rust/src/crypto/rsa_oaep.rs@@ -86,25 +86,3 @@ fn decrypt(base64_ciphertext: &str, private_key_jwk: &str, padding: Oaep) -> Vaufn label_text(label: &[u8]) -> VaultResult<String> {String::from_utf8(label.to_vec()).map_err(|_| VaultError::General("RSA-OAEP label must be UTF-8".to_string()))}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn label_must_match() {- let pair = generate_rsa_key_pair().unwrap();- let ciphertext = encrypt_with_public_key_and_label(b"vek", &pair.public_key, b"grant/a").unwrap();- assert_eq!(decrypt_with_private_key_and_label(&ciphertext, &pair.private_key, b"grant/a").unwrap(), b"vek");- assert!(decrypt_with_private_key_and_label(&ciphertext, &pair.private_key, b"grant/b").is_err());- assert!(decrypt_with_private_key(&ciphertext, &pair.private_key).is_err(), "a labelled ciphertext does not open without its label");- }-- #[test]- fn manifest_invitation_name_is_bound_to_its_manifest() {- let pair = generate_rsa_key_pair().unwrap();- let ciphertext = encrypt_with_public_key_and_label("Family".as_bytes(), &pair.public_key, &super::super::aad::invitation_name("A")).unwrap();- assert_eq!(decrypt_manifest_invitation_name(&ciphertext, "a", &pair.private_key).unwrap(), "Family");- assert!(decrypt_manifest_invitation_name(&ciphertext, "b", &pair.private_key).is_err());- }-}diff --git a/core/rust/src/crypto/signing.rs b/core/rust/src/crypto/signing.rsindex 8496f0cdc..db157129d 100644--- a/core/rust/src/crypto/signing.rs+++ b/core/rust/src/crypto/signing.rs@@ -164,123 +164,3 @@ fn verifying_key(public_key_base64: &str) -> VaultResult<VerifyingKey> {let bytes: [u8; PUBLIC_KEY_LENGTH] = bytes.as_slice().try_into().map_err(|_| VaultError::General(format!("Signing public key must be {} bytes", PUBLIC_KEY_LENGTH)))?;VerifyingKey::from_bytes(&bytes).map_err(|e| VaultError::General(format!("Invalid signing public key: {}", e)))}--#[cfg(test)]-mod tests {- use super::*;-- /// The private seed 0x00..0x1f, shared with the server's known-answer test.- fn vector_seed() -> String {- base64_encode(&(0u8..32).collect::<Vec<u8>>())- }-- /// Known-answer vector for the message encoding, which the server's `Signing.cs` builds byte for byte. A changed output- /// means stored signatures no longer verify. Never regenerate it.- #[test]- fn signed_message_known_answer() {- let message = signed_message(ACCOUNT_PUBLIC_KEY_LABEL, &[b"{\"kty\":\"RSA\"}"]);- assert_eq!(crate::common::encoding::hex_encode_lower(&message), MESSAGE_VECTOR);- assert_eq!(signing_public_key_of(&vector_seed()).unwrap(), PUBLIC_KEY_VECTOR);- assert_eq!(sign(&vector_seed(), &message).unwrap(), SIGNATURE_VECTOR);- }-- const MESSAGE_VECTOR: &str = "00000024616c6961737661756c742f76312f7369672f6163636f756e742d7075626c69632d6b65790000000d7b226b7479223a22525341227d";- const PUBLIC_KEY_VECTOR: &str = "A6EHv/POEL4dcN0Y50vAmWfk1jCbpQ1fHdyGZBJVMbg=";- const SIGNATURE_VECTOR: &str = "twY5wx2bX5kesFEjJa+ZUYOpw4Hs3hqFUpbWC4KbVRVgragIilho+vCl9Haik3F/a2vLcAoCtJssesL4wAaxDg==";-- /// Known-answer vectors for the grant, delivery key and invitation name messages, which `Signing.cs` builds too. The- /// manifest id is lowercased, as the server prints a GUID. Never regenerate them.- #[test]- fn grant_and_delivery_key_messages_known_answer() {- let manifest_id = "0A1B2C3D-0000-0000-0000-000000000001";- assert_eq!(crate::common::encoding::hex_encode_lower(&grant_message(manifest_id, 3, "user-1", "{\"kty\":\"RSA\"}", "rsa-oaep-sha256", "dmVr")), GRANT_MESSAGE_VECTOR);- assert_eq!(crate::common::encoding::hex_encode_lower(&delivery_key_message(manifest_id, "{\"kty\":\"RSA\"}", 42)), DELIVERY_KEY_MESSAGE_VECTOR);- assert_eq!(crate::common::encoding::hex_encode_lower(&invitation_name_message(manifest_id, "user-1", "{\"kty\":\"RSA\"}", "bmFtZQ==")), INVITATION_NAME_MESSAGE_VECTOR);- }-- /// Known-answer vector for the key certification message, which `Signing.cs` builds too. Never regenerate it.- #[test]- fn key_certification_message_known_answer() {- assert_eq!(crate::common::encoding::hex_encode_lower(&key_certification_message("user-1", "user-2", PUBLIC_KEY_VECTOR)), KEY_CERTIFICATION_MESSAGE_VECTOR);- }-- /// Known-answer vector for the email claim transfer message, which `Signing.cs` builds too. Never regenerate it.- #[test]- fn email_claim_transfer_message_known_answer() {- let message = email_claim_transfer_message("[email protected]", "0A1B2C3D-0000-0000-0000-000000000001", "0A1B2C3D-0000-0000-0000-000000000002", 1767225600000);- assert_eq!(crate::common::encoding::hex_encode_lower(&message), EMAIL_CLAIM_TRANSFER_MESSAGE_VECTOR);- }-- /// Known-answer vector for the Login with Mobile approval message, which `Signing.cs` builds too. Never regenerate it.- #[test]- fn mobile_login_approval_message_known_answer() {- let message = mobile_login_approval_message("0123456789abcdef0123456789abcdef", "rsa-oaep-sha256", "YWs=");- assert_eq!(crate::common::encoding::hex_encode_lower(&message), MOBILE_LOGIN_APPROVAL_MESSAGE_VECTOR);- }-- const MOBILE_LOGIN_APPROVAL_MESSAGE_VECTOR: &str = "00000027616c6961737661756c742f76312f7369672f6d6f62696c652d6c6f67696e2d617070726f76616c0000002030313233343536373839616263646566303132333435363738396162636465660000000f7273612d6f6165702d736861323536000000045957733d";-- const EMAIL_CLAIM_TRANSFER_MESSAGE_VECTOR: &str = "00000026616c6961737661756c742f76312f7369672f656d61696c2d636c61696d2d7472616e7366657200000011616c696173406578616d706c652e636f6d0000002430613162326333642d303030302d303030302d303030302d3030303030303030303030310000002430613162326333642d303030302d303030302d303030302d3030303030303030303030320000000d31373637323235363030303030";-- const KEY_CERTIFICATION_MESSAGE_VECTOR: &str = "00000023616c6961737661756c742f76312f7369672f6b65792d63657274696669636174696f6e00000006757365722d3100000006757365722d320000002c41364548762f504f454c3464634e3059353076416d57666b316a436270513166486479475a424a564d62673d";-- #[test]- fn fingerprint_matches_ignores_separators() {- assert!(fingerprint_matches(PUBLIC_KEY_VECTOR, FINGERPRINT_VECTOR));- assert!(fingerprint_matches(PUBLIC_KEY_VECTOR, " 0919 6981 5265 9210 5908 "));- assert!(!fingerprint_matches(PUBLIC_KEY_VECTOR, "0919-6981-5265-9210-5909"));- assert!(!fingerprint_matches(PUBLIC_KEY_VECTOR, ""));- assert!(!fingerprint_matches("not base64!", FINGERPRINT_VECTOR));- }--- const INVITATION_NAME_MESSAGE_VECTOR: &str = "00000021616c6961737661756c742f76312f7369672f696e7669746174696f6e2d6e616d650000002430613162326333642d303030302d303030302d303030302d30303030303030303030303100000006757365722d310000000d7b226b7479223a22525341227d00000008626d46745a513d3d";-- const GRANT_MESSAGE_VECTOR: &str = "00000017616c6961737661756c742f76312f7369672f6772616e740000002430613162326333642d303030302d303030302d303030302d303030303030303030303031000000013300000006757365722d310000000d7b226b7479223a22525341227d0000000f7273612d6f6165702d73686132353600000004646d5672";- const DELIVERY_KEY_MESSAGE_VECTOR: &str = "0000001e616c6961737661756c742f76312f7369672f64656c69766572792d6b65790000002430613162326333642d303030302d303030302d303030302d3030303030303030303030310000000d7b226b7479223a22525341227d000000023432";-- /// Known-answer vector for the fingerprint, which every client shows for the same key. A changed output means two- /// app versions show different fingerprints for one key. Never regenerate it.- #[test]- fn fingerprint_known_answer() {- assert_eq!(fingerprint(PUBLIC_KEY_VECTOR).unwrap(), FINGERPRINT_VECTOR);- }-- const FINGERPRINT_VECTOR: &str = "0919-6981-5265-9210-5908";-- #[test]- fn fingerprint_has_twenty_digits_in_groups_of_four() {- let code = fingerprint(&generate_signing_key_pair().public_key).unwrap();- assert_eq!(code.len(), 24);- assert!(code.split('-').all(|group| group.len() == 4 && group.chars().all(|c| c.is_ascii_digit())), "{}", code);- assert_ne!(code, fingerprint(&generate_signing_key_pair().public_key).unwrap());- assert!(fingerprint("not base64!").is_err());- assert!(fingerprint(&base64_encode(&[1u8; 16])).is_err());- }-- #[test]- fn signature_round_trip() {- let pair = generate_signing_key_pair();- assert_eq!(signing_public_key_of(&pair.private_key).unwrap(), pair.public_key);- let signature = sign(&pair.private_key, b"message").unwrap();- assert!(verify(&pair.public_key, b"message", &signature));- assert!(!verify(&pair.public_key, b"other message", &signature));- assert!(!verify(&generate_signing_key_pair().public_key, b"message", &signature));- }-- #[test]- fn malformed_input_does_not_verify() {- let pair = generate_signing_key_pair();- let signature = sign(&pair.private_key, b"message").unwrap();- assert!(!verify("not base64!", b"message", &signature));- assert!(!verify(&base64_encode(&[1u8; 16]), b"message", &signature));- assert!(!verify(&pair.public_key, b"message", &base64_encode(&[0u8; 63])));- assert!(sign(&base64_encode(&[0u8; 31]), b"message").is_err());- }-- #[test]- fn fields_are_length_prefixed() {- assert_ne!(signed_message("l", &[b"ab", b"c"]), signed_message("l", &[b"a", b"bc"]));- assert_ne!(signed_message("la", &[b"b"]), signed_message("l", &[b"ab"]));- }-}diff --git a/core/rust/src/crypto/srp.rs b/core/rust/src/crypto/srp.rsindex 380f39878..d31410f15 100644--- a/core/rust/src/crypto/srp.rs+++ b/core/rust/src/crypto/srp.rs@@ -3,7 +3,7 @@//! Uses RustCrypto `srp` crate for most operations, except certain places//! where the format must stay compatible with the `SecureRemotePassword` .NET package//! used by the API server and the `secure-remote-password` library used in the JS test suite.-//! The tests module carries a server side of the handshake to test the client-server flow locally.+//! `tests/srp.rs` carries a server side of the handshake to test the client-server flow locally.use num_bigint::BigUint;use serde::{Deserialize, Serialize};@@ -19,7 +19,7 @@ use crate::common::encoding::{hex_decode, hex_encode_upper as bytes_to_hex};use crate::common::rng::random_bytes;/// Byte length of the 2048-bit group modulus N; all padded values use this size.-const N_BYTES: usize = 256;+pub(super) const N_BYTES: usize = 256;/// SRP ephemeral key pair (public and secret values).#[derive(Clone, Serialize, Deserialize)]@@ -63,7 +63,7 @@ pub enum SrpError {}/// Decode a hex parameter (either case, optional 0x prefix).-fn hex_to_bytes(hex: &str) -> Result<Vec<u8>, SrpError> {+pub(super) fn hex_to_bytes(hex: &str) -> Result<Vec<u8>, SrpError> {let hex = hex.trim();let hex = hex.strip_prefix("0x").or_else(|| hex.strip_prefix("0X")).unwrap_or(hex);if hex.is_empty() {@@ -73,7 +73,7 @@ fn hex_to_bytes(hex: &str) -> Result<Vec<u8>, SrpError> {}/// Left-pad bytes with zeros to a specific length.-fn pad_to_length(bytes: Vec<u8>, target_len: usize) -> Vec<u8> {+pub(super) fn pad_to_length(bytes: Vec<u8>, target_len: usize) -> Vec<u8> {if bytes.len() >= target_len {bytes} else {@@ -84,7 +84,7 @@ fn pad_to_length(bytes: Vec<u8>, target_len: usize) -> Vec<u8> {}/// Convert a BigUint to big-endian bytes left-padded to the group size (256 bytes).-fn to_padded_bytes(value: &BigUint) -> Vec<u8> {+pub(super) fn to_padded_bytes(value: &BigUint) -> Vec<u8> {pad_to_length(value.to_bytes_be(), N_BYTES)}@@ -180,14 +180,14 @@ pub fn srp_verify_session(client_public: &str, client_proof: &str, session_key:*//// Derive the session key K = H(PAD(S)) from the premaster secret.-fn derive_session_key(s: &BigUint) -> Vec<u8> {+pub(super) fn derive_session_key(s: &BigUint) -> Vec<u8> {Sha256::digest(to_padded_bytes(s)).to_vec()}/// Compute M1 = H(H(N) XOR H(g) | H(I) | s | A | B | K)////// Note: H(g) uses g without padding, unlike k = H(N, PAD(g))-fn compute_m1(a_pub: &[u8], b_pub: &[u8], salt: &[u8], identity: &str, key: &[u8]) -> Vec<u8> {+pub(super) fn compute_m1(a_pub: &[u8], b_pub: &[u8], salt: &[u8], identity: &str, key: &[u8]) -> Vec<u8> {let h_n = Sha256::digest(G_2048.n.to_bytes_be());let h_g = Sha256::digest(G_2048.g.to_bytes_be());let h_n_xor_h_g: Vec<u8> = h_n.iter().zip(h_g.iter()).map(|(a, b)| a ^ b).collect();@@ -205,303 +205,10 @@ fn compute_m1(a_pub: &[u8], b_pub: &[u8], salt: &[u8], identity: &str, key: &[u8}/// Compute M2 = H(A | M1 | K)-fn compute_m2(a_pub: &[u8], m1: &[u8], key: &[u8]) -> Vec<u8> {+pub(super) fn compute_m2(a_pub: &[u8], m1: &[u8], key: &[u8]) -> Vec<u8> {let mut hasher = Sha256::new();hasher.update(a_pub);hasher.update(m1);hasher.update(key);hasher.finalize().to_vec()}--#[cfg(test)]-mod tests {- use super::*;- use srp::server::SrpServer;-- // Server side of the handshake: lets the tests run a full client/server flow.-- /// A server ephemeral pair: `B = k*v + g^b mod N` for a random 64-byte secret `b`, from the hex verifier.- fn srp_generate_ephemeral_server(verifier: &str) -> Result<SrpEphemeral, SrpError> {- let v_bytes = hex_to_bytes(verifier)?;-- let server = SrpServer::<Sha256>::new(&G_2048);-- let b = random_bytes(64);- let b_pub = server.compute_public_ephemeral(&b, &v_bytes);-- Ok(SrpEphemeral { public: bytes_to_hex(&pad_to_length(b_pub, N_BYTES)), secret: bytes_to_hex(&b) })- }-- /// The server session (key `K` and proof `M2`) once the client's proof `M1` verifies; `None` when it does not.- fn srp_derive_session_server(- server_secret: &str,- client_public: &str,- salt: &str,- identity: &str,- verifier: &str,- client_proof: &str,- ) -> Result<Option<SrpSession>, SrpError> {- let identity = identity.to_lowercase();- let b = BigUint::from_bytes_be(&hex_to_bytes(server_secret)?);- let a_pub = BigUint::from_bytes_be(&hex_to_bytes(client_public)?);- let salt_bytes = hex_to_bytes(salt)?;- let v = BigUint::from_bytes_be(&hex_to_bytes(verifier)?);- let client_m1 = hex_to_bytes(client_proof)?;-- // Safeguard against malicious A (A mod N must not be 0)- if &a_pub % &G_2048.n == BigUint::default() {- return Err(SrpError::InvalidParameter("client public ephemeral is invalid".to_string()));- }-- let server = SrpServer::<Sha256>::new(&G_2048);- let k = compute_k::<Sha256>(&G_2048);-- // B = k*v + g^b mod N- let b_pub = server.compute_b_pub(&b, &k, &v);-- let a_pub_bytes = to_padded_bytes(&a_pub);- let b_pub_bytes = to_padded_bytes(&b_pub);-- let u = compute_u::<Sha256>(&a_pub_bytes, &b_pub_bytes);- if u == BigUint::default() {- return Err(SrpError::InvalidParameter("scrambling parameter u is zero".to_string()));- }-- // S = (A * v^u)^b mod N- let s = server.compute_premaster_secret(&a_pub, &v, &u, &b);-- let key = derive_session_key(&s);- let expected_m1 = compute_m1(&a_pub_bytes, &b_pub_bytes, &salt_bytes, &identity, &key);-- if expected_m1.ct_eq(&client_m1).unwrap_u8() != 1 {- return Ok(None);- }-- let m2 = compute_m2(&a_pub_bytes, &expected_m1, &key);-- Ok(Some(SrpSession { proof: bytes_to_hex(&m2), key: bytes_to_hex(&key) }))- }-- /// Test with fixed values for deterministic verification.- #[test]- fn fixed_values() {- let salt = "0A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F";- let identity = "testuser";- let password_hash = "AABBCCDDEEFF00112233445566778899AABBCCDDEEFF00112233445566778899";-- let expected_private_key = "37D921B103087DDBCFEE50E240DBF5904BBC021BD07391F206CA74BE5430D79B";- let expected_verifier = "603ABD0F6C5494976B140BBF29D988989FD88654438994959D851C83FC891FA22C81B7CD3B1BBC5472651473183789A4DB5454D530BDEF328DCBA19C112ED266584D8750AEFDCFC0076FD40B3E16773672994C7CB56B4F6CD5FCA47927F9688483937890054D208DDBDD5117F18461B6AD7A279495583B7D99CDC1EB678E9402171F43DC7732549B5A5A3A4A2BF586686887E09D1DED55A7945C20F4DB62915DCF7FD4D7ECED87758B3E19E25CFC668FDB92FCE15E9452DE7F78BDB9BC80DE25882769870E156B2860A169F33045298CEC7700975E3EF4AAE5B41CE6086E2593EDCF2BEA8F3B613258259197C4AE8A67055ED5546C83F6EF035BA788EC63A1AE";-- let private_key = srp_derive_private_key(salt, identity, password_hash).unwrap();- assert_eq!(private_key.to_uppercase(), expected_private_key);-- let verifier = srp_derive_verifier(&private_key).unwrap();- assert_eq!(verifier.to_uppercase(), expected_verifier);- }-- /// Test session derivation with fixed ephemeral values.- #[test]- fn session_fixed_values() {- let salt = "0A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F";- let identity = "testuser";- let password_hash = "AABBCCDDEEFF00112233445566778899AABBCCDDEEFF00112233445566778899";-- let private_key = srp_derive_private_key(salt, identity, password_hash).unwrap();-- let client_secret = "89697cc13c1cea1f44c5f6b3f8f0cb7ce28246c80de10ca5d4976575dbcb0318";- let server_public = "523d0e314fccaace5ad5007357b07bb2fb2c5f566be0b812cbe4ffa65adc5bdd5cd59d9ca921b7491481d2963733513968e7bea637a733665f8e9fb7a18ba613a03740eed9ea3795489659a486cd87352054ed49f0636bb2605b8d836a459151cb670d35e8377202d9e1569bf88d0c86bd83d303d8775a65867b68fc7f9a9d5d59c76c413cb1b4d33f1d5eb784d1d18a5705800729a5d566548297c3b84ec1077c4546ab3c9b159a6d6c7265cdc784f36f731fa371e14bc506a544713591579d0a6952c2539746963434f0e97a024c0e93701008e4c54b620a9259d071b88c0a4cf102eaa22732ecfcd1fd23a81ee180074db1b5cee1b3e9172f76153f8d46bc";-- let expected_session_key = "AD713F5D8F520B7B9413CDD9EF6D9B5FE37F23A9B62C5E2B90D2291F8C3A9E6F";- let expected_session_proof = "698D0DA7137A0FC4A55B49525C1312ADCD07788E8CD5FFF5BD195B3C17B6B3DF";-- let session = srp_derive_session(client_secret, server_public, salt, identity, &private_key).unwrap();-- assert_eq!(session.key.to_uppercase(), expected_session_key);- assert_eq!(session.proof.to_uppercase(), expected_session_proof);- }-- /// Test with realistic 32-byte salt.- #[test]- fn realistic_salt() {- let salt = "7c9d6615bfeb06c552c7fbcbfbe7030035a09f058ed7cf7755ca6d3bfa56393c";- let username = "testuser";- let password_hash = "ABCD1234567890ABCD1234567890ABCD1234567890ABCD1234567890ABCD1234";-- let expected_private_key = "352C41C945185EDC02EBA1087A02D06A686A194D3542AE174B4F75F340E4E02E";- let expected_verifier = "8612168CF700A1CBAE568175B1BDD9B93874A9029B2EA34126910EABFE7DCEA57345560AD96754E1C5A5A2272F1C794D7C6A7D5A756FD37EF78170A3162051035D115AA376F85330701586A714C97413F84BAE12A87497357C0483E443B7D3B75B3C19BCF845ABD38956D2EAEFE733DC696D88277245DC7E25C9013D77053F82E9400F6918BF58176D536EB7D90572A645790E6F5660FD0FB8D5673B584F1F33F06C824CA1CF246BED84E228745CD4ABC1184E5057D03191AB9253F86A407970A4578DC6763D7D42AF2CB71C79F60BB71CA16CF98A17E4F3D62BE8396593427487115163B668A8E0069487C763342B58EFAF9499EBB87DE07E52836B3DF4F28C";-- let private_key = srp_derive_private_key(salt, username, password_hash).unwrap();- assert_eq!(private_key.to_uppercase(), expected_private_key);-- let verifier = srp_derive_verifier(&private_key).unwrap();- assert_eq!(verifier.to_uppercase(), expected_verifier);-- let client_secret = "d21695287e680db505882ba699bb1a417fe064cc817ead8f2e872fb4b8612273";- let server_public = "02ea98a39b29fee876b183124e9dd8f4e5dedf429a1bb0e74dafd67a6a855f8e43a317edb17b93fc6c42c7ed5a2d5cc166fe9dabc66e71475a3a947aec440c23e5c8b347ee4352a84a2fb94d683d1545ef2ac7571e5032d68a0bdfe8cc16d8cf852851dc9a74690d35439a722dc22eaa682ee50eb354131445fd414d4e30dd7653560a4342ffccf392f4b658b37f939a179f01be15aa4364f7d720eebb850a5cad023ce07ed09f47da00ba00ac31df2bb251c2e910a8d50044b9dc926711b648718357da4b233078a17862e5ad57df0cb13325ef39acd42625fd858f0073e073bd61eee07a89be4c2d4b52d868324fea7b68acf3dce94733973469fdc1cc8d32";-- let expected_session_key = "7564C550D5BF148D17B33C251B71EA2E0CD96D70E207B58622D9FF78BEE609A4";- let expected_session_proof = "87BF2829F780EF88C1BFB63F39547DAA3CC787B40978C27CDC50FDEBFD324470";-- let session = srp_derive_session(client_secret, server_public, salt, username, &private_key).unwrap();-- assert_eq!(session.key.to_uppercase(), expected_session_key);- assert_eq!(session.proof.to_uppercase(), expected_session_proof);- }-- #[test]- fn full_srp_flow() {- // 1. Registration: Generate salt and verifier- let salt = srp_generate_salt();- let identity = "[email protected]";- let password_hash = "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";-- let private_key = srp_derive_private_key(&salt, identity, password_hash).unwrap();- let verifier = srp_derive_verifier(&private_key).unwrap();-- // 2. Login: Client generates ephemeral- let client_ephemeral = srp_generate_ephemeral();-- // 3. Server generates ephemeral and sends to client- let server_ephemeral = srp_generate_ephemeral_server(&verifier).unwrap();-- // Salts are 32 bytes, public values are padded to the 2048-bit group as the server expects.- assert_eq!((salt.len(), client_ephemeral.public.len(), server_ephemeral.public.len(), verifier.len()), (64, 512, 512, 512));-- // 4. Client derives session- let client_session = srp_derive_session(&client_ephemeral.secret, &server_ephemeral.public, &salt, identity, &private_key).unwrap();-- // 5. Server verifies client proof and derives session- let server_session = srp_derive_session_server(- &server_ephemeral.secret,- &client_ephemeral.public,- &salt,- identity,- &verifier,- &client_session.proof,- )- .unwrap();-- let server_session = server_session.expect("server should accept valid client proof");-- assert_eq!(client_session.key, server_session.key);-- // 6. Client verifies server proof (M2)- let verified = srp_verify_session(&client_ephemeral.public, &client_session.proof, &client_session.key, &server_session.proof).unwrap();- assert!(verified);-- // A tampered server proof should fail client-side verification- let mut tampered = server_session.proof.clone();- let flipped = if tampered.starts_with('0') { "1" } else { "0" };- tampered.replace_range(0..1, flipped);- let verified_tampered = srp_verify_session(&client_ephemeral.public, &client_session.proof, &client_session.key, &tampered).unwrap();- assert!(!verified_tampered);- }-- /// Mixed-case identity must produce the same values as lowercase, matching- /// the C# implementation's ToLowerInvariant() normalization.- #[test]- fn identity_lowercased() {- let salt = "0A0B0C0D0E0F10111213141516171819";- let password_hash = "AABBCCDD";-- let key_lower = srp_derive_private_key(salt, "testuser", password_hash).unwrap();- let key_mixed = srp_derive_private_key(salt, "TestUser", password_hash).unwrap();- assert_eq!(key_lower, key_mixed);-- // Full flow: client uses mixed case, server uses lowercase- let salt = srp_generate_salt();- let private_key = srp_derive_private_key(&salt, "TestUser", password_hash).unwrap();- let verifier = srp_derive_verifier(&private_key).unwrap();-- let client_ephemeral = srp_generate_ephemeral();- let server_ephemeral = srp_generate_ephemeral_server(&verifier).unwrap();-- let client_session = srp_derive_session(&client_ephemeral.secret, &server_ephemeral.public, &salt, "TESTUSER", &private_key).unwrap();-- let server_session = srp_derive_session_server(- &server_ephemeral.secret,- &client_ephemeral.public,- &salt,- "testuser",- &verifier,- &client_session.proof,- )- .unwrap();-- assert!(server_session.is_some());- assert_eq!(client_session.key, server_session.unwrap().key);- }-- #[test]- fn wrong_password_fails() {- // Setup with correct credentials- let salt = srp_generate_salt();- let identity = "testuser";- let correct_password_hash = "CORRECT_PASSWORD_HASH_0123456789";- let wrong_password_hash = "WRONG_PASSWORD_HASH_0123456789AB";-- let correct_private_key = srp_derive_private_key(&salt, identity, correct_password_hash).unwrap();- let verifier = srp_derive_verifier(&correct_private_key).unwrap();-- // Client uses wrong password- let wrong_private_key = srp_derive_private_key(&salt, identity, wrong_password_hash).unwrap();-- let client_ephemeral = srp_generate_ephemeral();- let server_ephemeral = srp_generate_ephemeral_server(&verifier).unwrap();-- // Client derives session with wrong password- let client_session = srp_derive_session(&client_ephemeral.secret, &server_ephemeral.public, &salt, identity, &wrong_private_key).unwrap();-- // Server should reject the client proof- let server_session = srp_derive_session_server(- &server_ephemeral.secret,- &client_ephemeral.public,- &salt,- identity,- &verifier,- &client_session.proof,- )- .unwrap();-- assert!(server_session.is_none());- }-- #[test]- fn malicious_server_public_rejected() {- let salt = srp_generate_salt();- let identity = "testuser";- let private_key = srp_derive_private_key(&salt, identity, "AABBCCDD").unwrap();- let client_ephemeral = srp_generate_ephemeral();-- // B = 0 and B = N are both ≡ 0 mod N and must be rejected- let n_hex = bytes_to_hex(&G_2048.n.to_bytes_be());- for bad_b in ["00", n_hex.as_str()] {- let result = srp_derive_session(&client_ephemeral.secret, bad_b, &salt, identity, &private_key);- assert!(matches!(result, Err(SrpError::InvalidParameter(_))));- }- }-- #[test]- fn malicious_client_public_rejected() {- let salt = srp_generate_salt();- let identity = "testuser";- let private_key = srp_derive_private_key(&salt, identity, "AABBCCDD").unwrap();- let verifier = srp_derive_verifier(&private_key).unwrap();- let server_ephemeral = srp_generate_ephemeral_server(&verifier).unwrap();-- let n_hex = bytes_to_hex(&G_2048.n.to_bytes_be());- for bad_a in ["00", n_hex.as_str()] {- let result = srp_derive_session_server(&server_ephemeral.secret, bad_a, &salt, identity, &verifier, "AABBCCDD");- assert!(matches!(result, Err(SrpError::InvalidParameter(_))));- }- }-- /// Decoding itself is `common::encoding`'s; SRP adds the `0x` prefix, trimming and a typed error for empty input.- #[test]- fn hex_input_accepts_a_prefix_and_refuses_empty_or_malformed_text() {- assert_eq!(hex_to_bytes(" 0x00010aFF10 ").unwrap(), vec![0x00, 0x01, 0x0A, 0xFF, 0x10]);- for bad in ["", "0x", "ABC", "GG", "0é9"] {- assert!(matches!(hex_to_bytes(bad), Err(SrpError::InvalidHex(_))), "{bad:?}");- }- }-}diff --git a/core/rust/src/crypto/tests/aad.rs b/core/rust/src/crypto/tests/aad.rsnew file mode 100644index 000000000..58cac9ca4--- /dev/null+++ b/core/rust/src/crypto/tests/aad.rs@@ -0,0 +1,14 @@+use crate::crypto::aad::*;++#[test]+fn labels_are_stable_and_case_insensitive_on_ids() {+ assert_eq!(manifest("0A1B2C3D-0000-0000-0000-000000000001"), b"aliasvault/v1/manifest/0a1b2c3d-0000-0000-0000-000000000001".to_vec());+ assert_eq!(bucket("0a1b2c3d-0000-0000-0000-000000000001", "settings"), b"aliasvault/v1/bucket/0a1b2c3d-0000-0000-0000-000000000001/settings".to_vec());+ assert_eq!(blob_data("ID", "ABCD"), b"aliasvault/v1/blob/id/abcd".to_vec());+ assert_eq!(blob_key("ID", "ABCD"), b"aliasvault/v1/blob-key/id/abcd".to_vec());+ assert_eq!(manifest_name("ID"), b"aliasvault/v1/manifest-name/id".to_vec());+ assert_eq!(grant("ID"), b"aliasvault/v1/grant/id".to_vec());+ assert_eq!(invitation_name("ID"), b"aliasvault/v1/invitation-name/id".to_vec());+ assert_eq!(MOBILE_LOGIN_ACCOUNT_KEY, b"aliasvault/v1/mobile-login/account-key");+ assert_eq!(MOBILE_LOGIN_PAYLOAD_KEY, b"aliasvault/v1/mobile-login/payload-key");+}diff --git a/core/rust/src/crypto/tests/aes_gcm.rs b/core/rust/src/crypto/tests/aes_gcm.rsnew file mode 100644index 000000000..38a57e020--- /dev/null+++ b/core/rust/src/crypto/tests/aes_gcm.rs@@ -0,0 +1,66 @@+use crate::common::encoding::base64_decode;+use crate::crypto::aes_gcm::*;++#[test]+fn round_trips_bytes_and_strings() {+ let key = generate_key_base64();+ let bytes: Vec<u8> = (0..=255u8).collect();+ let encrypted = symmetric_encrypt_bytes(&bytes, &key).unwrap();+ assert_eq!(symmetric_decrypt_bytes(&base64_decode(&encrypted).unwrap(), &key).unwrap(), bytes);++ let encrypted = symmetric_encrypt("héllo ✓", &key).unwrap();+ assert_eq!(symmetric_decrypt(&encrypted, &key).unwrap(), "héllo ✓");+ assert_eq!(symmetric_encrypt("", &key).unwrap(), "");+ assert_eq!(symmetric_decrypt("", &key).unwrap(), "");+}++#[test]+fn raw_key_round_trips_and_matches_the_base64_key_layout() {+ let key: Vec<u8> = (0..32u8).collect();+ let encrypted = symmetric_encrypt_with_raw_key(b"secret", &key).unwrap();+ assert_eq!(encrypted.len(), IV_LENGTH + 6 + 16);+ assert_eq!(symmetric_decrypt_with_raw_key(&encrypted, &key).unwrap(), b"secret");+ assert_eq!(symmetric_decrypt_bytes(&encrypted, &crate::common::encoding::base64_encode(&key)).unwrap(), b"secret", "a raw key and its base64 form are the same key");+ assert!(symmetric_encrypt_with_raw_key(b"x", &key[..31]).is_err());+}++#[test]+fn rejects_wrong_key_and_short_input() {+ let key = generate_key_base64();+ let encrypted = symmetric_encrypt("secret", &key).unwrap();+ assert!(symmetric_decrypt(&encrypted, &generate_key_base64()).is_err());+ assert!(symmetric_decrypt_bytes(&[1, 2, 3], &key).is_err());+ assert!(symmetric_encrypt("x", "dG9vc2hvcnQ=").is_err());+}++#[test]+fn associated_data_must_match() {+ let key = generate_key_base64();+ let encrypted = symmetric_encrypt_with_aad("secret", &key, b"slot-a").unwrap();+ assert_eq!(symmetric_decrypt_with_aad(&encrypted, &key, b"slot-a").unwrap(), "secret");+ assert!(symmetric_decrypt_with_aad(&encrypted, &key, b"slot-b").is_err());+ assert!(symmetric_decrypt(&encrypted, &key).is_err(), "a bound ciphertext does not open without its associated data");++ let empty = symmetric_encrypt_with_aad("", &key, b"slot-a").unwrap();+ assert!(!empty.is_empty(), "an empty string is encrypted, not passed through");+ assert_eq!(symmetric_decrypt_with_aad(&empty, &key, b"slot-a").unwrap(), "");+ assert!(symmetric_decrypt_with_aad("", &key, b"slot-a").is_err());+}++#[test]+fn layout_is_iv_then_ciphertext_then_tag() {+ let key = generate_key_base64();+ let encrypted = base64_decode(&symmetric_encrypt_bytes(b"abc", &key).unwrap()).unwrap();+ assert_eq!(encrypted.len(), IV_LENGTH + 3 + 16);+ assert_eq!(symmetric_encrypt_raw_with_aad(b"abc", &key, &[]).unwrap().len(), encrypted.len());+}++/// Known-answer vectors made with WebCrypto (`crypto.subtle.encrypt`, AES-GCM, key 0x00..0x1f, IV 0x64..0x6f), which the+/// web app and the browser extension encrypt the local vault and read emails with. A changed outcome means the Rust core+/// and WebCrypto no longer agree on the `IV | ciphertext | tag` format. Never regenerate them.+#[test]+fn decrypts_webcrypto_vectors() {+ let key = "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=";+ assert_eq!(symmetric_decrypt("ZGVmZ2hpamtsbW5vAH6yChbFdulREDOM+zmyst740xDgbk6roItfB30=", key).unwrap(), "Hello, world!");+ assert_eq!(symmetric_decrypt_with_aad("ZGVmZ2hpamtsbW5vAH6yChbFdulREDOM+zPeAfsSNCDHPQrcFHPRnnk=", key, b"aliasvault/v1/test").unwrap(), "Hello, world!");+}diff --git a/core/rust/src/crypto/tests/argon2.rs b/core/rust/src/crypto/tests/argon2.rsnew file mode 100644index 000000000..cb6be52df--- /dev/null+++ b/core/rust/src/crypto/tests/argon2.rs@@ -0,0 +1,36 @@+use crate::common::encoding::base64_encode;+use crate::crypto::argon2::*;++#[test]+fn parses_complete_settings() {+ let params = Argon2Params::from_settings_json(r#"{"DegreeOfParallelism":1,"MemorySize":65536,"Iterations":5}"#).unwrap();+ assert_eq!(params, Argon2Params { memory_kib: 65536, iterations: 5, parallelism: 1 });+}++#[test]+fn rejects_incomplete_or_empty_settings() {+ for settings in ["", "{}", r#"{"MemorySize":65536,"Iterations":5}"#] {+ assert!(matches!(Argon2Params::from_settings_json(settings), Err(Argon2Error::InvalidSettings(_))), "accepted {settings:?}");+ }+}++#[test]+fn rejects_params_below_the_minimum() {+ for settings in [r#"{"DegreeOfParallelism":1,"MemorySize":19455,"Iterations":2}"#, r#"{"DegreeOfParallelism":1,"MemorySize":65536,"Iterations":1}"#, r#"{"DegreeOfParallelism":0,"MemorySize":65536,"Iterations":5}"#] {+ assert!(matches!(argon2_derive_key_from_settings("password", "[email protected]", settings), Err(Argon2Error::InvalidParameter(_))), "accepted {settings}");+ }+}++/// Expected keys come from libargon2 (argon2-cffi), for the pre-0.31.0 and the current default settings. A different+/// output means existing accounts can no longer derive their key. Never regenerate them.+#[test]+fn matches_the_reference_implementation() {+ let cases = [+ (r#"{"DegreeOfParallelism":1,"MemorySize":19456,"Iterations":2}"#, "l12OncuAll3SmDPkfv2sHtxaoEVsCXfuFulTShtBfxA="),+ (r#"{"DegreeOfParallelism":1,"MemorySize":65536,"Iterations":5}"#, "j7bnKpt3W46ak6Qid2JENR7NxznhfgRNDWAImnpAc40="),+ ];+ for (settings, expected) in cases {+ let key = argon2_derive_key_from_settings("password", "[email protected]", settings).unwrap();+ assert_eq!(base64_encode(&key), expected, "settings {settings}");+ }+}diff --git a/core/rust/src/crypto/tests/jwk.rs b/core/rust/src/crypto/tests/jwk.rsnew file mode 100644index 000000000..78bd3e53f--- /dev/null+++ b/core/rust/src/crypto/tests/jwk.rs@@ -0,0 +1,29 @@+use rsa::RsaPrivateKey;++use crate::crypto::jwk::*;++/// The member order of both JWK shapes is part of the stored format.+#[test]+fn member_order_is_stable_with_and_without_usage() {+ let key = RsaPrivateKey::new(&mut rand_core06::OsRng, 1024).unwrap();+ let usage = JwkUsage { key_op: "decrypt", alg: "RSA-OAEP-256" };+ // Member names in written order; no JWK value contains ',' or ':'.+ let keys_of = |json: &str| -> Vec<String> { json.trim_matches(['{', '}']).split(',').filter_map(|part| part.split(':').next().filter(|s| s.starts_with('"'))).map(|s| s.trim_matches('"').to_string()).collect() };+ let with = rsa_private_to_jwk(&key, Some(usage)).unwrap();+ assert_eq!(keys_of(&with), ["key_ops", "ext", "alg", "kty", "n", "e", "d", "p", "q", "dp", "dq", "qi"]);+ assert!(with.starts_with("{\"key_ops\":[\"decrypt\"],\"ext\":true,\"alg\":\"RSA-OAEP-256\",\"kty\":\"RSA\","));+ let without = rsa_private_to_jwk(&key, None).unwrap();+ assert_eq!(keys_of(&without), ["kty", "n", "e", "d", "p", "q", "dp", "dq", "qi"]);+ let public = rsa_public_to_jwk(&key.to_public_key(), None).unwrap();+ assert_eq!(keys_of(&public), ["kty", "n", "e"]);++ assert_eq!(rsa_private_from_jwk(&with).unwrap(), key);+ assert_eq!(rsa_private_from_jwk(&without).unwrap(), key);+ assert_eq!(rsa_public_from_jwk(&public).unwrap(), key.to_public_key());+}++#[test]+fn refuses_other_key_types_and_public_keys_in_private_slots() {+ assert!(rsa_public_from_jwk(r#"{"kty":"EC","n":"AQAB","e":"AQAB"}"#).is_err());+ assert!(rsa_private_from_jwk(r#"{"kty":"RSA","n":"AQAB","e":"AQAB"}"#).is_err(), "a public JWK is not a private key");+}diff --git a/core/rust/src/crypto/tests/key_chain.rs b/core/rust/src/crypto/tests/key_chain.rsnew file mode 100644index 000000000..15e01d328--- /dev/null+++ b/core/rust/src/crypto/tests/key_chain.rs@@ -0,0 +1,222 @@+use crate::common::encoding::hex_encode_upper;+use crate::crypto::aad;+use crate::crypto::aes_gcm::{generate_key_base64, symmetric_decrypt_with_aad};+use crate::crypto::key_chain::*;+use crate::crypto::rsa_oaep::{generate_rsa_key_pair, RsaKeyPair};+use crate::crypto::signing;+use crate::crypto::tokens::{ENCRYPTION_TYPE_ARGON2ID, ENCRYPTION_TYPE_ARGON2ID_HKDF};++/// HKDF-SHA256(ikm = 0x00..0x1f, salt = none, info = "AliasVault KEK v1", L = 32).+const KEK_VECTOR: &str = "8103CACFCD107162AECCFAEDB26426F53FF28C5D4273D2440641A5FA3ADD39D2";++/// HKDF-SHA256(ikm = 0x00..0x1f, salt = none, info = "AliasVault SRP v1", L = 32).+const SRP_VECTOR: &str = "BC09E255E5425823B7347FD803F4C5DCE8F11A7BC23B6F78FCC3D6D87240D923";++/// Known-answer vector: every host derives the KEK through this one function, and a changed output means no stored+/// Account Key opens any more. Never regenerate it.+#[test]+fn derive_kek_known_answer() {+ let unlock_key: Vec<u8> = (0u8..32).collect();+ assert_eq!(hex_encode_upper(&derive_kek(&unlock_key)), KEK_VECTOR);+}++/// Known-answer vector for the SRP input of an `Argon2IdHkdf` account: a changed output means no upgraded verifier+/// matches any more. Never regenerate it.+#[test]+fn derive_srp_password_hash_known_answer() {+ let unlock_key: Vec<u8> = (0u8..32).collect();+ assert_eq!(*derive_srp_password_hash(&unlock_key, ENCRYPTION_TYPE_ARGON2ID_HKDF).unwrap(), SRP_VECTOR);+ assert_eq!(*derive_srp_password_hash(&unlock_key, ENCRYPTION_TYPE_ARGON2ID).unwrap(), hex_encode_upper(&unlock_key));+}++#[test]+fn srp_input_and_kek_are_separate() {+ let unlock_key: Vec<u8> = (0u8..32).collect();+ let srp = derive_srp_password_hash(&unlock_key, ENCRYPTION_TYPE_ARGON2ID_HKDF).unwrap();+ assert_ne!(*srp, hex_encode_upper(&derive_kek(&unlock_key)));+ assert!(matches!(derive_srp_password_hash(&unlock_key, "Scrypt"), Err(SrpInputError::UnsupportedEncryptionType(_))));+}++#[test]+fn kek_differs_from_the_unlock_key() {+ let unlock_key = generate_key_base64();+ assert_ne!(*derive_kek_base64(&unlock_key).unwrap(), unlock_key);+}++#[test]+fn account_key_is_not_wrapped_with_the_raw_unlock_key() {+ let unlock_key = generate_key_base64();+ let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();+ assert!(unwrap_key(&hierarchy.account_keys.encrypted_account_key, &unlock_key, aad::ACCOUNT_KEY).is_err());+ assert!(unwrap_key(&hierarchy.account_keys.encrypted_account_key, &derive_kek_base64(&unlock_key).unwrap(), aad::ACCOUNT_KEY).is_ok());+}++#[test]+fn chain_opens_with_the_unlock_key_and_then_with_the_account_key_it_gave() {+ let unlock_key = generate_key_base64();+ let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();+ let blobs = &hierarchy.account_keys;++ let opened = open_key_chain_with_unlock_key(&unlock_key, &blobs.encrypted_account_key, &blobs.encrypted_vek, Some(&blobs.encrypted_account_private_key)).unwrap();+ assert_eq!(*opened.vault_encryption_key, hierarchy.vault_encryption_key);+ assert_eq!(opened.account_private_key.as_deref().map(String::as_str), Some(hierarchy.account_private_key.as_str()));+ assert_eq!(*opened.account_key, hierarchy.account_key, "a new hierarchy hands the client the Account Key it stores");+ assert_ne!(*opened.account_key, unlock_key);++ let reopened = open_key_chain_with_account_key(&opened.account_key, &blobs.encrypted_vek, Some(&blobs.encrypted_account_private_key)).unwrap();+ assert_eq!(*reopened.vault_encryption_key, hierarchy.vault_encryption_key);+ assert_eq!(*reopened.account_key, *opened.account_key, "the Account Key is handed back unchanged");+ assert_eq!(reopened.account_private_key, opened.account_private_key);+}++/// Neither function falls back to the other kind of key: a host has to know which key it holds.+#[test]+fn each_open_refuses_the_other_kind_of_key() {+ let unlock_key = generate_key_base64();+ let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();+ let blobs = &hierarchy.account_keys;+ let account_key = unwrap_account_key(&blobs.encrypted_account_key, &unlock_key).unwrap();++ assert_eq!(open_key_chain_with_account_key(&unlock_key, &blobs.encrypted_vek, None).err(), Some(KeyChainError::AccountKeyRejected));+ assert_eq!(open_key_chain_with_unlock_key(&account_key, &blobs.encrypted_account_key, &blobs.encrypted_vek, None).err(), Some(KeyChainError::UnlockKeyRejected));+}++#[test]+fn chain_rejects_a_wrong_key() {+ let hierarchy = create_account_key_hierarchy(&generate_key_base64()).unwrap();+ let blobs = &hierarchy.account_keys;+ assert_eq!(open_key_chain_with_unlock_key(&generate_key_base64(), &blobs.encrypted_account_key, &blobs.encrypted_vek, None).err(), Some(KeyChainError::UnlockKeyRejected));+ assert_eq!(open_key_chain_with_account_key(&generate_key_base64(), &blobs.encrypted_vek, None).err(), Some(KeyChainError::AccountKeyRejected));+}++#[test]+fn chain_with_a_foreign_vek_is_unreadable_under_the_unlock_key() {+ let unlock_key = generate_key_base64();+ let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();+ let account_key = unwrap_account_key(&hierarchy.account_keys.encrypted_account_key, &unlock_key).unwrap();+ let foreign_vek = wrap_key(&generate_key_base64(), &generate_key_base64(), aad::PERSONAL_VEK).unwrap();++ // The Account Key opened, so the unlock key was right: a damaged chain, never a wrong password.+ assert!(matches!(open_key_chain_with_unlock_key(&unlock_key, &hierarchy.account_keys.encrypted_account_key, &foreign_vek, None), Err(KeyChainError::KeyChainUnreadable(_))));+ // With the Account Key alone a wrong key and a damaged chain look the same.+ assert_eq!(open_key_chain_with_account_key(&account_key, &foreign_vek, None).err(), Some(KeyChainError::AccountKeyRejected));+}++#[test]+fn a_private_key_that_does_not_open_leaves_grants_closed_but_opens_the_vault() {+ let unlock_key = generate_key_base64();+ let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();+ let blobs = &hierarchy.account_keys;+ let account_key = unwrap_account_key(&blobs.encrypted_account_key, &unlock_key).unwrap();++ let opened = open_key_chain_with_account_key(&account_key, &blobs.encrypted_vek, Some(&blobs.encrypted_vek)).unwrap();+ assert_eq!(*opened.vault_encryption_key, hierarchy.vault_encryption_key);+ assert!(opened.account_private_key.is_none());+ assert!(open_key_chain_with_unlock_key(&unlock_key, &blobs.encrypted_account_key, &blobs.encrypted_vek, Some("")).unwrap().account_private_key.is_none());+}++#[test]+fn rotated_keys_open_with_the_new_unlock_key() {+ let old_hierarchy = create_account_key_hierarchy(&generate_key_base64()).unwrap();+ let new_unlock_key = generate_key_base64();+ let key_pair = generate_rsa_key_pair().unwrap();++ let rotated = rotate_account_keys(&new_unlock_key, &key_pair).unwrap();+ let blobs = &rotated.account_keys;++ // The new chain opens with the new unlock key and yields the new VEK and private keys.+ let opened = open_key_chain_with_unlock_key(&new_unlock_key, &blobs.encrypted_account_key, &blobs.encrypted_vek, Some(&blobs.encrypted_account_private_key)).unwrap();+ assert_eq!(*opened.vault_encryption_key, rotated.vault_encryption_key);+ assert_eq!(*opened.account_key, rotated.account_key);+ assert_eq!(opened.account_private_key.as_deref().map(String::as_str), Some(key_pair.private_key.as_str()));+ assert_ne!(rotated.vault_encryption_key, old_hierarchy.vault_encryption_key);+ assert_ne!(blobs.signing_public_key, old_hierarchy.account_keys.signing_public_key);++ // The new signing key vouches for the new account public key.+ assert!(signing::verify(&blobs.signing_public_key, &signing::account_public_key_message(&blobs.account_public_key), &blobs.account_public_key_signature));+}++#[test]+fn hierarchy_takes_a_host_key_pair_and_rejects_a_mismatched_one() {+ let unlock_key = generate_key_base64();+ let key_pair = generate_rsa_key_pair().unwrap();+ let hierarchy = create_account_key_hierarchy_with_key_pair(&unlock_key, &key_pair).unwrap();+ assert_eq!(hierarchy.account_keys.account_public_key, key_pair.public_key);+ assert_eq!(hierarchy.account_private_key, key_pair.private_key);++ let mismatched = RsaKeyPair { public_key: generate_rsa_key_pair().unwrap().public_key.clone(), private_key: key_pair.private_key.clone() };+ assert!(create_account_key_hierarchy_with_key_pair(&unlock_key, &mismatched).is_err());+}++#[test]+fn hierarchy_carries_a_signing_key_that_signed_the_account_public_key() {+ let unlock_key = generate_key_base64();+ let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();+ let blobs = &hierarchy.account_keys;+ let account_key = unwrap_account_key(&blobs.encrypted_account_key, &unlock_key).unwrap();++ let signing_private_key = open_account_signing_private_key(&blobs.encrypted_signing_private_key, &account_key).unwrap();+ assert_eq!(*signing_private_key, hierarchy.signing_private_key);+ assert_eq!(signing::signing_public_key_of(&signing_private_key).unwrap(), blobs.signing_public_key);++ let message = signing::account_public_key_message(&blobs.account_public_key);+ assert!(signing::verify(&blobs.signing_public_key, &message, &blobs.account_public_key_signature));+ assert!(open_account_private_key(&blobs.encrypted_signing_private_key, &account_key).is_err(), "the signing key does not open in the account private key slot");+}++#[test]+fn reencrypted_account_key_opens_with_the_new_unlock_key_only() {+ let old_unlock_key = generate_key_base64();+ let new_unlock_key = generate_key_base64();+ let hierarchy = create_account_key_hierarchy(&old_unlock_key).unwrap();+ let blobs = &hierarchy.account_keys;++ let reencrypted = reencrypt_account_key(&blobs.encrypted_account_key, &old_unlock_key, &new_unlock_key).unwrap();+ let opened = open_key_chain_with_unlock_key(&new_unlock_key, &reencrypted.new_encrypted_account_key, &blobs.encrypted_vek, None).unwrap();+ assert_eq!(*opened.vault_encryption_key, hierarchy.vault_encryption_key);+ assert_eq!(*opened.account_key, reencrypted.account_key);+ assert_eq!(open_key_chain_with_unlock_key(&old_unlock_key, &reencrypted.new_encrypted_account_key, &blobs.encrypted_vek, None).err(), Some(KeyChainError::UnlockKeyRejected));+}++#[test]+fn reencrypt_rejects_a_wrong_old_unlock_key() {+ let hierarchy = create_account_key_hierarchy(&generate_key_base64()).unwrap();+ let result = reencrypt_account_key(&hierarchy.account_keys.encrypted_account_key, &generate_key_base64(), &generate_key_base64());+ assert_eq!(result.err(), Some(KeyChainError::UnlockKeyRejected));+}++#[test]+fn wrap_and_unwrap_round_trip() {+ let wrapping = generate_key_base64();+ let key = generate_key_base64();+ assert_eq!(*unwrap_key(&wrap_key(&key, &wrapping, b"a").unwrap(), &wrapping, b"a").unwrap(), key);+ assert!(unwrap_key(&wrap_key(&key, &wrapping, b"a").unwrap(), &wrapping, b"b").is_err());+}++#[test]+fn chain_ciphertexts_do_not_open_in_each_others_slot() {+ let unlock_key = generate_key_base64();+ let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();+ let blobs = &hierarchy.account_keys;+ let account_key = unwrap_account_key(&blobs.encrypted_account_key, &unlock_key).unwrap();++ // The Account Key wrap served as the VEK wrap: refused, not read as the VEK.+ assert!(matches!(open_key_chain_with_unlock_key(&unlock_key, &blobs.encrypted_account_key, &blobs.encrypted_account_key, None), Err(KeyChainError::KeyChainUnreadable(_))));+ assert_eq!(open_key_chain_with_account_key(&account_key, &blobs.encrypted_account_key, None).err(), Some(KeyChainError::AccountKeyRejected));+ assert!(unwrap_key(&blobs.encrypted_vek, &account_key, aad::ACCOUNT_KEY).is_err());+ assert!(open_account_private_key(&blobs.encrypted_account_private_key, &account_key).is_ok());+ assert!(symmetric_decrypt_with_aad(&blobs.encrypted_account_private_key, &account_key, aad::PERSONAL_VEK).is_err());+}++#[test]+fn an_account_key_encrypted_under_any_other_label_is_refused() {+ let unlock_key = generate_key_base64();+ let hierarchy = create_account_key_hierarchy(&unlock_key).unwrap();+ let account_key = unwrap_account_key(&hierarchy.account_keys.encrypted_account_key, &unlock_key).unwrap();+ let kek = derive_kek_base64(&unlock_key).unwrap();+ for label in [aad::PERSONAL_VEK, aad::ACCOUNT_PRIVATE_KEY, aad::ACCOUNT_SIGNING_PRIVATE_KEY, aad::MOBILE_LOGIN_ACCOUNT_KEY, aad::MOBILE_LOGIN_PAYLOAD_KEY, b""] {+ let foreign = wrap_key(&account_key, &kek, label).unwrap();+ let opened = open_key_chain_with_unlock_key(&unlock_key, &foreign, &hierarchy.account_keys.encrypted_vek, None);+ assert_eq!(opened.err(), Some(KeyChainError::UnlockKeyRejected), "label {:?}", String::from_utf8_lossy(label));+ }+}diff --git a/core/rust/src/crypto/tests/mobile_login.rs b/core/rust/src/crypto/tests/mobile_login.rsnew file mode 100644index 000000000..f63d12fbb--- /dev/null+++ b/core/rust/src/crypto/tests/mobile_login.rs@@ -0,0 +1,12 @@+use crate::crypto::mobile_login::*;++/// Known-answer vectors from the former TypeScript implementation, which released clients still run. A changed output+/// means an old and a new client no longer agree on the QR code or the code they show. Never regenerate them.+#[test]+fn known_answers() {+ let jwk = r#"{"kty":"RSA","n":"abc","e":"AQAB"}"#;+ assert_eq!(mobile_login_public_key_hash(jwk), "1Dew3uCqsSjh4UPhSxj4DAT-YUO3M3XGzR2594gSIYw");+ assert_eq!(mobile_login_verification_code(jwk), "07");+ assert_eq!(mobile_login_public_key_hash("héllo ✓"), "VlfN74qFpYTg6WHm-CR89dP47SFJbtb9vP1Dp2HpQkU");+ assert_eq!(mobile_login_verification_code("héllo ✓"), "39");+}diff --git a/core/rust/src/crypto/tests/mod.rs b/core/rust/src/crypto/tests/mod.rsnew file mode 100644index 000000000..fe18fdbb5--- /dev/null+++ b/core/rust/src/crypto/tests/mod.rs@@ -0,0 +1,14 @@+//! Tests of the crypto modules, one file per module. The known-answer vectors pin stored and wire formats that released+//! clients and the server depend on: a failing vector means they no longer agree, so never regenerate one.++mod aad;+mod aes_gcm;+mod argon2;+mod jwk;+mod key_chain;+mod mobile_login;+mod pin;+mod rsa_oaep;+mod signing;+mod srp;+mod tokens;diff --git a/core/rust/src/crypto/tests/pin.rs b/core/rust/src/crypto/tests/pin.rsnew file mode 100644index 000000000..a87dd0e18--- /dev/null+++ b/core/rust/src/crypto/tests/pin.rs@@ -0,0 +1,34 @@+use crate::crypto::aes_gcm::symmetric_encrypt_with_raw_key;+use crate::crypto::argon2::argon2_derive_key_bytes_from_settings;+use crate::crypto::pin::*;++#[test]+fn round_trips_and_rejects_a_wrong_pin() {+ let salt = pin_generate_salt();+ assert_eq!(salt.len(), PIN_SALT_LENGTH);+ let encrypted = pin_encrypt("123456", &salt, b"account key").unwrap();+ assert_eq!(encrypted.len(), 12 + b"account key".len() + 16, "layout is IV | ciphertext | tag");+ assert_eq!(pin_decrypt("123456", &salt, &encrypted).unwrap(), b"account key");+ assert!(pin_decrypt("654321", &salt, &encrypted).is_err());+ assert!(pin_decrypt("123456", &pin_generate_salt(), &encrypted).is_err());+}++/// A wrap stored before this module existed: Argon2id under the PIN settings, then AES-GCM with that key.+#[test]+fn opens_a_wrap_made_with_the_argon2_key_directly() {+ let salt = b"some-salt-bytes!";+ let key = argon2_derive_key_bytes_from_settings(b"8765432", salt, PIN_ARGON2_SETTINGS).unwrap();+ let encrypted = symmetric_encrypt_with_raw_key(b"secret", &key).unwrap();+ assert_eq!(pin_decrypt("8765432", salt, &encrypted).unwrap(), b"secret");+}++#[test]+fn locks_after_the_maximum_attempts() {+ assert!(!pin_is_locked(0));+ assert!(!pin_is_locked(PIN_MAX_ATTEMPTS - 1));+ assert!(pin_is_locked(PIN_MAX_ATTEMPTS));+ assert_eq!(pin_register_failure(0), PinFailure { failed_attempts: 1, attempts_remaining: 3, locked: false });+ assert_eq!(pin_register_failure(2), PinFailure { failed_attempts: 3, attempts_remaining: 1, locked: false });+ assert_eq!(pin_register_failure(3), PinFailure { failed_attempts: 4, attempts_remaining: 0, locked: true });+ assert_eq!(pin_register_failure(u32::MAX), PinFailure { failed_attempts: u32::MAX, attempts_remaining: 0, locked: true });+}diff --git a/core/rust/src/crypto/tests/rsa_oaep.rs b/core/rust/src/crypto/tests/rsa_oaep.rsnew file mode 100644index 000000000..e664cb395--- /dev/null+++ b/core/rust/src/crypto/tests/rsa_oaep.rs@@ -0,0 +1,37 @@+use crate::crypto::aad;+use crate::crypto::rsa_oaep::*;++#[test]+fn label_must_match() {+ let pair = generate_rsa_key_pair().unwrap();+ let ciphertext = encrypt_with_public_key_and_label(b"vek", &pair.public_key, b"grant/a").unwrap();+ assert_eq!(decrypt_with_private_key_and_label(&ciphertext, &pair.private_key, b"grant/a").unwrap(), b"vek");+ assert!(decrypt_with_private_key_and_label(&ciphertext, &pair.private_key, b"grant/b").is_err());+ assert!(decrypt_with_private_key(&ciphertext, &pair.private_key).is_err(), "a labelled ciphertext does not open without its label");+}++#[test]+fn unlabelled_ciphertext_opens_without_a_label_only() {+ let pair = generate_rsa_key_pair().unwrap();+ let ciphertext = encrypt_with_public_key_and_label(b"email key", &pair.public_key, b"").unwrap();+ assert_eq!(decrypt_with_private_key(&ciphertext, &pair.private_key).unwrap(), b"email key", "an empty label is the plain OAEP the server uses for email keys");+ assert!(decrypt_with_private_key_and_label(&ciphertext, &pair.private_key, b"grant/a").is_err());+ assert!(decrypt_with_private_key(&ciphertext, &generate_rsa_key_pair().unwrap().private_key).is_err());+}++#[test]+fn manifest_invitation_name_is_bound_to_its_manifest() {+ let pair = generate_rsa_key_pair().unwrap();+ let ciphertext = encrypt_with_public_key_and_label("Family".as_bytes(), &pair.public_key, &aad::invitation_name("A")).unwrap();+ assert_eq!(decrypt_manifest_invitation_name(&ciphertext, "a", &pair.private_key).unwrap(), "Family");+ assert!(decrypt_manifest_invitation_name(&ciphertext, "b", &pair.private_key).is_err());+}++#[test]+fn key_pair_validation_requires_matching_halves() {+ let pair = generate_rsa_key_pair().unwrap();+ assert!(validate_rsa_key_pair(&pair).is_ok());+ let mismatched = RsaKeyPair { public_key: generate_rsa_key_pair().unwrap().public_key.clone(), private_key: pair.private_key.clone() };+ assert!(validate_rsa_key_pair(&mismatched).is_err());+ assert!(!format!("{:?}", pair).contains(&pair.private_key), "the private key is redacted in Debug output");+}diff --git a/core/rust/src/crypto/tests/signing.rs b/core/rust/src/crypto/tests/signing.rsnew file mode 100644index 000000000..6b7ab9665--- /dev/null+++ b/core/rust/src/crypto/tests/signing.rs@@ -0,0 +1,110 @@+use crate::common::encoding::{base64_encode, hex_encode_lower};+use crate::crypto::signing::*;++/// The private seed 0x00..0x1f, shared with the server's known-answer test.+fn vector_seed() -> String {+ base64_encode(&(0u8..32).collect::<Vec<u8>>())+}++const MESSAGE_VECTOR: &str = "00000024616c6961737661756c742f76312f7369672f6163636f756e742d7075626c69632d6b65790000000d7b226b7479223a22525341227d";+const PUBLIC_KEY_VECTOR: &str = "A6EHv/POEL4dcN0Y50vAmWfk1jCbpQ1fHdyGZBJVMbg=";+const SIGNATURE_VECTOR: &str = "twY5wx2bX5kesFEjJa+ZUYOpw4Hs3hqFUpbWC4KbVRVgragIilho+vCl9Haik3F/a2vLcAoCtJssesL4wAaxDg==";+const GRANT_MESSAGE_VECTOR: &str = "00000017616c6961737661756c742f76312f7369672f6772616e740000002430613162326333642d303030302d303030302d303030302d303030303030303030303031000000013300000006757365722d310000000d7b226b7479223a22525341227d0000000f7273612d6f6165702d73686132353600000004646d5672";+const DELIVERY_KEY_MESSAGE_VECTOR: &str = "0000001e616c6961737661756c742f76312f7369672f64656c69766572792d6b65790000002430613162326333642d303030302d303030302d303030302d3030303030303030303030310000000d7b226b7479223a22525341227d000000023432";+const INVITATION_NAME_MESSAGE_VECTOR: &str = "00000021616c6961737661756c742f76312f7369672f696e7669746174696f6e2d6e616d650000002430613162326333642d303030302d303030302d303030302d30303030303030303030303100000006757365722d310000000d7b226b7479223a22525341227d00000008626d46745a513d3d";+const KEY_CERTIFICATION_MESSAGE_VECTOR: &str = "00000023616c6961737661756c742f76312f7369672f6b65792d63657274696669636174696f6e00000006757365722d3100000006757365722d320000002c41364548762f504f454c3464634e3059353076416d57666b316a436270513166486479475a424a564d62673d";+const EMAIL_CLAIM_TRANSFER_MESSAGE_VECTOR: &str = "00000026616c6961737661756c742f76312f7369672f656d61696c2d636c61696d2d7472616e7366657200000011616c696173406578616d706c652e636f6d0000002430613162326333642d303030302d303030302d303030302d3030303030303030303030310000002430613162326333642d303030302d303030302d303030302d3030303030303030303030320000000d31373637323235363030303030";+const MOBILE_LOGIN_APPROVAL_MESSAGE_VECTOR: &str = "00000027616c6961737661756c742f76312f7369672f6d6f62696c652d6c6f67696e2d617070726f76616c0000002030313233343536373839616263646566303132333435363738396162636465660000000f7273612d6f6165702d736861323536000000045957733d";+const FINGERPRINT_VECTOR: &str = "0919-6981-5265-9210-5908";++/// Known-answer vector for the message encoding, which the server's `Signing.cs` builds byte for byte. A changed output+/// means stored signatures no longer verify. Never regenerate it.+#[test]+fn signed_message_known_answer() {+ let message = signed_message(ACCOUNT_PUBLIC_KEY_LABEL, &[b"{\"kty\":\"RSA\"}"]);+ assert_eq!(hex_encode_lower(&message), MESSAGE_VECTOR);+ assert_eq!(signing_public_key_of(&vector_seed()).unwrap(), PUBLIC_KEY_VECTOR);+ assert_eq!(sign(&vector_seed(), &message).unwrap(), SIGNATURE_VECTOR);+}++/// Known-answer vectors for the grant, delivery key and invitation name messages, which `Signing.cs` builds too. The+/// manifest id is lowercased, as the server prints a GUID. Never regenerate them.+#[test]+fn grant_and_delivery_key_messages_known_answer() {+ let manifest_id = "0A1B2C3D-0000-0000-0000-000000000001";+ assert_eq!(hex_encode_lower(&grant_message(manifest_id, 3, "user-1", "{\"kty\":\"RSA\"}", "rsa-oaep-sha256", "dmVr")), GRANT_MESSAGE_VECTOR);+ assert_eq!(hex_encode_lower(&delivery_key_message(manifest_id, "{\"kty\":\"RSA\"}", 42)), DELIVERY_KEY_MESSAGE_VECTOR);+ assert_eq!(hex_encode_lower(&invitation_name_message(manifest_id, "user-1", "{\"kty\":\"RSA\"}", "bmFtZQ==")), INVITATION_NAME_MESSAGE_VECTOR);+}++/// Known-answer vector for the key certification message, which `Signing.cs` builds too. Never regenerate it.+#[test]+fn key_certification_message_known_answer() {+ assert_eq!(hex_encode_lower(&key_certification_message("user-1", "user-2", PUBLIC_KEY_VECTOR)), KEY_CERTIFICATION_MESSAGE_VECTOR);+}++/// Known-answer vector for the email claim transfer message, which `Signing.cs` builds too. Never regenerate it.+#[test]+fn email_claim_transfer_message_known_answer() {+ let message = email_claim_transfer_message("[email protected]", "0A1B2C3D-0000-0000-0000-000000000001", "0A1B2C3D-0000-0000-0000-000000000002", 1767225600000);+ assert_eq!(hex_encode_lower(&message), EMAIL_CLAIM_TRANSFER_MESSAGE_VECTOR);+}++/// Known-answer vector for the Login with Mobile approval message, which `Signing.cs` builds too. Never regenerate it.+#[test]+fn mobile_login_approval_message_known_answer() {+ let message = mobile_login_approval_message("0123456789abcdef0123456789abcdef", "rsa-oaep-sha256", "YWs=");+ assert_eq!(hex_encode_lower(&message), MOBILE_LOGIN_APPROVAL_MESSAGE_VECTOR);+}++/// Known-answer vector for the fingerprint, which every client shows for the same key. A changed output means two app+/// versions show different fingerprints for one key. Never regenerate it.+#[test]+fn fingerprint_known_answer() {+ assert_eq!(fingerprint(PUBLIC_KEY_VECTOR).unwrap(), FINGERPRINT_VECTOR);+}++#[test]+fn fingerprint_matches_ignores_separators() {+ assert!(fingerprint_matches(PUBLIC_KEY_VECTOR, FINGERPRINT_VECTOR));+ assert!(fingerprint_matches(PUBLIC_KEY_VECTOR, " 0919 6981 5265 9210 5908 "));+ assert!(!fingerprint_matches(PUBLIC_KEY_VECTOR, "0919-6981-5265-9210-5909"));+ assert!(!fingerprint_matches(PUBLIC_KEY_VECTOR, ""));+ assert!(!fingerprint_matches("not base64!", FINGERPRINT_VECTOR));+}++#[test]+fn fingerprint_has_twenty_digits_in_groups_of_four() {+ let code = fingerprint(&generate_signing_key_pair().public_key).unwrap();+ assert_eq!(code.len(), 24);+ assert!(code.split('-').all(|group| group.len() == 4 && group.chars().all(|c| c.is_ascii_digit())), "{}", code);+ assert_ne!(code, fingerprint(&generate_signing_key_pair().public_key).unwrap());+ assert!(fingerprint("not base64!").is_err());+ assert!(fingerprint(&base64_encode(&[1u8; 16])).is_err());+}++#[test]+fn signature_round_trip() {+ let pair = generate_signing_key_pair();+ assert_eq!(signing_public_key_of(&pair.private_key).unwrap(), pair.public_key);+ let signature = sign(&pair.private_key, b"message").unwrap();+ assert!(verify(&pair.public_key, b"message", &signature));+ assert!(!verify(&pair.public_key, b"other message", &signature));+ assert!(!verify(&generate_signing_key_pair().public_key, b"message", &signature));+}++#[test]+fn malformed_input_does_not_verify() {+ let pair = generate_signing_key_pair();+ let signature = sign(&pair.private_key, b"message").unwrap();+ assert!(!verify("not base64!", b"message", &signature));+ assert!(!verify(&base64_encode(&[1u8; 16]), b"message", &signature));+ assert!(!verify(&pair.public_key, b"message", &base64_encode(&[0u8; 63])));+ assert!(sign(&base64_encode(&[0u8; 31]), b"message").is_err());+}++#[test]+fn fields_are_length_prefixed() {+ assert_ne!(signed_message("l", &[b"ab", b"c"]), signed_message("l", &[b"a", b"bc"]));+ assert_ne!(signed_message("la", &[b"b"]), signed_message("l", &[b"ab"]));+}diff --git a/core/rust/src/crypto/tests/srp.rs b/core/rust/src/crypto/tests/srp.rsnew file mode 100644index 000000000..a32f87236--- /dev/null+++ b/core/rust/src/crypto/tests/srp.rs@@ -0,0 +1,254 @@+//! Tests of the SRP client, against a server side of the handshake built here from the same `srp` crate primitives, so+//! the full client/server flow runs locally. The fixed vectors come from the .NET `SecureRemotePassword` server.++use num_bigint::BigUint;+use sha2::Sha256;+use srp::groups::G_2048;+use srp::server::SrpServer;+use srp::utils::{compute_k, compute_u};+use subtle::ConstantTimeEq;++use crate::common::encoding::hex_encode_upper as bytes_to_hex;+use crate::common::rng::random_bytes;+use crate::crypto::srp::*;++/// A server ephemeral pair: `B = k*v + g^b mod N` for a random 64-byte secret `b`, from the hex verifier.+fn srp_generate_ephemeral_server(verifier: &str) -> Result<SrpEphemeral, SrpError> {+ let v_bytes = hex_to_bytes(verifier)?;+ let server = SrpServer::<Sha256>::new(&G_2048);+ let b = random_bytes(64);+ let b_pub = server.compute_public_ephemeral(&b, &v_bytes);+ Ok(SrpEphemeral { public: bytes_to_hex(&pad_to_length(b_pub, N_BYTES)), secret: bytes_to_hex(&b) })+}++/// The server session (key `K` and proof `M2`) once the client's proof `M1` verifies; `None` when it does not.+fn srp_derive_session_server(server_secret: &str, client_public: &str, salt: &str, identity: &str, verifier: &str, client_proof: &str) -> Result<Option<SrpSession>, SrpError> {+ let identity = identity.to_lowercase();+ let b = BigUint::from_bytes_be(&hex_to_bytes(server_secret)?);+ let a_pub = BigUint::from_bytes_be(&hex_to_bytes(client_public)?);+ let salt_bytes = hex_to_bytes(salt)?;+ let v = BigUint::from_bytes_be(&hex_to_bytes(verifier)?);+ let client_m1 = hex_to_bytes(client_proof)?;++ // Safeguard against malicious A (A mod N must not be 0)+ if &a_pub % &G_2048.n == BigUint::default() {+ return Err(SrpError::InvalidParameter("client public ephemeral is invalid".to_string()));+ }++ let server = SrpServer::<Sha256>::new(&G_2048);+ let k = compute_k::<Sha256>(&G_2048);++ // B = k*v + g^b mod N+ let b_pub = server.compute_b_pub(&b, &k, &v);++ let a_pub_bytes = to_padded_bytes(&a_pub);+ let b_pub_bytes = to_padded_bytes(&b_pub);++ let u = compute_u::<Sha256>(&a_pub_bytes, &b_pub_bytes);+ if u == BigUint::default() {+ return Err(SrpError::InvalidParameter("scrambling parameter u is zero".to_string()));+ }++ // S = (A * v^u)^b mod N+ let s = server.compute_premaster_secret(&a_pub, &v, &u, &b);++ let key = derive_session_key(&s);+ let expected_m1 = compute_m1(&a_pub_bytes, &b_pub_bytes, &salt_bytes, &identity, &key);++ if expected_m1.ct_eq(&client_m1).unwrap_u8() != 1 {+ return Ok(None);+ }++ let m2 = compute_m2(&a_pub_bytes, &expected_m1, &key);+ Ok(Some(SrpSession { proof: bytes_to_hex(&m2), key: bytes_to_hex(&key) }))+}++/// Fixed values from the .NET server implementation. Never regenerate them.+#[test]+fn fixed_values() {+ let salt = "0A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F";+ let identity = "testuser";+ let password_hash = "AABBCCDDEEFF00112233445566778899AABBCCDDEEFF00112233445566778899";++ let expected_private_key = "37D921B103087DDBCFEE50E240DBF5904BBC021BD07391F206CA74BE5430D79B";+ let expected_verifier = "603ABD0F6C5494976B140BBF29D988989FD88654438994959D851C83FC891FA22C81B7CD3B1BBC5472651473183789A4DB5454D530BDEF328DCBA19C112ED266584D8750AEFDCFC0076FD40B3E16773672994C7CB56B4F6CD5FCA47927F9688483937890054D208DDBDD5117F18461B6AD7A279495583B7D99CDC1EB678E9402171F43DC7732549B5A5A3A4A2BF586686887E09D1DED55A7945C20F4DB62915DCF7FD4D7ECED87758B3E19E25CFC668FDB92FCE15E9452DE7F78BDB9BC80DE25882769870E156B2860A169F33045298CEC7700975E3EF4AAE5B41CE6086E2593EDCF2BEA8F3B613258259197C4AE8A67055ED5546C83F6EF035BA788EC63A1AE";++ let private_key = srp_derive_private_key(salt, identity, password_hash).unwrap();+ assert_eq!(private_key.to_uppercase(), expected_private_key);++ let verifier = srp_derive_verifier(&private_key).unwrap();+ assert_eq!(verifier.to_uppercase(), expected_verifier);+}++/// Session derivation with fixed ephemeral values. Never regenerate them.+#[test]+fn session_fixed_values() {+ let salt = "0A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F";+ let identity = "testuser";+ let password_hash = "AABBCCDDEEFF00112233445566778899AABBCCDDEEFF00112233445566778899";++ let private_key = srp_derive_private_key(salt, identity, password_hash).unwrap();++ let client_secret = "89697cc13c1cea1f44c5f6b3f8f0cb7ce28246c80de10ca5d4976575dbcb0318";+ let server_public = "523d0e314fccaace5ad5007357b07bb2fb2c5f566be0b812cbe4ffa65adc5bdd5cd59d9ca921b7491481d2963733513968e7bea637a733665f8e9fb7a18ba613a03740eed9ea3795489659a486cd87352054ed49f0636bb2605b8d836a459151cb670d35e8377202d9e1569bf88d0c86bd83d303d8775a65867b68fc7f9a9d5d59c76c413cb1b4d33f1d5eb784d1d18a5705800729a5d566548297c3b84ec1077c4546ab3c9b159a6d6c7265cdc784f36f731fa371e14bc506a544713591579d0a6952c2539746963434f0e97a024c0e93701008e4c54b620a9259d071b88c0a4cf102eaa22732ecfcd1fd23a81ee180074db1b5cee1b3e9172f76153f8d46bc";++ let expected_session_key = "AD713F5D8F520B7B9413CDD9EF6D9B5FE37F23A9B62C5E2B90D2291F8C3A9E6F";+ let expected_session_proof = "698D0DA7137A0FC4A55B49525C1312ADCD07788E8CD5FFF5BD195B3C17B6B3DF";++ let session = srp_derive_session(client_secret, server_public, salt, identity, &private_key).unwrap();++ assert_eq!(session.key.to_uppercase(), expected_session_key);+ assert_eq!(session.proof.to_uppercase(), expected_session_proof);+}++/// A realistic 32-byte salt, with fixed values from the .NET server. Never regenerate them.+#[test]+fn realistic_salt() {+ let salt = "7c9d6615bfeb06c552c7fbcbfbe7030035a09f058ed7cf7755ca6d3bfa56393c";+ let username = "testuser";+ let password_hash = "ABCD1234567890ABCD1234567890ABCD1234567890ABCD1234567890ABCD1234";++ let expected_private_key = "352C41C945185EDC02EBA1087A02D06A686A194D3542AE174B4F75F340E4E02E";+ let expected_verifier = "8612168CF700A1CBAE568175B1BDD9B93874A9029B2EA34126910EABFE7DCEA57345560AD96754E1C5A5A2272F1C794D7C6A7D5A756FD37EF78170A3162051035D115AA376F85330701586A714C97413F84BAE12A87497357C0483E443B7D3B75B3C19BCF845ABD38956D2EAEFE733DC696D88277245DC7E25C9013D77053F82E9400F6918BF58176D536EB7D90572A645790E6F5660FD0FB8D5673B584F1F33F06C824CA1CF246BED84E228745CD4ABC1184E5057D03191AB9253F86A407970A4578DC6763D7D42AF2CB71C79F60BB71CA16CF98A17E4F3D62BE8396593427487115163B668A8E0069487C763342B58EFAF9499EBB87DE07E52836B3DF4F28C";++ let private_key = srp_derive_private_key(salt, username, password_hash).unwrap();+ assert_eq!(private_key.to_uppercase(), expected_private_key);++ let verifier = srp_derive_verifier(&private_key).unwrap();+ assert_eq!(verifier.to_uppercase(), expected_verifier);++ let client_secret = "d21695287e680db505882ba699bb1a417fe064cc817ead8f2e872fb4b8612273";+ let server_public = "02ea98a39b29fee876b183124e9dd8f4e5dedf429a1bb0e74dafd67a6a855f8e43a317edb17b93fc6c42c7ed5a2d5cc166fe9dabc66e71475a3a947aec440c23e5c8b347ee4352a84a2fb94d683d1545ef2ac7571e5032d68a0bdfe8cc16d8cf852851dc9a74690d35439a722dc22eaa682ee50eb354131445fd414d4e30dd7653560a4342ffccf392f4b658b37f939a179f01be15aa4364f7d720eebb850a5cad023ce07ed09f47da00ba00ac31df2bb251c2e910a8d50044b9dc926711b648718357da4b233078a17862e5ad57df0cb13325ef39acd42625fd858f0073e073bd61eee07a89be4c2d4b52d868324fea7b68acf3dce94733973469fdc1cc8d32";++ let expected_session_key = "7564C550D5BF148D17B33C251B71EA2E0CD96D70E207B58622D9FF78BEE609A4";+ let expected_session_proof = "87BF2829F780EF88C1BFB63F39547DAA3CC787B40978C27CDC50FDEBFD324470";++ let session = srp_derive_session(client_secret, server_public, salt, username, &private_key).unwrap();++ assert_eq!(session.key.to_uppercase(), expected_session_key);+ assert_eq!(session.proof.to_uppercase(), expected_session_proof);+}++#[test]+fn full_srp_flow() {+ // 1. Registration: generate salt and verifier+ let salt = srp_generate_salt();+ let identity = "[email protected]";+ let password_hash = "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF";++ let private_key = srp_derive_private_key(&salt, identity, password_hash).unwrap();+ let verifier = srp_derive_verifier(&private_key).unwrap();++ // 2. Login: client generates ephemeral+ let client_ephemeral = srp_generate_ephemeral();++ // 3. Server generates ephemeral and sends to client+ let server_ephemeral = srp_generate_ephemeral_server(&verifier).unwrap();++ // Salts are 32 bytes, public values are padded to the 2048-bit group as the server expects.+ assert_eq!((salt.len(), client_ephemeral.public.len(), server_ephemeral.public.len(), verifier.len()), (64, 512, 512, 512));++ // 4. Client derives session+ let client_session = srp_derive_session(&client_ephemeral.secret, &server_ephemeral.public, &salt, identity, &private_key).unwrap();++ // 5. Server verifies client proof and derives session+ let server_session = srp_derive_session_server(&server_ephemeral.secret, &client_ephemeral.public, &salt, identity, &verifier, &client_session.proof).unwrap();+ let server_session = server_session.expect("server should accept valid client proof");+ assert_eq!(client_session.key, server_session.key);++ // 6. Client verifies server proof (M2)+ assert!(srp_verify_session(&client_ephemeral.public, &client_session.proof, &client_session.key, &server_session.proof).unwrap());++ // A tampered server proof should fail client-side verification+ let mut tampered = server_session.proof.clone();+ let flipped = if tampered.starts_with('0') { "1" } else { "0" };+ tampered.replace_range(0..1, flipped);+ assert!(!srp_verify_session(&client_ephemeral.public, &client_session.proof, &client_session.key, &tampered).unwrap());+}++/// Mixed-case identity must produce the same values as lowercase, matching the C# implementation's ToLowerInvariant().+#[test]+fn identity_lowercased() {+ let salt = "0A0B0C0D0E0F10111213141516171819";+ let password_hash = "AABBCCDD";++ let key_lower = srp_derive_private_key(salt, "testuser", password_hash).unwrap();+ let key_mixed = srp_derive_private_key(salt, "TestUser", password_hash).unwrap();+ assert_eq!(key_lower, key_mixed);++ // Full flow: client uses mixed case, server uses lowercase+ let salt = srp_generate_salt();+ let private_key = srp_derive_private_key(&salt, "TestUser", password_hash).unwrap();+ let verifier = srp_derive_verifier(&private_key).unwrap();++ let client_ephemeral = srp_generate_ephemeral();+ let server_ephemeral = srp_generate_ephemeral_server(&verifier).unwrap();++ let client_session = srp_derive_session(&client_ephemeral.secret, &server_ephemeral.public, &salt, "TESTUSER", &private_key).unwrap();+ let server_session = srp_derive_session_server(&server_ephemeral.secret, &client_ephemeral.public, &salt, "testuser", &verifier, &client_session.proof).unwrap();++ assert!(server_session.is_some());+ assert_eq!(client_session.key, server_session.unwrap().key);+}++#[test]+fn wrong_password_fails() {+ let salt = srp_generate_salt();+ let identity = "testuser";+ let correct_password_hash = "CORRECT_PASSWORD_HASH_0123456789";+ let wrong_password_hash = "WRONG_PASSWORD_HASH_0123456789AB";++ let correct_private_key = srp_derive_private_key(&salt, identity, correct_password_hash).unwrap();+ let verifier = srp_derive_verifier(&correct_private_key).unwrap();++ // Client uses wrong password+ let wrong_private_key = srp_derive_private_key(&salt, identity, wrong_password_hash).unwrap();++ let client_ephemeral = srp_generate_ephemeral();+ let server_ephemeral = srp_generate_ephemeral_server(&verifier).unwrap();++ let client_session = srp_derive_session(&client_ephemeral.secret, &server_ephemeral.public, &salt, identity, &wrong_private_key).unwrap();++ // Server should reject the client proof+ let server_session = srp_derive_session_server(&server_ephemeral.secret, &client_ephemeral.public, &salt, identity, &verifier, &client_session.proof).unwrap();+ assert!(server_session.is_none());+}++#[test]+fn malicious_server_public_rejected() {+ let salt = srp_generate_salt();+ let identity = "testuser";+ let private_key = srp_derive_private_key(&salt, identity, "AABBCCDD").unwrap();+ let client_ephemeral = srp_generate_ephemeral();++ // B = 0 and B = N are both ≡ 0 mod N and must be rejected+ let n_hex = bytes_to_hex(&G_2048.n.to_bytes_be());+ for bad_b in ["00", n_hex.as_str()] {+ let result = srp_derive_session(&client_ephemeral.secret, bad_b, &salt, identity, &private_key);+ assert!(matches!(result, Err(SrpError::InvalidParameter(_))));+ }+}++#[test]+fn malicious_client_public_rejected() {+ let salt = srp_generate_salt();+ let identity = "testuser";+ let private_key = srp_derive_private_key(&salt, identity, "AABBCCDD").unwrap();+ let verifier = srp_derive_verifier(&private_key).unwrap();+ let server_ephemeral = srp_generate_ephemeral_server(&verifier).unwrap();++ let n_hex = bytes_to_hex(&G_2048.n.to_bytes_be());+ for bad_a in ["00", n_hex.as_str()] {+ let result = srp_derive_session_server(&server_ephemeral.secret, bad_a, &salt, identity, &verifier, "AABBCCDD");+ assert!(matches!(result, Err(SrpError::InvalidParameter(_))));+ }+}++/// Decoding itself is `common::encoding`'s; SRP adds the `0x` prefix, trimming and a typed error for empty input.+#[test]+fn hex_input_accepts_a_prefix_and_refuses_empty_or_malformed_text() {+ assert_eq!(hex_to_bytes(" 0x00010aFF10 ").unwrap(), vec![0x00, 0x01, 0x0A, 0xFF, 0x10]);+ for bad in ["", "0x", "ABC", "GG", "0é9"] {+ assert!(matches!(hex_to_bytes(bad), Err(SrpError::InvalidHex(_))), "{bad:?}");+ }+}diff --git a/core/rust/src/crypto/tests/tokens.rs b/core/rust/src/crypto/tests/tokens.rsnew file mode 100644index 000000000..a37030dda--- /dev/null+++ b/core/rust/src/crypto/tests/tokens.rs@@ -0,0 +1,8 @@+use crate::crypto::tokens::*;++/// The tokens are stored and sent as-is. Never change them.+#[test]+fn tokens_are_stable() {+ let tokens = [ALGORITHM_AES256_GCM, ALGORITHM_RSA_OAEP_SHA256, KEY_TYPE_ACCOUNT_KEY, KEY_TYPE_GRANT_KEY, ENCRYPTION_TYPE_ARGON2ID, ENCRYPTION_TYPE_ARGON2ID_HKDF];+ assert_eq!(tokens, ["aes256-gcm", "rsa-oaep-sha256", "account-key", "grant-key", "Argon2Id", "Argon2IdHkdf"]);+}diff --git a/core/rust/src/crypto/tokens.rs b/core/rust/src/crypto/tokens.rsindex 6ecc2001f..b75493053 100644--- a/core/rust/src/crypto/tokens.rs+++ b/core/rust/src/crypto/tokens.rs@@ -17,14 +17,3 @@ pub const ENCRYPTION_TYPE_ARGON2ID: &str = "Argon2Id";/// The `EncryptionType` of a verifier made from the HKDF-derived SRP input: every new account and password change (since 0.31.0).pub const ENCRYPTION_TYPE_ARGON2ID_HKDF: &str = "Argon2IdHkdf";--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn tokens_are_stable() {- let tokens = [ALGORITHM_AES256_GCM, ALGORITHM_RSA_OAEP_SHA256, KEY_TYPE_ACCOUNT_KEY, KEY_TYPE_GRANT_KEY, ENCRYPTION_TYPE_ARGON2ID, ENCRYPTION_TYPE_ARGON2ID_HKDF];- assert_eq!(tokens, ["aes256-gcm", "rsa-oaep-sha256", "account-key", "grant-key", "Argon2Id", "Argon2IdHkdf"]);- }-}diff --git a/core/rust/src/email_parser/tests.rs b/core/rust/src/email_parser/tests/mod.rssimilarity index 100%rename from core/rust/src/email_parser/tests.rsrename to core/rust/src/email_parser/tests/mod.rsdiff --git a/core/rust/src/favicon/mod.rs b/core/rust/src/favicon/mod.rsindex fc698b1ca..8b588718d 100644--- a/core/rust/src/favicon/mod.rs+++ b/core/rust/src/favicon/mod.rs@@ -87,182 +87,4 @@ fn is_default_port(scheme: Option<&str>, port: &str) -> bool {}#[cfg(test)]-mod tests {- use super::*;-- fn urls(values: &[&str]) -> Vec<String> {- values.iter().map(|v| v.to_string()).collect()- }-- #[test]- fn web_urls_key_on_host() {- assert_eq!(favicon_source_key("https://example.com"), "example.com");- assert_eq!(favicon_source_key("http://example.com/login?a=1"), "example.com");- assert_eq!(favicon_source_key("www.example.com"), "example.com");- assert_eq!(favicon_source_key("example.com"), "example.com");- assert_eq!(favicon_source_key("HTTPS://Example.COM"), "example.com");- assert_eq!(favicon_source_key(" https://example.com "), "example.com");- assert_eq!(favicon_source_key("https://sub.example.co.uk/path"), "sub.example.co.uk");- }-- #[test]- fn app_urls_have_no_favicon_source() {- // App URLs have no favicon.- assert_eq!(favicon_source_key("androidapp://com.example.android"), "");- assert_eq!(favicon_source_key("androidapp://com.example.app"), "");- assert_eq!(favicon_source_key("android://com.example.android.app"), "");- assert_eq!(favicon_source_key("com.example.android.app"), "");- assert_eq!(favicon_source_key("iosapp://com.example.ios"), "");- assert_eq!(favicon_source_key("otpauth://totp/example"), "");- assert_eq!(favicon_source_key("mailto:[email protected]"), "");- }-- #[test]- fn only_web_schemes_are_fetchable() {- // A scheme other than http(s) names something that is not a website.- assert_eq!(favicon_source_key("ftp://files.example.com"), "");- assert_eq!(favicon_source_key("file:///Users/me/index.html"), "");- assert_eq!(favicon_source_key("javascript:alert(1)"), "");- assert_eq!(favicon_source_key("data:text/html,<h1>hi</h1>"), "");- assert_eq!(favicon_source_key("chrome-extension://abcdef/index.html"), "");- assert_eq!(favicon_source_key("music:track:exampleid"), "");- assert_eq!(favicon_source_key("s3://bucket.example.com/key"), "");-- // A host with a port is not a scheme, however much it looks like one.- assert_eq!(favicon_source_key("example.com:8080"), "example.com:8080");- assert_eq!(favicon_source_key("example.com:8080/login"), "example.com:8080");- }-- #[test]- fn scheme_less_input_needs_a_plausible_tld() {- // Dotted text a user typed into a URL field is not a host to fetch from.- assert_eq!(favicon_source_key("backup.7z"), "");- assert_eq!(favicon_source_key("v1.0"), "");- assert_eq!(favicon_source_key("release.2024"), "");- assert_eq!(favicon_source_key("192.168.1.5"), "");- assert_eq!(favicon_source_key("1.2.3.4:8080"), "");-- // Anything TLD-shaped is still accepted, including new gTLDs and LAN suffixes.- assert_eq!(favicon_source_key("example.xyz"), "example.xyz");- assert_eq!(favicon_source_key("nas.local"), "nas.local");- assert_eq!(favicon_source_key("gateway.home:8080"), "gateway.home:8080");-- // With a scheme the user has said what they mean, so the shape check does not apply.- assert_eq!(favicon_source_key("http://192.168.1.5:8080"), "192.168.1.5:8080");- assert_eq!(favicon_source_key("http://mediaserver:32400"), "mediaserver:32400");- }-- #[test]- fn unusable_input_has_no_favicon_source() {- assert_eq!(favicon_source_key(""), "");- assert_eq!(favicon_source_key(" "), "");- assert_eq!(favicon_source_key("not a url"), "");- assert_eq!(favicon_source_key("https://"), "");- assert_eq!(favicon_source_key("http://"), "");- }-- #[test]- fn non_default_port_is_part_of_the_key() {- assert_eq!(favicon_source_key("http://localhost:8080"), "localhost:8080");- assert_eq!(favicon_source_key("http://localhost:9090"), "localhost:9090");- assert_ne!(- favicon_source_key("http://localhost:8080"),- favicon_source_key("http://localhost:9090")- );- assert_eq!(favicon_source_key("https://nas.local:5001/files"), "nas.local:5001");- assert_eq!(favicon_source_key("example.com:8080"), "example.com:8080");- }-- #[test]- fn default_port_collapses_onto_the_bare_host() {- assert_eq!(favicon_source_key("http://localhost:80"), "localhost");- assert_eq!(favicon_source_key("https://example.com:443"), "example.com");- assert_eq!(favicon_source_key("example.com:443"), "example.com");- assert_eq!(- favicon_source_key("https://example.com:443/login"),- favicon_source_key("https://example.com/login")- );- // A non-default port for the scheme in use is still kept.- assert_eq!(favicon_source_key("https://localhost:80"), "localhost:80");- assert_eq!(favicon_source_key("http://example.com:443"), "example.com:443");- }-- #[test]- fn select_skips_app_urls_and_keeps_item_order() {- // An app URL listed before the website.- let target = select_favicon_target(&urls(&[- "androidapp://com.example.app",- "https://example.com",- ]))- .expect("website URL should be selected");- assert_eq!(target.url, "https://example.com");- assert_eq!(target.source, "example.com");-- // Reordering must not change the answer.- let reordered = select_favicon_target(&urls(&[- "https://example.com",- "androidapp://com.example.app",- ]))- .expect("website URL should be selected");- assert_eq!(reordered, target);- }-- #[test]- fn select_prefers_the_first_usable_url() {- let target = select_favicon_target(&urls(&[- "com.example.app",- "https://first.example.com",- "https://example.com",- ]))- .expect("first website URL should be selected");- assert_eq!(target.source, "first.example.com");- }-- #[test]- fn select_returns_none_when_no_url_is_fetchable() {- assert_eq!(select_favicon_target(&urls(&[])), None);- assert_eq!(- select_favicon_target(&urls(&[- "androidapp://com.example.android",- "android://com.example.android.app",- "com.example.music",- ])),- None- );- assert_eq!(select_favicon_target(&urls(&["", " "])), None);- }-- #[test]- fn casing_is_ignored() {- let lower = select_favicon_target(&urls(&["example.com"])).unwrap();- for variant in ["Example.com", "example.com", "https://example.com"] {- let target = select_favicon_target(&urls(&[variant])).unwrap();- assert_eq!(target.source, "example.com", "source for {variant}");- assert_eq!(target.url, lower.url, "fetch URL for {variant}");- }-- let target = select_favicon_target(&urls(&["Www.Example.com"])).unwrap();- assert_eq!(target.source, "example.com");- assert_eq!(target.url, "https://www.example.com");-- let target = select_favicon_target(&urls(&["HTTPS://Example.COM/Login?Token=AbC"])).unwrap();- assert_eq!(target.url, "https://example.com");- }-- #[test]- fn fetch_url_is_the_origin_only() {- let target = select_favicon_target(&urls(&["https://user:[email protected]:8443/account/reset?token=abc#top"])).unwrap();- assert_eq!(target.url, "https://example.com:8443");- }-- #[test]- fn select_adds_missing_scheme_to_fetch_url() {- let target = select_favicon_target(&urls(&["www.example.com"])).unwrap();- assert_eq!(target.url, "https://www.example.com");- assert_eq!(target.source, "example.com");-- let target = select_favicon_target(&urls(&["http://mediaserver:32400"])).unwrap();- assert_eq!(target.url, "http://mediaserver:32400");- assert_eq!(target.source, "mediaserver:32400");- }-}+mod tests;diff --git a/core/rust/src/favicon/tests/mod.rs b/core/rust/src/favicon/tests/mod.rsnew file mode 100644index 000000000..24b593267--- /dev/null+++ b/core/rust/src/favicon/tests/mod.rs@@ -0,0 +1,177 @@+use crate::favicon::*;++fn urls(values: &[&str]) -> Vec<String> {+ values.iter().map(|v| v.to_string()).collect()+}++#[test]+fn web_urls_key_on_host() {+ assert_eq!(favicon_source_key("https://example.com"), "example.com");+ assert_eq!(favicon_source_key("http://example.com/login?a=1"), "example.com");+ assert_eq!(favicon_source_key("www.example.com"), "example.com");+ assert_eq!(favicon_source_key("example.com"), "example.com");+ assert_eq!(favicon_source_key("HTTPS://Example.COM"), "example.com");+ assert_eq!(favicon_source_key(" https://example.com "), "example.com");+ assert_eq!(favicon_source_key("https://sub.example.co.uk/path"), "sub.example.co.uk");+}++#[test]+fn app_urls_have_no_favicon_source() {+ // App URLs have no favicon.+ assert_eq!(favicon_source_key("androidapp://com.example.android"), "");+ assert_eq!(favicon_source_key("androidapp://com.example.app"), "");+ assert_eq!(favicon_source_key("android://com.example.android.app"), "");+ assert_eq!(favicon_source_key("com.example.android.app"), "");+ assert_eq!(favicon_source_key("iosapp://com.example.ios"), "");+ assert_eq!(favicon_source_key("otpauth://totp/example"), "");+ assert_eq!(favicon_source_key("mailto:[email protected]"), "");+}++#[test]+fn only_web_schemes_are_fetchable() {+ // A scheme other than http(s) names something that is not a website.+ assert_eq!(favicon_source_key("ftp://files.example.com"), "");+ assert_eq!(favicon_source_key("file:///Users/me/index.html"), "");+ assert_eq!(favicon_source_key("javascript:alert(1)"), "");+ assert_eq!(favicon_source_key("data:text/html,<h1>hi</h1>"), "");+ assert_eq!(favicon_source_key("chrome-extension://abcdef/index.html"), "");+ assert_eq!(favicon_source_key("music:track:exampleid"), "");+ assert_eq!(favicon_source_key("s3://bucket.example.com/key"), "");++ // A host with a port is not a scheme, however much it looks like one.+ assert_eq!(favicon_source_key("example.com:8080"), "example.com:8080");+ assert_eq!(favicon_source_key("example.com:8080/login"), "example.com:8080");+}++#[test]+fn scheme_less_input_needs_a_plausible_tld() {+ // Dotted text a user typed into a URL field is not a host to fetch from.+ assert_eq!(favicon_source_key("backup.7z"), "");+ assert_eq!(favicon_source_key("v1.0"), "");+ assert_eq!(favicon_source_key("release.2024"), "");+ assert_eq!(favicon_source_key("192.168.1.5"), "");+ assert_eq!(favicon_source_key("1.2.3.4:8080"), "");++ // Anything TLD-shaped is still accepted, including new gTLDs and LAN suffixes.+ assert_eq!(favicon_source_key("example.xyz"), "example.xyz");+ assert_eq!(favicon_source_key("nas.local"), "nas.local");+ assert_eq!(favicon_source_key("gateway.home:8080"), "gateway.home:8080");++ // With a scheme the user has said what they mean, so the shape check does not apply.+ assert_eq!(favicon_source_key("http://192.168.1.5:8080"), "192.168.1.5:8080");+ assert_eq!(favicon_source_key("http://mediaserver:32400"), "mediaserver:32400");+}++#[test]+fn unusable_input_has_no_favicon_source() {+ assert_eq!(favicon_source_key(""), "");+ assert_eq!(favicon_source_key(" "), "");+ assert_eq!(favicon_source_key("not a url"), "");+ assert_eq!(favicon_source_key("https://"), "");+ assert_eq!(favicon_source_key("http://"), "");+}++#[test]+fn non_default_port_is_part_of_the_key() {+ assert_eq!(favicon_source_key("http://localhost:8080"), "localhost:8080");+ assert_eq!(favicon_source_key("http://localhost:9090"), "localhost:9090");+ assert_ne!(+ favicon_source_key("http://localhost:8080"),+ favicon_source_key("http://localhost:9090")+ );+ assert_eq!(favicon_source_key("https://nas.local:5001/files"), "nas.local:5001");+ assert_eq!(favicon_source_key("example.com:8080"), "example.com:8080");+}++#[test]+fn default_port_collapses_onto_the_bare_host() {+ assert_eq!(favicon_source_key("http://localhost:80"), "localhost");+ assert_eq!(favicon_source_key("https://example.com:443"), "example.com");+ assert_eq!(favicon_source_key("example.com:443"), "example.com");+ assert_eq!(+ favicon_source_key("https://example.com:443/login"),+ favicon_source_key("https://example.com/login")+ );+ // A non-default port for the scheme in use is still kept.+ assert_eq!(favicon_source_key("https://localhost:80"), "localhost:80");+ assert_eq!(favicon_source_key("http://example.com:443"), "example.com:443");+}++#[test]+fn select_skips_app_urls_and_keeps_item_order() {+ // An app URL listed before the website.+ let target = select_favicon_target(&urls(&[+ "androidapp://com.example.app",+ "https://example.com",+ ]))+ .expect("website URL should be selected");+ assert_eq!(target.url, "https://example.com");+ assert_eq!(target.source, "example.com");++ // Reordering must not change the answer.+ let reordered = select_favicon_target(&urls(&[+ "https://example.com",+ "androidapp://com.example.app",+ ]))+ .expect("website URL should be selected");+ assert_eq!(reordered, target);+}++#[test]+fn select_prefers_the_first_usable_url() {+ let target = select_favicon_target(&urls(&[+ "com.example.app",+ "https://first.example.com",+ "https://example.com",+ ]))+ .expect("first website URL should be selected");+ assert_eq!(target.source, "first.example.com");+}++#[test]+fn select_returns_none_when_no_url_is_fetchable() {+ assert_eq!(select_favicon_target(&urls(&[])), None);+ assert_eq!(+ select_favicon_target(&urls(&[+ "androidapp://com.example.android",+ "android://com.example.android.app",+ "com.example.music",+ ])),+ None+ );+ assert_eq!(select_favicon_target(&urls(&["", " "])), None);+}++#[test]+fn casing_is_ignored() {+ let lower = select_favicon_target(&urls(&["example.com"])).unwrap();+ for variant in ["Example.com", "example.com", "https://example.com"] {+ let target = select_favicon_target(&urls(&[variant])).unwrap();+ assert_eq!(target.source, "example.com", "source for {variant}");+ assert_eq!(target.url, lower.url, "fetch URL for {variant}");+ }++ let target = select_favicon_target(&urls(&["Www.Example.com"])).unwrap();+ assert_eq!(target.source, "example.com");+ assert_eq!(target.url, "https://www.example.com");++ let target = select_favicon_target(&urls(&["HTTPS://Example.COM/Login?Token=AbC"])).unwrap();+ assert_eq!(target.url, "https://example.com");+}++#[test]+fn fetch_url_is_the_origin_only() {+ let target = select_favicon_target(&urls(&["https://user:[email protected]:8443/account/reset?token=abc#top"])).unwrap();+ assert_eq!(target.url, "https://example.com:8443");+}++#[test]+fn select_adds_missing_scheme_to_fetch_url() {+ let target = select_favicon_target(&urls(&["www.example.com"])).unwrap();+ assert_eq!(target.url, "https://www.example.com");+ assert_eq!(target.source, "example.com");++ let target = select_favicon_target(&urls(&["http://mediaserver:32400"])).unwrap();+ assert_eq!(target.url, "http://mediaserver:32400");+ assert_eq!(target.source, "mediaserver:32400");+}diff --git a/core/rust/src/identity_generator/tests.rs b/core/rust/src/identity_generator/tests/mod.rssimilarity index 100%rename from core/rust/src/identity_generator/tests.rsrename to core/rust/src/identity_generator/tests/mod.rsdiff --git a/core/rust/src/passkey/tests.rs b/core/rust/src/passkey/tests/mod.rssimilarity index 100%rename from core/rust/src/passkey/tests.rsrename to core/rust/src/passkey/tests/mod.rsdiff --git a/core/rust/src/password_generator/tests.rs b/core/rust/src/password_generator/tests/mod.rssimilarity index 100%rename from core/rust/src/password_generator/tests.rsrename to core/rust/src/password_generator/tests/mod.rsdiff --git a/core/rust/src/totp/tests.rs b/core/rust/src/totp/tests/mod.rssimilarity index 100%rename from core/rust/src/totp/tests.rsrename to core/rust/src/totp/tests/mod.rsdiff --git a/core/rust/src/vault_codec/compress.rs b/core/rust/src/vault_codec/compress.rsindex 19b732079..63f6a3feb 100644--- a/core/rust/src/vault_codec/compress.rs+++ b/core/rust/src/vault_codec/compress.rs@@ -30,7 +30,7 @@ pub fn gunzip_to_string(bytes: &[u8]) -> VaultResult<String> {}/// Decompress gzipped bytes into a UTF-8 string, refusing output above `limit` bytes.-fn gunzip_to_string_capped(bytes: &[u8], limit: u64) -> VaultResult<String> {+pub(super) fn gunzip_to_string_capped(bytes: &[u8], limit: u64) -> VaultResult<String> {String::from_utf8(gunzip_capped(bytes, limit)?).map_err(|e| VaultError::General(format!("gunzip failed: {}", e)))}@@ -43,23 +43,3 @@ pub fn decompress_to_string(bytes: &[u8]) -> VaultResult<String> {String::from_utf8(bytes.to_vec()).map_err(|e| VaultError::General(format!("uncompressed payload is not valid UTF-8: {}", e)))}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn gzip_roundtrips() {- let text = r#"{"hello":"world","n":42}"#;- let gz = gzip(text.as_bytes()).unwrap();- assert_eq!(&gz[0..2], &[0x1f, 0x8b]);- assert_eq!(gunzip_to_string(&gz).unwrap(), text);- }-- #[test]- fn gunzip_rejects_output_over_the_limit() {- let gz = gzip(&[b'a'; 1025]).unwrap();- assert!(gunzip_to_string_capped(&gz, 1024).is_err());- assert_eq!(gunzip_to_string_capped(&gz, 1025).unwrap().len(), 1025);- }-}diff --git a/core/rust/src/vault_codec/integrity.rs b/core/rust/src/vault_codec/integrity.rsindex 48079e187..e1434776c 100644--- a/core/rust/src/vault_codec/integrity.rs+++ b/core/rust/src/vault_codec/integrity.rs@@ -122,60 +122,3 @@ fn drop_children_of_tombstoned_items(tables: &mut Tables) {rows.retain(|row| str_col(row, child.item_ref_column()).is_none_or(|item| !deleted.contains(&qualified(row, item))));}}--#[cfg(test)]-mod tests {- use super::*;- use super::super::test_support::{row, stamped, PERSONAL_MANIFEST_ID as M};- use serde_json::json;-- fn tables(entries: &[(&str, Vec<CodecRecord>)]) -> Tables {- entries.iter().map(|(name, rows)| (name.to_string(), rows.clone())).collect()- }-- #[test]- fn a_reference_that_resolves_only_in_another_manifest_dangles() {- let mut set = tables(&[- ("Folders", vec![row(&[("ManifestId", json!("m-other")), ("Id", json!("f-1"))])]),- ("Items", vec![stamped(M, &[("Id", json!("i-1")), ("FolderId", json!("f-1"))])]),- ]);- assert_eq!(violations(&set).len(), 1);- repair(&mut set);- assert_eq!(set["Items"][0]["FolderId"], Value::Null);- assert!(violations(&set).is_empty(), "validation cannot refuse what repair leaves behind");- }-- #[test]- fn child_rows_are_dropped_and_nullable_references_nulled() {- let mut set = tables(&[- ("Folders", vec![stamped(M, &[("Id", json!("f-1")), ("ParentFolderId", json!("gone"))])]),- ("Items", vec![stamped(M, &[("Id", json!("i-1")), ("FolderId", json!("gone")), ("IsDeleted", json!(0))]), stamped(M, &[("Id", json!("i-dead")), ("IsDeleted", json!(1))])]),- ("Tags", vec![]),- ("FieldDefinitions", vec![]),- ("TotpCodes", vec![stamped(M, &[("Id", json!("t-1")), ("ItemId", json!("i-1"))]), stamped(M, &[("Id", json!("t-orphan")), ("ItemId", json!("nobody"))]), stamped(M, &[("Id", json!("t-dead")), ("ItemId", json!("i-dead"))])]),- ("ItemTags", vec![stamped(M, &[("Id", json!("it-1")), ("ItemId", json!("i-1")), ("TagId", json!("no-tag"))])]),- ("FieldValues", vec![stamped(M, &[("Id", json!("fv-1")), ("ItemId", json!("i-1")), ("FieldDefinitionId", json!("no-def")), ("Value", json!("kept"))])]),- ]);- let ids: Vec<String> = violations(&set).into_iter().map(|(id, _)| id).collect();- assert_eq!(ids, vec!["folders-parentfolder-fk-broken", "items-folder-fk-broken", "totpcodes-item-fk-broken", "itemtags-tag-fk-broken", "fieldvalues-fielddefinition-fk-broken"]);-- repair(&mut set);-- assert_eq!(set["Folders"][0]["ParentFolderId"], Value::Null);- assert_eq!(set["Items"][0]["FolderId"], Value::Null);- assert_eq!(set["TotpCodes"].iter().map(|r| r["Id"].as_str().unwrap()).collect::<Vec<_>>(), vec!["t-1"], "the orphan and the tombstoned item's child are gone");- assert!(set["ItemTags"].is_empty());- assert_eq!(set["FieldValues"][0]["Value"], json!("kept"), "the value survives, only its definition link is cut");- assert_eq!(set["FieldValues"][0]["FieldDefinitionId"], Value::Null);- assert!(violations(&set).is_empty());- }-- #[test]- fn a_rule_whose_target_table_is_absent_is_skipped() {- let mut set = tables(&[("Items", vec![stamped(M, &[("Id", json!("i-1")), ("FolderId", json!("f-1"))])]), ("TotpCodes", vec![stamped(M, &[("Id", json!("t-1")), ("ItemId", json!("i-1"))])])]);- let before = set.clone();- repair(&mut set);- assert_eq!(set, before, "a partial table set is not a vault with empty tables");- assert!(violations(&set).is_empty());- }-}diff --git a/core/rust/src/vault_codec/mod.rs b/core/rust/src/vault_codec/mod.rsindex 00618ddbb..c08bafb0e 100644--- a/core/rust/src/vault_codec/mod.rs+++ b/core/rust/src/vault_codec/mod.rs@@ -13,8 +13,6 @@ mod manifest;mod materialize;pub(crate) mod row;mod sharing;-#[cfg(test)]-pub(crate) mod test_support;mod types;mod validate;@@ -146,7 +144,4 @@ pub fn compute_content_fingerprint(payload_json: &str) -> String {}#[cfg(test)]-mod tests;--#[cfg(test)]-mod sharing_tests;+pub(crate) mod tests;diff --git a/core/rust/src/vault_codec/normalize.rs b/core/rust/src/vault_codec/normalize.rsindex 1d72f4b1e..b4efd292f 100644--- a/core/rust/src/vault_codec/normalize.rs+++ b/core/rust/src/vault_codec/normalize.rs@@ -283,7 +283,8 @@ fn field_discriminator_of(field_key: &str, field_definition_id: &str) -> Stringif field_key.is_empty() { format!("fd:{}", field_definition_id.to_lowercase()) } else { format!("fk:{}", field_key.to_lowercase()) }}-fn has_id(row: &CodecRecord) -> bool {+/// Whether a row carries a non-empty `Id`.+pub(super) fn has_id(row: &CodecRecord) -> bool {str_col(row, ID_COL).is_some_and(|s| !s.is_empty())}@@ -299,105 +300,3 @@ fn value_index_of(row: &CodecRecord) -> Option<i64> {fn lower_str(row: &CodecRecord, column: &str) -> Option<String> {str_col(row, column).filter(|s| !s.is_empty()).map(id_key)}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn derivation_is_stable_and_well_formed() {- let id = field_value_id_for("m-1", "item-1", "login.username", "", 0);- // Known-answer vector: every platform must derive the same row id, so this value must never change.- assert_eq!(id, "f36327d9-f225-86ab-a061-1ba3a668d89a");- assert_eq!(id.len(), 36);- assert_eq!(id.as_bytes()[14], b'8', "UUIDv8 version nibble");- }-- #[test]- fn derivation_ignores_guid_casing() {- // iOS and the extension generate uppercase GUIDs; the natural key must not fork on casing.- let lower = field_value_id_for("aaaa-bbbb", "item-x", "", "def-1", 2);- let upper = field_value_id_for("AAAA-BBBB", "ITEM-X", "", "DEF-1", 2);- assert_eq!(lower, upper);- }-- #[test]- fn derivation_separates_system_and_custom_fields() {- // The same string as a FieldKey and as a FieldDefinitionId are different key spaces.- assert_ne!(field_value_id_for("m", "i", "x", "", 0), field_value_id_for("m", "i", "", "x", 0));- }-- #[test]- fn derivation_separates_positions() {- assert_ne!(field_value_id_for("m", "i", "login.url", "", 0), field_value_id_for("m", "i", "login.url", "", 1));- }-- fn field_value(id: Option<&str>, field_key: &str, value: &str, updated_at: &str) -> CodecRecord {- let mut row: CodecRecord = [- (MANIFEST_ID_COL.to_string(), json!("m-1")),- (ITEM_ID_COL.to_string(), json!("item-1")),- (FIELD_KEY_COL.to_string(), json!(field_key)),- ("Value".to_string(), json!(value)),- ("UpdatedAt".to_string(), json!(updated_at)),- ]- .into_iter()- .collect();- if let Some(id) = id {- row.insert(ID_COL.to_string(), json!(id));- }- row- }-- fn normalized(rows: Vec<CodecRecord>) -> Vec<CodecRecord> {- let mut tables: HashMap<String, Vec<CodecRecord>> = [(FIELD_VALUES_TABLE.to_string(), rows)].into_iter().collect();- normalize_row_shapes(&mut tables);- tables.remove(FIELD_VALUES_TABLE).unwrap()- }-- #[test]- fn a_field_this_build_does_not_know_keeps_every_value() {- // A newer writer's multi-value system field: collapsing it as single-value would destroy all but- // one value on this build's next push.- let rows = normalized(vec![- field_value(Some("a"), "login.future_multi", "one", "2024-01-01T00:00:00Z"),- field_value(Some("b"), "login.future_multi", "two", "2024-01-02T00:00:00Z"),- ]);- assert_eq!(rows.len(), 2);- assert!(rows.iter().all(has_id), "and the rows keep the ids they own");- }-- #[test]- fn an_unknown_field_row_and_its_id_less_twin_are_one_row() {- // A newer writer's single-value field arrives id-less; this build materialized it under the derived- // id and writes it back with that id. Both name one SQLite row, so they collapse to the newest.- let derived = field_value_id_for("m-1", "item-1", "login.future_single", "", 0);- let rows = normalized(vec![- field_value(None, "login.future_single", "server", "2024-01-01T00:00:00Z"),- field_value(Some(&derived), "login.future_single", "local-newer", "2024-01-09T00:00:00Z"),- ]);- assert_eq!(rows.len(), 1);- assert_eq!(rows[0]["Value"], json!("local-newer"));- }-- #[test]- fn a_known_single_value_field_still_collapses_to_the_newest() {- let rows = normalized(vec![- field_value(Some("a"), "login.username", "old", "2024-01-01T00:00:00Z"),- field_value(Some("b"), "login.username", "new", "2024-01-09T00:00:00Z"),- ]);- assert_eq!(rows.len(), 1);- assert_eq!(rows[0]["Value"], json!("new"));- assert!(!has_id(&rows[0]), "a single-value row travels without its derived id");- }-- #[test]- fn history_derivation_is_stable_and_disjoint_from_field_values() {- let id = field_history_id_for("m-1", "item-1", "login.password", "", "2026-01-01 10:00:00.000");- // Known-answer vector: every platform must derive the same row id, so this value must never change.- assert_eq!(id, "7431819b-eefd-834b-b4de-9e1f16df1a22");- assert_eq!(id.len(), 36);- // A different millisecond is a different row; the two namespaces never collide.- assert_ne!(id, field_history_id_for("m-1", "item-1", "login.password", "", "2026-01-01 10:00:00.001"));- assert_ne!(id, field_value_id_for("m-1", "item-1", "login.password", "", 0));- }-}diff --git a/core/rust/src/vault_codec/row.rs b/core/rust/src/vault_codec/row.rsindex edb0ab762..6cf7ecca3 100644--- a/core/rust/src/vault_codec/row.rs+++ b/core/rust/src/vault_codec/row.rs@@ -92,42 +92,3 @@ pub(crate) fn has_bytes(value: Option<&Value>) -> bool {Some(_) => true,}}--#[cfg(test)]-mod tests {- use super::*;- use serde_json::json;-- #[test]- fn truthy_accepts_every_spelling_sqlite_hands_over() {- for value in [json!(true), json!(1), json!(1.0), json!(2), json!("1"), json!("true"), json!("TRUE")] {- assert!(truthy(Some(&value)), "{value} should be truthy");- }- for value in [json!(false), json!(0), json!(0.0), json!("0"), json!(""), json!("false"), json!(null)] {- assert!(!truthy(Some(&value)), "{value} should be falsy");- }- assert!(!truthy(None));- }-- #[test]- fn byte_markers_round_trip_and_presence_reads_every_shape() {- assert_eq!(inline_b64(&inline_bytes(&[1, 2, 3])), Some("AQID"));- assert_eq!(blob_ref_of(&blob_ref("hash", "favicon")), Some(("hash", Some("favicon"))));- assert_eq!(blob_ref_of(&inline_bytes(&[1])), None);- assert!(has_bytes(Some(&inline_bytes(&[1]))));- assert!(!has_bytes(Some(&inline_bytes(&[]))));- assert!(has_bytes(Some(&blob_ref("hash", "attachment"))));- assert!(has_bytes(Some(&json!("x"))) && has_bytes(Some(&json!([1]))) && has_bytes(Some(&json!({ "0": 1 }))));- for empty in [json!(""), json!([]), json!({}), json!(null)] {- assert!(!has_bytes(Some(&empty)), "{empty} holds no bytes");- }- assert!(!has_bytes(None));- }-- #[test]- fn logo_kind_normalizes_case_whitespace_and_absence() {- assert_eq!(normalize_logo_kind(" Custom "), "custom");- assert_eq!(normalize_logo_kind(""), LOGO_KIND_FAVICON);- assert_eq!(logo_kind(&HashMap::new()), LOGO_KIND_FAVICON);- }-}diff --git a/core/rust/src/vault_codec/tests/compress.rs b/core/rust/src/vault_codec/tests/compress.rsnew file mode 100644index 000000000..44d3a2423--- /dev/null+++ b/core/rust/src/vault_codec/tests/compress.rs@@ -0,0 +1,16 @@+use crate::vault_codec::compress::*;++#[test]+fn gzip_roundtrips() {+ let text = r#"{"hello":"world","n":42}"#;+ let gz = gzip(text.as_bytes()).unwrap();+ assert_eq!(&gz[0..2], &[0x1f, 0x8b]);+ assert_eq!(gunzip_to_string(&gz).unwrap(), text);+}++#[test]+fn gunzip_rejects_output_over_the_limit() {+ let gz = gzip(&[b'a'; 1025]).unwrap();+ assert!(gunzip_to_string_capped(&gz, 1024).is_err());+ assert_eq!(gunzip_to_string_capped(&gz, 1025).unwrap().len(), 1025);+}diff --git a/core/rust/src/vault_codec/tests/integrity.rs b/core/rust/src/vault_codec/tests/integrity.rsnew file mode 100644index 000000000..b1d9febbd--- /dev/null+++ b/core/rust/src/vault_codec/tests/integrity.rs@@ -0,0 +1,57 @@+use std::collections::HashMap;++use serde_json::{json, Value};++use crate::vault_codec::integrity::*;+use crate::vault_codec::manifest::CodecRecord;+use crate::vault_codec::tests::support::{row, stamped, PERSONAL_MANIFEST_ID as M};++fn tables(entries: &[(&str, Vec<CodecRecord>)]) -> HashMap<String, Vec<CodecRecord>> {+ entries.iter().map(|(name, rows)| (name.to_string(), rows.clone())).collect()+}++#[test]+fn a_reference_that_resolves_only_in_another_manifest_dangles() {+ let mut set = tables(&[+ ("Folders", vec![row(&[("ManifestId", json!("m-other")), ("Id", json!("f-1"))])]),+ ("Items", vec![stamped(M, &[("Id", json!("i-1")), ("FolderId", json!("f-1"))])]),+ ]);+ assert_eq!(violations(&set).len(), 1);+ repair(&mut set);+ assert_eq!(set["Items"][0]["FolderId"], Value::Null);+ assert!(violations(&set).is_empty(), "validation cannot refuse what repair leaves behind");+}++#[test]+fn child_rows_are_dropped_and_nullable_references_nulled() {+ let mut set = tables(&[+ ("Folders", vec![stamped(M, &[("Id", json!("f-1")), ("ParentFolderId", json!("gone"))])]),+ ("Items", vec![stamped(M, &[("Id", json!("i-1")), ("FolderId", json!("gone")), ("IsDeleted", json!(0))]), stamped(M, &[("Id", json!("i-dead")), ("IsDeleted", json!(1))])]),+ ("Tags", vec![]),+ ("FieldDefinitions", vec![]),+ ("TotpCodes", vec![stamped(M, &[("Id", json!("t-1")), ("ItemId", json!("i-1"))]), stamped(M, &[("Id", json!("t-orphan")), ("ItemId", json!("nobody"))]), stamped(M, &[("Id", json!("t-dead")), ("ItemId", json!("i-dead"))])]),+ ("ItemTags", vec![stamped(M, &[("Id", json!("it-1")), ("ItemId", json!("i-1")), ("TagId", json!("no-tag"))])]),+ ("FieldValues", vec![stamped(M, &[("Id", json!("fv-1")), ("ItemId", json!("i-1")), ("FieldDefinitionId", json!("no-def")), ("Value", json!("kept"))])]),+ ]);+ let ids: Vec<String> = violations(&set).into_iter().map(|(id, _)| id).collect();+ assert_eq!(ids, vec!["folders-parentfolder-fk-broken", "items-folder-fk-broken", "totpcodes-item-fk-broken", "itemtags-tag-fk-broken", "fieldvalues-fielddefinition-fk-broken"]);++ repair(&mut set);++ assert_eq!(set["Folders"][0]["ParentFolderId"], Value::Null);+ assert_eq!(set["Items"][0]["FolderId"], Value::Null);+ assert_eq!(set["TotpCodes"].iter().map(|r| r["Id"].as_str().unwrap()).collect::<Vec<_>>(), vec!["t-1"], "the orphan and the tombstoned item's child are gone");+ assert!(set["ItemTags"].is_empty());+ assert_eq!(set["FieldValues"][0]["Value"], json!("kept"), "the value survives, only its definition link is cut");+ assert_eq!(set["FieldValues"][0]["FieldDefinitionId"], Value::Null);+ assert!(violations(&set).is_empty());+}++#[test]+fn a_rule_whose_target_table_is_absent_is_skipped() {+ let mut set = tables(&[("Items", vec![stamped(M, &[("Id", json!("i-1")), ("FolderId", json!("f-1"))])]), ("TotpCodes", vec![stamped(M, &[("Id", json!("t-1")), ("ItemId", json!("i-1"))])])]);+ let before = set.clone();+ repair(&mut set);+ assert_eq!(set, before, "a partial table set is not a vault with empty tables");+ assert!(violations(&set).is_empty());+}diff --git a/core/rust/src/vault_codec/tests.rs b/core/rust/src/vault_codec/tests/mod.rssimilarity index 98%rename from core/rust/src/vault_codec/tests.rsrename to core/rust/src/vault_codec/tests/mod.rsindex dfa68ac77..e72118ab9 100644--- a/core/rust/src/vault_codec/tests.rs+++ b/core/rust/src/vault_codec/tests/mod.rs@@ -1,8 +1,17 @@//! The codec round trip for one manifest: canonicalize, pack, unpack, materialize, and the forward-compatibility-//! overflow. Multi-manifest routing lives in `sharing_tests`.+//! overflow. Multi-manifest routing lives in `sharing.rs`, the fixtures in `support.rs`;+//! the other modules hold the unit tests of the `vault_codec` module of the same name.++pub(crate) mod support;+mod sharing;++mod compress;+mod integrity;+mod normalize;+mod row;use super::*;-use super::test_support::{b64, materialize_input, materialized_map, row, stamp_unstamped, stamped, table, PERSONAL_MANIFEST_ID as PERSONAL, PERSONAL_SALT as SALT};+use self::support::{b64, materialize_input, materialized_map, row, stamp_unstamped, stamped, table, PERSONAL_MANIFEST_ID as PERSONAL, PERSONAL_SALT as SALT};use super::types::{bucket_category_for, SCHEMA_VERSION};use crate::vault_model::{MANIFESTS_TABLE, MANIFEST_ID_COL, OVERFLOW_ROW_ID, OVERFLOW_TABLE};use serde_json::json;@@ -377,7 +386,7 @@ fn materialize_derives_the_missing_ids_back() {extra: HashMap::new(),};// The schema knows the id columns the wire omits, so the derived ids fit instead of landing in the overflow.- let mut schema = test_support::fitting_schema([&manifest], &[]);+ let mut schema = support::fitting_schema([&manifest], &[]);for table in ["FieldValues", "FieldHistories"] {schema.get_mut(table).unwrap().push("Id".to_string());}diff --git a/core/rust/src/vault_codec/tests/normalize.rs b/core/rust/src/vault_codec/tests/normalize.rsnew file mode 100644index 000000000..01b10cab5--- /dev/null+++ b/core/rust/src/vault_codec/tests/normalize.rs@@ -0,0 +1,105 @@+use std::collections::HashMap;++use serde_json::json;++use crate::vault_codec::manifest::CodecRecord;+use crate::vault_codec::normalize::*;+use crate::vault_model::names::{FIELD_KEY_COL, FIELD_VALUES_TABLE, ID_COL, ITEM_ID_COL};+use crate::vault_model::MANIFEST_ID_COL;++#[test]+fn derivation_is_stable_and_well_formed() {+ let id = field_value_id_for("m-1", "item-1", "login.username", "", 0);+ // Known-answer vector: every platform must derive the same row id, so this value must never change.+ assert_eq!(id, "f36327d9-f225-86ab-a061-1ba3a668d89a");+ assert_eq!(id.len(), 36);+ assert_eq!(id.as_bytes()[14], b'8', "UUIDv8 version nibble");+}++#[test]+fn derivation_ignores_guid_casing() {+ // iOS and the extension generate uppercase GUIDs; the natural key must not fork on casing.+ let lower = field_value_id_for("aaaa-bbbb", "item-x", "", "def-1", 2);+ let upper = field_value_id_for("AAAA-BBBB", "ITEM-X", "", "DEF-1", 2);+ assert_eq!(lower, upper);+}++#[test]+fn derivation_separates_system_and_custom_fields() {+ // The same string as a FieldKey and as a FieldDefinitionId are different key spaces.+ assert_ne!(field_value_id_for("m", "i", "x", "", 0), field_value_id_for("m", "i", "", "x", 0));+}++#[test]+fn derivation_separates_positions() {+ assert_ne!(field_value_id_for("m", "i", "login.url", "", 0), field_value_id_for("m", "i", "login.url", "", 1));+}++fn field_value(id: Option<&str>, field_key: &str, value: &str, updated_at: &str) -> CodecRecord {+ let mut row: CodecRecord = [+ (MANIFEST_ID_COL.to_string(), json!("m-1")),+ (ITEM_ID_COL.to_string(), json!("item-1")),+ (FIELD_KEY_COL.to_string(), json!(field_key)),+ ("Value".to_string(), json!(value)),+ ("UpdatedAt".to_string(), json!(updated_at)),+ ]+ .into_iter()+ .collect();+ if let Some(id) = id {+ row.insert(ID_COL.to_string(), json!(id));+ }+ row+}++fn normalized(rows: Vec<CodecRecord>) -> Vec<CodecRecord> {+ let mut tables: HashMap<String, Vec<CodecRecord>> = [(FIELD_VALUES_TABLE.to_string(), rows)].into_iter().collect();+ normalize_row_shapes(&mut tables);+ tables.remove(FIELD_VALUES_TABLE).unwrap()+}++#[test]+fn a_field_this_build_does_not_know_keeps_every_value() {+ // A newer writer's multi-value system field: collapsing it as single-value would destroy all but+ // one value on this build's next push.+ let rows = normalized(vec![+ field_value(Some("a"), "login.future_multi", "one", "2024-01-01T00:00:00Z"),+ field_value(Some("b"), "login.future_multi", "two", "2024-01-02T00:00:00Z"),+ ]);+ assert_eq!(rows.len(), 2);+ assert!(rows.iter().all(has_id), "and the rows keep the ids they own");+}++#[test]+fn an_unknown_field_row_and_its_id_less_twin_are_one_row() {+ // A newer writer's single-value field arrives id-less; this build materialized it under the derived+ // id and writes it back with that id. Both name one SQLite row, so they collapse to the newest.+ let derived = field_value_id_for("m-1", "item-1", "login.future_single", "", 0);+ let rows = normalized(vec![+ field_value(None, "login.future_single", "server", "2024-01-01T00:00:00Z"),+ field_value(Some(&derived), "login.future_single", "local-newer", "2024-01-09T00:00:00Z"),+ ]);+ assert_eq!(rows.len(), 1);+ assert_eq!(rows[0]["Value"], json!("local-newer"));+}++#[test]+fn a_known_single_value_field_still_collapses_to_the_newest() {+ let rows = normalized(vec![+ field_value(Some("a"), "login.username", "old", "2024-01-01T00:00:00Z"),+ field_value(Some("b"), "login.username", "new", "2024-01-09T00:00:00Z"),+ ]);+ assert_eq!(rows.len(), 1);+ assert_eq!(rows[0]["Value"], json!("new"));+ assert!(!has_id(&rows[0]), "a single-value row travels without its derived id");+}++#[test]+fn history_derivation_is_stable_and_disjoint_from_field_values() {+ let id = field_history_id_for("m-1", "item-1", "login.password", "", "2026-01-01 10:00:00.000");+ // Known-answer vector: every platform must derive the same row id, so this value must never change.+ assert_eq!(id, "7431819b-eefd-834b-b4de-9e1f16df1a22");+ assert_eq!(id.len(), 36);+ // A different millisecond is a different row; the two namespaces never collide.+ assert_ne!(id, field_history_id_for("m-1", "item-1", "login.password", "", "2026-01-01 10:00:00.001"));+ assert_ne!(id, field_value_id_for("m-1", "item-1", "login.password", "", 0));+}diff --git a/core/rust/src/vault_codec/tests/row.rs b/core/rust/src/vault_codec/tests/row.rsnew file mode 100644index 000000000..4fd3709d3--- /dev/null+++ b/core/rust/src/vault_codec/tests/row.rs@@ -0,0 +1,39 @@+use std::collections::HashMap;++use serde_json::json;++use crate::vault_codec::row::*;+use crate::vault_model::names::LOGO_KIND_FAVICON;++#[test]+fn truthy_accepts_every_spelling_sqlite_hands_over() {+ for value in [json!(true), json!(1), json!(1.0), json!(2), json!("1"), json!("true"), json!("TRUE")] {+ assert!(truthy(Some(&value)), "{value} should be truthy");+ }+ for value in [json!(false), json!(0), json!(0.0), json!("0"), json!(""), json!("false"), json!(null)] {+ assert!(!truthy(Some(&value)), "{value} should be falsy");+ }+ assert!(!truthy(None));+}++#[test]+fn byte_markers_round_trip_and_presence_reads_every_shape() {+ assert_eq!(inline_b64(&inline_bytes(&[1, 2, 3])), Some("AQID"));+ assert_eq!(blob_ref_of(&blob_ref("hash", "favicon")), Some(("hash", Some("favicon"))));+ assert_eq!(blob_ref_of(&inline_bytes(&[1])), None);+ assert!(has_bytes(Some(&inline_bytes(&[1]))));+ assert!(!has_bytes(Some(&inline_bytes(&[]))));+ assert!(has_bytes(Some(&blob_ref("hash", "attachment"))));+ assert!(has_bytes(Some(&json!("x"))) && has_bytes(Some(&json!([1]))) && has_bytes(Some(&json!({ "0": 1 }))));+ for empty in [json!(""), json!([]), json!({}), json!(null)] {+ assert!(!has_bytes(Some(&empty)), "{empty} holds no bytes");+ }+ assert!(!has_bytes(None));+}++#[test]+fn logo_kind_normalizes_case_whitespace_and_absence() {+ assert_eq!(normalize_logo_kind(" Custom "), "custom");+ assert_eq!(normalize_logo_kind(""), LOGO_KIND_FAVICON);+ assert_eq!(logo_kind(&HashMap::new()), LOGO_KIND_FAVICON);+}diff --git a/core/rust/src/vault_codec/sharing_tests.rs b/core/rust/src/vault_codec/tests/sharing.rssimilarity index 99%rename from core/rust/src/vault_codec/sharing_tests.rsrename to core/rust/src/vault_codec/tests/sharing.rsindex cf1829039..802e710e1 100644--- a/core/rust/src/vault_codec/sharing_tests.rs+++ b/core/rust/src/vault_codec/tests/sharing.rs@@ -1,10 +1,10 @@//! The shared-manifest split (canonicalize) and combine (materialize): every row routes to the manifest its stamp//! names, each manifest is self-contained, and nothing crosses a manifest boundary that should not.-use super::*;-use super::row::rows_of;-use super::test_support::{b64, materialize_input, materialized_map, row, stamped, table, PERSONAL_MANIFEST_ID as PERSONAL, PERSONAL_SALT as SALT_PERSONAL, SHARED_MANIFEST_ID as SHARED};-use super::types::{is_bucketed_table, is_personal_table, manifest_scoped_tables, SCHEMA_VERSION};+use super::super::*;+use super::super::row::rows_of;+use super::support::{b64, materialize_input, materialized_map, row, stamped, table, PERSONAL_MANIFEST_ID as PERSONAL, PERSONAL_SALT as SALT_PERSONAL, SHARED_MANIFEST_ID as SHARED};+use super::super::types::{is_bucketed_table, is_personal_table, manifest_scoped_tables, SCHEMA_VERSION};use crate::vault_model::OVERFLOW_TABLE;use serde_json::json;use std::collections::{HashMap, HashSet};diff --git a/core/rust/src/vault_codec/test_support.rs b/core/rust/src/vault_codec/tests/support.rssimilarity index 96%rename from core/rust/src/vault_codec/test_support.rsrename to core/rust/src/vault_codec/tests/support.rsindex 4fab51dc6..0821dbe12 100644--- a/core/rust/src/vault_codec/test_support.rs+++ b/core/rust/src/vault_codec/tests/support.rs@@ -4,8 +4,8 @@ use std::collections::{HashMap, HashSet};use serde_json::json;-use super::manifest::{CodecRecord, CodecTableData, DataBucket, Manifest, MaterializeInput, MaterializedTables};-use super::types::manifest_scoped_tables;+use super::super::manifest::{CodecRecord, CodecTableData, DataBucket, Manifest, MaterializeInput, MaterializedTables};+use super::super::types::manifest_scoped_tables;use crate::vault_model::{MANIFESTS_TABLE, MANIFEST_ID_COL};/// The personal manifest id every test suite uses.diff --git a/core/rust/src/vault_items/tests.rs b/core/rust/src/vault_items/tests/mod.rssimilarity index 100%rename from core/rust/src/vault_items/tests.rsrename to core/rust/src/vault_items/tests/mod.rsdiff --git a/core/rust/src/vault_merge/tests.rs b/core/rust/src/vault_merge/tests/mod.rssimilarity index 99%rename from core/rust/src/vault_merge/tests.rsrename to core/rust/src/vault_merge/tests/mod.rsindex 24d466c0d..371d5f17b 100644--- a/core/rust/src/vault_merge/tests.rs+++ b/core/rust/src/vault_merge/tests/mod.rs@@ -1,7 +1,7 @@//! The canonical merge: last write wins per row, an item deleted as a unit, manifests merged independently.use super::*;-use crate::vault_codec::test_support::{restamp, row, PERSONAL_MANIFEST_ID as PERSONAL, SHARED_MANIFEST_ID as SHARED};+use crate::vault_codec::tests::support::{restamp, row, PERSONAL_MANIFEST_ID as PERSONAL, SHARED_MANIFEST_ID as SHARED};use serde_json::json;const SALT: &str = "0123456789abcdef0123456789abcdef";diff --git a/core/rust/src/vault_pruner/tests.rs b/core/rust/src/vault_pruner/tests/mod.rssimilarity index 98%rename from core/rust/src/vault_pruner/tests.rsrename to core/rust/src/vault_pruner/tests/mod.rsindex 297cf9d9d..c3e5d915b 100644--- a/core/rust/src/vault_pruner/tests.rs+++ b/core/rust/src/vault_pruner/tests/mod.rs@@ -2,7 +2,7 @@//! tombstoned blob rows are reclaimed, and every statement names the manifest it addresses.use super::*;-use crate::vault_codec::test_support::{days_ago_iso, now_iso, restamp, row, table, PERSONAL_MANIFEST_ID as M, SHARED_MANIFEST_ID};+use crate::vault_codec::tests::support::{days_ago_iso, now_iso, restamp, row, table, PERSONAL_MANIFEST_ID as M, SHARED_MANIFEST_ID};use crate::vault_model::names::{ATTACHMENTS_TABLE, FIELD_HISTORIES_TABLE, FIELD_VALUES_TABLE, ITEM_TAGS_TABLE};use serde_json::{json, Value};diff --git a/core/rust/src/vault_sync/blob_keys.rs b/core/rust/src/vault_sync/blob_keys.rsindex 4e999d925..9049c298d 100644--- a/core/rust/src/vault_sync/blob_keys.rs+++ b/core/rust/src/vault_sync/blob_keys.rs@@ -44,54 +44,3 @@ mod base64_bytes {super::base64_decode(&String::deserialize(deserializer)?).map_err(serde::de::Error::custom)}}--#[cfg(test)]-mod tests {- use super::*;-- const MANIFEST: &str = "0a1b2c3d-0000-0000-0000-000000000001";- const HASH: &str = "aa11";-- #[test]- fn a_blob_opens_with_the_vek_through_its_own_key() {- let vek = crypto::generate_key_base64();- let blob = encrypt_blob(&[1, 2, 3, 4], &vek, MANIFEST, HASH).unwrap();-- assert_eq!(decrypt_blob(&blob, &vek, MANIFEST, HASH).unwrap(), vec![1, 2, 3, 4]);- assert!(crypto::symmetric_decrypt_bytes(&blob.encrypted_data, &vek).is_err(), "the bytes are not encrypted with the VEK itself");- assert!(decrypt_blob(&blob, &crypto::generate_key_base64(), MANIFEST, HASH).is_err());- }-- #[test]- fn a_blob_does_not_open_at_another_address() {- let vek = crypto::generate_key_base64();- let blob = encrypt_blob(&[1, 2, 3, 4], &vek, MANIFEST, HASH).unwrap();- assert!(decrypt_blob(&blob, &vek, MANIFEST, "bb22").is_err(), "served under another hash");- assert!(decrypt_blob(&blob, &vek, "0a1b2c3d-0000-0000-0000-000000000002", HASH).is_err(), "served under another manifest");-- // The blob key of one blob next to the bytes of another: neither half opens the other.- let other = encrypt_blob(&[5, 6], &vek, MANIFEST, "bb22").unwrap();- let mixed = EncryptedBlob { encrypted_data: other.encrypted_data, encrypted_blob_key: blob.encrypted_blob_key };- assert!(decrypt_blob(&mixed, &vek, MANIFEST, HASH).is_err());- }-- #[test]- fn changing_the_vek_only_encrypts_the_blob_key_again() {- let (old_vek, new_vek) = (crypto::generate_key_base64(), crypto::generate_key_base64());- let blob = encrypt_blob(&[9; 64], &old_vek, MANIFEST, HASH).unwrap();-- let key_aad = aad::blob_key(MANIFEST, HASH);- let blob_key = crypto::unwrap_key(&blob.encrypted_blob_key, &old_vek, &key_aad).unwrap();- let rekeyed = EncryptedBlob { encrypted_data: blob.encrypted_data.clone(), encrypted_blob_key: crypto::wrap_key(&blob_key, &new_vek, &key_aad).unwrap() };-- assert_eq!(decrypt_blob(&rekeyed, &new_vek, MANIFEST, HASH).unwrap(), vec![9; 64]);- assert!(decrypt_blob(&rekeyed, &old_vek, MANIFEST, HASH).is_err());- }-- #[test]- fn a_cached_blob_reads_back_as_it_was_written() {- let blob = encrypt_blob(&[5], &crypto::generate_key_base64(), MANIFEST, HASH).unwrap();- let read: EncryptedBlob = serde_json::from_value(serde_json::to_value(&blob).unwrap()).unwrap();- assert_eq!(read, blob);- }-}diff --git a/core/rust/src/vault_sync/db.rs b/core/rust/src/vault_sync/db.rsindex bb25b3170..12c360dff 100644--- a/core/rust/src/vault_sync/db.rs+++ b/core/rust/src/vault_sync/db.rs@@ -322,17 +322,3 @@ pub(crate) async fn prune_in_place(host: &Host, retention_days: u32) -> SyncResuexec(host, Db::Local, output.statements).await?;Ok(count)}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn ids_are_lowercase_uuid_v4() {- let id = new_id();- assert_eq!(id.len(), 36);- assert_eq!(id, id.to_lowercase());- assert_eq!(&id[14..15], "4");- assert!(matches!(&id[19..20], "8" | "9" | "a" | "b"));- }-}diff --git a/core/rust/src/vault_sync/email_routing.rs b/core/rust/src/vault_sync/email_routing.rsindex ab0f08bec..c9849db56 100644--- a/core/rust/src/vault_sync/email_routing.rs+++ b/core/rust/src/vault_sync/email_routing.rs@@ -65,37 +65,3 @@ pub(crate) fn build_email_routing(manifests: &[Manifest], private_email_domains:.collect(),}}--#[cfg(test)]-mod tests {- use super::*;- use std::collections::HashMap;-- fn manifest(id: &str, items: Vec<Value>, fields: Vec<Value>) -> Manifest {- let mut tables = HashMap::new();- tables.insert("Items".to_string(), items.into_iter().map(|v| serde_json::from_value(v).unwrap()).collect());- tables.insert("FieldValues".to_string(), fields.into_iter().map(|v| serde_json::from_value(v).unwrap()).collect());- Manifest { schema_version: 1, manifest_salt: String::new(), canonicalized_at: String::new(), manifest_id: id.to_string(), name: None, tables, extra: HashMap::new() }- }-- #[test]- fn claims_private_addresses_of_live_items_once_per_manifest() {- let m = manifest(- "m1",- vec![serde_json::json!({"Id": "i1", "IsDeleted": 0, "DeletedAt": null}), serde_json::json!({"Id": "i2", "IsDeleted": 0, "DeletedAt": "2026-01-01"})],- vec![- serde_json::json!({"ItemId": "i1", "FieldKey": "login.email", "Value": " [email protected] ", "IsDeleted": 0, "IsDisabled": 1}),- serde_json::json!({"ItemId": "i1", "FieldKey": "login.email", "Value": "[email protected]", "IsDeleted": 0, "IsDisabled": 0}),- serde_json::json!({"ItemId": "i2", "FieldKey": "login.email", "Value": "[email protected]", "IsDeleted": 0}),- serde_json::json!({"ItemId": "i1", "FieldKey": "login.email", "Value": "[email protected]", "IsDeleted": 0}),- ],- );- let routing = build_email_routing(&[m], &["private.io".to_string()], &HashMap::from([("m1".to_string(), 7)]));- assert_eq!(routing.email_address_list.len(), 1);- assert_eq!(routing.email_address_list[0].address, "[email protected]");- assert!(!routing.email_address_list[0].paused);- assert_eq!(routing.covered_manifest_ids, vec!["m1"]);- assert_eq!(routing.base_revisions.len(), 1);- assert_eq!(routing.base_revisions[0].revision, 7);- }-}diff --git a/core/rust/src/vault_sync/engine.rs b/core/rust/src/vault_sync/engine.rsindex 77ba2e630..0756efab7 100644--- a/core/rust/src/vault_sync/engine.rs+++ b/core/rust/src/vault_sync/engine.rs@@ -61,7 +61,7 @@ fn success() -> FullSyncResult {}/// The outcome of a failed sync: a forced logout, or a coded error.-fn failure(error: &SyncError) -> FullSyncResult {+pub(super) fn failure(error: &SyncError) -> FullSyncResult {FullSyncResult { failure: error.into(), ..Default::default() }}@@ -248,7 +248,7 @@ fn version_logout_reason(ctx: &Ctx, status: &StatusResponse) -> Option<LogoutRea/// Whether `version1 >= version2` under the client's SemVer rules: a pre-release sorts below its release, and/// two pre-releases compare lexically.-fn version_gte(version1: &str, version2: &str) -> bool {+pub(super) fn version_gte(version1: &str, version2: &str) -> bool {let (core1, pre1) = split_version(version1);let (core2, pre2) = split_version(version2);let parts1: Vec<u64> = core1.split('.').map(|part| part.parse().unwrap_or(0)).collect();@@ -474,32 +474,3 @@ async fn status_check(ctx: &mut Ctx) -> StatusCheckResult {}}}--#[cfg(test)]-mod tests {- use super::*;- use super::super::errors::ErrorCode;-- #[test]- fn failures_carry_a_code_or_a_logout_reason_never_both() {- let coded = failure(&SyncError::Timeout("slow".to_string())).failure;- assert_eq!(coded.error_code, Some(ErrorCode::UploadTimeout));- assert_eq!(coded.logout_reason, None);- assert!(!coded.requires_logout);-- let logout = failure(&SyncError::VaultVersionIncompatible("3.0.0".to_string())).failure;- assert_eq!(logout.logout_reason, Some(LogoutReason::VaultVersionIncompatible));- assert_eq!(logout.error_code, None);- assert!(logout.requires_logout);- }-- #[test]- fn semver_rules_match_the_client() {- assert!(version_gte("0.12.0", "0.12.0-dev"));- assert!(!version_gte("0.12.0-dev", "0.12.0"));- assert!(version_gte("0.13.1", "0.12.0-dev"));- assert!(!version_gte("0.11.9", "0.12.0-dev"));- assert!(version_gte("1.0", "1.0.0"));- assert!(version_gte("0.12.0-beta", "0.12.0-alpha"));- }-}diff --git a/core/rust/src/vault_sync/errors.rs b/core/rust/src/vault_sync/errors.rsindex d1f0d638f..260943fe4 100644--- a/core/rust/src/vault_sync/errors.rs+++ b/core/rust/src/vault_sync/errors.rs@@ -181,7 +181,8 @@ pub enum SyncError {impl From<crate::crypto::KeyChainError> for SyncError {fn from(error: crate::crypto::KeyChainError) -> Self {match error {- crate::crypto::KeyChainError::UnlockKeyRejected => SyncError::UnlockKeyRejected,+ // The engine opens chains with the unlock key only; either rejection is the same E-206 "wrong key" to the host.+ crate::crypto::KeyChainError::UnlockKeyRejected | crate::crypto::KeyChainError::AccountKeyRejected => SyncError::UnlockKeyRejected,crate::crypto::KeyChainError::KeyChainUnreadable(message) => SyncError::KeyChainUnreadable(message),}}@@ -241,32 +242,3 @@ fn storage_error_code(command: &str) -> ErrorCode {}pub type SyncResult<T> = Result<T, SyncError>;--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn codes_and_reasons_serialize_to_the_client_vocabulary() {- assert_eq!(serde_json::to_string(&ErrorCode::VaultLocked).unwrap(), "\"E-202\"");- assert_eq!(serde_json::to_string(&ErrorCode::UploadTimeout).unwrap(), "\"E-805\"");- assert_eq!(SyncError::VaultDecryptFailed(String::new()).failure(), Failure::Coded(ErrorCode::VaultDecryptFailed));- assert_eq!(SyncError::UnlockKeyRejected.failure(), Failure::Coded(ErrorCode::UnlockKeyRejected));- assert_eq!(SyncError::KeyChainUnreadable(String::new()).failure(), Failure::Coded(ErrorCode::KeyChainUnreadable));- assert_eq!(SyncError::KeyOutOfSync.failure(), Failure::Logout(LogoutReason::PasswordChanged));- assert_eq!(serde_json::to_string(&LogoutReason::PasswordChanged).unwrap(), "\"passwordChanged\"");- assert_eq!(SyncError::Auth.failure(), Failure::Logout(LogoutReason::SessionExpired));- assert_eq!(SyncError::Staging(String::new()).failure(), Failure::Coded(ErrorCode::DatabaseInitFailed));- assert_eq!(SyncError::Host { command: "dbExec", message: String::new() }.failure(), Failure::Coded(ErrorCode::StorageWriteFailed));- assert_eq!(SyncError::Host { command: "vaultKey", message: String::new() }.failure(), Failure::Coded(ErrorCode::SyncEngineFailed));- }-- #[test]- fn engine_internal_failures_carry_their_own_codes() {- assert_eq!(SyncError::Other("no rule".to_string()).failure(), Failure::Coded(ErrorCode::SyncEngineFailed));- assert_eq!(SyncError::Core(VaultError::General("codec".to_string())).failure(), Failure::Coded(ErrorCode::SyncCodecFailed));- assert_eq!(SyncError::VaultDataRejected("NOT NULL".to_string()).failure(), Failure::Coded(ErrorCode::SyncCodecFailed));- assert_eq!(serde_json::from_str::<serde_json::Value>("nope").map_err(SyncError::Json).unwrap_err().failure(), Failure::Coded(ErrorCode::SyncResponseInvalid));- assert_eq!(serde_json::to_string(&ErrorCode::SyncEngineFailed).unwrap(), "\"E-509\"");- }-}diff --git a/core/rust/src/vault_sync/frame.rs b/core/rust/src/vault_sync/frame.rsindex edd0bfeae..d342ced65 100644--- a/core/rust/src/vault_sync/frame.rs+++ b/core/rust/src/vault_sync/frame.rs@@ -60,58 +60,3 @@ pub(crate) fn decode<T: FrameBody + DeserializeOwned>(frame: &[u8]) -> SyncResul}Ok(body)}--#[cfg(test)]-mod tests {- use serde_json::{json, Value};-- use super::*;- use crate::vault_sync::types::{BlobDownloadResponse, BlobDto, BlobUploadRequest, GetResponse};-- fn frame(header: Value, data: &[u8]) -> Vec<u8> {- let header = serde_json::to_vec(&header).unwrap();- [&(header.len() as u32).to_be_bytes()[..], &header, data].concat()- }-- #[test]- fn an_upload_keeps_each_ciphertext_out_of_the_json_header() {- let blob = |hash: &str, bytes: Vec<u8>| BlobDto { hash: hash.to_string(), category: "attachment".to_string(), ciphertext: bytes.into(), encrypted_blob_key: format!("k{}", hash) };- let mut request = BlobUploadRequest { manifest_id: "m1".to_string(), overwrite: false, blobs: vec![blob("a", vec![1, 2, 3]), blob("b", vec![]), blob("c", vec![4])] };- let encoded = encode(&mut request).unwrap();-- let header_length = u32::from_be_bytes(encoded[..4].try_into().unwrap()) as usize;- let header: Value = serde_json::from_slice(&encoded[4..4 + header_length]).unwrap();- assert_eq!(header["blobs"][0], json!({ "hash": "a", "category": "attachment", "offset": 0, "size": 3, "encryptedBlobKey": "ka" }));- assert_eq!(&encoded[4 + header_length..], &[1, 2, 3, 4]);-- let decoded: BlobDownloadResponse = decode(&encoded).unwrap();- assert_eq!(decoded.blobs.iter().map(|b| b.ciphertext.bytes.clone()).collect::<Vec<_>>(), vec![vec![1, 2, 3], vec![], vec![4]]);- }-- #[test]- fn a_download_reads_each_part_by_offset_and_skips_what_it_does_not_know() {- // A newer server: parts in another order, an unknown list with a part of its own, and a part nothing known points at.- let encoded = frame(- json!({- "storageFormat": "manifest",- "futureList": [{ "offset": 0, "size": 2 }],- "manifests": [{ "manifestId": "m1", "offset": 5, "size": 3, "futureField": true }, { "manifestId": "m2" }],- "buckets": [{ "manifestId": "m1", "category": "settings", "offset": 2, "size": 3 }],- }),- &[9, 9, 4, 5, 6, 1, 2, 3, 7, 7, 7],- );- let snapshot: GetResponse = decode(&encoded).unwrap();- assert_eq!(snapshot.manifests[0].ciphertext.bytes, vec![1, 2, 3]);- assert!(!snapshot.manifests[1].has_content());- assert_eq!(snapshot.buckets[0].ciphertext.bytes, vec![4, 5, 6]);- }-- #[test]- fn a_malformed_frame_is_refused() {- let encoded = frame(json!({ "blobs": [{ "hash": "a", "category": "favicon", "encryptedBlobKey": "ka", "offset": 0, "size": 3 }] }), &[1, 2, 3]);- assert!(decode::<BlobDownloadResponse>(&encoded).is_ok());- assert!(decode::<BlobDownloadResponse>(&encoded[..encoded.len() - 1]).is_err(), "a truncated ciphertext");- assert!(decode::<BlobDownloadResponse>(&[]).is_err(), "no header length");- assert!(decode::<BlobDownloadResponse>(&[0, 0, 1, 0, b'{']).is_err(), "a header longer than the body");- }-}diff --git a/core/rust/src/vault_sync/http.rs b/core/rust/src/vault_sync/http.rsindex da5c6de32..a65051215 100644--- a/core/rust/src/vault_sync/http.rs+++ b/core/rust/src/vault_sync/http.rs@@ -47,7 +47,8 @@ async fn send_for_frame<T: FrameBody + DeserializeOwned>(host: &Host, method: Htframe::decode(&bytes.ok_or_else(|| SyncError::Network(format!("{} answered without a body", path)))?)}-fn check(response: HttpResponse) -> SyncResult<String> {+/// The body of a successful response, or the error a refused or failed request maps to.+pub(super) fn check(response: HttpResponse) -> SyncResult<String> {let code = api_error_code(&response.body);match response.status {200..=299 => Ok(response.body),@@ -163,41 +164,3 @@ pub(crate) async fn get_status(host: &Host) -> SyncResult<StatusResponse> {other => other,}}--#[cfg(test)]-mod tests {- use super::*;- use crate::vault_sync::types::FailureFields;-- fn response(status: u16, body: &str) -> HttpResponse {- HttpResponse { status, body: body.to_string(), transport_error: None, timed_out: false }- }-- #[test]- fn a_refusal_keeps_the_server_code() {- let error = check(response(400, r#"{"code":"INVALID_REQUEST","statusCode":400}"#)).unwrap_err();- assert_eq!(error.api_error_code().as_deref(), Some("INVALID_REQUEST"));- assert_eq!(FailureFields::from(&error).api_error_code.as_deref(), Some("INVALID_REQUEST"));- }-- #[test]- fn a_body_without_a_code_yields_none() {- assert_eq!(check(response(500, "")).unwrap_err().api_error_code(), None);- assert_eq!(check(response(502, "<html>Bad gateway</html>")).unwrap_err().api_error_code(), None);- assert_eq!(check(response(400, r#"{"code":"not a code"}"#)).unwrap_err().api_error_code(), None);- }-- #[test]- fn only_an_uncoded_403_ends_the_session() {- assert!(matches!(check(response(403, "")), Err(SyncError::Auth)));- let refused = check(response(403, r#"{"code":"CAPABILITY_NOT_AVAILABLE","statusCode":403}"#)).unwrap_err();- assert_eq!(refused.api_error_code().as_deref(), Some("CAPABILITY_NOT_AVAILABLE"));- }-- #[test]- fn only_an_uncoded_404_means_an_outdated_server() {- assert!(matches!(with_outdated_server_guard::<()>(check(response(404, "")).map(|_| ())), Err(SyncError::ServerUpdateRequired)));- let coded = with_outdated_server_guard::<()>(check(response(404, r#"{"code":"SHARED_MANIFEST_NOT_FOUND","statusCode":404}"#)).map(|_| ())).unwrap_err();- assert_eq!(coded.api_error_code().as_deref(), Some("SHARED_MANIFEST_NOT_FOUND"));- }-}diff --git a/core/rust/src/vault_sync/keys.rs b/core/rust/src/vault_sync/keys.rsindex ef257c778..1914dbe04 100644--- a/core/rust/src/vault_sync/keys.rs+++ b/core/rust/src/vault_sync/keys.rs@@ -58,10 +58,10 @@ async fn clear_cached_chain(host: &Host) -> SyncResult<()> {Ok(())}-/// Open a key chain with the unlock key or the stored Account Key: stages the Account Key and the account private key-/// for this run and returns the VEK, which the caller makes the session key.+/// Open a key chain with the unlock key: stages the Account Key and the account private key for this run and returns+/// the VEK, which the caller makes the session key.async fn open_chain(ctx: &mut Ctx, encrypted_account_key: &str, encrypted_vek: &str, encrypted_private_key: Option<&str>, unlock_key: &str) -> SyncResult<SecretString> {- let mut opened = crypto::open_account_key_chain(unlock_key, encrypted_account_key, encrypted_vek, None)?;+ let mut opened = crypto::open_key_chain_with_unlock_key(unlock_key, encrypted_account_key, encrypted_vek, None)?;let account_key = from_zeroizing(std::mem::take(&mut opened.account_key));ctx.account_key = Some(account_key.clone());if let Some(encrypted) = encrypted_private_key.filter(|e| !e.is_empty()) {diff --git a/core/rust/src/vault_sync/legacy.rs b/core/rust/src/vault_sync/legacy.rsindex d13692613..420fc75d9 100644--- a/core/rust/src/vault_sync/legacy.rs+++ b/core/rust/src/vault_sync/legacy.rs@@ -155,7 +155,7 @@ fn latest_legacy_revision() -> u32 {}/// The data version embedded in an EF migration id (`20250101000000_2.0.0-Name`).-fn extract_version_from_migration_id(migration_id: &str) -> Option<String> {+pub(super) fn extract_version_from_migration_id(migration_id: &str) -> Option<String> {let start = migration_id.find('_')? + 1;let rest = &migration_id[start..];let end = rest.find('-')?;@@ -169,7 +169,7 @@ fn is_well_formed_version(version: &str) -> bool {/// The legacy-chain revision a database version maps to. A known version maps to its entry; an unknown but/// well-formed version is treated as the latest (backwards compatible); a malformed version is incompatible.-fn legacy_revision_for(database_version: &str) -> Result<u32, String> {+pub(super) fn legacy_revision_for(database_version: &str) -> Result<u32, String> {if let Some((revision, _)) = LEGACY_VAULT_VERSIONS.iter().find(|(_, version)| *version == database_version) {return Ok(*revision);}@@ -182,22 +182,3 @@ pub(crate) fn stamp_predates_manifest_schema(migration_id: &str) -> SyncResult<blet revision = legacy_revision_for(&database_version).map_err(SyncError::VaultVersionIncompatible)?;Ok(revision < latest_legacy_revision())}--#[cfg(test)]-mod tests {- use super::*;-- #[test]- fn migration_stamps_map_onto_the_frozen_chain() {- assert_eq!(extract_version_from_migration_id("20250101000000_2.0.0-Squashed").as_deref(), Some("2.0.0"));- assert_eq!(extract_version_from_migration_id("20250101000000_Initial"), None);- assert_eq!(legacy_revision_for("1.7.0"), Ok(12));- assert_eq!(legacy_revision_for("2.1.0"), Ok(13), "an unknown but well-formed version reads as the latest");- assert!(legacy_revision_for("nope").is_err());-- assert!(stamp_predates_manifest_schema("20250101000000_1.7.0-Old").unwrap());- assert!(!stamp_predates_manifest_schema("20250101000000_2.0.0-Squashed").unwrap());- assert!(!stamp_predates_manifest_schema("20260101000000_2.1.0-Later").unwrap());- assert!(matches!(stamp_predates_manifest_schema("20250101000000_Initial"), Err(SyncError::Other(_))));- }-}diff --git a/core/rust/src/vault_sync/tests/blob_keys.rs b/core/rust/src/vault_sync/tests/blob_keys.rsnew file mode 100644index 000000000..d92ffcc47--- /dev/null+++ b/core/rust/src/vault_sync/tests/blob_keys.rs@@ -0,0 +1,48 @@+use crate::crypto::{self, aad};+use crate::vault_sync::blob_keys::*;++const MANIFEST: &str = "0a1b2c3d-0000-0000-0000-000000000001";+const HASH: &str = "aa11";++#[test]+fn a_blob_opens_with_the_vek_through_its_own_key() {+ let vek = crypto::generate_key_base64();+ let blob = encrypt_blob(&[1, 2, 3, 4], &vek, MANIFEST, HASH).unwrap();++ assert_eq!(decrypt_blob(&blob, &vek, MANIFEST, HASH).unwrap(), vec![1, 2, 3, 4]);+ assert!(crypto::symmetric_decrypt_bytes(&blob.encrypted_data, &vek).is_err(), "the bytes are not encrypted with the VEK itself");+ assert!(decrypt_blob(&blob, &crypto::generate_key_base64(), MANIFEST, HASH).is_err());+}++#[test]+fn a_blob_does_not_open_at_another_address() {+ let vek = crypto::generate_key_base64();+ let blob = encrypt_blob(&[1, 2, 3, 4], &vek, MANIFEST, HASH).unwrap();+ assert!(decrypt_blob(&blob, &vek, MANIFEST, "bb22").is_err(), "served under another hash");+ assert!(decrypt_blob(&blob, &vek, "0a1b2c3d-0000-0000-0000-000000000002", HASH).is_err(), "served under another manifest");++ // The blob key of one blob next to the bytes of another: neither half opens the other.+ let other = encrypt_blob(&[5, 6], &vek, MANIFEST, "bb22").unwrap();+ let mixed = EncryptedBlob { encrypted_data: other.encrypted_data, encrypted_blob_key: blob.encrypted_blob_key };+ assert!(decrypt_blob(&mixed, &vek, MANIFEST, HASH).is_err());+}++#[test]+fn changing_the_vek_only_encrypts_the_blob_key_again() {+ let (old_vek, new_vek) = (crypto::generate_key_base64(), crypto::generate_key_base64());+ let blob = encrypt_blob(&[9; 64], &old_vek, MANIFEST, HASH).unwrap();++ let key_aad = aad::blob_key(MANIFEST, HASH);+ let blob_key = crypto::unwrap_key(&blob.encrypted_blob_key, &old_vek, &key_aad).unwrap();+ let rekeyed = EncryptedBlob { encrypted_data: blob.encrypted_data.clone(), encrypted_blob_key: crypto::wrap_key(&blob_key, &new_vek, &key_aad).unwrap() };++ assert_eq!(decrypt_blob(&rekeyed, &new_vek, MANIFEST, HASH).unwrap(), vec![9; 64]);+ assert!(decrypt_blob(&rekeyed, &old_vek, MANIFEST, HASH).is_err());+}++#[test]+fn a_cached_blob_reads_back_as_it_was_written() {+ let blob = encrypt_blob(&[5], &crypto::generate_key_base64(), MANIFEST, HASH).unwrap();+ let read: EncryptedBlob = serde_json::from_value(serde_json::to_value(&blob).unwrap()).unwrap();+ assert_eq!(read, blob);+}diff --git a/core/rust/src/vault_sync/tests/db.rs b/core/rust/src/vault_sync/tests/db.rsnew file mode 100644index 000000000..e70a80a2c--- /dev/null+++ b/core/rust/src/vault_sync/tests/db.rs@@ -0,0 +1,10 @@+use crate::vault_sync::db::*;++#[test]+fn ids_are_lowercase_uuid_v4() {+ let id = new_id();+ assert_eq!(id.len(), 36);+ assert_eq!(id, id.to_lowercase());+ assert_eq!(&id[14..15], "4");+ assert!(matches!(&id[19..20], "8" | "9" | "a" | "b"));+}diff --git a/core/rust/src/vault_sync/tests/email_routing.rs b/core/rust/src/vault_sync/tests/email_routing.rsnew file mode 100644index 000000000..cab0a44a1--- /dev/null+++ b/core/rust/src/vault_sync/tests/email_routing.rs@@ -0,0 +1,34 @@+use std::collections::HashMap;++use serde_json::Value;++use crate::vault_codec::Manifest;+use crate::vault_sync::email_routing::*;++fn manifest(id: &str, items: Vec<Value>, fields: Vec<Value>) -> Manifest {+ let mut tables = HashMap::new();+ tables.insert("Items".to_string(), items.into_iter().map(|v| serde_json::from_value(v).unwrap()).collect());+ tables.insert("FieldValues".to_string(), fields.into_iter().map(|v| serde_json::from_value(v).unwrap()).collect());+ Manifest { schema_version: 1, manifest_salt: String::new(), canonicalized_at: String::new(), manifest_id: id.to_string(), name: None, tables, extra: HashMap::new() }+}++#[test]+fn claims_private_addresses_of_live_items_once_per_manifest() {+ let m = manifest(+ "m1",+ vec![serde_json::json!({"Id": "i1", "IsDeleted": 0, "DeletedAt": null}), serde_json::json!({"Id": "i2", "IsDeleted": 0, "DeletedAt": "2026-01-01"})],+ vec![+ serde_json::json!({"ItemId": "i1", "FieldKey": "login.email", "Value": " [email protected] ", "IsDeleted": 0, "IsDisabled": 1}),+ serde_json::json!({"ItemId": "i1", "FieldKey": "login.email", "Value": "[email protected]", "IsDeleted": 0, "IsDisabled": 0}),+ serde_json::json!({"ItemId": "i2", "FieldKey": "login.email", "Value": "[email protected]", "IsDeleted": 0}),+ serde_json::json!({"ItemId": "i1", "FieldKey": "login.email", "Value": "[email protected]", "IsDeleted": 0}),+ ],+ );+ let routing = build_email_routing(&[m], &["private.io".to_string()], &HashMap::from([("m1".to_string(), 7)]));+ assert_eq!(routing.email_address_list.len(), 1);+ assert_eq!(routing.email_address_list[0].address, "[email protected]");+ assert!(!routing.email_address_list[0].paused);+ assert_eq!(routing.covered_manifest_ids, vec!["m1"]);+ assert_eq!(routing.base_revisions.len(), 1);+ assert_eq!(routing.base_revisions[0].revision, 7);+}diff --git a/core/rust/src/vault_sync/tests/engine.rs b/core/rust/src/vault_sync/tests/engine.rsnew file mode 100644index 000000000..0dd160d60--- /dev/null+++ b/core/rust/src/vault_sync/tests/engine.rs@@ -0,0 +1,25 @@+use crate::vault_sync::engine::*;+use crate::vault_sync::errors::{ErrorCode, LogoutReason, SyncError};++#[test]+fn failures_carry_a_code_or_a_logout_reason_never_both() {+ let coded = failure(&SyncError::Timeout("slow".to_string())).failure;+ assert_eq!(coded.error_code, Some(ErrorCode::UploadTimeout));+ assert_eq!(coded.logout_reason, None);+ assert!(!coded.requires_logout);++ let logout = failure(&SyncError::VaultVersionIncompatible("3.0.0".to_string())).failure;+ assert_eq!(logout.logout_reason, Some(LogoutReason::VaultVersionIncompatible));+ assert_eq!(logout.error_code, None);+ assert!(logout.requires_logout);+}++#[test]+fn semver_rules_match_the_client() {+ assert!(version_gte("0.12.0", "0.12.0-dev"));+ assert!(!version_gte("0.12.0-dev", "0.12.0"));+ assert!(version_gte("0.13.1", "0.12.0-dev"));+ assert!(!version_gte("0.11.9", "0.12.0-dev"));+ assert!(version_gte("1.0", "1.0.0"));+ assert!(version_gte("0.12.0-beta", "0.12.0-alpha"));+}diff --git a/core/rust/src/vault_sync/tests/errors.rs b/core/rust/src/vault_sync/tests/errors.rsnew file mode 100644index 000000000..fed76fa6c--- /dev/null+++ b/core/rust/src/vault_sync/tests/errors.rs@@ -0,0 +1,26 @@+use crate::common::error::VaultError;+use crate::vault_sync::errors::*;++#[test]+fn codes_and_reasons_serialize_to_the_client_vocabulary() {+ assert_eq!(serde_json::to_string(&ErrorCode::VaultLocked).unwrap(), "\"E-202\"");+ assert_eq!(serde_json::to_string(&ErrorCode::UploadTimeout).unwrap(), "\"E-805\"");+ assert_eq!(SyncError::VaultDecryptFailed(String::new()).failure(), Failure::Coded(ErrorCode::VaultDecryptFailed));+ assert_eq!(SyncError::UnlockKeyRejected.failure(), Failure::Coded(ErrorCode::UnlockKeyRejected));+ assert_eq!(SyncError::KeyChainUnreadable(String::new()).failure(), Failure::Coded(ErrorCode::KeyChainUnreadable));+ assert_eq!(SyncError::KeyOutOfSync.failure(), Failure::Logout(LogoutReason::PasswordChanged));+ assert_eq!(serde_json::to_string(&LogoutReason::PasswordChanged).unwrap(), "\"passwordChanged\"");+ assert_eq!(SyncError::Auth.failure(), Failure::Logout(LogoutReason::SessionExpired));+ assert_eq!(SyncError::Staging(String::new()).failure(), Failure::Coded(ErrorCode::DatabaseInitFailed));+ assert_eq!(SyncError::Host { command: "dbExec", message: String::new() }.failure(), Failure::Coded(ErrorCode::StorageWriteFailed));+ assert_eq!(SyncError::Host { command: "vaultKey", message: String::new() }.failure(), Failure::Coded(ErrorCode::SyncEngineFailed));+}++#[test]+fn engine_internal_failures_carry_their_own_codes() {+ assert_eq!(SyncError::Other("no rule".to_string()).failure(), Failure::Coded(ErrorCode::SyncEngineFailed));+ assert_eq!(SyncError::Core(VaultError::General("codec".to_string())).failure(), Failure::Coded(ErrorCode::SyncCodecFailed));+ assert_eq!(SyncError::VaultDataRejected("NOT NULL".to_string()).failure(), Failure::Coded(ErrorCode::SyncCodecFailed));+ assert_eq!(serde_json::from_str::<serde_json::Value>("nope").map_err(SyncError::Json).unwrap_err().failure(), Failure::Coded(ErrorCode::SyncResponseInvalid));+ assert_eq!(serde_json::to_string(&ErrorCode::SyncEngineFailed).unwrap(), "\"E-509\"");+}diff --git a/core/rust/src/vault_sync/tests/frame.rs b/core/rust/src/vault_sync/tests/frame.rsnew file mode 100644index 000000000..26810c6a8--- /dev/null+++ b/core/rust/src/vault_sync/tests/frame.rs@@ -0,0 +1,51 @@+use serde_json::{json, Value};++use crate::vault_sync::frame::*;+use crate::vault_sync::types::{BlobDownloadResponse, BlobDto, BlobUploadRequest, GetResponse};++fn frame(header: Value, data: &[u8]) -> Vec<u8> {+ let header = serde_json::to_vec(&header).unwrap();+ [&(header.len() as u32).to_be_bytes()[..], &header, data].concat()+}++#[test]+fn an_upload_keeps_each_ciphertext_out_of_the_json_header() {+ let blob = |hash: &str, bytes: Vec<u8>| BlobDto { hash: hash.to_string(), category: "attachment".to_string(), ciphertext: bytes.into(), encrypted_blob_key: format!("k{}", hash) };+ let mut request = BlobUploadRequest { manifest_id: "m1".to_string(), overwrite: false, blobs: vec![blob("a", vec![1, 2, 3]), blob("b", vec![]), blob("c", vec![4])] };+ let encoded = encode(&mut request).unwrap();++ let header_length = u32::from_be_bytes(encoded[..4].try_into().unwrap()) as usize;+ let header: Value = serde_json::from_slice(&encoded[4..4 + header_length]).unwrap();+ assert_eq!(header["blobs"][0], json!({ "hash": "a", "category": "attachment", "offset": 0, "size": 3, "encryptedBlobKey": "ka" }));+ assert_eq!(&encoded[4 + header_length..], &[1, 2, 3, 4]);++ let decoded: BlobDownloadResponse = decode(&encoded).unwrap();+ assert_eq!(decoded.blobs.iter().map(|b| b.ciphertext.bytes.clone()).collect::<Vec<_>>(), vec![vec![1, 2, 3], vec![], vec![4]]);+}++#[test]+fn a_download_reads_each_part_by_offset_and_skips_what_it_does_not_know() {+ // A newer server: parts in another order, an unknown list with a part of its own, and a part nothing known points at.+ let encoded = frame(+ json!({+ "storageFormat": "manifest",+ "futureList": [{ "offset": 0, "size": 2 }],+ "manifests": [{ "manifestId": "m1", "offset": 5, "size": 3, "futureField": true }, { "manifestId": "m2" }],+ "buckets": [{ "manifestId": "m1", "category": "settings", "offset": 2, "size": 3 }],+ }),+ &[9, 9, 4, 5, 6, 1, 2, 3, 7, 7, 7],+ );+ let snapshot: GetResponse = decode(&encoded).unwrap();+ assert_eq!(snapshot.manifests[0].ciphertext.bytes, vec![1, 2, 3]);+ assert!(!snapshot.manifests[1].has_content());+ assert_eq!(snapshot.buckets[0].ciphertext.bytes, vec![4, 5, 6]);+}++#[test]+fn a_malformed_frame_is_refused() {+ let encoded = frame(json!({ "blobs": [{ "hash": "a", "category": "favicon", "encryptedBlobKey": "ka", "offset": 0, "size": 3 }] }), &[1, 2, 3]);+ assert!(decode::<BlobDownloadResponse>(&encoded).is_ok());+ assert!(decode::<BlobDownloadResponse>(&encoded[..encoded.len() - 1]).is_err(), "a truncated ciphertext");+ assert!(decode::<BlobDownloadResponse>(&[]).is_err(), "no header length");+ assert!(decode::<BlobDownloadResponse>(&[0, 0, 1, 0, b'{']).is_err(), "a header longer than the body");+}diff --git a/core/rust/src/vault_sync/tests/http.rs b/core/rust/src/vault_sync/tests/http.rsnew file mode 100644index 000000000..193ac7d0a--- /dev/null+++ b/core/rust/src/vault_sync/tests/http.rs@@ -0,0 +1,35 @@+use crate::vault_sync::http::*;+use crate::vault_sync::errors::SyncError;+use crate::vault_sync::types::{FailureFields, HttpResponse};++fn response(status: u16, body: &str) -> HttpResponse {+ HttpResponse { status, body: body.to_string(), transport_error: None, timed_out: false }+}++#[test]+fn a_refusal_keeps_the_server_code() {+ let error = check(response(400, r#"{"code":"INVALID_REQUEST","statusCode":400}"#)).unwrap_err();+ assert_eq!(error.api_error_code().as_deref(), Some("INVALID_REQUEST"));+ assert_eq!(FailureFields::from(&error).api_error_code.as_deref(), Some("INVALID_REQUEST"));+}++#[test]+fn a_body_without_a_code_yields_none() {+ assert_eq!(check(response(500, "")).unwrap_err().api_error_code(), None);+ assert_eq!(check(response(502, "<html>Bad gateway</html>")).unwrap_err().api_error_code(), None);+ assert_eq!(check(response(400, r#"{"code":"not a code"}"#)).unwrap_err().api_error_code(), None);+}++#[test]+fn only_an_uncoded_403_ends_the_session() {+ assert!(matches!(check(response(403, "")), Err(SyncError::Auth)));+ let refused = check(response(403, r#"{"code":"CAPABILITY_NOT_AVAILABLE","statusCode":403}"#)).unwrap_err();+ assert_eq!(refused.api_error_code().as_deref(), Some("CAPABILITY_NOT_AVAILABLE"));+}++#[test]+fn only_an_uncoded_404_means_an_outdated_server() {+ assert!(matches!(with_outdated_server_guard::<()>(check(response(404, "")).map(|_| ())), Err(SyncError::ServerUpdateRequired)));+ let coded = with_outdated_server_guard::<()>(check(response(404, r#"{"code":"SHARED_MANIFEST_NOT_FOUND","statusCode":404}"#)).map(|_| ())).unwrap_err();+ assert_eq!(coded.api_error_code().as_deref(), Some("SHARED_MANIFEST_NOT_FOUND"));+}diff --git a/core/rust/src/vault_sync/tests/keys.rs b/core/rust/src/vault_sync/tests/keys.rsindex ad0f04c30..d94ec1d2e 100644--- a/core/rust/src/vault_sync/tests/keys.rs+++ b/core/rust/src/vault_sync/tests/keys.rs@@ -32,11 +32,13 @@ fn resolve_vault_key_opens_the_chain_from_the_server() {assert_eq!(host.state[state::ENCRYPTED_SIGNING_PRIVATE_KEY], hierarchy.account_keys.encrypted_signing_private_key);assert!(host.store_calls.is_empty(), "resolving a key never touches the stored vault");- // A device that stores the Account Key (Login with Mobile) resolves with it as well as with the unlock key.+ // The operation takes the unlock key only: the Account Key itself is refused, never tried as a fallback.let account_key = crypto::unwrap_account_key(&hierarchy.account_keys.encrypted_account_key, &unlock_key).unwrap();let mut host = TestHost::new(&account_key);host.serve(&server);- assert_eq!(host.run("resolveVaultKey")["encryptionKey"], hierarchy.vault_encryption_key);+ let result = host.run("resolveVaultKey");+ assert_eq!(result["success"], false, "{}", result);+ assert_eq!(result["errorCode"], "E-206");}/// A legacy account has no chain: the password-derived key is the vault key and any stale cached chain is dropped.diff --git a/core/rust/src/vault_sync/tests/legacy.rs b/core/rust/src/vault_sync/tests/legacy.rsnew file mode 100644index 000000000..fb322b132--- /dev/null+++ b/core/rust/src/vault_sync/tests/legacy.rs@@ -0,0 +1,16 @@+use crate::vault_sync::errors::SyncError;+use crate::vault_sync::legacy::*;++#[test]+fn migration_stamps_map_onto_the_frozen_chain() {+ assert_eq!(extract_version_from_migration_id("20250101000000_2.0.0-Squashed").as_deref(), Some("2.0.0"));+ assert_eq!(extract_version_from_migration_id("20250101000000_Initial"), None);+ assert_eq!(legacy_revision_for("1.7.0"), Ok(12));+ assert_eq!(legacy_revision_for("2.1.0"), Ok(13), "an unknown but well-formed version reads as the latest");+ assert!(legacy_revision_for("nope").is_err());++ assert!(stamp_predates_manifest_schema("20250101000000_1.7.0-Old").unwrap());+ assert!(!stamp_predates_manifest_schema("20250101000000_2.0.0-Squashed").unwrap());+ assert!(!stamp_predates_manifest_schema("20260101000000_2.1.0-Later").unwrap());+ assert!(matches!(stamp_predates_manifest_schema("20250101000000_Initial"), Err(SyncError::Other(_))));+}diff --git a/core/rust/src/vault_sync/tests/migration.rs b/core/rust/src/vault_sync/tests/migration.rsindex 11f5a5b0f..bfdc027f1 100644--- a/core/rust/src/vault_sync/tests/migration.rs+++ b/core/rust/src/vault_sync/tests/migration.rs@@ -40,7 +40,7 @@ fn manifest_migration_generates_the_key_hierarchy_and_pushes() {let account_keys = &write["migration"]["accountKeys"];assert!(account_keys["encryptedAccountKey"].is_string(), "the migration push carries the key hierarchy");assert!(crypto::unwrap_key(account_keys["encryptedAccountKey"].as_str().unwrap(), &unlock_key, crypto::aad::ACCOUNT_KEY).is_err(), "the legacy vault key does not wrap the Account Key directly");- let opened = crypto::open_account_key_chain(&unlock_key, account_keys["encryptedAccountKey"].as_str().unwrap(), account_keys["encryptedVek"].as_str().unwrap(), None).unwrap();+ let opened = crypto::open_key_chain_with_unlock_key(&unlock_key, account_keys["encryptedAccountKey"].as_str().unwrap(), account_keys["encryptedVek"].as_str().unwrap(), None).unwrap();assert_eq!(*opened.vault_encryption_key, new_key);let signed = crypto::signing::account_public_key_message(account_keys["accountPublicKey"].as_str().unwrap());assert!(crypto::signing::verify(account_keys["signingPublicKey"].as_str().unwrap(), &signed, account_keys["accountPublicKeySignature"].as_str().unwrap()), "the upgrade push carries a signing key that signed the account public key");diff --git a/core/rust/src/vault_sync/tests/mod.rs b/core/rust/src/vault_sync/tests/mod.rsindex 3c4b6f1ea..d96710c8e 100644--- a/core/rust/src/vault_sync/tests/mod.rs+++ b/core/rust/src/vault_sync/tests/mod.rs@@ -1,7 +1,8 @@//! Engine tests: the whole sync driven through the command loop, one real SQLite host per device against an//! in-process model of the v2 server. A test reads as "the server holds X, the device does Y, sync, assert".//!-//! `fake_server` is the server, `test_host` is a device, this module holds the row fixtures they share.+//! `fake_server` is the server, `test_host` is a device, this module holds the row fixtures they share. The second+//! group of modules holds the unit tests of the `vault_sync` module of the same name.mod blobs;mod fake_server;@@ -13,6 +14,17 @@ mod migration;mod sync;mod test_host;+mod blob_keys;+mod db;+mod email_routing;+mod engine;+mod errors;+mod frame;+mod http;+mod legacy;+mod types;+mod write_set;+use rusqlite::Connection;use serde_json::json;@@ -22,7 +34,7 @@ use crate::crypto;use crate::vault_codec;use crate::vault_sync::state;-pub(crate) use crate::vault_codec::test_support::{PERSONAL_MANIFEST_ID, SHARED_MANIFEST_ID};+pub(crate) use crate::vault_codec::tests::support::{PERSONAL_MANIFEST_ID, SHARED_MANIFEST_ID};pub const ITEM_A: &str = "aaaaaaaa-0000-4000-8000-000000000001";pub const ITEM_B: &str = "aaaaaaaa-0000-4000-8000-000000000002";pub const ITEM_C: &str = "aaaaaaaa-0000-4000-8000-000000000003";diff --git a/core/rust/src/vault_sync/tests/types.rs b/core/rust/src/vault_sync/tests/types.rsnew file mode 100644index 000000000..af47ffede--- /dev/null+++ b/core/rust/src/vault_sync/tests/types.rs@@ -0,0 +1,25 @@+use crate::vault_sync::errors::{LogoutReason, SyncError};+use crate::vault_sync::types::*;++/// The failure fields flatten into the top level of every result.+#[test]+fn failure_fields_flatten_into_the_result_wire_shape() {+ let coded = FailureFields::from(&SyncError::VaultLocked);+ let full = serde_json::to_string(&FullSyncResult { failure: coded, ..Default::default() }).unwrap();+ assert_eq!(full, r#"{"success":false,"hasNewVault":false,"wasOffline":false,"sqliteBlobUpgradeRequired":false,"manifestMigrationRequired":false,"error":"No encryption key available","errorCode":"E-202","requiresLogout":false,"isOfflineMode":false}"#);+ let round_trip: FullSyncResult = serde_json::from_str(&full).unwrap();+ assert_eq!(serde_json::to_string(&round_trip).unwrap(), full);++ let logout = FailureFields::logout(LogoutReason::SessionExpired);+ let migrate = serde_json::to_string(&MigrateManifestResult { failure: logout.clone(), ..Default::default() }).unwrap();+ assert_eq!(migrate, r#"{"success":false,"pushed":false,"logoutReason":"sessionExpired","requiresLogout":true}"#);+ let round_trip: MigrateManifestResult = serde_json::from_str(&migrate).unwrap();+ assert_eq!(round_trip.failure, logout);++ let status = serde_json::to_value(StatusCheckResult { failure: logout.clone(), ..Default::default() }).unwrap();+ assert_eq!(status["logoutReason"], "sessionExpired");+ assert_eq!(status["requiresLogout"], true);+ assert!(status.get("error").is_none() && status.get("errorCode").is_none() && status.get("failure").is_none());+ let round_trip: StatusCheckResult = serde_json::from_value(status.clone()).unwrap();+ assert_eq!(serde_json::to_value(&round_trip).unwrap(), status);+}diff --git a/core/rust/src/vault_sync/tests/write_set.rs b/core/rust/src/vault_sync/tests/write_set.rsnew file mode 100644index 000000000..5a0e567c7--- /dev/null+++ b/core/rust/src/vault_sync/tests/write_set.rs@@ -0,0 +1,34 @@+use std::collections::HashMap;++use secrecy::{ExposeSecret, SecretString};++use crate::vault_sync::types::SharedManifestDto;+use crate::vault_sync::write_set::*;++fn held(ids: &[&str]) -> HashMap<String, SharedManifestDto> {+ ids.iter().map(|id| (id.to_string(), SharedManifestDto { manifest_id: id.to_string(), encrypted_vek: String::new(), account_public_key: String::new(), algorithm: String::new(), salt: format!("salt-{}", id), encrypted_name: None, can_administer: true, key_version: 0 })).collect()+}++fn opened(ids: &[&str]) -> HashMap<String, SecretString> {+ ids.iter().map(|id| (id.to_string(), SecretString::from(format!("vek-{}", id)))).collect()+}++fn strings(ids: &[&str]) -> Vec<String> {+ ids.iter().map(|id| id.to_string()).collect()+}++#[test]+fn the_write_set_leads_with_the_personal_manifest_and_names_what_it_left_out() {+ let (records, skipped) = resolve_write_set("PERSONAL", "personal-salt", &strings(&["PERSONAL", "man-1", "MAN-3"]), &opened(&["MAN-1", "MAN-2"]), &held(&["MAN-1", "MAN-2", "MAN-3"]));++ let written: Vec<(&str, bool, &str, Option<&str>)> = records.iter().map(|r| (r.manifest_id.as_str(), r.is_personal, r.salt.as_str(), r.vek.as_ref().map(|vek| vek.expose_secret()))).collect();+ assert_eq!(written, vec![("PERSONAL", true, "personal-salt", None), ("MAN-1", false, "salt-MAN-1", Some("vek-MAN-1"))], "ids match regardless of casing and the record's own spelling comes back");+ assert!(!records[0].can_administer, "a personal manifest is not administered through a group");+ assert_eq!(skipped, vec![("MAN-2".to_string(), SkipReason::NoRowsInVault), ("MAN-3".to_string(), SkipReason::KeyDidNotOpen)]);+}++#[test]+fn rows_of_a_manifest_this_session_cannot_write_are_reported() {+ assert_eq!(unwritable_manifests(&strings(&["PERSONAL", "MAN-1", "MAN-GONE"]), &strings(&["personal", "man-1"])), vec!["MAN-GONE".to_string()]);+ assert!(unwritable_manifests(&strings(&["PERSONAL"]), &strings(&["PERSONAL"])).is_empty());+}diff --git a/core/rust/src/vault_sync/types.rs b/core/rust/src/vault_sync/types.rsindex 5a403f17e..c70698ebd 100644--- a/core/rust/src/vault_sync/types.rs+++ b/core/rust/src/vault_sync/types.rs@@ -835,31 +835,3 @@ pub struct SharedManifestDto {#[serde(default)]pub key_version: i64,}--#[cfg(test)]-mod tests {- use super::*;-- /// The failure fields flatten into the top level of every result.- #[test]- fn failure_fields_flatten_into_the_result_wire_shape() {- let coded = FailureFields::from(&SyncError::VaultLocked);- let full = serde_json::to_string(&FullSyncResult { failure: coded, ..Default::default() }).unwrap();- assert_eq!(full, r#"{"success":false,"hasNewVault":false,"wasOffline":false,"sqliteBlobUpgradeRequired":false,"manifestMigrationRequired":false,"error":"No encryption key available","errorCode":"E-202","requiresLogout":false,"isOfflineMode":false}"#);- let round_trip: FullSyncResult = serde_json::from_str(&full).unwrap();- assert_eq!(serde_json::to_string(&round_trip).unwrap(), full);-- let logout = FailureFields::logout(LogoutReason::SessionExpired);- let migrate = serde_json::to_string(&MigrateManifestResult { failure: logout.clone(), ..Default::default() }).unwrap();- assert_eq!(migrate, r#"{"success":false,"pushed":false,"logoutReason":"sessionExpired","requiresLogout":true}"#);- let round_trip: MigrateManifestResult = serde_json::from_str(&migrate).unwrap();- assert_eq!(round_trip.failure, logout);-- let status = serde_json::to_value(StatusCheckResult { failure: logout.clone(), ..Default::default() }).unwrap();- assert_eq!(status["logoutReason"], "sessionExpired");- assert_eq!(status["requiresLogout"], true);- assert!(status.get("error").is_none() && status.get("errorCode").is_none() && status.get("failure").is_none());- let round_trip: StatusCheckResult = serde_json::from_value(status.clone()).unwrap();- assert_eq!(serde_json::to_value(&round_trip).unwrap(), status);- }-}diff --git a/core/rust/src/vault_sync/write_set.rs b/core/rust/src/vault_sync/write_set.rsindex a5401d3e7..4e2ec2c3c 100644--- a/core/rust/src/vault_sync/write_set.rs+++ b/core/rust/src/vault_sync/write_set.rs@@ -51,37 +51,3 @@ pub(crate) fn resolve_write_set(personal_manifest_id: &str, personal_salt: &str,pub(crate) fn unwritable_manifests(in_vault: &[String], writable: &[String]) -> Vec<String> {in_vault.iter().filter(|id| !writable.iter().any(|w| id_key(w) == id_key(id))).cloned().collect()}--#[cfg(test)]-mod tests {- use super::*;- use secrecy::ExposeSecret;-- fn held(ids: &[&str]) -> HashMap<String, SharedManifestDto> {- ids.iter().map(|id| (id.to_string(), SharedManifestDto { manifest_id: id.to_string(), encrypted_vek: String::new(), account_public_key: String::new(), algorithm: String::new(), salt: format!("salt-{}", id), encrypted_name: None, can_administer: true, key_version: 0 })).collect()- }-- fn opened(ids: &[&str]) -> HashMap<String, SecretString> {- ids.iter().map(|id| (id.to_string(), SecretString::from(format!("vek-{}", id)))).collect()- }-- fn strings(ids: &[&str]) -> Vec<String> {- ids.iter().map(|id| id.to_string()).collect()- }-- #[test]- fn the_write_set_leads_with_the_personal_manifest_and_names_what_it_left_out() {- let (records, skipped) = resolve_write_set("PERSONAL", "personal-salt", &strings(&["PERSONAL", "man-1", "MAN-3"]), &opened(&["MAN-1", "MAN-2"]), &held(&["MAN-1", "MAN-2", "MAN-3"]));-- let written: Vec<(&str, bool, &str, Option<&str>)> = records.iter().map(|r| (r.manifest_id.as_str(), r.is_personal, r.salt.as_str(), r.vek.as_ref().map(|vek| vek.expose_secret()))).collect();- assert_eq!(written, vec![("PERSONAL", true, "personal-salt", None), ("MAN-1", false, "salt-MAN-1", Some("vek-MAN-1"))], "ids match regardless of casing and the record's own spelling comes back");- assert!(!records[0].can_administer, "a personal manifest is not administered through a group");- assert_eq!(skipped, vec![("MAN-2".to_string(), SkipReason::NoRowsInVault), ("MAN-3".to_string(), SkipReason::KeyDidNotOpen)]);- }-- #[test]- fn rows_of_a_manifest_this_session_cannot_write_are_reported() {- assert_eq!(unwritable_manifests(&strings(&["PERSONAL", "MAN-1", "MAN-GONE"]), &strings(&["personal", "man-1"])), vec!["MAN-GONE".to_string()]);- assert!(unwritable_manifests(&strings(&["PERSONAL"]), &strings(&["PERSONAL"])).is_empty());- }-}