Cracken

Cracken é um gerador rápido de wordlists de senhas, criação de Smartlists e ferramenta de análise de máscaras híbridas de senhas escrito em Rust puro e seguro (mais em [talk/][talk]). Inspirado por ferramentas excelentes como [maskprocessor][mp], [hashcat][hashcat], [Crunch][crunch] e os [tokenizers][tokenizers] da 🤗 HuggingFace.

O quê? Porquê? Woot??

No [DeepSec2021][talk-abstract] apresentamos um novo método para analisar senhas como Máscaras Híbridas explorando substrings comuns em senhas utilizando tokenizadores de PLN (mais informações em [talk/][talk]).

Nosso método divide uma senha em suas subpalavras em vez de apenas uma máscara de caracteres. HelloWorld123! dividido em ['Hello', 'World', '123!'], já que essas três subpalavras são muito comuns em outras senhas.

Máscaras Híbridas & Smartlists

• 📄 Smartlists - Listas compactas e representativas de subpalavras criadas a partir de senhas utilizando tokenizadores de PLN
• 🎭 Máscara Híbrida - Uma representação de uma senha como combinação de wordlists e caracteres (ex.: ?w1?w2?l?d)

Analisando Senhas do RockYou com Smartlists e Máscaras Híbridas:

tabela completa aqui

Cracken 🐙 é usado para:

• ✅ Gerar Máscaras Híbridas MUITO RÁPIDO 🦸⚡💨 (veja secção desempenho)
• ✅ Construir Smartlists - lista compacta e representativa de subpalavras a partir de determinados ficheiros de senhas (usando 🤗 HuggingFace's [tokenizers][tokenizers])
• ✅ Analisar senhas para suas Máscaras Híbridas - construir estatísticas para melhores candidatos a senhas (novamente muito rápido)

Possíveis fluxos de trabalho com Cracken:

Simples:

1. Gerar candidatos a wordlist a partir de uma máscara híbrida - ex.: cracken -w rockyou.txt -w 100-most-common.txt '?w1?w2?d?d?d?d?s'
2. Pode canalizar as senhas geradas pelo Cracken para hashcat, john ou seu quebrador de senhas favorito

Avançado:

1. Criar uma Smartlist a partir de senhas existentes - cracken create
2. Analisar uma lista de senhas em texto simples - cracken entropy
3. Usar as Máscaras Híbridas mais frequentes para gerar candidatos a senhas rapidamente - cracken generate -i hybrid-masks.txt

Para mais detalhes veja secção Uso

Começando

descarregue (apenas linux atualmente): [última versão 🔗][releases]

para mais opções de instalação veja secção instalação

execute Cracken:

gerar todas as palavras de comprimento 8 começando com maiúscula seguidas de 6 minúsculas e depois um dígito:

$ cracken -o pwdz.lst '?u?l?l?l?l?l?l?d'

gerar palavras a partir de duas wordlists com sufixo de ano (1000-2999) <primeiro_nome><ultimo_nome><ano>

$ cracken --wordlist firstnames.txt --wordlist lastnames.lst --charset '12' '?w1?w2?1?d?d?d'

criar uma Smartlist de tamanho 50k a partir de subpalavras extraídas de rockyou.txt

$ cracken create -f rockyou.txt -m 50000 --smartlist smart.lst

estimar a entropia da máscara híbrida da senha HelloWorld123! usando uma smartlist

$ cracken entropy -f smart.lst 'HelloWorld123!'

hybrid-min-split: ["hello", "world1", "2", "3", "!"]
hybrid-mask: ?w1?w1?d?d?s
hybrid-min-entropy: 42.73
--
charset-mask: ?l?l?l?l?l?l?l?l?l?l?d?d?d?s
charset-mask-entropy: 61.97

Desempenho

No momento em que escrevo, Cracken é provavelmente o gerador de wordlists mais rápido do mundo:

Cracken tem cerca de 25% de aumento de desempenho em relação ao rápido [maskprocessor][mp] do hashcat escrito em C.

Cracken pode gerar cerca de 2 GB/s por núcleo.

mais detalhes em benchmarks/ 🔗

Por que a velocidade é importante? Uma GPU típica pode testar milhares de milhões de senhas por segundo, dependendo da função hash da senha. Quando o gerador de wordlists produz menos palavras por segundo do que a ferramenta de cracking consegue manipular - a velocidade de cracking degrada.

Desempenho da Análise de Máscaras Híbridas

Cracken usa o algoritmo A* para analisar senhas muito rapidamente. Pode encontrar a Máscara Híbrida mínima de um ficheiro de senhas a uma taxa de ~100k Senhas/seg (cracken entropy -f words1.txt -f words2.txt ... -p pwds.txt)

Instalação

instalar Cracken ou compilar a partir do código fonte

Descarregar Binário (Apenas Linux Atualmente)

descarregue a última versão de [releases 🔗][releases]

Construir a Partir do Código Fonte (Todas as Plataformas)

Cracken é escrito em Rust e precisa de rustc para ser compilado. Cracken deve suportar todas as plataformas que Rust suporta.

instruções de instalação para [cargo 🔗][rustc-installation]

existem duas opções para construir a partir do código fonte - instalar com cargo a partir do crates.io (preferido) ou compilar manualmente a partir do código fonte.

1. Instalar a partir do crates.io (preferido)

instalar com cargo:

$ cargo install cracken

2. Construir a partir do código fonte

clonar Cracken:

$ git clone https://github.com/shmuelamar/cracken

construir Cracken:

$ cd cracken
$ cargo build --release

executá-lo:

$ ./target/release/cracken --help

Informação de Uso

$ cracken --help
Cracken v1.0.0 - um gerador rápido de wordlists de senhas 

USO:
    cracken [SUBCOMANDO]

FLAGS:
    -h, --help       Imprime informação de ajuda
    -V, --version    Imprime informação de versão

SUBCOMANDOS:
    generate    (padrão) - Gera palavras separadas por nova linha de acordo com a máscara e ficheiros de wordlist fornecidos
    create      Criar uma nova smartlist a partir de ficheiro(s) de entrada
    entropy     
                Calcula a entropia estimada de uma senha ou ficheiro de senhas.
                A entropia de uma senha é o log2(tamanho(keyspace)) da senha.
                
                Existem dois tipos de estimativas de tamanho do keyspace:
                  * mask - keyspace de cada caractere (dígito=10, minúsculas=26...).
                  * hybrid - encontrar a divisão mínima em subpalavras e conjuntos de caracteres.


Para ajuda específica de um subcomando execute: cracken <subcomando> --help


Exemplos de Uso:

  ## Exemplos do Subcomando Generate:

  # todos os dígitos de 00000000 a 99999999
  cracken ?d?d?d?d?d?d?d?d

  # todos os dígitos de 0 a 99999999
  cracken -m 1 ?d?d?d?d?d?d?d?d

  # palavras com prefixo pwd - pwd0000 a pwd9999
  cracken pwd?d?d?d?d

  # todas as senhas de comprimento 8 começando com maiúscula, depois 6 minúsculas, depois dígito
  cracken ?u?l?l?l?l?l?l?d

  # igual ao anterior, escreve saída em pwds.txt em vez do stdout
  cracken -o pwds.txt ?u?l?l?l?l?l?l?d

  # conjunto de caracteres personalizado - todos os valores hexadecimais
  cracken -c 0123456789abcdef '?1?1?1?1'

  # 4 conjuntos de caracteres personalizados - a ordem determina o id do conjunto
  cracken -c 01 -c ab -c de -c ef '?1?2?3?4'

  # 4 caracteres minúsculos com sufixo de anos 2000-2019
  cracken -c 01 '?l?l?l?l20?1?d'

  # começa com primeiro nome de uma wordlist seguido de 4 dígitos
  cracken -w firstnames.txt '?w1?d?d?d?d'