nid-webauthn-emulator 0.1.3

package/dist/src/authenticator/ctap-model.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticationEmulatorError = exports.CTAP_COMMAND = exports.CTAP_STATUS_CODE = void 0;
+exports.unpackRequest = unpackRequest;
+exports.packMakeCredentialRequest = packMakeCredentialRequest;
+exports.packGetAssertionRequest = packGetAssertionRequest;
+exports.unpackMakeCredentialResponse = unpackMakeCredentialResponse;
+exports.packMakeCredentialResponse = packMakeCredentialResponse;
+exports.unpackGetAssertionResponse = unpackGetAssertionResponse;
+exports.packGetAssertionResponse = packGetAssertionResponse;
+exports.unpackGetInfoResponse = unpackGetInfoResponse;
+exports.packGetInfoResponse = packGetInfoResponse;
+const encode_utils_1 = __importDefault(require("../libs/encode-utils"));
+/** @see https://fidoalliance.org/specs/fido-v2.0-ps-20190130/fido-client-to-authenticator-protocol-v2.0-ps-20190130.html#error-responses */
+var CTAP_STATUS_CODE;
+(function (CTAP_STATUS_CODE) {
+    CTAP_STATUS_CODE[CTAP_STATUS_CODE["CTAP2_OK"] = 0] = "CTAP2_OK";
+    CTAP_STATUS_CODE[CTAP_STATUS_CODE["CTAP1_ERR_INVALID_COMMAND"] = 1] = "CTAP1_ERR_INVALID_COMMAND";
+    CTAP_STATUS_CODE[CTAP_STATUS_CODE["CTAP1_ERR_INVALID_PARAMETER"] = 2] = "CTAP1_ERR_INVALID_PARAMETER";
+    CTAP_STATUS_CODE[CTAP_STATUS_CODE["CTAP2_ERR_INVALID_CBOR"] = 18] = "CTAP2_ERR_INVALID_CBOR";
+    CTAP_STATUS_CODE[CTAP_STATUS_CODE["CTAP2_ERR_CREDENTIAL_EXCLUDED"] = 25] = "CTAP2_ERR_CREDENTIAL_EXCLUDED";
+    CTAP_STATUS_CODE[CTAP_STATUS_CODE["CTAP2_ERR_UNSUPPORTED_ALGORITHM"] = 38] = "CTAP2_ERR_UNSUPPORTED_ALGORITHM";
+    CTAP_STATUS_CODE[CTAP_STATUS_CODE["CTAP2_ERR_OPERATION_DENIED"] = 39] = "CTAP2_ERR_OPERATION_DENIED";
+    CTAP_STATUS_CODE[CTAP_STATUS_CODE["CTAP2_ERR_NO_CREDENTIALS"] = 46] = "CTAP2_ERR_NO_CREDENTIALS";
+    CTAP_STATUS_CODE[CTAP_STATUS_CODE["CTAP2_ERR_NOT_ALLOWED"] = 48] = "CTAP2_ERR_NOT_ALLOWED";
+})(CTAP_STATUS_CODE || (exports.CTAP_STATUS_CODE = CTAP_STATUS_CODE = {}));
+/** @see https://fidoalliance.org/specs/fido-v2.0-ps-20190130/fido-client-to-authenticator-protocol-v2.0-ps-20190130.html#commands */
+var CTAP_COMMAND;
+(function (CTAP_COMMAND) {
+    CTAP_COMMAND[CTAP_COMMAND["authenticatorMakeCredential"] = 1] = "authenticatorMakeCredential";
+    CTAP_COMMAND[CTAP_COMMAND["authenticatorGetAssertion"] = 2] = "authenticatorGetAssertion";
+    CTAP_COMMAND[CTAP_COMMAND["authenticatorGetInfo"] = 4] = "authenticatorGetInfo";
+    CTAP_COMMAND[CTAP_COMMAND["authenticatorClientPIN"] = 6] = "authenticatorClientPIN";
+    CTAP_COMMAND[CTAP_COMMAND["authenticatorReset"] = 7] = "authenticatorReset";
+    CTAP_COMMAND[CTAP_COMMAND["authenticatorGetNextAssertion"] = 8] = "authenticatorGetNextAssertion";
+})(CTAP_COMMAND || (exports.CTAP_COMMAND = CTAP_COMMAND = {}));
+// Not standard functions and interfaces
+class AuthenticationEmulatorError extends Error {
+    status;
+    type = "CTAPError";
+    constructor(status, options) {
+        super(`CTAP error: ${CTAP_STATUS_CODE[status]} (${status})`, options);
+        this.status = status;
+    }
+}
+exports.AuthenticationEmulatorError = AuthenticationEmulatorError;
+function unpackRequest(request) {
+    let data = {};
+    try {
+        data = (request.data ? encode_utils_1.default.decodeCbor(request.data) : {});
+    }
+    catch (error) {
+        throw new AuthenticationEmulatorError(CTAP_STATUS_CODE.CTAP2_ERR_INVALID_CBOR, { cause: error });
+    }
+    switch (request.command) {
+        case CTAP_COMMAND.authenticatorMakeCredential:
+            return {
+                command: request.command,
+                request: {
+                    clientDataHash: encode_utils_1.default.bufferSourceToUint8Array(data[0x01]),
+                    rp: data[0x02],
+                    user: data[0x03],
+                    pubKeyCredParams: data[0x04],
+                    excludeList: data[0x05],
+                    extensions: data[0x06],
+                    options: data[0x07],
+                    pinAuth: data[0x08] ? encode_utils_1.default.bufferSourceToUint8Array(data[0x08]) : undefined,
+                    pinProtocol: data[0x09],
+                },
+            };
+        case CTAP_COMMAND.authenticatorGetAssertion:
+            return {
+                command: request.command,
+                request: {
+                    rpId: data[0x01],
+                    clientDataHash: encode_utils_1.default.bufferSourceToUint8Array(data[0x02]),
+                    allowList: data[0x03],
+                    extensions: data[0x04],
+                    options: data[0x05],
+                    pinAuth: data[0x06] ? encode_utils_1.default.bufferSourceToUint8Array(data[0x06]) : undefined,
+                    pinProtocol: data[0x07],
+                },
+            };
+        default:
+            return {
+                command: request.command,
+                request: undefined,
+            };
+    }
+}
+function packMakeCredentialRequest(request) {
+    return {
+        command: CTAP_COMMAND.authenticatorMakeCredential,
+        data: encode_utils_1.default.encodeCbor({
+            [0x01]: request.clientDataHash,
+            [0x02]: request.rp,
+            [0x03]: request.user,
+            [0x04]: request.pubKeyCredParams,
+            [0x05]: request.excludeList,
+            [0x06]: request.extensions,
+            [0x07]: request.options,
+            [0x08]: request.pinAuth,
+            [0x09]: request.pinProtocol,
+        }),
+    };
+}
+function packGetAssertionRequest(request) {
+    return {
+        command: CTAP_COMMAND.authenticatorGetAssertion,
+        data: encode_utils_1.default.encodeCbor({
+            [0x01]: request.rpId,
+            [0x02]: request.clientDataHash,
+            [0x03]: request.allowList,
+            [0x04]: request.extensions,
+            [0x05]: request.options,
+            [0x06]: request.pinAuth,
+            [0x07]: request.pinProtocol,
+        }),
+    };
+}
+function unpackMakeCredentialResponse(response) {
+    try {
+        const data = encode_utils_1.default.decodeCbor(response.data);
+        return {
+            fmt: data[0x01],
+            authData: encode_utils_1.default.bufferSourceToUint8Array(data[0x02]),
+            attStmt: data[0x03],
+        };
+    }
+    catch (error) {
+        throw new AuthenticationEmulatorError(CTAP_STATUS_CODE.CTAP2_ERR_INVALID_CBOR, { cause: error });
+    }
+}
+function packMakeCredentialResponse(response) {
+    return {
+        status: CTAP_STATUS_CODE.CTAP2_OK,
+        data: encode_utils_1.default.encodeCbor({
+            [0x01]: response.fmt,
+            [0x02]: response.authData,
+            [0x03]: response.attStmt,
+        }),
+    };
+}
+function unpackGetAssertionResponse(response) {
+    try {
+        const data = encode_utils_1.default.decodeCbor(response.data);
+        return {
+            credential: data[0x01],
+            authData: encode_utils_1.default.bufferSourceToUint8Array(data[0x02]),
+            signature: encode_utils_1.default.bufferSourceToUint8Array(data[0x03]),
+            user: data[0x04],
+            numberOfCredentials: data[0x05],
+        };
+    }
+    catch (error) {
+        throw new AuthenticationEmulatorError(CTAP_STATUS_CODE.CTAP2_ERR_INVALID_CBOR, { cause: error });
+    }
+}
+function packGetAssertionResponse(response) {
+    return {
+        status: CTAP_STATUS_CODE.CTAP2_OK,
+        data: encode_utils_1.default.encodeCbor({
+            [0x01]: response.credential,
+            [0x02]: response.authData,
+            [0x03]: response.signature,
+            [0x04]: response.user,
+            [0x05]: response.numberOfCredentials,
+        }),
+    };
+}
+function unpackGetInfoResponse(response) {
+    try {
+        const data = encode_utils_1.default.decodeCbor(response.data);
+        return {
+            versions: data[0x01],
+            extensions: data[0x02],
+            aaguid: encode_utils_1.default.bufferSourceToUint8Array(data[0x03]),
+            options: data[0x04],
+            maxMsgSize: data[0x05],
+            pinProtocols: data[0x06],
+        };
+    }
+    catch (error) {
+        throw new AuthenticationEmulatorError(CTAP_STATUS_CODE.CTAP2_ERR_INVALID_CBOR, { cause: error });
+    }
+}
+function packGetInfoResponse(response) {
+    return {
+        status: CTAP_STATUS_CODE.CTAP2_OK,
+        data: encode_utils_1.default.encodeCbor({
+            [0x01]: response.versions,
+            [0x02]: response.extensions,
+            [0x03]: response.aaguid,
+            [0x04]: response.options,
+            [0x05]: response.maxMsgSize,
+            [0x06]: response.pinProtocols,
+        }),
+    };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,16 @@
+import { WebAuthnEmulator } from "./webauthn/webauthn-emulator";
+export default WebAuthnEmulator;
+export * from "./webauthn/webauthn-model-json";
+export * from "./webauthn/webauthn-model";
+export * from "./webauthn/webauthn-emulator";
+export * from "./webauthn/cose-key";
+export * from "./authenticator/authenticator-emulator";
+export * from "./authenticator/ctap-model";
+export * from "./repository/credentials-repository";
+export * from "./repository/credentials-file-repository";
+export * from "./repository/credentials-memory-repository";
+export declare const BrowserInjection: {
+    WebAuthnEmulatorGet: string;
+    WebAuthnEmulatorCreate: string;
+    HookWebAuthnApis: string;
+};

package/dist/src/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserInjection = void 0;
+const browser_injection_1 = require("./test-utils/browser-injection");
+const webauthn_emulator_1 = require("./webauthn/webauthn-emulator");
+exports.default = webauthn_emulator_1.WebAuthnEmulator;
+__exportStar(require("./webauthn/webauthn-model-json"), exports);
+__exportStar(require("./webauthn/webauthn-model"), exports);
+__exportStar(require("./webauthn/webauthn-emulator"), exports);
+__exportStar(require("./webauthn/cose-key"), exports);
+__exportStar(require("./authenticator/authenticator-emulator"), exports);
+__exportStar(require("./authenticator/ctap-model"), exports);
+__exportStar(require("./repository/credentials-repository"), exports);
+__exportStar(require("./repository/credentials-file-repository"), exports);
+__exportStar(require("./repository/credentials-memory-repository"), exports);
+exports.BrowserInjection = {
+    WebAuthnEmulatorGet: browser_injection_1.WebAuthnEmulatorGet,
+    WebAuthnEmulatorCreate: browser_injection_1.WebAuthnEmulatorCreate,
+    HookWebAuthnApis: browser_injection_1.HookWebAuthnApis,
+};

package/dist/src/libs/encode-utils.d.ts

@@ -0,0 +1,15 @@
+declare function encodeBase64Url(data: BufferSource): string;
+declare function decodeBase64Url(base64Url: string): Uint8Array;
+declare function bufferSourceToUint8Array(data: BufferSource): Uint8Array;
+declare function strToUint8Array(data: string): Uint8Array;
+declare function encodeCbor(data: object): Uint8Array;
+declare function decodeCbor<T>(data: Uint8Array): T;
+declare const EncodeUtils: {
+    strToUint8Array: typeof strToUint8Array;
+    bufferSourceToUint8Array: typeof bufferSourceToUint8Array;
+    encodeBase64Url: typeof encodeBase64Url;
+    decodeBase64Url: typeof decodeBase64Url;
+    encodeCbor: typeof encodeCbor;
+    decodeCbor: typeof decodeCbor;
+};
+export default EncodeUtils;

package/dist/src/libs/encode-utils.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cbor_1 = __importDefault(require("cbor"));
+function encodeBase64Url(data) {
+    const buffer = bufferSourceToUint8Array(data);
+    let binaryString = "";
+    for (let i = 0; i < buffer.length; i++) {
+        binaryString += String.fromCharCode(buffer[i]);
+    }
+    return btoa(binaryString).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function decodeBase64Url(base64Url) {
+    const binaryString = atob(base64Url.replace(/-/g, "+").replace(/_/g, "/"));
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+function bufferSourceToUint8Array(data) {
+    if (data instanceof ArrayBuffer) {
+        return new Uint8Array(data);
+    }
+    return new Uint8Array(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
+}
+function strToUint8Array(data) {
+    return new Uint8Array(data.split("").map((c) => c.charCodeAt(0)));
+}
+function encodeCbor(data) {
+    function encoder(value) {
+        if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
+            return Buffer.from(value);
+        }
+        if (Array.isArray(value)) {
+            return value.map((v) => encoder(v));
+        }
+        if (typeof value === "object" && value !== null) {
+            const encodedData = new Map();
+            for (const [k, v] of Object.entries(value)) {
+                const ki = Number.parseInt(k);
+                if (Number.isNaN(ki)) {
+                    encodedData.set(k, encoder(v));
+                }
+                else {
+                    encodedData.set(ki, encoder(v));
+                }
+            }
+            return encodedData;
+        }
+        return value;
+    }
+    return new Uint8Array(cbor_1.default.encode(encoder(data)));
+}
+function decodeCbor(data) {
+    const canonicalData = cbor_1.default.decode(data);
+    function decoder(value) {
+        if (value instanceof Buffer) {
+            return new Uint8Array(value);
+        }
+        if (Array.isArray(value)) {
+            return value.map((v) => decoder(v));
+        }
+        if (value instanceof Map) {
+            const decodedData = {};
+            for (const [k, v] of value) {
+                Object.assign(decodedData, { [k]: decoder(v) });
+            }
+            return decodedData;
+        }
+        if (typeof value === "object" && value !== null) {
+            const decodedData = {};
+            for (const [k, v] of Object.entries(value)) {
+                Object.assign(decodedData, { [k]: decoder(v) });
+            }
+            return decodedData;
+        }
+        return value;
+    }
+    return decoder(canonicalData);
+}
+const EncodeUtils = {
+    strToUint8Array,
+    bufferSourceToUint8Array,
+    encodeBase64Url,
+    decodeBase64Url,
+    encodeCbor,
+    decodeCbor,
+};
+exports.default = EncodeUtils;

package/dist/src/repository/credentials-file-repository.d.ts

@@ -0,0 +1,8 @@
+import { type PasskeyDiscoverableCredential, type PasskeysCredentialsRepository } from "./credentials-repository";
+export declare class PasskeysCredentialsFileRepository implements PasskeysCredentialsRepository {
+    private readonly credentialsDir;
+    constructor(credentialsDir?: string);
+    saveCredential(credential: PasskeyDiscoverableCredential): void;
+    deleteCredential(credential: PasskeyDiscoverableCredential): void;
+    loadCredentials(): PasskeyDiscoverableCredential[];
+}

package/dist/src/repository/credentials-file-repository.js

@@ -0,0 +1,62 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasskeysCredentialsFileRepository = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const credentials_repository_1 = require("./credentials-repository");
+const CREDENTIALS_DIR = path.join(__dirname, "./credentials");
+class PasskeysCredentialsFileRepository {
+    credentialsDir;
+    constructor(credentialsDir = CREDENTIALS_DIR) {
+        this.credentialsDir = credentialsDir;
+        fs.mkdirSync(credentialsDir, { recursive: true });
+    }
+    saveCredential(credential) {
+        const id = (0, credentials_repository_1.getRepositoryId)(credential);
+        const filename = path.join(this.credentialsDir, `${id}.json`);
+        const serialized = (0, credentials_repository_1.serializeCredential)(credential);
+        fs.writeFileSync(filename, serialized);
+    }
+    deleteCredential(credential) {
+        const id = (0, credentials_repository_1.getRepositoryId)(credential);
+        const filename = path.join(this.credentialsDir, `${id}.json`);
+        fs.unlink(filename, () => { });
+    }
+    loadCredentials() {
+        const files = fs.readdirSync(this.credentialsDir);
+        return files.flatMap((file) => {
+            try {
+                const filename = path.join(this.credentialsDir, file);
+                const serialized = fs.readFileSync(filename, "utf-8");
+                return [(0, credentials_repository_1.deserializeCredential)(serialized)];
+            }
+            catch {
+                return [];
+            }
+        });
+    }
+}
+exports.PasskeysCredentialsFileRepository = PasskeysCredentialsFileRepository;

package/dist/src/repository/credentials-memory-repository.d.ts

@@ -0,0 +1,7 @@
+import { type PasskeyDiscoverableCredential, type PasskeysCredentialsRepository } from "./credentials-repository";
+export declare class PasskeysCredentialsMemoryRepository implements PasskeysCredentialsRepository {
+    private readonly credentials;
+    saveCredential(credential: PasskeyDiscoverableCredential): void;
+    deleteCredential(credential: PasskeyDiscoverableCredential): void;
+    loadCredentials(): PasskeyDiscoverableCredential[];
+}

package/dist/src/repository/credentials-memory-repository.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PasskeysCredentialsMemoryRepository = void 0;
+const credentials_repository_1 = require("./credentials-repository");
+class PasskeysCredentialsMemoryRepository {
+    credentials = new Map();
+    saveCredential(credential) {
+        const id = (0, credentials_repository_1.getRepositoryId)(credential);
+        const serialized = (0, credentials_repository_1.serializeCredential)(credential);
+        this.credentials.set(id, serialized);
+    }
+    deleteCredential(credential) {
+        const id = (0, credentials_repository_1.getRepositoryId)(credential);
+        this.credentials.delete(id);
+    }
+    loadCredentials() {
+        return Array.from(this.credentials.values()).map((serialized) => (0, credentials_repository_1.deserializeCredential)(serialized));
+    }
+}
+exports.PasskeysCredentialsMemoryRepository = PasskeysCredentialsMemoryRepository;

package/dist/src/repository/credentials-repository.d.ts

@@ -0,0 +1,39 @@
+import { type AuthenticatorData, type PublicKeyCredentialSource, type PublicKeyCredentialSourceJSON } from "../webauthn/webauthn-model";
+import { type PublicKeyCredentialDescriptorJSON, type PublicKeyCredentialUserEntityJSON } from "../webauthn/webauthn-model-json";
+export type PasskeyDiscoverableCredential = {
+    readonly publicKeyCredentialDescriptor: PublicKeyCredentialDescriptor;
+    readonly publicKeyCredentialSource: PublicKeyCredentialSource;
+    readonly authenticatorData: AuthenticatorData;
+    readonly user: PublicKeyCredentialUserEntity;
+};
+export type PasskeyDiscoverableCredentialJSON = {
+    publicKeyCredentialDescriptor: PublicKeyCredentialDescriptorJSON;
+    publicKeyCredentialSource: PublicKeyCredentialSourceJSON;
+    authenticatorData: string;
+    user: PublicKeyCredentialUserEntityJSON;
+};
+/**
+ * Passkey credentials repository
+ */
+export interface PasskeysCredentialsRepository {
+    saveCredential(credential: PasskeyDiscoverableCredential): void;
+    deleteCredential(credential: PasskeyDiscoverableCredential): void;
+    loadCredentials(): PasskeyDiscoverableCredential[];
+}
+/**
+ * Get the ID of a credential
+ * @param credential Credential
+ */
+export declare function getRepositoryId(credential: PasskeyDiscoverableCredential): string;
+/**
+ * Serialize a credential to a JSON string
+ * @param credential Credential
+ * @returns { id: Credential ID; data: JSON Credential }
+ */
+export declare function serializeCredential(credential: PasskeyDiscoverableCredential): string;
+/**
+ * Deserialize a credential from a JSON string
+ * @param data JSON string
+ * @returns Credential
+ */
+export declare function deserializeCredential(data: string): PasskeyDiscoverableCredential;

package/dist/src/repository/credentials-repository.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRepositoryId = getRepositoryId;
+exports.serializeCredential = serializeCredential;
+exports.deserializeCredential = deserializeCredential;
+const encode_utils_1 = __importDefault(require("../libs/encode-utils"));
+const webauthn_model_1 = require("../webauthn/webauthn-model");
+const webauthn_model_json_1 = require("../webauthn/webauthn-model-json");
+/**
+ * Get the ID of a credential
+ * @param credential Credential
+ */
+function getRepositoryId(credential) {
+    return encode_utils_1.default.encodeBase64Url(credential.publicKeyCredentialDescriptor.id);
+}
+/**
+ * Serialize a credential to a JSON string
+ * @param credential Credential
+ * @returns { id: Credential ID; data: JSON Credential }
+ */
+function serializeCredential(credential) {
+    const serialized = {
+        publicKeyCredentialDescriptor: (0, webauthn_model_json_1.toPublicKeyCredentialDescriptorJSON)(credential.publicKeyCredentialDescriptor),
+        publicKeyCredentialSource: (0, webauthn_model_1.toPublickeyCredentialSourceJSON)(credential.publicKeyCredentialSource),
+        authenticatorData: encode_utils_1.default.encodeBase64Url((0, webauthn_model_1.packAuthenticatorData)(credential.authenticatorData)),
+        user: (0, webauthn_model_json_1.toPublicKeyCredentialUserEntityJSON)(credential.user),
+    };
+    return JSON.stringify(serialized, null, 2);
+}
+/**
+ * Deserialize a credential from a JSON string
+ * @param data JSON string
+ * @returns Credential
+ */
+function deserializeCredential(data) {
+    const serialized = JSON.parse(data);
+    return {
+        publicKeyCredentialDescriptor: (0, webauthn_model_json_1.parsePublicKeyCredentialDescriptorFromJSON)(serialized.publicKeyCredentialDescriptor),
+        publicKeyCredentialSource: (0, webauthn_model_1.parsePublicKeyCredentialSourceFromJSON)(serialized.publicKeyCredentialSource),
+        authenticatorData: (0, webauthn_model_1.unpackAuthenticatorData)(encode_utils_1.default.decodeBase64Url(serialized.authenticatorData)),
+        user: (0, webauthn_model_json_1.parsePublicKeyCredentialUserEntityFromJSON)(serialized.user),
+    };
+}

package/dist/src/test-utils/browser-injection.d.ts

@@ -0,0 +1,3 @@
+export declare const WebAuthnEmulatorGet = "webAuthnEmulatorGet";
+export declare const WebAuthnEmulatorCreate = "webAuthnEmulatorCreate";
+export declare const HookWebAuthnApis: string;

package/dist/src/test-utils/browser-injection.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookWebAuthnApis = exports.WebAuthnEmulatorCreate = exports.WebAuthnEmulatorGet = void 0;
+const Model = __importStar(require("../webauthn/webauthn-model-json"));
+exports.WebAuthnEmulatorGet = "webAuthnEmulatorGet";
+exports.WebAuthnEmulatorCreate = "webAuthnEmulatorCreate";
+const webAuthnModelExports = Object.values(Model)
+    .map((m) => m.toString())
+    .join("\n  ");
+exports.HookWebAuthnApis = `
+(function () {
+  ${webAuthnModelExports}
+
+  window.navigator.credentials.create = async (options) => {
+    if (!options.publicKey) return undefined;
+    const optionsJSON = toCreationOptionsJSON(options.publicKey);
+    const responseJSON = await window.${exports.WebAuthnEmulatorCreate}(optionsJSON);
+    return parseRegistrationResponseFromJSON(responseJSON);
+  }
+
+  window.navigator.credentials.get = async (options) => {
+    if (!options.publicKey) return undefined;
+    const optionsJSON = toRequestOptionsJSON(options.publicKey);
+    const responseJSON = await window.${exports.WebAuthnEmulatorGet}(optionsJSON);
+    return parseAuthenticationResponseFromJSON(responseJSON);
+  }
+  PublicKeyCredential.isConditionalMediationAvailable = async () => true;
+})();
+`;

package/dist/src/webauthn/cose-key.d.ts

@@ -0,0 +1,16 @@
+import { type JsonWebKey, type KeyObject } from "node:crypto";
+/** @see https://www.w3.org/TR/webauthn/#sctn-encoded-credPubKey-examples */
+export declare abstract class CoseKey {
+    kty: number;
+    alg: number;
+    constructor(kty: number, alg: number);
+    abstract toBytes(): Uint8Array;
+    abstract toJwk(): JsonWebKey;
+    toKeyObject(): KeyObject;
+    static fromKeyObject(keyObject: KeyObject): CoseKey;
+    toDer(): Uint8Array;
+    static fromDer(der: Uint8Array): CoseKey;
+    equals(other: CoseKey): boolean;
+    static fromBytes(bytes: Uint8Array): CoseKey;
+    static fromJwk(jwk: JsonWebKey): CoseKey;
+}