Wachtwoordhash-generator & -verificatie

Hash en verifieer wachtwoorden met bcrypt, scrypt, Argon2id en PBKDF2 volledig in uw browser — genereer strings in PHC-formaat, controleer een kandidaat-wachtwoord tegen een bestaande hash, en bekijk de parameters die erin verborgen zitten. Er wordt niets geüpload.
Alleen voor testwachtwoorden. Echte wachtwoorden van gebruikers mogen nooit in een webpagina worden geplakt. Dit hulpmiddel draait volledig in uw browser — de strings verlaten uw tabblad nooit — maar een echt datalek begint met één keer plakken.
bcrypt-kosten (2^kosten rondes)
bcrypt-variant de variant wijzigt alleen het voorvoegsel; de hash zelf is identiek
scrypt N (CPU-kosten)
scrypt r / p r =   p = blokgrootte 128·r bytes; geheugen = 128·N·r bytes (N=214, r=8 → 16 MiB)
Argon2id m (geheugen)
Argon2id t / p t =   p = t = passes; p = parallelisme (lanes)
PBKDF2-PRF
PBKDF2-iteraties  OWASP 2023: 600.000 voor HMAC-SHA-256 (1.300.000 voor SHA-1, 210.000 voor SHA-384/512)
Uitvoerlengte (bytes)  bcrypt-uitvoer is vast op 23 bytes (31 bcrypt-base64-tekens)
AlgoritmeParametersGeheugenUitvoerlengteTijd (deze browser)
bcryptkosten 124 KiB23 bytes-
scryptN=214, r=8, p=116 MiB32 bytes-
Argon2idm=19 MiB, t=2, p=119 MiB32 bytes-
PBKDF2HMAC-SHA-256, 600.000 iteraties~032 bytes-
Spiekbriefje parameters (OWASP Password Storage Cheat Sheet, minimumwaarden 2023)
AlgoritmeMinimumOpmerkingen
Argon2idm = 19 MiB (19.456 KiB), t = 2, p = 1aanbevolen; geheugenhard
scryptN = 214, r = 8, p = 1geheugenhard (16 MiB als minimum)
bcryptkosten = 10alleen werkfactor; wachtwoordlimiet van 72 bytes
PBKDF2-HMAC-SHA256600.000 iteratiesalleen iteratiehard — GPU-vriendelijk, laatste keuze
De standaardwaarden op deze pagina liggen op of boven elk minimum. Kies voor productie eerst Argon2id, scrypt of bcrypt als dat niet beschikbaar is, en PBKDF2 alleen om redenen van FIPS-naleving.
PHP-interoperabiliteit — password_hash($pw, PASSWORD_BCRYPT) geeft $2y$10$...: plak die in Verifiëren met het kandidaat-wachtwoord, en deze pagina antwoordt precies wat password_verify() zou antwoorden. Uitvoer van PASSWORD_ARGON2ID ($argon2id$v=19$m=65536,t=4,p=1$...) wordt ook geverifieerd. PHC-strings van passlib, django-argon2 en de crypto.scrypt-omhulling worden ook geparseerd.
Zelftest
Voert de paginamotor opnieuw uit tegen openbare vectoren: de testsuite crypt_blowfish voor bcrypt, door node/OpenSSL gegenereerde scrypt- en Argon2id-strings, de PBKDF2-vectoren uit RFC 6070 en de openbare SHA-256-set, plus genereer-dan-verifieer-rondes in elk algoritme en negatieve tests (een verkeerd wachtwoord moet mislukken, misvormde strings moeten worden geweigerd). Er wordt niets ergens naartoe verzonden.
Wachtwoordhashing vanaf nul uitgelegd
In één zin: een wachtwoordhash is bewust traag (en bij voorkeur geheugenhongerig), zodat het stelen van de database een aanvaller niet miljarden gissingen per seconde laat proberen — het tegenovergestelde doel van een snelle hash als SHA-256, die voor snelheid is gebouwd.
Waarom niet gewoon het wachtwoord met SHA-256 hashen?

SHA-256 op een moderne GPU draait op miljarden gissingen per seconde. Een wachtwoord van 8 tekens heeft ver minder dan 1013 combinaties — uren GPU-tijd, minuten op een grote rig. Wachtwoordhashfuncties (KDF's) bestrijden dit met kostenparameters: bcrypt herhaalt zijn kern 2cost keer, PBKDF2 itereert HMAC honderdduizenden keren, en scrypt en Argon2id eisen bovendien megabytes geheugen per gissing, zodat GPU's (snel maar geheugenarm per kern) hun voordeel verliezen. Een salt — willekeurig en onversleuteld opgeslagen in de hashstring — stopt vooraf berekende regenboogtabellen en dwingt elke gissing voor elke gebruiker opnieuw te berekenen.

De vier algoritmen op deze pagina
AlgoritmeJaarHardheidHandtekeningformaatLet op
bcrypt1999CPU (2kosten sleutelinstellingen)$2b$12$ + salt van 22 tekens + hash van 31 tekenswachtwoordlimiet van 72 bytes (alles daarboven wordt stilzwijgend genegeerd); een NUL-byte beëindigt het wachtwoord in de oorspronkelijke C-implementatie
PBKDF22000 (RFC 2898/8018)CPU (iteraties)$pbkdf2-sha256$i=600000$ + salt + hash (passlib-stijl)geen geheugenkosten — GPU's en ASIC's zijn er dol op; alleen het aantal iteraties is instelbaar
scrypt2009 (RFC 7914)CPU + geheugen (128·N·r bytes)$scrypt$ln=14,r=8,p=1$ + salt + hashN moet een macht van twee zijn; geheugen groeit lineair met r
Argon2id2015 (winnaar PHC, RFC 9106)CPU + geheugen (m KiB, t passes)$argon2id$v=19$m=19456,t=2,p=1$ + salt + hashArgon2i (data-onafhankelijk) versus Argon2d (data-afhankelijk) versus Argon2id (hybride) — kies altijd id, tenzij u weet waarom niet
Geheugenhardheid versus rekenhardheid

Een GPU heeft duizenden kernen, maar elke kern heeft slechts toegang tot een beetje snel geheugen. Een KDF die 19 MiB werkgeheugen per gissing nodig heeft, beperkt een aanvaller tot zoveel parallelle gissingen als hij 19-MiB-brokken geheugen heeft — daarom kan Argon2id met 19 MiB in de praktijk sterker zijn dan bcrypt met kosten 15, ondanks dat het op uw laptop minder wandkloktijd kost. PBKDF2 heeft hier geen antwoord op: de enige knop is het aantal iteraties, en silicium schaalt dat lineair.

Een PHC-string lezen

Het modular-crypt/PHC-formaat beschrijft zichzelf: in $argon2id$v=19$m=19456,t=2,p=1$ICEiIyQlJicoKSorLC0uLw$WTGpK4hf... zijn de velden algoritme, versie, parameters (m = geheugen in KiB, t = passes, p = lanes), base64-salt, base64-hash. bcrypt is ouder dan de standaard en gebruikt een eigen compacte vorm: $2b$-variant, 12 kosten, en daarna salt en hash in het eigen base64-alfabet van bcrypt (./A-Za-z0-9). De Verifiëren van deze pagina accepteert al deze vormen en toont de geparseerde velden — plak elke hash die u vindt en zie waaruit hij is opgebouwd.

Veelgemaakte fouten
  • Snelle hash voor wachtwoorden. MD5/SHA-1/SHA-256-wachtwoordkolommen vallen aan commerciële GPU's bij miljarden gissingen per seconde. Gebruik de Hashgenerator voor bestanden en gegevens; gebruik de algoritmen van deze pagina voor wachtwoorden.
  • Een salt delen. Eén salt voor alle gebruikers betekent dat gelijke wachtwoorden gelijke hashes hebben en regenboogtabellen terugkomen. Elke hash hier krijgt een verse willekeurige salt van 16 bytes.
  • De 72 bytes van bcrypt negeren. "a"*100 en "a"*72 leveren identieke hashes op — het staart wordt weggelaten. Deze pagina waarschuwt bij het invoervak wanneer het wachtwoord meer dan 72 bytes is. Argon2 kent zo'n limiet niet.
  • Hashes vergelijken met == in uw eigen code. Verificatie moet constante tijd kosten; de paginamotor doet dat intern (hij berekent opnieuw en vergelijkt de opgeslagen bytes), maar als u de aanpak kopieert, gebruik dan een vergelijking in constante tijd.
  • Parameters afstemmen op een snelle ontwikkelmachine. Mik op ~250–500 ms hashing op de mediane hardware van uw productiegebruikers, niet op uw werkstation. De knop Benchmark laat zien wat deze browser werkelijk ervaart.
  • Opnieuw hashen bij elke inlogcontrole. Verifieer eerst; hash alleen opnieuw (bijv. om de kosten te verhogen) na een geslaagde verificatie, en sla de nieuwe string op. De PHP-functie password_needs_rehash() bestaat precies hiervoor.
Veelgestelde vragen

Welke moet ik kiezen? Argon2id met ten minste de OWASP-minimumwaarden. Als de runtime die niet biedt: scrypt, daarna bcrypt (kosten zodanig dat hashen ≥250 ms duurt). PBKDF2 alleen waar certificering dat vereist.

Waarom staat er een willekeurige salt in de uitvoerstring? De salt is geen geheim — hij staat bewust onversleuteld in de PHC-string, zodat verificatie alleen de string en het kandidaat-wachtwoord nodig heeft. Zijn taak is uniciteit, niet geheimhouding.

Doet de variant ertoe ($2a$ / $2b$ / $2y$)? Voor ASCII-wachtwoorden leveren ze identieke hashes op; $2a$ is het origineel uit de jaren negentig, $2b$ repareerde een zeldzame sign-extension-bug (2014), $2y$ is PHP's markering dat de reparatie aanwezig is. Verifiëren accepteert alle drie.

Hoe lang moet een hash duren? Ongeveer 250–500 ms per inlogpoging op serverhardware. Onder 100 ms is offline kraken goedkoop; boven 1 s klagen gebruikers voordat de beveiliging verbetert.

Kan ik een hash verifiëren die elders is gemaakt? Ja — plak hem en geef het kandidaat-wachtwoord. Bekende goede formaten: PHP password_hash (bcrypt $2y$ en Argon2id), Python passlib, de argon2-hasher van Django, en het scrypt-stringformaat dat de scrypt-tool van Tarsnap gebruikt.

Wat doet de knop "benchmark"? Hij hasht het huidige wachtwoord één keer met elk algoritme bij de standaardparameters van de pagina en meldt de wandkloktijd in deze browser — een indruk van kostenverschillen, geen rigoureuze meting.