🔐 Comment Time2Crack calcule le temps de fissuration

Guide complet sur le fonctionnement scientifique et technique

Vue d'ensemble

Time2Crack répond à une question simple : « Combien de temps faudrait-il pour craquer ce mot de passe ? »

La réponse implique trois étapes :

MOT DE PASSE (ex. : "P@ssw0rd!")
    ↓
ÉTAPE 1 : Analyse (détection de motifs, entropie)
    ↓
ÉTAPE 2 : Estimation du nombre de tentatives (rang)
    ↓
ÉTAPE 3 : Conversion en temps (selon la vitesse GPU)
    ↓
RÉSULTAT (ex. : "2 jours sur GPU, NTLM")

Point crucial : Time2Crack ne teste pas réellement le mot de passe. Il estime mathématiquement combien de tentatives seraient nécessaires avec différentes attaques.

L'innovation clé est la séparation stricte entre Rang (nombre de tentatives) et Temps (conversion basée sur vitesse GPU). Cela permet de modifier les algorithmes d'attaque ou les vitesses GPU indépendamment.

Flux de calcul principal

calcCrackTime(password, options)  [core/calc.js]
    │
    ├─ analyzePatterns(password)
    │   └─ Retourne: { charset, entropy, patterns, flags, context }
    │
    ├─ estimateRank(password, context)
    │   ├─ rankBrute()      → charset^length
    │   ├─ rankDictionary() → dictionnaire + HIBP
    │   ├─ rankHybrid()     → dictionnaire + mutations
    │   ├─ rankMask()       → structures prévisibles
    │   ├─ rankMarkov()     → modèle probabiliste
    │   ├─ rankPCFG()       → grammaire
    │   ├─ rankCombinator() → combinaison de mots
    │   └─ Retourne: { standard, optimistic, worst_case, best_attack }
    │
    └─ rankToAllSeconds(rank)
        ├─ Convertit tentatives → secondes (vitesse GPU)
        └─ Retourne: { md5, sha1, sha256, ntlm, bcrypt, argon2 }

Architecture à deux couches

L'innovation clé de Time2Crack est la séparation stricte entre :

1️⃣Couche 1 (Rank)

« Combien de tentatives ? » — N'ont aucune notion de temps ou vitesse GPU. Modules : core/rank/*.js

2️⃣Couche 2 (Time)

« Combien de temps ? » — Convertissent tentatives en secondes. Module : core/time.js

Avantage : Modifier l'algorithme d'une attaque ne touche jamais à la logique de temps. Changer la vitesse GPU ne touche jamais aux attaques.

Étape 1 : Analyse du mot de passe

Qu'est-ce qu'on analyse ?

Avant de calculer le temps de fissuration, Time2Crack disséque le mot de passe pour détecter :

analyzePatterns(password) retourne {
  // CHARSET & ENTROPIE
  charset: { hasLower, hasUpper, hasDigit, hasSymbol },
  entropy: 52.3,  // bits

  // DÉTECTIONS
  patterns: {
    dictionaryWord: true,      // mot dans dictionnaire
    commonPassword: false,     // dans HIBP
    keyboardPattern: false,    // qwerty, asdfgh
    sequencePattern: false,    // abc, 123
    datePattern: false,        // 2024, 12/25
    repeatingPattern: false,   // aaaa, 1111
    maskLike: true,            // structure prévisible
    looksPassphrase: true,     // plusieurs mots
  }
}

Les 8 types de détections

1️⃣ Mot du dictionnaire

Teste le mot de passe contre 50k-200k mots courants et leurs variantes (mutations simples).

2️⃣ Mot de passe commun (HIBP)

Teste contre les 1 000 mots de passe les plus fuités en utilisant la k-anonymité (seulement 5 premiers caractères SHA-1 envoyés).

Vérifier si votre mot de passe a été piraté →

3️⃣ Pattern clavier

Détecte : qwerty, asdfgh, qazwsx, etc.

4️⃣ Séquence

Détecte : abc, 123, xyz, etc.

5️⃣ Date

Détecte : 2024, 12/25, 25-12-2024, etc.

6️⃣ Répétition

Détecte : aaaa, 1111, !!!, etc.

7️⃣ Structuré

Détecte structures prévisibles : Name2024!, Passw0rd!

8️⃣ Phrase

Détecte plusieurs mots concaténés : correcthorsebatterystaple → [correct] + [horse] + [battery] + [staple]

Étape 2 : Estimation du rang (nombre de tentatives)

Concept fondamental

Le rang est : « Combien de mots de passe une attaque doit-elle tester avant de le trouver ? »

Exemple

  • Brute force pour abc : 26³ = 17 576 tentatives
  • Dictionnaire pour password : ~1 tentative
  • PCFG pour Password123 : ~10¹¹ tentatives

Comment choisir l'attaque gagnante ?

Time2Crack lance les 7 attaques en parallèle et prend le meilleur résultat :

const results = {
  brute:      { rank: 1e30 },
  dictionary: { rank: 1e6 },      // GAGNANT
  hybrid:     { rank: 1e7 },
  mask:       { rank: 1e8 },
  markov:     { rank: 1e9 },
  pcfg:       { rank: 1e11 },
  combinator: { rank: 1e12 },
};

const best = Math.min(...Object.values(results).map(r => r.rank));
// → 1e6 (Dictionary attack est la plus rapide)
      

Étape 3 : Conversion en temps

Le concept

Maintenant qu'on sait qu'il faut rang tentatives, on convertit en secondes :

Formule : temps (secondes) = log₁₀(rang) / log₁₀(taux_hachage)

Les vitesses de hachage (GPU)

Time2Crack utilise vraies vitesses Hashcat pour 12× RTX 5090 :

Algorithme Vitesse Salification
MD5 2.63 TH/s Non
SHA-1 837 GH/s Non
SHA-256 332 GH/s Non
NTLM 4.08 TH/s Non
bcrypt 3.66 MH/s Oui
Argon2id 1 000 H/s Oui

Exemple de conversion

Mot de passe : "password" (Rang : 1 million = 10⁶)

Pour MD5 (2.63 TH/s):

Temps = 10⁶ / (2.63×10¹²) = 0.38 µs

Pour SHA-256 (332 GH/s):

Temps = 10⁶ / (3.32×10¹¹) = 3.0 µs

Pour bcrypt (3.66 MH/s):

Temps = 10⁶ / (3.66×10⁶) = 0.27 s

Pour Argon2id (1 000 H/s):

Temps = 10⁶ / 1 000 = 1 000 s ≈ 17 min

Les 7 attaques implémentées

1️⃣ Brute Force

Concept : Tester toutes les combinaisons possibles

Formule : rang = charset_size ^ length

Exemple : abc → 26³ = 17 576 tentatives

Très efficace pour : mots de passe courts et aléatoires

En savoir plus sur Brute Force →

2️⃣ Dictionary Attack

Concept : Tester chaque mot du dictionnaire

Formule : rang = taille_dictionnaire

Très efficace pour : mots humains

En savoir plus sur Dictionary Attack →

3️⃣ Hybrid Attack

Concept : Mot du dictionnaire + mutations simples

Formule : rang = taille_dictionnaire × nombre_mutations (~1000)

Très efficace pour : mots dictionnaire + petites modifications

En savoir plus sur Hybrid Attack →

4️⃣ Mask Attack

Concept : Tester les structures prévisibles

Très efficace pour : structures humaines (Name2024, Password!)

En savoir plus sur Mask Attack →

5️⃣ Markov Model

Concept : Approche statistique basée sur fréquences de n-grammes

Très efficace pour : mots humains — réduit espace de ~99%

En savoir plus sur Markov Model →

6️⃣ PCFG

Concept : Modèle grammatical qui apprend les structures

Exemple réel

Password123 :

  • Force brute : 62¹¹ ≈ 5 × 10¹⁹ tentatives
  • PCFG : sa structure (1 majuscule + 7 minuscules + 3 chiffres) est parmi les plus fréquentes, donc PCFG la teste très tôt

En savoir plus sur PCFG →

7️⃣ Combinator Attack

Concept : Concaténation de 2+ mots du dictionnaire

Très efficace pour : passphrases (4+ mots)

En savoir plus sur Combinator Attack →

Les 6 algorithmes de hachage

Pourquoi 6 ?

Différents algorithmes offrent différents niveaux de sécurité. Time2Crack montre les temps de fissuration pour les 6 pour montrer l'impact du choix d'algorithme.

🔴 MD5 (DÉPRÉCIÉ)

🔴 SHA-1 (DÉPRÉCIÉ)

🟡 SHA-256 (ACCEPTABLE)

🟠 NTLM (LEGACY)

🟢 bcrypt (RECOMMANDÉ)

🟢 Argon2id (MEILLEUR)

Les algorithmes modernes sont intentionnellement lents. C'est une feature, pas un bug! MD5 est rapide (mauvais), bcrypt est lent (excellent), Argon2id est encore plus lent (meilleur).

Les profils d'attaquant

Concept

Différents attaquants ont différentes ressources. Time2Crack modélise 4 profils :

Profil GPUs NTLM Cas d'usage
Amateur 1 340 GH/s Hackers hobbyistes
Experienced 12 4.08 TH/s Crackers sérieux (DÉFAUT)
Professional ~100 34.0 TH/s Entreprises, AWS clusters
Nation-State ~10k 3.40 PH/s Gouvernements

Impact concret

Exemple : un mot de passe de rang 10¹², haché en SHA-256

  • Amateur : 36 secondes
  • Expérimenté : 3 secondes
  • Professionnel : 0,36 seconde
  • État-nation : 3,6 millisecondes

Enseignement : Même un mot de passe "fort" peut être craqué en millisecondes par un état-nation!

Exemple concret : Tr0ub4dor&3

C’est le mot de passe de la BD xkcd « Password Strength » (n° 936), celle qui a aussi rendu célèbre « correct horse battery staple ». Voyons ce qu’en fait Time2Crack :

Étape 1 : Analyse

• length : 11 caractères
• charset : 94 caractères
• entropy : ~72 bits
• dictionaryWord : FALSE
• commonPassword : FALSE
• maskLike : TRUE
• looksPassphrase : FALSE

Étape 2 : Estimation du rang

Brute Force  : 94^11 ≈ 5 × 10^21
Dictionary   : ∞ (pas dans dictionnaire)
Mask         : ≈ 1.4 trillion
Markov       : ≈ 10 trillion
PCFG         : ≈ 50 billion (GAGNANT)
Combinator   : ∞

Étape 3 : Conversion en temps

Résultats pour 50 milliards tentatives

  • MD5 : 0.019 secondes
  • SHA-256 : 0.15 secondes
  • bcrypt : 3.8 heures
  • Argon2id : 1,6 ans

Conclusion

Questions fréquentes

Q: Time2Crack teste-t-il réellement le mot de passe ?

Non. Time2Crack n'envoie jamais votre mot de passe à un serveur.

En savoir plus sur notre politique de confidentialité →

Q: D'où viennent les chiffres de vitesse GPU ?

Hashcat benchmarks officiels (v6.2.6) sur RTX 5090 :

Q: Pourquoi Argon2id est-il si lent ?

C'est intentionnel. Argon2id est conçu pour être lent, memory-hard, et difficile à paralléliser. Cela force les attaquants à utiliser énormément de ressources.

Q: Peut-on améliorer un mot de passe 100% "sûr" ?

Non. Même le meilleur mot de passe peut être volé ou deviné. Stratégie défensive :

Q: Comment améliorer mon mot de passe ?

Règles simples :

Conclusion

Time2Crack fonctionne en 3 étapes immuables :

1. ANALYSE       → Détecte patterns (dictionnaire, keyboard, etc.)
2. RANG          → Estime tentatives nécessaires (7 attaques)
3. TEMPS         → Convertit tentatives en secondes (GPU speeds)

Innovation clé : Séparation rigoureuse entre rang (attaque) et temps (GPU), permettant :

Résultat : Estimation précise, hors ligne, multilingue du temps de fissuration d'un mot de passe.

↑ Retour au sommet