Aplicar reglas a listas de palabras para descifrado avanzado

Introducción

En este laboratorio, explorará las potentes capacidades de cracking basadas en reglas de John the Ripper (JtR). Si bien los ataques de diccionario simples son efectivos, las contraseñas del mundo real a menudo implican variaciones como mayúsculas/minúsculas, números añadidos o caracteres especiales. El motor de reglas de JtR le permite definir transformaciones complejas para aplicar a las palabras de una lista de palabras (wordlist), aumentando significativamente las posibilidades de descifrar contraseñas que no están directamente presentes en el diccionario. Aprenderá la sintaxis básica de las reglas de JtR, creará sus propias reglas personalizadas y las aplicará a una lista de palabras para ver su efecto.

Comprender la sintaxis de reglas de John the Ripper

En este paso, aprenderá la sintaxis básica de las reglas de John the Ripper (JtR). Las reglas de JtR se definen en un archivo de configuración, típicamente john.conf, o se pueden pasar directamente a través de la línea de comandos para casos simples. Cada regla es una secuencia de comandos de un solo carácter que modifican una palabra.

Los comandos de reglas comunes incluyen:

• c: Capitalizar la primera letra.
• C: Capitalizar todas las letras.
• l: Convertir la primera letra a minúscula.
• L: Convertir todas las letras a minúscula.
• t: Cambiar mayúsculas/minúsculas de la primera letra.
• T: Cambiar mayúsculas/minúsculas de todas las letras.
• p<N>: Añadir el carácter <N> al principio (prepend).
• a<N>: Añadir el carácter <N> al final (append).
• s<old><new>: Sustituir la primera ocurrencia de <old> por <new>.
• S<old><new>: Sustituir todas las ocurrencias de <old> por <new>.
• x<N>: Extraer una subcadena de longitud N desde el principio.
• z<N>: Extraer una subcadena de longitud N desde el final.
• D: Eliminar el primer carácter.
• M: Eliminar el último carácter.
• r: Invertir la palabra.

Comencemos viendo el archivo john.conf por defecto para ver algunos ejemplos de reglas integradas.

Abra el archivo john.conf usando nano:

nano /etc/john/john.conf

Desplácese por el archivo para encontrar la sección [List.Rules:Wordlist]. Verá varios conjuntos de reglas definidos allí. Por ejemplo, podría ver reglas como c (capitalizar la primera letra) o a[0-9] (añadir un dígito al final).

Presione Ctrl+X para salir de nano.

Ahora, probemos una regla simple directamente desde la línea de comandos usando la opción --stdout de JtR, que aplica reglas a una lista de palabras e imprime los resultados en la salida estándar sin intentar descifrar hashes. Esto es útil para probar reglas.

Ejecute el siguiente comando para aplicar la regla c (capitalizar la primera letra) a su wordlist.txt:

john --wordlist=~/project/wordlist.txt --rules=single --stdout

Debería ver las palabras de su wordlist.txt con la primera letra capitalizada. Por ejemplo, "password" se convierte en "Password".

Password
Secret
Labex
Test

Esto demuestra cómo una regla simple puede transformar palabras. En los siguientes pasos, creará y combinará reglas más complejas.

Crear una regla simple para capitalización

En este paso, creará un archivo de reglas personalizado para aplicar reglas de capitalización. Si bien el conjunto de reglas single en JtR incluye capitalización básica, la creación de su propio archivo de reglas le brinda más control y permite transformaciones más específicas.

Primero, cree un nuevo archivo llamado my_rules.rule en su directorio ~/project. Este archivo contendrá sus reglas personalizadas.

nano ~/project/my_rules.rule

Agregue las siguientes líneas al archivo my_rules.rule. Estas reglas:

• c: Capitalizar la primera letra.
• C: Capitalizar todas las letras.
• t: Cambiar mayúsculas/minúsculas de la primera letra (por ejemplo, "password" -> "Password", "Password" -> "password").

c
C
t

Guarde el archivo presionando Ctrl+O, luego Enter, y salga de nano presionando Ctrl+X.

Ahora, aplique estas reglas personalizadas a su wordlist.txt usando la opción --rules, especificando su nuevo archivo de reglas.

john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout

Observe la salida. Debería ver cada palabra de su wordlist.txt transformada por cada una de las reglas que definió. Por ejemplo, "password" aparecerá como "Password", "PASSWORD" y "Password" (debido a la regla t aplicada a la "password" original).

Password
SECRET
LABEX
TEST
password
PASSWORD
secret
SECRET
labex
LABEX
test
TEST
Password
Secret
Labex
Test

Esto demuestra cómo definir y usar un archivo de reglas personalizado. Cada regla en el archivo se aplica secuencialmente a cada palabra en la lista de palabras.

Aplicar reglas para añadir números

En este paso, aprenderá cómo añadir números a las palabras usando las reglas de JtR. Añadir números es una variación de contraseña muy común, y JtR proporciona comandos potentes para generar estas variaciones de manera eficiente.

El comando a<N> añade un carácter <N>. Para añadir dígitos, puede usar rangos de caracteres como a[0-9] para añadir un solo dígito del 0 al 9. También puede combinar esto con otras reglas.

Añadamos reglas a my_rules.rule para añadir números. Abra su archivo de reglas de nuevo:

nano ~/project/my_rules.rule

Agregue las siguientes líneas al final del archivo. Estas reglas:

• a[0-9]: Añade un solo dígito (0-9) a la palabra.
• a[0-9][0-9]: Añade dos dígitos (00-99) a la palabra. Esta regla generará 100 variaciones por cada palabra.

a[0-9]
a[0-9][0-9]

Guarde el archivo (Ctrl+O, Enter) y salga de nano (Ctrl+X).

Ahora, aplique estas reglas actualizadas a su wordlist.txt. Dado que a[0-9][0-9] genera muchas variaciones, limitaremos la salida usando head para fines de demostración.

john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout | head -n 50

Verá palabras como "password0", "password1", ..., "password00", "password01", etc. El comando head -n 50 limita la salida a las primeras 50 líneas, ya que la salida completa sería muy larga.

Password
SECRET
LABEX
TEST
password
PASSWORD
secret
SECRET
labex
LABEX
test
TEST
Password
Secret
Labex
Test
password0
password1
password2
password3
password4
password5
password6
password7
password8
password9
secret0
secret1
secret2
secret3
secret4
secret5
secret6
secret7
secret8
secret9
labex0
labex1
labex2
labex3
labex4
labex5
labex6
labex7
labex8
labex9
test0
test1
test2
test3
test4
test5

Esto muestra cómo generar eficazmente variaciones con números añadidos, que son cruciales para descifrar patrones de contraseñas comunes.

Combinar múltiples reglas para transformaciones complejas

En este paso, combinará múltiples comandos de reglas para crear transformaciones de contraseñas más complejas. JtR le permite encadenar comandos de reglas en una sola línea, aplicándolos secuencialmente a cada palabra.

Creemos una regla que capitaliza la primera letra y luego añade un solo dígito.

Abra su archivo my_rules.rule de nuevo:

nano ~/project/my_rules.rule

Agregue la siguiente regla al final del archivo. Esta regla ca[0-9] significa:

1. c: Capitalizar la primera letra.
2. a[0-9]: Añadir un solo dígito (0-9).

ca[0-9]

Guarde el archivo (Ctrl+O, Enter) y salga de nano (Ctrl+X).

Ahora, aplique estas reglas actualizadas a su wordlist.txt y observe la salida. De nuevo, usaremos head para limitar la salida.

john --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule --stdout | head -n 50

Debería ver variaciones como "Password0", "Password1", "Secret0", "Secret1", etc.

Password
SECRET
LABEX
TEST
password
PASSWORD
secret
SECRET
labex
LABEX
test
TEST
Password
Secret
Labex
Test
password0
password1
password2
password3
password4
password5
password6
password7
password8
password9
secret0
secret1
secret2
secret3
secret4
secret5
secret6
secret7
secret8
secret9
labex0
labex1
labex2
labex3
labex4
labex5
labex6
labexex7
labex8
labex9
test0
test1
test2
test3
test4
test5
Password0
Password1
Password2
Password3
Password4
Password5
Password6
Password7
Password8
Password9

Esto demuestra el poder de combinar reglas. Puede crear conjuntos de reglas muy específicos y efectivos encadenando comandos. Por ejemplo, s@a!ca[0-9] sustituiría '@' por '!', capitalizaría la primera letra y luego añadiría un dígito.

Probar reglas personalizadas en una lista de palabras

En este paso final, utilizará sus reglas personalizadas para intentar descifrar un hash ficticio. Esto simulará un escenario real de descifrado de contraseñas.

Recuerde que en la configuración, se creó un hash para la palabra "password" y se guardó en ~/project/hashes.txt. El hash es user1:5f4dcc3b5aa765d61d8327deb882cf99 (hash MD5 de "password").

Primero, asegúrese de que su archivo my_rules.rule contenga una regla que generaría "password" o una variación de la misma que coincida con el hash. Para este ejemplo, asumiremos que el hash es para la palabra original "password". Si tuviera un hash para "Password0", su regla ca[0-9] sería útil.

Para esta demostración, utilizaremos el wordlist.txt original y su my_rules.rule para intentar descifrar el hash.

Ejecute John the Ripper con su archivo de hashes, lista de palabras y reglas personalizadas:

john ~/project/hashes.txt --wordlist=~/project/wordlist.txt --rules=file:~/project/my_rules.rule

John the Ripper comenzará a procesar la lista de palabras, aplicando sus reglas y comparando las palabras generadas con el hash. Si encuentra una coincidencia, mostrará la contraseña descifrada.

Debería ver una salida similar a esta, indicando que la contraseña ha sido descifrada:

Using default input encoding: UTF-8
Loaded 1 password hash (md5crypt, crypt(3) $1$ [MD5 SSSP])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
password         (user1)
1g 0:00:00:00 DONE (2023-10-27 10:30) 100% (ETA: 00:00:00)
Session completed.

Para ver la contraseña descifrada de nuevo, puede usar la opción --show:

john --show ~/project/hashes.txt

Este comando mostrará cualquier contraseña que JtR haya descifrado con éxito y almacenado en su archivo pot.

user1:password

1 password hash cracked, 0 left

Este paso final demuestra la aplicación práctica de reglas personalizadas en el descifrado de contraseñas. Al crear reglas de manera inteligente, puede mejorar significativamente la efectividad de sus ataques de diccionario contra varios patrones de contraseñas.

Resumen

En este laboratorio, ha aprendido con éxito a aprovechar el potente motor de reglas de John the Ripper para el descifrado avanzado de contraseñas. Comenzó comprendiendo la sintaxis básica de las reglas de JtR, incluidos los comandos para capitalización y cambio de mayúsculas/minúsculas. Luego creó su propio archivo de reglas personalizado y agregó reglas para añadir números, una variación común de contraseñas. Finalmente, combinó múltiples comandos de reglas para crear transformaciones más complejas y aplicó sus reglas personalizadas para descifrar un hash ficticio, simulando un escenario del mundo real. Esta experiencia práctica le ha proporcionado el conocimiento para definir y aplicar conjuntos de reglas sofisticados, mejorando significativamente su capacidad para descifrar contraseñas que no están directamente presentes en una lista de palabras estándar.