Passordhash-generator & -verifikator

Hasher og verifiserer passord med bcrypt, scrypt, Argon2id og PBKDF2 helt i nettleseren — generer PHC-formaterte strenger, sjekk et kandidatpassord mot en eksisterende hash, og inspiser parametrene som er skjult i den. Ingenting lastes opp.
Kun for testpassord. Ekte brukerpassord bør aldri limes inn på noen nettside. Dette verktøyet kjører helt i nettleseren — strengene forlater aldri fanen — men et ekte datainnbrudd begynner med ett enkelt innliming.
bcrypt-kostnad (2^kostnad runder)
bcrypt-variant varianten endrer bare prefikset; selve hashen er identisk
scrypt N (CPU-kostnad)
scrypt r / p r =   p = blokkstørrelse 128·r byte; minne = 128·N·r byte (N=214, r=8 → 16 MiB)
Argon2id m (minne)
Argon2id t / p t =   p = t = passeringer; p = parallellitet (baner)
PBKDF2 PRF
PBKDF2-iterasjoner  OWASP 2023: 600 000 for HMAC-SHA-256 (1 300 000 for SHA-1, 210 000 for SHA-384/512)
Utdatalengde (byte)  bcrypt-utdata er fast 23 byte (31 bcrypt-base64-tegn)
AlgoritmeParametereMinneUtdatalengdeTid (denne nettleseren)
bcryptkostnad 124 KiB23 byte-
scryptN=214, r=8, p=116 MiB32 byte-
Argon2idm=19 MiB, t=2, p=119 MiB32 byte-
PBKDF2HMAC-SHA-256, 600 000 iterasjoner~032 byte-
Parameterjuksark (OWASP Password Storage Cheat Sheet, minimumskrav 2023)
AlgoritmeMinimumMerknader
Argon2idm = 19 MiB (19 456 KiB), t = 2, p = 1foretrukket; minnehard
scryptN = 214, r = 8, p = 1minnehard (16 MiB som minimum)
bcryptkostnad = 10bare arbeidsfaktor; grense på 72 byte for passord
PBKDF2-HMAC-SHA256600 000 iterasjonerbare iterasjonshard — GPU-vennlig, siste valg
Standardverdiene på denne siden ligger på eller over alle minimumskrav. I produksjon velges Argon2id først, deretter scrypt eller bcrypt hvis den ikke er tilgjengelig, og PBKDF2 bare av FIPS-hensyn.
PHP-interoperabilitet — password_hash($pw, PASSWORD_BCRYPT) gir $2y$10$...: lim det inn i Verifiser med kandidatpassordet, så svarer denne siden nøyaktig det password_verify() ville svart. PASSWORD_ARGON2ID-utdata ($argon2id$v=19$m=65536,t=4,p=1$...) verifiseres også. PHC-strenger fra passlib, django-argon2 og innpakninger av crypto.scrypt tolkes også.
Selvtest
Kjører siden-motoren på nytt mot offentlige vektorer: crypt_blowfish-testsettet for bcrypt, node/OpenSSL-genererte scrypt- og Argon2id-strenger, PBKDF2-vektorene fra RFC 6070 og det offentlige SHA-256-settet, pluss generer-og-verifiser-rundturer i alle algoritmer og negative tester (feil passord må feile, og feilformaterte strenger må avvises). Ingenting sendes noe sted.
Passordhashing forklart fra grunnen av
I én setning: en passordhash er med vilje treg (og helst minnekrevende), slik at tyveri av databasen ikke lar en angriper prøve milliarder av gjetninger per sekund — det motsatte av et raskt hash som SHA-256, som er laget for hastighet.
Hvorfor ikke bare SHA-256 passordet?

SHA-256 på en moderne GPU kjører med milliarder gjetninger per sekund. Et passord på 8 tegn har godt under 1013 kombinasjoner — timer med GPU-tid, minutter på et stort rigg. Passordhashfunksjoner (KDF-er) bekjemper dette med kostnadsparametere: bcrypt gjentar kjernen sin 2kostnad ganger, PBKDF2 itererer HMAC hundretusenvis av ganger, og scrypt og Argon2id krever i tillegg megabyte med minne per gjetning, slik at GPU-er (raske, men minnefattige per kjerne) mister fordelen. Et salt — tilfeldig, lagret i klartekst inne i hash-strengen — stopper forhåndsberegnede regnbuetabeller og tvinger hver gjetning til å beregnes på nytt for hver bruker.

De fire algoritmene på denne siden
AlgoritmeÅrHardhetSignaturformatVær oppmerksom på
bcrypt1999CPU (2kostnad nøkkeloppsett)$2b$12$ + salt på 22 tegn + hash på 31 tegngrense på 72 byte for passord (alt utover 72 ignoreres stille); NUL-byte avslutter passordet i den opprinnelige C-implementasjonen
PBKDF22000 (RFC 2898/8018)CPU (iterasjoner)$pbkdf2-sha256$i=600000$ + salt + hash (passlib-stil)ingen minnekostnad — GPU-er og ASIC-er elsker det; bare antall iterasjoner kan justeres
scrypt2009 (RFC 7914)CPU + minne (128·N·r byte)$scrypt$ln=14,r=8,p=1$ + salt + hashN må være en tallpotens av to; minnet vokser lineært med r
Argon2id2015 (PHC-vinner, RFC 9106)CPU + minne (m KiB, t passeringer)$argon2id$v=19$m=19456,t=2,p=1$ + salt + hashArgon2i (dataubetinget) kontra Argon2d (databetinget) kontra Argon2id (hybrid) — velg alltid id med mindre det finnes en grunn til å la være
Minnehardhet kontra beregningshardhet

En GPU har tusenvis av kjerner, men hver kjerne har tilgang til bare litt rask minne. En KDF som trenger 19 MiB arbeidssett per gjetning, begrenser en angriper til så mange parallelle gjetninger som vedkommende har 19 MiB-biter med minne — derfor kan Argon2id med 19 MiB i praksis være sterkere enn bcrypt med kostnad 15, til tross for at den tar mindre tid på en bærbar PC. PBKDF2 har ikke noe svar på dette: den eneste innstillingen er antall iterasjoner, og silisium skalerer det lineært.

Lese en PHC-streng

Det modulære krypteringsformatet / PHC-formatet beskriver seg selv: i $argon2id$v=19$m=19456,t=2,p=1$ICEiIyQlJicoKSorLC0uLw$WTGpK4hf... er feltene algoritme, versjon, parametere (m = minne i KiB, t = passeringer, p = baner), base64-salt og base64-hash. bcrypt kommer før standarden og bruker sin egen kompakte form: $2b$-variant, 12 kostnad, deretter salt og hash i bcrypts egen base64-alfabet (./A-Za-z0-9). Verifiser på denne siden godtar alle disse og viser de tolkede feltene — lim inn en hvilken som helst hash, og se hva den består av.

Vanlige feil
  • Raskt hash for passord. MD5/SHA-1/SHA-256-passordkolonner faller for vanlige GPU-er med milliarder gjetninger per sekund. Bruk Hashgeneratoren for filer og data; bruk denne sidens algoritmer for passord.
  • Å dele salt. Ett salt for alle brukere gjør at like passord gir like hasher, og regnbuetabeller kommer tilbake. Hver hash her får et nytt tilfeldig salt på 16 byte.
  • Å ignorere bcrypts 72 byte. "a"*100 og "a"*72 gir identisk hash — halen kastes. Denne siden varsler i inndatafeltet når passordet overskrider 72 byte. Argon2 har ingen slik grense.
  • Å sammenligne hasher med == i egen kode. Verifisering må være konstant tid; sidens motor gjør det internt (den regner ut på nytt og sammenligner de lagrede bytene), men hvis man kopierer framgangsmåten, må man bruke en sammenligning i konstant tid.
  • Å justere parametere på en rask utviklermaskin. Sikt mot ca. 250–500 ms hashing på produksjonsbrukernes median-maskinvare, ikke på utviklerstasjonen. Målknappen viser hva denne nettleseren faktisk opplever.
  • Rehashing ved hver innloggingssjekk. Verifiser først; rehash bare (f.eks. for å øke kostnaden) etter en vellykket verifisering, og lagre den nye strengen. PHP-funksjonen password_needs_rehash() finnes nettopp til dette.
Ofte stilte spørsmål

Hvilken bør man velge? Argon2id med minst OWASPs minimum. Hvis kjøretidsmiljøet ikke tilbyr den: scrypt, deretter bcrypt (med kostnad slik at hashing tar ≥250 ms). PBKDF2 bare der sertifisering krever det.

Hvorfor vises et tilfeldig salt i utdatastrengen? Saltet er ingen hemmelighet — det lagres i klartekst i PHC-strengen med vilje, slik at verifisering bare trenger strengen og kandidatpassordet. Oppgaven er unikhet, ikke hemmelighold.

Har varianten betydning ($2a$ / $2b$ / $2y$)? For ASCII-passord gir de identiske hasher; $2a$ er originalen fra 1990-tallet, $2b$ rettet en sjelden fortegnsutvidelsesfeil (2014), og $2y$ er PHPs markør for at rettelsen er med. Verifisering godtar alle tre.

Hvor lang tid bør en hash ta? Omtrent 250–500 ms per innlogging på serverutstyr. Under 100 ms og frakoblet knekking er billig; over 1 s klager brukerne før sikkerheten blir bedre.

Kan jeg verifisere en hash som er laget et annet sted? Ja — lim den inn og oppgi kandidatpassordet. Kjente gode formater: PHP password_hash (bcrypt $2y$ og Argon2id), Python passlib, Djangos argon2-hasher og scrypt-strengformatet som brukes av Tarsnaps scrypt-verktøy.

Hva gjør målknappen? Den hasher det gjeldende passordet én gang med hver algoritme med sidens standardparametere og rapporterer tiden på veggen i denne nettleseren — en følelse av kostnadsforskjeller, ikke en nøyaktig måling.