Cracken

Cracken est un générateur rapide de listes de mots de passe, un outil de création de Smartlist et d'analyse de masques hybrides de mots de passe écrit en Rust pur et sûr (plus d'infos dans [talk/][talk]). Inspiré par d'excellents outils comme [maskprocessor][mp], [hashcat][hashcat], [Crunch][crunch] et 🤗 HuggingFace [tokenizers][tokenizers].

Quoi ? Pourquoi ? Woot ??

Lors de [DeepSec2021][talk-abstract], nous avons présenté une nouvelle méthode pour analyser les mots de passe sous forme de masques hybrides exploitant les sous-chaînes communes dans les mots de passe à l'aide de tokenizers NLP (plus d'infos dans [talk/][talk]).

Notre méthode divise un mot de passe en ses sous-mots au lieu d'un simple masque de caractères. HelloWorld123! est divisé en ['Hello', 'World', '123!'] car ces trois sous-mots sont très courants dans d'autres mots de passe.

Masques hybrides et Smartlists

• 📄 Smartlists - Listes de sous-mots compactes et représentatives créées à partir de mots de passe à l'aide de tokenizers NLP
• 🎭 Masque hybride - Une représentation d'un mot de passe comme une combinaison de listes de mots et de caractères (par ex. ?w1?w2?l?d)

Analyse des mots de passe RockYou avec Smartlists et masques hybrides :

tableau complet ici

Cracken 🐙 est utilisé pour :

• ✅ Générer des masques hybrides très TRÈS RAPIDEMENT 🦸⚡💨 (voir section performance)
• ✅ Construire des Smartlists - liste compacte et représentative de sous-mots à partir de fichiers de mots de passe donnés (en utilisant 🤗 HuggingFace [tokenizers][tokenizers])
• ✅ Analyser les mots de passe pour leurs masques hybrides - construire des statistiques pour de meilleurs candidats de mots de passe (encore une fois très rapide)

Flux de travail possibles avec Cracken :

Simple :

1. Générer des candidats de liste de mots à partir d'un masque hybride - par ex. cracken -w rockyou.txt -w 100-most-common.txt '?w1?w2?d?d?d?d?s'
2. Vous pouvez diriger les mots de passe générés par Cracken vers hashcat, john ou votre craqueur de mots de passe préféré

Avancé :

1. Créer une Smartlist à partir de mots de passe existants - cracken create
2. Analyser une liste de mots de passe en clair - cracken entropy
3. Utiliser les masques hybrides les plus fréquents pour générer rapidement des candidats de mots de passe - cracken generate -i hybrid-masks.txt

Pour plus de détails, voir la section Usage

Pour commencer

téléchargement (linux seulement actuellement) : [dernière version 🔗][releases]

pour plus d'options d'installation, voir la section installation

exécuter Cracken :

générer tous les mots de longueur 8 commençant par une majuscule suivie de 6 minuscules puis d'un chiffre :

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

générer des mots à partir de deux listes de mots avec suffixe d'année (1000-2999) <prénom><nom><année>

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

créer une Smartlist de taille 50k à partir de sous-mots extraits de rockyou.txt

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

estimer l'entropie du masque hybride du mot de passe HelloWorld123! en utilisant une 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

Au moment de la rédaction, Cracken est probablement le générateur de listes de mots le plus rapide du monde :

Cracken offre environ 25% de performances supplémentaires par rapport au [maskprocessor][mp] rapide de hashcat écrit en C.

Cracken peut générer environ 2 Go/s par cœur.

plus de détails dans benchmarks/ 🔗

Pourquoi la vitesse est-elle importante ? Un GPU typique peut tester des milliards de mots de passe par seconde selon la fonction de hachage du mot de passe. Lorsque le générateur de listes de mots produit moins de mots par seconde que l'outil de craquage ne peut en traiter - la vitesse de craquage se dégradera.

Performance de l'analyse des masques hybrides

Cracken utilise l'algorithme A* pour analyser très rapidement les mots de passe. Il peut trouver le masque hybride minimal d'un fichier de mots de passe à un rythme d'environ ~100k mots de passe/s (cracken entropy -f words1.txt -f words2.txt ... -p pwds.txt)

Installation

installer Cracken ou compiler à partir des sources

Téléchargement du binaire (Linux seulement actuellement)

télécharger la dernière version depuis [releases 🔗][releases]

Compilation à partir des sources (toutes plateformes)

Cracken est écrit en Rust et a besoin de rustc pour être compilé. Cracken devrait supporter toutes les plateformes que Rust supporte.

instructions d'installation pour [cargo 🔗][rustc-installation]

il y a deux options pour construire à partir des sources - installer avec cargo depuis crates.io (recommandé) ou compiler manuellement à partir des sources.

1. installation depuis crates.io (recommandé)

installer avec cargo :

$ cargo install cracken

2. compilation à partir des sources

cloner Cracken :

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

compiler Cracken :

$ cd cracken
$ cargo build --release

l'exécuter :

$ ./target/release/cracken --help

Informations d'utilisation

$ cracken --help
Cracken v1.0.0 - a fast password wordlist generator 

USAGE:
    cracken [SUBCOMMAND]

FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information

SUBCOMMANDS:
    generate    (default) - Generates newline separated words according to given mask and wordlist files
    create      Create a new smartlist from input file(s)
    entropy     
                Computes the estimated entropy of password or password file.
                The entropy of a password is the log2(len(keyspace)) of the password.
                
                There are two types of keyspace size estimations:
                  * mask - keyspace of each char (digit=10, lowercase=26...).
                  * hybrid - finding minimal split into subwords and charsets.


For specific subcommand help run: cracken <subcommand> --help


Example Usage:

  ## Generate Subcommand Examples:

  # all digits from 00000000 to 99999999
  cracken ?d?d?d?d?d?d?d?d

  # all digits from 0 to 99999999
  cracken -m 1 ?d?d?d?d?d?d?d?d

  # words with pwd prefix - pwd0000 to pwd9999
  cracken pwd?d?d?d?d

  # all passwords of length 8 starting with upper then 6 lowers then digit
  cracken ?u?l?l?l?l?l?l?d

  # same as above, write output to pwds.txt instead of stdout
  cracken -o pwds.txt ?u?l?l?l?l?l?l?d

  # custom charset - all hex values
  cracken -c 0123456789abcdef '?1?1?1?1'

  # 4 custom charsets - the order determines the id of the charset
  cracken -c 01 -c ab -c de -c ef '?1?2?3?4'

  # 4 lowercase chars with years 2000-2019 suffix
  cracken -c 01 '?l?l?l?l20?1?d'