Postmortem di ingegneria

Una passkey, due chiavi: cosa abbiamo imparato su PRF e il fix che protegge ogni nuovo wallet

Due chiavi derivate da una passkey con un segno di spunta che verifica la corrispondenza

TL;DR: WebAuthn PRF è un modo sicuro e deterministico per derivare una chiave wallet: stessa passkey e stesso salt producono sempre lo stesso segreto. Abbiamo trovato un caso in cui un password manager ha restituito un valore alla creazione della passkey e un valore diverso a ogni login successivo. Il nostro errore è stato fidarci del valore di creazione senza verificare che un login lo riproducesse. I fondi sono stati recuperati e sono al sicuro. Il fix introduce un controllo di stabilità in registrazione, un confronto della chiave a ogni login e un ulteriore controllo prima di spostare fondi.

Autore Emin Mahrt

6 minuti di lettura

Questo articolo è disponibile anche in English , Deutsch e Español .

Cosa è successo

La chiave di un wallet Nuri viene derivata sul dispositivo dell’utente dall’output PRF della passkey e non viene mai salvata sui nostri server. In un account, la passkey ha restituito il valore A alla creazione. A è diventato la chiave del wallet e ha ricevuto fondi.

A ogni login successivo, la stessa passkey ha restituito il valore B. B deriva un wallet diverso e vuoto, quindi l’app mostrava saldo zero. I fondi non si erano mossi: l’app derivava semplicemente un altro wallet.

Sono dovute andare storte due cose insieme: il password manager ha fornito due risposte diverse per la stessa passkey e la nostra app non le ha confrontate.

Perché PRF resta lo strumento giusto

PRF è deterministico per progetto. CTAP2 hmac-secret memorizza un segreto casuale per la credenziale e l’output WebAuthn PRF viene calcolato con una formula fissa: HMAC-SHA256(CredRandom, SHA256("WebAuthn PRF" || 0x00 || salt)). Stessa credenziale, stesso salt, stesso risultato.

La nostra derivazione non è mai cambiata. Salt, parametri HKDF e percorso BIP-32 sono identici a quando l’account è stato creato, e la chiave dell’utente interessato si deriva ancora correttamente dal segreto originale. Il problema non era in PRF né nella derivazione, ma nel passaggio da cui prendevamo il valore e nel controllo mancante.

I due errori

Il nostro, ed è il più importante: alla registrazione abbiamo preso l’output PRF da create() e costruito il wallet su quello. La specifica WebAuthn consente che quel valore manchi e non garantisce i login futuri. Abbiamo registrato e finanziato la chiave senza interrogare una seconda volta la passkey, e al login abbiamo mostrato un wallet vuoto invece di segnalare una discrepanza. Tutto questo è stato corretto.

Quello del password manager: una credenziale ha restituito un valore alla creazione e un altro a ogni get(). Abbiamo verificato che il valore di creazione corrisponde esattamente alla formula standard sul segreto archiviato. Il valore di login non corrisponde ad alcun calcolo da quel segreto. Stiamo ancora indagando quale componente della catena passkey su Android lo causi.

Un limite onesto: i nostri dati provano che chiave registrata e chiavi di login differiscono, non se la divergenza esistesse dal primo giorno o sia comparsa dopo. I controlli seguenti coprono entrambi i casi.

Come sono stati recuperati i fondi

Il recupero è la parte rassicurante. Il password manager conserva il segreto da cui viene calcolato l’output PRF. Abbiamo decifrato offline il backup dell’utente, applicato la formula PRF standard e riprodotto esattamente il valore A. Passando A nella nostra derivazione normale è riemersa la chiave originale.

Lo abbiamo dimostrato prima di spostare qualsiasi somma: una firma con la chiave recuperata verifica e lo script ricostruito riproduce esattamente l’indirizzo finanziato. I fondi sono stati poi inviati on-chain alla destinazione scelta dall’utente e confermati. Nessuna chiave privata, output PRF o seed è mai stato pubblicato.

La lezione per tutti gli utenti: il denaro non è mai stato esposto a terzi, perché ogni spesa richiede la chiave dell’utente.

Il fix

Tre controlli, tutti leggeri.

1. Non derivare mai un wallet da un PRF di create(). Dopo create(), leggere sempre il PRF con una get() sulla nuova credenziale e usare quel valore.

2. Confrontare prima di registrare o ricevere fondi. Se create e get non coincidono, fermarsi, non registrare nulla e chiedere all’utente un altro password manager.

3. A ogni login confrontare la chiave derivata con quella salvata per la credenziale. In caso di discrepanza, mostrare un errore chiaro e aprire il supporto. Non mostrare mai un wallet vuoto e non riassociare automaticamente. Prima di qualsiasi migrazione o deposito, derivare e confrontare di nuovo.

Il confronto in registrazione intercetta subito un provider incoerente. Quelli al login e prima dei depositi intercettano risposte che cambiano nel tempo.

Il cuore del controllo in registrazione sta in poche righe:

const created = await createWalletPasskeyCredential(rpId, prfSalt);

const assertion = await getAssertion({ rpId, challenge: randomBytes(32), credIdB64u: created.credIdB64u, prfSalt });

const prf = readPrfFirst(assertion);

if (!prf) throw new Error("missing_prf_after_create");

if (created.prfB64 && created.prfB64 !== toBase64(prf)) throw new Error("prf_unstable");

return { ...created, prfB64: toBase64(prf) };

Test: un provider simulato con risposte diverse tra create e get deve far fallire la registrazione. Un vettore PRF fisso deve dare sempre la stessa chiave. Sul server, un controllo giornaliero trasforma eventuali derive silenziose in un ticket di supporto.

Cosa abbiamo imparato da filekey.app

filekey.app cifra file con chiavi derivate da passkey PRF ed evita del tutto la trappola di create(). La registrazione controlla solo il supporto PRF e la chiave arriva sempre da una get() separata con salt fisso e user verification obbligatoria.

Fonte: https://github.com/RockwellShah/filekey/blob/HEAD/reference/web/webauthn.ts

Abbiamo adottato quel modello aggiungendo il confronto esplicito, così da intercettare un provider incoerente alla registrazione e non dopo un deposito.

Cosa dovrebbero portarsi a casa altri team

- Tratta un PRF di create() come non verificato. Costruisci solo su un valore riprodotto da get().

- Salva la chiave pubblica derivata accanto all’id della credenziale e confrontala a ogni login.

- Fail closed. Un errore in registrazione costa un prompt passkey in più; una chiave sbagliata costa un recupero.

- Testa il guasto, non solo il percorso felice: basta un provider simulato che si contraddice.

- Mantieni la derivazione stabile e versionata, così un segreto recuperato ricostruisce sempre lo stesso wallet.

Cosa significa per gli utenti Nuri

Le tue chiavi vengono derivate sul tuo dispositivo e non sono salvate sui nostri server. La derivazione è invariata e sicura. I fondi interessati sono stati recuperati e i controlli descritti sono ora nell’app. Non è richiesta alcuna azione.

Se vedi un saldo che non torna, contatta il supporto invece di creare un nuovo wallet.

PRF è deterministico e sicuro quando il valore viene verificato. Tre controlli garantiscono ora che ogni discrepanza venga intercettata in registrazione, al login e prima di spostare fondi.

Emin Mahrt · Verifica