L'attaque par dictionnaire — Fonctionnement détaillé
Document de référence du projet Time2Crack
Public : développeurs, chercheurs en sécurité, utilisateurs avancés
Table des matières
- Vue d'ensemble
- Contexte historique et académique
- Pourquoi les dictionnaires fonctionnent
- Architecture d'une attaque par dictionnaire moderne
- Les corpus de mots de passe réels
- La vérification HIBP (k-anonymat)
- Les listes de mots linguistiques de Time2Crack
- Le rang dictionnaire :
rankDictionary() - La dé-leetification
- Du rang au temps de cassage
- Comparaison avec les attaques dérivées
- Limites de l'attaque par dictionnaire
- Défenses efficaces
- Références
1. Vue d'ensemble
L'attaque par dictionnaire est la plus ancienne méthode de cassage de mots de passe, la plus simple à comprendre, et statistiquement la plus efficace contre les vrais mots de passe humains. Au lieu d'énumérer toutes les combinaisons possibles comme la force brute, elle teste une liste de candidats préparée à l'avance — le « dictionnaire » — par ordre de probabilité décroissante.
Pourquoi elle fonctionne si bien. Les gens ne choisissent pas leur mot de passe au hasard. Des décennies de fuites de données montrent que les vrais mots de passe sont extrêmement concentrés : dans la fuite RockYou, 123456 était utilisé à lui seul par 290 731 comptes, environ 2 % du total. Une attaque par dictionnaire bien construite teste ces candidats en premier et les trouve en une fraction de seconde, là où la force brute demanderait des années.
Time2Crack utilise deux mécanismes indépendants :
- Le rang dictionnaire, calculé localement : le mot de passe fait-il partie des mots de passe les plus courants, éventuellement déguisé en leetspeak, ou est-ce un mot du dictionnaire de la langue choisie ? Ce rang donne les temps de cassage affichés dans le tableau des résultats.
- La vérification Have I Been Pwned (HIBP) : ce mot de passe exact est-il déjà apparu dans une fuite de données ? La réponse s'affiche dans un badge séparé, au-dessus des résultats.
Les deux sont complémentaires : HIBP connaît les mots de passe déjà fuités, les listes de mots couvrent les mots ordinaires qui n'ont pas encore fuité.
2. Contexte historique et académique
2.1 Origines
L'attaque par dictionnaire est antérieure à la sécurité informatique moderne. Les premiers systèmes Unix stockaient les empreintes des mots de passe dans le fichier /etc/passwd, lisible par tous : quiconque pouvait le lire pouvait tester une liste de mots contre tous les comptes.
| Année | Événement |
|---|---|
| 1979 | Morris et Thompson publient le premier article académique sur la sécurité des mots de passe Unix ; une grande partie des mots de passe étudiés étaient des mots ou des noms courants. |
| 1988 | Le ver Morris se propage en partie en devinant des mots de passe avec une liste intégrée de 432 mots, puis le dictionnaire du système /usr/share/dict/words. |
| 1991 | Crack (Alec Muffett) : le premier casseur de mots de passe Unix largement utilisé, avec des règles de transformation des mots. |
| 1996 | John the Ripper popularise le mode « liste de mots + règles ». |
| 2009 | Fuite RockYou : 32 millions de comptes stockés en clair (14,3 millions de mots de passe distincts) révèlent comment les gens choisissent réellement leurs mots de passe. |
| 2013 | Troy Hunt lance Have I Been Pwned. La même année, la fuite d'Adobe expose 153 millions de comptes dont les mots de passe étaient chiffrés sans sel, ce qui permettait de repérer les mots de passe identiques. |
| 2015 | Hashcat devient open source ; les attaques par dictionnaire sur GPU deviennent accessibles à tous. |
| 2019 | « Collection #1–5 » : des milliards de paires e-mail/mot de passe compilées à partir de fuites antérieures circulent publiquement. |
2.2 Les fuites fondatrices
Certaines fuites ont transformé l'attaque par dictionnaire en révélant la distribution réelle des mots de passe humains :
- RockYou (2009) : 14,3 millions de mots de passe distincts stockés en clair. Le mot de passe n° 1 (
123456) était utilisé par 290 731 comptes, environ 2 % du total. - LinkedIn (2012) : 6,5 millions d'empreintes SHA-1 sans sel publiées au départ ; on a appris plus tard que la fuite concernait environ 117 millions de comptes.
- Adobe (2013) : 153 millions de comptes ; les indices de mot de passe stockés en clair ont permis de deviner les mots de passe les plus courants.
- Have I Been Pwned (de 2013 à aujourd'hui) : une agrégation continue des fuites publiques, devenue une référence mondiale.
2.3 À quelle vitesse va une attaque par dictionnaire ?
Une liste de 1 million de mots, testée aux vitesses utilisées par Time2Crack (12× RTX 5090, le profil « Standard » par défaut) :
| Algorithme | Vitesse | Temps pour 1 million de candidats |
|---|---|---|
| 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 microsecondes |
| bcrypt (coût 5) | 3 658 kH/s | 0,27 seconde |
| Argon2id | 1 000 H/s | environ 17 minutes |
L'attaque par dictionnaire est donc instantanée contre les fonctions de hachage rapides (MD5, SHA-1, NTLM) et reste rapide même contre bcrypt.
3. Pourquoi les dictionnaires fonctionnent
3.1 La loi de puissance des mots de passe humains
Les études empiriques arrivent toutes à la même conclusion : les mots de passe humains ne sont pas répartis uniformément. Ils suivent une loi de puissance (loi de Zipf) : quelques mots de passe concentrent une part disproportionnée des choix.
Formellement : si l'on trie les mots de passe par fréquence décroissante, la fréquence du mot de passe de rang r est à peu près proportionnelle à r−s, où l'exposant s dépend du corpus (Wang et al., 2017).
Conséquence directe : un attaquant qui n'essaie que les 10 mots de passe les plus courants a déjà environ une chance sur 20 de réussir contre un compte donné.
3.2 Les biais cognitifs dans la création des mots de passe
Les gens appliquent des habitudes prévisibles quand ils créent un mot de passe :
- Mémorisation : les mots faciles à retenir (noms communs, prénoms, culture populaire) sont surreprésentés.
- Disponibilité : le mot de passe reflète l'environnement immédiat (nom de l'animal, équipe de sport, personnage préféré).
- Substitutions prévisibles : e → 3, a → @, o → 0. L'utilisateur croit son mot de passe plus solide, mais ce sont les premières substitutions qu'essaie un attaquant.
- Ajout en fin de mot : un chiffre ou un symbole ajouté à la fin d'un mot (
password1,soleil!). - Langue et culture : les mots de passe courants dépendent de la langue de l'utilisateur (
Soleil123en France,Sommer123en Allemagne).
3.3 Deux façons d'être « dans les listes »
Un mot de passe peut figurer dans une liste d'attaque pour deux raisons différentes :
- Il a déjà fuité. Le mot de passe exact est apparu dans une fuite passée. L'attaquant n'a pas besoin de deviner : il essaie les mots de passe connus par ordre de fréquence.
- C'est un mot ordinaire. Même s'il n'a jamais fuité, il figure dans toutes les listes d'attaque parce que c'est un candidat évident. Un mot comme
grenouillepeut être absent de HIBP, mais il est dans la liste française de tout outil de cassage sérieux.
Ces deux cas correspondent aux deux mécanismes de Time2Crack décrits plus bas.
4. Architecture d'une attaque par dictionnaire moderne
4.1 Le déroulement général
Une attaque par dictionnaire moderne se déroule en quatre phases :
Phase 1 : constituer la liste de mots
├── Mots de passe fuités (HIBP, RockYou, compilations)
├── Listes linguistiques (dictionnaires, prénoms, lieux)
├── Listes thématiques (sport, culture populaire, technologie, religion)
└── Listes ciblées (domaine de l'entreprise, noms des employés)
Phase 2 : préparer la liste
├── Trier par fréquence (les plus probables d'abord)
├── Supprimer les doublons
├── Filtrer par longueur (longueur visée ± 2)
└── Normaliser (minuscules, Unicode NFC)
Phase 3 : hacher et comparer
pour chaque candidat w de la liste :
si hash(w) == empreinte_cible : trouvé
(des milliards de candidats par seconde sur GPU pour MD5)
Phase 4 : bilan
└── Mots de passe cassés, statistiques de couverture
4.2 Optimisations matérielles
Les attaques par dictionnaire modernes s'exécutent massivement en parallèle sur des GPU :
- Hashcat (l'outil de référence) utilise des milliers de cœurs GPU pour calculer des milliards d'empreintes par seconde.
- Traitement par lots : les candidats sont envoyés au GPU par lots de plusieurs millions pour l'occuper en permanence.
- Règles sur le GPU : les règles de transformation sont appliquées directement sur le GPU ; une courte liste de mots produit ainsi des milliards de candidats sans avoir à les stocker.
Pour une liste de 1 milliard de mots de passe fuités, sur 12× RTX 5090 :
- MD5 : 109 / 2 634 × 109 ≈ 0,4 milliseconde
- bcrypt (coût 5) : 109 / 3 658 000 ≈ 5 minutes
Cet écart d'environ six ordres de grandeur entre MD5 et bcrypt montre à quel point le choix de l'algorithme de hachage compte.
4.3 L'ordre des candidats
La liste n'est pas testée par ordre alphabétique, mais par probabilité décroissante :
- Les mots de passe fuités les plus courants (top 100 de RockYou)
- Les mots de passe présents dans de nombreuses fuites (triés par fréquence HIBP)
- Les mots courants de la langue visée
- Les noms propres (prénoms, villes, célébrités)
- Les termes liés à la cible
- Les variantes et les formes fléchies
Avec cet ordre, un mot de passe faible est trouvé dans les premières millisecondes, quelle que soit la vitesse de hachage.
5. Les corpus de mots de passe réels
5.1 Have I Been Pwned (HIBP)
- Taille : plus d'un milliard de mots de passe distincts, issus de plus de 14 milliards de comptes compromis
- Source : agrégation des fuites publiques depuis 2013
- Format : empreintes SHA-1 (et NTLM) avec le nombre de fois où chaque mot de passe a été vu
- Accès : API à k-anonymat ; la liste complète peut être téléchargée par les défenseurs
HIBP est la référence mondiale parce qu'il couvre presque toutes les grandes fuites publiques, qu'il indique la fréquence de chaque mot de passe et qu'il est activement maintenu. Un attaquant qui dispose de la liste complète peut tester les mots de passe les plus fréquents en premier.
5.2 RockYou (2009) : le corpus fondateur
14,3 millions de mots de passe distincts stockés en clair. Le haut de la liste :
| Rang | Mot de passe | Comptes | Part |
|---|---|---|---|
| 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 % |
À retenir : une poignée de candidats, testés en quelques nanosecondes contre MD5, suffit à compromettre une part mesurable des comptes d'une base de données fuitée.
5.3 Les collections de listes spécialisées
- SecLists (Daniel Miessler) : une collection open source de listes pour les tests de sécurité — mots de passe fuités, mots de passe classés par langue, termes techniques, noms.
- CrackStation : environ 1,5 milliard d'entrées, dont tous les mots de Wikipédia dans plusieurs langues.
- Weakpass : de très grandes compilations de vrais mots de passe fuités.
Ces corpus sont téléchargeables publiquement : leur existence est un fait établi de la sécurité offensive.
6. La vérification HIBP (k-anonymat)
6.1 Le protocole de k-anonymat
Time2Crack vérifie le mot de passe auprès de HIBP sans jamais l'envoyer, ni lui ni son empreinte complète. Le protocole fonctionne ainsi :
1. Calculer SHA-1(mot de passe)
→ par ex. CBFDAC6008F9CAB4083784CBD1874F76618D2A97
2. Envoyer seulement les 5 premiers caractères à l'API HIBP
→ GET https://api.pwnedpasswords.com/range/CBFDA
3. L'API renvoie tous les suffixes d'empreinte qui commencent par ce préfixe
(plusieurs centaines de lignes, complétées par de fausses entrées)
4. Chercher le reste de l'empreinte dans la réponse, localement
→ C6008F9CAB4083784CBD1874F76618D2A97
5. Trouvé : le mot de passe a fuité, et HIBP indique combien de fois
Absent : le mot de passe n'est pas dans HIBP
Garantie de confidentialité : le serveur HIBP ne voit qu'un préfixe de 5 caractères partagé par des centaines de mots de passe. Il ne peut pas savoir quel mot de passe a été vérifié. La comparaison se fait dans le navigateur.
6.2 L'implémentation dans Time2Crack
La vérification démarre une demi-seconde après la dernière frappe, en parallèle de l'analyse locale :
// 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
}
Le résultat s'affiche dans un badge : « trouvé N fois », « absent », ou « indisponible » quand l'API ne répond pas. Il ne modifie pas les temps de cassage, qui sont calculés localement.
6.3 Lire le compteur HIBP
Le compteur est le nombre de fois où ce mot de passe exact a été vu dans les fuites indexées :
| Compteur | Signification |
|---|---|
| Plus de 1 000 000 | Parmi les mots de passe les plus utilisés au monde : essayé en premier par tous les attaquants |
| 10 000 à 1 000 000 | Très courant |
| 1 000 à 10 000 | Courant |
| 100 à 1 000 | Peu courant mais connu |
| 1 à 100 | Rare, mais compromis |
Même un compteur de 1 est un avertissement : le mot de passe figure dans les listes dont disposent les attaquants, et quiconque cible le compte d'où il a fuité l'essaiera.
7. Les listes de mots linguistiques de Time2Crack
7.1 Pourquoi des listes linguistiques en plus de HIBP
HIBP couvre les mots de passe qui ont déjà fuité, pas les mots ordinaires qui n'ont pas encore fuité. Un francophone qui choisit éphémère n'est peut-être pas dans HIBP, mais le mot figure dans la liste française de tout attaquant qui vise des utilisateurs francophones. Les listes linguistiques de Time2Crack comblent ce manque :
| Langue | Fichier | Mots |
|---|---|---|
| Anglais | en.txt.gz | 748 958 |
| Français | fr.txt.gz | 550 235 |
| Espagnol | es.txt.gz | 284 834 |
| Portugais | pt.txt.gz | 507 721 |
| Allemand | de.txt.gz | 2 009 880 |
| Italien | it.txt.gz | 3 252 670 |
| Néerlandais | nl.txt.gz | 2 678 323 |
| Polonais | pl.txt.gz | 3 670 705 |
| Turc | tr.txt.gz | 400 442 |
| Total | 14 103 768 |
Les premières versions venaient des listes de mots Wikipédia de SecLists et des listes de kkrypt0nn ; elles ont été enrichies depuis. Au chargement, chaque ligne est nettoyée de ses espaces et mise en minuscules, et les mots de moins de 3 caractères sont écartés.
7.2 Le chargement à la demande
Les listes ne sont pas incluses dans le code. Seule la liste de la langue choisie est téléchargée, la première fois qu'elle est nécessaire, sous forme de fichier gzip :
// 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);
}
Pourquoi un Set ? Un Set JavaScript répond à dictWords.has(word) en temps constant, que la liste contienne 285 000 mots (espagnol) ou 3,7 millions (polonais). Avec un Array, chaque recherche pourrait demander une comparaison par mot.
7.3 Le cache local (IndexedDB)
La liste préparée est enregistrée dans l'IndexedDB du navigateur, sous la clé dict_<langue>. À la visite suivante, elle est lue dans le cache au lieu d'être téléchargée et décompressée à nouveau :
Première visite Visites suivantes
--------------- -----------------
fetch fr.txt.gz cacheGet("dict_fr")
└── gunzip (DecompressionStream) └── new Set(words)
└── trim / minuscules / ≥ 3 └── prêt
└── new Set(words)
└── cachePut("dict_fr")
└── prêt
Le mot de passe ne quitte jamais le navigateur : la liste est téléchargée depuis le serveur de Time2Crack et la comparaison se fait localement.
8. Le rang dictionnaire : rankDictionary()
8.1 Le principe : un rang, puis un temps
Time2Crack ne se demande pas seulement « est-ce un mot du dictionnaire ? », mais « au bout de combien d'essais une attaque par dictionnaire le trouverait-elle ? ». Ce nombre d'essais est le rang. La fonction rankDictionary() (fichier core/rank/dictionary.js) le renvoie, ou renvoie null quand l'attaque ne s'applique pas :
// 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 Quatre niveaux
| Niveau | Règle | Exemple | Rang |
|---|---|---|---|
| 1. Mots de passe les plus courants | Position dans une liste de 105 des mots de passe les plus courants (RockYou, HIBP) | password | 2 |
| 2. Variante en leetspeak | Position de la forme dé-leetifiée × 10 | p@ssw0rd | 20 |
| 3. Liste linguistique | La moitié de la taille de la liste | soleil (français) | 275 117 |
| 4. Mot composé | Voir 8.4 | apfelbaumkuchen (allemand) | 21 129 |
Pourquoi la moitié de la liste ? Les listes ne sont pas triées par fréquence : la position d'un mot dans le fichier ne dit rien du moment où un attaquant l'essaierait. En moyenne, un attaquant qui parcourt la liste trouve un mot donné à mi-chemin.
8.3 Les majuscules
Un attaquant commence par les mots en minuscules, puis essaie les variantes avec majuscules. Le rang est multiplié par le nombre de variantes nécessaires pour atteindre la casse du mot de passe (fonction uppercaseCost(), même méthode que zxcvbn) :
| Casse | Multiplicateur | Exemple | Rang |
|---|---|---|---|
| Tout en minuscules | × 1 | soleil | 275 117 |
| Première lettre seulement | × 2 | Soleil | 550 234 |
| Dernière lettre seulement | × 2 | soleiL | 550 234 |
| Tout en majuscules | × 2 | PASSWORD | 4 |
| Tout autre mélange | somme des C(n, i) pour i = 1 … min(majuscules, minuscules) | PaSsWoRd | 324 |
8.4 Les mots composés
L'allemand (et le néerlandais) soude les mots entre eux : Apfelbaumkuchen = Apfel + Baum + Kuchen. Un tel mot est souvent absent de la liste, mais un attaquant peut le construire en combinant des mots plus courts. Time2Crack essaie de découper le mot de passe en 2 à 4 mots de la liste, en admettant les lettres de liaison habituelles de l'allemand (-s-, -es-, -n-, -en-, -er-, -e-). Le rang est alors le rang par masque du mot de passe multiplié par 0,25 (2 mots), 0,16 (3 mots) ou 0,10 (4 mots), et par 0,75 quand le dernier morceau est un suffixe courant (-heit, -ung, -haus…).
Le découpage est aussi essayé sur les mots longs présents dans la liste (9 caractères ou plus), et retenu s'il donne un rang plus bas : Sonnenblume obtient un rang de 42 680 au lieu de la moitié de la liste allemande (1 004 940).
9. La dé-leetification
9.1 Le leetspeak ne protège pas
Le leetspeak remplace des lettres par des chiffres ou des symboles qui leur ressemblent : a → @, e → 3, i → 1, o → 0, s → $. On l'utilise pour « renforcer » un mot courant : password → p@$$w0rd.
En réalité, ces substitutions font partie des premières règles appliquées par les outils de cassage. Elles ne ralentissent pas un attaquant compétent.
9.2 La fonction 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");
}
Le mot de passe est cherché tel qu'il a été saisi et sous sa forme dé-leetifiée. Dans les mots de passe les plus courants, la forme dé-leetifiée coûte 10 fois plus (l'attaquant doit essayer les variantes) : p@ssw0rd → 20 au lieu de 2. Dans la liste linguistique, elle coûte autant que le mot simple.
9.3 Ce qui n'est pas décodé
- Chaque caractère n'a qu'un seul remplacement :
1devient toujoursi, jamaisl;p1ayern'est donc pas reconnu commeplayer. - Les substitutions plus rares (
+→ t,9→ g,#→ h) ne sont pas décodées. - Un mot suivi de chiffres ou de symboles (
soleil2024,soleil!) n'est pas une correspondance du dictionnaire : il relève de l'attaque hybride.
10. Du rang au temps de cassage
Le rang est converti en secondes en le divisant par la vitesse de hachage de l'attaquant :
// 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);
}
Exemple pour soleil (liste française, rang 275 117), avec le profil par défaut :
| Algorithme | Vitesse (12× RTX 5090) | Calcul | Temps |
|---|---|---|---|
| NTLM | 4 081 GH/s | 275 117 / 4 081 × 109 | 67 nanosecondes |
| MD5 | 2 634 GH/s | 275 117 / 2 634 × 109 | 104 nanosecondes |
| SHA-1 | 837 GH/s | 275 117 / 837 × 109 | 329 nanosecondes |
| SHA-256 | 332 GH/s | 275 117 / 332 × 109 | 829 nanosecondes |
| bcrypt (coût 5) | 3 658 kH/s | 275 117 / 3 658 000 | 0,08 seconde |
| Argon2id | 1 000 H/s | 275 117 / 1 000 | 4 minutes 35 secondes |
Même avec Argon2id, un simple mot français tombe en moins de 5 minutes. Le profil d'attaquant change les vitesses : d'un seul GPU (profil « Amateur ») à environ 10 000 GPU (profil « État »). Comme pour tous les autres modèles, le rang dictionnaire ne peut jamais dépasser le rang de la force brute pour le même mot de passe.
11. Comparaison avec les attaques dérivées
L'attaque par dictionnaire « pure » est la première d'une famille d'attaques qui partent toutes d'une liste de mots. Time2Crack calcule neuf modèles (force brute, dictionnaire, hybride, masque, PCFG, Markov, combinatoire, motifs de clavier, dates), chacun attaquant le mot de passe sous un angle différent.
11.1 Dictionnaire et hybride
| Critère | Dictionnaire | Hybride (dictionnaire + règles) |
|---|---|---|
| Candidats | Les mots de la liste, tels quels | Chaque mot avec ses transformations (chiffres, symboles, majuscules…) |
| Exemples cassés | password, soleil | P@ssw0rd!, soleil2024 |
| Vitesse | Moins de candidats, donc plus rapide | Couverture beaucoup plus large |
| S'applique quand | Le mot exact est dans la liste | Le mot de passe dérive d'un mot de la liste |
L'attaque hybride commence là où s'arrête le dictionnaire pur : elle applique des règles de transformation systématiques à chaque mot de la liste (dans l'esprit de best64.rule de hashcat).
11.2 Dictionnaire et PCFG
| Critère | Dictionnaire | PCFG |
|---|---|---|
| Modèle | Liste fixe de candidats | Grammaire probabiliste des structures de mots de passe |
| Point fort | Les mots exacts | Les structures comme mot + chiffres, majuscule + minuscules + symbole |
| Exemple | password ✓ | Password123 ✓ (structure reconnue) |
Password123 n'est pas un mot du dictionnaire en tant que tel, mais PCFG reconnaît sa structure [majuscule][minuscules][chiffres] et le casse très vite.
11.3 Dictionnaire et Markov
| Critère | Dictionnaire | Markov |
|---|---|---|
| Candidats | Liste préparée à l'avance | Générés à la volée par un modèle statistique |
| Couverture | Vocabulaire connu | Toute séquence qui « ressemble à de l'humain » |
| Avantage | Très rapide sur les mots exacts | Couvre aussi les mots absents des listes |
Markov couvre les mots de passe qui ressemblent à des mots humains sans figurer dans aucune liste.
11.4 Dictionnaire et bourrage d'identifiants
| Critère | Dictionnaire | Bourrage d'identifiants (credential stuffing) |
|---|---|---|
| But | Casser une empreinte | Se connecter à un compte |
| Mécanisme | Calcul d'empreintes en local | Tentatives de connexion à distance |
| Source | Liste de mots générique | Paires e-mail/mot de passe fuitées |
| Défense | Algorithme de hachage lent | Limitation du débit, MFA, blocage d'IP |
Le bourrage d'identifiants n'attaque pas une empreinte : il essaie directement des paires e-mail/mot de passe fuitées sur des services en ligne. C'est une autre attaque, mais elle utilise les mêmes données (des fuites comme celles indexées par HIBP). Time2Crack ne la modélise pas.
12. Limites de l'attaque par dictionnaire
12.1 Limites intrinsèques
- Vocabulaire connu uniquement. Un mot de passe inventé, qui ne ressemble à aucun mot existant et n'a jamais fuité, échappe à l'attaque par dictionnaire pure :
Xqz7mK9pLne figure dans aucune liste. - Couverture linguistique. Un attaquant qui vise des francophones sans liste française manquera des mots comme
grenouilleoubricolage. - Mots de passe nouveaux. Un mot de passe qui n'a jamais fuité n'est pas dans HIBP, même s'il est courant.
- Longues phrases de passe.
MaGrandeAventureSousLesEtoilesne figure dans aucune liste, même si chaque mot est banal. Les phrases de passe relèvent d'autres attaques (combinatoire, PRINCE).
12.2 Ce que Time2Crack ne modélise pas
- Les listes ciblées : un attaquant qui vise un secteur construit des listes spécifiques (termes médicaux pour un hôpital, argot de joueurs pour une plateforme de jeu). Des outils comme CeWL extraient les mots du site web de la cible. Time2Crack utilise des listes génériques.
- Les fuites récentes : entre une fuite et son ajout à HIBP, les mots de passe circulent en privé sans être visibles par l'API publique.
- Les autres algorithmes de hachage : Time2Crack modélise six algorithmes (MD5, SHA-1, SHA-256, NTLM, bcrypt, Argon2id). SHA-512, scrypt ou PBKDF2 ont des profils différents.
- La fréquence des mots : chaque mot de la liste linguistique reçoit le même rang (la moitié de la liste), qu'il soit très courant ou très rare.
13. Défenses efficaces
13.1 Ce qui protège
Un algorithme de hachage lent (bcrypt, Argon2id). C'est la défense la plus efficace côté serveur : chaque essai coûte plus cher. Pour soleil (rang 275 117) :
- MD5 : environ 0,1 microseconde
- bcrypt coût 12 (128 fois plus lent que le coût 5) : environ 10 secondes
- Argon2id : environ 5 minutes
Un hachage lent freine l'attaquant, mais il ne sauve pas un mot du dictionnaire : la liste est tout simplement trop courte.
Un sel unique par compte. Il rend inutiles les tables précalculées (rainbow tables) et oblige l'attaquant à travailler compte par compte. Il n'empêche pas une attaque par liste de mots sur un seul compte.
La longueur et le hasard. Un mot du dictionnaire seul est toujours vulnérable. Une phrase de passe de 4 ou 5 mots résiste à l'attaque par dictionnaire pure, mais pas à l'attaque combinatoire si les mots sont prévisibles : ils doivent être tirés au sort.
Les mots de passe générés aléatoirement. La vraie solution : un gestionnaire de mots de passe qui génère de longs mots de passe aléatoires (20 caractères ou plus). Ils ne figurent dans aucun dictionnaire.
L'authentification multifacteur (MFA). Elle n'empêche pas le cassage hors ligne d'empreintes volées, mais elle empêche l'attaquant de se connecter avec un mot de passe cassé.
La limitation du débit et la détection d'anomalies. Elles protègent contre les tentatives en ligne, pas contre le cassage hors ligne d'empreintes volées.
13.2 Ce qui ne protège pas
- Les substitutions en leetspeak :
password→p@ssw0rd(voir la section 9). - Un chiffre à la fin :
password→password1, parmi les premières règles testées. - Une majuscule initiale :
password→Password, une règle standard (rang × 2). - Des chiffres et des symboles autour d'un mot reconnaissable :
soleil!est trouvé avec les règles les plus simples. - La complexité sans la longueur :
P@s1wrespecte les règles habituelles (majuscule, minuscule, chiffre, symbole) mais il est plus court et plus prévisible quecorrecthorsebatterystaple.
13.3 Recommandations pratiques
- Utilisez un gestionnaire de mots de passe (Bitwarden, 1Password, KeePass) : il génère des mots de passe aléatoires, vous ne retenez que le mot de passe principal.
- Activez la MFA partout : même si un mot de passe fuit, l'attaquant ne peut pas se connecter.
- Consultez HIBP régulièrement pour savoir si votre adresse e-mail figure dans des fuites connues.
- Ne réutilisez jamais un mot de passe : le bourrage d'identifiants exploite la réutilisation d'un service à l'autre.
- Pour les mots de passe à retenir : une phrase de passe de 5 mots ou plus, tirés au sort (avec des dés ou un générateur), pas choisis.
14. Références
Sources académiques
- Morris, R., & Thompson, K. (1979). Password security: A case history. Communications of the ACM, 22(11), 594–597. Première analyse académique des mots de passe Unix.
- Klein, D. V. (1990). Foiling the cracker: A survey of, and improvements to, password security. Proceedings of the 2nd USENIX Security Workshop. Environ un quart de 15 000 mots de passe Unix cassés avec des listes de mots et des règles.
- Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009). Password cracking using probabilistic context-free grammars. IEEE Symposium on Security and Privacy. L'article fondateur de PCFG, comparé aux attaques par dictionnaire.
- 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. Mesure la distribution réelle des mots de passe.
- Ma, J., Yang, W., Luo, M., & Li, N. (2014). A study of probabilistic password models. IEEE Symposium on Security and Privacy. Compare les modèles dictionnaire, Markov et PCFG sur des corpus réels.
- Wheeler, D. L. (2016). zxcvbn: Low-budget password strength estimation. 25th USENIX Security Symposium, 157–173. Source du coût des majuscules utilisé à la section 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.
Sources industrielles
- Have I Been Pwned. Pwned Passwords. https://haveibeenpwned.com/Passwords. L'API à k-anonymat utilisée par Time2Crack.
- Hive Systems (2025). Password table. Édition 2025 basée sur 12× RTX 5090. Time2Crack utilise des benchmarks hashcat mesurés sur RTX 5090 (Specops 2026, forum hashcat.net) ; Argon2id reste une estimation.
- Hashcat. Advanced password recovery. https://hashcat.net. Outil de référence pour les mesures sur GPU et les règles de transformation (
best64.rule). - Miessler, D. SecLists. GitHub. Source des premières listes linguistiques de Time2Crack.
Contexte
- 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. Montre que le k-anonymat protège la vie privée.
Code source : core/rank/dictionary.js (rankDictionary, deleet), core/rank/uppercase.js (uppercaseCost), core/time.js (rankToSeconds), app.js (loadDictionary, checkHIBP).