All chapters
  1. Start hereA valid token is not a permission
  2. Foundations · 1Identity and trust primitives: who is calling, and who checks
  3. Foundations · 2People and identity proofing: accounts, passwords and recovery
  4. Foundations · 3Sessions and browser security: cookies, CSRF, XSS and the BFF
  5. Foundations · 4Authenticators and MFA: passwords, passkeys and phishing resistance
  6. Foundations · 5API keys and application credentials: what a key proves
  7. Foundations · 6Tokens: bearer, JWT anatomy, validation and revocation
  8. Foundations · 7OAuth, OpenID Connect and federation: delegation and login
  9. Authorization · 8Authorization from first principles: subject, action, resource, context
  10. Authorization · 9Access control models: RBAC, ABAC, ReBAC and ownership
  11. Authorization · 10The enforcement architecture: PEP, PDP, PIP and PAP
  12. Authorization · 11Policy as code: versions, tests, engines and decision logs
  13. Authorization · 12Tenant and data isolation: one platform, many brokerages
  14. Authorization · 13Identity governance and lifecycle: joiner, mover, leaver
  15. Authorization · 14Privileged access: standing rights, just-in-time elevation and break-glass
  16. Workloads · 15TLS, PKI and certificates: proving a host, and a client
  17. Workloads · 16Workload and service identity: SPIFFE, mTLS and caller allowlists
  18. Workloads · 17API gateways and zero trust: the edge checks, the service decides
  19. Workloads · 18Event-driven identity: Kafka principals, ACLs and replay
  20. Workloads · 19Cloud IAM and secretless deployment: roles, federation and no stored keys
  21. Workloads · 20External SaaS, webhooks and trust: calls that cross company lines
  22. Workloads · 21Private controlled environments: what private networking does and does not secure
  23. AI-native · 22Authenticating to model providers: keys, gateways and cloud IAM
  24. AI-native · 23MCP identity and authorization: discovery is not permission
  25. AI-native · 24RAG and retrieval authorization: only what this caller may read
  26. AI-native · 25Agents as principals and delegates: whose authority is this?
  27. AI-native · 26Agent-to-agent trust: identity, capabilities and forwarded authority
  28. AI-native · 27Coding agents and CI: repository scopes, OIDC and no production keys
  29. Operations · 28Auditing and observability of access: decisions you can prove later
  30. Operations · 29Threat modeling and testing: the negative tests that prove access control
  31. Operations · 30Operational lifecycles: rotation, revocation and outages
  32. Reference · 31Standards, frameworks and products: what each one is, and what it is not
  33. Reference · 32Architecture decision playbooks: choosing an auth strategy
  34. ReferenceGlossary
  35. AboutAbout this site and its sources
Foundations · 4

Authenticators and MFA: passwords, passkeys and phishing resistance

What a second factor proves and what it does not. Passwords, one-time codes, passkeys with WebAuthn, phishing-resistant MFA, hardware-backed keys, risk-based prompts, lockout, recovery, accessibility and a stolen phone.

You will understand
Why a one-time code can be phished and a passkey cannot: the difference is what the proof is bound to.
You will be able to read
An AAL, an `acr` claim and a step-up challenge, and say what each one promises.
You will keep apart
How sure we are that the person is back, and what that person may do. MFA settles only the first.

At ten past eight the underwriter u-uw-w1 opens submission SUB-1004 in the underwriter cockpit. This is series case UW-004: the application says the roof is 9 years old, the roof data provider says 22 (evidence EV-ROOF-0412), and rule R-ROOF-03 escalates any gap above 5 years. The underwriting agent has written its recommendation with reasons and citations. The underwriter reads it, decides to refer the property to inspection, and presses "Record decision".

The cockpit answers with a prompt: confirm with your passkey. The underwriter signed in at eight with a password, ten minutes ago, and the session is still valid. So why ask again?

Because the decision is the one action on this platform that changes what the insurer commits to, and a password typed ten minutes ago is weak evidence that the person pressing the button is the underwriter. Passwords are phished, reused and guessed. The decision service therefore asks for something stronger and more recent before it accepts this one request. This page explains what that stronger thing is, why some second factors are much stronger than others, and how the request that needs it says so. The example's own case UW-A12 (this site's own case series) is the scene above: without the step-up, no decision is written.

What an authenticator proves#

An authenticator is something a person holds or knows that lets them prove, again and again, that they are the account's owner. NIST SP 800-63-4 defines it as "a means of demonstrating the control or possession of one or more factors in an authentication protocol". A password is one; a phone app that shows six-digit codes is another; a security key on a keyring is a third.

Authenticators come in kinds called factors: something you know (a password), something you have (a phone, a key), something you are (a fingerprint, used to unlock something you have). Multi-factor authentication (MFA) means the login needs evidence from at least two different factors. Guideline (OWASP MFA Cheat Sheet, read 2026-11-18): MFA "requires evidence from at least two distinct authentication factors"; two of the same factor, such as a password plus a PIN, "does not constitute MFA"; and "Any MFA is better than no MFA."

What all of them prove is narrow: the same person who enrolled is back, with some level of confidence. They do not prove who that person is in the real world (that was identity proofing, on People), and they say nothing about which submissions the person may decide. An underwriter in commercial-west who completes the strongest login still gets a refusal on a submission assigned to a peer.

Before AI. Engineers met step-up long before agents. A VPN asked for a code from a hardware token on top of the directory password. sudo asks for the password again before it runs a command as root, even inside an open terminal. A bank's web app lets you browse statements on a remembered device and asks for confirmation before a transfer. The cockpit's decision button is the same idea: routine reading on the existing session, fresh proof for the consequential act.

The smallest primitive: a one-time code, and why it can be relayed#

Start with the most common second factor, because its weakness teaches the rest of the page. A time-based one-time password (TOTP) is a short code that the phone app and the server both compute from a shared secret and the current time. Every 30 seconds both sides arrive at the same new code without talking to each other. Standard (RFC 6238, read 2026-11-18): "TOTP = HOTP(K, T)", where T is the number of 30-second steps since the Unix epoch, and HOTP is a truncated HMAC of the counter (RFC 4226).

The function below shows the computation. It demonstrates that the code is a pure function of a shared secret and the clock, and nothing else: no website name enters it. It is a minimal shape, not part of examples/uw-auth/; it was checked against the test vector published in RFC 6238 Appendix B. Production systems use a maintained library and store the seed encrypted.

import hashlib
import hmac
import struct


def totp(secret: bytes, unix_time: int, step: int = 30, digits: int = 6) -> str:
    counter = unix_time // step                                   # T = (now - T0) / X, T0 = 0
    mac = hmac.new(secret, struct.pack(">Q", counter), hashlib.sha1).digest()
    offset = mac[-1] & 0x0F                                       # dynamic truncation (RFC 4226)
    code = int.from_bytes(mac[offset:offset + 4], "big") & 0x7FFFFFFF
    return str(code % 10**digits).zfill(digits)


print(totp(b"12345678901234567890", 59, digits=8))               # RFC 6238 Appendix B: 94287082
94287082

Read the inputs again: a secret and a time. The code is valid for whoever presents it in the window, on whatever site asks for it. Now picture a phishing page that looks like the cockpit's sign-in. The underwriter types the password and the current code into it. The attacker's server forwards both to the real identity provider within seconds and gets a session. Nothing in the code could tell the real site from the fake one, because the site's name was never part of the computation. Guideline (OWASP MFA Cheat Sheet, read 2026-11-18): rejecting a code that was already used stops replay, but "does not stop real-time phishing proxies".

That gap has a name. Phishing resistance is the property that an authentication protocol does not hand a reusable proof to an impostor site. Guideline (NIST SP 800-63B-4, read 2026-11-18): "Two methods of phishing resistance are recognized: channel binding and verifier name binding", and authenticators "that involve the manual entry of an authenticator output (e.g., out-of-band and OTP authenticators) SHALL NOT be considered phishing-resistant". Codes typed by a person, whether from an app, an SMS or a push screen, fail that test by construction.

Passkeys: a proof bound to the site's name#

The fix is to make the site's name part of what is signed. That is what WebAuthn does. WebAuthn is the W3C browser API through which a site asks an authenticator to create a key pair for it and later to sign a fresh challenge with the private key. The private key stays in the authenticator; the site stores only the public key.

The binding comes from the relying party identifier. Standard (W3C WebAuthn Level 3, Recommendation 25 August 2026, read 2026-11-18): the RP ID is "a valid domain string identifying the WebAuthn Relying Party", and "The client MUST verify that the Relying Party's origin matches the scope of this RP ID." The browser, not the person, checks the name. A look-alike domain is a different origin, so the authenticator has no credential for it, and the person has nothing to type into it. NIST cites WebAuthn as phishing-resistant "through verifier name binding".

A passkey is the everyday name for a WebAuthn credential that the authenticator can find on its own, so the person does not type a username first. The specification lists "passkey" as a synonym for a discoverable credential. Product (FIDO Alliance, as documented on 2026-11-18): "Passkeys can be securely synced across a user's devices, or bound to a particular device (device-bound passkeys)". FIDO2 is the pair of specifications behind it: WebAuthn for the browser and platform, and CTAP2 for external authenticators over USB, NFC or Bluetooth.

One detail decides whether a passkey is one factor or two. Standard (WebAuthn Level 3): user verification is the authenticator locally authorizing the operation, for example with a PIN or a fingerprint, and "The UV flag SHALL be set if and only if the authenticator performed user verification." Guideline (OWASP MFA Cheat Sheet): a passkey counts as phishing-resistant MFA only with user verification; "a touch confirming user presence alone is not a second factor." So the relying party must request user verification and check the flag in the response; the WebAuthn default value for userVerification is preferred, not required.

Common confusion. The fingerprint does not travel to the site. It unlocks the private key on the device, and the site receives a signature plus a flag saying verification happened. FIDO states that biometric data "is never sent to any remote server".

Diagram: Same phishing page, two authenticators · the code is relayed, the passkey is not

Both lanes start at a look-alike sign-in page. In the top lane the person reads a code from an app and types it; the page forwards password and code to the real site within the window and receives a session. In the bottom lane the browser compares the page's origin with the RP ID the passkey was created for. They differ, so no credential is offered and nothing is signed. The difference is not the strength of the secret; it is whether the site's name is part of the proof.

  1. One-time code (TOTP)
    1. look-alike page asks for a code: The page imitates the cockpit sign-in. Its domain differs from the insurer's, but the person sees a familiar form.
    2. person types password + code: The code is a function of a shared secret and the clock only. Nothing in it names the site it is for.
    3. page relays both to the real site: A real-time proxy uses the code once before it expires. Replay protection does not help: this is the first use.
  2. Passkey (WebAuthn)
    1. look-alike page calls WebAuthn: The page asks the browser for an assertion. The browser, not the person, handles the request.
    2. browser checks origin against RP ID: WebAuthn Level 3: the client MUST verify that the origin matches the scope of the RP ID. The credential was created for the insurer's domain.
    3. no credential offered: nothing to relay: No signature is produced for the wrong site, so the proxy has nothing to forward. NIST cites WebAuthn as phishing-resistant through verifier name binding.

The diagram shows the two paths side by side through the same phishing page. On the code path, the person is the courier: whatever the page asks for, the person types, and the attacker relays it. On the passkey path, the browser compares the page's origin with the credential's RP ID before the authenticator signs anything, so the relay has nothing to carry.

Assurance levels: how strong, and how recent#

NIST grades the login itself on a scale. The authentication assurance level (AAL) describes "the robustness of the authentication process itself". Guideline (SP 800-63B-4, read 2026-11-18): AAL1 gives basic confidence that the claimant controls an authenticator; AAL2 high confidence that the claimant controls one or more authenticators; AAL3 very high confidence, where the authenticator "SHALL have a non-exportable private key and SHALL provide phishing resistance".

Two rules in the current revision surprise many teams. First, "Verifiers SHALL offer at least one phishing-resistant authentication option at AAL2"; the person need not choose it, but it must exist. Second, synced passkeys sit below AAL3: "syncable authenticators SHALL NOT be used at AAL3", because a key that can be copied to a sync service is exportable, while they "may be offered as a new option for applications that seek to implement up to AAL2".

Strength decays with time, so the guideline also sets how long a login counts. At AAL2 the overall reauthentication timeout "SHOULD be no more than 24 hours" and inactivity "SHOULD be no more than 1 hour"; at AAL3 the overall timeout "SHALL be no more than 12 hours" with inactivity of no more than 15 minutes (a SHOULD).

AuthenticatorFactorsPhishing-resistant?Can it serve AAL3? (63B-4)
Password alone (at least 15 characters)1NoNo
Password + TOTP app or SMS code2No (manual entry); SMS is also a restricted channelNo
Password + push with number matching2No (the person approves by hand)No
Synced passkey with user verification2 in one gestureYes (name binding)No: syncable authenticators SHALL NOT be used at AAL3; permitted up to AAL2
Device-bound key with user verification2 in one gestureYes (name binding)Yes, when the private key is non-exportable

Read the last two rows against the opening scene. A synced passkey is a large improvement over a code for the underwriter and is permitted up to AAL2. If the insurer's risk assessment puts the decision at AAL3, only a device-bound, non-exportable key qualifies. Which level the decision needs is the insurer's choice; this page shows how to express it.

The insurance example: step-up before record_underwriter_decision#

Back to the cockpit. The underwriter's session already exists; what is missing is evidence that is strong enough and recent enough for this one action. The pattern is called step-up: the server refuses the sensitive request with a challenge that names what it needs, the client gets a stronger authentication, and the request is retried.

The challenge has a standard shape. Standard (RFC 9470, Proposed Standard, September 2023, read 2026-11-18): the resource server returns the error insufficient_user_authentication, meaning "the authentication event associated with the access token presented with the request does not meet the authentication requirements", with acr_values (acceptable authentication context classes, "in order of preference") and max_age ("allowable elapsed time in seconds since the last active authentication event"). Tokens and introspection carry acr and auth_time, so the server can check both. RFC 9470 does not define any acr values: it takes the authentication context from OpenID Connect and leaves the logic that judges a request "out of scope", so each deployment defines its own values. The example defines its own.

In the example the rule lives in examples/uw-auth/pdp.py, rule R-AZ-09, which the cockpit backend's request asks through services.py cockpit_record_decision. The step-up part of the rule, verbatim (an excerpt from inside decide, so shown as text):

        at = subject.get("auth_time")
        recent = isinstance(at, int) and now - at <= STEP_UP_MAX_AGE_S
        if subject.get("acr") != ACR_STRONG or not recent:
            return _d(False, 401, "R-AZ-09", "step-up required: strong authentication within " + str(STEP_UP_MAX_AGE_S) + " s",
                      v, [AUDIT, "challenge: Bearer error=insufficient_user_authentication acr_values=" + ACR_STRONG
                          + " max_age=" + str(STEP_UP_MAX_AGE_S)])

ACR_STRONG is urn:insurer.example:acr:phishing-resistant and STEP_UP_MAX_AGE_S is 300 in directory.py (both this example's own values). This check runs after the others in the same rule: a person, role underwriter, entitlement uw.decide, same business unit, assigned to the submission, through svc-cockpit-bff. Step-up is the last gate, never the only one. Calling cockpit_record_decision for u-uw-w1 on SUB-1004 three times in a scratch copy, with three different authentication facts:

password, 600 s ago -> 401 R-AZ-09 | step-up required: strong authentication within 300 s
   obligation: challenge: Bearer error=insufficient_user_authentication acr_values=urn:insurer.example:acr:phishing-resistant max_age=300
phishing-resistant, 600 s ago -> 401 R-AZ-09 | step-up required: strong authentication within 300 s
   obligation: challenge: Bearer error=insufficient_user_authentication acr_values=urn:insurer.example:acr:phishing-resistant max_age=300
phishing-resistant, 60 s ago -> 200 R-AZ-09 | assigned underwriter decides through the cockpit after step-up
decisions written: 1

The second row is the one to notice. A strong authentication from ten minutes earlier is refused, because strength without recency would let a morning login authorize every decision of the day. run_cases.py --case UW-A12 checks the first row as a case: status 401, error insufficient_user_authentication, acr_values the phishing-resistant class, zero decisions written. The agent here is a scripted stand-in, so these results show how the access controls work, not how good any model is. The model recommends; a person decides, and the step-up makes sure the person is present.

Diagram: Step-up before a decision · refused, challenged, proven, retried

Time runs down the page. The underwriter presses Record decision on SUB-1004. The cockpit backend asks the policy decision point, which applies every rule of R-AZ-09 and then the step-up check: a password from ten minutes ago fails it. The refusal carries the RFC 9470 challenge with acr_values and max_age. The backend sends the browser to the identity provider, the underwriter completes a passkey gesture with user verification, and the backend stores the new acr and auth_time on its server-side session. The retry is allowed and a human decision is recorded. Case UW-A12 checks the refused half.

  1. Underwriter + browser to Cockpit BFF: record decision SUB-1004. The person acts in the cockpit. The model recommended; the person decides.
  2. Cockpit BFF to Policy decision point: decision.record, acr password. The backend asks with the verified session facts, never with what the browser claims.
  3. Policy decision point to Cockpit BFF: 401 · insufficient_user_authentication. Every other check passed; the authentication is not strong or recent enough. The challenge names acr_values and max_age 300.
  4. Cockpit BFF to Identity provider: authenticate · acr_values, max_age. The backend sends the browser to the identity provider with the requirements from the challenge.
  5. Underwriter + browser to Identity provider: passkey gesture with UV. The authenticator checks the origin, verifies the person locally and signs the challenge.
  6. Identity provider to Cockpit BFF: new acr + auth_time. The backend records them server-side and regenerates the session id after the privilege change.
  7. Cockpit BFF to Policy decision point: retry decision.record. Same request, stronger and fresher facts.
  8. Policy decision point to Cockpit BFF: 200 · human decision recorded. Allowed under authz-2026.11.1; the audit record names the underwriter and the policy version.

The sequence shows who acts. The cockpit backend sends the decision request; the policy decision point refuses with the challenge; the backend sends the underwriter's browser to the identity provider with acr_values and max_age; the passkey ceremony runs there; the backend stores the new acr and auth_time server-side and retries. What happens to the session itself during step-up (a new session id after the privilege change) is the home ground of Sessions.

The session lab lets you run the same event in two browser designs. Choose the step-up event and compare the cookie session at the backend with a token held in the browser.

For a reader without JavaScript, the same outcomes from sessions.py session_outcome, run in a scratch copy:

DesignEventRefused?The user seesWhy
Cookie session at the BFFsensitive action without step-upYesa prompt for stronger authentication (401 insufficient_user_authentication)The decision service requires a recent strong authentication (acr_values, max_age); same in both designs
Cookie session at the BFFstep-up completedNothe sensitive action proceeds if the policy otherwise allows itThe BFF records the new acr and auth_time server-side and regenerates the session id (privilege level change)
Bearer token in the browsersensitive action without step-upYesa prompt for stronger authentication (401 insufficient_user_authentication)Same as above
Bearer token in the browserstep-up completedNothe sensitive action proceeds if the policy otherwise allows itA new access token carries the new acr and auth_time; the old one is still valid until exp

The refusal is identical in both designs because it is decided by the server's policy, not by the browser. The difference is afterwards: in the token design an older, weaker token still works until it expires, so other services must check acr and auth_time themselves.

What this is not. Step-up raises the confidence that the underwriter is present. It does not authorize the decision. The peer underwriter u-uw-w2, stepped up and in the same unit, is still refused on SUB-1004 because the assignment check fails (case UW-A09). Authorization has its home in Authorization.

Failure mode: MFA at login, nothing at the moment that matters#

Here is the design the cockpit avoids, as a labelled mistake. The identity provider enforces MFA at login. The cockpit trusts its session for the whole working day and checks only "role underwriter, assigned". At nine in the morning the underwriter approves an MFA push on the phone without reading it; the prompt came from an attacker who had the password from an old breach. The attacker now holds a full-day session and records decisions in the underwriter's name. The audit record is accurate and useless: it names the underwriter.

Two controls were missing. The push was phishable and could be approved blindly. Guideline (OWASP MFA Cheat Sheet, read 2026-11-18): push needs number matching and rate-limited prompts against MFA fatigue. And the decision did not ask for fresh, phishing-resistant proof. With R-AZ-09 as written, the stolen session reads submissions but cannot decide, because the attacker cannot produce a passkey signature for the insurer's origin.

Risk signals, lockout, accessibility and a stolen phone#

Some login systems raise or lower the prompts by risk: a new device, an odd location, an impossible travel time. Those signals are useful for deciding when to ask. Guideline (OWASP MFA Cheat Sheet, read 2026-11-18): location and risk signals "do not substitute for an authentication factor". A familiar laptop is context, not proof.

Guessing needs a brake too. Account lockout stops or slows sign-in attempts on one account after repeated failures. Guideline (SP 800-63B-4): consecutive failures on one authenticator are limited to "no more than 100", an upper bound that may be lowered. Guideline (OWASP Authentication Cheat Sheet): tie counters to the account, not the source address, consider exponential delays, and keep the forgot-password path usable while locked. A hard lockout after a few attempts is itself an attack: anyone who knows an underwriter's username can lock them out before a deadline.

Every factor must have an accessible alternative. A person who cannot use a fingerprint reader can use a device PIN as user verification; a person without a smartphone can use a security key. Design the enrollment so that each person registers at least two authenticators, which also covers the stolen phone. If the underwriter's phone is stolen, its passkey still needs the device's user verification to sign; the underwriter removes that credential at the identity provider from another authenticator, and recovery follows the rules on People.

In a coding agent. A coding agent has no fingers and no passkey, and must not borrow a person's session. It works under its own repository-scoped GitHub App installation and proposes pull requests. The person with merge rights is the one who signs in with phishing-resistant MFA, because merging is the consequential act. The Coding agents page owns this case.

Architecture choice: which authenticators, and where to ask again#

SituationSimplest credible optionGrow whenAlternatives
Brokers reading their own quotesPassword at NIST length rules plus an optional passkeyBrokers submit or change binding dataFederation with the brokerage's identity provider
Underwriters reading submissionsPasskey (synced is acceptable at AAL2) at sign-inRisk assessment puts reading at AAL3Device-bound security keys for everyone
Recording a decisionStep-up to a phishing-resistant class within 300 s (this example's value)Regulators or policy require AAL3Device-bound keys with enterprise attestation
Platform administratorsDevice-bound keys plus just-in-time elevationAlways for standing production accessSee Privileged access

This site's recommendation: use the identity provider's WebAuthn support rather than building ceremonies, require user verification, and express sensitive operations as acr_values plus max_age checked by the service that performs the operation. Keep TOTP as a fallback for people who cannot use passkeys, and treat SMS as a restricted channel (NIST requires a risk assessment and an alternative).

Standards and products for this chapter#

Standard (W3C WebAuthn Level 3, Recommendation, 25 August 2026): cite the dated Level 3 Recommendation; the undated latest URL now shows the Level 4 First Public Working Draft of 15 September 2026. Standard (FIDO2): WebAuthn plus CTAP2. Standard (RFC 6238, Informational, May 2011; RFC 4226, Informational, December 2005): TOTP and HOTP; neither is Standards Track. Standard (RFC 9470): the step-up challenge. Guideline (NIST SP 800-63B-4): AAL rules, phishing resistance, syncable authenticators. Guideline (OWASP MFA Cheat Sheet): factors, push, passkeys with user verification. Product (AWS IAM, as documented on 2026-11-18): recommends phishing-resistant MFA "such as passkeys and security keys wherever possible". Identity provider support for WebAuthn and step-up is compared on Frameworks; none was run here.

Security notes#

Security note. Check the UV flag on every assertion when the policy counts the passkey as two factors. A credential registered with user verification can still be used without it if the server does not insist.
Security note. Store TOTP seeds encrypted and reject a code already accepted in its window (RFC 6238: the verifier "MUST NOT accept the second attempt").
Production pitfall. Two different checks drift apart: the identity provider enforces MFA at login, and each service assumes it. Put the requirement where the action is, as acr and auth_time checked by the receiving service.

Monday checklist#

  1. List the actions that change commitments or money (decisions, payouts, role changes) and give each an acr_values and max_age requirement.
  2. Confirm that at least one phishing-resistant option is offered to every user group, as NIST requires at AAL2.
  3. Turn on number matching and prompt rate limits for push MFA, or retire push.
  4. Check that WebAuthn registration and assertion request userVerification: "required" where a passkey counts as MFA, and that the server checks the UV flag.
  5. Replace hard lockouts with per-account throttling and exponential delay.
  6. Make every person enroll two authenticators, and test removal of a lost one.

Exercises#

  1. An underwriter signed in with a device-bound security key at 08:00. At 08:20 they record a decision. Under R-AZ-09, what happens, and why?
AnswerStrong but not recent

401 with insufficient_user_authentication: the acr is strong, but auth_time is 1,200 s old and the example's max_age is 300 s. A fresh passkey gesture satisfies it.

  1. A team says "we use passkeys, so we are AAL3". What two questions do you ask?
AnswerExportable? Verified?

Are the keys synced (exportable, so AAL2 at most) or device-bound and non-exportable? And does every assertion require and carry user verification?

  1. Why does rejecting a reused TOTP code not stop a phishing proxy?
AnswerThe proxy uses it first

The proxy relays the fresh code to the real site within the window and uses it once. Replay protection only stops a second use; nothing binds the code to the real site's name.

Advanced perspective#

What an acr value really promisesOpaque strings, agreed meaning, and who checks them

RFC 9470 defines no acr values of its own and calls other ways of determining the authentication level a matter "per agreement by the authorization server and the protected resource". So the identity provider and the resource server must agree on what urn:insurer.example:acr:phishing-resistant means. That agreement is governance, not protocol. Write down, per value, which authenticators produce it and whether user verification is required, and version the list; otherwise one identity provider change (adding a synced passkey type, say) silently changes what the decision service accepts.

auth_time has a similar subtlety. It is the time of the user's authentication, not the time the token was issued. RFC 9470 says the acr and auth_time values "are established at user-authentication time and will not change in the event of access token renewals". If an identity provider updated auth_time on refresh, max_age checks would become meaningless. Test it with your identity provider: refresh a token and compare the two values.

Finally, where the check runs matters. If the cockpit backend checks acr but the decision service behind it does not, any other client that reaches the decision service skips step-up. In the example the check is in the policy rule R-AZ-09, which the decision path asks; the cockpit backend is also the only allowed client, which closes the other side.

Synced against device-bound passkeysRecovery, attestation, and the AAL3 line

Synced passkeys solve the biggest operational problem of hardware keys: losing the device. The key is in the platform's sync service, so a new phone restores it. The price is that the private key is exportable, which NIST places below AAL3, and that the account at the sync provider becomes part of the trust chain. NIST's Appendix B requires keys in the sync fabric to be encrypted and access to them protected by AAL2-equivalent MFA.

WebAuthn exposes the difference to the relying party. The BE flag "SHALL be set if and only if the credential is a multi-device credential" and is fixed at creation; the BS flag says whether it is currently backed up. A relying party can therefore accept synced passkeys for ordinary sign-in and insist on a credential without BE for the decision class. Attestation (preference values none, indirect, direct, enterprise; the default is none) lets an enterprise require specific authenticator models, at the cost of managing an allowlist of models and of privacy considerations for consumer users.

For the underwriters, a defensible split is synced passkeys for sign-in and device-bound keys for the decision step-up, if the risk assessment asks for AAL3. For brokers, synced passkeys are a clear gain over passwords and codes.

Lockout as an attack, throttling as the defenseAvailability and guessing pull in opposite directions

A fixed lockout after five failures stops online guessing and hands any outsider a way to disable an account. Underwriters' usernames are often guessable from email conventions, so a hostile party can lock out a whole unit on the morning of a deadline. NIST sets only an upper bound (no more than 100 consecutive failures per authenticator) and leaves the mechanism open.

Throttling keeps both properties better: each failure adds a growing delay on that account, successful sign-in resets it, and a separate per-source limit catches spraying across many accounts. Passkeys change the calculation further. There is nothing to guess remotely, so the guessing threat moves to the device, where the authenticator's own PIN retry limits apply.

Log every lockout and every throttling step as a security event without the attempted password, and alert on many accounts locked at once. The Audit page covers the event shape.

Email, SMS and push as channelsWhat NIST now restricts or forbids

NIST SP 800-63B-4 says "Email SHALL NOT be used for out-of-band authentication". Email codes for confirming an address or for recovery are a different use and are outside that prohibition, but they still rely on the security of the email account, which OWASP notes "often lacks MFA". SMS and voice are a restricted channel: use requires a risk assessment and an unrestricted alternative, and NIST may change the restricted status. OWASP is blunter: "Do not use SMS for high-value or PII-handling applications."

Push approvals are convenient and phishable. Number matching makes the person read a value shown on the sign-in screen, which defeats blind approval. A real-time proxy can still display the number it received from the real site; that is this site's reading of how a relay works, not a statement from the cheat sheet, and it follows from NIST's rule that manual-entry methods are not phishing-resistant. Push is a reasonable second factor for low-risk access and not a substitute for a phishing-resistant step-up before decisions.

In one breath#

An authenticator proves that the same person is back; it never proves what that person may do. Codes typed by a person can be relayed by a phishing page, while a passkey's signature is bound to the site's name by the browser, which is why NIST counts it as phishing-resistant. For the consequential act, the service asks for strength and recency together, as acr_values and max_age, and checks them itself after every other rule.

The underwriter has now proved presence with a passkey before recording the decision on SUB-1004. Not every caller is a person with fingers, though: the portal backend calls the quote API, and the assessment service calls a roof data provider, with a string in a header. What that string proves, and when it is enough, is the subject of API keys and application credentials.