Tcache Bin Attack

Reading time: 6 minutes

Basic Information

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

Bins & Memory Allocations

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).

Ataque de índices Tcache

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 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.

Exemplos

• CTF https://guyinatuxedo.github.io/29-tcache/dcquals19_babyheap/index.html
• Vazamento de informações da Libc: É 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 sobrescrevendo apenas os primeiros 8B, deixando o segundo endereço da libc do chunk intacto para que possamos lê-lo.
• Ataque Tcache: O binário é vulnerável a um estouro 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, o que 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 pode ser abusado para escrever um one gadget.
• CTF https://guyinatuxedo.github.io/29-tcache/plaid19_cpp/index.html
• Vazamento de informações da Libc: Há um uso após a liberação e uma dupla liberação. Neste relato, o autor vazou um endereço da libc lendo o endereço de um chunk colocado em um bin pequeno (como vazá-lo do bin não ordenado, mas do pequeno).
• Ataque Tcache: Um Tcache é realizado via uma dupla liberação. 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 deslocamento.
• Ataque de índices Tcache: É 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 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 desse 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 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.
• Ataque de índices Tcache: 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 tcache de seu tamanho, permitindo alocar esse tamanho e obter as informações do chunk 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 relato mostra como controlar a cabeça da lista livre do Tcache é bastante útil.
• Vazamento de Glibc através de stdout (FSOP).
• Envenenamento de Tcache para obter uma primitiva de escrita arbitrária.