Generator și verificator de hash pentru parole

Se generează și se verifică hash-uri de parole cu bcrypt, scrypt, Argon2id și PBKDF2 integral în browser — se generează șiruri în format PHC, se verifică o parolă candidată față de un hash existent și se inspectează parametrii ascunși în el. Nimic nu se încarcă.
Doar pentru parole de test. Parolele reale ale utilizatorilor nu ar trebui lipite niciodată în nicio pagină web. Instrumentul rulează integral în browser — șirurile nu părăsesc niciodată tab-ul — dar o scurgere reală de date începe cu o singură lipire.
cost bcrypt (2^cost runde)
varianta bcrypt varianta schimbă doar prefixul; hash-ul în sine este identic
N scrypt (cost CPU)
r / p scrypt r =   p = dimensiunea blocului 128·r octeți; memoria = 128·N·r octeți (N=214, r=8 → 16 MiB)
Argon2id m (memorie)
Argon2id t / p t =   p = t = treceri; p = paralelism (benzi)
Funcție PRF PBKDF2
Iterații PBKDF2  OWASP 2023: 600.000 pentru HMAC-SHA-256 (1.300.000 pentru SHA-1, 210.000 pentru SHA-384/512)
Lungimea ieșirii (octeți)  ieșirea bcrypt este fixă la 23 de octeți (31 de caractere base64 bcrypt)
AlgoritmParametriMemorieLungimea ieșiriiTimp (acest browser)
bcryptcost 124 KiB23 de octeți-
scryptN=214, r=8, p=116 MiB32 de octeți-
Argon2idm=19 MiB, t=2, p=119 MiB32 de octeți-
PBKDF2HMAC-SHA-256, 600.000 de iterații~032 de octeți-
Fișă cu parametri (Cheat Sheet-ul OWASP pentru stocarea parolelor, minimele din 2023)
AlgoritmMinimumNote
Argon2idm = 19 MiB (19.456 KiB), t = 2, p = 1preferat; dur la memorie
scryptN = 214, r = 8, p = 1dur la memorie (16 MiB, minimul)
bcryptcost = 10doar factor de lucru; limită de 72 de octeți pentru parolă
PBKDF2-HMAC-SHA256600.000 de iterațiidur doar la iterații — prietenos cu GPU-urile, ultima alegere
Valorile implicite ale acestei pagini sunt la sau peste fiecare minim. Pentru producție se alege mai întâi Argon2id, scrypt sau bcrypt dacă nu este disponibil, iar PBKDF2 doar din motive de conformitate FIPS.
Interoperabilitate PHP — password_hash($pw, PASSWORD_BCRYPT) produce $2y$10$...: se lipește în Verificare împreună cu parola candidată, iar pagina răspunde exact ce ar răspunde password_verify(). Ieșirea PASSWORD_ARGON2ID ($argon2id$v=19$m=65536,t=4,p=1$...) se verifică și ea. Șirurile PHC din passlib, django-argon2 și din învelișul crypto.scrypt se analizează și ele.
Autotest
Rulează din nou motorul paginii față de vectori publici: suita de teste crypt_blowfish pentru bcrypt, șiruri scrypt și Argon2id generate cu node/OpenSSL, vectorii PBKDF2 din RFC 6070 și setul public SHA-256, plus transformări generare-apoi-verificare în fiecare algoritm și teste negative (parola greșită trebuie să eșueze, șirurile malformate trebuie respinse). Nimic nu se trimite nicăieri.
Hashing-ul parolelor explicat de la zero
Într-o propoziție: un hash de parolă este intenționat lent (și de preferat avid de memorie), astfel încât furtul bazei de date să nu permită unui atacator să încerce miliarde de ghiciri pe secundă — scop opus unui hash rapid precum SHA-256, construit pentru viteză.
De ce să nu se aplice pur și simplu SHA-256 pe parolă?

SHA-256 pe un GPU modern rulează cu miliarde de ghiciri pe secundă. O parolă de 8 caractere are mult sub 1013 combinații — ore de timp GPU, minute pe o instalație mare. Funcțiile de hash pentru parole (KDF) luptă împotriva asta prin parametri de cost: bcrypt repetă nucleul de 2cost ori, PBKDF2 iterează HMAC de sute de mii de ori, iar scrypt și Argon2id cer în plus o memorie de ordinul megaoctetelor pentru fiecare ghicire, astfel încât GPU-urile (rapide, dar cu puțină memorie pe nucleu) își pierd avantajul. O sare — aleatoare, stocată în clar în șirul hash — oprește tabelele rainbow precalculate și obligă fiecare ghicire să fie calculată din nou, pentru fiecare utilizator.

Cei patru algoritmi de pe această pagină
AlgoritmAnDuritateFormat de semnăturăAtenție la
bcrypt1999CPU (2cost configurări ale cheii)$2b$12$ + sare de 22 de caractere + hash de 31 de caractereLimită de 72 de octeți pentru parolă (tot ce depășește 72 este ignorat în tăcere); octetul NUL încheie parola în implementarea C originală
PBKDF22000 (RFC 2898/8018)CPU (iterații)$pbkdf2-sha256$i=600000$ + sare + hash (stil passlib)fără cost de memorie — GPU-urile și ASIC-urile îl iubesc; se poate regla doar numărul de iterații
scrypt2009 (RFC 7914)CPU + memorie (128·N·r octeți)$scrypt$ln=14,r=8,p=1$ + sare + hashN trebuie să fie o putere a lui doi; memoria crește liniar cu r
Argon2id2015 (câștigătorul PHC, RFC 9106)CPU + memorie (m KiB, t treceri)$argon2id$v=19$m=19456,t=2,p=1$ + sare + hashArgon2i (independent de date) față de Argon2d (dependent de date) față de Argon2id (hibrid) — se alege întotdeauna id, dacă nu există un motiv special
Duritate la memorie față de duritate la calcul

Un GPU are mii de nuclee, dar fiecare nucleu are acces la puțină memorie rapidă. O funcție de derivare a cheii care cere 19 MiB de memorie de lucru pentru fiecare ghicire limitează atacatorul la atâtea ghiciri paralele câte porțiuni de 19 MiB de memorie are — de aceea Argon2id la 19 MiB poate fi mai puternic în practică decât bcrypt la cost 15, deși durează mai puțin pe laptop. PBKDF2 nu are răspuns la asta: singurul său reglaj este numărul de iterații, iar siliciul îl scalează liniar.

Citirea unui șir PHC

Formatul modular-crypt / PHC este autodescriptiv: în $argon2id$v=19$m=19456,t=2,p=1$ICEiIyQlJicoKSorLC0uLw$WTGpK4hf... câmpurile sunt algoritmul, versiunea, parametrii (m = memoria în KiB, t = treceri, p = benzi), sarea în base64 și hash-ul în base64. bcrypt precede standardul și folosește propria formă compactă: varianta $2b$, costul 12, apoi sarea și hash-ul în alfabetul base64 propriu bcrypt (./A-Za-z0-9). Verificarea din această pagină acceptă toate acestea și arată câmpurile analizate — se lipește orice hash găsit și se vede în ce se descompune.

Greșeli frecvente
  • Hash rapid pentru parole. Coloanele de parole cu MD5/SHA-1/SHA-256 cad în fața plăcilor grafice obișnuite, cu miliarde de ghiciri pe secundă. Generatorul de hash este pentru fișiere și date; pentru parole se folosesc algoritmii acestei pagini.
  • Refolosirea aceleiași sări. O singură sare pentru toți utilizatorii înseamnă că parolele identice au hash-uri identice și se întorc tabelele rainbow. Fiecare hash de aici primește o sare aleatoare nouă, de 16 octeți.
  • Ignorarea celor 72 de octeți ai bcrypt. "a"*100 și "a"*72 produc același hash — restul se pierde. Această pagină avertizează în caseta de intrare când parola depășește 72 de octeți. Argon2 nu are o astfel de limită.
  • Compararea hash-urilor cu == în propriul cod. Verificarea trebuie să fie de timp constant; motorul paginii face asta intern (recalculează și compară octeții hash-ului), dar dacă se copiază abordarea, se folosește o comparație de timp constant.
  • Ajustarea parametrilor pe un calculator de dezvoltare rapid. Ținta este ~250–500 ms de calcul pe hardware-ul median al utilizatorilor de producție, nu pe stația de lucru. Butonul Test de performanță arată ce simte efectiv acest browser.
  • Recalcularea hash-ului la fiecare verificare de autentificare. Întâi se verifică; recalcularea (de exemplu pentru a crește costul) se face doar după o verificare reușită, iar noul șir se stochează. Funcția PHP password_needs_rehash() există tocmai pentru asta.
Întrebări frecvente

Care ar trebui aleasă? Argon2id cu cel puțin minimele OWASP. Dacă runtime-ul nu o oferă: scrypt, apoi bcrypt (cu un cost pentru care hashing-ul durează ≥250 ms). PBKDF2 doar acolo unde certificarea o cere.

De ce apare o sare aleatoare în șirul de ieșire? Sarea nu este un secret — este stocată în clar în șirul PHC intenționat, astfel încât verificarea să nu aibă nevoie de nimic în afară de șir și de parola candidată. Rolul ei este unicitatea, nu secretul.

Contează varianta ($2a$ / $2b$ / $2y$)? Pentru parole ASCII produc hash-uri identice; $2a$ este originalul din anii 1990, $2b$ a reparat o eroare rară de extensie a semnului (2014), iar $2y$ este marcajul PHP care arată că reparația este prezentă. Verificarea acceptă toate trei.

Cât ar trebui să dureze un hash? Aproximativ 250–500 ms pentru fiecare autentificare pe hardware de server. Sub 100 ms, spargerea offline devine ieftină; peste 1 s, utilizatorii se plâng înainte ca securitatea să se îmbunătățească.

Pot verifica un hash produs în altă parte? Da — se lipește și se dă parola candidată. Formate cunoscute ca funcționale: password_hash din PHP (bcrypt $2y$ și Argon2id), passlib pentru Python, hasher-ul argon2 din Django și formatul de șir scrypt folosit de unealta scrypt a Tarsnap.

Ce face butonul „test de performanță”? Calculează o dată hash-ul parolei curente cu fiecare algoritm, la valorile prestabilite ale paginii, și raportează timpul real din acest browser — o idee despre diferențele de cost, nu o măsurătoare riguroasă.