maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/binary-exploitation/libc-heap/use-after-free/first-fit.

Browse Source
This commit is contained in:
Translator 2025-08-20 09:39:19 +00:00
parent df7db598ec
commit b87f86eb5a
1 changed files with 14 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/binary-exploitation/libc-heap/use-after-free/first-fit.md
View File

@ -14,7 +14,7 @@ Beispiel:
- Sie reservieren 300 Bytes (`a`), dann 250 Bytes (`b`), dann geben Sie `a` frei und fordern erneut 250 Bytes (`c`) an.
- Wenn Sie `a` freigeben, gelangt es in den unsortierten Bin.
- Wenn Sie dann erneut 250 Bytes anfordern, findet der Zuweiser `a` am Schwanz und teilt es auf, wobei der Teil, der Ihrer Anfrage entspricht, zurückgegeben wird und der Rest im Bin bleibt.
- Wenn Sie dann erneut 250 Bytes anfordern, findet der Zuweiser `a` am Schwanz und teilt es auf, wobei der Teil zurückgegeben wird, der Ihrer Anfrage entspricht, und der Rest im Bin bleibt.
- `c` wird auf das vorherige `a` zeigen und mit den Inhalten von `a` gefüllt sein.
```c
char *a = malloc(300);
@ -24,7 +24,7 @@ char *c = malloc(250);
```
### Fastbins
Fastbins werden für kleine Speicherblöcke verwendet. Im Gegensatz zu unsortierten Bins fügen Fastbins neue Blöcke am Kopf hinzu, was ein Last-In-First-Out (LIFO) Verhalten erzeugt. Wenn Sie einen kleinen Speicherblock anfordern, zieht der Allocator vom Kopf des Fastbins.
Fastbins werden für kleine Speicherblöcke verwendet. Im Gegensatz zu unsortierten Bins fügen Fastbins neue Blöcke am Kopf hinzu, was ein Last-In-First-Out (LIFO) Verhalten erzeugt. Wenn Sie einen kleinen Speicherblock anfordern, wird der Allocator vom Kopf des Fastbins abrufen.
Beispiel:
```c
@ -60,7 +60,7 @@ Sobald der tcache erschöpft ist, gehen nachfolgende Freigaben in den unsortiert
---
### 🚩 Erstellen eines überlappenden Chunk UAF mit First-Fit
Der folgende Fragment (getestet auf glibc 2.38) zeigt, wie der Splitter im unsortierten Bin missbraucht werden kann, um 2 **überlappende Zeiger** zu erstellen – ein leistungsstarkes Primitive, das eine einzelne Freigabe in ein Write-After-Free umwandelt.
Der folgende Fragment (getestet auf glibc 2.38) zeigt, wie der Splitter im unsortierten Bin missbraucht werden kann, um 2 **überlappende Zeiger** zu erstellen – ein leistungsstarkes Primitive, das eine einzelne Freigabe in ein Write-after-Free umwandelt.
```c
#include <stdio.h>
#include <stdlib.h>
@ -90,24 +90,22 @@ memset(B, 'X', 0x10);
fwrite(C2, 1, 0x10, stdout); // prints Xs
}
```
Exploitation-Rezept (häufig in aktuellen CTFs):
Exploitation Rezept (häufig in aktuellen CTFs):
1. **Entleere** den tcache für die Zielgröße.
2. **Gib** einen Chunk frei, damit er im unsortierten Bin landet.
2. **Gib** einen Chunk frei, sodass er im unsortierten Bin landet.
3. **Allociere** eine etwas kleinere Größe – der Allocator teilt den unsortierten Chunk.
4. **Allociere** erneut – der verbleibende Teil überlappt mit einem bereits verwendeten Chunk → UAF.
5. Überschreibe sensible Felder (Funktionszeiger, FILE vtable usw.)
Eine praktische Anwendung findet sich in der *Setjmp*-Herausforderung der HITCON Quals 2024, wo dieses genaue Primitive verwendet wird, um von einem UAF zu vollständiger Kontrolle über `__free_hook` zu pivotieren.{{#ref}}
../../../../references/2024_setjmp_firstfit.md
{{#endref}}
Eine praktische Anwendung findet sich in der *Setjmp* Herausforderung der HITCON Quals 2024, wo dieses genaue Primitive verwendet wird, um von einem UAF zu vollständiger Kontrolle über `__free_hook` zu pivotieren.
---
### 🛡️ Milderungen & Härtung
* **Safe-linking (glibc ≥ 2.32)** schützt nur die einfach verketteten *tcache*/**fastbin**-Listen. Die unsortierten/kleinen/großen Bins speichern weiterhin rohe Zeiger, sodass Überlappungen basierend auf dem ersten Fit weiterhin möglich sind, wenn du einen Heap-Leak erhalten kannst.
* **Heap-Zeiger-Verschlüsselung & MTE** (ARM64) betreffen x86-64 glibc noch nicht, aber Distro-Härtungsflags wie `GLIBC_TUNABLES=glibc.malloc.check=3` werden bei inkonsistenten Metadaten abbrechen und naive PoCs brechen.
* **Füllen des tcache beim Freigeben** (vorgeschlagen für 2024 für glibc 2.41) würde die Nutzung des unsortierten Bins weiter reduzieren; beobachte zukünftige Releases bei der Entwicklung generischer Exploits.
* **Safe-linking (glibc ≥ 2.32)** schützt nur die einfach verlinkten *tcache*/**fastbin** Listen. Die unsortierten/kleinen/großen Bins speichern weiterhin rohe Zeiger, sodass Überlappungen basierend auf dem ersten Fit weiterhin möglich sind, wenn du einen Heap-Leak erhalten kannst.
* **Heap-Zeiger-Verschlüsselung & MTE** (ARM64) betreffen x86-64 glibc noch nicht, aber Härtungsflags der Distribution wie `GLIBC_TUNABLES=glibc.malloc.check=3` werden bei inkonsistenten Metadaten abbrechen und naive PoCs brechen.
* **Füllen des tcache beim Freigeben** (vorgeschlagen für 2024 für glibc 2.41) würde die Nutzung von unsortierten Chunks weiter reduzieren; beobachte zukünftige Releases bei der Entwicklung generischer Exploits.
---
## Weitere Referenzen & Beispiele
@ -116,14 +114,14 @@ Eine praktische Anwendung findet sich in der *Setjmp*-Herausforderung der HITCON
- [**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: Erzeuge ein Benutzerobjekt, gib es frei, erzeuge ein Objekt, das den freigegebenen Chunk erhält und schreibe darauf, **überschreibe die Position von user->password** vom vorherigen. Wiederverwende den Benutzer, um **die Passwortüberprüfung zu umgehen**.
- [**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)
- Das Programm erlaubt das Erstellen von Notizen. Eine Notiz hat die Notizinformationen in einem malloc(8) (mit einem Zeiger auf eine Funktion, die aufgerufen werden könnte) und einen Zeiger auf ein anderes malloc(<size>) mit dem Inhalt der Notiz.
- Der Angriff würde darin bestehen, 2 Notizen (note0 und note1) mit größeren malloc-Inhalten als der Notizinformationsgröße zu erstellen und sie dann freizugeben, damit sie in den Fast Bin (oder tcache) gelangen.
- Dann erstelle eine weitere Notiz (note2) mit einer Inhaltsgröße von 8. Der Inhalt wird in note1 sein, da der Chunk wiederverwendet wird, wo wir den Funktionszeiger ändern könnten, um auf die Gewinnfunktion zu zeigen und dann Use-After-Free für note1 zu verwenden, um den neuen Funktionszeiger aufzurufen.
- Das Programm erlaubt das Erstellen von Notizen. Eine Notiz hat die Notizinformation in einem malloc(8) (mit einem Zeiger auf eine Funktion, die aufgerufen werden könnte) und einen Zeiger auf ein anderes malloc(<size>) mit dem Inhalt der Notiz.
- Der Angriff würde darin bestehen, 2 Notizen (note0 und note1) mit größeren malloc-Inhalten als der Notizinformationsgröße zu erstellen und sie dann freizugeben, sodass sie in den Fast Bin (oder tcache) gelangen.
- Dann, erstelle eine weitere Notiz (note2) mit einer Inhaltsgröße von 8. Der Inhalt wird in note1 sein, da der Chunk wiederverwendet wird, wo wir den Funktionszeiger ändern könnten, um auf die Gewinnfunktion zu zeigen und dann Use-After-Free die note1 zu verwenden, um den neuen Funktionszeiger aufzurufen.
- [**https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html)
- Es ist möglich, etwas Speicher zu allocieren, den gewünschten Wert zu schreiben, ihn freizugeben, ihn erneut zu allocieren und da die vorherigen Daten noch vorhanden sind, wird er gemäß der neuen erwarteten Struktur im Chunk behandelt, was es ermöglicht, den Wert zu setzen, um das Flag zu erhalten.
- [**https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html)
- In diesem Fall ist es notwendig, 4 in einen bestimmten Chunk zu schreiben, der der erste ist, der allociert wird (auch nachdem alle gezwungen freigegeben wurden). Bei jedem neu allocierten Chunk wird seine Nummer im Array-Index gespeichert. Dann allociere 4 Chunks (+ den ursprünglich allocierten), der letzte wird 4 enthalten, gib sie frei und zwinge die Reallokation des ersten, der den letzten freigegebenen Chunk verwenden wird, der den 4 enthält.
- In diesem Fall ist es notwendig, 4 innerhalb eines bestimmten Chunks zu schreiben, der der erste ist, der allociert wird (auch nachdem alle gezwungen freigegeben wurden). Bei jedem neu allocierten Chunk wird seine Nummer im Array-Index gespeichert. Dann, allociere 4 Chunks (+ den ursprünglich allocierten), der letzte wird 4 enthalten, gib sie frei und zwinge die Reallokation des ersten, der den letzten freigegebenen Chunk verwenden wird, der den 4 enthält.
- 2024 HITCON Quals Setjmp Write-up (Quarkslab) – praktischer first-fit / unsorted-split Überlappungsangriff: <https://ctftime.org/writeup/39355>
- Angstrom CTF 2024 *heapify* Write-up – Ausnutzung der unsortierten Bin-Splittung, um libc zu leaken und Überlappung zu gewinnen: <https://hackmd.io/@aneii11/H1S2snV40>
- Angstrom CTF 2024 *heapify* Write-up – Ausnutzen der unsortierten Bin-Splittung, um libc zu leaken und Überlappung zu gewinnen: <https://hackmd.io/@aneii11/H1S2snV40>
{{#include ../../../banners/hacktricks-training.md}}