Server-side Web Authentication library for Java. Provides implementations of the Relying Party operations required for a server to support Web Authentication, including passkey authentication.

Table of contents

• Features
  • Non-features
• Dependency configuration
  • Semantic versioning
  • Additional modules
• Documentation
• Getting started
  • 1. Implement a CredentialRepository
  • 2. Instantiate a RelyingParty
  • 3. Registration
  • 4. Authentication
  • 5. Optional features: passkeys, multi-factor, backup state
    • Passkeys: passwordless, username-less authentication
    • User verification: passwordless multi-factor authentication
    • Using passkeys with autofill UI
    • Credential backup state
• Migrating from version 1.x
• Migrating from U2F
• Architecture
• Using attestation
• Building
  • Reproducible builds

• Generates request objects suitable as parameters to navigator.credentials.create() and .get()

• Performs all necessary validation logic on the response from the client

• No mutable state or side effects - everything (except builders) is thread safe

• Optionally integrates with an "attestation trust source" to verify authenticator attestations

• Reproducible builds: release signatures match fresh builds from source. See Reproducible builds below.

Non-features

Maven:

Gradle:

Semantic versioning

Additional modules

See the Javadoc for in-depth API documentation.

Using this library comes in two parts: the server side and the client side. The server side involves:

1. Implement the CredentialRepository interface with your database access logic.

2. Instantiate the RelyingParty class.

3. Use the RelyingParty.startRegistration(...) and RelyingParty.finishRegistration(...) methods to perform registration ceremonies.

4. Use the RelyingParty.startAssertion(...) and RelyingParty.finishAssertion(...) methods to perform authentication ceremonies.

5. Optionally use additional features: passkeys, passwordless multi-factor authentication, credential backup state.

The client side involves:

1. Call navigator.credentials.create() or .get(), passing the result from RelyingParty.startRegistration(...) or .startAssertion(...) as the argument.

2. Encode the result of the successfully resolved promise and return it to the server. For this you need some way to encode Uint8Array values; this guide will use GitHub’s webauthn-json library.

Example code is given below. For more detailed example usage, see webauthn-server-demo for a complete demo server.

1. Implement a CredentialRepository

2. Instantiate a RelyingParty

RelyingPartyIdentity rpIdentity = RelyingPartyIdentity.builder()
    .id("example.com")  // Set this to a parent domain that covers all subdomains
                        // where users' credentials should be valid
    .name("Example Application")
    .build();

RelyingParty rp = RelyingParty.builder()
    .identity(rpIdentity)
    .credentialRepository(new MyCredentialRepository())
    .build();

3. Registration

Optional<UserIdentity> findExistingUser(String username) { /* ... */ }

PublicKeyCredentialCreationOptions request = rp.startRegistration(
  StartRegistrationOptions.builder()
    .user(
        findExistingUser("alice")
            .orElseGet(() -> {
                byte[] userHandle = new byte[64];
                random.nextBytes(userHandle);
                return UserIdentity.builder()
                    .name("alice")
                    .displayName("Alice Hypothetical")
                    .id(new ByteArray(userHandle))
                    .build();
            })
    )
    .build());

String credentialCreateJson = request.toCredentialsCreateJson();
return credentialCreateJson;  // Send to client

import * as webauthnJson from "@github/webauthn-json";

// Make the call that returns the credentialCreateJson above
const credentialCreateOptions = await fetch(/* ... */).then(resp => resp.json());

// Call WebAuthn ceremony using webauthn-json wrapper
const publicKeyCredential = await webauthnJson.create(credentialCreateOptions);

// Return encoded PublicKeyCredential to server
fetch(/* ... */, { body: JSON.stringify(publicKeyCredential) });

String publicKeyCredentialJson = /* ... */;     // publicKeyCredential from client
PublicKeyCredential<AuthenticatorAttestationResponse, ClientRegistrationExtensionOutputs> pkc =
    PublicKeyCredential.parseRegistrationResponseJson(publicKeyCredentialJson);

try {
    RegistrationResult result = rp.finishRegistration(FinishRegistrationOptions.builder()
        .request(request)  // The PublicKeyCredentialCreationOptions from startRegistration above
                           // NOTE: Must be stored in server memory or otherwise protected against tampering
        .response(pkc)
        .build());
} catch (RegistrationFailedException e) { /* ... */ }

storeCredential(              // Some database access method of your own design
  "alice",                    // Username or other appropriate user identifier
  result.getKeyId(),          // Credential ID and transports for allowCredentials
  result.getPublicKeyCose(),  // Public key for verifying authentication signatures
  result.getSignatureCount(), // Initial signature counter value
  result.isDiscoverable(),    // Is this a passkey?
  result.isBackupEligible(),  // Can this credential be backed up (synced)?
  result.isBackedUp(),        // Is this credential currently backed up?
  pkc.getResponse().getAttestationObject(), // Store attestation object for future reference
  pkc.getResponse().getClientDataJSON()     // Store client data for re-verifying signature if needed
);

4. Authentication

AssertionRequest request = rp.startAssertion(StartAssertionOptions.builder()
    .username("alice")     // Or .userHandle(ByteArray) if preferred
    .build());
String credentialGetJson = request.toCredentialsGetJson();
return credentialGetJson;  // Send to client

import * as webauthnJson from "@github/webauthn-json";

// Make the call that returns the credentialGetJson above
const credentialGetOptions = await fetch(/* ... */).then(resp => resp.json());

// Call WebAuthn ceremony using webauthn-json wrapper
const publicKeyCredential = await webauthnJson.get(credentialGetOptions);

// Return encoded PublicKeyCredential to server
fetch(/* ... */, { body: JSON.stringify(publicKeyCredential) });

String publicKeyCredentialJson = /* ... */;  // publicKeyCredential from client
PublicKeyCredential<AuthenticatorAssertionResponse, ClientAssertionExtensionOutputs> pkc =
    PublicKeyCredential.parseAssertionResponseJson(publicKeyCredentialJson);

try {
    AssertionResult result = rp.finishAssertion(FinishAssertionOptions.builder()
        .request(request)  // The PublicKeyCredentialRequestOptions from startAssertion above
        .response(pkc)
        .build());

    if (result.isSuccess()) {
        return result.getUsername();
    }
} catch (AssertionFailedException e) { /* ... */ }
throw new RuntimeException("Authentication failed");

updateCredential(              // Some database access method of your own design
  "alice",                     // Query by username or other appropriate user identifier
  result.getCredentialId(),    // Query by credential ID of the credential used
  result.getSignatureCount(),  // Set new signature counter value
  result.isBackedUp(),         // Set new backup state flag
  Clock.systemUTC().instant()  // Set time of last use (now)
);

5. Optional features: passkeys, multi-factor, backup state

PublicKeyCredentialCreationOptions request = rp.startRegistration(
  StartRegistrationOptions.builder()
    .user(/* ... */)
    .authenticatorSelection(AuthenticatorSelectionCriteria.builder()
        .residentKey(ResidentKeyRequirement.REQUIRED)
        .build())
    .build());

AssertionRequest request = rp.startAssertion(StartAssertionOptions.builder().build());

AssertionRequest request = rp.startAssertion(StartAssertionOptions.builder()
    .username("alice")
    .userVerification(UserVerificationRequirement.REQUIRED)
    .build());

PublicKeyCredentialCreationOptions request = rp.startRegistration(
  StartRegistrationOptions.builder()
    .user(/* ... */)
    .authenticatorSelection(AuthenticatorSelectionCriteria.builder()
        .userVerification(UserVerificationRequirement.REQUIRED)
        .build())
    .build());

See the migration guide.

This section is only relevant for applications that have user credentials registered via the U2F JavaScript API. New WebAuthn deployments can skip this section.

The WebAuthn API is backwards-compatible with U2F authenticators, and credentials registered via the U2F API will continue to work with the WebAuthn API with the right settings.

To migrate to using the WebAuthn API, you need to do the following:

1. Follow the Getting started guide above to set up WebAuthn support in general.

   Note that unlike a U2F AppID, the WebAuthn RP ID consists of only the domain name of the AppID. WebAuthn does not support U2F Trusted Facet Lists.

2. Set the appId() setting on your RelyingParty instance. The argument to the appid() setting should be the same as you used for the appId argument to the U2F register and sign functions.

   This will enable the appid and appidExclude extensions and configure the RelyingParty to accept the given AppId when verifying authenticator signatures.

3. Generate a user handle for each existing user and store it in their account, or decide on a method for deriving one deterministically from existing user attributes. For example, if your user records are assigned UUIDs, you can use that UUID as the user handle. You SHOULD NOT use a plain username or e-mail address, or hash of either, as the user handle - for more on this, see the User Handle Contents privacy consideration.

4. When your CredentialRepository creates a RegisteredCredential for a U2F credential, use the U2F key handle as the credential ID. If you store key handles base64 encoded, you should decode them using ByteArray.fromBase64 or ByteArray.fromBase64Url as appropriate before passing them to the RegisteredCredential.

5. When your CredentialRepository creates a RegisteredCredential for a U2F credential, use the publicKeyEs256Raw() method instead of publicKeyCose() to set the credential public key.

6. Replace calls to the U2F register method with calls to navigator.credentials.create() as described in Getting started.

7. Replace calls to the U2F sign method with calls to navigator.credentials.get() as described in Getting started.

Existing U2F credentials should now work with the WebAuthn API.

Note that new credentials registered on U2F authenticators via the WebAuthn API are NOT backwards compatible with the U2F JavaScript API.

The library tries to place as few requirements on the overall application architecture as possible. For this reason it is stateless and free from side effects, and does not directly interact with any database. This means it is database agnostic and thread safe. The following diagram illustrates an example architecture for an application using the library.

The application manages all state and database access, and communicates with the library via POJO representations of requests and responses. The following diagram illustrates the data flow during a WebAuthn registration or authentication ceremony.

In this diagram, the Client is the user’s browser and the application’s client-side scripts. The Server is the application and its business logic, the Library is this library, and the Users database stores registered WebAuthn credentials.

1. The client requests to start the ceremony, for example by submitting a form. The username may or may not be known at this point. For example, the user might be requesting to create a new account, or we might be using username-less authentication.

2. If the user does not already have a user handle, the application creates one in some application-specific way.

3. The application may choose to authenticate the user with a password or the like before proceeding.

4. The application calls one of the library’s "start" methods to generate a parameter object to be passed to navigator.credentials.create() or .get() on the client.

5. The library generates a random challenge and an assortment of other arguments depending on configuration set by the application.

6. If the username is known, the library uses a read-only database adapter provided by the application to look up the user’s credentials.

7. The returned list of credential IDs is used to populate the excludeCredentials or allowCredentials parameter.

8. The library returns a request object which can be serialized to JSON and passed as the publicKey argument to navigator.credentials.create() or .get(). For registration ceremonies this will be a PublicKeyCredentialCreationOptions, and for authentication ceremonies it will be a PublicKeyCredentialRequestOptions. The application stores the request in temporary storage.

9. The application’s client-side script runs navigator.credentials.create() or .get() with request as the publicKey argument.

10. The user confirms the operation and the client returns a PublicKeyCredential object response to the application.

11. The application retrieves the request from temporary storage and passes request and response to one of the library’s "finish" methods to run the response validation logic.

12. The library verifies that the response contents - challenge, origin, etc. - are valid.

13. If this is an authentication ceremony, the library uses the database adapter to look up the public key for the credential named in response.id.

14. The database adapter returns the public key.

15. The library verifies the authentication signature.

16. The library returns a POJO representation of the result of the ceremony. For registration ceremonies, this will include the credential ID and public key of the new credential. The application may opt in to also getting information about the authenticator model and whether the authenticator attestation is trusted. For authentication ceremonies, this will include the username and user handle, the credential ID of the credential used, and the new signature counter value for the credential.

17. The application inspects the result object and takes any appropriate actions as defined by its business logic.

18. If the result is not satisfactory, the application reports failure to the client.

19. If the result is satisfactory, the application proceeds with storing the new credential if this is a registration ceremony.

20. If this is an authentication ceremony, the application updates the signature counter stored in the database for the credential.

21. Finally, the application reports success and resumes its business logic.

WebAuthn supports authenticator attestation, which provides a way for the web service to request cryptographic proof of what authenticator the user is using. Most services do not need this, and it is disabled by default.

The webauthn-server-attestation module provides optional additional features for working with attestation. See the module documentation for more details.

Alternatively, you can use the AttestationTrustSource interface to implement your own source of attestation root certificates and set it as the attestationTrustSource for your RelyingParty instance. Note that depending on your JCA provider configuration, you may need to set the enableRevocationChecking and/or policyTreeValidator settings for compatibility with some authenticators' attestation certificates. See the JavaDoc for these settings for more information.

Use the included Gradle wrapper to build the .jar artifact:

The output is built in the webauthn-server-core/build/libs/ directory, and the version is derived from the most recent Git tag. Builds done on a tagged commit will have a plain x.y.z version number, while a build on any other commit will result in a version number containing the abbreviated commit hash.

To run the tests:

To run the PIT mutation tests (this may take upwards of 30 minutes):

Reproducible builds

$ git checkout 1.4.0-RC2
$ ./gradlew :webauthn-server-core:jar

$ wget https://repo1.maven.org/maven2/com/yubico/webauthn-server-core/1.4.0-RC2/webauthn-server-core-1.4.0-RC2.jar.asc
$ gpg --verify webauthn-server-core-1.4.0-RC2.jar.asc webauthn-server-core/build/libs/webauthn-server-core-1.4.0-RC2.jar

$ wget https://github.com/Yubico/java-webauthn-server/releases/download/1.4.0-RC2/webauthn-server-core-1.4.0-RC2.jar.asc
$ gpg --verify webauthn-server-core-1.4.0-RC2.jar.asc webauthn-server-core/build/libs/webauthn-server-core-1.4.0-RC2.jar