Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Fix vault_codec and vault_sync errors in decoding
Leendert de Borst860dcfd19991
diff --git a/core/rust/src/sqlite_host/mod.rs b/core/rust/src/sqlite_host/mod.rsindex b2261c4a2..838757416 100644--- a/core/rust/src/sqlite_host/mod.rs+++ b/core/rust/src/sqlite_host/mod.rs@@ -157,18 +157,18 @@ impl From<ValueRef<'_>> for SqlValue {}}-/// A JSON parameter as a SQLite value.-fn to_sql(value: &Value) -> RsValue {- match value {+/// A JSON parameter as a SQLite value. A `{ __b64 }` cell that is not valid base64 is an error, never an empty BLOB.+fn to_sql(value: &Value) -> VaultResult<RsValue> {+ Ok(match value {Value::Null => RsValue::Null,Value::Bool(b) => RsValue::Integer(*b as i64),Value::Number(n) => n.as_i64().map(RsValue::Integer).unwrap_or_else(|| RsValue::Real(n.as_f64().unwrap_or(0.0))),Value::String(s) => RsValue::Text(s.clone()),other => match inline_b64(other) {- Some(b64) => RsValue::Blob(base64_decode(b64).unwrap_or_default()),+ Some(b64) => RsValue::Blob(base64_decode(b64).map_err(|_| VaultError::General("A BLOB parameter is not valid base64".to_string()))?),None => RsValue::Text(other.to_string()),},- }+ })}/// A SQLite value as JSON.@@ -186,7 +186,7 @@ fn from_sql(value: ValueRef<'_>) -> Value {pub fn query(conn: &Connection, sql: &str, params: &[Value]) -> VaultResult<Vec<Map<String, Value>>> {let mut statement = conn.prepare(sql).map_err(sql_error_at(sql))?;let columns: Vec<String> = statement.column_names().iter().map(|c| c.to_string()).collect();- let values: Vec<RsValue> = params.iter().map(to_sql).collect();+ let values: Vec<RsValue> = params.iter().map(to_sql).collect::<VaultResult<_>>()?;let mut rows = statement.query(params_from_iter(values.iter())).map_err(sql_error_at(sql))?;let mut out = Vec::new();while let Some(row) = rows.next().map_err(sql_error)? {@@ -203,7 +203,13 @@ pub fn query(conn: &Connection, sql: &str, params: &[Value]) -> VaultResult<Vec<pub fn exec(conn: &Connection, statements: &[SqlStatement]) -> VaultResult<()> {conn.execute_batch("SAVEPOINT exec_batch").map_err(sql_error)?;for statement in statements {- let values: Vec<RsValue> = statement.params.iter().map(to_sql).collect();+ let values = match statement.params.iter().map(to_sql).collect::<VaultResult<Vec<RsValue>>>() {+ Ok(values) => values,+ Err(error) => {+ let _ = conn.execute_batch("ROLLBACK TO exec_batch; RELEASE exec_batch");+ return Err(error);+ }+ };if let Err(error) = conn.execute(&statement.sql, params_from_iter(values.iter())) {let _ = conn.execute_batch("ROLLBACK TO exec_batch; RELEASE exec_batch");return Err(sql_error_at(&statement.sql)(error));@@ -211,3 +217,42 @@ pub fn exec(conn: &Connection, statements: &[SqlStatement]) -> VaultResult<()> {}conn.execute_batch("RELEASE exec_batch").map_err(sql_error)}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::common::encoding::base64_encode;++ fn adversarial() -> Vec<Vec<u8>> {+ let mut large = vec![0u8; 1024 * 1024];+ crate::common::rng::fill_random(&mut large);+ vec![vec![], vec![0x00], vec![0xFF], vec![0x00, 0xFF], vec![0xC3, 0x28, 0xA0], vec![0xED, 0xA0, 0x80, 0xF8], b"QUJD".to_vec(), (0u8..=255).collect(), large]+ }++ #[test]+ fn blob_cells_round_trip_through_json_and_typed_values() {+ let db = MemoryDatabase::with_schema("CREATE TABLE T (Id INTEGER, Data BLOB);").unwrap();+ for (id, bytes) in adversarial().iter().enumerate() {+ db.exec(&[SqlStatement { sql: "INSERT INTO T (Id, Data) VALUES (?, ?)".to_string(), params: vec![json!(id), inline_bytes(bytes)] }]).unwrap();+ let rows = db.query("SELECT typeof(Data) AS Kind, Data FROM T WHERE Id = ?", &[json!(id)]).unwrap();+ assert_eq!(rows[0]["Kind"], "blob", "{} bytes", bytes.len());+ assert_eq!(rows[0]["Data"], json!({ "__b64": base64_encode(bytes) }), "{} bytes", bytes.len());+ let typed = db.query_values("SELECT Data FROM T WHERE Id = ?", &[SqlValue::Integer(id as i64)]).unwrap();+ assert_eq!(typed.rows[0][0], SqlValue::Blob(bytes.clone()));+ db.execute("UPDATE T SET Data = ? WHERE Id = ?", &[SqlValue::Blob(bytes.clone()), SqlValue::Integer(id as i64)]).unwrap();+ assert_eq!(db.export().map(|exported| MemoryDatabase::from_bytes(&exported).unwrap().query_values("SELECT Data FROM T WHERE Id = ?", &[SqlValue::Integer(id as i64)]).unwrap().rows[0][0].clone()).unwrap(), SqlValue::Blob(bytes.clone()));+ }+ }++ #[test]+ fn invalid_base64_blob_parameter_fails_instead_of_binding_empty_bytes() {+ let db = MemoryDatabase::with_schema("CREATE TABLE T (Data BLOB);").unwrap();+ let statements = [+ SqlStatement { sql: "INSERT INTO T (Data) VALUES (?)".to_string(), params: vec![inline_bytes(&[1, 2, 3])] },+ SqlStatement { sql: "INSERT INTO T (Data) VALUES (?)".to_string(), params: vec![json!({ "__b64": "not base64!" })] },+ ];+ assert!(db.exec(&statements).is_err());+ assert!(db.query("SELECT * FROM T", &[]).unwrap().is_empty(), "the whole batch rolls back");+ assert!(db.query("SELECT * FROM T WHERE Data = ?", &[json!({ "__b64": "A" })]).is_err(), "a truncated parameter is refused, not read as empty");+ }+}diff --git a/core/rust/src/vault_codec/normalize.rs b/core/rust/src/vault_codec/normalize.rsindex a1b01c0c9..3bf64fdd0 100644--- a/core/rust/src/vault_codec/normalize.rs+++ b/core/rust/src/vault_codec/normalize.rs@@ -66,6 +66,7 @@ pub(crate) fn normalize_row_id_spelling(row: &mut CodecRecord) {/// Normalize the shape of rows for converting from materialized SQLite to the manifest format to save on filesize.pub(crate) fn normalize_row_shapes(tables: &mut HashMap<String, Vec<CodecRecord>>) {+ super::sharing::prune_dangling_references(tables);// Drop rows of deleted items first (any leftover state after a potential delete/update scenario in LWW merge).drop_children_of_deleted_items(tables);let multi_value_defs = multi_value_definition_ids(tables);diff --git a/core/rust/src/vault_codec/sharing.rs b/core/rust/src/vault_codec/sharing.rsindex 5e85db1fc..a50d22a89 100644--- a/core/rust/src/vault_codec/sharing.rs+++ b/core/rust/src/vault_codec/sharing.rs@@ -469,6 +469,15 @@ pub(super) fn combine_manifest_tables(tables}+/// Null or drop rows whose reference names no row in this manifest.+pub(super) fn prune_dangling_references(tables: &mut HashMap<String, Vec<CodecRecord>>) {+ if tables.contains_key(FOLDERS_TABLE) {+ null_dangling_item_folders(tables);+ }+ drop_orphan_item_children(tables);+ drop_item_tags_without_a_tag(tables);+}+/// Make every row of a single manifest's table set claim `manifest_id` as its scope, every table alike,/// registered or not. Stamping a row with the manifest it arrived in is what lets the next push route/// it home by its own stamp, instead of trusting whatever scope its author wrote into it (which woulddiff --git a/core/rust/src/vault_codec/tests.rs b/core/rust/src/vault_codec/tests.rsindex 0adccac2c..08f171c4c 100644--- a/core/rust/src/vault_codec/tests.rs+++ b/core/rust/src/vault_codec/tests.rs@@ -237,19 +237,40 @@ fn unpack_payload_rejects_tampered_payload() {#[test]fn validate_manifest_catches_broken_fk() {let mut manifest = canonicalize_from_sqlite(basic_input(vec![- CodecTableData { name: "Items".to_string(), records: vec![row(&[("Id", json!("i1")), ("FolderId", json!("missing"))])] },+ CodecTableData { name: "Items".to_string(), records: vec![row(&[("Id", json!("i1"))])] },CodecTableData { name: "Folders".to_string(), records: vec![] },])).unwrap().first().manifest.clone();+ // Canonicalize nulls a dangling FolderId itself, so the broken reference is put in afterwards.+ manifest.tables.get_mut("Items").unwrap()[0].insert("FolderId".to_string(), json!("missing"));manifest.tables.entry("Folders".to_string()).or_default();let result = validate_manifest(&manifest);assert!(!result.ok);assert!(result.failed_rules.iter().any(|r| r == "item-folder-fk-broken"));}+#[test]+fn canonicalize_prunes_references_the_validator_would_refuse() {+ let manifest = canonicalize_from_sqlite(basic_input(vec![+ CodecTableData { name: "Items".to_string(), records: vec![row(&[("Id", json!("i1")), ("FolderId", json!("missing"))]), row(&[("Id", json!("i2")), ("FolderId", json!(""))])] },+ CodecTableData { name: "Folders".to_string(), records: vec![] },+ CodecTableData { name: "Tags".to_string(), records: vec![] },+ CodecTableData { name: "ItemTags".to_string(), records: vec![row(&[("ItemId", json!("i1")), ("TagId", json!("gone"))])] },+ CodecTableData { name: "TotpCodes".to_string(), records: vec![row(&[("Id", json!("t1")), ("ItemId", json!("gone"))]), row(&[("Id", json!("t2")), ("ItemId", json!("i1"))])] },+ ]))+ .unwrap()+ .first()+ .manifest+ .clone();+ assert!(validate_manifest(&manifest).ok, "{:?}", validate_manifest(&manifest).failed_rules);+ assert!(manifest.tables["Items"].iter().all(|item| item["FolderId"].is_null()));+ assert!(manifest.tables["ItemTags"].is_empty());+ assert_eq!(manifest.tables["TotpCodes"].iter().map(|r| r["Id"].as_str().unwrap()).collect::<Vec<_>>(), vec!["t2"]);+}+#[test]fn validate_manifest_ok_for_clean_vault() {let manifest = canonicalize_from_sqlite(basic_input(vec![diff --git a/core/rust/src/vault_sync/engine.rs b/core/rust/src/vault_sync/engine.rsindex 3a1aef2c8..1f68ec1ec 100644--- a/core/rust/src/vault_sync/engine.rs+++ b/core/rust/src/vault_sync/engine.rs@@ -583,11 +583,11 @@ async fn migration_status(ctx: &mut Ctx) -> MigrationStatusResult {}/// Bring the local vault onto the current storage model and push it: a schema rebuild for a migrated account, the-/// whole sqlite-blob move (`legacy::migrate_sqlite_blob`) for an account without a key hierarchy yet.+/// one-time account upgrade (`legacy::upgrade_account_to_manifest_v1`) for an account without a key hierarchy yet.async fn migrate_manifest(ctx: &mut Ctx) -> MigrateManifestResult {let migrated: SyncResult<bool> = async {if !keys::has_local_vault_key(&ctx.host).await? {- return legacy::migrate_sqlite_blob(ctx).await;+ return legacy::upgrade_account_to_manifest_v1(ctx).await;}migrate_schema(ctx).await}diff --git a/core/rust/src/vault_sync/legacy.rs b/core/rust/src/vault_sync/legacy.rsindex a30684794..53078a528 100644--- a/core/rust/src/vault_sync/legacy.rs+++ b/core/rust/src/vault_sync/legacy.rs@@ -1,17 +1,22 @@-//! LEGACY: everything only a vault still on the sqlite-blob storage format needs. Remove this module once every-//! account has migrated to the manifest-v1 storage model, together with its callers:+//! LEGACY: what old sqlite-blob accounts need, including their one-time upgrade from sqlite-blob to manifest-v1+//! ([`upgrade_account_to_manifest_v1`]). Remove this module once every account has upgraded, together with its callers://! `pull::pull` (the legacy snapshot branch), `merge::pull_and_merge` (the legacy server branch),//! `db::schema_state` (the frozen chain check) and `engine::migrate_manifest` (the branch without a vault key).use std::collections::HashMap;-use super::db::SchemaState;+use serde_json::Value;++use super::db::{self, SchemaState};use super::errors::{SyncError, SyncResult};use super::pull::{self, email_routing_of, PulledVault};use super::push::resolve_personal_manifest_id;use super::state::{self, Ctx};-use super::types::GetResponse;+use super::types::{Db, GetResponse};use super::{engine, keys};+use crate::common::encoding::base64_decode;+use crate::sqlite_host::SqlStatement;+use crate::vault_codec::row::inline_bytes;/// The `storageFormat` of a legacy sqlite-blob snapshot; an absent value means the same.const STORAGE_FORMAT_SQLITE_BLOB: i32 = 0;@@ -35,10 +40,17 @@ pub(crate) async fn open_legacy_snapshot(ctx: &Ctx, snapshot: &GetResponse) -> SOk(PulledVault { encrypted_vault: snapshot.legacy_vault_blob.clone().unwrap_or_default(), revision, email_routing: email_routing_of(snapshot), manifest_revisions, bucket_revisions: HashMap::new(), needs_first_write: false })}-/// The one-way move of a sqlite-blob account onto the manifest storage format: the local vault is rebuilt onto the-/// current schema with its unstamped rows stamped with the personal manifest, and the push that carries it creates the-/// account key hierarchy. Returns whether that push reached the server.-pub(crate) async fn migrate_sqlite_blob(ctx: &mut Ctx) -> SyncResult<bool> {+/*+ * The one-time account upgrade: the one-way move of a sqlite-blob account onto the manifest storage format.+ */++/// Every column declared BLOB, as (TableName, ColumnName) rows.+const BLOB_TYPED_COLUMNS: &str = "SELECT m.name AS TableName, p.name AS ColumnName FROM sqlite_master m JOIN pragma_table_info(m.name) p WHERE m.type = 'table' AND upper(p.type) = 'BLOB'";++/// Upgrade a sqlite-blob account to manifest-v1: the local vault is rebuilt onto the current schema with its unstamped+/// rows stamped with the personal manifest, and the push that carries it creates the account key hierarchy. Returns+/// whether that push reached the server.+pub(crate) async fn upgrade_account_to_manifest_v1(ctx: &mut Ctx) -> SyncResult<bool> {if engine::schema_state(ctx).await? == SchemaState::LegacyChain {return Err(SyncError::LegacyUpgradePending);}@@ -48,7 +60,7 @@ pub(crate) async fn migrate_sqlite_blob(ctx: &mut Ctx) -> SyncResult<bool> {}record_server_baseline_if_missing(ctx).await?;if keys::has_local_vault_key(&ctx.host).await? {- // The account turned out to be migrated already (accepted above, or pulled with the baseline); a schema rebuild is all that can remain.+ // The account turned out to be upgraded already (accepted above, or pulled with the baseline); a schema rebuild is all that can remain.return engine::migrate_schema(ctx).await;}if engine::schema_state(ctx).await? == SchemaState::LegacyChain {@@ -56,14 +68,15 @@ pub(crate) async fn migrate_sqlite_blob(ctx: &mut Ctx) -> SyncResult<bool> {return Err(SyncError::LegacyUpgradePending);}let personal = resolve_personal_manifest_id(ctx).await?;+ decode_base64_text_in_blob_columns(ctx).await?;engine::rebuild_local_schema(ctx, Some(personal)).await?;engine::push_migrated_vault(ctx, true).await}/// A session that logged in through a client predating the manifest storage format never pulled through this engine,-/// so it holds neither the personal manifest id nor the revision baseline, and the migration push needs both (the-/// server refuses a write whose revision it does not know). Calling this method before a push fixes this.-pub(crate) async fn record_server_baseline_if_missing(ctx: &mut Ctx) -> SyncResult<()> {+/// so it holds neither the personal manifest id nor the revision baseline, and the upgrade push needs both (the+/// server refuses a write whose revision it does not know). Calling this method before the push fixes this.+async fn record_server_baseline_if_missing(ctx: &mut Ctx) -> SyncResult<()> {if state::get::<String>(&ctx.host, state::VAULT_PERSONAL_MANIFEST_ID).await?.is_some() {return Ok(());}@@ -80,6 +93,30 @@ pub(crate) async fn record_server_baseline_if_missing(ctx: &mut Ctx) -> SyncResupull::commit_revisions(ctx, &pulled.manifest_revisions, &pulled.bucket_revisions).await}+/// Decode base64 TEXT in BLOB columns back to bytes, in place. The 0.30.x merges (Android, iOS, Blazor) bound every+/// value as text, so the BLOB cells of each row the server copy won were stored as base64 TEXT. The upgrade push then+/// carries real bytes to every device. Text that is not base64 is left as-is.+async fn decode_base64_text_in_blob_columns(ctx: &Ctx) -> SyncResult<()> {+ let mut decoded = 0usize;+ for column in db::query(&ctx.host, Db::Local, BLOB_TYPED_COLUMNS, vec![]).await? {+ let (Some(table), Some(name)) = (column.get("TableName").and_then(Value::as_str), column.get("ColumnName").and_then(Value::as_str)) else { continue };+ let rows = db::query(&ctx.host, Db::Local, &format!("SELECT rowid AS RowId, \"{name}\" AS Text FROM \"{table}\" WHERE typeof(\"{name}\") = 'text'"), vec![]).await?;+ let statements: Vec<SqlStatement> = rows+ .iter()+ .filter_map(|row| {+ let bytes = base64_decode(row.get("Text")?.as_str()?).ok()?;+ Some(SqlStatement { sql: format!("UPDATE \"{table}\" SET \"{name}\" = ? WHERE rowid = ?"), params: vec![inline_bytes(&bytes), row.get("RowId")?.clone()] })+ })+ .collect();+ decoded += statements.len();+ db::exec(&ctx.host, Db::Local, statements).await?;+ }+ if decoded > 0 {+ ctx.warn(format!("[ManifestMigration] Decoded {} base64 TEXT cells in BLOB columns back to bytes (written by a 0.30.x merge).", decoded)).await;+ }+ Ok(())+}+/// The frozen sqlite-blob upgrade chain: (revision, data version). It ends at 2.0.0, the first schema compatible/// with manifest-v1; later schema changes ship through the full schema only, which every materialization uses directly.const LEGACY_VAULT_VERSIONS: &[(u32, &str)] = &[diff --git a/core/rust/src/vault_sync/tests/merge_edge_cases.rs b/core/rust/src/vault_sync/tests/merge_edge_cases.rsnew file mode 100644index 000000000..676fc4dc3--- /dev/null+++ b/core/rust/src/vault_sync/tests/merge_edge_cases.rs@@ -0,0 +1,528 @@+//! Merge edge cases run through the whole dirty-pull pipeline on the real client schema: both devices'+//! SQLite canonicalized, merged per manifest, validated, materialized and inserted into a fresh database.++use std::collections::HashMap;++use rusqlite::Connection;+use serde_json::{json, Value};++use super::test_host::{complete_schema_sql, open_schema_db, query};+use crate::common::encoding::base64_decode;+use crate::sqlite_host::{self, SqlStatement};+use crate::vault_codec::{self, CanonicalizeInput, CanonicalizedVault, CodecTableData, Manifest, ManifestSpec, MaterializeInput};+use crate::vault_merge::{merge_canonical, CanonicalMergeInput};++const PERSONAL: &str = "11111111-1111-4111-8111-111111111111";+const SHARED: &str = "22222222-2222-4222-8222-222222222222";+const SALT: &str = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";+const ITEM: &str = "33333333-3333-4333-8333-333333333333";+const TOTP_A: &str = "44444444-4444-4444-8444-444444444441";+const TOTP_B: &str = "44444444-4444-4444-8444-444444444442";+const PASSKEY: &str = "55555555-5555-4555-8555-555555555555";+const FOLDER: &str = "66666666-6666-4666-8666-666666666666";+const T0: &str = "2026-01-01 00:00:00.000";+const T1: &str = "2026-01-02 00:00:00.000";+const T2: &str = "2026-01-03 00:00:00.000";+const T3: &str = "2026-01-04 00:00:00.000";++/// What one merge produced: the materialized vault, or the reason the engine would drop the local changes.+type MergeResult = Result<Connection, String>;++/// A fresh client database; foreign keys are checked once after the inserts, like the engine's staging load.+fn new_db() -> Connection {+ let db = open_schema_db(&complete_schema_sql());+ db.execute_batch("PRAGMA foreign_keys = OFF;").unwrap();+ db+}++fn read_tables(conn: &Connection) -> Vec<CodecTableData> {+ let names: Vec<String> = query(conn, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name", &[]).unwrap().iter().map(|r| r["name"].as_str().unwrap().to_string()).collect();+ names.into_iter().filter(|name| !vault_codec::is_skip_table(name)).map(|name| CodecTableData { records: query(conn, &format!("SELECT * FROM \"{}\"", name), &[]).unwrap().into_iter().map(|row| row.into_iter().collect()).collect(), name }).collect()+}++fn schema_columns(conn: &Connection) -> HashMap<String, Vec<String>> {+ let sql = "SELECT m.name AS TableName, p.name AS ColumnName FROM sqlite_master m JOIN pragma_table_info(m.name) p WHERE m.type = 'table' ORDER BY m.name, p.cid";+ let mut out: HashMap<String, Vec<String>> = HashMap::new();+ for row in query(conn, sql, &[]).unwrap() {+ out.entry(row["TableName"].as_str().unwrap().to_string()).or_default().push(row["ColumnName"].as_str().unwrap().to_string());+ }+ out+}++fn canon(conn: &Connection) -> Result<CanonicalizedVault, String> {+ canon_manifests(conn, &[PERSONAL])+}++fn canon_manifests(conn: &Connection, manifest_ids: &[&str]) -> Result<CanonicalizedVault, String> {+ let manifests = manifest_ids.iter().map(|id| ManifestSpec { manifest_id: id.to_string(), manifest_salt: SALT.to_string(), name: None }).collect();+ vault_codec::canonicalize_from_sqlite(CanonicalizeInput { tables: read_tables(conn), canonicalized_at: "2026-02-01T00:00:00.000Z".to_string(), manifests, stamp_unstamped_into: None }).map_err(|e| format!("canonicalize: {}", e))+}++/// The engine's dirty pull (`vault_sync::merge`) minus HTTP and encryption: any `Err` is a merge the engine+/// answers by keeping the server vault and dropping the local changes.+fn merge_vaults(server: &Connection, local: &Connection) -> MergeResult {+ let server_side = canon(server)?;+ let local_side = canon(local)?;+ merge_canonical_sides(server_side.manifests.iter().map(|m| m.manifest.clone()).collect(), server_side.clone(), local_side)+}++fn merge_canonical_sides(server_manifests: Vec<Manifest>, server_side: CanonicalizedVault, local_side: CanonicalizedVault) -> MergeResult {+ let schema = schema_columns(&new_db());+ let output = merge_canonical(CanonicalMergeInput {+ server_manifests,+ server_buckets: server_side.data_buckets.clone(),+ contentless_server_manifest_ids: vec![],+ local_manifests: local_side.manifests.iter().map(|m| m.manifest.clone()).collect(),+ local_buckets: local_side.data_buckets.clone(),+ schema_columns: schema.clone(),+ })+ .map_err(|e| format!("merge: {}", e))?;++ let mut manifests = Vec::new();+ let mut buckets = Vec::new();+ for entry in output.manifests {+ let validation = vault_codec::validate_manifest(&entry.manifest);+ if !validation.ok {+ return Err(format!("validation fallback: {}", validation.failed_rules.join(", ")));+ }+ for bucket in &entry.buckets {+ let validation = vault_codec::validate_data_bucket(bucket);+ if !validation.ok {+ return Err(format!("bucket validation fallback: {}", validation.failed_rules.join(", ")));+ }+ }+ manifests.push(entry.manifest);+ buckets.extend(entry.buckets);+ }++ let mut blobs: HashMap<String, Vec<u8>> = HashMap::new();+ for side in [&server_side, &local_side] {+ for manifest in &side.manifests {+ for (hash, blob) in &manifest.blobs {+ blobs.insert(hash.clone(), base64_decode(&blob.bytes_base64).unwrap());+ }+ }+ }++ let materialized = vault_codec::materialize_as_sqlite(MaterializeInput { manifests, data_buckets: buckets, schema_columns: schema.clone() }).map_err(|e| format!("materialize: {}", e))?;+ let db = new_db();+ for table in materialized.tables.iter().filter(|t| !t.records.is_empty() && schema.contains_key(&t.name)) {+ let statements: Vec<SqlStatement> = table+ .records+ .iter()+ .map(|row| {+ let mut columns: Vec<&String> = row.keys().collect();+ columns.sort();+ let params = columns.iter().map(|c| bind(&row[*c], &blobs)).collect();+ let quoted: Vec<String> = columns.iter().map(|c| format!("\"{}\"", c)).collect();+ SqlStatement { sql: format!("INSERT INTO \"{}\" ({}) VALUES ({})", table.name, quoted.join(", "), vec!["?"; columns.len()].join(", ")), params }+ })+ .collect();+ sqlite_host::exec(&db, &statements).map_err(|e| format!("insert {}: {}", table.name, e))?;+ }+ let violations = query(&db, "PRAGMA foreign_key_check", &[]).unwrap();+ if !violations.is_empty() {+ return Err(format!("foreign key check: {:?}", violations));+ }+ Ok(db)+}++/// Bind like `vault_sync::db::bind_value`: a blob reference becomes its bytes, NULL when not at hand.+fn bind(value: &Value, blobs: &HashMap<String, Vec<u8>>) -> Value {+ match value.get("__blobRef").and_then(Value::as_str) {+ Some(hash) => blobs.get(hash).map(|bytes| json!({ "__b64": crate::common::encoding::base64_encode(bytes) })).unwrap_or(Value::Null),+ None => value.clone(),+ }+}++fn exec(db: &Connection, sql: &str, params: &[Value]) {+ sqlite_host::exec(db, &[SqlStatement { sql: sql.to_string(), params: params.to_vec() }]).unwrap();+}++fn insert_item(db: &Connection, id: &str, name: &str, at: &str) {+ exec(db, "INSERT INTO Items (ManifestId, Id, Name, ItemType, CreatedAt, UpdatedAt, IsDeleted) VALUES (?, ?, ?, 'Login', ?, ?, 0)", &[json!(PERSONAL), json!(id), json!(name), json!(T0), json!(at)]);+}++fn insert_totp(db: &Connection, id: &str, item: &str, secret: &str, at: &str, deleted: i64) {+ exec(db, "INSERT INTO TotpCodes (ManifestId, Id, ItemId, Name, SecretKey, CreatedAt, UpdatedAt, IsDeleted) VALUES (?, ?, ?, 'code', ?, ?, ?, ?)", &[json!(PERSONAL), json!(id), json!(item), json!(secret), json!(T0), json!(at), json!(deleted)]);+}++fn insert_password(db: &Connection, item: &str, value: &str, at: &str) {+ exec(db, "INSERT INTO FieldValues (ManifestId, Id, ItemId, FieldKey, Value, Weight, ValueIndex, CreatedAt, UpdatedAt, IsDeleted) VALUES (?, ?, ?, 'login.password', ?, 0, 0, ?, ?, 0)", &[json!(PERSONAL), json!(crate::vault_sync::db::new_id()), json!(item), json!(value), json!(T0), json!(at)]);+}++/// A passkey with the given `PrivateKey` cell (TEXT or `{ __b64 }` bytes) and fixed byte columns.+fn insert_passkey(db: &Connection, id: &str, item: &str, private_key: Value, display_name: &str, at: &str, deleted: i64) {+ exec(+ db,+ "INSERT INTO Passkeys (ManifestId, Id, ItemId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey, DisplayName, AdditionalData, CredentialId, CreatedAt, UpdatedAt, IsDeleted) VALUES (?, ?, ?, 'example.com', ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?)",+ &[json!(PERSONAL), json!(id), json!(item), user_handle(), json!("{\"kty\":\"EC\",\"x\":\"pub\"}"), private_key, prf_key(), json!(display_name), credential_id(), json!(T0), json!(at), json!(deleted)],+ );+}++fn user_handle() -> Value {+ json!({ "__b64": crate::common::encoding::base64_encode(&[0u8, 1, 2, 255, 254, 0, 7]) })+}++fn prf_key() -> Value {+ json!({ "__b64": crate::common::encoding::base64_encode(&(0u8..32).collect::<Vec<u8>>()) })+}++fn credential_id() -> Value {+ json!({ "__b64": crate::common::encoding::base64_encode(&[0x55u8; 16]) })+}++const JWK: &str = "{\"kty\":\"EC\",\"crv\":\"P-256\",\"d\":\"secret-d\",\"x\":\"x\",\"y\":\"y\"}";++/// Both devices after their last common sync: one item with a password, a TOTP code and a passkey.+fn synced_pair() -> (Connection, Connection) {+ let build = || {+ let db = new_db();+ insert_item(&db, ITEM, "Bank", T0);+ insert_password(&db, ITEM, "pw-0", T0);+ insert_totp(&db, TOTP_A, ITEM, "SECRET-A", T0, 0);+ insert_passkey(&db, PASSKEY, ITEM, json!(JWK), "me", T0, 0);+ db+ };+ let server = build();+ // Copy the server's rows, so both sides carry identical ids (the derived FieldValues id included).+ let local = new_db();+ for table in read_tables(&server).into_iter().filter(|t| !t.records.is_empty() && t.name != "__EFMigrationsHistory") {+ for row in table.records {+ let columns: Vec<&String> = row.keys().collect();+ let quoted: Vec<String> = columns.iter().map(|c| format!("\"{}\"", c)).collect();+ let sql = format!("INSERT INTO \"{}\" ({}) VALUES ({})", table.name, quoted.join(", "), vec!["?"; columns.len()].join(", "));+ exec(&local, &sql, &columns.iter().map(|c| row[*c].clone()).collect::<Vec<_>>());+ }+ }+ (server, local)+}++fn strings(db: &Connection, sql: &str) -> Vec<String> {+ let mut out: Vec<String> = query(db, sql, &[]).unwrap().iter().map(|r| r.values().map(|v| v.as_str().map(str::to_string).unwrap_or_else(|| v.to_string())).collect::<Vec<_>>().join("|")).collect();+ out.sort();+ out+}++fn live_totp_secrets(db: &Connection) -> Vec<String> {+ strings(db, "SELECT SecretKey FROM TotpCodes WHERE IsDeleted = 0")+}++fn live_passkeys(db: &Connection) -> Vec<String> {+ strings(db, "SELECT DisplayName FROM Passkeys WHERE IsDeleted = 0")+}++fn item_state(db: &Connection) -> Vec<String> {+ strings(db, &format!("SELECT Name || '|' || IsDeleted || '|' || ifnull(DeletedAt, '-') || '|' || ifnull(FolderId, '-') AS s FROM Items WHERE Id = '{}'", ITEM))+}++/*+ * Concurrent edits.+ */++#[test]+fn totp_added_on_both_devices_keeps_both() {+ let (server, local) = synced_pair();+ insert_totp(&server, TOTP_B, ITEM, "SERVER-NEW", T1, 0);+ insert_totp(&local, "44444444-4444-4444-8444-444444444443", ITEM, "LOCAL-NEW", T2, 0);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(live_totp_secrets(&merged), vec!["LOCAL-NEW", "SECRET-A", "SERVER-NEW"]);+}++#[test]+fn totp_deleted_on_one_device_while_the_other_edits_the_item() {+ let (server, local) = synced_pair();+ exec(&server, "UPDATE TotpCodes SET IsDeleted = 1, UpdatedAt = ? WHERE Id = ?", &[json!(T1), json!(TOTP_A)]);+ exec(&local, "UPDATE Items SET Name = 'Bank renamed', UpdatedAt = ? WHERE Id = ?", &[json!(T2), json!(ITEM)]);+ let merged = merge_vaults(&server, &local).unwrap();+ assert!(live_totp_secrets(&merged).is_empty(), "the delete of the code stands");+ assert_eq!(item_state(&merged), vec!["Bank renamed|0|-|-"]);+}++#[test]+fn totp_added_locally_while_the_server_edits_the_item_and_password() {+ let (server, local) = synced_pair();+ exec(&server, "UPDATE Items SET Name = 'Server name', UpdatedAt = ? WHERE Id = ?", &[json!(T3), json!(ITEM)]);+ exec(&server, "UPDATE FieldValues SET Value = 'pw-server', UpdatedAt = ? WHERE FieldKey = 'login.password'", &[json!(T3)]);+ insert_totp(&local, TOTP_B, ITEM, "LOCAL-NEW", T1, 0);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(live_totp_secrets(&merged), vec!["LOCAL-NEW", "SECRET-A"]);+ assert_eq!(strings(&merged, "SELECT Value FROM FieldValues WHERE IsDeleted = 0"), vec!["pw-server"]);+}++#[test]+fn passkey_created_on_mobile_while_the_extension_edits_the_item() {+ let (server, local) = synced_pair();+ exec(&server, "UPDATE Items SET Name = 'Extension edit', UpdatedAt = ? WHERE Id = ?", &[json!(T2), json!(ITEM)]);+ exec(&server, "UPDATE FieldValues SET Value = 'pw-ext', UpdatedAt = ? WHERE FieldKey = 'login.password'", &[json!(T2)]);+ insert_passkey(&local, "55555555-5555-4555-8555-555555555556", ITEM, json!(JWK), "mobile", T1, 0);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(live_passkeys(&merged), vec!["me", "mobile"]);+ assert_eq!(item_state(&merged), vec!["Extension edit|0|-|-"]);+ assert_eq!(strings(&merged, "SELECT Value FROM FieldValues WHERE IsDeleted = 0"), vec!["pw-ext"]);+}++#[test]+fn passkey_soft_deleted_versus_updated_is_last_write_wins_both_ways() {+ for (delete_at, rename_at, expected) in [(T2, T1, vec![]), (T1, T2, vec!["renamed".to_string()])] {+ let (server, local) = synced_pair();+ exec(&server, "UPDATE Passkeys SET IsDeleted = 1, UpdatedAt = ? WHERE Id = ?", &[json!(delete_at), json!(PASSKEY)]);+ exec(&local, "UPDATE Passkeys SET DisplayName = 'renamed', UpdatedAt = ? WHERE Id = ?", &[json!(rename_at), json!(PASSKEY)]);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(live_passkeys(&merged), expected, "delete at {}, rename at {}", delete_at, rename_at);+ }+}++#[test]+fn permanent_delete_on_one_side_and_a_later_totp_on_the_other_keeps_the_item_whole() {+ let (server, local) = synced_pair();+ // Server device purges the item: tombstone plus child tombstones, as the pruner writes them.+ exec(&server, "UPDATE Items SET IsDeleted = 1, DeletedAt = ?, UpdatedAt = ? WHERE Id = ?", &[json!(T1), json!(T1), json!(ITEM)]);+ for table in ["TotpCodes", "Passkeys", "FieldValues"] {+ exec(&server, &format!("UPDATE {} SET IsDeleted = 1, UpdatedAt = ? WHERE ItemId = ?", table), &[json!(T1), json!(ITEM)]);+ }+ insert_totp(&local, TOTP_B, ITEM, "LOCAL-NEW", T2, 0);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(item_state(&merged), vec!["Bank|0|-|-"]);+ assert_eq!(live_totp_secrets(&merged), vec!["LOCAL-NEW", "SECRET-A"]);+ assert_eq!(live_passkeys(&merged), vec!["me"]);+ assert_eq!(strings(&merged, "SELECT Value FROM FieldValues WHERE IsDeleted = 0"), vec!["pw-0"]);+}++#[test]+fn permanent_delete_newer_than_the_other_sides_edits_drops_the_item_and_its_secrets() {+ let (server, local) = synced_pair();+ insert_totp(&local, TOTP_B, ITEM, "LOCAL-NEW", T1, 0);+ exec(&server, "UPDATE Items SET IsDeleted = 1, DeletedAt = ?, UpdatedAt = ? WHERE Id = ?", &[json!(T2), json!(T2), json!(ITEM)]);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(strings(&merged, "SELECT IsDeleted FROM Items"), vec!["1"]);+ assert!(live_totp_secrets(&merged).is_empty() && live_passkeys(&merged).is_empty());+}++#[test]+fn trash_on_one_side_and_a_passkey_on_the_other_keeps_both_changes() {+ let (server, local) = synced_pair();+ exec(&server, "UPDATE Items SET DeletedAt = ?, UpdatedAt = ? WHERE Id = ?", &[json!(T2), json!(T2), json!(ITEM)]);+ insert_passkey(&local, "55555555-5555-4555-8555-555555555556", ITEM, json!(JWK), "mobile", T1, 0);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(item_state(&merged), vec![format!("Bank|0|{}|-", T2)]);+ assert_eq!(live_passkeys(&merged), vec!["me", "mobile"]);+}++#[test]+fn restore_from_trash_newer_than_a_trash_on_the_other_side_wins() {+ let (server, local) = synced_pair();+ exec(&server, "UPDATE Items SET DeletedAt = ?, UpdatedAt = ? WHERE Id = ?", &[json!(T1), json!(T1), json!(ITEM)]);+ exec(&local, "UPDATE Items SET DeletedAt = NULL, UpdatedAt = ? WHERE Id = ?", &[json!(T2), json!(ITEM)]);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(item_state(&merged), vec!["Bank|0|-|-"]);+}++#[test]+fn item_moved_into_a_folder_the_other_side_deleted_still_merges() {+ let (server, local) = synced_pair();+ for db in [&server, &local] {+ exec(db, "INSERT INTO Folders (ManifestId, Id, Name, CreatedAt, UpdatedAt, IsDeleted, Weight) VALUES (?, ?, 'Work', ?, ?, 0, 0)", &[json!(PERSONAL), json!(FOLDER), json!(T0), json!(T0)]);+ }+ exec(&server, "UPDATE Folders SET IsDeleted = 1, UpdatedAt = ? WHERE Id = ?", &[json!(T1), json!(FOLDER)]);+ exec(&local, "UPDATE Items SET FolderId = ?, UpdatedAt = ? WHERE Id = ?", &[json!(FOLDER), json!(T2), json!(ITEM)]);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(item_state(&merged), vec![format!("Bank|0|-|{}", FOLDER)]);+ assert_eq!(live_totp_secrets(&merged), vec!["SECRET-A"]);+}++/*+ * Spellings older or other clients write.+ */++#[test]+fn timestamp_spellings_compare_as_instants() {+ // Space vs 'T', a Z suffix, an offset, and seven-digit .NET precision.+ for (server_at, local_at, local_wins) in [+ ("2026-01-02 00:00:00.000", "2026-01-02T00:00:00.001Z", true),+ ("2026-01-02T00:00:00.000Z", "2026-01-02 00:00:00.000", false),+ ("2026-01-02 00:00:00.123", "2026-01-02 00:00:00.1234567", true),+ ("2026-01-02 02:00:00.000", "2026-01-02T03:00:00+02:00", false),+ ("2026-01-02 00:00:00", "2026-01-02 00:00:01", true),+ ] {+ let (server, local) = synced_pair();+ exec(&server, "UPDATE TotpCodes SET SecretKey = 'SERVER', UpdatedAt = ? WHERE Id = ?", &[json!(server_at), json!(TOTP_A)]);+ exec(&local, "UPDATE TotpCodes SET SecretKey = 'LOCAL', UpdatedAt = ? WHERE Id = ?", &[json!(local_at), json!(TOTP_A)]);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(live_totp_secrets(&merged), vec![if local_wins { "LOCAL" } else { "SERVER" }], "server {} vs local {}", server_at, local_at);+ }+}++#[test]+fn uppercase_guids_from_an_older_client_match_their_lowercase_twins() {+ let (server, local) = synced_pair();+ // The local client wrote its rows in uppercase (as an older iOS build did).+ for table in ["Items", "TotpCodes", "Passkeys", "FieldValues"] {+ exec(&local, &format!("UPDATE {} SET Id = upper(Id), ManifestId = upper(ManifestId)", table), &[]);+ }+ for table in ["TotpCodes", "Passkeys", "FieldValues"] {+ exec(&local, &format!("UPDATE {} SET ItemId = upper(ItemId)", table), &[]);+ }+ exec(&local, "UPDATE TotpCodes SET SecretKey = 'LOCAL', UpdatedAt = ?", &[json!(T2)]);+ insert_totp(&server, TOTP_B, ITEM, "SERVER-NEW", T1, 0);+ let merged = merge_vaults(&server, &local).unwrap();+ assert_eq!(live_totp_secrets(&merged), vec!["LOCAL", "SERVER-NEW"]);+ assert_eq!(live_passkeys(&merged), vec!["me"]);+ assert_eq!(strings(&merged, "SELECT COUNT(*) FROM Items"), vec!["1"]);+}++#[test]+fn an_empty_string_folder_id_is_read_as_no_folder() {+ let (server, local) = synced_pair();+ exec(&local, "UPDATE Items SET FolderId = '', Name = 'Edited', UpdatedAt = ? WHERE Id = ?", &[json!(T2), json!(ITEM)]);+ let merged = merge_vaults(&server, &local);+ assert!(merged.is_ok(), "an empty FolderId must not fail the whole merge and drop the local edits: {:?}", merged.err());+}++/*+ * Passkey byte columns.+ */++#[test]+fn passkey_bytes_survive_merge_unchanged_with_text_and_blob_private_keys() {+ let blob_private_key = json!({ "__b64": crate::common::encoding::base64_encode(JWK.as_bytes()) });+ for (private_key, expected_type) in [(json!(JWK), "text"), (blob_private_key, "blob")] {+ let (server, local) = synced_pair();+ insert_passkey(&local, "55555555-5555-4555-8555-555555555556", ITEM, private_key.clone(), "mobile", T1, 0);+ // The server side touches the original passkey, so both a local-only and a server-won row cross the merge.+ exec(&server, "UPDATE Passkeys SET DisplayName = 'server', UpdatedAt = ? WHERE Id = ?", &[json!(T2), json!(PASSKEY)]);+ let merged = merge_vaults(&server, &local).unwrap();+ let rows = query(&merged, "SELECT DisplayName, typeof(PrivateKey) AS pt, CAST(PrivateKey AS TEXT) AS pk, hex(UserHandle) AS uh, hex(PrfKey) AS prf, hex(CredentialId) AS cid, typeof(UserHandle) AS ut FROM Passkeys ORDER BY DisplayName", &[]).unwrap();+ assert_eq!(rows.len(), 2);+ for row in &rows {+ assert_eq!(row["uh"], json!("000102FFFE0007"), "UserHandle bytes kept, a NUL included");+ assert_eq!(row["ut"], json!("blob"));+ assert_eq!(row["prf"], json!((0u8..32).map(|b| format!("{:02X}", b)).collect::<String>()));+ assert_eq!(row["cid"], json!("55".repeat(16)));+ assert_eq!(row["pk"], json!(JWK));+ }+ let mobile = rows.iter().find(|r| r["DisplayName"] == json!("mobile")).unwrap();+ assert_eq!(mobile["pt"], json!(expected_type), "the PrivateKey storage class is kept as the writer chose it");+ }+}++#[test]+fn a_passkey_without_a_prf_key_merges_against_one_that_gained_it() {+ let (server, local) = synced_pair();+ exec(&server, "UPDATE Passkeys SET PrfKey = NULL, UpdatedAt = ? WHERE Id = ?", &[json!(T1), json!(PASSKEY)]);+ exec(&local, "UPDATE Passkeys SET DisplayName = 'local', UpdatedAt = ? WHERE Id = ?", &[json!(T2), json!(PASSKEY)]);+ let merged = merge_vaults(&server, &local).unwrap();+ // The local row wins as a whole, so its PrfKey comes along.+ assert_eq!(strings(&merged, "SELECT DisplayName || '|' || ifnull(hex(PrfKey), 'null') FROM Passkeys"), vec![format!("local|{}", (0u8..32).map(|b| format!("{:02X}", b)).collect::<String>())]);+}++/*+ * Rows real vaults carry that must never fail the whole merge.+ */++#[test]+fn an_unknown_column_on_a_totp_row_survives_a_local_win() {+ let (server, local) = synced_pair();+ exec(&local, "UPDATE TotpCodes SET SecretKey = 'LOCAL', UpdatedAt = ? WHERE Id = ?", &[json!(T2), json!(TOTP_A)]);+ let mut server_side = canon(&server).unwrap();+ let totps = server_side.manifests[0].manifest.tables.get_mut("TotpCodes").unwrap();+ totps[0].insert("FutureColumn".to_string(), json!("from a newer writer"));+ let local_side = canon(&local).unwrap();+ let server_manifests = server_side.manifests.iter().map(|m| m.manifest.clone()).collect();+ let schema = schema_columns(&new_db());+ let output = merge_canonical(CanonicalMergeInput {+ server_manifests,+ server_buckets: server_side.data_buckets.clone(),+ contentless_server_manifest_ids: vec![],+ local_manifests: local_side.manifests.iter().map(|m| m.manifest.clone()).collect(),+ local_buckets: local_side.data_buckets.clone(),+ schema_columns: schema,+ })+ .unwrap();+ let merged_totp = &output.manifests[0].manifest.tables["TotpCodes"][0];+ assert_eq!(merged_totp["SecretKey"], json!("LOCAL"));+ assert_eq!(merged_totp["FutureColumn"], json!("from a newer writer"));+}++#[test]+fn an_orphan_totp_on_the_local_side_does_not_fail_the_whole_merge() {+ let (server, local) = synced_pair();+ // A code left behind by an older client under an item that is gone from both sides.+ insert_totp(&local, TOTP_B, "77777777-7777-4777-8777-777777777777", "ORPHAN", T1, 0);+ insert_totp(&local, "44444444-4444-4444-8444-444444444443", ITEM, "LOCAL-NEW", T1, 0);+ let merged = merge_vaults(&server, &local);+ let merged = merged.unwrap_or_else(|e| panic!("one orphan row dropped every local change: {}", e));+ assert!(live_totp_secrets(&merged).contains(&"LOCAL-NEW".to_string()));+}++#[test]+fn an_item_pointing_at_a_folder_neither_side_has_does_not_fail_the_whole_merge() {+ let (server, local) = synced_pair();+ exec(&local, "UPDATE Items SET FolderId = ?, Name = 'Edited', UpdatedAt = ? WHERE Id = ?", &[json!(FOLDER), json!(T2), json!(ITEM)]);+ insert_totp(&local, TOTP_B, ITEM, "LOCAL-NEW", T2, 0);+ let merged = merge_vaults(&server, &local);+ assert!(merged.is_ok(), "a dangling FolderId fails validation and drops the new TOTP code: {:?}", merged.err());+}++#[test]+fn a_merged_vault_merges_onto_itself_without_changes() {+ let (server, local) = synced_pair();+ insert_totp(&local, TOTP_B, ITEM, "LOCAL-NEW", T2, 0);+ insert_passkey(&local, "55555555-5555-4555-8555-555555555556", ITEM, json!(JWK), "mobile", T1, 0);+ let merged = merge_vaults(&server, &local).unwrap();+ let again = merge_vaults(&merged, &merged).unwrap();+ for sql in ["SELECT Id, SecretKey, UpdatedAt FROM TotpCodes", "SELECT Id, hex(UserHandle), hex(PrfKey), PrivateKey, UpdatedAt FROM Passkeys", "SELECT Id, Value FROM FieldValues"] {+ assert_eq!(strings(&merged, sql), strings(&again, sql), "{}", sql);+ }+}++#[test]+fn an_orphan_field_value_on_the_local_side_does_not_fail_the_whole_merge() {+ let (server, local) = synced_pair();+ insert_password(&local, "77777777-7777-4777-8777-777777777777", "orphan", T1);+ insert_totp(&local, TOTP_B, ITEM, "LOCAL-NEW", T1, 0);+ let merged = merge_vaults(&server, &local).unwrap_or_else(|e| panic!("one orphan field value dropped every local change: {}", e));+ assert_eq!(live_totp_secrets(&merged), vec!["LOCAL-NEW", "SECRET-A"]);+}++#[test]+fn an_item_tag_without_its_tag_does_not_fail_the_whole_merge() {+ let (server, local) = synced_pair();+ exec(&local, "INSERT INTO ItemTags (ManifestId, ItemId, TagId, CreatedAt, UpdatedAt, IsDeleted) VALUES (?, ?, '88888888-8888-4888-8888-888888888888', ?, ?, 0)", &[json!(PERSONAL), json!(ITEM), json!(T1), json!(T1)]);+ insert_totp(&local, TOTP_B, ITEM, "LOCAL-NEW", T1, 0);+ let merged = merge_vaults(&server, &local).unwrap_or_else(|e| panic!("one dangling item tag dropped every local change: {}", e));+ assert_eq!(live_totp_secrets(&merged), vec!["LOCAL-NEW", "SECRET-A"]);+}++#[test]+fn a_local_vault_with_a_dangling_folder_id_can_still_be_pushed() {+ let (_, local) = synced_pair();+ exec(&local, "UPDATE Items SET FolderId = ? WHERE Id = ?", &[json!(FOLDER), json!(ITEM)]);+ let canonical = canon(&local).unwrap();+ let validation = vault_codec::validate_manifest(&canonical.manifests[0].manifest);+ assert!(validation.ok, "push refused: {:?}", validation.failed_rules);+}++#[test]+#[ignore = "a custom field whose FieldDefinition is gone fails validation (fieldvalue-fielddef-fk-broken) and drops all local changes; nulling the id instead would collapse every such field of the item into one row"]+fn custom_fields_whose_definitions_are_gone_do_not_fail_the_whole_merge() {+ let (server, local) = synced_pair();+ for (def, value) in [("99999999-9999-4999-8999-999999999991", "one"), ("99999999-9999-4999-8999-999999999992", "two")] {+ exec(&local, "INSERT INTO FieldValues (ManifestId, Id, ItemId, FieldDefinitionId, Value, Weight, ValueIndex, CreatedAt, UpdatedAt, IsDeleted) VALUES (?, ?, ?, ?, ?, 0, 0, ?, ?, 0)", &[json!(PERSONAL), json!(crate::vault_sync::db::new_id()), json!(ITEM), json!(def), json!(value), json!(T1), json!(T1)]);+ }+ let merged = merge_vaults(&server, &local).unwrap_or_else(|e| panic!("{}", e));+ assert_eq!(strings(&merged, "SELECT Value FROM FieldValues WHERE IsDeleted = 0"), vec!["one", "pw-0", "two"]);+}++#[test]+#[ignore = "a move to another manifest leaves a tombstone newer than the other device's offline TOTP add, so the delete stands and the new code is dropped from both manifests"]+fn totp_added_offline_survives_the_other_device_moving_the_item_to_a_shared_vault() {+ let (server, local) = synced_pair();+ insert_totp(&local, TOTP_B, ITEM, "LOCAL-NEW", T1, 0);+ // The other device moves the item to the shared vault later; the schema trigger carries its rows along.+ exec(&server, "UPDATE Items SET ManifestId = ?, UpdatedAt = ? WHERE Id = ? AND ManifestId = ?", &[json!(SHARED), json!(T2), json!(ITEM), json!(PERSONAL)]);+ let server_side = canon_manifests(&server, &[PERSONAL, SHARED]).unwrap();+ let local_side = canon_manifests(&local, &[PERSONAL, SHARED]).unwrap();+ let merged = merge_canonical_sides(server_side.manifests.iter().map(|m| m.manifest.clone()).collect(), server_side.clone(), local_side).unwrap_or_else(|e| panic!("{}", e));+ assert!(live_totp_secrets(&merged).contains(&"LOCAL-NEW".to_string()), "codes now: {:?}", strings(&merged, "SELECT ManifestId || ':' || SecretKey FROM TotpCodes WHERE IsDeleted = 0"));+}diff --git a/core/rust/src/vault_sync/tests/mod.rs b/core/rust/src/vault_sync/tests/mod.rsindex fdffe90dc..31ad2ccd1 100644--- a/core/rust/src/vault_sync/tests/mod.rs+++ b/core/rust/src/vault_sync/tests/mod.rs@@ -1,6 +1,7 @@//! Engine tests: the whole sync driven through the command loop against a real SQLite host.mod item_move;+mod merge_edge_cases;mod test_host;mod unloaded_blobs;@@ -673,6 +674,35 @@ fn manifest_migration_generates_the_key_hierarchy_and_pushes() {assert_eq!(host.rekeyed_stores_found_the_chain, vec![true], "the chain is cached before the vault is stored under the VEK");}+#[test]+fn account_upgrade_decodes_base64_text_that_0_30_merges_left_in_blob_columns() {+ let kek = crypto::generate_key_base64();+ let mut host = TestHost::new(&kek);+ let item = "aaaaaaaa-0000-4000-8000-000000000001";+ let bytes = vec![0x00u8, 0xFF, 0xC3, 0x28, 0x10];+ let text = crate::common::encoding::base64_encode(&bytes);+ let now = crate::common::timestamp::now_vault_datetime();+ insert_item(&host.local, item, "Item", PERSONAL_MANIFEST_ID);+ host.local.execute("INSERT INTO Passkeys (ManifestId, Id, ItemId, RpId, UserHandle, PublicKey, PrivateKey, PrfKey, DisplayName, AdditionalData, CredentialId, CreatedAt, UpdatedAt, IsDeleted) VALUES (?, 'bbbbbbbb-0000-4000-8000-000000000001', ?, 'example.com', ?, 'pub', 'priv', 'not base64!', 'Passkey', NULL, NULL, ?, ?, 0)", rusqlite::params![PERSONAL_MANIFEST_ID, item, text, now, now]).unwrap();+ host.local.execute("INSERT INTO Attachments (ManifestId, Id, ItemId, Filename, Blob, CreatedAt, UpdatedAt, IsDeleted) VALUES (?, 'cccccccc-0000-4000-8000-000000000001', ?, 'file.bin', ?, ?, ?, 0)", rusqlite::params![PERSONAL_MANIFEST_ID, item, text, now, now]).unwrap();+ host.store_local_as_blob();+ host.state.insert(state::SERVER_MANIFEST_REVISIONS.to_string(), json!({ PERSONAL_MANIFEST_ID: 3 }));+ host.state.insert(state::VAULT_PERSONAL_MANIFEST_ID.to_string(), json!(PERSONAL_MANIFEST_ID));+ host.state.insert(state::VAULT_MANIFEST_SALT.to_string(), json!(vault_codec::generate_manifest_salt()));+ host.respond_with(Box::new(|method, path, _| if method == "GET" && path == "VaultKey/Password" { Some((200, json!({ "vaultKey": null }))) } else { None }));+ host.respond("POST", "Vault/blobs/missing", json!({ "missing": [] }));+ host.respond("POST", "Vault/blobs", json!({}));+ host.respond("POST", "Vault", json!({ "status": 0, "manifestRevisions": [{ "manifestId": PERSONAL_MANIFEST_ID, "revision": 4 }], "bucketRevisions": [], "missingBlobHashes": [] }));++ let result = host.drive(&SyncSession::new(&request("migrateManifest", &kek, false, 0)).unwrap());++ assert_eq!(result["success"], true, "{} {:?}", result, host.logs);+ let cell = |sql: &str| host.local.query_row(sql, [], |row| Ok((row.get::<_, String>(0)?, row.get_ref(1)?.as_bytes().map(<[u8]>::to_vec).ok()))).unwrap();+ assert_eq!(cell("SELECT typeof(UserHandle), UserHandle FROM Passkeys"), ("blob".to_string(), Some(bytes.clone())));+ assert_eq!(cell("SELECT typeof(Blob), Blob FROM Attachments"), ("blob".to_string(), Some(bytes)));+ assert_eq!(cell("SELECT typeof(PrfKey), PrfKey FROM Passkeys"), ("text".to_string(), Some(b"not base64!".to_vec())), "text that is not base64 is kept as-is");+}+/// The latest EF migration stamp of a database.fn latest_migration_id(conn: &rusqlite::Connection) -> String {query(conn, "SELECT MigrationId FROM __EFMigrationsHistory ORDER BY MigrationId DESC LIMIT 1", &[]).unwrap()[0]["MigrationId"].as_str().unwrap().to_string()