Tcache Bin Attack
Last updated
Last updated
Aprenda e pratique Hacking na AWS:Treinamento HackTricks AWS Red Team Expert (ARTE) Aprenda e pratique Hacking no GCP: Treinamento HackTricks GCP Red Team Expert (GRTE)
Para mais informações sobre o que é um Tcache bin, consulte esta página:
Bins & Memory AllocationsEm primeiro lugar, observe que o Tcache foi introduzido na versão 2.26 do Glibc.
O ataque ao Tcache (também conhecido como Tcache poisoning) proposto na página guyinatuxido é muito semelhante ao ataque ao 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 mais tarde 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).
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 de cabeça de cada índice do tcache. Se, por algum motivo, for possível modificar essas informações, seria possível fazer o chunk de 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.
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 estouro 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.
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 vá para o 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.
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 gancho malloc em um deles e alocar um chunk do tamanho desse índice concederá um chunk no gancho calloc, o que permite escrever um one gadget para obter um shell.
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 gancho free como o endereço de um índice, alocá-lo e escrever um one gadget nele.
Write After Free para adicionar um número ao ponteiro fd.
Muito heap feng-shui é necessário neste desafio. O writeup mostra como controlar a cabeça da lista livre do Tcache é bastante útil.
Vazamento do Glibc através do stdout (FSOP).
Tcache poisoning para obter um primitivo de escrita arbitrário.
Aprenda e pratique Hacking na AWS:[**Treinamento HackTricks AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)\ Aprenda e pratique Hacking no GCP: [**Treinamento HackTricks GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)
