Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
//! The sync flow: pull, push, the no-op and outdated paths, and how a session ends.
use serde_json::{json, Value};
use super::fake_server::{decrypt_manifest, FakeServer};
use super::test_host::{request_json, TestHost, USERNAME};
use super::{active_delivery_keys, insert_item, insert_item_stats, rename_item, server_with_item, state, synced, ITEM_A, ITEM_B, ITEM_C, PERSONAL_MANIFEST_ID};
use crate::crypto;
use crate::vault_codec;
use crate::vault_sync::session::SyncSession;
/// The install ids the stats tests record uses under.
const THIS_DEVICE: &str = "6f1c1a2e-3b4d-4c5e-8f60-718293a4b5c6";
const OTHER_DEVICE: &str = "0a9b8c7d-6e5f-4a3b-9c2d-1e0f2a3b4c5d";
#[test]
fn fresh_client_pulls_and_materializes_the_server_vault() {
let vek = crypto::aes_gcm::generate_key();
let server = server_with_item(&vek);
let mut host = TestHost::logged_in(&vek, &server);
let result = host.sync();
assert_eq!(result["success"], true, "{}", result);
assert_eq!(result["hasNewVault"], true);
assert_eq!(result["vaultChanged"], true);
assert_eq!(result["pulledRevision"], 7);
assert_eq!(result["serverVersion"], "0.31.0");
assert_eq!(result["manifestMigrationRequired"], false);
assert_eq!(host.item_names(), vec!["Server item"]);
assert_eq!(host.state[state::SERVER_MANIFEST_REVISIONS][PERSONAL_MANIFEST_ID], 7);
assert_eq!(host.state[state::VAULT_PERSONAL_MANIFEST_ID], PERSONAL_MANIFEST_ID);
// Pinned: the persisted state key formats, which a stored vault from an earlier build must still match.
let keys = |name: &str| -> Vec<String> { host.state[name].as_object().unwrap().keys().cloned().collect::<std::collections::BTreeSet<_>>().into_iter().collect() };
let p = PERSONAL_MANIFEST_ID;
assert_eq!(keys(state::VAULT_CONTENT_FINGERPRINTS), vec![format!("bucket:{p}:settings"), format!("bucket:{p}:stats"), format!("manifest:{p}")]);
assert_eq!(keys(state::VAULT_BUCKET_REVISIONS), vec![format!("{p}:settings"), format!("{p}:stats")]);
assert_eq!(host.request_log(), vec!["GET Status", "GET Vault"]);
server.borrow().assert_converged(&host);
}
#[test]
fn new_account_starts_from_an_empty_vault_and_writes_its_first_revision() {
let vek = crypto::aes_gcm::generate_key();
let server = FakeServer::new();
server.borrow_mut().publish_contentless_personal(0);
let mut host = TestHost::logged_in(&vek, &server);
let result = host.sync();
assert_eq!(result["success"], true, "{}", result);
assert_eq!(result["hasNewVault"], true);
assert!(host.item_names().is_empty());
assert_eq!(host.vault_writes().len(), 1, "the new vault is written once");
let write = host.last_vault_write();
assert_eq!(write["manifests"][0]["manifestId"], PERSONAL_MANIFEST_ID);
assert_eq!(write["manifests"][0]["currentRevision"], 0);
assert_eq!(host.state[state::SERVER_MANIFEST_REVISIONS][PERSONAL_MANIFEST_ID], 1);
assert!(!host.is_dirty);
// The written manifest opens with the VEK and names the personal manifest.
let manifest = decrypt_manifest(write["manifests"][0]["manifestBlob"].as_str().unwrap(), &vek, PERSONAL_MANIFEST_ID);
assert_eq!(manifest["manifestId"], PERSONAL_MANIFEST_ID);
assert_eq!(manifest["manifestSalt"], host.state[state::VAULT_MANIFEST_SALT]);
server.borrow().assert_converged(&host);
}
#[test]
fn new_account_whose_first_write_fails_retries_it_on_the_next_sync() {
let vek = crypto::aes_gcm::generate_key();
let server = FakeServer::new();
server.borrow_mut().publish_contentless_personal(0);
server.borrow_mut().faults.drop_writes = true;
let mut host = TestHost::logged_in(&vek, &server);
// The write never gets an answer: the vault stays dirty and the sync goes offline on the stored empty vault.
let result = host.sync();
assert_eq!(result["success"], true, "{}", result);
assert!(host.is_dirty, "the unwritten new vault stays dirty");
server.borrow_mut().faults.drop_writes = false;
let result = host.sync();
assert_eq!(result["success"], true, "{}", result);
assert_eq!(host.last_vault_write()["manifests"][0]["currentRevision"], 0);
assert_eq!(host.state[state::SERVER_MANIFEST_REVISIONS][PERSONAL_MANIFEST_ID], 1);
assert!(!host.is_dirty);
}
#[test]
fn contentless_personal_manifest_past_revision_zero_is_refused() {
let server = FakeServer::new();
server.borrow_mut().publish_contentless_personal(4);
let mut host = TestHost::logged_in(&crypto::aes_gcm::generate_key(), &server);
let result = host.sync();
assert_eq!(result["success"], false, "{}", result);
assert!(host.vault_writes().is_empty(), "nothing is written over a damaged manifest");
assert!(host.store_calls.is_empty());
}
#[test]
fn unknown_storage_format_is_refused_not_read_as_legacy() {
let vek = crypto::aes_gcm::generate_key();
let server = server_with_item(&vek);
let mut vault = server.borrow().vault();
vault["storageFormat"] = json!("manifest-v2");
let mut host = TestHost::logged_in(&vek, &server);
host.respond("GET", "Vault", vault);
let result = host.sync();
assert_eq!(result["success"], false, "{}", result);
assert_eq!(result["logoutReason"], "vaultVersionIncompatible", "an app too old for the format is told to update");
assert!(host.item_names().is_empty(), "nothing is materialized");
assert!(host.vault_writes().is_empty(), "no legacy migration push");
}
#[test]
fn clean_client_in_sync_does_nothing() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
let result = s.host.sync();
assert_eq!(result["success"], true, "{}", result);
assert_eq!(result["hasNewVault"], false);
assert_eq!(s.host.request_log(), vec!["GET Status"]);
assert!(s.host.store_calls.is_empty());
}
#[test]
fn dirty_client_pushes_only_what_changed() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
s.host.edit(|db| insert_item(db, ITEM_B, "Local item"));
let result = s.host.sync();
assert_eq!(result["success"], true, "{}", result);
let writes = s.host.vault_writes();
assert_eq!(writes.len(), 1, "one write expected");
let write = &writes[0];
assert_eq!(write["username"], USERNAME);
assert_eq!(write["manifests"].as_array().unwrap().len(), 1, "only the personal manifest changed");
assert_eq!(write["manifests"][0]["currentRevision"], 7);
assert_eq!(write["manifests"][0]["credentialsCount"], 2);
assert_eq!(write["buckets"].as_array().unwrap().len(), 0, "unchanged buckets stay out of the write");
assert_eq!(write["emailRouting"]["coveredManifestIds"][0], PERSONAL_MANIFEST_ID);
assert_eq!(write["emailRouting"]["baseRevisions"][0]["revision"], 7, "routing carries the revision it was built from");
assert_eq!(s.host.state[state::SERVER_MANIFEST_REVISIONS][PERSONAL_MANIFEST_ID], 8);
assert_eq!(s.host.mark_clean_calls, vec![1]);
assert!(!s.host.is_dirty);
// The written manifest decrypts with the VEK and carries both items.
let manifest = s.server.borrow().open_personal(&s.vek);
assert_eq!(manifest["tables"]["Items"].as_array().unwrap().len(), 2);
s.server.borrow().assert_converged(&s.host);
}
/// Give an item a login email.
fn set_login_email(db: &rusqlite::Connection, item_id: &str, email: &str) {
db.execute("INSERT INTO FieldValues (ManifestId, Id, ItemId, FieldKey, Value, Weight, ValueIndex, CreatedAt, UpdatedAt, IsDeleted) VALUES (?1, ?2, ?3, 'login.email', ?4, 0, 0, ?5, ?5, 0)", (PERSONAL_MANIFEST_ID, crate::vault_sync::db::new_id(), item_id, email, super::now())).unwrap();
}
#[test]
fn push_routes_with_the_domains_from_status() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
s.server.borrow_mut().email_domains = json!({ "privateEmailDomainList": ["private.io", "legacy.io"], "hiddenPrivateEmailDomainList": ["legacy.io"], "publicEmailDomainList": [] });
// The request still carries the domains of the last pull, which lack legacy.io.
s.host.edit(|db| {
insert_item(db, ITEM_B, "Legacy alias");
set_login_email(db, ITEM_B, "[email protected]");
});
let result = s.host.sync();
assert_eq!(result["success"], true, "{}", result);
let write = s.host.last_vault_write();
assert_eq!(write["emailRouting"]["emailAddressList"][0]["address"], "[email protected]", "a hidden domain still routes");
assert_eq!(result["emailDomains"]["hiddenPrivateEmailDomainList"], json!(["legacy.io"]), "the host is handed the current domains");
}
#[test]
fn status_check_reports_the_email_domains() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
s.server.borrow_mut().email_domains = json!({ "privateEmailDomainList": ["private.io"], "hiddenPrivateEmailDomainList": [], "publicEmailDomainList": ["spamok.com"] });
let result = s.host.run("statusCheck");
assert_eq!(result["success"], true, "{}", result);
assert_eq!(result["emailDomains"]["publicEmailDomainList"], json!(["spamok.com"]));
}
#[test]
fn no_op_mutation_clears_the_dirty_flag_without_a_write() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
// Marked dirty, nothing actually changed.
s.host.edit(|_| {});
let result = s.host.sync();
assert_eq!(result["success"], true, "{}", result);
assert!(s.host.vault_writes().is_empty(), "no write for a no-op mutation");
assert_eq!(s.host.mark_clean_calls, vec![1]);
assert!(!s.host.is_dirty);
}
#[test]
fn push_creates_and_publishes_a_missing_personal_delivery_key() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
assert!(active_delivery_keys(&s.host.local, PERSONAL_MANIFEST_ID).is_empty());
s.host.edit(|db| rename_item(db, "Renamed"));
let result = s.host.sync();
assert_eq!(result["success"], true, "{}", result);
let keys = active_delivery_keys(&s.host.local, PERSONAL_MANIFEST_ID);
assert_eq!(keys.len(), 1, "the push created exactly one keypair");
let write = s.host.last_vault_write();
assert_eq!(write["manifests"][0]["deliveryPublicKey"], json!(keys[0]), "the write publishes the new public key");
assert_eq!(write["manifests"][0]["deliveryPublicKeyAlgorithm"], json!("rsa-oaep-sha256"), "the write states the key's algorithm");
// The keypair travels inside the manifest (so other devices get the private half) and sits in the stored vault.
assert_eq!(s.server.borrow().open_personal(&s.vek)["tables"]["EncryptionKeys"].as_array().unwrap().len(), 1);
assert_eq!(active_delivery_keys(&s.host.stored_vault(), PERSONAL_MANIFEST_ID), keys);
// The next push keeps the same keypair.
s.host.edit(|db| rename_item(db, "Renamed again"));
let again = s.host.sync();
assert_eq!(again["success"], true, "{}", again);
assert_eq!(active_delivery_keys(&s.host.local, PERSONAL_MANIFEST_ID), keys);
assert_eq!(s.host.last_vault_write()["manifests"][0]["deliveryPublicKey"], json!(keys[0]));
}
#[test]
fn bucket_only_push_writes_the_manifest_while_the_personal_delivery_key_is_missing() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
let category = vault_codec::bucket_layout()[0].category.clone();
s.host.edit(|db| insert_item_stats(db, ITEM_A, THIS_DEVICE, 1));
let result = s.host.sync_scoped(&[category.as_str()]);
assert_eq!(result["success"], true, "{}", result);
let keys = active_delivery_keys(&s.host.local, PERSONAL_MANIFEST_ID);
assert_eq!(keys.len(), 1);
assert_eq!(s.host.last_vault_write()["manifests"][0]["deliveryPublicKey"], json!(keys[0]), "the full write publishes the key a bucket-only write could not");
}
#[test]
fn outdated_push_merges_the_server_change_and_retries() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
// Another device adds an item on the server (revision 8) after this one's status check, while this one adds a different item.
let stale_status = s.server.borrow().status();
insert_item(&s.db, ITEM_C, "Other device item");
s.publish(8);
s.host.respond_once("GET", "Status", stale_status);
s.host.edit(|db| insert_item(db, ITEM_B, "Local item"));
let result = s.host.sync();
assert_eq!(result["success"], true, "{}", result);
assert_eq!(result["hasNewVault"], true);
assert_eq!(s.host.item_names(), vec!["Local item", "Other device item", "Server item"]);
assert_eq!(s.host.state[state::SERVER_MANIFEST_REVISIONS][PERSONAL_MANIFEST_ID], 9);
let writes = s.host.vault_writes();
assert_eq!(writes.len(), 2, "the refused write and the one after the merge");
assert_eq!(writes[0]["manifests"][0]["currentRevision"], 7);
assert_eq!(writes[1]["manifests"][0]["currentRevision"], 8);
assert_eq!(s.server.borrow().open_personal(&s.vek)["tables"]["Items"].as_array().unwrap().len(), 3);
s.server.borrow().assert_converged(&s.host);
}
#[test]
fn outdated_bucket_only_push_merges_the_server_bucket_instead_of_overwriting_it() {
let mut s = synced(|db| {
insert_item(db, ITEM_A, "Item A");
insert_item(db, ITEM_B, "Item B");
});
// Another device writes the stats of item B after this client's status check, while this one used item A.
let stale_status = s.server.borrow().status();
insert_item_stats(&s.db, ITEM_B, OTHER_DEVICE, 5);
s.publish(8);
s.host.respond_once("GET", "Status", stale_status);
s.host.edit(|db| insert_item_stats(db, ITEM_A, THIS_DEVICE, 1));
let result = s.host.sync_scoped(&["stats"]);
assert_eq!(result["success"], true, "{}", result);
let writes = s.host.vault_writes();
assert_eq!(writes.len(), 2);
assert_eq!(writes[0]["buckets"][0]["currentRevision"], 7);
assert_eq!(writes[1]["buckets"][0]["currentRevision"], 8);
let bucket = s.server.borrow().open_bucket("stats", &s.vek);
assert_eq!(bucket["tables"]["ItemStats"].as_array().unwrap().len(), 2, "the other device's stats must survive: {}", bucket);
let tail: Vec<String> = s.host.request_log().into_iter().rev().take(4).rev().collect();
assert_eq!(tail, vec!["POST Vault", "GET Status", "GET Vault", "POST Vault"], "the refused write must be followed by a pull before the next attempt");
// The first attempt created the missing delivery keypair; the write after the merge carries it although the host
// only recorded a bucket scope, so the server ends up with everything the merge changed.
assert_eq!(writes[1]["manifests"].as_array().unwrap().len(), 1);
s.server.borrow().assert_converged(&s.host);
}
#[test]
fn a_mutation_during_a_pull_is_merged_by_the_next_round_instead_of_refusing_every_store() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
// Another device adds an item, and this one saves an item while its sync pulls that change.
insert_item(&s.db, ITEM_C, "Other device item");
s.publish(8);
s.host.edit_before_next_sync_store = Some(Box::new(|db| insert_item(db, ITEM_B, "Local item")));
let result = s.host.sync();
assert_eq!(result["success"], true, "{}", result);
assert_eq!(s.host.item_names(), vec!["Local item", "Other device item", "Server item"]);
assert_eq!(s.host.vault_writes().len(), 1, "the merged vault is written once");
assert!(!s.host.is_dirty, "the raced change reached the server");
s.server.borrow().assert_converged(&s.host);
}
#[test]
fn a_write_the_server_keeps_refusing_gives_up_after_three_resyncs() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
s.server.borrow_mut().faults.refuse_writes = 10;
s.host.edit(|db| insert_item(db, ITEM_B, "Local item"));
let result = s.host.sync();
assert_eq!(result["success"], false, "{}", result);
assert_eq!(result["errorCode"], "E-702");
assert_eq!(s.host.vault_writes().len(), 4, "the first attempt plus three re-syncs");
assert!(s.host.is_dirty, "the local change is kept for the next sync");
}
#[test]
fn unreachable_server_with_a_local_vault_goes_offline() {
let mut host = TestHost::new(&crypto::aes_gcm::generate_key());
host.store_local_as_blob();
let result = host.sync();
assert_eq!(result["success"], true, "{}", result);
assert_eq!(result["wasOffline"], true);
assert_eq!(result["isOfflineMode"], true);
}
#[test]
fn expired_session_requires_logout() {
let server = FakeServer::new();
server.borrow_mut().faults.status_http = Some(401);
let mut host = TestHost::logged_in(&crypto::aes_gcm::generate_key(), &server);
let result = host.sync();
assert_eq!(result["success"], false);
assert_eq!(result["requiresLogout"], true);
assert_eq!(result["logoutReason"], "sessionExpired");
}
#[test]
fn password_changed_elsewhere_requires_logout() {
let server = FakeServer::new();
server.borrow_mut().srp_salt = "new-salt".to_string();
let mut host = TestHost::logged_in(&crypto::aes_gcm::generate_key(), &server);
host.set_state(state::UNLOCK_KEY_DERIVATION_PARAMS, json!({ "salt": "old-salt", "encryptionType": "Argon2Id", "encryptionSettings": "{}" }));
let result = host.sync();
assert_eq!(result["requiresLogout"], true);
assert_eq!(result["logoutReason"], "passwordChanged");
}
#[test]
fn a_write_the_server_refuses_for_a_missing_key_chain_requires_logout() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
s.host.responders.insert(0, Box::new(|m, p, _| if m == "POST" && p == "Vault" { Some((400, json!({ "code": "VAULT_KEY_NOT_FOUND", "statusCode": 400 }))) } else { None }));
s.host.edit(|db| insert_item(db, ITEM_B, "Local item"));
let result = s.host.sync();
assert_eq!(result["requiresLogout"], true, "{}", result);
assert_eq!(result["logoutReason"], "passwordChanged");
}
#[test]
fn status_check_reports_newer_server_state_without_touching_the_vault() {
let mut s = synced(|db| insert_item(db, ITEM_A, "Server item"));
s.publish(8);
s.host.is_dirty = true;
let result = s.host.run("statusCheck");
assert_eq!(result["success"], true, "{}", result);
assert_eq!(result["hasNewerVault"], true);
assert_eq!(result["hasDirtyChanges"], true);
assert_eq!(result["isOffline"], false);
assert!(s.host.store_calls.is_empty());
assert_eq!(s.host.request_log(), vec!["GET Status"]);
}
#[test]
fn session_reports_when_a_response_is_missing() {
let session = SyncSession::new(&request_json("fullSync", "key", false, 0).to_string()).unwrap();
let first: Value = serde_json::from_str(&session.next_command().unwrap()).unwrap();
assert_eq!(first["kind"], "log", "the engine announces the sync before touching the host");
assert!(session.next_command().is_err(), "the session refuses to advance without a response");
session.resume("{}", None).unwrap();
let second: Value = serde_json::from_str(&session.next_command().unwrap()).unwrap();
assert_eq!(second["kind"], "http");
assert_eq!(second["path"], "Status");
}