Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
how2heap — Un repository per apprendere varie tecniche di sfruttamento dell'heap. | Kitploit
Strumenti/GitHubGitHub/shellphish/how2heap
ExploitCTFApprendimento e FormazioneRisorse CurateBinary ExploitationLab e PraticaTop in Binary Exploitation n.4Top in CTF n.7
GitHubshellphish/how2heap

how2heap

Un repository per apprendere varie tecniche di sfruttamento dell'heap.

8.8k1.3k93 mesi faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Vedi Repository
Condividi

Exploit Educativi dell'Heap

Questa repository serve per apprendere varie tecniche di exploitation dell'heap. Usiamo le release della Libc di Ubuntu come standard di riferimento. Ogni tecnica è verificata per funzionare sulle corrispondenti release di Ubuntu. Puoi eseguire apt source libc6 per scaricare il codice sorgente della Libc che stai usando su un sistema operativo basato su Debian. Puoi anche fare clic su ▶️ per eseguire il debug della tecnica nel tuo browser usando gdb.

L'idea è nata durante un hack meeting e abbiamo implementato le seguenti tecniche:

Scarica lo strumento
File▶️TecnicaVersione GlibcPatchSfide CTF Applicabili
first_fit.cDimostra il comportamento first-fit di malloc in glibc.
calc_tcache_idx.cDimostrare il calcolo dell'indice tcache di glibc.
fastbin_dup.c▶️Indurre malloc a restituire un puntatore heap già allocato abusando della freelist fastbin.< 2.43patch
fastbin_dup_into_stack.c▶️Indurre malloc a restituire un puntatore quasi arbitrario abusando della freelist fastbin.< 2.43patch9447-search-engine, 0ctf 2017-babyheap
fastbin_dup_consolidate.c▶️Indurre malloc a restituire un puntatore heap già allocato inserendo un puntatore sia nella freelist fastbin che nella top chunk.< 2.43patchHitcon 2016 SleepyHolder
unsafe_unlink.c▶️Sfruttare la free su una chunk corrotta per ottenere scrittura arbitraria.latestHITCON CTF 2014-stkof, Insomni'hack 2017-Wheel of Robots
house_of_spirit.c▶️Eseguire la free di una fake chunk fastbin per ottenere da malloc un puntatore quasi arbitrario.latesthack.lu CTF 2014-OREO
poison_null_byte.c▶️Sfruttare un overflow di un singolo byte nullo.latestPlaidCTF 2015-plaiddb, BalsnCTF 2019-PlainNote
house_of_lore.c▶️Indurre malloc a restituire un puntatore quasi arbitrario abusando della freelist smallbin.latest
overlapping_chunks.c▶️Sfruttare la sovrascrittura della dimensione di una chunk liberata nella unsorted bin per fare in modo che una nuova allocazione si sovrapponga a una chunk esistente< 2.29patchhack.lu CTF 2015-bookstore, Nuit du Hack 2016-night-deamonic-heap
overlapping_chunks_2.c▶️Sfruttare la sovrascrittura della dimensione di una chunk in uso per fare in modo che una nuova allocazione si sovrapponga a una chunk esistente< 2.29patch
mmap_overlapping_chunks.cSfruttare una chunk mmap in uso per fare in modo che una nuova allocazione si sovrapponga a una chunk mmap correntelatest
house_of_force.c▶️Sfruttare l'header della Top Chunk (Wilderness) per ottenere da malloc un puntatore quasi arbitrario< 2.29patchBoston Key Party 2016-cookbook, BCTF 2016-bcloud
unsorted_bin_into_stack.c▶️Sfruttare la sovrascrittura di una chunk liberata nella freelist della unsorted bin per ottenere un puntatore quasi arbitrario.< 2.29patch
unsorted_bin_attack.c▶️Sfruttare la sovrascrittura di una chunk liberata nella freelist della unsorted bin per scrivere un valore grande in un indirizzo arbitrario< 2.29patch0ctf 2016-zerostorage
large_bin_attack.c▶️Sfruttare la sovrascrittura di una chunk liberata nella freelist della large bin per scrivere un valore grande in un indirizzo arbitrario< 2.42patch0ctf 2018-heapstorm2
house_of_einherjar.c▶️Sfruttare un overflow di un singolo byte nullo per indurre malloc a restituire un puntatore controllatolatestSeccon 2016-tinypad
house_of_water.cSfruttare una UAF o una double free per ottenere il controllo senza leak dei metadati della t-cache e un modo senza leak per collegare la libc nella t-cachelatest37c3 Potluck - Tamagoyaki
sysmalloc_int_free.cDimostrare la liberazione della Top Chunk (Wilderness) di dimensione quasi arbitraria usando malloc (sysmalloc _int_free() )latest
house_of_orange.c▶️Sfruttare la Top Chunk (Wilderness) per ottenere l'esecuzione di codice arbitrario< 2.26patchHitcon 2016 houseoforange
house_of_tangerine.cSfruttare la Top Chunk (Wilderness) per indurre malloc a restituire un puntatore completamente arbitrario abusando della freelist tcache>= 2.26PicoCTF 2024- high frequency troubles
house_of_roman.c▶️Tecnica senza leak per ottenere l'esecuzione remota di codice tramite fake fastbins, l'attacco unsorted_bin e sovrascritture relative.< 2.29patch
tcache_poisoning.c▶️Indurre malloc a restituire un puntatore completamente arbitrario abusando della freelist tcache. (richiede heap leak dalla 2.32 in poi)> 2.25patch
tcache_house_of_spirit.c▶️Eseguire la free di una fake chunk per ottenere da malloc un puntatore quasi arbitrario.> 2.25
house_of_botcake.c▶️Bypassare la restrizione della double free su tcache. Riporta tcache_dup ai vecchi splendori.> 2.25
tcache_stashing_unlink_attack.c▶️Sfruttare la sovrascrittura di una chunk liberata nella freelist small bin per indurre malloc a restituire un puntatore arbitrario e scrivere un valore grande in un indirizzo arbitrario con l'aiuto di calloc.> 2.25Hitcon 2019 one punch man
fastbin_reverse_into_tcache.c▶️Sfruttare la sovrascrittura di una chunk liberata nella fastbin per scrivere un valore grande in un indirizzo arbitrario.2.26 - 2.42patch
house_of_mind_fastbin.c▶️Sfruttare una sovrascrittura di un singolo byte nella gestione dell'arena per scrivere un valore grande (puntatore heap) in un indirizzo arbitrario< 2.43patch
house_of_storm.c▶️Sfruttare una use after free su una chunk della large bin e una della unsorted bin per ottenere da malloc una chunk arbitraria< 2.29
house_of_gods.c▶️Una tecnica per dirottare l'arena di un thread entro 8 allocazioni< 2.27
decrypt_safe_linking.c▶️Decriptare il valore avvelenato nella lista collegata per recuperare il puntatore reale>= 2.32
safe_link_double_protect.cBypass senza leak per PROTECT_PTR proteggendo due volte un puntatore, consentendo il collegamento arbitrario di puntatori nella t-cache>= 2.3237c3 Potluck - Tamagoyaki
tcache_dup.c(obsolete)Indurre malloc a restituire un puntatore heap già allocato abusando della freelist tcache.2.26 - 2.28patch
tcache_metadata_poisoning.cIndurre la tcache a fornire puntatori arbitrari manipolando la struct dei metadati della tcache>= 2.26
house_of_io.cIndurre malloc a restituire un puntatore a memoria arbitraria manipolando la struct di gestione della tcache tramite UAF in una chunk tcache liberata.2.31 - 2.33
tcache_relative_write.cScrittura di un valore decimale arbitrario e di un puntatore a chunk nell'heap tramite scrittura fuori dai limiti dei metadati tcache2.30-2.41patch
tcache_metadata_hijackingAllocazione arbitraria tramite overflow nei metadati tcache>= 2.42

La GnuLibc è in continuo sviluppo e diverse tecniche sopra descritte hanno portato all'introduzione di controlli di coerenza nella logica di malloc/free. Di conseguenza, questi controlli rompono regolarmente alcune tecniche e richiedono aggiustamenti per bypassarli (se possibile). Affrontiamo questo problema mantenendo più versioni della stessa tecnica per ogni release di Glibc che ha richiesto un aggiustamento. La struttura è glibc_<version>/technique.c.

Hai un buon esempio? Aggiungilo qui! Cerca di includere l'intera tecnica in un singolo file .c -- è molto più facile da imparare in questo modo.

Per Iniziare

Configurazione Rapida

  • assicurati di avere installati i seguenti pacchetti/strumenti: patchelf zstd wget (ovviamente anche build-essential o simili per i compilatori, make, ...)
  • inoltre, /usr/bin/python deve essere o puntare al tuo binario python (ad es. /usr/bin/python3)```shell git clone https://github.com/shellphish/how2heap cd how2heap make clean base ./malloc_playground
root@kitploit:~
Notice that this will link the binaries with your system libc. If you want to play with other libc versions. Please refer to `Complete Setup`.

## Complete Setup

You will encounter symbol versioning issues (see [this](https://github.com/shellphish/how2heap/issues/169)) if you try to `LD_PRELOAD` libcs to a binary that's compiled on your host machine.
We have two ways to bypass it.

### Method 1: link against older libc
This one tells linker to link the target binary with the target libc.```shell
git clone https://github.com/shellphish/how2heap
cd how2heap
H2H_USE_SYSTEM_LIBC=N make v2.23

Questo linkerà tutti i binari con le corrispondenti libc. La parte migliore è che include i simboli di debug. Ora puoi giocare con qualsiasi versione di libc sulla tua macchina host. In questo esempio, compilerà tutti i binari di glibc-2.23 e li linkerà con libc-2.23. Puoi cambiare il numero per giocare con altre versioni di libc.

Metodo 2: usa docker

Questo approccio si basa su Docker per compilare i binari all'interno di un vecchio container ubuntu, così che siano eseguibili con la versione di libc target.```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

root@kitploit:~
# Strumenti per lo sfruttamento dell'heap

Ci sono alcuni strumenti per lo sfruttamento dell'heap in circolazione.

## Malloc Playground

Il file `malloc_playground.c` fornito è il sorgente di un programma che chiede all'utente di inserire comandi per allocare e liberare memoria in modo interattivo.

## Pwngdb

Esamina l'heap di glibc in gdb: https://github.com/scwuaptx/Pwngdb

## pwndbg

Un plugin per gdb incentrato sullo sfruttamento che offre la possibilità di visualizzare/manipolare l'heap di glibc: https://github.com/pwndbg/pwndbg

## gef

Un altro eccellente plugin per gdb che offre la possibilità di esaminare l'heap di glibc: https://github.com/hugsy/gef

## heap-viewer

Esamina l'heap di glibc in IDA Pro: https://github.com/danigargu/heap-viewer

## heaptrace

Aiuta a visualizzare le operazioni sull'heap sostituendo gli indirizzi con i simboli: https://github.com/Arinerron/heaptrace

# Altre risorse

Alcune buone risorse sullo sfruttamento dell'heap, più o meno in ordine inverso di pubblicazione, sono:

## Tutorial utili sullo sfruttamento dell'heap
- Panoramica delle tecniche di sfruttamento dell'heap di GLIBC (https://0x434b.dev/overview-of-glibc-heap-exploitation-techniques/) <!-- 2022 -->
- Tutorial approfondito su glibc (https://heap-exploitation.dhavalkapil.com/) - libro ed esempi di exploit <!-- 2022 -->
- Tecniche di sfruttamento dell'heap che funzionano su glibc-2.31 (https://github.com/StarCross-Tech/heap_exploit_2.31) <!-- 2020 -->
- Introduzione indolore all'heap userland di Linux (https://sensepost.com/blog/2017/painless-intro-to-the-linux-userland-heap/) <!-- 2017 -->
- ptmalloc fanzine, un insieme di risorse ed esempi relativi ad attacchi ai metadati su 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) - sfruttamento avanzato dell'heap <!-- 2015 -->

## Sfruttamento storico dell'heap (La storia)
- 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) - alcune tecniche di sfruttamento di malloc <!-- 2009 -->
- Ancora un'altra tecnica di sfruttamento di free() (http://phrack.org/issues/66/6.html) <!-- 2009 -->
- L'uso di set_head per sconfiggere la wilderness (http://phrack.org/issues/64/9.html) <!-- 2007 -->
- Comprendere l'heap rompendolo (https://www.blackhat.com/presentations/bh-usa-07/Ferguson/Whitepaper/bh-usa-07-ferguson-WP.pdf) - spiega l'implementazione dell'heap e un paio di exploit <!-- 2007 -->
- Tecniche di sfruttamento dell'heap su OS X (http://phrack.org/issues/63/5.html) <!-- 2005 -->
- The Malloc Maleficarum (http://seclists.org/bugtraq/2005/Oct/118) <!-- 2005 -->
- Sfruttare la wilderness (http://seclists.org/vuln-dev/2004/Feb/25) <!-- 2004 -->
- Exploit avanzati per la malloc di Doug Lea (http://phrack.org/issues/61/6.html) <!-- 2003 -->

# Hardening
Esistono un paio di misure di "hardening" integrate in glibc, come `export MALLOC_CHECK_=1` (abilita alcuni controlli), `export MALLOC_PERTURB_=1` (i dati vengono sovrascritti), `export MALLOC_MMAP_THRESHOLD_=1` (usa sempre mmap()), ...

Maggiori informazioni: [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).

C'è anche un supporto di tracciamento come [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), e in altre funzioni di questa famiglia.