How Time2Crack calculates cracking time
Complete Guide to Scientific and Technical Operations
Overview
Time2Crack answers a simple question: "How long would it take to crack this password?"
The answer involves three steps:
PASSWORD (e.g. "P@ssw0rd!")
↓
STEP 1: Analysis (pattern detection, entropy)
↓
STEP 2: Estimated number of guesses (rank)
↓
STEP 3: Conversion to time (based on GPU speed)
↓
RESULT (e.g. "2 days on GPU, NTLM")
Critical point : Time2Crack testes Not really The password. mathematically how many attempts would be needed with different attacks.
Main calculation flow
calcCrackTime(password, options) [core/calc.js]
│
├─ analyzePatterns(password)
│ └─ Returns: { charset, entropy, patterns, flags, context }
│
├─ estimateRank(password, context)
│ ├─ rankBrute() → charset^length
│ ├─ rankDictionary() → dictionary + HIBP
│ ├─ rankHybrid() → dictionary + mutations
│ ├─ rankMask() → predictable structures
│ ├─ rankMarkov() → probabilistic model
│ ├─ rankPCFG() → grammar
│ ├─ rankCombinator() → word combinations
│ └─ Returns: { standard, optimistic, worst_case, best_attack }
│
└─ rankToAllSeconds(rank)
├─ Converts guesses → seconds (GPU speed)
└─ Returns: { md5, sha1, sha256, ntlm, bcrypt, argon2 }
Two-layer architecture
Time2Crack's key innovation is strict separation between:
"How many attempts?" — Have no notion of GPU time or speed. Modules: core/rank/*.js
"How long?" — Convert attempts into seconds. Module: core/time.js
Advantage : Changing the algorithm of an attack never affects the logic of time. Changing the GPU speed never affects attacks.
Step 1: Password Analysis
What are we analyzing?
Before calculating the crack time, Time2Crack dissects the password to detect:
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
}
}
The 8 types of detections
1 Dictionary Word
Test the password against 50k-200k common words and their variants (simple mutations).
2 Common password (HIBP)
Test against the 1,000 most escaped passwords using the k-anonymity (only 5 first SHA-1 characters sent).
Check if your password has been hacked →
3 Keyboard pattern
Detect: qwerty, asdfgh, qazwsx, etc.
4 Sequence
Detect: abc, 123, xyz, etc.
5 Date
Detect: 2024, 12/25, 25-12-2024, etc.
6 Repeat
Detect: aaaa, 1111, !!!, etc.
7 Structured
Detects foreseeable structures: Name2024!, Passw0rd!
8 Phrase
Detects several concatenated words: correcthorsebatterystaple → [correct] + [horse] + [battery] + [staple]
Step 2: Rank estimate (number of attempts)
Basic concept
The row is: "How many passwords does an attack have to test before you find it?"
Example
- Gross strength for
abc: 263 = 17,576 attempts - Dictionary for
password: ~1 attempt - PCFG for
Password123: ~1011 attempts
How to choose the winning attack?
Time2Crack launches the 7 parallel attacks and takes the best result:
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)
Step 3: Conversion to Time
The concept
Now that we know we have to rang attempts, we convert to seconds :
Formule : temps (secondes) = log₁₀(rang) / log₁₀(taux_hachage)
Hashing speeds (GPU)
Time2Crack uses true speeds Hashcat for 12× RTX 5090:
| Algorithm | Speed | Salification |
|---|---|---|
| MD5 | 2.63 TH/s | No |
| SHA-1 | 837 GH/s | No |
| SHA-256 | 332 GH/s | No |
| NTLM | 4.08 TH/s | No |
| bcrypt | 3.66 MH/s | Yes |
| Argon2id | 1,000 H/s | Yes |
Example of conversion
Password: "password" (Rang: 1 million = 106)
For MD5 (2.63 TH/s):
Temps = 10⁶ / (2.63×10¹²) = 0.38 µs
For SHA-256 (332 GH/s):
Temps = 10⁶ / (3.32×10¹¹) = 3.0 µs
For bcrypt (3.66 MH/s):
Temps = 10⁶ / (3.66×10⁶) = 0.27 s
For Argon2id (1,000 H/s):
Temps = 10⁶ / 1 000 = 1 000 s ≈ 17 min
The 7 attacks implemented
1 Gross Force
Concept : Test all possible combinations
Formule : rang = charset_size ^ length
Example : abc → 263 = 17,576 attempts
Very effective for : short and random passwords
Learn more about Brute Force →
2 Dictionary Attack
Concept : Test every word in the dictionary
Formule : rang = taille_dictionnaire
Very effective for Human words
Learn more about Dictionary Attack →
3 Hybrid Attack
Concept : Dictionary Word + simple mutations
Formule : rang = taille_dictionnaire × nombre_mutations (~1000)
Very effective for : dictionary words + small modifications
Learn more about Hybrid Attack →
4 Mask Attack
Concept : Test predictable structures
Very effective for : human structures (Name2024, Password!)
Learn more about Mask Attack →
5 Markov Model
Concept : Statistical approach based on n-gram frequencies
Very effective for Human words — reduced space by ~99%
Learn more about Markov Model →
6 PCFG
Concept : Grammatical model that learns structures
Real example
Password123 :
- Brute force: 62¹¹ ≈ 5 × 10¹⁹ attempts
- PCFG: its structure (1 uppercase + 7 lowercase + 3 digits) is among the most common, so PCFG tries it very early
7 Combiner Attack
Concept : Concatenation of 2+ dictionary words
Very effective for : passphrases (4+ words)
The 6 hash algorithms
Why six?
Different algorithms offer different levels of security. Time2Crack shows crack times for the 6 to show the impact of the algorithm choice.
MD5 (DEPRECTED)
- Speed : 2.63 TH/s (very fast)
- Salification No
- Status - Do not use
SHA-1 (DEPRECTED)
- Speed : 837 GH/s
- Salification No
- Status - Collisions found (2017)
SHA-256 (ACCEPTABLE)
- Speed : 332 GH/s
- Salification : Generally yes
- Status - Acceptable if with SALT + iteration
NTLM (LEGACY)
- Speed : 4.08 TH/s
- Status - Used in Windows legacy
bcrypt (RECOMMENDED)
- Speed 3.66 MH/s (intentionally slow)
- Salification : YES
- Status * Excellent for production
Argon2id (Better)
- Speed 1,000 H/s (very slow = very safe)
- Type : Hybrid (time + memory)
- Status Best modern choice (NIST 2021)
Attacker profiles
Concept
Different attackers have different resources. Time2Crack models 4 profiles:
| Profile | GPUs | NTLM | Use cases |
|---|---|---|---|
| Amateur | 1 | 340 GH/s | Hobbyist Hackers |
| Experienced | 12 | 4.08 TH/s | Serious crackers |
| Professional | ~100 | 34.0 TH/s | Companies, AWS clusters |
| State Nation | ~10k | 3.40 PH/s | Governments |
Concrete impact
Example: a password of rank 10¹², hashed with SHA-256
- Amateur: 36 seconds
- Experienced: 3 seconds
- Professional: 0.36 seconds
- Nation-state: 3.6 milliseconds
Education : Even a "strong" password can be cracked in milliseconds by a nation-state!
Concrete example: Tr0ub4dor&3
This is the password from the xkcd comic “Password Strength” (no. 936), which also made “correct horse battery staple” famous. Let’s see what Time2Crack does with it:
Step 1: Analysis
• length : 11 caractères • charset : 94 caractères • entropy : ~72 bits • dictionaryWord : FALSE • commonPassword : FALSE • maskLike : TRUE • looksPassphrase : FALSE
Step 2: Rank estimate
Brute Force : 94^11 ≈ 5 × 10^21 Dictionary : ∞ (pas dans dictionnaire) Mask : ≈ 1.4 trillion Markov : ≈ 10 trillion PCFG : ≈ 50 billion (GAGNANT) Combinator : ∞
Step 3: Conversion to Time
Results for 50 billion attempts
- MD5 : 0.019 seconds
- SHA-256 0.15 seconds
- bcrypt 3.8 hours
- Argon2id 1.6 years
Conclusion
- • Safe against bcrypt/Argon2id (hours → years)
Frequently Asked Questions
Q: Does Time2Crack actually test the password?
No. Time2Crack does not send Never your password to a server.
- All calculations are done Local in the browser
- Only network call: HIBP check using k-anonymity
- No full password transmission
Learn more about our privacy policy →
Q: Where do GPU speed numbers come from?
Official Hashcat benchmarks (v6.2.6) on RTX 5090:
- Laboratory measurements
- Public domain
- Alignment with Hive Systems 2025
Q: Why is Argon2id so slow?
It's intentional.. Argon2id is designed to be slow, memory-hard, and difficult to parallelize. This forces attackers to use a lot of resources.
Q: Can we improve a 100% "safe" password?
NoEven the best password can be stolen or guessed. Defensive strategy :
- Good password (15+ random characters)
- Multifactor authentication
- Password Manager
- Verification of breaches (Have I Been Pwned)
Q: How do I improve my password?
Simple rules :
- Length : 15+ characters (greater than complexity)
- Random : Use password manager
- Unique : Different password per site
- MFA : Enable 2FA authentication if possible
Conclusion
Time2Crack works in 3 immutable steps :
1. ANALYSE → Détecte patterns (dictionnaire, keyboard, etc.) 2. RANG → Estime tentatives nécessaires (7 attaques) 3. TEMPS → Convertit tentatives en secondes (GPU speeds)
Key Innovation : Rigorous separation between row (attack) and time (GPU), allowing:
- Easy update of GPU speeds
- Easy addition of new attacks
- Modular and testable architecture
Result : Estimate precise, Offline, multilingual time to crack a password.
↑ Back to top