Ataque ao Tcache Bin

Aprenda hacking na AWS do zero ao herói com htARTE (HackTricks AWS Red Team Expert)!

Outras maneiras de apoiar o HackTricks:

Se você deseja ver sua empresa anunciada no HackTricks ou baixar o HackTricks em PDF, confira os PLANOS DE ASSINATURA!
Adquira o swag oficial do PEASS & HackTricks
Descubra A Família PEASS, nossa coleção exclusiva de NFTs
Junte-se ao 💬 grupo do Discord ou ao grupo do telegram ou siga-nos no Twitter 🐦 @hacktricks_live.
Compartilhe seus truques de hacking enviando PRs para os repositórios HackTricks e HackTricks Cloud.

Informações Básicas

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 %}

Em primeiro lugar, observe que o Tcache foi introduzido na versão 2.26 do glibc.

O ataque Tcache proposto na página guyinatuxido é muito semelhante ao ataque 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 posteriormente ser possível alocar esse 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 um endereço alinhado no novo ponteiro (ou executar o binário várias vezes para que o endereço escrito esteja realmente alinhado).

Ataque aos índices do Tcache

Normalmente é 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 principal de cada índice do tcache. Se, por algum motivo, for possível modificar essas informações, seria possível fazer o chunk principal de algum índice apontar para um endereço desejado (como o malloc hook) para então alocar um chunk do tamanho do índice e sobrescrever o conteúdo do malloc hook neste caso.

Exemplos

CTF https://guyinatuxedo.github.io/29-tcache/dcquals19_babyheap/index.html
Vazamento de informações do Libc: É possível preencher os tcaches, adicionar um chunk na lista não ordenada, esvaziar o tcache e realocar o chunk da lista não ordenada sobrescrevendo apenas os primeiros 8B, deixando o segundo endereço para o Libc do chunk intacto para que possamos lê-lo.
Ataque ao Tcache: O binário é vulnerável a um overflow de heap de 1B. Isso será abusado para alterar o cabeçalho de tamanho de um chunk alocado, tornando-o maior. Em seguida, este chunk será liberado, adicionando-o ao tcache de chunks do tamanho falso. Em seguida, alocaremos um chunk com o tamanho falsificado, e o chunk anterior será retornado sabendo que este chunk era realmente menor e isso nos dá a oportunidade de sobrescrever o próximo chunk na memória.
Vamos abusar disso para sobrescrever o ponteiro FD do próximo chunk para apontar para malloc_hook, então é possível alocar 2 ponteiros: primeiro o ponteiro legítimo que acabamos de modificar e, em seguida, 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 do Libc: Há um uso após free e um double free. Neste writeup, o autor vazou um endereço do Libc lendo o endereço de um chunk colocado em um bin pequeno (como vazando-o do bin não ordenado, mas do pequeno).
Ataque ao Tcache: Um Tcache é realizado via um double free. O mesmo chunk é liberado duas vezes, então dentro do Tcache o chunk apontará para si mesmo. Em seguida, ele é alocado, seu ponteiro FD é modificado para apontar para o free hook e então é alocado novamente para que o próximo chunk na lista esteja no free hook. Em seguida, isso também é alocado e é possível escrever o endereço do system aqui, então quando um malloc contendo "/bin/sh" é liberado, obtemos um shell.
CTF https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps0/index.html
A principal vulnerabilidade aqui é a capacidade de liberar qualquer endereço no heap indicando seu deslocamento
Ataque aos índices do Tcache: É possível alocar e liberar um chunk de um tamanho que, quando armazenado dentro do chunk do tcache (o chunk com as informações dos bins do 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.
Em seguida, esse valor parece que há um chunk de tamanho 0x100. Permitindo abusar disso ao liberar este endereço. Isso irá adicionar esse endereço ao índice de chunks de tamanho 0x100 no tcache.
Em seguida, alocando um chunk de tamanho 0x100, o endereço anterior será retornado como um chunk, permitindo sobrescrever outros índices do tcache.
Por exemplo, colocar o endereço do malloc hook em um deles e alocar um chunk do tamanho desse índice concederá um chunk no calloc hook, o que permite escrever um one gadget para obter um shell.
CTF https://guyinatuxedo.github.io/44-more_tcache/csaw19_popping_caps1/index.html
Mesma vulnerabilidade que antes com uma restrição extra
Ataque aos índices do Tcache: Ataque semelhante ao anterior, mas usando menos etapas ao liberar o chunk que contém as informações do tcache para que seu endereço seja adicionado ao índice do tcache de seu tamanho, permitindo alocar esse tamanho e obter as informações do chunk do 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.