Lösenordshashgenerator & verifierare

Hasha och verifiera lösenord med bcrypt, scrypt, Argon2id och PBKDF2 helt i webbläsaren — generera strängar i PHC-format, kontrollera ett kandidatlösenord mot en befintlig hash och granska parametrarna gömda i den. Inget laddas upp.
Endast för testlösenord. Riktiga användarlösenord ska aldrig klistras in på någon webbsida. Detta verktyg körs helt i webbläsaren — strängarna lämnar aldrig fliken — men ett verkligt intrång börjar med en enda inklistring.
bcrypt-kostnad (2^kostnad varv)
bcrypt-variant varianten ändrar bara prefixet; hashen i sig är identisk
scrypt N (CPU-kostnad)
scrypt r / p r =   p = blockstorlek 128·r byte; minne = 128·N·r byte (N=214, r=8 → 16 MiB)
Argon2id m (minne)
Argon2id t / p t =   p = t = pass; p = parallellism (banor)
PBKDF2-PRF
PBKDF2-iterationer  OWASP 2023: 600 000 för HMAC-SHA-256 (1 300 000 för SHA-1, 210 000 för SHA-384/512)
Utdatalängd (byte)  bcrypt-utdata är fast 23 byte (31 bcrypt-base64-tecken)
AlgoritmParametrarMinneUtdatalängdTid (denna webbläsare)
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 iterationer~032 byte-
Parameterfusklapp (OWASP Password Storage Cheat Sheet, minimum 2023)
AlgoritmMinimumAnteckningar
Argon2idm = 19 MiB (19 456 KiB), t = 2, p = 1föredragen; minneshård
scryptN = 214, r = 8, p = 1minneshård (16 MiB vid minimum)
bcryptkostnad = 10endast arbetsfaktor; 72-byte lösenordsgräns
PBKDF2-HMAC-SHA256600 000 iterationerendast iterationshårdhet — GPU-vänlig, sista valet
Standardvärdena på denna sida ligger på eller över alla minimum. För produktion: välj Argon2id först, scrypt eller bcrypt om den inte finns, PBKDF2 endast av FIPS-efterlevnadsskäl.
PHP-interop — password_hash($pw, PASSWORD_BCRYPT) ger $2y$10$...: klistra in den under Verifiera tillsammans med kandidatlösenordet, så svarar denna sida exakt vad password_verify() skulle svara. Utdata från PASSWORD_ARGON2ID ($argon2id$v=19$m=65536,t=4,p=1$...) verifieras också. PHC-strängar från passlib, django-argon2 och crypto.scrypt-omslag tolkas också.
Självtest
Kör sidmotorn igen mot offentliga testvektorer: crypt_blowfish-testsviten för bcrypt, node/OpenSSL-genererade scrypt- och Argon2id-strängar, PBKDF2-vektorerna från RFC 6070 och den publika SHA-256-uppsättningen, samt generera-sedan-verifiera-rundresor i alla algoritmer och negativa tester (fel lösenord måste misslyckas, felaktiga strängar måste avvisas). Inget skickas någonstans.
Lösenordshashning förklarat från grunden
I en mening: en lösenordshash är medvetet långsam (och helst minneskrävande) så att en stulen databas inte låter en angripare pröva miljarder gissningar per sekund — motsatsen till en snabb hash som SHA-256, som är byggd för hastighet.
Varför inte bara SHA-256 på lösenordet?

SHA-256 på en modern GPU kör miljarder gissningar per sekund. Ett lösenord på 8 tecken har väl under 1013 kombinationer — timmar av GPU-tid, minuter i ett stort rigg. Lösenordshashningsfunktioner (KDF:er) motverkar detta med kostnadsparametrar: bcrypt upprepar sin kärna 2kostnad gånger, PBKDF2 itererar HMAC hundratusentals gånger, och scrypt och Argon2id kräver dessutom megabyte minne per gissning, så att GPU:er (snabba men minnesfattiga per kärna) förlorar sin fördel. Ett salt — slumpmässigt och lagrat i klartext inne i hash-strängen — förhindrar förberäknade regnbågstabeller och tvingar varje gissning att beräknas på nytt för varje användare.

De fyra algoritmerna på denna sida
AlgoritmÅrHårdhetSignaturformatSe upp för
bcrypt1999CPU (2kostnad nyckelinställningar)$2b$12$ + 22 tecken salt + 31 tecken hash72-byte lösenordsgräns (allt efter 72 ignoreras tyst); NUL-byte avslutar lösenordet i den ursprungliga C-implementationen
PBKDF22000 (RFC 2898/8018)CPU (iterationer)$pbkdf2-sha256$i=600000$ + salt + hash (passlib-stil)ingen minneskostnad — GPU:er och ASIC:ar älskar det; endast iterationsantalet kan justeras
scrypt2009 (RFC 7914)CPU + minne (128·N·r byte)$scrypt$ln=14,r=8,p=1$ + salt + hashN måste vara en potens av två; minnet växer linjärt med r
Argon2id2015 (PHC-vinnaren, RFC 9106)CPU + minne (m KiB, t pass)$argon2id$v=19$m=19456,t=2,p=1$ + salt + hashArgon2i (dataoberoende) mot Argon2d (databeroende) mot Argon2id (hybrid) — välj alltid id om man inte vet varför inte
Minneshårdhet kontra beräkningshårdhet

En GPU har tusentals kärnor, men varje kärna har tillgång till lite snabbt minne. En KDF som behöver 19 MiB arbetsminne per gissning begränsar en angripare till så många parallella gissningar som de har 19-MiB-delar av minne — vilket är varför Argon2id med 19 MiB i praktiken kan vara starkare än bcrypt med kostnad 15, trots att det tar kortare tid på en laptop. PBKDF2 har inget svar på detta: dess enda reglage är antalet iterationer, och kisel skalar det linjärt.

Läsa en PHC-sträng

Det modulära crypt-/PHC-formatet är självbeskrivande: i $argon2id$v=19$m=19456,t=2,p=1$ICEiIyQlJicoKSorLC0uLw$WTGpK4hf... är fälten algoritm, version, parametrar (m = minne i KiB, t = pass, p = banor), base64-salt och base64-hash. bcrypt är äldre än standarden och använder en egen kompakt form: $2b$-variant, 12 kostnad, och sedan salt och hash i bcrypts egna base64-alfabet (./A-Za-z0-9). Denna sidas Verifiera accepterar alla dessa och visar de tolkade fälten — klistra in valfri hash och se hur den bryts ner.

Vanliga misstag
  • Snabb hash för lösenord. Kolumner med MD5/SHA-1/SHA-256 för lösenord faller för vanliga GPU:er vid miljarder gissningar per sekund. Använd Hash Generator för filer och data; använd denna sidas algoritmer för lösenord.
  • Att dela salt. Ett salt för alla användare innebär att lika lösenord ger lika hashar och att regnbågstabeller fungerar. Varje hash här får ett nytt slumpmässigt 16-byte-salt.
  • Att ignorera bcrypts 72 byte. "a"*100 och "a"*72 ger identiska hashar — svansen kastas. Denna sida varnar i inmatningsrutan när lösenordet överstiger 72 byte. Argon2 har ingen sådan gräns.
  • Att jämföra hashar med == i egen kod. Verifiering måste vara konstant i tid; sidans motor gör det internt (den beräknar om och jämför de lagrade byten), men den som kopierar tillvägagångssättet bör använda en jämförelse i konstant tid.
  • Att ställa in parametrar på en snabb utvecklarmaskin. Sikta på cirka 250–500 ms hashning på produktionsanvändarnas typiska hårdvara, inte på den egna arbetsstationen. Knappen Jämför visar vad denna webbläsare faktiskt upplever.
  • Ny hashning vid varje inloggningskontroll. Verifiera först; hasha om (t.ex. för att höja kostnaden) först efter lyckad verifiering, och lagra den nya strängen. PHP-funktionen password_needs_rehash() finns just för detta.
Vanliga frågor

Vilken ska man välja? Argon2id med minst OWASP-minimum. Om körmiljön inte erbjuder den: scrypt, sedan bcrypt (kostnad så att hashning tar ≥250 ms). PBKDF2 endast där certifiering kräver det.

Varför visas ett slumpmässigt salt i utdatasträngen? Saltet är inte en hemlighet — det lagras i klartext i PHC-strängen med avsikt, så att verifiering bara behöver strängen och kandidatlösenordet. Dess uppgift är unikhet, inte hemlighållning.

Spelar varianten roll ($2a$ / $2b$ / $2y$)? För ASCII-lösenord ger de identiska hashar; $2a$ är originalet från 1990-talet, $2b$ rättade en sällsynt teckenutvidgningsbugg (2014), och $2y$ är PHP:s markering att rättelsen finns. Verifiera accepterar alla tre.

Hur lång tid bör en hash ta? Ungefär 250–500 ms per inloggning på serverhårdvara. Under 100 ms blir offlineknäckning billig; över 1 s klagar användarna innan säkerheten blir bättre.

Kan en hash skapad någon annanstans verifieras här? Ja — klistra in den och ange kandidatlösenordet. Kända format: PHP password_hash (bcrypt $2y$ och Argon2id), Python passlib, djangos argon2-hasher och scrypt-strängformatet som används av Tarsnaps scrypt-verktyg.

Vad gör knappen "jämför"? Den hashar det aktuella lösenordet en gång med varje algoritm med sidans standardparametrar och rapporterar klockslaget i denna webbläsare — en känsla för kostnadsskillnaderna, inte en noggrann mätning.