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

2025-10-10 18:36:50 +00:00 · 2025-08-18 16:17:00 +00:00 · 2025-08-18 16:17:00 +00:00 · 23cddbbc99
commit 23cddbbc99
parent c63e539cab
1 changed files with 116 additions and 51 deletions
--- 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,57 +4,61 @@

 ## Basic Information

-यह तकनीक **Base Pointer (EBP)** को नियंत्रित करने की क्षमता का लाभ उठाती है ताकि EBP रजिस्टर और **`leave; ret`** निर्देश अनुक्रम के सावधानीपूर्वक उपयोग के माध्यम से कई कार्यों के निष्पादन को श्रृंखला में जोड़ा जा सके।
+यह तकनीक **Base Pointer (EBP/RBP)** को नियंत्रित करने की क्षमता का लाभ उठाती है ताकि फ़्रेम पॉइंटर के सावधानीपूर्वक उपयोग और **`leave; ret`** निर्देश अनुक्रम के माध्यम से कई कार्यों के निष्पादन को श्रृंखला में जोड़ा जा सके।

-याद दिलाने के लिए, **`leave`** का मूल अर्थ है:
+याद दिलाने के लिए, x86/x86-64 पर **`leave`** के बराबर है:
 ```
-mov       ebp, esp
-pop       ebp
+mov       rsp, rbp   ; mov esp, ebp on x86
+pop       rbp        ; pop ebp on x86
 ret
 ```
-And as the **EBP is in the stack** before the EIP it's possible to control it controlling the stack.
+And as the saved **EBP/RBP is in the stack** before the saved EIP/RIP, it's possible to control it by controlling the stack.
+
+> Notes
+> - On 64-bit, replace EBP→RBP and ESP→RSP. Semantics are the same.
+> - Some compilers omit the frame pointer (see “EBP might not be used”). In that case, `leave` might not appear and this technique won’t work.

 ### EBP2Ret

-यह तकनीक विशेष रूप से उपयोगी है जब आप **EBP रजिस्टर को बदल सकते हैं लेकिन EIP रजिस्टर को सीधे बदलने का कोई तरीका नहीं है**। यह कार्यों के समाप्त होने पर उनके व्यवहार का लाभ उठाती है।
+यह तकनीक विशेष रूप से उपयोगी है जब आप **सहेजे गए EBP/RBP को बदल सकते हैं लेकिन EIP/RIP को सीधे बदलने का कोई तरीका नहीं है**। यह फ़ंक्शन एपिलॉग व्यवहार का लाभ उठाता है।

-यदि, `fvuln` के निष्पादन के दौरान, आप स्टैक में एक **फर्जी EBP** इंजेक्ट करने में सफल होते हैं जो मेमोरी के उस क्षेत्र की ओर इशारा करता है जहाँ आपका शेलकोड का पता स्थित है (प्लस 4 बाइट्स `pop` ऑपरेशन के लिए), तो आप अप्रत्यक्ष रूप से EIP को नियंत्रित कर सकते हैं। जैसे ही `fvuln` लौटता है, ESP को इस तैयार स्थान पर सेट किया जाता है, और अगला `pop` ऑपरेशन ESP को 4 से घटाता है, **जिससे यह प्रभावी रूप से एक पते की ओर इशारा करता है जिसे हमलावर ने वहाँ स्टोर किया है।**\
-ध्यान दें कि आपको **2 पते जानने की आवश्यकता है**: वह जहाँ ESP जाने वाला है, जहाँ आपको उस पते को लिखने की आवश्यकता होगी जिस पर ESP इशारा करता है।
+यदि, `fvuln` के निष्पादन के दौरान, आप स्टैक में एक **फर्जी EBP** इंजेक्ट करने में सफल होते हैं जो मेमोरी के उस क्षेत्र की ओर इशारा करता है जहां आपका शेलकोड/ROP श्रृंखला पता स्थित है (amd64 पर 8 बाइट्स / x86 पर 4 बाइट्स `pop` के लिए), तो आप अप्रत्यक्ष रूप से RIP को नियंत्रित कर सकते हैं। जैसे ही फ़ंक्शन लौटता है, `leave` RSP को तैयार स्थान पर सेट करता है और अगला `pop rbp` RSP को कम करता है, **जिससे यह उस पते की ओर इशारा करता है जो हमलावर द्वारा वहां संग्रहीत किया गया है**। फिर `ret` उस पते का उपयोग करेगा।
+
+ध्यान दें कि आपको **2 पते जानने की आवश्यकता है**: वह पता जहां ESP/RSP जाने वाला है, और उस पते पर संग्रहीत मान जो `ret` उपभोग करेगा।

 #### Exploit Construction

-पहले आपको एक **पता जानने की आवश्यकता है जहाँ आप मनमाने डेटा / पते लिख सकते हैं**। ESP यहाँ इशारा करेगा और **पहला `ret` चलाएगा**।
+पहले आपको एक **पते के बारे में जानने की आवश्यकता है जहां आप मनमाने डेटा/पते लिख सकते हैं**। RSP यहाँ इशारा करेगा और **पहला `ret` उपभोग करेगा**।

-फिर, आपको उस पते के बारे में जानने की आवश्यकता है जिसका उपयोग `ret` द्वारा **मनमाना कोड निष्पादित करने के लिए किया जाएगा**। आप उपयोग कर सकते हैं:
+फिर, आपको उस पते का चयन करने की आवश्यकता है जिसका उपयोग `ret` करेगा जो **निष्पादन स्थानांतरित करेगा**। आप उपयोग कर सकते हैं:

 - एक मान्य [**ONE_GADGET**](https://github.com/david942j/one_gadget) पता।
- **`system()`** का पता उसके बाद **4 जंक बाइट्स** और `"/bin/sh"` का पता (x86 बिट्स)।
- एक **`jump esp;`** गैजेट ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) का पता उसके बाद **निष्पादित करने के लिए शेलकोड**।
- कुछ [**ROP**](../rop-return-oriented-programing/index.html) श्रृंखला
+- **`system()`** का पता उसके उपयुक्त लौटने और तर्कों के साथ (x86 पर: `ret` लक्ष्य = `&system`, फिर 4 जंक बाइट्स, फिर `&"/bin/sh"`).
+- एक **`jmp esp;`** गैजेट ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) के पते के साथ इनलाइन शेलकोड।
+- एक [**ROP**](../rop-return-oriented-programing/index.html) श्रृंखला जो लिखने योग्य मेमोरी में स्टेज की गई है।

-याद रखें कि नियंत्रित मेमोरी के इन पते से पहले, वहाँ **`4` बाइट्स** होनी चाहिए क्योंकि **`pop`** भाग `leave` निर्देश का है। इन 4B का दुरुपयोग करना संभव होगा एक **दूसरा फर्जी EBP** सेट करने के लिए और निष्पादन को नियंत्रित करना जारी रखने के लिए।
+याद रखें कि नियंत्रित क्षेत्र में इन पते से पहले, `leave` से **`pop ebp/rbp`** के लिए **स्थान होना चाहिए** (amd64 पर 8B, x86 पर 4B)। आप इन बाइट्स का दुरुपयोग कर सकते हैं ताकि एक **दूसरा फर्जी EBP** सेट किया जा सके और पहले कॉल के लौटने के बाद नियंत्रण बनाए रखा जा सके।

 #### Off-By-One Exploit

-इस तकनीक का एक विशिष्ट रूप "Off-By-One Exploit" के रूप में जाना जाता है। इसका उपयोग तब किया जाता है जब आप **केवल EBP के सबसे कम महत्वपूर्ण बाइट को संशोधित कर सकते हैं**। ऐसे मामले में, मेमोरी स्थान जो **`ret`** के साथ कूदने के लिए पता संग्रहीत करता है, उसे EBP के साथ पहले तीन बाइट्स साझा करने चाहिए, जिससे अधिक सीमित परिस्थितियों के साथ समान हेरफेर की अनुमति मिलती है।\
-आमतौर पर इसे 0x00 बाइट को संशोधित किया जाता है ताकि जितना संभव हो सके कूद सके।
+एक भिन्नता है जिसका उपयोग तब किया जाता है जब आप **सहेजे गए EBP/RBP के सबसे कम महत्वपूर्ण बाइट को केवल संशोधित कर सकते हैं**। ऐसे मामले में, मेमोरी स्थान जो **`ret`** के साथ कूदने के लिए पता संग्रहीत करता है, को मूल EBP/RBP के साथ पहले तीन/पांच बाइट्स साझा करना चाहिए ताकि 1-बाइट ओवरराइट इसे पुनर्निर्देशित कर सके। आमतौर पर निम्न बाइट (ऑफसेट 0x00) को निकटतम पृष्ठ/संरेखित क्षेत्र के भीतर जितना संभव हो उतना कूदने के लिए बढ़ाया जाता है।

-इसके अलावा, स्टैक में एक RET स्लेड का उपयोग करना और असली ROP श्रृंखला को अंत में रखना सामान्य है ताकि यह अधिक संभावना हो कि नया ESP RET SLED के अंदर इशारा करे और अंतिम ROP श्रृंखला निष्पादित हो।
+यह भी सामान्य है कि स्टैक में एक RET स्लेड का उपयोग किया जाए और असली ROP श्रृंखला को अंत में रखा जाए ताकि यह अधिक संभावित हो कि नया RSP स्लेड के अंदर इशारा करता है और अंतिम ROP श्रृंखला निष्पादित होती है।

-### **EBP Chaining**
+### EBP Chaining

-इसलिए, स्टैक के `EBP` प्रविष्टि में एक नियंत्रित पता डालकर और `EIP` में `leave; ret` का पता डालकर, यह संभव है कि **`ESP` को स्टैक से नियंत्रित `EBP` पते पर ले जाया जाए**।
+स्टैक के सहेजे गए `EBP` स्लॉट में एक नियंत्रित पता रखकर और `EIP/RIP` में एक `leave; ret` गैजेट रखकर, यह संभव है कि **`ESP/RSP` को एक हमलावर-नियंत्रित पते पर ले जाया जाए**।

-अब, **`ESP`** नियंत्रित है जो एक इच्छित पते की ओर इशारा कर रहा है और निष्पादित करने के लिए अगला निर्देश `RET` है। इसका दुरुपयोग करने के लिए, नियंत्रित ESP स्थान में यह रखा जा सकता है:
+अब `RSP` नियंत्रित है और अगला निर्देश `ret` है। नियंत्रित मेमोरी में कुछ इस तरह रखें:

- **`&(next fake EBP)`** -> `leave` निर्देश से `pop ebp` के कारण नया EBP लोड करें
- **`system()`** -> `ret` द्वारा कॉल किया गया
- **`&(leave;ret)`** -> सिस्टम समाप्त होने के बाद कॉल किया जाएगा, यह ESP को फर्जी EBP पर ले जाएगा और फिर से शुरू करेगा
- **`&("/bin/sh")`**-> `system` के लिए पैरामीटर
+- `&(next fake EBP)` -> `leave` से `pop ebp/rbp` द्वारा लोड किया गया।
+- `&system()` -> `ret` द्वारा कॉल किया गया।
+- `&(leave;ret)` -> `system` समाप्त होने के बाद, RSP को अगले फर्जी EBP पर ले जाता है और जारी रहता है।
+- `&("/bin/sh")` -> `system` के लिए तर्क।

-बुनियादी रूप से इस तरह से कई फर्जी EBPs को जोड़ना संभव है ताकि कार्यक्रम के प्रवाह को नियंत्रित किया जा सके।
+इस तरह यह संभव है कि कई फर्जी EBPs को जोड़कर कार्यक्रम के प्रवाह को नियंत्रित किया जा सके।

-यह [ret2lib](../rop-return-oriented-programing/ret2lib/index.html) की तरह है, लेकिन अधिक जटिल है जिसमें कोई स्पष्ट लाभ नहीं है लेकिन कुछ किनारे के मामलों में दिलचस्प हो सकता है।
+यह एक [ret2lib](../rop-return-oriented-programing/ret2lib/index.html) की तरह है, लेकिन अधिक जटिल और केवल किनारे के मामलों में उपयोगी है।

 इसके अलावा, यहाँ एक [**चुनौती का उदाहरण**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) है जो इस तकनीक का उपयोग करता है एक **स्टैक लीक** के साथ एक विजेता फ़ंक्शन को कॉल करने के लिए। यह पृष्ठ से अंतिम पेलोड है:
 ```python
@ -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())
 ```
-## EBP शायद उपयोग नहीं किया जाएगा
+> amd64 संरेखण टिप: System V ABI कॉल साइट्स पर 16-बाइट स्टैक संरेखण की आवश्यकता होती है। यदि आपकी श्रृंखला `system` जैसी फ़ंक्शंस को कॉल करती है, तो संरेखण बनाए रखने और `movaps` क्रैश से बचने के लिए कॉल से पहले एक संरेखण गैजेट (जैसे, `ret`, या `sub rsp, 8 ; ret`) जोड़ें।

-जैसा कि [**इस पोस्ट में समझाया गया है**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), यदि एक बाइनरी कुछ ऑप्टिमाइजेशन के साथ संकलित की गई है, तो **EBP कभी भी ESP को नियंत्रित नहीं करता**, इसलिए, EBP को नियंत्रित करके काम करने वाला कोई भी एक्सप्लॉइट मूल रूप से विफल हो जाएगा क्योंकि इसका कोई वास्तविक प्रभाव नहीं है।\
-यह इसलिए है क्योंकि **प्रोलॉग और एपिलॉग में बदलाव** होता है यदि बाइनरी ऑप्टिमाइज्ड है।
+## EBP का उपयोग नहीं किया जा सकता

- **ऑप्टिमाइज्ड नहीं:**
+जैसा कि [**इस पोस्ट में समझाया गया है**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), यदि कोई बाइनरी कुछ ऑप्टिमाइजेशन के साथ या फ्रेम-पॉइंटर ओमिशन के साथ संकलित की गई है, तो **EBP/RBP कभी भी ESP/RSP को नियंत्रित नहीं करता**। इसलिए, EBP/RBP को नियंत्रित करके काम करने वाला कोई भी एक्सप्लॉइट विफल हो जाएगा क्योंकि प्रोलॉग/एपिलॉग फ्रेम पॉइंटर से पुनर्स्थापित नहीं करता।
+
+- अनुकूलित नहीं किया गया / फ्रेम पॉइंटर का उपयोग किया गया:
 ```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
 ```
- **अनुकूलित:**
+- अनुकूलित / फ्रेम पॉइंटर छोड़ा गया:
 ```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 को नियंत्रित करने के लिए
+On amd64 आप अक्सर `pop rbp ; ret` देखेंगे इसके बजाय `leave ; ret`, लेकिन अगर फ्रेम पॉइंटर पूरी तरह से छोड़ा गया है तो फिर `rbp`-आधारित उपसंहार के माध्यम से पिवट करने के लिए कोई नहीं है।

-### **`pop rsp`** गैजेट
+## RSP को नियंत्रित करने के अन्य तरीके

-[**इस पृष्ठ पर**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) आप इस तकनीक का उपयोग करते हुए एक उदाहरण पा सकते हैं। इस चुनौती के लिए 2 विशिष्ट तर्कों के साथ एक फ़ंक्शन को कॉल करना आवश्यक था, और वहाँ एक **`pop rsp` गैजेट** था और वहाँ **स्टैक से लीक** है:
+### `pop rsp` गैजेट
+
+[**इस पृष्ठ में**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) आप इस तकनीक का उपयोग करते हुए एक उदाहरण पा सकते हैं। उस चुनौती के लिए 2 विशिष्ट तर्कों के साथ एक फ़ंक्शन को कॉल करना आवश्यक था, और वहाँ एक **`pop rsp` गैजेट** था और वहाँ **स्टैक से लीक** है:
 ```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 @@ xchg <reg>, rsp
 ../rop-return-oriented-programing/ret2esp-ret2reg.md
 {{#endref}}

-## References & Other Examples
+### तेजी से पिवट गैजेट्स खोजना

- [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 बिट, एक से बाहर शोषण एक rop श्रृंखला के साथ जो एक 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 बिट, कोई relro, canary, nx और pie नहीं। प्रोग्राम स्टैक या पाई के लिए एक लीक प्रदान करता है और एक qword का WWW। पहले स्टैक लीक प्राप्त करें और पाई लीक प्राप्त करने के लिए WWW का उपयोग करें। फिर एक स्थायी लूप बनाने के लिए WWW का उपयोग करें जो `.fini_array` प्रविष्टियों का दुरुपयोग करता है + `__libc_csu_fini` को कॉल करता है ([more info here](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). इस "स्थायी" लेखन का दुरुपयोग करते हुए, यह .bss में एक ROP श्रृंखला लिखी जाती है और अंततः इसे RBP के साथ पिवटिंग करने के लिए कॉल किया जाता है।
+अपने पसंदीदा गैजेट खोजक का उपयोग करके क्लासिक पिवट प्राइमिटिव्स के लिए खोजें:
+
+- `leave ; ret` फ़ंक्शनों या लाइब्रेरी में
+- `pop rsp` / `xchg rax, rsp ; ret`
+- `add rsp, <imm> ; ret` (या `add esp, <imm> ; ret` x86 पर)
+
+उदाहरण:
+```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"
+```
+### क्लासिक पिवट स्टेजिंग पैटर्न
+
+एक मजबूत पिवट रणनीति जो कई CTFs/exploits में उपयोग की जाती है:
+
+1) एक छोटे प्रारंभिक ओवरफ्लो का उपयोग करें ताकि `read`/`recv` को एक बड़े लिखने योग्य क्षेत्र (जैसे, `.bss`, heap, या मैप किए गए RW मेमोरी) में कॉल किया जा सके और वहां एक पूर्ण ROP चेन रखी जा सके।
+2) एक पिवट गैजेट (`leave ; ret`, `pop rsp`, `xchg rax, rsp ; ret`) में लौटें ताकि RSP को उस क्षेत्र में ले जाया जा सके।
+3) स्टेज्ड चेन के साथ जारी रखें (जैसे, libc लीक करें, `mprotect` कॉल करें, फिर `read` शेलकोड, फिर उस पर कूदें)।
+
+## आधुनिक रोकथाम जो स्टैक पिवटिंग को तोड़ती हैं (CET/शैडो स्टैक)
+
+आधुनिक x86 CPUs और OSes बढ़ती हुई **CET शैडो स्टैक (SHSTK)** को लागू करते हैं। SHSTK सक्षम होने पर, `ret` सामान्य स्टैक पर लौटने के पते की तुलना हार्डवेयर-सुरक्षित शैडो स्टैक से करता है; कोई भी असंगति एक नियंत्रण-सुरक्षा दोष उठाती है और प्रक्रिया को समाप्त कर देती है। इसलिए, EBP2Ret/leave;ret-आधारित पिवट जैसी तकनीकें पहले `ret` के पिवटेड स्टैक से निष्पादित होते ही क्रैश हो जाएंगी।
+
+- पृष्ठभूमि और गहरे विवरण के लिए देखें:
+
+{{#ref}}
+../common-binary-protections-and-bypasses/cet-and-shadow-stack.md
+{{#endref}}
+
+- लिनक्स पर त्वरित जांच:
+```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
+```
+- प्रयोगशालाओं/CTF के लिए नोट्स:
+- कुछ आधुनिक डिस्ट्रीब्यूशंस CET-सक्षम बाइनरी के लिए SHSTK को सक्षम करते हैं जब हार्डवेयर और glibc समर्थन मौजूद होता है। VMs में नियंत्रित परीक्षण के लिए, SHSTK को सिस्टम-व्यापी `nousershstk` कर्नेल बूट पैरामीटर के माध्यम से अक्षम किया जा सकता है, या स्टार्टअप के दौरान glibc ट्यूनबल्स के माध्यम से चयनात्मक रूप से सक्षम किया जा सकता है (संदर्भ देखें)। उत्पादन लक्ष्यों पर शमन को अक्षम न करें।
+- JOP/COOP या SROP-आधारित तकनीकें कुछ लक्ष्यों पर अभी भी व्यवहार्य हो सकती हैं, लेकिन SHSTK विशेष रूप से `ret`-आधारित पिवट को तोड़ता है।
+
+- Windows नोट: Windows 10+ उपयोगकर्ता-मोड को उजागर करता है और Windows 11 कर्नेल-मोड "हार्डवेयर-प्रवर्तन स्टैक सुरक्षा" को छाया स्टैक्स पर आधारित करता है। CET-संगत प्रक्रियाएँ `ret` पर स्टैक पिवटिंग/ROP को रोकती हैं; डेवलपर्स CETCOMPAT और संबंधित नीतियों के माध्यम से ऑप्ट-इन करते हैं (संदर्भ देखें)।

 ## ARM64

-ARM64 में, कार्यों के **प्रोलॉग और एपिलॉग** स्टैक में **SP रजिस्टर को स्टोर और पुनर्प्राप्त नहीं करते**। इसके अलावा, **`RET`** निर्देश SP द्वारा इंगित पते पर वापस नहीं लौटता, बल्कि **`x30`** के अंदर के पते पर लौटता है।
+ARM64 में, कार्यों के **प्रोलॉग और एपिलॉग** स्टैक में **SP रजिस्टर** को स्टोर और पुनर्प्राप्त नहीं करते हैं। इसके अलावा, **`RET`** निर्देश SP द्वारा इंगित पते पर वापस नहीं लौटता है, बल्कि **`x30`** के अंदर के पते पर लौटता है।

-इसलिए, डिफ़ॉल्ट रूप से, केवल एपिलॉग का दुरुपयोग करके आप **SP रजिस्टर को नियंत्रित नहीं कर पाएंगे** कुछ डेटा को स्टैक के अंदर ओवरराइट करके। और यदि आप SP को नियंत्रित करने में सफल होते हैं, तो भी आपको **`x30`** रजिस्टर को **नियंत्रित करने** का एक तरीका चाहिए।
+इसलिए, डिफ़ॉल्ट रूप से, केवल एपिलॉग का दुरुपयोग करके आप **SP रजिस्टर को नियंत्रित नहीं कर पाएंगे** कुछ डेटा को स्टैक के अंदर ओवरराइट करके। और यदि आप SP को नियंत्रित करने में सफल होते हैं, तो भी आपको **`x30`** रजिस्टर को नियंत्रित करने का एक तरीका चाहिए।

 - प्रोलॉग

 ```armasm
 sub sp, sp, 16
 stp x29, x30, [sp]      // [sp] = x29; [sp + 8] = x30
-mov x29, sp             // FP points to frame record
+mov x29, sp             // FP फ्रेम रिकॉर्ड की ओर इशारा करता है
 ```

 - एपिलॉग
@ -221,4 +275,15 @@ ret
 ../rop-return-oriented-programing/ret2esp-ret2reg.md
 {{#endref}}

+## संदर्भ
+
+- [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 बिट्स, एक रोप श्रृंखला के साथ एक रिट स्लेड से एक ऑफ बाय वन शोषण
+- [https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html](https://guyinatuxedo.github.io/17-stack_pivot/insomnihack18_onewrite/index.html)
+- 64 बिट, कोई relro, कैनरी, nx और pie नहीं। प्रोग्राम स्टैक या pie के लिए एक लीक और एक qword का WWW प्रदान करता है। पहले स्टैक लीक प्राप्त करें और वापस जाने के लिए WWW का उपयोग करें और pie लीक प्राप्त करें। फिर WWW का उपयोग करके एक शाश्वत लूप बनाएं जो `.fini_array` प्रविष्टियों का दुरुपयोग करता है + `__libc_csu_fini` को कॉल करता है ([यहां अधिक जानकारी](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini_array.md)). इस "शाश्वत" लेखन का दुरुपयोग करते हुए, .bss में एक ROP श्रृंखला लिखी जाती है और अंततः इसे RBP के साथ पिवटिंग करते हुए कॉल किया जाता है।
+- Linux कर्नेल दस्तावेज़: नियंत्रण-प्रवाह प्रवर्तन प्रौद्योगिकी (CET) छाया स्टैक — SHSTK, `nousershstk`, `/proc/$PID/status` ध्वज, और `arch_prctl` के माध्यम से सक्षम करने के विवरण। https://www.kernel.org/doc/html/next/x86/shstk.html
+- Microsoft Learn: कर्नेल मोड हार्डवेयर-प्रवर्तन स्टैक सुरक्षा (Windows पर CET छाया स्टैक्स)। https://learn.microsoft.com/en-us/windows-server/security/kernel-mode-hardware-stack-protection
+
 {{#include ../../banners/hacktricks-training.md}}