@idos-network/enclave 1.5.0 → 2.2.2

package/src/local.test.ts

@@ -1,4 +1,4 @@
-import type { idOSCredential } from "@idos-network/credentials/types";
+import type { idOSCredentialRecord as idOSCredential } from "@idos-network/credentials/types";
 
 import { base64Decode, base64Encode, utf8Encode } from "@idos-network/utils/codecs";
 import { encryptContent } from "@idos-network/utils/cryptography";
@@ -6,8 +6,24 @@ import { MemoryStore } from "@idos-network/utils/store";
 import tweetnacl from "tweetnacl";
 import { describe, expect, it, vi } from "vitest";
 
+import { STORAGE_KEYS } from "./keys.js";
 import { LocalEnclave, type LocalEnclaveOptions } from "./local.js";
 
+// ponytail: real scrypt (N=16384) runs on every obfuscated store read/write, which is
+// several hundred ms per test and times out on CI. The codec only needs a deterministic
+// key of the right length, not a real KDF.
+vi.mock("scrypt-js", () => ({
+  syncScrypt: (
+    _password: Uint8Array,
+    salt: Uint8Array,
+    _n: number,
+    _r: number,
+    _p: number,
+    dkLen: number,
+  ) =>
+    new Uint8Array(Array.from({ length: dkLen }, (_, index) => salt[index % salt.length] ^ index)),
+}));
+
 vi.mock("@idos-network/utils/encryption", async (importOriginal) => {
   const actual = await importOriginal<typeof import("@idos-network/utils/encryption")>();
 
@@ -19,8 +35,20 @@ vi.mock("@idos-network/utils/encryption", async (importOriginal) => {
   };
 });
 
+// Obfuscated store uses syncScrypt(N=16384); keep tests under vitest's default 5s timeout on CI.
+vi.mock("scrypt-js", () => ({
+  syncScrypt: vi.fn(
+    (_password: Uint8Array, _salt: Uint8Array, _N: number, _r: number, _p: number, dkLen: number) =>
+      new Uint8Array(dkLen).fill(7),
+  ),
+}));
+
 class TestEnclave extends LocalEnclave {
+  userIdPresentOnPrompt: boolean[] = [];
+
   async getPasswordContext() {
+    this.userIdPresentOnPrompt.push((await this.store.get(STORAGE_KEYS.USER_ID)) !== undefined);
+
     return {
       encryptionPasswordStore: "user",
       password: "super-secret",
@@ -29,9 +57,116 @@ class TestEnclave extends LocalEnclave {
   }
 }
 
+class MPCTestEnclave extends LocalEnclave {
+  mpcPassword = "super-secret";
+
+  async getPasswordContext() {
+    return {
+      encryptionPasswordStore: "mpc",
+    } as const;
+  }
+
+  protected async ensureMPCPassword() {
+    return this.mpcPassword;
+  }
+}
+
 describe("LocalEnclave", () => {
   const userId = "9f51b3b2-4cbe-4c2b-8ea3-0b0c1b2f1a11";
 
+  it("rejects passwords whose derived public key does not match expectedUserEncryptionPublicKey", async () => {
+    const store = new MemoryStore();
+    const enclave = new TestEnclave({
+      userId,
+      store,
+      expectedUserEncryptionPublicKey: base64Encode(new Uint8Array(32).fill(1)),
+    } as LocalEnclaveOptions);
+
+    await expect(
+      enclave.createEncryptionProfileFromPassword("super-secret", userId, "user"),
+    ).rejects.toThrow(
+      "Derived encryption public key does not match expectedUserEncryptionPublicKey",
+    );
+  });
+
+  it("accepts passwords whose derived public key matches expectedUserEncryptionPublicKey", async () => {
+    const store = new MemoryStore();
+    const enclave = new TestEnclave({ userId, store } as LocalEnclaveOptions);
+    const { keyPair } = await enclave.createEncryptionProfileFromPassword(
+      "super-secret",
+      userId,
+      "user",
+    );
+
+    const matchingEnclave = new TestEnclave({
+      userId,
+      store: new MemoryStore(),
+      expectedUserEncryptionPublicKey: base64Encode(keyPair.publicKey),
+    } as LocalEnclaveOptions);
+
+    await expect(
+      matchingEnclave.createEncryptionProfileFromPassword("super-secret", userId, "user"),
+    ).resolves.toMatchObject({ userId, encryptionPasswordStore: "user" });
+  });
+
+  it("rejects MPC unlock when the downloaded password derives a mismatched public key", async () => {
+    const store = new MemoryStore();
+    const enclave = new MPCTestEnclave({
+      userId,
+      store,
+      mode: "existing",
+      expectedUserEncryptionPublicKey: base64Encode(new Uint8Array(32).fill(1)),
+    } as LocalEnclaveOptions);
+
+    await expect(enclave.getPrivateEncryptionProfile()).rejects.toThrow(
+      "Derived encryption public key does not match expectedUserEncryptionPublicKey",
+    );
+  });
+
+  it("requires origin authorization after deriving a key and keeps the profile if denied", async () => {
+    const store = new MemoryStore();
+    const enclave = new TestEnclave({ userId, store } as LocalEnclaveOptions);
+    let allowed = false;
+    const guard = vi.spyOn(enclave, "guardKeys").mockImplementation(async () => allowed);
+    const passwordContextSpy = vi.spyOn(enclave, "getPasswordContext");
+
+    await expect(enclave.getPrivateEncryptionProfile()).rejects.toThrow(
+      "Origin is not authorized to use the keys",
+    );
+    expect(passwordContextSpy).toHaveBeenCalledTimes(1);
+    expect(guard).toHaveBeenCalledTimes(1);
+
+    allowed = true;
+    const profile = await enclave.getPrivateEncryptionProfile();
+
+    expect(profile.userId).toBe(userId);
+    expect(passwordContextSpy).toHaveBeenCalledTimes(1);
+    expect(guard).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not check origin authorization when the guard is skipped", async () => {
+    const enclave = new TestEnclave({ userId, store: new MemoryStore() } as LocalEnclaveOptions);
+    const guard = vi.spyOn(enclave, "guardKeys");
+
+    await enclave.getPrivateEncryptionProfile(true);
+
+    expect(guard).not.toHaveBeenCalled();
+  });
+
+  it("does not request a password context for an MM profile without a stored key", async () => {
+    const enclave = new TestEnclave({
+      userId,
+      store: new MemoryStore(),
+      encryptionPasswordStore: "mm",
+    });
+    const passwordContextSpy = vi.spyOn(enclave, "getPasswordContext");
+
+    await expect(enclave.getPrivateEncryptionProfile()).rejects.toThrow(
+      "MM encryption profiles require an externally supplied encryption private key",
+    );
+    expect(passwordContextSpy).not.toHaveBeenCalled();
+  });
+
   it("creates and exposes a public encryption profile", async () => {
     const store = new MemoryStore();
     const enclave = new TestEnclave({ userId, store } as LocalEnclaveOptions);
@@ -121,4 +256,65 @@ describe("LocalEnclave", () => {
     expect(filtered[0]?.content).toBe("");
     expect(passwordContextSpy).toHaveBeenCalledTimes(1);
   });
+
+  it("wipes a live cached profile once the canonical public key rotates", async () => {
+    const store = new MemoryStore();
+    const enclave = new TestEnclave({ userId, store } as LocalEnclaveOptions);
+    const { keyPair } = await enclave.getPrivateEncryptionProfile();
+
+    await enclave.reconfigure({ expectedUserEncryptionPublicKey: base64Encode(keyPair.publicKey) });
+    expect((await enclave.getPrivateEncryptionProfile()).keyPair).toBe(keyPair);
+
+    await enclave.reconfigure({
+      expectedUserEncryptionPublicKey: base64Encode(new Uint8Array(32).fill(1)),
+    });
+    await expect(enclave.getPrivateEncryptionProfile()).rejects.toThrow(
+      "Derived encryption public key does not match expectedUserEncryptionPublicKey",
+    );
+    // Rotation reset before re-entry: the second prompt found an empty store.
+    expect(enclave.userIdPresentOnPrompt).toEqual([false, false]);
+    expect(await store.get(STORAGE_KEYS.OBFUSCATED_BASE64_ENCRYPTION_SECRET_KEY)).toBeUndefined();
+  });
+
+  it("wipes a reloaded cached profile whose key no longer matches the canonical key", async () => {
+    const store = new MemoryStore();
+    await new TestEnclave({ userId, store } as LocalEnclaveOptions).getPrivateEncryptionProfile();
+
+    const reloaded = new TestEnclave({
+      userId,
+      store,
+      expectedUserEncryptionPublicKey: base64Encode(new Uint8Array(32).fill(1)),
+    } as LocalEnclaveOptions);
+    await reloaded.load();
+
+    await expect(reloaded.encrypt(new Uint8Array([1]), new Uint8Array(32))).rejects.toThrow(
+      "Derived encryption public key does not match expectedUserEncryptionPublicKey",
+    );
+    expect(reloaded.userIdPresentOnPrompt).toEqual([false]);
+    expect(await store.get(STORAGE_KEYS.OBFUSCATED_BASE64_ENCRYPTION_SECRET_KEY)).toBeUndefined();
+  });
+
+  it("forgets a cached profile after the remember duration elapses", async () => {
+    vi.useFakeTimers({ toFake: ["Date"] });
+
+    try {
+      vi.setSystemTime(new Date("2026-01-01T00:00:00Z"));
+
+      const store = new MemoryStore();
+      const enclave = new TestEnclave({ userId, store } as LocalEnclaveOptions);
+      const first = await enclave.getPrivateEncryptionProfile();
+
+      expect(await enclave.getPrivateEncryptionProfile()).toBe(first);
+
+      vi.setSystemTime(new Date("2026-01-03T00:00:00Z"));
+      const after = await enclave.getPrivateEncryptionProfile();
+
+      expect(after).not.toBe(first);
+      expect(after.userId).toBe(userId);
+      // First prompt finds an empty store. The second must too: expiry resets before re-entry.
+      expect(enclave.userIdPresentOnPrompt).toEqual([false, false]);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });

package/src/local.ts

@@ -96,7 +96,7 @@ export class LocalEnclave<
   async reset(): Promise<void> {
     await super.reset();
     this.storedEncryptionProfile = undefined;
-    this.store.reset();
+    await this.store.reset();
   }
 
   /** @override parent method to reconfigure the enclave */
@@ -266,26 +266,39 @@ export class LocalEnclave<
    * @see BaseProvider#getPrivateEncryptionProfile
    */
   async getPrivateEncryptionProfile(skipGuard = false): Promise<PrivateEncryptionProfile> {
-    // In case there is a no key pair, which matches we don't need a new one.
-    if (this.storedEncryptionProfile) {
-      let canBeUsed = this.storedEncryptionProfile.userId === this.userId;
+    // Remember duration is a key-use check. A long-lived iframe keeps this profile
+    // in memory, so construction-time store expiry is not enough.
+    if (this.storedEncryptionProfile && (await this.store.hasRememberDurationElapsed())) {
+      await this.reset();
+    }
 
-      if (canBeUsed && !skipGuard) {
-        // When users matches, we also need to check
-        // if origin is authorized to use the keys.
-        canBeUsed = await this.guardKeys();
+    // A cached key is only reusable while it still matches the canonical public key;
+    // after a rotation it falls through to the reset below and gets wiped.
+    const expectedPublicKey = this.options.expectedUserEncryptionPublicKey;
+    if (
+      this.storedEncryptionProfile?.userId === this.userId &&
+      (!expectedPublicKey ||
+        base64Encode(this.storedEncryptionProfile.keyPair.publicKey) === expectedPublicKey)
+    ) {
+      // A matching cached profile still needs origin authorization before key use.
+      // Denying it must keep the profile and the allowlist; only a different user resets.
+      if (!skipGuard && !(await this.guardKeys())) {
+        throw new Error("Origin is not authorized to use the keys");
       }
 
-      if (canBeUsed) {
-        return this.storedEncryptionProfile;
-      }
+      return this.storedEncryptionProfile;
+    }
 
-      // Something did not match, we need to create a new key pair
-      // and reset the enclave.
+    if (this.storedEncryptionProfile) {
       await this.reset();
     }
 
-    // The stored profile can't be used, or we have to create a new one.
+    if (this.options.encryptionPasswordStore === "mm") {
+      throw new Error(
+        "MM encryption profiles require an externally supplied encryption private key",
+      );
+    }
+
     let password: string | undefined;
     let encryptionPasswordStore: EncryptionPasswordStore | undefined;
 
@@ -310,7 +323,18 @@ export class LocalEnclave<
       throw new Error("Password or encryption password store is not found");
     }
 
-    return this.createEncryptionProfileFromPassword(password, this.userId, encryptionPasswordStore);
+    const profile = await this.createEncryptionProfileFromPassword(
+      password,
+      this.userId,
+      encryptionPasswordStore,
+    );
+
+    // Same origin check as the cached path. Password or MPC success is not authorization.
+    if (!skipGuard && !(await this.guardKeys())) {
+      throw new Error("Origin is not authorized to use the keys");
+    }
+
+    return profile;
   }
 
   /** @see BaseProvider#ensureUserEncryptionProfile */
@@ -351,6 +375,13 @@ export class LocalEnclave<
 
     const keyPair = nacl.box.keyPair.fromSecretKey(secretKey);
 
+    const expectedPublicKey = this.options.expectedUserEncryptionPublicKey;
+    if (expectedPublicKey && base64Encode(keyPair.publicKey) !== expectedPublicKey) {
+      throw new Error(
+        "Derived encryption public key does not match expectedUserEncryptionPublicKey",
+      );
+    }
+
     await this.store.set(STORAGE_KEYS.USER_ID, userId);
     await this.storeObfuscated.set(STORAGE_KEYS.OBFUSCATED_PASSWORD, password);
     await this.store.delete(STORAGE_KEYS.DEPRECATED___PASSWORD);