Auditar Políticas de Contraseñas con John the Ripper

Introducción

En el panorama digital actual, las políticas de contraseñas robustas son cruciales para proteger la información sensible. Sin embargo, incluso con políticas implementadas, pueden existir vulnerabilidades. Este laboratorio te guiará a través del proceso de uso de John the Ripper, una potente herramienta de cracking de contraseñas, para evaluar la efectividad de las políticas de contraseñas existentes. Aprenderás a identificar debilidades, recomendar políticas más fuertes y comprender cómo implementar verificaciones de cumplimiento automatizadas para mejorar la seguridad general. Esta experiencia práctica te proporcionará habilidades prácticas en auditoría y aplicación de la seguridad de contraseñas.

Analizar Políticas de Contraseñas Existentes

En este paso, comenzará por comprender cómo analizar las políticas de contraseñas existentes en un sistema Linux. Aunque no modificaremos las políticas a nivel de sistema directamente en este laboratorio, comprender dónde se configuran estas políticas es crucial para la auditoría. Nos centraremos en examinar archivos de configuración comunes que dictan la complejidad, antigüedad y configuración de bloqueo de contraseñas.

Primero, examinemos el archivo /etc/login.defs, que contiene la configuración global para el conjunto de contraseñas shadow. Este archivo define parámetros como el envejecimiento de la contraseña, la longitud mínima de la contraseña y la antigüedad máxima de la contraseña.

Utilice el comando grep para buscar configuraciones relacionadas con contraseñas en /etc/login.defs:

grep -E "PASS_MAX_DAYS|PASS_MIN_DAYS|PASS_WARN_AGE|ENCRYPT_METHOD" /etc/login.defs

Debería ver una salida similar a esta, aunque los valores pueden variar:

PASS_MAX_DAYS	99999
PASS_MIN_DAYS	0
PASS_WARN_AGE	7
ENCRYPT_METHOD SHA512

A continuación, veremos /etc/pam.d/common-password, que es un archivo de configuración de PAM (Pluggable Authentication Modules) que controla las reglas de complejidad de las contraseñas. Este archivo a menudo incluye módulos como pam_cracklib.so o pam_pwquality.so que aplican reglas como requerir mayúsculas, minúsculas, dígitos y caracteres especiales.

Utilice cat para ver el contenido de /etc/pam.d/common-password:

cat /etc/pam.d/common-password

Verá muchas líneas, pero preste atención a las líneas que contienen pam_pwquality.so o pam_cracklib.so y sus parámetros (por ejemplo, minlen, difok, ucredit, lcredit, dcredit, ocredit).

password        [success=1 default=ignore]      pam_unix.so obscure sha512 shadow
password        requisite                       pam_pwquality.so retry=3 minlen=8 difok=3 reject_username enforce_for_root
password        optional                        pam_gnome_keyring.so
password        optional                        pam_kwallet.so
password        optional                        pam_systemd.so

Finalmente, revisemos el archivo /etc/security/pwquality.conf, que proporciona un control más granular sobre la configuración de calidad de las contraseñas cuando se utiliza pam_pwquality.so.

cat /etc/security/pwquality.conf

Podría ver configuraciones como minlen, dcredit, ucredit, lcredit, ocredit, maxrepeat, etc.

## Configuration for the pam_pwquality module
#
## The setting of the PAM module is usually in /etc/pam.d/common-password
#
## minlen = 8
## difok = 3
## dcredit = -1
## ucredit = -1
## lcredit = -1
## ocredit = -1
## minclass = 0
## maxrepeat = 0
## maxsequence = 0
## gecoscheck = 0
## dictcheck = 1
## usercheck = 1
## enforce_for_root

Al examinar estos archivos, puede obtener una buena comprensión de la configuración actual de la política de contraseñas en el sistema.

Usar John the Ripper para Probar la Efectividad de las Políticas

En este paso, utilizará John the Ripper (JtR) para probar la efectividad de las políticas de contraseñas. Simularemos un escenario en el que tiene acceso a un archivo de hash de contraseñas e intentará descifrar contraseñas débiles.

Primero, creemos un archivo de contraseñas ficticio para fines de demostración. Crearemos un archivo llamado passwords.txt con algunas contraseñas débiles.

echo "user1:password123" > ~/project/passwords.txt
echo "user2:welcome" >> ~/project/passwords.txt
echo "user3:labexrocks" >> ~/project/passwords.txt

Ahora, necesitamos convertir estas contraseñas en texto plano a un formato que John the Ripper pueda entender. Usaremos unshadow (un componente de JtR) para combinar un archivo ficticio similar a /etc/passwd y /etc/shadow. Para simplificar, simplemente usaremos el archivo passwords.txt directamente con el modo stdin de JtR para el cracking.

Creemos un archivo de lista de palabras simple llamado wordlist.txt que John the Ripper utilizará para intentar descifrar las contraseñas.

echo "password123" > ~/project/wordlist.txt
echo "welcome" >> ~/project/wordlist.txt
echo "labexrocks" >> ~/project/wordlist.txt
echo "secret" >> ~/project/wordlist.txt
echo "123456" >> ~/project/wordlist.txt

Ahora, use John the Ripper para descifrar las contraseñas de passwords.txt utilizando wordlist.txt.

john --format=raw-md5 --wordlist=~/project/wordlist.txt ~/project/passwords.txt

Podría ver una salida similar a esta, indicando las contraseñas descifradas:

Using default input encoding: UTF-8
Loaded 3 password hashes with no different salts (Raw-MD5 [MD5])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
password123 (user1)
welcome (user2)
labexrocks (user3)
3g 0:00:00:00 DONE (2023-10-27 08:30) 100.0% 3g/s 100.0p/s 100.0c/s 100.0C/s password123 welcome labexrocks
Session completed.

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

john --show ~/project/passwords.txt

Salida:

user1:password123

user2:welcome

user3:labexrocks

3 password hashes cracked, 0 left

Esto demuestra con qué facilidad se pueden descifrar contraseñas débiles utilizando una lista de palabras simple.

Identificar Brechas en las Políticas de Contraseñas

En este paso, identificará las brechas en las políticas de contraseñas simuladas basándose en los resultados de descifrado del paso anterior. El hecho de que John the Ripper pudiera descifrar fácilmente las contraseñas indica debilidades significativas.

Basándonos en las contraseñas descifradas (password123, welcome, labexrocks), aquí hay algunas brechas comunes que permitieron su descifrado:

Falta de Requisitos de Complejidad: Las contraseñas welcome y labexrocks son palabras de diccionario simples o frases fácilmente adivinables. password123 es un patrón común. Una política sólida debería exigir una combinación de letras mayúsculas, minúsculas, números y caracteres especiales.
Longitud Insuficiente: Si bien password123 y labexrocks tienen 11 y 10 caracteres respectivamente, siguen siendo vulnerables debido a su simplicidad. Las políticas deberían exigir una longitud mínima, típicamente 12 caracteres o más, para aumentar el espacio de búsqueda para los atacantes.
Sin Verificación de Palabras de Diccionario: La política no impidió que los usuarios eligieran palabras comunes de diccionario o variaciones simples.
Sin Verificación de Patrones Comunes: Contraseñas como password123 siguen patrones predecibles que a menudo se incluyen en las listas de palabras para descifrado.
Falta de Historial de Contraseñas/Prevención de Reutilización: Si se permite a los usuarios reutilizar contraseñas antiguas, incluso si alguna vez fueron sólidas, se vuelven vulnerables si esas contraseñas antiguas se filtran.

Para simular la identificación de estas brechas, consideremos cómo podría ser una política de contraseñas más sólida. Por ejemplo, si nuestra política actual permite minlen=8 y no hay requisitos específicos de clase de caracteres, entonces welcome (7 caracteres) fallaría, pero password123 (11 caracteres, sin caracteres especiales) pasaría. Los resultados del descifrado resaltan que incluso si una contraseña cumple con un requisito de longitud básico, aún podría ser débil si no se aplican verificaciones de complejidad y diccionario.

Piense en cómo se podrían ajustar los parámetros del módulo pam_pwquality.so (como minlen, dcredit, ucredit, lcredit, ocredit, dictcheck) para prevenir contraseñas tan débiles. Por ejemplo, establecer dcredit=-1 requeriría al menos un dígito, ucredit=-1 para mayúsculas, etc.

Este paso es principalmente conceptual, centrándose en el análisis de los resultados del ejercicio de descifrado anterior para comprender las deficiencias de la política.

Recomendar Políticas de Contraseñas Más Robustas

En este paso, formulará recomendaciones para políticas de contraseñas más sólidas basándose en las brechas identificadas. Las políticas de contraseñas efectivas equilibran la seguridad con la usabilidad.

Aquí hay algunas recomendaciones para una política de contraseñas más robusta:

Longitud Mínima: Aumente la longitud mínima de la contraseña a al menos 12-14 caracteres. Las contraseñas más largas son exponencialmente más difíciles de descifrar.
- Ejemplo de configuración PAM: minlen=12 en /etc/security/pwquality.conf o pam_pwquality.so minlen=12 en /etc/pam.d/common-password.
Requisitos de Complejidad: Exija el uso de una combinación de tipos de caracteres:
- Letras mayúsculas (A-Z)
- Letras minúsculas (a-z)
- Números (0-9)
- Caracteres especiales (!@#$%^&*()_+-=[]{}|;':",./<>?)
- Ejemplo de configuración PAM: dcredit=-1 ucredit=-1 lcredit=-1 ocredit=-1 en /etc/security/pwquality.conf o pam_pwquality.so dcredit=-1 ucredit=-1 lcredit=-1 ocredit=-1 en /etc/pam.d/common-password.
Verificación de Diccionario y Patrones Comunes: Evite el uso de palabras de diccionario comunes, nombres comunes y patrones fácilmente adivinables (como password123, qwerty, 123456).
- Ejemplo de configuración PAM: dictcheck=1 usercheck=1 en /etc/security/pwquality.conf o pam_pwquality.so dictcheck=1 usercheck=1 en /etc/pam.d/common-password.
Historial de Contraseñas/Prevención de Reutilización: Evite que los usuarios reutilicen un cierto número de sus contraseñas anteriores. Esto mitiga el riesgo si una contraseña antigua se ve comprometida.
- Ejemplo de configuración PAM: remember=5 con pam_unix.so en /etc/pam.d/common-password (por ejemplo, password required pam_unix.so obscure sha512 shadow remember=5).
Política de Bloqueo de Cuentas: Implemente una política de bloqueo de cuentas después de un cierto número de intentos de inicio de sesión fallidos para disuadir los ataques de fuerza bruta.
- Ejemplo de configuración PAM: Usando pam_tally2.so o pam_faillock.so en /etc/pam.d/common-auth (por ejemplo, auth required pam_faillock.so deny=3 unlock_time=600).
Cambios Regulares de Contraseña (con precaución): Aunque tradicionalmente se recomienda, los cambios obligatorios frecuentes de contraseña pueden llevar a que los usuarios elijan contraseñas más simples y predecibles. Un mejor enfoque es exigir una complejidad y longitud sólidas, y solo requerir cambios si se sospecha una brecha.

Para demostrar un cambio conceptual, imaginemos que estamos actualizando una política. No modificaremos los archivos del sistema, pero puede ver cómo se podría editar el archivo pwquality.conf.

Abra un archivo ficticio para simular las recomendaciones de políticas:

nano ~/project/recommended_policy.txt

Agregue el siguiente contenido al archivo:

## Recommended Password Policy Settings
minlen = 14
dcredit = -1
ucredit = -1
lcredit = -1
ocredit = -1
dictcheck = 1
usercheck = 1
maxrepeat = 3
maxsequence = 3

Guarde y salga de nano (Ctrl+S, Ctrl+X).

Estas configuraciones exigirían una longitud mínima de 14 caracteres, requerirían al menos un dígito, una mayúscula, una minúscula y un carácter especial, y evitarían palabras de diccionario y nombres de usuario.

Implementar Verificaciones Automatizadas de Cumplimiento de Políticas

En este paso, aprenderá sobre la implementación de verificaciones automatizadas de cumplimiento de políticas. Si bien la aplicación directa de políticas en todo el sistema se realiza a través de PAM y otros archivos de configuración, las verificaciones automatizadas se pueden utilizar para auditar regularmente las contraseñas de los usuarios o las configuraciones del sistema frente a las políticas definidas.

Para este laboratorio, simularemos una verificación de cumplimiento simple utilizando un script de shell. Este script verificará si la contraseña de un usuario ficticio cumple con un requisito básico de longitud. En un escenario del mundo real, dichos scripts serían más complejos, potencialmente integrándose con herramientas como OpenSCAP o scripts personalizados para auditar hashes de contraseñas reales (si está permitido y es ético) o archivos de configuración.

Primero, creemos un usuario ficticio y un archivo de hash de contraseña ficticio para simular un estado del sistema. No crearemos usuarios reales del sistema.

echo "testuser:\$6\$salt\$hashedpassword" > ~/project/dummy_shadow.txt

Ahora, cree un script de shell simple llamado check_password_compliance.sh que verifique si la longitud de la contraseña para testuser en dummy_shadow.txt es mayor que un valor determinado (por ejemplo, 10 caracteres).

nano ~/project/check_password_compliance.sh

Agregue el siguiente contenido al script:

#!/bin/bash

## This script simulates a basic password length compliance check.
## In a real scenario, you would parse actual shadow file entries
## or use more sophisticated tools.

MIN_LENGTH=10
PASSWORD_HASH=$(grep "testuser" ~/project/dummy_shadow.txt | cut -d':' -f2)

## For demonstration, we'll just check the length of a placeholder hash.
## In reality, you'd need to crack or analyze the actual hash.
## Here, we're just checking if the hash string itself is long enough,
## which is NOT how real password length checks work, but serves as a
## placeholder for a compliance check.

if [ ${#PASSWORD_HASH} -ge $MIN_LENGTH ]; then
  echo "Compliance Check: testuser password hash length meets minimum requirement ($MIN_LENGTH characters)."
  exit 0
else
  echo "Compliance Check: testuser password hash length DOES NOT meet minimum requirement ($MIN_LENGTH characters)."
  exit 1
fi

Guarde y salga de nano (Ctrl+S, Ctrl+X).

Haga que el script sea ejecutable:

chmod +x ~/project/check_password_compliance.sh

Ahora, ejecute el script de verificación de cumplimiento:

~/project/check_password_compliance.sh

Debería ver una salida que indique el cumplimiento según la longitud del hash ficticio:

Compliance Check: testuser password hash length meets minimum requirement (10 characters).

Este simple ejemplo ilustra el concepto de una verificación de cumplimiento automatizada. En un entorno de producción, dichos scripts podrían programarse para ejecutarse periódicamente utilizando cron para garantizar la adhesión continua a las políticas de contraseñas. Las verificaciones más avanzadas implicarían analizar hashes de contraseñas reales (si se permite y con las consideraciones de seguridad adecuadas), verificar contra listas de diccionario o integrarse con marcos de cumplimiento de seguridad.

Resumen

En este laboratorio, adquirió experiencia práctica en la auditoría y aplicación de políticas de contraseñas. Aprendió a analizar las configuraciones de políticas de contraseñas existentes en un sistema Linux examinando archivos clave como /etc/login.defs, /etc/pam.d/common-password y /etc/security/pwquality.conf. Luego utilizó John the Ripper para demostrar cuán fácilmente se pueden descifrar contraseñas débiles, destacando la importancia de políticas sólidas. Basándose en estos hallazgos, formuló recomendaciones para políticas de contraseñas más sólidas, centrándose en la longitud, la complejidad y las verificaciones de diccionario. Finalmente, exploró el concepto de verificaciones de cumplimiento automatizadas creando un script simple para verificar la adherencia a la política de contraseñas. Este laboratorio proporciona una comprensión fundamental de la auditoría de seguridad de contraseñas, equipándolo con las habilidades para identificar y mitigar vulnerabilidades relacionadas con contraseñas.

John the Ripper y Aplicación de Políticas de Contraseñas