Tcache Bin Attack

Reading time: 6 minutes

Basic Information

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

Bins & Memory Allocations

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

L'attaque Tcache (également connue sous le nom de poisoning Tcache) proposée sur la page guyinatuxido est très similaire à l'attaque fast bin où l'objectif est d'écraser le pointeur vers le prochain chunk dans le bin à l'intérieur d'un chunk libéré vers une adresse arbitraire afin qu'il soit ensuite possible de allouer cette adresse spécifique et potentiellement écraser les pointeurs.

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 comme adresse dans le nouveau pointeur une adresse alignée (ou d'exécuter suffisamment de fois le binaire pour que l'adresse écrite soit en fait alignée).

Attaque des index Tcache

Il est généralement possible de trouver au début du tas un chunk contenant le nombre de chunks par index à l'intérieur du tcache et l'adresse du head chunk de chaque index tcache. Si pour une raison quelconque il est possible de modifier cette information, il serait possible de faire pointer le head chunk de certains index vers une adresse souhaitée (comme __malloc_hook) pour ensuite allouer un chunk de la taille de l'index et écraser le contenu de __malloc_hook 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 écrasant seulement les 8 premiers octets, laissant la deuxième adresse vers libc du chunk intacte afin que nous puissions la lire.
• Attaque Tcache : Le binaire est vulnérable à un débordement de tas de 1 octet. Cela sera abusé pour changer le header de taille d'un chunk alloué en le rendant plus grand. Ensuite, ce chunk sera libéré, l'ajoutant au tcache de chunks de fausse taille. Ensuite, nous allouerons un chunk avec la taille falsifiée, et le chunk précédent sera retourné sachant que ce chunk était en fait plus petit et cela nous donne l'opportunité de écraser le prochain chunk en mémoire.
  Nous allons en abuser pour écraser le pointeur FD du prochain chunk pour pointer vers malloc_hook, afin qu'il soit possible d'allouer 2 pointeurs : d'abord le pointeur légitime que nous venons de modifier, puis la deuxième allocation retournera un chunk dans malloc_hook qui peut être abusé 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 libération et une double libération. Dans ce rapport, l'auteur a divulgué une adresse de libc en lisant l'adresse d'un chunk placé dans un petit bin (comme le fuyant depuis le bin non trié mais depuis le petit).
• Attaque Tcache : Une attaque Tcache est effectuée 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 free hook et ensuite il est alloué à nouveau, donc le prochain chunk dans la liste sera dans le free hook. Ensuite, cela est également alloué et il est possible d'écrire l'adresse de system ici, donc lorsque 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 free n'importe quelle adresse dans le tas en indiquant son offset.
• Attaque des index Tcache : Il est possible d'allouer et de libérer un chunk d'une taille qui, lorsqu'elle est stockée à l'intérieur du chunk tcache (le chunk avec les informations des bins tcache), générera une adresse avec la valeur 0x100. Cela est dû au fait que le tcache stocke le nombre de chunks dans 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'abuser en free cette adresse. Cela ajoutera cette adresse à l'index des chunks de taille 0x100 dans le tcache.
• Ensuite, allouer un chunk de taille 0x100, l'adresse précédente sera retournée comme un chunk, permettant d'écraser d'autres index tcache.
  Par exemple, en mettant l'adresse de malloc hook dans l'un d'eux et en allouant un chunk de la taille de cet index, cela accordera un chunk dans le calloc hook, 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é que précédemment avec une restriction supplémentaire.
• Attaque des index Tcache : Attaque similaire à la précédente mais utilisant moins d'étapes en libérant le chunk qui contient les informations 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 free hook comme adresse d'un index, de l'allouer et d'écrire un one gadget dessus.
• Math Door. HTB Cyber Apocalypse CTF 2023
• Write After Free pour ajouter un nombre au pointeur fd.
• Beaucoup de heap feng-shui est nécessaire dans ce défi. Le rapport montre comment contrôler la tête de la liste libre Tcache est très pratique.
• Fuite Glibc via stdout (FSOP).
• Poisoning Tcache pour obtenir un primitive d'écriture arbitraire.