John the Ripper y Aceleración por Hardware (GPU)

Introducción

En este laboratorio, explorará la potente combinación de John the Ripper (JtR) y las Unidades de Procesamiento Gráfico (GPU) para la aceleración de la descifrado de contraseñas. El descifrado tradicional basado en CPU puede ser lento, especialmente para contraseñas complejas. Las GPU, con sus capacidades masivas de procesamiento paralelo, pueden reducir drásticamente el tiempo necesario para descifrar contraseñas.

Comenzará comprendiendo los principios fundamentales detrás del descifrado con GPU, luego procederá con los pasos prácticos para configurar su entorno. Esto incluye la instalación de los controladores de GPU y frameworks necesarios como CUDA u OpenCL. A continuación, configurará John the Ripper para utilizar su GPU, evaluará su rendimiento (benchmark) y aprenderá técnicas comunes de resolución de problemas. Al final de este laboratorio, tendrá una sólida comprensión de cómo utilizar eficazmente la aceleración por GPU con John the Ripper.

Comprender los Principios del Descifrado con GPU

En este paso, aprenderá los principios fundamentales que permiten a las GPU acelerar el descifrado de contraseñas.

Las GPU están diseñadas para el procesamiento paralelo, lo que significa que pueden realizar muchos cálculos simultáneamente. Esta arquitectura es ideal para tareas como el descifrado de contraseñas, donde la misma operación (por ejemplo, hashear un candidato a contraseña) necesita realizarse millones o miles de millones de veces.

Conceptos Clave:

• Paralelismo: A diferencia de las CPU, que sobresalen en tareas secuenciales, las GPU tienen miles de núcleos más pequeños que pueden trabajar en partes independientes de un problema de forma concurrente. En el descifrado de contraseñas, cada núcleo puede probar un candidato a contraseña diferente.
• Algoritmos de Hashing: El descifrado de contraseñas implica hashear repetidamente candidatos a contraseñas y comparar el resultado con un hash conocido. Muchos algoritmos de hashing (como MD5, SHA-1, bcrypt, scrypt) son computacionalmente intensivos, lo que los convierte en buenos candidatos para la aceleración por GPU.
• CUDA/OpenCL: Estas son plataformas de computación paralela y modelos de programación que permiten a los desarrolladores de software utilizar una GPU para el procesamiento de propósito general.
  • CUDA (Compute Unified Device Architecture): Desarrollado por NVIDIA, es una plataforma propietaria para GPU NVIDIA.
  • OpenCL (Open Computing Language): Un estándar abierto para la programación paralela en plataformas heterogéneas (CPU, GPU, FPGA, etc.) de diferentes fabricantes. John the Ripper soporta ambos.

Cómo funciona:

1. Cargar Hashes: John the Ripper carga los hashes de contraseñas objetivo en la memoria de la GPU.
2. Generar Candidatos: La GPU genera un gran número de candidatos a contraseñas (por ejemplo, a partir de una lista de palabras o mediante fuerza bruta).
3. Hashear y Comparar: Cada núcleo de la GPU hashea simultáneamente sus candidatos asignados y compara el hash resultante con los hashes objetivo.
4. Reportar Descifrados: Si se encuentra una coincidencia, se reporta la contraseña descifrada.

Esta ejecución paralela reduce significativamente el tiempo necesario para encontrar una contraseña coincidente.

Instalar Controladores de GPU y CUDA/OpenCL

En este paso, preparará su entorno LabEx para la aceleración por GPU instalando los controladores necesarios y el framework OpenCL. Dado que los entornos LabEx están virtualizados y pueden no tener acceso directo a GPU físicas, simularemos la configuración instalando las bibliotecas de desarrollo de OpenCL, que son esenciales para los módulos de GPU de John the Ripper.

Primero, actualice la lista de paquetes para asegurarse de obtener las últimas versiones del software.

sudo apt update

A continuación, instale el paquete ocl-icd-opencl-dev. Este paquete proporciona el cargador de OpenCL Installable Client Driver (ICD) y los archivos de desarrollo, que son cruciales para que aplicaciones como John the Ripper interactúen con dispositivos compatibles con OpenCL.

sudo apt install -y ocl-icd-opencl-dev

Después de la instalación, puede verificar que las bibliotecas de OpenCL están presentes. Aunque no tendrá una GPU física para consultar con clinfo, la presencia de los archivos de desarrollo indica que el sistema está configurado para compilar y ejecutar aplicaciones OpenCL.

ls -l /usr/lib/x86_64-linux-gnu/libOpenCL.so

Debería ver una salida similar a esta, confirmando que la biblioteca existe:

lrwxrwxrwx 1 root root 19 Mar 28  2023 /usr/lib/x86_64-linux-gnu/libOpenCL.so -> libOpenCL.so.1.0.0

Este paso asegura que los componentes fundamentales de OpenCL estén disponibles para que John the Ripper los detecte y utilice.

Configurar John the Ripper para Uso con GPU

En este paso, instalará John the Ripper y verificará su capacidad para detectar OpenCL. Aunque el entorno LabEx podría no tener una GPU física, los módulos OpenCL de John the Ripper seguirán presentes y podrán configurarse.

Primero, instale John the Ripper.

sudo apt install -y john

Después de la instalación, puede comprobar las capacidades de John the Ripper, buscando específicamente el soporte de OpenCL. El comando john --list=opencl-devices de John the Ripper se utiliza para listar los dispositivos OpenCL detectados. En un entorno virtualizado sin una GPU física, es posible que no liste ningún dispositivo real, pero el comando en sí confirma que los módulos OpenCL están compilados en John the Ripper.

john --list=opencl-devices

Es posible que vea una salida que indique "No OpenCL devices found" (No se encontraron dispositivos OpenCL) o similar, lo cual es esperado en este entorno virtual. La parte importante es que el comando se ejecuta sin errores, confirmando que las capacidades OpenCL de JtR están presentes.

No OpenCL devices found.

A continuación, creemos un archivo de hash ficticio para prepararnos para el descifrado. Usaremos un hash MD5 simple para la demostración.

echo "testuser:5d41402abc4b2a76b9719d911017c592" > ~/project/hashes.txt

Esto crea un archivo hashes.txt en su directorio ~/project con un hash para la contraseña "hello".

Ahora, intente descifrar el hash usando John the Ripper. Incluso sin una GPU física, John the Ripper intentará usar sus módulos habilitados para OpenCL si están disponibles, recurriendo a la CPU si no se encuentran dispositivos.

john --format=raw-md5 ~/project/hashes.txt --wordlist=/usr/share/john/password.lst

Debería ver una salida que indica que John the Ripper está procesando el hash. Si la contraseña "hello" está en la lista de palabras predeterminada, se descifrará.

Using default input encoding: UTF-8
Loaded 1 password hash (Raw-MD5 [MD5])
Cost 1 (iteration count) is 1 for all loaded hashes
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
hello            (testuser)
1g 0:00:00:00 DONE (2024-01-01 12:00) 100.0% 1000000g/s 1000000p/s 1000000c/s 1000000C/s testuser
Session completed.

Este paso confirma que John the Ripper está instalado, sus componentes OpenCL son reconocidos y puede procesar hashes.

Evaluar el Rendimiento de Descifrado de GPU

En este paso, aprenderá cómo evaluar el rendimiento de John the Ripper. Aunque estamos en un entorno virtualizado sin una GPU física, comprender el proceso de evaluación comparativa es crucial para escenarios del mundo real. John the Ripper tiene una herramienta de evaluación comparativa incorporada que puede probar varios tipos de hash.

Para evaluar John the Ripper, use la opción --test. Este comando ejecutará una serie de pruebas contra diferentes algoritmos de hash, mostrando la velocidad de descifrado (intentos por segundo) para cada uno.

john --test

La salida será extensa, mostrando el rendimiento para varios tipos de hash. Busque líneas que incluyan "OpenCL" en su descripción, si se detectaron dispositivos OpenCL. Incluso si no hay una GPU física presente, John the Ripper podría informar un rendimiento OpenCL teórico basado en sus módulos compilados.

Ejemplo de salida (truncada por brevedad):

Benchmarking: Raw-MD5 [MD5]... DONE
Many salts:     1000000 c/s real, 1000000 c/s virtual

Benchmarking: bcrypt ($2*$, $2a$, $2x$, $2y$, $2b$) [Blowfish OpenCL]... DONE
Many salts:     1000000 c/s real, 1000000 c/s virtual
Only one salt:  1000000 c/s real, 1000000 c/s virtual

Los valores c/s (candidatos por segundo) o p/s (contraseñas por segundo) indican la velocidad de descifrado. En un entorno real con una GPU potente, estos números serían significativamente más altos para los algoritmos acelerados por GPU en comparación con las evaluaciones comparativas solo de CPU.

También puede evaluar un tipo de hash específico, por ejemplo, raw-md5, para obtener resultados más enfocados:

john --test=0 --format=raw-md5

Este comando evalúa específicamente el formato raw-md5. La opción --test=0 ejecuta la evaluación comparativa durante un corto período de tiempo, lo cual es útil para comprobaciones rápidas.

Comprender estos resultados de evaluación comparativa es clave para evaluar la efectividad de su configuración de GPU y comparar diferentes configuraciones de hardware.

Solución de Problemas de Descifrado con GPU

En este paso, aprenderá técnicas comunes de solución de problemas para John the Ripper y la aceleración por GPU. Aunque el entorno LabEx no tiene una GPU física, comprender estos pasos es crucial para aplicaciones del mundo real.

Problemas Comunes y Soluciones:

1. "No OpenCL devices found" (No se encontraron dispositivos OpenCL) o "CUDA error":

   • Causa: Controladores de GPU incorrectos o faltantes, o el SDK de OpenCL/CUDA no está instalado correctamente.
   • Solución: Asegúrese de que sus controladores de GPU estén actualizados e instalados correctamente. Para GPUs NVIDIA, instale el CUDA Toolkit. Para GPUs AMD/Intel, asegúrese de que los controladores OpenCL estén instalados. En un entorno virtual, este mensaje es esperado si no se expone ninguna GPU virtual.
   • Comprobar: Ejecute john --list=opencl-devices o nvidia-smi (para NVIDIA) para verificar la detección del dispositivo.

2. Bajo Rendimiento:

   • Causa: Controladores desactualizados, memoria de GPU insuficiente o uso de un tipo de hash optimizado para CPU en la GPU.
   • Solución: Actualice los controladores. Asegúrese de que su GPU tenga suficiente memoria para el tipo de hash y la lista de palabras elegidos. Algunos tipos de hash (por ejemplo, bcrypt, scrypt) están diseñados intencionalmente para ser lentos y consumir mucha memoria, lo que los hace menos eficientes en GPUs en comparación con hashes más simples como MD5.
   • Comprobar: Use john --test para evaluar el rendimiento y compararlo con los valores esperados para su GPU.

3. Bloqueos o Congelamientos:

   • Causa: Sobrecalentamiento, overclocking inestable o conflictos de controladores.
   • Solución: Monitoree la temperatura de la GPU. Reduzca el overclocking si se aplicó. Reinstale los controladores de forma limpia.
   • Comprobar: Use watch -n 1 nvidia-smi (para NVIDIA) para monitorear el uso y la temperatura de la GPU.

4. John the Ripper no utiliza la GPU:

   • Causa: JtR no compilado con soporte de GPU, o el formato de hash específico no es compatible con el módulo de GPU.
   • Solución: Asegúrese de haber instalado la versión correcta de JtR (por ejemplo, john-opencl o john-cuda si están disponibles, o una compilación desde el código fuente con flags de GPU). Verifique que el formato de hash que está descifrando tenga una implementación OpenCL/CUDA en JtR.
   • Comprobar: Ejecute john --list=formats y busque formatos con OpenCL o CUDA en su descripción.

Simulación de un paso de solución de problemas:

Imaginemos que se encontró con un problema y necesitaba verificar la versión de John the Ripper para asegurarse de que admite OpenCL.

john --version

Este comando mostrará la versión de John the Ripper instalada, lo que puede ayudar a identificar si tiene una compilación que incluye soporte de GPU.

John the Ripper 1.9.0-jumbo-1 (linux-gnu)
Copyright (c) 1996-2023 by Solar Designer and others
...

Comprender estos problemas comunes y sus soluciones le ayudará a solucionar eficazmente los problemas al utilizar John the Ripper con aceleración por GPU en escenarios del mundo real.

Resumen

En este laboratorio, ha adquirido una comprensión integral de cómo aprovechar John the Ripper con aceleración por hardware de GPU para un descifrado de contraseñas más rápido. Comenzó explorando los principios fundamentales del paralelismo de GPU y el papel de frameworks como OpenCL.

Luego procedió con los pasos prácticos para configurar su entorno, incluida la instalación de las bibliotecas de desarrollo OpenCL necesarias. Aprendió a instalar John the Ripper, verificar sus capacidades OpenCL y realizar un descifrado básico de hash. Además, exploró las herramientas de evaluación comparativa integradas de John the Ripper para evaluar el rendimiento y discutió técnicas comunes de solución de problemas para problemas de descifrado con GPU.

Al completar este laboratorio, ahora está equipado con el conocimiento para utilizar eficazmente la aceleración por GPU con John the Ripper, mejorando significativamente sus capacidades de descifrado de contraseñas en escenarios del mundo real.