De woordenboekaanval — uitgebreide werking

Referentiedocument van het project Time2Crack
Doelgroep: ontwikkelaars, beveiligingsonderzoekers, gevorderde gebruikers

Inhoud

  1. Overzicht
  2. Historische en wetenschappelijke achtergrond
  3. Waarom woordenboeken werken
  4. Opbouw van een moderne woordenboekaanval
  5. Corpora van echte wachtwoorden
  6. De HIBP-controle (k-anonimiteit)
  7. De taalwoordenlijsten van Time2Crack
  8. De woordenboekrang: rankDictionary()
  9. De-leetificatie
  10. Van rang naar kraaktijd
  11. Vergelijking met afgeleide aanvallen
  12. Grenzen van de woordenboekaanval
  13. Doeltreffende verdediging
  14. 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 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.

JaarGebeurtenis
1979Morris 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.
1988De 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.
1991Crack (Alec Muffett): de eerste veelgebruikte wachtwoordkraker voor Unix, met regels om woorden te bewerken.
1996John the Ripper maakt de modus „woordenlijst + regels” populair.
2009RockYou-lek: 32 miljoen accounts in platte tekst (14,3 miljoen verschillende wachtwoorden) laten zien hoe mensen echt hun wachtwoord kiezen.
2013Troy 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.
2015Hashcat 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:

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”):

AlgoritmeSnelheidTijd voor 1 miljoen kandidaten
NTLM4.081 GH/s0,25 microseconde
MD52.634 GH/s0,38 microseconde
SHA-1837 GH/s1,2 microseconde
SHA-256332 GH/s3,0 microseconde
bcrypt (kosten 5)3.658 kH/s0,27 seconde
Argon2id1.000 H/songeveer 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:

3.3 Twee manieren om „in de lijsten” te staan

Een wachtwoord kan om twee verschillende redenen in een aanvalslijst staan:

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:

Voor een lijst van 1 miljard gelekte wachtwoorden op 12× RTX 5090:

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:

  1. De meest gebruikte gelekte wachtwoorden (top 100 van RockYou)
  2. Wachtwoorden die in veel lekken voorkomen (gesorteerd op HIBP-frequentie)
  3. Gewone woorden uit de doeltaal
  4. Eigennamen (voornamen, steden, beroemdheden)
  5. Termen die met het doelwit te maken hebben
  6. 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)

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:

RangWachtwoordAccountsAandeel
1123456290.7312,03%
21234579.0780,55%
312345678976.7900,54%
4password59.4620,42%
5iloveyou49.9520,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

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:

TellerBetekenis
Meer dan 1.000.000Een van de meest gebruikte wachtwoorden ter wereld: elke aanvaller probeert het als eerste
10.000 tot 1.000.000Zeer gangbaar
1.000 tot 10.000Gangbaar
100 tot 1.000Ongewoon maar bekend
1 tot 100Zeldzaam, 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:

TaalBestandWoorden
Engelsen.txt.gz748.958
Fransfr.txt.gz550.235
Spaanses.txt.gz284.834
Portugeespt.txt.gz507.721
Duitsde.txt.gz2.009.880
Italiaansit.txt.gz3.252.670
Nederlandsnl.txt.gz2.678.323
Poolspl.txt.gz3.670.705
Turkstr.txt.gz400.442
Totaal14.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

NiveauRegelVoorbeeldRang
1. Meest gebruikte wachtwoordenPositie in een lijst van 105 van de meest gebruikte wachtwoorden (RockYou, HIBP)password2
2. Leetspeak-variantPositie van de gede-leetificeerde vorm × 10p@ssw0rd20
3. TaalwoordenlijstDe helft van de lijstgroottesoleil (Frans)275.117
4. Samengesteld woordZie 8.4apfelbaumkuchen (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):

SchrijfwijzeFactorVoorbeeldRang
Alles in kleine letters× 1soleil275.117
Alleen de eerste letter× 2Soleil550.234
Alleen de laatste letter× 2soleiL550.234
Alles in hoofdletters× 2PASSWORD4
Elke andere mengvormsom van C(n, i) voor i = 1 … min(hoofdletters, kleine letters)PaSsWoRd324

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


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:

AlgoritmeSnelheid (12× RTX 5090)BerekeningTijd
NTLM4.081 GH/s275.117 / 4.081 × 10967 nanoseconden
MD52.634 GH/s275.117 / 2.634 × 109104 nanoseconden
SHA-1837 GH/s275.117 / 837 × 109329 nanoseconden
SHA-256332 GH/s275.117 / 332 × 109829 nanoseconden
bcrypt (kosten 5)3.658 kH/s275.117 / 3.658.0000,08 seconde
Argon2id1.000 H/s275.117 / 1.0004 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

CriteriumWoordenboekHybride (woordenboek + regels)
KandidatenDe woorden uit de lijst, ongewijzigdElk woord met zijn bewerkingen (cijfers, symbolen, hoofdletters…)
Gekraakte voorbeeldenpassword, vlinderP@ssw0rd!, vlinder2024
SnelheidMinder kandidaten, dus snellerVeel bredere dekking
Van toepassing alsHet exacte woord in de lijst staatHet 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

CriteriumWoordenboekPCFG
ModelVaste lijst kandidatenProbabilistische grammatica van wachtwoordstructuren
Sterk puntExacte woordenStructuren als woord + cijfers, hoofdletter + kleine letters + symbool
Voorbeeldpassword ✓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

CriteriumWoordenboekMarkov
KandidatenVooraf samengestelde lijstTer plekke gegenereerd door een statistisch model
DekkingBekende woordenschatElke reeks die er „menselijk uitziet”
VoordeelZeer snel bij exacte woordenDekt 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

CriteriumWoordenboekCredential stuffing
DoelEen hash krakenInloggen op een account
MechanismeLokale hashberekeningInlogpogingen op afstand
BronAlgemene woordenlijstGelekte e-mail/wachtwoordparen
VerdedigingTraag hashalgoritmePogingen 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

12.2 Wat Time2Crack niet modelleert


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):

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

13.3 Praktische aanbevelingen


14. Bronnen

Wetenschappelijke bronnen

Bronnen uit de praktijk

Achtergrond


Broncode: core/rank/dictionary.js (rankDictionary, deleet), core/rank/uppercase.js (uppercaseCost), core/time.js (rankToSeconds), app.js (loadDictionary, checkHIBP).