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

  1. Vue d'ensemble
  2. Contexte historique et académique
  3. Pourquoi les dictionnaires fonctionnent
  4. Architecture d'une attaque par dictionnaire moderne
  5. Les corpus de mots de passe réels
  6. La vérification HIBP (k-anonymat)
  7. Les listes de mots linguistiques de Time2Crack
  8. Le rang dictionnaire : rankDictionary()
  9. La dé-leetification
  10. Du rang au temps de cassage
  11. Comparaison avec les attaques dérivées
  12. Limites de l'attaque par dictionnaire
  13. Défenses efficaces
  14. 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 :

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
1979Morris 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.
1988Le 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.
1991Crack (Alec Muffett) : le premier casseur de mots de passe Unix largement utilisé, avec des règles de transformation des mots.
1996John the Ripper popularise le mode « liste de mots + règles ».
2009Fuite 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.
2013Troy 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.
2015Hashcat 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 :

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

AlgorithmeVitesseTemps pour 1 million de candidats
NTLM4 081 GH/s0,25 microseconde
MD52 634 GH/s0,38 microseconde
SHA-1837 GH/s1,2 microseconde
SHA-256332 GH/s3,0 microsecondes
bcrypt (coût 5)3 658 kH/s0,27 seconde
Argon2id1 000 H/senviron 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 :

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 :

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 :

Pour une liste de 1 milliard de mots de passe fuités, sur 12× RTX 5090 :

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 :

  1. Les mots de passe fuités les plus courants (top 100 de RockYou)
  2. Les mots de passe présents dans de nombreuses fuites (triés par fréquence HIBP)
  3. Les mots courants de la langue visée
  4. Les noms propres (prénoms, villes, célébrités)
  5. Les termes liés à la cible
  6. 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)

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 :

RangMot de passeComptesPart
1123456290 7312,03 %
21234579 0780,55 %
312345678976 7900,54 %
4password59 4620,42 %
5iloveyou49 9520,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

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 :

CompteurSignification
Plus de 1 000 000Parmi les mots de passe les plus utilisés au monde : essayé en premier par tous les attaquants
10 000 à 1 000 000Très courant
1 000 à 10 000Courant
100 à 1 000Peu courant mais connu
1 à 100Rare, 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 :

LangueFichierMots
Anglaisen.txt.gz748 958
Françaisfr.txt.gz550 235
Espagnoles.txt.gz284 834
Portugaispt.txt.gz507 721
Allemandde.txt.gz2 009 880
Italienit.txt.gz3 252 670
Néerlandaisnl.txt.gz2 678 323
Polonaispl.txt.gz3 670 705
Turctr.txt.gz400 442
Total14 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

NiveauRègleExempleRang
1. Mots de passe les plus courantsPosition dans une liste de 105 des mots de passe les plus courants (RockYou, HIBP)password2
2. Variante en leetspeakPosition de la forme dé-leetifiée × 10p@ssw0rd20
3. Liste linguistiqueLa moitié de la taille de la listesoleil (français)275 117
4. Mot composéVoir 8.4apfelbaumkuchen (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) :

CasseMultiplicateurExempleRang
Tout en minuscules× 1soleil275 117
Première lettre seulement× 2Soleil550 234
Dernière lettre seulement× 2soleiL550 234
Tout en majuscules× 2PASSWORD4
Tout autre mélangesomme des C(n, i) pour i = 1 … min(majuscules, minuscules)PaSsWoRd324

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é


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 :

AlgorithmeVitesse (12× RTX 5090)CalculTemps
NTLM4 081 GH/s275 117 / 4 081 × 10967 nanosecondes
MD52 634 GH/s275 117 / 2 634 × 109104 nanosecondes
SHA-1837 GH/s275 117 / 837 × 109329 nanosecondes
SHA-256332 GH/s275 117 / 332 × 109829 nanosecondes
bcrypt (coût 5)3 658 kH/s275 117 / 3 658 0000,08 seconde
Argon2id1 000 H/s275 117 / 1 0004 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èreDictionnaireHybride (dictionnaire + règles)
CandidatsLes mots de la liste, tels quelsChaque mot avec ses transformations (chiffres, symboles, majuscules…)
Exemples casséspassword, soleilP@ssw0rd!, soleil2024
VitesseMoins de candidats, donc plus rapideCouverture beaucoup plus large
S'applique quandLe mot exact est dans la listeLe 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èreDictionnairePCFG
ModèleListe fixe de candidatsGrammaire probabiliste des structures de mots de passe
Point fortLes mots exactsLes structures comme mot + chiffres, majuscule + minuscules + symbole
Exemplepassword ✓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èreDictionnaireMarkov
CandidatsListe préparée à l'avanceGénérés à la volée par un modèle statistique
CouvertureVocabulaire connuToute séquence qui « ressemble à de l'humain »
AvantageTrès rapide sur les mots exactsCouvre 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èreDictionnaireBourrage d'identifiants (credential stuffing)
ButCasser une empreinteSe connecter à un compte
MécanismeCalcul d'empreintes en localTentatives de connexion à distance
SourceListe de mots génériquePaires e-mail/mot de passe fuitées
DéfenseAlgorithme de hachage lentLimitation 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

12.2 Ce que Time2Crack ne modélise pas


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

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

13.3 Recommandations pratiques


14. Références

Sources académiques

Sources industrielles

Contexte


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