Tcache Bin Attack

{% 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)

Support HackTricks

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

{% endhint %}

Basic Information

Para mais informações sobre o que é um Tcache bin, confira esta página:

{% content-ref url="bins-and-memory-allocations.md" %} bins-and-memory-allocations.md {% endcontent-ref %}

Primeiramente, note que o Tcache foi introduzido na versão 2.26 do Glibc.

O ataque Tcache (também conhecido como envenenamento de Tcache) proposto na página guyinatuxido é muito semelhante ao ataque de fast bin, onde o objetivo é sobrescrever o ponteiro para o próximo chunk no bin dentro de um chunk liberado para um endereço arbitrário, para que depois seja possível alocar aquele endereço específico e potencialmente sobrescrever ponteiros.

No entanto, atualmente, se você executar o código mencionado, receberá o erro: malloc(): unaligned tcache chunk detected. Portanto, é necessário escrever como endereço no novo ponteiro um endereço alinhado (ou executar o binário o suficiente para que o endereço escrito esteja realmente alinhado).

Tcache indexes attack

Geralmente, é possível encontrar no início do heap um chunk contendo a quantidade de chunks por índice dentro do tcache e o endereço do chunk cabeça de cada índice de tcache. Se por algum motivo for possível modificar essa informação, seria possível fazer o chunk cabeça de algum índice apontar para um endereço desejado (como __malloc_hook) para então alocar um chunk do tamanho do índice e sobrescrever o conteúdo de __malloc_hook neste caso.

Examples

CTF https://guyinatuxedo.github.io/29-tcache/dcquals19_babyheap/index.html
Libc info leak: É possível preencher os tcaches, adicionar um chunk na lista não ordenada, esvaziar o tcache e re-alocar o chunk do bin não ordenado apenas sobrescrevendo os primeiros 8B, deixando o segundo endereço para libc do chunk intacto para que possamos lê-lo.
Tcache attack: O binário é vulnerável a um overflow de heap de 1B. Isso será abusado para mudar o cabeçalho de tamanho de um chunk alocado, tornando-o maior. Então, esse chunk será liberado, adicionando-o ao tcache de chunks de tamanho falso. Em seguida, alocaremos um chunk com o tamanho falso, e o chunk anterior será retornado sabendo que esse chunk era na verdade menor, e isso nos dá a oportunidade de sobrescrever o próximo chunk na memória.
Abusaremos disso para sobrescrever o ponteiro FD do próximo chunk para apontar para malloc_hook, para que então seja possível alocar 2 ponteiros: primeiro o ponteiro legítimo que acabamos de modificar, e então a segunda alocação retornará um chunk em malloc_hook que é possível abusar para escrever um one gadget.
CTF https://guyinatuxedo.github.io/29-tcache/plaid19_cpp/index.html
Libc info leak: Há um uso após a liberação e um duplo free. Neste writeup, o autor vazou um endereço da libc lendo o endereço de um chunk colocado em um bin pequeno (como vazando do bin não ordenado, mas do pequeno).
Tcache attack: Um Tcache é realizado via um duplo free. O mesmo chunk é liberado duas vezes, então dentro do Tcache o chunk apontará para si mesmo. Em seguida, é alocado, seu ponteiro FD é modificado para apontar para o free hook e então é alocado novamente, de modo que o próximo chunk na lista estará no free hook. Então, isso também é alocado e é possível escrever o endereço de system aqui, para que quando um malloc contendo "/bin/sh" for liberado, consigamos uma shell.
CTF https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps0/index.html
A principal vulnerabilidade aqui é a capacidade de free qualquer endereço no heap indicando seu offset.
Tcache indexes attack: É possível alocar e liberar um chunk de um tamanho que, quando armazenado dentro do chunk tcache (o chunk com as informações dos bins de tcache), gerará um endereço com o valor 0x100. Isso ocorre porque o tcache armazena a quantidade de chunks em cada bin em bytes diferentes, portanto, um chunk em um índice específico gera o valor 0x100.
Então, esse valor parece que há um chunk de tamanho 0x100. Permitindo abusar disso ao free esse endereço. Isso adicionará esse endereço ao índice de chunks de tamanho 0x100 no tcache.
Então, alocando um chunk de tamanho 0x100, o endereço anterior será retornado como um chunk, permitindo sobrescrever outros índices de tcache.
Por exemplo, colocando o endereço do malloc hook em um deles e alocando um chunk do tamanho desse índice garantirá um chunk no calloc hook, o que permite escrever um one gadget para obter uma shell.
CTF https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps1/index.html
Mesma vulnerabilidade que antes com uma restrição extra.
Tcache indexes attack: Ataque semelhante ao anterior, mas usando menos etapas ao liberar o chunk que contém as informações do tcache, de modo que seu endereço seja adicionado ao índice de tcache de seu tamanho, permitindo alocar esse tamanho e obter as informações do chunk de tcache como um chunk, o que permite adicionar o free hook como o endereço de um índice, alocá-lo e escrever um one gadget nele.
Math Door. HTB Cyber Apocalypse CTF 2023
Write After Free para adicionar um número ao ponteiro fd.
Muito de heap feng-shui é necessário neste desafio. O writeup mostra como controlar a cabeça da lista livre do Tcache é bastante útil.
Glibc leak através de stdout (FSOP).
Tcache poisoning para obter uma primitiva de escrita arbitrária.