Most of the passkey conversation is about the login ceremony. The signature is bound to the origin, the private key never leaves the authenticator, there is nothing to phish. All true. Then the user loses their phone, clicks “I can’t sign in”, and the whole thing gets decided by a support form, an email link or a tired help desk agent. I’ve reviewed enough account systems to say the recovery path is where the real security level of a passkey deployment gets set, and it’s usually lower than anyone wrote down.
What attestation does and doesn’t give you

The diagram shows the recovery flow I would build: strong factors recover immediately, email-only recovery is delayed and noisy, and nobody can override it by phone.
During registration a WebAuthn authenticator can return an attestation statement, a signature over the new credential’s public key and some metadata, made with a key that chains to the device vendor. The relying party chooses how much it wants through the attestation option: none, indirect, direct or enterprise. The spec defines several statement formats, including packed, tpm, android-key, apple and fido-u2f, plus none for “no statement at all”.
If you verify an attestation, you learn which model of authenticator made the key, via its AAGUID, and you can check that against the FIDO Metadata Service. That is useful in a narrow setting. A company issuing YubiKeys to staff can require that only those models register. A bank can refuse authenticators with no certified user verification.
For a consumer site it is close to useless. Synced passkeys from the big platform providers generally come back with none attestation, because the provider doesn’t want every site fingerprinting the user’s device. Browsers also replace the AAGUID with zeros in that case unless the user agrees to share. So the attestation field mostly tells you “something made a key”, and you can’t use it to decide that a credential is hardware bound.
Backup flags are the signal that matters now
What you can read on every login is the authenticator data. Its flags byte includes BE (backup eligible, bit 3) and BS (backup state, bit 4), added with the multi-device credential work that became WebAuthn Level 3. BE is fixed for the life of the credential. If it’s set, the private key can be copied to other devices. BS says whether it currently has been.
Here is a small parser. The inputs are synthetic, built by hand to show the bit layout, not captured from a real device.
import hashlib, struct
FLAGS = {0: "UP", 2: "UV", 3: "BE", 4: "BS", 6: "AT", 7: "ED"}
def parse(auth_data: bytes):
rp_hash = auth_data[:32]
flags = auth_data[32]
counter = struct.unpack(">I", auth_data[33:37])[0]
names = [n for bit, n in FLAGS.items() if flags & (1 << bit)]
return rp_hash, names, counter
rp = hashlib.sha256(b"example.com").digest()
hw_key = rp + bytes([0x45]) + struct.pack(">I", 7)
synced = rp + bytes([0x5D]) + struct.pack(">I", 0)

This is the real output of the script above, run against the two synthetic blobs.
The first blob has UP, UV and AT set, so it looks like a device-bound key. The second adds BE and BS, so it is a credential that lives in someone’s cloud keychain. Note the signature counter of zero. Synced credentials often don’t maintain a counter at all, which means you can’t use counter regression as a clone detector for them. You can only use it where the counter is nonzero.
I’d store BE and BS at registration, and re-check BS on each login. A credential that was device-bound and suddenly reports as backed up is worth a log line. It’s a cheap signal and almost nobody collects it.
Why recovery is the weak point
Strong login only helps if the alternative door is as strong. In practice recovery is the alternative door, and it tends to be one of four things:
- an email link or SMS code, so the account is as secure as the user’s mailbox or phone number
- a set of recovery codes the user never saved
- a support agent who verifies identity with a birthdate and an address
- a second enrolled authenticator, which is the only one that holds up
The first three drag you back to phishable or socially engineerable factors. The 2023 MGM Resorts intrusion is the case people cite, and it matters here because nothing about phishing-resistant MFA would have helped: the attacker talked a help desk into resetting a credential. Twilio’s 2022 breach started with SMS phishing of employees. Neither is a WebAuthn bug. Both are what happens around WebAuthn.
SMS recovery deserves special blame. NIST SP 800-63B has treated the PSTN as a restricted authenticator for years, and SIM swapping is a documented, commercial attack. Using a text message to bypass a passkey means you bought a phishing-resistant lock and left a key under the mat.
A recovery design I’d defend
Treat recovery as a login at a lower assurance level that you have to deliberately raise, not as a convenience feature.
- Require at least two authenticators at enrollment where you can, and nag until the second is registered. A synced passkey plus a hardware key is a good pair, because the failure modes are unrelated.
- Make recovery codes the first-class fallback: generated once, high entropy (a 20 character base32 string is about 100 bits), stored hashed, single use, and shown with a prompt to save them in a password manager.
- When recovery goes through email, add a delay. A 24 to 72 hour wait with notifications to every existing channel and to the old devices gives a real owner time to object. It is irritating, and that’s the point for accounts that hold money or admin rights.
- After any recovery, drop all sessions, revoke all existing passkeys unless the user re-confirms them, and demand a fresh enrollment before sensitive actions.
- Give help desk staff no ability to bypass any of this. A support agent should be able to start the delayed flow, not shortcut it. If a human can reset MFA over the phone, an attacker only has to find that human.
For enterprise setups, the same logic applies with an identity proofing step such as a manager approval or an in-person check. Okta and others published guidance after the 2023 help desk attacks that says roughly this.
What to log
You can’t detect recovery abuse without recording it. At a minimum I want events for recovery started, channel used, delay elapsed, credential added, credential removed and sessions revoked, all tied to the account and to the source IP and user agent. A recovery followed within an hour by a new passkey registration and a password or email change is the shape of a takeover. A Sigma-style rule over that sequence is easy to write, and it has a very low false positive rate because legitimate recoveries are rare.
Where I land
Passkeys are the best thing to happen to consumer authentication in years and I’d roll them out everywhere. I just wouldn’t claim the account is phishing resistant until the recovery flow is.



