Como Time2Crack calcula o tempo de fissuração
Guia completo de operações científicas e técnicas
Visão geral
Time2Crack responde a uma pergunta simples: "Quanto tempo levaria para decifrar esta senha?"
A resposta envolve três etapas:
SENHA (ex.: "P@ssw0rd!")
↓
PASSO 1: Análise (deteção de padrões, entropia)
↓
PASSO 2: Número estimado de tentativas (posição)
↓
PASSO 3: Conversão em tempo (com base na velocidade da GPU)
↓
RESULTADO (ex.: "2 dias em GPU, NTLM")
Ponto crítico : Testes Time2Crack Nem por isso. A senha. matematicamente Quantas tentativas seriam necessárias com diferentes ataques.
Fluxo de cálculo principal
calcCrackTime(password, options) [core/calc.js]
│
├─ analyzePatterns(password)
│ └─ Devolve: { charset, entropy, patterns, flags, context }
│
├─ estimateRank(password, context)
│ ├─ rankBrute() → charset^length
│ ├─ rankDictionary() → dicionário + HIBP
│ ├─ rankHybrid() → dicionário + mutações
│ ├─ rankMask() → estruturas previsíveis
│ ├─ rankMarkov() → modelo probabilístico
│ ├─ rankPCFG() → gramática
│ ├─ rankCombinator() → combinação de palavras
│ └─ Devolve: { standard, optimistic, worst_case, best_attack }
│
└─ rankToAllSeconds(rank)
├─ Converte tentativas → segundos (velocidade da GPU)
└─ Devolve: { md5, sha1, sha256, ntlm, bcrypt, argon2 }
Arquitetura de duas camadas
A inovação chave da Time2Crack é separação estrita entre:
"Quantas tentativas?" — Não têm noção de tempo ou velocidade da GPU. Módulos: core/rank/*.js
"Quanto tempo?" — Converta tentativas em segundos. Módulo: core/time.js
Vantagem : A mudança do algoritmo de um ataque nunca afeta a lógica do tempo.
Passo 1: Análise de Senha
O que estamos a analisar?
Antes de calcular o tempo de crack, Time2Crack disseca a senha para detectar:
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
}
}
Os 8 tipos de detecção
1 Palavra do dicionário
Teste a senha contra palavras comuns de 50k-200k e suas variantes (mutações simples).
2 Senha comum (HIBP)
Teste contra as 1.000 senhas mais escapadas usando o k-anonimidade (apenas 5 primeiros caracteres SHA-1 enviados).
Verifique se sua senha foi hackeada →
3 Padrão do teclado
Detectar: qwerty, asdfgh, qazwsx, etc.
4 Sequência
Detectar: abc, 123, xyz, etc.
5 Data
Detectar: 2024, 12/25, 25-12-2024, etc.
6 Repetir
Detectar: aaaa, 1111, !!!, etc.
7 Estruturado
Detecta estruturas previsíveis: Name2024!, Passw0rd!
8 Frase
Detecta várias palavras concatenadas: correcthorsebatterystaple → [correct] + [horse] + [battery] + [staple]
Etapa 2: Estimativa de classificação (número de tentativas)
Conceito básico
A linha é: "Quantas senhas um ataque tem que testar antes de encontrá-lo?"
Exemplo
- Resistência bruta em vez
abc: 263 = 17.576 tentativas - Dicionário em vez
password: ~ 1 tentativa - PCFG em vez
Password123: ~1011 tentativas
Como escolher o ataque vencedor?
Time2Crack lança o 7 ataques paralelos e toma o melhor resultado:
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: Conversão para o Tempo
O conceito
Agora que sabemos que temos de rang tentativas, convertemo-nos para segundos :
Formule : temps (secondes) = log₁₀(rang) / log₁₀(taux_hachage)
Velocidades de movimento (GPU)
Time2Crack usa Velocidades verdadeiras Hashcat para 12× RTX 5090:
| Algoritmo | Velocidade | Salificação |
|---|---|---|
| MD5 | 2,63 TH/s | Não |
| SHA-1 | 837 GH/s | Não |
| SHA-256 | 332 GH/s | Não |
| NTLM | 4,08 TH/s | Não |
| bcrypt | 3.66 MH/s | Sim. |
| Argon2id | 1.000 H/s | Sim. |
Exemplo de conversão
Senha: "senha" (Rang: 1 milhão = 106)
Para MD5 (2.63 TH/s):
Temps = 10⁶ / (2.63×10¹²) = 0.38 µs
Para SHA-256 (332 GH/s):
Temps = 10⁶ / (3.32×10¹¹) = 3.0 µs
Para bcrypt (3.66 MH/s):
Temps = 10⁶ / (3.66×10⁶) = 0.27 s
Para Argon2id (1.000 H/s):
Temps = 10⁶ / 1 000 = 1 000 s ≈ 17 min
Os 7 ataques implementados
1 Força bruta
Conceito : Teste todas as combinações possíveis
Formule : rang = charset_size ^ length
Exemplo : abc → 263 = 17,576 tentativas
Muito eficaz para : senhas curtas e aleatórias
Saiba mais sobre Força Bruta →
2 Ataque do Dicionário
Conceito : Teste cada palavra no dicionário
Formule : rang = taille_dictionnaire
Muito eficaz para Palavras humanas
Saiba mais sobre o Ataque do Dicionário →
3 Ataque híbrido
Conceito : Dicionário Palavra + mutações simples
Formule : rang = taille_dictionnaire × nombre_mutations (~1000)
Muito eficaz para : palavras de dicionário + pequenas modificações
Saiba mais sobre o ataque híbrido →
4 Ataque de Máscara
Conceito : Testar estruturas previsíveis
Muito eficaz para : estruturas humanas (Name2024, Password!)
Saiba mais sobre Mask Attack →
5 Modelo Markov
Conceito : Abordagem estatística baseada em frequências de n-gram
Muito eficaz para Palavras humanas — espaço reduzido em ~99%
Saiba mais sobre Markov Model →
6 PCFG
Conceito : Modelo gramatical que aprende estruturas
Exemplo real
Password123 :
- Força bruta: 62¹¹ ≈ 5 × 10¹⁹ tentativas
- PCFG: a sua estrutura (1 maiúscula + 7 minúsculas + 3 algarismos) está entre as mais frequentes, por isso o PCFG testa-a muito cedo
7 Ataque de Combinador
Conceito : Concatenação de mais de 2 palavras do dicionário
Muito eficaz para : frases-passe (4+ palavras)
Os algoritmos de 6 hash
Porquê seis?
Diferentes algoritmos oferecem diferentes níveis de segurança. Time2Crack mostra tempos de crack para o 6 para mostrar o impacto da escolha do algoritmo.
MD5 (DEPRECTADO)
- Velocidade : 2,63 TH/s (muito rápido)
- Salificação Não
- Estado - Não utilizar
SHA-1 (DEPRECTADO)
- Velocidade : 837 GH/s
- Salificação Não
- Estado - Colisões encontradas (2017)
SHA-256 (ACEPTÁVEL)
- Velocidade : 332 GH/s
- Salificação : Geralmente sim
- Estado - Aceitável se com SALT + iteração
NTLM (LEGACY)
- Velocidade : 4,08 TH/s
- Estado - Usado no legado do Windows
bcrypt (RECOMENDADO)
- Velocidade 3.66 MH/s (intencionalmente lento)
- Salificação : SIM
- Estado * Excelente para a produção
Argon2id (Melhor)
- Velocidade 1.000 H/s (muito lento = muito seguro)
- Tipo : Híbrido (tempo + memória)
- Estado Melhor escolha moderna (NIST 2021)
Perfis do atacante
Conceito
Diferentes atacantes têm recursos diferentes. Time2Crack modelos 4 perfis:
| Perfil | GPUs | NTLM | Casos de uso |
|---|---|---|---|
| Amador | 1 | 340 GH/s | Hackers Hobbyist |
| Experiência | 12 | 4,08 TH/s | Bolachas secas |
| Profissional | ~100 | 28, 8 TH/ s | Empresas, grupos AWS |
| Nação do Estado | ~10k | 3,40 PH/s | Governos |
Impacto do betão
Exemplo: uma senha de posição 10¹², com hash SHA-256
- Amador: 36 segundos
- Experiente: 3 segundos
- Profissional: 0,36 segundos
- Estado-nação: 3,6 milissegundos
Educação : Mesmo uma senha "forte" pode ser rachada em milissegundos por um estado-nação!
Exemplo concreto: Tr0ub4dor&3
É a senha da tira xkcd “Password Strength” (n.º 936), a mesma que tornou famosa “correct horse battery staple”. Vejamos o que o Time2Crack faz com ela:
Passo 1: Análise
• length : 11 caractères • charset : 94 caractères • entropy : ~72 bits • dictionaryWord : FALSE • commonPassword : FALSE • maskLike : TRUE • looksPassphrase : FALSE
Passo 2: Estimativa de classificação
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: Conversão para o Tempo
Resultados para 50 bilhões de tentativas
- MD5 : 0.019 segundos
- SHA-256 0,15 segundos
- bcrypt 6. 3 horas
- Argon2id 1,6 anos
Conclusão
- • Seguro contra bcrypt/Argon2id (horas → anos)
Perguntas Mais Frequentes
P: O Time2Crack realmente testa a senha?
Não. O Time2Crack não envia Nunca sua senha para um servidor.
- Todos os cálculos são feitos Local no navegador
- Apenas chamada de rede: verificação HIBP usando k-anonymity
- Sem transmissão completa da senha
Saiba mais sobre nossa política de privacidade →
P: De onde vêm os números de velocidade da GPU?
Parâmetros de referência oficiais do Hashcat (v6.2.6) em RTX 5090:
- Medições laboratoriais
- Domínio público
- Alinhamento com sistemas de colmeia 2025
P: Por que Argon2id é tão lento?
É intencional.. Argon2id foi projetado para ser lento, difícil de paralelizar e difícil de ser paralelizado. Isso força os atacantes a usar muitos recursos.
P: Podemos melhorar uma senha 100% "segura"?
NãoMesmo a melhor senha pode ser roubada ou adivinhada. Estratégia de defesa :
- Boa senha (15+ caracteres aleatórios)
- Autenticação multifatorial
- Gerenciador de senhas
- Verificação de violações (Fui enganado)
Q: Como melhoro minha senha?
Regras simples :
- Comprimento : 15+ caracteres (maior que complexidade)
- Aleatório : Use o gerenciador de senhas
- Único : Senha diferente por site
- MFA : Activar a autenticação 2FA se possível
Conclusão
Time2Crack funciona em 3 passos imutáveis :
1. ANALYSE → Détecte patterns (dictionnaire, keyboard, etc.) 2. RANG → Estime tentatives nécessaires (7 attaques) 3. TEMPS → Convertit tentatives en secondes (GPU speeds)
Inovação-chave : Separação rígida entre linha (ataque) e tempo (GPU), permitindo:
- Fácil atualização das velocidades da GPU
- Fácil adição de novos ataques
- Arquitetura modular e testável
Resultado : Estimativa preciso, Desligado, multilingue Hora de decifrar uma senha.
↑ Voltar ao topo