* Controleer de [**abonnementsplannen**](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 hacktruuks 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.
Die **Tcache-aanval** (ook bekend as **Tcache-vergiftiging**) voorgestel in die [**guyinatuxido-bladsy**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) is baie soortgelyk aan die vinnige bin-aanval waar die doel is om die aanwysers na die volgende blok in die bin binne 'n vrygemaakte blok te oorskryf na 'n willekeurige adres sodat dit later moontlik is om daardie spesifieke adres toe te ken en moontlik aanwysers te oorskryf.
Tans, as jy die genoemde kode hardloop, sal jy die fout kry: **`malloc(): unaligned tcache chunk detected`**. Dus moet 'n uitgelyste adres geskryf word in die nuwe aanwyser 'n uitgelyste adres (of voer die binêre genoeg keer uit sodat die geskrewe adres eintlik uitgelyst is).
Gewoonlik is dit moontlik om aan die begin van die heap 'n blok te vind wat die **aantal blokke per indeks** binne die tcache bevat en die adres na die **hoofblok van elke tcache-indeks**. As dit om een of ander rede moontlik is om hierdie inligting te wysig, sou dit moontlik wees om **die hoofblok van 'n sekere indeks na 'n gewenste adres te laat wys** (soos `__malloc_hook`) sodat 'n blok van die grootte van die indeks toegewys kan word en die inhoud van `__malloc_hook` in hierdie geval oorskryf kan word.
* **Libc-inligtingslek**: Dit is moontlik om die tcaches te vul, 'n blok by die ongesorteerde lys te voeg, die tcache leeg te maak en die blok van die ongesorteerde bin **her toe te ken** deur slegs die eerste 8B te oorskryf, waar die **tweede adres na libc van die blok ongeskonde bly sodat ons dit kan lees**.
* **Tcache-aanval**: Die binêre is kwesbaar vir 'n 1B-heap-oorvloei. Dit sal misbruik word om die **grootte-kop** van 'n toegewysde blok te verander om dit groter te maak. Dan sal hierdie blok **vrygestel** word, dit by die tcache van blokke van die valse grootte voeg. Dan sal ons 'n blok met die vervalste grootte toewys, en die vorige blok sal **teruggegee word met die wete dat hierdie blok eintlik kleiner was** en dit bied die geleentheid om **die volgende blok in die geheue te oorskryf**.\
Ons sal dit misbruik om die volgende blok se FD-aanwyser te **oor te skryf om na `malloc_hook` te wys**, sodat dit moontlik is om 2 aanwysers toe te ken: eerste die regte aanwyser wat ons net gewysig het, en dan sal die tweede toekenning 'n blok in **`malloc_hook`** teruggee wat dit moontlik is om te misbruik om 'n **een gadget** te skryf.
* **Libc-inligtingslek**: Daar is 'n gebruik na vry en 'n dubbele vrylating. In hierdie uiteensetting het die skrywer 'n adres van libc gelekte deur die adres van 'n blok in 'n klein bin te lees (soos om dit van die ongesorteerde bin te lek, maar van die klein een)
* **Tcache-aanval**: 'n Tcache word uitgevoer deur 'n **dubbele vrylating**. Dieselfde blok word twee keer vrygestel, sodat binne die Tcache die blok na homself sal wys. Dan word dit toegewys, sy FD-aanwyser word gewysig om na die **vrye haak** te wys en dan word dit weer toegewys sodat die volgende blok in die lys in die vrye haak sal wees. Dan word dit ook toegewys en dit is moontlik om die adres van `system` hier te skryf sodat wanneer 'n malloc wat `"/bin/sh"` bevat, vrygestel word, kry ons 'n skul.
* Die hoofkwesbaarheid hier is die vermoë om enige adres in die heap vry te stel deur sy offset aan te dui
* **Tcache-indekse-aanval**: Dit is moontlik om 'n blok van 'n grootte toe te ken en vry te stel wat wanneer dit binne die tcache-blok gestoor word (die blok met die inligting van die tcache-binne) 'n **adres met die waarde 0x100** sal genereer. Dit is omdat die tcache die aantal blokke in elke bin in verskillende bytes stoor, daarom genereer een blok in een spesifieke indeks die waarde 0x100.
* Dan lyk hierdie waarde asof daar 'n blok van grootte 0x100 is. Dit maak dit moontlik om dit te misbruik deur hierdie adres te `vry` maak. Dit sal **daardie adres by die indeks van blokke van grootte 0x100 in die tcache voeg**.
* Dan, **toekenning** van 'n blok van grootte **0x100**, sal die vorige adres as 'n blok teruggegee word, wat dit moontlik maak om ander tcache-indekse te oorskryf.\
Byvoorbeeld om die adres van malloc-haak in een van hulle te plaas en 'n blok van die grootte van daardie indeks toe te ken, sal 'n blok in calloc-haak gee, wat dit moontlik maak om 'n een gadget te skryf om 'n s-skulp te kry.
* **Tcache-indekse-aanval**: Soortgelyke aanval aan die vorige een maar met minder stappe deur **die blok wat die tcache-inligting bevat vry te stel** sodat sy adres by die tcache-indeks van sy grootte gevoeg word sodat dit moontlik is om daardie grootte toe te ken en die tcache-blok inligting as 'n blok te kry, wat dit moontlik maak om die vrye haak as die adres van een indeks by te voeg, dit toe te ken, en 'n een gadget daarop te skryf.
* **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 hacktruuks deur PR's in te dien by die** [**HackTricks**](https://github.com/carlospolop/hacktricks) en [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
