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 sur 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 de la liste non triée en ne remplaçant que les premiers 8B, 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, donc 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 sur 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 et ensuite 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
La principale vulnérabilité ici est la capacité de libérer n'importe quelle adresse dans le tas en indiquant son décalage
Attaque des index Tcache : Il est possible d'allouer et de libérer un chunk d'une taille telle que lorsqu'il est stocké à l'intérieur du chunk tcache (le chunk avec les informations des bins tcache), il générera une adresse avec la valeur 0x100. Cela est dû au fait que le tcache stocke la quantité de chunks sur chaque bin dans des octets différents, donc un chunk dans un index spécifique génère la valeur 0x100.
Ensuite, cette valeur ressemble à un chunk de taille 0x100. Permettant de l'exploiter en le libérant. Cela ajoutera cette adresse à l'index des chunks de taille 0x100 dans le tcache.
Ensuite, en allouant un chunk de taille 0x100, l'adresse précédente sera renvoyée en tant que chunk, permettant d'écraser 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, un chunk dans le crochet calloc sera accordé, ce qui permet d'écrire un one gadget pour obtenir un shell.
CTF https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps1/index.html
Même vulnérabilité qu'auparavant avec une restriction supplémentaire
Attaque des index Tcache : Attaque similaire à la précédente mais en utilisant moins d'étapes en libérant le chunk contenant les informations du tcache afin que son adresse soit ajoutée à l'index tcache de sa taille, il est donc possible d'allouer cette taille et d'obtenir les informations du chunk tcache en tant que chunk, ce qui permet d'ajouter le crochet free en tant qu'adresse d'un index, de l'allouer, et d'écrire un one gadget dessus.