Skip to content

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.ts
index 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.ts
index 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.rs
similarity index 100%
rename from core/rust/src/credential_matcher/tests.rs
rename to core/rust/src/credential_matcher/tests/mod.rs
diff --git a/core/rust/src/crypto/aad.rs b/core/rust/src/crypto/aad.rs
index 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.rs
index 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], setti
let 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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) -> Vau
fn 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
similarity index 100%
rename from core/rust/src/email_parser/tests.rs
rename to core/rust/src/email_parser/tests/mod.rs
diff --git a/core/rust/src/favicon/mod.rs b/core/rust/src/favicon/mod.rs
index 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.rs
new file mode 100644
index 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.rs
similarity index 100%
rename from core/rust/src/identity_generator/tests.rs
rename to core/rust/src/identity_generator/tests/mod.rs
diff --git a/core/rust/src/passkey/tests.rs b/core/rust/src/passkey/tests/mod.rs
similarity index 100%
rename from core/rust/src/passkey/tests.rs
rename to core/rust/src/passkey/tests/mod.rs
diff --git a/core/rust/src/password_generator/tests.rs b/core/rust/src/password_generator/tests/mod.rs
similarity index 100%
rename from core/rust/src/password_generator/tests.rs
rename to core/rust/src/password_generator/tests/mod.rs
diff --git a/core/rust/src/totp/tests.rs b/core/rust/src/totp/tests/mod.rs
similarity index 100%
rename from core/rust/src/totp/tests.rs
rename to core/rust/src/totp/tests/mod.rs
diff --git a/core/rust/src/vault_codec/compress.rs b/core/rust/src/vault_codec/compress.rs
index 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.rs
index 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.rs
index 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.rs
index 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) -> String
if 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
similarity index 98%
rename from core/rust/src/vault_codec/tests.rs
rename to core/rust/src/vault_codec/tests/mod.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
similarity index 99%
rename from core/rust/src/vault_codec/sharing_tests.rs
rename to core/rust/src/vault_codec/tests/sharing.rs
index 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.rs
similarity index 96%
rename from core/rust/src/vault_codec/test_support.rs
rename to core/rust/src/vault_codec/tests/support.rs
index 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.rs
similarity index 100%
rename from core/rust/src/vault_items/tests.rs
rename to core/rust/src/vault_items/tests/mod.rs
diff --git a/core/rust/src/vault_merge/tests.rs b/core/rust/src/vault_merge/tests/mod.rs
similarity index 99%
rename from core/rust/src/vault_merge/tests.rs
rename to core/rust/src/vault_merge/tests/mod.rs
index 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.rs
similarity index 98%
rename from core/rust/src/vault_pruner/tests.rs
rename to core/rust/src/vault_pruner/tests/mod.rs
index 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.rs
index 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.rs
index 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) -> SyncResu
exec(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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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: Ht
frame::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.rs
index 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.rs
index 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<b
let 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
new file mode 100644
index 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.rs
index 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.rs
index 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());
- }
-}