nid-webauthn-emulator 0.2.0 → 0.2.2

package/README.md

@@ -146,10 +146,24 @@ async function startWebAuthnEmulator(page: Page, origin: string, debug = false)
 
   await page.exposeFunction(
     BrowserInjection.WebAuthnEmulatorSignalUnknownCredential,
-    async (options: { rpId: string; credentialId: string }) => {
+    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"] }, () => {

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/webauthn/webauthn-emulator.spec.js

@@ -258,3 +258,141 @@ const webauthn_test_server_1 = require("./webauthn-test-server");
         (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

@@ -56,6 +56,10 @@ export declare class AuthenticatorEmulator {
      * @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

@@ -88,10 +88,82 @@ class AuthenticatorEmulator {
         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) {

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

@@ -1,4 +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,11 +33,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HookWebAuthnApis = exports.WebAuthnEmulatorSignalUnknownCredential = 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  ");
@@ -65,5 +67,15 @@ exports.HookWebAuthnApis = `
     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, type UnknownCredentialOptionsJSON } 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;
@@ -24,6 +24,20 @@ export declare class WebAuthnEmulator {
     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

@@ -50,14 +50,83 @@ class WebAuthnEmulator {
     }
     signalUnknownCredential(options) {
         const credentialId = (0, webauthn_model_json_1.decodeBase64Url)(options.credentialId);
-        const request = (0, ctap_model_1.packCredentialManagementRequest)({
+        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,
             },
-        });
-        this.authenticator.command(request);
+        }));
+    }
+    /**
+     * 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) {

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

@@ -95,6 +95,17 @@ 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/dist/src/webauthn/webauthn-model.js

@@ -26,8 +26,8 @@ class RpId {
     }
     /** @see https://www.w3.org/TR/webauthn-3/#sctn-validating-origin */
     validate(origin) {
-        const parsedOrigin = (0, tldts_1.parse)(origin);
-        const parsedRpId = (0, tldts_1.parse)(this.value);
+        const parsedOrigin = (0, tldts_1.parse)(origin, { validHosts: ["localhost"] });
+        const parsedRpId = (0, tldts_1.parse)(this.value, { validHosts: ["localhost"] });
         return Boolean(parsedOrigin.domain &&
             parsedOrigin.subdomain !== null &&
             parsedRpId.subdomain !== null &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nid-webauthn-emulator",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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.14.1",
     "jest": "^29.7.0",
-    "ts-jest": "^29.2.5",
+    "ts-jest": "^29.3.2",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.3"
+    "typescript": "^5.8.3"
   },
   "dependencies": {
     "cbor": "^10.0.3",
-    "tldts": "^6.1.77"
+    "tldts": "^7.0.0"
   },
   "scripts": {
     "check": "biome check .",