mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-22 04:33:28 +00:00
Translated ['binary-exploitation/heap/house-of-einherjar.md', 'binary-ex
This commit is contained in:
Translator
parent
63f5e17894
commit
03487e3629
5 changed files with 110 additions and 49 deletions
|
|
@ -740,7 +740,7 @@
|
|||
* [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)
|
||||
* [House of Lore | Small bin Attack](binary-exploitation/heap/house-of-lore.md)
|
||||
* [House of Einherjar](binary-exploitation/heap/house-of-einherjar.md)
|
||||
* [House of Force](binary-exploitation/heap/house-of-force.md)
|
||||
* [House of Orange](binary-exploitation/heap/house-of-orange.md)
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ Altri modi per supportare HackTricks:
|
|||
### Codice
|
||||
|
||||
* Controlla l'esempio da [https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c)
|
||||
* Oppure quello da [https://guyinatuxedo.github.io/42-house\_of\_einherjar/house\_einherjar\_exp/index.html#house-of-einherjar-explanation](https://guyinatuxedo.github.io/42-house\_of\_einherjar/house\_einherjar\_exp/index.html#house-of-einherjar-explanation) (potresti dover riempire la tcache)
|
||||
|
||||
### Obiettivo
|
||||
|
||||
|
|
@ -26,25 +27,34 @@ Altri modi per supportare HackTricks:
|
|||
|
||||
### Requisiti
|
||||
|
||||
* Off by one sull'intestazione del prossimo chunk per modificare il prev in uso
|
||||
* Essere in grado di modificare i dati `prev_size`, che fanno parte del chunk corrente (alla fine)
|
||||
* Leak di Heap
|
||||
* Creare un chunk falso quando vogliamo allocare un chunk:
|
||||
* Impostare i puntatori per puntare a se stessi per aggirare i controlli di integrità
|
||||
* Off by one da un chunk all'altro per modificare il prev in uso
|
||||
* Indicare nel `prev_size` del chunk abusato off-by-one la differenza tra se stesso e il chunk falso
|
||||
* Anche la dimensione del chunk falso deve essere impostata alla stessa dimensione per aggirare i controlli di integrità
|
||||
* Per costruire questi chunk, avrai bisogno di una fuga di memoria dell'heap.
|
||||
|
||||
### Attacco
|
||||
|
||||
* Viene creato un chunk falso all'interno di un chunk controllato dall'attaccante puntando con `fd` e `bk` al chunk originale per aggirare le protezioni
|
||||
* Vengono creati altri 2 chunk (`B` e `C`).
|
||||
* Sfruttando l'off by one nel chunk `B`, il bit `prev in use` viene pulito e i dati `prev_size` vengono sovrascritti con la differenza tra il luogo in cui è allocato il chunk `C` e il chunk falso `A` generato prima.
|
||||
* Questo `prev_size` e la dimensione del chunk falso `A` devono essere gli stessi per aggirare i controlli.
|
||||
* Quindi, il Tcache viene riempito
|
||||
* Quindi, `C` viene liberato in modo che si consolidi con il chunk falso `A`
|
||||
* Quindi, viene creato un nuovo chunk `D` che inizierà nel chunk falso `A` e coprirà il chunk `B`
|
||||
* Quindi, viene liberato `B` e il suo `fd` viene sovrascritto con l'indirizzo di destinazione facendolo puntare all'indirizzo di destinazione sfruttando il chunk `D` che lo contiene.
|
||||
* Quindi, vengono fatti 2 malloc perché il secondo conterrà l'indirizzo di destinazione
|
||||
* Vengono allocati altri 2 chunk (`B` e `C`)
|
||||
* Sfruttando l'off by one nel chunk `B`, il bit `prev in use` viene pulito e i dati `prev_size` vengono sovrascritti con la differenza tra il luogo in cui è allocato il chunk `C` e il chunk falso `A` generato prima
|
||||
* Questo `prev_size` e la dimensione nel chunk falso `A` devono essere uguali per aggirare i controlli.
|
||||
* Quindi, la tcache viene riempita
|
||||
* Poi, `C` viene liberato in modo che si consolidi con il chunk falso `A`
|
||||
* Poi, viene creato un nuovo chunk `D` che inizierà nel chunk falso `A` e coprirà il chunk `B`
|
||||
* La casa di Einherjar finisce qui
|
||||
* Questo può essere continuato con un attacco al fast bin:
|
||||
* Liberare `B` per aggiungerlo al fast bin
|
||||
* Il `fd` di `B` viene sovrascritto facendolo puntare all'indirizzo di destinazione sfruttando il chunk `D` (poiché contiene `B` all'interno) 
|
||||
* Poi, vengono fatti 2 malloc e il secondo sarà **allocare l'indirizzo di destinazione**
|
||||
|
||||
## Riferimenti
|
||||
## Riferimenti e altri esempi
|
||||
|
||||
* [https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.35/house\_of\_einherjar.c)
|
||||
* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_einherjar/#2016-seccon-tinypad](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_einherjar/#2016-seccon-tinypad)
|
||||
* Dopo aver liberato i puntatori, non vengono annullati, quindi è ancora possibile accedere ai loro dati. Pertanto, un chunk viene posizionato nel bin non ordinato e vengono rivelati i puntatori che contiene (fuga di libc) e quindi viene posizionato un nuovo heap nel bin non ordinato e viene rivelato un indirizzo di heap dal puntatore che ottiene.
|
||||
*
|
||||
|
||||
<details>
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Casa del Lore
|
||||
# House of Lore | Piccolo attacco binario
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -6,45 +6,55 @@
|
|||
|
||||
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)!
|
||||
* 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)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT**](https://opensea.io/collection/the-peass-family) esclusivi
|
||||
* **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 repositori [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **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).
|
||||
|
||||
</details>
|
||||
|
||||
## Informazioni di Base
|
||||
## Informazioni di base
|
||||
|
||||
### Codice
|
||||
|
||||
* Questo non funziona
|
||||
* Controlla quello da [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/)
|
||||
* Questo non funziona
|
||||
* Oppure: [https://github.com/shellphish/how2heap/blob/master/glibc\_2.39/house\_of\_lore.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.39/house\_of\_lore.c)
|
||||
* Anche questo non funziona anche se cerca di aggirare alcuni controlli ottenendo l'errore: `malloc(): unaligned tcache chunk detected`
|
||||
* Questo esempio funziona ancora**:** [**https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html**](https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html) 
|
||||
|
||||
### Obiettivo
|
||||
|
||||
* Inserire dei chunk piccoli falsi nel bin piccolo in modo da poterlo allocare.
|
||||
* Inserire un **falso small chunk nel small bin in modo che sia possibile allocarlo**.\
|
||||
Nota che il small chunk aggiunto è quello falso creato dall'attaccante e non uno falso in una posizione arbitraria.
|
||||
|
||||
### Requisiti
|
||||
|
||||
* Creare chunk falsi
|
||||
* Conoscere l'indirizzo del chunk vittima e dei chunk falsi
|
||||
* Essere in grado di modificare i puntatori `bk` e `fd`
|
||||
* Creare 2 chunk falsi e collegarli tra di loro e con il chunk legittimo nel small bin:
|
||||
* `fake0.bk` -> `fake1`
|
||||
* `fake1.fd` -> `fake0`
|
||||
* `fake0.fd` -> `legit` (è necessario modificare un puntatore nel chunk del small bin liberato tramite qualche altra vulnerabilità)
|
||||
* `legit.bk` -> `fake0`
|
||||
|
||||
Allora sarai in grado di allocare `fake0`.
|
||||
|
||||
### Attacco
|
||||
|
||||
* Viene allocato un chunk piccolo vittima
|
||||
* Un attaccante genera un paio di chunk piccoli falsi e fa sì che il primo chunk falso punti a un chunk reale con `fd` e il `bk` punti al secondo chunk falso. Inoltre, fa sì che il `bk` del secondo chunk falso punti al primo.
|
||||
* Successivamente, viene allocato un nuovo chunk grande per evitare che il primo venga fuso nel chunk superiore quando viene liberato
|
||||
* Quindi, il puntatore iniziale viene liberato e viene allocato un secondo puntatore di dimensioni maggiori in modo che il chunk piccolo iniziale liberato venga posizionato nel bin piccolo.
|
||||
* Il chunk piccolo reale viene modificato in modo che il suo puntatore `bk` punti a quello falso.
|
||||
* Quindi, quando vengono allocati 2 chunk di questa dimensione, ottengono prima il chunk valido e poi il chunk non valido controllato in qualche modo dall'attaccante.
|
||||
* Viene allocato un small chunk (`legit`), quindi un altro viene allocato per evitare la consolidazione con il top chunk. Quindi, `legit` viene liberato (spostandolo nell'elenco non ordinato) e viene allocato un chunk più grande, **spostando `legit` nel small bin.**
|
||||
* Un attaccante genera un paio di piccoli chunk falsi e crea il collegamento necessario per aggirare i controlli di integrità:
|
||||
* `fake0.bk` -> `fake1`
|
||||
* `fake1.fd` -> `fake0`
|
||||
* `fake0.fd` -> `legit` (è necessario modificare un puntatore nel chunk del small bin liberato tramite qualche altra vulnerabilità)
|
||||
* `legit.bk` -> `fake0`
|
||||
* Viene allocato un piccolo chunk per ottenere `legit`, facendo diventare **`fake0`** il primo della lista dei piccoli bin
|
||||
* Viene allocato un altro piccolo chunk, ottenendo fake0 come chunk, consentendo potenzialmente di leggere/scrivere puntatori al suo interno.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/)
|
||||
* [https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_lore](https://heap-exploitation.dhavalkapil.com/attacks/house\_of\_lore)
|
||||
* [https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html](https://guyinatuxedo.github.io/40-house\_of\_lore/house\_lore\_exp/index.html)
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -52,10 +62,10 @@ Altri modi per supportare 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)!
|
||||
* 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)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT**](https://opensea.io/collection/the-peass-family) esclusivi
|
||||
* **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 repositori [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
|
||||
* **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).
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -2,15 +2,15 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Impara l'hacking su AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se desideri 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 [**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.
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -69,16 +69,51 @@ return 0;
|
|||
|
||||
### Obiettivo
|
||||
|
||||
* Essere in grado di aggiungere un indirizzo arbitrario nel tcache / fast bin in modo che, chiamando malloc, venga utilizzato in un chunk
|
||||
* Essere in grado di aggiungere un indirizzo nel tcache / fast bin in modo che in seguito sia possibile allocarlo
|
||||
|
||||
### Requisiti
|
||||
|
||||
* Questo attacco richiede che un attaccante sia in grado di creare un paio di chunk fast falsi indicando correttamente il valore della dimensione e sovrascrivere un chunk fast di quella dimensione che verrà liberato, in modo che il chunk dell'attaccante sia effettivamente quello che entra nel fast bin.
|
||||
* Questo attacco richiede che un attaccante sia in grado di creare un paio di chunk fast falsi indicando correttamente il valore della dimensione e successivamente liberare il primo chunk falso in modo che vada nel bin.
|
||||
|
||||
### Attacco
|
||||
|
||||
* Creare un chunk falso che bypassi i controlli di sicurezza (saranno necessari 2 chunk falsi)
|
||||
* Prima che un puntatore venga liberato, sovrascriverlo con il chunk falso in modo che sia quello che entra nel bin
|
||||
* Creare chunk falsi che eludono i controlli di sicurezza: sarà necessario creare 2 chunk falsi che indicano essenzialmente nelle posizioni corrette le dimensioni corrette
|
||||
* Gestire in qualche modo la liberazione del primo chunk falso in modo che vada nel bin fast o tcache e quindi allocarlo per sovrascrivere quell'indirizzo
|
||||
|
||||
**Il codice di** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house\_of\_spirit/house\_spirit\_exp/index.html) **è ottimo per comprendere l'attacco.** Anche questo schema dal codice lo riassume piuttosto bene:
|
||||
```c
|
||||
/*
|
||||
this will be the structure of our two fake chunks:
|
||||
assuming that you compiled it for x64
|
||||
|
||||
+-------+---------------------+------+
|
||||
| 0x00: | Chunk # 0 prev size | 0x00 |
|
||||
+-------+---------------------+------+
|
||||
| 0x08: | Chunk # 0 size | 0x60 |
|
||||
+-------+---------------------+------+
|
||||
| 0x10: | Chunk # 0 content | 0x00 |
|
||||
+-------+---------------------+------+
|
||||
| 0x60: | Chunk # 1 prev size | 0x00 |
|
||||
+-------+---------------------+------+
|
||||
| 0x68: | Chunk # 1 size | 0x40 |
|
||||
+-------+---------------------+------+
|
||||
| 0x70: | Chunk # 1 content | 0x00 |
|
||||
+-------+---------------------+------+
|
||||
|
||||
for what we are doing the prev size values don't matter too much
|
||||
the important thing is the size values of the heap headers for our fake chunks
|
||||
*/
|
||||
```
|
||||
{% hint style="info" %}
|
||||
Nota che è necessario creare il secondo chunk per eludere alcuni controlli di coerenza.
|
||||
{% endhint %}
|
||||
|
||||
## Esempi
|
||||
|
||||
* CTF [https://guyinatuxedo.github.io/39-house\_of\_spirit/hacklu14\_oreo/index.html](https://guyinatuxedo.github.io/39-house\_of\_spirit/hacklu14\_oreo/index.html)
|
||||
* **Libc infoleak**: Attraverso un overflow è possibile cambiare un puntatore per puntare a un indirizzo GOT al fine di ottenere un indirizzo libc tramite l'azione di lettura del CTF
|
||||
* **House of Spirit**: Sfruttando un contatore che conta il numero di "fucili" è possibile generare una dimensione falsa del primo chunk falso, quindi sfruttando un "messaggio" è possibile falsificare la seconda dimensione di un chunk e infine sfruttando un overflow è possibile cambiare un puntatore che verrà liberato in modo che il nostro primo chunk falso venga liberato. Quindi, possiamo allocarlo e al suo interno ci sarà l'indirizzo in cui è memorizzato il "messaggio". Successivamente, è possibile far puntare questo all'ingresso di `scanf` all'interno della tabella GOT, in modo da poterlo sovrascrivere con l'indirizzo a system.\
|
||||
La prossima volta che viene chiamato `scanf`, possiamo inviare l'input `"/bin/sh"` e ottenere una shell.
|
||||
|
||||
## Riferimenti
|
||||
|
||||
|
|
@ -86,14 +121,14 @@ return 0;
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Impara l'hacking di AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
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)
|
||||
* 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) repository di Github.
|
||||
* **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.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ Per ulteriori informazioni su cosa sia un bin di tcache, controlla questa pagina
|
|||
|
||||
Innanzitutto, nota che il Tcache è stato introdotto nella versione 2.26 di glibc.
|
||||
|
||||
L'attacco al **Tcache** proposto nella [**pagina guyinatuxido**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) è molto simile all'attacco al fast bin dove l'obiettivo è sovrascrivere il puntatore al chunk successivo nel bin all'interno di un chunk liberato con un indirizzo arbitrario in modo da **allocare quell'indirizzo specifico e potenzialmente sovrascrivere i puntatori**.
|
||||
L'attacco **Tcache** proposto nella [pagina di 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 **allocare successivamente 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).
|
||||
|
||||
|
|
@ -35,15 +35,21 @@ Di solito è possibile trovare all'inizio dell'heap un chunk contenente la **qua
|
|||
## Esempi
|
||||
|
||||
* CTF [https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html](https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html)
|
||||
* **Leak di informazioni sulla libc**: È possibile riempire i tcache, aggiungere un chunk nella lista non ordinata, svuotare il tcache e **ri-allocare il chunk dalla lista non ordinata** sovrascrivendo solo i primi 8B, lasciando **intatto il secondo indirizzo alla libc dal chunk in modo da poterlo leggere**.
|
||||
* **Attacco al Tcache**: Il binario è vulnerabile a un overflow di heap di 1B. Questo sarà abusato per cambiare l'**intestazione di dimensione** di un chunk allocato rendendola più grande. Quindi, questo chunk verrà **liberato**, aggiungendolo al tcache dei chunk della dimensione falsa. Poi, verrà allocato un chunk con la dimensione falsata e il chunk precedente verrà **restituito sapendo che questo chunk era effettivamente più piccolo** e ciò permette di **sovrascrivere il chunk successivo in memoria**.\
|
||||
Questo sarà abusato per **sovrascrivere il puntatore FD del chunk successivo** per farlo puntare a **`malloc_hook`**, quindi è possibile allocare 2 puntatori: prima il puntatore legittimo appena modificato e poi la seconda allocazione restituirà un chunk in **`malloc_hook`** che è possibile abusare per scrivere un **one gadget**.
|
||||
* **Leak di informazioni sulla libc**: È possibile riempire i tcache, aggiungere un chunk alla lista non ordinata, svuotare il tcache e **ri-allocare il chunk dalla lista non ordinata** sovrascrivendo solo i primi 8B, lasciando **intatto il secondo indirizzo alla libc dal chunk in modo da poterlo leggere**.
|
||||
* **Attacco Tcache**: Il binario è vulnerabile a un overflow di heap di 1B. Questo sarà abusato per cambiare l'**header di dimensione** di un chunk allocato rendendolo più grande. Quindi, questo chunk verrà **liberato**, aggiungendolo al tcache dei chunk della dimensione falsa. Poi, verrà allocato un chunk con la dimensione falsificata e il chunk precedente verrà **restituito sapendo che questo chunk era effettivamente più piccolo** e ciò offre l'opportunità di **sovrascrivere il prossimo chunk in memoria**.\
|
||||
Questo sarà abusato per **sovrascrivere il puntatore FD del prossimo chunk** per farlo puntare a **`malloc_hook`**, quindi sarà possibile allocare 2 puntatori: prima il puntatore legittimo appena modificato e poi la seconda allocazione restituirà un chunk in **`malloc_hook`** che è possibile abusare per scrivere un **one gadget**.
|
||||
* CTF [https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html](https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html)
|
||||
* **Leak di informazioni sulla libc**: C'è un use after free e un double free. In questo writeup l'autore ha fatto trapelare un indirizzo della libc leggendo l'indirizzo di un chunk posizionato in un bin piccolo (come se lo stesse facendo trapelare dal bin non ordinato ma da quello piccolo)
|
||||
* **Attacco al Tcache**: Viene eseguito un Tcache tramite un **double free**. Lo stesso chunk viene liberato due volte, quindi all'interno del Tcache il chunk punterà a se stesso. Quindi, viene allocato, il suo puntatore FD viene modificato per puntare al **free hook** e quindi viene allocato di nuovo in modo che il prossimo chunk nella lista sarà nel free hook. Poi, anche questo viene allocato ed è possibile scrivere l'indirizzo di `system` qui in modo che quando un malloc contenente `"/bin/sh"` viene liberato otteniamo una shell.
|
||||
* **Attacco Tcache**: Viene eseguito un Tcache tramite un **double free**. Lo stesso chunk viene liberato due volte, quindi all'interno del Tcache il chunk punterà a se stesso. Quindi, viene allocato, il suo puntatore FD viene modificato per puntare al **free hook** e quindi viene allocato di nuovo in modo che il prossimo chunk nella lista sarà nel free hook. Poi, anche questo viene allocato ed è possibile scrivere l'indirizzo di `system` qui in modo che quando un malloc contenente `"/bin/sh"` viene liberato otteniamo una shell.
|
||||
* CTF [https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps0/index.html](https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps0/index.html)
|
||||
* **Attacco agli indici di Tcache**: È possibile allocare e liberare un chunk di una dimensione tale che quando memorizzato nelle informazioni del tcache genererà una **posizione con il valore 0x100** (perché il byte che indica quanti chunk in quell'indice sono memorizzati). Quindi, abusando di questo valore è possibile `free` questo indirizzo poiché sembra essere un chunk di dimensione 0x100. Questo aggiungerà quell'indirizzo all'indice dei chunk di dimensione 0x100 nel tcache.\
|
||||
Quindi, allocando un chunk di dimensione 0x100, è possibile sovrascrivere l'indirizzo del chunk iniziale di altri indici di tcache. Ad esempio mettendo l'indirizzo del malloc hook in uno di essi e allocando un chunk della dimensione di quell'indice si otterrà un chunk nel calloc hook, che consente di scrivere un one gadget per ottenere una shell.
|
||||
* La vulnerabilità principale qui è la capacità di `liberare` qualsiasi indirizzo nell'heap indicandone l'offset
|
||||
* **Attacco agli indici di Tcache**: È possibile allocare e liberare un chunk di una dimensione tale che quando viene memorizzato all'interno del chunk di tcache (il chunk con le informazioni dei bin di tcache) genererà un **indirizzo con il valore 0x100**. Questo perché il tcache memorizza la quantità di chunk su ciascun bin in byte diversi, quindi un chunk in un indice specifico genera il valore 0x100.
|
||||
* Quindi, questo valore sembra che ci sia un chunk di dimensione 0x100. Consentendo di abusarne liberando questo indirizzo. Questo aggiungerà quell'indirizzo all'indice dei chunk di dimensione 0x100 nel tcache.
|
||||
* Quindi, **allocando** un chunk di dimensione **0x100**, l'indirizzo precedente verrà restituito come un chunk, consentendo di sovrascrivere altri indici di tcache.\
|
||||
Ad esempio mettendo l'indirizzo del malloc hook in uno di essi e allocando un chunk della dimensione di quell'indice permetterà di ottenere un chunk nel calloc hook, che consente di scrivere un one gadget per ottenere una shell.
|
||||
* CTF [https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps1/index.html](https://guyinatuxedo.github.io/44-more\_tcache/csaw19\_popping\_caps1/index.html)
|
||||
* Stessa vulnerabilità di prima con una restrizione aggiuntiva
|
||||
* **Attacco agli indici di Tcache**: Attacco simile al precedente ma con meno passaggi liberando il chunk che contiene le informazioni del tcache in modo che il suo indirizzo venga aggiunto all'indice di tcache della sua dimensione in modo da poter allocare quella dimensione e ottenere le informazioni del chunk di tcache come un chunk, consentendo di aggiungere il free hook come l'indirizzo di un indice, allocarlo e scrivere un one gadget su di esso.
|
||||
|
||||
<details>
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue