Heap-Exploitation zu Lernzwecken

Dieses Repo dient zum Erlernen verschiedener Heap-Exploitation-Techniken. Wir verwenden die Libc-Releases von Ubuntu als Goldstandard. Jede Technik wurde verifiziert, um auf den entsprechenden Ubuntu-Releases zu funktionieren. Du kannst apt source libc6 ausführen, um den Quellcode der Libc herunterzuladen, die du auf einem Debian-basierten Betriebssystem verwendest. Du kannst auch auf ▶️ klicken, um die Technik in deinem Browser mit gdb zu debuggen.

Wir kamen während eines Hack-Meetings auf die Idee und haben die folgenden Techniken implementiert:

Datei	▶️	Technik	Glibc-Version	Patch	Anwendbare CTF-Challenges
first_fit.c		Demonstriert das First-Fit-Verhalten von glibc malloc.
calc_tcache_idx.c		Demonstriert die tcache-Indexberechnung von glibc.
fastbin_dup.c	▶️	Bringt malloc dazu, einen bereits zugewiesenen Heap-Pointer zurückzugeben, indem die fastbin-Freeliste missbraucht wird.	< 2.43	Patch
fastbin_dup_into_stack.c	▶️	Bringt malloc dazu, einen nahezu beliebigen Pointer zurückzugeben, indem die fastbin-Freeliste missbraucht wird.	< 2.43	Patch	9447-search-engine, 0ctf 2017-babyheap
fastbin_dup_consolidate.c	▶️	Bringt malloc dazu, einen bereits zugewiesenen Heap-Pointer zurückzugeben, indem ein Pointer sowohl in die fastbin-Freeliste als auch in den Top Chunk eingetragen wird.

Die GnuLibc befindet sich in ständiger Entwicklung, und einige der oben genannten Techniken haben zu Konsistenzprüfungen in der malloc/free-Logik geführt. Infolgedessen brechen diese Prüfungen regelmäßig einige der Techniken und erfordern Anpassungen, um sie (wenn möglich) zu umgehen. Wir begegnen diesem Problem, indem wir mehrere Versionen derselben Technik für jede Glibc-Version vorhalten, die eine Anpassung erforderte. Die Struktur ist glibc_<version>/technique.c.

Hast du ein gutes Beispiel? Füge es hier hinzu! Versuche, die gesamte Technik in eine einzelne .c-Datei zu packen -- so lernt es sich viel leichter.

Erste Schritte

Schnelle Einrichtung

stelle sicher, dass die folgenden Pakete/Werkzeuge installiert sind: patchelf zstd wget (natürlich auch build-essential oder Ähnliches für Compiler, make, ...)
außerdem muss /usr/bin/python dein python-Binary sein oder darauf zeigen (z. B. /usr/bin/python3)```shell git clone https://github.com/shellphish/how2heap cd how2heap make clean base ./malloc_playground

Beachte, dass dies die Binärdateien mit deiner System-libc verknüpft. Wenn du mit anderen libc-Versionen spielen möchtest, lies bitte `Complete Setup`.

## Complete Setup

Du wirst auf Symbol-Versionierungsprobleme stoßen (siehe [dieses](https://github.com/shellphish/how2heap/issues/169)), wenn du versuchst, `LD_PRELOAD` libcs an eine Binärdatei zu hängen, die auf deiner Host-Maschine kompiliert wurde.
Wir haben zwei Möglichkeiten, dies zu umgehen.

### Methode 1: Gegen ältere libc linken
Diese weist den Linker an, die Ziel-Binärdatei mit der Ziel-libc zu verlinken.```shell
git clone https://github.com/shellphish/how2heap
cd how2heap
H2H_USE_SYSTEM_LIBC=N make v2.23

Dadurch werden alle Binärdateien mit den entsprechenden libcs verknüpft. Noch besser ist, dass es mit Debug-Symbolen kommt. Jetzt kannst du auf deinem Host-Rechner mit beliebigen libc-Versionen spielen. In diesem Beispiel werden alle glibc-2.23-Binärdateien kompiliert und mit libc-2.23 verknüpft. Du kannst die Zahl ändern, um mit anderen libc-Versionen zu spielen.

Methode 2: docker verwenden

Diese Methode nutzt einen Docker-basierten Ansatz, um Binärdateien in einem alten Ubuntu-Container zu kompilieren, sodass sie mit der Ziel-libc-Version ausführbar sind.```shell git clone https://github.com/shellphish/how2heap cd how2heap

the next command will prepare the target binary so it runs with

the expected libc version

make base ./glibc_run.sh 2.30 ./malloc_playground -d -p

now you can play with the binary with glibc-2.30

and even debug it with the correct symbols

readelf -d -W malloc_playground | grep RUNPATH # or use checksec readelf -l -W malloc_playground | grep interpreter gdb -q -ex "start" ./malloc_playground

# Tools zur Heap-Exploitation

Es gibt einige Heap-Exploitation-Tools, die herumschwirren.

## Malloc Playground

Die bereitgestellte Datei `malloc_playground.c` ist der Quellcode für ein Programm, das den Benutzer interaktiv zur Eingabe von Befehlen auffordert, um Speicher zu allozieren und freizugeben.

## Pwngdb

Untersuche den glibc-Heap in gdb: https://github.com/scwuaptx/Pwngdb

## pwndbg

Ein auf Exploitation ausgerichtetes gdb-Plugin, das die Möglichkeit bietet, den glibc-Heap anzusehen/zu manipulieren: https://github.com/pwndbg/pwndbg

## gef

Ein weiteres hervorragendes gdb-Plugin, mit dem sich der glibc-Heap untersuchen lässt: https://github.com/hugsy/gef

## heap-viewer

Untersuche den glibc-Heap in IDA Pro: https://github.com/danigargu/heap-viewer

## heaptrace

Hilft dir, Heap-Operationen zu visualisieren, indem Adressen durch Symbole ersetzt werden: https://github.com/Arinerron/heaptrace

# Weitere Ressourcen

Einige gute Ressourcen zur Heap-Exploitation, ungefähr in umgekehrter Reihenfolge ihrer Veröffentlichung, sind:

## Nützliche Tutorials zur Heap-Exploitation
- Überblick über GLIBC-Heap-Exploitation-Techniken (https://0x434b.dev/overview-of-glibc-heap-exploitation-techniques/) <!-- 2022 -->
- Ausführliches glibc-Tutorial (https://heap-exploitation.dhavalkapil.com/) - Buch und Exploit-Beispiele <!-- 2022 -->
- Heap-Exploitation-Techniken, die mit glibc-2.31 funktionieren (https://github.com/StarCross-Tech/heap_exploit_2.31) <!-- 2020 -->
- Schmerzfreie Einführung in den Linux-Userland-Heap (https://sensepost.com/blog/2017/painless-intro-to-the-linux-userland-heap/) <!-- 2017 -->
- ptmalloc-Fanzine, eine Sammlung von Ressourcen und Beispielen zu Metadaten-Angriffen auf ptmalloc (http://tukan.farm/2016/07/26/ptmalloc-fanzine/) <!-- 2016 -->
- Glibc Adventures: The Forgotten Chunk (https://github.com/bash-c/slides/blob/master/pwn_heap/Glibc%20Adventures:%20The%20forgotten%20chunks.pdf) - fortgeschrittene Heap-Exploitation <!-- 2015 -->

## Historische Heap-Exploitation (Die Geschichte)
- Pseudomonarchia jemallocum (http://www.phrack.org/issues/68/10.html) <!-- 2012 -->
- The House Of Lore: Reloaded (http://phrack.org/issues/67/8.html) <!-- 2010 -->
- Malloc Des-Maleficarum (http://phrack.org/issues/66/10.html) - einige malloc-Exploitation-Techniken <!-- 2009 -->
- Wieder eine weitere free()-Exploitation-Technik (http://phrack.org/issues/66/6.html) <!-- 2009 -->
- Die Verwendung von set_head, um die Wilderness zu besiegen (http://phrack.org/issues/64/9.html) <!-- 2007 -->
- Den Heap verstehen, indem man ihn bricht (https://www.blackhat.com/presentations/bh-usa-07/Ferguson/Whitepaper/bh-usa-07-ferguson-WP.pdf) - erklärt die Heap-Implementierung und ein paar Exploits <!-- 2007 -->
- OS-X-Heap-Exploitation-Techniken (http://phrack.org/issues/63/5.html) <!-- 2005 -->
- The Malloc Maleficarum (http://seclists.org/bugtraq/2005/Oct/118) <!-- 2005 -->
- Die Wilderness ausnutzen (http://seclists.org/vuln-dev/2004/Feb/25) <!-- 2004 -->
- Fortgeschrittene Doug-lea-malloc-Exploits (http://phrack.org/issues/61/6.html) <!-- 2003 -->

# Härtung
Es gibt einige „Härtungs“-Maßnahmen, die in glibc eingebaut sind, wie `export MALLOC_CHECK_=1` (aktiviert einige Prüfungen), `export MALLOC_PERTURB_=1` (Daten werden überschrieben), `export MALLOC_MMAP_THRESHOLD_=1` (verwendet immer mmap()), ...

Weitere Informationen: [mcheck()](http://www.gnu.org/software/libc/manual/html_node/Heap-Consistency-Checking.html), [mallopt()](http://www.gnu.org/software/libc/manual/html_node/Malloc-Tunable-Parameters.html).

Es gibt auch Tracing-Unterstützung wie [mtrace()](http://manpages.ubuntu.com/mtrace), [malloc_stats()](http://manpages.ubuntu.com/malloc_stats), [malloc_info()](http://manpages.ubuntu.com/malloc_info), [memusage](http://manpages.ubuntu.com/memusage) sowie in anderen Funktionen dieser Familie.

how2heap

Beliebteste