Exploitation pédagogique du tas

Ce dépôt sert à apprendre diverses techniques d'exploitation du tas. Nous utilisons les versions de la Libc d'Ubuntu comme étalon-or. Chaque technique est vérifiée pour fonctionner sur les versions d'Ubuntu correspondantes. Vous pouvez exécuter apt source libc6 pour télécharger le code source de la Libc que vous utilisez sur un système d'exploitation basé sur Debian. Vous pouvez également cliquer sur ▶️ pour déboguer la technique dans votre navigateur avec gdb.

L'idée nous est venue lors d'une session de hacking, et nous avons implémenté les techniques suivantes :

Fichier	▶️	Technique	Version de Glibc	Correctif	Défis CTF applicables
first_fit.c		Démontre le comportement first-fit de malloc de glibc.
calc_tcache_idx.c		Démontre le calcul d'index tcache de glibc.
fastbin_dup.c	▶️	Duper malloc pour qu'il renvoie un pointeur de tas déjà alloué en abusant de la freelist fastbin.	< 2.43	correctif
fastbin_dup_into_stack.c	▶️	Duper malloc pour qu'il renvoie un pointeur presque arbitraire en abusant de la freelist fastbin.	< 2.43	correctif	9447-search-engine, 0ctf 2017-babyheap
fastbin_dup_consolidate.c	▶️	Duper malloc pour qu'il renvoie un pointeur de tas déjà alloué en plaçant un pointeur à la fois dans la freelist fastbin et dans le top chunk.

La GnuLibc est en développement constant et plusieurs des techniques ci-dessus ont conduit à des contrôles de cohérence introduits dans la logique de malloc/free. Par conséquent, ces contrôles cassent régulièrement certaines techniques et nécessitent des ajustements pour les contourner (si possible). Nous répondons à ce problème en conservant plusieurs versions de la même technique pour chaque version de Glibc ayant nécessité un ajustement. La structure est glibc_<version>/technique.c.

Vous avez un bon exemple ? Ajoutez-le ici ! Essayez d'inliner toute la technique dans un seul .c -- c'est beaucoup plus facile à apprendre ainsi.

Pour commencer

Mise en place rapide

assurez-vous d'avoir les paquets/outils suivants installés : patchelf zstd wget (bien sûr aussi build-essential ou similaire pour les compilateurs, make, ...)
également, /usr/bin/python doit être/pointer vers votre binaire python (p. ex. /usr/bin/python3)```shell git clone https://github.com/shellphish/how2heap cd how2heap make clean base ./malloc_playground

Notez que cela liera les binaires avec la libc de votre système. Si vous souhaitez essayer d'autres versions de libc, veuillez vous référer à `Complete Setup`.

## Configuration complète

Vous rencontrerez des problèmes de versionnage de symboles (voir [ceci](https://github.com/shellphish/how2heap/issues/169)) si vous essayez de précharger des libcs via `LD_PRELOAD` sur un binaire compilé sur votre machine hôte.
Nous avons deux moyens de contourner ce problème.

### Méthode 1 : lier avec une libc plus ancienne
Cette méthode indique à l'éditeur de liens de lier le binaire cible avec la libc cible.```shell
git clone https://github.com/shellphish/how2heap
cd how2heap
H2H_USE_SYSTEM_LIBC=N make v2.23

Cela liera tous les binaires avec les libc correspondantes. Mieux encore, cela inclut les symboles de débogage. Vous pouvez désormais jouer avec n'importe quelle version de libc sur votre machine hôte. Dans cet exemple, cela compilera tous les binaires glibc-2.23 et les liera avec libc-2.23. Vous pouvez modifier le numéro pour jouer avec d'autres versions de libc.

Méthode 2 : utiliser docker

Cette approche utilise Docker pour compiler les binaires dans un ancien conteneur ubuntu afin qu'ils soient exécutables avec la version de libc cible.```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

# Outils d'exploitation du tas

Il existe quelques outils d'exploitation du tas qui traînent.

## Malloc Playground

Le fichier `malloc_playground.c` fourni est le source d'un programme qui invite l'utilisateur à saisir des commandes pour allouer et libérer de la mémoire de manière interactive.

## Pwngdb

Examinez le tas de glibc dans gdb : https://github.com/scwuaptx/Pwngdb

## pwndbg

Un plugin gdb orienté exploitation qui permet de visualiser/modifier le tas de glibc : https://github.com/pwndbg/pwndbg

## gef

Un autre excellent plugin gdb qui permet d'examiner le tas de glibc : https://github.com/hugsy/gef

## heap-viewer

Examinez le tas de glibc dans IDA Pro : https://github.com/danigargu/heap-viewer

## heaptrace

Vous aide à visualiser les opérations sur le tas en remplaçant les adresses par des symboles : https://github.com/Arinerron/heaptrace

# Autres ressources

Voici quelques bonnes ressources sur l'exploitation du tas, approximativement dans l'ordre inverse de leur publication :

## Tutoriels utiles sur l'exploitation du tas
- Aperçu des techniques d'exploitation du tas de GLIBC (https://0x434b.dev/overview-of-glibc-heap-exploitation-techniques/) <!-- 2022 -->
- Tutoriel approfondi sur glibc (https://heap-exploitation.dhavalkapil.com/) - livre et exemples d'exploits <!-- 2022 -->
- Techniques d'exploitation du tas fonctionnant sur glibc-2.31 (https://github.com/StarCross-Tech/heap_exploit_2.31) <!-- 2020 -->
- Introduction sans douleur au tas de l'espace utilisateur Linux (https://sensepost.com/blog/2017/painless-intro-to-the-linux-userland-heap/) <!-- 2017 -->
- ptmalloc fanzine, un ensemble de ressources et d'exemples liés aux attaques sur les métadonnées de 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) - exploitation avancée du tas <!-- 2015 -->

## Exploitation historique du tas (The History)
- 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) - quelques techniques d'exploitation de malloc <!-- 2009 -->
- Encore une technique d'exploitation de free() (http://phrack.org/issues/66/6.html) <!-- 2009 -->
- L'utilisation de set_head pour vaincre le wilderness (http://phrack.org/issues/64/9.html) <!-- 2007 -->
- Comprendre le tas en le cassant (https://www.blackhat.com/presentations/bh-usa-07/Ferguson/Whitepaper/bh-usa-07-ferguson-WP.pdf) - explique l'implémentation du tas et quelques exploits <!-- 2007 -->
- Techniques d'exploitation du tas sous OS X (http://phrack.org/issues/63/5.html) <!-- 2005 -->
- The Malloc Maleficarum (http://seclists.org/bugtraq/2005/Oct/118) <!-- 2005 -->
- Exploiting The Wilderness (http://seclists.org/vuln-dev/2004/Feb/25) <!-- 2004 -->
- Exploits avancés de malloc de Doug Lea (http://phrack.org/issues/61/6.html) <!-- 2003 -->

# Durcissement
Il existe quelques mesures de « durcissement » intégrées à glibc, comme `export MALLOC_CHECK_=1` (active quelques vérifications), `export MALLOC_PERTURB_=1` (les données sont écrasées), `export MALLOC_MMAP_THRESHOLD_=1` (toujours utiliser mmap()), ...

Plus d'informations : [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).

Il existe également un support de traçage comme [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), et dans d'autres fonctions de cette famille.

how2heap

Populaires