# Maison d'Orange
Apprenez le piratage AWS de zéro à héros avec htARTE (Expert Red Team 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**](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.
## Informations de base ### Code * Trouvez un exemple dans [https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_orange.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_orange.c) * La technique d'exploitation a été corrigée dans ce [correctif](https://sourceware.org/git/?p=glibc.git;a=blobdiff;f=stdlib/abort.c;h=117a507ff88d862445551f2c07abb6e45a716b75;hp=19882f3e3dc1ab830431506329c94dcf1d7cc252;hb=91e7cf982d0104f0e71770f5ae8e3faf352dea9f;hpb=0c25125780083cbba22ed627756548efe282d1a0) donc cela ne fonctionne plus (fonctionne dans les versions antérieures à 2.26) * Même exemple **avec plus de commentaires** dans [https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html](https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html) ### Objectif * Abuser de la fonction `malloc_printerr` ### Exigences * Écraser la taille du chunk supérieur * Fuites de libc et de tas ### Contexte Certains antécédents nécessaires des commentaires de [**cet exemple**](https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html)**:** Le problème est que, dans les anciennes versions de libc, lorsque la fonction `malloc_printerr` était appelée, elle **itérait à travers une liste de structures `_IO_FILE` stockées dans `_IO_list_all`**, et exécutait en fait un pointeur d'instruction dans cette structure.\ Cette attaque forgée une **fausse structure `_IO_FILE`** que nous écrirons dans **`_IO_list_all`**, et provoquera l'exécution de `malloc_printerr`.\ Ensuite, il exécutera **n'importe quelle adresse** que nous avons stockée dans les **structures `_IO_FILE`**, et nous obtiendrons une exécution de code ### Attaque L'attaque commence par parvenir à obtenir le **chunk supérieur** à l'intérieur du **tas non trié**. Cela est réalisé en appelant `malloc` avec une taille supérieure à la taille actuelle du chunk supérieur mais plus petite que **`mmp_.mmap_threshold`** (par défaut 128K), ce qui déclencherait autrement une allocation `mmap`. Chaque fois que la taille du chunk supérieur est modifiée, il est important de s'assurer que le **chunk supérieur + sa taille** est aligné sur la page et que le bit **prev\_inuse** du chunk supérieur est toujours défini. Pour obtenir le chunk supérieur à l'intérieur du tas non trié, allouez un chunk pour créer le chunk supérieur, modifiez la taille du chunk supérieur (avec un débordement dans le chunk alloué) de sorte que **le chunk supérieur + la taille** soit aligné sur la page avec le bit **prev\_inuse** défini. Ensuite, allouez un chunk plus grand que la nouvelle taille du chunk supérieur. Notez que `free` n'est jamais appelé pour placer le chunk supérieur dans le tas non trié. L'ancien chunk supérieur est maintenant dans le tas non trié. En supposant que nous puissions lire des données à l'intérieur (éventuellement en raison d'une vulnérabilité ayant également provoqué le débordement), il est possible de fuiter des adresses de libc à partir de celui-ci et d'obtenir l'adresse de **\_IO\_list\_all**. Une attaque sur le tas non trié est effectuée en abusant du débordement pour écrire `topChunk->bk->fwd = _IO_list_all - 0x10`. Lorsqu'un nouveau chunk est alloué, l'ancien chunk supérieur sera divisé, et un pointeur vers le tas non trié sera écrit dans **`_IO_list_all`**. L'étape suivante consiste à réduire la taille de l'ancien chunk supérieur pour qu'il rentre dans un petit bin, en réglant spécifiquement sa taille sur **0x61**. Cela sert à deux fins : 1. **Insertion dans le petit bin 4** : Lorsque `malloc` parcourt le tas non trié et voit ce chunk, il essaiera de l'insérer dans le petit bin 4 en raison de sa petite taille. Cela fait que le chunk se retrouve en tête de la liste du petit bin 4, qui est l'emplacement du pointeur FD du chunk de **`_IO_list_all`** car nous avons écrit une adresse proche dans **`_IO_list_all`** via l'attaque sur le tas non trié. 2. **Déclenchement d'une vérification de malloc** : Cette manipulation de la taille du chunk provoquera des vérifications internes de `malloc`. Lorsqu'il vérifie la taille du faux chunk suivant, qui sera nulle, cela déclenche une erreur et appelle `malloc_printerr`. La manipulation du petit bin vous permettra de contrôler le pointeur avant du chunk. Le chevauchement avec **\_IO\_list\_all** est utilisé pour forger une fausse structure **\_IO\_FILE**. La structure est soigneusement conçue pour inclure des champs clés comme `_IO_write_base` et `_IO_write_ptr` définis sur des valeurs qui passent les vérifications internes de libc. De plus, une table de saut est créée à l'intérieur de la fausse structure, où un pointeur d'instruction est défini sur l'adresse où un code arbitraire (par exemple, la fonction `system`) peut être exécuté. Pour résumer la partie restante de la technique : * **Réduire l'ancien chunk supérieur** : Ajustez la taille de l'ancien chunk supérieur à **0x61** pour le faire rentrer dans un petit bin. * **Configurer la fausse structure `_IO_FILE`** : Faites chevaucher l'ancien chunk supérieur avec la fausse structure **\_IO\_FILE** et définissez les champs de manière appropriée pour détourner le flux d'exécution. L'étape suivante consiste à forger une fausse structure **\_IO\_FILE** qui chevauche l'ancien chunk supérieur actuellement dans le tas non trié. Les premiers octets de cette structure sont soigneusement conçus pour inclure un pointeur vers une commande (par exemple, "/bin/sh") qui sera exécutée. Les champs clés de la fausse structure **\_IO\_FILE**, tels que `_IO_write_base` et `_IO_write_ptr`, sont définis sur des valeurs qui passent les vérifications internes de libc. De plus, une table de saut est créée à l'intérieur de la fausse structure, où un pointeur d'instruction est défini sur l'adresse où un code arbitraire peut être exécuté. Typiquement, il s'agirait de l'adresse de la fonction `system` ou d'une autre fonction pouvant exécuter des commandes shell. L'attaque culmine lorsque l'appel à `malloc` déclenche l'exécution du code à travers la structure **\_IO\_FILE** manipulée. Cela permet efficacement l'exécution de code arbitraire, aboutissant généralement à un shell ou à l'exécution d'une autre charge malveillante. **Résumé de l'attaque :** 1. **Configurer le chunk supérieur** : Allouer un chunk et modifier la taille du chunk supérieur. 2. **Forcer le chunk supérieur dans le tas non trié** : Allouer un chunk plus grand. 3. **Fuite des adresses de libc** : Utiliser la vulnérabilité pour lire à partir du tas non trié. 4. **Effectuer l'attaque sur le tas non trié** : Écrire dans **\_IO\_list\_all** en utilisant un débordement. 5. **Réduire l'ancien chunk supérieur** : Ajustez sa taille pour qu'il rentre dans un petit bin. 6. **Configurer une fausse structure \_IO\_FILE** : Forger une fausse structure de fichier pour détourner le flux de contrôle. 7. **Déclencher l'exécution de code** : Allouer un chunk pour exécuter l'attaque et exécuter du code arbitraire. Cette approche exploite les mécanismes de gestion du tas, les fuites d'informations libc et les débordements de tas pour parvenir à une exécution de code sans appeler directement `free`. En concevant soigneusement la fausse structure **\_IO\_FILE** et en la plaçant au bon endroit, l'attaque peut détourner le flux de contrôle lors des opérations standard d'allocation de mémoire. Cela permet l'exécution de code arbitraire, aboutissant potentiellement à un shell ou à d'autres activités malveillantes. ## Références * [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_orange/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_orange/) * [https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html](https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html)
Apprenez le piratage AWS de zéro à héros avec htARTE (Expert Red Team 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**](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) github repos.