nid-webauthn-emulator 0.1.3

package/dist/spec/repository/credential-repository.spec.js

@@ -0,0 +1,96 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const globals_1 = require("@jest/globals");
+const credentials_file_repository_1 = require("../../src/repository/credentials-file-repository");
+const credentials_memory_repository_1 = require("../../src/repository/credentials-memory-repository");
+const credentials_repository_1 = require("../../src/repository/credentials-repository");
+(0, globals_1.describe)("Credential Repository Test", () => {
+    const testCredentialJSON = {
+        publicKeyCredentialDescriptor: {
+            id: "9gd8oypZ_ccpqhk3RBjUp85EOK4NA1wtEkU7zr_BOd8",
+            type: "public-key",
+            transports: ["usb"],
+        },
+        publicKeyCredentialSource: {
+            type: "public-key",
+            id: "9gd8oypZ_ccpqhk3RBjUp85EOK4NA1wtEkU7zr_BOd8",
+            privateKey: "MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgMh82zVqIuCWxqRCVlkDvT0H9-0BoYZlol0AVTa2DDAmhRANCAAQbND1i36p1FOClK5Hn7liDCqpz-_H5Hv3kGEc_uX-wxMoERGk7_fHgm4i5QTq27Dby30eqFPryoKA3cNIOvWqJ",
+            rpId: "example.com",
+            userHandle: "AQIDBA",
+        },
+        authenticatorData: "o3mm9u6vuaVeN4wRgDTidR5oL6ufLTCrE9ISVYbOGUdNAAAAAE5JRC1BVVRILTMxNDE1OTIAIPYHfKMqWf3HKaoZN0QY1KfORDiuDQNcLRJFO86_wTnfpQECAyYgASFYIBs0PWLfqnUU4KUrkefuWIMKqnP78fke_eQYRz-5f7DEIlggygREaTv98eCbiLlBOrbsNvLfR6oU-vKgoDdw0g69aok",
+        user: {
+            id: "AQIDBA",
+            name: "example",
+            displayName: "example",
+        },
+    };
+    (0, globals_1.test)("Serialize and Deserialize Test", async () => {
+        const deserialized = (0, credentials_repository_1.deserializeCredential)(JSON.stringify(testCredentialJSON));
+        const serialization = (0, credentials_repository_1.serializeCredential)(deserialized);
+        const reDeserialized = (0, credentials_repository_1.deserializeCredential)(serialization);
+        (0, globals_1.expect)(reDeserialized).toEqual(deserialized);
+    });
+    (0, globals_1.test)("Memory Repository Test", async () => {
+        const deserialized = (0, credentials_repository_1.deserializeCredential)(JSON.stringify(testCredentialJSON));
+        const repository = new credentials_memory_repository_1.PasskeysCredentialsMemoryRepository();
+        repository.saveCredential(deserialized);
+        const loaded = repository.loadCredentials();
+        (0, globals_1.expect)(loaded[0]).toEqual(deserialized);
+        (0, globals_1.expect)(loaded.length).toEqual(1);
+        repository.deleteCredential(deserialized);
+        const reLoaded = repository.loadCredentials();
+        (0, globals_1.expect)(reLoaded.length).toEqual(0);
+    });
+    (0, globals_1.test)("File Repository Test", async () => {
+        const FILE_IO_WAIT = 500;
+        const deserialized = (0, credentials_repository_1.deserializeCredential)(JSON.stringify(testCredentialJSON));
+        const TEST_CREDENTIALS_DIR = node_path_1.default.join(__dirname, "test-credentials");
+        try {
+            fs.rmSync(TEST_CREDENTIALS_DIR, { recursive: true, force: true });
+            const repository = new credentials_file_repository_1.PasskeysCredentialsFileRepository(TEST_CREDENTIALS_DIR);
+            repository.saveCredential(deserialized);
+            await new Promise((resolve) => setTimeout(resolve, FILE_IO_WAIT));
+            const loaded = repository.loadCredentials();
+            (0, globals_1.expect)(loaded[0]).toEqual(deserialized);
+            (0, globals_1.expect)(loaded.length).toEqual(1);
+            repository.deleteCredential(deserialized);
+            await new Promise((resolve) => setTimeout(resolve, FILE_IO_WAIT));
+            // create dummy file
+            fs.writeFileSync(node_path_1.default.join(TEST_CREDENTIALS_DIR, "dummy"), "dummy");
+            const reLoaded = repository.loadCredentials();
+            (0, globals_1.expect)(reLoaded.length).toEqual(0);
+        }
+        finally {
+            fs.rmSync(TEST_CREDENTIALS_DIR, { recursive: true, force: true });
+        }
+    });
+});

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

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

package/dist/spec/webauthn/cose-key.spec.js

@@ -0,0 +1,74 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = __importStar(require("node:crypto"));
+const globals_1 = require("@jest/globals");
+const src_1 = require("../../src");
+const encode_utils_1 = __importDefault(require("../../src/libs/encode-utils"));
+(0, globals_1.describe)("COSEKey Tests", () => {
+    (0, globals_1.test)("RSA Key test", () => {
+        const keys = crypto.generateKeyPairSync("rsa", { modulusLength: 2048 });
+        const coseKey1 = src_1.CoseKey.fromKeyObject(keys.publicKey);
+        const coseKey2 = src_1.CoseKey.fromDer(coseKey1.toDer());
+        const coseKey3 = src_1.CoseKey.fromBytes(coseKey1.toBytes());
+        const coseKey4 = src_1.CoseKey.fromJwk(coseKey1.toJwk());
+        (0, globals_1.expect)(coseKey1.equals(coseKey2)).toBeTruthy();
+        (0, globals_1.expect)(coseKey1.equals(coseKey3)).toBeTruthy();
+        (0, globals_1.expect)(coseKey1.equals(coseKey4)).toBeTruthy();
+    });
+    (0, globals_1.test)("P256 Key test", () => {
+        const keys = crypto.generateKeyPairSync("ec", { namedCurve: "P-256" });
+        const coseKey1 = src_1.CoseKey.fromKeyObject(keys.publicKey);
+        const coseKey2 = src_1.CoseKey.fromDer(coseKey1.toDer());
+        const coseKey3 = src_1.CoseKey.fromBytes(coseKey1.toBytes());
+        const coseKey4 = src_1.CoseKey.fromJwk(coseKey1.toJwk());
+        (0, globals_1.expect)(coseKey1.equals(coseKey2)).toBeTruthy();
+        (0, globals_1.expect)(coseKey1.equals(coseKey3)).toBeTruthy();
+        (0, globals_1.expect)(coseKey1.equals(coseKey4)).toBeTruthy();
+    });
+    (0, globals_1.test)("Ed25519 Key test", () => {
+        const keys = crypto.generateKeyPairSync("ed25519");
+        const coseKey1 = src_1.CoseKey.fromKeyObject(keys.publicKey);
+        const coseKey2 = src_1.CoseKey.fromDer(coseKey1.toDer());
+        const coseKey3 = src_1.CoseKey.fromBytes(coseKey1.toBytes());
+        const coseKey4 = src_1.CoseKey.fromJwk(coseKey1.toJwk());
+        (0, globals_1.expect)(coseKey1.equals(coseKey2)).toBeTruthy();
+        (0, globals_1.expect)(coseKey1.equals(coseKey3)).toBeTruthy();
+        (0, globals_1.expect)(coseKey1.equals(coseKey4)).toBeTruthy();
+    });
+    (0, globals_1.test)("Unsupported key type test", () => {
+        const keys = crypto.generateKeyPairSync("rsa", { modulusLength: 2048 });
+        const unsupportedJwk = {
+            ...src_1.CoseKey.fromKeyObject(keys.publicKey).toJwk(),
+            kty: "unsupported",
+        };
+        (0, globals_1.expect)(() => src_1.CoseKey.fromJwk(unsupportedJwk)).toThrow("Not supported key type");
+        const unsupportedBytes = encode_utils_1.default.encodeCbor({ 1: 123, 3: 456 });
+        (0, globals_1.expect)(() => src_1.CoseKey.fromBytes(unsupportedBytes)).toThrow("Not supported key type");
+    });
+});

package/dist/spec/webauthn/webauthn-emulator.spec.d.ts

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

package/dist/spec/webauthn/webauthn-emulator.spec.js

@@ -0,0 +1,222 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const src_1 = __importStar(require("../../src"));
+const encode_utils_1 = __importDefault(require("../../src/libs/encode-utils"));
+const webauthn_test_server_1 = require("./webauthn-test-server");
+(0, globals_1.describe)("WebAuthnEmulator Registration Passkeys Test", () => {
+    const user = { username: "test", id: "test" };
+    (0, globals_1.test)("Create Passkeys test _ OK", async () => {
+        const emulator = new src_1.default();
+        const testServer = new webauthn_test_server_1.WebAuthnTestServer();
+        const options = await testServer.getRegistrationOptions(user);
+        const credential1 = emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        await testServer.getRegistrationVerification(user, credential1);
+        const credential2 = emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        await testServer.getRegistrationVerification(user, credential2);
+        // Last Credentials only
+        const credentialRecords = emulator.authenticator.params.credentialsRepository?.loadCredentials() ?? [];
+        (0, globals_1.expect)(credentialRecords.length).toBe(1);
+        (0, globals_1.expect)(encode_utils_1.default.encodeBase64Url(credentialRecords[0].publicKeyCredentialSource.id)).toBe(credential2.id);
+    });
+    (0, globals_1.test)("Create Passkeys with an illegal origin _ failed to response", async () => {
+        const illegalOrigin = `${webauthn_test_server_1.TEST_RP_ORIGIN}_illegal`;
+        const emulator = new src_1.default();
+        const testServer = new webauthn_test_server_1.WebAuthnTestServer();
+        const options = await testServer.getRegistrationOptions(user);
+        await (0, globals_1.expect)(async () => {
+            emulator.createJSON(illegalOrigin, options);
+        }).rejects.toThrow(src_1.InvalidRpIdError);
+    });
+    (0, globals_1.test)("Create Passkeys with no public key credential parameters _ failed to response", async () => {
+        const emulator = new src_1.default();
+        await (0, globals_1.expect)(async () => {
+            emulator.create(webauthn_test_server_1.TEST_RP_ORIGIN, {});
+        }).rejects.toThrow(src_1.NoPublicKeyError);
+    });
+    (0, globals_1.test)("Found in the exclude List _ CTAP Error", async () => {
+        const emulator = new src_1.default();
+        const testServer = new webauthn_test_server_1.WebAuthnTestServer();
+        const options = await testServer.getRegistrationOptions(user);
+        const credential = emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        await testServer.getRegistrationVerification(user, credential);
+        const options2 = await testServer.getRegistrationOptions(user);
+        await (0, globals_1.expect)(async () => {
+            emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options2);
+        }).rejects.toThrow(new src_1.AuthenticationEmulatorError(src_1.CTAP_STATUS_CODE.CTAP2_ERR_CREDENTIAL_EXCLUDED));
+    });
+    (0, globals_1.test)("Invalid algorithm _ CTAP Error", async () => {
+        const emulator = new src_1.default();
+        const testServer = new webauthn_test_server_1.WebAuthnTestServer();
+        const options = await testServer.getRegistrationOptions(user);
+        const illegalOptions = { ...options, pubKeyCredParams: [{ type: "public-key", alg: 99 }] };
+        await (0, globals_1.expect)(async () => {
+            emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, illegalOptions);
+        }).rejects.toThrow(new src_1.AuthenticationEmulatorError(src_1.CTAP_STATUS_CODE.CTAP2_ERR_UNSUPPORTED_ALGORITHM));
+    });
+    (0, globals_1.test)("User registration operation failed _ CTAP Error", async () => {
+        const authenticator = new src_1.AuthenticatorEmulator({
+            userMakeCredentialInteraction: () => undefined,
+        });
+        const emulator = new src_1.default(authenticator);
+        const testServer = new webauthn_test_server_1.WebAuthnTestServer();
+        const options = await testServer.getRegistrationOptions(user);
+        await (0, globals_1.expect)(async () => {
+            emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        }).rejects.toThrow(new src_1.AuthenticationEmulatorError(src_1.CTAP_STATUS_CODE.CTAP2_ERR_OPERATION_DENIED));
+    });
+    (0, globals_1.test)("Create Passkeys without RP ID _ OK", async () => {
+        const emulator = new src_1.default();
+        const testServer = new webauthn_test_server_1.WebAuthnTestServer();
+        const options = await testServer.getRegistrationOptions(user);
+        const customOptions = {
+            ...options,
+            rp: { name: "test" },
+        };
+        const credential1 = emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, customOptions);
+        await testServer.getRegistrationVerification(user, credential1);
+    });
+});
+(0, globals_1.describe)("WebAuthnEmulator Authentication Passkeys Test", () => {
+    const user = { username: "test", id: "test" };
+    const createCredential = async (authenticator) => {
+        const testServer1 = new webauthn_test_server_1.WebAuthnTestServer();
+        const testServer2 = new webauthn_test_server_1.WebAuthnTestServer("https://test-rp2.com", "test-rp2.com");
+        const emulator = new src_1.default(authenticator);
+        const options1 = await testServer1.getRegistrationOptions(user);
+        const credential1 = emulator.createJSON(testServer1.origin, options1);
+        await testServer1.getRegistrationVerification(user, credential1);
+        const options2 = await testServer2.getRegistrationOptions(user);
+        const customOptions2 = {
+            ...options2,
+            authenticatorSelection: { residentKey: "discouraged" },
+        };
+        const credential2 = emulator.createJSON(testServer2.origin, customOptions2);
+        await testServer2.getRegistrationVerification(user, credential2);
+        return [emulator, testServer1];
+    };
+    (0, globals_1.test)("Create and Authenticate Passkeys test _ OK", async () => {
+        const [emulator, testServer] = await createCredential();
+        const options = await testServer.getAuthenticationOptions();
+        const credential = emulator.getJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        await testServer.getAuthenticationVerification(credential);
+    });
+    (0, globals_1.test)("EdDSA Algorithm Passkeys test _ OK", async () => {
+        const authenticator = new src_1.AuthenticatorEmulator({ algorithmIdentifiers: ["EdDSA"] });
+        const [emulator, testServer] = await createCredential(authenticator);
+        const options = await testServer.getAuthenticationOptions();
+        const credential = emulator.getJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        await testServer.getAuthenticationVerification(credential);
+    });
+    (0, globals_1.test)("RS256 Algorithm Passkeys test _ OK", async () => {
+        const authenticator = new src_1.AuthenticatorEmulator({ algorithmIdentifiers: ["RS256"] });
+        const [emulator, testServer] = await createCredential(authenticator);
+        const options = await testServer.getAuthenticationOptions();
+        const credential = emulator.getJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        await testServer.getAuthenticationVerification(credential);
+    });
+    (0, globals_1.test)("SignCounter Increment test _ OK", async () => {
+        const authenticator = new src_1.AuthenticatorEmulator({ signCounterIncrement: 13 });
+        const [emulator, testServer] = await createCredential(authenticator);
+        const options1 = await testServer.getAuthenticationOptions();
+        const credential1 = emulator.getJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options1);
+        const authData = (0, src_1.unpackAuthenticatorData)(encode_utils_1.default.decodeBase64Url(credential1.response.authenticatorData));
+        (0, globals_1.expect)(authData.signCount).toBe(13);
+        const options2 = await testServer.getAuthenticationOptions();
+        const credential2 = emulator.getJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options2);
+        const authData2 = (0, src_1.unpackAuthenticatorData)(encode_utils_1.default.decodeBase64Url(credential2.response.authenticatorData));
+        (0, globals_1.expect)(authData2.signCount).toBe(26);
+    });
+    (0, globals_1.test)("Authenticate Passkeys with an illegal origin _ failed to response", async () => {
+        const [emulator, testServer] = await createCredential();
+        const illegalOrigin = `${webauthn_test_server_1.TEST_RP_ORIGIN}_illegal`;
+        const options = await testServer.getAuthenticationOptions();
+        await (0, globals_1.expect)(async () => {
+            emulator.getJSON(illegalOrigin, options);
+        }).rejects.toThrow(src_1.InvalidRpIdError);
+    });
+    (0, globals_1.test)("Request Passkeys with no public key credential parameters _ failed to response", async () => {
+        const emulator = new src_1.default();
+        await (0, globals_1.expect)(async () => {
+            emulator.get(webauthn_test_server_1.TEST_RP_ORIGIN, {});
+        }).rejects.toThrow(src_1.NoPublicKeyError);
+    });
+    (0, globals_1.test)("Not found in allow list _ CTAP Error", async () => {
+        const [emulator, testServer] = await createCredential();
+        const options = await testServer.getAuthenticationOptions();
+        await (0, globals_1.expect)(async () => {
+            emulator.getJSON(webauthn_test_server_1.TEST_RP_ORIGIN, {
+                ...options,
+                allowCredentials: [{ id: "AAAAAA", type: "public-key" }],
+            });
+        }).rejects.toThrow(new src_1.AuthenticationEmulatorError(src_1.CTAP_STATUS_CODE.CTAP2_ERR_NO_CREDENTIALS));
+    });
+    (0, globals_1.test)("User authentication operation failed _ CTAP Error", async () => {
+        const authenticator = new src_1.AuthenticatorEmulator({
+            userGetAssertionInteraction: () => undefined,
+        });
+        const [emulator, testServer] = await createCredential(authenticator);
+        const options = await testServer.getAuthenticationOptions();
+        await (0, globals_1.expect)(async () => {
+            emulator.getJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        }).rejects.toThrow(new src_1.AuthenticationEmulatorError(src_1.CTAP_STATUS_CODE.CTAP2_ERR_OPERATION_DENIED));
+    });
+    (0, globals_1.test)("Only one credential is allowed and RP ID is undefined _ credential is undefined and OK", async () => {
+        const [emulator, testServer] = await createCredential();
+        const options = await testServer.getAuthenticationOptions();
+        const credential = (emulator.authenticator.params.credentialsRepository?.loadCredentials() ?? [])[0];
+        emulator.getJSON(webauthn_test_server_1.TEST_RP_ORIGIN, {
+            ...options,
+            rpId: undefined,
+            allowCredentials: [(0, src_1.toPublicKeyCredentialDescriptorJSON)(credential.publicKeyCredentialDescriptor)],
+        });
+    });
+    (0, globals_1.test)("Stateless Authenticator Test _ OK", async () => {
+        const authenticator = new src_1.AuthenticatorEmulator({ stateless: true });
+        const [emulator, testServer] = await createCredential(authenticator);
+        const options = await testServer.getAuthenticationOptions();
+        const credential = emulator.getJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        await testServer.getAuthenticationVerification(credential);
+        const credentialRecords = emulator.authenticator.params.credentialsRepository?.loadCredentials() ?? [];
+        const authData = (0, src_1.unpackAuthenticatorData)(encode_utils_1.default.decodeBase64Url(credential.response.authenticatorData));
+        (0, globals_1.expect)(credentialRecords.length).toBe(0);
+        (0, globals_1.expect)(authData.signCount).toBe(0);
+    });
+});
+(0, globals_1.describe)("WebAuthnEmulator getAuthenticatorInfo Test", () => {
+    (0, globals_1.test)("Get Authenticator Information _ OK", () => {
+        const emulator = new src_1.default();
+        const info = emulator.getAuthenticatorInfo();
+        (0, globals_1.expect)(info).toEqual({
+            version: "FIDO_2_0",
+            aaguid: "TklELUFVVEgtMzE0MTU5Mg",
+            options: { rk: true, uv: true },
+        });
+    });
+});

package/dist/spec/webauthn/webauthn-model-json.spec.d.ts

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

package/dist/spec/webauthn/webauthn-model-json.spec.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const encode_utils_1 = __importDefault(require("../../src/libs/encode-utils"));
+const webauthn_emulator_1 = require("../../src/webauthn/webauthn-emulator");
+const webauthn_model_json_1 = require("../../src/webauthn/webauthn-model-json");
+(0, globals_1.describe)("WebAuthn JSON Model Test", () => {
+    const creationOption = {
+        rp: { name: "test-rp.org", id: "test-rp.org" },
+        user: { id: encode_utils_1.default.strToUint8Array("test-user"), name: "user", displayName: "user" },
+        excludeCredentials: [{ id: encode_utils_1.default.strToUint8Array("test-credential"), type: "public-key" }],
+        challenge: encode_utils_1.default.strToUint8Array("challenge"),
+        pubKeyCredParams: [{ alg: -7, type: "public-key" }],
+    };
+    const requestOption = {
+        challenge: encode_utils_1.default.strToUint8Array("challenge"),
+        allowCredentials: [{ id: encode_utils_1.default.strToUint8Array("test-credential"), type: "public-key" }],
+        rpId: "test-rp.org",
+        timeout: 60000,
+        userVerification: "required",
+    };
+    (0, globals_1.test)("Create Option JSON Serialize Deserialize test", async () => {
+        const json = (0, webauthn_model_json_1.toCreationOptionsJSON)(creationOption);
+        const model = (0, webauthn_model_json_1.parseCreationOptionsFromJSON)(json);
+        const reJson = (0, webauthn_model_json_1.toCreationOptionsJSON)(model);
+        (0, globals_1.expect)(reJson).toEqual(json);
+    });
+    (0, globals_1.test)("Create Response JSON Serialize Deserialize test", async () => {
+        const emulator = new webauthn_emulator_1.WebAuthnEmulator();
+        const response = emulator.create("https://test-rp.org", { publicKey: creationOption });
+        const json = (0, webauthn_model_json_1.toRegistrationResponseJSON)(response);
+        const model = (0, webauthn_model_json_1.parseRegistrationResponseFromJSON)(json);
+        const reJson = (0, webauthn_model_json_1.toRegistrationResponseJSON)(model);
+        (0, globals_1.expect)(reJson).toEqual(json);
+    });
+    (0, globals_1.test)("Get Option JSON Serialize Deserialize test", async () => {
+        const json = (0, webauthn_model_json_1.toRequestOptionsJSON)(requestOption);
+        const model = (0, webauthn_model_json_1.parseRequestOptionsFromJSON)(json);
+        const reJson = (0, webauthn_model_json_1.toRequestOptionsJSON)(model);
+        (0, globals_1.expect)(reJson).toEqual(json);
+    });
+    (0, globals_1.test)("Get Response JSON Serialize Deserialize test", async () => {
+        const emulator = new webauthn_emulator_1.WebAuthnEmulator();
+        emulator.create("https://test-rp.org", { publicKey: creationOption });
+        const response = emulator.get("https://test-rp.org", {
+            publicKey: { ...requestOption, allowCredentials: undefined },
+        });
+        const json = (0, webauthn_model_json_1.toAuthenticationResponseJSON)(response);
+        const model = (0, webauthn_model_json_1.parseAuthenticationResponseFromJSON)(json);
+        const reJson = (0, webauthn_model_json_1.toAuthenticationResponseJSON)(model);
+        (0, globals_1.expect)(reJson).toEqual(json);
+    });
+    (0, globals_1.test)("Create Response JSON optional test", async () => {
+        const emulator = new webauthn_emulator_1.WebAuthnEmulator();
+        const customOption = { publicKey: { ...creationOption, excludeCredentials: undefined } };
+        const json = emulator.createJSON("https://test-rp.org", (0, webauthn_model_json_1.toCreationOptionsJSON)(customOption.publicKey));
+        const customJson = {
+            ...json,
+            authenticatorAttachment: "platform",
+            response: { ...json.response, publicKey: undefined, publicKeyAlgorithm: undefined },
+        };
+        const model = (0, webauthn_model_json_1.parseRegistrationResponseFromJSON)(customJson);
+        (0, globals_1.expect)(model.authenticatorAttachment).toEqual(customJson.authenticatorAttachment);
+        (0, globals_1.expect)(model.response.getPublicKey()).toBeNull();
+        (0, globals_1.expect)(model.response.getPublicKeyAlgorithm()).toEqual(-1);
+        (0, globals_1.expect)((0, webauthn_model_json_1.toRegistrationResponseJSON)(model)).toEqual(customJson);
+        (0, globals_1.expect)(model.toJSON()).toEqual(customJson);
+    });
+    (0, globals_1.test)("Get Response JSON optional test", async () => {
+        const emulator = new webauthn_emulator_1.WebAuthnEmulator();
+        const customOption = { publicKey: { ...requestOption, allowCredentials: undefined } };
+        const json = emulator.getJSON("https://test-rp.org", (0, webauthn_model_json_1.toRequestOptionsJSON)(customOption.publicKey));
+        const customJson = {
+            ...json,
+            authenticatorAttachment: "platform",
+            response: { ...json.response, userHandle: undefined },
+        };
+        const model = (0, webauthn_model_json_1.parseAuthenticationResponseFromJSON)(customJson);
+        (0, globals_1.expect)(model.response.userHandle).toBeNull();
+        (0, globals_1.expect)((0, webauthn_model_json_1.toAuthenticationResponseJSON)(model)).toEqual(customJson);
+        (0, globals_1.expect)(model.toJSON()).toEqual(customJson);
+    });
+    (0, globals_1.test)("Parse Authentication Response with User Handle JSON test", async () => {
+        const testData = {
+            type: "public-key",
+            id: "AAAAAA",
+            rawId: "AAAAAA",
+            response: {
+                clientDataJSON: "BBBBBB",
+                authenticatorData: "CCCCCC",
+                signature: "DDDDDD",
+                userHandle: "EEEEEE",
+            },
+            clientExtensionResults: {},
+        };
+        const model = (0, webauthn_model_json_1.parseAuthenticationResponseFromJSON)(testData);
+        const json = model.toJSON();
+        (0, globals_1.expect)(json).toEqual(testData);
+    });
+});

package/dist/spec/webauthn/webauthn-model.spec.d.ts

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

package/dist/spec/webauthn/webauthn-model.spec.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const encode_utils_1 = __importDefault(require("../../src/libs/encode-utils"));
+const webauthn_emulator_1 = require("../../src/webauthn/webauthn-emulator");
+const webauthn_model_1 = require("../../src/webauthn/webauthn-model");
+(0, globals_1.describe)("WebAuthn Model Test", () => {
+    const webauthnEmulator = new webauthn_emulator_1.WebAuthnEmulator();
+    (0, globals_1.test)("Attestation Object pack and unpack", async () => {
+        const createResponse = webauthnEmulator.create("https://test-rp.org", {
+            publicKey: {
+                rp: { name: "test-rp.org", id: "test-rp.org" },
+                user: { id: encode_utils_1.default.strToUint8Array("test-user"), name: "user", displayName: "user" },
+                challenge: encode_utils_1.default.strToUint8Array("challenge"),
+                pubKeyCredParams: [{ alg: -7, type: "public-key" }],
+            },
+        });
+        const testData = new Uint8Array(createResponse.response.attestationObject);
+        const unpacked = (0, webauthn_model_1.unpackAttestationObject)(testData);
+        const rePacked = (0, webauthn_model_1.packAttestationObject)(unpacked);
+        const reUnpacked = (0, webauthn_model_1.unpackAttestationObject)(rePacked);
+        (0, globals_1.expect)(rePacked).toEqual(testData);
+        (0, globals_1.expect)(reUnpacked).toEqual(unpacked);
+    });
+    (0, globals_1.test)("Attestation Object pack and unpack optional1", async () => {
+        const testData = {
+            fmt: "none",
+            authData: {
+                flags: {
+                    userPresent: false,
+                    userVerified: false,
+                    backupEligibility: false,
+                    backupState: false,
+                    extensionData: true,
+                    attestedCredentialData: false,
+                },
+                rpIdHash: new Uint8Array(32),
+                signCount: 0,
+            },
+            attStmt: { test: "test123" },
+        };
+        const packed = (0, webauthn_model_1.packAttestationObject)(testData);
+        const unpacked = (0, webauthn_model_1.unpackAttestationObject)(packed);
+        (0, globals_1.expect)(unpacked).toEqual(testData);
+    });
+    (0, globals_1.test)("Undefined User Handle PublicKey serialize test", async () => {
+        const testData = {
+            type: "public-key",
+            id: new Uint8Array([116, 101, 115, 116, 45, 99]),
+            privateKey: new Uint8Array([116, 101, 115, 116, 45, 99]),
+            rpId: new webauthn_model_1.RpId("test-rp.org"),
+            userHandle: undefined,
+        };
+        const json = (0, webauthn_model_1.toPublickeyCredentialSourceJSON)(testData);
+        const model = (0, webauthn_model_1.parsePublicKeyCredentialSourceFromJSON)(json);
+        (0, globals_1.expect)(model).toEqual(testData);
+    });
+    globals_1.test.each([
+        [
+            { residentKey: "required", userVerification: "required" },
+            { rk: true, uv: true, up: true },
+        ],
+        [
+            { residentKey: "preferred", userVerification: "preferred" },
+            { rk: true, uv: true, up: true },
+        ],
+        [
+            { residentKey: "discouraged", userVerification: "discouraged" },
+            { rk: false, uv: false, up: true },
+        ],
+        [
+            { requireResidentKey: true, userVerification: "preferred" },
+            { rk: true, uv: true, up: true },
+        ],
+        [
+            { residentKey: "discouraged", userVerification: "preferred" },
+            { rk: false, uv: true, up: true },
+        ],
+        [
+            { requireResidentKey: false, userVerification: "preferred" },
+            { rk: false, uv: true, up: true },
+        ],
+    ])("toFido2CreateOptions test: $a", (criteria, expected) => {
+        (0, globals_1.expect)((0, webauthn_model_1.toFido2CreateOptions)(criteria)).toEqual(expected);
+    });
+    globals_1.test.each([
+        ["required", true],
+        ["preferred", true],
+        ["discouraged", false],
+        [undefined, false],
+    ])("UserVerificationRequirement test: $a", (criteria, expected) => {
+        (0, globals_1.expect)((0, webauthn_model_1.toFido2RequestOptions)(criteria).uv).toEqual(expected);
+    });
+});

package/dist/spec/webauthn/webauthn-test-server.d.ts

@@ -0,0 +1,15 @@
+import type { AuthenticationResponseJSON, PublicKeyCredentialCreationOptionsJSON, PublicKeyCredentialRequestOptionsJSON, RegistrationResponseJSON } from "../../src";
+import type { PasskeysApiClient, PasskeysUser } from "../integration/passkeys-api-client";
+export declare const TEST_RP_ORIGIN = "https://test-rp.com";
+export declare const TEST_RP_ID = "test-rp.com";
+export declare class WebAuthnTestServer implements PasskeysApiClient {
+    origin: string;
+    rpID: string;
+    private challenges;
+    private credentials;
+    constructor(origin?: string, rpID?: string);
+    getRegistrationOptions(user: PasskeysUser): Promise<PublicKeyCredentialCreationOptionsJSON>;
+    getRegistrationVerification(user: PasskeysUser, response: RegistrationResponseJSON): Promise<void>;
+    getAuthenticationOptions(): Promise<PublicKeyCredentialRequestOptionsJSON>;
+    getAuthenticationVerification(response: AuthenticationResponseJSON): Promise<void>;
+}