Cracken

Cracken es un rápido generador de listas de palabras, creador de smartlists y herramienta de análisis de máscaras híbridas para contraseñas, escrito en Rust puro y seguro (más información en [talk/][talk]). Inspirado por grandes herramientas como [maskprocessor][mp], [hashcat][hashcat], [Crunch][crunch] y los 🤗 [tokenizers][tokenizers] de HuggingFace.

¿Qué? ¿Por qué? ¿¿Cómo??

En [DeepSec2021][talk-abstract] presentamos un nuevo método para analizar contraseñas como Máscaras Híbridas, explotando subcadenas comunes en contraseñas mediante tokenizadores NLP (más información en [talk/][talk]).

Nuestro método divide una contraseña en sus subpalabras en lugar de solo una máscara de caracteres. HelloWorld123! dividido en ['Hello', 'World', '123!'] ya que estas tres subpalabras son muy comunes en otras contraseñas.

Máscaras Híbridas y Smartlists

• 📄 Smartlists - Listas compactas y representativas de subpalabras creadas a partir de contraseñas mediante tokenizadores NLP.
• 🎭 Máscara Híbrida - Representación de una contraseña como combinación de listas de palabras y caracteres (ej. ?w1?w2?l?d)

Analizando contraseñas de RockYou con Smartlists y Máscaras Híbridas:

tabla completa aquí

Cracken 🐙 se utiliza para:

• ✅ Generar Máscaras Híbridas MUY MUY RÁPIDO 🦸⚡💨 (ver sección rendimiento)
• ✅ Construir Smartlists - lista compacta y representativa de subpalabras a partir de archivos de contraseñas (usando [tokenizers][tokenizers] de 🤗 HuggingFace)
• ✅ Analizar contraseñas para sus Máscaras Híbridas - construir estadísticas para mejores candidatos a contraseña (nuevamente muy rápido)

Posibles flujos de trabajo con Cracken:

Simple:

1. Generar candidatos de lista de palabras a partir de una máscara híbrida - ej. cracken -w rockyou.txt -w 100-most-common.txt '?w1?w2?d?d?d?d?s'
2. Puedes canalizar las contraseñas que genera Cracken a hashcat, john o tu crackeador de contraseñas favorito.

Avanzado:

1. Crear una Smartlist a partir de contraseñas existentes - cracken create
2. Analizar una lista de contraseñas en texto plano - cracken entropy
3. Usar las Máscaras Híbridas más frecuentes para generar candidatos a contraseña rápidamente - cracken generate -i hybrid-masks.txt

Para más detalles, ver sección Uso

Primeros pasos

descarga (solo linux por ahora): [última versión 🔗][releases]

Para más opciones de instalación, ver sección instalación

ejecuta Cracken:

generar todas las palabras de longitud 8 que comienzan con mayúscula seguidas de 6 minúsculas y luego un dígito:

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

generar palabras a partir de dos listas de palabras con sufijo de año (1000-2999) <nombre><apellido><año>

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

crear una Smartlist de tamaño 50k a partir de subpalabras extraídas de rockyou.txt

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

estimar la entropía de la máscara híbrida de la contraseña 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

Rendimiento

Al momento de escribir esto, Cracken es probablemente el generador de listas de palabras más rápido del mundo:

Cracken tiene alrededor de un 25% de rendimiento superior sobre el rápido [maskprocessor][mp] de hashcat, escrito en C.

Cracken puede generar alrededor de 2 GB/s por núcleo.

más detalles en benchmarks/ 🔗

¿Por qué es importante la velocidad? Una GPU típica puede probar miles de millones de contraseñas por segundo dependiendo de la función hash de la contraseña. Cuando el generador de listas de palabras produce menos palabras por segundo de las que la herramienta de cracking puede manejar, la velocidad de cracking se degrada.

Rendimiento del análisis de Máscaras Híbridas

Cracken usa el algoritmo A* para analizar contraseñas muy rápidamente. Puede encontrar la Máscara Híbrida mínima de un archivo de contraseñas a una tasa de ~100k contraseñas/segundo (cracken entropy -f words1.txt -f words2.txt ... -p pwds.txt)

Instalación

instala Cracken o compila desde el código fuente

Descargar binario (solo Linux por ahora)

descarga la última versión desde [releases 🔗][releases]

Compilar desde código fuente (todas las plataformas)

Cracken está escrito en Rust y necesita rustc para compilarse. Cracken debería funcionar en todas las plataformas que Rust soporta.

instrucciones de instalación para [cargo 🔗][rustc-installation]

hay dos opciones para compilar desde código fuente: instalar con cargo desde crates.io (preferido) o compilar manualmente desde el código fuente.

1. Instalar desde crates.io (preferido)

instalar con cargo:

$ cargo install cracken

2. Compilar desde el código fuente

clonar Cracken:

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

compilar Cracken:

$ cd cracken
$ cargo build --release

ejecutarlo:

$ ./target/release/cracken --help

Información de Uso

$ 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'

  # starts with firstname from wordlist followed by 4 digits
  cracken -w firstnames.txt '?w1?d?d?d?d'