First Fit

Learn & practice AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Learn & practice GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Support HackTricks

• Check the subscription plans!

• Join the 💬 Discord group or the telegram group or follow us on Twitter 🐦 @hacktricks_live.

• Share hacking tricks by submitting PRs to the HackTricks and HackTricks Cloud github repos.

First Fit

Quando si libera memoria in un programma utilizzando glibc, vengono utilizzati diversi "bins" per gestire i chunk di memoria. Ecco una spiegazione semplificata di due scenari comuni: unsorted bins e fastbins.

Unsorted Bins

Quando si libera un chunk di memoria che non è un fast chunk, va nell'unsorted bin. Questo bin funziona come una lista in cui i nuovi chunk liberati vengono aggiunti all'inizio (la "testa"). Quando si richiede un nuovo chunk di memoria, l'allocatore guarda l'unsorted bin dalla parte posteriore (la "coda") per trovare un chunk abbastanza grande. Se un chunk dell'unsorted bin è più grande di quanto necessario, viene diviso, con la parte anteriore restituita e la parte rimanente che rimane nel bin.

Esempio:

• Si allocano 300 byte (a), poi 250 byte (b), si libera a e si richiedono di nuovo 250 byte (c).

• Quando si libera a, va nell'unsorted bin.

• Se poi si richiedono di nuovo 250 byte, l'allocatore trova a alla coda e lo divide, restituendo la parte che soddisfa la richiesta e mantenendo il resto nel bin.

• c punterà al precedente a e sarà riempito con gli a's.

char *a = malloc(300);
char *b = malloc(250);
free(a);
char *c = malloc(250);

Fastbins

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.

Esempio:

• Allocchi quattro chunk di 20 byte ciascuno (a, b, c, d).

• Quando li liberi in qualsiasi ordine, i chunk liberati vengono aggiunti alla testa del fastbin.

• Se poi richiedi un chunk di 20 byte, l'allocatore restituirà il chunk liberato più di recente dalla testa del fastbin.

char *a = malloc(20);
char *b = malloc(20);
char *c = malloc(20);
char *d = malloc(20);
free(a);
free(b);
free(c);
free(d);
a = malloc(20);   // d
b = malloc(20);   // c
c = malloc(20);   // b
d = malloc(20);   // a

Altre Riferimenti & Esempi

• https://heap-exploitation.dhavalkapil.com/attacks/first_fit

• 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

• 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(<size>) 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

• È 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

• 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.