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

Casa da Força

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

Outras maneiras de apoiar o HackTricks:

• Se você quiser ver sua empresa anunciada no HackTricks ou baixar o HackTricks em PDF Verifique os PLANOS DE ASSINATURA!
• Adquira o swag oficial PEASS & HackTricks
• Descubra A Família PEASS, nossa coleção exclusiva de NFTs
• Junte-se ao 💬 grupo Discord ou ao grupo telegram ou siga-nos no Twitter 🐦 @hacktricks_live.
• Compartilhe seus truques de hacking enviando PRs para os HackTricks e HackTricks Cloud repositórios do github.

Informações Básicas

Código

• Esta técnica foi corrigida (aqui) e produz este erro: malloc(): corrupted top size
• Você pode testar o código daqui se quiser.

Objetivo

• O objetivo deste ataque é ser capaz de alocar um chunk em um endereço específico.

Requisitos

• Um overflow que permita sobrescrever o tamanho do cabeçalho do top chunk (por exemplo, -1).
• Ser capaz de controlar o tamanho da alocação do heap

Ataque

Se um atacante deseja alocar um chunk no endereço P para sobrescrever um valor aqui. Ele começa sobrescrevendo o tamanho do top chunk com -1 (talvez com um overflow). Isso garante que o malloc não usará mmap para nenhuma alocação, pois o Top chunk sempre terá espaço suficiente.

Em seguida, calcule a distância entre o endereço do top chunk e o espaço-alvo para alocar. Isso ocorre porque um malloc com esse tamanho será realizado para mover o top chunk para essa posição. É assim que a diferença/tamanho pode ser facilmente calculada:

// 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)
*/

Portanto, alocar um tamanho de target - old_top - 4*sizeof(long) (os 4 longs são devido aos metadados do chunk superior e do novo chunk quando alocado) moverá o chunk superior para o endereço que queremos sobrescrever.
Em seguida, faça outro malloc para obter um chunk no endereço alvo.

Referências e Outros Exemplos

• https://github.com/shellphish/how2heap/tree/master
• https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/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://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
• O objetivo deste cenário é um ret2win onde precisamos modificar o endereço de uma função que será chamada pelo endereço da função ret2win
• O binário tem um overflow que pode ser explorado para modificar o tamanho do top chunk, que é modificado para -1 ou p64(0xffffffffffffffff)
• Em seguida, é calculado o endereço do local onde o ponteiro a ser sobrescrito existe, e a diferença da posição atual do top chunk até lá é alocada com malloc
• Finalmente, um novo chunk é alocado que conterá este alvo desejado dentro, que é sobrescrito pela função 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
• No Input your name:, há uma vulnerabilidade inicial que permite vazar um endereço do heap
• Em seguida, nas funcionalidades Org: e Host:, é possível preencher os 64B do ponteiro s quando solicitado pelo nome da organização, que na pilha é seguido pelo endereço de v2, que é então seguido pelo nome do host indicado. Como então, strcpy vai copiar o conteúdo de s para um chunk de tamanho 64B, é possível sobrescrever o tamanho do top chunk com os dados inseridos no nome do host.
• Agora que a escrita arbitrária é possível, o GOT do atoi foi sobrescrito para o endereço do printf. Então foi possível vazar o endereço de IO_2_1_stderr com %24$p. E com esse vazamento de libc foi possível sobrescrever novamente o GOT do atoi com o endereço do system e chamá-lo passando como parâmetro /bin/sh
• Um método alternativo proposto neste outro writeup, é sobrescrever free com puts, e então adicionar o endereço de atoi@got, no ponteiro que será posteriormente liberado para que seja vazado e com esse vazamento sobrescrever novamente atoi@got com system e chamá-lo com /bin/sh.
• https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html
• Existe um UAF que permite reutilizar um chunk que foi liberado sem limpar o ponteiro. Como existem alguns métodos de leitura, é possível vazar um endereço libc escrevendo um ponteiro para a função free no GOT aqui e depois chamando a função de leitura.
• Em seguida, House of force foi usado (abusando do UAF) para sobrescrever o tamanho do espaço à esquerda com um -1, alocar um chunk grande o suficiente para chegar ao hook de free e, em seguida, alocar outro chunk que conterá o hook de free. Em seguida, escreva no hook o endereço do system, escreva em um chunk "/bin/sh" e finalmente libere o chunk com esse conteúdo de string.