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

# Maison de la Force



<details>

<summary><strong>Apprenez le piratage AWS de zéro à héros avec</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Expert en équipe rouge AWS de HackTricks)</strong></a><strong>!</strong></summary>

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**](https://github.com/sponsors/carlospolop)!
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**La famille PEASS**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) dépôts GitHub.

</details>

## Informations de base

### Code

* Cette technique a été corrigée ([**ici**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=30a17d8c95fbfb15c52d1115803b63aaa73a285c)) et produit cette erreur : `malloc(): corrupted top size`
* Vous pouvez essayer le [**code d'ici**](https://guyinatuxedo.github.io/41-house\_of\_force/house\_force\_exp/index.html) 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 une allocation quelconque 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:
```c
// 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://github.com/shellphish/how2heap/tree/master?tab=readme-ov-file)
* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/)
* [https://heap-exploitation.dhavalkapil.com/attacks/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://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://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](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](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 é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](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#2016-bctf-bcloud), 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](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 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, écrire dans le crochet l'adresse de `system`, écrire dans un chunk `"/bin/sh"` et enfin libérer le chunk avec ce contenu de chaîne.