OOmnistu

Blog / Engineering Playbooks

Engineering Playbooks

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.

OOmnistu
Reviewed 2026-11-16 · 5 min read
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

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

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.

THE REGISTRATION CEREMONY, AFTER THE SHEET YOUR SERVER USER'S AUTHENTICATOR 1. Create the challenge cryptographically random, at least 16 bytes; single-use; expires promptly; tied to the account, RP ID and policy challenge + RP ID 2. Verify the user locally PIN or biometric; create the key pair; private key stays under authenticator control registration response: public key + credential ID 3. Verify, then store the credential check type, challenge, origin, RP ID hash and the UV flag where required THE REGISTRATION CEREMONY, AFTER THE SHEET YOUR SERVER 1. Create the challenge cryptographically random, at least 16 bytes; single-use; expires promptly; tied to the account, RP ID and policy challenge + RP ID USER'S AUTHENTICATOR 2. Verify the user locally PIN or biometric; create the key pair; private key stays under authenticator control registration response: public key + credential ID YOUR SERVER 3. Verify, then store the credential check type, challenge, origin, RP ID hash, UV flag; store public key + credential ID
After the OWASP Passkey Security Cheat Sheet's registration section: the challenge is single-use and ceremony-bound, the private key stays under authenticator control (synced passkeys sync between devices via a credential provider, never to your server), and the server verifies the full response (type webauthn.create, exact challenge, allowlisted origin, RP ID hash, UP/UV flags) before storing the credential: its public key and credential ID, never a shared secret. This is the registration ceremony; the sheet says a challenge issued for authentication must never be accepted for registration.

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

Questions for your team

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.

Sources

Previous
Node.js app security: a checklist from OWASP's guidance