Passkeys for app teams: what the server side must get right
Review relying-party verification, user verification and account recovery considerations when implementing passkey sign-in.
- Passwordless, phishing-resistant by design
- Passkeys are discoverable WebAuthn credentials: the device keeps the private key, the app stores a public key, and the RP ID ties the credential to your domain.
- A passkey is not automatically MFA
- OWASP: the server must ask for user verification (UV) and check the returned UV flag - do not treat UP and UV as equal.
- Recovery sets the real security floor
- The account is only as secure as its weakest recovery route; do not let email or SMS reset quietly bypass passkeys.
All wording checked against the OWASP Passkey Security Cheat Sheet linked in Sources.
A passkey lets people sign in with a device-held private key instead of a password. OWASP's Passkey Security Cheat Sheet is aimed at developers who build the server ("relying party") side. We read it in full on 15 November 2026. We did not read the W3C WebAuthn specification or the NIST documents it cites, and did not view its diagrams. This article is a plain-language summary for founders and their developers, not an implementation guide.
What a passkey is
OWASP describes passkeys as discoverable WebAuthn credentials for passwordless sign-in without sending a shared secret to the app. The device (authenticator) keeps the private key and the app stores a public key. A passkey is tied to a relying party identifier (RP ID), which gives phishing resistance when the process and server checks are implemented correctly. The sheet covers both synced and device-bound passkeys. It excludes the older FIDO U2F second-factor credentials.
Its main recommendations: use a maintained WebAuthn server library and check every required field; bind registration to the right account and require recent sign-in before changing passkeys; treat user presence and user verification as different; design credential management and recovery as carefully as sign-in; support more than one authenticator.
Two terms that matter
- User presence (UP): someone touched the authenticator.
- User verification (UV): the authenticator checked the user locally, with a PIN or biometric.
OWASP says not to treat them as equal. A passkey is not automatically multi-factor: the server must ask for UV and check the returned UV flag. This matches the point in our MFA article.
User presence (UP)
Someone touched the authenticator. Nothing more is proven about who.
User verification (UV)
The authenticator checked the user locally, with a PIN or biometric. Required when a passkey is meant to be MFA - the server must ask for it and check the flag.
What passkeys do not fix
The sheet lists: an already-hijacked session adding an attacker's passkey, a weak recovery process bypassing passkeys, credentials linked to the wrong account on the server, bugs in application code, authorisation or sessions, and compromise of a device or of the account used to sync passkeys.
Hijacked session
An already-hijacked session adding an attacker's passkey.
Weak recovery
A weak recovery process bypassing passkeys.
Wrong account
Credentials linked to the wrong account on the server.
App bugs
Bugs in application code, authorisation or sessions.
Device compromise
Compromise of a device.
Sync account
Compromise of the account used to sync passkeys.
Choices to make
- RP ID: use the narrowest stable domain that covers the app; not a parent domain just to share credentials across unrelated subdomains. Keep an exact allowlist of origins; do not build the expected origin from a request header.
- Native apps: the sheet says Android and Apple apps report origins differently and each platform decides whether an app may use your RP ID from an association file you host (assetlinks.json on Android, apple-app-site-association on Apple platforms). Treat those files like the origin allowlist, with the same change control.
- HTTPS for all passkey pages, protected against script injection. Avoid cross-origin use in embedded frames unless it is a reviewed design.
- Library: do not write the CBOR, key handling or signature verification yourself; use a maintained library, keep it updated and test registration and sign-in. The library does not make your account workflows safe on its own.
- Attestation: OWASP says most public-facing apps should use none and not restrict users to certain authenticator models; use it only for a documented enterprise or regulatory need.
Registration
Treat adding a passkey as a sensitive account change. Require recent authentication for an existing account; for a new account tie it to the verified sign-up. Protect the endpoints against CSRF, rate-limit and log attempts. The challenge must be cryptographically random (at least 16 bytes per the sheet), expire promptly, be used once, and be tied to the ceremony, account, RP ID and policy. The server then verifies the response type, challenge, origin, RP ID hash, presence and (where required) verification flags, algorithm and key. Store the credential only after all checks pass, linked to the account from server-side state and never one the client names. Keep user handles opaque, with no email or name in them.
Sign-in
Fresh single-use challenge each time. With account-first sign-in, use generic responses so the first step does not reveal which accounts exist. Verify type, challenge, origin, RP ID hash, credential ownership, signature and flags, then create the session and rotate its identifier. Signature counters are risk signals only: some authenticators do not use them and synced passkeys may not count strictly upward, so do not lock users out on a counter anomaly alone. Return generic errors, and never let a failed passkey check quietly drop to a weaker method. The sheet says an attacker in the middle steers people to whatever fallback is still enabled, and cites NIST that manually typed codes (OTP, out-of-band) are not phishing-resistant.
Managing and recovering passkeys
- Let users see passkeys by name, creation date and last-used date, not raw IDs.
- Require recent sign-in to add or remove one; allow several; notify on changes; revoke on the server immediately.
- Before removing the last passkey, confirm another way to sign in remains.
- Recovery: the sheet says the account is only as secure as its weakest recovery route. Prefer another registered passkey, a separately protected single-use recovery code, or a high-assurance identity process. Do not let email or SMS recovery silently bypass a stronger policy on high-risk accounts. After recovery, rotate sessions, review credentials and notify the user.
- Synced vs device-bound: synced passkeys improve availability but depend on the sync provider's account protection. The sheet suggests public apps generally support synced passkeys with extra authenticator and recovery options, and enterprise or high-assurance apps may require managed device-bound authenticators. It says NIST does not allow syncable authenticators at AAL3.
Questions for your team
- Do we require user verification when a passkey is meant to be MFA?
- What can an attacker with a stolen session cookie do to our passkeys?
- What is our recovery route and is it weaker than sign-in?
- Is there a silent fallback to passwords or SMS?
Related: MFA options compared, forgot-password flows, session management basics.
Limits
One OWASP page, read in full. W3C, NIST and diagrams unread. Browser and device support, adoption and user-experience results are outside the sheet and we make no claims about them. Regulated products may have assurance requirements to check with counsel or an assessor.
By Omnistu.