Der Wörterbuchangriff — ausführliche Funktionsweise
Referenzdokument des Projekts Time2Crack
Zielgruppe: Entwickler, Sicherheitsforscher, fortgeschrittene Nutzer
Inhalt
- Überblick
- Historischer und wissenschaftlicher Hintergrund
- Warum Wörterbücher funktionieren
- Aufbau eines modernen Wörterbuchangriffs
- Korpora echter Passwörter
- Die HIBP-Prüfung (k-Anonymität)
- Die Sprach-Wortlisten von Time2Crack
- Der Wörterbuchrang:
rankDictionary() - De-Leetifizierung
- Vom Rang zur Knackzeit
- Vergleich mit abgeleiteten Angriffen
- Grenzen des Wörterbuchangriffs
- Wirksame Abwehrmaßnahmen
- Quellen
1. Überblick
Der Wörterbuchangriff ist die älteste Methode zum Knacken von Passwörtern, die am einfachsten zu verstehende und statistisch die wirksamste gegen echte, von Menschen gewählte Passwörter. Statt wie die Brute-Force-Methode alle möglichen Kombinationen durchzuprobieren, testet er eine vorab erstellte Liste von Kandidaten — das „Wörterbuch“ — in absteigender Wahrscheinlichkeit.
Warum er so gut funktioniert. Menschen wählen ihre Passwörter nicht zufällig. Jahrzehnte von Datenlecks zeigen, dass echte Passwörter extrem konzentriert sind: Im RockYou-Leck wurde 123456 allein von 290.731 Konten verwendet, etwa 2 % aller Konten. Ein gut aufgebauter Wörterbuchangriff testet diese Kandidaten zuerst und findet sie in Sekundenbruchteilen, wo Brute Force Jahre bräuchte.
Time2Crack nutzt zwei voneinander unabhängige Mechanismen:
- Der Wörterbuchrang, lokal berechnet: Gehört das Passwort zu den häufigsten Passwörtern, eventuell in Leetspeak verkleidet, oder ist es ein Wort aus dem Wörterbuch der gewählten Sprache? Aus diesem Rang ergeben sich die Knackzeiten in der Ergebnistabelle.
- Die Prüfung bei Have I Been Pwned (HIBP): Ist genau dieses Passwort schon in einem Datenleck aufgetaucht? Die Antwort erscheint als eigenes Abzeichen über den Ergebnissen.
Beide ergänzen sich: HIBP kennt die bereits geleakten Passwörter, die Wortlisten decken gewöhnliche Wörter ab, die noch nicht geleakt sind.
2. Historischer und wissenschaftlicher Hintergrund
2.1 Ursprünge
Der Wörterbuchangriff ist älter als die moderne IT-Sicherheit. Frühe Unix-Systeme speicherten die Passwort-Hashes in der für alle lesbaren Datei /etc/passwd: Wer sie lesen konnte, konnte eine Wortliste gegen alle Konten testen.
| Jahr | Ereignis |
|---|---|
| 1979 | Morris und Thompson veröffentlichen den ersten wissenschaftlichen Artikel über die Sicherheit von Unix-Passwörtern; ein großer Teil der untersuchten Passwörter waren gängige Wörter oder Namen. |
| 1988 | Der Morris-Wurm verbreitet sich unter anderem, indem er Passwörter mit einer eingebauten Liste von 432 Wörtern errät, danach mit dem Systemwörterbuch /usr/share/dict/words. |
| 1991 | Crack (Alec Muffett): der erste weit verbreitete Passwort-Cracker für Unix, mit Regeln zur Abwandlung von Wörtern. |
| 1996 | John the Ripper macht den Modus „Wortliste + Regeln“ populär. |
| 2009 | RockYou-Leck: 32 Millionen im Klartext gespeicherte Konten (14,3 Millionen verschiedene Passwörter) zeigen, wie Menschen Passwörter wirklich wählen. |
| 2013 | Troy Hunt startet Have I Been Pwned. Im selben Jahr legt das Adobe-Leck 153 Millionen Konten offen, deren Passwörter ohne Salt verschlüsselt waren, sodass gleiche Passwörter erkennbar waren. |
| 2015 | Hashcat wird Open Source; Wörterbuchangriffe auf GPUs werden für alle zugänglich. |
| 2019 | „Collection #1–5“: Milliarden von E-Mail/Passwort-Paaren aus früheren Lecks kursieren öffentlich. |
2.2 Die prägenden Lecks
Einige Lecks haben den Wörterbuchangriff verändert, weil sie die tatsächliche Verteilung menschlicher Passwörter offenlegten:
- RockYou (2009): 14,3 Millionen verschiedene Passwörter im Klartext. Passwort Nr. 1 (
123456) wurde von 290.731 Konten verwendet, etwa 2 % aller Konten. - LinkedIn (2012): zunächst 6,5 Millionen SHA-1-Hashes ohne Salt veröffentlicht; später stellte sich heraus, dass etwa 117 Millionen Konten betroffen waren.
- Adobe (2013): 153 Millionen Konten; die im Klartext gespeicherten Passwort-Hinweise halfen, die häufigsten Passwörter zu erraten.
- Have I Been Pwned (seit 2013): eine fortlaufende Sammlung öffentlicher Lecks, heute weltweit eine Referenz.
2.3 Wie schnell ist ein Wörterbuchangriff?
Eine Liste mit 1 Million Wörtern, getestet mit den Geschwindigkeiten, die Time2Crack verwendet (12× RTX 5090, das voreingestellte Profil „Standard“):
| Algorithmus | Geschwindigkeit | Zeit für 1 Million Kandidaten |
|---|---|---|
| NTLM | 4.081 GH/s | 0,25 Mikrosekunden |
| MD5 | 2.634 GH/s | 0,38 Mikrosekunden |
| SHA-1 | 837 GH/s | 1,2 Mikrosekunden |
| SHA-256 | 332 GH/s | 3,0 Mikrosekunden |
| bcrypt (Kosten 5) | 3.658 kH/s | 0,27 Sekunden |
| Argon2id | 1.000 H/s | etwa 17 Minuten |
Gegen schnelle Hash-Funktionen (MD5, SHA-1, NTLM) ist der Wörterbuchangriff also sofort erfolgreich, und selbst gegen bcrypt bleibt er schnell.
3. Warum Wörterbücher funktionieren
3.1 Das Potenzgesetz menschlicher Passwörter
Empirische Studien kommen alle zum selben Ergebnis: Menschliche Passwörter sind nicht gleichmäßig verteilt. Sie folgen einem Potenzgesetz (Zipfsches Gesetz): Wenige Passwörter vereinen einen unverhältnismäßig großen Anteil aller Entscheidungen auf sich.
Formal: Sortiert man die Passwörter nach absteigender Häufigkeit, ist die Häufigkeit des Passworts auf Rang r ungefähr proportional zu r−s, wobei der Exponent s vom Korpus abhängt (Wang et al., 2017).
Direkte Folge: Ein Angreifer, der nur die 10 häufigsten Passwörter ausprobiert, hat bei einem bestimmten Konto bereits etwa eine Chance von 1 zu 20.
3.2 Kognitive Verzerrungen bei der Passwortwahl
Menschen folgen beim Erstellen eines Passworts vorhersehbaren Gewohnheiten:
- Merkbarkeit: leicht zu merkende Wörter (gängige Begriffe, Vornamen, Popkultur) sind überrepräsentiert.
- Verfügbarkeit: Das Passwort spiegelt die unmittelbare Umgebung wider (Name des Haustiers, Sportverein, Lieblingsfigur).
- Vorhersehbare Ersetzungen: e → 3, a → @, o → 0. Der Nutzer hält sein Passwort für stärker, doch genau diese Ersetzungen probiert ein Angreifer zuerst.
- Anhängen: eine Ziffer oder ein Symbol am Ende eines Wortes (
password1,sonne!). - Sprache und Kultur: Häufige Passwörter hängen von der Sprache ab (
Soleil123in Frankreich,Sommer123in Deutschland).
3.3 Zwei Wege, „in den Listen“ zu stehen
Ein Passwort kann aus zwei verschiedenen Gründen in einer Angriffsliste stehen:
- Es wurde bereits geleakt. Genau dieses Passwort ist in einem früheren Leck aufgetaucht. Der Angreifer muss nicht raten: Er probiert die bekannten Passwörter nach Häufigkeit durch.
- Es ist ein gewöhnliches Wort. Auch wenn es nie geleakt wurde, steht es in jeder Angriffsliste, weil es ein naheliegender Kandidat ist. Ein Wort wie
Regenschirmfehlt vielleicht in HIBP, steht aber in der deutschen Wortliste jedes ernsthaften Cracking-Tools.
Diese beiden Fälle entsprechen den beiden unten beschriebenen Mechanismen von Time2Crack.
4. Aufbau eines modernen Wörterbuchangriffs
4.1 Allgemeiner Ablauf
Ein moderner Wörterbuchangriff verläuft in vier Phasen:
Phase 1: Wortliste zusammenstellen
├── Geleakte Passwörter (HIBP, RockYou, Sammlungen)
├── Sprach-Wortlisten (Wörterbücher, Vornamen, Orte)
├── Themenlisten (Sport, Popkultur, Technik, Religion)
└── Gezielte Listen (Firmendomain, Namen der Mitarbeiter)
Phase 2: Wortliste vorbereiten
├── Nach Häufigkeit sortieren (wahrscheinlichste zuerst)
├── Duplikate entfernen
├── Nach Länge filtern (Ziellänge ± 2)
└── Normalisieren (Kleinbuchstaben, Unicode NFC)
Phase 3: Hashen und vergleichen
für jeden Kandidaten w der Wortliste:
wenn hash(w) == Ziel-Hash: gefunden
(Milliarden Kandidaten pro Sekunde auf der GPU bei MD5)
Phase 4: Auswertung
└── Geknackte Passwörter, Abdeckungsstatistik
4.2 Hardware-Optimierungen
Moderne Wörterbuchangriffe laufen massiv parallel auf GPUs:
- Hashcat (das Referenzwerkzeug) nutzt Tausende GPU-Kerne, um Milliarden Hashes pro Sekunde zu berechnen.
- Stapelverarbeitung: Die Kandidaten werden in Stapeln von Millionen an die GPU geschickt, damit sie voll ausgelastet bleibt.
- Regeln auf der GPU: Abwandlungsregeln werden direkt auf der GPU angewendet; so erzeugt eine kurze Wortliste Milliarden Kandidaten, ohne dass diese gespeichert werden müssen.
Für eine Liste von 1 Milliarde geleakter Passwörter auf 12× RTX 5090:
- MD5: 109 / 2.634 × 109 ≈ 0,4 Millisekunden
- bcrypt (Kosten 5): 109 / 3.658.000 ≈ 5 Minuten
Dieser Unterschied von etwa sechs Größenordnungen zwischen MD5 und bcrypt zeigt, wie wichtig die Wahl des Hash-Algorithmus ist.
4.3 Reihenfolge der Kandidaten
Die Wortliste wird nicht alphabetisch getestet, sondern nach absteigender Wahrscheinlichkeit:
- Die häufigsten geleakten Passwörter (RockYou-Top-100)
- Passwörter, die in vielen Lecks vorkommen (nach HIBP-Häufigkeit sortiert)
- Gängige Wörter der Zielsprache
- Eigennamen (Vornamen, Städte, Prominente)
- Begriffe mit Bezug zum Ziel
- Varianten und gebeugte Formen
Mit dieser Reihenfolge wird ein schwaches Passwort in den ersten Millisekunden gefunden, unabhängig von der Hash-Geschwindigkeit.
5. Korpora echter Passwörter
5.1 Have I Been Pwned (HIBP)
- Größe: mehr als eine Milliarde verschiedene Passwörter aus über 14 Milliarden kompromittierten Konten
- Quelle: Sammlung öffentlicher Lecks seit 2013
- Format: SHA-1- (und NTLM-)Hashes mit der Anzahl, wie oft jedes Passwort gesehen wurde
- Zugang: API mit k-Anonymität; die vollständige Liste können Verteidiger herunterladen
HIBP ist die weltweite Referenz, weil es fast alle großen öffentlichen Lecks abdeckt, die Häufigkeit jedes Passworts angibt und aktiv gepflegt wird. Ein Angreifer mit der vollständigen Liste kann die häufigsten Passwörter zuerst testen.
5.2 RockYou (2009): das grundlegende Korpus
14,3 Millionen verschiedene Passwörter im Klartext. Der Anfang der Liste:
| Rang | Passwort | Konten | Anteil |
|---|---|---|---|
| 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 % |
Fazit: Eine Handvoll Kandidaten, gegen MD5 in wenigen Nanosekunden getestet, reicht aus, um einen messbaren Anteil der Konten einer geleakten Datenbank zu kompromittieren.
5.3 Spezialisierte Wortlisten-Sammlungen
- SecLists (Daniel Miessler): eine Open-Source-Sammlung von Listen für Sicherheitstests — geleakte Passwörter, Passwörter nach Sprache, Fachbegriffe, Namen.
- CrackStation: etwa 1,5 Milliarden Einträge, darunter alle Wörter der Wikipedia in mehreren Sprachen.
- Weakpass: sehr große Sammlungen echter geleakter Passwörter.
Diese Korpora sind öffentlich herunterladbar: Ihre Existenz ist eine feststehende Tatsache der offensiven Sicherheit.
6. Die HIBP-Prüfung (k-Anonymität)
6.1 Das k-Anonymitäts-Protokoll
Time2Crack prüft das Passwort bei HIBP, ohne es jemals zu senden, auch nicht seinen vollständigen Hash. Das Protokoll funktioniert so:
1. SHA-1(Passwort) berechnen
→ z. B. CBFDAC6008F9CAB4083784CBD1874F76618D2A97
2. Nur die ersten 5 Zeichen an die HIBP-API senden
→ GET https://api.pwnedpasswords.com/range/CBFDA
3. Die API liefert alle Hash-Suffixe, die mit diesem Präfix beginnen
(mehrere Hundert Zeilen, mit falschen Einträgen aufgefüllt)
4. Den Rest des Hashes lokal in der Antwort suchen
→ C6008F9CAB4083784CBD1874F76618D2A97
5. Gefunden: Das Passwort wurde geleakt, HIBP nennt die Anzahl
Nicht gefunden: Das Passwort ist nicht in HIBP
Datenschutzgarantie: Der HIBP-Server sieht nur ein 5-stelliges Präfix, das Hunderte Passwörter gemeinsam haben. Er kann nicht wissen, welches Passwort geprüft wurde. Der Vergleich findet im Browser statt.
6.2 Umsetzung in Time2Crack
Die Prüfung startet eine halbe Sekunde nach dem letzten Tastenanschlag, parallel zur lokalen 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
}
Das Ergebnis erscheint als Abzeichen: „N-mal gefunden“, „nicht gefunden“ oder „nicht verfügbar“, wenn die API nicht erreichbar ist. Es verändert die Knackzeiten nicht, die lokal berechnet werden.
6.3 Den HIBP-Zähler lesen
Der Zähler gibt an, wie oft genau dieses Passwort in den erfassten Lecks gesehen wurde:
| Zähler | Bedeutung |
|---|---|
| Mehr als 1.000.000 | Eines der meistgenutzten Passwörter der Welt: wird von jedem Angreifer zuerst probiert |
| 10.000 bis 1.000.000 | Sehr häufig |
| 1.000 bis 10.000 | Häufig |
| 100 bis 1.000 | Selten, aber bekannt |
| 1 bis 100 | Sehr selten, aber kompromittiert |
Schon ein Zähler von 1 ist eine Warnung: Das Passwort steht in den Listen, über die Angreifer verfügen, und wer das Konto angreift, aus dem es stammt, wird es ausprobieren.
7. Die Sprach-Wortlisten von Time2Crack
7.1 Warum Sprach-Wortlisten zusätzlich zu HIBP
HIBP deckt Passwörter ab, die bereits geleakt wurden, nicht aber gewöhnliche Wörter, die noch nicht geleakt sind. Wer Regenschirm als Passwort wählt, steht vielleicht nicht in HIBP, aber das Wort steht in der deutschen Wortliste jedes Angreifers, der deutschsprachige Nutzer ins Visier nimmt. Die Sprach-Wortlisten von Time2Crack schließen diese Lücke:
| Sprache | Datei | Wörter |
|---|---|---|
| Englisch | en.txt.gz | 748.958 |
| Französisch | fr.txt.gz | 550.235 |
| Spanisch | es.txt.gz | 284.834 |
| Portugiesisch | pt.txt.gz | 507.721 |
| Deutsch | de.txt.gz | 2.009.880 |
| Italienisch | it.txt.gz | 3.252.670 |
| Niederländisch | nl.txt.gz | 2.678.323 |
| Polnisch | pl.txt.gz | 3.670.705 |
| Türkisch | tr.txt.gz | 400.442 |
| Gesamt | 14.103.768 |
Die ersten Versionen stammten aus den Wikipedia-Wortlisten von SecLists und den Wortlisten von kkrypt0nn; sie wurden seitdem erweitert. Beim Laden wird jede Zeile von Leerzeichen befreit und in Kleinbuchstaben umgewandelt; Wörter mit weniger als 3 Zeichen werden verworfen.
7.2 Laden bei Bedarf
Die Wortlisten sind nicht im Code enthalten. Nur die Liste der gewählten Sprache wird heruntergeladen, beim ersten Bedarf, als gzip-Datei:
// 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);
}
Warum ein Set? Ein JavaScript-Set beantwortet dictWords.has(word) in konstanter Zeit, ob die Liste 285.000 Wörter (Spanisch) oder 3,7 Millionen (Polnisch) enthält. Mit einem Array könnte jede Suche einen Vergleich pro Wort erfordern.
7.3 Lokaler Cache (IndexedDB)
Die vorbereitete Liste wird in der IndexedDB des Browsers unter dem Schlüssel dict_<Sprache> gespeichert. Beim nächsten Besuch wird sie aus dem Cache gelesen, statt erneut heruntergeladen und entpackt zu werden:
Erster Besuch Weitere Besuche
------------- ---------------
fetch de.txt.gz cacheGet("dict_de")
└── gunzip (DecompressionStream) └── new Set(words)
└── trim / Kleinbuchst. / ≥ 3 └── bereit
└── new Set(words)
└── cachePut("dict_de")
└── bereit
Das Passwort verlässt nie den Browser: Die Liste wird vom Time2Crack-Server heruntergeladen, der Vergleich findet lokal statt.
8. Der Wörterbuchrang: rankDictionary()
8.1 Das Prinzip: erst ein Rang, dann eine Zeit
Time2Crack fragt nicht nur „Ist das ein Wörterbuchwort?“, sondern „Nach wie vielen Versuchen fände ein Wörterbuchangriff es?“. Diese Anzahl von Versuchen ist der Rang. Die Funktion rankDictionary() (Datei core/rank/dictionary.js) gibt ihn zurück, oder null, wenn der Angriff nicht greift:
// 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 Stufen
| Stufe | Regel | Beispiel | Rang |
|---|---|---|---|
| 1. Häufigste Passwörter | Position in einer Liste von 105 der häufigsten Passwörter (RockYou, HIBP) | password | 2 |
| 2. Leetspeak-Variante | Position der de-leetifizierten Form × 10 | p@ssw0rd | 20 |
| 3. Sprach-Wortliste | Die Hälfte der Listengröße | soleil (Französisch) | 275.117 |
| 4. Kompositum | Siehe 8.4 | apfelbaumkuchen (Deutsch) | 21.129 |
Warum die Hälfte der Liste? Die Wortlisten sind nicht nach Häufigkeit sortiert: Die Position eines Wortes in der Datei sagt nichts darüber aus, wann ein Angreifer es ausprobieren würde. Im Durchschnitt findet ein Angreifer, der die Liste durchgeht, ein bestimmtes Wort nach der Hälfte.
8.3 Großbuchstaben
Ein Angreifer beginnt mit kleingeschriebenen Wörtern und probiert dann Varianten mit Großbuchstaben. Der Rang wird mit der Anzahl der Varianten multipliziert, die nötig sind, um die Schreibweise des Passworts zu erreichen (Funktion uppercaseCost(), gleiche Methode wie zxcvbn):
| Schreibweise | Faktor | Beispiel | Rang |
|---|---|---|---|
| Alles klein | × 1 | soleil | 275.117 |
| Nur der erste Buchstabe groß | × 2 | Soleil | 550.234 |
| Nur der letzte Buchstabe groß | × 2 | soleiL | 550.234 |
| Alles groß | × 2 | PASSWORD | 4 |
| Jede andere Mischung | Summe von C(n, i) für i = 1 … min(Groß-, Kleinbuchstaben) | PaSsWoRd | 324 |
8.4 Zusammengesetzte Wörter
Das Deutsche (und das Niederländische) fügt Wörter zusammen: Apfelbaumkuchen = Apfel + Baum + Kuchen. Ein solches Wort fehlt oft in der Liste, doch ein Angreifer kann es aus kürzeren Wörtern zusammensetzen. Time2Crack versucht, das Passwort in 2 bis 4 Wörter der Liste zu zerlegen, und lässt dabei die üblichen deutschen Fugenelemente zu (-s-, -es-, -n-, -en-, -er-, -e-). Der Rang ist dann der Maskenrang des Passworts, multipliziert mit 0,25 (2 Wörter), 0,16 (3 Wörter) oder 0,10 (4 Wörter), und mit 0,75, wenn das letzte Teilstück ein häufiges Suffix ist (-heit, -ung, -haus …).
Die Zerlegung wird auch bei langen Wörtern versucht, die in der Liste stehen (ab 9 Zeichen), und beibehalten, wenn sie einen niedrigeren Rang ergibt: Sonnenblume erhält den Rang 42.680 statt der Hälfte der deutschen Liste (1.004.940).
9. De-Leetifizierung
9.1 Leetspeak schützt nicht
Leetspeak ersetzt Buchstaben durch ähnlich aussehende Ziffern oder Symbole: a → @, e → 3, i → 1, o → 0, s → $. Man verwendet es, um ein gängiges Wort zu „verstärken“: password → p@$$w0rd.
In Wirklichkeit gehören diese Ersetzungen zu den ersten Regeln, die Cracking-Tools anwenden. Einen kompetenten Angreifer halten sie nicht auf.
9.2 Die Funktion 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");
}
Das Passwort wird sowohl in der eingegebenen als auch in der de-leetifizierten Form gesucht. Bei den häufigsten Passwörtern kostet die de-leetifizierte Form das Zehnfache (der Angreifer muss die Varianten durchprobieren): p@ssw0rd → 20 statt 2. In der Sprach-Wortliste kostet sie so viel wie das einfache Wort.
9.3 Was nicht dekodiert wird
- Jedes Zeichen hat nur eine Ersetzung:
1wird immer zui, nie zul;p1ayerwird daher nicht alsplayererkannt. - Seltenere Ersetzungen (
+→ t,9→ g,#→ h) werden nicht dekodiert. - Ein Wort mit angehängten Ziffern oder Symbolen (
sommer2024,sonne!) ist kein Wörterbuchtreffer: Das übernimmt der Hybridangriff.
10. Vom Rang zur Knackzeit
Der Rang wird in Sekunden umgerechnet, indem man ihn durch die Hash-Geschwindigkeit des Angreifers teilt:
// 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);
}
Beispiel für soleil (französische Wortliste, Rang 275.117) mit dem voreingestellten Profil:
| Algorithmus | Geschwindigkeit (12× RTX 5090) | Rechnung | Zeit |
|---|---|---|---|
| NTLM | 4.081 GH/s | 275.117 / 4.081 × 109 | 67 Nanosekunden |
| MD5 | 2.634 GH/s | 275.117 / 2.634 × 109 | 104 Nanosekunden |
| SHA-1 | 837 GH/s | 275.117 / 837 × 109 | 329 Nanosekunden |
| SHA-256 | 332 GH/s | 275.117 / 332 × 109 | 829 Nanosekunden |
| bcrypt (Kosten 5) | 3.658 kH/s | 275.117 / 3.658.000 | 0,08 Sekunden |
| Argon2id | 1.000 H/s | 275.117 / 1.000 | 4 Minuten 35 Sekunden |
Selbst mit Argon2id fällt ein einfaches französisches Wort in weniger als 5 Minuten. Das Angreiferprofil ändert die Geschwindigkeiten: von einer einzigen GPU (Profil „Amateur“) bis zu etwa 10.000 GPUs (Profil „Staat“). Wie bei allen anderen Modellen kann der Wörterbuchrang nie höher sein als der Brute-Force-Rang desselben Passworts.
11. Vergleich mit abgeleiteten Angriffen
Der „reine“ Wörterbuchangriff ist der erste einer Familie von Angriffen, die alle von einer Wortliste ausgehen. Time2Crack berechnet neun Modelle (Brute Force, Wörterbuch, Hybrid, Maske, PCFG, Markov, Kombinator, Tastaturmuster, Daten), die das Passwort jeweils aus einem anderen Blickwinkel angreifen.
11.1 Wörterbuch und Hybrid
| Kriterium | Wörterbuch | Hybrid (Wörterbuch + Regeln) |
|---|---|---|
| Kandidaten | Die Wörter der Liste, unverändert | Jedes Wort mit seinen Abwandlungen (Ziffern, Symbole, Großbuchstaben …) |
| Geknackte Beispiele | password, soleil | P@ssw0rd!, sommer2024 |
| Geschwindigkeit | Weniger Kandidaten, also schneller | Viel breitere Abdeckung |
| Greift, wenn | Das genaue Wort in der Liste steht | Das Passwort von einem Wort der Liste abgeleitet ist |
Der Hybridangriff beginnt dort, wo das reine Wörterbuch aufhört: Er wendet systematische Abwandlungsregeln auf jedes Wort der Liste an (im Stil von best64.rule aus hashcat).
11.2 Wörterbuch und PCFG
| Kriterium | Wörterbuch | PCFG |
|---|---|---|
| Modell | Feste Liste von Kandidaten | Probabilistische Grammatik der Passwortstrukturen |
| Stärke | Genaue Wörter | Strukturen wie Wort + Ziffern, Groß + klein + Symbol |
| Beispiel | password ✓ | Password123 ✓ (Struktur erkannt) |
Password123 ist als solches kein Wörterbuchwort, aber PCFG erkennt die Struktur [Großbuchstabe][Kleinbuchstaben][Ziffern] und knackt es sehr schnell.
11.3 Wörterbuch und Markov
| Kriterium | Wörterbuch | Markov |
|---|---|---|
| Kandidaten | Vorab erstellte Liste | Von einem statistischen Modell laufend erzeugt |
| Abdeckung | Bekannter Wortschatz | Jede Zeichenfolge, die „menschlich aussieht“ |
| Vorteil | Sehr schnell bei genauen Wörtern | Deckt auch Wörter ab, die in keiner Liste stehen |
Markov deckt Passwörter ab, die wie menschliche Wörter aussehen, ohne in einer Liste zu stehen.
11.4 Wörterbuch und Credential Stuffing
| Kriterium | Wörterbuch | Credential Stuffing |
|---|---|---|
| Ziel | Einen Hash knacken | Sich bei einem Konto anmelden |
| Mechanismus | Lokale Hash-Berechnung | Anmeldeversuche aus der Ferne |
| Quelle | Allgemeine Wortliste | Geleakte E-Mail/Passwort-Paare |
| Abwehr | Langsamer Hash-Algorithmus | Ratenbegrenzung, MFA, IP-Sperren |
Credential Stuffing greift keinen Hash an: Es probiert geleakte E-Mail/Passwort-Paare direkt bei Online-Diensten aus. Das ist ein anderer Angriff, der aber dieselben Daten nutzt (Lecks wie die von HIBP erfassten). Time2Crack modelliert ihn nicht.
12. Grenzen des Wörterbuchangriffs
12.1 Grundsätzliche Grenzen
- Nur bekannter Wortschatz. Ein erfundenes Passwort, das keinem existierenden Wort ähnelt und nie geleakt wurde, entgeht dem reinen Wörterbuchangriff:
Xqz7mK9pLsteht in keiner Wortliste. - Sprachabdeckung. Ein Angreifer, der deutschsprachige Nutzer ohne deutsche Wortliste angreift, verpasst Wörter wie
RegenschirmoderFeierabend. - Neue Passwörter. Ein Passwort, das nie geleakt wurde, steht nicht in HIBP, auch wenn es häufig ist.
- Lange Passphrasen.
MeinGrossesAbenteuerUnterDenSternensteht in keiner Liste, auch wenn jedes Wort banal ist. Passphrasen übernehmen andere Angriffe (Kombinator, PRINCE).
12.2 Was Time2Crack nicht modelliert
- Gezielte Wortlisten: Ein Angreifer, der eine Branche ins Visier nimmt, baut eigene Listen (Fachbegriffe für ein Krankenhaus, Spielerjargon für eine Gaming-Plattform). Werkzeuge wie CeWL extrahieren Wörter von der Website des Ziels. Time2Crack verwendet allgemeine Listen.
- Neue Lecks: Zwischen einem Leck und seiner Aufnahme in HIBP kursieren die Passwörter privat, ohne über die öffentliche API sichtbar zu sein.
- Andere Hash-Algorithmen: Time2Crack modelliert sechs Algorithmen (MD5, SHA-1, SHA-256, NTLM, bcrypt, Argon2id). SHA-512, scrypt oder PBKDF2 haben andere Profile.
- Worthäufigkeit: Jedes Wort der Sprach-Wortliste erhält denselben Rang (die Hälfte der Liste), egal ob es sehr häufig oder sehr selten ist.
13. Wirksame Abwehrmaßnahmen
13.1 Was schützt
Ein langsamer Hash-Algorithmus (bcrypt, Argon2id). Das ist die wirksamste Abwehr auf Serverseite: Jeder Versuch kostet mehr. Für soleil (Rang 275.117):
- MD5: etwa 0,1 Mikrosekunden
- bcrypt Kosten 12 (128-mal langsamer als Kosten 5): etwa 10 Sekunden
- Argon2id: etwa 5 Minuten
Ein langsamer Hash bremst den Angreifer, rettet aber kein Wörterbuchwort: Die Liste ist einfach zu kurz.
Ein eigener Salt pro Konto. Er macht vorberechnete Tabellen (Rainbow Tables) nutzlos und zwingt den Angreifer, Konto für Konto vorzugehen. Einen Wortlistenangriff auf ein einzelnes Konto verhindert er nicht.
Länge und Zufall. Ein einzelnes Wörterbuchwort ist immer angreifbar. Eine Passphrase aus 4 oder 5 Wörtern widersteht dem reinen Wörterbuchangriff, nicht aber dem Kombinatorangriff, wenn die Wörter vorhersehbar sind: Sie müssen zufällig gezogen werden.
Zufällig erzeugte Passwörter. Die eigentliche Lösung: ein Passwortmanager, der lange Zufallspasswörter erzeugt (20 Zeichen oder mehr). Sie stehen in keinem Wörterbuch.
Mehr-Faktor-Authentifizierung (MFA). Sie verhindert nicht das Offline-Knacken gestohlener Hashes, aber sie hindert den Angreifer daran, sich mit einem geknackten Passwort anzumelden.
Ratenbegrenzung und Anomalieerkennung. Sie schützen vor Online-Versuchen, nicht vor dem Offline-Knacken gestohlener Hashes.
13.2 Was nicht schützt
- Leetspeak-Ersetzungen:
password→p@ssw0rd(siehe Abschnitt 9). - Eine Ziffer am Ende:
password→password1, eine der ersten getesteten Regeln. - Ein großer Anfangsbuchstabe:
password→Password, eine Standardregel (Rang × 2). - Ziffern und Symbole um ein erkennbares Wort:
sonne!wird schon mit den einfachsten Regeln gefunden. - Komplexität ohne Länge:
P@s1werfüllt die üblichen Regeln (Groß- und Kleinbuchstabe, Ziffer, Symbol), ist aber kürzer und vorhersehbarer alscorrecthorsebatterystaple.
13.3 Praktische Empfehlungen
- Verwenden Sie einen Passwortmanager (Bitwarden, 1Password, KeePass): Er erzeugt Zufallspasswörter, Sie merken sich nur das Hauptpasswort.
- Aktivieren Sie überall MFA: Selbst wenn ein Passwort geleakt wird, kann sich der Angreifer nicht anmelden.
- Prüfen Sie regelmäßig HIBP, um zu wissen, ob Ihre E-Mail-Adresse in bekannten Lecks vorkommt.
- Verwenden Sie nie ein Passwort zweimal: Credential Stuffing nutzt die Wiederverwendung über Dienste hinweg aus.
- Für Passwörter, die Sie sich merken müssen: eine Passphrase aus 5 oder mehr Wörtern, zufällig gezogen (mit Würfeln oder einem Generator), nicht ausgewählt.
14. Quellen
Wissenschaftliche Quellen
- Morris, R., & Thompson, K. (1979). Password security: A case history. Communications of the ACM, 22(11), 594–597. Erste wissenschaftliche Analyse von Unix-Passwörtern.
- Klein, D. V. (1990). Foiling the cracker: A survey of, and improvements to, password security. Proceedings of the 2nd USENIX Security Workshop. Etwa ein Viertel von 15.000 Unix-Passwörtern mit Wortlisten und Regeln geknackt.
- Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009). Password cracking using probabilistic context-free grammars. IEEE Symposium on Security and Privacy. Der grundlegende Artikel zu PCFG, verglichen mit Wörterbuchangriffen.
- 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. Misst die tatsächliche Verteilung von Passwörtern.
- Ma, J., Yang, W., Luo, M., & Li, N. (2014). A study of probabilistic password models. IEEE Symposium on Security and Privacy. Vergleicht Wörterbuch-, Markov- und PCFG-Modelle an echten Korpora.
- Wheeler, D. L. (2016). zxcvbn: Low-budget password strength estimation. 25th USENIX Security Symposium, 157–173. Quelle der in Abschnitt 8.3 verwendeten Kosten für Großbuchstaben.
- 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.
Quellen aus der Praxis
- Have I Been Pwned. Pwned Passwords. https://haveibeenpwned.com/Passwords. Die von Time2Crack genutzte API mit k-Anonymität.
- Hive Systems (2025). Password table. Ausgabe 2025 auf Basis von 12× RTX 5090. Time2Crack verwendet gemessene hashcat-Benchmarks der RTX 5090 (Specops 2026, hashcat.net-Forum); Argon2id bleibt eine Schätzung.
- Hashcat. Advanced password recovery. https://hashcat.net. Referenzwerkzeug für GPU-Messungen und Abwandlungsregeln (
best64.rule). - Miessler, D. SecLists. GitHub. Quelle der ersten Sprach-Wortlisten von Time2Crack.
Hintergrund
- 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. Zeigt, dass k-Anonymität die Privatsphäre schützt.
Quellcode: core/rank/dictionary.js (rankDictionary, deleet), core/rank/uppercase.js (uppercaseCost), core/time.js (rankToSeconds), app.js (loadDictionary, checkHIBP).