1. Introduction
+This section is not normative.
+This specification defines an API enabling the creation and use of strong, attested, cryptographic scoped +credentials by web applications, for the purpose of strongly authenticating users. A scoped credential is +created and stored by an authenticator at the behest of a Relying Party, subject to user +consent. Subsequently, the scoped credential can only be accessed by origins belonging to that Relying Party. +This scoping is enforced jointly by conforming User Agents and authenticators. +Additionally, privacy across Relying Parties is maintained; Relying Parties are not able to detect any properties, or even +the existence, of credentials scoped to other Relying Parties.
+Relying Parties employ the Web Authentication API during two distinct, but related, ceremonies involving a user. The first
+is Registration, where a scoped credential is created on an authenticator, and associated by a Relying Party with the present user’s account (the account may already exist or may be created at this time). The second is Authentication, where the Relying Party is presented with an Authentication Assertion proving the presence
+and consent of the user who registered the scoped credential. Functionally, the Web Authentication API comprises
+two methods (along with associated data structures): makeCredential() and getAssertion(). The former is used
+during Registration and the latter during Authentication.
Broadly, compliant authenticators protect scoped credentials, and interact with user agents to implement the Web Authentication API. Some authenticators may run on the same computing device (e.g., smart phone, tablet, desktop PC) as +the user agent is running on. For instance, such an authenticator might consist of a Trusted Execution Environment (TEE) applet, +a Trusted Platform Module (TPM), or a Secure Element (SE) integrated into the computing device in conjunction with some means +for user verification, along with appropriate platform software to mediate access to these components' functionality. Other +authenticators may operate autonomously from the computing device running the user agent, and be accessed over a transport such +as Universal Serial Bus (USB), Bluetooth Low Energy (BLE) or Near Field Communications (NFC).
+1.1. Use Cases
+The below use case scenarios illustrate use of two very different types of authenticators, as well as outline further +scenarios. Additional scenarios, including sample code, are given later in §11 Sample scenarios.
+1.1.1. Registration
+-
+
-
+
On a phone:
+-
+
-
+
User navigates to example.com in a browser and signs in to an existing account using whatever method they have been using +(possibly a legacy method such as a password), or creates a new account.
+ -
+
The phone prompts, "Do you want to register this device with example.com?"
+ -
+
User agrees.
+ -
+
The phone prompts the user for a previously configured authorization gesture (PIN, biometric, etc.); the user +provides this.
+ -
+
Website shows message, "Registration complete."
+
-
+
1.1.2. Authentication
+-
+
-
+
On a laptop or desktop:
+-
+
-
+
User navigates to example.com in a browser, sees an option to "Sign in with your phone."
+ -
+
User chooses this option and gets a message from the browser, "Please complete this action on your phone."
+
-
+
-
+
Next, on their phone:
+-
+
-
+
User sees a discrete prompt or notification, "Sign in to example.com."
+ -
+
User selects this prompt / notification.
+ -
+
User is shown a list of their example.com identities, e.g., "Sign in as Alice / Sign in as Bob."
+ -
+
User picks an identity, is prompted for an authorization gesture (PIN, biometric, etc.) and provides this.
+
-
+
-
+
Now, back on the laptop:
+-
+
-
+
Web page shows that the selected user is signed-in, and navigates to the signed-in page.
+
-
+
1.1.3. Other use cases and configurations
+A variety of additional use cases and configurations are also possible, including (but not limited to):
+-
+
-
+
A user navigates to example.com on their laptop, is guided through a flow to create and register a credential on their phone.
+ -
+
A user obtains an discrete, roaming authenticator, such as a "fob" with USB or USB+NFC/BLE connectivity options, loads +example.com in their browser on a laptop or phone, and is guided though a flow to create and register a credential on the +fob.
+ -
+
A Relying Party prompts the user for their authorization gesture in order to authorize a single transaction, such as a payment +or other financial transaction.
+
2. Conformance
+This specification defines criteria for a Conforming User Agent: A User Agent MUST behave as described in this +specification in order to be considered conformant. Conforming User Agents MAY implement algorithms given in this +specification in any way desired, so long as the end result is indistinguishable from the result that would be obtained by the +specification’s algorithms. A conforming User Agent MUST also be a conforming implementation of the IDL fragments of this +specification, as described in the “Web IDL” specification. [WebIDL-1]
+This specification also defines a model of a conformant authenticator (see §5 WebAuthn Authenticator model). This is a set of +functional and security requirements for an authenticator to be usable by a Conforming User Agent. As described in §1.1 Use Cases, an authenticator may be implemented in the operating system underlying the User Agent, or in external hardware, +or a combination of both.
+2.1. Dependencies
+This specification relies on several other underlying specifications, listed +below and in Terms defined by reference.
+-
+
- Base64url encoding +
-
+
The term Base64url Encoding refers to the base64 encoding using the URL- and filename-safe character set defined +in Section 5 of [RFC4648], with all trailing '=' characters omitted (as permitted by Section 3.2) and without the +inclusion of any line breaks, whitespace, or other additional characters.
+ - CBOR +
-
+
A number of structures in this specification, including attestation statements and extensions, are encoded using the Compact +Binary Object Representation (CBOR) [RFC7049].
+ - CDDL +
-
+
This specification describes the syntax of all CBOR-encoded data using the CBOR Data Definition Language (CDDL) [CDDL].
+ - DOM +
-
+
+DOMExceptionand the DOMException values used in this specification are defined in [DOM4]. - ECMAScript +
-
+
%ArrayBuffer% is defined in [ECMAScript].
+ - HTML +
-
+
The concepts of relevant settings object, origin, opaque origin, is a registrable domain suffix of or is equal to, and the
+Navigatorinterface are +defined in [HTML52]. - Web Cryptography API +
-
+
The
+AlgorithmIdentifiertype and the method for normalizing an algorithm are defined in Web Cryptography API §algorithm-dictionary. - Web IDL +
-
+
Many of the interface definitions and all of the IDL in this specification depend on [WebIDL-1]. This updated version of +the Web IDL standard adds support for
+Promises, which are now the preferred mechanism for asynchronous +interaction in all new web APIs.
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and +"OPTIONAL" in this document are to be interpreted as described in [RFC2119].
+3. Terminology
+-
+
- Assertion +
- + +
- Attestation +
-
+
Generally, a statement that serves to bear witness, confirm, or authenticate. +In the WebAuthn context, attestation is employed to attest to the provenance of an authenticator and the data it emits; +including, for example: credential IDs, credential key pairs, signature counters, etc. Attestation information is +conveyed in attestation objects. +See also attestation statement format, and attestation type.
+ - Attestation Certificate +
-
+
A X.509 Certificate for the attestation key pair used by an authenticator to attest to its manufacture +and capabilities. At registration time, the authenticator uses the attestation private key to sign +the Relying Party-specific credential public key (and additional data) that it generates and returns via the authenticatorMakeCredential operation. Relying Parties use the attestation public key conveyed in the attestation +certificate to verify the attestation signature. Note that in the case of self attestation, the authenticator has no distinct attestation key pair nor attestation certificate, see self +attestation for details.
+ - Authentication +
-
+
The ceremony where a user, and the user’s computing device(s) (containing at least one authenticator) work in +concert to cryptographically prove to an Relying Party that the user controls the private key associated with a +previously-registered scoped credential (see Registration). Note that this includes employing user +verification.
+ - Authentication Assertion +
-
+
The cryptographically signed
+AuthenticatorAssertionResponseobject returned by an authenticator as the result of a authenticatorGetAssertion operation. - Authenticator +
-
+
A cryptographic device used by a WebAuthn Client to (i) generate a scoped credential and register it with a Relying Party, +and (ii) subsequently used to cryptographically sign and return, in the form of an Authentication Assertion, a +challenge and other data presented by a Relying Party (in concert with the WebAuthn Client) in order to effect authentication.
+ - Authorization Gesture +
-
+
An authorization gesture is a physical interaction performed by a user with an authenticator as part of a ceremony, +such as registration or authentication. By making such an authorization gesture, a user provides +consent for (i.e., authorizes) a ceremony to proceed. This may involve user verification if the +employed authenticator is capable, or it may involve a simple test of user presence.
+ - Biometric Recognition +
-
+
The automated recognition of individuals based on their biological and behavioral characteristics [ISOBiometricVocabulary].
+ - Ceremony +
-
+
The concept of a ceremony [Ceremony] is an extension of the concept of a network protocol, with human nodes alongside +computer nodes and with communication links that include user interface(s), human-to-human communication, and transfers of +physical objects that carry data. What is out-of-band to a protocol is in-band to a ceremony. In this specification, Registration and Authentication are ceremonies, and an authorization gesture is often a component of +those ceremonies.
+ - Client +
- + +
- Conforming User Agent +
-
+
A user agent implementing, in conjunction with the underlying platform, the Web Authentication API and algorithms +given in this specification, and handling communication between authenticators and Relying Parties.
+ - Credential Public Key +
-
+
The public key portion of an Relying Party-specific credential key pair, generated by an authenticator and +returned to an Relying Party at registration time (see also scoped credential). The private key portion of the credential key pair is known as the credential private key. Note that in the case of self +attestation, the credential key pair is also used as the attestation key pair, see self attestation for details.
+ - Registration +
-
+
The ceremony where a user, a Relying Party, and the user’s computing device(s) (containing at least one authenticator) work in concert to create a scoped credential and associate it with the user’s Relying Party account. Note that this includes employing user verification.
+ - Relying Party +
-
+
The entity whose web application utilizes the Web Authentication API to register and authenticate users. See Registration and Authentication, respectively.
+Note: While the term Relying Party is used in other contexts (e.g., X.509 and OAuth), an entity acting as a Relying Party in one context is + not necessarily a Relying Party in other contexts.
+ - Relying Party Identifier
+
- RP ID +
-
+
An identifier for the Relying Party on whose behalf a given registration or authentication ceremony is being performed. Scoped +credentials can only be used for authentication by the same entity (as identified by RP ID) that created and registered +them. By default, the RP ID for a WebAuthn operation is set to the origin specified by the
+WebAuthenticationobject’s relevant settings object. This default can be overridden by the caller subject to certain restrictions, as +specified in §4.1.1 Create a new credential - makeCredential() method and §4.1.2 Use an existing credential - getAssertion() method. - Scoped Credential +
-
+
Generically, a credential is data one entity presents to another in order to authenticate the former’s identity [RFC4949]. +A WebAuthn scoped credential is a
+{ identifier, type }pair identifying authentication +information established by the authenticator and the Relying Party, together, at registration time. The authentication +information consists of an asymmetric key pair, where the public key portion is returned to the Relying Party, which stores it in +conjunction with the present user’s account. The authenticator maps the private key to the Relying Party’s RP ID and stores +it. Subsequently, only that Relying Party, as identified by its RP ID, is able to employ the scoped credential in authentication ceremonies, via thegetAssertion()method. The Relying Party uses its copy of the stored public key to +verify the resultant Authentication Assertion. - Test of User Presence
+
- TUP +
-
+
A test of user presence is a simple form of authorization gesture and technical process where a user interacts with +an authenticator by (typically) simply touching it (other modalities may also exist), yielding a boolean result. Note +that this does not constitute user verification because TUP, by definition, is not capable of biometric +recognition, nor does it involve the presentation of a shared secret such as a password or PIN.
+ - User Consent +
-
+
User consent means the user agrees with what they are being asked, i.e., it encompasses reading and understanding prompts. +An authorization gesture is a ceremony component often employed to indicate user consent.
+ - User Verification +
-
+
The technical process by which an authenticator locally authorizes the invocation of the authenticatorMakeCredential and authenticatorGetAssertion operations. User verification may be instigated +through various authorization gesture modalities; for example, through a touch plus pin code, password entry, or biometric recognition (e.g., presenting a fingerprint) [ISOBiometricVocabulary]. The intent is to be able to +distinguish individual users. Note that invocation of the authenticatorMakeCredential and authenticatorGetAssertion operations implies use of key material managed by the authenticator. Note that for +security, user verification and use of credential private keys must occur within a single logical security boundary +defining the authenticator.
+ - WebAuthn Client +
-
+
Also referred to herein as simply a client. See also Conforming User Agent.
+
4. Web Authentication API
+This section normatively specifies the API for creating and using scoped credentials. The basic +idea is that the credentials belong to the user and are managed by an authenticator, with which the Relying Party interacts through the +client (consisting of the browser and underlying OS platform). Scripts can (with the user’s consent) request the browser to +create a new credential for future use by the Relying Party. Scripts can also request the user’s permission to perform authentication +operations with an existing credential. All such operations are performed in the authenticator and are mediated by the browser +and/or platform on the user’s behalf. At no point does the script get access to the credentials themselves; it only gets +information about the credentials in the form of objects.
+In addition to the above script interface, the authenticator may implement (or come with client software that implements) a user +interface for management. Such an interface may be used, for example, to reset the authenticator to a clean state or to inspect +the current state of the authenticator. In other words, such an interface is similar to the user interfaces provided by browsers +for managing user state such as history, saved passwords and cookies. Authenticator management actions such as credential +deletion are considered to be the responsibility of such a user interface and are deliberately omitted from the API exposed to +scripts.
+The security properties of this API are provided by the client and the authenticator working together. The authenticator, which +holds and manages credentials, ensures that all operations are scoped to a particular origin, and cannot be replayed against +a different origin, by incorporating the origin in its responses. Specifically, as defined in §5.2 Authenticator operations, the full +origin of the requester is included, and signed over, in the attestation object produced when a new credential is created +as well as in all assertions produced by WebAuthn credentials.
+Additionally, to maintain user privacy and prevent malicious Relying Parties from probing for the presence of credentials belonging to +other Relying Parties, each credential is also associated with a Relying Party Identifier, or RP ID. This RP ID is provided by the client +to the authenticator for all operations, and the authenticator ensures that credentials created by a Relying Party can only be used in +operations requested by the same RP ID. Separating the origin from the RP ID in this way allows the API to be used in cases +where a single Relying Party maintains multiple origins.
+The client facilitates these security measures by providing correct origins and RP IDs to the authenticator for each +operation. Since this is an integral part of the WebAuthn security model, user agents MUST only expose this API to callers in secure contexts.
+The Web Authentication API is defined by the union of the Web IDL fragments presented in the following sections. A combined IDL listing is given in the IDL Index. The API is defined as a part of the Navigator interface:
partial interface Navigator { + readonly attribute WebAuthentication authentication; +}; ++
4.1. WebAuthentication Interface
+[SecureContext] +interface WebAuthentication { + Promise<AuthenticatorAttestationResponse> makeCredential(MakeCredentialOptions options); + Promise<AuthenticatorAssertionResponse> getAssertion(AssertionOptions options); +}; ++
This interface has two methods, which are described in the following subsections.
+4.1.1. Create a new credential - makeCredential() method
+AuthenticatorAttestationResponse object describing the newly
+created credential.
+ -
+
- options +
-
+
This parameter specifies how the credential is to be made, as described in §4.4 Options for Credential Creation (dictionary MakeCredentialOptions).
+
When this method is invoked, the user agent MUST execute the following algorithm:
+-
+
-
+
If any of the
+namemember ofoptions.rp, thenamemember ofoptions.user, or theidmember ofoptions.userare not present, return a promise rejected with aTypeErrorsimple exception. -
+
If the
+timeoutmember ofoptionsis 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 thetimeoutmember ofoptionsis not +present, then set adjustedTimeout to a platform-specific default. -
+
Let global be this
+WebAuthenticationobject’s environment settings object’s global object. -
+
Let callerOrigin be the origin specified by this
+WebAuthenticationobject’s relevant settings object. If callerOrigin is an opaque origin, return a promise rejected with aDOMExceptionwhose name is +"NotAllowedError", and terminate this algorithm. -
+
If the
+idmember ofoptions.rpis not present, then set rpId to callerOrigin.Otherwise:
+-
+
-
+
Let effectiveDomain be the callerOrigin’s effective domain.
+ -
+
If effectiveDomain is null, then return a promise rejected with a
+DOMExceptionwhose name is +"SecurityError" and terminate this algorithm. -
+
If
+options.rp.idis not a registrable domain suffix of and is +not equal to effectiveDomain, return a promise rejected with aDOMExceptionwhose name is +"SecurityError", and terminate this algorithm. - + +
-
+
-
+
Let normalizedParameters be a new list whose items are pairs of
+ScopedCredentialTypeand a dictionary type (as returned by normalizing an algorithm). -
+
For each current of
+options.parameters:-
+
-
+
If
+current.does not contain atypeScopedCredentialTypesupported by +this implementation, then continue. -
+
Let normalizedAlgorithm be the result of normalizing an algorithm [WebCryptoAPI], with alg set to
+current.and op set toalgorithm"generateKey". If an error occurs during this procedure, then continue. -
+
Append the pair of
+current.and normalizedAlgorithm to normalizedParameters.type
-
+
-
+
If normalizedParameters is empty and
+options.parametersis not empty, +cancel the timer started in step 2, return a promise rejected with with aDOMExceptionwhose name is +"NotSupportedError", and terminate this algorithm. -
+
Let clientExtensions be a new list.
+ -
+
If the
+extensionsmember ofoptionsis present, then for each extension → argument ofoptions.extensions-
+
-
+
If extension is not supported by this client platform, then continue.
+ -
+
Otherwise, let result be the result of running extension’s client processing algorithm on argument. If the +algorithm returned an error, continue.
+ -
+
Append result to clientExtensions.
+
-
+
-
+
Let collectedclientData be a new
+CollectedClientDatainstance whose fields are:-
+
challenge+-
+
The base64url encoding of
+options.challenge origin+-
+
The unicode serialization of rpId
+ hashAlg+-
+
The recognized algorithm name of the hash algorithm selected by the client for generating the hash of the serialized client data
+ tokenBinding+-
+
The Token Binding ID associated with callerOrigin, if one is available.
+ extensions+-
+
clientExtensions
+
-
+
Let clientDataJSON be the JSON-serialized client data constructed from collectedclientData.
+ -
+
Let clientDataHash be the hash of the serialized client data represented by clientDataJSON.
+ -
+
Let issuedRequests and currentlyAvailableAuthenticators be new ordered sets.
+ -
+
For each authenticator currently available on this platform, if
+options.attachment -
+
For each authenticator in currentlyAvailableAuthenticators:
+-
+
-
+
Let excludeList be a new list.
+ -
+
For each credential C in
+options.excludeList-
+
-
+
If
+C.is not empty, and authenticator is connected over a transport not +mentioned intransportsC., the client MAY continue.transports -
+
Otherwise, Append C to excludeList.
+
-
+
-
+
In parallel, invoke the authenticatorMakeCredential operation on authenticator with rpId, clientDataHash,
+options.rp,options.user, normalizedParameters, excludeList and clientExtensions as parameters. -
+
Append authenticator to issuedRequests.
+
-
+
-
+
Let promise be a new promise. Return promise and 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.
+ -
+
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, +
-
+
-
+
-
+
Remove authenticator from issuedRequests.
+ -
+
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, +
-
+
-
+
-
+
Remove authenticator from issuedRequests.
+ -
+
Let value be a new
+AuthenticatorAttestationResponseobject associated with global whose fields are:-
+
clientDataJSON+-
+
A new
+ArrayBuffer, created using global’s %ArrayBuffer%, containing the bytes of clientDataJSON. attestationObject+-
+
A new
+ArrayBuffer, created using global’s %ArrayBuffer%, containing the bytes of the value returned +from the successful authenticatorMakeCredential operation
-
+
For each remaining authenticator in issuedRequests invoke the authenticatorCancel operation on authenticator and remove it from issuedRequests.
+ -
+
Resolve promise with value and terminate this algorithm.
+
-
+
-
+
Reject promise with a
+DOMExceptionwhose 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.
+4.1.2. Use an existing credential - getAssertion() method
+-
+
- options +
-
+
This dictionary contains the data necessary to generate an assertion, as described in §4.5 Options for Assertion Generation (dictionary AssertionOptions).
+
When this method is invoked, the user agent MUST execute the following algorithm:
+-
+
-
+
If the
+timeoutmember ofoptionsis 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 thetimeoutmember ofoptionsis not present, then set adjustedTimeout to a platform-specific default. -
+
Let global be this
+WebAuthenticationobject’s environment settings object’s global object. -
+
Let callerOrigin be the origin specified by this
+WebAuthenticationobject’s relevant settings object. If callerOrigin is an opaque origin, return a promise rejected with aDOMExceptionwhose name is +"NotAllowedError", and terminate this algorithm. -
+
If the
+rpIdmember ofoptionsis not present, then set rpId to callerOrigin. +Otherwise:-
+
-
+
Let effectiveDomain be the callerOrigin’s effective domain.
+ -
+
If effectiveDomain is null, then return a promise rejected with a
+DOMExceptionwhose name is +"SecurityError" and terminate this algorithm. -
+
If
+rpIdis not a registrable domain suffix of and is not equal to effectiveDomain, return a promise rejected with aDOMExceptionwhose name is "SecurityError", and +terminate this algorithm. -
+
Set rpId to the
+rpId.
-
+
-
+
Let clientExtensions be a new list.
+ -
+
If the
+extensionsmember ofoptionsis present, then for each extension → argument ofoptions.extensions-
+
-
+
If extension is not supported by this client platform, then continue.
+ -
+
Otherwise, let result be the result of running extension’s client processing algorithm on argument. If the +algorithm returned an error, continue.
+ -
+
Append result to clientExtensions.
+
-
+
-
+
Let collectedclientData be a new
+CollectedClientDatainstance whose fields are:-
+
challenge+-
+
The base64url encoding of
+options.challenge origin+-
+
The unicode serialization of rpId
+ hashAlg+-
+
The recognized algorithm name of the hash algorithm selected by the client for generating the hash of the serialized client data
+ tokenBinding+-
+
The Token Binding ID associated with callerOrigin, if one is available.
+ extensions+-
+
clientExtensions
+
-
+
Let clientDataJSON be the JSON-serialized client data constructed from collectedclientData.
+ -
+
Let clientDataHash be the hash of the serialized client data represented by clientDataJSON.
+ -
+
Let issuedRequests be a new ordered set.
+ -
+
For each authenticator currently available on this platform, perform the following steps:
+-
+
-
+
Let credentialList be a new list.
+ -
+
If
+options.allowListoptions.allowListoptions.allowList.idoptions.allowList.type - + +
-
+
In parallel, for each credential C in credentialList:
+-
+
-
+
If
+C.is not empty, the client SHOULD select one transport fromtransportstransports. Then, using transport, invoke the authenticatorGetAssertion operation on authenticator, with rpId, clientDataHash, credentialList, and clientExtensions as parameters. -
+
Otherwise, using local configuration knowledge of the appropriate transport to use with authenticator, invoke the authenticatorGetAssertion operation on authenticator with rpId, clientDataHash, credentialList, and clientExtensions as parameters.
+
-
+
-
+
Append authenticator to issuedRequests.
+
-
+
-
+
Let promise be a new Promise. Return promise and 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.
+ -
+
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, +
-
+
-
+
-
+
Remove authenticator from issuedRequests.
+ -
+
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, +
-
+
-
+
-
+
Remove authenticator from issuedRequests.
+ -
+
Let value be a new
+AuthenticatorAssertionResponseobject associated with global whose fields are:-
+
credential+-
+
A new
+ScopedCredentialobject associated with global whose fields are:-
+
-
+
+typewhose value is theScopedCredentialTyperepresenting this scoped +credential's type. -
+
+idwhose value is a newArrayBuffer, created using global’s %ArrayBuffer%, +containing the bytes of the credential ID returned from the successful authenticatorGetAssertion operation.
-
+
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 returnedauthenticatorData signature+-
+
A new
+ArrayBuffer, created using global’s %ArrayBuffer%, containing the bytes of the returnedsignature
-
+
For each remaining authenticator in issuedRequests invoke the authenticatorCancel operation on authenticator and remove it from issuedRequests.
+ -
+
Resolve promise with value and terminate this algorithm.
+
-
+
-
+
Reject promise with a
+DOMExceptionwhose 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.
+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; +}; ++
-
+
- clientDataJSON, of type ArrayBuffer, readonly +
-
+
This attribute contains a JSON serialization of the client data passed to the +authenticator by the client in its call to either
+makeCredential()orgetAssertion().
4.2.1. Information about Scoped Credential (interface AuthenticatorAttestationResponse)
+The AuthenticatorAttestationResponse interface represents the authenticator's response to a client’s request
+for the creation of a new scoped 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; +}; ++
-
+
clientDataJSON+-
+
This attribute, inherited from
+AuthenticatorResponse, contains the JSON-serialized client data (see §5.3 Credential Attestation) passed to the authenticator by the client in order to generate this credential. The +exact JSON serialization must be preserved, as the hash of the serialized client data has been computed +over it. - attestationObject, of type ArrayBuffer, readonly +
-
+
This attribute contains an attestation object, which is opaque to, and cryptographically protected against +tampering by, the client. The attestation object contains both authenticator data and an attestation +statement. The former contains the AAGUID, a unique credential ID, and the credential public key. The +contents of the attestation statement are determined by the attestation statement format used by the authenticator. It also contains any additional information that the Relying Party’s server requires to validate the +attestation statement, as well as to decode and validate the authenticator data along with the JSON-serialized client data. For more details, see §5.3 Credential Attestation as well as Figure 3.
+
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 ScopedCredential credential; + readonly attribute ArrayBuffer authenticatorData; + readonly attribute ArrayBuffer signature; +}; ++
-
+
clientDataJSON+-
+
This attribute, inherited from
+AuthenticatorResponse, contains the JSON-serialized client data (see §4.7.1 Client data used in WebAuthn signatures (dictionary CollectedClientData)) passed to the authenticator by the client in order to generate this assertion. The +exact JSON serialization must be preserved, as the hash of the serialized client data has been computed +over it. - credential, of type ScopedCredential, readonly +
-
+
This attribute represents the scoped credential that was used to generate this assertion.
+ - authenticatorData, of type ArrayBuffer, readonly +
-
+
This attribute contains the authenticator data returned by the authenticator. See §5.1 Authenticator data.
+ - signature, of type ArrayBuffer, readonly +
-
+
This attribute contains the raw signature returned from the authenticator. See §5.2.2 The authenticatorGetAssertion operation.
+
4.3. Parameters for Credential Generation (dictionary ScopedCredentialParameters)
+dictionary ScopedCredentialParameters { + required ScopedCredentialType type; + required AlgorithmIdentifier algorithm; +}; ++
The type member specifies the type of credential to be created.
+The algorithm member specifies the cryptographic signature algorithm with which the newly generated credential + will be used, and thus also the type of asymmetric key pair to be generated, e.g., RSA or Elliptic Curve.
+4.3.1. 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.5 Credential Transport enumeration (enum ExternalTransport)) to discover and +communicate with cross-platform attached authenticators. 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.4. Options for Credential Creation (dictionary MakeCredentialOptions)
+dictionary MakeCredentialOptions { + required ScopedCredentialEntity rp; + required ScopedCredentialEntity user; + + required BufferSource challenge; + required sequence<ScopedCredentialParameters> parameters; + + unsigned long timeout; + sequence<ScopedCredentialDescriptor> excludeList; + Attachment attachment; + AuthenticationExtensions extensions; +}; ++
-
+
- rp, of type ScopedCredentialEntity +
-
+
This member contains data about the relying party responsible for the request.
+Its value’s
+namemember is required, and contains the friendly name of the relying party +(e.g. "Acme Corporation", "Widgets, Inc.", or "Awesome Site".Its value’s
+idmember specifies the relying party identifier with which the credential +should be associated. If this identifier is not explicitly set, it will default to the ASCII serialization of theWebAuthenticationobject’s relevant settings object's origin. - user, of type ScopedCredentialEntity +
-
+
This member contains data about the user account for which the relying party is requesting attestation.
+Its value’s
+namemember is required, and contains a friendly name for the user account (e.g. +"john.p.smith@example.com", or "John P. Smith").Its value’s
+idmember is required, and contains an identifier for the account, specified by +the relying party. This is not meant to be displayed to the user, but is used by the relying party to control the +number of credentials - an authenticator will never contain more than one credential for a given relying party under the +sameid. - challenge, of type BufferSource +
-
+
This member contains a challenge intended to be used for generating the newly created credential’s attestation object.
+ - parameters, of type sequence<ScopedCredentialParameters> +
-
+
This member contains information about the desired properties of the credential to be created. The sequence is ordered +from most preferred to least preferred. The platform makes a best-effort to create the most preferred credential that it +can.
+ - timeout, of type unsigned long +
-
+
This member specifies a time, in milliseconds, that the caller is willing to wait for the call to complete. This is +treated as a hint, and may be overridden by the platform.
+ - excludeList, of type sequence<ScopedCredentialDescriptor> +
-
+
This member is intended for use by Relying Parties that wish to limit the creation of multiple credentials for the same +account on a single authenticator. The platform is requested to return an error if the new credential would be created +on an authenticator that also contains one of the credentials enumerated in this parameter.
+ - attachment, of type Attachment +
-
+
This member contains authenticator attachment descriptions, which are used as an additional constraint on which +authenticators are eligible to participate in a §4.1.1 Create a new credential - makeCredential() method or §4.1.2 Use an existing credential - getAssertion() method operation. See §4.3.1 Credential Attachment enumeration (enum Attachment) for a description of the attachment values and their meanings.
+ - extensions, of type AuthenticationExtensions +
-
+
This member contains additional parameters requesting additional processing by the client and authenticator. For example, +the caller may request that only authenticators with certain capabilies be used to create the credential, or that +particular information be returned in the attestation object. Some extensions are defined in §8 WebAuthn Extensions; +consult the IANA "WebAuthn Extension Identifier" registry established by [WebAuthn-Registries] for an up-to-date list +of registered WebAuthn Extensions.
+
4.4.1. Entity Description
+The ScopedCredentialEntity dictionary describes a user account or a relying party with which a credential is associated.
dictionary ScopedCredentialEntity { + DOMString id; + DOMString name; + USVString icon; +}; ++
-
+
- id, of type DOMString +
-
+
A unique identifier for the entity. This will be the ASCII serialization of an origin for a relying party, +and an arbitrary string specified by the relying party for user accounts.
+ - name, of type DOMString +
-
+
A human-friendly identifier for the entity. For example, this could be a company name for a relying party, or a +user’s name. This identifier is intended for display.
+ - icon, of type USVString +
-
+
A serialized URL which resolves to an image associated with the entity. For example, this could be +a user’s avatar or a relying party's logo.
+
4.5. Options for Assertion Generation (dictionary AssertionOptions)
+The AssertionOptions dictionary supplies getAssertion() with the data it needs to generate an assertion. Its
+member challenge must be present, while its other members are optional.
dictionary AssertionOptions { + required BufferSource challenge; + unsigned long timeout; + USVString rpId; + sequence<ScopedCredentialDescriptor> allowList = []; + AuthenticationExtensions extensions; +}; ++
-
+
- challenge, of type BufferSource +
-
+
This member represents a challenge that the selected authenticator is expected to sign in order to produce 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 ASCII serialization of the
+WebAuthenticationobject’s relevant +settings object's origin. - allowList, of type sequence<ScopedCredentialDescriptor>, defaulting to
None+ -
+
This optional member contains a list of
+ScopedCredentialDescriptorobject representing scoped 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 line). - 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 Assertion Extensions (dictionary AuthenticationExtensions)
+dictionary AuthenticationExtensions { +}; ++
This is a dictionary containing zero or more extensions as defined in §8 WebAuthn Extensions. An extension is an additional parameter
+that can be passed to the getAssertion() method and triggers some additional processing by the client platform and/or the
+authenticator.
If the caller wishes to pass extensions to the platform, it MUST do so by adding one entry per extension to this dictionary +with the extension identifier as the key, and the extension’s value as the value (see §8 WebAuthn Extensions for details).
+4.7. Supporting Data Structures
+The scoped 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 tokenBinding; + AuthenticationExtensions extensions; +}; ++
The origin member contains the fully qualified origin of the requester, as provided to the authenticator by + the client, in the syntax defined by [RFC6454].
+The hashAlg member is a recognized algorithm name that supports the "digest" operation, which specifies the
+ algorithm used to compute the hash of the serialized client data. This algorithm is chosen by the client at its sole
+ discretion.
The tokenBinding member contains the base64url encoding of the Token Binding ID that this client uses for the Token Binding protocol when communicating with the Relying Party. This can be omitted if no Token Binding has been negotiated + between the client and the Relying Party.
+The optional extensions member contains additional parameters generated by processing the extensions passed in + by the Relying Party. WebAuthn extensions are detailed in Section §8 WebAuthn Extensions.
+This structure is used by the client to compute the following quantities:
+-
+
- JSON-serialized client data +
-
+
This is the UTF-8 encoding of the result of calling the initial value of
+JSON.stringifyon aCollectedClientDatadictionary. - Hash of the serialized client data +
-
+
This is the hash (computed using
+hashAlg) of the JSON-serialized client data, as constructed by the client.
4.7.2. Credential Type enumeration (enum ScopedCredentialType)
+enum ScopedCredentialType { + "ScopedCred" +}; ++
Currently one credential type is defined, namely "ScopedCred".
+4.7.3. Unique Identifier for Credential (interface ScopedCredential)
+[SecureContext] +interface ScopedCredential { + readonly attribute ScopedCredentialType type; + readonly attribute ArrayBuffer id; +}; ++
This interface contains the attributes that are returned to the caller when a new credential is created, and can be used later +by the caller to select a credential for use.
+ScopedCredentialType, indicating the specification and version
+ that this credential conforms to.
+ The id attribute contains an identifier for the credential, chosen by the platform with help from the + authenticator. This identifier is used to look up credentials for use, and is therefore expected to be globally unique with + high probability across all credentials of the same type, across all authenticators. This API does not constrain the format + or length of this identifier, except that it must be sufficient for the platform to uniquely select a key. For example, an + authenticator without on-board storage may create identifiers that consist of the key material wrapped with a key that is + burned into the authenticator.
+4.7.4. Credential Descriptor (dictionary ScopedCredentialDescriptor)
+dictionary ScopedCredentialDescriptor { + required ScopedCredentialType 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 makeCredential() or getAssertion() method. It mirrors the fields of the ScopedCredential object returned by
+these methods.
The id member contains the identifier of the credential that the caller is referring to.
+4.7.5. Credential Transport enumeration (enum ExternalTransport)
+enum Transport { + "usb", + "nfc", + "ble" +}; ++
-
+
- usb - the respective Authenticator may be contacted over USB. +
- nfc - the respective Authenticator may be contacted over Near Field Communication (NFC). +
- ble - the respective Authenticator may be contacted over Bluetooth Smart (Bluetooth Low Energy / BLE). +
4.7.6. 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 scoped credentials. Each scoped credential has an identifier which is unique (or +extremely unlikely to be duplicated) among all scoped 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:
+-
+
-
+
An attestation signature is produced when a new credential is created, and provides cryptographic proof of certain +properties of the credential and the authenticator. For instance, an attestation signature asserts the type of authenticator +(as denoted by its AAGUID) and the public key of the credential. The attestation signature is signed by an attestation key, +which is chosen depending on the type of attestation desired. For more details on attestation, see §5.3 Credential Attestation.
+ -
+
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 which possesses a particular credential private key +has established, to the best of its ability, that the human who is requesting this transaction is the same human who +consented to creating that particular credential. It also provides additional information that might be useful to the +caller, such as the means by which user consent was provided, and the prompt that was shown to the user by the +authenticator.
+
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.
+| Length (in bytes) + | Description + |
|---|---|
| 32 + | SHA-256 hash of the RP ID associated with the credential. + |
| 1 + |
+ Flags (bit 0 is the least significant bit):
+
|
| 4 + | Signature counter (signCount), 32-bit unsigned big-endian integer.
+ |
| variable (if present) + | attestation data (if present). See §5.3.1 Attestation data for details. Its length depends on the length of + the credential public key and credential ID being attested. + |
| variable (if present) + | Extension-defined authenticator data. This is a CBOR [RFC7049] map with extension identifiers as keys, and + extension authenticator data values as values. See §8 WebAuthn Extensions for details. + |
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.
+The TUP flag SHALL be set if and only if the authenticator detected a user through an authenticator specific gesture. The RFU bits in the flags byte 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 in the first byte 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 user account’s
+ScopedCredentialEntity. -
+
The
+ScopedCredentialTypeand cryptographic parameters requested by the Relying Party, with the cryptographic algorithms normalized +as per the procedure in Web Cryptography API §algorithm-normalization-normalize-an-algorithm. -
+
A list of
+ScopedCredentialobjects 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.
+
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
+ScopedCredentialTypeand 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
+ScopedCredentialidentifiers is present on this authenticator. If so, +return an error code equivalent to NotAllowedError 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
+ScopedCredentialTypeand 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.idthat +are stored locally in 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 Credential 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).
+ -
+
Extension data created by the client based on the extensions requested by the Relying Party.
+
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 without attestation data as specified in §5.1 Authenticator 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 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 used to generate the signature.
+ -
+
The authenticator data used to generate the 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. Credential Attestation
+Authenticators must also provide some form of attestation. The basic requirement is that the authenticator can produce, for each +credential public key, attestation information that can be verified by a Relying Party. Typically, this information contains a +signature by an attestation private key over the attested credential public key and a challenge, as well as a certificate or +similar information providing provenance information for the attestation public key, enabling a trust decision to be made. +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 the authenticator any time a new +credential is generated, in the form of an attestation object. The relationship of authenticator data and the attestation data, attestation object, and attestation statement data structures is illustrated in the figure below.
+
+ An important component of the attestation object is the credential attestation statement. This is a specific type of +signed data object, containing statements about a 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 private key associated with the credential). In order to correctly interpret an attestation statement, a Relying Party needs to understand two aspects of the attestation:
+-
+
-
+
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.
+ -
+
The attestation type defines the semantics of the attestation statement and its underlying trust model. 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:
+| Length (in bytes) + | Description + |
|---|---|
| 16 + | The AAGUID of the authenticator. + |
| 2 + | Byte length L of Credential ID + |
| L + | Credential ID + |
| variable + |
+ Credential public key encoded in CBOR format. This is a CBOR map defined by the following CDDL rules:
+ 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"
+
+ Thus, each public key type is a CBOR map starting with an entry named |
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 is defined by the following attributes:
+-
+
- + +
-
+
The set of attestation types supported by the format.
+ -
+
The syntax of an attestation statement produced in this format, defined using CDDL for the extension point
+$attStmtFormatdefined in §5.3.4 Generating an Attestation Object. -
+
The procedure for computing an attestation statement in this format given the credential to be attested, the authenticator data structure containing the authenticator data for the attestation, and the hash of the serialized client data.
+ -
+
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 supported 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 scoped +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 for any attestation statement format.
+In order to construct an attestation object for a given 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") scoped 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 Scoped +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 a makeCredential() or getAssertion() call, the Relying Party’s script receives a AuthenticatorAttestationResponse or AuthenticatorAssertionResponse structure respectively from the client. It must then
+deliver the contents of this structure to the Relying Party, 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 requested to register a new credential, represented by a AuthenticatorAttestationResponse structure, as part of registration
+ceremony, a Relying Party MUST proceed as follows:
-
+
-
+
Perform JSON deserialization on the
+clientDataJSONfield of theAuthenticatorAttestationResponseobject to +extract the client data C claimed to have been used for the credential’s attestation. -
+
Verify that the
+challengein C matches the challenge that was sent to the authenticator in themakeCredential()call. -
+
Verify that the
+originin C matches the Relying Party’s origin. -
+
Verify that the
+tokenBindingin C matches the Token Binding ID for the TLS connection over +which the attestation was obtained. -
+
Verify that the
+extensionsin C is a proper subset of the extensions requested by the RP. -
+
Compute the hash of
+clientDataJSONusing the algorithm identified byC..hashAlg -
+
Perform CBOR decoding on the
+attestationObjectfield of theAuthenticatorAttestationResponsestructure to +obtain the attestation statement format fmt, the authenticator data authData, and the attestation statement attStmt. -
+
Verify that the RP ID hash in authData is indeed the SHA-256 hash of the RP ID expected by the RP.
+ -
+
Determine the attestation statement format by performing an USASCII case-sensitive match on fmt against the set of +WebAuthn Attestation Statement Format Identifier values in the IANA registry of the same name [WebAuthn-Registries].
+ -
+
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.
+ -
+
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.
+ -
+
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.
+
-
+
-
+
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.userpassed tomakeCredential(), 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. -
+
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 Scoped Credential has been generated by a particular Authenticator model. See [FIDOSecRef] and [UAFProtocol] for a more detailed discussion.
+ -
+
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 requested to authenticate a given AuthenticatorAssertionResponse structure as part of an authentication ceremony, the
+Relying Party MUST proceed as follows:
-
+
-
+
Using the
+idattribute contained in thecredentialattribute of the givenAuthenticatorAssertionResponsestructure, look up the corresponding credential public key. -
+
Let cData, aData and sig denote the
+clientDataJSON,authenticatorDataandsignatureattributes of the givenAuthenticatorAssertionResponsestructure, respectively. -
+
Perform JSON deserialization on cData to extract the client data C used for the signature.
+ -
+
Verify that the
+challengemember of C matches the challenge that was sent to the authenticator in thegetAssertion()call. -
+
Verify that the
+originmember of C matches the Relying Party’s origin. -
+
Verify that the
+tokenBindingmember of C (if present) matches the Token Binding ID for the TLS connection +over which the signature was obtained. -
+
Verify that the
+extensionsmember of C is a proper subset of the extensions requested by the RP. -
+
Verify that the RP ID hash in aData is the SHA-256 hash of the RP ID expected by the RP.
+ -
+
Let hash be the result of computing a hash over the cData using the algorithm represented by the
+hashAlgmember of C. -
+
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.
+ -
+
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
+rsaAlgNameandeccAlgNameare 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-ocspand 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
+rsaAlgNameandeccAlgNAmeare 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
+qualifyingDataparameter 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
+parametersanduniquefields 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
+magicis set toTPM_GENERATED_VALUE. -
+
Verify that
+typeis set toTPM_ST_ATTEST_CERTIFY. -
+
Verify that
+extraDatais set to attToBeSigned. -
+
Verify that
+attestedcontains aTPMS_CERTIFY_INFOstructure, whosenamefield contains a valid Name for pubArea, +as computed using the algorithm in thenameAlgfield 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-ocspand 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 a 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
+attestationChallengefield is identical to the concatenation of authenticatorData and clientDataHash. -
+
The
+AuthorizationList.allApplicationsfield is not present, since ScopedCredentials must be bound to the +RP ID. -
+
The value in the
+AuthorizationList.originfield is equal toKM_TAG_GENERATED. -
+
The value in the
+AuthorizationList.purposefield is equal toKM_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
+ctsProfileMatchattribute 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 scoped 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. Extensions can define additions to the following steps and data:
+-
+
-
+
+makeCredential()request parameters for registration extension. -
+
+getAssertion()request parameters for authentication extensions. -
+
Client processing, and the client data, for registration extensions and authentication extensions.
+ -
+
Authenticator processing, and the authenticator data, for registration extensions and authentication extensions.
+
When requesting an assertion for a scoped credential, a Relying Party can list a set of extensions to be used, if they are supported by
+the client and/or the authenticator. It sends the client arguments for each extension in the getAssertion() call (for
+authentication extensions) or makeCredential() call (for registration extensions) to the client platform. The client
+platform performs additional processing for each extension that it supports, and augments the client data as required by the
+extension. In addition, the client collects the authenticator arguments for the above extensions, and passes them to the
+authenticator in the authenticatorMakeCredential call (for registration extensions) or authenticatorGetAssertion call (for authentication extensions). These authenticator arguments are passed as name-value pairs, with the extension
+identifier as the name, and the corresponding authenticator argument as the value. The authenticator, in turn, performs
+additional processing for the extensions that it supports, and augments the authenticator data as specified by the
+extension.
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 argument by simply encoding the client argument 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 argument, 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.
+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, at minimum, an extension identifier and an extension client argument sent via the getAssertion() or makeCredential() call. Additionally, extensions may specify additional values in the client data, authenticator data (in the case of authentication extensions), or both. Finally, if the extension requires any
+authenticator processing, it must also specify an authenticator argument to be sent via the authenticatorGetAssertion or authenticatorMakeCredential call.
Any extension that requires client processing MUST specify a method of augmenting the client data that unambiguously lets +the Relying Party know that the extension was honored by the client. Similarly, any extension that requires authenticator processing MUST +specify a method of augmenting the authenticator data to let the Relying Party know that the extension was honored by the +authenticator.
+8.3. Extending request parameters
+An extension defines up to two request arguments. The client argument is passed from the Relying Party to the client
+in the getAssertion() or makeCredential() call, while the authenticator argument is passed from the client
+to the authenticator during the processing of these calls.
A Relying Party simultaneously requests the use of an extension and sets its client argument by including an entry in the extensions option to the makeCredential() or getAssertion() call. The entry key MUST be the
+extension identifier, and the value MUST be the client argument.
var assertionPromise = credentials.getAssertion(..., /* extensions */ { + "webauthnExample_foobar": 42 +}); ++
Extension definitions MUST specify the valid values for their client argument. Clients SHOULD ignore extensions with an invalid
+client argument. 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 an authenticator argument. Extensions that affect authenticator
+processing MUST specify a method of computing the authenticator argument from the client argument. For extensions that do not
+require additional parameters, and are defined as taking a Boolean client argument set to true, this method SHOULD consist of
+passing an authenticator argument 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. Extending client processing
+Extensions may define additional processing requirements on the client platform during the creation of credentials or the +generation of an assertion. In order for the Relying Party to verify the processing took place, or if the processing has a result +value that the Relying Party needs to be aware of, the extension should specify a key-value pair to be included in the client data.
+The client data value may be any value that can be encoded using JSON. If any extension processed by a client defines such a
+value, the client SHOULD include a dictionary in its client data with the key extensions. For each such
+extension, the client SHOULD add an entry to this dictionary with the extension identifier as the key, and the extension’s client data value.
Extensions that require authenticator processing MUST define the process by which the client argument can be used to determine +the authenticator argument.
+8.5. Extending authenticator processing
+Extensions that define additional authenticator processing may similarly define an authenticator data value. The value may +be any data that can be encoded in CBOR. An authenticator that processes an authentication extension that defines such a +value must include it in the authenticator data.
+As specified in §5.1 Authenticator data, the authenticator data value of each processed extension is included in the +extended data part of the authenticator data. This part is a CBOR map, with extension identifiers as keys, and the authenticator data value of each extension as the value.
+8.6. Example Extension
+This section is not normative.
+To illustrate the requirements above, consider a hypothetical registration extension and authentication extension "Geo". This +extension, if supported, lets both clients and authenticators embed their geolocation in assertions.
+The extension identifier is chosen as webauthnExample_geo. The client argument is the constant value true, since the
+extension does not require the Relying Party to pass any particular information to the client, other than that it requests the use
+of the extension. The Relying Party sets this value in its request for an assertion:
var assertionPromise = + credentials.getAssertion("SGFuIFNvbG8gc2hvdCBmaXJzdC4", + {}, /* Empty filter */ + { 'webauthnExample_geo': true }); ++
The extension defines the additional client data to be the client’s location, if known, as a GeoJSON [GeoJSON] point. The +client constructs the following client data:
+{ + ..., + 'extensions': { + 'webauthnExample_geo': { + 'type': 'Point', + 'coordinates': [65.059962, -13.993041] + } + } +} ++
The extension also requires the client to set the authenticator parameter to the fixed value true.
Finally, the extension requires the authenticator to specify its geolocation in the authenticator data, if known. The +extension e.g. specifies that the location shall be encoded as a two-element array of floating point numbers, encoded with CBOR. +An authenticator does this by including it in the authenticator data. As an example, authenticator data may be as +follows (notation taken from [RFC7049]):
+81 (hex) -- Flags, ED and TUP both set. +20 05 58 1F -- Signature counter +A1 -- CBOR map of one element + 73 -- Key 1: CBOR text string of 19 bytes + 77 65 62 61 75 74 68 6E 45 78 61 + 6D 70 6C 65 5F 67 65 6F -- "webauthnExample_geo" [=UTF-8 encoded=] string + 82 -- Value 1: CBOR array of two elements + FA 42 82 1E B3 -- Element 1: Latitude as CBOR encoded float + FA C1 5F E3 7F -- Element 2: Longitude as CBOR encoded float ++
9. Defined Extensions
+This section defines the initial set of extensions to be registered in the +IANA "WebAuthn Extension Identifier" registry established by [WebAuthn-Registries]. +These are recommended for implementation by user agents targeting broad interoperability.
+9.1. FIDO AppId Extension (appid)
+This authentication extension allows Relying Parties that have previously registered a
+credential using the legacy FIDO JavaScript APIs to request an assertion.
+Specifically, this extension allows Relying Parties to specify an appId [FIDO-APPID] to overwrite the otherwise computed rpId. This extension is only valid if
+used during the getAssertion() call; other usage will result in client
+error.
-
+
- Extension identifier +
-
+
+appid - Client argument +
-
+
A single UTF-8 encoded string specifying a FIDO appId.
+ - Client processing +
-
+
If
+rpIdis present, reject promise with a DOMException +whose name is "NotAllowedError", and terminate this algorithm. +Replace the calculation of rpId in Step 3 of §4.1.2 Use an existing credential - getAssertion() method with the +following procedure: The client uses the value of appid to perform +the AppId validation procedure (as defined by [FIDO-APPID]). If valid, +the value of rpId for all client processing should be replaced by the +value of appid. - Authenticator argument +
-
+
none
+ - Authenticator processing +
-
+
none
+ - Authenticator data +
-
+
none
+
9.2. Simple Transaction Authorization Extension (txAuthSimple)
+This registration extension and authentication extension allows for a simple form of transaction authorization. A Relying Party can specify a +prompt string, intended for display on a trusted device on the authenticator.
+-
+
- Extension identifier +
-
+
+txAuthSimple - Client argument +
-
+
A single UTF-8 encoded string prompt.
+ - Client processing +
-
+
None, except default forwarding of client argument to authenticator argument.
+ - Authenticator argument +
-
+
The client argument encoded as a CBOR text string (major type 3).
+ - Authenticator processing +
-
+
The authenticator MUST display the prompt to the user before performing either user verification or test of user +presence. The authenticator may insert line breaks if needed.
+ - Authenticator data +
-
+
A single UTF-8 encoded string, representing the prompt as displayed (including any eventual line breaks).
+
9.3. Generic Transaction Authorization Extension (txAuthGeneric)
+This registration extension and authentication extension allows images to be used as transaction authorization prompts as well. This +allows authenticators without a font rendering engine to be used and also supports a richer visual appearance.
+-
+
- Extension identifier +
-
+
+txAuthGeneric - Client argument +
-
+
A CBOR map defined as follows:
+txAuthGenericArg = { + contentType: text, ; MIME-Type of the content, e.g. "image/png" + content: bytes + } ++ - Client processing +
-
+
None, except default forwarding of client argument to authenticator argument.
+ - Authenticator argument +
-
+
The client argument encoded as a CBOR map.
+ - Authenticator processing +
-
+
The authenticator MUST display the
+contentto the user before performing either user verification or test of +user presence. The authenticator may add other information below thecontent. No changes are allowed to thecontentitself, i.e., insidecontentboundary box. - Authenticator data +
-
+
The hash value of the
+contentwhich was displayed. The authenticator MUST use the same hash algorithm as it uses for the +signature itself.
9.4. Authenticator Selection Extension (authnSel)
+This registration extension allows a Relying Party to guide the selection of the authenticator that will be leveraged when creating +the credential. It is intended primarily for Relying Parties that wish to tightly control the experience around credential creation.
+-
+
- Extension identifier +
-
+
+authnSel - Client argument +
-
+
A sequence of AAGUIDs:
+typedef sequence<AAGUID> AuthenticatorSelectionList; +
+Each AAGUID corresponds to an authenticator model that is acceptable to the Relying Party for this credential creation. The +list is ordered by decreasing preference.
+An AAGUID is defined as an array containing the globally unique identifier of the authenticator model being sought.
+typedef BufferSource AAGUID; +
+ - Client processing +
-
+
This extension can only be used during
+makeCredential(). If the client supports the Authenticator Selection Extension, it +MUST use the first available authenticator whose AAGUID is present in theAuthenticatorSelectionList. If none of +the available authenticators match a provided AAGUID, the client MUST select an authenticator from among the available +authenticators to generate the credential. - Authenticator argument +
-
+
There is no authenticator argument.
+ - Authenticator processing +
-
+
None.
+
9.5. Supported Extensions Extension (exts)
+This registration extension enables the Relying Party to determine which extensions the authenticator supports.
+-
+
- Extension identifier +
-
+
+exts - Client argument +
-
+
The Boolean value
+trueto indicate that this extension is requested by the Relying Party. - Client processing +
-
+
None, except default forwarding of client argument to authenticator argument.
+ - Authenticator argument +
-
+
The Boolean value
+true, encoded in CBOR (major type 7, value 21). - Authenticator processing +
-
+
The authenticator augments the authenticator data with a list of extensions that the authenticator supports, as +defined below. This extension can be added to attestation objects.
+ - Authenticator data +
-
+
The SupportedExtensions extension is a list (CBOR array) of extension identifiers (UTF-8 encoded strings).
+
9.6. User Verification Index Extension (uvi)
+This registration extension and authentication extension enables use of a user verification index.
+-
+
- Extension identifier +
-
+
+uvi - Client argument +
-
+
The Boolean value
+trueto indicate that this extension is requested by the Relying Party. - Client processing +
-
+
None, except default forwarding of client argument to authenticator argument.
+ - Authenticator argument +
-
+
The Boolean value
+true, encoded in CBOR (major type 7, value 21). - Authenticator processing +
-
+
The authenticator augments the authenticator data with a user verification index indicating the method used by the +user to authorize the operation, as defined below. This extension can be added to attestation objects and assertions.
+ - Authenticator data +
-
+
The user verification index (UVI) is a value uniquely identifying a user verification data record. The UVI is encoded as CBOR +byte string (type 0x58). Each UVI value MUST be specific to the related key (in order to provide unlinkability). It also +must contain sufficient entropy that makes guessing impractical. UVI values MUST NOT be reused by the Authenticator (for +other biometric data or users).
+The UVI data can be used by servers to understand whether an authentication was authorized by the exact same biometric data +as the initial key generation. This allows the detection and prevention of "friendly fraud".
+As an example, the UVI could be computed as SHA256(KeyID | SHA256(rawUVI)), where the rawUVI reflects (a) the biometric +reference data, (b) the related OS level user ID and (c) an identifier which changes whenever a factory reset is performed +for the device, e.g. rawUVI = biometricReferenceData | OSLevelUserID | FactoryResetCounter.
+Servers supporting UVI extensions MUST support a length of up to 32 bytes for the UVI value.
+Example for authenticator data containing one UVI extension
+... -- RP ID hash (32 bytes) +81 -- TUP and ED set +00 00 00 01 -- (initial) signature counter +... -- all public key alg etc. +A1 -- extension: CBOR map of one element + 63 -- Key 1: CBOR text string of 3 bytes + 75 76 69 -- "uvi" [=UTF-8 encoded=] string + 58 20 -- Value 1: CBOR byte string with 0x20 bytes + 00 43 B8 E3 BE 27 95 8C -- the UVI value itself + 28 D5 74 BF 46 8A 85 CF + 46 9A 14 F0 E5 16 69 31 + DA 4B CF FF C1 BB 11 32 + 82 +
+
9.7. Location Extension (loc)
+The location registration extension and authentication extension provides the client device’s current location to the WebAuthn relying +party.
+-
+
- Extension identifier +
-
+
+loc - Client argument +
-
+
The Boolean value
+trueto indicate that this extension is requested by the Relying Party. - Client processing +
-
+
None, except default forwarding of client argument to authenticator argument.
+ - Authenticator argument +
-
+
The Boolean value
+true, encoded in CBOR (major type 7, value 21). - Authenticator processing +
-
+
If the authenticator does not support the extension, then the authenticator MUST ignore the extension request. +If the authenticator accepts the extension, then the authenticator SHOULD only add this extension data to a packed +attestation or assertion.
+ - Authenticator data +
-
+
If the authenticator accepts the extension request, then authenticator data SHOULD provide location data in the form +of a CBOR-encoded map, with the first value being the extension identifier and the second being an array of returned values. +The array elements SHOULD be derived from (key,value) pairings for each location attribute that the authenticator supports. The following is an example of authenticator data where the returned array is comprised of a {longitude, +latitude, altitude} triplet, following the coordinate representation defined in The W3C Geolocation API +Specification.
+... -- RP ID hash (32 bytes) +81 -- TUP and ED set +00 00 00 01 -- (initial) signature counter +... -- all public key alg etc. +A1 -- extension: CBOR map of one element + 63 -- Value 1: CBOR text string of 3 bytes + 6C 6F 63 -- "loc" [=UTF-8 encoded=] string + 86 -- Value 2: array of 6 elements + 68 -- Element 1: CBOR text string of 8 bytes + 6C 61 74 69 74 75 64 65 -- “latitude” [=UTF-8 encoded=] string + FB ... -- Element 2: Latitude as CBOR encoded double-precision float + 69 -- Element 3: CBOR text string of 9 bytes + 6C 6F 6E 67 69 74 75 64 65 -- “longitude” [=UTF-8 encoded=] string + FB ... -- Element 4: Longitude as CBOR encoded double-precision float + 68 -- Element 5: CBOR text string of 8 bytes + 61 6C 74 69 74 75 64 65 -- “altitude” [=UTF-8 encoded=] string + FB ... -- Element 6: Altitude as CBOR encoded double-precision float +
+
9.8. User Verification Mode Extension (uvm)
+This registration extension and authentication extension enables use of a user verification mode.
+-
+
- Extension identifier +
-
+
+uvm - Client argument +
-
+
The Boolean value true to indicate that this extension is requested by the WebAuthn Relying Party.
+ - Client processing +
-
+
None, except default forwarding of client argument to authenticator argument.
+ - Authenticator argument +
-
+
The Boolean value
+true, encoded in CBOR (major type 7, value 21). - Authenticator processing +
-
+
The authenticator augments the authenticator data with a user verification index indicating the method used by the +user to authorize the operation, as defined below. This extension can be added to attestation objects and assertions.
+ - Authenticator data +
-
+
Authenticators can report up to 3 different user verification methods (factors) used in a single authentication instance, +using the CBOR syntax defined below:
+uvmFormat = [ 1*3 uvmEntry ] + uvmEntry = [ + userVerificationMethod: uint .size 4, + keyProtectionType: uint .size 2, + matcherProtectionType: uint .size 2 + ] +
+The semantics of the fields in each
+uvmEntryare as follows:-
+
- userVerificationMethod +
-
+
The authentication method/factor used by the authenticator to verify the user. Available values are defined in [FIDOReg], "User Verification Methods" section.
+ - keyProtectionType +
-
+
The method used by the authenticator to protect the FIDO registration private key material. Available values are defined +in [FIDOReg], "Key Protection Types" section.
+ - matcherProtectionType +
-
+
The method used by the authenticator to protect the matcher that performs user verification. Available values are defined +in [FIDOReg], "Matcher Protection Types" section.
+
If >3 factors can be used in an authentication instance the authenticator vendor must select the 3 factors it believes +will be most relevant to the Server to include in the UVM.
+Example for authenticator data containing one UVM extension for a multi-factor authentication instance where 2 factors were used:
+... -- RP ID hash (32 bytes) +81 -- TUP and ED set +00 00 00 01 -- (initial) signature counter +... -- all public key alg etc. +A1 -- extension: CBOR map of one element + 63 -- Key 1: CBOR text string of 3 bytes + 75 76 6d -- "uvm" [=UTF-8 encoded=] string + 82 -- Value 1: CBOR array of length 2 indicating two factor usage + 83 -- Item 1: CBOR array of length 3 + 02 -- Subitem 1: CBOR integer for User Verification Method Fingerprint + 04 -- Subitem 2: CBOR short for Key Protection Type TEE + 02 -- Subitem 3: CBOR short for Matcher Protection Type TEE + 83 -- Item 2: CBOR array of length 3 + 04 -- Subitem 1: CBOR integer for User Verification Method Passcode + 01 -- Subitem 2: CBOR short for Key Protection Type Software + 01 -- Subitem 3: CBOR short for Matcher Protection Type Software +
+
10. IANA Considerations
+10.1. WebAuthn Attestation Statement Format Identifier Registrations
+This section registers the attestation statement formats defined in Section §7 Defined Attestation Statement Formats in the +IANA "WebAuthn Attestation Statement Format Identifier" registry established by [WebAuthn-Registries].
+-
+
-
+
WebAuthn Attestation Statement Format Identifier: packed
+ -
+
Description: The "packed" attestation statement format is a WebAuthn-optimized format for attestation data. It uses a very +compact but still extensible encoding method. This format is implementable by authenticators with limited resources (e.g., +secure elements).
+ -
+
Specification Document: Section §7.2 Packed Attestation Statement Format of this specification
+ -
+
WebAuthn Attestation Statement Format Identifier: tpm
+ -
+
Description: The TPM attestation statement format returns an attestation statement in the same format as the packed +attestation statement format, although the the rawData and signature fields are computed differently.
+ -
+
Specification Document: Section §7.3 TPM Attestation Statement Format of this specification
+ -
+
WebAuthn Attestation Statement Format Identifier: android-key
+ -
+
Description: Platform-provided authenticators based on Android versions "N", and later, may provide this proprietary "hardware +attestation" statement.
+ -
+
Specification Document: Section §7.4 Android Key Attestation Statement Format of this specification
+ -
+
WebAuthn Attestation Statement Format Identifier: android-safetynet
+ -
+
Description: Android-based, platform-provided authenticators may produce an attestation statement based on the Android +SafetyNet API.
+ -
+
Specification Document: Section §7.5 Android SafetyNet Attestation Statement Format of this specification
+ -
+
WebAuthn Attestation Statement Format Identifier: fido-u2f
+ -
+
Description: Used with FIDO U2F authenticators
+ -
+
Specification Document: Section §7.6 FIDO U2F Attestation Statement Format of this specification
+
10.2. WebAuthn Extension Identifier Registrations
+This section registers the extension identifiers defined in Section §8 WebAuthn Extensions in the +IANA "WebAuthn Extension Identifier" registry established by [WebAuthn-Registries].
+-
+
-
+
WebAuthn Extension Identifier: appid
+ -
+
Description: This authentication extension allows Relying Parties that have previously registered a credential using the legacy FIDO +JavaScript APIs to request an assertion.
+ -
+
Specification Document: Section §9.1 FIDO AppId Extension (appid) of this specification
+ -
+
WebAuthn Extension Identifier: txAuthSimple
+ -
+
Description: This registration extension and authentication extension allows for a simple form of transaction authorization. A +WebAuthn Relying Party can specify a prompt string, intended for display on a trusted device on the authenticator
+ -
+
Specification Document: Section §9.2 Simple Transaction Authorization Extension (txAuthSimple) of this specification
+ -
+
WebAuthn Extension Identifier: txAuthGeneric
+ -
+
Description: This registration extension and authentication extension allows images to be used as transaction authorization prompts +as well. This allows authenticators without a font rendering engine to be used and also supports a richer visual appearance +than accomplished with the webauthn.txauth.simple extension.
+ -
+
Specification Document: Section §9.3 Generic Transaction Authorization Extension (txAuthGeneric) of this specification
+ -
+
WebAuthn Extension Identifier: authnSel
+ -
+
Description: This registration extension allows a WebAuthn Relying Party to guide the selection of the authenticator that +will be leveraged when creating the credential. It is intended primarily for WebAuthn Relying Parties that wish to tightly +control the experience around credential creation.
+ -
+
Specification Document: Section §9.4 Authenticator Selection Extension (authnSel) of this specification
+ -
+
WebAuthn Extension Identifier: exts
+ -
+
Description: This registration extension enables the Relying Party to determine which extensions the authenticator supports. The +extension data is a list (CBOR array) of extension identifiers encoded as UTF-8 Strings. This extension is added +automatically by the authenticator. This extension can be added to attestation statements.
+ -
+
Specification Document: Section §9.5 Supported Extensions Extension (exts) of this specification
+ -
+
WebAuthn Extension Identifier: uvi
+ -
+
Description: This registration extension and authentication extension enables use of a user verification index. The user +verification index is a value uniquely identifying a user verification data record. The UVI data can be used by servers to +understand whether an authentication was authorized by the exact same biometric data as the initial key generation. This +allows the detection and prevention of "friendly fraud".
+ -
+
Specification Document: Section §9.6 User Verification Index Extension (uvi) of this specification
+ -
+
WebAuthn Extension Identifier: loc
+ -
+
Description: The location registration extension and authentication extension provides the client device’s current location to the +WebAuthn relying party, if supported by the client device and subject to user consent.
+ -
+
Specification Document: Section §9.7 Location Extension (loc) of this specification
+ -
+
WebAuthn Extension Identifier: uvm
+ -
+
Description: This registration extension and authentication extension enables use of a user verification mode. The user verification +mode extension returns to the Webauthn relying party which user verification methods (factors) were used for the WebAuthn +operation.
+ -
+
Specification Document: Section §9.8 User Verification Mode Extension (uvm) of this specification
+
11. Sample scenarios
+This section is not normative.
+In this section, we walk through some events in the lifecycle of a scoped credential, along with the corresponding sample code +for using this API. Note that this is an example flow, and does not limit the scope of how the API can be used.
+As was the case in earlier sections, this flow focuses on a use case involving an external first-factor authenticator with its own display. One example of such an authenticator would be a smart phone. Other authenticator types are also supported +by this API, subject to implementation by the platform. For instance, this flow also works without modification for the case of +an authenticator that is embedded in the client platform. The flow also works for the case of an authenticator without +its own display (similar to a smart card) subject to specific implementation considerations. Specifically, the client platform +needs to display any prompts that would otherwise be shown by the authenticator, and the authenticator needs to allow the client +platform to enumerate all the authenticator’s credentials so that the client can have information to show appropriate prompts.
+11.1. Registration
+This is the first-time flow, in which a new credential is created and registered with the server.
+-
+
-
+
The user visits example.com, which serves up a script. At this point, the user must already be logged in using a legacy +username and password, or additional authenticator, or other means acceptable to the Relying Party.
+ -
+
The Relying Party script runs the code snippet below.
+ -
+
The client platform searches for and locates the authenticator.
+ -
+
The client platform connects to the authenticator, performing any pairing actions if necessary.
+ -
+
The authenticator shows appropriate UI for the user to select the authenticator on which the new credential will be +created, and obtains a biometric or other authorization gesture from the user.
+ -
+
The authenticator returns a response to the client platform, which in turn returns a response to the Relying Party script. If +the user declined to select an authenticator or provide authorization, an appropriate error is returned.
+ -
+
If a new credential was created,
+-
+
-
+
The Relying Party script sends the newly generated credential public key to the server, along with additional information +such as attestation regarding the provenance and characteristics of the authenticator.
+ -
+
The server stores the credential public key in its database and associates it with the user as well as with the +characteristics of authentication indicated by attestation, also storing a friendly name for later use.
+ -
+
The script may store data such as the credential ID in local storage, to improve future UX by narrowing the choice of +credential for the user.
+
-
+
The sample code for generating and registering a new key follows:
+var webauthnAPI = navigator.authentication; + +if (!webauthnAPI) { /* Platform not capable. Handle error. */ } + +var userAccountInformation = { + rpDisplayName: "Acme", + displayName: "John P. Smith", + name: "johnpsmith@example.com", + id: "1098237235409872", + imageURL: "https://pics.acme.com/00/p/aBjjjpqPb.png" +}; + +// This Relying Party will accept either an ES256 or RS256 credential, but +// prefers an ES256 credential. +var cryptoParams = [ + { + type: "ScopedCred", + algorithm: "ES256" + }, + { + type: "ScopedCred", + algorithm: "RS256" + } +]; + +var challenge = new TextEncoder().encode("climb a mountain"); +var options = { timeout: 60000, // 1 minute + excludeList: [], // No excludeList + extensions: {"webauthn.location": true} // Include location information + // in attestation +}; + +// Note: The following call will cause the authenticator to display UI. +webauthnAPI.makeCredential(userAccountInformation, cryptoParams, challenge, options) + .then(function (newCredentialInfo) { + // Send new credential info to server for verification and registration. +}).catch(function (err) { + // No acceptable authenticator or user refused consent. Handle appropriately. +}); ++
11.2. Authentication
+This is the flow when a user with an already registered credential visits a website and wants to authenticate using the +credential.
+-
+
-
+
The user visits example.com, which serves up a script.
+ -
+
The script asks the client platform for an Authentication Assertion, providing as much information as possible to narrow +the choice of acceptable credentials for the user. This may be obtained from the data that was stored locally after +registration, or by other means such as prompting the user for a username.
+ -
+
The Relying Party script runs one of the code snippets below.
+ -
+
The client platform searches for and locates the authenticator.
+ -
+
The client platform connects to the authenticator, performing any pairing actions if necessary.
+ -
+
The authenticator presents the user with a notification that their attention is required. On opening the +notification, the user is shown a friendly selection menu of acceptable credentials using the account information provided +when creating the credentials, along with some information on the origin that is requesting these keys.
+ -
+
The authenticator obtains a biometric or other authorization gesture from the user.
+ -
+
The authenticator returns a response to the client platform, which in turn returns a response to the Relying Party script. +If the user declined to select a credential or provide an authorization, an appropriate error is returned.
+ -
+
If an assertion was successfully generated and returned,
+-
+
-
+
The script sends the assertion to the server.
+ -
+
The server examines the assertion, extracts the credential ID, looks up the registered +credential public key it is database, and verifies the assertion’s authentication signature. +If valid, it looks up the identity associated with the assertion’s credential ID; that +identity is now authenticated. If the credential ID is not recognized by the server (e.g., +it has been deregistered due to inactivity) then the authentication has failed; each Relying Party +will handle this in its own way.
+ -
+
The server now does whatever it would otherwise do upon successful authentication -- return a success page, set +authentication cookies, etc.
+
-
+
If the Relying Party script does not have any hints available (e.g., from locally stored data) to help it narrow the list of credentials, +then the sample code for performing such an authentication might look like this:
+var webauthnAPI = navigator.authentication; + +if (!webauthnAPI) { /* Platform not capable. Handle error. */ } + +var options = { + challenge: new TextEncoder().encode("climb a mountain"), + timeout: 60000, // 1 minute + allowList: [{ type: "ScopedCred" }] + }; + +webauthnAPI.getAssertion(options) + .then(function (assertion) { + // Send assertion to server for verification +}).catch(function (err) { + // No acceptable credential or user refused consent. Handle appropriately. +}); ++
On the other hand, if the Relying Party script has some hints to help it narrow the list of credentials, then the sample code for +performing such an authentication might look like the following. Note that this sample also demonstrates how to use the +extension for transaction authorization.
+var webauthnAPI = navigator.authentication; + +if (!webauthnAPI) { /* Platform not capable. Handle error. */ } + +var encoder = new TextEncoder(); +var acceptableCredential1 = { + type: "ScopedCred", + id: encoder.encode("!!!!!!!hi there!!!!!!!\n") +}; +var acceptableCredential2 = { + type: "ScopedCred", + id: encoder.encode("roses are red, violets are blue\n") +}; + +var options = { + challenge: encoder.encode("climb a mountain"), + timeout: 60000, // 1 minute + allowList: [acceptableCredential1, acceptableCredential2]; + extensions: { 'webauthn.txauth.simple': + "Wave your hands in the air like you just don’t care" }; + }; + +webauthnAPI.getAssertion(challenge, options) + .then(function (assertion) { + // Send assertion to server for verification +}).catch(function (err) { + // No acceptable credential or user refused consent. Handle appropriately. +}); ++
11.3. Decommissioning
+The following are possible situations in which decommissioning a credential might be desired. Note that all of these are +handled on the server side and do not need support from the API specified here.
+-
+
-
+
Possibility #1 -- user reports the credential as lost.
+-
+
-
+
User goes to server.example.net, authenticates and follows a link to report a lost/stolen device.
+ -
+
Server returns a page showing the list of registered credentials with friendly names as configured during registration.
+ -
+
User selects a credential and the server deletes it from its database.
+ -
+
In future, the Relying Party script does not specify this credential in any list of acceptable credentials, and assertions +signed by this credential are rejected.
+
-
+
-
+
Possibility #2 -- server deregisters the credential due to inactivity.
+-
+
-
+
Server deletes credential from its database during maintenance activity.
+ -
+
In the future, the Relying Party script does not specify this credential in any list of acceptable credentials, and assertions +signed by this credential are rejected.
+
-
+
-
+
Possibility #3 -- user deletes the credential from the device.
+-
+
-
+
User employs a device-specific method (e.g., device settings UI) to delete a credential from their device.
+ -
+
From this point on, this credential will not appear in any selection prompts, and no assertions can be generated with it.
+ -
+
Sometime later, the server deregisters this credential due to inactivity.
+
-
+