nid-webauthn-emulator 0.1.5 → 0.2.1

package/README.md

@@ -143,6 +143,27 @@ async function startWebAuthnEmulator(page: Page, origin: string, debug = false)
       return response;
     },
   );
+
+  await page.exposeFunction(
+    BrowserInjection.WebAuthnEmulatorSignalUnknownCredential,
+    async (options: UnknownCredentialOptionsJSON) => {
+      emulator.signalUnknownCredential(options);
+    },
+  );
+
+  await page.exposeFunction(
+    BrowserInjection.WebAuthnEmulatorSignalAllAcceptedCredentials,
+    async (options: AllAcceptedCredentialsOptionsJSON) => {
+      emulator.signalAllAcceptedCredentials(options);
+    };
+  );
+
+  await page.exposeFunction(
+    BrowserInjection.WebAuthnEmulatorSignalCurrentUserDetails,
+    async (options: CurrentUserDetailsOptionsJSON) => {
+      emulator.signalCurrentUserDetails(options);
+    };
+  );
 }
 
 test.describe("Passkeys Tests", { tag: ["@daily"] }, () => {
@@ -162,6 +183,7 @@ test.describe("Passkeys Tests", { tag: ["@daily"] }, () => {
 
 - `window.webAuthnEmulatorGet`: `WebAuthnEmulator.getJSON` の Exposed Function
 - `window.webAuthnEmulatorCreate`: `WebAuthnEmulator.createJSON` の Exposed Function
+- `window.webAuthnEmulatorSignalUnknownCredential`: `WebAuthnEmulator.signalUnknownCredential` の Exposed Function
 
 これらは Page グローバルに定義されるため、Page インスタンスにつき 1 回だけ定義する必要があります。
 
@@ -175,6 +197,7 @@ await page.evaluate(BrowserInjection.HookWebAuthnApis);
 
 - `navigator.credentials.get` の定義を上書きし、`window.webAuthnEmulatorGet` を呼び出す
 - `navigator.credentials.create` の定義を上書きし、`window.webAuthnEmulatorCreate` を呼び出す
+- `PublicKeyCredential.signalUnknownCredential` の定義を追加し、`window.webAuthnEmulatorSignalUnknownCredential` を呼び出す
 
 これにより先ほどの `exposeFunction` で定義した `WebAuthnEmulator` のメソッドが、`navigator.credentials.get` および `navigator.credentials.create` 呼び出し時に実行されるようになります。これらの処理中にはテストコンテキストと Playwright のコンテキスト間の通信のためにデータのシリアライズおよびデシリアライズが行われるため、そのための処理も含まれています。
 

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

@@ -1,9 +1,14 @@
 "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 globals_2 = require("@jest/globals");
 const src_1 = require("../../src");
 const ctap_model_1 = require("../../src/authenticator/ctap-model");
+const ctap_model_2 = require("../../src/authenticator/ctap-model");
+const encode_utils_1 = __importDefault(require("../../src/libs/encode-utils"));
+const credentials_memory_repository_1 = require("../../src/repository/credentials-memory-repository");
 (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 () => {
@@ -11,8 +16,230 @@ const ctap_model_1 = require("../../src/authenticator/ctap-model");
             command: ctap_model_1.CTAP_COMMAND.authenticatorReset,
         };
         const authenticator = new src_1.AuthenticatorEmulator();
-        (0, globals_2.expect)(() => {
+        (0, globals_1.expect)(() => {
             authenticator.command(testRequest);
         }).toThrowError("CTAP error: CTAP1_ERR_INVALID_COMMAND (1)");
     });
 });
+(0, globals_1.describe)("Authenticator Credential Management Tests", () => {
+    let authenticator;
+    let repository;
+    // Test data
+    const rpId1 = "example.com";
+    const rpId2 = "test.com";
+    const user1 = {
+        id: encode_utils_1.default.strToUint8Array("user1-id"),
+        name: "user1",
+        displayName: "User One",
+    };
+    const user2 = {
+        id: encode_utils_1.default.strToUint8Array("user2-id"),
+        name: "user2",
+        displayName: "User Two",
+    };
+    const user3 = {
+        id: encode_utils_1.default.strToUint8Array("user3-id"),
+        name: "user3",
+        displayName: "User Three",
+    };
+    (0, globals_1.beforeEach)(() => {
+        // Create a new repository for each test
+        repository = new credentials_memory_repository_1.PasskeysCredentialsMemoryRepository();
+        // Create authenticator with the repository
+        authenticator = new src_1.AuthenticatorEmulator({
+            credentialsRepository: repository,
+        });
+        // Create test credentials
+        createTestCredential(rpId1, user1);
+        createTestCredential(rpId1, user2);
+        createTestCredential(rpId2, user3);
+    });
+    // Helper function to create a test credential
+    function createTestCredential(rpId, user) {
+        const clientDataHash = new Uint8Array(32).fill(1);
+        const makeCredentialRequest = {
+            clientDataHash,
+            rp: { id: rpId, name: rpId },
+            user,
+            pubKeyCredParams: [{ type: "public-key", alg: -7 }],
+        };
+        authenticator.authenticatorMakeCredential(makeCredentialRequest);
+    }
+    (0, globals_1.describe)("enumerateCredentialsBegin", () => {
+        (0, globals_1.test)("should return the total number of credentials for a specific RP", () => {
+            // Create request for enumerateCredentialsBegin
+            const request = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsBegin,
+                subCommandParams: {
+                    rpId: rpId1,
+                },
+            };
+            // Execute the command
+            const response = authenticator.authenticatorCredentialManagement(request);
+            // Verify the response
+            (0, globals_1.expect)(response.totalCredentials).toBe(2); // We created 2 credentials for rpId1
+        });
+        (0, globals_1.test)("should throw an error if rpId is not provided", () => {
+            // Create request without rpId
+            const request = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsBegin,
+            };
+            // Execute the command and expect an error
+            (0, globals_1.expect)(() => {
+                authenticator.authenticatorCredentialManagement(request);
+            }).toThrow(new ctap_model_2.AuthenticationEmulatorError(ctap_model_2.CTAP_STATUS_CODE.CTAP1_ERR_INVALID_PARAMETER));
+        });
+        (0, globals_1.test)("should return 0 credentials for an RP with no credentials", () => {
+            // Create request for a non-existent RP
+            const request = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsBegin,
+                subCommandParams: {
+                    rpId: "nonexistent.com",
+                },
+            };
+            // Execute the command
+            const response = authenticator.authenticatorCredentialManagement(request);
+            // Verify the response
+            (0, globals_1.expect)(response.totalCredentials).toBe(0);
+        });
+    });
+    (0, globals_1.describe)("enumerateCredentialsGetNextCredential", () => {
+        (0, globals_1.test)("should return credentials one by one", () => {
+            // First, call enumerateCredentialsBegin
+            const beginRequest = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsBegin,
+                subCommandParams: {
+                    rpId: rpId1,
+                },
+            };
+            authenticator.authenticatorCredentialManagement(beginRequest);
+            // Now call enumerateCredentialsGetNextCredential twice to get both credentials
+            const getNextRequest = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsGetNextCredential,
+            };
+            // Get first credential
+            const response1 = authenticator.authenticatorCredentialManagement(getNextRequest);
+            (0, globals_1.expect)(response1.user).toBeDefined();
+            (0, globals_1.expect)(response1.credentialID).toBeDefined();
+            (0, globals_1.expect)(response1.publicKey).toBeDefined();
+            // Get second credential
+            const response2 = authenticator.authenticatorCredentialManagement(getNextRequest);
+            (0, globals_1.expect)(response2.user).toBeDefined();
+            (0, globals_1.expect)(response2.credentialID).toBeDefined();
+            (0, globals_1.expect)(response2.publicKey).toBeDefined();
+            // Verify we got different credentials
+            if (response1.credentialID && response2.credentialID) {
+                (0, globals_1.expect)(encode_utils_1.default.encodeBase64Url(response1.credentialID)).not.toBe(encode_utils_1.default.encodeBase64Url(response2.credentialID));
+            }
+            // Verify we can't get more credentials
+            (0, globals_1.expect)(() => {
+                authenticator.authenticatorCredentialManagement(getNextRequest);
+            }).toThrow(new ctap_model_2.AuthenticationEmulatorError(ctap_model_2.CTAP_STATUS_CODE.CTAP2_ERR_NO_CREDENTIALS));
+        });
+        (0, globals_1.test)("should throw an error if called without calling enumerateCredentialsBegin first", () => {
+            const getNextRequest = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsGetNextCredential,
+            };
+            (0, globals_1.expect)(() => {
+                authenticator.authenticatorCredentialManagement(getNextRequest);
+            }).toThrow(new ctap_model_2.AuthenticationEmulatorError(ctap_model_2.CTAP_STATUS_CODE.CTAP2_ERR_NO_CREDENTIALS));
+        });
+    });
+    (0, globals_1.describe)("updateUserInformation", () => {
+        (0, globals_1.test)("should update user information for all credentials of a user", () => {
+            // Create updated user information
+            const updatedUser = {
+                id: user1.id, // Same ID
+                name: "user1-updated",
+                displayName: "Updated User One",
+            };
+            // Create request for updateUserInformation
+            const request = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.updateUserInformation,
+                subCommandParams: {
+                    rpId: rpId1,
+                    user: updatedUser,
+                },
+            };
+            // Execute the command
+            authenticator.authenticatorCredentialManagement(request);
+            // Verify the user information was updated by enumerating credentials
+            const beginRequest = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsBegin,
+                subCommandParams: {
+                    rpId: rpId1,
+                },
+            };
+            authenticator.authenticatorCredentialManagement(beginRequest);
+            const getNextRequest = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsGetNextCredential,
+            };
+            // Get credentials and check if user info was updated
+            const nextResponse = authenticator.authenticatorCredentialManagement(getNextRequest);
+            // Find the credential for user1
+            if (nextResponse.user &&
+                encode_utils_1.default.encodeBase64Url(nextResponse.user.id) === encode_utils_1.default.encodeBase64Url(user1.id)) {
+                (0, globals_1.expect)(nextResponse.user.name).toBe(updatedUser.name);
+                (0, globals_1.expect)(nextResponse.user.displayName).toBe(updatedUser.displayName);
+            }
+        });
+        (0, globals_1.test)("should throw an error if rpId is not provided", () => {
+            const request = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.updateUserInformation,
+                subCommandParams: {
+                    user: user1,
+                },
+            };
+            (0, globals_1.expect)(() => {
+                authenticator.authenticatorCredentialManagement(request);
+            }).toThrow(new ctap_model_2.AuthenticationEmulatorError(ctap_model_2.CTAP_STATUS_CODE.CTAP1_ERR_INVALID_PARAMETER));
+        });
+        (0, globals_1.test)("should throw an error if user is not provided", () => {
+            const request = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.updateUserInformation,
+                subCommandParams: {
+                    rpId: rpId1,
+                },
+            };
+            (0, globals_1.expect)(() => {
+                authenticator.authenticatorCredentialManagement(request);
+            }).toThrow(new ctap_model_2.AuthenticationEmulatorError(ctap_model_2.CTAP_STATUS_CODE.CTAP1_ERR_INVALID_PARAMETER));
+        });
+        (0, globals_1.test)("should throw an error if no credentials exist for the user", () => {
+            const nonExistentUser = {
+                id: encode_utils_1.default.strToUint8Array("nonexistent-id"),
+                name: "nonexistent",
+                displayName: "Non Existent User",
+            };
+            const request = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.updateUserInformation,
+                subCommandParams: {
+                    rpId: rpId1,
+                    user: nonExistentUser,
+                },
+            };
+            (0, globals_1.expect)(() => {
+                authenticator.authenticatorCredentialManagement(request);
+            }).toThrow(new ctap_model_2.AuthenticationEmulatorError(ctap_model_2.CTAP_STATUS_CODE.CTAP2_ERR_NO_CREDENTIALS));
+        });
+    });
+    (0, globals_1.describe)("authenticatorCredentialManagement with stateless authenticator", () => {
+        (0, globals_1.test)("should throw an error if authenticator is stateless", () => {
+            // Create a stateless authenticator
+            const statelessAuthenticator = new src_1.AuthenticatorEmulator({
+                stateless: true,
+            });
+            // Create request for enumerateCredentialsBegin
+            const request = {
+                subCommand: ctap_model_2.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsBegin,
+                subCommandParams: {
+                    rpId: rpId1,
+                },
+            };
+            // Execute the command and expect an error
+            (0, globals_1.expect)(() => {
+                statelessAuthenticator.authenticatorCredentialManagement(request);
+            }).toThrow(new ctap_model_2.AuthenticationEmulatorError(ctap_model_2.CTAP_STATUS_CODE.CTAP2_ERR_NOT_ALLOWED));
+        });
+    });
+});

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

@@ -5,11 +5,15 @@ 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 };
+        const PublicKeyCredential = {
+            isConditionalMediationAvailable: async () => false,
+            signalUnknownCredential: undefined,
+        };
         // 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();
+        (0, globals_1.expect)(PublicKeyCredential.signalUnknownCredential).toBeDefined();
     });
 });

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

@@ -39,6 +39,7 @@ 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 credentials_memory_repository_1 = require("../../src/repository/credentials-memory-repository");
 const webauthn_test_server_1 = require("./webauthn-test-server");
 (0, globals_1.describe)("WebAuthnEmulator Registration Passkeys Test", () => {
     const user = { username: "test", id: "test" };
@@ -230,3 +231,168 @@ const webauthn_test_server_1 = require("./webauthn-test-server");
         });
     });
 });
+(0, globals_1.describe)("WebAuthnEmulator signalUnknownCredential Test", () => {
+    (0, globals_1.test)("Signal Unknown Credential _ OK", async () => {
+        const user = { username: "test-signal", id: "test-signal" };
+        // Create a new emulator with a clean repository
+        const repository = new credentials_memory_repository_1.PasskeysCredentialsMemoryRepository();
+        const authenticator = new src_1.AuthenticatorEmulator({
+            credentialsRepository: repository,
+        });
+        const emulator = new src_1.default(authenticator);
+        const testServer = new webauthn_test_server_1.WebAuthnTestServer();
+        // Create a credential
+        const options = await testServer.getRegistrationOptions(user);
+        const credential = emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        await testServer.getRegistrationVerification(user, credential);
+        // Verify the credential exists
+        const credentialsBefore = repository.loadCredentials();
+        (0, globals_1.expect)(credentialsBefore.length).toBe(1);
+        // Signal unknown credential
+        emulator.signalUnknownCredential({
+            rpId: webauthn_test_server_1.TEST_RP_ORIGIN.replace("https://", ""),
+            credentialId: credential.id,
+        });
+        // Verify the credential was deleted
+        const credentialsAfter = repository.loadCredentials();
+        (0, globals_1.expect)(credentialsAfter.length).toBe(0);
+    });
+});
+(0, globals_1.describe)("WebAuthnEmulator signalAllAcceptedCredentials Test", () => {
+    (0, globals_1.test)("Signal All Accepted Credentials _ OK", async () => {
+        // Create users
+        const user = { username: "user1", id: "user1-id" };
+        // Create a new emulator with a clean repository
+        const repository = new credentials_memory_repository_1.PasskeysCredentialsMemoryRepository();
+        const authenticator = new src_1.AuthenticatorEmulator({
+            credentialsRepository: repository,
+        });
+        const emulator = new src_1.default(authenticator);
+        const testServer = new webauthn_test_server_1.WebAuthnTestServer();
+        const options = await testServer.getRegistrationOptions(user);
+        // Create credential1 for user
+        const credential1 = emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        const backupCredential1 = repository.loadCredentials()[0];
+        // Create credential2 for user (credential1 is overwritten)
+        const credential2 = emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        // restore credential1
+        repository.saveCredential(backupCredential1);
+        // Verify all credentials exist
+        const credentialsBefore = repository.loadCredentials();
+        (0, globals_1.expect)(credentialsBefore.length).toBe(2);
+        // Get the user1 credentials
+        const user1Credentials = credentialsBefore.filter((cred) => cred.user.name === user.username);
+        // Get the actual user ID from the credential
+        const actualUserId = encode_utils_1.default.encodeBase64Url(user1Credentials[0].user.id);
+        // Get the IDs of all credentials
+        const allCredentialIds = credentialsBefore.map((cred) => encode_utils_1.default.encodeBase64Url(cred.publicKeyCredentialSource.id));
+        // Signal that only the first credential is accepted for user1
+        emulator.signalAllAcceptedCredentials({
+            rpId: webauthn_test_server_1.TEST_RP_ORIGIN.replace("https://", ""),
+            userId: actualUserId,
+            allAcceptedCredentialIds: [credential1.id],
+        });
+        // Verify that one credential was deleted
+        const credentialsAfter = repository.loadCredentials();
+        (0, globals_1.expect)(credentialsAfter.length).toBe(1);
+        // Check that credential1 and credential3 still exist
+        const remainingIds = credentialsAfter.map((cred) => encode_utils_1.default.encodeBase64Url(cred.publicKeyCredentialSource.id));
+        (0, globals_1.expect)(remainingIds).toContain(credential1.id);
+        (0, globals_1.expect)(remainingIds).not.toContain(credential2.id);
+        // Verify one credential was deleted
+        (0, globals_1.expect)(remainingIds.length).toBe(1);
+        (0, globals_1.expect)(allCredentialIds.length).toBe(2);
+        const deletedIds = allCredentialIds.filter((id) => !remainingIds.includes(id));
+        (0, globals_1.expect)(deletedIds.length).toBe(1);
+    });
+    (0, globals_1.test)("Signal All Accepted Credentials with empty list _ Delete all user credentials", async () => {
+        // Create user
+        const user = { username: "user-test", id: "user-test-id" };
+        // Create a new emulator with a clean repository
+        const repository = new credentials_memory_repository_1.PasskeysCredentialsMemoryRepository();
+        const authenticator = new src_1.AuthenticatorEmulator({
+            credentialsRepository: repository,
+        });
+        const emulator = new src_1.default(authenticator);
+        const testServer = new webauthn_test_server_1.WebAuthnTestServer();
+        // Create a credential for the user
+        const options = await testServer.getRegistrationOptions(user);
+        const credential1 = emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        await testServer.getRegistrationVerification(user, credential1);
+        // Verify credentials exist
+        const credentialsBefore = repository.loadCredentials();
+        (0, globals_1.expect)(credentialsBefore.length).toBe(1);
+        // Get the actual user ID from the credential
+        const actualUserId = encode_utils_1.default.encodeBase64Url(credentialsBefore[0].user.id);
+        // Signal empty accepted credentials list
+        emulator.signalAllAcceptedCredentials({
+            rpId: webauthn_test_server_1.TEST_RP_ORIGIN.replace("https://", ""),
+            userId: actualUserId,
+            allAcceptedCredentialIds: [],
+        });
+        // Verify all user credentials were deleted
+        const userCredentialsAfter = repository
+            .loadCredentials()
+            .filter((cred) => encode_utils_1.default.encodeBase64Url(cred.user.id) === actualUserId);
+        (0, globals_1.expect)(userCredentialsAfter.length).toBe(0);
+    });
+});
+(0, globals_1.describe)("WebAuthnEmulator signalCurrentUserDetails Test", () => {
+    (0, globals_1.test)("Signal Current User Details _ OK", async () => {
+        // Create user
+        const user = { username: "user-details", id: "user-details-id" };
+        // Create a new emulator with a clean repository
+        const repository = new credentials_memory_repository_1.PasskeysCredentialsMemoryRepository();
+        const authenticator = new src_1.AuthenticatorEmulator({
+            credentialsRepository: repository,
+        });
+        const emulator = new src_1.default(authenticator);
+        const testServer = new webauthn_test_server_1.WebAuthnTestServer();
+        // Create a credential
+        const options = await testServer.getRegistrationOptions(user);
+        const credential = emulator.createJSON(webauthn_test_server_1.TEST_RP_ORIGIN, options);
+        await testServer.getRegistrationVerification(user, credential);
+        // Verify the credential exists with original user details
+        const credentialsBefore = repository.loadCredentials();
+        (0, globals_1.expect)(credentialsBefore.length).toBe(1);
+        (0, globals_1.expect)(credentialsBefore[0].user.name).toBe(user.username);
+        // Note: We don't check displayName as it's not consistently set by the test server
+        // Get the actual user ID from the credential
+        const actualUserId = encode_utils_1.default.encodeBase64Url(credentialsBefore[0].user.id);
+        // Update user details using the actual user ID from the credential
+        const updatedName = "Updated User Name";
+        const updatedDisplayName = "Updated Display Name";
+        emulator.signalCurrentUserDetails({
+            rpId: webauthn_test_server_1.TEST_RP_ORIGIN.replace("https://", ""),
+            userId: actualUserId,
+            name: updatedName,
+            displayName: updatedDisplayName,
+        });
+        // Verify the user details were updated
+        const credentialsAfter = repository.loadCredentials();
+        (0, globals_1.expect)(credentialsAfter.length).toBe(1);
+        (0, globals_1.expect)(credentialsAfter[0].user.name).toBe(updatedName);
+        (0, globals_1.expect)(credentialsAfter[0].user.displayName).toBe(updatedDisplayName);
+        // Verify the credential ID and user ID remain unchanged
+        (0, globals_1.expect)(encode_utils_1.default.encodeBase64Url(credentialsAfter[0].publicKeyCredentialSource.id)).toBe(credential.id);
+        (0, globals_1.expect)(encode_utils_1.default.encodeBase64Url(credentialsAfter[0].user.id)).toBe(actualUserId);
+    });
+    (0, globals_1.test)("Signal Current User Details with non-existent user _ Error", async () => {
+        // Create a new emulator with a clean repository
+        const repository = new credentials_memory_repository_1.PasskeysCredentialsMemoryRepository();
+        const authenticator = new src_1.AuthenticatorEmulator({
+            credentialsRepository: repository,
+        });
+        const emulator = new src_1.default(authenticator);
+        // Try to update non-existent user
+        const nonExistentUserId = "non-existent-user-id";
+        (0, globals_1.expect)(() => {
+            emulator.signalCurrentUserDetails({
+                rpId: webauthn_test_server_1.TEST_RP_ORIGIN.replace("https://", ""),
+                userId: encode_utils_1.default.encodeBase64Url(encode_utils_1.default.strToUint8Array(nonExistentUserId)),
+                name: "New Name",
+                displayName: "New Display Name",
+            });
+        }).toThrow(); // Should throw CTAP2_ERR_NO_CREDENTIALS
+    });
+});

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

@@ -1,6 +1,6 @@
 import type { PasskeysCredentialsRepository } from "../repository/credentials-repository";
 import { type AuthenticatorData, type PublicKeyCredentialSource } from "../webauthn/webauthn-model";
-import { type AuthenticatorGetAssertionRequest, type AuthenticatorGetAssertionResponse, type AuthenticatorGetInfoResponse, type AuthenticatorMakeCredentialRequest, type AuthenticatorMakeCredentialResponse, type AuthenticatorOptions, type CTAPAuthenticatorRequest, type CTAPAuthenticatorResponse } from "./ctap-model";
+import { type AuthenticatorCredentialManagementRequest, type AuthenticatorCredentialManagementResponse, type AuthenticatorGetAssertionRequest, type AuthenticatorGetAssertionResponse, type AuthenticatorGetInfoResponse, type AuthenticatorMakeCredentialRequest, type AuthenticatorMakeCredentialResponse, type AuthenticatorOptions, type CTAPAuthenticatorRequest, type CTAPAuthenticatorResponse } from "./ctap-model";
 type InteractionResponse = {
     options: {
         uv: boolean;
@@ -52,6 +52,15 @@ export declare class AuthenticatorEmulator {
     constructor(params?: Partial<AuthenticatorParameters>);
     /** @see https://fidoalliance.org/specs/fido-v2.0-ps-20190130/fido-client-to-authenticator-protocol-v2.0-ps-20190130.html#authenticator-api */
     command(request: CTAPAuthenticatorRequest): CTAPAuthenticatorResponse;
+    /**
+     * @see https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-errata-20220621.html#authenticatorCredentialManagement
+     */
+    authenticatorCredentialManagement(request: AuthenticatorCredentialManagementRequest): AuthenticatorCredentialManagementResponse;
+    private enumerationState;
+    private authenticatorEnumerateCredentialsBegin;
+    private authenticatorEnumerateCredentialsGetNextCredential;
+    private authenticatorUpdateUserInformation;
+    private authenticatorDeleteCredential;
     /** @see https://fidoalliance.org/specs/fido-v2.0-ps-20190130/fido-client-to-authenticator-protocol-v2.0-ps-20190130.html#authenticatorGetInfo */
     authenticatorGetInfo(): AuthenticatorGetInfoResponse;
     /**

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

@@ -48,7 +48,9 @@ class AuthenticatorEmulator {
             verifications: params.verifications ?? AuthenticatorEmulator.DEFAULT_VERIFICATIONS,
             userMakeCredentialInteraction: params.userMakeCredentialInteraction ?? AuthenticatorEmulator.DEFAULT_MAKE_CREDENTIAL_INTERACTION,
             userGetAssertionInteraction: params.userGetAssertionInteraction ?? AuthenticatorEmulator.DEFAULT_GET_ASSERTION_INTERACTION,
-            credentialsRepository: params.stateless ? undefined : AuthenticatorEmulator.DEFAULT_CREDENTIALS_REPOSITORY,
+            credentialsRepository: params.stateless
+                ? undefined
+                : (params.credentialsRepository ?? AuthenticatorEmulator.DEFAULT_CREDENTIALS_REPOSITORY),
             stateless: params.stateless ?? AuthenticatorEmulator.DEFAULT_STATELESS,
         };
     }
@@ -68,8 +70,119 @@ class AuthenticatorEmulator {
         if (unpackedRequest.command === ctap_model_1.CTAP_COMMAND.authenticatorGetInfo) {
             return (0, ctap_model_1.packGetInfoResponse)(this.authenticatorGetInfo());
         }
+        if (unpackedRequest.command === ctap_model_1.CTAP_COMMAND.authenticatorCredentialManagement) {
+            const credentialManagementRequest = (0, ctap_model_1.unpackCredentialManagementRequest)(request);
+            const credentialManagementResponse = this.authenticatorCredentialManagement(credentialManagementRequest);
+            return (0, ctap_model_1.packCredentialManagementResponse)(credentialManagementResponse);
+        }
         throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP1_ERR_INVALID_COMMAND);
     }
+    /**
+     * @see https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-errata-20220621.html#authenticatorCredentialManagement
+     */
+    authenticatorCredentialManagement(request) {
+        const repository = this.params.credentialsRepository;
+        if (!repository) {
+            throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP2_ERR_NOT_ALLOWED);
+        }
+        switch (request.subCommand) {
+            case ctap_model_1.CREDENTIAL_MANAGEMENT_SUBCOMMAND.deleteCredential:
+                return this.authenticatorDeleteCredential(request);
+            case ctap_model_1.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsBegin:
+                return this.authenticatorEnumerateCredentialsBegin(request);
+            case ctap_model_1.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsGetNextCredential:
+                return this.authenticatorEnumerateCredentialsGetNextCredential();
+            case ctap_model_1.CREDENTIAL_MANAGEMENT_SUBCOMMAND.updateUserInformation:
+                return this.authenticatorUpdateUserInformation(request);
+            default:
+                throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP1_ERR_INVALID_COMMAND);
+        }
+    }
+    // Store the current enumeration state
+    enumerationState = null;
+    authenticatorEnumerateCredentialsBegin(request) {
+        const repository = this.params.credentialsRepository;
+        if (!repository) {
+            throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP2_ERR_NOT_ALLOWED);
+        }
+        const rpId = request.subCommandParams?.rpId;
+        if (!rpId) {
+            throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP1_ERR_INVALID_PARAMETER);
+        }
+        // Get all credentials for the RP
+        const allCredentials = repository.loadCredentials();
+        const rpCredentials = allCredentials.filter((cred) => cred.publicKeyCredentialSource.rpId.value === rpId);
+        // Store the enumeration state
+        this.enumerationState = {
+            rpId,
+            credentials: rpCredentials,
+            currentIndex: 0,
+        };
+        return {
+            totalCredentials: rpCredentials.length,
+        };
+    }
+    authenticatorEnumerateCredentialsGetNextCredential() {
+        if (!this.enumerationState || this.enumerationState.currentIndex >= this.enumerationState.credentials.length) {
+            throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP2_ERR_NO_CREDENTIALS);
+        }
+        const credential = this.enumerationState.credentials[this.enumerationState.currentIndex++];
+        return {
+            user: credential.user,
+            credentialID: encode_utils_1.default.bufferSourceToUint8Array(credential.publicKeyCredentialDescriptor.id),
+            publicKey: credential.authenticatorData.attestedCredentialData?.credentialPublicKey.toDer(),
+        };
+    }
+    authenticatorUpdateUserInformation(request) {
+        const repository = this.params.credentialsRepository;
+        if (!repository) {
+            throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP2_ERR_NOT_ALLOWED);
+        }
+        const rpId = request.subCommandParams?.rpId;
+        const user = request.subCommandParams?.user;
+        if (!rpId || !user) {
+            throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP1_ERR_INVALID_PARAMETER);
+        }
+        // Find all credentials for this user and RP
+        const allCredentials = repository.loadCredentials();
+        const userCredentials = allCredentials.filter((cred) => cred.publicKeyCredentialSource.rpId.value === rpId &&
+            encode_utils_1.default.encodeBase64Url(cred.user.id) === encode_utils_1.default.encodeBase64Url(user.id));
+        if (userCredentials.length === 0) {
+            throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP2_ERR_NO_CREDENTIALS);
+        }
+        // Update user information for all matching credentials
+        for (const credential of userCredentials) {
+            const updatedCredential = {
+                ...credential,
+                user: {
+                    ...user,
+                    id: user.id, // Keep the same ID
+                },
+            };
+            repository.deleteCredential(credential);
+            repository.saveCredential(updatedCredential);
+        }
+        return {};
+    }
+    authenticatorDeleteCredential(request) {
+        const repository = this.params.credentialsRepository;
+        if (!repository) {
+            throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP2_ERR_NOT_ALLOWED);
+        }
+        if (!request.subCommandParams?.credentialId) {
+            throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP1_ERR_INVALID_PARAMETER);
+        }
+        const credentialId = request.subCommandParams.credentialId;
+        const credentials = repository.loadCredentials();
+        const credential = credentials.find((cred) => encode_utils_1.default.encodeBase64Url(cred.publicKeyCredentialSource.id) === encode_utils_1.default.encodeBase64Url(credentialId));
+        if (!credential) {
+            throw new ctap_model_1.AuthenticationEmulatorError(ctap_model_1.CTAP_STATUS_CODE.CTAP2_ERR_NO_CREDENTIALS);
+        }
+        repository.deleteCredential(credential);
+        return {
+            existingResidentCredentialsCount: repository.loadCredentials().length,
+        };
+    }
     /** @see https://fidoalliance.org/specs/fido-v2.0-ps-20190130/fido-client-to-authenticator-protocol-v2.0-ps-20190130.html#authenticatorGetInfo */
     authenticatorGetInfo() {
         return {

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

@@ -76,7 +76,40 @@ export declare enum CTAP_COMMAND {
     authenticatorGetInfo = 4,
     authenticatorClientPIN = 6,
     authenticatorReset = 7,
-    authenticatorGetNextAssertion = 8
+    authenticatorGetNextAssertion = 8,
+    authenticatorCredentialManagement = 10
+}
+export declare enum CREDENTIAL_MANAGEMENT_SUBCOMMAND {
+    getCredsMetadata = 1,
+    enumerateRPsBegin = 2,
+    enumerateRPsGetNextRP = 3,
+    enumerateCredentialsBegin = 4,
+    enumerateCredentialsGetNextCredential = 5,
+    deleteCredential = 6,
+    updateUserInformation = 7
+}
+export interface AuthenticatorCredentialManagementRequest {
+    subCommand: CREDENTIAL_MANAGEMENT_SUBCOMMAND;
+    subCommandParams?: {
+        credentialId?: Uint8Array;
+        rpId?: string;
+        user?: PublicKeyCredentialUserEntity;
+    };
+    pinUvAuthProtocol?: number;
+    pinUvAuthParam?: Uint8Array;
+}
+export interface AuthenticatorCredentialManagementResponse {
+    existingResidentCredentialsCount?: number;
+    maxPossibleRemainingResidentCredentialsCount?: number;
+    rp?: PublicKeyCredentialRpEntity;
+    rpIDHash?: Uint8Array;
+    totalRPs?: number;
+    user?: PublicKeyCredentialUserEntity;
+    credentialID?: Uint8Array;
+    publicKey?: Uint8Array;
+    totalCredentials?: number;
+    credProtect?: number;
+    largeBlobKey?: Uint8Array;
 }
 /** @see https://fidoalliance.org/specs/fido-v2.0-ps-20190130/fido-client-to-authenticator-protocol-v2.0-ps-20190130.html#responses */
 export interface CTAPAuthenticatorResponse {
@@ -99,9 +132,13 @@ export declare function unpackRequest(request: CTAPAuthenticatorRequest): {
 };
 export declare function packMakeCredentialRequest(request: AuthenticatorMakeCredentialRequest): CTAPAuthenticatorRequest;
 export declare function packGetAssertionRequest(request: AuthenticatorGetAssertionRequest): CTAPAuthenticatorRequest;
+export declare function packCredentialManagementRequest(request: AuthenticatorCredentialManagementRequest): CTAPAuthenticatorRequest;
+export declare function unpackCredentialManagementRequest(request: CTAPAuthenticatorRequest): AuthenticatorCredentialManagementRequest;
 export declare function unpackMakeCredentialResponse(response: CTAPAuthenticatorResponse): AuthenticatorMakeCredentialResponse;
 export declare function packMakeCredentialResponse(response: AuthenticatorMakeCredentialResponse): CTAPAuthenticatorResponse;
 export declare function unpackGetAssertionResponse(response: CTAPAuthenticatorResponse): AuthenticatorGetAssertionResponse;
 export declare function packGetAssertionResponse(response: AuthenticatorGetAssertionResponse): CTAPAuthenticatorResponse;
 export declare function unpackGetInfoResponse(response: CTAPAuthenticatorResponse): AuthenticatorGetInfoResponse;
 export declare function packGetInfoResponse(response: AuthenticatorGetInfoResponse): CTAPAuthenticatorResponse;
+export declare function packCredentialManagementResponse(response: AuthenticatorCredentialManagementResponse): CTAPAuthenticatorResponse;
+export declare function unpackCredentialManagementResponse(response: CTAPAuthenticatorResponse): AuthenticatorCredentialManagementResponse;

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

@@ -3,16 +3,20 @@ 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.AuthenticationEmulatorError = exports.CREDENTIAL_MANAGEMENT_SUBCOMMAND = exports.CTAP_COMMAND = exports.CTAP_STATUS_CODE = void 0;
 exports.unpackRequest = unpackRequest;
 exports.packMakeCredentialRequest = packMakeCredentialRequest;
 exports.packGetAssertionRequest = packGetAssertionRequest;
+exports.packCredentialManagementRequest = packCredentialManagementRequest;
+exports.unpackCredentialManagementRequest = unpackCredentialManagementRequest;
 exports.unpackMakeCredentialResponse = unpackMakeCredentialResponse;
 exports.packMakeCredentialResponse = packMakeCredentialResponse;
 exports.unpackGetAssertionResponse = unpackGetAssertionResponse;
 exports.packGetAssertionResponse = packGetAssertionResponse;
 exports.unpackGetInfoResponse = unpackGetInfoResponse;
 exports.packGetInfoResponse = packGetInfoResponse;
+exports.packCredentialManagementResponse = packCredentialManagementResponse;
+exports.unpackCredentialManagementResponse = unpackCredentialManagementResponse;
 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;
@@ -36,7 +40,18 @@ var CTAP_COMMAND;
     CTAP_COMMAND[CTAP_COMMAND["authenticatorClientPIN"] = 6] = "authenticatorClientPIN";
     CTAP_COMMAND[CTAP_COMMAND["authenticatorReset"] = 7] = "authenticatorReset";
     CTAP_COMMAND[CTAP_COMMAND["authenticatorGetNextAssertion"] = 8] = "authenticatorGetNextAssertion";
+    CTAP_COMMAND[CTAP_COMMAND["authenticatorCredentialManagement"] = 10] = "authenticatorCredentialManagement";
 })(CTAP_COMMAND || (exports.CTAP_COMMAND = CTAP_COMMAND = {}));
+var CREDENTIAL_MANAGEMENT_SUBCOMMAND;
+(function (CREDENTIAL_MANAGEMENT_SUBCOMMAND) {
+    CREDENTIAL_MANAGEMENT_SUBCOMMAND[CREDENTIAL_MANAGEMENT_SUBCOMMAND["getCredsMetadata"] = 1] = "getCredsMetadata";
+    CREDENTIAL_MANAGEMENT_SUBCOMMAND[CREDENTIAL_MANAGEMENT_SUBCOMMAND["enumerateRPsBegin"] = 2] = "enumerateRPsBegin";
+    CREDENTIAL_MANAGEMENT_SUBCOMMAND[CREDENTIAL_MANAGEMENT_SUBCOMMAND["enumerateRPsGetNextRP"] = 3] = "enumerateRPsGetNextRP";
+    CREDENTIAL_MANAGEMENT_SUBCOMMAND[CREDENTIAL_MANAGEMENT_SUBCOMMAND["enumerateCredentialsBegin"] = 4] = "enumerateCredentialsBegin";
+    CREDENTIAL_MANAGEMENT_SUBCOMMAND[CREDENTIAL_MANAGEMENT_SUBCOMMAND["enumerateCredentialsGetNextCredential"] = 5] = "enumerateCredentialsGetNextCredential";
+    CREDENTIAL_MANAGEMENT_SUBCOMMAND[CREDENTIAL_MANAGEMENT_SUBCOMMAND["deleteCredential"] = 6] = "deleteCredential";
+    CREDENTIAL_MANAGEMENT_SUBCOMMAND[CREDENTIAL_MANAGEMENT_SUBCOMMAND["updateUserInformation"] = 7] = "updateUserInformation";
+})(CREDENTIAL_MANAGEMENT_SUBCOMMAND || (exports.CREDENTIAL_MANAGEMENT_SUBCOMMAND = CREDENTIAL_MANAGEMENT_SUBCOMMAND = {}));
 // Not standard functions and interfaces
 class AuthenticationEmulatorError extends Error {
     status;
@@ -84,6 +99,24 @@ function unpackRequest(request) {
                     pinProtocol: data[0x07],
                 },
             };
+        case CTAP_COMMAND.authenticatorCredentialManagement:
+            return {
+                command: request.command,
+                request: {
+                    subCommand: data[0x01],
+                    subCommandParams: data[0x02]
+                        ? {
+                            credentialId: data[0x02][0x01]
+                                ? encode_utils_1.default.bufferSourceToUint8Array(data[0x02][0x01])
+                                : undefined,
+                            rpId: data[0x02][0x02],
+                            user: data[0x02][0x03],
+                        }
+                        : undefined,
+                    pinUvAuthProtocol: data[0x03],
+                    pinUvAuthParam: data[0x04] ? encode_utils_1.default.bufferSourceToUint8Array(data[0x04]) : undefined,
+                },
+            };
         default:
             return {
                 command: request.command,
@@ -121,6 +154,46 @@ function packGetAssertionRequest(request) {
         }),
     };
 }
+function packCredentialManagementRequest(request) {
+    return {
+        command: CTAP_COMMAND.authenticatorCredentialManagement,
+        data: encode_utils_1.default.encodeCbor({
+            [0x01]: request.subCommand,
+            [0x02]: request.subCommandParams
+                ? {
+                    [0x01]: request.subCommandParams.credentialId,
+                    [0x02]: request.subCommandParams.rpId,
+                    [0x03]: request.subCommandParams.user,
+                }
+                : undefined,
+            [0x03]: request.pinUvAuthProtocol,
+            [0x04]: request.pinUvAuthParam,
+        }),
+    };
+}
+function unpackCredentialManagementRequest(request) {
+    try {
+        const data = encode_utils_1.default.decodeCbor(request.data);
+        const subCommandParams = data[0x02];
+        return {
+            subCommand: data[0x01],
+            subCommandParams: subCommandParams
+                ? {
+                    credentialId: subCommandParams[0x01]
+                        ? encode_utils_1.default.bufferSourceToUint8Array(subCommandParams[0x01])
+                        : undefined,
+                    rpId: subCommandParams[0x02],
+                    user: subCommandParams[0x03],
+                }
+                : undefined,
+            pinUvAuthProtocol: data[0x03],
+            pinUvAuthParam: data[0x04] ? encode_utils_1.default.bufferSourceToUint8Array(data[0x04]) : undefined,
+        };
+    }
+    catch (error) {
+        throw new AuthenticationEmulatorError(CTAP_STATUS_CODE.CTAP2_ERR_INVALID_CBOR, { cause: error });
+    }
+}
 function unpackMakeCredentialResponse(response) {
     try {
         const data = encode_utils_1.default.decodeCbor(response.data);
@@ -200,3 +273,42 @@ function packGetInfoResponse(response) {
         }),
     };
 }
+function packCredentialManagementResponse(response) {
+    return {
+        status: CTAP_STATUS_CODE.CTAP2_OK,
+        data: encode_utils_1.default.encodeCbor({
+            [0x01]: response.existingResidentCredentialsCount,
+            [0x02]: response.maxPossibleRemainingResidentCredentialsCount,
+            [0x03]: response.rp,
+            [0x04]: response.rpIDHash,
+            [0x05]: response.totalRPs,
+            [0x06]: response.user,
+            [0x07]: response.credentialID,
+            [0x08]: response.publicKey,
+            [0x09]: response.totalCredentials,
+            [0x0a]: response.credProtect,
+            [0x0b]: response.largeBlobKey,
+        }),
+    };
+}
+function unpackCredentialManagementResponse(response) {
+    try {
+        const data = encode_utils_1.default.decodeCbor(response.data);
+        return {
+            existingResidentCredentialsCount: data[0x01],
+            maxPossibleRemainingResidentCredentialsCount: data[0x02],
+            rp: data[0x03],
+            rpIDHash: data[0x04] ? encode_utils_1.default.bufferSourceToUint8Array(data[0x04]) : undefined,
+            totalRPs: data[0x05],
+            user: data[0x06],
+            credentialID: data[0x07] ? encode_utils_1.default.bufferSourceToUint8Array(data[0x07]) : undefined,
+            publicKey: data[0x08] ? encode_utils_1.default.bufferSourceToUint8Array(data[0x08]) : undefined,
+            totalCredentials: data[0x09],
+            credProtect: data[0x0a],
+            largeBlobKey: data[0x0b] ? encode_utils_1.default.bufferSourceToUint8Array(data[0x0b]) : undefined,
+        };
+    }
+    catch (error) {
+        throw new AuthenticationEmulatorError(CTAP_STATUS_CODE.CTAP2_ERR_INVALID_CBOR, { cause: error });
+    }
+}

package/dist/src/index.d.ts

@@ -12,5 +12,6 @@ export * from "./repository/credentials-memory-repository";
 export declare const BrowserInjection: {
     WebAuthnEmulatorGet: string;
     WebAuthnEmulatorCreate: string;
+    WebAuthnEmulatorSignalUnknownCredential: string;
     HookWebAuthnApis: string;
 };

package/dist/src/index.js

@@ -30,5 +30,6 @@ __exportStar(require("./repository/credentials-memory-repository"), exports);
 exports.BrowserInjection = {
     WebAuthnEmulatorGet: browser_injection_1.WebAuthnEmulatorGet,
     WebAuthnEmulatorCreate: browser_injection_1.WebAuthnEmulatorCreate,
+    WebAuthnEmulatorSignalUnknownCredential: browser_injection_1.WebAuthnEmulatorSignalUnknownCredential,
     HookWebAuthnApis: browser_injection_1.HookWebAuthnApis,
 };

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

@@ -1,3 +1,6 @@
 export declare const WebAuthnEmulatorGet = "webAuthnEmulatorGet";
 export declare const WebAuthnEmulatorCreate = "webAuthnEmulatorCreate";
+export declare const WebAuthnEmulatorSignalUnknownCredential = "webAuthnEmulatorSignalUnknownCredential";
+export declare const WebAuthnEmulatorSignalAllAcceptedCredentials = "webAuthnEmulatorSignalAllAcceptedCredentials";
+export declare const WebAuthnEmulatorSignalCurrentUserDetails = "webAuthnEmulatorSignalCurrentUserDetails";
 export declare const HookWebAuthnApis: string;

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

@@ -33,10 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HookWebAuthnApis = exports.WebAuthnEmulatorCreate = exports.WebAuthnEmulatorGet = void 0;
+exports.HookWebAuthnApis = exports.WebAuthnEmulatorSignalCurrentUserDetails = exports.WebAuthnEmulatorSignalAllAcceptedCredentials = exports.WebAuthnEmulatorSignalUnknownCredential = exports.WebAuthnEmulatorCreate = exports.WebAuthnEmulatorGet = void 0;
 const Model = __importStar(require("../webauthn/webauthn-model-json"));
 exports.WebAuthnEmulatorGet = "webAuthnEmulatorGet";
 exports.WebAuthnEmulatorCreate = "webAuthnEmulatorCreate";
+exports.WebAuthnEmulatorSignalUnknownCredential = "webAuthnEmulatorSignalUnknownCredential";
+exports.WebAuthnEmulatorSignalAllAcceptedCredentials = "webAuthnEmulatorSignalAllAcceptedCredentials";
+exports.WebAuthnEmulatorSignalCurrentUserDetails = "webAuthnEmulatorSignalCurrentUserDetails";
 const webAuthnModelExports = Object.values(Model)
     .map((m) => m.toString())
     .join("\n  ");
@@ -57,6 +60,22 @@ exports.HookWebAuthnApis = `
     const responseJSON = await window.${exports.WebAuthnEmulatorGet}(optionsJSON);
     return parseAuthenticationResponseFromJSON(responseJSON);
   }
+  
   PublicKeyCredential.isConditionalMediationAvailable = async () => true;
+  
+  PublicKeyCredential.signalUnknownCredential = async (options) => {
+    if (!options || !options.rpId || !options.credentialId) return;
+    await window.${exports.WebAuthnEmulatorSignalUnknownCredential}(options);
+  }
+
+  PublicKeyCredential.signalAllAcceptedCredentials = async (options) => {
+    if (!options || !options.rpId || !options.userId || !options.allAcceptedCredentialIds) return;
+    await window.${exports.WebAuthnEmulatorSignalAllAcceptedCredentials}(options);
+  }
+
+  PublicKeyCredential.signalCurrentUserDetails = async (options) => {
+    if (!options || !options.rpId || !options.userId) return;
+    await window.${exports.WebAuthnEmulatorSignalCurrentUserDetails}(options);
+  }
 })();
 `;

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

@@ -1,5 +1,5 @@
 import { AuthenticatorEmulator } from "../authenticator/authenticator-emulator";
-import { type AuthenticationResponseJSON, type CreatePublicKeyCredential, type PublicKeyCredentialCreationOptionsJSON, type PublicKeyCredentialRequestOptionsJSON, type RegistrationResponseJSON, type RequestPublicKeyCredential } from "./webauthn-model-json";
+import { type AllAcceptedCredentialsOptionsJSON, type AuthenticationResponseJSON, type CreatePublicKeyCredential, type CurrentUserDetailsOptionsJSON, type PublicKeyCredentialCreationOptionsJSON, type PublicKeyCredentialRequestOptionsJSON, type RegistrationResponseJSON, type RequestPublicKeyCredential, type UnknownCredentialOptionsJSON } from "./webauthn-model-json";
 export type AuthenticatorInfo = {
     version: string;
     aaguid: string;
@@ -23,6 +23,21 @@ export declare class WebAuthnEmulator {
     getJSON(origin: string, optionsJSON: PublicKeyCredentialRequestOptionsJSON): AuthenticationResponseJSON;
     createJSON(origin: string, optionsJSON: PublicKeyCredentialCreationOptionsJSON): RegistrationResponseJSON;
     getAuthenticatorInfo(): AuthenticatorInfo;
+    signalUnknownCredential(options: UnknownCredentialOptionsJSON): void;
+    /**
+     * Signal all accepted credentials for a user
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredential/signalAllAcceptedCredentials_static
+     */
+    signalAllAcceptedCredentials(options: AllAcceptedCredentialsOptionsJSON): void;
+    /**
+     * Process credentials for an RP and delete those not in the accepted list
+     */
+    private processCredentials;
+    /**
+     * Signal current user details
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredential/signalCurrentUserDetails_static
+     */
+    signalCurrentUserDetails(options: CurrentUserDetailsOptionsJSON): void;
     /** @see https://developer.mozilla.org/en-US/docs/Web/API/CredentialsContainer/get */
     get(origin: string, options: CredentialRequestOptions): RequestPublicKeyCredential;
     /** @see https://developer.mozilla.org/ja/docs/Web/API/CredentialsContainer/create */

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

@@ -48,6 +48,86 @@ class WebAuthnEmulator {
             },
         };
     }
+    signalUnknownCredential(options) {
+        const credentialId = (0, webauthn_model_json_1.decodeBase64Url)(options.credentialId);
+        this.authenticator.command((0, ctap_model_1.packCredentialManagementRequest)({
+            subCommand: ctap_model_1.CREDENTIAL_MANAGEMENT_SUBCOMMAND.deleteCredential,
+            subCommandParams: {
+                credentialId: encode_utils_1.default.bufferSourceToUint8Array(credentialId),
+                rpId: options.rpId,
+            },
+        }));
+    }
+    /**
+     * Signal all accepted credentials for a user
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredential/signalAllAcceptedCredentials_static
+     */
+    signalAllAcceptedCredentials(options) {
+        // Create a set of accepted credential IDs for quick lookup
+        const acceptedCredentialIds = new Set(options.allAcceptedCredentialIds);
+        // Start enumerating credentials for the specified RP
+        const beginResponse = (0, ctap_model_1.unpackCredentialManagementResponse)(this.authenticator.command((0, ctap_model_1.packCredentialManagementRequest)({
+            subCommand: ctap_model_1.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsBegin,
+            subCommandParams: {
+                rpId: options.rpId,
+            },
+        })));
+        // Get the total number of credentials
+        const totalCredentials = beginResponse.totalCredentials ?? 0;
+        // Get all credentials for the RP and delete those not in the accepted list
+        this.processCredentials(options.rpId, options.userId, acceptedCredentialIds, totalCredentials);
+    }
+    /**
+     * Process credentials for an RP and delete those not in the accepted list
+     */
+    processCredentials(rpId, userId, acceptedCredentialIds, totalCredentials) {
+        // Process each credential
+        for (let i = 0; i < totalCredentials; i++) {
+            // Get next credential and unpack the response
+            const credResponse = (0, ctap_model_1.unpackCredentialManagementResponse)(this.authenticator.command((0, ctap_model_1.packCredentialManagementRequest)({
+                subCommand: ctap_model_1.CREDENTIAL_MANAGEMENT_SUBCOMMAND.enumerateCredentialsGetNextCredential,
+            })));
+            // Skip if this is not for the user we're looking for
+            if (credResponse.user && encode_utils_1.default.encodeBase64Url(credResponse.user.id) !== userId) {
+                continue;
+            }
+            // Delete credential if it's not in the accepted list
+            if (credResponse.credentialID) {
+                const credentialId = encode_utils_1.default.encodeBase64Url(credResponse.credentialID);
+                if (!acceptedCredentialIds.has(credentialId)) {
+                    // Delete the credential directly
+                    this.authenticator.command((0, ctap_model_1.packCredentialManagementRequest)({
+                        subCommand: ctap_model_1.CREDENTIAL_MANAGEMENT_SUBCOMMAND.deleteCredential,
+                        subCommandParams: {
+                            credentialId: credResponse.credentialID,
+                            rpId: rpId,
+                        },
+                    }));
+                }
+            }
+        }
+    }
+    /**
+     * Signal current user details
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/PublicKeyCredential/signalCurrentUserDetails_static
+     */
+    signalCurrentUserDetails(options) {
+        const userId = (0, webauthn_model_json_1.decodeBase64Url)(options.userId);
+        // Create user object with updated information
+        const user = {
+            id: userId,
+            name: options.name,
+            displayName: options.displayName,
+        };
+        // Update user information using the credential management API
+        this.authenticator.command((0, ctap_model_1.packCredentialManagementRequest)({
+            subCommand: ctap_model_1.CREDENTIAL_MANAGEMENT_SUBCOMMAND.updateUserInformation,
+            subCommandParams: {
+                rpId: options.rpId,
+                user: user,
+            },
+        }));
+    }
     /** @see https://developer.mozilla.org/en-US/docs/Web/API/CredentialsContainer/get */
     get(origin, options) {
         if (!options.publicKey)

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

@@ -91,6 +91,21 @@ export declare function toAuthenticationResponseJSON(credential: PublicKeyCreden
 export declare function toCreationOptionsJSON(options: PublicKeyCredentialCreationOptions): PublicKeyCredentialCreationOptionsJSON;
 export declare function toRequestOptionsJSON(options: PublicKeyCredentialRequestOptions): PublicKeyCredentialRequestOptionsJSON;
 export declare function parseRegistrationResponseFromJSON(options: RegistrationResponseJSON): CreatePublicKeyCredential;
+export interface UnknownCredentialOptionsJSON {
+    rpId: string;
+    credentialId: Base64urlString;
+}
+export interface AllAcceptedCredentialsOptionsJSON {
+    rpId: string;
+    userId: Base64urlString;
+    allAcceptedCredentialIds: Base64urlString[];
+}
+export interface CurrentUserDetailsOptionsJSON {
+    rpId: string;
+    userId: Base64urlString;
+    name: string;
+    displayName: string;
+}
 export declare function parseAuthenticationResponseFromJSON(options: AuthenticationResponseJSON): RequestPublicKeyCredential;
 export declare function toPublicKeyCredentialDescriptorJSON(credential: PublicKeyCredentialDescriptor): PublicKeyCredentialDescriptorJSON;
 export declare function parsePublicKeyCredentialDescriptorFromJSON(credential: PublicKeyCredentialDescriptorJSON): PublicKeyCredentialDescriptor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nid-webauthn-emulator",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "keywords": [
     "test",
     "e2e",
@@ -19,15 +19,15 @@
     "@jest/globals": "^29.7.0",
     "@simplewebauthn/server": "^13.1.1",
     "@tsconfig/recommended": "^1.0.8",
-    "@types/node": "^22.13.4",
+    "@types/node": "^22.13.10",
     "jest": "^29.7.0",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.2.6",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.3"
+    "typescript": "^5.8.2"
   },
   "dependencies": {
     "cbor": "^10.0.3",
-    "tldts": "^6.1.77"
+    "tldts": "^6.1.84"
   },
   "scripts": {
     "check": "biome check .",