WWW2Exec - __malloc_hook & __free_hook

Reading time: 4 minutes

Malloc Hook

Comme vous pouvez le voir sur le site officiel de GNU, la variable __malloc_hook est un pointeur pointant vers l'adresse d'une fonction qui sera appelée chaque fois que malloc() est appelée stockée dans la section de données de la bibliothèque libc. Par conséquent, si cette adresse est écrasée avec un One Gadget par exemple et que malloc est appelé, le One Gadget sera appelé.

Pour appeler malloc, il est possible d'attendre que le programme l'appelle ou en appelant printf("%10000$c") qui alloue trop de bytes, ce qui fait que libc appelle malloc pour les allouer dans le tas.

Plus d'infos sur One Gadget dans :

One Gadget

Free Hook

Cela a été abusé dans un des exemples de la page abusant d'une attaque de fast bin après avoir abusé d'une attaque de unsorted bin :

Unsorted Bin Attack

Il est possible de trouver l'adresse de __free_hook si le binaire a des symboles avec la commande suivante :

gef➤  p &__free_hook

Dans le post, vous pouvez trouver un guide étape par étape sur la façon de localiser l'adresse du free hook sans symboles. En résumé, dans la fonction free :

gef➤  x/20i free
0xf75dedc0 : push   ebx
0xf75dedc1 : call   0xf768f625
0xf75dedc6 : add    ebx,0x14323a
0xf75dedcc :  sub    esp,0x8
0xf75dedcf :  mov    eax,DWORD PTR [ebx-0x98]
0xf75dedd5 :  mov    ecx,DWORD PTR [esp+0x10]
0xf75dedd9 :  mov    eax,DWORD PTR [eax]--- BREAK HERE
0xf75deddb :  test   eax,eax ;<
0xf75deddd :  jne    0xf75dee50 

Dans la rupture mentionnée dans le code précédent, $eax contiendra l'adresse du free hook.

Maintenant, une attaque fast bin est effectuée :

• Tout d'abord, il est découvert qu'il est possible de travailler avec des chunks de taille 200 dans l'emplacement __free_hook :

• gef➤  p &__free_hook
  

$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook> gef➤ x/60gx 0x7ff1e9e607a8 - 0x59 0x7ff1e9e6074f: 0x0000000000000000 0x0000000000000200 0x7ff1e9e6075f: 0x0000000000000000 0x0000000000000000 0x7ff1e9e6076f <list_all_lock+15>: 0x0000000000000000 0x0000000000000000 0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000 0x0000000000000000

• Si nous parvenons à obtenir un chunk rapide de taille 0x200 à cet emplacement, il sera possible d'écraser un pointeur de fonction qui sera exécuté.
• Pour cela, un nouveau chunk de taille 0xfc est créé et la fonction fusionnée est appelée avec ce pointeur deux fois, de cette manière nous obtenons un pointeur vers un chunk libéré de taille 0xfc*2 = 0x1f8 dans le fast bin.
• Ensuite, la fonction d'édition est appelée dans ce chunk pour modifier l'adresse fd de ce fast bin afin de pointer vers la fonction __free_hook précédente.
• Ensuite, un chunk de taille 0x1f8 est créé pour récupérer du fast bin le chunk inutile précédent, de sorte qu'un autre chunk de taille 0x1f8 soit créé pour obtenir un chunk fast bin dans le __free_hook qui est écrasé avec l'adresse de la fonction system.
• Et enfin, un chunk contenant la chaîne /bin/sh\x00 est libéré en appelant la fonction de suppression, déclenchant la fonction __free_hook qui pointe vers system avec /bin/sh\x00 comme paramètre.

Références

• https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook
• https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md.