L'attaque hybride — Fonctionnement exhaustif

Document de référence pour le projet Time2Crack

Destinataires : développeurs, chercheurs en sécurité, utilisateurs avancés

Table des matières

1. Vue d'ensemble

L'attaque hybride est la méthode de cracking qui combine une wordlist dictionnaire avec un jeu de règles de transformation. Plutôt que de tester chaque mot du dictionnaire tel quel (attaque dictionnaire pure), elle génère à la volée toutes les variantes plausibles de chaque mot — capitalisations, substitutions de caractères, ajouts préfixes/suffixes, inversions — et les teste systématiquement.

L'attaque hybride est historiquement la méthode responsable de la majorité des crackings réels de mots de passe "moyens" — ceux qui ont l'apparence d'être forts sans l'être. Selon Ma et al. (2014, IEEE S&P), les 8 à 10 premières règles appliquées à un mot courant suffisent à crack le mot de passe médian de la population.

Dans Time2Crack, l'attaque hybride modélise :

2. Contexte historique et académique

2.1 Origines : John the Ripper et les règles de mutation

L'attaque hybride naît formellement avec John the Ripper (Solar Designer, 1996), premier outil public à combiner une wordlist avec un moteur de règles configurable. Avant John the Ripper, les attaques dictionnaire testaient les mots bruts ; John introduit la notion que chaque mot génère une famille de candidats.

2.2 Études empiriques fondatrices

• Règle 1 (: → mot brut) : crack 18% des mots de passe dict-based

2.3 La fuite LinkedIn comme cas d'école

La fuite LinkedIn de 2012 (6,5 millions de SHA-1 non salés) illustre parfaitement la puissance de l'hybride. En 72 heures, la communauté hashcat avait cracké :

L'analyse post-crack a révélé que "linkedin1", "LinkedIn1", "l!nked!n" et "LINKEDIN" — toutes des variantes de "linkedin" — représentaient collectivement plusieurs dizaines de milliers de comptes compromis.

3. Fondements conceptuels : pourquoi l'hybride fonctionne

3.1 Le comportement humain de "sécurisation"

Quand un système impose des règles de complexité (majuscule, chiffre, symbole), les utilisateurs ne génèrent pas de l'aléatoire — ils appliquent des transformations prévisibles à des mots mémorisables :

Ces transformations semblent créatives à l'utilisateur. Elles sont exactement les premières que tente l'attaquant car elles correspondent aux contraintes imposées par les politiques de sécurité.

3.2 La notion d'espace réduit efficace

Un mot de passe de 10 caractères avec lettres+chiffres+symboles a un keyspace brute-force de 94^10 ≈ 5,4 × 10^19 combinaisons. Trop grand pour être parcouru en temps raisonnable.

Mais si ce mot de passe est "Password1!" — une transformation triviale de "password" — il se trouve parmi les 500 premiers candidats générés par un outil hybride sur le mot "password". L'attaquant ne parcourt pas 5,4 × 10^19 combinaisons : il en parcourt 500.

C'est la réduction fondamentale de l'attaque hybride : l'espace réel des choix humains est astronomiquement plus petit que l'espace théorique des caractères possibles.

3.3 La loi de puissance des transformations

Tout comme les mots de passe bruts suivent une loi de puissance (Zipf), les transformations que les humains appliquent suivent elles aussi une distribution très concentrée. Ma et al. (2014) ont montré empiriquement :

Cette concentration permet à un jeu de 64 règles bien choisies (best64) d'atteindre une couverture de 79-85%, là où 64 règles aléatoires n'atteindraient que 10-15%.

3.4 Interaction avec la popularité du mot de base

Plus le mot de base est fréquent, plus le mot de passe dérivé est tôt dans la liste de priorité de l'attaquant. L'attaquant ordonne ses candidats par probabilité décroissante :

Candidats générés par l'attaquant (ordre de test) :
password        (mot brut, le plus courant)
Password        (capitalize first)
password1       ($1)
PASSWORD        (uppercase all)
password!       ($!)
p@ssword        (substitute a→@)
passw0rd        (substitute o→0)
Password1       (c + $1)
P@ssword        (c + s a @)
password123   ($1 $2 $3)
...
p@ssW0rd!     (combinaison complexe)

"password" est le mot le plus courant → ses dérivés sont testés en premier. "papillon" est moins courant → ses dérivés sont testés bien plus tard. Cette priorisation est le mécanisme central qui explique les trois keyspaces distincts dans Time2Crack.

4. Architecture d'une attaque hybride moderne

4.1 Pipeline général

Phase 1 : Sélection de la wordlist
    ├── Passwords fuités triés par fréquence (RockYou, HIBP, Collections)
    ├── Dictionnaire linguistique (fr.txt, en.txt, de.txt...)
    ├── Wordlists thématiques (prénoms, villes, marques, séries TV)
    └── Wordlists contextuelles (domaine cible, noms d'employés, termes métier)
Phase 2 : Sélection du jeu de règles
    ├── best64.rule (référence équilibrée, 64 règles)
    ├── OneRuleToRuleThemAll.rule (52 000 règles, ML-generated)
    ├── d3ad0ne.rule (34 000 règles, empirical)
    ├── JtR rules (generated.rule, specific.rule, extra.rule)
    └── Règles custom (adaptées au domaine cible)
Phase 3 : Expansion (wordlist × règles)
    ├── Pour chaque mot w dans wordlist :
    │     Pour chaque règle r dans ruleset :
    │       candidat = apply(r, w)
    │       Si candidat ≠ w et candidat non déjà testé :
    │         filedecandidats.push(candidat)
    └── Ordre : (w1, règle1), (w1, règle2)... (w2, règle1)...
        ou : (w1, règle1), (w2, règle1)... selon la stratégie
Phase 4 : Hachage et comparaison (GPU)
    ├── Envoi par batch de ~10M candidats au GPU
    ├── Calcul parallèle des hashes (SIMD, 168 GH/s pour MD5)
    ├── Comparaison avec hash(es) cible(s)
    └── Si match : TROUVÉ — log(candidat, hash, règle)
Phase 5 : Reporting
    └── Candidat cracké + règle utilisée + rang dans la liste

4.2 Modes d'opération hashcat

Hashcat implémente l'hybride de deux façons distinctes :

hashcat -a 0 -m 0 hashes.txt rockyou.txt -r best64.rule

hashcat -a 6 -m 0 hashes.txt wordlist.txt ?d?d?d?d
Teste "sunshine0000", "sunshine0001", ..., "sunshine9999"

hashcat -a 7 -m 0 hashes.txt ?d?d wordlist.txt
Teste "00sunshine", "01sunshine", ..., "99sunshine"

Time2Crack modélise principalement le mode -a 0 (règles de mutation), qui couvre la grande majorité des attaques hybrides réelles documentées.

4.3 Ordre des candidats et stratégie de priorisation

L'ordre dans lequel les candidats sont testés est critique. Deux stratégies principales :

(W1, R1), (W1, R2), ..., (W1, Rn), (W2, R1), (W2, R2)...

(W1, R1), (W2, R1), ..., (Wm, R1), (W1, R2), (W2, R2)...

En pratique, hashcat utilise word-first par défaut mais les opérateurs expérimentés choisissent selon le profil cible.

5. Les jeux de règles de mutation

5.1 Syntaxe des règles hashcat

Les règles hashcat sont exprimées dans un langage minimal où chaque caractère représente une opération sur la chaîne candidate :

5.2 Règles composées

Les règles peuvent être enchaînées sur une seule ligne pour créer des transformations complexes :

c $1          → "Password1" (capitalize + append 1)
c $! $1       → "Password!1" (capitalize + append ! + 1)
s a @ s e 3   → "p@ssw3rd" (substitute a→@ et e→3)
r $1          → "1drowssap" (reverse + append 1)
u $2 $0 $2 $3 → "PASSWORD2023" (uppercase + append year)

La puissance est dans la composition : 64 règles simples génèrent des milliers de transformations distinctes par combinaison.

5.3 Jeux de règles principaux

6. Règles best64 : le jeu de référence

Best64 est le jeu de 64 règles standard de référence dans la littérature académique et l'industrie. Voici les règles les plus importantes et leur justification empirique :

6.1 Les 20 règles les plus efficaces (par ordre de rendement)

6.2 Pourquoi ces règles sont-elles si efficaces ?

Chaque règle top-10 correspond à une contrainte de politique de sécurité courante :

Les politiques de mots de passe n'augmentent pas réellement la sécurité si les utilisateurs appliquent des transformations prévisibles — elles déplacent seulement les passwords vers la seconde ou troisième règle de best64.

7. Taxonomie complète des transformations

7.1 Catégorie 1 : Transformations de casse

Les plus courantes. Exploitent l'obligation d'avoir une majuscule :

7.2 Catégorie 2 : Suffixes et préfixes numériques

Exploitent l'obligation d'avoir un chiffre :

7.3 Catégorie 3 : Substitutions leet

Remplacement systématique de lettres par des chiffres ou symboles visuellement similaires :

Les substitutions combinées ("P@ssw0rd") semblent complexes mais sont générées en quelques règles : c s a @ s o 0. Elles sont parmi les 500 premiers candidats sur "password".

7.4 Catégorie 4 : Suffixes symboliques

Exploitent l'obligation d'avoir un caractère spécial :

7.5 Catégorie 5 : Transformations structurelles

Moins fréquentes mais utiles pour certains profils :

7.6 Catégorie 6 : Transformations composées (niveau avancé)

Les règles complexes combinent plusieurs opérations :

c $1 s a @        → "P@ssword1" (capitalize + append 1 + substitute a→@)
u $! $1 $2 $3     → "SUNSHINE!123" (uppercase + append !123)
r c $1            → "Drowssap1" (reverse + capitalize + append 1)
s e 3 s a @ c $!  → "P@ssw3rd!" (multiple substitutions + capitalize + !)

Ces transformations semblent très complexes mais restent détectables par un bon jeu de règles. OneRuleToRuleThemAll en contient des milliers de ce type.

8. Priorisation par fréquence : le cœur de l'efficacité

8.1 La fréquence du mot de base détermine la priorité

Un attaquant intelligent n'applique pas les règles de façon uniforme à tous les mots. Il priorise :

Cette stratégie est implémentée dans hashcat via le tri de la wordlist par fréquence décroissante combiné à la stratégie word-first. Elle explique pourquoi "Password1" (dérivé de "password", le mot #1) est craqué en millisecondes, alors que "Soleil1" (dérivé de "soleil", mot ~5000 du dictionnaire français) prend peut-être quelques secondes.

8.2 Position médiane dans l'espace de recherche

La mesure clé est le nombre médian de candidats testés avant de trouver le mot de passe cible. Ma et al. (2014) fournissent des mesures empiriques :

Ces mesures sont la base directe des constantes de Time2Crack :

const HYBRIDKEYSPACECOMMON = 500;    // Ma et al. 2014 — médiane top-100
const HYBRIDKEYSPACEDICT = 8000;   // Ma et al. 2014 — médiane dict courant
const HYBRIDKEYSPACEFULL = 128e6;   // Gosney 2012 — best64 × 2M words exhaustif

8.3 Conditions nécessaires pour que l'hybride soit applicable

L'attaque hybride requiert que le mot de passe soit structurellement dérivable d'un mot de dictionnaire. Time2Crack détecte cette condition via hybridVuln :

const hybridVuln = dictWord || (common && /[a-z]/i.test(pw));

Si ni dictWord ni hybridVuln ne sont vrais — le mot de passe ne contient aucune racine dictionnaire détectable — l'attaque hybride retourne null (non applicable). Un mot de passe purement aléatoire comme "xK9#mQ7@" n'est pas vulnérable à l'hybride.

9. Implémentation dans Time2Crack : addHybridAttacks()

9.1 Code complet annoté

function addHybridAttacks(rows, hybridVuln, weak, common, dictWord) {
  if (hybridVuln || weak) {
    // Sélection du keyspace selon la popularité du mot de base :
    // common → mot dans HIBP top-400 → position ~500 dans la liste de l'attaquant
    // dictWord → mot dans la wordlist → position ~8000
    // sinon (hybridVuln sans dictWord ni common) → scan exhaustif ~128M
    const hybridKS = common ? HYBRIDKEYSPACECOMMON
      : dictWord ? HYBRIDKEYSPACEDICT
      : HYBRIDKEYSPACEFULL;
for (const a of ALGOS) {
      rows.push({
        atk: t("aHybrid"),
        hash: a.name,
        rate: a.rate,
        // budgetTime : le keyspace IS le nombre de guesses — pas de division par 2
        // (contrairement à bruteTime, ici les candidats sont ordonnés par probabilité)
        sec: weak ? weakGuessTime(a.rate) : budgetTime(hybridKS, a.rate),
        note: weak ? t("nWeakPassword") : t("nDictMut"),
        cat: "hybrid",
      });
    }
  } else {
    // Mot de passe sans structure dictionnaire → hybride inapplicable
    rows.push({
      atk: t("aHybrid"),
      hash: "(all)",
      rate: 0,
      sec: null,                     // N/A dans le tableau
      note: t("nStructUnrecog"),
      cat: "hybrid",
    });
  }
}

9.2 budgetTime vs bruteTime

La distinction entre les deux fonctions est fondamentale :

// bruteTime : l'attaquant ne sait pas où est le mot de passe dans l'espace.
// Il teste en moyenne la moitié avant de le trouver. → keyspace/2
function bruteTime(keyspace, rate) {
  const ls = Math.log(keyspace / 2) - Math.log(rate);
  return Math.exp(ls);
}
// budgetTime : l'attaquant teste les candidats en ordre de probabilité décroissante.
// Le keyspace IS le nombre de candidats attendus avant trouvaille (position médiane).
// Pas de division par 2 — la médiane est déjà incorporée dans les constantes Ma 2014.
function budgetTime(guesses, rate) {
  const ls = Math.log(guesses) - Math.log(rate);
  return Math.exp(ls);
}

Pour l'hybride, budgetTime est correct car les 500/8000/128M candidats sont des estimations empiriques de la position médiane, pas de l'espace total à parcourir.

9.3 Relation avec isDictWord()

La détection dictWord qui conditionne le choix du keyspace hybride est produite par isDictWord() :

function isDictWord(pw) {
  if (!DICTWORDS || !DICTWORDS.size) return false;
  const l = pw.normalize("NFC").toLowerCase();
// Test direct : le password est-il tel quel dans le dictionnaire ?
  if (DICTWORDS.has(l)) return true;
// Test de-leetifié : "s0le1l" → "soleil" dans le dico ?
  const dl = deLeet(pw);
  if (dl !== l && DICTWORDS.has(dl)) return true;
// Test substring : "sunshine123" contient "sunshine" dans le dico ?
  for (const w of DICTWORDS) {
    if (l.includes(w) && w.length >= 4) return true;
  }
return false;
}

Cette détection détermine non seulement si l'hybride est applicable, mais aussi quel keyspace (common vs dict) est utilisé pour le calcul du temps.

10. Les trois keyspaces hybrides et leur justification

10.1 HYBRIDKEYSPACECOMMON = 500

10.2 HYBRIDKEYSPACEDICT = 8 000

10.3 HYBRIDKEYSPACEFULL = 128 000 000

11. Calibration haute fidélité

11.1 Rôle du mode haute fidélité

Quand le mode haute fidélité (HF) est activé dans Time2Crack, un multiplicateur supplémentaire est appliqué aux temps calculés pour affiner la précision. Pour l'attaque hybride, ce multiplicateur tient compte de facteurs non capturés par les keyspaces de base.

11.2 Multiplicateurs HF pour l'hybride

Dans applyHighFidelityCalibration() :

case "hybrid":
  // Mots très courants : crackés encore plus tôt que la médiane Ma 2014
  // car les attaquants modernes trient word-first + règle-first simultanément.
  // Réduction de 30% sur les temps déjà courts.
  m = context.common ? 0.7
    : context.dictWord ? 0.8
    : 1.0;
  break;

11.3 Interaction avec le guard de monotonie

Le guard de monotonie s'assure qu'aucune attaque spécialisée ne prétend être plus rapide que la force brute sur la sous-chaîne alphabétique du mot de passe :

// Pour chaque row non-brute :
const floorAlpha = bruteTime(Math.pow(26, alphaOnly.length), algo.rate);
if (row.sec < floorAlpha) row.sec = floorAlpha;

Pour les mots courts (ex: "cat" = 3 lettres, floor = 26^3/rate ≈ 0 secondes), ce guard ne change rien. Pour des mots longs entiers dans le dictionnaire (ex: "concatenation" = 13 lettres), il évite qu'un hybride prétende cracker en moins de temps que le brute-force alphabétique — ce qui serait physiquement impossible.

12. Relation avec les attaques dérivées

12.1 Hybride vs Dictionnaire pur

12.2 Hybride vs Rule-Based (attaque par règles)

L'attaque rule-based dans Time2Crack est conceptuellement similaire mais avec un jeu de règles beaucoup plus large :

const RULEKEYSPACE = 250000000;  // vs 128M pour hybride full

La différence : l'hybride modélise best64 (64 règles, focus sur les transformations humaines communes). L'attaque rule-based modélise des jeux plus larges comme d3ad0ne (34k règles) ou OneRuleToRuleThemAll (52k règles), utilisés quand best64 échoue. Le rule-based est l'hybride "de seconde ligne" — plus lent mais plus exhaustif.

12.3 Hybride vs PCFG

PCFG (Probabilistic Context-Free Grammar, Weir 2009) modélise la structure grammaticale du mot de passe pour générer des candidats. Différences :

PCFG peut attaquer des mots de passe sans racine dictionnaire si leur structure est commune (ex: "Thelonious8" → aucun mot du dico mais structure Capitalize+lower+digit très prévisible).

12.4 Hybride vs Morphologique (morph)

L'attaque morphologique teste les variantes linguistiques (flexions, dérivations). C'est une généralisation de l'hybride pour les langues à morphologie riche :

L'hybride opère sur la surface du mot (transformations de caractères), le morphologique opère sur la structure lexicale (dérivation, flexion). Ils sont complémentaires.

13. Benchmarks par algorithme de hachage

13.1 Temps pour les trois keyspaces hybrides (12× RTX 4090)

13.2 Impact du profil attaquant

Time2Crack propose deux profils (Experienced 12 GPU, Professional 100 GPU). Pour l'hybride, la différence de profil est directement proportionnelle :

Pour MD5, SHA-1, NTLM : le profil change les temps de microsecondes à nanosecondes — sans aucun impact pratique, les deux sont instantanés.

14. Exemples concrets de cracking hybride

14.1 Exemple 1 : "Password1" (COMMON)

14.2 Exemple 2 : "Soleil2024" (DICT)

14.3 Exemple 3 : "p@pillon!" (DICT avec substitutions)

14.4 Exemple 4 : "xK9#mQ7@" (résistant)

Ce mot de passe ne peut pas être cracké par attaque hybride. Il n'a aucune racine dictionnaire. L'attaquant doit recourir à la force brute pure, au PCFG ou à des attaques statistiques (Markov, Neural).

14.5 Exemple 5 : "LinkedInB3st!" (DICT avec contexte)

Cas intéressant : le mot de passe contient deux racines ("linkedin" et "best" via de-leetification). L'attaque hybride est applicable car au moins une racine est détectée. En pratique, une attaque combinator (deux mots collés) serait encore plus efficace ici.

15. Limites de l'attaque hybride

15.1 Limites intrinsèques

15.2 Ce que Time2Crack ne capture pas

15.3 Cas où l'hybride est surestimé

Time2Crack peut surestimer la vitesse hybride dans deux cas :

16. Défenses efficaces

16.1 Ce qui résiste à l'hybride

L'attaque hybride échoue si le mot de passe ne dérive d'aucun mot de dictionnaire existant. Stratégies efficaces :

16.2 Ce qui ne résiste PAS à l'hybride

Les stratégies "de renforcement" les plus courantes ne résistent pas :

16.3 Algorithmes de hachage résistants

Même si un mot de passe est vulnérable à l'hybride structurellement, l'algorithme de hachage peut rendre l'attaque économiquement inviable :

16.4 Recommandations pratiques

17. Références bibliographiques

Publications académiques