Web Authentication: An API for accessing Public Key Credentials

Note: This algorithm is synchronous; the Promise resolution/rejection is handled by navigator.credentials.create().

This method accepts a single argument:

options

This argument is a CredentialCreationOptions object whose options.publicKey member contains a MakeCredentialOptions object specifying the desired attributes of the to-be-created public key credential.

When this method is invoked, the user agent MUST execute the following algorithm:

1. Assert: options.publicKey is present.

2. Let options be the value of options.publicKey.

3. If any of the name member of options.rp, the name member of options.user, the displayName member of options.user, or the id member of options.user are not present, return a TypeError simple exception.

4. If the timeout member of options is present, check if its value lies within a reasonable range as defined by the platform and if not, correct it to the closest value lying within that range. Set adjustedTimeout to this adjusted value. If the timeout member of options is not present, then set adjustedTimeout to a platform-specific default.

5. Let global be the PublicKeyCredential's interface object's environment settings object’s global object.

6. Let callerOrigin be the origin specified by this PublicKeyCredential interface object's relevant settings object. If callerOrigin is an opaque origin, return a DOMException whose name is "NotAllowedError", and terminate this algorithm.

7. Let effectiveDomain be the callerOrigin’s effective domain. If effectiveDomain is null, then return a DOMException whose name is "SecurityError" and terminate this algorithm.

8. Let rpId be effectiveDomain.

9. If options.rp.id is present:

   1. If options.rp.id is not a registrable domain suffix of and is not equal to effectiveDomain, return a DOMException whose name is "SecurityError", and terminate this algorithm.

   2. Set rpId to options.rp.id.

      Note: rpId represents the caller’s RP ID. The RP ID defaults to being the caller’s origin's effective domain unless the caller has explicitly set options.rp.id when calling create().

10. Let normalizedParameters be a new list whose items are pairs of PublicKeyCredentialType and a dictionary type (as returned by normalizing an algorithm).

11. For each current of options.parameters:

    1. If current.type does not contain a PublicKeyCredentialType supported by this implementation, then continue.

    2. Let normalizedAlgorithm be the result of normalizing an algorithm [WebCryptoAPI], with alg set to current.algalgorithm and op set to "generateKey". If an error occurs during this procedure, then continue.

    3. Append the pair of current.type and normalizedAlgorithm to normalizedParameters.

12. If normalizedParameters is empty and options.parameters is not empty, cancel the timer started in step 2, return a DOMException whose name is "NotSupportedError", and terminate this algorithm.

13. Let clientExtensions be a new map and let authenticatorExtensions be a new map.

14. If the extensions member of options is present, then for each extensionId → clientExtensionInput of options.extensions:

    1. If extensionId is not supported by this client platform or is not a registration extension, then continue.

    2. Set clientExtensions[extensionId] to clientExtensionInput.

    3. If extensionId is not an authenticator extension, then continue.

    4. Let authenticatorExtensionInput be the (CBOR) result of running extensionId’s client extension processing algorithm on clientExtensionInput. If the algorithm returned an error, continue.

    5. Set authenticatorExtensions[extensionId] to the base64url encoding of authenticatorExtensionInput.

15. Let collectedClientData be a new CollectedClientData instance whose fields are:

    challenge

    The base64url encoding of options.challenge.

    origin

    The serialization of callerOrigin.

    hashAlgorithm

    hashAlg

    The recognized algorithm name of the hash algorithm selected by the client for generating the hash of the serialized client data.

    tokenBindingId

    The Token Binding ID associated with callerOrigin, if one is available.

    clientExtensions

    clientExtensions

    authenticatorExtensions

    authenticatorExtensions

16. Let clientDataJSON be the JSON-serialized client data constructed from collectedClientData.

17. Let clientDataHash be the hash of the serialized client data represented by clientDataJSON.

18. Let currentlyAvailableAuthenticators be a new ordered set consisting of all authenticators available on this platform.

19. Let selectedAuthenticators be a new ordered set.

20. If currentlyAvailableAuthenticators is empty, return a DOMException whose name is "NotFoundError", and terminate this algorithm.

21. If options.authenticatorSelection is present, iterate through currentlyAvailableAuthenticators and do the following for each authenticator:

    1. If attachment is present and its value is not equal to authenticator’s attachment modality, continue.

    2. If requireResidentKey is set to true and the authenticator is not capable of storing a Client-Side-Resident Credential Private Key, continue.

    3. Append authenticator to selectedAuthenticators.

22. If selectedAuthenticators is empty, return a DOMException whose name is "ConstraintError", and terminate this algoritm.

23. Let issuedRequests be a new ordered set.

24. For each authenticator in currentlyAvailableAuthenticators:

    1. Let excludeCredentialDescriptorList excludeList be a new list.

    2. For each credential descriptor C in options.excludeCredentialsexcludeList:

       1. If C.transports is not empty, and authenticator is connected over a transport not mentioned in C.transports, the client MAY continue.

       2. Otherwise, Append C to excludeCredentialDescriptorList excludeList.

    3. In parallel, invoke the authenticatorMakeCredential operation on authenticator with rpId, clientDataHash, options.rp, options.user, normalizedParameters, excludeCredentialDescriptorList excludeList, and authenticatorExtensions as parameters.

    4. Append authenticator to issuedRequests.

25. Start a timer for adjustedTimeout milliseconds. Then execute the following steps in parallel. The task source for these tasks is the dom manipulation task source.

26. While issuedRequests is not empty, perform the following actions depending upon the adjustedTimeout timer and responses from the authenticators:

    If the adjustedTimeout timer expires,

    For each authenticator in issuedRequests invoke the authenticatorCancel operation on authenticator and remove authenticator from issuedRequests.

    If any authenticator returns a status indicating that the user cancelled the operation,

    1. Remove authenticator from issuedRequests.

    2. For each remaining authenticator in issuedRequests invoke the authenticatorCancel operation on authenticator and remove it from issuedRequests.

    If any authenticator returns an error status,

    Remove authenticator from issuedRequests.

    If any authenticator indicates success,

    1. Remove authenticator from issuedRequests.

    2. Let attestationObject be a new ArrayBuffer, created using global’s %ArrayBuffer%, containing the bytes of the value returned from the successful authenticatorMakeCredential operation (which is attObj, as defined in §5.3.4 Generating an Attestation Object).

    3. Let id be attestationObject.authData.attestation data.credential ID (see §5.3.1 Attestation data and §5.1 Authenticator data).

    4. Let value be a new PublicKeyCredential object associated with global whose fields are:

       [[identifier]]

       id

       response

       A new AuthenticatorAttestationResponse object associated with global whose fields are:

       clientDataJSON

       A new ArrayBuffer, created using global’s %ArrayBuffer%, containing the bytes of clientDataJSON.

       attestationObject

       attestationObject

       clientExtensionResults

       A new AuthenticationExtensions object containing the extension identifier → client extension output entries created by running each extension’s client extension processing algorithm to create the client extension outputs, for each client extension in clientDataJSON.clientExtensions.

    5. For each remaining authenticator in issuedRequests invoke the authenticatorCancel operation on authenticator and remove it from issuedRequests.

    6. Return value and terminate this algorithm.

27. Return a DOMException whose name is "NotAllowedError".

During the above process, the user agent SHOULD show some UI to the user to guide them in the process of selecting and authorizing an authenticator.

Note: This algorithm is synchronous; the Promise resolution/rejection is handled by navigator.credentials.get().

This method accepts a single argument:

options

This argument is a CredentialRequestOptions object whose options.publicKey member contains a challenge and additional options as described in §4.5 Options for Assertion Generation (dictionary PublicKeyCredentialRequestOptions). The selected authenticator signs the challenge along with other collected data in order to produce an assertion. See §5.2.2 The authenticatorGetAssertion operation.

When this method is invoked, the user agent MUST execute the following algorithm:

1. Assert: options.publicKey is present.

2. Let options be the value of options.publicKey.

3. If the timeout member of options is present, check if its value lies within a reasonable range as defined by the platform and if not, correct it to the closest value lying within that range. Set adjustedTimeout to this adjusted value. If the timeout member of options is not present, then set adjustedTimeout to a platform-specific default.

4. Let global be the PublicKeyCredential's interface object's environment settings object’s global object.

5. Let callerOrigin be the origin specified by this PublicKeyCredential interface object's relevant settings object. If callerOrigin is an opaque origin, return a DOMException whose name is "NotAllowedError", and terminate this algorithm.

6. Let effectiveDomain be the callerOrigin’s effective domain. If effectiveDomain is null, then return a DOMException whose name is "SecurityError" and terminate this algorithm.

7. If options.rpId is not present, then set rpId to effectiveDomain.

   Otherwise:

   1. If options.rpId is not a registrable domain suffix of and is not equal to effectiveDomain, return a DOMException whose name is "SecurityError", and terminate this algorithm.

   2. Set rpId to options.rpId.

      Note: rpId represents the caller’s RP ID. The RP ID defaults to being the caller’s origin's effective domain unless the caller has explicitly set options.rpId when calling get().

8. Let clientExtensions be a new map and let authenticatorExtensions be a new map.

9. If the extensions member of options is present, then for each extensionId → clientExtensionInput of options.extensions:

   1. If extensionId is not supported by this client platform or is not an authentication extension, then continue.

   2. Set clientExtensions[extensionId] to clientExtensionInput.

   3. If extensionId is not an authenticator extension, then continue.

   4. Let authenticatorExtensionInput be the (CBOR) result of running extensionId’s client extension processing algorithm on clientExtensionInput. If the algorithm returned an error, continue.

   5. Set authenticatorExtensions[extensionId] to the base64url encoding of authenticatorExtensionInput.

10. Let collectedClientData be a new CollectedClientData instance whose fields are:

    challenge

    The base64url encoding of options.challenge

    origin

    The serialization of callerOrigin.

    hashAlgorithm

    hashAlg

    The recognized algorithm name of the hash algorithm selected by the client for generating the hash of the serialized client data

    tokenBindingId

    The Token Binding ID associated with callerOrigin, if one is available.

    clientExtensions

    clientExtensions

    authenticatorExtensions

    authenticatorExtensions

11. Let clientDataJSON be the JSON-serialized client data constructed from collectedClientData.

12. Let clientDataHash be the hash of the serialized client data represented by clientDataJSON.

13. Let issuedRequests be a new ordered set.

14. If there are no authenticators currently available on this platform, return a DOMException whose name is "NotFoundError", and terminate this algorithm.

15. Let authenticator be a platform-specific handle whose value identifies an authenticator.

16. For each authenticator currently available on this platform, perform the following steps:

    1. Let allowCredentialDescriptorList credentialDescriptorList be a new list.

    2. If options.allowCredentialsallowList is not empty, execute a platform-specific procedure to determine which, if any, public key credentials described by options.allowCredentialsallowList are bound to this authenticator, by matching with rpId, options.allowCredentialsallowList.id, and options.allowCredentialsallowList.type. Set allowCredentialDescriptorList credentialDescriptorList to this filtered list.

    3. If allowCredentialDescriptorList credentialDescriptorList

       is not empty

       in parallel, for each credential descriptor C in allowCredentialDescriptorList credentialDescriptorList:

       1. If C.transports is not empty, the client SHOULD select one transport from transports. Then, using transport, invoke the authenticatorGetAssertion operation on authenticator, with rpId, clientDataHash, allowCredentialDescriptorList credentialDescriptorList, and authenticatorExtensions as parameters.

       2. Otherwise, using local configuration knowledge of the appropriate transport to use with authenticator, invoke the authenticatorGetAssertion operation on authenticator with rpId, clientDataHash, allowCredentialDescriptorList credentialDescriptorList, and clientExtensions as parameters.

       is empty

       Using local configuration knowledge of the appropriate transport to use with authenticator, invoke in parallel the authenticatorGetAssertion operation on authenticator with rpId, clientDataHash, and clientExtensions as parameters.

    4. Append authenticator to issuedRequests.

17. Start a timer for adjustedTimeout milliseconds. Then execute the following steps in parallel. The task source for these tasks is the dom manipulation task source.

18. While issuedRequests is not empty, perform the following actions depending upon the adjustedTimeout timer and responses from the authenticators:

    If the adjustedTimeout timer expires,

    For each authenticator in issuedRequests invoke the authenticatorCancel operation on authenticator and remove authenticator from issuedRequests.

    If any authenticator returns a status indicating that the user cancelled the operation,

    1. Remove authenticator from issuedRequests.

    2. For each remaining authenticator in issuedRequests invoke the authenticatorCancel operation on authenticator and remove it from issuedRequests.

    If any authenticator returns an error status,

    Remove authenticator from issuedRequests.

    If any authenticator indicates success,

    1. Remove authenticator from issuedRequests.

    2. Let value be a new PublicKeyCredential associated with global whose fields are:

       [[identifier]]

       A new ArrayBuffer, created using global’s %ArrayBuffer%, containing the bytes of the credential ID returned from the successful authenticatorGetAssertion operation, as defined in §5.2.2 The authenticatorGetAssertion operation.

       response

       A new AuthenticatorAssertionResponse object associated with global whose fields are:

       clientDataJSON

       A new ArrayBuffer, created using global’s %ArrayBuffer%, containing the bytes of clientDataJSON

       authenticatorData

       A new ArrayBuffer, created using global’s %ArrayBuffer%, containing the bytes of the returned authenticatorData

       signature

       A new ArrayBuffer, created using global’s %ArrayBuffer%, containing the bytes of the returned signature

       clientExtensionResults

       A new AuthenticationExtensions object containing the extension identifier → client extension output entries created by running each extension’s client extension processing algorithm to create the client extension outputs, for each client extension in clientDataJSON.clientExtensions.

    3. For each remaining authenticator in issuedRequests invoke the authenticatorCancel operation on authenticator and remove it from issuedRequests.

    4. Return value and terminate this algorithm.

19. Return a DOMException whose name is "NotAllowedError".

During the above process, the user agent SHOULD show some UI to the user to guide them in the process of selecting and authorizing an authenticator with which to complete the operation.

This method doesn’t accept any argument and returns a boolean object as the response.

[SecureContext]
partial interface PublicKeyCredential {
    [Unscopable] Promise < boolean > isPlatformAuthenticatorReady();
};

When this method is invoked, the user agent MUST execute the following algorithm:

1. Let promise be a a new Promise. Return promise and execute the following steps in parallel.

2. Enumerate all the platform authenticators on this platform. If there are no such authenticators, resolve promise with a value of false and terminate this algorithm.

3. If one or more platform authenticators were found, make a determination of the user’s willingness to create a credential for this Relying Party on such an authenticator. Factors used in this determination may include, for example:

   1. Whether the user is running in private or incognito mode

   2. Whether the user has configured the client to never create such credentials

   3. Whether the user has on a previous occasion expressed an unwillingness to create a new credential for this Relying Party, either through configuration or by declining a user interface prompt.

   4. The user’s explicitly stated intention, as obtained through a browser-specific user interface prompt.

4. If the above procedure determines that the user is not willing to create a new credential on a platform authenticator, resolve promise with a value of False and terminate this algorithm. Otherwise, resolve promise with a value of true.

4.2. Authenticator Responses (interface AuthenticatorResponse)

Authenticators respond to Relying Party requests by returning an object derived from the AuthenticatorResponse interface:

[SecureContext]
interface AuthenticatorResponse {
    

readonly attribute ArrayBuffer 

clientDataJSON;
};

4.2.1. Information about Public Key Credential (interface AuthenticatorAttestationResponse)

The AuthenticatorAttestationResponse interface represents the authenticator's response to a client’s request for the creation of a new public key credential. It contains information about the new credential that can be used to identify it for later use, and metadata that can be used by the Relying Party to assess the characteristics of the credential during registration.

[SecureContext]
interface AuthenticatorAttestationResponse : AuthenticatorResponse {
    

readonly attribute ArrayBuffer 

attestationObject;
};

4.2.2. Web Authentication Assertion (interface AuthenticatorAssertionResponse)

The AuthenticatorAssertionResponse interface represents an authenticator's response to a client’s request for generation of a new authentication assertion given the Relying Party's challenge and optional list of credentials it is aware of. This response contains a cryptographic signature proving possession of the credential private key, and optionally evidence of user consent to a specific transaction.

[SecureContext]
interface AuthenticatorAssertionResponse : AuthenticatorResponse {
    

readonly attribute ArrayBuffer      authenticatorData;
    

readonly attribute ArrayBuffer      signature;
};

4.3. Parameters for Credential Generation (dictionary PublicKeyCredentialParameters)

dictionary PublicKeyCredentialParameters {
    required PublicKeyCredentialType  

type;
    required AlgorithmIdentifier   

algorithm;
};

4.4. Options for Credential Creation (dictionary MakeCredentialOptions)

dictionary MakeCredentialOptions {
    required PublicKeyCredentialEntity 

rp;
    required PublicKeyCredentialUserEntity 

user;

    required BufferSource                         

challenge;
    required sequence<PublicKeyCredentialParameters> 

parameters;

    unsigned long                        

timeout;
    sequence<PublicKeyCredentialDescriptor> 

excludeList;
    AuthenticatorSelectionCriteria       

authenticatorSelection;
    AuthenticationExtensions             

extensions;
};

4.4.1. Public Key Entity Description (dictionary PublicKeyCredentialEntity)

The PublicKeyCredentialEntity dictionary describes a user account, or a Relying Party, with which a public key credential is associated.

dictionary PublicKeyCredentialEntity {
    DOMString 

id;
    DOMString 

name;
    USVString 

icon;
};

4.4.2. User Account Parameters for Credential Generation (dictionary PublicKeyCredentialUserEntity)

The PublicKeyCredentialUserEntity dictionary is used to supply additional user account attributes when creating a new credential.

dictionary PublicKeyCredentialUserEntity : PublicKeyCredentialEntity {
    DOMString 

displayName;
};

4.4.3. Authenticator Selection Criteria (dictionary AuthenticatorSelectionCriteria)

Relying Parties may use the AuthenticatorSelectionCriteria dictionary to specify their requirements regarding authenticator attributes.

dictionary AuthenticatorSelectionCriteria {
    

Attachment    

attachment;
    boolean       

requireResidentKey = false;
};

4.4.4.

Credential Attachment enumeration (enum

Attachment)

enum 

Attachment {
    "platform",
    "cross-platform"
};

Clients may communicate with authenticators using a variety of mechanisms. For example, a client may use a platform-specific API to communicate with an authenticator which is physically bound to a platform. On the other hand, a client may use a variety of standardized cross-platform transport protocols such as Bluetooth (see §4.7.4

Credential Transport enumeration (enum

ExternalTransport)) to discover and communicate with cross-platform attached authenticators. Therefore, we use

Attachment to describe an authenticator's attachment modality. We define authenticators that are part of the client’s platform as having a platform attachment, and refer to them as platform authenticators. While those that are reachable via cross-platform transport protocols are defined as having cross-platform attachment, and refer to them as roaming authenticators.

• platform attachment - the respective authenticator is attached using platform-specific transports. Usually, authenticators of this class are non-removable from the platform.
• cross-platform attachment - the respective authenticator is attached using cross-platform transports. Authenticators of this class are removable from, and can "roam" among, client platforms.

This distinction is important because there are use-cases where only platform authenticators are acceptable to a Relying Party, and conversely ones where only roaming authenticators are employed. As a concrete example of the former, a credential on a platform authenticator may be used by Relying Parties to quickly and conveniently reauthenticate the user with a minimum of friction, e.g., the user will not have to dig around in their pocket for their key fob or phone. As a concrete example of the latter, when the user is accessing the Relying Party from a given client for the first time, they may be required to use a roaming authenticator which was originally registered with the Relying Party using a different client.

4.5. Options for Assertion Generation (dictionary PublicKeyCredentialRequestOptions)

The PublicKeyCredentialRequestOptions dictionary supplies get() with the data it needs to generate an assertion. Its challenge member must be present, while its other members are optional.

dictionary PublicKeyCredentialRequestOptions {
    required BufferSource                challenge;
    unsigned long                        timeout;
    USVString                            rpId;
    sequence<PublicKeyCredentialDescriptor> 

allowList = [];
    AuthenticationExtensions             extensions;
};

challenge, of type BufferSource

This member represents a challenge that the selected authenticator signs, along with other data, when producing an authentication assertion.

timeout, of type unsigned long

This optional member specifies a time, in milliseconds, that the caller is willing to wait for the call to complete. The value is treated as a hint, and may be overridden by the platform.

rpId, of type USVString

This optional member specifies the relying party identifier claimed by the caller. If omitted, its value will be the CredentialsContainer object’s relevant settings object's origin's effective domain.

allowList, of type sequence<PublicKeyCredentialDescriptor>, defaulting to None

This optional member contains a list of PublicKeyCredentialDescriptor object representing public key credentials acceptable to the caller, in decending order of the caller’s preference (the first item in the list is the most preferred credential, and so on down the list).

extensions, of type AuthenticationExtensions

This optional member contains additional parameters requesting additional processing by the client and authenticator. For example, if transaction confirmation is sought from the user, then the prompt string might be included as an extension.

4.6. Authentication Extensions (typedef AuthenticationExtensions)

typedef record<DOMString, any> 

AuthenticationExtensions;

This is a dictionary containing zero or more WebAuthn extensions, as defined in §8 WebAuthn Extensions. An AuthenticationExtensions instance can contain either client extensions or authenticator extensions, depending upon context.

4.7. Supporting Data Structures

The public key credential type uses certain data structures that are specified in supporting specifications. These are as follows.

4.7.1. Client data used in WebAuthn signatures (dictionary CollectedClientData)

The client data represents the contextual bindings of both the Relying Party and the client platform. It is a key-value mapping with string-valued keys. Values may be any type that has a valid encoding in JSON. Its structure is defined by the following Web IDL.

dictionary CollectedClientData {
    required DOMString           challenge;
    required DOMString           origin;
    required DOMString           

hashAlg;
    DOMString                    tokenBindingId;
    AuthenticationExtensions     clientExtensions;
    AuthenticationExtensions     authenticatorExtensions;
};

4.7.2. Credential Type enumeration (enum PublicKeyCredentialType)

enum PublicKeyCredentialType {
    "public-key"
};

4.7.3. Credential Descriptor (dictionary PublicKeyCredentialDescriptor)

dictionary PublicKeyCredentialDescriptor {
    required PublicKeyCredentialType 

type;
    required BufferSource 

id;
    sequence<

Transport>   

transports;
};

This dictionary contains the attributes that are specified by a caller when referring to a credential as an input parameter to the create() or get() methods. It mirrors the fields of the PublicKeyCredential object returned by the latter methods.

4.7.4.

Credential Transport enumeration (enum

ExternalTransport)

enum 

Transport {
    "usb",
    "nfc",
    "ble"
};

4.7.5. Cryptographic Algorithm Identifier (type AlgorithmIdentifier)

A string or dictionary identifying a cryptographic algorithm and optionally a set of parameters for that algorithm. This type is defined in [WebCryptoAPI].

5. WebAuthn Authenticator model

The API defined in this specification implies a specific abstract functional model for an authenticator. This section describes the authenticator model.

Client platforms may implement and expose this abstract model in any way desired. However, the behavior of the client’s Web Authentication API implementation, when operating on the authenticators supported by that platform, MUST be indistinguishable from the behavior specified in §4 Web Authentication API.

For authenticators, this model defines the logical operations that they must support, and the data formats that they expose to the client and the Relying Party. However, it does not define the details of how authenticators communicate with the client platform, unless they are required for interoperability with Relying Parties. For instance, this abstract model does not define protocols for connecting authenticators to clients over transports such as USB or NFC. Similarly, this abstract model does not define specific error codes or methods of returning them; however, it does define error behavior in terms of the needs of the client. Therefore, specific error codes are mentioned as a means of showing which error conditions must be distinguishable (or not) from each other in order to enable a compliant and secure client implementation.

In this abstract model, the authenticator provides key management and cryptographic signatures. It may be embedded in the WebAuthn client, or housed in a separate device entirely. The authenticator may itself contain a cryptographic module which operates at a higher security level than the rest of the authenticator. This is particularly important for authenticators that are embedded in the WebAuthn client, as in those cases this cryptographic module (which may, for example, be a TPM) could be considered more trustworthy than the rest of the authenticator.

Each authenticator stores some number of public key credentials. Each public key credential has an identifier which is unique (or extremely unlikely to be duplicated) among all public key credentials. Each credential is also associated with a Relying Party, whose identity is represented by a Relying Party Identifier (RP ID).

Each authenticator has an AAGUID, which is a 128-bit identifier that indicates the type (e.g. make and model) of the authenticator. The AAGUID MUST be chosen by the manufacturer to be identical across all substantially identical authenticators made by that manufacturer, and different (with probability 1-2^-128 or greater) from the AAGUIDs of all other types of authenticators. The RP MAY use the AAGUID to infer certain properties of the authenticator, such as certification level and strength of key protection, using information from other sources.

The primary function of the authenticator is to provide WebAuthn signatures, which are bound to various contextual data. These data are observed, and added at different levels of the stack as a signature request passes from the server to the authenticator. In verifying a signature, the server checks these bindings against expected values. These contextual bindings are divided in two: Those added by the RP or the client, referred to as client data; and those added by the authenticator, referred to as the authenticator data. The authenticator signs over the client data, but is otherwise not interested in its contents. To save bandwidth and processing requirements on the authenticator, the client hashes the client data and sends only the result to the authenticator. The authenticator signs over the combination of the hash of the serialized client data, and its own authenticator data.

The goals of this design can be summarized as follows.

• The scheme for generating signatures should accommodate cases where the link between the client platform and authenticator is very limited, in bandwidth and/or latency. Examples include Bluetooth Low Energy and Near-Field Communication.

• The data processed by the authenticator should be small and easy to interpret in low-level code. In particular, authenticators should not have to parse high-level encodings such as JSON.

• Both the client platform and the authenticator should have the flexibility to add contextual bindings as needed.

• The design aims to reuse as much as possible of existing encoding formats in order to aid adoption and implementation.

Authenticators produce cryptographic signatures for two distinct purposes:

1. An attestation signature is produced when a new public key credential is created via an authenticatorMakeCredential operation. An attestation signature provides cryptographic proof of certain properties of the the authenticator and the credential. For instance, an attestation signature asserts the authenticator type (as denoted by its AAGUID) and the credential public key. The attestation signature is signed by an attestation private key, which is chosen depending on the type of attestation desired. For more details on attestation, see §5.3 Attestation.

2. An assertion signature is produced when the authenticatorGetAssertion method is invoked. It represents an assertion by the authenticator that the user has consented to a specific transaction, such as logging in, or completing a purchase. Thus, an assertion signature asserts that the authenticator possessing a particular credential private key has established, to the best of its ability, that the user requesting this transaction is the same user who consented to creating that particular public key credential. It also asserts additional information, termed client data, that may be useful to the caller, such as the means by which user consent was provided, and the prompt shown to the user by the authenticator. The assertion signature format is illustrated in Figure 2, below.

The formats of these signatures, as well as the procedures for generating them, are specified below.

5.1. Authenticator data

The authenticator data structure encodes contextual bindings made by the authenticator. These bindings are controlled by the authenticator itself, and derive their trust from the Relying Party's assessment of the security properties of the authenticator. In one extreme case, the authenticator may be embedded in the client, and its bindings may be no more trustworthy than the client data. At the other extreme, the authenticator may be a discrete entity with high-security hardware and software, connected to the client over a secure channel. In both cases, the Relying Party receives the authenticator data in the same format, and uses its knowledge of the authenticator to make trust decisions.

The authenticator data has a compact but extensible encoding. This is desired since authenticators can be devices with limited capabilities and low power requirements, with much simpler software stacks than the client platform components.

The authenticator data structure is a byte array of 37 bytes or more, as follows.

The RP ID is originally received from the client when the credential is created, and again when an assertion is generated. However, it differs from other client data in some important ways. First, unlike the client data, the RP ID of a credential does not change between operations but instead remains the same for the lifetime of that credential. Secondly, it is validated by the authenticator during the authenticatorGetAssertion operation, by verifying that the RP ID associated with the requested credential exactly matches the RP ID supplied by the client, and that the RP ID is a registrable domain suffix of or is equal to the effective domain of the RP’s origin's effective domain.

The TUP flag SHALL be set if and only if the authenticator detected a user through an authenticator specific gesture. The RFU bits SHALL be set to zero.

For attestation signatures, the authenticator MUST set the AT flag and include the attestation data. For authentication signatures, the AT flag MUST NOT be set and the attestation data MUST NOT be included.

If the authenticator does not include any extension data, it MUST set the ED flag to zero, and to one if extension data is included.

The figure below shows a visual representation of the authenticator data structure.

Note that the authenticator data describes its own length: If the AT and ED flags are not set, it is always 37 bytes long. The attestation data (which is only present if the AT flag is set) describes its own length. If the ED flag is set, then the total length is 37 bytes plus the length of the attestation data, plus the length of the CBOR map that follows.

5.2. Authenticator operations

A client must connect to an authenticator in order to invoke any of the operations of that authenticator. This connection defines an authenticator session. An authenticator must maintain isolation between sessions. It may do this by only allowing one session to exist at any particular time, or by providing more complicated session management.

The following operations can be invoked by the client in an authenticator session.

5.2.1. The authenticatorMakeCredential operation

This operation must be invoked in an authenticator session which has no other operations in progress. It takes the following input parameters:

• The caller’s RP ID, as determined by the user agent and the client.

• The hash of the serialized client data, provided by the client.

• The Relying Party's PublicKeyCredentialEntity.

• The user account’s PublicKeyCredentialUserEntity.

• A sequence of pairs of PublicKeyCredentialType and cryptographic algorithms (a dictionary type) requested by the Relying Party, where the cryptographic algorithms are normalized as per the procedure in Web Cryptography API §algorithm-normalization-normalize-an-algorithm. This sequence is is ordered from most preferred to least preferred. The platform makes a best-effort to create the most preferred credential that it can.

• An optional list of PublicKeyCredentialDescriptor objects provided by the Relying Party with the intention that, if any of these are known to the authenticator, it should not create a new credential.

• Extension data created by the client based on the extensions requested by the Relying Party, if any.

• The requireResidentKey parameter of the options.authenticatorSelection dictionary.

When this operation is invoked, the authenticator must perform the following procedure:

• Check if all the supplied parameters are syntactically well-formed and of the correct length. If not, return an error code equivalent to "UnknownError" and terminate the operation.

• Check if at least one of the specified combinations of PublicKeyCredentialType and cryptographic parameters is supported. If not, return an error code equivalent to "NotSupportedError" and terminate the operation.

• Check if a credential matching any of the supplied PublicKeyCredential identifiers is present on this authenticator. If so, return an error code equivalent to "NotAllowedError" and terminate the operation.

• If the requireResidentKey flag is set to true and the authenticator cannot store a Client-side-resident Credential Private Key, return an error code equivalent to "ConstraintError" and terminate the operation.

• Prompt the user for consent to create a new credential. The prompt for obtaining this consent is shown by the authenticator if it has its own output capability, or by the user agent otherwise. If the user denies consent, return an error code equivalent to "NotAllowedError" and terminate the operation.

• Once user consent has been obtained, generate a new credential object:

  • Generate a set of cryptographic keys using the most preferred combination of PublicKeyCredentialType and cryptographic parameters supported by this authenticator.

  • Generate an identifier for this credential, such that this identifier is globally unique with high probability across all credentials with the same type across all authenticators.

  • Associate the credential with the specified RP ID and the user’s account identifier user.id.

  • Delete any older credentials with the same RP ID and user.id that are stored locally by the authenticator.

• If any error occurred while creating the new credential object, return an error code equivalent to "UnknownError" and terminate the operation.

• Process all the supported extensions requested by the client, and generate the authenticator data with attestation data as specified in §5.1 Authenticator data. Use this authenticator data and the hash of the serialized client data to create an attestation object for the new credential using the procedure specified in §5.3.4 Generating an Attestation Object. For more details on attestation, see §5.3 Attestation.

On successful completion of this operation, the authenticator returns the attestation object to the client.

5.2.2. The authenticatorGetAssertion operation

This operation must be invoked in an authenticator session which has no other operations in progress. It takes the following input parameters:

• The caller’s RP ID, as determined by the user agent and the client.

• The hash of the serialized client data, provided by the client.

• A list of credentials acceptable to the Relying Party (possibly filtered by the client), if any.

• Extension data created by the client based on the extensions requested by the Relying Party, if any.

When this method is invoked, the authenticator must perform the following procedure:

• Check if all the supplied parameters are syntactically well-formed and of the correct length. If not, return an error code equivalent to "UnknownError" and terminate the operation.

• If a list of credentials was supplied by the client, filter it by removing those credentials that are not present on this authenticator. If no list was supplied, create a list with all credentials stored for the caller’s RP ID (as determined by an exact match of the RP ID).

• If the previous step resulted in an empty list, return an error code equivalent to "NotAllowedError" and terminate the operation.

• Prompt the user to select a credential from among the above list. Obtain user consent for using this credential. The prompt for obtaining this consent may be shown by the authenticator if it has its own output capability, or by the user agent otherwise.

• Process all the supported extensions requested by the client, and generate the authenticator data as specified in §5.1 Authenticator data, though without attestation data. Concatenate this authenticator data with the hash of the serialized client data to generate an assertion signature using the private key of the selected credential as shown in Figure 2, below. A simple, undelimited concatenation is safe to use here because the authenticator data describes its own length. The hash of the serialized client data (which potentially has a variable length) is always the last element.

• If any error occurred while generating the assertion signature, return an error code equivalent to "UnknownError" and terminate the operation.

On successful completion, the authenticator returns to the user agent:

• The identifier of the credential (credential ID) used to generate the assertion signature.

• The authenticator data used to generate the assertion signature.

• The assertion signature.

If the authenticator cannot find any credential corresponding to the specified Relying Party that matches the specified criteria, it terminates the operation and returns an error.

If the user refuses consent, the authenticator returns an appropriate error status to the client.

5.2.3. The authenticatorCancel operation

This operation takes no input parameters and returns no result.

When this operation is invoked by the client in an authenticator session, it has the effect of terminating any authenticatorMakeCredential or authenticatorGetAssertion operation currently in progress in that authenticator session. The authenticator stops prompting for, or accepting, any user input related to authorizing the canceled operation. The client ignores any further responses from the authenticator for the canceled operation.

This operation is ignored if it is invoked in an authenticator session which does not have an authenticatorMakeCredential or authenticatorGetAssertion operation currently in progress.

5.3. Attestation

Authenticators must also provide some form of attestation. The basic requirement is that the authenticator can produce, for each credential public key, an attestation statement verifable by the Relying Party. Typically, this attestation statement contains a signature by an attestation private key over the attested credential public key and a challenge, as well as a certificate or similar data providing provenance information for the attestation public key, enabling the Relying Party to make a trust decision. However, if an attestation key pair is not available, then the authenticator MUST perform self attestation of the credential public key with the corresponding credential private key. All this information is returned by authenticators any time a new public key credential is generated, in the overall form of an attestation object. The relationship of the attestation object with authenticator data (containing attestation data) and the attestation statement is illustrated in figure 3, below.

This figure illustrates only the packed attestation statement format. Several additional attestation statement formats are defined in §7 Defined Attestation Statement Formats.

An important component of the attestation object is the attestation statement. This is a specific type of signed data object, containing statements about a public key credential itself and the authenticator that created it. It contains an attestation signature created using the key of the attesting authority (except for the case of self attestation, when it is created using the credential private key). In order to correctly interpret an attestation statement, a Relying Party needs to understand these two aspects of attestation:

1. The attestation statement format is the manner in which the signature is represented and the various contextual bindings are incorporated into the attestation statement by the authenticator. In other words, this defines the syntax of the statement. Various existing devices and platforms (such as TPMs and the Android OS) have previously defined attestation statement formats. This specification supports a variety of such formats in an extensible way, as defined in §5.3.2 Attestation Statement Formats.

2. The attestation type defines the semantics of attestation statements and their underlying trust models. Specifically, it defines how a Relying Party establishes trust in a particular attestation statement, after verifying that it is cryptographically valid. This specification supports a number of attestation types, as described in §5.3.3 Attestation Types.

In general, there is no simple mapping between attestation statement formats and attestation types. For example, the "packed" attestation statement format defined in §7.2 Packed Attestation Statement Format can be used in conjunction with all attestation types, while other formats and types have more limited applicability.

The privacy, security and operational characteristics of attestation depend on:

• The attestation type, which determines the trust model,

• The attestation statement format, which may constrain the strength of the attestation by limiting what can be expressed in an attestation statement, and

• The characteristics of the individual authenticator, such as its construction, whether part or all of it runs in a secure operating environment, and so on.

It is expected that most authenticators will support a small number of attestation types and attestation statement formats, while Relying Parties will decide what attestation types are acceptable to them by policy. Relying Parties will also need to understand the characteristics of the authenticators that they trust, based on information they have about these authenticators. For example, the FIDO Metadata Service [FIDOMetadataService] provides one way to access such information.

5.3.1. Attestation data

Attestation data is added to the authenticator data when generating an attestation object for a given credential. It has the following format:

            pubKey = $pubKeyFmt

            ; All public key formats must include an alg name
            pubKeyTemplate = { alg: text }
            pubKeyTemplate .within $pubKeyFmt

            pubKeyFmt /= rsaPubKey
            rsaPubKey = { alg: rsaAlgName, n: biguint, e: uint }
            rsaAlgName = "RS256" / "RS384" / "RS512" / "PS256" / "PS384" / "PS512"

            pubKeyFmt /= eccPubKey
            eccPubKey = { alg: eccAlgName, x: biguint, y: biguint }
            eccAlgName = "ES256" / "ES384" / "ES512"

5.3.2. Attestation Statement Formats

As described above, an attestation statement format is a data format which represents a cryptographic signature by an authenticator over a set of contextual bindings. Each attestation statement format MUST be defined using the following template:

• Attestation statement format identifier:

• Supported attestation types:

• Syntax: The syntax of an attestation statement produced in this format, defined using [CDDL] for the extension point $attStmtFormat defined in §5.3.4 Generating an Attestation Object.

• Signing procedure: The signing procedure for computing an attestation statement in this format given the public key credential to be attested, the authenticator data structure containing the authenticator data for the attestation, and the hash of the serialized client data.

• Verification procedurs: The procedure for verifying an attestation statement, which takes as inputs the authenticator data structure containing the authenticator data claimed to have been used for the attestation and the hash of the serialized client data, and returns either:

  • An error indicating that the attestation is invalid, or

  • The attestation type, and the trust path of the attestation. This trust path is either empty (in case of self-attestation), an identifier of a ECDAA-Issuer public key (in the case of ECDAA), or a set of X.509 certificates.

The initial list of specified attestation statement formats is in §7 Defined Attestation Statement Formats.

5.3.3. Attestation Types

WebAuthn supports multiple attestation types:

Basic Attestation

In the case of basic attestation [UAFProtocol], the authenticator’s attestation key pair is specific to an authenticator model. Thus, authenticators of the same model often share the same attestation key pair. See §5.3.5.1 Privacy for futher information.

Self Attestation

In the case of self attestation, also known as surrogate basic attestation [UAFProtocol], the Authenticator doesn’t have any specific attestation key. Instead it uses the authentication key itself to create the attestation signature. Authenticators without meaningful protection measures for an attestation private key typically use this attestation type.

Privacy CA

In this case, the Authenticator owns an authenticator-specific (endorsement) key. This key is used to securely communicate with a trusted third party, the Privacy CA. The Authenticator can generate multiple attestation key pairs and asks the Privacy CA to issue an attestation certificate for it. Using this approach, the Authenticator can limit the exposure of the endorsement key (which is a global correlation handle) to Privacy CA(s). Attestation keys can be requested for each public key credential individually.

Note: This concept typically leads to multiple attestation certificates. The attestation certificate requested most recently is called "active".

Elliptic Curve based Direct Anonymous Attestation (ECDAA)

In this case, the Authenticator receives direct anonymous attestation (DAA]) credentials from a single DAA-Issuer. These DAA credentials are used along with blinding to sign the attestation data. The concept of blinding avoids the DAA credentials being misused as global correlation handle. WebAuthn supports DAA using elliptic curve cryptography and bilinear pairings, called ECDAA (see [FIDOEcdaaAlgorithm]) in this specification. Consequently we denote the DAA-Issuer as ECDAA-Issuer (see [FIDOEcdaaAlgorithm]).

5.3.4. Generating an Attestation Object

This section specifies the algorithm for generating an attestation object (see: Figure 3) for any attestation statement format.

In order to construct an attestation object for a given public key credential using a particular attestation statement format, the authenticator MUST first generate the authenticator data.

The authenticator MUST then run the signing procedure for the desired attestation statement format with this authenticator data and the hash of the serialized client data as input, and use this to construct an attestation statement in that attestation statement format.

Finally, the authenticator MUST construct the attestation object as a CBOR map with the following syntax:

attObj = {
            authData: bytes,
            $$attStmtType
         }

attStmtTemplate = (
                      fmt: text,
                      attStmt: bytes
                  )

; Every attestation statement format must have the above fields
attStmtTemplate .within $$attStmtType

The semantics of the fields in the attestation object are as follows:

fmt

The attestation statement format identifier associated with the attestation statement. Each attestation statement format defines its identifier.

authData

The authenticator data used to generate the attestation statement.

attStmt

The attestation statement constructed above. The syntax of this is defined by the attestation statement format used.

5.3.5. Security Considerations

5.3.5.1. Privacy

Attestation keys may be used to track users or link various online identities of the same user together. This may be mitigated in several ways, including:

• A WebAuthn authenticator manufacturer may choose to ship all of their devices with the same (or a fixed number of) attestation key(s) (called Basic Attestation). This will anonymize the user at the risk of not being able to revoke a particular attestation key should its WebAuthn Authenticator be compromised.

• A WebAuthn Authenticator may be capable of dynamically generating different attestation keys (and requesting related certificates) per origin (following the Privacy CA approach). For example, a WebAuthn Authenticator can ship with a master attestation key (and certificate), and combined with a cloud operated privacy CA, can dynamically generate per origin attestation keys and attestation certificates.

• A WebAuthn Authenticator can implement Elliptic Curve based direct anonymous attestation (see [FIDOEcdaaAlgorithm]). Using this scheme, the authenticator generates a blinded attestation signature. This allows the Relying Party to verify the signature using the ECDAA-Issuer public key, but the attestation signature doesn’t serve as a global correlation handle.

5.3.5.2. Attestation Certificate and Attestation Certificate CA Compromise

When an intermediate CA or a root CA used for issuing attestation certificates is compromised, WebAuthn authenticator attestation keys are still safe although their certificates can no longer be trusted. A WebAuthn Authenticator manufacturer that has recorded the public attestation keys for their devices can issue new attestation certificates for these keys from a new intermediate CA or from a new root CA. If the root CA changes, the Relying Parties must update their trusted root certificates accordingly.

A WebAuthn Authenticator attestation certificate must be revoked by the issuing CA if its key has been compromised. A WebAuthn Authenticator manufacturer may need to ship a firmware update and inject new attestation keys and certificates into already manufactured WebAuthn Authenticators, if the exposure was due to a firmware flaw. (The process by which this happens is out of scope for this specification.) If the WebAuthn Authenticator manufacturer does not have this capability, then it may not be possible for Relying Parties to trust any further attestation statements from the affected WebAuthn Authenticators.

If attestation certificate validation fails due to a revoked intermediate attestation CA certificate, and the Relying Party's policy requires rejecting the registration/authentication request in these situations, then it is recommended that the Relying Party also un-registers (or marks with a trust level equivalent to "self attestation") public key credentials that were registered after the CA compromise date using an attestation certificate chaining up to the same intermediate CA. It is thus recommended that Relying Parties remember intermediate attestation CA certificates during Authenticator registration in order to un-register related public key credentials if the registration was performed after revocation of such certificates.

If an ECDAA attestation key has been compromised, it can be added to the RogueList (i.e., the list of revoked authenticators) maintained by the related ECDAA-Issuer. The Relying Party should verify whether an authenticator belongs to the RogueList when performing ECDAA-Verify (see section 3.6 in [FIDOEcdaaAlgorithm]). For example, the FIDO Metadata Service [FIDOMetadataService] provides one way to access such information.

5.3.5.3. Attestation Certificate Hierarchy

A 3-tier hierarchy for attestation certificates is recommended (i.e., Attestation Root, Attestation Issuing CA, Attestation Certificate). It is also recommended that for each WebAuthn Authenticator device line (i.e., model), a separate issuing CA is used to help facilitate isolating problems with a specific version of a device.

If the attestation root certificate is not dedicated to a single WebAuthn Authenticator device line (i.e., AAGUID), the AAGUID should be specified in the attestation certificate itself, so that it can be verified against the authenticator data.

6. Relying Party Operations

Upon successful execution of create() or get(), the Relying Party's script receives a PublicKeyCredential containing an AuthenticatorAttestationResponse or AuthenticatorAssertionResponse structure, respectively, from the client. It must then deliver the contents of this structure to the Relying Party server, using methods outside the scope of this specification. This section describes the operations that the Relying Party must perform upon receipt of these structures.

6.1. Registering a new credential

When registering a new credential, represented by a AuthenticatorAttestationResponse structure, as part of a registration ceremony, a Relying Party MUST proceed as follows:

1. Perform JSON deserialization on the clientDataJSON field of the AuthenticatorAttestationResponse object to extract the client data C claimed as collected during the credential creation.

2. Verify that the challenge in C matches the challenge that was sent to the authenticator in the create() call.

3. Verify that the origin in C matches the Relying Party's origin.

4. Verify that the tokenBindingId in C matches the Token Binding ID for the TLS connection over which the attestation was obtained.

5. Verify that the clientExtensions in C is a proper subset of the extensions requested by the RP and that the authenticatorExtensions in C is also a proper subset of the extensions requested by the RP.

6. Compute the hash of clientDataJSON using the algorithm identified by C.

1. hashAlg.

2. Perform CBOR decoding on the attestationObject field of the AuthenticatorAttestationResponse structure to obtain the attestation statement format fmt, the authenticator data authData, and the attestation statement attStmt.

3. Verify that the RP ID hash in authData is indeed the SHA-256 hash of the RP ID expected by the RP.

4. Determine the attestation statement format by performing an USASCII case-sensitive match on fmt against the set of supported WebAuthn Attestation Statement Format Identifier values. The up-to-date list of registered WebAuthn Attestation Statement Format Identifier values is maintained in the in the IANA registry of the same name [WebAuthn-Registries].

5. Verify that attStmt is a correct, validly-signed attestation statement, using the attestation statement format fmt’s verification procedure given authenticator data authData and the hash of the serialized client data computed in step 6.

6. If validation is successful, obtain a list of acceptable trust anchors (attestation root certificates or ECDAA-Issuer public keys) for that attestation type and attestation statement format fmt, from a trusted source or from policy. For example, the FIDO Metadata Service [FIDOMetadataService] provides one way to obtain such information, using the AAGUID in the attestation data contained in authData.

7. Assess the attestation trustworthiness using the outputs of the verification procedure in step 10, as follows:

   • If self-attestation was used, check if self-attestation is acceptable under Relying Party policy.

   • If ECDAA was used, verify that the identifier of the ECDAA-Issuer public key used is included in the set of acceptable trust anchors obtained in step 11.

   • Otherwise, use the X.509 certificates returned by the verification procedure to verify that the attestation public key correctly chains up to an acceptable root certificate.

8. If the attestation statement attStmt verified successfully and is found to be trustworthy, then register the new credential with the account that was denoted in the options.user passed to create(), by associating it with the credential ID and credential public key contained in authData’s attestation data, as appropriate for the Relying Party's systems.

9. If the attestation statement attStmt successfully verified but is not trustworthy per step 12 above, the Relying Party SHOULD fail the registration ceremony.

   NOTE: However, if permitted by policy, the Relying Party MAY register the credential ID and credential public key but treat the credential as one with self-attestation (see §5.3.3 Attestation Types). If doing so, the Relying Party is asserting there is no cryptographic proof that the public key credential has been generated by a particular authenticator model. See [FIDOSecRef] and [UAFProtocol] for a more detailed discussion.

10. If verification of the attestation statement failed, the Relying Party MUST fail the registration ceremony.

Verification of attestation objects requires that the Relying Party has a trusted method of determining acceptable trust anchors in step 11 above. Also, if certificates are being used, the Relying Party must have access to certificate status information for the intermediate CA certificates. The Relying Party must also be able to build the attestation certificate chain if the client did not provide this chain in the attestation information.

To avoid ambiguity during authentication, the Relying Party SHOULD check that each credential is registered to no more than one user. If registration is requested for a credential that is already registered to a different user, the Relying Party SHOULD fail this ceremony, or it MAY decide to accept the registration, e.g. while deleting the older registration.

6.2. Verifying an authentication assertion

When verifying a given PublicKeyCredential structure (credential) as part of an authentication ceremony, the Relying Party MUST proceed as follows:

1. Using credential’s id attribute (or the corresponding rawId, if base64url encoding is inappropriate for your use case), look up the corresponding credential public key.

2. Let cData, aData and sig denote the value of credential’s response's clientDataJSON, authenticatorData, and signature respectively.

3. Perform JSON deserialization on cData to extract the client data C used for the signature.

4. Verify that the challenge member of C matches the challenge that was sent to the authenticator in the PublicKeyCredentialRequestOptions passed to the get() call.

5. Verify that the origin member of C matches the Relying Party's origin.

6. Verify that the tokenBindingId member of C (if present) matches the Token Binding ID for the TLS connection over which the signature was obtained.

7. Verify that the clientExtensions member of C is a proper subset of the extensions requested by the Relying Party and that the authenticatorExtensions in C is also a proper subset of the extensions requested by the Relying Party.

8. Verify that the RP ID hash in aData is the SHA-256 hash of the RP ID expected by the Relying Party.

9. Let hash be the result of computing a hash over the cData using the algorithm represented by the

1. hashAlg member of C.

2. Using the credential public key looked up in step 1, verify that sig is a valid signature over the binary concatenation of aData and hash.

3. If all the above steps are successful, continue with the authentication ceremony as appropriate. Otherwise, fail the authentication ceremony.

7. Defined Attestation Statement Formats

WebAuthn supports pluggable attestation statement formats. This section defines an initial set of such formats.

7.1. Attestation Statement Format Identifiers

Attestation statement formats are identified by a string, called a attestation statement format identifier, chosen by the author of the attestation statement format.

Attestation statement format identifiers SHOULD be registered per [WebAuthn-Registries] "Registries for Web Authentication (WebAuthn)". All registered attestation statement format identifiers are unique amongst themselves as a matter of course.

Unregistered attestation statement format identifiers SHOULD use lowercase reverse domain-name naming, using a domain name registered by the developer, in order to assure uniqueness of the identifier. All attestation statement format identifiers MUST be a maximum of 32 octets in length and MUST consist only of printable USASCII characters, excluding backslash and doublequote, i.e., VCHAR as defined in [RFC5234] but without %x22 and %x5c.

Note: This means attestation statement format identifiers based on domain names MUST incorporate only LDH Labels [RFC5890].

Implementations MUST match WebAuthn attestation statement format identifiers in a case-sensitive fashion.

Attestation statement formats that may exist in multiple versions SHOULD include a version in their identifier. In effect, different versions are thus treated as different formats, e.g., packed2 as a new version of the packed attestation statement format.

The following sections present a set of currently-defined and registered attestation statement formats and their identifiers. The up-to-date list of registered WebAuthn Extensions is maintained in the IANA "WebAuthn Attestation Statement Format Identifier" registry established by [WebAuthn-Registries].

7.2. Packed Attestation Statement Format

This is a WebAuthn optimized attestation statement format. It uses a very compact but still extensible encoding method. It is implementable by authenticators with limited resources (e.g., secure elements).

Attestation statement format identifier

packed

Attestation types supported

All

Syntax

The syntax of a Packed Attestation statement is defined by the following CDDL:

    $$attStmtType //= (
                          fmt: "packed",
                          attStmt: packedStmtFormat
                      )

    packedStmtFormat = {
                           alg: rsaAlgName / eccAlgName,
                           sig: bytes,
                           x5c: [ attestnCert: bytes, * (caCert: bytes) ]
                       } //
                       {
                           alg: "ED256" / "ED512",
                           sig: bytes,
                           ecdaaKeyId: bytes
                       }

The semantics of the fields are as follows:

alg

A text string containing the name of the algorithm used to generate the attestation signature. The types rsaAlgName and eccAlgName are as defined in §5.3.1 Attestation data. "ED256" and "ED512" refer to algorithms defined in [FIDOEcdaaAlgorithm].

sig

A byte string containing the attestation signature.

x5c

The elements of this array contain the attestation certificate and its certificate chain, each encoded in X.509 format. The attestation certificate must be the first element in the array.

ecdaaKeyId

The identifier of the ECDAA-Issuer public key. This is the BigNumberToB encoding of the component "c" of the ECDAA-Issuer public key as defined section 3.3, step 3.5 in [FIDOEcdaaAlgorithm].

Signing procedure

The signing procedure for this attestation statement format is similar to the procedure for generating assertion signatures.

Let authenticatorData denote the authenticator data for the attestation, and let clientDataHash denote the hash of the serialized client data.

If Basic or Privacy CA attestation is in use, the authenticator produces the sig by concatenating authenticatorData and clientDataHash, and signing the result using an attestation private key selected through an authenticator-specific mechanism. It sets x5c to the certificate chain of the attestation public key and alg to the algorithm of the attestation private key.

If ECDAA is in use, the authenticator produces sig by concatenating authenticatorData and clientDataHash, and signing the result using ECDAA-Sign (see section 3.5 of [FIDOEcdaaAlgorithm]) with a ECDAA-Issuer public key selected through an authenticator-specific mechanism (see [FIDOEcdaaAlgorithm]). It sets alg to the algorithm of the ECDAA-Issuer public key and ecdaaKeyId to the identifier of the ECDAA-Issuer public key (see above).

If self attestation is in use, the authenticator produces sig by concatenating authenticatorData and clientDataHash, and signing the result using the credential private key. It sets alg to the algorithm of the credential private key, and omits the other fields.

Verification procedure

Verify that the given attestation statement is valid CBOR conforming to the syntax defined above.

Let authenticatorData denote the authenticator data claimed to have been used for the attestation, and let clientDataHash denote the hash of the serialized client data.

If x5c is present, this indicates that the attestation type is not ECDAA. In this case:

• Verify that sig is a valid signature over the concatenation of authenticatorData and clientDataHash using the attestation public key in x5c with the algorithm specified in alg.

• Verify that x5c meets the requirements in §7.2.1 Packed attestation statement certificate requirements.

• If x5c contains an extension with OID 1 3 6 1 4 1 45724 1 1 4 (id-fido-gen-ce-aaguid) verify that the value of this extension matches the AAGUID in authenticatorData.

• If successful, return attestation type Basic and trust path x5c.

If ecdaaKeyId is present, then the attestation type is ECDAA. In this case:

• Verify that sig is a valid signature over the concatenation of authenticatorData and clientDataHash using ECDAA-Verify with ECDAA-Issuer public key identified by ecdaaKeyId (see [FIDOEcdaaAlgorithm]).

• If successful, return attestation type ECDAA and trust path ecdaaKeyId.

If neither x5c nor ecdaaKeyId is present, self attestation is in use.

• Validate that alg matches the algorithm of the credential private key in authenticatorData.

• Verify that sig is a valid signature over the concatenation of authenticatorData and clientDataHash using the credential public key with alg.

• If successful, return attestation type Self and empty trust path.

7.2.1. Packed attestation statement certificate requirements

The attestation certificate MUST have the following fields/extensions:

• Version must be set to 3.

• Subject field MUST be set to:

  Subject-C

  Country where the Authenticator vendor is incorporated

  Subject-O

  Legal name of the Authenticator vendor

  Subject-OU

  Authenticator Attestation

  Subject-CN

  No stipulation.

• If the related attestation root certificate is used for multiple authenticator models, the Extension OID 1 3 6 1 4 1 45724 1 1 4 (id-fido-gen-ce-aaguid) MUST be present, containing the AAGUID as value.

• The Basic Constraints extension MUST have the CA component set to false

• An Authority Information Access (AIA) extension with entry id-ad-ocsp and a CRL Distribution Point extension [RFC5280] are both optional as the status of many attestation certificates is available through authenticator metadata services. See, for example, the FIDO Metadata Service [FIDOMetadataService].

7.3. TPM Attestation Statement Format

This attestation statement format is generally used by authenticators that use a Trusted Platform Module as their cryptographic engine.

Attestation statement format identifier

tpm

Attestation types supported

Privacy CA, ECDAA

Syntax

The syntax of a TPM Attestation statement is as follows:

    $$attStmtType // = (
                           fmt: "tpm",
                           attStmt: tpmStmtFormat
                       )

    tpmStmtFormat = {
                        ver: "2.0",
                        (
                            alg: rsaAlgName / eccAlgName,
                            x5c: [ aikCert: bytes, * (caCert: bytes) ]
                        ) //
                        (
                            alg:  "ED256" / "ED512",
                            ecdaaKeyId: bytes
                        ),
                        sig: bytes,
                        certInfo: bytes,
                        pubArea: bytes
                    }

The semantics of the above fields are as follows:

ver

The version of the TPM specification to which the signature conforms.

alg

The name of the algorithm used to generate the attestation signature. The types rsaAlgName and eccAlgNAme are as defined in §5.3.1 Attestation data. The types "ED256" and "ED512" refer to the algorithms specified in [FIDOEcdaaAlgorithm].

x5c

The AIK certificate used for the attestation and its certificate chain, in X.509 encoding.

ecdaaKeyId

The identifier of the ECDAA-Issuer public key. This is the BigNumberToB encoding of the component "c" as defined section 3.3, step 3.5 in [FIDOEcdaaAlgorithm].

sig

The attestation signature, in the form of a TPMT_SIGNATURE structure as specified in [TPMv2-Part2] section 11.3.4.

certInfo

The TPMS_ATTEST structure over which the above signature was computed, as specified in [TPMv2-Part2] section 10.12.8.

pubArea

The TPMT_PUBLIC structure (see [TPMv2-Part2] section 12.2.4) used by the TPM to represent the credential public key.

Signing procedure

Let authenticatorData denote the authenticator data for the attestation, and let clientDataHash denote the hash of the serialized client data.

Concatenate authenticatorData and clientDataHash to form attToBeSigned.

Generate a signature using the procedure specified in [TPMv2-Part3] Section 18.2, using the attestation private key and setting the qualifyingData parameter to attToBeSigned.

Set the pubArea field to the public area of the credential public key, the certInfo field to the output parameter of the same name, and the sig field to the signature obtained from the above procedure.

Verification procedure

Verify that the given attestation statement is valid CBOR conforming to the syntax defined above.

Let authenticatorData denote the authenticator data claimed to have been used for the attestation, and let clientDataHash denote the hash of the serialized client data.

Verify that the public key specified by the parameters and unique fields of pubArea is identical to the public key contained in the attestation data inside authenticatorData.

Concatenate authenticatorData and clientDataHash to form attToBeSigned.

Validate that certInfo is valid:

• Verify that magic is set to TPM_GENERATED_VALUE.

• Verify that type is set to TPM_ST_ATTEST_CERTIFY.

• Verify that extraData is set to attToBeSigned.

• Verify that attested contains a TPMS_CERTIFY_INFO structure, whose name field contains a valid Name for pubArea, as computed using the algorithm in the nameAlg field of pubArea using the procedure specified in [TPMv2-Part1] section 16.

If x5c is present, this indicates that the attestation type is not ECDAA. In this case:

• Verify the sig is a valid signature over certInfo using the attestation public key in x5c with the algorithm specified in alg.

• Verify that x5c meets the requirements in §7.3.1 TPM attestation statement certificate requirements.

• If x5c contains an extension with OID 1 3 6 1 4 1 45724 1 1 4 (id-fido-gen-ce-aaguid) verify that the value of this extension matches the AAGUID in authenticatorData.

• If successful, return attestation type Privacy CA and trust path x5c.

If ecdaaKeyId is present, then the attestation type is ECDAA.

• Perform ECDAA-Verify on sig to verify that it is a valid signature over certInfo (see [FIDOEcdaaAlgorithm]).

• If successful, return attestation type ECDAA and the identifier of the ECDAA-Issuer public key ecdaaKeyId.

7.3.1. TPM attestation statement certificate requirements

TPM attestation certificate MUST have the following fields/extensions:

• Version must be set to 3.

• Subject field MUST be set to empty.

• The Subject Alternative Name extension must be set as defined in [TPMv2-EK-Profile] section 3.2.9.

• The Extended Key Usage extension MUST contain the "joint-iso-itu-t(2) internationalorganizations(23) 133 tcg-kp(8) tcg-kp-AIKCertificate(3)" OID.

• The Basic Constraints extension MUST have the CA component set to false.

• An Authority Information Access (AIA) extension with entry id-ad-ocsp and a CRL Distribution Point extension [RFC5280] are both optional as the status of many attestation certificates is available through metadata services. See, for example, the FIDO Metadata Service [FIDOMetadataService].

7.4. Android Key Attestation Statement Format

When the authenticator in question is a platform-provided Authenticator on the Android "N" or later platform, the attestation statement is based on the Android key attestation. In these cases, the attestation statement is produced by a component running in a secure operating environment, but the authenticator data for the attestation is produced outside this environment. The Relying Party is expected to check that the authenticator data claimed to have been used for the attestation is consistent with the fields of the attestation certificate’s extension data.

Attestation statement format identifier

android-key

Attestation types supported

Basic

Syntax

An Android key attestation statement consists simply of the Android attestation statement, which is a series of DER encoded X.509 certificates. See the Android developer documentation. Its syntax is defined as follows:

    $$attStmtType //= (
                          fmt: "android-key",
                          attStmt: androidStmtFormat
                      )

    androidStmtFormat = bytes

Signing procedure

Let authenticatorData denote the authenticator data for the attestation, and let clientDataHash denote the hash of the serialized client data.

Concatenate authenticatorData and clientDataHash to form attToBeSigned.

Request an Android Key Attestation by calling "keyStore.getCertificateChain(myKeyUUID)") providing attToBeSigned as the challenge value (e.g., by using setAttestationChallenge), and set the attestation statement to the returned value.

Verification procedure

Verification is performed as follows:

• Let authenticatorData denote the authenticator data claimed to have been used for the attestation, and let clientDataHash denote the hash of the serialized client data.

• Verify that the public key in the first certificate in the series of certificates represented by the signature matches the credential public key in the attestation data field of authenticatorData.

• Verify that in the attestation certificate extension data:

  • The value of the attestationChallenge field is identical to the concatenation of authenticatorData and clientDataHash.

  • The AuthorizationList.allApplications field is not present, since PublicKeyCredentials must be bound to the RP ID.

  • The value in the AuthorizationList.origin field is equal to KM_TAG_GENERATED.

  • The value in the AuthorizationList.purpose field is equal to KM_PURPOSE_SIGN.

• If successful, return attestation type Basic with the trust path set to the entire attestation statement.

7.5. Android SafetyNet Attestation Statement Format

When the authenticator in question is a platform-provided Authenticator on certain Android platforms, the attestation statement is based on the SafetyNet API. In this case the authenticator data is completely controlled by the caller of the SafetyNet API (typically an application running on the Android platform) and the attestation statement only provides some statements about the health of the platform and the identity of the calling application.

Attestation statement format identifier

android-safetynet

Attestation types supported

Basic

Syntax

The syntax of an Android Attestation statement is defined as follows:

    $$attStmtType //= (
                          fmt: "android-safetynet",
                          attStmt: safetynetStmtFormat
                      )

    safetynetStmtFormat = {
                              ver: text,
                              response: bytes
                          }

The semantics of the above fields are as follows:

ver

The version number of Google Play Services responsible for providing the SafetyNet API.

response

The value returned by the above SafetyNet API. This value is a JWS [RFC7515] object (see SafetyNet online documentation) in Compact Serialization.

Signing procedure

Let authenticatorData denote the authenticator data for the attestation, and let clientDataHash denote the hash of the serialized client data.

Concatenate authenticatorData and clientDataHash to form attToBeSigned.

Request a SafetyNet attestation, providing attToBeSigned as the nonce value. Set response to the result, and ver to the version of Google Play Services running in the authenticator.

Verification procedure

Verification is performed as follows:

• Verify that the given attestation statement is valid CBOR conforming to the syntax defined above.

• Verify that response is a valid SafetyNet response of version ver.

• Verify that the nonce in the response is identical to the concatenation of the authenticatorData and clientDataHash.

• Verify that the attestation certificate is issued to the hostname "attest.android.com" (see SafetyNet online documentation).

• Verify that the ctsProfileMatch attribute in the payload of response is true.

• If successful, return attestation type Basic with the trust path set to the above attestation certificate.

7.6. FIDO U2F Attestation Statement Format

This attestation statement format is used with FIDO U2F authenticators using the formats defined in [FIDO-U2F-Message-Formats].

Attestation statement format identifier

fido-u2f

Attestation types supported

Basic

Syntax

The syntax of a FIDO U2F attestation statement is defined as follows:

    $$attStmtType //= (
                          fmt: "fido-u2f",
                          attStmt: u2fStmtFormat
                      )

    u2fStmtFormat = {
                        x5c: [ attestnCert: bytes, * (caCert: bytes) ],
                        sig: bytes
                    }

The semantics of the above fields are as follows:

x5c

The elements of this array contain the attestation certificate and its certificate chain, each encoded in X.509 format. The attestation certificate must be the first element in the array.

sig

The attestation signature.

Signing procedure

If the credential public key of the given credential is not of algorithm "ES256", stop and return an error.

Let authenticatorData denote the authenticator data for the attestation, and let clientDataHash denote the hash of the serialized client data.

If clientDataHash is 256 bits long, set tbsHash to this value. Otherwise set tbsHash to the SHA-256 hash of clientDataHash.

Generate a signature as specified in [FIDO-U2F-Message-Formats] section 4.3, with the application parameter set to the SHA-256 hash of the RP ID associated with the given credential, the challenge parameter set to tbsHash, and the key handle parameter set to the credential ID of the given credential. Set this as sig and set the attestation certificate of the attestation public key as x5c.

Verification procedure

Verification is performed as follows:

• Verify that the given attestation statement is valid CBOR conforming to the syntax defined above.

• If x5c is not a certificate for an ECDSA public key over the P-256 curve, stop verification and return an error.

• Let authenticatorData denote the authenticator data claimed to have been used for the attestation, and let clientDataHash denote the hash of the serialized client data.

• If clientDataHash is 256 bits long, set tbsHash to this value. Otherwise set tbsHash to the SHA-256 hash of clientDataHash.

• From authenticatorData, extract the claimed RP ID hash, the claimed credential ID and the claimed credential public key.

• Generate the claimed to-be-signed data as specified in [FIDO-U2F-Message-Formats] section 4.3, with the application parameter set to the claimed RP ID hash, the challenge parameter set to tbsHash, the key handle parameter set to the claimed credential ID of the given credential, and the user public key parameter set to the claimed credential public key.

• Verify that the sig is a valid ECDSA P-256 signature over the to-be-signed data constructed above.

• If successful, return attestation type Basic with the trust path set to x5c.

8. WebAuthn Extensions

The mechanism for generating public key credentials, as well as requesting and generating Authentication assertions, as defined in §4 Web Authentication API, can be extended to suit particular use cases. Each case is addressed by defining a registration extension and/or an authentication extension.

Every extension is a client extension, meaning that the extension involves communication with and processing by the client. Client extensions define the following steps and data:

• navigator.credentials.create() extension request parameters and response values for registration extensions.

• navigator.credentials.get() extension request parameters and response values for authentication extensions.

• Client extension processing for registration extensions and authentication extensions.

When creating a public key credential or requesting an authentication assertion, a Relying Party can request the use of a set of extensions. These extensions will be invoked during the requested operation if they are supported by the client and/or the authenticator. The Relying Party sends the client extension input for each extension in the get() call (for authentication extensions) or create() call (for registration extensions) to the client platform. The client platform performs client extension processing for each extension that it supports, and augments the client data as specified by each extension, by including the extension identifier and client extension output values.

An extension can also be an authenticator extension, meaning that the extension invoves communication with and processing by the authenticator. Authenticator extensions define the following steps and data:

• authenticatorMakeCredential extension request parameters and response values for registration extensions.

• authenticatorGetAssertion extension request parameters and response values for authentication extensions.

• Authenticator extension processing for registration extensions and authentication extensions.

For authenticator extensions, as part of the client extension processing, the client also creates the CBOR authenticator extension input value for each extension (often based on the corresponding client extension input value), and passes them to the authenticator in the create() call (for registration extensions) or the get() call (for authentication extensions). These authenticator extension input values are represented in CBOR and passed as name-value pairs, with the extension identifier as the name, and the corresponding authenticator extension input as the value. The authenticator, in turn, performs additional processing for the extensions that it supports, and returns the CBOR authenticator extension output for each as specified by the extension. Part of the client extension processing for authenticator extensions is to use the authenticator extension output as an input to creating the client extension output.

All WebAuthn extensions are optional for both clients and authenticators. Thus, any extensions requested by a Relying Party may be ignored by the client browser or OS and not passed to the authenticator at all, or they may be ignored by the authenticator. Ignoring an extension is never considered a failure in WebAuthn API processing, so when Relying Parties include extensions with any API calls, they must be prepared to handle cases where some or all of those extensions are ignored.

Clients wishing to support the widest possible range of extensions may choose to pass through any extensions that they do not recognize to authenticators, generating the authenticator extension input by simply encoding the client extension input in CBOR. All WebAuthn extensions MUST be defined in such a way that this implementation choice does not endanger the user’s security or privacy. For instance, if an extension requires client processing, it could be defined in a manner that ensures such a naïve pass-through will produce a semantically invalid authenticator extension input value, resulting in the extension being ignored by the authenticator. Since all extensions are optional, this will not cause a functional failure in the API operation. Likewise, clients can choose to produce a client extension output value for an extension that it does not understand by encoding the authenticator extension output value into JSON, provided that the CBOR output uses only types present in JSON.

The IANA "WebAuthn Extension Identifier" registry established by [WebAuthn-Registries] should be consulted for an up-to-date list of registered WebAuthn Extensions.

8.1. Extension Identifiers

Extensions are identified by a string, called an extension identifier, chosen by the extension author.

Extension identifiers SHOULD be registered per [WebAuthn-Registries] "Registries for Web Authentication (WebAuthn)". All registered extension identifiers are unique amongst themselves as a matter of course.

Unregistered extension identifiers should aim to be globally unique, e.g., by including the defining entity such as myCompany_extension.

All extension identifiers MUST be a maximum of 32 octets in length and MUST consist only of printable USASCII characters, excluding backslash and doublequote, i.e., VCHAR as defined in [RFC5234] but without %x22 and %x5c. Implementations MUST match WebAuthn extension identifiers in a case-sensitive fashion.

Extensions that may exist in multiple versions should take care to include a version in their identifier. In effect, different versions are thus treated as different extensions, e.g., myCompany_extension_01

§9 Defined Extensions defines an initial set of extensions and their identifiers. See the IANA "WebAuthn Extension Identifier" registry established by [WebAuthn-Registries] for an up-to-date list of registered WebAuthn Extension Identifiers.

8.2. Defining extensions

A definition of an extension must specify an extension identifier, a client extension input argument to be sent via the get() or create() call, the client extension processing rules, and a client extension output value. If the extension communicates with the authenticator (meaning it is an authenticator extension), it must also specify the CBOR authenticator extension input argument sent via the authenticatorGetAssertion or authenticatorMakeCredential call, the authenticator extension processing rules, and the CBOR authenticator extension output value.

Any client extension that is processed by the client MUST return a client extension output value so that the Relying Party knows that the extension was honored by the client. Similarly, any extension that requires authenticator processing MUST return an authenticator extension output to let the Relying Party know that the extension was honored by the authenticator. If an extension does not otherwise require any result values, it SHOULD be defined as returning a JSON Boolean client extension output result, set to true to signify that the extension was understood and processed. Likewise, any authenticator extension that does not otherwise require any result values MUST return a value and SHOULD return a CBOR Boolean authenticator extension output result, set to true to signify that the extension was understood and processed.

8.3. Extending request parameters

An extension defines one or two request arguments. The client extension input, which is a value that can be encoded in JSON, is passed from the Relying Party to the client in the get() or create() call, while the CBOR authenticator extension input is passed from the client to the authenticator for authenticator extensions during the processing of these calls.

A Relying Party simultaneously requests the use of an extension and sets its client extension input by including an entry in the extensions option to the create() or get() call. The entry key is the extension identifier and the value is the client extension input.

var assertionPromise = navigator.credentials.get({
    publicKey: {
        challenge: "...",
        extensions: {
            "webauthnExample_foobar": 42
        }
    }
});

Extension definitions MUST specify the valid values for their client extension input. Clients SHOULD ignore extensions with an invalid client extension input. If an extension does not require any parameters from the Relying Party, it SHOULD be defined as taking a Boolean client argument, set to true to signify that the extension is requested by the Relying Party.

Extensions that only affect client processing need not specify authenticator extension input. Extensions that have authenticator processing MUST specify the method of computing the authenticator extension input from the client extension input. For extensions that do not require input parameters and are defined as taking a Boolean client extension input value set to true, this method SHOULD consist of passing an authenticator extension input value of true (CBOR major type 7, value 21).

Note: Extensions should aim to define authenticator arguments that are as small as possible. Some authenticators communicate over low-bandwidth links such as Bluetooth Low-Energy or NFC.

8.4. Client extension processing

Extensions may define additional processing requirements on the client platform during the creation of credentials or the generation of an assertion. The client extension input for the extension is used an input to this client processing. Supported client extensions are recorded as a dictionary in the client data with the key clientExtensions. For each such extension, the client adds an entry to this dictionary with the extension identifier as the key, and the extension’s client extension input as the value.

Likewise, the client extension outputs are represented as a dictionary in the clientExtensionResults with extension identifiers as keys, and the client extension output value of each extension as the value. Like the client extension input, the client extension output is a value that can be encoded in JSON.

Extensions that require authenticator processing MUST define the process by which the client extension input can be used to determine the CBOR authenticator extension input and the process by which the CBOR authenticator extension output can be used to determine the client extension output.