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

# Casa da Força


<details>

<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

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**](https://github.com/sponsors/carlospolop)!
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.

</details>

## Informações Básicas

### Código

* Esta técnica foi corrigida ([**aqui**](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=30a17d8c95fbfb15c52d1115803b63aaa73a285c)) e produz este erro: `malloc(): corrupted top size`
* Você pode testar o [**código daqui**](https://guyinatuxedo.github.io/41-house\_of\_force/house\_force\_exp/index.html) 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:
```c
// 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://github.com/shellphish/how2heap/tree/master?tab=readme-ov-file)
* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/)
* [https://heap-exploitation.dhavalkapil.com/attacks/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://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://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](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](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](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#2016-bctf-bcloud), é 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](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.
Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc 2024-06-16 09:01:40 +00:00			`# Casa da Força`



			`<details>`

			`<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>`

			`Outras maneiras de apoiar o HackTricks:`

Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m 2024-07-17 18:06:45 +00:00			`* Se você quiser ver sua empresa anunciada no HackTricks ou baixar o HackTricks em PDF Verifique os [PLANOS DE ASSINATURA](https://github.com/sponsors/carlospolop)!`
			`* Adquira o [swag oficial PEASS & HackTricks](https://peass.creator-spring.com)`
Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc 2024-06-16 09:01:40 +00:00			`* Descubra [A Família PEASS](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [NFTs](https://opensea.io/collection/the-peass-family)`
			`* Junte-se ao 💬 [grupo Discord](https://discord.gg/hRep4RUj7f) ou ao [grupo telegram](https://t.me/peass) ou siga-nos no Twitter 🐦 [@hacktricks\_live](https://twitter.com/hacktricks\_live).`
			`* Compartilhe seus truques de hacking enviando PRs para os [HackTricks](https://github.com/carlospolop/hacktricks) e [HackTricks Cloud](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.`

			`</details>`

Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m 2024-07-17 18:06:45 +00:00			`## Informações Básicas`
Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc 2024-06-16 09:01:40 +00:00
			`### Código`

			* Esta técnica foi corrigida ([aqui](https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=30a17d8c95fbfb15c52d1115803b63aaa73a285c)) e produz este erro: `malloc(): corrupted top size`
			`* Você pode testar o [código daqui](https://guyinatuxedo.github.io/41-house\_of\_force/house\_force\_exp/index.html) se quiser.`

			`### Objetivo`

Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m 2024-07-17 18:06:45 +00:00			`* O objetivo deste ataque é ser capaz de alocar um chunk em um endereço específico.`
Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc 2024-06-16 09:01:40 +00:00
			`### Requisitos`

Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m 2024-07-17 18:06:45 +00:00			`* Um overflow que permita sobrescrever o tamanho do cabeçalho do top chunk (por exemplo, -1).`
Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc 2024-06-16 09:01:40 +00:00			`* Ser capaz de controlar o tamanho da alocação do heap`

			`### Ataque`

Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m 2024-07-17 18:06:45 +00:00			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.
Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc 2024-06-16 09:01:40 +00:00
Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m 2024-07-17 18:06:45 +00:00			`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:`
Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc 2024-06-16 09:01:40 +00:00			```c
			`// 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.\
Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m 2024-07-17 18:06:45 +00:00			`Em seguida, faça outro malloc para obter um chunk no endereço alvo.`
Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc 2024-06-16 09:01:40 +00:00
			`### Referências e Outros Exemplos`

			`* [https://github.com/shellphish/how2heap/tree/master](https://github.com/shellphish/how2heap/tree/master?tab=readme-ov-file)`
			`* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/)`
			`* [https://heap-exploitation.dhavalkapil.com/attacks/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://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://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](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`
Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m 2024-07-17 18:06:45 +00:00			`* 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`
Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc 2024-06-16 09:01:40 +00:00			`* [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](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
Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m 2024-07-17 18:06:45 +00:00			* 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`
Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc 2024-06-16 09:01:40 +00:00			* Um método alternativo [proposto neste outro writeup](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_force/#2016-bctf-bcloud), é 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](https://guyinatuxedo.github.io/41-house\_of\_force/bkp16\_cookbook/index.html)`
Translated ['binary-exploitation/libc-heap/bins-and-memory-allocations.m 2024-07-17 18:06:45 +00:00			`* 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.