Creación Avanzada de Reglas para John the Ripper

Kali LinuxBeginner
Practicar Ahora

Introducción

En este laboratorio, profundizarás en las capacidades avanzadas del motor de reglas de John the Ripper. John the Ripper es una potente herramienta para descifrar contraseñas, y su motor de reglas permite ataques altamente personalizados y eficientes. Comprender cómo crear reglas efectivas es crucial para maximizar su potencial. Aprenderás sobre la encadenación de reglas, la creación de reglas para transformaciones comunes como Leet Speak, el desarrollo de reglas para patrones de contraseñas típicos, la prueba de conjuntos de reglas complejos y la optimización del rendimiento de las reglas. Al final de este laboratorio, tendrás una sólida comprensión de cómo aprovechar el motor de reglas de John the Ripper para escenarios de descifrado de contraseñas más sofisticados.

Comprender la Encadenación de Reglas

En este paso, aprenderás sobre la encadenación de reglas en John the Ripper. La encadenación de reglas te permite combinar múltiples reglas para crear transformaciones más complejas. Esto es particularmente útil cuando necesitas aplicar una secuencia de modificaciones a una entrada de la lista de palabras.

Primero, asegúrate de que John the Ripper esté instalado. Si no lo está, puedes instalarlo usando apt.

sudo apt update
sudo apt install -y john

A continuación, crearemos un archivo de lista de palabras simple llamado wordlist.txt en tu directorio ~/project.

echo "password" > ~/project/wordlist.txt
echo "secret" >> ~/project/wordlist.txt

Ahora, creemos un archivo de reglas llamado chain_rules.rule en ~/project que demuestre la encadenación básica de reglas. Esta regla primero agregará "123" a la palabra y luego capitalizará la primera letra.

nano ~/project/chain_rules.rule

Agrega el siguiente contenido al archivo chain_rules.rule:

: A123 c
  • : (dos puntos) indica el inicio de una regla.
  • A123 agrega "123" al final de la palabra.
  • c capitaliza la primera letra de la palabra.

Guarda el archivo presionando Ctrl+X, luego Y, luego Enter.

Ahora, usemos John the Ripper con este archivo de reglas. Usaremos la opción --stdout para ver las palabras transformadas sin descifrar contraseñas.

john --wordlist=~/project/wordlist.txt --rules=~/project/chain_rules.rule --stdout

Deberías ver una salida similar a esta:

Password123
Secret123

Esto demuestra cómo se encadenan las reglas: A123 se aplica primero, y luego c se aplica al resultado.

Crear Reglas para Transformaciones de Leet Speak

En este paso, crearás reglas para realizar transformaciones de Leet Speak. Leet Speak (o "1337 Speak") es una práctica común donde las letras se reemplazan por números o símbolos que se les parecen (por ejemplo, 'a' se convierte en '4', 'e' se convierte en '3', 's' se convierte en '5'). Esta es una técnica frecuente utilizada en contraseñas.

Crearemos un nuevo archivo de reglas llamado leet_rules.rule en tu directorio ~/project. Este archivo contendrá reglas para convertir letras comunes a sus equivalentes de Leet Speak.

nano ~/project/leet_rules.rule

Agrega el siguiente contenido al archivo leet_rules.rule:

: s/a/4 s/e/3 s/i/1 s/o/0 s/s/5
  • s/old/new es una regla de sustitución. Reemplaza la primera ocurrencia de old con new.
  • Estamos encadenando múltiples reglas de sustitución para aplicar varias transformaciones de Leet Speak.

Guarda el archivo presionando Ctrl+X, luego Y, luego Enter.

Ahora, probemos estas reglas con nuestro wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/leet_rules.rule --stdout

Deberías ver una salida similar a esta:

p4ssw0rd
s3cr3t

Esto demuestra cómo puedes crear reglas para manejar variaciones comunes de Leet Speak, lo que puede mejorar significativamente la efectividad de tus esfuerzos de descifrado de contraseñas contra usuarios que emplean estas sustituciones.

Desarrollar Reglas para Patrones Comunes de Contraseñas

En este paso, desarrollarás reglas que se dirigen a patrones comunes de contraseñas, como agregar años o números comunes, o capitalizar la primera letra. Estos patrones son utilizados frecuentemente por los usuarios para hacer sus contraseñas "más fuertes" sin aumentar realmente su entropía.

Creemos un nuevo archivo de reglas llamado pattern_rules.rule en tu directorio ~/project. Este archivo combinará varias transformaciones comunes.

nano ~/project/pattern_rules.rule

Agrega el siguiente contenido al archivo pattern_rules.rule:

: c A2023
: c A!
: c A@
  • c capitaliza la primera letra.
  • A2023 agrega el año "2023".
  • A! agrega un signo de exclamación.
  • A@ agrega un símbolo arroba.

Cada línea representa una regla separada. John the Ripper aplicará cada regla a cada palabra de la lista de palabras de forma independiente.

Guarda el archivo presionando Ctrl+X, luego Y, luego Enter.

Ahora, probemos estas reglas con nuestro wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/pattern_rules.rule --stdout

Deberías ver una salida similar a esta:

Password2023
Secret2023
Password!
Secret!
Password@
Secret@

Esto demuestra cómo puedes crear un conjunto de reglas para cubrir patrones comunes de contraseñas, expandiendo significativamente tu superficie de ataque más allá de las simples palabras de diccionario.

Probar Conjuntos de Reglas Complejos

En este paso, combinarás los conceptos aprendidos hasta ahora para probar un conjunto de reglas más complejo. Esto implica crear un archivo de reglas que incorpore tanto transformaciones de Leet Speak como adiciones de patrones comunes, demostrando cómo se pueden usar múltiples tipos de reglas juntas.

Creemos un archivo de reglas completo llamado complex_rules.rule en tu directorio ~/project. Este archivo incluirá sustituciones de Leet Speak y luego agregará números o símbolos comunes.

nano ~/project/complex_rules.rule

Agrega el siguiente contenido al archivo complex_rules.rule:

: s/a/4 s/e/3 s/i/1 s/o/0 s/s/5 A123
: s/a/4 s/e/3 s/i/1 s/o/0 s/s/5 A!
  • La primera regla aplica Leet Speak y luego agrega "123".
  • La segunda regla aplica Leet Speak y luego agrega "!".

Guarda el archivo presionando Ctrl+X, luego Y, luego Enter.

Ahora, probemos estas reglas complejas con nuestro wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/complex_rules.rule --stdout

Deberías ver una salida similar a esta:

p4ssw0rd123
s3cr3t123
p4ssw0rd!
s3cr3t!

Esto demuestra el poder de combinar diferentes tipos de reglas para generar una amplia gama de posibles candidatos a contraseñas, lo cual es esencial para un descifrado de contraseñas efectivo.

Optimizar el Rendimiento de las Reglas

En este paso, aprenderás sobre la optimización del rendimiento de las reglas. Si bien las reglas complejas son potentes, también pueden ser computacionalmente intensivas. John the Ripper proporciona mecanismos para optimizar la aplicación de reglas, principalmente al comprender el orden de las operaciones y evitar reglas redundantes.

Una forma de optimizar es asegurarse de que tus reglas sean lo más específicas posible y evitar generar candidatos innecesarios. Por ejemplo, si sabes que una contraseña siempre comenzará con una letra mayúscula, aplicar una regla que capitalice cada letra es ineficiente.

Considera el archivo complex_rules.rule del paso anterior. Cada regla aplica todas las sustituciones de Leet Speak antes de agregar algo. Si tuvieras muchas reglas de este tipo, repetir las sustituciones podría ser menos eficiente que aplicarlas una vez y luego ramificar. Sin embargo, para casos simples, encadenar dentro de una sola regla suele ser lo suficientemente eficiente.

Para conjuntos de reglas muy grandes o escenarios específicos, John the Ripper permite una sintaxis de reglas más avanzada y archivos de reglas externos. Para este laboratorio, nos centraremos en una comprensión conceptual de la optimización.

Una técnica de optimización común es filtrar tu lista de palabras o apuntar a patrones específicos con conjuntos de reglas separados y más pequeños en lugar de un único conjunto de reglas masivo y que lo abarque todo.

Demostremos un concepto de optimización simple creando una regla que solo se aplica si la palabra es más corta que una cierta longitud, utilizando la regla l (longitud). Esto puede evitar la aplicación de reglas complejas a palabras que ya son demasiado largas para ser contraseñas comunes.

Crea un nuevo archivo de reglas llamado optimized_rules.rule en tu directorio ~/project.

nano ~/project/optimized_rules.rule

Agrega el siguiente contenido al archivo optimized_rules.rule:

: l<10 s/e/3 A!
  • l<10 significa "solo aplica esta regla si la longitud de la palabra es menor a 10 caracteres".
  • s/e/3 sustituye 'e' por '3'.
  • A! agrega un signo de exclamación.

Guarda el archivo presionando Ctrl+X, luego Y, luego Enter.

Ahora, probemos esta regla con nuestro wordlist.txt.

john --wordlist=~/project/wordlist.txt --rules=~/project/optimized_rules.rule --stdout

Deberías ver una salida similar a esta:

s3cr3t!
p4ssw0rd!

Tanto "password" (8 caracteres) como "secret" (6 caracteres) tienen menos de 10 caracteres, por lo que la regla se aplica. Si tuvieras una palabra como "superlongpassword" (17 caracteres), esta regla no se aplicaría a ella, ahorrando así cómputo.

Comprender cómo aplicar selectivamente reglas basadas en condiciones como la longitud puede mejorar significativamente el rendimiento de tus intentos de descifrado al reducir el número de candidatos innecesarios generados.

Resumen

En este laboratorio, has adquirido una comprensión integral de la creación de reglas avanzadas para John the Ripper. Comenzaste explorando el encadenamiento de reglas (rule chaining), que permite transformaciones secuenciales. Luego aprendiste a crear reglas específicas para transformaciones comunes de Leet Speak y desarrollaste reglas para apuntar a patrones de contraseñas prevalentes. Además, practicaste la prueba de conjuntos de reglas complejos combinando diferentes tipos de reglas. Finalmente, se te introdujeron conceptos de optimización del rendimiento de las reglas, como el uso de reglas condicionales para reducir cálculos innecesarios. Estas habilidades son fundamentales para aprovechar eficazmente John the Ripper en escenarios del mundo real de auditoría y descifrado de contraseñas.