# Estouro por um byte {% hint style="success" %} Aprenda e pratique Hacking AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\ Aprenda e pratique Hacking GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte) <details> <summary>Apoie o HackTricks</summary> * Verifique os [**planos de assinatura**](https://github.com/sponsors/carlospolop)! * **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 truques de hacking enviando PRs para os repositórios** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud). </details> {% endhint %} ## Informações Básicas Ter apenas acesso a um estouro de 1 byte permite a um atacante modificar o campo `size` do próximo chunk. Isso permite manipular quais chunks são realmente liberados, potencialmente gerando um chunk que contém outro chunk legítimo. A exploração é semelhante a [double free](double-free.md) ou chunks sobrepostos. Existem 2 tipos de vulnerabilidades de estouro por um byte: * Byte arbitrário: Esse tipo permite sobrescrever esse byte com qualquer valor * Byte nulo (off-by-null): Esse tipo permite sobrescrever esse byte apenas com 0x00 * Um exemplo comum dessa vulnerabilidade pode ser visto no código a seguir, onde o comportamento de `strlen` e `strcpy` é inconsistente, o que permite definir um byte 0x00 no início do próximo chunk. * Isso pode ser explorado com o [House of Einherjar](house-of-einherjar.md). * Se estiver usando Tcache, isso pode ser aproveitado para uma situação de [double free](double-free.md). <details> <summary>Off-by-null</summary> ```c // From https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off_by_one/ int main(void) { char buffer[40]=""; void *chunk1; chunk1 = malloc(24); puts("Get Input"); gets(buffer); if(strlen(buffer)==24) { strcpy(chunk1,buffer); } return 0; } ``` </details> Entre outras verificações, agora sempre que um chunk é liberado, o tamanho anterior é comparado com o tamanho configurado nos metadados do chunk, tornando esse ataque bastante complexo a partir da versão 2.28. ### Exemplo de código: * [https://github.com/DhavalKapil/heap-exploitation/blob/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/shrinking\_free\_chunks.c](https://github.com/DhavalKapil/heap-exploitation/blob/d778318b6a14edad18b20421f5a06fa1a6e6920e/assets/files/shrinking\_free\_chunks.c) * Este ataque não está mais funcionando devido ao uso de Tcaches. * Além disso, se você tentar abusar dele usando chunks maiores (para que as tcaches não estejam envolvidas), você receberá o erro: `malloc(): invalid next size (unsorted)` ### Objetivo * Fazer um chunk estar contido dentro de outro chunk, de modo que o acesso de escrita sobre esse segundo chunk permita sobrescrever o contido ### Requisitos * Estouro de buffer por um para modificar as informações de metadados de tamanho ### Ataque geral de off-by-one * Aloque três chunks `A`, `B` e `C` (digamos tamanhos 0x20), e outro para evitar a consolidação com o chunk superior. * Libere `C` (inserido na lista de liberação Tcache de 0x20). * Use o chunk `A` para transbordar em `B`. Abusa do off-by-one para modificar o campo `size` de `B` de 0x21 para 0x41. * Agora temos `B` contendo o chunk livre `C` * Libere `B` e aloque um chunk de 0x40 (ele será colocado aqui novamente) * Podemos modificar o ponteiro `fd` de `C`, que ainda está livre (envenenamento de Tcache) ### Ataque off-by-null * 3 chunks de memória (a, b, c) são reservados um após o outro. Em seguida, o do meio é liberado. O primeiro contém uma vulnerabilidade de estouro por um e o atacante a abusa com um 0x00 (se o byte anterior fosse 0x10, faria com que o chunk do meio indicasse que é 0x10 menor do que realmente é). * Em seguida, 2 chunks menores são alocados no meio do chunk liberado (b), no entanto, como `b + b->size` nunca atualiza o chunk c porque o endereço apontado é menor do que deveria. * Em seguida, b1 e c são liberados. Como `c - c->prev_size` ainda aponta para b (agora b1), ambos são consolidados em um único chunk. No entanto, b2 ainda está dentro entre b1 e c. * Finalmente, é feito um novo malloc para recuperar esta área de memória que na verdade vai conter b2, permitindo ao proprietário do novo malloc controlar o conteúdo de b2. Esta imagem explica perfeitamente o ataque: <figure><img src="../../.gitbook/assets/image (1247).png" alt=""><figcaption><p><a href="https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks">https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks</a></p></figcaption></figure> ## Outros Exemplos e Referências * [**https://heap-exploitation.dhavalkapil.com/attacks/shrinking\_free\_chunks**](https://heap-exploitation.dhavalkapil.com/attacks/shrinking\_free\_chunks) * [**Bon-nie-appetit. HTB Cyber Apocalypse CTF 2022**](https://7rocky.github.io/en/ctf/htb-challenges/pwn/bon-nie-appetit/) * Off-by-one devido ao `strlen` considerando o campo `size` do próximo chunk. * Tcache está sendo usado, então ataques gerais de off-by-one funcionam para obter um primitivo de escrita arbitrário com envenenamento de Tcache. * [**Asis CTF 2016 b00ks**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off\_by\_one/#1-asis-ctf-2016-b00ks) * É possível abusar de um off-by-one para vazar um endereço do heap porque o byte 0x00 do final de uma string está sendo sobrescrito pelo próximo campo. * A escrita arbitrária é obtida abusando do off-by-one para fazer o ponteiro apontar para outro lugar onde uma estrutura falsa com ponteiros falsos será construída. Em seguida, é possível seguir o ponteiro desta estrutura para obter uma escrita arbitrária. * O endereço do libc é vazado porque se o heap for estendido usando mmap, a memória alocada por mmap tem um deslocamento fixo do libc. * Finalmente, a escrita arbitrária é abusada para escrever no endereço de \_\_free\_hook com um one gadget. * [**plaidctf 2015 plaiddb**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/off\_by\_one/#instance-2-plaidctf-2015-plaiddb) * Existe uma vulnerabilidade de off-by-one NULL na função `getline` que lê linhas de entrada do usuário. Esta função é usada para ler a "chave" do conteúdo e não o conteúdo. * **Compartilhe 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.**