De woordenboekaanval — uitgebreide werking
Referentiedocument van het project Time2Crack
Doelgroep: ontwikkelaars, beveiligingsonderzoekers, gevorderde gebruikers
Inhoud
- Overzicht
- Historische en wetenschappelijke achtergrond
- Waarom woordenboeken werken
- Opbouw van een moderne woordenboekaanval
- Corpora van echte wachtwoorden
- De HIBP-controle (k-anonimiteit)
- De taalwoordenlijsten van Time2Crack
- De woordenboekrang:
rankDictionary() - De-leetificatie
- Van rang naar kraaktijd
- Vergelijking met afgeleide aanvallen
- Grenzen van de woordenboekaanval
- Doeltreffende verdediging
- Bronnen
1. Overzicht
De woordenboekaanval is de oudste methode om wachtwoorden te kraken, de eenvoudigste om te begrijpen en statistisch de doeltreffendste tegen echte, door mensen gekozen wachtwoorden. In plaats van alle mogelijke combinaties af te lopen zoals brute force, test ze een vooraf samengestelde lijst kandidaten — het „woordenboek” — in volgorde van afnemende waarschijnlijkheid.
Waarom ze zo goed werkt. Mensen kiezen hun wachtwoord niet willekeurig. Decennia aan datalekken laten zien dat echte wachtwoorden extreem geconcentreerd zijn: in het RockYou-lek werd 123456 alleen al door 290.731 accounts gebruikt, ongeveer 2% van het totaal. Een goed opgebouwde woordenboekaanval test deze kandidaten eerst en vindt ze in een fractie van een seconde, waar brute force jaren nodig zou hebben.
Time2Crack gebruikt twee onafhankelijke mechanismen:
- De woordenboekrang, lokaal berekend: hoort het wachtwoord bij de meest gebruikte wachtwoorden, eventueel vermomd in leetspeak, of is het een woord uit het woordenboek van de gekozen taal? Deze rang bepaalt de kraaktijden in de resultatentabel.
- De controle bij Have I Been Pwned (HIBP): is precies dit wachtwoord al in een datalek opgedoken? Het antwoord verschijnt als een aparte badge boven de resultaten.
De twee vullen elkaar aan: HIBP kent de wachtwoorden die al gelekt zijn, de woordenlijsten dekken gewone woorden die nog niet gelekt zijn.
2. Historische en wetenschappelijke achtergrond
2.1 Oorsprong
De woordenboekaanval is ouder dan de moderne computerbeveiliging. De eerste Unix-systemen bewaarden de wachtwoordhashes in het voor iedereen leesbare bestand /etc/passwd: wie het kon lezen, kon een woordenlijst tegen alle accounts testen.
| Jaar | Gebeurtenis |
|---|---|
| 1979 | Morris en Thompson publiceren het eerste wetenschappelijke artikel over de beveiliging van Unix-wachtwoorden; een groot deel van de onderzochte wachtwoorden waren gewone woorden of namen. |
| 1988 | De Morris-worm verspreidt zich onder meer door wachtwoorden te raden met een ingebouwde lijst van 432 woorden en daarna met het systeemwoordenboek /usr/share/dict/words. |
| 1991 | Crack (Alec Muffett): de eerste veelgebruikte wachtwoordkraker voor Unix, met regels om woorden te bewerken. |
| 1996 | John the Ripper maakt de modus „woordenlijst + regels” populair. |
| 2009 | RockYou-lek: 32 miljoen accounts in platte tekst (14,3 miljoen verschillende wachtwoorden) laten zien hoe mensen echt hun wachtwoord kiezen. |
| 2013 | Troy Hunt lanceert Have I Been Pwned. In hetzelfde jaar legt het Adobe-lek 153 miljoen accounts bloot waarvan de wachtwoorden zonder salt versleuteld waren, zodat identieke wachtwoorden herkenbaar waren. |
| 2015 | Hashcat wordt open source; woordenboekaanvallen op GPU's komen binnen ieders bereik. |
| 2019 | „Collection #1–5”: miljarden e-mail/wachtwoordparen uit eerdere lekken circuleren openbaar. |
2.2 De bepalende lekken
Sommige lekken hebben de woordenboekaanval veranderd door de werkelijke verdeling van menselijke wachtwoorden bloot te leggen:
- RockYou (2009): 14,3 miljoen verschillende wachtwoorden in platte tekst. Wachtwoord nr. 1 (
123456) werd door 290.731 accounts gebruikt, ongeveer 2% van het totaal. - LinkedIn (2012): eerst werden 6,5 miljoen SHA-1-hashes zonder salt gepubliceerd; later bleek het lek ongeveer 117 miljoen accounts te betreffen.
- Adobe (2013): 153 miljoen accounts; de in platte tekst bewaarde wachtwoordhints hielpen de meest gebruikte wachtwoorden te raden.
- Have I Been Pwned (sinds 2013): een doorlopende verzameling van openbare lekken, inmiddels wereldwijd een referentie.
2.3 Hoe snel is een woordenboekaanval?
Een lijst van 1 miljoen woorden, getest met de snelheden die Time2Crack gebruikt (12× RTX 5090, het standaardprofiel „Standard”):
| Algoritme | Snelheid | Tijd voor 1 miljoen kandidaten |
|---|---|---|
| NTLM | 4.081 GH/s | 0,25 microseconde |
| MD5 | 2.634 GH/s | 0,38 microseconde |
| SHA-1 | 837 GH/s | 1,2 microseconde |
| SHA-256 | 332 GH/s | 3,0 microseconde |
| bcrypt (kosten 5) | 3.658 kH/s | 0,27 seconde |
| Argon2id | 1.000 H/s | ongeveer 17 minuten |
Tegen snelle hashfuncties (MD5, SHA-1, NTLM) slaagt de woordenboekaanval dus vrijwel meteen, en zelfs tegen bcrypt blijft ze snel.
3. Waarom woordenboeken werken
3.1 De machtswet van menselijke wachtwoorden
Empirische studies komen allemaal tot dezelfde conclusie: menselijke wachtwoorden zijn niet gelijkmatig verdeeld. Ze volgen een machtswet (de wet van Zipf): een paar wachtwoorden nemen een onevenredig groot deel van de keuzes voor hun rekening.
Formeel: als je de wachtwoorden sorteert op afnemende frequentie, is de frequentie van het wachtwoord op rang r ongeveer evenredig met r−s, waarbij de exponent s van het corpus afhangt (Wang et al., 2017).
Direct gevolg: een aanvaller die alleen de 10 meest gebruikte wachtwoorden probeert, heeft bij een bepaald account al ongeveer één kans op 20.
3.2 Cognitieve vooroordelen bij het kiezen van wachtwoorden
Mensen volgen voorspelbare gewoonten als ze een wachtwoord maken:
- Onthoudbaarheid: makkelijk te onthouden woorden (gewone woorden, voornamen, popcultuur) zijn oververtegenwoordigd.
- Beschikbaarheid: het wachtwoord weerspiegelt de directe omgeving (naam van het huisdier, sportclub, favoriete personage).
- Voorspelbare vervangingen: e → 3, a → @, o → 0. De gebruiker denkt dat het wachtwoord sterker is, maar dit zijn precies de vervangingen die een aanvaller het eerst probeert.
- Toevoegingen aan het eind: een cijfer of symbool achter een woord (
password1,vlinder!). - Taal en cultuur: veelgebruikte wachtwoorden hangen af van de taal van de gebruiker (
Soleil123in Frankrijk,Sommer123in Duitsland).
3.3 Twee manieren om „in de lijsten” te staan
Een wachtwoord kan om twee verschillende redenen in een aanvalslijst staan:
- Het is al gelekt. Precies dit wachtwoord is in een eerder lek opgedoken. De aanvaller hoeft niet te raden: hij probeert de bekende wachtwoorden op volgorde van frequentie.
- Het is een gewoon woord. Ook als het nooit gelekt is, staat het in elke aanvalslijst omdat het een voor de hand liggende kandidaat is. Een woord als
parapluontbreekt misschien in HIBP, maar staat in de Nederlandse woordenlijst van elk serieus kraakprogramma.
Deze twee gevallen komen overeen met de twee mechanismen van Time2Crack die hieronder worden beschreven.
4. Opbouw van een moderne woordenboekaanval
4.1 Algemeen verloop
Een moderne woordenboekaanval verloopt in vier fasen:
Fase 1: de woordenlijst samenstellen
├── Gelekte wachtwoorden (HIBP, RockYou, verzamelingen)
├── Taalwoordenlijsten (woordenboeken, voornamen, plaatsen)
├── Themalijsten (sport, popcultuur, techniek, religie)
└── Gerichte lijsten (domein van het bedrijf, namen van medewerkers)
Fase 2: de woordenlijst voorbereiden
├── Sorteren op frequentie (meest waarschijnlijke eerst)
├── Dubbele invoer verwijderen
├── Filteren op lengte (doellengte ± 2)
└── Normaliseren (kleine letters, Unicode NFC)
Fase 3: hashen en vergelijken
voor elke kandidaat w uit de woordenlijst:
als hash(w) == doelhash: gevonden
(miljarden kandidaten per seconde op de GPU bij MD5)
Fase 4: rapport
└── Gekraakte wachtwoorden, dekkingsstatistieken
4.2 Hardware-optimalisaties
Moderne woordenboekaanvallen draaien massaal parallel op GPU's:
- Hashcat (het referentieprogramma) gebruikt duizenden GPU-kernen om miljarden hashes per seconde te berekenen.
- Batchverwerking: kandidaten worden in batches van miljoenen naar de GPU gestuurd, zodat die voortdurend bezig blijft.
- Regels op de GPU: bewerkingsregels worden direct op de GPU toegepast; zo levert een korte woordenlijst miljarden kandidaten op zonder dat die opgeslagen hoeven te worden.
Voor een lijst van 1 miljard gelekte wachtwoorden op 12× RTX 5090:
- MD5: 109 / 2.634 × 109 ≈ 0,4 milliseconde
- bcrypt (kosten 5): 109 / 3.658.000 ≈ 5 minuten
Dit verschil van ongeveer zes ordes van grootte tussen MD5 en bcrypt laat zien hoe belangrijk de keuze van het hashalgoritme is.
4.3 De volgorde van de kandidaten
De woordenlijst wordt niet alfabetisch getest, maar op afnemende waarschijnlijkheid:
- De meest gebruikte gelekte wachtwoorden (top 100 van RockYou)
- Wachtwoorden die in veel lekken voorkomen (gesorteerd op HIBP-frequentie)
- Gewone woorden uit de doeltaal
- Eigennamen (voornamen, steden, beroemdheden)
- Termen die met het doelwit te maken hebben
- Varianten en vervoegde vormen
Met deze volgorde wordt een zwak wachtwoord in de eerste milliseconden gevonden, ongeacht de hashsnelheid.
5. Corpora van echte wachtwoorden
5.1 Have I Been Pwned (HIBP)
- Omvang: meer dan een miljard verschillende wachtwoorden, afkomstig van meer dan 14 miljard gecompromitteerde accounts
- Bron: verzameling van openbare lekken sinds 2013
- Formaat: SHA-1- (en NTLM-)hashes met het aantal keren dat elk wachtwoord is gezien
- Toegang: API met k-anonimiteit; verdedigers kunnen de volledige lijst downloaden
HIBP is de wereldwijde referentie omdat het bijna alle grote openbare lekken dekt, de frequentie van elk wachtwoord vermeldt en actief wordt bijgehouden. Een aanvaller met de volledige lijst kan de meest voorkomende wachtwoorden eerst testen.
5.2 RockYou (2009): het grondleggende corpus
14,3 miljoen verschillende wachtwoorden in platte tekst. De top van de lijst:
| Rang | Wachtwoord | Accounts | Aandeel |
|---|---|---|---|
| 1 | 123456 | 290.731 | 2,03% |
| 2 | 12345 | 79.078 | 0,55% |
| 3 | 123456789 | 76.790 | 0,54% |
| 4 | password | 59.462 | 0,42% |
| 5 | iloveyou | 49.952 | 0,35% |
Conclusie: een handvol kandidaten, in enkele nanoseconden tegen MD5 getest, volstaat om een meetbaar deel van de accounts in een gelekte database te compromitteren.
5.3 Gespecialiseerde verzamelingen woordenlijsten
- SecLists (Daniel Miessler): een opensourceverzameling lijsten voor beveiligingstests — gelekte wachtwoorden, wachtwoorden per taal, technische termen, namen.
- CrackStation: ongeveer 1,5 miljard items, waaronder alle woorden van Wikipedia in meerdere talen.
- Weakpass: zeer grote verzamelingen echte gelekte wachtwoorden.
Deze corpora zijn openbaar te downloaden: hun bestaan is een vaststaand feit in de offensieve beveiliging.
6. De HIBP-controle (k-anonimiteit)
6.1 Het k-anonimiteitsprotocol
Time2Crack controleert het wachtwoord bij HIBP zonder het ooit te versturen, en ook niet de volledige hash ervan. Het protocol werkt zo:
1. SHA-1(wachtwoord) berekenen
→ bv. CBFDAC6008F9CAB4083784CBD1874F76618D2A97
2. Alleen de eerste 5 tekens naar de HIBP-API sturen
→ GET https://api.pwnedpasswords.com/range/CBFDA
3. De API geeft alle hash-suffixen terug die met dit prefix beginnen
(enkele honderden regels, aangevuld met nepregels)
4. De rest van de hash lokaal in het antwoord zoeken
→ C6008F9CAB4083784CBD1874F76618D2A97
5. Gevonden: het wachtwoord is gelekt en HIBP zegt hoe vaak
Niet gevonden: het wachtwoord staat niet in HIBP
Privacygarantie: de HIBP-server ziet alleen een prefix van 5 tekens dat honderden wachtwoorden gemeen hebben. Hij kan niet weten welk wachtwoord is gecontroleerd. De vergelijking gebeurt in de browser.
6.2 De uitvoering in Time2Crack
De controle start een halve seconde na de laatste toetsaanslag, tegelijk met de lokale analyse:
// app.js - checkHIBP()
async function checkHIBP(password) {
const sha1 = await sha1Hex(password); // uppercase hex SHA-1
const prefix = sha1.slice(0, 5); // sent to the API
const suffix = sha1.slice(5); // never leaves the browser
const res = await fetch(`https://api.pwnedpasswords.com/range/${prefix}`, {
headers: { "Add-Padding": "true" }, // hide the real size of the response
});
if (!res.ok) return null; // API unavailable
const text = await res.text();
for (const line of text.split("\n")) {
const [hashSuffix, count] = line.trim().split(":");
if (hashSuffix === suffix) return parseInt(count, 10); // number of leaks
}
return 0; // not found
}
Het resultaat verschijnt als badge: „N keer gevonden”, „niet gevonden” of „niet beschikbaar” als de API niet bereikbaar is. Het verandert de kraaktijden niet; die worden lokaal berekend.
6.3 De HIBP-teller lezen
De teller is het aantal keren dat precies dit wachtwoord in de geïndexeerde lekken is gezien:
| Teller | Betekenis |
|---|---|
| Meer dan 1.000.000 | Een van de meest gebruikte wachtwoorden ter wereld: elke aanvaller probeert het als eerste |
| 10.000 tot 1.000.000 | Zeer gangbaar |
| 1.000 tot 10.000 | Gangbaar |
| 100 tot 1.000 | Ongewoon maar bekend |
| 1 tot 100 | Zeldzaam, maar gecompromitteerd |
Zelfs een teller van 1 is een waarschuwing: het wachtwoord staat in de lijsten waarover aanvallers beschikken, en wie het account aanvalt waar het uit gelekt is, zal het proberen.
7. De taalwoordenlijsten van Time2Crack
7.1 Waarom taalwoordenlijsten naast HIBP
HIBP dekt wachtwoorden die al gelekt zijn, niet gewone woorden die nog niet gelekt zijn. Wie zonnebloem kiest, staat misschien niet in HIBP, maar het woord staat in de Nederlandse woordenlijst van elke aanvaller die het op Nederlandstalige gebruikers gemunt heeft. De taalwoordenlijsten van Time2Crack vullen dit gat:
| Taal | Bestand | Woorden |
|---|---|---|
| Engels | en.txt.gz | 748.958 |
| Frans | fr.txt.gz | 550.235 |
| Spaans | es.txt.gz | 284.834 |
| Portugees | pt.txt.gz | 507.721 |
| Duits | de.txt.gz | 2.009.880 |
| Italiaans | it.txt.gz | 3.252.670 |
| Nederlands | nl.txt.gz | 2.678.323 |
| Pools | pl.txt.gz | 3.670.705 |
| Turks | tr.txt.gz | 400.442 |
| Totaal | 14.103.768 |
De eerste versies kwamen uit de Wikipedia-woordenlijsten van SecLists en de woordenlijsten van kkrypt0nn; ze zijn sindsdien uitgebreid. Bij het laden wordt van elke regel de witruimte verwijderd en wordt hij omgezet naar kleine letters; woorden van minder dan 3 tekens worden weggelaten.
7.2 Laden wanneer nodig
De woordenlijsten zitten niet in de code. Alleen de lijst van de gekozen taal wordt gedownload, de eerste keer dat ze nodig is, als gzip-bestand:
// app.js - loadDictionary() (simplified: progress bar updates removed)
async function loadDictionary(lang = AppConfig.lang) {
// Already loaded for this language
if (AppConfig.dictWords !== null && AppConfig.dictLang === lang) return;
// 1. Local cache (IndexedDB)
const cached = await cacheGet(`dict_${lang}`);
if (cached) {
AppConfig.setDictionary(new Set(cached), lang);
return;
}
// 2. Download the compressed list
const res = await fetch(`${basePath}data/wordlists/${lang}.txt.gz`);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const buffer = await res.arrayBuffer();
// 3. Decompress in the browser (plain .txt if DecompressionStream is missing)
let text;
try {
text = await new Response(
ReadableStream.from([new Uint8Array(buffer)])
.pipeThrough(new DecompressionStream("gzip"))
).text();
} catch {
text = await (await fetch(`${basePath}data/wordlists/${lang}.txt`)).text();
}
// 4. Normalise, filter, index
const words = text.split("\n")
.map(w => w.trim().toLowerCase())
.filter(w => w.length >= 3);
AppConfig.setDictionary(new Set(words), lang);
// 5. Keep it for the next visit
await cachePut(`dict_${lang}`, words);
}
Waarom een Set? Een JavaScript-Set beantwoordt dictWords.has(word) in constante tijd, of de lijst nu 285.000 woorden (Spaans) of 3,7 miljoen (Pools) bevat. Met een Array zou elke zoekopdracht één vergelijking per woord kunnen vergen.
7.3 Lokale cache (IndexedDB)
De voorbereide lijst wordt in de IndexedDB van de browser opgeslagen onder de sleutel dict_<taal>. Bij het volgende bezoek wordt ze uit de cache gelezen in plaats van opnieuw gedownload en uitgepakt:
Eerste bezoek Volgende bezoeken
------------- -----------------
fetch nl.txt.gz cacheGet("dict_nl")
└── gunzip (DecompressionStream) └── new Set(words)
└── trim / kleine letters / ≥ 3 └── klaar
└── new Set(words)
└── cachePut("dict_nl")
└── klaar
Het wachtwoord verlaat nooit de browser: de lijst wordt van de server van Time2Crack gedownload en de vergelijking gebeurt lokaal.
8. De woordenboekrang: rankDictionary()
8.1 Het principe: eerst een rang, dan een tijd
Time2Crack vraagt zich niet alleen af „is dit een woordenboekwoord?”, maar „na hoeveel pogingen zou een woordenboekaanval het vinden?”. Dat aantal pogingen is de rang. De functie rankDictionary() (bestand core/rank/dictionary.js) geeft hem terug, of null als de aanval niet van toepassing is:
// core/rank/dictionary.js - rankDictionary()
export function rankDictionary(password, dictWords = null) {
const lower = password.toLowerCase();
const deleeted = deleet(password);
const alpha = password.replace(/[^a-zA-Z]/g, "");
const uCost = uppercaseCost(alpha); // capital letters, see 8.3
// 1. In the top passwords as is?
const topIdx = TOP_PASSWORDS.indexOf(lower);
if (topIdx !== -1) return { rank: (topIdx + 1) * uCost, model: "dictionary" };
// 2. De-leeted form in the top passwords?
const deIdx = TOP_PASSWORDS.indexOf(deleeted);
if (deIdx !== -1) return { rank: (deIdx + 1) * 10 * uCost, model: "dictionary" };
// 3. In the wordlist of the selected language?
if (dictWords instanceof Set) {
if (dictWords.has(lower) || dictWords.has(deleeted)) {
const mid = Math.floor(dictWords.size / 2);
if (passwordLength(password) >= 9) {
// a long word may also be split into shorter words, see 8.4
const compound = rankGermanCompound(password, dictWords);
if (compound && compound.rank < mid)
return { rank: compound.rank * uCost, model: "dictionary" };
}
return { rank: mid * uCost, model: "dictionary" };
}
// 4. Compound made of several dictionary words?
const compound = rankGermanCompound(password, dictWords);
if (compound) return { rank: compound.rank * uCost, model: "dictionary" };
}
// Not found: the dictionary attack does not apply
return { rank: null, model: "dictionary" };
}
8.2 Vier niveaus
| Niveau | Regel | Voorbeeld | Rang |
|---|---|---|---|
| 1. Meest gebruikte wachtwoorden | Positie in een lijst van 105 van de meest gebruikte wachtwoorden (RockYou, HIBP) | password | 2 |
| 2. Leetspeak-variant | Positie van de gede-leetificeerde vorm × 10 | p@ssw0rd | 20 |
| 3. Taalwoordenlijst | De helft van de lijstgrootte | soleil (Frans) | 275.117 |
| 4. Samengesteld woord | Zie 8.4 | apfelbaumkuchen (Duits) | 21.129 |
Waarom de helft van de lijst? De woordenlijsten zijn niet op frequentie gesorteerd: de positie van een woord in het bestand zegt niets over wanneer een aanvaller het zou proberen. Gemiddeld vindt een aanvaller die de lijst doorloopt een bepaald woord halverwege.
8.3 Hoofdletters
Een aanvaller begint met woorden in kleine letters en probeert daarna varianten met hoofdletters. De rang wordt vermenigvuldigd met het aantal varianten dat nodig is om de schrijfwijze van het wachtwoord te bereiken (functie uppercaseCost(), dezelfde methode als zxcvbn):
| Schrijfwijze | Factor | Voorbeeld | Rang |
|---|---|---|---|
| Alles in kleine letters | × 1 | soleil | 275.117 |
| Alleen de eerste letter | × 2 | Soleil | 550.234 |
| Alleen de laatste letter | × 2 | soleiL | 550.234 |
| Alles in hoofdletters | × 2 | PASSWORD | 4 |
| Elke andere mengvorm | som van C(n, i) voor i = 1 … min(hoofdletters, kleine letters) | PaSsWoRd | 324 |
8.4 Samengestelde woorden
Het Duits (en het Nederlands) plakt woorden aan elkaar: Apfelbaumkuchen = Apfel + Baum + Kuchen. Zo'n woord ontbreekt vaak in de lijst, maar een aanvaller kan het samenstellen uit kortere woorden. Time2Crack probeert het wachtwoord op te splitsen in 2 tot 4 woorden uit de lijst en laat daarbij de gebruikelijke Duitse tussenletters toe (-s-, -es-, -n-, -en-, -er-, -e-). De rang is dan de maskerrang van het wachtwoord vermenigvuldigd met 0,25 (2 woorden), 0,16 (3 woorden) of 0,10 (4 woorden), en met 0,75 als het laatste stuk een veelvoorkomend achtervoegsel is (-heit, -ung, -haus…).
De splitsing wordt ook geprobeerd bij lange woorden die in de lijst staan (9 tekens of meer) en behouden als ze een lagere rang geeft: Sonnenblume krijgt rang 42.680 in plaats van de helft van de Duitse lijst (1.004.940).
9. De-leetificatie
9.1 Leetspeak beschermt niet
Leetspeak vervangt letters door cijfers of symbolen die erop lijken: a → @, e → 3, i → 1, o → 0, s → $. Mensen gebruiken het om een gewoon woord te „versterken”: password → p@$$w0rd.
In werkelijkheid behoren deze vervangingen tot de eerste regels die kraakprogramma's toepassen. Een bekwame aanvaller wordt er niet door afgeremd.
9.2 De functie deleet()
// core/rank/dictionary.js - deleet()
function deleet(pw) {
return pw
.toLowerCase()
.replace(/0/g, "o")
.replace(/1/g, "i")
.replace(/3/g, "e")
.replace(/4/g, "a")
.replace(/5/g, "s")
.replace(/7/g, "t")
.replace(/8/g, "b")
.replace(/@/g, "a")
.replace(/\$/g, "s")
.replace(/!/g, "i");
}
Het wachtwoord wordt gezocht zoals het is ingetypt en in de gede-leetificeerde vorm. Bij de meest gebruikte wachtwoorden kost de gede-leetificeerde vorm 10 keer meer (de aanvaller moet de varianten proberen): p@ssw0rd → 20 in plaats van 2. In de taalwoordenlijst kost ze evenveel als het gewone woord.
9.3 Wat niet gedecodeerd wordt
- Elk teken heeft maar één vervanging:
1wordt altijdi, nooitl;p1ayerwordt dus niet alsplayerherkend. - Zeldzamere vervangingen (
+→ t,9→ g,#→ h) worden niet gedecodeerd. - Een woord gevolgd door cijfers of symbolen (
vlinder2024,vlinder!) is geen woordenboektreffer: dat neemt de hybride aanval voor zijn rekening.
10. Van rang naar kraaktijd
De rang wordt omgezet in seconden door hem te delen door de hashsnelheid van de aanvaller:
// core/time.js - rankToSeconds()
export function rankToSeconds(rank, algo, profile = "experienced") {
const baseRate = HASH_RATES[algo]; // guesses per second, 12× RTX 5090
if (!baseRate) throw new Error(`Unknown algorithm: ${algo}`);
const multiplier = ATTACKER_MULTIPLIERS[profile] ?? 1;
return rank / (baseRate * multiplier);
}
Voorbeeld voor soleil (Franse woordenlijst, rang 275.117) met het standaardprofiel:
| Algoritme | Snelheid (12× RTX 5090) | Berekening | Tijd |
|---|---|---|---|
| NTLM | 4.081 GH/s | 275.117 / 4.081 × 109 | 67 nanoseconden |
| MD5 | 2.634 GH/s | 275.117 / 2.634 × 109 | 104 nanoseconden |
| SHA-1 | 837 GH/s | 275.117 / 837 × 109 | 329 nanoseconden |
| SHA-256 | 332 GH/s | 275.117 / 332 × 109 | 829 nanoseconden |
| bcrypt (kosten 5) | 3.658 kH/s | 275.117 / 3.658.000 | 0,08 seconde |
| Argon2id | 1.000 H/s | 275.117 / 1.000 | 4 minuten 35 seconden |
Zelfs met Argon2id valt een eenvoudig Frans woord in minder dan 5 minuten. Het aanvallersprofiel verandert de snelheden: van één GPU (profiel „Amateur”) tot ongeveer 10.000 GPU's (profiel „Staat”). Zoals bij alle andere modellen kan de woordenboekrang nooit hoger zijn dan de brute-forcerang van hetzelfde wachtwoord.
11. Vergelijking met afgeleide aanvallen
De „pure” woordenboekaanval is de eerste van een familie aanvallen die allemaal van een woordenlijst uitgaan. Time2Crack berekent negen modellen (brute force, woordenboek, hybride, masker, PCFG, Markov, combinator, toetsenbordpatronen, datums), die het wachtwoord elk vanuit een andere hoek aanvallen.
11.1 Woordenboek en hybride
| Criterium | Woordenboek | Hybride (woordenboek + regels) |
|---|---|---|
| Kandidaten | De woorden uit de lijst, ongewijzigd | Elk woord met zijn bewerkingen (cijfers, symbolen, hoofdletters…) |
| Gekraakte voorbeelden | password, vlinder | P@ssw0rd!, vlinder2024 |
| Snelheid | Minder kandidaten, dus sneller | Veel bredere dekking |
| Van toepassing als | Het exacte woord in de lijst staat | Het wachtwoord van een woord uit de lijst is afgeleid |
De hybride aanval begint waar het pure woordenboek ophoudt: ze past systematische bewerkingsregels toe op elk woord uit de lijst (in de geest van best64.rule van hashcat).
11.2 Woordenboek en PCFG
| Criterium | Woordenboek | PCFG |
|---|---|---|
| Model | Vaste lijst kandidaten | Probabilistische grammatica van wachtwoordstructuren |
| Sterk punt | Exacte woorden | Structuren als woord + cijfers, hoofdletter + kleine letters + symbool |
| Voorbeeld | password ✓ | Password123 ✓ (structuur herkend) |
Password123 is als zodanig geen woordenboekwoord, maar PCFG herkent de structuur [hoofdletter][kleine letters][cijfers] en kraakt het zeer snel.
11.3 Woordenboek en Markov
| Criterium | Woordenboek | Markov |
|---|---|---|
| Kandidaten | Vooraf samengestelde lijst | Ter plekke gegenereerd door een statistisch model |
| Dekking | Bekende woordenschat | Elke reeks die er „menselijk uitziet” |
| Voordeel | Zeer snel bij exacte woorden | Dekt ook woorden die in geen enkele lijst staan |
Markov dekt wachtwoorden die op menselijke woorden lijken zonder in een lijst te staan.
11.4 Woordenboek en credential stuffing
| Criterium | Woordenboek | Credential stuffing |
|---|---|---|
| Doel | Een hash kraken | Inloggen op een account |
| Mechanisme | Lokale hashberekening | Inlogpogingen op afstand |
| Bron | Algemene woordenlijst | Gelekte e-mail/wachtwoordparen |
| Verdediging | Traag hashalgoritme | Pogingen beperken, MFA, IP-blokkering |
Credential stuffing valt geen hash aan: het probeert gelekte e-mail/wachtwoordparen rechtstreeks bij onlinediensten. Het is een andere aanval, maar met dezelfde gegevens (lekken zoals die in HIBP). Time2Crack modelleert het niet.
12. Grenzen van de woordenboekaanval
12.1 Inherente grenzen
- Alleen bekende woordenschat. Een verzonnen wachtwoord dat op geen bestaand woord lijkt en nooit gelekt is, ontsnapt aan de pure woordenboekaanval:
Xqz7mK9pLstaat in geen enkele woordenlijst. - Taaldekking. Een aanvaller die het op Nederlandstaligen gemunt heeft zonder Nederlandse woordenlijst, mist woorden als
parapluofgezellig. - Nieuwe wachtwoorden. Een wachtwoord dat nooit gelekt is, staat niet in HIBP, ook al is het gangbaar.
- Lange wachtzinnen.
MijnGrootAvontuurOnderDeSterrenstaat in geen enkele lijst, ook al is elk woord banaal. Wachtzinnen worden door andere aanvallen behandeld (combinator, PRINCE).
12.2 Wat Time2Crack niet modelleert
- Gerichte woordenlijsten: een aanvaller die een sector viseert, stelt specifieke lijsten samen (medische termen voor een ziekenhuis, gamersjargon voor een gameplatform). Programma's als CeWL halen woorden van de website van het doelwit. Time2Crack gebruikt algemene lijsten.
- Recente lekken: tussen een lek en de opname ervan in HIBP circuleren de wachtwoorden privé, zonder zichtbaar te zijn via de openbare API.
- Andere hashalgoritmen: Time2Crack modelleert zes algoritmen (MD5, SHA-1, SHA-256, NTLM, bcrypt, Argon2id). SHA-512, scrypt of PBKDF2 hebben andere profielen.
- Woordfrequentie: elk woord uit de taalwoordenlijst krijgt dezelfde rang (de helft van de lijst), of het nu heel gangbaar of heel zeldzaam is.
13. Doeltreffende verdediging
13.1 Wat beschermt
Een traag hashalgoritme (bcrypt, Argon2id). Dit is de doeltreffendste verdediging aan de serverkant: elke poging kost meer. Voor soleil (rang 275.117):
- MD5: ongeveer 0,1 microseconde
- bcrypt kosten 12 (128 keer trager dan kosten 5): ongeveer 10 seconden
- Argon2id: ongeveer 5 minuten
Een trage hash remt de aanvaller af, maar redt geen woordenboekwoord: de lijst is gewoon te kort.
Een unieke salt per account. Die maakt vooraf berekende tabellen (rainbow tables) nutteloos en dwingt de aanvaller account per account te werken. Een woordenlijstaanval op één account verhindert hij niet.
Lengte en willekeur. Eén woordenboekwoord is altijd kwetsbaar. Een wachtzin van 4 of 5 woorden weerstaat de pure woordenboekaanval, maar niet de combinatoraanval als de woorden voorspelbaar zijn: ze moeten willekeurig getrokken worden.
Willekeurig gegenereerde wachtwoorden. De echte oplossing: een wachtwoordbeheerder die lange, willekeurige wachtwoorden genereert (20 tekens of meer). Die staan in geen enkel woordenboek.
Meervoudige authenticatie (MFA). Die verhindert het offline kraken van gestolen hashes niet, maar wel dat de aanvaller inlogt met een gekraakt wachtwoord.
Pogingen beperken en afwijkingen opsporen. Dat beschermt tegen onlinepogingen, niet tegen het offline kraken van gestolen hashes.
13.2 Wat niet beschermt
- Leetspeak-vervangingen:
password→p@ssw0rd(zie hoofdstuk 9). - Een cijfer aan het eind:
password→password1, een van de eerste geteste regels. - Een hoofdletter vooraan:
password→Password, een standaardregel (rang × 2). - Cijfers en symbolen rond een herkenbaar woord:
vlinder!wordt met de eenvoudigste regels gevonden. - Complexiteit zonder lengte:
P@s1wvoldoet aan de gebruikelijke regels (hoofdletter, kleine letter, cijfer, symbool), maar is korter en voorspelbaarder dancorrecthorsebatterystaple.
13.3 Praktische aanbevelingen
- Gebruik een wachtwoordbeheerder (Bitwarden, 1Password, KeePass): die genereert willekeurige wachtwoorden, u onthoudt alleen het hoofdwachtwoord.
- Schakel overal MFA in: zelfs als een wachtwoord lekt, kan de aanvaller niet inloggen.
- Raadpleeg HIBP regelmatig om te weten of uw e-mailadres in bekende lekken voorkomt.
- Gebruik een wachtwoord nooit opnieuw: credential stuffing maakt misbruik van hergebruik tussen diensten.
- Voor wachtwoorden die u moet onthouden: een wachtzin van 5 woorden of meer, willekeurig getrokken (met dobbelstenen of een generator), niet zelf gekozen.
14. Bronnen
Wetenschappelijke bronnen
- Morris, R., & Thompson, K. (1979). Password security: A case history. Communications of the ACM, 22(11), 594–597. Eerste wetenschappelijke analyse van Unix-wachtwoorden.
- Klein, D. V. (1990). Foiling the cracker: A survey of, and improvements to, password security. Proceedings of the 2nd USENIX Security Workshop. Ongeveer een kwart van 15.000 Unix-wachtwoorden gekraakt met woordenlijsten en regels.
- Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009). Password cracking using probabilistic context-free grammars. IEEE Symposium on Security and Privacy. Het grondleggende artikel over PCFG, vergeleken met woordenboekaanvallen.
- Ur, B., et al. (2012). How does your password measure up? The effect of strength meters on password creation. 21st USENIX Security Symposium.
- Bonneau, J. (2012). The science of guessing: Analyzing an anonymized corpus of 70 million passwords. IEEE Symposium on Security and Privacy. Meet de werkelijke verdeling van wachtwoorden.
- Ma, J., Yang, W., Luo, M., & Li, N. (2014). A study of probabilistic password models. IEEE Symposium on Security and Privacy. Vergelijkt woordenboek-, Markov- en PCFG-modellen op echte corpora.
- Wheeler, D. L. (2016). zxcvbn: Low-budget password strength estimation. 25th USENIX Security Symposium, 157–173. Bron van de hoofdletterkosten uit hoofdstuk 8.3.
- Wang, D., Cheng, H., Wang, P., Huang, X., & Jian, G. (2017). Zipf's law in passwords. IEEE Transactions on Information Forensics and Security, 12(11), 2776–2791.
- Pasquini, D., Cianfriglia, M., Ateniese, G., & Bernaschi, M. (2021). Reducing bias in modeling real-world password strength via deep learning and dynamic dictionaries. 30th USENIX Security Symposium.
Bronnen uit de praktijk
- Have I Been Pwned. Pwned Passwords. https://haveibeenpwned.com/Passwords. De API met k-anonimiteit die Time2Crack gebruikt.
- Hive Systems (2025). Password table. Editie 2025 op basis van 12× RTX 5090. Time2Crack gebruikt gemeten hashcat-benchmarks van de RTX 5090 (Specops 2026, hashcat.net-forum); Argon2id blijft een schatting.
- Hashcat. Advanced password recovery. https://hashcat.net. Referentieprogramma voor GPU-metingen en bewerkingsregels (
best64.rule). - Miessler, D. SecLists. GitHub. Bron van de eerste taalwoordenlijsten van Time2Crack.
Achtergrond
- Hunt, T. (2017). Introducing 306 million freely downloadable Pwned Passwords. troyhunt.com.
- Thomas, K., et al. (2019). Protecting accounts from credential stuffing with password breach alerting. 28th USENIX Security Symposium. Laat zien dat k-anonimiteit de privacy beschermt.
Broncode: core/rank/dictionary.js (rankDictionary, deleet), core/rank/uppercase.js (uppercaseCost), core/time.js (rankToSeconds), app.js (loadDictionary, checkHIBP).