Usar John the Ripper para Crackear Hashes SHA1

Introducción

En este laboratorio, explorará el proceso de cracking de hashes SHA1 utilizando John the Ripper, una potente herramienta de cracking de contraseñas de código abierto. Comprender cómo se craquean los hashes es crucial para entender las vulnerabilidades de seguridad de las contraseñas e implementar medidas de seguridad más sólidas. Aprenderá a generar hashes SHA1 a partir de contraseñas en texto plano, preparar estos hashes para John the Ripper y luego utilizar la herramienta para recuperar las contraseñas originales. Esta experiencia práctica le proporcionará información sobre la efectividad de los algoritmos de hashing y la importancia de contraseñas fuertes y únicas.

Generar Hashes SHA1 a partir de Contraseñas

En este paso, generará hashes SHA1 a partir de algunas contraseñas de ejemplo. SHA1 (Secure Hash Algorithm 1) es una función hash criptográfica que toma una entrada y produce un valor hash de 160 bits (20 bytes), que normalmente se representa como un número hexadecimal de 40 dígitos. Aunque SHA1 se considera criptográficamente roto para ciertas aplicaciones debido a vulnerabilidades, sigue siendo útil para demostrar los principios del cracking de hashes.

Primero, creemos un archivo llamado passwords.txt que contenga algunas contraseñas sencillas.

echo -e "password123\nlabexuser\nsecretpass" > passwords.txt

Ahora, utilizaremos el comando sha1sum para generar el hash SHA1 de cada contraseña en el archivo passwords.txt. La opción -t indica a sha1sum que lea en modo texto, y la opción -b indica que lea en modo binario. Usaremos xargs para pasar cada línea del archivo como argumento a sha1sum.

cat passwords.txt | xargs -I {} sh -c 'echo -n "{}" | sha1sum' > hashes.txt

Este comando lee cada contraseña de passwords.txt, la canaliza a sha1sum (usando echo -n para evitar añadir un carácter de nueva línea que cambiaría el hash) y luego redirige la salida (el hash y la contraseña original) a un nuevo archivo llamado hashes.txt.

Veamos el contenido de hashes.txt:

cat hashes.txt

Debería ver una salida similar a esta, donde cada línea contiene un hash SHA1 seguido de la contraseña original:

5d41402abc4b2a76b9719d911017c592070b4783  password123
1234567890abcdef1234567890abcdef12345678  labexuser
5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8  secretpass

Nota: La segunda columna (la contraseña original) es incluida por sha1sum por defecto. Para el cracking, John the Ripper normalmente solo necesita el hash en sí. Prepararemos el archivo para John en el siguiente paso.

Preparar un Archivo de Hashes para SHA1

En este paso, preparará el archivo hashes.txt para que contenga solo los hashes SHA1, que es el formato que John the Ripper espera para el cracking. El archivo hashes.txt contiene actualmente tanto el hash como la contraseña original, lo cual no es ideal para la entrada de John.

Extraeremos solo los valores hash de hashes.txt y los guardaremos en un nuevo archivo llamado sha1_hashes_for_john.txt. Podemos usar el comando awk para lograr esto, ya que nos permite seleccionar fácilmente columnas específicas de un archivo.

awk '{print $1}' hashes.txt > sha1_hashes_for_john.txt

Este comando le dice a awk que imprima el primer campo ($1) de cada línea en hashes.txt y redirija la salida a sha1_hashes_for_john.txt.

Ahora, inspeccionemos el contenido del nuevo archivo para asegurarnos de que solo contiene los hashes:

cat sha1_hashes_for_john.txt

Debería ver una salida similar a esta, con solo los hashes SHA1 listados:

5d41402abc4b2a76b9719d911017c592070b4783
1234567890abcdef1234567890abcdef12345678
5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8

Este archivo ahora está listo para ser utilizado como entrada para John the Ripper.

Crackear Hashes SHA1 con John the Ripper

En este paso, utilizará John the Ripper para crackear los hashes SHA1 almacenados en sha1_hashes_for_john.txt. John the Ripper es un rápido cracker de contraseñas, disponible para muchos sistemas operativos. Su propósito principal es detectar contraseñas débiles de Unix. Soporta varios tipos de hash, incluyendo SHA1.

Usaremos John the Ripper en "modo lista de palabras" para intentar crackear los hashes. Este modo prueba contraseñas de una lista predefinida (una "lista de palabras" o "wordlist"). Para este laboratorio, crearemos una lista de palabras simple que contenga las contraseñas originales. En un escenario del mundo real, usaría una lista de palabras mucho más grande y completa.

Primero, cree un archivo de lista de palabras simple llamado wordlist.txt:

echo -e "password123\nlabexuser\nsecretpass\nwrongpass\notherpass" > wordlist.txt

Ahora, ejecute John the Ripper con el archivo de hashes preparado y la lista de palabras:

john --format=raw-sha1 --wordlist=wordlist.txt sha1_hashes_for_john.txt

Analicemos el comando:

• john: El comando para invocar John the Ripper.
• --format=raw-sha1: Especifica que los hashes de entrada son hashes SHA1 "raw" (crudos). John soporta muchos formatos, y especificar el correcto le ayuda a crackear eficientemente.
• --wordlist=wordlist.txt: Indica a John que use wordlist.txt como diccionario para el cracking.
• sha1_hashes_for_john.txt: El archivo que contiene los hashes a crackear.

Después de ejecutar el comando, John intentará crackear los hashes. Si tiene éxito, mostrará las contraseñas crackeadas.

Debería ver una salida similar a esta, indicando las contraseñas crackeadas:

Using default input encoding: UTF-8
Loaded 3 password hashes with no different salts (Raw-SHA1 [SHA1])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
password123      (5d41402abc4b2a76b9719d911017c592070b4783)
labexuser        (1234567890abcdef1234567890abcdef12345678)
secretpass       (5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8)
3g 0:00:00:00 DONE (2023-10-27 10:30) 100.0% (ETA: 00:00:00) 3.000g/s 100.0p/s 100.0c/s 100.0C/s password123..secretpass
Session completed.

Para ver las contraseñas crackeadas de nuevo, puede usar la opción --show:

john --show sha1_hashes_for_john.txt

Este comando mostrará todos los hashes que John ha crackeado con éxito y almacenado en su archivo "pot" interno.

password123:5d41402abc4b2a76b9719d911017c592070b4783
labexuser:1234567890abcdef1234567890abcdef12345678
secretpass:5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8

3 password hashes cracked, 0 left

Analizar el Rendimiento del Cracking SHA1

En este paso, analizará brevemente el rendimiento de John the Ripper al crackear hashes SHA1. Aunque nuestro ejemplo utiliza una lista de palabras muy pequeña y contraseñas sencillas, en un escenario del mundo real, el rendimiento del cracking es un factor crítico.

John the Ripper proporciona algunas métricas de rendimiento en su salida, como "g/s" (guesses per second - intentos por segundo) y "p/s" (passwords per second - contraseñas por segundo). Estas métricas indican cuántos intentos de contraseña puede realizar John por segundo.

Volvamos a ejecutar el comando de cracking y observemos la salida detenidamente:

john --format=raw-sha1 --wordlist=wordlist.txt sha1_hashes_for_john.txt

Busque líneas similares a esta en la salida:

3g 0:00:00:00 DONE (2023-10-27 10:30) 100.0% (ETA: 00:00:00) 3.000g/s 100.0p/s 100.0c/s 100.0C/s password123..secretpass

Aquí, 3.000g/s indica que John procesó 3 intentos por segundo, y 100.0p/s indica 100 contraseñas por segundo. Para un conjunto tan pequeño de hashes y una lista de palabras diminuta, el cracking es casi instantáneo.

Factores que afectan el rendimiento del cracking:

• Complejidad de la Contraseña: Las contraseñas simples y comunes se crackean mucho más rápido que las complejas y únicas.
• Tamaño y Calidad de la Lista de Palabras: Una lista de palabras más grande y relevante aumenta las posibilidades de cracking, pero también aumenta el tiempo necesario.
• Algoritmo de Hashing: Algunos algoritmos de hashing están diseñados para ser computacionalmente intensivos (por ejemplo, bcrypt, scrypt) para ralentizar los intentos de cracking, mientras que otros como el SHA1 "raw" son relativamente rápidos.
• Hardware: La potencia de procesamiento (CPU/GPU) de la máquina de cracking impacta significativamente en el rendimiento.

Este breve análisis pone de manifiesto que, incluso con una herramienta potente como John the Ripper, la fortaleza de la contraseña original y el algoritmo de hashing juegan un papel crucial en el tiempo que se tarda en crackear un hash.

Comprender las Características del Hash SHA1

En este paso, obtendrá una comprensión más profunda de las características del hash SHA1 y por qué es importante utilizar algoritmos de hashing más robustos para el almacenamiento de contraseñas.

Características Clave de SHA1:

1. Tamaño de Salida Fijo: SHA1 siempre produce un valor hash de 160 bits (20 bytes), independientemente del tamaño de la entrada. Por eso ve una cadena hexadecimal de 40 caracteres.
2. Función Unidireccional: Es computacionalmente inviable revertir el proceso de hashing para obtener la entrada original a partir del hash. Por eso el cracking se basa en ataques de fuerza bruta o de diccionario.
3. Determinista: La misma entrada siempre producirá el mismo hash SHA1. Esta propiedad es esencial para verificar la integridad de los datos.
4. Efecto Avalancha: Un pequeño cambio en la entrada (incluso un solo bit) resulta en una salida de hash drásticamente diferente. Esto hace que sea difícil adivinar entradas basándose en similitudes de hash.

Por qué SHA1 se considera inseguro para el almacenamiento de contraseñas:

• Ataques de Colisión: En 2017, se demostró un ataque de colisión práctico contra SHA1. Una colisión ocurre cuando dos entradas diferentes producen la misma salida de hash. Si bien encontrar una colisión no revela directamente la contraseña original, socava la integridad de la función de hashing y puede ser explotada en varios ataques.
• Velocidad: SHA1 es relativamente rápido de calcular. Esta velocidad, combinada con la potencia de cálculo moderna, lo hace vulnerable a ataques de fuerza bruta y de diccionario, especialmente para contraseñas comunes o débiles.
• Falta de "Salting" (Sal): Los hashes SHA1 "raw" (crudos), como se demostró en este laboratorio, no incluyen inherentemente "salting". El "salting" implica añadir una cadena única y aleatoria a cada contraseña antes de hashearla. Esto evita que las tablas "rainbow" precalculadas sean efectivas y asegura que dos contraseñas idénticas tengan hashes diferentes, incluso si se almacenan en la misma base de datos.

Para el almacenamiento seguro de contraseñas hoy en día, se recomiendan algoritmos de hashing más robustos, lentos y con "salting" como bcrypt, scrypt o Argon2. Estos algoritmos están diseñados para ser computacionalmente intensivos, lo que hace que los ataques de fuerza bruta sean mucho más lentos y costosos.

Este laboratorio demostró los principios fundamentales del cracking de hashes utilizando SHA1. Sirve como un recordatorio de la importancia de utilizar algoritmos de hashing robustos y contraseñas fuertes y únicas para proteger la información sensible.

Resumen

En este laboratorio, aprendió con éxito cómo generar hashes SHA1 a partir de contraseñas en texto plano y prepararlos para el cracking. Luego utilizó John the Ripper en modo de lista de palabras para crackear estos hashes SHA1, recuperando las contraseñas originales. Además, obtuvo información sobre los factores que afectan el rendimiento del cracking de hashes y comprendió las características clave de SHA1, incluido por qué ya no se considera seguro para el almacenamiento de contraseñas debido a su velocidad y susceptibilidad a ataques de colisión. Esta experiencia práctica refuerza la importancia de utilizar contraseñas fuertes y únicas, así como algoritmos de hashing modernos y robustos como bcrypt, scrypt o Argon2 para una gestión segura de contraseñas.