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/). Inspirado por ferramentas excelentes como maskprocessor, hashcat, Crunch e os tokenizers da 🤗 HuggingFace.

O quê? Porquê? Woot??

No DeepSec2021 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/).

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:

Top25 Máscaras Híbridas do RockYou

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)
✅ 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:

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'
Pode canalizar as senhas geradas pelo Cracken para hashcat, john ou seu quebrador de senhas favorito

Avançado:

Criar uma Smartlist a partir de senhas existentes - cracken create
Analisar uma lista de senhas em texto simples - cracken entropy
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 🔗

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:

resultados de benchmarks

Cracken tem cerca de 25% de aumento de desempenho em relação ao rápido maskprocessor 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 🔗

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 🔗

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'

  # começa com primeiro nome de uma wordlist com último nome de uma wordlist terminando com símbolo
  cracken -w firstnames.txt -w lastnames.txt -c '!@#$' '?w1?w2?1'

  # repetir wordlists várias vezes e combinar conjuntos de caracteres
  cracken -w verbs.txt -w nouns.txt '?w1?w2?w1?w2?w2?d?d?d'


  ## Exemplos do Subcomando Create Smartlists:

  # criar smartlist a partir de um único ficheiro em smart.txt
  cracken create -f rockyou.txt --smartlist smart.txt

  # criar smartlist a partir de múltiplos ficheiros com múltiplos algoritmos de tokenização
  cracken create -t bpe -t unigram -t wordpiece -f rockyou.txt -f passwords.txt -f wikipedia.txt --smartlist smart.txt

  # criar smartlist com comprimento mínimo de subpalavra de 3 e tamanho máximo de subpalavras apenas numéricas de 6
  cracken create -f rockyou.txt --min-word-len 3 --numbers-max-size 6 --smartlist smart.txt


  ## Exemplos do Subcomando Entropy:

  # estimar entropia de uma senha
  cracken entropy --smartlist vocab.txt 'helloworld123!'

  # estimar entropia de um ficheiro de senhas com entropia de máscara de conjunto de caracteres (padrão é híbrido)
  cracken entropy --smartlist vocab.txt -t charset -p passwords.txt

  # estimar a entropia de um ficheiro de senhas
  cracken entropy --smartlist vocab.txt -p passwords.txt

cracken-v1.0.0 linux-x86_64 compilador: rustc 1.56.1 (59eed8a2a 2021-11-01)
mais informações em: https://github.com/shmuelamar/cracken

Informação de Uso do Subcomando Generate

$ cracken generate --help
cracken-generate 
(padrão) - Gera palavras separadas por nova linha de acordo com a máscara e ficheiros de wordlist fornecidos

USO:
    cracken generate [FLAGS] [OPÇÕES] <máscara> --masks-file <ficheiro-máscaras>

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

    -s, --stats      
            imprime o número de palavras que este comando irá gerar e sai

    -V, --version    
            Imprime informação de versão


OPÇÕES:
    -c, --custom-charset <custom-charset>...    
            conjunto de caracteres personalizado (string de caracteres). até 9 conjuntos - ?1 a ?9. use ?1 na máscara para o primeiro conjunto

    -i, --masks-file <masks-file>               
            um ficheiro contendo máscaras a gerar

    -x, --maxlen <max-length>                   
            comprimento máximo da máscara para começar

    -m, --minlen <min-length>                   
            comprimento mínimo da máscara para começar

    -o, --output-file <output-file>             
            ficheiro de saída para escrever a wordlist, predefinido para stdout

    -w, --wordlist <wordlist>...                
            nome do ficheiro contendo palavras separadas por nova linha (0xA). nota: atualmente todas as wordlists são carregadas na memória


ARGUMENTOS:
    <máscara>    
            a máscara da wordlist a gerar.
            máscaras disponíveis são:
                conjuntos de caracteres embutidos:
                ?d - dígitos: "0123456789"
                ?l - minúsculas: "abcdefghijklmnopqrstuvwxyz"
                ?u - maiúsculas: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                ?s - símbolos: " !\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
                ?a - todos os caracteres: ?d + ?l + ?u + ?s
                ?b - todos os valores binários: (0-255)
            
                conjuntos personalizados ?1 a ?9:
                ?1 - primeiro conjunto personalizado especificado por --charset 'mychars'
            
                wordlists ?w1 a ?w9:
                ?w1 - primeira wordlist especificada por --wordlist 'my-wordlist.txt'

Informação de Uso do Subcomando Create Smartlist

$ cracken create --help  
cracken-create 
Criar uma nova smartlist a partir de ficheiro(s) de entrada

USO:
    cracken create [FLAGS] [OPÇÕES] --file <ficheiro>... --smartlist <smartlist>

FLAGS:
    -h, --help       Imprime informação de ajuda
    -q, --quiet      desativa a exibição da barra de progresso
    -V, --version    Imprime informação de versão

OPÇÕES:
    -f, --file <ficheiro>...                         nome do ficheiro de entrada, pode ser especificado várias vezes para múltiplos ficheiros
        --min-frequency <frequência_mínima>          frequência mínima de uma palavra, relevante apenas para tokenizador BPE
    -l, --min-word-len <comprimento_mínimo_palavra>            filtra palavras mais curtas que o comprimento especificado
        --numbers-max-size <tamanho_máximo_números>    filtra números (apenas dígitos) mais longos que o tamanho especificado
    -o, --smartlist <smartlist>                  nome do ficheiro smartlist de saída
    -t, --tokenizer <tokenizador>...               tokenizador a usar, pode ser especificado várias vezes.
                                                 um de: bpe,unigram,wordpiece [padrão: bpe]  [valores possíveis: bpe, unigram, wordpiece]
    -m, --vocab-max-size <tamanho_máximo_vocab>        tamanho máximo do vocabulário

Informação de Uso do Subcomando Entropy

$ cracken entropy --help
cracken-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.


USO:
    cracken entropy [FLAGS] [OPÇÕES] <senha> --smartlist <smartlist>...

FLAGS:
    -h, --help       Imprime informação de ajuda
    -s, --summary    apresentar resumo da entropia para a senha
    -V, --version    Imprime informação de versão

OPÇÕES:
    -t, --mask-type <tipo_máscara>              tipo de máscara a apresentar, um de: charsets(apenas conjuntos de caracteres), hybrid(conjuntos de caracteres+wordlists) [valores possíveis: hybrid, charset]
    -p, --passwords-file <ficheiro-senhas>    ficheiro de senhas separado por nova linha para estimar entropia
    -f, --smartlist <smartlist>...           ficheiro smartlist de entrada para estimar entropia, um ficheiro de texto separado por nova linha

ARGUMENTOS:
    <senha>    senha para

Licença

Cracken está licenciado sob MIT. ESTE PROJETO DEVE SER USADO APENAS PARA FINS LEGAIS ⚖️

Contribuição

Cracken está em desenvolvimento ativo, se deseja ajudar, abaixo está o roadmap parcial para este projeto. Sinta-se à vontade para submeter PRs e abrir issues.

cracken

Mais Populares