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 !
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 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
La technique d'exploitation a été corrigée dans ce correctif 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

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:

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 :

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é.
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 :

Configurer le chunk supérieur : Allouer un chunk et modifier la taille du chunk supérieur.
Forcer le chunk supérieur dans le tas non trié : Allouer un chunk plus grand.
Fuite des adresses de libc : Utiliser la vulnérabilité pour lire à partir du tas non trié.
Effectuer l'attaque sur le tas non trié : Écrire dans _IO_list_all en utilisant un débordement.
Réduire l'ancien chunk supérieur : Ajustez sa taille pour qu'il rentre dans un petit bin.
Configurer une fausse structure _IO_FILE : Forger une fausse structure de fichier pour détourner le flux de contrôle.
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