hacktricks/binary-exploitation/heap/house-of-force.md

Maison de la Force

Apprenez le piratage AWS de zéro à héros avec htARTE (Expert en équipe rouge AWS de 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 github repos.

Informations de Base

Code

• Cette technique a été corrigée (ici) et produit cette erreur : malloc(): corrupted top size
• Vous pouvez essayer le code d'ici pour le tester si vous le souhaitez.

Objectif

• L'objectif de cette attaque est de pouvoir allouer un chunk à une adresse spécifique.

Exigences

• Un débordement qui permet de remplacer la taille de l'en-tête du chunk supérieur (par exemple, -1).
• Pouvoir contrôler la taille de l'allocation du tas

Attaque

Si un attaquant souhaite allouer un chunk à l'adresse P pour remplacer une valeur ici. Il commence par remplacer la taille du chunk supérieur par -1 (peut-être avec un débordement). Cela garantit que malloc n'utilisera pas mmap pour une allocation quelconque car le chunk supérieur aura toujours suffisamment d'espace.

Ensuite, calculez la distance entre l'adresse du chunk supérieur et l'espace cible à allouer. Cela est nécessaire car un malloc de cette taille sera effectué pour déplacer le chunk supérieur à cette position. Voici comment la différence/taille peut être facilement calculée:

// From https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c#L59C2-L67C5
/*
* The evil_size is calulcated as (nb is the number of bytes requested + space for metadata):
* new_top = old_top + nb
* nb = new_top - old_top
* req + 2sizeof(long) = new_top - old_top
* req = new_top - old_top - 2sizeof(long)
* req = target - 2sizeof(long) - old_top - 2sizeof(long)
* req = target - old_top - 4*sizeof(long)
*/

Par conséquent, allouer une taille de cible - old_top - 4*sizeof(long) (les 4 longs sont dus aux métadonnées du chunk supérieur et du nouveau chunk lors de l'allocation) déplacera le chunk supérieur à l'adresse que nous voulons écraser. Ensuite, effectuez un autre malloc pour obtenir un chunk contenant le début des données à écrire à l'adresse cible.

Références et Autres Exemples

• https://github.com/shellphish/how2heap/tree/master
• https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/
• https://heap-exploitation.dhavalkapil.com/attacks/house_of_force
• https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c
• https://guyinatuxedo.github.io/41-house_of_force/house_force_exp/index.html
• https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/#hitcon-training-lab-11
• Le but de ce scénario est un ret2win où nous devons modifier l'adresse d'une fonction qui va être appelée par l'adresse de la fonction ret2win
• Le binaire a un débordement qui peut être exploité pour modifier la taille du chunk supérieur, qui est modifié en -1 ou p64(0xffffffffffffffff)
• Ensuite, l'adresse de l'endroit où se trouve le pointeur à écraser est calculée, et la différence entre la position actuelle du chunk supérieur et cet endroit est allouée avec malloc
• Enfin, un nouveau chunk est alloué qui contiendra cette cible désirée à l'intérieur et qui sera écrasée par la fonction ret2win
• https://shift--crops-hatenablog-com.translate.goog/entry/2016/03/21/171249?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp
• Dans Input your name:, il y a une vulnérabilité initiale qui permet de divulguer une adresse du tas
• Ensuite, dans les fonctionnalités Org: et Host:, il est possible de remplir les 64B du pointeur s lorsqu'on demande le nom de l'org, qui dans la pile est suivi de l'adresse de v2, qui est ensuite suivi du nom d'hôte indiqué. Comme ensuite, strcpy va copier le contenu de s dans un chunk de taille 64B, il est possible de écraser la taille du chunk supérieur avec les données mises à l'intérieur du nom d'hôte.
• Maintenant qu'une écriture arbitraire est possible, le GOT de atoi a été écrasé avec l'adresse de printf. il est alors possible de divulguer l'adresse de IO_2_1_stderr avec %24$p. Et avec cette fuite de libc, il était possible de réécrire le GOT de atoi avec l'adresse de system et de l'appeler en passant en paramètre /bin/sh
• Une méthode alternative proposée dans cet autre writeup, consiste à écraser free avec puts, puis à ajouter l'adresse de atoi@got, dans le pointeur qui sera plus tard libéré pour qu'elle soit divulguée et avec cette fuite réécrire à nouveau atoi@got avec system et l'appeler avec /bin/sh.
• https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html
• Il y a une UAF permettant de réutiliser un chunk qui a été libéré sans effacer le pointeur. Comme il y a quelques méthodes de lecture, il est possible de divulguer une adresse de libc en écrivant un pointeur vers la fonction free dans le GOT ici, puis en appelant la fonction de lecture.
• Ensuite, House of force a été utilisé (en abusant de l'UAF) pour écraser la taille de l'espace restant avec un -1, allouer un chunk suffisamment grand pour atteindre le crochet free, puis allouer un autre chunk qui contiendra le crochet free. Ensuite, écrivez dans le crochet l'adresse de system, écrivez dans un chunk "/bin/sh" et enfin libérez le chunk avec ce contenu de chaîne.