Off by one overflow

Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Support HackTricks

• Check the subscription plans!

• Join the 💬 Discord group or the telegram group or follow us on Twitter 🐦 @hacktricks_live.

• Share hacking tricks by submitting PRs to the HackTricks and HackTricks Cloud github repos.

Basic Information

Om net toegang te hê tot 'n 1B overflow laat 'n aanvaller toe om die size veld van die volgende chunk te verander. Dit laat toe om te manipuleer watter chunks eintlik vrygestel word, wat potensieel 'n chunk kan genereer wat 'n ander legitieme chunk bevat. Die uitbuiting is soortgelyk aan double free of oorvleuelende chunks.

Daar is 2 tipes off by one kwesbaarhede:

• Arbitraire byte: Hierdie soort laat toe om daardie byte met enige waarde te oorskryf

• Null byte (off-by-null): Hierdie soort laat toe om daardie byte slegs met 0x00 te oorskryf

• 'n Algemene voorbeeld van hierdie kwesbaarheid kan gesien word in die volgende kode waar die gedrag van strlen en strcpy onbestendig is, wat toelaat om 'n 0x00 byte aan die begin van die volgende chunk in te stel.

• Dit kan benut word met die House of Einherjar.

• As Tcache gebruik word, kan dit benut word vir 'n double free situasie.

Off-by-null

```c // From https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off_by_one/ int main(void) { char buffer[40]=""; void *chunk1; chunk1 = malloc(24); puts("Get Input"); gets(buffer); if(strlen(buffer)==24) { strcpy(chunk1,buffer); } return 0; } ```

Onder andere kontroles, nou wanneer 'n stuk vry is, word die vorige grootte vergelyk met die grootte wat in die metadata se stuk geconfigureer is, wat hierdie aanval redelik kompleks maak vanaf weergawe 2.28.

Kode voorbeeld:

• https://github.com/DhavalKapil/heap-exploitation/blob/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/shrinking_free_chunks.c

• Hierdie aanval werk nie meer nie weens die gebruik van Tcaches.

• Boonop, as jy probeer om dit te misbruik deur groter stukke te gebruik (sodat tcaches nie betrokke is nie), sal jy die fout kry: malloc(): invalid next size (unsorted)

Doel

• Maak 'n stuk ingesluit binne 'n ander stuk sodat skryftoegang oor daardie tweede stuk toelaat om die ingeslote een te oorskry

Vereistes

• Off by one overflow om die grootte metadata-inligting te wysig

Algemene off-by-one aanval

• Allokeer drie stukke A, B en C (sê groottes 0x20), en nog een om konsolidasie met die top-stuk te voorkom.

• Vry C (ingevoeg in 0x20 Tcache vrylys).

• Gebruik stuk A om oor te vloei op B. Misbruik off-by-one om die size veld van B van 0x21 na 0x41 te wysig.

• Nou het ons B wat die vrye stuk C bevat

• Vry B en allokeer 'n 0x40 stuk (dit sal hier weer geplaas word)

• Ons kan die fd pointer van C wysig, wat steeds vry is (Tcache vergiftiging)

Off-by-null aanval

• 3 stukke geheue (a, b, c) word een na die ander gereserveer. Dan word die middelste een vrygelaat. Die eerste een bevat 'n off by one overflow kwesbaarheid en die aanvaller misbruik dit met 'n 0x00 (as die vorige byte 0x10 was, sou dit die middelste stuk aandui dat dit 0x10 kleiner is as wat dit werklik is).

• Dan word 2 meer kleiner stukke in die middel vrygelaat stuk (b) allokeer, egter, aangesien b + b->size nooit die c stuk opdateer nie omdat die aangeduide adres kleiner is as wat dit moet wees.

• Dan, b1 en c word vrygelaat. Aangesien c - c->prev_size steeds na b (b1 nou) wys, word albei in een stuk gekonsolideer. egter, b2 is steeds binne tussen b1 en c.

• Laastens, 'n nuwe malloc word uitgevoer wat hierdie geheuegebied herwin wat eintlik b2 gaan bevat, wat die eienaar van die nuwe malloc toelaat om die inhoud van b2 te beheer.

Hierdie beeld verduidelik perfek die aanval:

https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks

Ander Voorbeelde & Verwysings

• https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks

• Bon-nie-appetit. HTB Cyber Apocalypse CTF 2022

• Off-by-one weens strlen wat die volgende stuk se size veld oorweeg.

• Tcache word gebruik, so 'n algemene off-by-one aanval werk om 'n arbitrêre skryf primitief met Tcache vergiftiging te verkry.

• Asis CTF 2016 b00ks

• Dit is moontlik om 'n off by one te misbruik om 'n adres van die heap te lek omdat die byte 0x00 van die einde van 'n string wat oorgeskryf word deur die volgende veld.

• Arbitrêre skryf word verkry deur die off by one skryf te misbruik om die pointer na 'n ander plek te laat wys waar 'n valse struktuur met valse pointers gebou sal word. Dan is dit moontlik om die pointer van hierdie struktuur te volg om arbitrêre skryf te verkry.

• Die libc adres word gelek omdat as die heap met mmap uitgebrei word, die geheue wat deur mmap toegeken word 'n vaste offset van libc het.

• Laastens word die arbitrêre skryf misbruik om in die adres van __free_hook te skryf met 'n one gadget.

• plaidctf 2015 plaiddb

• Daar is 'n NULL off by one kwesbaarheid in die getline funksie wat gebruikersinvoerlijnen lees. Hierdie funksie word gebruik om die "sleutel" van die inhoud te lees en nie die inhoud nie.

• In die skrywe word 5 aanvanklike stukke geskep:

• stuk1 (0x200)

• stuk2 (0x50)

• stuk5 (0x68)

• stuk3 (0x1f8)

• stuk4 (0xf0)

• stuk verdediging (0x400) om te voorkom dat dit met die top stuk konsolideer

• Dan word stuk 1, 5 en 3 vrygelaat, so:

[ 0x200 Stuk 1 (vry) ] [ 0x50 Stuk 2 ] [ 0x68 Stuk 5 (vry) ] [ 0x1f8 Stuk 3 (vry) ] [ 0xf0 Stuk 4 ] [ 0x400 Stuk verdediging ]

* Dan, deur stuk3 (0x1f8) te misbruik, word die null off-by-one misbruik deur die prev\_size na `0x4e0` te skryf.
* Let op hoe die groottes van die aanvanklik toegeken stukke 1, 2, 5 en 3 plus die koppe van 4 van daardie stukke gelyk is aan `0x4e0`:  `hex(0x1f8 + 0x10 + 0x68 + 0x10 + 0x50 + 0x10 + 0x200) = 0x4e0`
* Dan, stuk 4 word vrygelaat, wat 'n stuk genereer wat al die stukke tot by die begin verbruik:
* ```python
[ 0x4e0 Stuk 1-2-5-3 (vry) ] [ 0xf0 Stuk 4 (gecorrompeerd) ] [ 0x400 Stuk verdediging ]

[ 0x200 Stuk 1 (vry) ] [ 0x50 Stuk 2 ] [ 0x68 Stuk 5 (vry) ] [ 0x1f8 Stuk 3 (vry) ] [ 0xf0 Stuk 4 ] [ 0x400 Stuk verdediging ]

* Dan, word `0x200` bytes toegeken wat die oorspronklike stuk 1 vul
* En nog 'n 0x200 bytes word toegeken en stuk2 word vernietig en daarom is daar geen fokken lek nie en dit werk nie? Miskien moet dit nie gedoen word nie
* Dan, word 'n ander stuk met 0x58 "a"s toegeken (wat stuk2 oorgeskryf en stuk5 bereik) en wysig die `fd` van die vinnige bin stuk van stuk5 wat dit na `__malloc_hook` wys
* Dan, word 'n stuk van 0x68 toegeken sodat die valse vinnige bin stuk in `__malloc_hook` die volgende vinnige bin stuk is
* Laastens, word 'n nuwe vinnige bin stuk van 0x68 toegeken en `__malloc_hook` word oorgeskryf met 'n `one_gadget` adres

<div data-gb-custom-block data-tag="hint" data-style='success'>

Leer & oefen AWS Hacking:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
Leer & oefen GCP Hacking: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>Ondersteun HackTricks</summary>

* Kyk na die [**subskripsie planne**](https://github.com/sponsors/carlospolop)!
* **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 hacking truuks deur PRs in te dien na die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

</details>

</div>