Wachtwoord-entropie: zo meet en maximaliseer je je wachtwoordsterkte
Je hebt waarschijnlijk gehoord dat een “sterk wachtwoord” hoofdletters, cijfers en speciale tekens nodig heeft. Maar P@$$w0rd! volgt al die regels — en is binnen een seconde te kraken.
De echte maatstaf voor wachtwoordsterkte is niet welke tekens je gebruikt. Het is entropie: een concept uit de informatietheorie dat kwantificeert hoe onvoorspelbaar je wachtwoord werkelijk is.
In deze gids leer je precies hoe wachtwoord-entropie werkt, hoe je die berekent en hoe je wachtwoorden genereert die echt moeilijk te kraken zijn.
Wat is wachtwoord-entropie?
Wachtwoord-entropie meet hoe onvoorspelbaar een wachtwoord is, uitgedrukt in bits. Elke extra bit entropie verdubbelt het aantal pogingen dat een aanvaller nodig heeft om het via brute force te kraken.
Zie het als dobbelstenen. Een dobbelsteen met 6 zijden heeft ongeveer 2,6 bits entropie per worp — er zijn maar 6 mogelijke uitkomsten. Een 20-zijdige dobbelsteen heeft ongeveer 4,3 bits — meer zijden betekent meer onzekerheid.
Wachtwoorden werken op dezelfde manier: meer mogelijke tekens (grotere “dobbelstenen”) én meer tekens in het wachtwoord (meer “worpen”) verhogen beide de entropie.
Daarom is entropie een betere maatstaf dan complexiteitsregels. Een wachtwoord kan complex ogen (Tr0ub4dor&3) maar lage entropie hebben omdat het voorspelbare patronen volgt. Een simpel ogende passphrase (correct horse battery staple) kan daarentegen hoge entropie hebben omdat die uit een grote verzameling mogelijkheden is getrokken.
De formule: zo bereken je wachtwoord-entropie
De formule is eenvoudig:
E = L × log₂(R)
Waarbij:
- E = entropie in bits
- L = wachtwoordlengte (aantal tekens)
- R = poolgrootte (aantal mogelijke tekens per positie)
Poolgroottes per tekenset
| Tekentype | Poolgrootte (R) | Bits per teken |
|---|---|---|
| Alleen kleine letters (a-z) | 26 | 4,70 |
| Kleine letters + cijfers | 36 | 5,17 |
| Hoofdletters + kleine letters + cijfers | 62 | 5,95 |
| Volledige printbare ASCII | 94 | 6,55 |
| Diceware-woordenlijst | 7.776 | 12,92 per woord |
Bereken het in code
// Calculate password entropy in JavaScript
const entropy = (length, poolSize) =>
length * Math.log2(poolSize);
entropy(8, 26); // → 37.60 bits (lowercase only)
entropy(12, 62); // → 71.45 bits (alphanumeric)
entropy(16, 94); // → 104.87 bits (full charset)import math
def entropy(length: int, pool_size: int) -> float:
return length * math.log2(pool_size)
entropy(8, 26) # → 37.60 bits
entropy(12, 62) # → 71.45 bits
entropy(16, 94) # → 104.87 bitsBelangrijk: deze formule gaat ervan uit dat elk teken uniform willekeurig wordt gekozen. Als een mens het wachtwoord kiest op basis van patronen of woordenboekwoorden, ligt de werkelijke entropie veel lager dan het theoretische maximum.
Hoeveel entropie is genoeg?
Het antwoord hangt af van wat je beschermt en hoe snel een aanvaller kan gokken.
Moderne GPU’s kunnen meer dan 10¹² (één biljoen) wachtwoord-hashes per seconde testen tegen snelle algoritmen zoals MD5. Wat dat in de praktijk betekent:
| Entropie (bits) | Sterkte | Kraaktijd bij 10¹² pogingen/s | Aanbevolen voor |
|---|---|---|---|
| < 40 | Zwak | Onder 1 seconde | Nooit gebruiken |
| 40–59 | Redelijk | Seconden tot uren | Wegwerpaccounts |
| 60–79 | Sterk | Dagen tot eeuwen | Gewone accounts |
| 80–99 | Zeer sterk | Millennia+ | E-mail, bankieren |
| 100+ | Extreem | Voorbij de warmtedood van het universum | Versleutelingssleutels, hoofdwachtwoorden |
Een wachtwoord van 16 tekens met de volledige printbare ASCII-set geeft je ongeveer 105 bits entropie — ruim in het “extreem”-bereik. Je genereert er direct een met onze willekeurige wachtwoordgenerator, die voor elk wachtwoord realtime entropie-analyse toont.
Wat NIST zegt (update van 2024)
NIST SP 800-63B, bijgewerkt in 2024, bracht belangrijke wijzigingen aan in de wachtwoordrichtlijnen:
- Verwijderd: verplichte complexiteitsregels (geen verplichte speciale tekens meer)
- Verwijderd: verplichte periodieke wachtwoordwijzigingen
- Verhoogd: minimum naar 15 tekens (was 8 in eerdere versies)
- Benadrukt: screening tegen bekende gelekte wachtwoorden
- Voorkeur: lengte en willekeurigheid boven complexiteit
Deze wijzigingen weerspiegelen wat de entropie-wiskunde altijd al liet zien: lengte en willekeurigheid tellen zwaarder dan tekenvariëteit.
Waarom lengte complexiteit verslaat
Laten we naar de wiskunde kijken. Bekijk twee manieren om de entropie van een wachtwoord van 12 tekens te verhogen:
Optie A — Houd 12 tekens aan, schakel over van alfanumeriek (62) naar volledige ASCII (94):
- 12 × log₂(94) - 12 × log₂(62) = 78,66 - 71,45 = +7,21 bits
Optie B — Houd alfanumeriek (62) aan, voeg één teken toe (12 → 13):
- 13 × log₂(62) - 12 × log₂(62) = 77,40 - 71,45 = +5,95 bits
Eén teken toevoegen levert je bijna evenveel entropie op als overstappen naar een veel grotere tekenset. Voeg er twee toe en je bent er al voorbij.
Neem nu P@$$w0rd! (9 tekens). Het gebruikt de volledige ASCII-pool maar is te kort. Erger nog, het volgt het voorspelbare “leet speak”-patroon dat woordenboekaanvallen al afdekken, waardoor de effectieve entropie ver onder de theoretische 59 bits ligt.
De les: voor echt willekeurige wachtwoorden is extra lengte efficiënter dan extra tekentypes. Maar de echte vijand is voorspelbaarheid, niet kortheid.
Passphrase vs willekeurig wachtwoord
| Dimensie | Willekeurig wachtwoord | Passphrase (Diceware) |
|---|---|---|
| Voorbeeld | kX#9mP$2vL!nQ7wR | correct horse battery staple |
| Bits per eenheid | 6,55 per teken | 12,92 per woord |
| Lengte voor ~78 bits | 12 tekens | 6 woorden |
| Onthoudbaarheid | Slecht | Goed |
| Typen op mobiel | Pijnlijk | Makkelijk |
| Beste inzet | Vermeldingen in wachtwoordbeheerder | Hoofdwachtwoorden, onthouden logins |
Zo werkt Diceware
Diceware gebruikt een woordenlijst van 7.776 items (6⁵ = 7.776). Je gooit met vijf dobbelstenen om elk woord te kiezen, wat exact 12,92 bits entropie per woord oplevert.
Vier woorden geven ~51 bits; zes woorden geven ~77 bits.
Welke moet je kiezen?
- Voor wachtwoorden in een beheerder: gebruik willekeurige wachtwoorden van 16+ tekens met volledige tekensets. Je typt ze nooit met de hand, dus onthoudbaarheid speelt geen rol. Onze willekeurige wachtwoordgenerator kan er batchgewijs tot 50 tegelijk genereren.
- Voor je hoofdwachtwoord: gebruik een Diceware-passphrase van 5-6 woorden. Het is onthoudbaar genoeg om dagelijks te typen en biedt 64-77 bits entropie.
- Voor API-sleutels en tokens: gebruik
openssl randofcrypto.randomBytes()voor maximale entropie zonder eis van menselijke onthoudbaarheid.
Entropie in de praktijk: ontwikkeltools en code
Een paar concrete voorbeelden van hoe ontwikkelaars secrets met hoge entropie genereren:
Browser (Web Crypto API)
// Cryptographically secure password generation
function generatePassword(length, charset) {
const array = new Uint32Array(length);
crypto.getRandomValues(array);
return Array.from(array, v => charset[v % charset.length]).join('');
}
const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*';
generatePassword(16, chars);
// → 'kX#9mP$2vL!nQ7wR' (random each time)Node.js
const crypto = require('crypto');
const token = crypto.randomBytes(32).toString('base64url');
// → 'Ql2Hj8xK9mNp3rVw5tYz7uBa0cEf4gIk' (43 chars, 256 bits)Python
import secrets
token = secrets.token_urlsafe(32) # 256 bits of entropy
password = secrets.token_hex(16) # 128 bits, hex formatCommandoregel
# 192 bits of entropy, base64 encoded
openssl rand -base64 24
# 256 bits, hex encoded
openssl rand -hex 32Entropie per methode vergeleken
| Methode | Uitvoerlengte | Entropie (bits) |
|---|---|---|
| UUID v4 | 36 tekens | 122 |
openssl rand -base64 24 | 32 tekens | 192 |
| 16-teken volledige ASCII | 16 tekens | 105 |
| 6-woord Diceware | ~30 tekens | 78 |
| 4-woord Diceware | ~20 tekens | 52 |
Gebruik nooit
Math.random()voor iets dat met beveiliging te maken heeft. Het gebruikt een niet-cryptografische PRNG — de uitvoer is voorspelbaar als een aanvaller de seed kent. Gebruik altijdcrypto.getRandomValues()in de browser ofcrypto.randomBytes()in Node.js.
Wachtwoordopslag: waarom entropie alleen niet genoeg is
Zelfs een wachtwoord van 128 bits is waardeloos als de server het opslaat als een kale MD5-hash. Wanneer een database lekt, kunnen aanvallers biljoenen MD5-hashes per seconde testen op één enkele GPU.
Hier komen trage hash-algoritmen in beeld. Ze maken elke poging bewust duur:
| Algoritme | Snelheid op GPU | Effectieve vertraging |
|---|---|---|
| MD5 | ~10 miljard/s | Basislijn (niet gebruiken) |
| SHA-256 | ~5 miljard/s | ~2× trager |
| bcrypt (cost=12) | ~5/s | ~2 miljard× trager |
| argon2id | ~2/s | ~5 miljard× trager |
De cost-parameter van bcrypt is bijzonder elegant: elke verhoging verdubbelt het benodigde werk. Een cost-factor van 12 betekent 2¹² = 4.096 hash-rondes. Dat voegt effectief 12 bits “opslagentropie” toe bovenop de eigen entropie van het wachtwoord.
Het duale beschermingsmodel: wachtwoorden met hoge entropie beschermen tegen offline brute force, terwijl trage hashing beschermt tegen databaselekken. Je hebt beide nodig.
Meer over hash-algoritmen lees je in onze MD5 vs SHA-256-vergelijking en probeer de MD5-hashgenerator om te ontdekken hoe verschillende algoritmen verschillende uitvoer opleveren.
Veelvoorkomende wachtwoordmythes ontkracht
”Verander je wachtwoord elke 90 dagen”
De NIST-richtlijnen van 2024 raden verplichte periodieke wijzigingen expliciet af. Frequente rotaties zetten gebruikers aan tot zwakkere, voorspelbaardere wachtwoorden — een cijfer aan het einde plakken, door een kleine set cyclen. Verander je wachtwoord alleen als je reden hebt om aan te nemen dat het gecompromitteerd is.
”a→@, e→3 maakt het sterker”
Leet speak-substituties horen bij de eerste patronen die woordenboekaanvallen controleren. a vervangen door @ in password voegt vrijwel geen entropie toe, omdat aanvallers het al verwachten.
Echte willekeurigheid — niet slimme substituties — is wat de entropie verhoogt.
”8 tekens met symbolen is genoeg”
Zelfs met de volledige 94-teken ASCII-set levert 8 tekens maar 52 bits entropie op. Bij 10¹² pogingen per seconde is dat in ongeveer 75 minuten gekraakt.
Gebruik minimaal 12 tekens, 16+ voor belangrijke accounts.
”Hoe complexer het eruitziet, hoe veiliger”
Visuele complexiteit en entropie zijn verschillende dingen. Tr0ub4dor&3 oogt complex maar volgt het voorspelbare patroon van een basiswoord met substituties. mfYq8kL2nR oogt simpeler maar heeft hogere entropie omdat het echt willekeurig is.
Voor het opbouwen van een brede beveiligingsstrategie, zie essentiële webbeveiliging.
Veelgestelde vragen
Hoeveel bits entropie geldt als veilig?
Voor de meeste online accounts biedt 60-80 bits sterke bescherming. Voor doelen met hoge waarde zoals hoofdwachtwoorden of versleutelingssleutels mik je op 100+ bits. Elke extra bit verdubbelt de inspanning die een aanvaller moet leveren.
Verhoogt het toevoegen van speciale tekens altijd de entropie?
Alleen als de tekens willekeurig uit de volledige pool worden gekozen. Voorspelbare substituties zoals @ voor a of ! aan het einde voegen vrijwel geen entropie toe, omdat aanvallers deze patronen al in hun woordenboeken meenemen.
Wat is de entropie van een Diceware-passphrase van 4 woorden?
Met de standaard Diceware-lijst van 7.776 woorden draagt elk woord 12,92 bits bij. Vier woorden geven ongeveer 51,7 bits — voldoende voor toepassingen met lage beveiligingseisen. Gebruik voor belangrijke accounts 5-6 woorden (64-78 bits).
Is Math.random() veilig voor het genereren van wachtwoorden?
Nee. Math.random() is een pseudo-willekeurige getallengenerator die niet cryptografisch veilig is. Gebruik crypto.getRandomValues() in de browser of crypto.randomBytes() in Node.js voor beveiligingsgevoelige willekeurige generatie.
Hoe beïnvloedt de cost-factor van bcrypt de beveiliging?
Elke verhoging van de cost-factor van bcrypt verdubbelt de benodigde rekenkracht om een hash van een wachtwoord te berekenen (en dus via brute force te kraken). Een cost van 12 betekent 2¹² = 4.096 iteraties, wat effectief 12 bits moeilijkheid toevoegt bovenop de intrinsieke entropie van het wachtwoord.
Wat veranderde er in de NIST-wachtwoordrichtlijnen van 2024?
NIST SP 800-63B liet verplichte complexiteitseisen (afgedwongen speciale tekens, gemengde hoofdletters) en periodieke wachtwoordrotatie vallen. De nieuwe richtlijn geeft voorkeur aan langere wachtwoorden (15+ tekens aanbevolen), screening tegen databases met gelekte wachtwoorden en het toestaan van alle printbare tekens, inclusief spaties.
Belangrijkste inzichten
- Entropie = L × log₂(R) — elke extra bit verdubbelt het aantal benodigde pogingen
- Lengte > complexiteit — één teken toevoegen is effectiever dan de tekenset uitbreiden
- Gebruik crypto-API’s —
crypto.getRandomValues()ofcrypto.randomBytes(), nooitMath.random() - Wachtwoordbeheerder + willekeurige generatie is voor de meeste mensen de beste aanpak
- Serverzijde telt ook — gebruik bcrypt of argon2, sla wachtwoorden nooit op met MD5
Wil je een wachtwoord met hoge entropie genereren? Probeer onze willekeurige wachtwoordgenerator — die toont realtime entropie-analyse voor elk wachtwoord dat je maakt.