Cracken

Cracken è un veloce generatore di wordlist di password, creazione di Smartlist e strumento di analisi ibrida-mask delle password scritto in puro Rust sicuro (maggiori informazioni su talk/). Ispirato da grandi strumenti come maskprocessor, hashcat, Crunch e 🤗 HuggingFace's tokenizers.

Cosa? Perché? Eh??

Al DeepSec2021 abbiamo presentato un nuovo metodo per analizzare le password come Hybrid-Masks sfruttando sottostringhe comuni nelle password utilizzando tokenizer NLP (maggiori informazioni in talk/).

Il nostro metodo suddivide una password nelle sue sottoparole invece di una semplice maschera di caratteri. HelloWorld123! suddiviso in ['Hello', 'World', '123!'] poiché queste tre sottoparole sono molto comuni in altre password.

Maschere ibride e Smartlist

📄 Smartlist - Elenchi compatti e rappresentativi di sottoparole creati da password utilizzando tokenizer NLP
🎭 Hybrid-Mask - Una rappresentazione di una password come combinazione di wordlist e caratteri (es. ?w1?w2?l?d)

Analisi delle password RockYou con Smartlist e Hybrid-Masks:

Top25 Hybrid Masks da RockYou

tabella completa qui

Cracken 🐙 è utilizzato per:

✅ Generare Hybrid-Masks MOLTO VELOCEMENTE 🦸⚡💨 (vedi sezione performance)
✅ Costruire Smartlist - elenco compatto e rappresentativo di sottoparole da file di password forniti (usando i 🤗 HuggingFace's tokenizers)
✅ Analizzare le password per le loro Hybrid-Masks - costruire statistiche per migliori candidati password (di nuovo molto veloce)

Possibili flussi di lavoro con Cracken:

Semplice:

Genera candidati wordlist da una hybrid mask - es. cracken -w rockyou.txt -w 100-most-common.txt '?w1?w2?d?d?d?d?s'
Puoi inviare tramite pipe le password generate da Cracken a hashcat, john o al tuo cracker di password preferito

Avanzato:

Crea una Smartlist da password esistenti - cracken create
Analizza un elenco di password in testo normale - cracken entropy
Usa le Hybrid-Masks più frequenti per generare rapidamente candidati password - cracken generate -i hybrid-masks.txt

Per maggiori dettagli consulta la sezione Utilizzo

Per iniziare

download (solo linux attualmente): ultima release 🔗

per altre opzioni di installazione vedi sezione installazione

esegui Cracken:

genera tutte le parole di lunghezza 8 che iniziano con maiuscolo seguite da 6 caratteri minuscoli e poi una cifra:

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

genera parole da due wordlist con suffisso anno (1000-2999) <nome><cognome><anno>

$ cracken --wordlist nomi.txt --wordlist cognomi.lst --charset '12' '?w1?w2?1?d?d?d'

crea una Smartlist di dimensione 50k da sottoparole estratte da rockyou.txt

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

stima l'entropia della hybrid mask della password HelloWorld123! usando una 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

Performance

Al momento della stesura, Cracken è probabilmente il generatore di wordlist più veloce al mondo:

risultati benchmark

Cracken ha un aumento di prestazioni di circa il 25% rispetto al veloce maskprocessor di hashcat, scritto in C.

Cracken può generare circa 2 GB/s per core.

maggiori dettagli su benchmarks/ 🔗

Perché la velocità è importante? Una GPU tipica può testare miliardi di password al secondo a seconda della funzione hash della password. Quando il generatore di wordlist produce meno parole al secondo rispetto a quanto il tool di cracking può gestire - la velocità di cracking diminuirà.

Performance dell'analisi Hybrid-Masks

Cracken utilizza l'algoritmo A* per analizzare le password molto velocemente. Può trovare la Hybrid-Mask minima di un file di password a una velocità di ~100k Password/sec (cracken entropy -f parole1.txt -f parole2.txt ... -p pwd.txt)

Installazione

Installa Cracken o compila dal sorgente

Scarica il binario (Solo Linux al momento)

Scarica l'ultima release da releases 🔗

Compila dal sorgente (Tutte le piattaforme)

Cracken è scritto in Rust e necessita di rustc per essere compilato. Cracken dovrebbe supportare tutte le piattaforme supportate da Rust.

istruzioni per l'installazione di cargo 🔗

ci sono due opzioni per compilare dal sorgente - installare con cargo da crates.io (preferito) o compilare manualmente dal sorgente.

1. Installa da crates.io (preferito)

installa con cargo:

$ cargo install cracken

2. Compila dal sorgente

clona Cracken:

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

compila Cracken:

$ cd cracken
$ cargo build --release

eseguilo:

$ ./target/release/cracken --help

Informazioni sull'uso

$ cracken --help
Cracken v1.0.0 - un veloce generatore di wordlist di password

USO:
    cracken [SUBCOMANDO]

FLAGS:
    -h, --help       Stampa le informazioni di aiuto
    -V, --version    Stampa le informazioni sulla versione

SUBCOMANDI:
    generate    (predefinito) - Genera parole separate da newline secondo la maschera e i file wordlist forniti
    create      Crea una nuova smartlist dal file(i) di input
    entropy     
                Calcola l'entropia stimata di una password o di un file di password.
                L'entropia di una password è log2(len(keyspace)) della password.
                
                Esistono due tipi di stime della dimensione del keyspace:
                  * mask - keyspace di ogni carattere (cifra=10, minuscolo=26...).
                  * hybrid - trova la suddivisione minima in sottoparole e charset.


Per l'aiuto specifico sui subcomandi esegui: cracken <subcomando> --help


Esempi di utilizzo:

  ## Esempi del Subcomando Generate:

  # tutte le cifre da 00000000 a 99999999
  cracken ?d?d?d?d?d?d?d?d

  # tutte le cifre da 0 a 99999999
  cracken -m 1 ?d?d?d?d?d?d?d?d

  # parole con prefisso pwd - da pwd0000 a pwd9999
  cracken pwd?d?d?d?d

  # tutte le password di lunghezza 8 che iniziano con maiuscolo seguite da 6 minuscole e poi una cifra
  cracken ?u?l?l?l?l?l?l?d

  # stesso comando di sopra, scrive l'output su pwds.txt invece che stdout
  cracken -o pwds.txt ?u?l?l?l?l?l?l?d

  # charset personalizzato - tutti i valori esadecimali
  cracken -c 0123456789abcdef '?1?1?1?1'

  # 4 charset personalizzati - l'ordine determina l'id del charset
  cracken -c 01 -c ab -c de -c ef '?1?2?3?4'

  # 4 caratteri minuscoli con suffisso anni 2000-2019
  cracken -c 01 '?l?l?l?l20?1?d'

  # inizia con nome da wordlist seguito da 4 cifre
  cracken -w nomi.txt '?w1?d?d?d?d'

  # inizia con nome da wordlist con cognome da wordlist che termina con simbolo
  cracken -w nomi.txt -w cognomi.txt -c '!@#$' '?w1?w2?1'

  # ripetizione di wordlist più volte e combinazione di charset
  cracken -w verbi.txt -w sostantivi.txt '?w1?w2?w1?w2?w2?d?d?d'


  ## Esempi del Subcomando Create Smartlists:

  # crea smartlist da singolo file in smart.txt
  cracken create -f rockyou.txt --smartlist smart.txt

  # crea smartlist da più file con più algoritmi di tokenizzazione
  cracken create -t bpe -t unigram -t wordpiece -f rockyou.txt -f password.txt -f wikipedia.txt --smartlist smart.txt

  # crea smartlist con lunghezza minima sottoparola di 3 e dimensione massima solo numeri di 6
  cracken create -f rockyou.txt --min-word-len 3 --numbers-max-size 6 --smartlist smart.txt


  ## Esempi del Subcomando Entropy:

  # stima dell'entropia di una password
  cracken entropy --smartlist vocab.txt 'helloworld123!'

  # stima dell'entropia di un file di password con entropia della maschera charset (predefinito è hybrid)
  cracken entropy --smartlist vocab.txt -t charset -p password.txt

  # stima dell'entropia di un file di password
  cracken entropy --smartlist vocab.txt -p password.txt

cracken-v1.0.0 linux-x86_64 compilatore: rustc 1.56.1 (59eed8a2a 2021-11-01)
maggiori informazioni su: https://github.com/shmuelamar/cracken

Informazioni sull'uso del Subcomando Generate

$ cracken generate --help
cracken-generate 
(predefinito) - Genera parole separate da newline secondo la maschera e i file wordlist forniti

USO:
    cracken generate [FLAGS] [OPZIONI] <maschera> --masks-file <maschere-file>

FLAGS:
    -h, --help       
            Stampa le informazioni di aiuto

    -s, --stats      
            stampa il numero di parole che questo comando genererà ed esce

    -V, --version    
            Stampa le informazioni sulla versione


OPZIONI:
    -c, --custom-charset <charset-personalizzato>...    
            charset personalizzato (stringa di caratteri). fino a 9 charset personalizzati - ?1 a ?9. usa ?1 nella maschera per il primo charset

    -i, --masks-file <file-maschere>               
            un file contenente le maschere da generare

    -x, --maxlen <lunghezza-massima>                   
            lunghezza massima della maschera da cui iniziare

    -m, --minlen <lunghezza-minima>                   
            lunghezza minima della maschera da cui iniziare

    -o, --output-file <file-output>             
            file di output in cui scrivere la wordlist, predefinito stdout

    -w, --wordlist <wordlist>...                
            nome del file contenente parole separate da newline (0xA). nota: attualmente tutte le wordlist vengono caricate in memoria


ARGOMENTI:
    <maschera>    
            la maschera della wordlist da generare.
            maschere disponibili:
                charset incorporati:
                ?d - cifre: "0123456789"
                ?l - minuscole: "abcdefghijklmnopqrstuvwxyz"
                ?u - maiuscole: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                ?s - simboli: " !\"\#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
                ?a - tutti i caratteri: ?d + ?l + ?u + ?s
                ?b - tutti i valori binari: (0-255)
            
                charset personalizzati ?1 a ?9:
                ?1 - primo charset personalizzato specificato da --charset 'miocharset'
            
                wordlist ?w1 a ?w9:
                ?w1 - prima wordlist specificata da --wordlist 'mia-wordlist.txt'

Informazioni sull'uso del Subcomando Create Smartlist

$ cracken create --help  
cracken-create 
Crea una nuova smartlist dal file(i) di input

USO:
    cracken create [FLAGS] [OPZIONI] --file <file>... --smartlist <smartlist>

FLAGS:
    -h, --help       Stampa le informazioni di aiuto
    -q, --quiet      disabilita la stampa della barra di avanzamento
    -V, --version    Stampa le informazioni sulla versione

OPZIONI:
    -f, --file <file>...                         nome del file di input, può essere specificato più volte per più file
        --min-frequency <frequenza_minima>          frequenza minima di una parola, rilevante solo per tokenizer BPE
    -l, --min-word-len <lunghezza_minima_parola>            filtra le parole più corte della lunghezza specificata
        --numbers-max-size <dimensione_massima_numeri>    filtra i numeri (solo cifre) più lunghi della dimensione specificata
    -o, --smartlist <smartlist>                  nome del file della smartlist di output
    -t, --tokenizer <tokenizer>...               tokenizer da utilizzare, può essere specificato più volte.
                                                 uno tra: bpe,unigram,wordpiece [default: bpe]  [possibili valori: bpe, unigram, wordpiece]
    -m, --vocab-max-size <dimensione_massima_vocabolario>        dimensione massima del vocabolario

Informazioni sull'uso del Subcomando Entropy

$ cracken entropy --help
cracken-entropy 

Calcola l'entropia stimata di una password o di un file di password.
L'entropia di una password è log2(len(keyspace)) della password.

Esistono due tipi di stime della dimensione del keyspace:
  * mask - keyspace di ogni carattere (cifra=10, minuscolo=26...).
  * hybrid - trova la suddivisione minima in sottoparole e charset.


USO:
    cracken entropy [FLAGS] [OPZIONI] <password> --smartlist <smartlist>...

FLAGS:
    -h, --help       Stampa le informazioni di aiuto
    -s, --summary    output riassuntivo dell'entropia per la password
    -V, --version    Stampa le informazioni sulla versione

OPZIONI:
    -t, --mask-type <tipo_maschera>              tipo di maschera da produrre, uno tra: charsets(solo charset), hybrid(charset+wordlist) [possibili valori: hybrid, charset]
    -p, --passwords-file <file_password>    file di password separato da newline per cui stimare l'entropia
    -f, --smartlist <smartlist>...           file di input smartlist con cui stimare l'entropia, un file di testo separato da newline

ARGOMENTI:
    <password>    password per cui

Licenza

Cracken è distribuito con licenza MIT. QUESTO PROGETTO DEVE ESSERE UTILIZZATO SOLO PER SCOPI LEGALI ⚖️

Contribuire

Cracken è in fase di sviluppo attivo, se desideri aiutare, di seguito è riportata la roadmap parziale per questo progetto. Sentiti libero di inviare PR e aprire issue.

cracken

Più Popolari