PBKDF2 online - derivazione chiave

Deriva una chiave crittografica da una password con PBKDF2-HMAC direttamente nel browser. Configura funzione hash (SHA-1, SHA-256, SHA-384 o SHA-512), iterazioni, lunghezza dell'output e salt. La modalità Verify confronta una password candidata con un valore PBKDF2 hex esistente.

Salt (vuoto — casuale)
Password
0 caratt. · 0 byte
Hash da verificare
Prova:
Risultato
✓ Elaborazione locale nel browser ✓ L’input non viene inviato al server
Esempi
Password comune
Funzione hash: SHA-256 Iterazioni: 600000 Lunghezza chiave (byte): 32
Input password123

Una password utente tipica. Premi Compute per derivare una chiave con le impostazioni correnti.

Passphrase
Funzione hash: SHA-256 Iterazioni: 600000 Lunghezza chiave (byte): 32
Input cavallo corretto batteria graffetta

Una passphrase lunga è facile da ricordare e di solito offre più entropia di una password breve.

PBKDF2-HMAC-SHA512
Funzione hash: SHA-512 Iterazioni: 210000 Lunghezza chiave (byte): 64 Salt (vuoto — casuale): docs-example-salt
Input segreto-note-rilascio

Usa SHA-512, output da 64 byte e un salt fisso di esempio per documentazione ripetibile o test di interoperabilità.

Controllo ad alto costo
Funzione hash: SHA-256 Iterazioni: 1000000 Lunghezza chiave (byte): 32 Salt (vuoto — casuale): login-user-42-unique-salt
Input passphrase pannello admin

Esecuzione PBKDF2-HMAC-SHA256 con un milione di iterazioni per confrontare la latenza e verificare che gli stessi parametri riproducano la stessa chiave.

Che cos'è PBKDF2?

PBKDF2 (Password-Based Key Derivation Function 2) è un algoritmo di derivazione di chiavi da password, definito in RFC 2898 e standardizzato in NIST SP 800-132. Usa una password, un salt, un numero di iterazioni, una funzione pseudo-casuale come HMAC-SHA256 e una lunghezza di output per produrre una chiave crittografica deterministica.

L'algoritmo è volutamente costoso: ogni iterazione ripete il lavoro HMAC, quindi ogni tentativo di password richiede più tempo. Questo strumento PBKDF2 online usa la Web Crypto API del browser per derivare una chiave hex localmente, senza inviare password o salt al server.

PBKDF2 è usato per archiviazione password, formati di file cifrati, backup di wallet, fixture API e sistemi compatibili in cui un protocollo richiede PBKDF2-HMAC-SHA256 o PBKDF2-HMAC-SHA512.

PBKDF2 vs bcrypt vs Argon2

PBKDF2 è l'opzione di derivazione più portabile: è disponibile nei browser, in OpenSSL, Java, .NET, Python, Node.js, API dei sistemi operativi e molti ambienti orientati alla conformità. Per questo è utile per password hashing interoperabile, migrazioni legacy e sistemi che richiedono compatibilità PBKDF2_HMAC o pbkdf2_sha256.

Il suo limite è che dipende quasi solo dalla CPU e non ha un costo di memoria significativo. Attaccanti con GPU e ASIC possono parallelizzare i tentativi PBKDF2 molto meglio di server applicativi ordinari.

bcrypt resiste meglio agli attacchi GPU grazie al piccolo stato interno in memoria. Argon2id è la scelta moderna predefinita per nuovi sistemi di archiviazione password perché è memory-hard e configurabile. Scegli Argon2id se controlli lo stack; scegli PBKDF2 quando compatibilità, Web Crypto, ambienti FIPS o requisiti di protocolli esistenti sono più importanti.

Parametri PBKDF2: hash, salt, iterazioni, lunghezza

Questo generatore PBKDF2 espone i parametri di cui gli sviluppatori hanno più spesso bisogno. L'opzione hash seleziona il digest HMAC usato come funzione pseudo-casuale: SHA-256 è il default pratico, SHA-512 è comune negli ambienti SHA-2, SHA-384 è disponibile per compatibilità e SHA-1 dovrebbe restare solo per formati legacy.

Il salt deve essere unico per ogni password o chiave derivata. Non deve essere segreto; salvalo insieme all'hash derivato o ai dati cifrati. In produzione genera il salt con una sorgente casuale crittograficamente sicura. Un salt fisso serve solo per esempi ripetibili e vettori di test.

Le iterazioni controllano il costo. Valori più alti rallentano sia la verifica legittima sia gli attacchi offline. Il default è 600.000 iterazioni per PBKDF2-HMAC-SHA256, in linea con la base OWASP 2024. La lunghezza chiave è la dimensione dell'output in byte: 32 byte producono una chiave a 256 bit e un risultato hex di 64 caratteri; 64 byte producono un output a 512 bit.

Generare, verificare e salvare PBKDF2

Usa la modalità Hash per generare un valore PBKDF2 hex da una password e dai parametri scelti. Usa Verify se hai già un valore PBKDF2 hex salvato: lo strumento deriva di nuovo la chiave con lo stesso salt, hash, numero di iterazioni e lunghezza, poi indica se i valori coincidono.

PBKDF2 non può essere decifrato. È una funzione di derivazione monodirezionale, quindi la verifica funziona solo provando la password candidata con i parametri originali e confrontando l'output. Se cambia qualunque parametro - salt, funzione hash, iterazioni o lunghezza - cambia anche il valore derivato.

Per account reali esegui l'hashing delle password sul server applicativo con una libreria mantenuta, rate limiting, monitoraggio e un piano per aggiornare i parametri. Questo calcolatore PBKDF2 online è pensato per apprendimento, debug di interoperabilità, documentazione dei parametri, test vector riproducibili e verifica di hash durante lo sviluppo.

FAQ

OWASP 2024 raccomanda 600.000 iterazioni per PBKDF2-HMAC-SHA-256 e 210.000 per PBKDF2-HMAC-SHA-512. NIST SP 800-132 raccomanda almeno 1.000, ma oggi è un limite minimo molto basso. Il valore corretto dipende da threat model e hardware: punta a 100-500 ms sul tuo server. Più iterazioni rallentano proporzionalmente l'attaccante; meno iterazioni riducono la latenza utente.

Un salt è un valore casuale unico aggiunto a ogni password prima della derivazione. Senza salt, password identiche producono hash identici, rendendo pratici gli attacchi rainbow table. Con un salt unico per utente, l'attaccante deve colpire ogni hash separatamente. Il salt non deve essere segreto, solo unico; 16 byte casuali sono in genere sufficienti. Salvalo insieme all'hash.

Scegli PBKDF2 quando servono supporto ampio delle piattaforme, validazione FIPS o interoperabilità con sistemi legacy. Argon2id è generalmente migliore per nuovi sistemi quando disponibile. PBKDF2 non ha costo di memoria, quindi gli attaccanti possono parallelizzarlo economicamente su GPU. Per applicazioni ad alta sicurezza, Argon2id è la scelta raccomandata.

No. PBKDF2 viene calcolato interamente nel browser tramite Web Crypto API (window.crypto.subtle.deriveBits). Password e salt non lasciano il dispositivo: nessuna richiesta di rete, nessun log, nessuna elaborazione server.

No. PBKDF2 non è cifratura e non ha un'operazione di decifratura. È una funzione monodirezionale di derivazione chiavi. Per controllare una password, deriva PBKDF2 di nuovo con lo stesso salt, hash, iterazioni e lunghezza chiave, poi confronta il nuovo hex con il valore salvato.

Usa PBKDF2-HMAC-SHA256 salvo che un protocollo o database esistente richieda altro. PBKDF2-HMAC-SHA512 è anch'esso comune, soprattutto in sistemi già standardizzati su SHA-512. SHA-384 è disponibile per compatibilità. Evita SHA-1 nei nuovi design; mantienilo solo per formati legacy che richiedono esplicitamente PBKDF2-HMAC-SHA1.

Salva hash derivato, salt, numero di iterazioni, funzione hash e lunghezza chiave. L'output PBKDF2 da solo non basta per verificare una password in seguito, perché il verificatore deve ripetere esattamente gli stessi parametri. Alcuni sistemi codificano tutto in una stringa; altri usano colonne separate.

No. Il salt deve essere unico e preferibilmente casuale, ma non è una chiave segreta. Serve a far produrre output PBKDF2 diversi a password uguali e a impedire il riuso di tabelle precalcolate. Salva il salt accanto all'hash.

Usalo per apprendimento, confronto parametri, controlli di interoperabilità e vettori di test. Per account di produzione calcola e verifica PBKDF2 sul server con salt casuali sicuri, rate limiting, monitoraggio e aggiornamenti controllati dei parametri. L'hashing nel browser da solo non sostituisce i controlli server per lo storage delle password.
Strumenti correlati

Generatore HMAC

Genera un HMAC da testo e chiave segreta direttamente nel browser.