Come Time2Crack calcola il tempo di cracking

Guida completa alle operazioni scientifiche e tecniche

Panoramica

Time2Crack risponde a una semplice domanda: "Quanto ci vorrebbe per decifrare questa password?"

La risposta comporta tre passi:

PASSWORD (es. "P@ssw0rd!")
    ↓
PASSO 1: Analisi (rilevamento di schemi, entropia)
    ↓
PASSO 2: Numero stimato di tentativi (rango)
    ↓
PASSO 3: Conversione in tempo (in base alla velocità della GPU)
    ↓
RISULTATO (es. "2 giorni su GPU, NTLM")

Punto critico : Time2Crack testicoli Non proprio. La password. matematicamente quanti tentativi sarebbero necessari con diversi attacchi.

L'innovazione chiave è la stretta separazione tra Rank (numero di tentativi) e Tempo Questo permette di modificare gli algoritmi di attacco o le velocità GPU indipendentemente.

Flusso di calcolo principale

calcCrackTime(password, options)  [core/calc.js]
    │
    ├─ analyzePatterns(password)
    │   └─ Restituisce: { charset, entropy, patterns, flags, context }
    │
    ├─ estimateRank(password, context)
    │   ├─ rankBrute()      → charset^length
    │   ├─ rankDictionary() → dizionario + HIBP
    │   ├─ rankHybrid()     → dizionario + mutazioni
    │   ├─ rankMask()       → strutture prevedibili
    │   ├─ rankMarkov()     → modello probabilistico
    │   ├─ rankPCFG()       → grammatica
    │   ├─ rankCombinator() → combinazione di parole
    │   └─ Restituisce: { standard, optimistic, worst_case, best_attack }
    │
    └─ rankToAllSeconds(rank)
        ├─ Converte tentativi → secondi (velocità GPU)
        └─ Restituisce: { md5, sha1, sha256, ntlm, bcrypt, argon2 }

Architettura a due strati

L'innovazione chiave di Time2Crack è separazione rigorosa tra:

1Livello 1 (Rank)

"Quanti tentativi?" — Non hanno idea di tempo o velocità della GPU. Moduli: core/rank/*.js

2Livello 2 (Tempo)

"Quanto tempo?" — Converti tentativi in secondi. Modulo: core/time.js

Vantaggio : Cambiare l'algoritmo di un attacco non influisce mai sulla logica del tempo.

Passo 1: Analisi della password

Cosa stiamo analizzando?

Prima di calcolare il tempo di crepa, Time2Crack disseziona la password per rilevare:

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
  }
}

Gli 8 tipi di rilevamento

1 Dizionario Word

Testare la password contro le parole comuni 50k-200k e le loro varianti (mutazioni semplici).

2 Password comune (HIBP)

Prova contro le 1.000 password più evase utilizzando le k-anonimato (solo 5 primi caratteri SHA-1 inviati).

Controllare se la password è stata hackerata →

3 Modello tastiera

Rilevamento: qwerty♪ asdfgh♪ qazwsx, ecc.

4 Sequenza

Rilevamento: abc♪ 123♪ xyz, ecc.

5 Data

Rilevamento: 2024♪ 12/25♪ 25-12-2024, ecc.

6 Ripeto

Rilevamento: aaaa♪ 1111♪ !!!, ecc.

7 Struttura

Rileva strutture prevedibili: Name2024!♪ Passw0rd!

8 Phrase

Rileva diverse parole concatenate: correcthorsebatterystaple → [correct] + [horse] + [battery] + [staple]

Fase 2: Stime casuali (numero di tentativi)

Concezione di base

The riga è: "Quante password devono essere provate prima di trovarlo?"

Esempio

  • Forza lorda per abc : 263 = 17,576 tentativi
  • Dizionario per password 1 tentativo
  • PCF per Password123 1011 tentativi

Come scegliere l'attacco vincente?

Time2Crack lancia il 7 attacchi paralleli e prende il miglior risultato:

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)
      

Passo 3: Conversione al Tempo

Il concetto

Ora che sappiamo che dobbiamo rang tentativi, ci convertiamo in secondi :

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

Velocità di taglio (GPU)

Time2Crack utilizza vero velocità Hashcat per 12× RTX 5090:

Algoritmo Velocità Salificazione
MD5 2.63 TH/s No.
SHA-1 837 GH/s No.
SHA-256 332 GH/s No.
NT1 4.08 TH/s No.
b. 3.66 MH/s Sì.
Argon2id 1.000 H/s Sì.

Esempio di conversione

Password: "password" (Rang: 1 milione = 106)

Per MD5 (2.63 TH/s):

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

Per SHA-256 (332 GH/s):

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

Per bcrypt (3.66 MH/s):

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

Per Argon2id (1.000 H/s):

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

7 attacchi implementati

1 Forza lorda

Concezione : Testare tutte le combinazioni possibili

Formule : rang = charset_size ^ length

Esempio : abc → 263 = 17,576 tentativi

Molto efficace per : password corte e casuali

Scopri di più su Brute Force →

2 Attacco dizionario

Concezione : Testare ogni parola nel dizionario

Formule : rang = taille_dictionnaire

Molto efficace per Parole umane

Scopri di più su Dictionary Attack →

3 Attacco ibrido

Concezione : Dizionario Word + semplici mutazioni

Formule : rang = taille_dictionnaire × nombre_mutations (~1000)

Molto efficace per : dizionario parole + piccole modifiche

Scopri di più su Attacco ibrido →

4 Attacco della maschera

Concezione : Test strutture prevedibili

Molto efficace per : strutture umane (Name2024♪ Password!)

Scopri di più su Mask Attack →

5 Modello di Markov

Concezione : Approccio statistico basato sulle frequenze n-gram

Molto efficace per Parole umane — ridotto di ~99%

Scopri di più su Markov Model →

6 PCF

Concezione : Modello grammaticale che impara le strutture

Esempio reale

Password123 :

  • Forza bruta: 62¹¹ ≈ 5 × 10¹⁹ tentativi
  • PCFG: la sua struttura (1 maiuscola + 7 minuscole + 3 cifre) è tra le più frequenti, quindi PCFG la prova molto presto

Scopri di più su PCFG →

7 Attacco combinato

Concezione : Concatenazione di 2+ parole del dizionario

Molto efficace per : passphrases (4+ parole)

Scopri di più su Combiner Attack →

I 6 algoritmi hash

Perche' sei?

Time2Crack mostra tempi di crepa per i 6 per mostrare l'impatto della scelta dell'algoritmo.

MD5 (DEPRECTED)

SHA-1 (DEPRECTED)

SHA-256 (ACCETTABILE)

NTl LAVORATORI

bcrypt (RECOMMENDED)

Argon2id (migliore)

Gli algoritmi moderni sono intenzionalmente lentoMD5 è veloce (cattivo), bcrypt è lento (ottimo), Argon2id è anche più lento (migliore).

Profili attaccanti

Concezione

Diversi attaccanti hanno diverse risorse. Time2Crack modelli 4 profili:

Profilo GPUs NT1 Utilizzare i casi
Amatoriali 1 340 GH/s Hobbyist Hackers
Esperienza 12 4.08 TH/s Cracker seri
Professionista - 100. 34.0 TH/s Aziende, cluster AWS
Nazione di Stato - 10k 3.40 PH/s Governi

Impatto concreto

Esempio: una password di rango 10¹², con hash SHA-256

  • Amatoriale: 36 secondi
  • Esperto: 3 secondi
  • Professionista: 0,36 secondi
  • Stato-nazione: 3,6 millisecondi

Istruzione : Anche una password "forte" può essere decifrata in millisecondi da una nazione-stato!

Esempio concreto: Tr0ub4dor&3

È la password del fumetto xkcd «Password Strength» (n. 936), lo stesso che ha reso famosa «correct horse battery staple». Vediamo cosa ne fa Time2Crack:

Passo 1: Analisi

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

Fase 2: preventivo casuale

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

Passo 3: Conversione al Tempo

Risultati per 50 miliardi di tentativi

  • MD5 : 0,019 secondi
  • SHA-256 0,15 secondi
  • b. 3.8 ore
  • Argon2id 1,6 anni

Conclusioni

Domande frequenti

D: Time2Crack effettivamente testare la password?

No.. Time2Crack non invia Mai la password di un server.

Scopri di più sulla nostra politica sulla privacy →

D: Da dove vengono i numeri di velocità GPU?

benchmark ufficiali Hashcat (v6.2.6) su RTX 5090:

D: Perché Argon2id è così lento?

E' intenzionale.. Argon2id è progettato per essere lento, memoria-hard, e difficile da parallelizzare, questo costringe gli attaccanti a utilizzare un sacco di risorse.

D: Possiamo migliorare una password "safe" al 100%?

No.Anche la password migliore può essere rubata o indovinata. Strategia difensiva :

D: Come posso migliorare la mia password?

Regole semplici :

Conclusioni

Time2Crack funziona in 3 passi immutabili :

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

Innovazione chiave : Separazione rigorosa tra riga (attacco) e tempo (GPU), permettendo:

Risultato : Stime precisione precisa♪ Offline♪ multilingue tempo per rompere una password.

↑ Torna all'inizio