PKCE Challenge Generator
Genera coppie code_verifier e code_challenge per il flusso OAuth 2.0 Authorization Code con PKCE (RFC 7636). Metodo S256 e plain supportati.
Genera Coppia PKCE
RFC 7636 richiede tra 43 e 128 caratteri. Valori tra 64 e 96 sono consigliati.
Come utilizzare PKCE Challenge Generator
Seleziona il metodo di challenge
Scegli "S256" (raccomandato) per generare il code_challenge come hash SHA-256 del code_verifier, codificato in Base64URL. Il metodo "plain" usa il code_verifier direttamente come challenge: da usare solo se il client non supporta SHA-256.
Imposta la lunghezza del code_verifier
Usa il cursore per scegliere la lunghezza del code_verifier tra 43 e 128 caratteri (RFC 7636). Una lunghezza di 64 caratteri offre un ottimo equilibrio tra sicurezza e compatibilità. Più lunga è la stringa, maggiore è l'entropia.
Genera la coppia PKCE
Clicca "Genera" per creare una nuova coppia code_verifier / code_challenge. La generazione avviene interamente nel browser usando l'API Web Crypto: nessun dato viene inviato a server esterni.
Copia i valori e usali nel flusso OAuth 2.0
Copia il code_verifier e conservalo in modo sicuro (es. sessionStorage). Invia il code_challenge al server di autorizzazione nella richiesta iniziale. Al momento dello scambio del codice, invia il code_verifier originale per la verifica.
Consulta il template URL di autorizzazione
La sezione "Flusso OAuth 2.0" mostra un esempio di URL di autorizzazione con i valori generati già inseriti. Sostituisci i segnaposto con i tuoi valori reali (authorization_endpoint, client_id, redirect_uri, scope).
Suggerimenti
- Genera sempre un nuovo code_verifier per ogni flusso OAuth: non riutilizzare mai lo stesso valore. La freschezza del verifier è parte essenziale della protezione offerta da PKCE.
- Se il tuo server di autorizzazione lo supporta, preferisci sempre il metodo S256. Alcuni server rifiutano esplicitamente il metodo plain per motivi di sicurezza.
- Lunghezze di code_verifier comprese tra 64 e 96 caratteri offrono un ottimo compromesso tra sicurezza (alta entropia) e compatibilità con server che limitano la dimensione dei parametri URL.
Domande frequenti
Cos'è PKCE e perché è importante?
PKCE (Proof Key for Code Exchange, RFC 7636) è un'estensione del flusso Authorization Code di OAuth 2.0. Protegge i client pubblici (app mobile, SPA) dall'attacco di intercettazione del codice di autorizzazione. Senza PKCE, un'applicazione malevola che intercettasse il codice potrebbe scambiarlo con un access token. Con PKCE, solo il client che ha generato il code_verifier può completare lo scambio.
Qual è la differenza tra S256 e plain?
Con il metodo S256, il code_challenge viene calcolato come Base64URL(SHA-256(ASCII(code_verifier))). È il metodo raccomandato da RFC 7636 e obbligatorio per i server conformi alle specifiche più recenti. Il metodo plain usa il code_verifier direttamente come challenge ed è deprecato: va usato solo se il client non può eseguire SHA-256, ma in questo caso il flusso non offre protezione aggiuntiva reale.
Come devo conservare il code_verifier?
Il code_verifier deve essere generato casualmente per ogni richiesta di autorizzazione e conservato temporaneamente (es. sessionStorage o memoria in-app) fino al momento dello scambio del codice. Non salvarlo in localStorage in quanto persiste tra sessioni. Non inviarlo mai prima del momento dello scambio: solo il code_challenge viaggia nella prima richiesta.
Il code_verifier generato qui è sicuro per la produzione?
Sì. Il generatore usa window.crypto.getRandomValues, la stessa API crittograficamente sicura usata dai browser per generare numeri casuali. I valori sono generati solo nel tuo browser e non vengono mai inviati a server. Tuttavia, questo strumento è pensato per test e sviluppo: in produzione il code_verifier deve essere generato dall'applicazione client a ogni avvio del flusso.
Quali caratteri sono ammessi nel code_verifier?
Secondo RFC 7636, il code_verifier può contenere solo caratteri "unreserved" dell'URI: lettere maiuscole (A-Z), lettere minuscole (a-z), cifre (0-9), trattino (-), punto (.), underscore (_) e tilde (~). La lunghezza deve essere tra 43 e 128 caratteri. Questo generatore rispetta esattamente questi vincoli.
Cos'è la codifica Base64URL?
Base64URL è una variante di Base64 progettata per essere usata in URL e header HTTP senza encoding aggiuntivo. Usa "-" al posto di "+" e "_" al posto di "/", e omette il padding "=". Il code_challenge in metodo S256 usa questa codifica per rappresentare il digest SHA-256 del code_verifier.