<summary><strong>Aprenda hacking AWS do zero ao herói com</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
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**](https://github.com/sponsors/carlospolop)!
* Obtenha o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
</details>
## Informações Básicas
Para mais informações sobre o que é um unsorted bin, consulte esta página:
As listas não ordenadas são capazes de escrever o endereço para `unsorted_chunks (av)` no endereço `bk` do chunk. Portanto, se um atacante puder **modificar o endereço do ponteiro `bk`** em um chunk dentro do unsorted bin, ele poderia ser capaz de **escrever esse endereço em um endereço arbitrário** que poderia ser útil para vazar endereços do Glibc ou contornar algumas defesas.
Portanto, basicamente, esse ataque permite **definir um número grande em um endereço arbitrário**. Esse número grande é um endereço, que poderia ser um endereço de heap ou um endereço do Glibc. Um alvo típico é **`global_max_fast`** para permitir a criação de bins rápidos com tamanhos maiores (e passar de um ataque unsorted bin para um ataque fast bin).
Analisando o exemplo fornecido em [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle) e usando 0x4000 e 0x5000 em vez de 0x400 e 0x500 como tamanhos de chunk (para evitar Tcache), é possível ver que **atualmente** o erro **`malloc(): unsorted double linked list corrupted`** é acionado.
Portanto, esse ataque ao unsorted bin agora (entre outras verificações) também requer ser capaz de corrigir a lista duplamente encadeada para que isso seja contornado `victim->bk->fd == victim` ou não `victim->fd == av (arena)`, o que significa que o endereço onde queremos escrever deve ter o endereço do chunk falso em sua posição `fd` e que o `fd` do chunk falso está apontando para a arena.
Observe que esse ataque corrompe o unsorted bin (portanto, também o small e o large). Portanto, agora só podemos **usar alocações do fast bin** (um programa mais complexo pode fazer outras alocações e travar), e para acionar isso devemos **alocar o mesmo tamanho ou o programa travará.**
Observe que sobrescrever **`global_max_fast`** pode ajudar nesse caso, confiando que o fast bin será capaz de lidar com todas as outras alocações até que a exploração seja concluída.
O código de [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/unsorted\_explanation/index.html) explica muito bem, embora se você modificar as alocações de memória para alocar memória grande o suficiente para não terminar em um Tcache, você verá que o erro mencionado anteriormente aparece, impedindo essa técnica: **`malloc(): unsorted double linked list corrupted`**
Este é na verdade um conceito muito básico. Os chunks no unsorted bin terão ponteiros. O primeiro chunk no unsorted bin na verdade terá os links **`fd`** e **`bk`** **apontando para uma parte da arena principal (Glibc)**.\
Portanto, se você pode **colocar um chunk dentro de um unsorted bin e lê-lo** (uso após liberação) ou **alocá-lo novamente sem sobrescrever pelo menos 1 dos ponteiros** para então **lê-lo**, você pode ter um **vazamento de informações do Glibc**.
Um [**ataque semelhante usado neste artigo**](https://guyinatuxedo.github.io/33-custom\_misc\_heap/csaw18\_alienVSsamurai/index.html), foi abusar de uma estrutura de 4 chunks (A, B, C e D - D é apenas para evitar a consolidação com o top chunk) para que uma sobrecarga de byte nulo em B fosse usada para fazer C indicar que B não estava sendo usado. Além disso, em B, os dados `prev_size` foram modificados para que o tamanho, em vez de ser o tamanho de B, fosse A+B.\
Então C foi desalocado e consolidado com A+B (mas B ainda estava em uso). Um novo chunk de tamanho A foi alocado e então os endereços vazados do Glibc foram escritos em B de onde foram vazados.
* É possível gerar chunks de tamanhos arbitrários e há um estouro de heap com o tamanho desejado.
* O ataque começa criando 3 chunks: chunk0 para abusar do estouro, chunk1 para ser estourado e chunk2 para que o top chunk não consolide os anteriores.
* Em seguida, o chunk1 é liberado e o chunk0 é estourado para que o ponteiro `bk` do chunk1 aponte para: `bk = magic - 0x10`
* Em seguida, o chunk3 é alocado com o mesmo tamanho que o chunk1, o que acionará o ataque ao unsorted bin e modificará o valor da variável global, tornando possível obter a flag.
* A função de mesclagem é vulnerável porque se ambos os índices passados forem iguais, ela realocará nele e então o liberará, mas retornando um ponteiro para essa região liberada que pode ser usada.
* Portanto, **2 chunks são criados**: **chunk0** que será mesclado consigo mesmo e chunk1 para evitar a consolidação com o top chunk. Em seguida, a **função de mesclagem é chamada com o chunk0** duas vezes, o que causará um uso após a liberação.
* Em seguida, a função **`view`** é chamada com o índice 2 (que é o índice do chunk de uso após liberação), que irá **vazar um endereço do Glibc**.
* Como o binário tem proteções para alocar apenas tamanhos maiores que **`global_max_fast`** para que nenhum fastbin seja usado, um ataque ao unsorted bin será usado para sobrescrever a variável global `global_max_fast`.
* Em seguida, é possível chamar a função edit com o índice 2 (o ponteiro de uso após liberação) e sobrescrever o ponteiro `bk` para apontar para `p64(global_max_fast-0x10)`. Em seguida, criando um novo chunk usará o endereço de liberação comprometido anteriormente (0x20) e **acionará o ataque ao unsorted bin** sobrescrevendo o `global_max_fast` com um valor muito grande, permitindo agora criar chunks em fast bins.
* Se conseguirmos obter um fast chunk de tamanho 0x200 nessa localização, será possível sobrescrever um ponteiro de função que será executado
* Para isso, um novo chunk de tamanho `0xfc` é criado e a função mesclada é chamada com esse ponteiro duas vezes, dessa forma obtemos um ponteiro para um chunk liberado de tamanho `0xfc*2 = 0x1f8` no fast bin.
* Em seguida, a função edit é chamada nesse chunk para modificar o endereço **`fd`** desse fast bin para apontar para a função **`__free_hook`** anterior.
* Depois, um chunk com tamanho `0x1f8` é criado para recuperar do fast bin o chunk inútil anterior, então outro chunk de tamanho `0x1f8` é criado para obter um chunk fast bin no **`__free_hook`** que é sobrescrito com o endereço da função **`system`**.
* E finalmente um chunk contendo a string `/bin/sh\x00` é liberado chamando a função delete, acionando a função **`__free_hook`** que aponta para system com `/bin/sh\x00` como parâmetro.
* Outro exemplo de abuso de um overflow de 1B para consolidar chunks no unsorted bin e obter um vazamento de informações da libc e depois realizar um ataque fast bin para sobrescrever o malloc hook com um endereço de one gadget
* [**Robot Factory. BlackHat MEA CTF 2022**](https://7rocky.github.io/en/ctf/other/blackhat-ctf/robot-factory/)
* Só podemos alocar chunks de tamanho maior que `0x100`.
* Sobrescrever `global_max_fast` usando um ataque Unsorted Bin (funciona 1/16 vezes devido ao ASLR, porque precisamos modificar 12 bits, mas devemos modificar 16 bits).
* Ataque Fast Bin para modificar um array global de chunks. Isso fornece um primitivo de leitura/gravação arbitrário, que permite modificar o GOT e definir algumas funções para apontar para `system`.
<summary><strong>Aprenda hacking AWS do zero ao herói com</strong><ahref="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
Outras maneiras de apoiar o HackTricks:
* Se você quiser ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF** Verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
* Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
* Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
