+
+int main() {
+// Allocate memory for three chunks
+char *a = (char *)malloc(10);
+char *b = (char *)malloc(10);
+char *c = (char *)malloc(10);
+char *d = (char *)malloc(10);
+char *e = (char *)malloc(10);
+char *f = (char *)malloc(10);
+char *g = (char *)malloc(10);
+char *h = (char *)malloc(10);
+char *i = (char *)malloc(10);
+
+// Print initial memory addresses
+printf("Initial allocations:\n");
+printf("a: %p\n", (void *)a);
+printf("b: %p\n", (void *)b);
+printf("c: %p\n", (void *)c);
+printf("d: %p\n", (void *)d);
+printf("e: %p\n", (void *)e);
+printf("f: %p\n", (void *)f);
+printf("g: %p\n", (void *)g);
+printf("h: %p\n", (void *)h);
+printf("i: %p\n", (void *)i);
+
+// Fill tcache
+free(a);
+free(b);
+free(c);
+free(d);
+free(e);
+free(f);
+free(g);
+
+// Introduce double-free vulnerability in fast bin
+free(h);
+free(i);
+free(h);
+
+
+// Reallocate memory and print the addresses
+char *a1 = (char *)malloc(10);
+char *b1 = (char *)malloc(10);
+char *c1 = (char *)malloc(10);
+char *d1 = (char *)malloc(10);
+char *e1 = (char *)malloc(10);
+char *f1 = (char *)malloc(10);
+char *g1 = (char *)malloc(10);
+char *h1 = (char *)malloc(10);
+char *i1 = (char *)malloc(10);
+char *i2 = (char *)malloc(10);
+
+// Print initial memory addresses
+printf("After reallocations:\n");
+printf("a1: %p\n", (void *)a1);
+printf("b1: %p\n", (void *)b1);
+printf("c1: %p\n", (void *)c1);
+printf("d1: %p\n", (void *)d1);
+printf("e1: %p\n", (void *)e1);
+printf("f1: %p\n", (void *)f1);
+printf("g1: %p\n", (void *)g1);
+printf("h1: %p\n", (void *)h1);
+printf("i1: %p\n", (void *)i1);
+printf("i2: %p\n", (void *)i1);
+
+return 0;
+}
+```
+In questo esempio, dopo aver riempito la tcache con diversi chunk liberati, il codice **libera il chunk `h`, poi il chunk `i`, e poi di nuovo `h`, causando un errore di double-free**. Questo apre la possibilità di ricevere sovrapposizioni di indirizzi di memoria durante il riallocazione, il che significa che due o più puntatori possono puntare alla stessa posizione di memoria. Manipolare i dati attraverso un puntatore può quindi influenzare l'altro, creando un rischio critico per la sicurezza e un potenziale per l'exploit.
+
+Eseguendolo, nota come **`i1` e `i2` abbiano lo stesso indirizzo**:
+
+Assegnazioni iniziali:
+a: 0xaaab0f0c22a0
+b: 0xaaab0f0c22c0
+c: 0xaaab0f0c22e0
+d: 0xaaab0f0c2300
+e: 0xaaab0f0c2320
+f: 0xaaab0f0c2340
+g: 0xaaab0f0c2360
+h: 0xaaab0f0c2380
+i: 0xaaab0f0c23a0
+Dopo le riallocazioni:
+a1: 0xaaab0f0c2360
+b1: 0xaaab0f0c2340
+c1: 0xaaab0f0c2320
+d1: 0xaaab0f0c2300
+e1: 0xaaab0f0c22e0
+f1: 0xaaab0f0c22c0
+g1: 0xaaab0f0c22a0
+h1: 0xaaab0f0c2380
+i1: 0xaaab0f0c23a0
+i2: 0xaaab0f0c23a0
+
+
+## Riferimenti
+
+* [https://heap-exploitation.dhavalkapil.com/attacks/double\_free](https://heap-exploitation.dhavalkapil.com/attacks/double\_free)
+
+
+
+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 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) repos di github.
+
+
diff --git a/binary-exploitation/heap/heap-functions-security-checks.md b/binary-exploitation/heap/heap-functions-security-checks.md
new file mode 100644
index 000000000..e17ceca15
--- /dev/null
+++ b/binary-exploitation/heap/heap-functions-security-checks.md
@@ -0,0 +1,92 @@
+# Controlli di sicurezza delle funzioni di heap
+
+
+
+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 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
+
+
+
+## unlink
+
+Questa funzione rimuove un chunk da una lista doppiamente collegata. I controlli comuni garantiscono che la struttura della lista collegata rimanga consistente durante lo scollegamento dei chunk.
+
+* **Controlli di coerenza**:
+* Verifica se `P->fd->bk == P` e `P->bk->fd == P`.
+* Messaggio di errore: `corrupted double-linked list`
+
+## \_int\_malloc
+
+Questa funzione è responsabile dell'allocazione di memoria dall'heap. I controlli qui garantiscono che la memoria non venga corrotta durante l'allocazione.
+
+* **Controllo della dimensione di Fastbin**:
+* Quando si rimuove un chunk da un fastbin, assicurarsi che la dimensione del chunk sia all'interno dell'intervallo del fastbin.
+* Messaggio di erroro: `malloc(): memory corruption (fast)`
+* **Controllo di coerenza di Smallbin**:
+* Quando si rimuove un chunk da un smallbin, assicurarsi che i collegamenti precedenti e successivi nella lista doppiamente collegata siano coerenti.
+* Messaggio di errore: `malloc(): smallbin double linked list corrupted`
+* **Controllo dell'intervallo di memoria di Unsorted Bin**:
+* Assicurarsi che la dimensione dei chunk nell'unsorted bin sia all'interno dei limiti minimi e massimi.
+* Messaggio di errore: `malloc(): memory corruption`
+* **Controllo di coerenza di Unsorted Bin (Primo Scenario)**:
+* Quando si inserisce un chunk di resto nell'unsorted bin, controllare se `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)`.
+* Messaggio di errore: `malloc(): corrupted unsorted chunks`
+* **Controllo di coerenza di Unsorted Bin (Secondo Scenario)**:
+* Come il controllo precedente, ma attivato quando si inserisce dopo aver diviso un chunk veloce o piccolo.
+* Messaggio di errore: `malloc(): corrupted unsorted chunks 2`
+
+## \_int\_free
+
+Questa funzione libera la memoria precedentemente allocata. I controlli qui aiutano a garantire una corretta deallocazione della memoria e a prevenire la corruzione della memoria.
+
+* **Controllo del limite del puntatore**:
+* Assicurarsi che il puntatore che viene liberato non si avvolga attorno alla memoria.
+* Messaggio di errore: `free(): invalid pointer`
+* **Controllo della dimensione**:
+* Assicurarsi che la dimensione del chunk che viene liberato sia almeno `MINSIZE` o un multiplo di `MALLOC_ALIGNMENT`.
+* Messaggio di errore: `free(): invalid size`
+* **Controllo della dimensione di Fastbin**:
+* Per i chunk di fastbin, assicurarsi che la dimensione del chunk successivo sia all'interno dei limiti minimi e massimi.
+* Messaggio di errore: `free(): invalid next size (fast)`
+* **Controllo di Double Free di Fastbin**:
+* Quando si inserisce un chunk in un fastbin, assicurarsi che il chunk in testa non sia lo stesso di quello che viene inserito.
+* Messaggio di errore: `double free or corruption (fasttop)`
+* **Controllo di coerenza di Fastbin**:
+* Quando si inserisce in un fastbin, assicurarsi che le dimensioni del chunk in testa e del chunk che viene inserito siano le stesse.
+* Messaggio di errore: `invalid fastbin entry (free)`
+* **Controllo di coerenza del Top Chunk**:
+* Per i chunk non di fastbin, assicurarsi che il chunk non sia lo stesso del top chunk.
+* Messaggio di errore: `double free or corruption (top)`
+* **Controllo dei limiti di memoria**:
+* Assicurarsi che il chunk successivo per memoria sia all'interno dei limiti dell'arena.
+* Messaggio di errore: `double free or corruption (out)`
+* **Controllo del bit Prev\_inuse**:
+* Assicurarsi che il bit precedente-in-uso nel chunk successivo sia contrassegnato.
+* Messaggio di errore: `double free or corruption (!prev)`
+* **Controllo della dimensione normale**:
+* Assicurarsi che la dimensione del chunk successivo sia all'interno di intervalli validi.
+* Messaggio di errore: `free(): invalid next size (normal)`
+* **Controllo di coerenza di Unsorted Bin**:
+* Quando si inserisce un chunk fuso nell'unsorted bin, controllare se `unsorted_chunks(av)->fd->bk == unsorted_chunks(av)`.
+* Messaggio di errore: `free(): corrupted unsorted chunks`
+
+
+
+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 [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
+
+
diff --git a/binary-exploitation/heap/heap-overflow.md b/binary-exploitation/heap/heap-overflow.md
index c83c75fdb..2b9ff51d9 100644
--- a/binary-exploitation/heap/heap-overflow.md
+++ b/binary-exploitation/heap/heap-overflow.md
@@ -7,16 +7,16 @@
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 PEASS & HackTricks**](https://peass.creator-spring.com)
+* 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) github repos.
+* **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
-Un heap overflow è simile a un [**stack overflow**](../stack-overflow/) ma nell'heap. Fondamentalmente significa che è stato riservato dello spazio nell'heap per memorizzare dei dati e che i **dati memorizzati erano più grandi dello spazio riservato**.
+Un heap overflow è simile a un [**stack overflow**](../stack-overflow/) ma nell'heap. Fondamentalmente significa che è stato riservato dello spazio nell'heap per memorizzare alcuni dati e **i dati memorizzati erano più grandi dello spazio riservato**.
Nei stack overflows sappiamo che alcuni registri come il puntatore di istruzione o il frame dello stack verranno ripristinati dallo stack e potrebbe essere possibile abusarne. Nel caso degli heap overflows, **non c'è alcuna informazione sensibile memorizzata per impostazione predefinita** nel chunk dell'heap che può essere sovraffollato. Tuttavia, potrebbero esserci informazioni sensibili o puntatori, quindi la **criticità** di questa vulnerabilità **dipende** da **quali dati potrebbero essere sovrascritti** e da come un attaccante potrebbe abusarne.
@@ -24,15 +24,29 @@ Nei stack overflows sappiamo che alcuni registri come il puntatore di istruzione
Per trovare gli offset degli overflow puoi utilizzare gli stessi schemi dei [**stack overflows**](../stack-overflow/#finding-stack-overflows-offsets).
{% endhint %}
+### Stack Overflows vs Heap Overflows
+
+Nei stack overflows l'organizzazione e i dati che saranno presenti nello stack nel momento in cui la vulnerabilità può essere attivata sono abbastanza affidabili. Questo perché lo stack è lineare, aumenta sempre in memoria in collisione, in **specifici punti dell'esecuzione del programma la memoria dello stack di solito memorizza tipi di dati simili** e ha una struttura specifica con alcuni puntatori alla fine della parte dello stack utilizzata da ciascuna funzione.
+
+Tuttavia, nel caso di un heap overflow, poiché la memoria utilizzata non è lineare ma **i chunk allocati sono di solito in posizioni separate della memoria** (non uno accanto all'altro) a causa di **bin e zone** che separano le allocazioni per dimensione e perché **la memoria precedentemente liberata viene utilizzata** prima di allocare nuovi chunk. È **complicato sapere quale oggetto andrà a collidere con quello vulnerabile** a un heap overflow. Quindi, quando viene trovato un heap overflow, è necessario trovare un **modo affidabile per far sì che l'oggetto desiderato sia il successivo in memoria** rispetto a quello che può essere sovraffollato.
+
+Una delle tecniche utilizzate per questo è il **Heap Grooming** che viene utilizzato ad esempio [**in questo post**](https://azeria-labs.com/grooming-the-ios-kernel-heap/). Nel post viene spiegato come nel kernel iOS quando una zona esaurisce la memoria per memorizzare chunk di memoria, la espande di una pagina del kernel, e questa pagina viene divisa in chunk delle dimensioni previste che verranno utilizzati in ordine (fino alla versione iOS 9.2, poi questi chunk vengono utilizzati in modo randomizzato per rendere più difficile lo sfruttamento di questi attacchi).
+
+Pertanto, nel post precedente in cui si verifica un heap overflow, per forzare l'oggetto sovraffollato a collidere con un ordine vittima, diversi **`kallocs` sono forzati da diversi thread per cercare di garantire che tutti i chunk liberi siano riempiti e che venga creata una nuova pagina**.
+
+Per forzare questo riempimento con oggetti di una dimensione specifica, l'**allocazione fuori linea associata a una porta mach iOS** è un candidato ideale. Creando la dimensione del messaggio, è possibile specificare esattamente la dimensione dell'allocazione `kalloc` e quando la porta mach corrispondente viene distrutta, l'allocazione corrispondente verrà immediatamente rilasciata a `kfree`.
+
+Quindi, alcuni di questi segnaposto possono essere **liberati**. La lista di liberazione **`kalloc.4096` rilascia gli elementi in ordine di ultimo entrato, primo uscito**, il che significa fondamentalmente che se alcuni segnaposto vengono liberati e l'exploit prova a allocare diversi oggetti vittima mentre cerca di allocare l'oggetto vulnerabile all'overflow, è probabile che questo oggetto sarà seguito da un oggetto vittima.
+
## Esempio ARM64
-Nella pagina [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) puoi trovare un esempio di heap overflow in cui un comando che verrà eseguito è memorizzato nel chunk seguente al chunk sovraccaricato. Quindi, è possibile modificare il comando eseguito sovrascribendolo con un exploit semplice come:
+Nella pagina [https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/](https://8ksec.io/arm64-reversing-and-exploitation-part-1-arm-instruction-set-simple-heap-overflow/) puoi trovare un esempio di heap overflow in cui un comando che verrà eseguito è memorizzato nel chunk seguente rispetto al chunk sovraffollato. Quindi, è possibile modificare il comando eseguito sovrascribendolo con un exploit semplice come:
```bash
python3 -c 'print("/"*0x400+"/bin/ls\x00")' > hax.txt
```
-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:
@@ -40,6 +54,6 @@ 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 esclusive [**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) 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.
diff --git a/binary-exploitation/heap/use-after-free/README.md b/binary-exploitation/heap/use-after-free/README.md
new file mode 100644
index 000000000..75d13a5d7
--- /dev/null
+++ b/binary-exploitation/heap/use-after-free/README.md
@@ -0,0 +1,46 @@
+# Uso dopo la liberazione
+
+
+
+Impara l'hacking su AWS da zero a esperto 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)!
+* 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
+
+Come suggerisce il nome, questa vulnerabilità si verifica quando un programma **riserva dello spazio** nell'heap per un oggetto, **scrive** alcune informazioni lì, **lo libera** apparentemente perché non è più necessario e poi **vi accede di nuovo**.
+
+Il problema qui è che non è illegale (non ci saranno errori) quando si accede a una **memoria liberata**. Quindi, se il programma (o l'attaccante) riesce a **allocare la memoria liberata e memorizzare dati arbitrari**, quando la memoria liberata viene acceduta dal puntatore iniziale quei dati saranno stati sovrascritti causando una **vulnerabilità che dipenderà dalla sensibilità dei dati** che erano stati memorizzati originariamente (se si trattava di un puntatore di una funzione che sarebbe stata chiamata, un attaccante potrebbe controllarlo).
+
+### Attacco First Fit
+
+Un attacco di tipo First Fit mira al modo in cui alcuni allocatori di memoria, come in glibc, gestiscono la memoria liberata. Quando si libera un blocco di memoria, viene aggiunto a una lista e le nuove richieste di memoria vengono prelevate da quella lista dalla fine. Gli attaccanti possono utilizzare questo comportamento per manipolare **quali blocchi di memoria vengono riutilizzati, potenzialmente ottenendo il controllo su di essi**. Ciò può portare a problemi di "uso dopo la liberazione", dove un attaccante potrebbe **modificare i contenuti della memoria che viene riallocata**, creando un rischio per la sicurezza.\
+Controlla ulteriori informazioni in:
+
+{% content-ref url="first-fit.md" %}
+[first-fit.md](first-fit.md)
+{% endcontent-ref %}
+
+##
+
+
+
+Impara l'hacking su AWS da zero a esperto 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)!
+* 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).
+
+
diff --git a/binary-exploitation/heap/use-after-free/first-fit.md b/binary-exploitation/heap/use-after-free/first-fit.md
new file mode 100644
index 000000000..a30aef982
--- /dev/null
+++ b/binary-exploitation/heap/use-after-free/first-fit.md
@@ -0,0 +1,64 @@
+# First Fit
+
+
+
+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) github repos.
+
+
+
+## **First Fit**
+
+Quando liberi la memoria in un programma utilizzando glibc, vengono utilizzati diversi "bin" per gestire i blocchi di memoria. Ecco una spiegazione semplificata di due scenari comuni: unsorted bins e fastbins.
+
+### Unsorted Bins
+
+Quando liberi un blocco di memoria che non è un blocco veloce, va al bin non ordinato. Questo bin funziona come una lista in cui i nuovi blocchi liberati vengono aggiunti all'inizio (la "testa"). Quando richiedi un nuovo blocco di memoria, l'allocatore guarda il bin non ordinato dalla fine (la "coda") per trovare un blocco abbastanza grande. Se un blocco dal bin non ordinato è più grande di quanto necessiti, viene diviso, con la parte anteriore restituita e la parte rimanente che rimane nel bin.
+
+Esempio:
+
+* Alloci 300 byte (`a`), quindi 250 byte (`b`), liberi `a` e richiedi di nuovo 250 byte (`c`).
+* Quando liberi `a`, va al bin non ordinato.
+* Se successivamente richiedi di nuovo 250 byte, l'allocatore trova `a` in coda e lo divide, restituendo la parte che soddisfa la tua richiesta e mantenendo il resto nel bin.
+* `c` punterà al precedente `a` e sarà riempito con i dati di `a`.
+```c
+char *a = malloc(300);
+char *b = malloc(250);
+free(a);
+char *c = malloc(250);
+```
+### Fastbins
+
+I fastbins sono utilizzati per piccoli blocchi di memoria. A differenza dei blocchi non ordinati, i fastbins aggiungono nuovi blocchi all'inizio, creando un comportamento di tipo ultimo ad entrare, primo ad uscire (LIFO). Se richiedi un piccolo blocco di memoria, l'allocatore preleverà dalla testa del fastbin.
+
+Esempio:
+
+* Alloci quattro blocchi di 20 byte ciascuno (`a`, `b`, `c`, `d`).
+* Quando li liberi in qualsiasi ordine, i blocchi liberati vengono aggiunti alla testa del fastbin.
+* Se successivamente richiedi un blocco da 20 byte, l'allocatore restituirà il blocco liberato più di recente dalla testa del fastbin.
+```c
+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
+```
+## Altri riferimenti ed esempi
+
+* [https://heap-exploitation.dhavalkapil.com/attacks/first\_fit](https://heap-exploitation.dhavalkapil.com/attacks/first\_fit)
+* [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. Uso dopo la liberazione: Generare un oggetto utente, liberarlo, generare un oggetto che ottiene il pezzo liberato e consente di scriverci sopra, sovrascrivendo la posizione di user->password da quello precedente. Riutilizzare l'utente per aggirare il controllo della password
.png)
.png)
.png)
