@dfns/sdk-browser 0.8.31 → 0.8.34

package/index.d.ts

@@ -1,2 +1,4 @@
-export { BrowserKeySigner } from './signers/key';
 export { WebAuthnSigner } from './signers/webauthn';
+export { PasswordProtectedKeyAttestation, PasswordProtectedKeyRing, PasswordProtectedKeySigner, PromptCallback, PromptResult, } from './signers/ppk';
+export { RecoveryKeyAssertion, RecoveryKeyAttestation, RecoveryKeySigner, randomRecoveryCode } from './signers/recovery';
+export { SessionKeyAttestation, SessionKeySigner } from './signers/session';

package/index.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebAuthnSigner = exports.BrowserKeySigner = void 0;
-var key_1 = require("./signers/key");
-Object.defineProperty(exports, "BrowserKeySigner", { enumerable: true, get: function () { return key_1.BrowserKeySigner; } });
-var webauthn_1 = require("./signers/webauthn");
-Object.defineProperty(exports, "WebAuthnSigner", { enumerable: true, get: function () { return webauthn_1.WebAuthnSigner; } });
+export { WebAuthnSigner } from './signers/webauthn';
+export { PasswordProtectedKeyRing, PasswordProtectedKeySigner, } from './signers/ppk';
+export { RecoveryKeySigner, randomRecoveryCode } from './signers/recovery';
+export { SessionKeySigner } from './signers/session';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dfns/sdk-browser",
-  "version": "0.8.31",
+  "version": "0.8.34",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dfns/dfns-sdk-ts.git",
@@ -11,9 +11,10 @@
     "cross-fetch": "^3.1.6"
   },
   "peerDependencies": {
-    "@dfns/sdk": "0.8.31"
+    "@dfns/sdk": "0.8.34"
   },
+  "module": "./index.js",
+  "type": "module",
   "main": "./index.js",
-  "type": "commonjs",
   "license": "MIT"
 }

package/signers/ppk.d.ts

@@ -0,0 +1,57 @@
+import { CredentialSigner, KeyAssertion } from '@dfns/sdk';
+import { CreateCredentialBody } from '@dfns/sdk/types/auth';
+export type PasswordProtectedKeyAttestation = Omit<Extract<CreateCredentialBody, {
+    credentialKind: 'PasswordProtectedKey';
+}>, 'challengeIdentifier' | 'credentialName'>;
+export declare class PasswordProtectedKeySigner {
+    private readonly keyData;
+    private readonly ttlMs;
+    private handle;
+    private ttlTimer;
+    constructor(keyData: {
+        username: string;
+        credId: string;
+        wrappedKey: string;
+    }, ttlMs?: number);
+    static create(username: string, options: {
+        challenge: string;
+    }, password: string): Promise<PasswordProtectedKeyAttestation>;
+    isUnlocked(): boolean;
+    unlock(password: string): Promise<void>;
+    sign(options: {
+        challenge: string;
+        allowCredentials?: {
+            passwordProtectedKey?: {
+                id: string;
+            }[];
+        };
+    }): Promise<KeyAssertion>;
+    lock(): Promise<void>;
+    private resetTtl;
+    private clearTtl;
+}
+export type PromptResult = {
+    password: string;
+};
+export type PromptCallback = (opts: {
+    lastError?: Error;
+}) => Promise<PromptResult>;
+export declare class PasswordProtectedKeyRing implements CredentialSigner<KeyAssertion> {
+    private readonly username;
+    private readonly prompt;
+    private readonly ttlMs?;
+    private signers;
+    private signerIds;
+    private current;
+    constructor(username: string, prompt: PromptCallback, ttlMs?: number | undefined);
+    sign(options: {
+        challenge: string;
+        allowCredentials?: {
+            passwordProtectedKey?: {
+                id: string;
+                encryptedPrivateKey: string;
+            }[];
+        };
+    }): Promise<KeyAssertion>;
+    reset(): Promise<void>;
+}

package/signers/ppk.js

@@ -0,0 +1,196 @@
+import { Buffer } from 'buffer';
+import { fromBase64Url, toBase64Url } from '@dfns/sdk/utils';
+import { IsolatedKeyHandle } from '../worker/handle';
+import { namedError } from '../worker/protocol';
+const DEFAULT_TTL_MS = 60000;
+const deriveSaltFromUsername = async (username) => {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(username.toLowerCase().trim()));
+    return new Uint8Array(digest);
+};
+const spawnWorker = () => {
+    const worker = new Worker(new URL('../worker/dedicatedWorker', import.meta.url), { type: 'module' });
+    return new IsolatedKeyHandle(worker);
+};
+export class PasswordProtectedKeySigner {
+    constructor(keyData, ttlMs = DEFAULT_TTL_MS) {
+        this.keyData = keyData;
+        this.ttlMs = ttlMs;
+        this.handle = null;
+        this.ttlTimer = null;
+    }
+    static async create(username, options, password) {
+        const handle = spawnWorker();
+        try {
+            const salt = await deriveSaltFromUsername(username);
+            const { publicKey, credId, wrappedKey } = await handle.create({ password, salt });
+            if (!wrappedKey) {
+                throw namedError('InvalidArgument', 'IsolatedKey.create did not return a wrappedKey despite a password being provided');
+            }
+            const clientData = JSON.stringify({ type: 'key.create', challenge: options.challenge });
+            const clientDataHash = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(clientData));
+            const fingerprint = JSON.stringify({
+                clientDataHash: Buffer.from(clientDataHash).toString('hex'),
+                publicKey,
+            });
+            const { signature: sigB64Url } = await handle.sign(fingerprint);
+            const signatureHex = fromBase64Url(sigB64Url).toString('hex');
+            const attestationData = JSON.stringify({
+                algorithm: 'SHA256',
+                publicKey,
+                signature: signatureHex,
+            });
+            return {
+                credentialKind: 'PasswordProtectedKey',
+                credentialInfo: {
+                    attestationData: toBase64Url(Buffer.from(attestationData)),
+                    clientData: toBase64Url(Buffer.from(clientData)),
+                    credId,
+                },
+                encryptedPrivateKey: wrappedKey,
+            };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    isUnlocked() {
+        return this.handle !== null;
+    }
+    async unlock(password) {
+        await this.lock();
+        const handle = spawnWorker();
+        try {
+            const salt = await deriveSaltFromUsername(this.keyData.username);
+            await handle.unlock({ credId: this.keyData.credId, wrappedKey: this.keyData.wrappedKey, password, salt });
+            if (this.handle) {
+                // Another unlock won the race during our handle.unlock() await. Terminate our worker
+                // rather than orphan it — overwriting this.handle would drop the winner's reference and
+                // leave a decrypted-key worker with no TTL and nothing holding it.
+                handle.terminate();
+                return;
+            }
+            this.handle = handle;
+            this.resetTtl();
+        }
+        catch (err) {
+            handle.terminate();
+            throw err;
+        }
+    }
+    async sign(options) {
+        if (!this.handle) {
+            throw namedError('InvalidOperation', 'PasswordProtectedKey is locked; call unlock(password) first');
+        }
+        const { credId } = this.keyData;
+        const allowedIds = options.allowCredentials?.passwordProtectedKey?.map((c) => c.id) ?? [];
+        if (!allowedIds.includes(credId)) {
+            throw namedError('InvalidArgument', `${credId} does not match allowed password-protected credentials: ${allowedIds.join(', ')}`);
+        }
+        const clientData = JSON.stringify({ challenge: options.challenge, type: 'key.get' });
+        this.resetTtl();
+        let signature;
+        try {
+            ;
+            ({ signature } = await this.handle.sign(clientData));
+        }
+        catch (err) {
+            if (err instanceof Error && (err.name === 'WorkerCrashed' || err.name === 'DispatchFailed')) {
+                this.clearTtl();
+                this.handle.terminate();
+                this.handle = null;
+            }
+            throw err;
+        }
+        return {
+            kind: 'Key',
+            credentialAssertion: {
+                credId,
+                clientData: toBase64Url(Buffer.from(clientData)),
+                signature,
+            },
+        };
+    }
+    async lock() {
+        this.clearTtl();
+        const h = this.handle;
+        this.handle = null;
+        if (h) {
+            await h.close();
+        }
+    }
+    resetTtl() {
+        this.clearTtl();
+        this.ttlTimer = setTimeout(() => {
+            this.handle?.terminate();
+            this.handle = null;
+            this.ttlTimer = null;
+        }, this.ttlMs);
+    }
+    clearTtl() {
+        if (this.ttlTimer) {
+            clearTimeout(this.ttlTimer);
+            this.ttlTimer = null;
+        }
+    }
+}
+export class PasswordProtectedKeyRing {
+    constructor(username, prompt, ttlMs) {
+        this.username = username;
+        this.prompt = prompt;
+        this.ttlMs = ttlMs;
+        this.signers = [];
+        this.signerIds = [];
+        this.current = null;
+    }
+    async sign(options) {
+        const ppks = options.allowCredentials?.passwordProtectedKey ?? [];
+        if (ppks.length === 0) {
+            throw namedError('InvalidArgument', 'challenge has no password-protected credentials');
+        }
+        const ids = ppks.map((p) => p.id);
+        if (!sameIds(this.signerIds, ids)) {
+            await this.reset();
+            this.signers = ppks.map((p) => new PasswordProtectedKeySigner({ credId: p.id, username: this.username, wrappedKey: p.encryptedPrivateKey }, this.ttlMs));
+            this.signerIds = ids;
+        }
+        // The current signer's handle may have been terminated by its own TTL timer. Drop the stale
+        // reference so the prompt loop re-unlocks, rather than calling sign() on a locked handle.
+        if (this.current && !this.current.isUnlocked()) {
+            this.current = null;
+        }
+        let lastError;
+        while (!this.current) {
+            const { password } = await this.prompt({ lastError });
+            lastError = undefined;
+            for (const signer of this.signers) {
+                try {
+                    await signer.unlock(password);
+                    this.current = signer;
+                    break;
+                }
+                catch (err) {
+                    if (err instanceof Error && err.name === 'UnlockFailed') {
+                        lastError = err;
+                        continue;
+                    }
+                    throw err;
+                }
+            }
+        }
+        return this.current.sign(options);
+    }
+    async reset() {
+        const c = this.current;
+        this.current = null;
+        this.signers = [];
+        this.signerIds = [];
+        if (c)
+            await c.lock();
+    }
+}
+const sameIds = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    const seen = new Set(a);
+    return b.every((id) => seen.has(id));
+};

package/signers/recovery.d.ts

@@ -0,0 +1,21 @@
+import { CreateCredentialBody, RecoverBody } from '@dfns/sdk/types/auth';
+export type RecoveryKeyAttestation = Omit<Extract<CreateCredentialBody, {
+    credentialKind: 'RecoveryKey';
+}>, 'challengeIdentifier' | 'credentialName'>;
+export type RecoveryKeyAssertion = RecoverBody['recovery'];
+export declare const randomRecoveryCode: () => string;
+export declare class RecoveryKeySigner {
+    private readonly keyData;
+    constructor(keyData: {
+        username: string;
+        credId: string;
+        wrappedKey: string;
+    });
+    static create(username: string, options: {
+        challenge: string;
+    }): Promise<{
+        attestation: RecoveryKeyAttestation;
+        recoveryCode: string;
+    }>;
+    sign(newCredentials: RecoverBody['newCredentials'], recoveryCode: string): Promise<RecoveryKeyAssertion>;
+}

package/signers/recovery.js

@@ -0,0 +1,89 @@
+import { Buffer } from 'buffer';
+import { fromBase64Url, toBase64Url } from '@dfns/sdk/utils';
+import { IsolatedKeyHandle } from '../worker/handle';
+import { namedError } from '../worker/protocol';
+const RECOVERY_CODE_ALPHABET = 'ABCDEFGHJKLMNPQRSTUVWXYZ23456789';
+export const randomRecoveryCode = () => {
+    const uuid1 = crypto.randomUUID().replace(/-/g, '');
+    const uuid2 = crypto.randomUUID().replace(/-/g, '');
+    let out = '';
+    for (let i = 0; i < uuid1.length; ++i) {
+        const idx = parseInt(uuid1[i], 16) + (parseInt(uuid2[i]) < 8 ? 0 : 16);
+        out += RECOVERY_CODE_ALPHABET[idx];
+    }
+    return `D1-${out.substring(0, 6)}-${out.substring(6, 11)}-${out.substring(11, 16)}-${out.substring(16, 21)}-${out.substring(21, 26)}-${out.substring(26)}`;
+};
+const deriveSaltFromUsername = async (username) => {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(username.toLowerCase().trim()));
+    return new Uint8Array(digest);
+};
+const spawnWorker = () => {
+    const worker = new Worker(new URL('../worker/dedicatedWorker', import.meta.url), { type: 'module' });
+    return new IsolatedKeyHandle(worker);
+};
+export class RecoveryKeySigner {
+    constructor(keyData) {
+        this.keyData = keyData;
+    }
+    static async create(username, options) {
+        const handle = spawnWorker();
+        try {
+            const recoveryCode = randomRecoveryCode();
+            const salt = await deriveSaltFromUsername(username);
+            const { publicKey, credId, wrappedKey } = await handle.create({ password: recoveryCode, salt });
+            if (!wrappedKey) {
+                throw namedError('InvalidArgument', 'IsolatedKey.create did not return a wrappedKey despite a password being provided');
+            }
+            const clientData = JSON.stringify({ type: 'key.create', challenge: options.challenge });
+            const clientDataHash = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(clientData));
+            const fingerprint = JSON.stringify({
+                clientDataHash: Buffer.from(clientDataHash).toString('hex'),
+                publicKey,
+            });
+            const { signature: sigB64Url } = await handle.sign(fingerprint);
+            const signatureHex = fromBase64Url(sigB64Url).toString('hex');
+            const attestationData = JSON.stringify({
+                algorithm: 'SHA256',
+                publicKey,
+                signature: signatureHex,
+            });
+            return {
+                attestation: {
+                    credentialKind: 'RecoveryKey',
+                    credentialInfo: {
+                        credId,
+                        clientData: toBase64Url(Buffer.from(clientData)),
+                        attestationData: toBase64Url(Buffer.from(attestationData)),
+                    },
+                    encryptedPrivateKey: wrappedKey,
+                },
+                recoveryCode,
+            };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async sign(newCredentials, recoveryCode) {
+        const { credId, username, wrappedKey } = this.keyData;
+        const challenge = toBase64Url(Buffer.from(JSON.stringify(newCredentials)));
+        const clientData = JSON.stringify({ challenge, type: 'key.get' });
+        const handle = spawnWorker();
+        try {
+            const salt = await deriveSaltFromUsername(username);
+            await handle.unlock({ credId, wrappedKey, password: recoveryCode, salt });
+            const { signature } = await handle.sign(clientData);
+            return {
+                kind: 'RecoveryKey',
+                credentialAssertion: {
+                    credId,
+                    clientData: toBase64Url(Buffer.from(clientData)),
+                    signature,
+                },
+            };
+        }
+        finally {
+            await handle.close();
+        }
+    }
+}

package/signers/session.d.ts

@@ -0,0 +1,27 @@
+import { CredentialSigner, KeyAssertion } from '@dfns/sdk';
+import { OidcLoginCredentialsBody } from '@dfns/sdk/types/auth';
+export type SessionKeyAttestation = Omit<Extract<OidcLoginCredentialsBody, {
+    credentialKind: 'SessionKey';
+}>, 'challengeIdentifier' | 'credentialName'>;
+export declare class SessionKeySigner implements CredentialSigner<KeyAssertion> {
+    private readonly handle;
+    private readonly publicKey?;
+    private constructor();
+    static create(): Promise<{
+        signer: SessionKeySigner;
+        credId: string;
+    }>;
+    attest(options: {
+        challenge: string;
+    }): Promise<SessionKeyAttestation>;
+    sign(options: {
+        challenge: string;
+        allowCredentials?: {
+            key?: {
+                id: string;
+            }[];
+        };
+    }): Promise<KeyAssertion>;
+    static fromExistingWorker(): Promise<SessionKeySigner | null>;
+    static destroy(): Promise<void>;
+}

package/signers/session.js

@@ -0,0 +1,103 @@
+import { Buffer } from 'buffer';
+import { fromBase64Url, toBase64Url } from '@dfns/sdk/utils';
+import { IsolatedKeyHandle } from '../worker/handle';
+import { namedError } from '../worker/protocol';
+let cachedHandle = null;
+let keepAliveTimer = null;
+// Chrome idle-terminates SharedWorkers heuristically even with a connected port. A periodic no-op
+// (status) ping registers as activity and keeps the worker alive long enough to cover a typical
+// IdP access-token TTL. Not a guarantee — memory pressure or device sleep can still kill it.
+const KEEP_ALIVE_INTERVAL_MS = 30000;
+const spawnSharedWorker = () => {
+    if (!cachedHandle) {
+        const worker = new SharedWorker(new URL('../worker/sharedWorker', import.meta.url), { type: 'module' });
+        const handle = new IsolatedKeyHandle(worker);
+        cachedHandle = handle;
+        const myTimer = setInterval(() => {
+            void handle.status().catch(() => {
+                // Worker is dead (crash, idle-kill, dispatch timeout). Always stop OUR timer so we don't
+                // leak intervals, but only null the module-global cache/timer if they still identify this
+                // pair — a concurrent destroy()+create() may have already swapped in a newer handle+timer.
+                clearInterval(myTimer);
+                if (cachedHandle === handle)
+                    cachedHandle = null;
+                if (keepAliveTimer === myTimer)
+                    keepAliveTimer = null;
+            });
+        }, KEEP_ALIVE_INTERVAL_MS);
+        keepAliveTimer = myTimer;
+    }
+    return cachedHandle;
+};
+export class SessionKeySigner {
+    constructor(handle, publicKey) {
+        this.handle = handle;
+        this.publicKey = publicKey;
+    }
+    static async create() {
+        const handle = spawnSharedWorker();
+        const { publicKey, credId } = await handle.create();
+        return { signer: new SessionKeySigner(handle, publicKey), credId };
+    }
+    async attest(options) {
+        if (!this.publicKey) {
+            throw namedError('InvalidOperation', 'SessionKeySigner.attest() requires a freshly created signer; rehydrated signers cannot attest.');
+        }
+        const clientData = JSON.stringify({ type: 'key.create', challenge: options.challenge });
+        const clientDataHash = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(clientData));
+        const fingerprint = JSON.stringify({
+            clientDataHash: Buffer.from(clientDataHash).toString('hex'),
+            publicKey: this.publicKey,
+        });
+        const { credId, signature: sigB64Url } = await this.handle.sign(fingerprint);
+        const attestationData = JSON.stringify({
+            algorithm: 'SHA256',
+            publicKey: this.publicKey,
+            signature: fromBase64Url(sigB64Url).toString('hex'),
+        });
+        return {
+            credentialKind: 'SessionKey',
+            credentialInfo: {
+                credId,
+                clientData: toBase64Url(Buffer.from(clientData)),
+                attestationData: toBase64Url(Buffer.from(attestationData)),
+            },
+        };
+    }
+    async sign(options) {
+        const clientData = JSON.stringify({ challenge: options.challenge, type: 'key.get' });
+        const { credId, signature } = await this.handle.sign(clientData);
+        const allowedIds = options.allowCredentials?.key?.map((c) => c.id) ?? [];
+        if (!allowedIds.includes(credId)) {
+            throw namedError('InvalidArgument', `${credId} does not match allowed key credentials: ${allowedIds.join(', ')}`);
+        }
+        return {
+            kind: 'Key',
+            credentialAssertion: {
+                credId,
+                clientData: toBase64Url(Buffer.from(clientData)),
+                signature,
+            },
+        };
+    }
+    static async fromExistingWorker() {
+        const handle = spawnSharedWorker();
+        const { hasKey } = await handle.status();
+        if (!hasKey)
+            return null;
+        return new SessionKeySigner(handle);
+    }
+    // SharedWorker persists across tabs and does not auto-terminate; on logout we need to flush
+    // its key material. Closes the worker and clears the module-level cache so a subsequent login
+    // spawns a fresh one.
+    static async destroy() {
+        if (keepAliveTimer) {
+            clearInterval(keepAliveTimer);
+            keepAliveTimer = null;
+        }
+        const h = cachedHandle;
+        cachedHandle = null;
+        if (h)
+            await h.close();
+    }
+}

package/signers/webauthn.d.ts

@@ -1,5 +1,4 @@
-import { CredentialSigner, CredentialStore, Fido2Assertion, Fido2Attestation, UserActionChallenge } from '@dfns/sdk';
-import { CreateCredentialChallengeResponse, CreateRegistrationChallengeResponse } from '@dfns/sdk/generated/auth';
+import { CredentialSigner, CredentialStore, Fido2Assertion, Fido2Attestation } from '@dfns/sdk';
 export declare const DEFAULT_WAIT_TIMEOUT = 60000;
 interface WebAuthnSignerConf {
     /**
@@ -23,9 +22,30 @@ interface WebAuthnSignerConf {
 export declare class WebAuthnSigner implements CredentialSigner<Fido2Assertion>, CredentialStore<Fido2Attestation> {
     private conf;
     constructor(conf: WebAuthnSignerConf);
-    sign(challenge: UserActionChallenge): Promise<Fido2Assertion>;
-    create(challenge: CreateRegistrationChallengeResponse | (CreateCredentialChallengeResponse & {
-        kind: 'Fido2';
-    })): Promise<Fido2Attestation>;
+    sign(options: {
+        challenge: string;
+        allowCredentials?: {
+            webauthn?: {
+                id: string;
+                type: PublicKeyCredentialType;
+            }[];
+        };
+        userVerification?: UserVerificationRequirement;
+    }): Promise<Fido2Assertion>;
+    create(options: {
+        challenge: string;
+        pubKeyCredParams: PublicKeyCredentialParameters[];
+        user: {
+            displayName: string;
+            id: string;
+            name: string;
+        };
+        attestation: AttestationConveyancePreference;
+        excludeCredentials: {
+            id: string;
+            type: PublicKeyCredentialType;
+        }[];
+        authenticatorSelection?: AuthenticatorSelectionCriteria;
+    }): Promise<Fido2Attestation>;
 }
 export {};

package/signers/webauthn.js

@@ -1,32 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebAuthnSigner = exports.DEFAULT_WAIT_TIMEOUT = void 0;
-const sdk_1 = require("@dfns/sdk");
-const utils_1 = require("@dfns/sdk/utils");
-const buffer_1 = require("buffer");
-exports.DEFAULT_WAIT_TIMEOUT = 60000;
-class WebAuthnSigner {
+import { Buffer } from 'buffer';
+import { DfnsError } from '@dfns/sdk';
+import { fromBase64Url, toBase64Url } from '@dfns/sdk/utils';
+export const DEFAULT_WAIT_TIMEOUT = 60000;
+export class WebAuthnSigner {
     constructor(conf) {
         this.conf = conf;
         if (!this.conf?.relyingParty?.id || !this.conf?.relyingParty?.name) {
-            throw new sdk_1.DfnsError(-1, `Relying party ID and name must be specified in the WebauthnSigner initializer`);
+            throw new DfnsError(-1, `Relying party ID and name must be specified in the WebauthnSigner initializer`);
         }
     }
-    async sign(challenge) {
+    async sign(options) {
         const response = await navigator.credentials.get({
             publicKey: {
-                challenge: buffer_1.Buffer.from(challenge.challenge),
-                allowCredentials: challenge.allowCredentials?.webauthn.map(({ id, type }) => ({
-                    id: (0, utils_1.fromBase64Url)(id).buffer,
+                challenge: Buffer.from(options.challenge),
+                allowCredentials: options.allowCredentials?.webauthn?.map(({ id, type }) => ({
+                    id: fromBase64Url(id).buffer,
                     type,
                 })),
                 rpId: this.conf.relyingParty.id,
-                userVerification: challenge.userVerification,
-                timeout: this.conf.timeout ?? exports.DEFAULT_WAIT_TIMEOUT,
+                userVerification: options.userVerification,
+                timeout: this.conf.timeout ?? DEFAULT_WAIT_TIMEOUT,
             },
         });
         if (response === null) {
-            throw new sdk_1.DfnsError(-1, 'Failed to sign with WebAuthn credential');
+            throw new DfnsError(-1, 'Failed to sign with WebAuthn credential');
         }
         const credential = response;
         const assertion = credential.response;
@@ -34,36 +31,35 @@ class WebAuthnSigner {
             kind: 'Fido2',
             credentialAssertion: {
                 credId: credential.id,
-                clientData: (0, utils_1.toBase64Url)(buffer_1.Buffer.from(assertion.clientDataJSON)),
-                authenticatorData: (0, utils_1.toBase64Url)(buffer_1.Buffer.from(assertion.authenticatorData)),
-                signature: (0, utils_1.toBase64Url)(buffer_1.Buffer.from(assertion.signature)),
-                userHandle: assertion.userHandle ? (0, utils_1.toBase64Url)(buffer_1.Buffer.from(assertion.userHandle)) : undefined,
+                clientData: toBase64Url(Buffer.from(assertion.clientDataJSON)),
+                authenticatorData: toBase64Url(Buffer.from(assertion.authenticatorData)),
+                signature: toBase64Url(Buffer.from(assertion.signature)),
+                userHandle: assertion.userHandle ? toBase64Url(Buffer.from(assertion.userHandle)) : undefined,
             },
         };
     }
-    async create(challenge) {
-        const options = {
+    async create(options) {
+        const response = await navigator.credentials.create({
             publicKey: {
-                challenge: buffer_1.Buffer.from(challenge.challenge),
-                pubKeyCredParams: challenge.pubKeyCredParams,
+                challenge: Buffer.from(options.challenge),
+                pubKeyCredParams: options.pubKeyCredParams,
                 rp: this.conf.relyingParty,
                 user: {
-                    displayName: challenge.user.displayName,
-                    id: buffer_1.Buffer.from(challenge.user.id),
-                    name: challenge.user.name,
+                    displayName: options.user.displayName,
+                    id: Buffer.from(options.user.id),
+                    name: options.user.name,
                 },
-                attestation: challenge.attestation,
-                excludeCredentials: challenge.excludeCredentials.map(({ id, type }) => ({
-                    id: (0, utils_1.fromBase64Url)(id).buffer,
+                attestation: options.attestation,
+                excludeCredentials: options.excludeCredentials.map(({ id, type }) => ({
+                    id: fromBase64Url(id).buffer,
                     type,
                 })),
-                authenticatorSelection: challenge.authenticatorSelection,
-                timeout: this.conf.timeout ?? exports.DEFAULT_WAIT_TIMEOUT,
+                authenticatorSelection: options.authenticatorSelection,
+                timeout: this.conf.timeout ?? DEFAULT_WAIT_TIMEOUT,
             },
-        };
-        const response = await navigator.credentials.create(options);
+        });
         if (response === null) {
-            throw new sdk_1.DfnsError(-1, `Failed to create and sign with WebAuthn credential`);
+            throw new DfnsError(-1, `Failed to create and sign with WebAuthn credential`);
         }
         const credential = response;
         const attestation = credential.response;
@@ -71,10 +67,9 @@ class WebAuthnSigner {
             credentialKind: 'Fido2',
             credentialInfo: {
                 credId: credential.id,
-                attestationData: (0, utils_1.toBase64Url)(buffer_1.Buffer.from(attestation.attestationObject)),
-                clientData: (0, utils_1.toBase64Url)(buffer_1.Buffer.from(attestation.clientDataJSON)),
+                attestationData: toBase64Url(Buffer.from(attestation.attestationObject)),
+                clientData: toBase64Url(Buffer.from(attestation.clientDataJSON)),
             },
         };
     }
 }
-exports.WebAuthnSigner = WebAuthnSigner;

package/worker/dedicatedWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/worker/dedicatedWorker.js

@@ -0,0 +1,7 @@
+/// <reference lib="webworker" />
+import { createDispatcher, replyOverPort } from './dispatcher';
+const scope = self;
+const dispatch = createDispatcher(() => scope.close());
+scope.onmessage = (e) => {
+    void replyOverPort(dispatch, e);
+};

package/worker/dispatcher.d.ts

@@ -0,0 +1,3 @@
+import { IsolatedKeyRequest, IsolatedKeyResponse } from './protocol';
+export declare const createDispatcher: (onClose: () => void) => (req: IsolatedKeyRequest) => Promise<IsolatedKeyResponse>;
+export declare const replyOverPort: (handle: (req: IsolatedKeyRequest) => Promise<IsolatedKeyResponse>, event: MessageEvent) => Promise<void>;

package/worker/dispatcher.js

@@ -0,0 +1,51 @@
+import { Buffer } from 'buffer';
+import { toBase64Url } from '@dfns/sdk/utils';
+import { IsolatedKey } from './isolatedKey';
+import { namedError } from './protocol';
+const toMessageError = (e) => e instanceof Error ? { name: e.name, message: e.message } : { message: String(e) };
+export const createDispatcher = (onClose) => {
+    let isolated = null;
+    return async (req) => {
+        switch (req.kind) {
+            case 'create': {
+                const { isolated: made, publicKey, credId, wrappedKey, } = await IsolatedKey.create({
+                    password: req.password,
+                    salt: req.salt,
+                });
+                isolated = made;
+                return { kind: 'created', publicKey, credId, wrappedKey };
+            }
+            case 'unlock': {
+                isolated = await IsolatedKey.fromWrapped(req.credId, req.wrappedKey, req.password, req.salt);
+                return { kind: 'unlocked' };
+            }
+            case 'sign': {
+                if (!isolated)
+                    throw namedError('InvalidOperation', 'IsolatedKey not initialized');
+                // Snapshot before awaiting: another message (SharedWorker: concurrent port) could reassign
+                // `isolated` while crypto.subtle.sign is in flight, letting us return a credId for one key
+                // and a signature from another.
+                const key = isolated;
+                const sig = await key.sign(req.message);
+                return { kind: 'signed', credId: key.credId, signature: toBase64Url(Buffer.from(sig)) };
+            }
+            case 'status': {
+                return isolated ? { kind: 'status', hasKey: true, credId: isolated.credId } : { kind: 'status', hasKey: false };
+            }
+            case 'close': {
+                isolated = null;
+                onClose();
+                return { kind: 'closed' };
+            }
+        }
+    };
+};
+export const replyOverPort = async (handle, event) => {
+    const reply = (envelope) => event.ports[0]?.postMessage(envelope);
+    try {
+        reply({ result: await handle(event.data) });
+    }
+    catch (error) {
+        reply({ error: toMessageError(error) });
+    }
+};

package/worker/handle.d.ts

@@ -0,0 +1,40 @@
+type WorkerLike = Worker | SharedWorker;
+export declare class IsolatedKeyHandle {
+    private readonly worker;
+    private readonly timeoutMs;
+    private readonly inFlight;
+    private deadReason;
+    constructor(worker: WorkerLike, timeoutMs?: number);
+    create(args?: {
+        password?: string;
+        salt?: Uint8Array<ArrayBuffer>;
+    }): Promise<{
+        kind: "created";
+        publicKey: string;
+        credId: string;
+        wrappedKey?: string;
+    }>;
+    unlock(args: {
+        credId: string;
+        wrappedKey: string;
+        password: string;
+        salt: Uint8Array<ArrayBuffer>;
+    }): Promise<{
+        kind: "unlocked";
+    }>;
+    sign(message: string): Promise<{
+        kind: "signed";
+        credId: string;
+        signature: string;
+    }>;
+    status(): Promise<{
+        kind: "status";
+        hasKey: boolean;
+        credId?: string;
+    }>;
+    close(): Promise<void>;
+    terminate(): void;
+    private failAll;
+    private postMessage;
+}
+export {};

package/worker/handle.js

@@ -0,0 +1,114 @@
+import { namedError } from './protocol';
+const DEFAULT_TIMEOUT_MS = 30000;
+const targetPort = (worker) => {
+    return 'port' in worker ? worker.port : worker;
+};
+export class IsolatedKeyHandle {
+    constructor(worker, timeoutMs = DEFAULT_TIMEOUT_MS) {
+        this.worker = worker;
+        this.timeoutMs = timeoutMs;
+        // In-flight requests' reject functions. Populated per postMessage, drained by failAll on crash.
+        this.inFlight = new Set();
+        // Once a crash is observed, future requests short-circuit instead of queueing onto a dead port.
+        this.deadReason = null;
+        // Dedicated Workers fire .onerror reliably on uncaught exceptions. SharedWorker's .onerror is
+        // spottier across browsers but still worth attaching — on Chrome/Safari it fires on worker-side
+        // uncaught errors. The per-request timeout is the backstop for silent kills.
+        this.worker.onerror = (event) => {
+            const message = event.message || 'worker crashed';
+            this.failAll(namedError('WorkerCrashed', message));
+        };
+    }
+    create(args = {}) {
+        return this.postMessage({ kind: 'create', ...args });
+    }
+    unlock(args) {
+        return this.postMessage({ kind: 'unlock', ...args });
+    }
+    sign(message) {
+        return this.postMessage({ kind: 'sign', message });
+    }
+    status() {
+        return this.postMessage({ kind: 'status' });
+    }
+    async close() {
+        try {
+            await this.postMessage({ kind: 'close' });
+        }
+        catch {
+            // worker may already be gone or racing self.close() — close() is best-effort for the ack
+        }
+        finally {
+            // Dedicated workers hold the key material in a tab-local process; a timeout or ignored ack
+            // above would leave that process alive with the unlocked key. terminate() is a hard kill
+            // and safe to re-call.
+            if (!('port' in this.worker)) {
+                this.worker.terminate();
+                this.failAll(namedError('WorkerCrashed', 'worker terminated after close'));
+            }
+        }
+    }
+    terminate() {
+        if ('port' in this.worker) {
+            throw namedError('InvalidOperation', 'terminate() is only supported for dedicated workers');
+        }
+        this.worker.terminate();
+        // A manual terminate kills everything in-flight too; drain them so callers see a WorkerCrashed
+        // rejection rather than a hung promise.
+        this.failAll(namedError('WorkerCrashed', 'worker terminated'));
+    }
+    failAll(err) {
+        // Preserve the ORIGINAL crash reason; a later cascading failure must not overwrite it.
+        if (!this.deadReason)
+            this.deadReason = err;
+        for (const cleanup of this.inFlight)
+            cleanup(err);
+        this.inFlight.clear();
+    }
+    postMessage(msg) {
+        if (this.deadReason)
+            return Promise.reject(this.deadReason);
+        return new Promise((resolve, reject) => {
+            const channel = new MessageChannel();
+            let settled = false;
+            const settle = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                this.inFlight.delete(crashCleanup);
+                channel.port1.close();
+                fn();
+            };
+            const crashCleanup = (err) => settle(() => reject(err));
+            const timer = setTimeout(() => {
+                settle(() => {
+                    // Treat a dispatch timeout as evidence the worker is dead (silent kill, hung on crypto,
+                    // etc). Poison the handle so future requests fail immediately instead of each waiting out
+                    // another full timeout, and reject every other in-flight request on the same dead port.
+                    const err = namedError('DispatchFailed', `worker did not respond within ${this.timeoutMs}ms`);
+                    this.failAll(err);
+                    reject(err);
+                });
+            }, this.timeoutMs);
+            this.inFlight.add(crashCleanup);
+            channel.port1.onmessage = ({ data }) => {
+                settle(() => {
+                    if ('error' in data) {
+                        const err = new Error(data.error.message);
+                        if (data.error.name)
+                            err.name = data.error.name;
+                        reject(err);
+                    }
+                    else {
+                        resolve(data.result);
+                    }
+                });
+            };
+            channel.port1.onmessageerror = () => {
+                settle(() => reject(namedError('DispatchFailed', 'worker response could not be deserialized')));
+            };
+            targetPort(this.worker).postMessage(msg, [channel.port2]);
+        });
+    }
+}

package/worker/isolatedKey.d.ts

@@ -0,0 +1,16 @@
+export declare class IsolatedKey {
+    private readonly privateKey;
+    readonly credId: string;
+    private constructor();
+    static create(opts: {
+        password?: string;
+        salt?: Uint8Array<ArrayBuffer>;
+    }): Promise<{
+        isolated: IsolatedKey;
+        publicKey: string;
+        credId: string;
+        wrappedKey?: string;
+    }>;
+    static fromWrapped(credId: string, wrappedKey: string, password: string, salt: Uint8Array<ArrayBuffer>): Promise<IsolatedKey>;
+    sign(message: string): Promise<Uint8Array>;
+}

package/worker/isolatedKey.js

@@ -0,0 +1,98 @@
+import { Buffer } from 'buffer';
+import { fromBase64, rawSignatureToAns1, toBase64, toBase64Url } from '@dfns/sdk/utils';
+import { namedError } from './protocol';
+const deriveWrappingKey = async (password, salt) => {
+    const material = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), { name: 'PBKDF2' }, false, [
+        'deriveKey',
+    ]);
+    return crypto.subtle.deriveKey({ hash: 'SHA-256', iterations: 100000, name: 'PBKDF2', salt }, material, { length: 256, name: 'AES-GCM' }, false, ['wrapKey', 'unwrapKey']);
+};
+const exportPublicKeySpki = (publicKey) => crypto.subtle.exportKey('spki', publicKey);
+const exportPublicKeyAsPem = async (publicKey) => {
+    const buf = await exportPublicKeySpki(publicKey);
+    const b64 = toBase64(Buffer.from(buf));
+    return `-----BEGIN PUBLIC KEY-----\n${b64.match(/.{1,64}/g)?.join('\n')}\n-----END PUBLIC KEY-----`;
+};
+const computeCredId = async (publicKey) => {
+    const spki = await exportPublicKeySpki(publicKey);
+    const hash = await crypto.subtle.digest('SHA-256', spki);
+    return toBase64Url(Buffer.from(hash));
+};
+export class IsolatedKey {
+    constructor(privateKey, credId) {
+        this.privateKey = privateKey;
+        this.credId = credId;
+    }
+    static async create(opts) {
+        if (opts.password === undefined) {
+            const pair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign', 'verify']);
+            const publicKey = await exportPublicKeyAsPem(pair.publicKey);
+            const credId = await computeCredId(pair.publicKey);
+            return { isolated: new IsolatedKey(pair.privateKey, credId), publicKey, credId };
+        }
+        if (!opts.salt) {
+            throw namedError('InvalidArgument', 'salt is required when password is provided');
+        }
+        const extractablePair = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, true, [
+            'sign',
+            'verify',
+        ]);
+        const publicKey = await exportPublicKeyAsPem(extractablePair.publicKey);
+        const credId = await computeCredId(extractablePair.publicKey);
+        const iv = crypto.getRandomValues(new Uint8Array(16));
+        const wrappingKey = await deriveWrappingKey(opts.password, opts.salt);
+        const wrappedBuf = await crypto.subtle.wrapKey('pkcs8', extractablePair.privateKey, wrappingKey, {
+            iv,
+            name: 'AES-GCM',
+        });
+        const nonExtractable = await crypto.subtle.unwrapKey('pkcs8', wrappedBuf, wrappingKey, { iv, name: 'AES-GCM' }, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign']);
+        const envelope = {
+            iv: toBase64(Buffer.from(iv)),
+            key: toBase64(Buffer.from(wrappedBuf)),
+        };
+        const wrappedKey = toBase64(JSON.stringify(envelope));
+        return { isolated: new IsolatedKey(nonExtractable, credId), publicKey, credId, wrappedKey };
+    }
+    static async fromWrapped(credId, wrappedKey, password, salt) {
+        let envelope;
+        try {
+            envelope = JSON.parse(fromBase64(wrappedKey).toString('utf8'));
+        }
+        catch {
+            throw namedError('InvalidArgument', 'stored key envelope could not be parsed');
+        }
+        if (!envelope ||
+            typeof envelope !== 'object' ||
+            typeof envelope.iv !== 'string' ||
+            typeof envelope.key !== 'string') {
+            throw namedError('InvalidArgument', 'stored key envelope is missing iv or key');
+        }
+        let wrappedBuf;
+        let iv;
+        try {
+            wrappedBuf = new Uint8Array(fromBase64(envelope.key));
+            iv = new Uint8Array(fromBase64(envelope.iv));
+        }
+        catch {
+            throw namedError('InvalidArgument', 'stored key envelope has invalid base64 fields');
+        }
+        const wrappingKey = await deriveWrappingKey(password, salt);
+        try {
+            const privateKey = await crypto.subtle.unwrapKey('pkcs8', wrappedBuf, wrappingKey, { iv, name: 'AES-GCM' }, { name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign']);
+            return new IsolatedKey(privateKey, credId);
+        }
+        catch (err) {
+            // AES-GCM auth tag didn't verify. Overwhelmingly the common cause is a wrong
+            // password/recovery code; the rare alternative is tampered or truncated ciphertext.
+            // Both surface as OperationError from Web Crypto — we don't try to distinguish.
+            if (err instanceof Error && err.name === 'OperationError') {
+                throw namedError('UnlockFailed', 'key could not be unlocked; check the unlock code');
+            }
+            throw err;
+        }
+    }
+    async sign(message) {
+        const raw = await crypto.subtle.sign({ hash: { name: 'SHA-256' }, name: 'ECDSA' }, this.privateKey, new TextEncoder().encode(message));
+        return rawSignatureToAns1(new Uint8Array(raw));
+    }
+}

package/worker/protocol.d.ts

@@ -0,0 +1,46 @@
+export type IsolatedKeyRequest = {
+    kind: 'create';
+    password?: string;
+    salt?: Uint8Array<ArrayBuffer>;
+} | {
+    kind: 'unlock';
+    credId: string;
+    password: string;
+    salt: Uint8Array<ArrayBuffer>;
+    wrappedKey: string;
+} | {
+    kind: 'sign';
+    message: string;
+} | {
+    kind: 'close';
+} | {
+    kind: 'status';
+};
+export type IsolatedKeyResponse = {
+    kind: 'created';
+    publicKey: string;
+    credId: string;
+    wrappedKey?: string;
+} | {
+    kind: 'unlocked';
+} | {
+    kind: 'signed';
+    credId: string;
+    signature: string;
+} | {
+    kind: 'closed';
+} | {
+    kind: 'status';
+    hasKey: boolean;
+    credId?: string;
+};
+export type MessageError = {
+    name?: string;
+    message: string;
+};
+export type MessageEnvelope<T> = {
+    result: T;
+} | {
+    error: MessageError;
+};
+export declare const namedError: (name: string, message: string) => Error;

package/worker/protocol.js

@@ -0,0 +1,7 @@
+// Builds an Error whose `.name` is the given discriminator. Callers match on `.name` to classify
+// failure categories (`UnlockFailed`, `InvalidArgument`, `InvalidOperation`, `WorkerCrashed`, `DispatchFailed`).
+export const namedError = (name, message) => {
+    const e = new Error(message);
+    e.name = name;
+    return e;
+};

package/worker/sharedWorker.d.ts

@@ -0,0 +1 @@
+export {};

package/worker/sharedWorker.js

@@ -0,0 +1,11 @@
+/// <reference lib="webworker" />
+import { createDispatcher, replyOverPort } from './dispatcher';
+const scope = self;
+const dispatch = createDispatcher(() => scope.close());
+scope.onconnect = (e) => {
+    const port = e.ports[0];
+    port.onmessage = (msg) => {
+        void replyOverPort(dispatch, msg);
+    };
+    port.start();
+};

package/signers/key.d.ts

@@ -1,10 +0,0 @@
-import { CredentialSigner, CredentialStore, KeyAssertion, KeyAttestation, UserActionChallenge, UserRegistrationChallenge } from '@dfns/sdk';
-export declare class BrowserKeySigner implements CredentialSigner<KeyAssertion>, CredentialStore<KeyAttestation> {
-    private options;
-    constructor(options: {
-        credId?: string;
-        keyPair: CryptoKeyPair;
-    });
-    create(challenge: UserRegistrationChallenge): Promise<KeyAttestation>;
-    sign(challenge: Pick<UserActionChallenge, 'challenge' | 'allowCredentials'>): Promise<KeyAssertion>;
-}

package/signers/key.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BrowserKeySigner = void 0;
-const sdk_1 = require("@dfns/sdk");
-const utils_1 = require("@dfns/sdk/utils");
-const buffer_1 = require("buffer");
-class BrowserKeySigner {
-    constructor(options) {
-        this.options = options;
-    }
-    async create(challenge) {
-        let credId = this.options.credId;
-        if (credId === undefined || credId === '') {
-            credId = (0, utils_1.toBase64Url)(buffer_1.Buffer.from((0, utils_1.generateRandom)(32)));
-            this.options.credId = credId;
-        }
-        const publicKeyPem = await (0, utils_1.exportPublicKeyInPemFormatBrowser)(this.options.keyPair);
-        const clientData = JSON.stringify({
-            type: 'key.create',
-            challenge: challenge.challenge,
-        });
-        const clientDataHash = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(clientData));
-        const clientDataHashHex = (0, utils_1.toHex)(clientDataHash);
-        const credInfoFingerprint = JSON.stringify({
-            clientDataHash: clientDataHashHex,
-            publicKey: publicKeyPem,
-        });
-        let rawSignature;
-        const algorithm = this.options.keyPair.privateKey.algorithm.name;
-        if (algorithm == 'ECDSA') {
-            rawSignature = await crypto.subtle.sign({ name: 'ECDSA', hash: { name: 'SHA-256' } }, this.options.keyPair.privateKey, new TextEncoder().encode(credInfoFingerprint));
-        }
-        else {
-            throw new sdk_1.DfnsError(-1, `${algorithm} is not supported`);
-        }
-        const signature = (0, utils_1.rawSignatureToAns1)(new Uint8Array(rawSignature));
-        const attestationData = JSON.stringify({
-            publicKey: publicKeyPem,
-            signature: (0, utils_1.toHex)(signature.buffer),
-        });
-        return {
-            credentialKind: 'Key',
-            credentialInfo: {
-                credId,
-                clientData: (0, utils_1.toBase64Url)(clientData),
-                attestationData: (0, utils_1.toBase64Url)(attestationData),
-            },
-        };
-    }
-    async sign(challenge) {
-        const credId = this.options.credId;
-        if (credId === undefined || credId === '') {
-            throw new sdk_1.DfnsError(-1, 'credId is needed to sign');
-        }
-        if (challenge.allowCredentials) {
-            const allowedCredId = challenge.allowCredentials.key.map((cred) => cred.id);
-            if (!allowedCredId.includes(credId)) {
-                throw new sdk_1.DfnsError(-1, `${credId} does not match allowed credentials: ${allowedCredId}`);
-            }
-        }
-        const clientData = JSON.stringify({
-            type: 'key.get',
-            challenge: challenge.challenge,
-        });
-        let rawSignature;
-        const algorithm = this.options.keyPair.privateKey.algorithm.name;
-        if (algorithm == 'ECDSA') {
-            rawSignature = await crypto.subtle.sign({ name: 'ECDSA', hash: { name: 'SHA-256' } }, this.options.keyPair.privateKey, new TextEncoder().encode(clientData));
-        }
-        else {
-            throw new sdk_1.DfnsError(-1, `${algorithm} is not supported`);
-        }
-        const signature = (0, utils_1.rawSignatureToAns1)(new Uint8Array(rawSignature));
-        return {
-            kind: 'Key',
-            credentialAssertion: {
-                credId: this.options.credId ?? '',
-                clientData: (0, utils_1.toBase64Url)(clientData),
-                signature: (0, utils_1.toBase64Url)(buffer_1.Buffer.from(signature)),
-            },
-        };
-    }
-}
-exports.BrowserKeySigner = BrowserKeySigner;