@le-space/orbitdb-identity-provider-webauthn-did 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changes
 
+## 0.11.0
+
+Another session of the same passkey may still write: OrbitDB's verified-identity cache, worked
+around in the provider so that no application carries a copy.
+
+### Added
+
+- **`withoutStaleIdentityCache(identities)`** and **`createIdentities(options)`** (main entry and
+  `./keystore`): `@orbitdb/core` 4 caches a verified identity under `signatures.id` and, on a hit,
+  compares the whole identity. This provider keeps the id signature the same in every session of a
+  passkey (the PRF-derived signing key) while the WebAuthn proof in `signatures.publicKey` is new per
+  session — so whichever session's entries are verified first owns the cache, and every other
+  session of the same passkey is refused: _"Key … is not allowed to write to the log"_. Seen in
+  belege's restore (belege#259) and in simple-todo's archived01, a phone restoring a laptop's
+  archive (simple-todo#79). The wrapper re-checks a refused webauthn identity the way an uncached
+  one would be: `isIdentity`, the id signature over the public key, this provider's binding. Other
+  providers' identities and anything failing those checks stay refused. Upstream
+  orbitdb/orbitdb#1258; to be removed once OrbitDB keys its cache by identity hash (#90).
+
 ## 0.10.0
 
 An identity that is nobody's passkey, so that every security key of an owner can write as the same

package/README.md

@@ -98,6 +98,30 @@ const identity = await identities.createIdentity({
 });
 ```
 
+### Identities for a passkey: `createIdentities`
+
+OrbitDB keeps a cache of verified identities keyed by `signatures.id`. This provider keeps that
+signature the same in every session of a passkey (the signing key is derived from the PRF output),
+while the WebAuthn proof in `signatures.publicKey` is a fresh assertion per session. So whichever
+session's entries a peer verifies first owns its cache, and every other session of the same passkey
+is refused: _"Key … is not allowed to write to the log"_ — a phone restoring a laptop's backup, a
+browser that gets its own earlier entries back from a relay ([orbitdb/orbitdb#1258](https://github.com/orbitdb/orbitdb/issues/1258),
+[#90](https://github.com/Le-Space/orbitdb-identity-provider-webauthn-did/issues/90)).
+
+Until OrbitDB keys its cache by identity hash, build the identities with the provider's wrapper:
+
+```javascript
+import { createIdentities } from '@le-space/orbitdb-identity-provider-webauthn-did';
+
+const identities = await createIdentities({ ipfs, keystore }); // Identities(options), wrapped
+const orbitdb = await createOrbitDB({ ipfs, identities, identity });
+```
+
+or wrap an instance you already have with `withoutStaleIdentityCache(identities)`. Where OrbitDB
+says no, a webauthn identity is checked again the way an uncached one would be — the shape, the id
+signature over the public key, and this provider's binding of the key to the DID. Other providers'
+identities, and anything that fails those checks, stay refused.
+
 ### Discoverable Recovery Notes
 
 For the DID-based flow:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/orbitdb-identity-provider-webauthn-did",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "WebAuthn-based DID identity provider for OrbitDB for hardware-secured wallets and biometric Passkey authentication",
   "main": "src/index.js",
   "types": "types/index.d.ts",
@@ -52,7 +52,8 @@
     "version": "git add -A",
     "postversion": "git push && git push --tags",
     "test:two-peer": "playwright test tests/webauthn-two-peer-replication.test.js --project=chromium --reporter=line",
-    "test:node": "playwright test --config=playwright.node.config.js"
+    "test:node": "playwright test --config=playwright.node.config.js",
+    "test:wallet-fork": "PASSKEY_WALLET_FORK_URL=${PASSKEY_WALLET_FORK_URL:-https://sepolia.drpc.org} playwright test --config=playwright.fork.config.js"
   },
   "keywords": [
     "orbitdb",

package/src/index.js

@@ -308,6 +308,12 @@ export {
   recoverPublicKeyCandidates,
 } from './webauthn/recovery.js';
 export { restoreIdentityFromAuthenticator } from './webauthn/restore.js';
+// OrbitDB's identity cache refuses another session of the same passkey
+// (orbitdb/orbitdb#1258); this is the provider's answer until it is fixed there.
+export {
+  withoutStaleIdentityCache,
+  createIdentities,
+} from './keystore/stale-identity-cache.js';
 // The two halves of it, for a caller that already holds one: a PRF output, or
 // a credential it wants the output for.
 export {

package/src/keystore/index.js

@@ -6,4 +6,8 @@ export { default } from './encryption.js';
 export * from './provider.js';
 export * from './session-keystore.js';
 export { createSecretSigner } from './secret-signer.js';
+export {
+  withoutStaleIdentityCache,
+  createIdentities,
+} from './stale-identity-cache.js';
 export { PrfUnavailableError } from '../errors.js';

package/src/keystore/stale-identity-cache.js

@@ -0,0 +1,97 @@
+/**
+ * OrbitDB's verified-identity cache keyed by the wrong thing, worked around.
+ *
+ * `Identities.verifyIdentity` (@orbitdb/core 4) remembers a verified identity
+ * under `signatures.id` and, on a hit, answers `isEqual(identity, cached)`.
+ * With this provider the PRF-derived signing key gives the *same*
+ * `signatures.id` in every session of a passkey, while `signatures.publicKey`
+ * — the WebAuthn assertion that binds the key to the DID — is new per session.
+ * So once one session's identity is in the cache, every other session of the
+ * same passkey is refused: "Could not append entry: Key … is not allowed to
+ * write to the log". Whichever session's entries are verified first owns the
+ * cache: after a join (a restore from backup), after a sync (a peer that held
+ * the list), or simply the browser's own earlier entries coming back.
+ *
+ * Seen in Le-Space/belege's restore (belege#259) and in simple-todo's
+ * archived01 (a phone restoring a laptop's archive, Le-Space/simple-todo#79).
+ * Upstream: orbitdb/orbitdb#1258. The right fix is a cache keyed by identity
+ * hash; until OrbitDB has it, this is the provider's own answer, so that no
+ * application has to carry a copy.
+ *
+ * Where OrbitDB says no, an identity of this provider is checked again the way
+ * an uncached one would be: the shape (`isIdentity`), the id signature over
+ * the public key (`identities.verify`), and this provider's binding of the key
+ * to the DID (`verifyIdentity`, the check GHSA-326j-4cc3-4rrg added). Other
+ * providers' identities, and anything that fails those checks, stay refused.
+ */
+import { OrbitDBWebAuthnIdentityProviderFunction } from './provider.js';
+
+/**
+ * OrbitDB's own shape check (`identities/identity.js`, `isIdentity`), kept
+ * here rather than imported: this file is reachable from the `./keystore`
+ * entry, which does not load `@orbitdb/core` at import time — the peer
+ * dependency is the application's, and @orbitdb/core 4.0.0 cannot even be
+ * imported from a bare install (it uses `it-drain` without declaring it).
+ *
+ * @param {any} identity
+ */
+function isIdentity(identity) {
+  return Boolean(
+    identity &&
+    identity.id &&
+    identity.hash &&
+    identity.bytes &&
+    identity.publicKey &&
+    identity.signatures &&
+    identity.signatures.id &&
+    identity.signatures.publicKey &&
+    identity.type
+  );
+}
+
+/**
+ * Wrap an `Identities` instance so that another session of the same passkey
+ * is verified rather than refused. Idempotent in effect; wrapping twice only
+ * checks twice.
+ *
+ * @template {{ verifyIdentity: (identity: any) => Promise<boolean>, verify: (signature: string, publicKey: string, data: string) => Promise<boolean> }} T
+ * @param {T} identities - from `Identities(...)` (or `createIdentities` below)
+ * @returns {T} the same instance, its `verifyIdentity` replaced
+ */
+export function withoutStaleIdentityCache(identities) {
+  if (
+    !identities ||
+    typeof identities.verifyIdentity !== 'function' ||
+    typeof identities.verify !== 'function'
+  ) {
+    throw new TypeError(
+      'withoutStaleIdentityCache needs an OrbitDB Identities instance (verifyIdentity, verify)'
+    );
+  }
+  const cached = identities.verifyIdentity;
+  identities.verifyIdentity = async (identity) => {
+    if (await cached(identity)) return true;
+    if (
+      !isIdentity(identity) ||
+      identity.type !== OrbitDBWebAuthnIdentityProviderFunction.type
+    ) {
+      return false;
+    }
+    const { id, publicKey, signatures } = identity;
+    if (!(await identities.verify(signatures.id, publicKey, id))) return false;
+    return OrbitDBWebAuthnIdentityProviderFunction.verifyIdentity(identity);
+  };
+  return identities;
+}
+
+/**
+ * `Identities(options)` from @orbitdb/core, already wrapped: what an
+ * application that builds identities for a passkey should call. The peer
+ * dependency is loaded when this is called, not when the module is.
+ *
+ * @param {Record<string, unknown>} [options] - `{ ipfs, keystore, storage, path }`, as OrbitDB takes them
+ */
+export async function createIdentities(options) {
+  const { Identities } = await import('@orbitdb/core');
+  return withoutStaleIdentityCache(await Identities(options));
+}

package/types/index.d.ts

@@ -659,3 +659,26 @@ declare const defaultExport: {
 };
 
 export default defaultExport;
+
+/**
+ * OrbitDB's verified-identity cache is keyed by `signatures.id`, which this
+ * provider keeps the same in every session of a passkey while the WebAuthn
+ * proof changes; another session of the same passkey is then refused
+ * (orbitdb/orbitdb#1258). Wraps an `Identities` instance so that such an
+ * identity is checked again the way an uncached one would be.
+ */
+export function withoutStaleIdentityCache<
+  T extends {
+    verifyIdentity: (identity: unknown) => Promise<boolean>;
+    verify: (
+      signature: string,
+      publicKey: string,
+      data: string
+    ) => Promise<boolean>;
+  },
+>(identities: T): T;
+
+/** `Identities(options)` from `@orbitdb/core`, already wrapped by `withoutStaleIdentityCache`. */
+export function createIdentities(
+  options?: Record<string, unknown>
+): Promise<unknown>;

package/types/keystore.d.ts

@@ -206,3 +206,26 @@ declare const defaultExport: {
 };
 
 export default defaultExport;
+
+/**
+ * OrbitDB's verified-identity cache is keyed by `signatures.id`, which this
+ * provider keeps the same in every session of a passkey while the WebAuthn
+ * proof changes; another session of the same passkey is then refused
+ * (orbitdb/orbitdb#1258). Wraps an `Identities` instance so that such an
+ * identity is checked again the way an uncached one would be.
+ */
+export function withoutStaleIdentityCache<
+  T extends {
+    verifyIdentity: (identity: unknown) => Promise<boolean>;
+    verify: (
+      signature: string,
+      publicKey: string,
+      data: string
+    ) => Promise<boolean>;
+  },
+>(identities: T): T;
+
+/** `Identities(options)` from `@orbitdb/core`, already wrapped by `withoutStaleIdentityCache`. */
+export function createIdentities(
+  options?: Record<string, unknown>
+): Promise<unknown>;