hacktricks/binary-exploitation/libc-heap/off-by-one-overflow.md

Estouro por um byte

{% hint style="success" %} Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE)

Apoie o HackTricks

• Verifique os planos de assinatura!
• Junte-se ao 💬 grupo Discord ou ao grupo telegram ou siga-nos no Twitter 🐦 @hacktricks_live.
• Compartilhe truques de hacking enviando PRs para os repositórios HackTricks e HackTricks Cloud.

{% 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 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.
• Se estiver usando Tcache, isso pode ser aproveitado para uma situação de double free.

Off-by-null

```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; } ```

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
• 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:

https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks

Outros Exemplos e Referências

• https://heap-exploitation.dhavalkapil.com/attacks/shrinking_free_chunks
• Bon-nie-appetit. HTB Cyber Apocalypse CTF 2022
• 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
• É 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
• 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 e HackTricks Cloud repositórios do Github.