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

Maison de la Force

{% hint style="success" %} Apprenez et pratiquez le piratage AWS :Formation HackTricks AWS Red Team Expert (ARTE)
Apprenez et pratiquez le piratage GCP : Formation HackTricks GCP Red Team Expert (GRTE)

Soutenez HackTricks

• Consultez les plans d'abonnement!
• Rejoignez le 💬 groupe Discord ou le groupe Telegram ou suivez-nous sur Twitter 🐦 @hacktricks_live.
• Partagez des astuces de piratage en soumettant des PR aux HackTricks et HackTricks Cloud github repos.

{% endhint %}

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 morceau dans une adresse spécifique.

Exigences

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

Attaque

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

Ensuite, calculez la distance entre l'adresse du morceau supérieur et l'espace cible à allouer. Cela est nécessaire car un malloc de cette taille sera effectué pour déplacer le morceau supérieur à cette position. C'est ainsi que 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 à 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 de la heap
• 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 a été 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'il soit divulgué 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 arriver au 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.