hacktricks/binary-exploitation/libc-heap/use-after-free/first-fit.md

# First Fit

{% hint style="success" %}
Apprenez et pratiquez le piratage AWS : <img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**Formation HackTricks AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
Apprenez et pratiquez le piratage GCP : <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**Formation HackTricks GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>Soutenez HackTricks</summary>

* Consultez les [**plans d'abonnement**](https://github.com/sponsors/carlospolop)!
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Partagez des astuces de piratage en soumettant des PR aux** [**HackTricks**](https://github.com/carlospolop/hacktricks) et [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

</details>
{% endhint %}

## **First Fit**

Lorsque vous libérez de la mémoire dans un programme utilisant glibc, différents "bins" sont utilisés pour gérer les morceaux de mémoire. Voici une explication simplifiée de deux scénarios courants : les bacs non triés et les fastbins.

### Bacs non triés

Lorsque vous libérez un morceau de mémoire qui n'est pas un morceau rapide, il va dans le bac non trié. Ce bac agit comme une liste où les nouveaux morceaux libérés sont ajoutés à l'avant (la "tête"). Lorsque vous demandez un nouveau morceau de mémoire, l'allocateur regarde le bac non trié depuis l'arrière (la "queue") pour trouver un morceau suffisamment grand. Si un morceau du bac non trié est plus grand que ce dont vous avez besoin, il est divisé, la partie avant étant renvoyée et la partie restante restant dans le bac.

Exemple :

* Vous allouez 300 octets (`a`), puis 250 octets (`b`), libérez `a` et demandez à nouveau 250 octets (`c`).
* Lorsque vous libérez `a`, il va dans le bac non trié.
* Si vous demandez ensuite à nouveau 250 octets, l'allocateur trouve `a` à la queue et le divise, renvoyant la partie qui correspond à votre demande et conservant le reste dans le bac.
* `c` pointera vers le `a` précédent et sera rempli avec les données de `a`.
```c
char *a = malloc(300);
char *b = malloc(250);
free(a);
char *c = malloc(250);
```
### Fastbins

Les fastbins sont utilisés pour de petits morceaux de mémoire. Contrairement aux bacs non triés, les fastbins ajoutent de nouveaux morceaux à la tête, créant un comportement de dernier entré, premier sorti (LIFO). Si vous demandez un petit morceau de mémoire, l'allocateur le prendra à partir de la tête du fastbin.

Exemple :

* Vous allouez quatre morceaux de 20 octets chacun (`a`, `b`, `c`, `d`).
* Lorsque vous les libérez dans n'importe quel ordre, les morceaux libérés sont ajoutés à la tête du fastbin.
* Si vous demandez ensuite un morceau de 20 octets, l'allocateur renverra le morceau le plus récemment libéré de la tête du 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
```
## Autres références et exemples

* [**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. Utilisation après libération : Générer un objet utilisateur, le libérer, générer un objet qui récupère le morceau libéré et permet d'écrire dedans, **écrasant la position du mot de passe de l'utilisateur** du précédent. Réutiliser l'utilisateur pour **contourner la vérification du mot de passe**
* [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use\_after\_free/#example**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use\_after\_free/#example)
* Le programme permet de créer des notes. Une note aura les informations de la note dans un malloc(8) (avec un pointeur vers une fonction qui pourrait être appelée) et un pointeur vers un autre malloc(\<size>) avec le contenu de la note.
* L'attaque consisterait à créer 2 notes (note0 et note1) avec des contenus malloc plus grands que la taille des informations de la note, puis à les libérer pour qu'elles entrent dans le fast bin (ou tcache).
* Ensuite, créer une autre note (note2) avec une taille de contenu de 8. Le contenu va être dans note1 car le morceau va être réutilisé, où nous pourrions modifier le pointeur de fonction pour pointer vers la fonction win et ensuite Utiliser-Après-Libre la note1 pour appeler le nouveau pointeur de fonction.
* [**https://guyinatuxedo.github.io/26-heap\_grooming/pico\_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap\_grooming/pico\_areyouroot/index.html)
* Il est possible d'allouer de la mémoire, d'écrire la valeur souhaitée, de la libérer, de la réallouer et comme les données précédentes sont toujours là, elles seront traitées selon la nouvelle structure attendue dans le morceau, ce qui permet de définir la valeur ou d'obtenir le drapeau.
* [**https://guyinatuxedo.github.io/26-heap\_grooming/swamp19\_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap\_grooming/swamp19\_heapgolf/index.html)
* Dans ce cas, il est nécessaire d'écrire 4 à l'intérieur d'un morceau spécifique qui est le premier à être alloué (même après les avoir tous libérés de force). À chaque nouveau morceau alloué, son numéro dans l'index du tableau est stocké. Ensuite, allouez 4 morceaux (+ celui initialement alloué), le dernier aura 4 à l'intérieur, libérez-les et forcez la réaffectation du premier, qui utilisera le dernier morceau libéré qui est celui avec 4 à l'intérieur.