Hoe een wachtwoord wordt opgeslagen: hash en salt
Als je ergens een account aanmaakt, gaat je wachtwoord naar een server. Een goede site bewaart dat wachtwoord daarna nergens. Hoe een wachtwoord wordt opgeslagen bepaalt wat er gebeurt als die database ooit uitlekt: blijft het bij een vervelend incident, of liggen een dag later miljoenen wachtwoorden op straat? Dat verschil zit in drie dingen: hashing, een salt en een rekensom die met opzet traag is.
In dit artikel volg je wat er met een wachtwoord gebeurt, van een simpele SHA-256 tot bcrypt en Argon2id. Ik heb alle varianten op een bescheiden thuisserver (een Intel Celeron J3455) gemeten, zodat je ziet hoeveel trager "traag" precies is en waarom dat hier goed nieuws is.
Hashen in plaats van versleutelen
Versleutelen kun je terugdraaien, als je de sleutel hebt. Voor wachtwoorden is dat juist een zwakte: wie de database steelt, steelt vaak ook de sleutel. Daarom gebruiken sites een hashfunctie. Die maakt van elke invoer een vaste reeks bits, en uit de uitkomst kun je de invoer niet terugrekenen. De OWASP-richtlijn voor wachtwoordopslag noemt hashing daarom "a one-way function".
Bij het inloggen hoeft de server je wachtwoord ook niet te kennen. Hij hasht wat je intypt en vergelijkt de uitkomst met wat er in de database staat. Is die gelijk, dan klopt het wachtwoord. Daarna krijg je meestal een sessiecookie, zoals beschreven in hoe cookies en sessies je ingelogd houden.
$ printf 'welkom123' | sha256sum
2a5c5f2623024ce3de6fe7dc8f5e13ca55b7aadc13174254b40af574e37018c1 -
Twee keer draaien geeft twee keer exact dezelfde uitkomst. Dat is nodig om te kunnen vergelijken, maar het is ook het eerste probleem.
Waarom alleen hashen niet genoeg is
Iedereen die welkom123 gebruikt, krijgt dezelfde hash. Een aanvaller kan dus vooraf een grote tabel maken met de hashes van veelgebruikte wachtwoorden en de gestolen database daarin opzoeken. Rainbow tables zijn een compacte vorm van zo'n vooraf berekende tabel. Bovendien zie je meteen welke gebruikers hetzelfde wachtwoord hebben.
Het tweede probleem is snelheid. SHA-256 is bedoeld om snel te zijn, zodat je er ook grote bestanden mee kunt controleren. Met openssl speed haalde één kern van mijn Celeron 19.592 kB/s bij blokjes van 16 bytes. Dat zijn ruim 1,2 miljoen hashes per seconde. Een lijst van tien miljoen bekende wachtwoorden is daarmee in ongeveer 8 seconden afgewerkt, op een zuinig processortje. MD5 was op dezelfde machine nog sneller: 2 miljoen per seconde.
De salt: elke hash uniek
De oplossing voor het eerste probleem is een salt: een willekeurige reeks bytes die per gebruiker wordt aangemaakt en vóór het hashen aan het wachtwoord wordt toegevoegd. De salt is geen geheim. Hij staat gewoon naast de hash in de database, want de server heeft hem nodig om bij het inloggen dezelfde berekening te herhalen.
Met acht willekeurige tekens ervoor werd de SHA-256 van welkom123 bij mij 22c4afd64fcd69f0… in plaats van 2a5c5f2623024ce3…. Een vooraf berekende tabel is nu waardeloos, want die zou voor elke mogelijke salt opnieuw gemaakt moeten worden. Twee gebruikers met hetzelfde wachtwoord hebben ook geen gelijke hash meer. De Amerikaanse norm NIST SP 800-63B eist minstens 32 bits salt. RFC 9106 noemt 128 bits ruim voldoende voor wachtwoorden.
Een salt lost het snelheidsprobleem niet op. Een aanvaller die één specifiek account wil kraken, kent de salt en probeert gewoon zijn lijst. Daarvoor is iets anders nodig.
Traag met opzet: bcrypt
Voor de verdediger maakt het weinig uit of een inlogpoging een microseconde of een tiende seconde kost. Voor een aanvaller die miljoenen pogingen doet, maakt het alles uit. Dat is het idee achter bcrypt, dat Niels Provos en David Mazières in 1999 presenteerden.
bcrypt is gebaseerd op het versleutelalgoritme Blowfish, waarvan de sleutelvoorbereiding al relatief duur is. bcrypt herhaalt die voorbereiding met salt en wachtwoord 2^cost keer, en versleutelt daarna de vaste tekst "OrpheanBeholderScryDoubt" 64 keer. De salt is 128 bits. Omdat elke berekening 4 KB aan steeds veranderende tabellen nodig heeft, is bcrypt in hardware lastig te versnellen, schrijven de makers.
De cost is een exponent, dus elke stap omhoog verdubbelt het werk. Dat zie je terug in mijn metingen:
| cost | tijd per hash |
|---|---|
| 10 | 89 ms |
| 12 | 358 ms |
| 13 | 715 ms |
Dezelfde lijst van tien miljoen wachtwoorden kost bij cost 12 op deze kern geen 8 seconden meer, maar ruim 41 dagen. Wel heeft bcrypt een beperking: het gebruikt hooguit 72 bytes van het wachtwoord. De Python-bibliotheek bcrypt (versie 5.0.0) weigert een langer wachtwoord zelfs met een foutmelding.
Wat er in de database staat
Een bcrypt-hash bevat alles wat nodig is om hem later te controleren:
$2b$12$QT8ICNutlWcC3/rjqqRYo.bZpwz76dAzUUOP9W56.YFuA.gYy1q2y
2b is de variant, 12 de cost, dan volgen 22 tekens salt en 31 tekens hash, samen 60 tekens. Bij het inloggen leest de bibliotheek de cost en salt uit deze regel en rekent opnieuw. Daardoor kan een site de cost later verhogen: nieuwe en gewijzigde wachtwoorden krijgen de hogere waarde, de oude blijven gewoon controleerbaar. NIST vraagt precies dat: een cost "as high as practical", die met de tijd omhoog gaat.
Geheugen als extra drempel: Argon2id
Een serieuze aanvaller kraakt niet op een Celeron, maar op hardware die duizenden pogingen tegelijk doet. Argon2, vastgelegd in RFC 9106, is "memory-hard": je kiest niet alleen hoeveel rekenwerk, maar ook hoeveel geheugen elke hash nodig heeft. Wie tienduizend pogingen tegelijk wil doen, heeft tienduizend keer dat geheugen nodig. Volgens de RFC maakt dat aanvallen met speciale kraakhardware zo duur mogelijk.
Argon2 heeft drie smaken. Argon2d leest het geheugen in een volgorde die van de invoer afhangt, en is daardoor alleen geschikt waar niemand timingaanvallen kan doen. Argon2i doet dat niet en is bedoeld voor wachtwoorden. Argon2id werkt de eerste helft van de eerste doorgang als Argon2i en daarna als Argon2d. RFC 9106 raadt Argon2id aan met 2 GiB geheugen, of met 64 MiB en drie doorgangen als er weinig geheugen is. OWASP noemt onder meer 19 MiB met twee doorgangen.
| instelling | tijd per hash |
|---|---|
| Argon2id, 19 MiB, t=2, p=1 (OWASP) | 69 ms |
| Argon2id, 64 MiB, t=3, p=4 (RFC 9106, tweede advies) | 279 ms |
| PBKDF2-SHA256, 600.000 rondes (OWASP) | 934 ms |
| scrypt, N=2^17, r=8, p=1 (OWASP) | 1070 ms |
PBKDF2 herhaalt gewoon een snelle hash heel vaak en vraagt geen geheugen. OWASP noemt het vooral voor situaties waar FIPS-certificering verplicht is. Sommige sites voegen nog een pepper toe: een geheime sleutel die niet in de database staat. NIST adviseert die apart te bewaren, bij voorkeur in een HSM of TPM.
Zelf proberen
Hoe snel is een gewone hash op jouw machine?
$ openssl speed -seconds 3 -bytes 16 -evp sha256
type 16 bytes
sha256 19592.49k
Deel het getal (in 1000 bytes per seconde) door 16 voor het aantal hashes per seconde. Een bcrypt-hash maken kan met htpasswd uit de Apache-tools:
$ time htpasswd -bnBC 12 jeroen welkom123
jeroen:$2y$12$A/alcd2.oG4w79qOQ6j//.KfNKQFuKSaTgY8DQi6FUmD6WDTYAwt.
real 0m0.468s
Draai het nog eens en de hash is compleet anders, door de nieuwe salt. htpasswd gebruikt het voorvoegsel $2y$ in plaats van $2b$; de opbouw is verder gelijk. In Python heb je scrypt zonder extra pakketten:
$ python3 -c "import hashlib,os; print(hashlib.scrypt(b'welkom123', salt=os.urandom(16), n=2**14, r=8, p=1).hex()[:32])"
8aed53a9b6fb3fd560bbe1f5e9ed5069
Tot slot
Wat me het meest verraste was het verschil tussen 8 seconden en 41 dagen, voor precies dezelfde lijst wachtwoorden op dezelfde processor. Een site kan dat in één regel code kiezen. Opvallend vond ik ook dat de Python-bibliotheek voor Argon2 standaard exact het tweede advies uit RFC 9106 gebruikt: 64 MiB, drie doorgangen, vier lanes, 128 bits salt. Een passkey slaat dit hele probleem over, omdat de server dan alleen een publieke sleutel bewaart; hoe dat in de praktijk gaat, lees je in passkeys inrichten in Microsoft Entra ID.