Introducción
En este laboratorio, obtendrá experiencia práctica con John the Ripper, una herramienta de auditoría de seguridad de contraseñas y recuperación de contraseñas de código abierto ampliamente utilizada. Comprender cómo utilizar estas herramientas es crucial para identificar vulnerabilidades en las políticas de contraseñas y fortalecer la seguridad general del sistema. Aprenderá los pasos prácticos para recopilar hashes de contraseñas, utilizar John the Ripper para identificar contraseñas débiles, generar informes sobre contraseñas descifradas y formular recomendaciones para mejorar las políticas de contraseñas. Este laboratorio también abordará la automatización del proceso de auditoría de contraseñas, proporcionando una visión general completa de las mejores prácticas de seguridad de contraseñas.
Recopilar hashes de contraseñas para auditoría
En este paso, aprenderá a recopilar hashes de contraseñas, que son esenciales para la auditoría de contraseñas. En los sistemas Linux, los hashes de contraseñas se almacenan típicamente en el archivo /etc/shadow. Sin embargo, el acceso directo a este archivo requiere privilegios de root. Para el propósito de este laboratorio, hemos creado un archivo shadow ficticio llamado /etc/shadow_dummy que utilizará.
Primero, examinemos el contenido del archivo shadow ficticio.
cat /etc/shadow_dummy
Debería ver una salida similar a esta, mostrando nombres de usuario y sus correspondientes hashes de contraseñas:
user1:5f4dcc3b5aa765d61d8327deb882cf99
user2:21232f297a57a5a743894a0e4a801fc3
user3:d41d8cd98f00b204e9800998ecf8427e
user4:e10adc3949ba59abbe56e057f20f883e
user5:a8b7c6d5e4f3g2h1i0j9k8l7m6n5o4p3
A continuación, copiará este archivo shadow ficticio a su directorio de trabajo actual (~/project) para que sea fácilmente accesible para John the Ripper.
cp /etc/shadow_dummy ~/project/hashes.txt
Ahora, verifique que el archivo hashes.txt se ha copiado correctamente a su directorio ~/project.
ls ~/project/hashes.txt
La salida debería confirmar la presencia del archivo:
/home/labex/project/hashes.txt
Ejecutar John the Ripper para la identificación de contraseñas débiles
En este paso, utilizará John the Ripper para identificar contraseñas débiles del archivo hashes.txt que preparó. John the Ripper puede utilizar varios modos de cracking, incluidos los ataques de diccionario. Realizaremos un ataque de diccionario utilizando una lista de palabras predefinida.
Primero, asegúrese de estar en el directorio ~/project donde se encuentran sus archivos hashes.txt y wordlist.txt.
cd ~/project
Ahora, ejecute John the Ripper utilizando el archivo hashes.txt y el archivo wordlist.txt. La opción --wordlist especifica la ruta a su lista de palabras.
john --wordlist=wordlist.txt hashes.txt
John the Ripper comenzará a procesar los hashes. Si encuentra alguna coincidencia, mostrará las contraseñas descifradas. La salida podría ser similar a esta:
Using default input encoding: UTF-8
Loaded 5 password hashes with no different salts (LM HASH, descrypt/BSDI crypt/other crypt(3) [DES/AES-NI])
Press 'q' or Ctrl-C to abort, almost any other key for status
password (user1)
123456 (user2)
test (user3)
admin (user4)
4g 0:00:00:00 DONE (2023-10-27 08:30) 400% (ETA: 08:30) 0.000c/s 0p/s 4.000w/s 4.000P/s user1, user2, user3, user4
Session completed.
En este ejemplo, John the Ripper descifró con éxito las contraseñas de user1, user2, user3 y user4. La contraseña de user5 no se descifró porque no está en nuestra lista de palabras simple.
Para ver las contraseñas que John ha descifrado hasta ahora, puede usar la opción --show.
john --show hashes.txt
La salida listará las contraseñas descifradas:
user1:password
user2:123456
user3:test
user4:admin
4 password hashes cracked, 1 left
Este comando es útil para revisar los resultados de su sesión de cracking.
Generar informes sobre contraseñas descifradas
En este paso, aprenderá a generar informes sobre las contraseñas descifradas. John the Ripper almacena las contraseñas descifradas en un archivo, típicamente ~/.john/john.pot. Puede usar la opción --show para mostrar estas contraseñas descifradas, lo que sirve como un informe básico.
Para obtener una lista limpia de contraseñas descifradas, puede redirigir la salida de john --show a un archivo. Esta es una práctica común para generar informes que pueden ser analizados o compartidos posteriormente.
Primero, asegurémonos de que estamos en el directorio ~/project.
cd ~/project
Ahora, redirija la salida de john --show hashes.txt a un nuevo archivo llamado cracked_passwords.txt.
john --show hashes.txt > cracked_passwords.txt
Este comando no producirá ninguna salida en la terminal, pero creará el archivo cracked_passwords.txt en su directorio actual.
A continuación, vea el contenido del archivo cracked_passwords.txt para confirmar que el informe se ha generado correctamente.
cat cracked_passwords.txt
Debería ver la lista de contraseñas descifradas, similar a la siguiente:
user1:password
user2:123456
user3:test
user4:admin
4 password hashes cracked, 1 left
Este archivo cracked_passwords.txt ahora sirve como su informe, detallando las cuentas de usuario con contraseñas débiles y descifradas. En un escenario del mundo real, este informe se utilizaría para identificar a los usuarios que necesitan cambiar sus contraseñas de inmediato.
Recomendar mejoras en la política de contraseñas
En este paso, formulará recomendaciones para mejorar las políticas de contraseñas basándose en los hallazgos de la auditoría de contraseñas. Identificar contraseñas débiles es solo el primer paso; el siguiente paso crucial es implementar medidas para prevenir tales vulnerabilidades en el futuro.
Basándonos en las contraseñas descifradas (password, 123456, test, admin), está claro que la política de contraseñas actual (o la falta de ella) permite contraseñas muy simples y comunes.
Aquí hay algunas recomendaciones clave para mejorar las políticas de contraseñas:
- Longitud mínima: Exija una longitud mínima de contraseña, típicamente 12 caracteres o más. Las contraseñas más largas son exponencialmente más difíciles de descifrar.
- 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 (!@#$%^&*()_+-=[]{}|;:'",.<>/?`~)
- Evitar contraseñas comunes: Implemente una lista negra de contraseñas comúnmente utilizadas o fácilmente adivinables (como las encontradas en nuestro
wordlist.txt). Muchos sistemas pueden verificar nuevas contraseñas contra dichas listas negras. - No información personal: Aconseje a los usuarios que no utilicen información personal (nombres, cumpleaños, nombres de mascotas) que pueda ser fácilmente adivinada o encontrada en línea.
- Cambios regulares (con precaución): Aunque históricamente recomendado, los cambios frecuentes y obligatorios de contraseña pueden llevar a los usuarios a elegir contraseñas más simples y predecibles. Un mejor enfoque es exigir contraseñas seguras y solo requerir cambios si se sospecha una brecha.
- Autenticación Multifactor (MFA): Para sistemas críticos, implemente MFA. Incluso si una contraseña se ve comprometida, MFA agrega una capa adicional de seguridad.
- Gestores de contraseñas: Anime o proporcione gestores de contraseñas a los usuarios. Estas herramientas pueden generar y almacenar contraseñas seguras y únicas para diferentes servicios.
Para demostrar su comprensión, considere cómo comunicaría estas recomendaciones. Por ejemplo, podría redactar una declaración de política simple.
Creemos un archivo llamado password_policy_recommendations.txt en su directorio ~/project y agreguemos algunas recomendaciones clave.
cd ~/project
echo "--- Password Policy Recommendations ---" | tee password_policy_recommendations.txt > /dev/null
echo "1. Minimum length: 12 characters" | tee -a password_policy_recommendations.txt > /dev/null
echo "2. Complexity: Mix of uppercase, lowercase, numbers, special characters" | tee -a password_policy_recommendations.txt > /dev/null
echo "3. Avoid common passwords and personal information" | tee -a password_policy_recommendations.txt > /dev/null
echo "4. Implement Multi-Factor Authentication (MFA) for critical systems" | tee -a password_policy_recommendations.txt > /dev/null
Ahora, vea el contenido del archivo password_policy_recommendations.txt.
cat password_policy_recommendations.txt
La salida debería mostrar sus recomendaciones:
--- Password Policy Recommendations ---
1. Minimum length: 12 characters
2. Complexity: Mix of uppercase, lowercase, numbers, special characters
3. Avoid common passwords and personal information
4. Implement Multi-Factor Authentication (MFA) for critical systems
Este archivo representa un informe básico de sus recomendaciones.
Automatizar el proceso de auditoría de contraseñas
En este paso, explorará cómo automatizar partes del proceso de auditoría de contraseñas. Si bien John the Ripper es una herramienta manual, su ejecución puede ser guionizada para que se ejecute periódicamente, haciendo el proceso de auditoría más eficiente y proactivo. La automatización ayuda a monitorear continuamente la fortaleza de las contraseñas e identificar nuevas vulnerabilidades a medida que surgen.
Una forma sencilla de automatizar es crear un script de shell que realice los pasos que ha aprendido: recopilar hashes, ejecutar John the Ripper y generar un informe.
Creemos un script de shell simple llamado audit_script.sh en su directorio ~/project.
cd ~/project
nano audit_script.sh
Dentro del editor nano, agregue el siguiente contenido:
#!/bin/bash
## Define paths
HASH_FILE="/etc/shadow_dummy" ## In a real scenario, this would be /etc/shadow
WORDLIST_FILE="wordlist.txt"
OUTPUT_DIR="~/project/audit_results"
CRACKED_REPORT="$OUTPUT_DIR/cracked_passwords_$(date +%Y%m%d_%H%M%S).txt"
## Create output directory if it doesn't exist
mkdir -p "$OUTPUT_DIR"
echo "--- Starting Password Audit ---"
## Step 1: Copy hashes
cp "$HASH_FILE" "$OUTPUT_DIR/hashes.txt"
echo "Hashes copied to $OUTPUT_DIR/hashes.txt"
## Step 2: Run John the Ripper
echo "Running John the Ripper..."
john --wordlist="$WORDLIST_FILE" "$OUTPUT_DIR/hashes.txt"
## Step 3: Generate report
echo "Generating cracked password report..."
john --show "$OUTPUT_DIR/hashes.txt" > "$CRACKED_REPORT"
echo "Audit complete. Report saved to $CRACKED_REPORT"
echo "--- Audit Finished ---"
Presione Ctrl+X, luego Y, luego Enter para guardar y salir de nano.
A continuación, haga que el script sea ejecutable:
chmod +x audit_script.sh
Ahora, ejecute el script para verlo en acción:
./audit_script.sh
Verá una salida similar a los pasos manuales, indicando que el proceso de auditoría se está ejecutando y se está generando un informe.
--- Starting Password Audit ---
Hashes copied to /home/labex/project/audit_results/hashes.txt
Running John the Ripper...
Using default input encoding: UTF-8
Loaded 5 password hashes with no different salts (LM HASH, descrypt/BSDI crypt/other crypt(3) [DES/AES-NI])
Press 'q' or Ctrl-C to abort, almost any other key for status
password (user1)
123456 (user2)
test (user3)
admin (user4)
4g 0:00:00:00 DONE (2023-10-27 08:35) 400% (ETA: 08:35) 0.000c/s 0p/s 4.000w/s 4.000P/s user1, user2, user3, user4
Session completed.
Generating cracked password report...
Audit complete. Report saved to /home/labex/project/audit_results/cracked_passwords_YYYYMMDD_HHMMSS.txt
--- Audit Finished ---
Finalmente, verifique que se hayan creado el directorio audit_results y un archivo de informe dentro de él.
ls ~/project/audit_results/
Debería ver hashes.txt y un archivo cracked_passwords_YYYYMMDD_HHMMSS.txt (donde YYYYMMDD_HHMMSS es la marca de tiempo actual).
cracked_passwords_20231027_083500.txt hashes.txt
Este script puede programarse para ejecutarse periódicamente utilizando herramientas como cron en un sistema Linux real, lo que permite una auditoría continua de contraseñas.
Resumen
En este laboratorio, ha aprendido con éxito a utilizar John the Ripper para la auditoría de contraseñas. Comenzó recopilando hashes de contraseñas de un archivo shadow simulado, luego utilizó John the Ripper con una lista de palabras para identificar contraseñas débiles. Generó un informe de las contraseñas descifradas y formuló recomendaciones clave para mejorar las políticas de contraseñas, como exigir una longitud mínima, complejidad y evitar contraseñas comunes. Finalmente, creó un script de shell básico para automatizar el proceso de auditoría de contraseñas, demostrando cómo estas tareas pueden integrarse en una estrategia de monitoreo de seguridad continuo. Esta experiencia práctica proporciona una comprensión fundamental de la auditoría de seguridad de contraseñas, una habilidad crítica para cualquier administrador de sistemas o profesional de seguridad.
