diff --git a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md index fc6c022f0..b834e14c3 100644 --- a/src/binary-exploitation/libc-heap/use-after-free/first-fit.md +++ b/src/binary-exploitation/libc-heap/use-after-free/first-fit.md @@ -26,7 +26,7 @@ char *c = malloc(250); I fastbins sono utilizzati per piccoli chunk di memoria. A differenza degli unsorted bins, i fastbins aggiungono nuovi chunk all'inizio, creando un comportamento last-in-first-out (LIFO). Se richiedi un piccolo chunk di memoria, l'allocatore preleverà dalla testa del fastbin. -Example: +Esempio: ```c char *a = malloc(20); char *b = malloc(20); @@ -46,7 +46,7 @@ d = malloc(20); // a Dalla glibc 2.26, ogni thread mantiene il proprio **tcache** che viene interrogato *prima* del bin non ordinato. Pertanto, uno scenario di first-fit sarà **raggiunto solo se**: -1. La dimensione richiesta è **maggiore di `tcache_max`** (0x420 su 64 bit per impostazione predefinita), *oppure* +1. La dimensione richiesta è **maggiore di `tcache_max`** (0x420 su 64-bit per impostazione predefinita), *oppure* 2. Il corrispondente bin tcache è **già pieno o svuotato manualmente** (allocando 7 elementi e mantenendoli in uso). Negli exploit reali di solito aggiungerai una routine di supporto come: @@ -55,7 +55,7 @@ Negli exploit reali di solito aggiungerai una routine di supporto come: for(int i = 0; i < 7; i++) pool[i] = malloc(0x100); for(int i = 0; i < 7; i++) free(pool[i]); ``` -Una volta che il tcache è esaurito, le liberazioni successive vanno al bin non ordinato e il comportamento classico del first-fit (ricerca dalla coda, inserimento dalla testa) può essere attivato di nuovo. +Una volta che il tcache è esaurito, le liberazioni successive vanno al bin non ordinato e il comportamento classico del first-fit (ricerca dalla coda, inserimento nella testa) può essere attivato di nuovo. --- ### 🚩 Creazione di un UAF con chunk sovrapposti utilizzando first-fit @@ -98,15 +98,13 @@ Ricetta di sfruttamento (comune nei recenti CTF): 4. **Alloca** di nuovo – la parte rimanente si sovrappone con un chunk esistente in uso → UAF. 5. Sovrascrivi campi sensibili (puntatori a funzioni, vtable di FILE, ecc.) -Un'applicazione pratica può essere trovata nella sfida *Setjmp* delle Quals HITCON 2024 dove questo esatto primitivo è usato per passare da un UAF a un controllo completo di `__free_hook`.{{#ref}} -../../../../references/2024_setjmp_firstfit.md -{{#endref}} +Un'applicazione pratica può essere trovata nella sfida *Setjmp* delle HITCON Quals 2024 dove questo esatto primitivo è usato per passare da un UAF a un controllo completo di `__free_hook`. --- ### 🛡️ Mitigazioni & Indurimento -* **Safe-linking (glibc ≥ 2.32)** protegge solo le liste *tcache*/**fastbin** collegate singolarmente. I bin non ordinati/piccoli/grandi continuano a memorizzare puntatori raw, quindi sovrapposizioni basate su first-fit rimangono valide se riesci a ottenere una leak dell'heap. -* **Crittografia dei puntatori dell'heap & MTE** (ARM64) non influenzano ancora glibc x86-64, ma i flag di indurimento della distribuzione come `GLIBC_TUNABLES=glibc.malloc.check=3` abortiranno su metadati inconsistenti e possono rompere PoC naive. +* **Safe-linking (glibc ≥ 2.32)** protegge solo le liste *tcache*/**fastbin** a collegamento singolo. I bin non ordinati/piccoli/grandi memorizzano ancora puntatori raw, quindi sovrapposizioni basate su first-fit rimangono valide se riesci a ottenere una leak dell'heap. +* **Crittografia dei puntatori dell'heap & MTE** (ARM64) non influenzano ancora glibc x86-64, ma i flag di indurimento delle distribuzioni come `GLIBC_TUNABLES=glibc.malloc.check=3` abortiranno su metadati inconsistenti e possono rompere PoC naïve. * **Riempimento del tcache alla liberazione** (proposto nel 2024 per glibc 2.41) ridurrebbe ulteriormente l'uso non ordinato; monitora le future versioni durante lo sviluppo di exploit generici. --- @@ -116,14 +114,14 @@ Un'applicazione pratica può essere trovata nella sfida *Setjmp* delle Quals HIT - [**https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/**](https://8ksec.io/arm64-reversing-and-exploitation-part-2-use-after-free/) - ARM64. Use after free: Genera un oggetto utente, liberalo, genera un oggetto che ottiene il chunk liberato e consenti di scriverci, **sovrascrivendo la posizione di user->password** del precedente. Riutilizza l'utente per **bypassare il controllo della password** - [**https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/use_after_free/#example) -- Il programma consente di creare note. Una nota avrà le informazioni della nota in un malloc(8) (con un puntatore a una funzione che potrebbe essere chiamata) e un puntatore a un altro malloc() con il contenuto della nota. +- Il programma consente di creare note. Una nota avrà le informazioni della nota in un malloc(8) (con un puntatore a una funzione che potrebbe essere chiamata) e un puntatore a un altro malloc() con i contenuti della nota. - L'attacco consisterebbe nel creare 2 note (note0 e note1) con contenuti malloc più grandi della dimensione delle informazioni della nota e poi liberarle in modo che finiscano nel fast bin (o tcache). - Poi, crea un'altra nota (note2) con una dimensione del contenuto di 8. Il contenuto andrà in note1 poiché il chunk verrà riutilizzato, dove potremmo modificare il puntatore della funzione per puntare alla funzione win e poi Use-After-Free la note1 per chiamare il nuovo puntatore della funzione. - [**https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/pico_areyouroot/index.html) - È possibile allocare della memoria, scrivere il valore desiderato, liberarlo, riallocarlo e poiché i dati precedenti sono ancora lì, verrà trattato secondo la nuova struttura prevista nel chunk rendendo possibile impostare il valore per ottenere il flag. - [**https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html**](https://guyinatuxedo.github.io/26-heap_grooming/swamp19_heapgolf/index.html) -- In questo caso è necessario scrivere 4 all'interno di un chunk specifico che è il primo ad essere allocato (anche dopo aver forzato la liberazione di tutti). Ad ogni nuovo chunk allocato, il suo numero nell'indice dell'array è memorizzato. Poi, allocare 4 chunk (+ quello inizialmente allocato), l'ultimo avrà 4 all'interno, liberali e forzare la riallocazione del primo, che utilizzerà l'ultimo chunk liberato che è quello con 4 all'interno. +- In questo caso è necessario scrivere 4 all'interno di un chunk specifico che è il primo ad essere allocato (anche dopo aver forzato la liberazione di tutti). In ogni nuovo chunk allocato, il suo numero nell'indice dell'array è memorizzato. Poi, allocare 4 chunk (+ quello inizialmente allocato), l'ultimo avrà 4 al suo interno, liberali e forzare la riallocazione del primo, che utilizzerà l'ultimo chunk liberato che è quello con 4 al suo interno. - 2024 HITCON Quals Setjmp write-up (Quarkslab) – attacco pratico di sovrapposizione first-fit / unsorted-split: -- Angstrom CTF 2024 *heapify* write-up – abusare della divisione del bin non ordinato per leak libc e ottenere sovrapposizione: +- Angstrom CTF 2024 *heapify* write-up – abuso della divisione del bin non ordinato per leak libc e ottenere sovrapposizione: {{#include ../../../banners/hacktricks-training.md}}