Attaque Tcache Bin

Apprenez le piratage AWS de zéro à héros avec htARTE (Expert Red Team AWS HackTricks)!

Autres façons de soutenir HackTricks :

Si vous souhaitez voir votre entreprise annoncée dans HackTricks ou télécharger HackTricks en PDF, consultez les PLANS D'ABONNEMENT !
Obtenez le swag officiel PEASS & HackTricks
Découvrez La famille PEASS, notre collection exclusive de NFTs
Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez-nous sur Twitter 🐦 @hacktricks_live.
Partagez vos astuces de piratage en soumettant des PR aux HackTricks et HackTricks Cloud dépôts GitHub.

Informations de base

Pour plus d'informations sur ce qu'est un tcache bin, consultez cette page :

{% content-ref url="bins-and-memory-allocations.md" %} bins-and-memory-allocations.md {% endcontent-ref %}

Tout d'abord, notez que le Tcache a été introduit dans la version 2.26 de glibc.

L'attaque Tcache proposée dans la page de guyinatuxido est très similaire à l'attaque fast bin où le but est de remplacer le pointeur vers le chunk suivant dans le bin à l'intérieur d'un chunk libéré par une adresse arbitraire afin de allouer cette adresse spécifique et potentiellement écraser des pointeurs par la suite.

Cependant, de nos jours, si vous exécutez le code mentionné, vous obtiendrez l'erreur : malloc(): unaligned tcache chunk detected. Il est donc nécessaire d'écrire une adresse alignée dans le nouveau pointeur (ou d'exécuter suffisamment de fois le binaire pour que l'adresse écrite soit effectivement alignée).

Attaque des index Tcache

Il est généralement possible de trouver au début du tas un chunk contenant la quantité de chunks par index à l'intérieur du tcache et l'adresse de la tête du chunk de chaque index tcache. Si, pour une raison quelconque, il est possible de modifier ces informations, il serait possible de faire pointer la tête du chunk de certains index vers une adresse souhaitée (comme le crochet malloc) pour ensuite allouer un chunk de la taille de l'index et écraser le contenu du crochet malloc dans ce cas.

Exemples

CTF https://guyinatuxedo.github.io/29-tcache/dcquals19_babyheap/index.html
Fuite d'informations libc : Il est possible de remplir les tcaches, d'ajouter un chunk dans la liste non triée, de vider le tcache et de ré-allouer le chunk depuis le bin non trié en ne remplaçant que les 8 premiers octets, laissant la deuxième adresse vers libc du chunk intacte pour que nous puissions la lire.
Attaque Tcache : Le binaire est vulnérable à un débordement de tas de 1B. Cela sera exploité pour modifier l'en-tête de taille d'un chunk alloué le rendant plus grand. Ensuite, ce chunk sera libéré, ajouté au tcache des chunks de la fausse taille. Ensuite, nous allouerons un chunk avec la taille falsifiée, et le chunk précédent sera retourné en sachant que ce chunk était en réalité plus petit et cela ouvre la possibilité de écraser le chunk suivant en mémoire.
Nous allons exploiter cela pour écraser le pointeur FD du chunk suivant pour pointer vers malloc_hook, puis il est possible d'allouer 2 pointeurs : d'abord le pointeur légitime que nous venons de modifier, puis la deuxième allocation renverra un chunk dans malloc_hook qu'il est possible d'exploiter pour écrire un one gadget.
CTF https://guyinatuxedo.github.io/29-tcache/plaid19_cpp/index.html
Fuite d'informations libc : Il y a une utilisation après la libération et une double libération. Dans ce compte rendu, l'auteur a divulgué une adresse de libc en lisant l'adresse d'un chunk placé dans un petit bin (comme en le fuyant du bin non trié mais du petit).
Attaque Tcache : Un Tcache est effectué via une double libération. Le même chunk est libéré deux fois, donc à l'intérieur du Tcache, le chunk pointera vers lui-même. Ensuite, il est alloué, son pointeur FD est modifié pour pointer vers le crochet free puis il est alloué à nouveau, de sorte que le chunk suivant dans la liste sera dans le crochet free. Ensuite, cela est également alloué et il est possible d'écrire l'adresse de system ici, donc lorsqu'un malloc contenant "/bin/sh" est libéré, nous obtenons un shell.
CTF https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps0/index.html
Attaque des index Tcache : Il est possible d'allouer et de libérer un chunk d'une taille qui, lorsqu'elle est stockée dans les informations du tcache, générera une position ayant la valeur 0x100 (car le byte indique combien de chunks dans cet index sont stockés). En abusant de cette valeur, il est possible de libérer cette adresse car elle ressemble à un chunk de taille 0x100. Cela ajoutera cette adresse à l'index des chunks de taille 0x100 dans le tcache.
Ensuite, en allouant un chunk de taille 0x100, il est possible d'écraser l'adresse initiale du chunk d'autres index tcache. Par exemple, en mettant l'adresse du crochet malloc dans l'un d'eux et en allouant un chunk de la taille de cet index, cela permettra d'obtenir un chunk dans le crochet calloc, ce qui permet d'écrire un one gadget pour obtenir un shell.