Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-12-18 17:16:10 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md

5.6 KiB
Raw Blame History

WWW2Exec - __malloc_hook & __free_hook

Aprenda hacking AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks:

Malloc Hook

Conforme você pode ver no site oficial da GNU, a variável __malloc_hook é um ponteiro que aponta para o endereço de uma função que será chamada sempre que malloc() for chamado armazenado na seção de dados da biblioteca libc. Portanto, se este endereço for sobrescrito com um One Gadget, por exemplo, e malloc for chamado, o One Gadget será chamado.

Para chamar malloc é possível esperar o programa chamar ou chamando printf("%10000$c") que aloca muitos bytes fazendo com que libc chame malloc para alocá-los no heap.

Mais informações sobre One Gadget em:

{% content-ref url="../rop-return-oriented-programing/ret2lib/one-gadget.md" %} one-gadget.md {% endcontent-ref %}

{% hint style="warning" %} Observe que os hooks são desativados para GLIBC >= 2.34. Existem outras técnicas que podem ser usadas em versões modernas do GLIBC. Veja: https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md. {% endhint %}

Free Hook

Isso foi abusado em um dos exemplos da página abusando de um ataque de fast bin após ter abusado de um ataque de unsorted bin:

{% content-ref url="../heap/unsorted-bin-attack.md" %} unsorted-bin-attack.md {% endcontent-ref %}

Um truque interessante (de aqui) para encontrar a localização do free hook se o binário tiver símbolos é fazer algo como:

gef➤  set __free_hook = 0xfacade
gef➤  search-pattern 0xfacade

No mesmo post, você pode encontrar um guia passo a passo sobre como localizar o endereço do gancho de liberação sem símbolos. Em resumo, na função de liberação:

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

Na quebra mencionada no código anterior em $eax estará localizado o endereço do gancho de liberação.

Agora é realizado um ataque de fast bin:

  • Primeiramente, é descoberto que é possível trabalhar com pedaços rápidos de tamanho 200 na localização do __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
  • Se conseguirmos obter um pedaço rápido de tamanho 0x200 nessa localização, será possível sobrescrever um ponteiro de função que será executado.
  • Para isso, é criado um novo pedaço de tamanho 0xfc e a função mesclada é chamada com esse ponteiro duas vezes, dessa forma obtemos um ponteiro para um pedaço liberado de tamanho 0xfc*2 = 0x1f8 no fast bin.
  • Em seguida, a função de edição é chamada neste pedaço para modificar o endereço fd deste fast bin para apontar para a função anterior __free_hook.
  • Depois, é criado um pedaço com tamanho 0x1f8 para recuperar do fast bin o pedaço inútil anterior, então outro pedaço com tamanho 0x1f8 é criado para obter um pedaço do fast bin no __free_hook que é sobrescrito com o endereço da função system.
  • E finalmente, um pedaço contendo a string /bin/sh\x00 é liberado chamando a função de exclusão, acionando a função __free_hook que aponta para o sistema com /bin/sh\x00 como parâmetro.

Referências