From 3855c6c4b61b8a3f1ffaf106a4df2a292ccc09a4 Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 12 Jun 2024 15:27:22 +0000 Subject: [PATCH] Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc --- SUMMARY.md | 3 +- .../aw2exec-__malloc_hook.md | 41 ++++++++-- binary-exploitation/heap/fast-bin-attack.md | 35 +++++---- binary-exploitation/heap/large-bin-attack.md | 78 +++++++++++++++++++ binary-exploitation/heap/tcache-bin-attack.md | 29 +++++++ .../heap/unsorted-bin-attack.md | 71 +++++++++++++++++ 6 files changed, 235 insertions(+), 22 deletions(-) create mode 100644 binary-exploitation/heap/large-bin-attack.md create mode 100644 binary-exploitation/heap/tcache-bin-attack.md create mode 100644 binary-exploitation/heap/unsorted-bin-attack.md diff --git a/SUMMARY.md b/SUMMARY.md index c76bee72e..e688d3892 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -736,6 +736,7 @@ * [Fast Bin Attack](binary-exploitation/heap/fast-bin-attack.md) * [Unsorted Bin Attack](binary-exploitation/heap/unsorted-bin-attack.md) * [Large Bin Attack](binary-exploitation/heap/large-bin-attack.md) + * [Tcache Bin Attack](binary-exploitation/heap/tcache-bin-attack.md) * [Off by one overflow](binary-exploitation/heap/off-by-one-overflow.md) * [House of Spirit](binary-exploitation/heap/house-of-spirit.md) * [House of Lore](binary-exploitation/heap/house-of-lore.md) @@ -762,7 +763,7 @@ * [WWW2Exec - atexit()](binary-exploitation/arbitrary-write-2-exec/www2exec-atexit.md) * [WWW2Exec - .dtors & .fini\_array](binary-exploitation/arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md) * [WWW2Exec - GOT/PLT](binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md) - * [WWW2Exec - \_\_malloc\_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-\_\_malloc\_hook.md) + * [WWW2Exec - \_\_malloc\_hook & \_\_free\_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-\_\_malloc\_hook.md) * [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md) * [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md) diff --git a/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md b/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md index 1483462c0..6874713f4 100644 --- a/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md +++ b/binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md @@ -1,12 +1,12 @@ -# WWW2Exec - \_\_malloc\_hook +# WWW2Exec - \_\_malloc\_hook & \_\_free\_hook
-Impara l'hacking su AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)! +Impara l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)! Altri modi per supportare HackTricks: -* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)! +* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PACCHETTI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)! * Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com) * Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family) * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** @@ -16,9 +16,9 @@ Altri modi per supportare HackTricks: ## **Malloc Hook** -Come puoi vedere sul [sito ufficiale di GNU](https://www.gnu.org/software/libc/manual/html\_node/Hooks-for-Malloc.html), la variabile **`__malloc_hook`** è un puntatore che punta all'**indirizzo di una funzione che verrà chiamata** ogni volta che viene chiamato `malloc()` **memorizzata nella sezione dati della libreria libc**. Pertanto, se questo indirizzo viene sovrascritto con un **One Gadget** ad esempio e viene chiamato `malloc`, verrà chiamato il **One Gadget**. +Come puoi vedere sul [sito ufficiale di GNU](https://www.gnu.org/software/libc/manual/html\_node/Hooks-for-Malloc.html), la variabile **`__malloc_hook`** è un puntatore che punta all'**indirizzo di una funzione che verrà chiamata** ogni volta che viene chiamato `malloc()` **memorizzato nella sezione dati della libreria libc**. Pertanto, se questo indirizzo viene sovrascritto con un **One Gadget** ad esempio e viene chiamato `malloc`, verrà chiamato il **One Gadget**. -Per chiamare malloc è possibile aspettare che il programma lo chiami o chiamando `printf("%10000$c")` che alloca troppi byte facendo sì che `libc` chiami malloc per allocarli nell'heap. +Per chiamare malloc è possibile aspettare che il programma lo chiami o chiamando `printf("%10000$c")` che alloca molti byte facendo sì che `libc` chiami malloc per allocarli nell'heap. Ulteriori informazioni su One Gadget in: @@ -30,18 +30,43 @@ Ulteriori informazioni su One Gadget in: Nota che i hook sono **disabilitati per GLIBC >= 2.34**. Ci sono altre tecniche che possono essere utilizzate nelle versioni moderne di GLIBC. Vedi: [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md). {% endhint %} -## References +## Free Hook + +Questo è stato abusato in uno degli esempi dalla pagina sfruttando un attacco fast bin dopo aver sfruttato un attacco unsorted bin: + +{% content-ref url="../heap/unsorted-bin-attack.md" %} +[unsorted-bin-attack.md](../heap/unsorted-bin-attack.md) +{% endcontent-ref %} + +Ora viene eseguito un **attacco fast bin**: + +* Prima di tutto è stato scoperto che è possibile lavorare con **chunk di dimensione 200** nella posizione di **`__free_hook`**: +* 
gef➤  p &__free_hook
+$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
+gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
+0x7ff1e9e6074f: 0x0000000000000000      0x0000000000000200
+0x7ff1e9e6075f: 0x0000000000000000      0x0000000000000000
+0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
+0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
+
+* Se riusciamo ad ottenere un chunk fast di dimensione 0x200 in questa posizione, sarà possibile sovrascrivere un puntatore di funzione che verrà eseguito +* Per fare ciò, viene creato un nuovo chunk di dimensione `0xfc` e la funzione merged viene chiamata con quel puntatore due volte, in questo modo otteniamo un puntatore a un chunk liberato di dimensione `0xfc*2 = 0x1f8` nel fast bin. +* Quindi, la funzione di modifica viene chiamata in questo chunk per modificare l'indirizzo **`fd`** di questo fast bin in modo che punti alla funzione precedente di **`__free_hook`**. +* Successivamente, viene creato un chunk di dimensione `0x1f8` per recuperare dal fast bin il chunk inutile precedente in modo che un altro chunk di dimensione `0x1f8` venga creato per ottenere un chunk fast bin nel **`__free_hook`** che viene sovrascritto con l'indirizzo della funzione **`system`**. +* E infine viene liberato un chunk contenente la stringa `/bin/sh\x00` chiamando la funzione di eliminazione, attivando la funzione **`__free_hook`** che punta a system con `/bin/sh\x00` come parametro. + +## Riferimenti * [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook) * [https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md).
-Impara l'hacking su AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)! +Impara l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)! Altri modi per supportare HackTricks: -* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)! +* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PACCHETTI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)! * Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com) * Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family) * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** diff --git a/binary-exploitation/heap/fast-bin-attack.md b/binary-exploitation/heap/fast-bin-attack.md index ce7a844de..0eb0755d9 100644 --- a/binary-exploitation/heap/fast-bin-attack.md +++ b/binary-exploitation/heap/fast-bin-attack.md @@ -10,13 +10,19 @@ Altri modi per supportare HackTricks: * Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com) * Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family) * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** -* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github. +* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
## Informazioni di Base -Poiché il fast bin è a singolo collegamento, ci sono molte meno protezioni rispetto ad altri bin e semplicemente **modificare un indirizzo in un chunk fast bin liberato** è sufficiente per poter **allocare successivamente un chunk in qualsiasi indirizzo di memoria**. +Per ulteriori informazioni su cosa sia un fast bin, controlla questa pagina: + +{% content-ref url="bins-and-memory-allocations.md" %} +[bins-and-memory-allocations.md](bins-and-memory-allocations.md) +{% endcontent-ref %} + +Poiché il fast bin è single linked, ci sono molte meno protezioni rispetto ad altri bin e semplicemente **modificare un indirizzo in un chunk fast bin liberato** è sufficiente per poter **allocare successivamente un chunk in qualsiasi indirizzo di memoria**. In sintesi: @@ -126,21 +132,24 @@ printf("Chunk 5: %p\t Contains: 0x%x\n", ptr5, (int)*ptr5); printf("\n\nJust like that, we executed a fastbin attack to allocate an address to a stack variable using malloc!\n"); } - ``` +{% hint style="danger" %} +Se è possibile sovrascrivere il valore della variabile globale **`global_max_fast`** con un numero grande, ciò consente di generare fast bin di dimensioni maggiori, permettendo potenzialmente di eseguire attacchi fast bin in scenari in cui in precedenza non era possibile. +{% endhint %} + ## Esempi * **CTF** [**https://guyinatuxedo.github.io/28-fastbin\_attack/0ctf\_babyheap/index.html**](https://guyinatuxedo.github.io/28-fastbin\_attack/0ctf\_babyheap/index.html)**:** * È possibile allocare chunk, liberarli, leggerne i contenuti e riempirli (con una vulnerabilità di overflow). -* **Consolidare il chunk per l'infoleak**: La tecnica consiste nell'abusare dell'overflow per creare una dimensione previa fittizia in modo che un chunk precedente venga inserito in uno più grande, quindi quando si alloca il più grande contenente un altro chunk, è possibile stamparne i dati e ottenere un indirizzo a libc (main\_arena+88). -* **Sovrascrivere l'hook di malloc**: Per fare ciò, e sfruttando la situazione di sovrapposizione precedente, era possibile avere 2 chunk che puntavano alla stessa memoria. Di conseguenza, liberandoli entrambi (liberando un altro chunk in mezzo per evitare protezioni) era possibile avere lo stesso chunk nel fast bin 2 volte. Poi, era possibile allocarlo di nuovo, sovrascrivere l'indirizzo al prossimo chunk in modo che puntasse un po' prima di malloc\_hook (in modo che puntasse a un intero che malloc pensa sia una dimensione libera - un altro bypass), allocarlo di nuovo e quindi allocare un altro chunk che riceverà un indirizzo agli hook di malloc.\ +* **Consolidare chunk per infoleak**: La tecnica consiste nell'abuso dell'overflow per creare una dimensione previa fittizia in modo che un chunk precedente venga inserito in uno più grande, quindi quando si alloca il più grande contenente un altro chunk, è possibile stamparne i dati e ottenere un indirizzo a libc (main\_arena+88). +* **Sovrascrivere l'hook di malloc**: Per fare ciò, e sfruttando la situazione di sovrapposizione precedente, è stato possibile avere 2 chunk che puntavano alla stessa memoria. Di conseguenza, liberandoli entrambi (liberando un altro chunk in mezzo per evitare protezioni) è stato possibile avere lo stesso chunk nel fast bin 2 volte. Quindi, è stato possibile allocarlo di nuovo, sovrascrivere l'indirizzo al chunk successivo in modo che punti un po' prima di malloc\_hook (in modo che punti a un intero che malloc pensa sia una dimensione libera - un altro bypass), allocarlo di nuovo e quindi allocare un altro chunk che riceverà un indirizzo agli hook di malloc.\ Infine è stato scritto un **one gadget** lì. * **CTF** [**https://guyinatuxedo.github.io/28-fastbin\_attack/csaw17\_auir/index.html**](https://guyinatuxedo.github.io/28-fastbin\_attack/csaw17\_auir/index.html)**:** -* C'è un overflow di heap e user after free e double free perché quando un chunk viene liberato è possibile riutilizzare e liberare nuovamente i puntatori. +* C'è un heap overflow e user after free e double free perché quando un chunk viene liberato è possibile riutilizzare e liberare nuovamente i puntatori. * **Leak di informazioni su Libc**: Basta liberare alcuni chunk e otterranno un puntatore a una parte della posizione dell'arena principale. Poiché è possibile riutilizzare i puntatori liberati, basta leggere questo indirizzo. -* **Attacco al fast bin**: Tutti i puntatori alle allocazioni sono memorizzati all'interno di un array, quindi possiamo liberare un paio di chunk fast bin e nell'ultimo sovrascrivere l'indirizzo per puntare un po' prima di questo array di puntatori. Quindi, allocare un paio di chunk con la stessa dimensione e otterremo prima quello legittimo e poi quello falso contenente l'array di puntatori. Ora possiamo sovrascrivere questi puntatori di allocazione per puntare all'indirizzo got di `free` per puntare a system e quindi scrivere il chunk 1 `"/bin/sh"` per poi `free(chunk1)` che eseguirà `system("/bin/sh")`. - -Puoi trovare un attacco Fast Bin abusato attraverso un attacco unsorted bin negli esempi da: +* **Attacco fast bin**: Tutti i puntatori alle allocazioni sono memorizzati all'interno di un array, quindi possiamo liberare un paio di chunk fast bin e nell'ultimo sovrascrivere l'indirizzo per puntare un po' prima di questo array di puntatori. Quindi, allocare un paio di chunk con la stessa dimensione e otterremo prima quello legittimo e poi quello falso contenente l'array di puntatori. Ora possiamo sovrascrivere questi puntatori di allocazione per puntare all'indirizzo got di `free` per puntare a system e quindi scrivere il chunk 1 `"/bin/sh"` per poi `free(chunk1)` che eseguirà `system("/bin/sh")`. +* Puoi trovare un attacco Fast Bin abusato attraverso un attacco unsorted bin. +* Nota {% content-ref url="unsorted-bin-attack.md" %} [unsorted-bin-attack.md](unsorted-bin-attack.md) @@ -148,14 +157,14 @@ Puoi trovare un attacco Fast Bin abusato attraverso un attacco unsorted bin negl
-Impara l'hacking di AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)! +Impara l'hacking AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)! Altri modi per supportare HackTricks: -* Se desideri vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)! +* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)! * Ottieni il [**merchandising ufficiale PEASS & HackTricks**](https://peass.creator-spring.com) -* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family) +* Scopri [**The PEASS Family**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusivi [**NFT**](https://opensea.io/collection/the-peass-family) * **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** -* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos. +* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repository di github.
diff --git a/binary-exploitation/heap/large-bin-attack.md b/binary-exploitation/heap/large-bin-attack.md new file mode 100644 index 000000000..da68ba109 --- /dev/null +++ b/binary-exploitation/heap/large-bin-attack.md @@ -0,0 +1,78 @@ +# Attacco Large Bin + +
+ +Impara l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)! + +Altri modi per supportare HackTricks: + +* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)! +* Ottieni il [**merchandising ufficiale PEASS & HackTricks**](https://peass.creator-spring.com) +* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusivi [**NFT**](https://opensea.io/collection/the-peass-family) +* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github. + +
+ +## Informazioni di Base + +Per ulteriori informazioni su cosa sia un large bin, controlla questa pagina: + +{% content-ref url="bins-and-memory-allocations.md" %} +[bins-and-memory-allocations.md](bins-and-memory-allocations.md) +{% endcontent-ref %} + +È possibile trovare un ottimo esempio in [**how2heap - large bin attack**](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/large\_bin\_attack.c). + +Fondamentalmente qui puoi vedere come, nell'ultima "corrente" versione di glibc (2.35), non viene controllato: **`P->bk_nextsize`** permettendo di modificare un indirizzo arbitrario con il valore di un chunk di large bin se vengono soddisfatte determinate condizioni. + +In quell'esempio puoi trovare le seguenti condizioni: + +* Viene allocato un chunk grande +* Viene allocato un chunk grande più piccolo del primo ma nello stesso indice +* Deve essere più piccolo quindi nel bin deve andare prima +* (Viene creato un chunk per evitare la fusione con il chunk superiore) +* Quindi, il primo chunk grande viene liberato e viene allocato un nuovo chunk più grande di esso -> Chunk1 va nel large bin +* Quindi, il secondo chunk grande viene liberato +* Ora, la vulnerabilità: L'attaccante può modificare `chunk1->bk_nextsize` in `[target-0x20]` +* Quindi, viene allocato un chunk più grande rispetto al chunk 2, quindi il chunk2 viene inserito nel large bin sovrascrivendo l'indirizzo `chunk1->bk_nextsize->fd_nextsize` con l'indirizzo di chunk2 + +{% hint style="success" %} +Ci sono altri scenari potenziali, l'importante è aggiungere al large bin un chunk che è **più piccolo** di un attuale chunk X nel bin, quindi deve essere inserito proprio prima di esso nel bin, e dobbiamo essere in grado di modificare **`bk_nextsize`** di X poiché è lì che verrà scritto l'indirizzo del chunk più piccolo. +{% endhint %} + +Questo è il codice rilevante da malloc. Sono stati aggiunti commenti per capire meglio come è stata sovrascritta l'indirizzo: + +{% code overflow="wrap" %} +```c +/* if smaller than smallest, bypass loop below */ +assert (chunk_main_arena (bck->bk)); +if ((unsigned long) (size) < (unsigned long) chunksize_nomask (bck->bk)) +{ +fwd = bck; // fwd = p1 +bck = bck->bk; // bck = p1->bk + +victim->fd_nextsize = fwd->fd; // p2->fd_nextsize = p1->fd (Note that p1->fd is p1 as it's the only chunk) +victim->bk_nextsize = fwd->fd->bk_nextsize; // p2->bk_nextsize = p1->fd->bk_nextsize +fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim; // p1->fd->bk_nextsize->fd_nextsize = p2 +} +``` +{% endcode %} + +Questo potrebbe essere utilizzato per **sovrascrivere la variabile globale `global_max_fast`** di libc per poi sfruttare un attacco fast bin con chunk più grandi. + +Puoi trovare un'altra ottima spiegazione di questo attacco in [**guyinatuxedo**](https://guyinatuxedo.github.io/32-largebin\_attack/largebin\_explanation0/index.html). + +
+ +Impara l'hacking su AWS da zero a esperto con htARTE (HackTricks AWS Red Team Expert)! + +Altri modi per supportare HackTricks: + +* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)! +* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com) +* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family) +* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repository di github. + +
diff --git a/binary-exploitation/heap/tcache-bin-attack.md b/binary-exploitation/heap/tcache-bin-attack.md new file mode 100644 index 000000000..283830063 --- /dev/null +++ b/binary-exploitation/heap/tcache-bin-attack.md @@ -0,0 +1,29 @@ +# Attacco al Bin di Tcache + +
+ +Impara l'hacking di AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)! + +Altri modi per supportare HackTricks: + +* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)! +* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com) +* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family) +* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e ai [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repository di github. + +
+ +## Informazioni di Base + +Per ulteriori informazioni su cosa sia un bin di tcache, controlla questa pagina: + +{% content-ref url="bins-and-memory-allocations.md" %} +[bins-and-memory-allocations.md](bins-and-memory-allocations.md) +{% endcontent-ref %} + +Innanzitutto, nota che il Tcache è stato introdotto nella versione 2.26 di glibc. + +L'attacco **Tcache** proposto nella [**pagina guyinatuxido**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) è molto simile all'attacco fast bin dove l'obiettivo è sovrascrivere il puntatore al prossimo chunk nel bin all'interno di un chunk liberato con un indirizzo arbitrario in modo da poter successivamente **allocare quell'indirizzo specifico e sovrascrivere potenzialmente i puntatori**. + +Tuttavia, al giorno d'oggi, se esegui il codice menzionato otterrai l'errore: **`malloc(): unaligned tcache chunk detected`**. Quindi, è necessario scrivere come indirizzo nel nuovo puntatore un indirizzo allineato (o eseguire abbastanza volte il binario in modo che l'indirizzo scritto sia effettivamente allineato). diff --git a/binary-exploitation/heap/unsorted-bin-attack.md b/binary-exploitation/heap/unsorted-bin-attack.md new file mode 100644 index 000000000..1be6ea398 --- /dev/null +++ b/binary-exploitation/heap/unsorted-bin-attack.md @@ -0,0 +1,71 @@ +# Attacco al Bin Non Ordinato + +
+ +Impara l'hacking di AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)! + +Altri modi per supportare HackTricks: + +* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)! +* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com) +* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family) +* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.** +* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e ai repository github di [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud). + +
+ +## Informazioni di Base + +Per ulteriori informazioni su cosa sia un bin non ordinato, controlla questa pagina: + +{% content-ref url="bins-and-memory-allocations.md" %} +[bins-and-memory-allocations.md](bins-and-memory-allocations.md) +{% endcontent-ref %} + +Le liste non ordinate sono in grado di scrivere l'indirizzo in `unsorted_chunks (av)` nell'indirizzo `bk` del chunk. Pertanto, se un attaccante può **modificare l'indirizzo del puntatore bk** in un chunk all'interno del bin non ordinato, potrebbe essere in grado di **scrivere quell'indirizzo in un indirizzo arbitrario** che potrebbe essere utile per ottenere un leak di indirizzi libc o bypassare alcune difese. + +Quindi, fondamentalmente, questo attacco permette di **sovrascrivere un indirizzo arbitrario con un numero grande** (un indirizzo che potrebbe essere un indirizzo di heap o un indirizzo libc) come un indirizzo di stack che potrebbe essere leakato o una restrizione come la variabile globale **`global_max_fast`** per consentire di creare bin rapidi con dimensioni maggiori (e passare da un attacco al bin non ordinato a un attacco al bin rapido). + +{% hint style="success" %} +Guardando l'esempio fornito in [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#principle) e utilizzando 0x4000 e 0x5000 invece di 0x400 e 0x500 come dimensioni dei chunk (per evitare tcaches) è possibile vedere che **oggi** l'errore **`malloc(): unsorted double linked list corrupted`** viene attivato. + +Pertanto, questo attacco al bin non ordinato ora (tra altri controlli) richiede anche di essere in grado di correggere la lista doppiamente collegata in modo che venga bypassato `victim->bck->fd == victim` o non `victim->fd == av (arena)`. Ciò significa che l'indirizzo in cui vogliamo scrivere deve avere l'indirizzo del chunk falso nella sua posizione `fd` e che il `fd` del chunk falso punti all'arena. +{% endhint %} + +{% hint style="danger" %} +Nota che questo attacco corrompe il bin non ordinato (quindi anche quello piccolo e grande). Quindi possiamo **usare solo allocazioni dal bin rapido ora** (un programma più complesso potrebbe fare altre allocazioni e bloccarsi), e per attivare questo dobbiamo **allocare la stessa dimensione o il programma si bloccherà.** + +Nota che rendere **`global_max_fast`** potrebbe aiutare in questo caso fidandosi che il bin rapido sarà in grado di gestire tutte le altre allocazioni fino a quando l'exploit non è completato. +{% endhint %} + +Il codice di [**guyinatuxedo**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/unsorted\_explanation/index.html) lo spiega molto bene, anche se se si modificano le malloc per allocare memoria sufficientemente grande in modo che non finisca in un tcache, si può vedere che compare l'errore precedentemente menzionato che impedisce questa tecnica: **`malloc(): unsorted double linked list corrupted`** + +## Riferimenti e Altri Esempi + +* [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#hitcon-training-lab14-magic-heap**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/unsorted\_bin\_attack/#hitcon-training-lab14-magic-heap) +* L'obiettivo è sovrascrivere una variabile globale con un valore maggiore di 4869 in modo da poter ottenere il flag e PIE non è abilitato. +* È possibile generare chunk di dimensioni arbitrarie e c'è un heap overflow con la dimensione desiderata. +* L'attacco inizia creando 3 chunk: chunk0 per sfruttare l'overflow, chunk1 per essere sovraffollato e chunk2 in modo che il chunk superiore non consolidi quelli precedenti. +* Quindi, chunk1 viene liberato e chunk0 viene sovraffollato in modo che il puntatore `bk` di chunk1 punti a: `bk = magic - 0x10` +* Successivamente, viene allocato chunk3 con la stessa dimensione di chunk1, il che attiverà l'attacco al bin non ordinato e modificherà il valore della variabile globale, rendendo possibile ottenere il flag. +* [**https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html**](https://guyinatuxedo.github.io/31-unsortedbin\_attack/0ctf16\_zerostorage/index.html) +* La funzione di merge è vulnerabile perché se entrambi gli indici passati sono gli stessi, realloc su di esso e quindi lo libera ma restituisce un puntatore a quella regione liberata che può essere utilizzato. +* Pertanto, **vengono creati 2 chunk**: **chunk0** che verrà unito con se stesso e chunk1 per evitare la consolidazione con il chunk superiore. Quindi, la **funzione di merge viene chiamata con chunk0** due volte, causando un use after free. +* Successivamente, viene chiamata la funzione **`view`** con indice 2 (che è l'indice del chunk use after free), che **fa trapelare un indirizzo libc**. +* Poiché il binario ha protezioni per allocare solo dimensioni maggiori di **`global_max_fast`** quindi non viene utilizzato alcun fastbin, verrà utilizzato un attacco al bin non ordinato per sovrascrivere la variabile globale `global_max_fast`. +* Quindi, è possibile chiamare la funzione di modifica con l'indice 2 (il puntatore use after free) e sovrascrivere il puntatore `bk` per puntare a `p64(global_max_fast-0x10)`. Quindi, creando un nuovo chunk verrà utilizzato l'indirizzo di free compromesso in precedenza (0x20) attiverà **l'attacco al bin non ordinato** sovrascrivendo il `global_max_fast` con un valore molto grande, consentendo ora di creare chunk nei bin rapidi. +* Ora viene eseguito un **attacco al fast bin**: +* Prima di tutto si scopre che è possibile lavorare con **chunk rapidi di dimensione 200** nella posizione di **`__free_hook`**: +* 
gef➤  p &__free_hook
+$1 = (void (**)(void *, const void *)) 0x7ff1e9e607a8 <__free_hook>
+gef➤  x/60gx 0x7ff1e9e607a8 - 0x59
+0x7ff1e9e6074f: 0x0000000000000000      0x0000000000000200
+0x7ff1e9e6075f: 0x0000000000000000      0x0000000000000000
+0x7ff1e9e6076f <list_all_lock+15>:      0x0000000000000000      0x0000000000000000
+0x7ff1e9e6077f <_IO_stdfile_2_lock+15>: 0x0000000000000000      0x0000000000000000
+
+* Se riusciamo a ottenere un chunk rapido di dimensione 0x200 in questa posizione, sarà possibile sovrascrivere un puntatore di funzione che verrà eseguito +* Per fare ciò, viene creato un nuovo chunk di dimensione `0xfc` e la funzione di merge viene chiamata con quel puntatore due volte, in questo modo otteniamo un puntatore a un chunk liberato di dimensione `0xfc*2 = 0x1f8` nel fast bin. +* Quindi, viene chiamata la funzione di modifica in questo chunk per modificare l'indirizzo **`fd`** di questo fast bin in modo che punti alla funzione precedente di **`__free_hook`**. +* Quindi, viene creato un chunk con dimensione `0x1f8` per recuperare dal fast bin il chunk inutilizzato precedente in modo da creare un altro chunk di dimensione `0x1f8` per ottenere un chunk fast bin nel **`__free_hook`** che viene sovrascritto con l'indirizzo della funzione **`system`**. +* Infine, viene liberato un chunk contenente la stringa `/bin/sh\x00` chiamando la funzione di eliminazione, attivando la funzione **`__free_hook`** che punta a system con `/bin/sh\x00` come parametro.