FIDO 2.0: Web API for accessing FIDO 2.0 credentials

partial interface Window { 
    readonly attribute FIDOCredentials fido; 
}; 
   
interface FIDOCredentials { 
    Promise < FIDOCredentialInfo > makeCredential ( 
        Account                               accountInformation, 
        sequence < FIDOCredentialParameters > cryptoParameters, 
        DOMString                             attestationChallenge,
        optional unsigned long                credentialTimeoutSeconds,
        optional sequence < Credential >      blacklist,
        optional FIDOExtensions               credentialExtensions#dom-fidocredentials-makecredential-accountinformation-cryptoparameters-attestationchallenge-credentialtimeoutseconds-blacklist-credentialextensions-credentialextensionsReferenced in:7.3. Extending request parameters
    ); 
   
    Promise < FIDOAssertion > getAssertion ( 
        DOMString                        assertionChallenge,
        optional unsigned long           assertionTimeoutSeconds,
        optional sequence < Credential > whitelist, 
        optional FIDOExtensions          assertionExtensions#dom-fidocredentials-getassertion-assertionchallenge-assertiontimeoutseconds-whitelist-assertionextensions-assertionextensionsReferenced in:7.3. Extending request parameters 
    ); 
}; 
   
interface FIDOCredentialInfo { 
    readonly attribute Credential           credential; 
    readonly attribute AlgorithmIdentifier  algorithm; 
    readonly attribute any                  publicKey; 
    readonly attribute AttestationStatement attestation; 
}; 

dictionary Account { 
    required DOMString rpDisplayName; 
    required DOMString displayName; 
    DOMString          name; 
    DOMString          id; 
    DOMString          imageUri; 
};
   
dictionary FIDOCredentialParameters { 
    required CredentialType        type; 
    required AlgorithmIdentifier   algorithm; 
}; 

enum CredentialType { 
    "FIDO" 
}; 

interface Credential { 
    readonly attribute CredentialType type; 
    readonly attribute DOMString      id; 
};
  
dictionary FIDOExtensions#dictdef-fidoextensionsReferenced in:4. FIDO Credential API (2) {
};

This interface represents a newly-created FIDO credential. It contains information about the credential that can be used to locate it later for use, and also contains metadata that can be used by the FIDO Relying Party to assess the strength of the credential during registration.

The credential attribute contains a unique identifier for the credential represented by this object.

The algorithm attribute contains the cryptographic algorithm associated with the credential, in the format defined in [WebCryptoAPI].

The publicKey attribute contains the public key associated with the credential, represented as a JsonWebKey structure as defined in [WebCryptoAPI].

The attestation attribute contains a key attestation statement returned by the authenticator. This provides information about the credential and the authenticator it is held in, such as the level of security assurance provided by the authenticator.

This dictionary is used by the caller to specify information about the user account and Relying Party with which a credential is to be associated. It is intended to help the authenticator in providing a friendly credential selection interface for the user.

The rpDisplayName member contains the friendly name of the Relying Party, such as "Google", "Microsoft" or "PayPal".

The displayName member contains the friendly name associated with the user account by the Relying Party, such as "John P. Smith".

The name member contains a detailed name for the account, such as "john.p.smith@example.com".

The id member contains an identifier for the account, stored for the use of the Relying Party. This is not meant to be displayed to the user.

The imageUri member contains a URI that resolves to the user’s account image. This may be a URL that can be used to retrieve the user’s current avatar, or a data URI that contains the image data.

This dictionary is used to supply additional parameters when creating a new credential.

The type member specifies the type of credential to be created.

The algorithm member specifies the cryptographic algorithm with which the newly generated credential will be used.

This enumeration defines the valid credential types. It is an extension point; values may be added to it in the future, as more credential types are defined. The values of this enumeration are used for versioning the FIDO assertion and attestation statement according to the type of the authenticator.

Currently one credential type is defined, namely "FIDO", the FIDO 2.0 credential type.

The type attribute indicates 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. 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.

dictionary ClientData#dictdef-clientdataReferenced in:5.1. Client data (2)6.4.3.4. AndroidAttestationClientData7. FIDO Extensions (2)7.2. Defining extensions (2)7.3. Extending request parameters7.4. Extending client processing (2) {
  DOMString       challenge;
  DOMString       facet;
  JsonWebKey      tokenBinding;
  object          extensions#dom-clientdata-extensionsReferenced in:7.4. Extending client processing; // optional
  DOMString       hashAlg#dom-clientdata-hashalgReferenced in:5.1. Client data (2);
};

DOMString challenge

A base64url-encoded challenge provided by the RP.

DOMString facet

A string value describing the RP identifier facet. When the RP client-side app is a website, this is its fully qualified web origin, using the syntax defined by [RFC6454]. When the client-side app is a native application, this string is a platform specific identifier.

JsonWebKey tokenBinding

A JsonWebKey object [JWK] describing the public key 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.

optional object extensions

An object with extension-provided authenticator data. Signature extensions are detailed in Section §7 FIDO Extensions.

DOMString hashAlg

The hash algorithm used to compute clientDataHash (see §5.3 Generating a signature). Use "S256" for SHA-256, "S384" for SHA384, "S512" for SHA512, and "SM3" for SM3 (see §9 IANA Considerations).

interface FIDOAssertion#fidoassertionReferenced in:4. FIDO Credential API4.1.2. Use an existing credential (getAssertion() method)4.5.4. FIDO Assertion (interface FIDOAssertion) {
  attribute Credential credential;
  attribute DOMString  clientData;
  attribute DOMString  authenticatorData#dom-fidoassertion-authenticatordataReferenced in:5.4. Client encoding of assertions;
  attribute DOMString  signature;
};

attribute Credential credential

An object representing which credential was used to generate an assertion.

attribute DOMString clientData

A base64url encoding of clientDataJSON. (See §5.1 Client data)

attribute DOMString authenticatorData

A base64url encoding of authenticatorData. (See §5.2 Authenticator data)

attribute DOMString signature

A base64url encoding of the raw signature returned from the authenticator. (See §5.3 Generating a signature)

This assertion is delivered to the RP in either a platform specific manner, or in the case of web applications, according to the FIDO Web API (§4 FIDO Credential API). It contains all the information that the RP’s FIDO server requires to reconstruct the signature base string, as well as to decode and validate the bindings of both the client- and authenticator data.

6. Key Attestation Format

This specification defines generic data structures that cover the semantics of FIDO Authenticator attestation. This specification also provides a profile of these structures when a TPM [TPM] acts as a crypto kernel. More profiles are expected to be added as the specification evolves.

6.1. Overview

6.1.1. Attestation Models

FIDO 2.0 specifies multiple attestation models:

Full Basic Attestation

In the case of full basic attestation [UAFProtocol], the Authenticator’s attestation private key is specific to an Authenticator model. That means that an Authenticator of the same model typically shares the same attestation private key.

This model is also used for FIDO UAF 1.0 and FIDO U2F 1.0.

Surrogate Basic Attestation

In the case of surrogate basic attestation [UAFProtocol], the Authenticator doesn’t have any specific attestation key. Instead it uses the authentication key to (self-)sign the (surrogate) attestation message. Authenticators without meaningful protection measures for an attestation private key typically use this attestation model.

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 FIDO credential individually.

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

Direct Anonymous Attestation (DAA)

In this case, the Authenticator receives 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.

FIDO 2.0 supports DAA using elliptic curve cryptography and bilinear pairings, called ECDAA (see [FIDOEcdaaAlgorithm]) in this specification.

Compliant FIDO Servers MUST support all attestation models. Authenticators can choose what attestation model to implement.

Relying parties can always decide what attestation models are acceptable by policy.

6.1.2. Contextual Data

FIDO 2.0 attestation statements 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 components can be divided into three layers:

1. The relying party (RP) consists of two subcomponents: an online service and a client-side application. The client-side app may, for example, be a web application running in a browser, or a native application that runs directly on the OS platform.
2. The client platform, which consists of the user’s OS and device used to host the RP’s client-side app. For web applications, the browser also belongs to this layer.
3. The authenticator itself, which provides key generation and key management and cryptographic signatures.

The goals of this design can be summarized as follows.

• The scheme for generating keys and attestation statements 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 existing encoding formats as much as possible to aid adoption and implementation.

There are two kinds of contextual bindings: Those added by the RP or the client platform, referred to as client data (see §5 Signature Format) and those added by the authenticator, referred to as the attestation data. The client data must be signed over, but an authenticator is otherwise not interested in its contents. More specifically, the authenticator cannot attest to the correctness of such data. To save bandwidth and processing requirements on the authenticator, the client platform hashes the client data and sends only the hash result to the authenticator. The authenticator attestation statement includes the combination of this hash, and its own attestation data.

6.1.3. Attestation Raw Data Types

FIDO specifies pluggable attestation raw data types, i.e., ways to serialize the data being attested to by the authenticator. The reason is to be able to support existing devices like TPMs and other platform-specific formats.

Each attestation type provides the ability to cryptographically attest to a public key, the authenticator model, and contextual data to a remote party.

Attestation raw data types are orthogonal to attestation models, i.e. attestation raw data types in general are not restricted to a single attestation model.

6.2. Attestation Statement

When an attestation statement is required for an Authenticator, the client needs to ask the Authenticator to generate one. This section describes the attestation statement data structures. Attestation statements can also include some host and other Authenticator information.

The attestation statement consists of

1. the header object, containing the signing algorithm and additional information required to verify the attestation signature.
2. the core object, containing the attested data. This object is a container and can carry multiple, authenticator model specific, attestation rawData types (see section §6.4 Defined Attestation Raw Data Types).
3. the signature object. This object contains the cryptographic signature computed over the rawData object. The structure of this object depends on the signature algorithm.

6.3. Client encoding of attestation statements

The client platform uses an authenticator generated attestation signature (signature) and the authenticator generated rawData object to construct the final attestation statement object (which will be returned to the RP). This attestation statement is encoded as:

interface AttestationStatement#fidoassertion-attestationstatementReferenced in:4. FIDO Credential API {
    readonly    attribute AttestationHeader header;
    readonly    attribute AttestationCore   core;
    readonly    attribute DOMString         signature;
};

readonly attribute AttestationHeader header

Attestation header, including algorithm, (optionally) the claimed AAGUID and (optionally) the attestation certificate chain.

readonly attribute AttestationCore core

AttestationCore object. This object includes the attested rawData and its type and version.

readonly attribute DOMString signature

The base64url-encoded attestation signature. The structure of this object depends on the signature algorithm specified in the header.

This attestation statement is delivered to the RP according to the Client API. It contains all the information that the RP’s FIDO server requires to reconstruct the signature base string, as well as to decode and validate the bindings of both the client- and authenticator data.

6.3.1. AttestationCore

Data attested by the Authenticator and description of its structure. Different types of Authenticators might generate different object types (identified by type and version).

interface AttestationCore#fidoassertion-attestationcoreReferenced in:6.3. Client encoding of attestation statements {
    readonly    attribute DOMString     type;
    readonly    attribute unsigned long version;
    readonly    attribute DOMString     rawData;
    readonly    attribute DOMString     clientData;
};  

readonly attribute DOMString type

The type of the rawData object. This specification defines these attestation raw data types: "tpm", "packed", and "android". Other attestation raw data types may be defined in further versions of this specification.

readonly attribute unsigned long version

The version number of the rawData object.

readonly attribute DOMString rawData

The rawData object (for type "android"), or the base64url-encoded rawData object (for types "tpm" and "packed"), containing the attested public key and the clientDataHash.

readonly attribute DOMString clientData

A base64url encoding of clientDataJSON (see §5 Signature Format). The exact encoding must be preserved as the hash (clientDataHash) has been computed over it.

6.3.1.1. Client data

The client platform SHALL deliver, through the EAP API, the clientDataHash (see §5 Signature Format) to the authenticator. The client platform MUST also preserve the exact encodedClientData string (see §5 Signature Format), for embedding in a signature object sent back to the RP. This is necessary since multiple JSON encodings of the same client data are possible.

6.3.2. AttestationHeader

Additional data required to verify the attestation signature.

interface AttestationHeader#fidoassertion-attestationheaderReferenced in:6.3. Client encoding of attestation statements {
    readonly    attribute DOMString   claimedAAGUID;
    readonly    attribute DOMString[] x5c;
    readonly    attribute DOMString   alg;
};

readonly attribute DOMString claimedAAGUID

The claimed Authenticator Attestation GUID (a version 4 GUID, see [RFC4122]). This value is used by the FIDO Server to lookup the trust anchor for verifying this AttestationCore object. If the verification succeeds, the AAGUID related to the trust anchor is trusted. This field MUST be present, if either no attestation certificates are used (e.g., DAA) or if the attestation certificate doesn’t contain the AAGUID value in an extension.

readonly attribute DOMString[] x5c

Attestation Certificate and its certificate chain as described in [RFC7515] section 4.1.6.

readonly attribute DOMString alg

The name of the algorithm used to generate the attestation signature according to [RFC7518].

See §6.4.1.3 Signature for the signature algorithms to be implemented by FIDO Servers.

6.4. Defined Attestation Raw Data Types

Attestation Raw Data (rawData) is the to-be-signed object of the attestation statement. FIDO supports pluggable attestation data types. This allows support of TPM generated attestation data as well as support of other FIDO authenticators.

The contents of the attestation data must be controlled (i.e., generated or at least verified) by the authenticator itself.

6.4.1. Packed Attestation

Packed attestation is a FIDO optimized format of attestation data. It uses a very compact but still extensible encoding method. Encoding this format can even be implemented by authenticators with very limited resources (e.g., secure elements).

6.4.1.1. Attestation rawData (type="packed")

The attestation data encodes contextual bindings made by the authenticator itself. Unlike client data, 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.

For this type, only version="1" is defined at this time.

The field rawData is the base64url encoding of the byte array. The encoding of attestation data (for type "packed") is a byte array of 45 bytes + length of public key + length of KeyHandle + potentially more extensions. The first bytes before the extensions have a fixed layout as follows:

Length (in bytes)	Description
2	0xF1D0, fixed big-endian TAG to make sure this object won’t be confused with other (non-FIDO) binary objects.
1	Flags (bit 0 is the least significant bit): Bit 0: Test of User Presence (TUP) result. Bits 1-6: Reserved for future use (RFU). Bit 7: Extension data included (ED). Indicates whether the authenticator added extensions (see below).
4	Signature counter (signCount), 32-bit unsigned big-endian integer.
2	Public key algorithm and encoding (16-bit big-endian value). Allowed values are: 0x0100. This is raw ANSI X9.62 formatted Elliptic Curve public key [SEC1]. I.e., [0x04, X (n bytes), Y (n bytes)]. Where the byte 0x04 denotes the uncompressed point compression method and n denotes the key length in bytes. 0x0102. Raw encoded RSA PKCS1 or RSASSA-PSS public key [RFC3447]. In the case of RSASSA-PSS, the default parameters according to [RFC4055] MUST be assumed, i.e., Mask Generation Algorithm MGF1 with SHA256 Salt Length of 32 bytes, i.e., the length of a SHA256 hash value. Trailer Field value of 1, which represents the trailer field with hexadecimal value 0xBC. That is, [modulus (256 bytes), e (m-n bytes)]. Where m is the total length of the field. This total length should be taken from the object containing this key
2	Byte length m of following public key bytes (16 bit value with most significant byte first).
(length)	The public key (m bytes) according to the encoding denoted before.
2	Byte length l of KeyHandle
(length)	KeyHandle (l bytes)
2	Byte length n of clientDataHash
n	clientDataHash (see §6.3.1.1 Client data). This is the hash of clientData. The hash algorithm itself is stored in the clientData object §5 Signature Format.
As defined by the extension map	Extension-defined authenticator data. This is a CBOR [RFC7049] map with extension identifiers as keys, and extension authenticator data values as values. See §7 FIDO Extensions for a description of the extension mechanism. See §6.4.1.2 Extensions for Packed Attestation rawData for pre-defined extensions.

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 cleared (i.e., zeroed).

If the authenticator does not wish to add extensions, it MUST clear the ED flag in the third byte.

6.4.1.2. Extensions for Packed Attestation rawData

6.4.1.2.1. AAGUID Extension

Extension identifier

fido.aaguid

Client argument

N/A

Client processing

N/A

Authenticator argument

N/A

Authenticator processing

This extension is added automatically by the authenticator. This extension can be added to attestation statements and signatures.

Authenticator data

A 128-bit Authenticator Attestation GUID encoded as a CBOR text string (major type 3).

This AAGUID is used to identify the Authenticator model (Authenticator Attestation GUID).

The authenticator model (identified by the AAGUID) can be derived from (a) here, or (b) from the attestation certificate (if we have an authenticator specific or authenticator model specific attestation certificate), or (c) or from the claimed AAGUID in the client encoded attestation statement (if we have one attestation root certificate per authenticator model).

In the case of DAA there is no need for an X.509 attestation certificate hierarchy. Instead the trust anchor being known to the RP is the DAA root key (i.e. ECPoint2 X, Y). This root key must be dedicated to a single authenticator model.

6.4.1.2.2. SupportedExtensions Extension

Extension identifier

fido.exts

Client argument

N/A

Client processing

N/A

Authenticator argument

N/A

Authenticator processing

This extension is added automatically by the authenticator. This extension can be added to attestation statements.

Authenticator data

The SupportedExtension extension is a list (CBOR array) of extension identifiers encoded as UTF-8 Strings.

6.4.1.2.3. User Verification Index (UVI) Extension

Extension identifier

fido.uvi

Client argument

N/A

Client processing

N/A

Authenticator argument

N/A

Authenticator processing

This extension is added automatically by the authenticator. This extension can be added to attestation statements and signatures.

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 FIDO 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.

FIDO Servers supporting UVI extensions MUST support a length of up to 32 bytes for the UVI value.

Example for rawData containing one UVI extension

F1 D0                         -- This is a FIDO packed rawData object
81                            -- TUP and ED set
00 00 00 01                   -- (initial) signature counter
...                           -- all public key alg etc.
A1                            -- extension: CBOR map of one element
  68                          -- Key 1: CBOR text string of 8 bytes
    66 69 64 6F 2E 75 76 69   -- "fido.uvi" UTF-8 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

6.4.1.3. Signature

The signature is computed over the base64url-decoded rawData field.

The following algorithms must be implemented by FIDO Servers:

1. "ES256" [RFC7518]
2. "RS256" [RFC7518]
3. "PS256" [RFC7518]
4. "ED256" [FIDOEcdaaAlgorithm]

Authenticators can choose which algorithm to implement.

6.4.1.4. Packed attestation statement certificate requirements

In the case of DAA attestation [FIDOEcdaaAlgorithm] no attestation certificate is used.

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 following extension MUST be present:

  Extension OID 1 3 6 1 4 1 45724 1 1 4 (id-fido-gen-ce-aaguid) containing the AAGUID as value.

• The Basic Constraints extension MUST have the cA component set to false
• An Authority Information Access (AIA) extension with entry id-ad-ocsp and a CRL Distribution Point extension [RFC5280] are both optional as the status of attestation certificates is available through the FIDO Metadata Service [FIDOMetadataService].

6.4.2. TPM Attestation

6.4.2.1. Attestation rawData (type="tpm")

The value of rawData is the base64url encoding of a binary object. This binary object is either a TPM_CERTIFY_INFO or a TPM_CERTIFY_INFO2 structure [TPMv1-2-Part2] sections 11.1 and 11.2, if attestationStatement.core.version equals 1. Else, if attestationStatement.core.version equals 2, it MUST be the base64url encoding of a TPMS_ATTEST structure as defined in [TPMv2-Part2] sections 10.12.9.

The field "extraData" (in the case of TPMS_ATTEST) or the field "data" (in the case of TPM_CERTIFY_INFO or TPM_CERTIFY_INFO2) MUST contain the clientDataHash (see [[#signature-format]).

6.4.2.2. Signature

If attestationStatement.core.version equals 1, (i.e., for TPM 1.2), RSASSA-PKCS1-v1_5 signature algorithm (section 8.2 of [RFC3447]) can be used by FIDO Authenticators (i.e. attestationStatement.header.alg="RS256").

If attestationStatement.core.version equals 2, the following algorithms can be used by FIDO Authenticators:

1. TPM_ALG_RSASSA (0x14). This is the same algorithm RSASSA-PKCS1-v1_5 as for version 1 but for use with TPMv2. attestationStatement.header.alg="RS256".
2. TPM_ALG_RSAPSS (0x16); attestationStatement.header.alg="PS256".
3. TPM_ALG_ECDSA (0x18); attestationStatement.header.alg="ES256".
4. TPM_ALG_ECDAA (0x1A); attestationStatement.header.alg="ED256".
5. TPM_ALG_SM2 (0x1B); attestationStatement.header.alg="SM256".

The signature is computed over the base64url-decoded rawData field

See §6.4.1.3 Signature for the signature algorithms to be implemented by FIDO Servers.

6.4.2.3. 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 if "version" equals 2 and [TPMv1-2-Credential-Profiles] section 3.2.9 if "version" equals 1.
• The Extended Key Usage extension MUST contain the "joint-iso-itu-t(2) internationalorganizations(23) 133 tcg-kp(8) tcg-kp-AIKCertificate(3)" OID.
• The Basic Constraints extension MUST have the CA component set to false
• An Authority Information Access (AIA) extension with entry id-ad-ocsp and a CRL Distribution Point extension [RFC5280] are both optional as the status of attestation certificates is available through the FIDO Metadata Service [FIDOMetadataService].

6.4.3. Android Attestation

When the Authenticator in question is a platform-provided Authenticator on the Android platform, the attestation statement is based on the SafetyNet API.

Android attestation statement MUST always be used in conjunction with the more specific AndroidAttestationClientData (see §6.4.3.4 AndroidAttestationClientData) in order to let the RP App store the public key in the attestation object.

6.4.3.1. Attestation rawData (type="android")

Android SafetyNet returns a JWS [RFC7515] object (see SafetyNet online documentation) in Compact Serialization. A JWS in Compact Serialization consists of three segments (each a base64url-encoded string) separated by a dot ("."). The rawData object is the concatenation of:

1. the first segment (a base64url encoding of the UTF-8 encoded JWS Protected Header)
2. a dot "."
3. the second segment (a base64url encoding of the UTF-8 encoded JWS Payload).

In contrast to the "packed" and "tpm" attestation types, for the "android" attestation type, the rawData field and the rawData object are the same string. (In the "packed" and "tpm" attestation types the rawData field is the base64url-encoding of the rawData object.)

6.4.3.2. Signature

The signature is directly computed over the rawData field, as defined above (see [RFC7515] for more details). The third segment of the JWS returned by SafetyNet is the base64url encoding of this signature, and also becomes the AttestationStatement.signature.

6.4.3.3. Converting SafetyNet response to attestationStatement

The Authenticator and/or platform SHOULD use the steps outlined below to create an attestationStatement from an Android SafetyNet response. It MAY use a different algorithm, as long as the results are the same.

1. create clientDataJSON with type AndroidAttestationClientData (see below) and compute clientData as base64url-encoded clientDataJSON.
2. provide the clientDataHash computed as the hash value of clientData as Nonce value when requesting the SafetyNet attestation.
3. take SafetyNet response snr. This is a JWS object ([RFC7515]).
4. extract the base64url-encoded Protected Header hdr from snr (see [RFC7515])
5. extract the base64url-encoded payload p from snr
6. extract the base64url-encoded signature s from snr
7. set AttestationStatement.core.rawData = hdr | "." | p
8. set AttestationStatement.signature = s
9. base64url-decode hdr into hdr-d
10. set AttestationStatement.header.alg = hdr-d.alg
11. if hdr-d.x5c is present, then set AttestationStatement.header.x5c = hdr-d.x5c
12. if hdr-d.x5u is present, then resolve the URL and add the retrieved certificate chain to AttestationStatement.header.x5c
13. set AttestationStatement.core.type = "android"
14. set AttestationStatement.core.version to the version number of Google Play Services responsible for providing the SafetyNet API

6.4.3.4. AndroidAttestationClientData

The ClientData dictionary is extended in the following way:

dictionary AndroidAttestationClientData : ClientData {
             JsonWebKey             publicKey;
             boolean                isInsideSecureHardware;
             DOMString              userAuthentication;
             unsigned long userAuthenticationValidityDurationSeconds; // optional
};  

JsonWebKey publicKey

The public key generated by the Authenticator, as a JsonWebKey object (see [WebCryptoAPI]).

boolean isInsideSecureHardware

true if the key resides inside secure hardware (e.g., Trusted Execution Environment (TEE) or Secure Element (SE)).

DOMString userAuthentication

One of "none", "keyguard", or "fingerprint". none means that the user has not enrolled a fingerprint, or set up a secure lock screen, and that therefore the key has not been linked to user authentication. keyguard means that the generated key only be used after the user unlocks a secure lock screen. fingerprint means that each operation involving the generated key must be individually authorized by the user by presenting a fingerprint.

optional unsigned long userAuthenticationValidityDurationSeconds

If the userAuthentication is set to "keyguard", then this parameter specifies the duration of time (seconds) for which this key is authorized to be used after the user is successfully authenticated.

6.4.3.5. Verifying AndroidClientData specific contextual bindings

A relying party shall verify the clientData contextual bindings (see step 4 in §6.5 Verifying an Attestation Statement) as follows:

• Check that AndroidAttestationClientData.challenge equals the attestationChallenge that was passed into the makeCredential() call.
• Check that the facet and tokenBinding parameters in the AndroidAttestationClientData match the RP App.
• Check that AndroidAttestationClientData.publicKey is the same key as the one returned in the FIDOCredentialInfo by the makeCredential call.
• Check that the hash of the clientDataJSON matches the nonce attribute in the payload of the safetynetResponse JWS.
• Check that the ctsProfileMatch attribute in the payload of the safetynetResponse is true.
• Check that the apkPackageName attribute in the payload of the safetynetResponse matches package name of the application calling SafetyNet API.
• Check that the apkDigestSha256 attribute in the payload of the safetynetResponse matches the package hash of the application calling SafetyNet API.
• Check that the apkCertificateDigestSha256 attribute in the payload of the safetynetResponse matches the hash of the signing certificate of the application calling SafetyNet API.

6.5. Verifying an Attestation Statement

This section outlines the recommended algorithm for verifying an attestation statement, independent of attestation type.

Upon receiving an attestation statement, the relying party shall:

1. Verify that the attestation statement is properly formatted
2. If attestationSignature.alg is not ECDAA (e.g., not "ED256" and not "ED512"):
   1. Lookup the attestation root certificate from a trusted source. The FIDO Metadata Service [FIDOMetadataService] provides an easy way to access such information. The header.claimedAAGUID can be used for this lookup.
   2. Verify that the attestation certificate chain is valid and chains up to a trusted root (following [RFC5280]).
   3. Verify that the attestation certificate has the right Extended Key Usage (EKU) based on the FIDO Authenticator type (as denoted by the header.type member). In case of a type="tpm", this EKU shall be OID "2.23.133.8.3".
   4. If the attestation type is "android", verify that the attestation certificate is issued to the hostname "attest.android.com" (see SafetyNet online documentation).
   5. Verify that all issuing CA certificates in the chain are valid and not revoked.
   6. Verify the signature on core.rawData using the attestation certificate public key and algorithm as identified by header.alg.
   7. Verify core.rawData syntax and that it doesn’t contradict the signing algorithm specified in header.alg.
   8. If the attestation certificate 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 header.claimedAAGUID. This identifies the Authenticator model.
   9. If such extension doesn’t exist, the attestation root certificate is dedicated to a single Authenticator model.
3. If attestationSignature.alg is ECDAA (e.g., "ED256", "ED512"):
   1. Lookup the DAA root key from a trusted source. The FIDO Metadata Service [FIDOMetadataService] provides an easy way to access such information. The header.claimedAAGUID can be used for this lookup.
   2. Perform DAA-Verify on signature for core.rawData (see [FIDOEcdaaAlgorithm]).
   3. Verify core.rawData syntax and that it doesn’t contradict the signing algorithm specified in header.alg.
   4. The DAA root key is dedicated to a single Authenticator model.
4. Verify the contextual bindings (e.g., channel binding) from the clientData (see §6.3.1.1 Client data).
5. Verify that user verification method and other authenticator characteristics related to this authenticator model, match the relying party policy. The FIDO Metadata Service [FIDOMetadataService] provides an easy way to access the authenticator characteristics.

The relying party MAY take any of the below actions when verification of an attestation statement fails:

• Reject the request, such as a registration request, associated with the attestation statement.
• Accept the request associated with the attestation statement but treat the attested FIDO Credential as one with surrogate basic attestation (see §6.1.1 Attestation Models), if policy allows it. If doing so, there is no cryptographic proof that the FIDO Credential has been generated by a particular Authenticator model. See [FIDOSecRef] and [UAFProtocol] for more details on the relevance on attestation.

Verification of attestation statements requires that the relying party trusts the root of the attestation certificate chain. Also, 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 didn’t provide this chain in the attestation information.

6.6. Security Considerations

6.6.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 FIDO Authenticator manufacturer may choose to ship all of their devices with the same (or a fixed number of) attestation key(s) (called Full Basic Attestation). This will anonymize the user at the risk of not being able to revoke a particular attestation key should its FIDO Authenticator be compromised.
• A FIDO Authenticator may be capable of dynamically generating different attestation keys (and requesting related certificates) per origin (following the Privacy CA model). For example, a FIDO 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 FIDO Authenticator can implement 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 DAA root key, but the attestation signature doesn’t serve as a global correlation handle.

6.6.2. Attestation Certificate and Attestation Certificate CA Compromise

When an intermediate CA or a root CA used for issuing attestation certificates is compromised, FIDO Authenticator attestation keys are still safe although their certificates can no longer be trusted. A FIDO 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 FIDO Authenticator attestation certificate must be revoked by the issuing CA if its key has been compromised. A FIDO Authenticator manufacturer may need to ship a firmware update and inject new attestation keys and certificates into already manufactured FIDO Authenticators, if the exposure was due to a firmware flaw. (The process by which this happens is out of scope for this specification.) No further valid attestation statements can be made by the affected FIDO Authenticators unless the FIDO Authenticator manufacturer has this capability.

If attestation certificate validation fails due to a revoked intermediate attestation CA certificate, and relying party policy requires rejecting the registration/authentication request in these situations, then it is recommended that the relying party also un-registers (or marks as "surrogate attestation" (see §6.1.1 Attestation Models), policy permitting) FIDO credentials that were registered post 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 FIDO Credentials if the registration was performed after revocation of such certificates.

If a DAA attestation key has been compromised, it can be added to the RogueList (i.e., the list of revoked authenticators) maintained by the related DAA-Issuer. The relying party should verify whether an authenticator belongs to the RogueList when performing DAA-Verify. The FIDO Metadata Service [FIDOMetadataService] provides an easy way to access such information.

6.6.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 FIDO 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 FIDO Authenticator device line (i.e., AAGUID), the AAGUID must be specified either in the attestation certificate itself or as an extension in the core.rawData.

7. FIDO Extensions

The mechanism for generating FIDO 2.0 credentials, as well as requesting and generating FIDO 2.0 assertions, as defined in §4 FIDO Credential API, can be extended to suit particular use cases. Each case is addressed by defining a registration extension and/or a signature extension. Extensions can define additions to the following steps and data:

• makeCredential() request parameters (see §4 FIDO Credential API) for registration extension.
• getAssertion() request parameters (see §4 FIDO Credential API) for signature extensions.
• Client processing, and the ClientData structure, for registration extensions and signature extensions.
• Authenticator processing, and the authenticatorData structure, for signature extensions.

When requesting an assertion for a FIDO 2.0 credential, an RP can list a set of extensions to be used, if they are supported by the client and/or the authenticator. It sends the request parameters for each extension in the getAssertion() call (for signature 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 ClientData as required by the extension. For extensions that the client platform does not support, it passes the request parameters on to the authenticator when possible (criteria defined below). This allows one to define extensions that affect the authenticator only.

Similarly, the authenticator performs additional processing for the extensions that it supports, and augments authenticatorData as specified by the extension.

Extensions that are not supported are ignored.

7.1. Extension identifiers

Extensions are identified by a string, chosen by the extension author. Extension identifiers should aim to be globally unique, e.g., by using reverse domain-name of the defining entity such as com.example.fido.myextension.

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.

Standard extensions defined by FIDO in this specification use a fixed prefix of fido. for the extension identifiers. This prefix should not be used for 3rd party extensions.

7.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 (see below). Additionally, extensions may specify additional values in ClientData, authenticatorData (in the case of signature extensions), or both.

An extension that does not define additions to ClientData nor authenticatorData is possible, but should be avoided. In such cases, the relying party would have no indication if the extension was supported or processed by the client and/or authenticator.

7.3. Extending request parameters

An extension defines two request arguments. The client argument#fidoassertion-client-argumentReferenced in:7.3. Extending request parameters is passed from the RP 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.

Extension definitions MUST specify the valid values for their client argument. Clients are free to ignore extensions with an invalid client argument. Specifying an authenticator argument is optional, since some extensions may only affect client processing.

An RP simultaneously requests the use of an extension and sets its client argument by including an entry in the credentialExtensions or assertionExtensions dictionary parameters 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 */ {
  "com.example.fido.foobar": 42
});

Extensions that affect the behavior of the client platform can define their argument to be any set of values that can be encoded in JSON. Such an extension will in general (but not always) specify additional values to the ClientData structure (see below). It may also specify an authenticator argument that platforms implementing the extension are expected to send to the authenticator. The authenticator argument should be a byte string.

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.

Extensions that do not need to pass any particular argument value, must still define a client argument. It is recommended that the argument be defined as the constant value true in this case.

For extensions that specify additional authenticator processing only, it is desirable that the platform need not know the extension. To support this, platforms SHOULD pass the client argument of unknown extension as the authenticator argument unchanged, under the same extension identifier. The authenticator argument should be the CBOR encoding of the client argument, as specified in Section 4.2 of [RFC7049]. Clients SHOULD silently drop unknown extensions whose client argument cannot be encoded as a CBOR structure.

7.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 RP to verify the processing took place, or if the processing has a result value that the RP needs to be aware of, the extension should specify a client data value to be included in the ClientData structure.

The value may be any value that can be encoded as a JSON value. If any extension processed by a client defines such a value, the client SHOULD include a dictionary in ClientData 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.

7.5. Extending authenticator processing with signature extensions

Signature extensions that define additional authenticator processing should similarly define an authenticator data value. The value may be any data that can be encoded as a CBOR value. An authenticator that processes a signature extension that defines such a value must include it in the authenticatorData.

As specified in §5.2 Authenticator data, the authenticator data value of each processed extension is included in the extended data part of the authenticatorData. This part is a CBOR map, with extension identifiers as keys, and the authenticator data value of each extension as the value.

7.6. Example extension

This section is non-normative.

To illustrate the requirements above, consider a hypothetical extension Geo. This extension, if supported, lets both clients and authenticators embed their geolocation in signatures.

The extension identifier is chosen as com.example.fido.geo. The client argument is the constant value true, since the extension does not require the RP to pass any particular information to the client, other than that it requests the use of the extension. The RP sets this value in its request for an assertion:

var assertionPromise =
    credentials.getAssertion("SGFuIFNvbG8gc2hvdCBmaXJzdC4",
        {}, /* Empty filter */
        { 'com.example.fido.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': {
       'com.example.fido.geo': {
           'type': 'Point',
           'coordinates': [65.059962, -13.993041]
       }
   }
}

The extension also requires the client to set the authenticator parameter to the fixed value 1.

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 authenticatorData. 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
  68                          -- Key 1: CBOR text string of 8 bytes
    66 69 64 6F 2E 67 65 6F   -- "fido.geo" UTF-8 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

8. Standard Extensions

This section defines standard extensions defined by the FIDO Alliance.

8.1. Transaction authorization

This signature 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

fido.txauth.simple

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 the user verification / test of user presence. The authenticator may insert line breaks if needed.

Authenticator data

A single UTF-8 string, representing the prompt as displayed (including any eventual line breaks).

The generic version of this extension allows images to be used as prints as well. This is allows authenticators without a font rendering engine to be used and also supports a richer visual appearance.

Extension identifier

fido.txauth.generic

Client argument

A CBOR map with one pair of data items (CBOR tagged as 0xa1). The pair of data items consists of

1. one UTF-8 encoded string contentType, containing the MIME-Type of the content, e.g. "image/png"
2. and the content#fidoassertion-contentReferenced in:8.1. Transaction authorization (2) (3) (4) (5) itself, encoded as CBOR byte array.

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 content to the user before performing the user verification / test of user presence. The authenticator may add other information below the content. No changes are allowed to the content itself, i.e. inside content boundary box.

Authenticator data

The hash value of the content which was displayed. The authenticator MUST use the same hash algorithm as it uses for the signature itself.

8.2. Authenticator Selection Extension

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

fido.authn-sel (only used during makeCredential())

Client argument

A sequence of AAGUIDs:

typedef sequence < AAGUID > AuthenticatorSelectionList#typedefdef-fidoassertion-authenticatorselectionlistReferenced in:8.2. Authenticator Selection Extension;

Each AAGUID corresponds to an authenticator attestation that is acceptable to the RP for this credential creation. The list is ordered by decreasing preference.

An AAGUID is defined as a DOMString, and is the globally unique identifier of the authenticator attestation being sought.

typedef DOMString AAGUID#typedefdef-fidoassertion-aaguidReferenced in:8.2. Authenticator Selection Extension;

Client processing

If the client supports the Authenticator Selection Extension, it MUST use the first available authenticator whose AAGUID is present in the AuthenticatorSelectionList. 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. IANA Considerations

This specification registers the algorithm names "S256", "S384", "S512", and "SM3" with the IANA JSON Web Algorithms registry as defined in section "Cryptographic Algorithms for Digital Signatures and MACs" in [RFC7518].

These names follow the naming strategy in draft-ietf-oauth-spop-15.

Algorithm Name	"S256"
Algorithm Description	The SHA256 hash algorithm.
Algorithm Usage Location(s)	"alg", i.e. used with JWS.
JOSE Implementation Requirements	Optional+
Change Controller	FIDO Alliance, Contact Us
Specification Documents	[FIPS-180-4]
Algorithm Analysis Document(s)	[SP800-107r1]

Algorithm Name	"S384"
Algorithm Description	The SHA384 hash algorithm.
Algorithm Usage Location(s)	"alg", i.e. used with JWS.
JOSE Implementation Requirements	Optional
Change Controller	FIDO Alliance, Contact Us
Specification Documents	[FIPS-180-4]
Algorithm Analysis Document(s)	[SP800-107r1]

Algorithm Name	"S512"
Algorithm Description	The SHA512 hash algorithm.
Algorithm Usage Location(s)	"alg", i.e. used with JWS.
JOSE Implementation Requirements	Optional+
Change Controller	FIDO Alliance, Contact Us
Specification Documents	[FIPS-180-4]
Algorithm Analysis Document(s)	[SP800-107r1]

Algorithm Name	"SM3"
Algorithm Description	The SM3 hash algorithm.
Algorithm Usage Location(s)	"alg", i.e. used with JWS.
JOSE Implementation Requirements	Optional
Change Controller	FIDO Alliance, Contact Us
Specification Documents	[OSCCA-SM3]
Algorithm Analysis Document(s)	N/A

10. Sample scenarios

This section is not normative.

In this section, we walk through some events in the lifecycle of a FIDO 2.0 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 external 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.

10.1. Registration

This is the first time flow, when a new credential is created and registered with the server.

1. 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.
2. The Relying Party script runs the code snippet below.
3. The client platform searches for and locates the external authenticator.
4. The client platform connects to the external authenticator, performing any pairing actions if necessary.
5. The external 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.
6. The external authenticator returns a response to the client platform, which in turn returns a response to the RP script. If the user declined to select an authenticator or provide authorization, an appropriate error is returned.
7. If a new credential was created,
   1. The RP script sends the newly generated public key to the server, along with additional information about public key such as attestation that it is held in trusted hardware.
   2. The server stores the public key in its database and associates it with the user as well as with the strength of authentication indicated by attestation, also storing a friendly name for later use.
   3. 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 fidoAPI = window.fido;

if (!fidoAPI) { /* Platform not capable. Handle error. */ }

var userAccountInformation = {
  rpDisplayName: "PayPal",
  displayName: "John P. Smith",
  name: "johnpsmith@gmail.com",
  id: "1098237235409872";
  imageUri: "https://pics.paypal.com/00/p/aBjjjpqPb.png"
};

// This RP will accept either an ES256 or RS256 credential, but 
// prefers an ES256 credential.
var cryptoParams = [
  { 
    type: "FIDO",
    algorithm: "ES256",
  },
  {
    type: "FIDO",
    algorithm: "RS256",
  }
];
var challenge = "Y2xpbWIgYSBtb3VudGFpbg";
var timeoutSeconds = 300;  // 5 minutes
var blacklist = [];  // No blacklist
var extensions = {"fido.location": true};  // Include location information 
                                           // in attestation


// Note: The following call will cause the authenticator to display UI.
fidoAPI.makeCredential(userAccountInformation, cryptoParams, challenge,
                       timeoutSeconds, blacklist, extensions)
  .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.
});

10.2. Authentication

This is the flow when a user with an already registered credential visits a website and wants to authenticate using the credential.

1. The user visits example.com, which serves up a script.
2. The script asks the client platform for a FIDO identity 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.
3. The Relying Party script runs one of the code snippets below.
4. The client platform searches for and locates the external authenticator.
5. The client platform connects to the external authenticator, performing any pairing actions if necessary.
6. The external 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.
7. The authenticator obtains a biometric or other authorization gesture from the user.
8. The external authenticator returns a response to the client platform, which in turn returns a response to the RP script. If the user declined to select a credential or provide an authorization, an appropriate error is returned.
9. If an assertion was successfully generated and returned,
   1. The script sends the assertion to the server.
   2. The server examines the assertion and validates that it was correctly generated. If so, it looks up the identity associated with the associated public key; that identity is now authenticated. If the public key is not recognized by the server (e.g., deregistered by server due to inactivity) then the authentication has failed; each Relying Party will handle this in its own way.
   3. 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 fidoAPI = window.fido;

if (!fidoAPI) { /* Platform not capable. Handle error. */ }

var challenge = "Y2xpbWIgYSBtb3VudGFpbg";
var timeoutSeconds = 300;  // 5 minutes
var whitelist = [{ type: "FIDO" }];

fidoAPI.getAssertion(challenge, timeoutSeconds, whitelist)
  .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 fidoAPI = window.fido;

if (!fidoAPI) { /* Platform not capable. Handle error. */ }

var challenge = "Y2xpbWIgYSBtb3VudGFpbg";
var timeoutSeconds = 300;  // 5 minutes
var acceptableCredential1 = {
  type: "FIDO",
  id: "ISEhISEhIWhpIHRoZXJlISEhISEhIQo=",
};
var acceptableCredential2 = {
  type: "FIDO",
  id: "cm9zZXMgYXJlIHJlZCwgdmlvbGV0cyBhcmUgYmx1ZQo=",
};
var whitelist = [acceptableCredential1, acceptableCredential2];
var extensions = { 'fido.txauth.simple': 
                   "Wave your hands in the air like you just don’t care" };
            
fidoAPI.getAssertion(challenge, timeoutSeconds, whitelist, extensions)
  .then(function (assertion) {
    // Send assertion to server for verification
}).catch(function (err) {
    // No acceptable credential or user refused consent. Handle appropriately.
});

10.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, 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.

11. Acknowledgements

We would like to thank the following for their contributions to, and thorough review of, this specification: Jing Jin, Michael B. Jones, Rolf Lindemann.