Il problema dei segreti condivisi
Una password è un segreto condiviso: lo conoscono l'utente e il server, e per autenticarsi l'utente lo consegna. Tutto il resto deriva da qui. Lo si può riusare su altri siti, quindi un breach altrove diventa un accesso qui (credential stuffing). Lo si può consegnare alla persona sbagliata, quindi il phishing funziona. Il server ne conserva una forma derivata, quindi un database rubato diventa una lista da craccare.
L'MFA con codici OTP o notifiche push alza l'asticella ma non cambia la natura del problema: anche il codice è un segreto che l'utente consegna. Un proxy di phishing in tempo reale (adversary in the middle) si mette tra utente e sito, inoltra password e codice, e si tiene il cookie di sessione. L'utente non ha fatto niente di sbagliato, se non fidarsi di un dominio quasi uguale a quello vero.
| Password | OTP (SMS, TOTP) | Push | Passkey / FIDO2 | |
|---|---|---|---|---|
| Segreto sul server | Hash della password | Seed TOTP | Token del dispositivo | Nessuno: solo una chiave pubblica |
| Riutilizzabile su altri siti | Sì, spesso | No | No | No: una chiave per rpId |
| Phishing in tempo reale (AitM) | Vulnerabile | Vulnerabile | Vulnerabile (MFA fatigue) | Resistente: firma legata all'origin |
| Data breach del server | Hash da craccare | Seed da rubare | Dipende | Inutile per l'attaccante |
| Cosa digita l'utente | Tutto | Un codice | Niente | Niente (o un PIN locale) |
L'idea chiave
FIDO2: WebAuthn + CTAP
FIDO2 è il nome ombrello di due specifiche che lavorano insieme. WebAuthn (W3C, oggi Level 3) è l'API JavaScript che un sito usa per creare e usare credenziali, e definisce i formati dei dati e le verifiche che il server deve fare. CTAP (Client to Authenticator Protocol, FIDO Alliance, oggi 2.2) è il protocollo con cui il browser o il sistema operativo parla con un autenticatore esterno: una chiavetta su USB o NFC, un telefono via Bluetooth.
Server del Relying Party
genera challenge, verifica firme, conserva chiavi pubbliche
JavaScript del sito
chiama navigator.credentials.create() / get()
Browser / sistema operativo
il client: verifica l'origin, scrive clientDataJSON, parla con gli autenticatori
Di piattaforma
Touch ID, Windows Hello, sblocco Android: chiave nel Secure Enclave, nel TPM, nel TEE
Gestore di passkey
Portachiavi iCloud, Google Password Manager, 1Password: passkey sincronizzate
Roaming
Chiavetta FIDO2 (USB, NFC, BLE) o telefono via hybrid
autenticatori
Gli attori
Il Relying Party (RP) è il sito: un server che emette challenge e verifica firme, più il JavaScript che chiama l'API. Il client è il browser, spesso insieme al sistema operativo (su Windows le chiamate passano da webauthn.dll, su Android da Credential Manager). L'autenticatore genera e custodisce le chiavi private e firma. Può essere di piattaforma, integrato nel dispositivo (Touch ID, Windows Hello, il gestore di passkey del sistema), oppure roaming, staccabile e usabile su più dispositivi (una chiavetta, un telefono via hybrid). In WebAuthn si chiama authenticatorAttachment: platform o cross-platform.
CTAP esiste in tre generazioni. CTAP1 è il vecchio U2F: messaggi APDU binari, solo secondo fattore, nessuna credenziale salvata, nessun PIN. CTAP2.0 introduce CBOR, credenziali discoverable e PIN. CTAP2.1 aggiunge token PIN con permessi, gestione delle credenziali, biometria; la 2.2 standardizza il trasporto hybrid. Un autenticatore dichiara cosa parla nella risposta a getInfo.
Credenziali, rpId e passkey
Una credenziale WebAuthn è una coppia di chiavi creata per un solo rpId e un solo utente. Gli ingredienti che vedremo nei messaggi sono pochi, conviene fissarli subito.
- rpId: un dominio, uguale all'host della pagina o un suo suffisso registrabile. Da
https://login.example.comsi può usarelogin.example.comoexample.com, noncomnéexample.org. Per più domini diversi esistono le Related Origin Requests: un file/.well-known/webauthnsull'rpId che elenca le origin ammesse. - credential ID: fino a 1023 byte scelti dall'autenticatore, che il server usa per ritrovare la chiave pubblica.
- user handle (
user.id): fino a 64 byte opachi scelti dal server. Dovrebbe essere un valore casuale, non l'email. - challenge: almeno 16 byte casuali, monouso, che rendono ogni firma impossibile da riutilizzare.
- signCount: un contatore che l'autenticatore può incrementare a ogni firma.
Discoverable e non discoverable
Una credenziale non discoverable non esiste per l'autenticatore finché il server non gli passa il suo ID: molte chiavette cifrano la chiave privata con un segreto interno e la restituiscono come credential ID, così possono gestire infinite credenziali senza memoria. È il modello del secondo fattore: prima lo username, poi la chiavetta. Una credenziale discoverable (resident key) è salvata sull'autenticatore insieme a rpId e user handle, e si può trovare da sola: il server chiede «una qualunque credenziale per example.com» e l'autenticatore propone gli account.
| Non discoverable | Discoverable (passkey) | |
|---|---|---|
| Dove sta la chiave privata | Spesso cifrata dentro il credential ID (key wrapping) | Nella memoria dell'autenticatore o del gestore |
| Il server deve conoscere l'ID | Sì, in allowCredentials | No: login senza username |
| Spazio sull'autenticatore | Nessuno | Uno slot per credenziale |
| Parametro WebAuthn | residentKey: "discouraged" | residentKey: "required" o "preferred" |
| Opzione CTAP | rk: false | rk: true |
Cos'è, esattamente, una passkey
Registrazione, messaggio per messaggio
Seguiamo una registrazione reale. Tutti i valori che vedi, challenge, chiavi, hash, firme, sono stati generati con chiavi P-256 vere per l'rpId example.com e l'origin https://login.example.com: decodificano e si verificano, puoi controllarli nel laboratorio più avanti.
1. Il sito chiede le opzioni
POST /webauthn/register/options HTTP/1.1
Host: login.example.com
Cookie: session=…
Content-Type: application/json
{ "username": "gianni@example.com" }clientDataJSON
È il documento che il browser compone e che l'autenticatore firma (attraverso il suo hash). Il server lo riceve in chiaro, come byte UTF-8, e deve verificarlo prima di qualsiasi altra cosa.
{
"type": "webauthn.create",
"challenge": "COTwHfFRxa0Tm-d4bmst0mTUbp5GTy67g9Z0FM0kl4I",
"origin": "https://login.example.com",
"crossOrigin": false
}type distingue registrazione (webauthn.create) e login (webauthn.get), così una firma non si può spacciare per l'altra. challenge è quella del server, in base64url. origin è l'origin completa della pagina che ha chiamato l'API: il server la confronta con l'elenco delle proprie. crossOrigin segnala una chiamata da un iframe di terze parti, con topOrigin che indica la pagina contenitore.
attestationObject
È una mappa CBOR (Concise Binary Object Representation, RFC 8949): JSON binario, compatto e senza ambiguità di parsing. Contiene il formato dell'attestation, lo statement e, soprattutto, l'authData. Clicca le righe per vedere quali byte codificano cosa.
browser → sito · response.attestationObject · 178 byte
byte 0–177 · 178 B
messaggio
Una mappa CBOR con tre chiavi testuali. È lo stesso contenuto della risposta CTAP, con i nomi al posto degli interi.
authenticatorData byte per byte
L'authenticatorData è la struttura binaria che l'autenticatore produce e firma, identica in registrazione e in login, con una parte opzionale in più quando nasce una credenziale. Non è CBOR: è un formato a campi fissi, con la chiave pubblica codificata in CBOR (COSE) in coda.
byte 32–32 di 148
flags · 1 B
Una bitmask. Il server deve controllare almeno UP, e UV se la sua policy lo richiede.
0x5d = 01011101b
- UPbit 0 · User Present: qualcuno ha toccato, cliccato, confermato
- UVbit 2 · User Verified: PIN, biometria o sblocco del dispositivo
- BEbit 3 · Backup Eligible: la credenziale può essere sincronizzata
- BSbit 4 · Backup State: la credenziale è sincronizzata ora
- ATbit 6 · Attested credential data presente (solo in registrazione)
- EDbit 7 · Extension data presente
offset len campo 0 32 rpIdHash SHA-256(rpId) 32 1 flags UP(0) UV(2) BE(3) BS(4) AT(6) ED(7) 33 4 signCount uint32 big endian --- solo se AT = 1 (attestedCredentialData) --- 37 16 aaguid 53 2 credentialIdLength uint16 big endian 55 L credentialId 55+L var credentialPublicKey COSE_Key in CBOR --- solo se ED = 1 --- ... var extensions mappa CBOR
La chiave pubblica in COSE
COSE (RFC 9052 e 9053) è l'equivalente CBOR di JOSE: chiavi intere al posto dei nomi. Per una chiave EC2 su P-256 con ES256 servono cinque voci, 77 byte in tutto. Il server la può conservare così com'è o convertirla in JWK o SPKI.
{ 1: 2, kty: EC2 → "kty": "EC"
3: -7, alg: ES256 → "alg": "ES256"
-1: 1, crv: P-256 → "crv": "P-256"
-2: h'39a446e6…', x (32 B) → "x": "OaRG5q3jhmmeKY7cI2t17icpnk6kcxZfYS2XN8KE480"
-3: h'cf33a76a…', y (32 B) → "y": "zzOnaoZXLLHR5CCHWrBOB6f-NFXBBDFUunUaFGEYybY" }Gli altri algoritmi che incontrerai: -257 RS256 (Windows Hello lo usa ancora su alcuni TPM), -8 EdDSA (Ed25519, molte chiavette), -35 e -36 ES384 ed ES512. Un server dovrebbe offrire almeno -7 e -257.
Attestation: chi ha creato la chiave?
Un server può voler sapere non solo che una chiave esiste, ma dove è stata creata: un'azienda può accettare solo chiavette certificate FIDO L2, una banca può voler escludere autenticatori software. L'attestation serve a questo: un produttore installa in fabbrica una chiave di attestation, condivisa da un lotto di almeno 100 000 dispositivi per non renderli tracciabili, e l'autenticatore firma con quella la nuova credenziale. Il server verifica la catena fino a un certificato radice pubblicato nel FIDO Metadata Service (MDS3), cercato per AAGUID.
| fmt | Chi lo usa | Cosa contiene |
|---|---|---|
| none | Default, quasi tutte le passkey sincronizzate | Niente: il sito non ha chiesto attestation |
| packed | Chiavette FIDO2, molti autenticatori | alg, sig e x5c (certificato di batch) oppure self attestation |
| tpm | Windows Hello | Struttura TPMS_ATTEST firmata da una chiave AIK del TPM |
| android-key | Android, chiavi in hardware | Catena Android Key Attestation |
| apple | Dispositivi Apple (attestation anonima) | Certificato con nonce = hash di authData e clientDataHash |
| fido-u2f | Vecchi token U2F | Firma U2F e certificato di attestation |
Il sito sceglie con attestation: none (default), indirect, direct o enterprise. Per un sito consumer la scelta giusta è quasi sempre none: le passkey sincronizzate non offrono attestation e chiederla aggiunge solo un prompt di privacy. In ambito aziendale, con enterprise una chiavetta configurata dall'organizzazione può includere il numero di serie, solo per gli rpId autorizzati.
{
"fmt": "packed",
"attStmt": {
"alg": -7,
"sig": h'3045…', // firma con la chiave di attestation
"x5c": [ h'3082…' ] // certificato di batch: O=Yubico AB, OU=Authenticator Attestation
}, // estensione 1.3.6.1.4.1.45724.1.1.4 = AAGUID
"authData": h'a379a6f6…'
}
verifica: sig su authData ‖ clientDataHash con la chiave di x5c[0],
catena fino alla radice del Metadata Statement dell'AAGUIDAutenticazione e verifica della firma
Il login è più semplice della registrazione: una challenge, una firma, una verifica. Le passkey rendono possibile il login senza username, con allowCredentials vuota, e la conditional UI le integra nel normale autocompletamento del browser.
1. Una nuova challenge
Cosa si firma, esattamente
L'autenticatore firma authenticatorData ‖ SHA-256(clientDataJSON). Le firme ECDSA arrivano codificate in DER (una SEQUENCE ASN.1 di due INTEGER, r e s), non nel formato raw r‖s di JOSE: è un dettaglio che fa fallire molte implementazioni fatte a mano.
authenticatorData (37 B)
a379a6f6eeafb9a55e378c118034e2751e682fab9f2d30ab13d2125586ce19471d00000000
clientDataHash = SHA-256(clientDataJSON) (32 B)
bcf2fb4fe07c22c66fd69269411aa2d690fb027534318b856f22fa4f8763bf33
signature (DER, 71 B)
30 45 SEQUENCE, 69 B
02 20 21c5603c12969d… INTEGER r (32 B)
02 21 00 ae6cebd1e2706d… INTEGER s (33 B: 00 iniziale, bit alto a 1)La checklist del server
- la credenziale con quell'
idesiste e, se c'è lo userHandle, appartiene a quell'utente; clientDataJSON.typeèwebauthn.get, lachallengeè quella emessa (e non ancora usata), l'originè ammessa;rpIdHashè lo SHA-256 dell'rpId atteso;- il flag UP è a 1, e UV se la policy lo richiede;
- la firma è valida con la chiave pubblica salvata;
- se signCount o il valore salvato sono diversi da zero, il nuovo valore è maggiore: altrimenti possibile clone;
- aggiornare signCount, il flag BS e la data di ultimo uso.
Laboratorio: una passkey vera
Basta teoria. Questo widget esegue cerimonie WebAuthn vere su questa pagina, con il tuo autenticatore (il gestore di passkey del sistema, una chiavetta, il telefono via QR), e poi fa nel browser tutte le verifiche che farebbe un server: challenge, origin, rpIdHash, flag e firma, con WebCrypto. Nessun dato lascia la pagina.
Prova con autenticatori diversi e confronta: un gestore di passkey avrà BE e BS a 1 e signCount 0, una chiavetta BE a 0 e un contatore che cresce; con attestation: direct e una chiavetta vedrai un fmt packed con il certificato del produttore in x5c.
CTAP2: il protocollo dell'autenticatore
Quando l'autenticatore è esterno, tra browser e dispositivo viaggia CTAP2. Il modello è semplice: richiesta e risposta. Una richiesta è un byte di comando seguito da una mappa CBOR con chiavi intere; una risposta è un byte di stato seguito, se lo stato è 0x00, da una mappa CBOR. Le chiavi intere al posto dei nomi servono a stare dentro dispositivi con pochi KB di RAM, e la codifica è canonica (chiavi ordinate, lunghezze minime) perché ogni byte deve essere deterministico.
| Byte | Comando | A cosa serve |
|---|---|---|
| 0x01 | authenticatorMakeCredential | Crea una credenziale (registrazione) |
| 0x02 | authenticatorGetAssertion | Firma una challenge (autenticazione) |
| 0x04 | authenticatorGetInfo | Versioni, estensioni, AAGUID, opzioni, limiti |
| 0x06 | authenticatorClientPIN | Gestione PIN e pinUvAuthToken (subCommand) |
| 0x07 | authenticatorReset | Cancella tutto: credenziali, PIN. Solo entro 10 s dall'accensione |
| 0x08 | authenticatorGetNextAssertion | Le altre asserzioni, se le credenziali sono più di una |
| 0x09 | authenticatorBioEnrollment | Registrazione delle impronte (chiavette biometriche) |
| 0x0A | authenticatorCredentialManagement | Elenca e cancella le passkey salvate |
| 0x0B | authenticatorSelection | «Tocca la chiavetta che vuoi usare» |
| 0x0C | authenticatorLargeBlobs | Piccoli blob cifrati associati alle credenziali |
| 0x0D | authenticatorConfig | enterprise attestation, alwaysUv, lunghezza minima PIN |
Ecco i messaggi di una registrazione completa con una chiavetta con PIN, nell'ordine in cui la piattaforma li manda. Sono gli stessi byte che passano sul cavo, dentro i pacchetti USB che vedremo tra poco.
piattaforma → autenticatore · 0x01 authenticatorMakeCredential · 238 byte
byte 0–0 · 1 B
command
0x01 = authenticatorMakeCredential. Il byte di comando precede la mappa CBOR.
Dalla chiamata WebAuthn al comando CTAP
Il client traduce: residentKey: "required" diventa options: { rk: true }, excludeCredentials diventa la excludeList (chiave 0x05), userVerification: "required" impone di ottenere un pinUvAuthToken prima del comando, le estensioni WebAuthn (prf, credProtect, largeBlob) diventano estensioni CTAP (hmac-secret, credProtect, largeBlobKey). E al ritorno riscrive la risposta con chiavi testuali. Se l'autenticatore risponde con un errore, il sito non vede il codice CTAP: vede un DOMException generico, quasi sempre NotAllowedError, per non rivelare informazioni sugli autenticatori presenti.
| Codice | Nome | Quando |
|---|---|---|
| 0x00 | CTAP2_OK | Successo |
| 0x19 | CTAP2_ERR_CREDENTIAL_EXCLUDED | Una credenziale in excludeList esiste già: il browser restituisce InvalidStateError |
| 0x27 | CTAP2_ERR_OPERATION_DENIED | L'utente ha rifiutato |
| 0x28 | CTAP2_ERR_KEY_STORE_FULL | Nessuno slot libero per una resident key |
| 0x2E | CTAP2_ERR_NO_CREDENTIALS | Nessuna credenziale per l'rpId o nella allowList |
| 0x2F | CTAP2_ERR_USER_ACTION_TIMEOUT | Nessun tocco entro il timeout |
| 0x31 | CTAP2_ERR_PIN_INVALID | PIN sbagliato |
| 0x32 | CTAP2_ERR_PIN_BLOCKED | Tentativi esauriti: serve un reset, che cancella tutto |
| 0x33 | CTAP2_ERR_PIN_AUTH_INVALID | pinUvAuthParam non valido |
| 0x35 | CTAP2_ERR_PIN_NOT_SET | Serve UV ma il PIN non è impostato |
| 0x36 | CTAP2_ERR_PUAT_REQUIRED | Il comando richiede un pinUvAuthToken |
Chiavette FIDO2: USB HID e NFC
Una chiavetta FIDO2 su USB è un dispositivo HID (Human Interface Device), la stessa classe di tastiere e mouse: nessun driver, funziona ovunque. Si riconosce dalla usage page 0xF1D0 e scambia report di 64 byte. Il protocollo di trasporto, CTAPHID, aggiunge tre cose: canali (più applicazioni sullo stesso dispositivo), frammentazione (messaggi più lunghi di 64 byte) e keepalive (mentre la chiavetta aspetta il tocco).
Scoperta e canale
1. La pagina chiede una credenziale
Frame e pacchetti
Il pacchetto iniziale ha 4 byte di Channel ID, 1 di comando (con il bit alto a 1), 2 di lunghezza totale e 57 di dati. Quelli di continuazione hanno il CID, un numero di sequenza da 0 a 127 e 59 byte di dati. Il resto del report si riempie di zeri. Scegli un messaggio e un trasporto per vedere come viene tagliato.
piattaforma → autenticatore · 0x01 authenticatorMakeCredential · messaggio 238 B → 5 frame, 320 B sul filo
init · 64 B · CID (4) · CMD 0x90 = CTAPHID_CBOR | 0x80 · BCNT (2) · dati (57)
cont 0 · 64 B · CID (4) · SEQ 0x00 · dati (59)
cont 1 · 64 B · CID (4) · SEQ 0x01 · dati (59)
cont 2 · 64 B · CID (4) · SEQ 0x02 · dati (59)
cont 3 · 64 B · CID (4) · SEQ 0x03 · dati (59)
| CMD | Nome | Uso |
|---|---|---|
| 0x83 | CTAPHID_MSG | Messaggi CTAP1/U2F (APDU) |
| 0x86 | CTAPHID_INIT | Allocare un Channel ID |
| 0x81 | CTAPHID_PING | Eco, per test |
| 0x88 | CTAPHID_WINK | Fa lampeggiare il LED, per riconoscere la chiavetta |
| 0x90 | CTAPHID_CBOR | Messaggi CTAP2: comando + CBOR |
| 0x91 | CTAPHID_CANCEL | Annulla l'operazione in corso |
| 0xBB | CTAPHID_KEEPALIVE | «Sto lavorando» / «aspetto il tocco» |
| 0xBF | CTAPHID_ERROR | Errore di trasporto (canale occupato, sequenza sbagliata…) |
NFC
Su NFC la chiavetta è una smart card ISO 7816. La piattaforma seleziona l'applet FIDO con una SELECT sull'AID A0000006472F0001 (la risposta FIDO_2_0 o U2F_V2 dice cosa parla), poi incapsula ogni messaggio CTAP2 in un APDU con CLA 0x80 e INS 0x10 (NFCCTAP_MSG). Non ci sono keepalive asincroni: se l'operazione è lunga, la chiavetta risponde con lo status 9100 e la piattaforma interroga con NFCCTAP_GETRESPONSE. La user presence è implicita: avvicinare la chiavetta al lettore è il gesto.
| USB HID | NFC | BLE (GATT) | Hybrid | |
|---|---|---|---|---|
| Livello fisico | USB, report da 64 B | ISO 14443, APDU ISO 7816-4 | GATT, service 0xFFFD | Annuncio BLE + WebSocket via internet |
| Frammentazione | init 57 B, cont 59 B | APDU chaining o extended length | frammenti di fidoControlPointLength | Messaggi interi nel tunnel |
| Cifratura del trasporto | No (cavo) | No (pochi cm) | Pairing BLE (LE Secure Connections) | Noise end-to-end |
| User presence | Tocco sul sensore | Avvicinare la chiavetta | Pulsante | UI del telefono |
| Tipico | Chiavette, desktop | Chiavette e telefoni | Poche chiavette, ormai rare | Telefono come autenticatore per il PC |
Più chiavette collegate
PIN e pinUvAuthToken
Una chiavetta senza schermo né tastiera fa user verification con un PIN digitato sulla piattaforma. Il problema è ovvio: il PIN deve arrivare alla chiavetta senza viaggiare in chiaro e senza che un malware sul cavo possa riutilizzarlo. CTAP lo risolve con il protocollo clientPIN.
- Accordo di chiavi: la chiavetta espone una chiave ECDH P-256 effimera, la piattaforma ne genera una sua, entrambe calcolano Z. Con il protocollo 2, HKDF-SHA-256 ricava da Z una chiave HMAC e una AES-256.
- PIN cifrato: la piattaforma manda i primi 16 byte di SHA-256(PIN), cifrati in AES-CBC con IV casuale. La chiavetta confronta con l'hash salvato.
- Token: se il PIN è giusto, la chiavetta restituisce un pinUvAuthToken cifrato, con permessi (mc, ga, cm…) e legato a un rpId. Il token vive in RAM e scade.
- Autorizzazione dei comandi: ogni makeCredential o getAssertion porta
pinUvAuthParam = HMAC-SHA-256(token, clientDataHash). La chiavetta lo ricalcola e imposta UV = 1.
token = 32 byte casuali (decifrati da getPinUvAuthToken)
clientDataHash = 03810f69dcb0fdcfe96cf36d66e81fc14478fc2414edd3b090b096cde2c19a23
pinUvAuthParam = HMAC-SHA-256(token, clientDataHash) // protocollo 2: 32 B
// protocollo 1: primi 16 BIl PIN ha 8 tentativi in tutto; dopo 3 errori consecutivi la chiavetta pretende di essere scollegata e ricollegata, così un malware non può provarli tutti in un colpo. Esauriti i tentativi, l'unica strada è il reset, che cancella tutte le credenziali. Le chiavette con lettore di impronte usano lo stesso schema: getPinUvAuthTokenUsingUvWithPermissions (subCommand 0x06) ottiene il token con la biometria invece che con il PIN.
Il telefono come autenticatore: hybrid via BLE
Il caso più comune oggi: sei su un PC che non ha la tua passkey, che invece sta nel telefono. Il browser mostra un QR code, lo inquadri, confermi con l'impronta, e sul PC sei dentro. Il trasporto si chiama hybrid (CTAP 2.2; era caBLE v2, «cloud-assisted BLE») ed è un ibrido davvero: il Bluetooth serve solo a dimostrare la vicinanza, mentre i dati passano da internet, attraverso un tunnel server, cifrati end-to-end con Noise.
Perché non tutto in Bluetooth? Il vecchio trasporto BLE di CTAP richiede pairing, e il pairing tra un telefono e un PC qualunque è fragile e invasivo. Perché non tutto via internet? Perché un QR code si può fotografare e inoltrare: un sito di phishing potrebbe mostrare all'utente il QR generato dal PC dell'attaccante. Con hybrid il PC deve ricevere via radio un annuncio del telefono per poter aprire il tunnel: se il PC è dall'altra parte del mondo, non lo riceve.
1 · QR code
1. Nessuna passkey su questo PC
Le chiavi in gioco
Tutto discende da due valori nel QR: la identity key pubblica del PC e un qrSecret di 16 byte. Da qrSecret, con HKDF, entrambi derivano la chiave dell'annuncio (EID key) e il tunnel ID. Dall'annuncio decifrato, insieme a qrSecret, derivano la psk dell'handshake. Nell'handshake Noise_KNpsk0_P256_AESGCM_SHA256 il telefono autentica il PC tramite la identity key letta nel QR, la psk lega la sessione al QR e al Bluetooth, le chiavi effimere danno forward secrecy. Il tunnel server vede due WebSocket e byte cifrati.
┌──────────── AES-256(eidKey[0:32]) ────────────┐┌ HMAC[0:4] ┐ │ 00 │ nonce (10 B) │ routing ID (3 B) │ dom (2) ││ tag (4) │ └────────────────────────────────────────────────┘└───────────┘ 20 byte in tutto: entrano in un singolo advertisement BLE legacy. Nessuna connessione GATT, nessun pairing.
Linking: la seconda volta senza QR
Dopo il primo uso il telefono può offrire al PC dei dati di linking: un identificativo per contattarlo con una notifica push e un segreto condiviso. La volta successiva il PC mostra il telefono nell'elenco, lo sveglia via push con i parametri del tunnel, e il resto è identico, annuncio BLE compreso: anche un dispositivo collegato deve essere vicino. È così che Chrome mostra «Usa il telefono di Gianni» senza QR.
E il vecchio CTAP su BLE?
Esiste ancora, per le chiavette Bluetooth: un servizio GATT FIDO (UUID 0xFFFD) con le caratteristiche fidoControlPoint (scrittura delle richieste), fidoStatus (notifiche con le risposte), fidoControlPointLength e fidoServiceRevisionBitfield. I frame hanno un byte di comando (0x83 MSG, 0x82 KEEPALIVE, 0xBF ERROR), due di lunghezza e frammenti con numero di sequenza, come nel widget sopra. Richiede pairing con LE Secure Connections. È poco diffuso: per i telefoni ha vinto hybrid.
Passkey sincronizzate e flag BE/BS
Per anni FIDO ha avuto un problema di adozione: se la chiave privata non esce mai dal dispositivo, perdere il dispositivo vuol dire perdere l'account. Le passkey sincronizzate cambiano il compromesso: la chiave privata viene cifrata end-to-end e copiata sui dispositivi dello stesso utente dal gestore di passkey (Portachiavi iCloud, Google Password Manager, gestori di password di terze parti). Il server lo sa grazie a due flag dell'authenticatorData.
| Device-bound | Sincronizzata | |
|---|---|---|
| Flag | BE = 0, BS = 0 | BE = 1, BS = 1 (BS può cambiare nel tempo) |
| Esempi | Chiavetta FIDO2, chiave in un TPM | Portachiavi iCloud, Google Password Manager, 1Password, Bitwarden |
| Chiave privata | Non esportabile, in hardware | Cifrata end-to-end e copiata sui dispositivi dell'utente |
| Se perdi il dispositivo | Perdi la credenziale: registrane almeno due | La recuperi dal gestore |
| signCount | Cresce a ogni uso | Di solito 0 |
| Attestation | Sì, verificabile con il Metadata Service | Di norma none |
| Livello di assurance | AAL3 (NIST SP 800-63B-4) | AAL2 |
BE (Backup Eligible) è fisso per tutta la vita della credenziale: dice se può essere sincronizzata. BS (Backup State) può cambiare: dice se è sincronizzata ora. Un uso pratico: se una credenziale è l'unico metodo di accesso e ha BS = 0, conviene suggerire all'utente di registrarne un'altra. Se invece la policy richiede chiavi non esportabili, il server rifiuta BE = 1 in registrazione.
Per spostare le passkey da un gestore all'altro, FIDO Alliance ha definito il Credential Exchange Protocol e Format (CXP/CXF). Per tenere allineati sito e gestore, WebAuthn Level 3 ha la Signal API: signalUnknownCredential (questa credenziale non esiste più sul server), signalAllAcceptedCredentials e signalCurrentUserDetails (l'utente ha cambiato email o nome).
Implementazione lato server
Il parsing di CBOR, COSE, attestation e firme DER non va scritto a mano in produzione. Ogni linguaggio ha una libreria matura: in Node.js SimpleWebAuthn, in Java webauthn4j o java-webauthn-server di Yubico, in Go go-webauthn, in Python py_webauthn, in .NET fido2-net-lib. Keycloak, Auth0, Entra ID e gli altri identity provider le integrano. Ecco i due endpoint con SimpleWebAuthn.
import { generateRegistrationOptions, verifyRegistrationResponse } from "@simplewebauthn/server";
const rpID = "example.com";
const expectedOrigin = ["https://login.example.com"];
// POST /webauthn/register/options
const options = await generateRegistrationOptions({
rpName: "Example",
rpID,
userName: user.email,
userID: user.webauthnHandle, // 16-64 byte casuali, non l'email
attestationType: "none",
excludeCredentials: user.credentials.map((c) => ({ id: c.id, transports: c.transports })),
authenticatorSelection: { residentKey: "required", userVerification: "preferred" },
});
session.challenge = options.challenge; // monouso, scadenza breve
return options;
// POST /webauthn/register/verify
const { verified, registrationInfo } = await verifyRegistrationResponse({
response: body,
expectedChallenge: session.challenge,
expectedOrigin,
expectedRPID: rpID,
});
delete session.challenge;
if (verified) {
const { credential, credentialDeviceType, credentialBackedUp, aaguid } = registrationInfo;
await db.credentials.insert({
id: credential.id,
publicKey: credential.publicKey, // COSE_Key, Uint8Array
counter: credential.counter,
transports: credential.transports,
userId: user.id,
deviceType: credentialDeviceType, // "singleDevice" | "multiDevice" (BE)
backedUp: credentialBackedUp, // BS
aaguid,
});
}import { generateAuthenticationOptions, verifyAuthenticationResponse } from "@simplewebauthn/server";
// POST /webauthn/login/options
const options = await generateAuthenticationOptions({ rpID, userVerification: "preferred" });
session.challenge = options.challenge;
// POST /webauthn/login/verify
const cred = await db.credentials.findById(body.id);
if (!cred) throw new Unauthorized();
if (body.response.userHandle && body.response.userHandle !== cred.userHandle) throw new Unauthorized();
const { verified, authenticationInfo } = await verifyAuthenticationResponse({
response: body,
expectedChallenge: session.challenge,
expectedOrigin,
expectedRPID: rpID,
credential: { id: cred.id, publicKey: cred.publicKey, counter: cred.counter, transports: cred.transports },
});
delete session.challenge;
if (!verified) throw new Unauthorized();
await db.credentials.update(cred.id, {
counter: authenticationInfo.newCounter,
backedUp: authenticationInfo.credentialBackedUp,
lastUsedAt: new Date(),
});
startSession(cred.userId);Errori classici
startsWith. rpId diverso tra registrazione e login (la credenziale «sparisce»). user handle uguale all'email. Nessuna excludeCredentials, e l'utente registra due volte la stessa chiavetta. Nessun modo per gestire le passkey: l'utente deve poterle vedere, rinominare e revocare.Threat model: cosa protegge e cosa no
WebAuthn risolve molto bene un problema preciso: dimostrare che l'utente possiede una chiave legata a questo sito, senza segreti riutilizzabili. Tutto quello che sta intorno resta da progettare.
Phishing e AitM
Un proxy alla Evilginx inoltra password, OTP e push, ma non una firma WebAuthn: il browser scrive nel clientDataJSON l'origin del proxy, e l'rpIdHash sarebbe quello del dominio falso. Il punto debole diventa il fallback: se il login accetta ancora password + SMS, l'attaccante farà un downgrade.
Sottodomini
Una credenziale con rpId example.com è utilizzabile da qualunque sottodominio. Un sottodominio compromesso o preso con un DNS dimenticato (subdomain takeover) può chiedere asserzioni valide. Scegli l'rpId più stretto che ti serve e tieni l'inventario dei sottodomini.
XSS sull'origin del sito
WebAuthn lega la firma all'origin, non al codice: uno script iniettato nella tua pagina può chiamare credentials.get() e ottenere un'asserzione, se l'utente fa il gesto. Content Security Policy e igiene del frontend restano necessarie.
Furto della sessione
Dopo il login c'è un cookie. Un infostealer che lo copia salta l'autenticazione. Cookie brevi, rotazione, e per il futuro Device Bound Session Credentials, che legano la sessione a una chiave del dispositivo.
Recupero dell'account
Se perdere le passkey si risolve con «mandami un link via email», la sicurezza dell'account è quella dell'email. Offri più passkey, codici di recupero, verifiche di identità proporzionate al rischio.
Client compromesso
Browser e sistema operativo sono fidati per definizione: sono loro a scrivere l'origin. Un'estensione malevola con i permessi giusti o un malware con privilegi elevati possono chiedere firme per qualunque sito.
Account del gestore di passkey
Una passkey sincronizzata è sicura quanto l'account che la sincronizza (Apple, Google, gestore di password). I gestori cifrano end-to-end, ma proteggere quell'account diventa critico.
Privacy
Lo user handle non deve contenere email o nomi: alcuni autenticatori lo restituiscono senza UV. L'attestation diretta rivela il modello: chiedila solo se la usi davvero, e in ambito enterprise usa enterprise attestation.
In sintesi
- 1Le passkey sostituiscono un segreto condiviso con una coppia di chiavi per sito: il server conserva solo chiavi pubbliche.
- 2La resistenza al phishing nasce dal client: il browser scrive l'origin nel clientDataJSON e l'autenticatore firma l'hash dell'rpId.
- 3In registrazione il server verifica clientDataJSON, rpIdHash, flag e attestation, e salva la chiave COSE; in login verifica una firma su authenticatorData ‖ SHA-256(clientDataJSON).
- 4authenticatorData è un formato a campi fissi: rpIdHash, flag UP/UV/BE/BS/AT/ED, contatore e, alla creazione, AAGUID, credential ID e chiave pubblica.
- 5CTAP2 è il protocollo verso gli autenticatori esterni: comandi a un byte e mappe CBOR canoniche con chiavi intere.
- 6Su USB viaggia in report HID da 64 byte con canali, frammentazione e keepalive; su NFC in APDU; il PIN passa cifrato via ECDH e autorizza i comandi con un HMAC.
- 7Con hybrid il telefono fa da autenticatore per il PC: QR per le chiavi, Bluetooth solo per la prossimità, tunnel cifrato Noise per i messaggi CTAP.
- 8Passkey sincronizzate (BE/BS) per gli utenti consumer, chiavi device-bound con attestation dove serve l'assurance più alta. E nessun fallback debole.
Per approfondire: W3C Web Authentication Level 3, FIDO Client to Authenticator Protocol 2.2 (in particolare le sezioni su CTAPHID, NFC, BLE e hybrid), FIDO Metadata Service 3, RFC 8949 (CBOR), RFC 9052 e 9053 (COSE), il framework Noise, NIST SP 800-63B-4 e la documentazione di passkeys.dev.