John the Ripper y Salting de Contraseñas

Introducción

En el ámbito de la ciberseguridad, proteger las credenciales de los usuarios es primordial. Las contraseñas, cuando se almacenan, rara vez se guardan en texto plano. En su lugar, normalmente se "hashean" (hashed), lo que significa que se transforman en una cadena de caracteres de tamaño fijo utilizando una función criptográfica unidireccional. Esto evita que los atacantes accedan directamente a las contraseñas, incluso si obtienen acceso a la base de datos. Sin embargo, un hash simple no es suficiente. Los atacantes pueden utilizar tablas precalculadas de hashes (tablas arcoíris o "rainbow tables") o ataques de fuerza bruta para descifrar contraseñas.

Aquí es donde entra en juego el "salting" (salado). El salting es una técnica en la que se añade una cadena única y aleatoria (la "sal" o "salt") a una contraseña antes de hashearla. Esta sal se almacena junto con el hash. Cuando un usuario intenta iniciar sesión, se recupera la misma sal y se combina con la contraseña introducida antes de hashearla, y el hash resultante se compara con el hash almacenado.

En este laboratorio, explorará el concepto de salting de contraseñas, comprenderá su importancia para mejorar la seguridad y observará cómo una potente herramienta de descifrado de contraseñas como John the Ripper interactúa con hashes salados. Aprenderá a identificar hashes salados, verá cómo John the Ripper los maneja y comprenderá el impacto significativo que el salting tiene en la dificultad de descifrar contraseñas. Finalmente, obtendrá una visión de cómo se implementa el salting en el almacenamiento de contraseñas en el mundo real.

Comprender el Concepto de Salting

En este paso, aprenderá el concepto fundamental del salting de contraseñas y por qué es crucial para mejorar la seguridad de las contraseñas.

Cuando una contraseña se "saltea" (salted), se añade una cadena única y aleatoria (la sal o "salt") a la contraseña antes de hashearla. Esto significa que, incluso si dos usuarios tienen exactamente la misma contraseña, sus hashes almacenados serán diferentes porque se utilizó una sal diferente para cada uno. Esto derrota eficazmente las tablas arcoíris precalculadas ("rainbow tables"), que se basan en un hash fijo para una contraseña dada. También hace que los ataques de fuerza bruta sean más difíciles, ya que un atacante tendría que calcular un hash para cada contraseña posible y cada sal posible, en lugar de solo cada contraseña posible.

Veamos un ejemplo de un hash salteado. Abra el archivo salted_passwords.txt que se creó en su directorio ~/project.

cat ~/project/salted_passwords.txt

Verá una salida similar a esta:

user1:$6$salt12345$abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ./:user1password
user2:5f4dcc3b5aa765d61d8327deb882cf99
user3:$6$another_salt$zyxwuvtsrqponmlkjihgfedcba9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA./:anotherpassword
user4:$6$short$abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ./:shortpass

Observe las líneas de user1, user3 y user4. Contienen una sección como $6$salt12345$ o $6$another_salt$. El $6$ indica el algoritmo de hashing utilizado (SHA-512 en este caso), y la cadena entre el segundo y tercer signo $ (salt12345 o another_salt) es la sal. El resto de la cadena después del tercer $ es el hash real de la contraseña combinado con la sal. La línea de user2 es un hash MD5 sin sal, que utilizaremos para comparar más adelante.

La conclusión clave es que cada hash salteado tiene una sal única, lo que dificulta el descifrado de múltiples contraseñas simultáneamente utilizando las mismas tablas precalculadas.

Identificar Hashes Salteados

En este paso, aprenderá a identificar hashes salteados basándose en sus formatos comunes. Reconocer estos formatos es el primer paso para comprender cómo abordar el descifrado o la defensa de contraseñas.

Diferentes algoritmos y sistemas de hashing utilizan varios formatos para almacenar hashes salteados. Sin embargo, muchos formatos comunes, especialmente los utilizados en sistemas Linux, siguen un patrón en el que la sal está incrustada directamente dentro de la cadena del hash, a menudo delimitada por caracteres especiales como $.

Reexaminemos el archivo salted_passwords.txt y busquemos específicamente patrones que indiquen salting.

cat ~/project/salted_passwords.txt

Como observó en el paso anterior:

• user1:$6$salt12345$abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ./:user1password
• user3:$6$another_salt$zyxwuvtsrqponmlkjihgfedcba9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA./:anotherpassword
• user4:$6$short$abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ./:shortpass

Estas líneas muestran claramente el prefijo $6$ (que indica SHA-512 crypt) seguido de la cadena de sal (por ejemplo, salt12345, another_salt, short), y luego el hash real. Esta estructura es un fuerte indicador de un hash salteado.

En contraste, la línea para user2:

• user2:5f4dcc3b5aa765d61d8327deb882cf99

Este es un hash MD5 simple. Carece de delimitadores o sal incrustada, lo que lo hace fácilmente identificable como un hash sin sal.

Ser capaz de distinguir rápidamente entre hashes salteados y sin sal es crucial para los profesionales de la seguridad y los pentesters, ya que dicta las estrategias de descifrado que se pueden emplear.

Observar el Manejo de Hashes Salteados por John the Ripper

En este paso, utilizará John the Ripper, una popular herramienta de descifrado de contraseñas, para observar cómo maneja tanto los hashes salteados como los no salteados. Esto demostrará las implicaciones prácticas del salting.

Primero, intentemos descifrar las contraseñas en salted_passwords.txt utilizando una simple lista de palabras (wordlist). Usaremos una lista de palabras pequeña y personalizada para esta demostración.

Cree un archivo de lista de palabras llamado wordlist.txt en su directorio ~/project con algunas contraseñas comunes:

echo "password" > ~/project/wordlist.txt
echo "user1password" >> ~/project/wordlist.txt
echo "anotherpassword" >> ~/project/wordlist.txt
echo "shortpass" >> ~/project/wordlist.txt
echo "123456" >> ~/project/wordlist.txt

Ahora, ejecute John the Ripper contra su archivo salted_passwords.txt utilizando esta lista de palabras:

john --wordlist=~/project/wordlist.txt ~/project/salted_passwords.txt

John the Ripper analizará los hashes. Debería ver una salida que indique que está intentando descifrar las contraseñas. Probablemente encontrará la contraseña de user2 rápidamente porque es un hash MD5 sin sal y "password" está en la lista de palabras. También encontrará las contraseñas salteadas si sus textos planos correspondientes están en la lista de palabras.

La salida de ejemplo podría verse así:

Using default input encoding: UTF-8
Loaded 4 password hashes with no different salts to crack (crypt, generic crypt(3) [MD5/Blowfish/SHA1/SHA256/SHA512/XSHAa/XSHAab/bcrypt/scrypt])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
password         (user2)
user1password    (user1)
anotherpassword  (user3)
shortpass        (user4)
4g 0:00:00:00 DONE (2023-10-27 10:30) ...
Session completed.

Después de que John termine, puede ver las contraseñas descifradas usando la opción --show:

john --show ~/project/salted_passwords.txt

Este comando mostrará cualquier contraseña que John haya descifrado con éxito.

user2:password (user2)
user1:user1password (user1)
user3:anotherpassword (user3)
user4:shortpass (user4)

4 password hashes cracked, 0 left

John the Ripper está diseñado para manejar varios formatos de hash, incluidos aquellos con sales incrustadas. Extrae automáticamente la sal y la utiliza durante el proceso de descifrado. Sin embargo, la presencia de sales únicas para cada contraseña aumenta significativamente el esfuerzo computacional requerido para el descifrado, especialmente en ataques a gran escala.

Comprender el Impacto del Salting en el Descifrado

En este paso, afianzará su comprensión de por qué el salting hace que el descifrado de contraseñas sea significativamente más difícil, especialmente para ataques a gran escala.

Considere la entrada user2 de nuestro archivo salted_passwords.txt: user2:5f4dcc3b5aa765d61d8327deb882cf99. Este es un hash MD5 sin sal para la contraseña "password". Si un atacante obtiene una base de datos de hashes MD5 sin sal, puede:

1. Usar Tablas Arcoíris (Rainbow Tables): Tablas precalculadas de hashes para contraseñas comunes. Si "password" está en la tabla, su hash 5f4dcc3b5aa765d61d8327deb882cf99 estará allí, y la contraseña en texto plano se podrá recuperar instantáneamente.
2. Descifrar Múltiples Contraseñas Simultáneamente: Si muchos usuarios tienen la misma contraseña débil (por ejemplo, "123456"), sus hashes sin sal serán idénticos. Un atacante solo necesita descifrar una instancia de ese hash para conocer la contraseña de todos los usuarios que la comparten.

Ahora, veamos los hashes salteados:

• user1:$6$salt12345$abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ./:user1password
• user3:$6$another_salt$zyxwuvtsrqponmlkjihgfedcba9876543210ZYXWVUTSRQPONMLKJIHGFEDCBA./:anotherpassword

Incluso si user1 y user3 tuvieran exactamente la misma contraseña, sus hashes serían diferentes porque sus sales (salt12345 y another_salt) son distintas. Esto tiene varias implicaciones críticas para los atacantes:

• Las Tablas Arcoíris son Inútiles: Debido a que cada hash es único gracias a su sal, las tablas arcoíris precalculadas se vuelven ineficaces. Un atacante necesitaría una tabla arcoíris para cada sal posible, lo cual es computacionalmente inviable.
• Descifrado por Hash: Un atacante debe descifrar cada hash salteado individualmente. Si 100 usuarios tienen la misma contraseña, pero cada uno tiene una sal única, el atacante debe realizar 100 operaciones de descifrado separadas, una por cada par hash-sal único. Esto aumenta drásticamente el tiempo y los recursos necesarios para un ataque exitoso.
• Dificultad del Ataque de Fuerza Bruta (Brute-Force): Para un ataque de fuerza bruta, el atacante debe combinar cada contraseña potencial con su sal específica antes de hashear y comparar. Esto añade una capa de complejidad y ralentiza significativamente el proceso de descifrado en comparación con los hashes sin sal.

En esencia, el salting transforma un único problema de descifrado en muchos problemas de descifrado independientes, lo que hace que las brechas de contraseñas a gran escala sean mucho más difíciles y lentas para los atacantes.

Implementar Salting en el Almacenamiento de Contraseñas

En este paso, obtendrá una comprensión conceptual de cómo se implementa el salting en los sistemas de almacenamiento de contraseñas del mundo real. Aunque no construiremos un sistema completo, verá los componentes principales.

Cuando un usuario establece o cambia su contraseña, un sistema seguro generalmente realiza los siguientes pasos:

1. Generar una Sal Aleatoria: Se genera una sal aleatoria criptográficamente segura. Esta sal debe ser única para cada usuario y cada cambio de contraseña.
2. Combinar Contraseña y Sal: La contraseña en texto plano del usuario se concatena con la sal generada.
3. Hashear la Cadena Combinada: La cadena combinada de contraseña y sal se pasa luego a través de un algoritmo de hashing fuerte y lento (por ejemplo, bcrypt, scrypt, Argon2, o SHA-512 crypt como se ve en nuestros ejemplos). Se prefieren los algoritmos de hashing lentos porque hacen que los ataques de fuerza bruta consuman aún más tiempo.
4. Almacenar Hash y Sal: El hash resultante y la sal se almacenan juntos en la base de datos. La sal no necesita ser secreta; su propósito es garantizar la unicidad del hash.

Cuando un usuario intenta iniciar sesión:

1. Recuperar la Sal Almacenada: El sistema recupera la sal asociada con la cuenta del usuario de la base de datos.
2. Combinar Contraseña Ingresada y Sal Almacenada: La contraseña ingresada por el usuario se combina con la sal recuperada.
3. Hashear la Cadena Combinada: Esta cadena combinada se hashea utilizando el mismo algoritmo de hashing que se usó durante el registro.
4. Comparar Hashes: El hash recién calculado se compara con el hash almacenado. Si coinciden, la contraseña es correcta.

Simulemos la generación de un hash salteado usando el comando mkpasswd, que es parte del paquete whois y puede generar hashes estilo crypt(3).

Primero, asegúrese de que whois esté instalado:

sudo apt install -y whois

Ahora, genere un hash salteado SHA-512 para la contraseña "mysecretpassword" con una sal personalizada "mysalt":

mkpasswd -m sha-512 "mysecretpassword" -s "mysalt"

Verá una salida similar a esta:

$6$mysalt$some_long_hash_string_here

La salida $6$mysalt$some_long_hash_string_here es el hash salteado. $6$ indica SHA-512, mysalt es la sal que proporcionó, y el resto es el hash real. En un sistema real, la sal se generaría aleatoriamente, no se proporcionaría manualmente.

Esto demuestra el proceso fundamental. Las aplicaciones modernas utilizan bibliotecas y frameworks que abstraen estos detalles, pero el principio subyacente de generar una sal única, combinarla con la contraseña, hashear y almacenar ambos, sigue siendo la piedra angular del almacenamiento seguro de contraseñas.

Resumen

En este laboratorio, ha adquirido una comprensión integral del salting de contraseñas y su papel fundamental en la mejora de la seguridad de las contraseñas. Aprendió que el salting implica agregar una cadena única y aleatoria (la sal) a una contraseña antes de que se hashee, lo que hace que cada hash sea único incluso para contraseñas idénticas.

Identificó con éxito los hashes salteados por sus formatos característicos, que a menudo incluyen delimitadores como $ y una cadena de sal incrustada. A través de la observación práctica con John the Ripper, vio cómo esta poderosa herramienta maneja tanto hashes salteados como sin sal, y de manera crucial, cómo el salting obliga a que el proceso de descifrado se realice por cada hash, aumentando significativamente el esfuerzo computacional para los atacantes.

Finalmente, exploró la implementación conceptual del salting en los sistemas de almacenamiento de contraseñas, comprendiendo los pasos involucrados en la generación, combinación, hasheo y almacenamiento de sales y contraseñas. Este conocimiento es fundamental para cualquier persona involucrada en ciberseguridad, ya sea para defender sistemas o para comprender las metodologías de ataque.

Al hacer que cada hash de contraseña sea único, el salting mitiga eficazmente la amenaza de los ataques de tablas arcoíris y ralentiza drásticamente los intentos de fuerza bruta, lo que lo convierte en una técnica indispensable para una seguridad de contraseñas robusta.