# First Fit

<details>

<summary><strong>Aprenda hacking AWS do zero ao herói com</strong> <a href="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) repositórios do github.

</details>

## **First Fit**

Quando você libera memória em um programa usando glibc, diferentes "bins" são usados para gerenciar os pedaços de memória. Aqui está uma explicação simplificada de dois cenários comuns: bins não ordenados e fastbins.

### Bins Não Ordenados

Quando você libera um pedaço de memória que não é um pedaço rápido, ele vai para o bin não ordenado. Este bin age como uma lista onde novos pedaços liberados são adicionados à frente (a "cabeça"). Quando você solicita um novo pedaço de memória, o alocador olha para o bin não ordenado de trás (a "cauda") para encontrar um pedaço grande o suficiente. Se um pedaço do bin não ordenado for maior do que o que você precisa, ele é dividido, com a parte da frente sendo retornada e a parte restante permanecendo no bin.

Exemplo:

* Você aloca 300 bytes (`a`), então 250 bytes (`b`), libera `a` e solicita novamente 250 bytes (`c`).
* Quando você libera `a`, ele vai para o bin não ordenado.
* Se então você solicitar 250 bytes novamente, o alocador encontra `a` na cauda e o divide, retornando a parte que se encaixa em sua solicitação e mantendo o restante no bin.
* `c` estará apontando para o `a` anterior e preenchido com os `a's`.
```c
char *a = malloc(300);
char *b = malloc(250);
free(a);
char *c = malloc(250);
```
### Fastbins

Fastbins são usados para pequenos pedaços de memória. Ao contrário dos bins não ordenados, os fastbins adicionam novos pedaços à cabeça, criando um comportamento de último a entrar, primeiro a sair (LIFO). Se você solicitar um pequeno pedaço de memória, o alocador irá retirar da cabeça do fastbin.

Exemplo:

* Você aloca quatro pedaços de 20 bytes cada (`a`, `b`, `c`, `d`).
* Quando você os libera em qualquer ordem, os pedaços liberados são adicionados à cabeça do fastbin.
* Se você então solicitar um pedaço de 20 bytes, o alocador irá retornar o pedaço mais recentemente liberado da cabeça do fastbin.
```c
char *a = malloc(20);
char *b = malloc(20);
char *c = malloc(20);
char *d = malloc(20);
free(a);
free(b);
free(c);
free(d);
a = malloc(20);   // d
b = malloc(20);   // c
c = malloc(20);   // b
d = malloc(20);   // a
```
## Outras Referências e Exemplos

* [https://heap-exploitation.dhavalkapil.com/attacks/first\_fit](https://heap-exploitation.dhavalkapil.com/attacks/first\_fit)
* [https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/](https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/)
* ARM64. Use after free: Gerar um objeto de usuário, liberá-lo, gerar um objeto que obtém o bloco liberado e permite escrever nele, **sobrescrevendo a posição da senha do usuário** da anterior. Reutilizar o usuário para **burlar a verificação da senha**