nid-webauthn-emulator 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (C) 2024 Nikkei Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,185 @@
+# NID WebAuthn Emulator
+
+[![CI Status](https://github.com/Nikkei/nid-webauthn-emulator/actions/workflows/ci.yml/badge.svg)](https://github.com/Nikkei/nid-webauthn-emulator/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+`NID WebAuthn Emulator` は、[FIDO2/CTAP Authenticator のエミュレータ](src/authenticator/authenticator-emulator.ts) およびそれを利用した [WebAuthn API のエミュレータ](src/webauthn/webauthn-emulator.ts) ライブラリです。それぞれ WebAuthn API および CTAP の仕様に基づいて実装されています。このモジュールは Node.js 上で動作し、ローカルでの Passkeys の統合テストを目的として設計されています。
+
+それぞれのエミュレータの詳細な仕様は下記を参照してください。
+
+- [FIDO2/CTAP Authenticator Emulator 開発者向け詳細仕様](docs/authenticator-emulator.md)
+- [WebAuthn API Emulator 開発者向け詳細仕様](docs/webauthn-emulator.md)
+
+## 使用方法
+
+```bash
+npm install nid-webauthn-emulator
+```
+
+基本的な使い方は `WebAuthnEmulator` クラスを作成し、`create` および `get` メソッドを利用することで、WebAuthn API における `navigator.credentials.create` および `navigator.credentials.get` をエミュレーションすることができます。
+
+```TypeScript
+import WebAuthnEmulator from "nid-webauthn-emulator";
+
+const emulator = new WebAuthnEmulator();
+const origin = "https://example.com";
+
+emulator.create(origin, creationOptions);
+emulator.get(origin, requestOptions);
+```
+
+また、`createJSON` および `getJSON` メソッドを利用することで、WebAuthn API で WebAuthn API 仕様に基づいた JSON データでのエミュレーションを行うこともできます。
+
+```TypeScript
+emulator.createJSON(origin, creationOptionsJSON);
+emulator.getJSON(origin, requestOptionsJSON);
+```
+
+これらの JSON の仕様は、標準仕様の下記に定義されたデータです。
+
+- <https://www.w3.org/TR/webauthn-3/#dictdef-authenticationresponsejson>
+- <https://www.w3.org/TR/webauthn-3/#dictdef-registrationresponsejson>
+
+`WebAuthnEmulator` クラスは標準で下記の FIDO2/CTAP Authenticator をエミュレートします。
+
+- 自動で User Verification を行います (`uv` フラグを立てます)
+- ES256, RS256, EdDSA のアルゴリズムをサポートします
+- USB 接続の CTAP2 デバイスをエミュレートします
+- AAGUID は `NID-AUTH-3141592` です
+- 認証時には Sign Counter を `1` インクリメントさせます
+
+これらの設定は下記のように `AuthenticatorEmulator` クラスを作成し、`WebAuthnEmulator` クラスに渡すことで、Authenticator の挙動を変更することができます。
+
+```TypeScript
+import WebAuthnEmulator, { AuthenticatorEmulator } from "nid-webauthn-emulator";
+
+const authenticator = new AuthenticatorEmulator({
+  algorithmIdentifiers: ["ES256"],
+  verifications: {
+    userVerified: false,
+    userPresent: false,
+  },
+  signCounterIncrement: 0,
+});
+
+const webAuthnEmulator = new WebAuthnEmulator(authenticator);
+```
+
+`AuthenticatorEmulator` は FIDO2/CTAP の仕様のうち下記のコマンドを実装しています。
+
+- `authenticatorMakeCredential` (CTAP2) : 認証情報の作成
+- `authenticatorGetAssertion` (CTAP2) : 認証情報の取得
+- `authenticatorGetInfo` (CTAP2) : 認証情報の取得
+
+これらは通常は直接利用することはありませんが、`WebAuthnEmulator` クラスの内部で CTAP のプロトコルに従って下記の通り呼び出されています。
+
+```TypeScript
+const authenticatorRequest = packMakeCredentialRequest({
+  clientDataHash: createHash("sha256").update(clientDataJSON).digest(),
+  rp: options.publicKey.rp,
+  user: options.publicKey.user,
+  pubKeyCredParams: options.publicKey.pubKeyCredParams,
+  excludeList: options.publicKey.excludeCredentials,
+  options: {
+    rk: options.publicKey.authenticatorSelection?.requireResidentKey,
+    uv: options.publicKey.authenticatorSelection?.userVerification !== "discouraged",
+  },
+});
+const authenticatorResponse = unpackMakeCredentialResponse(this.authenticator.command(authenticatorRequest));
+```
+
+## [WebAuthn.io](https://webauthn.io/) での実行例
+
+WebAuthn の著名なデモサイトである [webauthn.io](https://webauthn.io/) での使用例を示します。[統合テスト](spec/integration/integration.spec.ts) に実際にうごくテストコード例があります。
+
+```TypeScript
+// Origin および WebAuthn API エミュレータを初期化します
+// ここでは、https://webauthn.io を Origin として利用します
+const origin = "https://webauthn.io";
+const emulator = new WebAuthnEmulator();
+const webauthnIO = await WebAuthnIO.create();
+const user = webauthnIO.getUser();
+
+// Authenticator の情報を表示します
+console.log("Authenticator Information", emulator.getAuthenticatorInfo());
+
+// WebAuthn API Emulator により パスキーを作成します
+const creationOptions = await webauthnIO.getRegistrationOptions(user);
+const creationCredential = emulator.createJSON(origin, creationOptions);
+await webauthnIO.getRegistrationVerification(user, creationCredential);
+
+// 認証を webauthn.io で検証します
+const requestOptions = await webauthnIO.getAuthenticationOptions();
+const requestCredential = emulator.getJSON(origin, requestOptions);
+await webauthnIO.getAuthenticationVerification(requestCredential);
+```
+
+## Playwright による自動テスト
+
+このライブラリは Passkeys の E2E テストでの利用を目的としており、特に Playwright での利用を想定しています。Playwright でのテスト用にユーティリティクラス `BrowserInjection` を利用して簡単に、WebAuthn API エミュレータを利用することができます。使い方は下記の通りです。
+
+```TypeScript
+import WebAuthnEmulator, {
+  BrowserInjection,
+  type PublicKeyCredentialCreationOptionsJSON,
+  type PublicKeyCredentialRequestOptionsJSON,
+} from "nid-webauthn-emulator";
+
+async function startWebAuthnEmulator(page: Page, origin: string, debug = false) {
+  const emulator = new WebAuthnEmulator();
+
+  await page.exposeFunction(
+    BrowserInjection.WebAuthnEmulatorCreate,
+    async (optionsJSON: PublicKeyCredentialCreationOptionsJSON) => {
+      const response = emulator.createJSON(origin, optionsJSON);
+      return response;
+    },
+  );
+
+  await page.exposeFunction(
+    BrowserInjection.WebAuthnEmulatorGet,
+    async (optionsJSON: PublicKeyCredentialRequestOptionsJSON) => {
+      const response = emulator.getJSON(origin, optionsJSON);
+      return response;
+    },
+  );
+}
+
+test.describe("Passkeys Tests", { tag: ["@daily"] }, () => {
+  test("Passkeys login test", async ({ page }) => {
+    // Page内で最初に1回だけ定義する exposed functions
+    await startWebAuthnEmulator(page, env, true);
+    await page.goto("https://example.com/passkeys/login");
+
+    // Passkeys の WebAuthn API をフック開始
+    // ページ遷移後に実行する必要がある
+    await page.evaluate(BrowserInjection.HookWebAuthnApis);
+  });
+});
+```
+
+`startWebAuthnEmulator` では Playwright の `exposeFunction` を利用して、`WebAuthnEmulator` の `createJSON` および `getJSON` メソッドをブラウザのコンテキストに注入します。これにより、Playwright でのテストコンテキストにおいて `WebAuthnEmulator` クラスの `get` および `create` の各 API がそれぞれ `window` オブジェクトの下に定義されるようになります。
+
+- `window.webAuthnEmulatorGet`: `WebAuthnEmulator.getJSON` の Exposed Function
+- `window.webAuthnEmulatorCreate`: `WebAuthnEmulator.createJSON` の Exposed Function
+
+これらは Page グローバルに定義されるため、Page インスタンスにつき 1 回だけ定義する必要があります。
+
+次に `navigator.credentials.get` 等の WebAuthn API をフックするために、`BrowserInjection.HookWebAuthnApis` をテストコンテキストにおいて評価します。
+
+```TypeScript
+await page.evaluate(BrowserInjection.HookWebAuthnApis);
+```
+
+`BrowserInjection.HookWebAuthnApis` は JavaScript 関数のシリアライズされた文字列であり、評価すると下記のような処理を行います。
+
+- `navigator.credentials.get` の定義を上書きし、`window.webAuthnEmulatorGet` を呼び出す
+- `navigator.credentials.create` の定義を上書きし、`window.webAuthnEmulatorCreate` を呼び出す
+
+これにより先ほどの `exposeFunction` で定義した `WebAuthnEmulator` のメソッドが、`navigator.credentials.get` および `navigator.credentials.create` 呼び出し時に実行されるようになります。これらの処理中にはテストコンテキストと Playwright のコンテキスト間の通信のためにデータのシリアライズおよびデシリアライズが行われるため、そのための処理も含まれています。
+
+## ライセンス
+
+MIT License
+
+Copyright (C) 2024 Nikkei Inc.

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const globals_2 = require("@jest/globals");
+const src_1 = require("../../src");
+const ctap_model_1 = require("../../src/authenticator/ctap-model");
+(0, globals_1.describe)("Authenticator Emulator Exceptional Test", () => {
+    // Success case has been tested in the webauthn-emulator.spec.ts
+    (0, globals_1.test)("Unknown command _ CTAP Error", async () => {
+        const testRequest = {
+            command: ctap_model_1.CTAP_COMMAND.authenticatorReset,
+        };
+        const authenticator = new src_1.AuthenticatorEmulator();
+        (0, globals_2.expect)(() => {
+            authenticator.command(testRequest);
+        }).toThrowError("CTAP error: CTAP1_ERR_INVALID_COMMAND (1)");
+    });
+});

package/dist/spec/authenticator/ctap-model.spec.d.ts

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

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const globals_2 = require("@jest/globals");
+const ctap_model_1 = require("../../src/authenticator/ctap-model");
+(0, globals_1.describe)("CTAP Model Test", () => {
+    (0, globals_1.test)("MakeCredentialRequest CTAP Object pack and unpack", async () => {
+        const testRequest = {
+            clientDataHash: new Uint8Array([99, 104, 97, 108, 108, 101, 110, 103, 101]),
+            rp: { name: "webauthn.io", id: "webauthn.io" },
+            user: { id: new Uint8Array([116, 101, 115, 116, 45, 117, 115, 101, 114]), name: "user", displayName: "user" },
+            pubKeyCredParams: [{ alg: -7, type: "public-key" }],
+            excludeList: [{ id: new Uint8Array([116, 101, 115, 116, 45, 99]), type: "public-key" }],
+            options: { rk: true, uv: true },
+            pinAuth: new Uint8Array([112, 105, 110, 65, 117, 116, 104]),
+            extensions: {},
+            pinProtocol: 9,
+        };
+        const packed = (0, ctap_model_1.packMakeCredentialRequest)(testRequest);
+        const unpacked = (0, ctap_model_1.unpackRequest)(packed);
+        const rePacked = (0, ctap_model_1.packMakeCredentialRequest)(unpacked.request);
+        (0, globals_2.expect)(packed).toEqual(rePacked);
+        (0, globals_2.expect)(unpacked.request).toEqual(testRequest);
+    });
+    (0, globals_1.test)("GetAssertionRequest CTAP Object pack and unpack", async () => {
+        const testRequest = {
+            rpId: "webauthn.io",
+            clientDataHash: new Uint8Array([99, 104, 97, 108, 108, 101, 110, 103, 101]),
+            allowList: [{ id: new Uint8Array([116, 101, 115, 116, 45, 99]), type: "public-key" }],
+            extensions: {},
+            options: { up: true, uv: true },
+            pinAuth: new Uint8Array([112, 105, 110, 65, 117, 116, 104]),
+            pinProtocol: 9,
+        };
+        const packed = (0, ctap_model_1.packGetAssertionRequest)(testRequest);
+        const unpacked = (0, ctap_model_1.unpackRequest)(packed);
+        const rePacked = (0, ctap_model_1.packGetAssertionRequest)(unpacked.request);
+        (0, globals_2.expect)(packed).toEqual(rePacked);
+        (0, globals_2.expect)(unpacked.request).toEqual(testRequest);
+    });
+    (0, globals_1.test)("MakeCredentialResponse CTAP Object pack and unpack", async () => {
+        const testResponse = {
+            fmt: "none",
+            attStmt: {},
+            authData: new Uint8Array([97, 117, 116, 104, 68, 97, 116, 97]),
+        };
+        const packed = (0, ctap_model_1.packMakeCredentialResponse)(testResponse);
+        const unpacked = (0, ctap_model_1.unpackMakeCredentialResponse)(packed);
+        const rePacked = (0, ctap_model_1.packMakeCredentialResponse)(unpacked);
+        (0, globals_2.expect)(packed).toEqual(rePacked);
+        (0, globals_2.expect)(unpacked).toEqual(testResponse);
+    });
+    (0, globals_1.test)("GetAssertionResponse CTAP Object pack and unpack", async () => {
+        const testResponse = {
+            authData: new Uint8Array([97, 117, 116, 104, 68, 97, 116, 97]),
+            signature: new Uint8Array([115, 105, 103]),
+            user: { id: new Uint8Array([116, 101, 115, 116, 45, 117, 115, 101, 114]), name: "user", displayName: "user" },
+            numberOfCredentials: 1,
+        };
+        const packed = (0, ctap_model_1.packGetAssertionResponse)(testResponse);
+        const unpacked = (0, ctap_model_1.unpackGetAssertionResponse)(packed);
+        const rePacked = (0, ctap_model_1.packGetAssertionResponse)(unpacked);
+        (0, globals_2.expect)(packed).toEqual(rePacked);
+        (0, globals_2.expect)(unpacked).toEqual(testResponse);
+    });
+    (0, globals_1.test)("GetInfoResponse CTAP Object pack and unpack", async () => {
+        const testResponse = {
+            versions: ["U2F_V2"],
+            extensions: ["credProtect"],
+            aaguid: new Uint8Array([97, 97, 103, 117, 105, 100]),
+            options: { plat: false, rk: true, clientPin: true, up: true, uv: true },
+            maxMsgSize: 1200,
+            pinProtocols: [1, 2, 3],
+        };
+        const packed = (0, ctap_model_1.packGetInfoResponse)(testResponse);
+        const unpacked = (0, ctap_model_1.unpackGetInfoResponse)(packed);
+        const rePacked = (0, ctap_model_1.packGetInfoResponse)(unpacked);
+        (0, globals_2.expect)(packed).toEqual(rePacked);
+        (0, globals_2.expect)(unpacked).toEqual(testResponse);
+    });
+    (0, globals_1.test)("Illegal data parse test _ failed to unpack", async () => {
+        const response = {};
+        const expected = "CTAP error: CTAP2_ERR_INVALID_CBOR (18)";
+        (0, globals_2.expect)(() => (0, ctap_model_1.unpackMakeCredentialResponse)(response)).toThrowError(expected);
+        (0, globals_2.expect)(() => (0, ctap_model_1.unpackGetAssertionResponse)(response)).toThrowError(expected);
+        (0, globals_2.expect)(() => (0, ctap_model_1.unpackGetInfoResponse)(response)).toThrowError(expected);
+    });
+    (0, globals_1.test)("Illegal cbor data parse test _ failed to unpack", async () => {
+        const request = {
+            command: ctap_model_1.CTAP_COMMAND.authenticatorMakeCredential,
+            data: new Uint8Array([1, 2, 3, 4, 5]),
+        };
+        (0, globals_2.expect)(() => (0, ctap_model_1.unpackRequest)(request)).toThrowError("CTAP error: CTAP2_ERR_INVALID_CBOR (18)");
+    });
+});

package/dist/spec/integration/integration.spec.d.ts

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

package/dist/spec/integration/integration.spec.js

@@ -0,0 +1,32 @@
+"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 index_1 = __importDefault(require("../../src/index"));
+const webauthn_io_1 = require("./webauthn-io");
+(0, globals_1.describe)("Passkeys Integration Test by webauthn.io", () => {
+    globals_1.test.skip("Registration Ceremony and Authentication Ceremony", async () => {
+        const origin = "https://webauthn.io";
+        const emulator = new index_1.default();
+        const webauthnIO = await webauthn_io_1.WebAuthnIO.create();
+        const user = webauthnIO.getUser();
+        // Authenticator Information
+        console.log("Authenticator Information", emulator.getAuthenticatorInfo());
+        // Create passkey.
+        const creationOptions = await webauthnIO.getRegistrationOptions(user);
+        console.log("Registration options", creationOptions);
+        const creationCredential = emulator.createJSON(origin, creationOptions);
+        console.log("Registration credential", creationCredential);
+        await webauthnIO.getRegistrationVerification(user, creationCredential);
+        console.log("Registration verification completed");
+        // Authenticate passkey.
+        const requestOptions = await webauthnIO.getAuthenticationOptions();
+        console.log("Authentication options", requestOptions);
+        const requestCredential = emulator.getJSON(origin, requestOptions);
+        console.log("Authentication credential", requestCredential);
+        await webauthnIO.getAuthenticationVerification(requestCredential);
+        console.log("Authentication verification completed");
+    }, 60000);
+});

package/dist/spec/integration/passkeys-api-client.d.ts

@@ -0,0 +1,11 @@
+import type { AuthenticationResponseJSON, PublicKeyCredentialCreationOptionsJSON, PublicKeyCredentialRequestOptionsJSON, RegistrationResponseJSON } from "../../src/webauthn/webauthn-model-json";
+export interface PasskeysUser {
+    username: string;
+    id: string;
+}
+export interface PasskeysApiClient {
+    getRegistrationOptions(user: PasskeysUser): Promise<PublicKeyCredentialCreationOptionsJSON>;
+    getRegistrationVerification(user: PasskeysUser, response: RegistrationResponseJSON): Promise<void>;
+    getAuthenticationOptions(): Promise<PublicKeyCredentialRequestOptionsJSON>;
+    getAuthenticationVerification(response: AuthenticationResponseJSON): Promise<void>;
+}

package/dist/spec/integration/passkeys-api-client.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/spec/integration/webauthn-io.d.ts

@@ -0,0 +1,32 @@
+import type { AuthenticationResponseJSON, PublicKeyCredentialCreationOptionsJSON, PublicKeyCredentialRequestOptionsJSON, RegistrationResponseJSON } from "../../src/webauthn/webauthn-model-json";
+import type { PasskeysApiClient, PasskeysUser } from "./passkeys-api-client";
+/**
+ * Passkeys Api Client implementation for webauthn.io
+ */
+export declare class WebAuthnIO implements PasskeysApiClient {
+    private sessionId;
+    private constructor();
+    static create(): Promise<WebAuthnIO>;
+    getUser(): PasskeysUser;
+    /**
+     * Get a passkey registration options by https://webauthn.io/registration/options
+     * @returns PublicKeyCredentialCreationOptionsJSON
+     */
+    getRegistrationOptions(user: PasskeysUser): Promise<PublicKeyCredentialCreationOptionsJSON>;
+    /**
+     * Register your passkey account by https://webauthn.io/registration/verification
+     * @param response RegistrationResponseJSON
+     */
+    getRegistrationVerification(user: PasskeysUser, response: RegistrationResponseJSON): Promise<void>;
+    /**
+     * Get a passkey authentication options by https://webauthn.io/authentication/options
+     * @returns PublicKeyCredentialRequestOptionsJSON
+     */
+    getAuthenticationOptions(): Promise<PublicKeyCredentialRequestOptionsJSON>;
+    /**
+     * Authenticate your passkey account by https://webauthn.io/authentication/verification
+     * @param response AuthenticationResponseJSON
+     */
+    getAuthenticationVerification(response: AuthenticationResponseJSON): Promise<void>;
+    private static getSessionId;
+}

package/dist/spec/integration/webauthn-io.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAuthnIO = void 0;
+/**
+ * Passkeys Api Client implementation for webauthn.io
+ */
+class WebAuthnIO {
+    sessionId;
+    constructor(sessionId) {
+        this.sessionId = sessionId;
+    }
+    static async create() {
+        const sessionId = await WebAuthnIO.getSessionId();
+        return new WebAuthnIO(sessionId);
+    }
+    getUser() {
+        return { username: `user-${this.sessionId}`, id: this.sessionId };
+    }
+    /**
+     * Get a passkey registration options by https://webauthn.io/registration/options
+     * @returns PublicKeyCredentialCreationOptionsJSON
+     */
+    async getRegistrationOptions(user) {
+        const optionsRequest = {
+            username: user.username,
+            user_verification: "preferred",
+            attestation: "none",
+            attachment: "all",
+            algorithms: ["es256", "rs256"],
+            discoverable_credential: "preferred",
+            hints: [],
+        };
+        const options = await fetch("https://webauthn.io/registration/options", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(optionsRequest),
+        });
+        const optionsJson = await options.json();
+        return optionsJson;
+    }
+    /**
+     * Register your passkey account by https://webauthn.io/registration/verification
+     * @param response RegistrationResponseJSON
+     */
+    async getRegistrationVerification(user, response) {
+        const verificationRequest = {
+            response: response,
+            username: user.username,
+        };
+        const verification = await fetch("https://webauthn.io/registration/verification", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(verificationRequest),
+        });
+        const verificationJson = await verification.json();
+        if (!verificationJson.verified) {
+            throw new Error(`Verification failed: ${JSON.stringify(verificationJson)}`);
+        }
+    }
+    /**
+     * Get a passkey authentication options by https://webauthn.io/authentication/options
+     * @returns PublicKeyCredentialRequestOptionsJSON
+     */
+    async getAuthenticationOptions() {
+        const optionsRequest = {
+            user_verification: "preferred",
+        };
+        const options = await fetch("https://webauthn.io/authentication/options", {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Cookie: `sessionid=${this.sessionId}` },
+            body: JSON.stringify(optionsRequest),
+        });
+        const optionsJson = await options.json();
+        return optionsJson;
+    }
+    /**
+     * Authenticate your passkey account by https://webauthn.io/authentication/verification
+     * @param response AuthenticationResponseJSON
+     */
+    async getAuthenticationVerification(response) {
+        const verificationRequest = {
+            response: response,
+            username: "",
+        };
+        const verification = await fetch("https://webauthn.io/authentication/verification", {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Cookie: `sessionid=${this.sessionId}` },
+            body: JSON.stringify(verificationRequest),
+        });
+        const verificationJson = await verification.json();
+        if (!verificationJson.verified) {
+            throw new Error(`Verification failed: ${JSON.stringify(verificationJson)}`);
+        }
+    }
+    static async getSessionId() {
+        const home = await fetch("https://webauthn.io/");
+        return home.headers.get("set-cookie")?.split(";")[0].split("=")[1] ?? "";
+    }
+}
+exports.WebAuthnIO = WebAuthnIO;

package/dist/spec/libs/browser-injection.spec.d.ts

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

package/dist/spec/libs/browser-injection.spec.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const browser_injection_1 = require("../../src/test-utils/browser-injection");
+(0, globals_1.describe)("Browser Injection Test", () => {
+    (0, globals_1.test)("Browser Injection Test", async () => {
+        const window = { navigator: { credentials: { create: undefined, get: undefined } } };
+        const PublicKeyCredential = { isConditionalMediationAvailable: async () => false };
+        // biome-ignore lint/security/noGlobalEval: This is a test code.
+        eval(browser_injection_1.HookWebAuthnApis);
+        (0, globals_1.expect)(await PublicKeyCredential.isConditionalMediationAvailable()).toBeTruthy();
+        (0, globals_1.expect)(window.navigator.credentials.create).toBeDefined();
+        (0, globals_1.expect)(window.navigator.credentials.get).toBeDefined();
+    });
+});

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

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

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const authenticator_emulator_1 = require("../../src/authenticator/authenticator-emulator");
+const cose_key_1 = require("../../src/webauthn/cose-key");
+const webauthn_model_1 = require("../../src/webauthn/webauthn-model");
+globals_1.describe.each([-7, -8, -257])("CoseKey Test: %s", (alg) => {
+    const getKey = () => {
+        const authenticator = new authenticator_emulator_1.AuthenticatorEmulator();
+        const rpId = new webauthn_model_1.RpId("example.com");
+        const userHandle = new Uint8Array([0x01, 0x02, 0x03, 0x04]);
+        const credential = authenticator.authenticatorMakeCredential({
+            rp: { id: rpId.value, name: "example" },
+            user: { id: userHandle, name: "example", displayName: "example" },
+            pubKeyCredParams: [{ alg, type: "public-key" }],
+            clientDataHash: new Uint8Array(32),
+        });
+        return (0, webauthn_model_1.unpackAuthenticatorData)(credential.authData).attestedCredentialData?.credentialPublicKey;
+    };
+    (0, globals_1.test)("Der format _ serialize and deserialize test", async () => {
+        const testCoseKey = getKey();
+        const serialized = testCoseKey.toDer();
+        const deserialized = cose_key_1.CoseKey.fromDer(testCoseKey.toDer());
+        const reSerialized = deserialized.toDer();
+        (0, globals_1.expect)(testCoseKey.alg).toEqual(alg);
+        (0, globals_1.expect)(testCoseKey).toEqual(deserialized);
+        (0, globals_1.expect)(serialized).toEqual(reSerialized);
+    });
+    (0, globals_1.test)("Jwk format _ serialize and deserialize test", async () => {
+        const testCoseKey = getKey();
+        const serialized = testCoseKey.toJwk();
+        const deserialized = cose_key_1.CoseKey.fromJwk(testCoseKey.toJwk()).toJwk();
+        const reSerialized = cose_key_1.CoseKey.fromJwk(deserialized).toJwk();
+        (0, globals_1.expect)(testCoseKey.alg).toEqual(alg);
+        (0, globals_1.expect)(serialized).toEqual(deserialized);
+        (0, globals_1.expect)(serialized).toEqual(reSerialized);
+    });
+    (0, globals_1.test)("KeyObject format _ serialize and deserialize test", async () => {
+        const testCoseKey = getKey();
+        const serialized = testCoseKey.toKeyObject();
+        const deserialized = cose_key_1.CoseKey.fromKeyObject(testCoseKey.toKeyObject()).toKeyObject();
+        const reSerialized = cose_key_1.CoseKey.fromKeyObject(deserialized).toKeyObject();
+        (0, globals_1.expect)(testCoseKey.alg).toEqual(alg);
+        (0, globals_1.expect)(serialized).toEqual(deserialized);
+        (0, globals_1.expect)(serialized).toEqual(reSerialized);
+    });
+});

package/dist/spec/repository/credential-repository.spec.d.ts

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