@vrtmrz/livesync-commonlib 0.1.31 → 0.1.33

package/dist/managers/HashManager/HashManager.d.ts

@@ -9,6 +9,9 @@ export declare class HashManager extends HashManagerCore {
      * Instance of the hash manager currently in use.
      */
     manager: HashManagerCore;
+    private chunkIdGenerator?;
+    clearCaches(): void;
+    private computeIndependentChunkId;
     /**
      * Checks whether the specified hash algorithm is available.
      *
@@ -43,6 +46,7 @@ export declare class HashManager extends HashManagerCore {
      * @returns The hash value (returned as a Promise)
      */
     computeHash(piece: string): Promise<string>;
+    usesIndependentIdKey(): boolean;
     /**
      * Computes the hash value without encryption.
      *

package/dist/managers/HashManager/HashManager.js

@@ -1,7 +1,8 @@
 import { FallbackWasmHashManager, XXHash32RawHashManager, XXHash64HashManager } from "./XXHashHashManager.js";
 import { FallbackPureJSHashManager, PureJSHashManager, SHA1HashManager } from "./PureJSHashManager.js";
-import { HashManagerCore } from "./HashManagerCore.js";
+import { HashEncryptedPrefix, HashManagerCore } from "./HashManagerCore.js";
 import { LOG_LEVEL_VERBOSE, Logger } from "../../common/logger.js";
+import { createChunkIdGenerator, configuredIdKey } from "../../common/idDerivation.js";
 const HashManagers = [
   XXHash64HashManager,
   XXHash32RawHashManager,
@@ -16,6 +17,22 @@ class HashManager extends HashManagerCore {
    * Instance of the hash manager currently in use.
    */
   manager = void 0;
+  chunkIdGenerator;
+  clearCaches() {
+    this.chunkIdGenerator = void 0;
+  }
+  async computeIndependentChunkId(key, piece) {
+    let cached = this.chunkIdGenerator;
+    if (cached?.key !== key) {
+      const entry = { key, task: createChunkIdGenerator(key) };
+      this.chunkIdGenerator = cached = entry;
+      void entry.task.catch(() => {
+        if (this.chunkIdGenerator === entry) this.clearCaches();
+      });
+    }
+    const generate = await cached.task;
+    return await generate(piece);
+  }
   /**
    * Checks whether the specified hash algorithm is available.
    *
@@ -71,7 +88,19 @@ class HashManager extends HashManagerCore {
    * @returns The hash value (returned as a Promise)
    */
   async computeHash(piece) {
-    return await this.manager.computeHash(piece);
+    const settings = this.options.settingService.currentSettings();
+    const key = configuredIdKey(settings);
+    if (settings.encrypt && key) {
+      return HashEncryptedPrefix + await this.computeIndependentChunkId(key, piece);
+    }
+    this.clearCaches();
+    return settings.encrypt ? HashEncryptedPrefix + await this.manager.computeHashWithEncryption(piece) : await this.manager.computeHashWithoutEncryption(piece);
+  }
+  usesIndependentIdKey() {
+    const settings = this.options.settingService.currentSettings();
+    const active = settings.encrypt && configuredIdKey(settings) !== false;
+    if (!active) this.clearCaches();
+    return active;
   }
   /**
    * Computes the hash value without encryption.
@@ -89,6 +118,9 @@ class HashManager extends HashManagerCore {
    * @returns The hash value (returned as a Promise)
    */
   computeHashWithEncryption(piece) {
+    const key = configuredIdKey(this.options.settingService.currentSettings());
+    if (key) return this.computeIndependentChunkId(key, piece);
+    this.clearCaches();
     return this.manager.computeHashWithEncryption(piece);
   }
 }

package/dist/managers/LiveSyncManagers.js

@@ -39,6 +39,8 @@ class LiveSyncManagers {
   }
   async teardownManagers() {
     this.log("Teardown LiveSync Managers...", LOG_LEVEL_VERBOSE);
+    this.hashManager?.clearCaches();
+    this.entryManager?.hashManager?.clearCaches();
     if (this.changeManager) {
       this.changeManager.teardown();
       this.changeManager = void 0;
@@ -123,8 +125,12 @@ class LiveSyncManagers {
   }
   clearCaches() {
     this.chunkManager?.clearCaches();
+    this.hashManager?.clearCaches();
+    this.entryManager?.hashManager?.clearCaches();
   }
   async prepareHashFunction() {
+    this.hashManager?.clearCaches();
+    this.entryManager?.hashManager?.clearCaches();
     this.hashManager = new HashManager({
       settingService: this.options.settingService
     });

package/dist/pouchdb/LiveSyncDBFunctions.d.ts

@@ -1,6 +1,6 @@
 import { type EntryDoc, type EntryMilestoneInfo, type RemoteDBSettings, type ChunkVersionRange, type TweakValues, type DeviceInfo, type TweakAssessment } from "../common/types.js";
 export declare function getEffectiveTweakValues(setting: RemoteDBSettings): TweakValues;
-export type ENSURE_DB_RESULT = "OK" | "INCOMPATIBLE" | "LOCKED" | "NODE_LOCKED" | "NODE_CLEANED" | ["MISMATCHED", TweakValues];
+export type ENSURE_DB_RESULT = "OK" | "INCOMPATIBLE" | "ID_KEY_MISMATCH" | "LOCKED" | "NODE_LOCKED" | "NODE_CLEANED" | ["MISMATCHED", TweakValues];
 /**
  * Ensures that the remote database is compatible with the current device.
  *

package/dist/pouchdb/LiveSyncDBFunctions.js

@@ -34,7 +34,38 @@ async function ensureRemoteIsCompatible(infoSrc, setting, deviceNodeID, currentV
   let remoteMilestone = infoSrc;
   if (!remoteMilestone) remoteMilestone = baseMilestone;
   const currentTweakValues = getEffectiveTweakValues(setting);
-  remoteMilestone.node_chunk_info = { ...baseMilestone.node_chunk_info, ...remoteMilestone.node_chunk_info };
+  const nodeChunkInfo = { ...baseMilestone.node_chunk_info, ...remoteMilestone.node_chunk_info };
+  let globalMin = currentVersionRange.min;
+  let globalMax = currentVersionRange.max;
+  for (const nodeId of remoteMilestone.accepted_nodes) {
+    if (nodeId == deviceNodeID) continue;
+    if (nodeId in nodeChunkInfo) {
+      const nodeInfo = nodeChunkInfo[nodeId];
+      globalMin = Math.max(nodeInfo.min, globalMin);
+      globalMax = Math.min(nodeInfo.max, globalMax);
+    } else {
+      globalMin = 0;
+      globalMax = 0;
+    }
+  }
+  if (globalMax < globalMin && !setting.ignoreVersionCheck) {
+    return "INCOMPATIBLE";
+  }
+  const preferred_tweak = remoteMilestone.tweak_values?.[DEVICE_ID_PREFERRED] ?? currentTweakValues;
+  const tweakAssessment = assessTweakCompatibility(currentTweakValues, preferred_tweak);
+  if (tweakAssessment.entries.some(({ key, relation }) => key === "idDerivationVersion" && relation === "different")) {
+    return "ID_KEY_MISMATCH";
+  }
+  if (!setting.disableCheckingConfigMismatch) {
+    recordTweakAssessment?.(tweakAssessment);
+    if (tweakAssessment.alignment === "mismatched") {
+      return ["MISMATCHED", preferred_tweak];
+    }
+  }
+  if (remoteMilestone.locked && remoteMilestone.accepted_nodes.indexOf(deviceNodeID) == -1) {
+    return remoteMilestone.cleaned ? "NODE_CLEANED" : "NODE_LOCKED";
+  }
+  remoteMilestone.node_chunk_info = nodeChunkInfo;
   let writeMilestone = remoteMilestone.node_chunk_info[deviceNodeID].min != currentVersionRange.min || remoteMilestone.node_chunk_info[deviceNodeID].max != currentVersionRange.max || isObjectDifferent(remoteMilestone.tweak_values?.[deviceNodeID], currentTweakValues) || typeof remoteMilestone._rev == "undefined" || !(DEVICE_ID_PREFERRED in remoteMilestone.tweak_values);
   if (!remoteMilestone.node_info) {
     remoteMilestone.node_info = {};
@@ -69,43 +100,7 @@ async function ensureRemoteIsCompatible(infoSrc, setting, deviceNodeID, currentV
     }
     await updateCallback(remoteMilestone);
   }
-  let globalMin = currentVersionRange.min;
-  let globalMax = currentVersionRange.max;
-  for (const nodeId of remoteMilestone.accepted_nodes) {
-    if (nodeId == deviceNodeID) continue;
-    if (nodeId in remoteMilestone.node_chunk_info) {
-      const nodeInfo = remoteMilestone.node_chunk_info[nodeId];
-      globalMin = Math.max(nodeInfo.min, globalMin);
-      globalMax = Math.min(nodeInfo.max, globalMax);
-    } else {
-      globalMin = 0;
-      globalMax = 0;
-    }
-  }
-  if (globalMax < globalMin) {
-    if (!setting.ignoreVersionCheck) {
-      return "INCOMPATIBLE";
-    }
-  }
-  if (!setting.disableCheckingConfigMismatch) {
-    const preferred_tweak = remoteMilestone.tweak_values?.[DEVICE_ID_PREFERRED] ?? currentTweakValues;
-    const current_tweak = currentTweakValues;
-    const tweakAssessment = assessTweakCompatibility(current_tweak, preferred_tweak);
-    recordTweakAssessment?.(tweakAssessment);
-    if (tweakAssessment.alignment === "mismatched") {
-      return ["MISMATCHED", preferred_tweak];
-    }
-  }
-  if (remoteMilestone.locked) {
-    if (remoteMilestone.accepted_nodes.indexOf(deviceNodeID) == -1) {
-      if (remoteMilestone.cleaned) {
-        return "NODE_CLEANED";
-      }
-      return "NODE_LOCKED";
-    }
-    return "LOCKED";
-  }
-  return "OK";
+  return remoteMilestone.locked ? "LOCKED" : "OK";
 }
 async function ensureDatabaseIsCompatible(db, setting, deviceNodeID, currentVersionRange, nodeDeviceInfo, recordTweakAssessment) {
   const remoteMilestone = await resolveWithIgnoreKnownError(

package/dist/pouchdb/negotiation.js

@@ -9,7 +9,7 @@ import { isErrorOfMissingDoc } from "./utils_couchdb.js";
 import {
   assessRemoteFeatureDocument,
   describeRemoteFeatureRejection,
-  ENCRYPTED_INTERNAL_METADATA_FEATURE,
+  supportedFeatures,
   REMOTE_FEATURE_GENERATION
 } from "./remoteFeatureCompatibility.js";
 const checkRemoteVersion = async (db, migrate, barrier = VER, requiredFeatures = []) => {
@@ -32,7 +32,11 @@ const checkRemoteVersion = async (db, migrate, barrier = VER, requiredFeatures =
     if (isErrorOfMissingDoc(ex)) {
       const info = await db.info();
       if (info.doc_count > 0) return false;
-      return await bumpRemoteVersion(db, requiredFeatures.length ? REMOTE_FEATURE_GENERATION : VER, requiredFeatures);
+      return await bumpRemoteVersion(
+        db,
+        requiredFeatures.length ? REMOTE_FEATURE_GENERATION : VER,
+        requiredFeatures
+      );
     }
     throw ex;
   }
@@ -75,7 +79,7 @@ const bumpRemoteVersion = async (db, barrier = VER, usedFeatures = []) => {
 };
 async function declareRemoteFeatures(db, requiredFeatures) {
   const requested = [...new Set(requiredFeatures)];
-  if (requested.some((name) => name !== ENCRYPTED_INTERNAL_METADATA_FEATURE)) {
+  if (requested.some((name) => !supportedFeatures.has(name))) {
     throw new Error("A writer requested an unsupported remote feature.");
   }
   if (requested.length === 0) return true;

package/dist/pouchdb/remoteFeatureCompatibility.d.ts

@@ -1,5 +1,15 @@
 export declare const REMOTE_FEATURE_GENERATION = 13;
 export declare const ENCRYPTED_INTERNAL_METADATA_FEATURE = "encrypted-internal-metadata-v1";
+export declare const INDEPENDENT_ID_DERIVATION_FEATURE = "independent-id-derivation-v1";
+export declare const supportedFeatures: Set<string>;
+export declare function requiredRemoteFeatures(setting: {
+    encrypt?: boolean;
+    usePathObfuscation?: boolean;
+    E2EEAlgorithm?: string;
+    encryptInternalMetadata?: boolean;
+    idDerivationVersion: 0 | 1;
+    idDerivationKey: string;
+}): string[];
 export declare function usesEncryptedInternalMetadata(setting: {
     encrypt?: boolean;
     usePathObfuscation?: boolean;

package/dist/pouchdb/remoteFeatureCompatibility.js

@@ -1,7 +1,15 @@
 import { E2EEAlgorithms, VERSIONING_DOCID } from "../common/types.js";
+import { configuredIdKey } from "../common/idDerivation.js";
 const REMOTE_FEATURE_GENERATION = 13;
 const ENCRYPTED_INTERNAL_METADATA_FEATURE = "encrypted-internal-metadata-v1";
-const supportedFeatures = /* @__PURE__ */ new Set([ENCRYPTED_INTERNAL_METADATA_FEATURE]);
+const INDEPENDENT_ID_DERIVATION_FEATURE = "independent-id-derivation-v1";
+const supportedFeatures = /* @__PURE__ */ new Set([ENCRYPTED_INTERNAL_METADATA_FEATURE, INDEPENDENT_ID_DERIVATION_FEATURE]);
+function requiredRemoteFeatures(setting) {
+  const features = [];
+  if (usesEncryptedInternalMetadata(setting)) features.push(ENCRYPTED_INTERNAL_METADATA_FEATURE);
+  if (setting.encrypt && configuredIdKey(setting)) features.push(INDEPENDENT_ID_DERIVATION_FEATURE);
+  return features;
+}
 function usesEncryptedInternalMetadata(setting) {
   return setting.encryptInternalMetadata === true && setting.encrypt === true && setting.usePathObfuscation === true && setting.E2EEAlgorithm === E2EEAlgorithms.V2;
 }
@@ -45,8 +53,11 @@ function describeRemoteFeatureRejection(assessment) {
 }
 export {
   ENCRYPTED_INTERNAL_METADATA_FEATURE,
+  INDEPENDENT_ID_DERIVATION_FEATURE,
   REMOTE_FEATURE_GENERATION,
   assessRemoteFeatureDocument,
   describeRemoteFeatureRejection,
+  requiredRemoteFeatures,
+  supportedFeatures,
   usesEncryptedInternalMetadata
 };

package/dist/pouchdb/remoteIdCompatibility.d.ts

@@ -0,0 +1,5 @@
+import type { DocumentID, EntryDoc, RemoteDBSettings } from "../common/types.js";
+import { type FilePathWithPrefix } from "../common/types.js";
+export type RemoteIdCompatibility = "matching" | "mismatched" | "unverified";
+/** Check a bounded set of existing document IDs before admitting an ID configuration. */
+export declare function assessRemoteDocumentIds(db: PouchDB.Database<EntryDoc>, setting: Pick<RemoteDBSettings, "encrypt" | "idDerivationVersion" | "idDerivationKey" | "usePathObfuscation" | "passphrase" | "handleFilenameCaseSensitive">, path2id: (path: FilePathWithPrefix) => Promise<DocumentID>): Promise<RemoteIdCompatibility>;

package/dist/pouchdb/remoteIdCompatibility.js

@@ -0,0 +1,28 @@
+import { configuredIdKey } from "../common/idDerivation.js";
+import { ICHeader, ICXHeader, PSCHeader } from "../common/models/fileaccess.const.js";
+import { PREFIX_OBFUSCATED } from "../common/types.js";
+async function assessRemoteDocumentIds(db, setting, path2id) {
+  configuredIdKey(setting);
+  if (!setting.encrypt || !setting.usePathObfuscation) return "unverified";
+  let matched = false;
+  for (const prefix of [
+    PREFIX_OBFUSCATED,
+    `${ICHeader}${PREFIX_OBFUSCATED}`,
+    `${ICXHeader}${PREFIX_OBFUSCATED}`,
+    `${PSCHeader}${PREFIX_OBFUSCATED}`
+  ]) {
+    const rows = await db.allDocs({ startkey: prefix, endkey: `${prefix}\uFFF0`, limit: 2 });
+    for (const row of rows.rows) {
+      if ("error" in row || !row.id) continue;
+      const doc = await db.get(row.id);
+      if (!("path" in doc) || typeof doc.path !== "string") continue;
+      const expected = await path2id(doc.path);
+      if (expected !== doc._id) return "mismatched";
+      matched = true;
+    }
+  }
+  return matched ? "matching" : "unverified";
+}
+export {
+  assessRemoteDocumentIds
+};

package/dist/replication/CentralCompatibility.d.ts

@@ -11,6 +11,7 @@ export declare const CENTRAL_COMPATIBILITY_REJECTION_REASONS: Readonly<{
     readonly NODE_LOCKED: "node-locked";
     readonly NODE_CLEANED: "node-cleaned";
     readonly TWEAK_MISMATCH: "tweak-mismatch";
+    readonly ID_DERIVATION_MISMATCH: "id-derivation-mismatch";
 }>;
 export type CentralCompatibilityRejectionReason = (typeof CENTRAL_COMPATIBILITY_REJECTION_REASONS)[keyof typeof CENTRAL_COMPATIBILITY_REJECTION_REASONS];
 export declare const CENTRAL_COMPATIBILITY_NOT_ASSESSED: Readonly<{

package/dist/replication/CentralCompatibility.js

@@ -7,7 +7,8 @@ const CENTRAL_COMPATIBILITY_REJECTION_REASONS = Object.freeze({
   INCOMPATIBLE_VERSION: "incompatible-version",
   NODE_LOCKED: "node-locked",
   NODE_CLEANED: "node-cleaned",
-  TWEAK_MISMATCH: "tweak-mismatch"
+  TWEAK_MISMATCH: "tweak-mismatch",
+  ID_DERIVATION_MISMATCH: "id-derivation-mismatch"
 });
 const CENTRAL_COMPATIBILITY_NOT_ASSESSED = Object.freeze({
   status: CENTRAL_COMPATIBILITY_STATUSES.NOT_ASSESSED

package/dist/replication/couchdb/LiveSyncReplicator.d.ts

@@ -1,16 +1,20 @@
 import { type EntryDoc, type RemoteDBSettings, type EntryLeaf, type SyncParameters, type DatabaseEntry, type NodeData, type RemotePreferredTweakResult } from "../../common/types.js";
 import { LiveSyncAbstractReplicator, type LiveSyncReplicatorEnv, type RemoteDBStatus } from "../LiveSyncAbstractReplicator.js";
 import type { OwnedCouchDBConnection, RemoteConnectionOpenOptions } from "../../services/base/RemoteConnection.js";
+import type { IPathService } from "../../services/base/IService.js";
 import { type CentralCompatibilityDecisionRecorder } from "../CentralCompatibility.js";
 import { type ReplicationOutcome } from "../ReplicatorProvider.js";
 export type { OwnedCouchDBConnection, RemoteConnectionOpenOptions } from "../../services/base/RemoteConnection.js";
 /**
  * Compatibility constructor environment for the CouchDB Replicator facade.
  *
- * CouchDB adds only the bounded one-shot preflight policy to the shared
- * Replicator environment. Active-provider capabilities remain separate.
+ * CouchDB needs the host path service for remote ID checks and adds the
+ * bounded one-shot preflight policy. Active-provider capabilities remain separate.
  */
 export interface LiveSyncCouchDBReplicatorEnv extends LiveSyncReplicatorEnv {
+    services: LiveSyncReplicatorEnv["services"] & {
+        path: IPathService;
+    };
     /** Internal injection point for the bounded one-shot connectivity preflight. */
     oneShotConnectivityTimeoutMs?: number;
 }

package/dist/replication/couchdb/LiveSyncReplicator.js

@@ -22,10 +22,8 @@ import {
 } from "../../common/utils.js";
 import { Logger } from "../../common/logger.js";
 import { checkRemoteVersion, countCompromisedChunks, declareRemoteFeatures } from "../../pouchdb/negotiation.js";
-import {
-  ENCRYPTED_INTERNAL_METADATA_FEATURE,
-  usesEncryptedInternalMetadata
-} from "../../pouchdb/remoteFeatureCompatibility.js";
+import { requiredRemoteFeatures, usesEncryptedInternalMetadata } from "../../pouchdb/remoteFeatureCompatibility.js";
+import { assessRemoteDocumentIds } from "../../pouchdb/remoteIdCompatibility.js";
 import { isErrorOfMissingDoc } from "../../pouchdb/utils_couchdb.js";
 import { preprocessOutgoing } from "../../pouchdb/encryption.js";
 import { ensureDatabaseIsCompatible, getEffectiveTweakValues } from "../../pouchdb/LiveSyncDBFunctions.js";
@@ -889,6 +887,21 @@ ${sendingDocs}/(${sentDocsCount} done)`,
         this.remoteLockedAndDeviceNotAccepted = false;
         this.tweakSettingsMismatched = false;
         this.preferredTweakValue = void 0;
+        const idCompatibility = await assessRemoteDocumentIds(
+          dbRet.db,
+          setting,
+          (path) => this.env.services.path.path2idWithSettings(path, setting)
+        );
+        if (idCompatibility === "mismatched") {
+          recordCompatibilityDecision?.(
+            centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.ID_DERIVATION_MISMATCH)
+          );
+          Logger("The remote document IDs do not match the configured ID key.", LOG_LEVEL_NOTICE);
+          return false;
+        }
+        if (idCompatibility === "unverified" && setting.idDerivationVersion === 1 && setting.usePathObfuscation) {
+          Logger("No remote document was available to verify the configured ID key.", LOG_LEVEL_INFO);
+        }
         if (!await checkRemoteVersion(dbRet.db, this.migrate.bind(this), VER)) {
           recordCompatibilityDecision?.(
             centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.INCOMPATIBLE_VERSION)
@@ -953,6 +966,11 @@ ${sendingDocs}/(${sentDocsCount} done)`,
             this.remoteCleaned = true;
             return false;
           }
+        } else if (ensure == "ID_KEY_MISMATCH") {
+          recordCompatibilityDecision?.(
+            centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.ID_DERIVATION_MISMATCH)
+          );
+          return false;
         } else if (ensure == "OK") {
         } else if (ensure[0] == "MISMATCHED") {
           recordCompatibilityDecision?.(
@@ -967,7 +985,8 @@ ${sendingDocs}/(${sentDocsCount} done)`,
           this.preferredTweakValue = ensure[1];
           return false;
         }
-        if (usesEncryptedInternalMetadata(setting) && !await declareRemoteFeatures(dbRet.db, [ENCRYPTED_INTERNAL_METADATA_FEATURE])) {
+        const requiredFeatures = requiredRemoteFeatures(setting);
+        if (requiredFeatures.length > 0 && !await declareRemoteFeatures(dbRet.db, requiredFeatures)) {
           recordCompatibilityDecision?.(
             centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.INCOMPATIBLE_VERSION)
           );

package/dist/replication/journal/LiveSyncJournalReplicator.d.ts

@@ -53,6 +53,7 @@ export declare class LiveSyncJournalReplicator extends LiveSyncAbstractReplicato
     closeReplication(): void;
     tryResetRemoteDatabase(setting: RemoteDBSettings): Promise<void>;
     tryCreateRemoteDatabase(setting: RemoteDBSettings): Promise<void>;
+    private createInitialIdDerivationProof;
     markRemoteLocked(setting: RemoteDBSettings, locked: boolean, lockByClean: boolean): Promise<void>;
     markRemoteResolved(setting: RemoteDBSettings): Promise<void>;
     tryConnectRemote(setting: RemoteDBSettings, showResult?: boolean): Promise<boolean>;

package/dist/replication/journal/LiveSyncJournalReplicator.js

@@ -12,6 +12,8 @@ import { LiveSyncAbstractReplicator } from "../LiveSyncAbstractReplicator.js";
 import { ensureRemoteIsCompatible } from "../../pouchdb/LiveSyncDBFunctions.js";
 import { getEffectiveTweakValues } from "../../pouchdb/LiveSyncDBFunctions.js";
 import { JournalStorageReadStatuses } from "./objectstore/JournalStorageAdapter.js";
+import { computeKeyedId, configuredIdKey } from "../../common/idDerivation.js";
+import { decryptString, encryptString } from "../../encryption/stringEncryption.js";
 import {
   CENTRAL_COMPATIBILITY_ACCEPTED,
   CENTRAL_COMPATIBILITY_NOT_ASSESSED,
@@ -35,6 +37,9 @@ const currentVersionRange = {
   max: 2,
   current: 2
 };
+function journalVersionRange(setting) {
+  return configuredIdKey(setting) && setting.encrypt && setting.usePathObfuscation ? { min: 3, max: 3, current: 3 } : currentVersionRange;
+}
 class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   get client() {
     return this.setupJournalSyncClient();
@@ -73,6 +78,27 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       throw milestoneResult.error;
     }
     const downloadedMilestone = milestoneResult.status === JournalStorageReadStatuses.AVAILABLE ? milestoneResult.value : false;
+    const idKey = configuredIdKey(setting);
+    let encryptedProof;
+    const preferredTweak = downloadedMilestone && downloadedMilestone.tweak_values?.[DEVICE_ID_PREFERRED];
+    if (preferredTweak?.idDerivationVersion === 1 && preferredTweak.usePathObfuscation === true && (!idKey || !setting.encrypt || !setting.usePathObfuscation)) {
+      return "ID_KEY_MISMATCH";
+    }
+    if (idKey && setting.encrypt && setting.usePathObfuscation) {
+      const expected = await computeKeyedId(idKey, "remote-agreement", "journal-milestone-v1");
+      const stored = downloadedMilestone && downloadedMilestone.encrypted_id_derivation_proof;
+      if (stored) {
+        try {
+          if (await decryptString(stored, setting.passphrase) !== expected) return "ID_KEY_MISMATCH";
+        } catch {
+          return "ID_KEY_MISMATCH";
+        }
+      } else if (downloadedMilestone) {
+        return "ID_KEY_MISMATCH";
+      } else {
+        encryptedProof = await encryptString(expected, setting.passphrase);
+      }
+    }
     const cPointInfo = await client.getCheckpointInfo();
     const progress = [...cPointInfo?.receivedFiles || []].sort().pop() || "";
     return await ensureRemoteIsCompatible(
@@ -88,6 +114,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
         progress
       },
       async (info) => {
+        if (encryptedProof) info.encrypted_id_derivation_proof = encryptedProof;
         if (!await client.uploadJson(MILSTONE_DOCID, info)) {
           throw new Error("Could not upload remote milestone");
         }
@@ -269,7 +296,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       let tweakAssessment;
       const ensure = await this.ensureBucketIsCompatible(
         this.nodeid,
-        currentVersionRange,
+        journalVersionRange(setting),
         setting,
         client,
         (assessment) => {
@@ -285,6 +312,12 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
           LOG_LEVEL_NOTICE
         );
         return false;
+      } else if (ensure == "ID_KEY_MISMATCH") {
+        recordCompatibilityDecision?.(
+          centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.ID_DERIVATION_MISMATCH)
+        );
+        Logger("The remote ID derivation key does not match this device.", LOG_LEVEL_NOTICE);
+        return false;
       } else if (ensure == "NODE_LOCKED") {
         recordCompatibilityDecision?.(
           centralCompatibilityRejected(CENTRAL_COMPATIBILITY_REJECTION_REASONS.NODE_LOCKED)
@@ -366,6 +399,12 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     }
     return await Promise.resolve();
   }
+  async createInitialIdDerivationProof(setting) {
+    const idKey = configuredIdKey(setting);
+    if (!idKey || !setting.encrypt || !setting.usePathObfuscation) return void 0;
+    const proof = await computeKeyedId(idKey, "remote-agreement", "journal-milestone-v1");
+    return await encryptString(proof, setting.passphrase);
+  }
   async markRemoteLocked(setting, locked, lockByClean) {
     const defInitPoint = {
       _id: MILSTONE_DOCID,
@@ -374,14 +413,17 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       locked,
       cleaned: lockByClean,
       accepted_nodes: [this.nodeid],
-      node_chunk_info: { [this.nodeid]: currentVersionRange },
+      node_chunk_info: { [this.nodeid]: journalVersionRange(setting) },
       node_info: {},
       tweak_values: {}
     };
     const client = this.setupJournalSyncClient(setting);
+    const existingMilestone = await readRemoteMilestone(client);
+    const initialProof = existingMilestone ? void 0 : await this.createInitialIdDerivationProof(setting);
     const remoteMilestone = {
       ...defInitPoint,
-      ...await readRemoteMilestone(client) ?? {}
+      ...existingMilestone ?? {},
+      ...initialProof ? { encrypted_id_derivation_proof: initialProof } : {}
     };
     remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
     remoteMilestone.accepted_nodes = [this.nodeid];
@@ -403,14 +445,17 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       created: Date.now(),
       locked: false,
       accepted_nodes: [this.nodeid],
-      node_chunk_info: { [this.nodeid]: currentVersionRange },
+      node_chunk_info: { [this.nodeid]: journalVersionRange(setting) },
       node_info: {},
       tweak_values: {}
     };
     const client = this.setupJournalSyncClient(setting);
+    const existingMilestone = await readRemoteMilestone(client);
+    const initialProof = existingMilestone ? void 0 : await this.createInitialIdDerivationProof(setting);
     const remoteMilestone = {
       ...defInitPoint,
-      ...await readRemoteMilestone(client) ?? {}
+      ...existingMilestone ?? {},
+      ...initialProof ? { encrypted_id_derivation_proof: initialProof } : {}
     };
     remoteMilestone.node_chunk_info = { ...defInitPoint.node_chunk_info, ...remoteMilestone.node_chunk_info };
     remoteMilestone.accepted_nodes = Array.from(/* @__PURE__ */ new Set([...remoteMilestone.accepted_nodes, this.nodeid]));

package/dist/replication/trystero/ProxiedDB.d.ts

@@ -4,7 +4,7 @@ export declare function createHostingDB(env: ReplicatorHostEnv): {
     info: () => Promise<PouchDB.Core.DatabaseInfo>;
     changes: (options: PouchDB.Core.ChangesOptions) => PouchDB.Core.Changes<EntryDoc>;
     revsDiff: (diff: PouchDB.Core.RevisionDiffOptions) => Promise<PouchDB.Core.RevisionDiffResponse>;
-    bulkDocs: (docs: PouchDB.Core.PutDocument<EntryDoc & Record<string, unknown>>[], options?: PouchDB.Core.BulkDocsOptions) => Promise<(PouchDB.Core.Response | PouchDB.Core.Error)[]>;
+    bulkDocs: (docs: PouchDB.Core.PutDocument<EntryDoc & Record<string, unknown>>[], options?: PouchDB.Core.BulkDocsOptions) => Promise<(PouchDB.Core.Error | PouchDB.Core.Response)[]>;
     bulkGet: (options: PouchDB.Core.BulkGetOptions) => Promise<PouchDB.Core.BulkGetResponse<EntryDoc>>;
     put: (doc: PouchDB.Core.PutDocument<EntryDoc & Record<string, unknown>>, options?: PouchDB.Core.PutOptions) => Promise<PouchDB.Core.Response>;
     get: (id: string, options?: PouchDB.Core.GetOptions) => Promise<EntryDoc & PouchDB.Core.IdMeta & PouchDB.Core.GetMeta>;