# Authentication levels

The ACR / AAL assurance model and the mapping of each authentication factor to its assurance level.

When a user signs in, the platform records *how strongly* their identity was proven and expresses it as an assurance level. Policies and applications can then require a minimum level before granting access. This page explains the two terms you will see — **AAL** and **ACR** — and how individual factors map onto them.

## AAL — Authenticator Assurance Level

**AAL** is the strength of the authentication, following the NIST SP 800-63B model. The platform offers seven assurance levels in the policy picker, from an email-only sign-in up to hardware-protected multi-factor:

| Level | ACR value | Meaning | Typical use |
|---|---|---|---|
| **AAL0 (passwordless email)** | `urn:nist:800-63:aal0` | A single **weak** possession factor: a one-time code or sign-in link sent to the user's verified email address. The lowest level in the model and **below AAL1**: a mailbox is not an accepted authenticator under NIST SP 800-63B, so **no NIST assurance level is claimed**. | A consumer sign-in in a directory using [email code login](https://dts-identity.com/docs/directories/user-directories.md#email-code-login), where convenience outweighs assurance. |
| **AAL1** | `urn:nist:800-63:aal1` | A single full first factor: a password, or a login through an external identity provider. Some assurance, but vulnerable to phishing and guessing. Requiring this level asks for a password specifically — a second factor cannot stand in for one, so a user signed in with an email code is asked for their password. | Sign-in where a real credential is required, while weaker methods are not enough. |
| **AAL1+ (enhanced)** | `urn:nist:800-63:aal1:mfa` | A single factor strengthened by a weak second channel. Slightly stronger than AAL1, but not true MFA. | Password plus an email one-time code. |
| **AAL2 (conditional)** | `urn:nist:800-63:aal2:ifenrolled` | Multi-factor *only if the user has a factor enrolled*. Otherwise no second factor is asked for, and the sign-in keeps the level of its first factor — AAL1 for a password, AAL0 for an email code. The default for normal application sign-in. | Password plus a second factor when one exists; password, or an email code, alone while none is enrolled yet. |
| **AAL2** | `urn:nist:800-63:aal2` | Multi-factor: a password plus a possession factor, always required. Phishing-resistant when a cryptographic factor is used. | Password plus TOTP, SMS, or a security key / passkey. |
| **AAL2+ (phishing-resistant)** | `urn:nist:800-63:aal2:phr` | Multi-factor where the possession factor cryptographically verifies the sign-in origin, with user verification. Currently satisfied only by FIDO2 / WebAuthn. | A passkey with biometric or PIN verification. |
| **AAL3** | `urn:nist:800-63:aal3` | Phishing-resistant, **hardware-protected** authentication: a hardware-bound key whose private key cannot be exported, with user verification. | A hardware security key whose make and model is attestation-verified. |

**AAL0 never satisfies a higher requirement.** An application or policy asking for AAL1 or above is not met by an email-only sign-in, so the user is challenged for another factor, and because a password is not in play, only a passkey can close that gap. The Admin Console requires multi-factor authentication and is therefore never reachable at AAL0.

The **AAL2 (conditional)** level lets you raise everyone toward MFA without locking out users who have not yet enrolled a factor: the second factor is demanded only when the user has one, otherwise the login settles at AAL1.

> **Note:** The level a session reaches is decided by the *combination* of factors used, not merely by how many categories they fall into. A factor combination only reaches a level if it matches one of that level's accepted combinations.

## ACR — Authentication Context Class Reference

**ACR** is the value the platform uses to *name* an assurance level in policies and tokens. Where AAL is the concept, ACR is the identifier that travels with a request or a session:

- An **authentication policy** or an **application** can request a minimum ACR. If the user's current session does not meet it, the platform prompts for a stronger or additional factor (step-up).
- After authentication, the platform resolves the **highest ACR** the session's factors satisfy and records it. OIDC tokens carry this value so downstream applications can make their own decisions.
- A SAML application can request a specific assurance through the **AuthnContext** in its request; the platform maps this to the same model.
- A relying application or API can request a specific assurance **per request**, not only as a fixed per-app default — so a sensitive operation (a payment, an admin action) can demand step-up at the moment it happens. If the active session already meets the requested level, no extra prompt appears; if it does not, the user is challenged for the missing factor before a token is issued at that level.
- A level requested by an application **can only raise the requirement, never lower it**. The configured requirement (the tenant-wide MFA setting under Security, or a matching authentication policy) is the lower bound: if an application asks for a weaker level than that, the configured requirement still applies and the user is challenged as usual. The one exception is an **authentication policy**, which is set by an administrator and therefore authoritative: its level replaces the tenant-wide default and may also be lower, for example to exempt a low-risk application from MFA.

The ACR values follow the NIST SP 800-63B naming convention — `urn:nist:800-63:aal1`, `:aal2`, and `:aal3`, with a colon-qualifier (`:pwd`, `:mfa`, `:ifenrolled`, `:phr`) for the finer tiers; the **ACR value** column above lists the exact string for each level. An OIDC application requests a minimum level through the standard `acr_values` request parameter — or a fixed per-application default — and the platform issues the token at the highest level the session actually satisfies. (SAML applications express assurance through the SAML `AuthnContext`, using the standard SAML class references rather than these values.)

An ACR configured in an authentication policy or on an application that the platform does not recognize is treated as *unsatisfiable*: it fails closed rather than being silently allowed through. An unrecognized value in the `acr_values` request parameter is ignored instead, and the configured requirement applies unchanged, so a malformed request cannot lock a user out of a working application.

## Factor-to-assurance mapping

The following table summarizes which assurance level each factor contributes to. Most second factors reach **AAL2** when combined with a password; the phishing-resistant and hardware levels depend on the *kind* of WebAuthn credential used. Note that the email channel appears twice: once as the sole factor of a passwordless sign-in (AAL0) and once as a second factor backing a password (AAL1+).

| Factor | On its own | Combined with a password | Notes |
|---|---|---|---|
| **Password** | AAL1 | — | Knowledge factor; the usual first step. |
| **External IdP / social login** | AAL1 | — | Treated as a single-factor sign-in. |
| **Email one-time code / sign-in link** (as the *only* factor) | AAL0 | — | Available only in a directory with [email code login](https://dts-identity.com/docs/directories/user-directories.md#email-code-login) enabled. Below AAL1; no NIST assurance level is claimed. |
| **Email one-time code** (as a *second* factor) | — | AAL1+ (enhanced) | A weak possession channel; never reaches AAL2 (email is not an accepted out-of-band authenticator). Available only when a policy explicitly requires the enhanced level. Email never counts as the second factor of a sign-in that started with an email code. |
| **TOTP (authenticator app)** | — | AAL2 | Standard second factor. |
| **SMS one-time code** | — | AAL2 | Standard second factor. |
| **Passkey / platform authenticator** (software-secured) | AAL2+ with user verification | AAL2+ | Phishing-resistant; synced or platform passkeys (e.g. Touch ID, iCloud Keychain) count as software-secured, capping at AAL2+. |
| **Security key — make/model unverified** | AAL2+ with user verification | AAL2+ | Caps at AAL2+ until the model's hardware protection is attestation-verified. |
| **Security key — hardware-attested** | AAL3 with user verification | AAL3 | The only factor reaching AAL3: a non-exportable hardware key, verified against published authenticator metadata, used in a phishing-resistant protocol. |
| **Recovery code** | — | — | A last-resort fallback, not an assurance-raising factor. |

The distinction between a software-secured passkey (AAL2+) and a hardware-attested security key (AAL3) is established at **enrollment** and stored with the credential — it is never re-derived at sign-in. A credential enrolled as unverified stays unverified until it is re-enrolled. See [Multi-factor authentication](https://dts-identity.com/docs/security/multi-factor-authentication.md) for how factors are enabled and enrolled.

Because of this, a security key that was enrolled before its hardware protection could be attested cannot satisfy an AAL3 requirement. Where AAL3 is required, such a key is **not offered** as a verification option, and the user is shown a message explaining that the key does not meet the requirement, rather than being asked to verify a key that can never complete the sign-in. The fix is to enroll the security key again under Multi-factor authentication in the user's account, which re-runs attestation and stores the result with the credential.

## Where assurance levels are used

- **Authentication policies** — require a minimum ACR under given conditions (directory, group, specific users, network zone, time window), driving step-up. See [Authentication policies](https://dts-identity.com/docs/security/conditional-access/authentication-policies.md).
- **Per-application requirements** — an individual application can demand a higher assurance than the default, for example requiring phishing-resistant MFA for an administrative tool.
- **SAML AuthnContext** — a SAML application requests an assurance class in its authentication request, which the platform honors and reflects in the assertion.
- **Admin Console sign-in** — administrative access is held to a multi-factor requirement independent of end-user application policies.
