n.Newfeed

Technology · 6 min read

How Passkeys Use Public-Key Credentials to Replace Passwords

A protocol-level explanation of passkey registration, authentication, synchronization, recovery, and residual risk.

How Passkeys Use Public-Key Credentials to Replace Passwords

A credential rather than a shared secret

A password works by presenting a secret that the user and service both recognize. Even when a server stores a salted hash instead of the password itself, the user still types the same reusable string into a website. A convincing imitation site can collect it, malware can capture it, and a database breach can expose material for offline guessing.

A passkey changes the protocol. The user’s authenticator—a phone, computer, security key, or password manager—creates a cryptographic key pair for a particular service. The service stores the public key. The private key remains under the authenticator’s control. At sign-in, the service sends a fresh challenge, and the authenticator signs data that includes that challenge and the service identity. The service verifies the signature with the public key.

This is the Web Authentication, or WebAuthn, model developed through the W3C and the FIDO Alliance’s FIDO2 specifications. “Passkey” is ecosystem language for a discoverable WebAuthn credential that can support sign-in without first entering a username. Some passkeys remain bound to one device; others are synchronized across a user’s devices by a credential provider.

The change removes a phishable shared password from the authentication ceremony. It does not remove every source of account compromise. Device security, recovery, session cookies, enrollment, and the service’s own authorization rules remain part of the system.

Registration binds a key to a relying party

WebAuthn calls the website or service a relying party. During registration, the relying party sends the browser a creation request containing a random challenge, its relying-party identifier, user information, and acceptable credential options. The browser mediates between the site and an authenticator. The authenticator creates a new key pair and returns a credential identifier, the public key, and signed registration data.

The relying-party identifier is usually based on a web domain. A credential created for example.com is scoped to that relying party; a page at a look-alike domain cannot ask the authenticator to use it as though it were the original. This “verifier name binding” is why NIST SP 800-63B-4 cites WebAuthn as an example of phishing-resistant authentication. The defense does not depend on a person spotting a misspelled logo or URL before entering a secret.

The authenticator may also provide attestation: information about the authenticator or its provenance. Relying parties can use attestation in managed environments, but broad consumer services often limit it because detailed device identification can create privacy and interoperability costs. Attestation is distinct from authentication. A service can verify a user’s credential without learning a uniquely identifying hardware model.

Registration is a sensitive moment. If an attacker controls an authenticated session and can add their own passkey, later cryptography will faithfully recognize the attacker’s credential. Services therefore need strong reauthentication, notification, and audit controls around adding or removing authenticators. Passkeys improve the sign-in primitive; they do not make account settings harmless.

Authentication signs a fresh challenge

At sign-in, the relying party creates a random challenge and asks for a credential appropriate to its identifier. The authenticator checks the relying-party context, seeks user presence, and may require user verification through a device PIN, biometric, or another local method. It then signs an assertion containing the challenge-related client data and authenticator data. The server verifies the signature and confirms that the challenge, origin, and relying-party identifier match its request.

Fresh challenges provide replay resistance. Recording one valid assertion should not let an attacker reuse it for a later request because the next challenge differs. Origin checking prevents a signature produced in one web context from silently authenticating another. The private key is not sent to the service during registration or sign-in.

A fingerprint or face scan in this flow normally unlocks the authenticator locally; the biometric template is not sent to each relying party as the credential. The server receives evidence that the authenticator performed the required user-verification ceremony. Exact handling depends on the platform, and a device PIN can often serve the same protocol role.

Passkeys can combine possession of the authenticator with local user verification. That can satisfy a multi-factor intent within one interaction: something controlled by the user plus a PIN or biometric check. Whether a deployment meets a formal assurance level depends on its complete configuration and lifecycle, not on the presence of a passkey label.

Synchronization, recovery, and new trust boundaries

Device-bound credentials keep the private key in one authenticator. They can offer a narrow hardware boundary, but loss or damage creates a recovery problem unless the user registered another authenticator. Syncable passkeys encrypt credential material and make it available across devices through a provider account. That improves usability and reduces lockout, while moving part of the security argument to the provider’s synchronization, device enrollment, and account-recovery controls.

NIST’s supplement on syncable authenticators recognizes both benefits and risks. Synchronization can preserve phishing resistance and avoid transmitting passwords, but federal agencies are advised to evaluate sharing, recovery, key protection, and threat models. “Synced” does not mean the private key is published; it means encrypted credential material may exist beyond the device where it was created.

Cross-device authentication adds another path. A user may begin on a laptop and approve with a nearby phone, often using a QR code and a proximity-protected protocol. This is safer than typing a reusable password into the laptop, but users still need intelligible prompts. An attacker may manipulate a person into approving an action they did not initiate. Protocol resistance to credential phishing is not resistance to all social engineering.

Recovery is where hybrid systems often fall back to weaker methods. If a service allows account reset through easily intercepted email, weak security questions, or a support process vulnerable to impersonation, an attacker may bypass the passkey. Mature deployments treat recovery as another authentication ceremony, encourage multiple authenticators, and tell users when credentials change.

What passkeys solve and what they leave open

Passkeys directly address several password failures. There is no reusable secret for a fake site to collect, a distinct key pair can be used for each relying party, and the signed response is bound to a fresh challenge. A server breach exposes public keys, which are meant to be public, rather than password hashes that attackers can guess against offline. These properties are established by the protocol design and recognized in standards guidance.

Implementation can still fail. A relying party might validate origins incorrectly, mishandle challenges, permit unsafe credential enrollment, or retain a weak fallback. Compromised endpoints can steal authenticated sessions or manipulate transactions after sign-in. Malware with sufficient device control may act as the user. Authorization bugs can expose data even when identity was correctly authenticated.

Privacy is mixed. Per-site key pairs reduce cross-site correlation through a shared credential. Sync providers, operating systems, browsers, and services may still observe metadata under their respective designs and policies. Attestation choices can reveal device information. Users may also become dependent on an account ecosystem for synchronized recovery, although standards allow credentials from multiple authenticators and providers.

Adoption remains a coordination problem. Sites need well-designed enrollment and fallback; platforms need interoperable credential management; users need to understand where a credential lives. A mixed password-and-passkey period can preserve the weakest route unless services deliberately harden recovery and let users remove passwords where appropriate.

What is established is that WebAuthn public-key credentials can provide replay and phishing resistance that reusable passwords lack. What is deployment-dependent is key storage, synchronization, user verification, and recovery. What remains unknown is how consistently services will implement the complete lifecycle and how attackers will shift toward enrollment fraud, session theft, and social manipulation as direct credential phishing becomes less productive.

Sources

4 sources, 1 of them with a link you can follow.

  1. World Wide Web Consortium, Web Authentication: An API for Accessing Public Key Credentials, Level 2 (W3C Recommendation, 8 April 2021) and Level 3 specification work.
  2. FIDO Alliance, Client to Authenticator Protocol (CTAP) 2.2 and FIDO2 technical specifications.
  3. National Institute of Standards and Technology, SP 800-63B-4: Authentication and Authenticator Management (2025), sections on phishing and replay resistance.
  4. NIST, Incorporating Syncable Authenticators into SP 800-63B, Supplement 1 (2024), doi:10.6028/NIST.SP.800-63Bsup1.

Want the reader to remember this spot? Sign in — it is free.

Next How Passkeys Use Public-Key Signatures for Authentication

The app

Keep going, or take it with you.

Free accounts read twenty pieces a day. Pro is US$1.99 a month or US$11.99 a year for unlimited reading.