L'attaque par masque — 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

  • Vue d'ensemble
  • Contexte historique et académique
  • Fondements conceptuels : pourquoi les masques fonctionnent
  • Architecture d'une attaque par masque moderne
  • Syntaxe des masques (Hashcat/JtR)
  • Réduction du keyspace : principe mathématique
  • Implémentation dans Time2Crack : addMaskAttacks()
  • Détection de date et réduction structurelle
  • Calibration haute fidélité
  • Benchmarks et ordres de grandeur
  • Exemples concrets de craquage par masque
  • Comparaison avec brute force, hybride et PCFG
  • Limites de l'attaque par masque
  • Défenses efficaces
  • Références bibliographiques

  • 1. Vue d'ensemble

    L'attaque par masque (mask attack) consiste à tester des mots de passe qui suivent une forme positionnelle précise plutôt que toutes les combinaisons possibles.

    Exemple : au lieu de tester tout l'espace 8 caractères sur 95 symboles (95^8), l'attaquant cible un motif probable comme :

  • 5 minuscules,
  • 2 chiffres.
  • Soit le masque Hashcat ?u?l?l?l?l?l?d?d.

    L'idée centrale : les mots de passe humains ne sont pas aléatoires. Ils sont souvent structurés (Thomas42, Marine2024, Bonjour!1). Le masque exploite précisément cette régularité.


    2. Contexte historique et académique

    2.1 Origines

    La logique des masques est ancienne : dès les premiers outils de cracking, les opérateurs observaient que les politiques de mot de passe produisent des formats répétitifs.

    L'industrialisation vient avec :

  • John the Ripper (modes incrémentaux et patterns),
  • Hashcat (modes masque GPU ultra-optimisés),
  • les fuites massives (RockYou, LinkedIn, Adobe), qui ont permis d'identifier les structures les plus fréquentes.
  • 2.2 Validation empirique

    La littérature offensive/défensive converge : une fraction très importante de mots de passe réels suit des patterns simples (Mot + chiffres, Initiale majuscule + mot + année, etc.).

    Wheeler (USENIX 2016), et les travaux probabilistes (Markov/PCFG/OMEN), montrent que la structure est aussi déterminante que la longueur brute.


    3. Fondements conceptuels : pourquoi les masques fonctionnent

    3.1 Les humains génèrent des structures, pas du hasard

    La plupart des utilisateurs construisent des secrets mémorisables :

  • mot connu,
  • variation de casse,
  • suffixe numérique,
  • symbole final facultatif.
  • Cette stratégie est prévisible et hautement compressible en masques.

    3.2 Les politiques de complexité renforcent la prévisibilité

    Une règle du type « 1 majuscule, 1 chiffre, 1 symbole » n'impose pas l'aléatoire ; elle pousse souvent vers des patterns stables :

  • Mot123!
  • Prénom2024
  • Ville75#
  • Le masque est justement l'outil idéal pour parcourir ces schémas avec un coût très faible.

    3.3 Réduction du keyspace effectif

    Pour un mot de passe de longueur 8 :

  • brute force complet (95^8) ≈ 6.63e15 candidats,
  • masque ?u?l?l?l?l?d?d = 26 26^4 10^2 = 1.19e9 candidats.
  • La réduction est de plusieurs millions de fois, tout en couvrant un pattern humain fréquent.


    4. Architecture d'une attaque par masque moderne

    Pipeline type :

    1) Profilage de la cible / du corpus
       -> structures fréquentes (L8D2, L6D4, U1L5D2, etc.)
    

    2) Génération des masques candidats -> ordonnés par probabilité

    3) Exécution GPU (Hashcat -a 3) -> tests en parallèle à très haut débit

    4) Ajustement adaptatif -> on garde les masques performants, on écarte les faibles

    Le succès dépend moins de la quantité brute de masques que de leur priorisation.


    5. Syntaxe des masques (Hashcat/JtR)

    5.1 Classes de base

  • ?l : minuscule (a-z)
  • ?u : majuscule (A-Z)
  • ?d : chiffre (0-9)
  • ?s : symbole imprimable
  • ?a : alphabet mixte standard (souvent ?l?u?d?s)
  • 5.2 Exemples

  • ?u?l?l?l?l?d?d -> Thomas42
  • ?l?l?l?l?l?l?d?d?d?d -> summer2024
  • ?u?l?l?l?l?l?l?s?d -> Marine!7
  • 5.3 Masques personnalisés

    Hashcat permet des jeux de caractères custom (-1, -2, etc.), par exemple :

  • -1 ?l?uéèàç pour langues latines,
  • -2 0123456789!@# pour suffixes probables,
  • puis masque combiné ?1?1?1?1?2?2.

  • 6. Réduction du keyspace : principe mathématique

    Soit un masque de longueur n avec des cardinalités positionnelles c1, c2, ..., cn.

    Le keyspace masqué est :

    Kmask = Π(ci)

    Le temps attendu (modèle budget) :

    T = Kmask / rate

    Dans un modèle naïf non masqué :

    Kfull = cs^n

    Le gain du masque est :

    Gain = Kfull / K_mask

    Plus les contraintes positionnelles sont fortes (ex. digits en fin, majuscule en tête), plus le gain augmente.


    7. Implémentation dans Time2Crack : addMaskAttacks()

    Time2Crack implémente la logique masque dans app.js :

  • fonction : addMaskAttacks(rows, full, len, cs, kbPat, seq, weak, dt, pw)
  • catégorie : cat: "mask"
  • affichage : aMask / note nMaskPositional, nKBDetected, nSeqDetected, nDateDetected
  • 7.1 Calcul du keyspace masqué

    Le code compte les occurrences réelles de chaque type de caractère dans le mot de passe :

  • majuscules,
  • minuscules,
  • chiffres,
  • symboles.
  • Puis construit :

    maskKS = 26^U 26^L 10^D 33^S (approximation via constantes internes)

    Cela modélise un attaquant connaissant la structure par type, pas seulement la longueur totale.

    7.2 Cas particuliers

  • weak : estimation via weakGuessTime(a.rate) (rang minimal dépendant du débit),
  • dt (date détectée) : réduction via detectDateAndReduce(),
  • sinon : keyspace positionnel standard.
  • Le temps est ensuite estimé par budgetTime(effectiveMaskGuesses, a.rate) (avec facteur de rang de masque et traitement Unicode/date).


    8. Détection de date et réduction structurelle

    Time2Crack intègre un traitement spécifique des dates (hasDate, detectDateAndReduce) :

  • détection d'années 1600-2099,
  • détection de patterns date (DD/MM/YYYY, variantes séparateurs),
  • remplacement d'un espace énorme (10^dateChars) par un ensemble plausible (~200 années ou ~36500 dates).
  • Conséquence : un mot de passe de type Mot2024! est fortement réévalué à la baisse, ce qui est cohérent avec la pratique offensive.


    9. Calibration haute fidélité

    Quand le mode haute fidélité est actif, la catégorie masque reçoit un multiplicateur supplémentaire dans applyHighFidelityCalibration() :

  • si pattern clavier / séquence / date : facteur de réduction additionnel,
  • sinon : estimation conservatrice.
  • Intuition : ces signaux augmentent la probabilité d'un classement précoce dans la file de masques testés.


    10. Benchmarks et ordres de grandeur

    Ordres de grandeur (profil 12x RTX 4090) :

    AlgorithmeDébit approxTemps pour 1e9 candidats ------:---: MD5~2.03 TH/s~0.0005 s SHA-1~610 GH/s~0.0016 s SHA-256~272 GH/s~0.0037 s NTLM~3.46 TH/s~0.0003 s bcrypt (cost 10)~69 kH/s~4.0 h Argon2id~800 H/s~14.5 jours

    Lecture :

  • sur hash rapides, le masque est foudroyant,
  • sur hash lents, il reste très dangereux sur patterns fréquents mais le coût devient concret.

  • 11. Exemples concrets de craquage par masque

    11.1 Thomas42

  • masque pertinent : ?u?l?l?l?l?l?d?d
  • keyspace : 26 26^4 10^2 (ordre de grandeur ~1e9)
  • sur NTLM/MD5 : quasi instantané.
  • 11.2 summer2024

  • masque pertinent : ?l?l?l?l?l?l?d?d?d?d
  • si année détectée, réduction forte (années plausibles << 10^4).
  • 11.3 Marine!7

  • masque pertinent : ?u?l?l?l?l?l?s?d
  • pattern très fréquent dans les politiques d'entreprise.

  • 12. Comparaison avec brute force, hybride et PCFG

    AttaquePoint fortPoint faible --------- Brute forceCouverture exhaustiveCoût exponentiel MaskExcellente efficacité sur structures humainesSensible au mauvais choix de masques Hybride/rulesTrès bon sur mots + mutationsDépend d'un mot de base PCFGCapture la grammaire globalePlus coûteux à entraîner/opérer

    En pratique, les opérateurs combinent souvent mask + rules + probabiliste.


    13. Limites de l'attaque par masque

  • Dépendance au bon masque : un mauvais set de masques perd vite en rendement.
  • Faible généralisation hors structure : sur mot de passe réellement aléatoire, l'avantage disparaît.
  • Explosion combinatoire si masques trop larges : ?a répété sur grande longueur revient proche de la brute force.
  • Couverture linguistique partielle : les alphabets Unicode/diacritiques nécessitent des jeux custom.

  • 14. Défenses efficaces

    14.1 Côté utilisateur

  • utiliser un gestionnaire de mots de passe,
  • générer des mots de passe aléatoires longs (>= 16),
  • éviter complètement les patterns Mot+année, Prénom+chiffres, Majuscule+mot+symbole.
  • 14.2 Côté système

  • stockage avec Argon2id (ou bcrypt cost élevé),
  • MFA systématique,
  • blocage des mots de passe compromis,
  • télémétrie de connexion et détection d'anomalies.
  • 14.3 Côté politique

  • privilégier longueur et contrôle de compromission,
  • réduire les règles de complexité purement cosmétique qui favorisent les patterns prévisibles.

  • 15. Références bibliographiques

    Sources académiques

    Wheeler, D. L. (2016). zxcvbn: Low-Budget Password Strength Estimation. 25th USENIX Security Symposium. Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009). Password Cracking Using Probabilistic Context-Free Grammars. IEEE Symposium on Security and Privacy. Dürmuth, M., Angelstorf, F., Horsch, J., et al. (2015). OMEN: Faster Password Guessing Using an Ordered Markov Enumerator. ESSoS. Ur, B., Kelley, P. G., Komanduri, S., et al. (2012). How Does Your Password Measure Up? USENIX Security.

    Sources industrielles et techniques

    Hashcat Wiki.
    Mask attack (-a 3). https://hashcat.net/wiki/ Hashcat (benchmarks). https://hashcat.net/hashcat/ Hive Systems (Password Table). https://www.hivesystems.io/password-table

    Sources web citées dans l'application Time2Crack

    USENIX Security 2016 (Wheeler). https://www.usenix.org/conference/usenixsecurity16/technical-sessions/presentation/wheeler
    Document généré pour le projet Time2Crack — Version 1.0 — 2026-04-01 Sources code : app.js (fonctions addMaskAttacks, detectDateAndReduce, hasDate, budgetTime, applyHighFidelityCalibration)*