Hashcat & John: Password Cracking

Recuperación y Auditoría de Contraseñas a Gran Escala

---

Autor: ViciousByte Security Team Nivel: Intermedio - Avanzado Duración: 8-12 horas de lectura práctica Versión: 1.0 Última actualización: June 2026

---

Lo que vas a dominar

Una guía práctica y densa sobre Hashcat & John: Password Cracking, de nivel Intermedio - Avanzado, con Hashcat, John the Ripper, hashid, CeWL, Hydra.

• Instalación y configuración profesional (Linux, Windows, macOS y Docker)
• Comandos y flujos de trabajo del mundo real, explicados línea por línea
• Casos prácticos y troubleshooting con soluciones probadas
• Scripts y plantillas listos para usar

Duración: 8-12 horas de lectura práctica · Nivel: Intermedio - Avanzado

---

Hashcat & John: Password Cracking — Guía Premium de Maestría

Introducción

---

1. Bienvenida y Contexto

En 2025, el cracking de contraseñas no es un arte oscuro relegado a sótanos: es una disciplina central en cada engagement de seguridad ofensiva y defensiva. Las contraseñas siguen siendo el mecanismo de autenticación más ubicuo — y el más débil. El 81% de las brechas relacionadas con hacking en 2024 involucraron credenciales robadas o débiles, según el Verizon DBIR 2024. No importa si auditas una Active Directory con 50,000 usuarios, realizas un pentest externo contra una aplicación web, o recuperas acceso a un sistema legacy durante una respuesta a incidentes: vas a necesitar crackear hashes.

Hashcat y John the Ripper son los dos titanes que dominan este terreno. Hashcat, con su motor de GPU brutalmente optimizado, alcanza velocidades de 300 GH/s para NTLM en una RTX 4090. John the Ripper (JtR) ofrece una flexibilidad incomparable con sus modos de ataque híbridos, reglas de mutación avanzadas y soporte para formatos exóticos que Hashcat ni siquiera toca. Juntos forman un arsenal que ningún profesional puede ignorar.

Casos reales que definen la relevancia:

• En 2023, un equipo de red team comprometió un dominio Fortune 500 partiendo de un hash NetNTLMv2 capturado con Responder. Hashcat en modo diccionario + reglas OneRuleToRuleThemAll rompió la contraseña en 47 segundos. Ese hash dio acceso a una cuenta de servicio con privilegios de administrador local en 200 servidores.
• Durante la auditoría de una fintech en 2024, se extrajeron 2.3 millones de hashes bcrypt de una base de datos comprometida. Con 8 GPUs NVIDIA A100 en la nube, Hashcat probó 14 mil millones de candidatos en 6 horas y recuperó el 12% de las contraseñas — suficiente para demostrar el riesgo sistémico y forzar una rotación global.
• John the Ripper, con su modo single crack y reglas internas, sigue siendo imbatible para cracking rápido de hashes UNIX en entornos donde no hay GPU disponible. En un incidente de respuesta en 2024, JtR recuperó la contraseña root de un servidor Solaris legacy en menos de 3 minutos usando variaciones del nombre de la empresa.

Evolución y tendencias actuales:

• Hashcat 6.2.6+ incorpora kernels optimizados para arquitecturas AMD CDNA e Intel Xe, soporte para algoritmos post-cuánticos en fase experimental (SPHINCS+, CRYSTALS-Dilithium) y modos de ataque por fuerza bruta con máscaras que aprovechan estadísticas de fugas reales (rockyou2024, COMB, LinkedIn).
• John the Ripper 1.9.0-jumbo-1+ expandió su soporte a formatos como DPAPI masterkeys de Windows, hashes de Bitcoin Core, Ethereum keystore, y PDF 2.0 con AES-256. Su motor de reglas ahora permite generar variaciones Unicode y emoji, algo crítico dado que el 6% de las contraseñas en fugas recientes contienen emojis.
• La integración con cloud cracking (AWS EC2 G5, Azure NVads, Google Cloud G2) permite desplegar clústeres efímeros de 8 GPUs por menos de $12/hora, democratizando ataques que antes requerían hardware dedicado de $50k.
• La defensa también evoluciona: los algoritmos modernos (Argon2id, yescrypt) y políticas de rotación estrictas obligan al atacante a ser más inteligente. Ya no basta con fuerza bruta; se requiere cracking basado en reglas contextuales, análisis de patrones corporativos y generación de diccionarios específicos por industria.

Esta guía te coloca en la frontera de esa evolución. No aprenderás a ejecutar hashcat -a 0 -m 1000 hash.txt rockyou.txt y ya. Aprenderás a diseñar campañas de cracking que combinan inteligencia de fuentes abiertas, generación de wordlists con CeWL y herramientas de scraping, optimización de kernels, distribución de carga en múltiples GPUs, y análisis post-cracking para extraer políticas de contraseñas del adversario.

---

2. ¿Para Quién es Esta Guía?

Perfil del lector ideal:

• Pentesters y consultores de seguridad ofensiva que realizan auditorías internas/externas y necesitan crackear hashes de manera eficiente y profesional.
• Red teamers que capturan NetNTLMv2, Kerberoasting hashes, o AS-REP roastables y deben convertirlos en acceso real.
• Blue teamers y analistas de threat hunting que validan la fortaleza de las contraseñas de su organización mediante ejercicios de cracking controlado (password strength assessment).
• Investigadores de seguridad y forenses digitales que recuperan acceso a evidencia cifrada (discos, archivos, wallets).
• Estudiantes avanzados que se preparan para certificaciones como OSCP, GPEN, PNPT, o CREST CRT.

Prerrequisitos técnicos:

• Conocimiento sólido de línea de comandos Linux/Windows (bash, PowerShell).
• Comprensión básica de funciones hash (MD5, SHA1, SHA256, bcrypt, PBKDF2) y protocolos de autenticación (NTLM, Kerberos, WPA2).
• Familiaridad con formatos de hashes comunes (modo Hashcat, sintaxis JtR).
• No necesitas ser programador, pero sí entender scripts en Python y Bash para automatizar tareas. Si puedes leer un bucle for y modificar variables, estás listo.

Qué aprenderás exactamente:

• Instalación y optimización de Hashcat y JtR en Linux, Windows y WSL2, con compilación desde fuente para aprovechar instrucciones AVX2/AVX512.
• Identificación precisa de tipos de hash con hashid, hash-identifier y análisis manual de estructura.
• Diseño de ataques: diccionario, reglas, máscaras, híbridos, combinator, y fuerza bruta con presupuesto de tiempo.
• Generación de wordlists específicas con CeWL, TTPs de scraping, y manipulación de fugas masivas (COMB, rockyou2024).
• Uso de reglas avanzadas: OneRuleToRuleThemAll, d3ad0ne, InsidePro-PasswordsPro, y creación de reglas propias basadas en patrones corporativos.
• Cracking distribuido con Hashtopolis y despliegue cloud automatizado con scripts Terraform.
• Extracción de hashes de fuentes reales: SAM/SYSTEM, NTDS.dit, shadow, DPAPI, Kerberos, WPA2 handshakes, archivos cifrados (ZIP, RAR, PDF, Office).
• Análisis post-cracking: métricas de efectividad, generación de reportes ejecutivos y recomendaciones de hardening.

---

3. Qué Hace Diferente a Esta Guía

El mercado está inundado de tutoriales superficiales que te muestran hashcat -a 0 y te dicen "usa rockyou.txt". Esta guía es radicalmente distinta.

Enfoque práctico vs teórico: Cada capítulo está construido alrededor de un escenario real. No te explico qué es un ataque de diccionario; te pongo frente a un hash NTLM extraído de un controlador de dominio y te guío para crackearlo en menos de 2 minutos usando reglas optimizadas. No teorizo sobre fuerza bruta; te doy un script que calcula el keyspace exacto para una máscara de 10 caracteres y estima el tiempo en tu GPU específica. Todo es aplicable inmediatamente en tu próximo engagement.

Ejemplos reales del mundo laboral:

• Caso 1: Crackeo de hashes Kerberoasting (modo 13100) usando un diccionario generado a partir del sitio web corporativo con CeWL y reglas que añaden años, símbolos y patrones de la industria (banca, salud, tech).
• Caso 2: Recuperación de contraseña de un archivo ZIP con AES-256 (modo 13600) que contiene evidencia forense, usando un ataque de máscara basado en la política de contraseñas conocida de la organización.
• Caso 3: Auditoría de 100,000 hashes bcrypt de una fuga interna: filtrado por complejidad, ataque incremental con diccionarios ordenados por probabilidad (rockyou2024 con frecuencia), y reporte automático con hashcat --show y análisis en Python.

Scripts y comandos listos para usar: Cada técnica incluye el comando completo, explicado parámetro por parámetro, y el output real esperado. Además, proporciono scripts en Python y Bash para automatizar tareas repetitivas: extracción de hashes de múltiples fuentes, generación de wordlists con reglas personalizadas, splitting de diccionarios para cracking distribuido, y parseo de resultados. No hay placeholders. Todo el código ha sido probado en entornos reales con Hashcat 6.2.6 y JtR 1.9.0-jumbo-1.

Troubleshooting de problemas comunes:

• "Hashcat no detecta mi GPU": guía paso a paso para instalar drivers NVIDIA/AMD, CUDA/OpenCL, y comprobar con hashcat -I.
• "El ataque va lento": análisis de cuellos de botella (temperatura, power limit, workload profile) y optimización con -w 4, --gpu-temp-retain, y overclocking seguro.
• "John no reconoce el hash": cómo depurar con --format=raw-md5 y --list=formats, y cómo convertir formatos entre Hashcat y JtR.
• "Me sale 'Exhausted' sin resultados": verificación de que el hash y el ataque coinciden, uso de --show y --left, y estrategias para ampliar el ataque sin empezar de cero.

---

4. Estructura de la Guía

La guía está organizada en 8 capítulos progresivos que te llevan desde la instalación hasta campañas de cracking de nivel empresarial.

1. Fundamentos y Setup: Instalación nativa y cloud, compilación optimizada, benchmarks, y configuración de entornos multi-GPU.
2. Identificación y Extracción de Hashes: Uso de hashid, análisis manual, extracción de Windows (SAM, NTDS, DPAPI), Linux (shadow), redes (WPA2, Kerberos), y archivos cifrados.
3. Ataques Clásicos y Optimización: Diccionario, reglas, máscaras, combinator, y fuerza bruta. Uso de las reglas más efectivas del planeta y creación de reglas personalizadas.
4. Generación de Wordlists Profesionales: CeWL, scraping, manipulación de fugas (COMB, rockyou2024), y generación contextual por industria.
5. Cracking Distribuido y Cloud: Hashtopolis, despliegue automatizado en AWS/Azure/GCP, y estrategias de cracking colaborativo.
6. Casos de Estudio Reales: Escenarios completos de pentest, red team, forense y auditoría de políticas.
7. Análisis Post-Cracking y Reportes: Métricas, visualización, y recomendaciones de hardening basadas en los resultados.
8. Automatización y Scripting: Scripts para integrar cracking en pipelines de CI/CD, notificaciones, y workflows de respuesta.

Metodología de aprendizaje: Cada capítulo sigue el ciclo Explicación → Demostración → Ejercicio → Caso Real. Lees el concepto, ves el comando ejecutándose con output real, realizas un ejercicio guiado con un hash proporcionado, y finalmente aplicas la técnica en un escenario simulado que refleja un engagement real.

Cómo aprovechar al máximo el contenido:

• Ejecuta cada comando en tu propio laboratorio (te proporciono hashes de prueba y un entorno Docker con todas las herramientas).
• No te saltes los ejercicios: están diseñados para exponer los errores comunes que cometen incluso profesionales con experiencia.
• Usa los scripts como base para tus propias herramientas; modifícalos y adáptalos a tu entorno.
• Participa en la comunidad de Discord asociada a la guía donde compartimos wordlists, reglas y estrategias.

---

5. Disclaimer Legal y Ético

Esta guía es una herramienta educativa para profesionales de la seguridad informática. El conocimiento aquí contenido debe usarse exclusivamente en contextos donde tengas autorización explícita por escrito del propietario de los sistemas o datos. Esto incluye:

• Pentests y auditorías de seguridad contratadas formalmente.
• Ejercicios de red team internos con reglas de engagement aprobadas.
• Investigación de seguridad en entornos controlados y propios.
• Recuperación de acceso a sistemas o datos propios o autorizados.
• Actividades académicas y de formación en ciberseguridad.

Usos prohibidos:

• Crackear contraseñas de sistemas o cuentas sin autorización.
• Acceder, modificar o exfiltrar datos ajenos.
• Vulnerar la seguridad de terceros con fines maliciosos, lucrativos o de cualquier índole no autorizada.
• Distribuir hashes o wordlists obtenidas ilegalmente.

Responsabilidades: El autor y los distribuidores de esta guía no asumen ninguna responsabilidad por el uso indebido de la información aquí presentada. El lector es el único responsable de sus acciones y debe cumplir con todas las leyes locales, nacionales e internacionales aplicables. El cracking de contraseñas sin permiso es un delito en la mayoría de jurisdicciones y puede acarrear penas de prisión y multas sustanciales.

Contexto profesional: En el ámbito profesional, el cracking de contraseñas es una práctica estándar y necesaria. Las normas PCI DSS (requisito 8.3.1) exigen que las organizaciones evalúen la fortaleza de sus contraseñas. Los frameworks como NIST SP 800-63B recomiendan verificar que las contraseñas no figuren en listas de contraseñas comprometidas. Las auditorías ISO 27001 incluyen pruebas de resistencia de credenciales. Esta guía te prepara para realizar esas tareas de manera competente y ética.

Si tienes dudas sobre la legalidad de una acción, no la realices. Consulta con un abogado especializado en derecho informático. La ignorancia de la ley no exime de su cumplimiento.

---

6. Certificaciones y Carrera

Dominar Hashcat y John the Ripper no es un fin en sí mismo: es un diferenciador competitivo que acelera tu carrera en seguridad ofensiva y defensiva.

Certificaciones relacionadas:

• OSCP (Offensive Security Certified Professional): El cracking de hashes es fundamental en el examen de 24 horas. Esta guía cubre exactamente las técnicas que necesitas para romper los hashes que encontrarás en los desafíos de Active Directory.
• GPEN (GIAC Penetration Tester): El dominio 5 (Password Attacks) evalúa competencia en cracking. Aquí obtienes el conocimiento práctico para superar esa sección con soltura.
• PNPT (Practical Network Penetration Tester): El examen de TCM Security incluye cracking de hashes Kerberoasting y NetNTLMv2. Nuestros casos de estudio replican ese escenario.
• CREST CRT/CCT: Las certificaciones CREST requieren demostrar habilidades de cracking en entornos simulados. Esta guía te da la fluidez necesaria.
• eCPPTv2 / eWPTXv2: Los exámenes de INE/eLearnSecurity incluyen extracción y cracking de hashes diversos. Cubrimos todos los formatos relevantes.

Oportunidades laborales:

• Pentester Junior/Senior: El cracking eficiente reduce el tiempo de engagement y aumenta la probabilidad de comprometer objetivos críticos. Un pentester que crackea un hash en

---

Hashcat & John: Password Cracking — Guía Premium de Maestría

Capítulo 1: Fundamentos y Setup Profesional

---

1.1 ¿Qué es Hashcat? — Definición Técnica y Contexto Operacional

Hashcat es el motor de cracking de hashes más rápido y avanzado del mundo. No es una simple herramienta: es un framework de ataque por fuerza bruta, diccionario, reglas, máscaras y combinatoria que aprovecha al máximo CPU, GPU, FPGA y aceleradores dedicados mediante OpenCL, CUDA y Metal. Su núcleo está escrito en C altamente optimizado con kernels ensamblados a mano para algoritmos específicos (MD5, SHA1, SHA256, bcrypt, WPA/WPA2, NTLM, Kerberos, etc.). Soporta más de 300 tipos de hash y modos de ataque que cubren desde contraseñas simples hasta esquemas empresariales complejos.

Historia y evolución: Hashcat nació en 2009 como "atomcrack" de la mano de Jens "atom" Steube. En 2011 se liberó oclHashcat (OpenCL) y en 2015 se unificaron CPU y GPU en el actual hashcat. La versión 6.x (2021) introdujo el backend Metal para Apple Silicon, soporte para algoritmos post‑cuánticos y modos de ataque híbridos. Hoy es el estándar de facto en auditorías de seguridad, pentesting y recuperación forense.

Casos de uso reales en empresas:

• Auditorías de Active Directory: cracking de hashes NTLM extraídos de NTDS.dit para validar políticas de contraseñas.
• Respuesta a incidentes: recuperación de contraseñas de archivos cifrados (PDF, ZIP, Office) durante investigaciones forenses.
• Pruebas de penetración: cracking de handshakes WPA2 capturados con aircrack‑ng para demostrar debilidad de PSK.
• Cumplimiento normativo: verificación de que los hashes almacenados en bases de datos (bcrypt, Argon2) resisten ataques con hardware real.

Comparación con alternativas:

| Herramienta | Velocidad GPU | Algoritmos | Modos de ataque | Extensibilidad | Licencia | |-------------|---------------|------------|-----------------|----------------|----------| | Hashcat | Extrema (OpenCL/CUDA/Metal) | 300+ | Diccionario, reglas, máscara, combinator, híbrido, príncipe | Plugins, kernels propios | MIT / Propietaria (hashcat+) | | John the Ripper | Alta (OpenCL limitado) | 200+ | Diccionario, reglas, incremental, Markov | Parches comunitarios | GPLv2 | | Hydra | Solo CPU (ataque online) | N/A (servicios) | Diccionario, fuerza bruta | Módulos de protocolo | AGPLv3 | | Cain & Abel | Solo CPU (legado) | 20+ | Diccionario, tablas arcoíris | Ninguna | Freeware |

Ventajas:

• Rendimiento inigualable: kernels optimizados por algoritmo, uso de memoria compartida, vectorización.
• Flexibilidad: reglas, máscaras, ataques combinatorios y príncipe permiten modelar cualquier política de contraseñas.
• Automatización: salida en formato potfile, integración con scripts, modo restauración de sesión.
• Comunidad activa: foros, reglas públicas (OneRuleToRuleThemAll), diccionarios masivos.

Limitaciones:

• Requiere hardware GPU moderno para máximo rendimiento; CPU solo es viable para algoritmos lentos (bcrypt).
• No realiza ataques online (no es Hydra); es exclusivamente offline contra hashes.
• Curva de aprendizaje: la sintaxis de máscaras y reglas puede ser intimidante para novatos.
• Algoritmos muy lentos (Argon2id con parámetros altos) siguen siendo prácticamente inmunes incluso con clusters.

---

1.2 Arquitectura y Componentes Internos

Hashcat se compone de cuatro capas:

1. Frontend (CLI): parsea argumentos, carga hashes, diccionarios, reglas y máscaras, y orquesta la sesión.
2. Motor de ataque: genera candidatos según el modo (straight, combinator, mask, hybrid) y los alimenta al backend.
3. Backend de cómputo: gestiona dispositivos OpenCL/CUDA/Metal, compila kernels JIT, distribuye trabajo en lotes y recoge resultados.
4. Kernels de hash: implementaciones específicas por algoritmo, escritas en OpenCL C o CUDA, con optimizaciones como bitslicing, SIMD y precomputación de constantes.

Componentes principales:

• hashcat binario: el ejecutable único que integra todos los backends.
• hashcat.hctune: archivo de tuning automático con perfiles de workload óptimos por dispositivo y algoritmo.
• hashcat.potfile: almacena hashes crackeados (hash:plain) para evitar re‑trabajo y como salida final.
• hashcat.restore: archivo de sesión para reanudar ataques interrumpidos.
• OpenCL/: kernels compilados en caché (.kernel).
• rules/: directorio con reglas predefinidas (best64.rule, d3ad0ne.rule, etc.).
• masks/: máscaras predefinidas para ataques de fuerza bruta inteligente.

Dependencias críticas:

• Linux: OpenCL ICD (ocl-icd-libopencl1), drivers de GPU (NVIDIA: nvidia-opencl-icd; AMD: rocm-opencl-runtime; Intel: intel-opencl-icd).
• Windows: NVIDIA CUDA Toolkit o AMD ROCm, OpenCL.dll del fabricante.
• macOS: Metal framework (integrado en el SO), no requiere OpenCL adicional.
• Compilación desde fuente: gcc, make, libpthread, libssl-dev (para algoritmos que usan AES-NI).

Flujo de trabajo típico:

[Hashlist] → hashcat (modo ataque) → [Motor genera candidatos] → [Backend GPU/CPU] → [Kernel calcula hash] → [Comparación] → [Coincidencia → potfile]

ASCII del pipeline:

+----------+ +----------------+ +------------------+ +-------------+
| Hashlist | --> | Motor de ataque| --> | Backend (GPU/CPU)| --> | Comparación |
+----------+ +----------------+ +------------------+ +-------------+
^ | |
| v v
+------- Reglas/Máscaras/Diccionarios Kernel JIT potfile (éxito)

---

1.3 Instalación Paso a Paso — Todos los Sistemas

Requisitos del Sistema

• RAM: 4 GB mínimo; 16 GB recomendado para diccionarios grandes y reglas complejas.
• CPU: Cualquier x86_64 moderno; para CPU‑only, núcleos rápidos (Intel i7/i9, AMD Ryzen 7/9).
• GPU: NVIDIA (CUDA 11+), AMD (ROCm 5+), Intel (OpenCL 3.0), Apple Silicon M1/M2/M3 (Metal 3). VRAM: 4 GB mínimo, 8 GB+ ideal.
• Disco: 10 GB libres para diccionarios, reglas y sesiones.
• SO: Linux (Ubuntu 20.04+, Debian 11+, RHEL 8+), Windows 10/11 (64‑bit), macOS 12+.

Descarga e Instalación

Linux (Ubuntu/Debian):

## 1. Actualizar repositorios e instalar dependencias
sudo apt update && sudo apt install -y ocl-icd-libopencl1 opencl-headers clinfo \
pocl-opencl-icd git make gcc

## 2. Instalar drivers GPU (NVIDIA)
sudo apt install -y nvidia-driver-545 nvidia-opencl-icd-545
## Para AMD (ROCm) — requiere kernel 5.15+
## sudo apt install rocm-opencl-runtime

## 3. Verificar plataformas OpenCL
clinfo | grep -i "platform name"

## 4. Clonar hashcat desde GitHub (versión estable)
git clone https://github.com/hashcat/hashcat.git
cd hashcat

## 5. Compilar (opcional, el binario precompilado ya funciona)
make -j$(nproc)
sudo make install # instala en /usr/local/bin

## 6. Verificar
hashcat --version
hashcat -I # lista dispositivos

Linux (RedHat/CentOS/Rocky):

## 1. Habilitar EPEL y instalar dependencias
sudo dnf install -y epel-release
sudo dnf install -y ocl-icd-devel opencl-headers clinfo git make gcc

## 2. Drivers NVIDIA (desde repositorio NVIDIA)
sudo dnf config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
sudo dnf install -y cuda-drivers nvidia-opencl
## AMD: ROCm desde repo AMD

## 3. Compilar igual que en Debian
git clone https://github.com/hashcat/hashcat.git
cd hashcat && make -j$(nproc) && sudo make install

Windows:

1. Descargar el binario oficial desde hashcat.net/hashcat (versión hashcat-6.2.6.7z).
2. Extraer con 7‑Zip en C:\Tools\hashcat.
3. Instalar drivers GPU:

• NVIDIA: descargar CUDA Toolkit 12.x desde developer.nvidia.com.
• AMD: instalar Adrenalin Edition con OpenCL.
• Intel: instalar Intel OpenCL Runtime.

4. Agregar al PATH del sistema: C:\Tools\hashcat y C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.4\bin.
5. Verificar en PowerShell:

hashcat.exe --version
hashcat.exe -I

macOS (Apple Silicon/Intel):

## 1. Instalar Homebrew si no está
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

## 2. Instalar hashcat (ya incluye backend Metal)
brew install hashcat

## 3. Verificar
hashcat --version
hashcat -I # debe mostrar "Apple M1/M2 GPU" con Metal

Troubleshooting M1/M2: Si hashcat -I no muestra GPU, asegurar que Xcode Command Line Tools esté instalado (xcode-select --install). Metal funciona nativamente sin OpenCL.

Docker (entorno reproducible): Dockerfile:

FROM nvidia/cuda:12.4.0-devel-ubuntu22.04
RUN apt-get update && apt-get install -y ocl-icd-libopencl1 opencl-headers clinfo git make gcc
RUN git clone https://github.com/hashcat/hashcat.git /opt/hashcat && \
cd /opt/hashcat && make -j$(nproc) && make install
WORKDIR /data
ENTRYPOINT ["hashcat"]

docker-compose.yml:

version: '3.8'
services:
hashcat:
build: .
runtime: nvidia
environment:
- NVIDIA_VISIBLE_DEVICES=all
volumes:
- ./data:/data
entrypoint: hashcat

Construir y ejecutar:

docker-compose build
docker-compose run --rm hashcat -I
docker-compose run --rm hashcat -m 0 -a 3 /data/hashes.txt ?l?l?l?l

Verificación y Troubleshooting de Errores Comunes

Comandos de verificación:

hashcat --version # debe mostrar v6.2.6+
hashcat -I # lista todos los dispositivos con capacidad
hashcat -b -m 0 # benchmark MD5 en todos los dispositivos
hashcat -b -m 1000 # benchmark NTLM

Errores frecuentes:

• No devices found/left: OpenCL no detecta GPU. Solución: reinstalar drivers, verificar con clinfo. En Windows, asegurar que OpenCL.dll esté en PATH.
• clGetDeviceIDs(): CL_DEVICE_NOT_FOUND: el driver OpenCL no está instalado o es incompatible. Instalar el ICD correcto del fabricante.
• * Device #1: ATTENTION! OpenCL kernel self-test failed: kernels compilados incorrectamente. Borrar caché ~/.hashcat/kernels/ y re‑ejecutar.
• Cannot convert rule...: error de sintaxis en archivo de reglas. Validar con hashcat --stdout -r regla.rule dicc.txt.
• insufficient memory: reducir workload profile (-w 1) o usar diccionarios más pequeños.

---

1.4 Configuración Inicial y Puesta a Punto Profesional

Archivos de configuración: Hashcat no usa un archivo .conf tradicional; la configuración se realiza mediante argumentos CLI y variables de entorno. Sin embargo, existen archivos clave:

• hashcat.hctune: ubicado junto al binario, contiene perfiles de workload por dispositivo. No editar manualmente a menos que se desarrollen kernels propios.
• hashcat.potfile: por defecto en ~/.hashcat/hashcat.potfile (Linux) o %USERPROFILE%\.hashcat\hashcat.potfile (Windows). Almacena los cracks previos.
• hashcat.restore: se genera automáticamente al interrumpir una sesión; permite reanudar con --restore.

Variables de entorno críticas:

## Forzar backend específico (útil si hay múltiples plataformas)
export HASHCAT_OPENCL=1 # usar OpenCL
export HASHCAT_CUDA=1 # usar CUDA (solo NVIDIA)
export HASHCAT_METAL=1 # usar Metal (macOS)

## Directorio de sesiones personalizado
export HASHCAT_SESSION_DIR=/mnt/nas/hashcat_sessions

## Limitar dispositivos (por índice)
export HASHCAT_DEVICES=1,2 # usar solo dispositivos 1 y 2

## Aumentar caché de kernels (acelera inicio)
export HASHCAT_KERNEL_CACHE=/ssd/hashcat_kernels

Configuración de proxies/VPN: Hashcat no realiza conexiones de red durante el cracking, por lo que no necesita proxy. Sin embargo, para descargar diccionarios o reglas de repositorios remotos, se puede configurar:

export http_proxy=http://proxy:8080
export https_proxy=http://proxy:8080
git clone https://github.com/... # usará el proxy

Logging y debugging:

## Activar depuración detallada
hashcat -m 0 -a 3 --debug-mode=1 --debug-file=debug.log hashes.txt ?a?a?a?a

## Registrar toda la salida
hashcat ... 2>&1 | tee session_$(date +%Y%m%d_%H%

---

## 🔒 Hashcat & John: Password Cracking — Guía Premium de Maestría

## Capítulo 2: Técnicas Avanzadas

---

### 2.1 Comandos Esenciales

Dominar la línea de comandos es lo que separa al script kiddie del operador real. Aquí tienes los 20 comandos que usarás a diario, con sintaxis completa, parámetros críticos y el output que debes esperar. No hay atajos: cada flag tiene un propósito y vas a entenderlo.

**1. Ataque por diccionario clásico (Hashcat)**
```bash
hashcat -m 0 -a 0 -w 3 --status --status-timer=10 -O hashes.txt rockyou.txt

• -m 0: modo MD5. Cambia según el hash (1000=NTLM, 1800=sha512crypt, etc.).
• -a 0: ataque straight (diccionario).
• -w 3: perfil de workload alto (usa toda la GPU).
• --status: muestra progreso interactivo.
• --status-timer=10: actualiza cada 10 segundos.
• -O: optimiza kernels limitando longitud de contraseña a 32 (más velocidad).
• Output esperado: línea Cracked al final, y durante el proceso verás Progress..., Rejected..., Restore.Point....

2. Ataque por máscara (Hashcat)

hashcat -m 1000 -a 3 -w 3 --increment --increment-min=8 --increment-max=12 hashes.ntlm ?u?l?l?l?l?l?l?d?d

• -a 3: ataque por máscara.
• --increment: prueba longitudes crecientes desde min hasta max.
• Máscara ?u?l?l?l?l?l?l?d?d: una mayúscula, 6 minúsculas, 2 dígitos. Personaliza con ?l, ?u, ?d, ?s, ?a.
• Output: Candidates.#1.... muestra ejemplos generados.

3. Ataque combinator (Hashcat)

hashcat -m 0 -a 1 -w 3 --stdout -j '$-' -k '$$' dict1.txt dict2.txt | hashcat -m 0 -a 0 hashes.txt

• -a 1: combinator, une cada palabra de dict1 con cada una de dict2.
• -j '$-': aplica regla a palabra izquierda (añade guion al final).
• -k '$$': aplica regla a palabra derecha (añade dólar al final).
• Se puede pipear a otro hashcat para ataque straight con el diccionario generado.

4. Ataque híbrido (Hashcat)

hashcat -m 0 -a 6 -w 3 hashes.txt dict.txt ?d?d?d?d

• -a 6: híbrido wordlist + máscara (añade máscara a cada palabra).
• -a 7: máscara + wordlist (prefijo máscara a cada palabra).
• Aquí añade 4 dígitos al final de cada palabra del diccionario.

5. Reglas (Hashcat)

hashcat -m 0 -a 0 -w 3 -r best64.rule hashes.txt rockyou.txt

• -r best64.rule: aplica reglas de mutación (leet, capitalización, append, etc.).
• Las reglas se almacenan en archivos .rule. Puedes encadenar varias con -r múltiple.

6. Modo benchmark (Hashcat)

hashcat -b -m 1000

• -b: benchmark. Mide velocidad de tu hardware para ese tipo de hash.
• Output: Speed.#1.........: 12345.6 MH/s (ejemplo para NTLM en GPU moderna).

7. Restaurar sesión (Hashcat)

hashcat --restore --session mysession

• --session: nombre de sesión al iniciar. Si se interrumpe, --restore continúa desde el checkpoint.

8. Mostrar resultados cracked (Hashcat)

hashcat -m 1000 --show --username hashes.ntlm

• --show: imprime hashes crackeados con contraseña en claro.
• --username: si el archivo tiene formato user:hash, muestra usuario también.
• Output: Administrator:500:aad3b435b51404eeaad3b435b51404ee:Password123

9. John the Ripper: modo single crack

john --single --format=NT hashes.ntlm

• --single: modo rápido que usa variaciones del nombre de usuario (si está presente) y reglas internas.
• Ideal para primeros intentos.

10. John: wordlist con reglas

john --wordlist=rockyou.txt --rules=Jumbo --format=NT hashes.ntlm

• --rules=Jumbo: aplica el conjunto de reglas Jumbo integrado (miles de mutaciones).
• --format=NT: especifica formato (NT es NTLM). John autodetecta si no se pone, pero es más lento.

11. John: ataque incremental (fuerza bruta)

john --incremental=All --format=NT hashes.ntlm

• --incremental=All: fuerza bruta con todos los caracteres imprimibles. Muy lento, último recurso.

12. John: mostrar resultados

john --show --format=NT hashes.ntlm

• Similar a hashcat --show. Muestra usuario:contraseña.

13. Hashcat: modo prince (ataque combinator probabilístico)

hashcat -m 0 -a 8 -w 3 hashes.txt rockyou.txt

• -a 8: Prince attack, genera candidatos combinando fragmentos de palabras del diccionario con un algoritmo de probabilidad. Muy efectivo.

14. Hashcat: generar diccionario con reglas (stdout)

hashcat --stdout -r best64.rule rockyou.txt | sort -u > mutated.txt

• --stdout: no crackea, solo aplica reglas y saca por pantalla. Redirige a archivo para usar después.

15. John: generar diccionario con reglas

john --wordlist=rockyou.txt --rules=Jumbo --stdout > mutated_john.txt

• Similar, pero con reglas de John.

16. Hashcat: ataque por fuerza bruta pura (máscara sin diccionario)

hashcat -m 0 -a 3 -w 3 --increment --increment-min=1 --increment-max=6 hashes.txt ?a?a?a?a?a?a

• ?a: cualquier carácter imprimible. Para longitudes 1-6. Útil para hashes cortos.

17. Hashcat: modo asociación (asociación de palabras)

hashcat -m 0 -a 9 -w 3 hashes.txt dict1.txt dict2.txt

• -a 9: Association attack. Combina palabras de dos diccionarios usando un algoritmo de asociación entrenado. Requiere archivos .dictstat generados con hashcat --dictstat.

18. John: modo Markov (estadístico)

john --markov --format=NT hashes.ntlm

• --markov: genera candidatos basados en probabilidades de transición de caracteres. Más rápido que incremental puro.

19. Hashcat: limitar temperatura de GPU

hashcat -m 1000 -a 3 -w 3 --gpu-temp-abort=85 hashes.ntlm ?a?a?a?a?a?a?a?a

• --gpu-temp-abort=85: aborta si GPU alcanza 85°C. Protege hardware en sesiones largas.

20. John: sesiones y restauración

john --session=ntlm_crack --wordlist=rockyou.txt --rules=Jumbo --format=NT hashes.ntlm
john --restore=ntlm_crack

• --session: guarda progreso. --restore continúa.

Output real de una sesión de Hashcat:

Session..........: hashcat
Status...........: Running
Hash.Mode........: 1000 (NTLM)
Hash.Target......: hashes.ntlm
Time.Started.....: Mon Mar 10 14:22:15 2025 (5 secs)
Time.Estimated...: Mon Mar 10 14:30:00 2025 (7 mins, 45 secs)
Kernel.Feature...: Optimized Kernel
Guess.Base.......: File (rockyou.txt)
Guess.Mod........: Rules (best64.rule)
Speed.#1.........: 12345.6 MH/s (98.34ms) @ Accel:512 Loops:64 Thr:1024 Vec:1
Recovered........: 1/5 (20.00%) Digests, 1/5 (20.00%) Salts
Progress.........: 12345678/98765432 (12.50%)
Rejected.........: 0/12345678 (0.00%)
Restore.Point....: 12345678/98765432 (12.50%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:0-1
Candidate.Engine.: Device Generator
Candidates.#1....: Password1 -> Passw0rd!
Hardware.Mon.#1..: Temp: 68c Fan:45% Util:98% Core:1950MHz Mem:6800MHz Bus:16

---

2.2 Automatización con Scripts

La automatización convierte horas de trabajo manual en un proceso repetible y auditable. Aquí tienes scripts completos, listos para producción, con logging profesional y scheduling.

Script Bash: Crackeo Automático con Wordlists y Reglas

Este script itera sobre múltiples diccionarios y reglas, registra resultados y envía notificaciones. Ideal para laboratorios de cracking continuo

---

Hashcat & John: Password Cracking — Guía Premium de Maestría

---

Contenido Premium

Los siguientes capítulos están disponibles en la versión completa:

• Capítulo 3: Análisis de Casos Reales
• Capítulo 4: Ejercicios Prácticos Guiados
• Capítulo 5: Troubleshooting y FAQs
• Capítulo 6: Recursos y Certificaciones
• Scripts completos y plantillas
• Soporte técnico incluido

Desbloquear Contenido Completo