# EBP2Ret - EBP-ketting

<details>

<summary><strong>Leer AWS-hacking vanaf nul tot held met</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Ander maniere om HackTricks te ondersteun:

* As jy wil sien dat jou **maatskappy geadverteer word in HackTricks** of **HackTricks aflaai in PDF-formaat** Kontroleer die [**INSKRYWINGSPLANNE**](https://github.com/sponsors/carlospolop)!
* Kry die [**amptelike PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Ontdek [**Die PEASS Familie**](https://opensea.io/collection/the-peass-family), ons versameling eksklusiewe [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Sluit aan by die** 💬 [**Discord-groep**](https://discord.gg/hRep4RUj7f) of die [**telegram-groep**](https://t.me/peass) of **volg** ons op **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Deel jou haktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github-opslag.

</details>

## Basiese Inligting

Hierdie tegniek maak gebruik van die vermoë om die **Base Pointer (EBP)** te manipuleer om die uitvoering van verskeie funksies aan mekaar te koppel deur sorgvuldige gebruik van die EBP-register en die `leave; ret` instruksievolgorde.

As 'n herinnering, beteken **`leave`** basies:
```
movl               %ebp, %esp
popl               %ebp
ret
```
En aangesien die **EBP in die stapel** voor die EIP is, is dit moontlik om dit te beheer deur die stapel te beheer.

### EBP2Ret

Hierdie tegniek is veral nuttig wanneer jy die **EBP-register kan verander maar geen direkte manier het om die EIP-register te verander nie**. Dit maak gebruik van die gedrag van funksies wanneer hulle klaar uitgevoer is.

As jy tydens die uitvoering van `fvuln` 'n **vals EBP** in die stapel kan inspuit wat na 'n area in die geheue wys waar jou shellcode se adres geleë is (plus 4 byte om die `pop`-operasie te akkommodeer), kan jy indirek die EIP beheer. Wanneer `fvuln` terugkeer, word die ESP na hierdie gekonstrueerde plek ingestel, en die daaropvolgende `pop`-operasie verminder ESP met 4, wat dit effektief laat wys na jou shellcode. Wanneer die `ret`-instruksie uitgevoer word, word beheer oorgedra na jou shellcode.

#### Uitbuiting Konstruksie

Eerstens moet jy jou shellcode **inspuit na 'n uitvoerbare geheue en die adres kry**, of kry die adres na 'n geldige [**ONE\_GADGET**](https://github.com/david942j/one\_gadget), of maak die ESP wys na 'n plek met die adres van **`system()`** gevolg deur **4 rommelbyte** en die adres van `"/bin/sh"`.

Skep dan 'n vulsel en **kompromitteer die EBP** met die `adres na die shellcode/one_gadget - 4`. Dit moet `-4` wees as gevolg van die `pop`. Dan sal die `ESP` na ons gewenste adres wys en die `ret` sal uitgevoer word.

#### Off-By-One Uitbuiting

Daar is 'n spesifieke variasie van hierdie tegniek bekend as 'n "Off-By-One Uitbuiting". Dit word gebruik wanneer jy slegs die minst betekenisvolle byte van die EBP kan wysig. In so 'n geval moet die geheueplek wat die adres van die shellcode stoor, die eerste drie byte deel met die EBP, wat 'n soortgelyke manipulasie met meer beperkte toestande moontlik maak.

### **EBP Ketting**

Daarom, deur 'n beheerde adres in die `EBP`-inskrywing van die stapel te plaas en 'n adres na `leave; ret` in `EIP`, is dit moontlik om die `ESP` na die beheerde `EBP`-adres van die stapel te **skuif**.

Nou word die **`ESP`** beheer deur na 'n gewenste adres te wys en die volgende instruksie om uit te voer is 'n `RET`. Om hiervan misbruik te maak, is dit moontlik om in die beheerde ESP-plek hierdie te plaas:

* **`&(volgende vals EBP)`** -> Laai die nuwe EBP as gevolg van `pop ebp` van die `leave`-instruksie
* **`system()`** -> Geroep deur `ret`
* **`&(leave;ret)`** -> Geroep nadat die stelsel eindig, sal dit ESP na die vals EBP skuif en weer begin
* **`&("/bin/sh")`**-> Parameter vir `system`

Op hierdie manier is dit moontlik om verskeie valse EBPs aan mekaar te koppel om die vloei van die program te beheer.

Eintlik is dit soos 'n [ret2lib](ret2lib/), maar meer kompleks sonder 'n ooglopende voordeel, maar dit kan interessant wees in sekere randgevalle.