hacktricks/binary-exploitation/libc-heap/house-of-orange.md

# Casa di Orange

{% hint style="success" %}
Impara e pratica l'Hacking su AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
Impara e pratica l'Hacking su GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>Sostieni HackTricks</summary>

* Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
* **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 trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.

</details>
{% endhint %}

## Informazioni di Base

### Codice

* Trova un esempio in [https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_orange.c](https://github.com/shellphish/how2heap/blob/master/glibc\_2.23/house\_of\_orange.c)
* La tecnica di exploit è stata corretta in questa [patch](https://sourceware.org/git/?p=glibc.git;a=blobdiff;f=stdlib/abort.c;h=117a507ff88d862445551f2c07abb6e45a716b75;hp=19882f3e3dc1ab830431506329c94dcf1d7cc252;hb=91e7cf982d0104f0e71770f5ae8e3faf352dea9f;hpb=0c25125780083cbba22ed627756548efe282d1a0) quindi non funziona più (funzionante in versioni precedenti alla 2.26)
* Stesso esempio **con più commenti** in [https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html](https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html)

### Obiettivo

* Abusare della funzione `malloc_printerr`

### Requisiti

* Sovrascrivere la dimensione del top chunk
* Perdite di Libc e heap

### Contesto

Alcune informazioni necessarie dai commenti di [**questo esempio**](https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html)**:**

Il punto è che, nelle versioni più vecchie di libc, quando veniva chiamata la funzione `malloc_printerr`, essa avrebbe **iterato attraverso una lista di strutture `_IO_FILE`** memorizzate in `_IO_list_all`, e in realtà **eseguito** un puntatore di istruzione in quella struttura.\
Questo attacco forgerà una **falsa struttura `_IO_FILE`** che scriveremo in **`_IO_list_all`**, e causerà l'esecuzione di `malloc_printerr`.\
Poi **eseguirà qualsiasi indirizzo** che abbiamo memorizzato nella tabella di salto delle strutture **`_IO_FILE`**, e otterremo l'esecuzione del codice

### Attacco

L'attacco inizia riuscendo a ottenere il **top chunk** all'interno del **unsorted bin**. Questo viene ottenuto chiamando `malloc` con una dimensione maggiore della dimensione corrente del top chunk ma minore di **`mmp_.mmap_threshold`** (di default è 128K), che altrimenti attiverebbe l'allocazione di `mmap`. Ogni volta che la dimensione del top chunk viene modificata, è importante assicurarsi che il **top chunk + la sua dimensione** sia allineato alla pagina e che il bit **prev\_inuse** del top chunk sia sempre impostato.

Per ottenere il top chunk all'interno dell'unsorted bin, allocare un chunk per creare il top chunk, cambiare la dimensione del top chunk (con un overflow nel chunk allocato) in modo che **top chunk + dimensione** sia allineato alla pagina con il bit **prev\_inuse** impostato. Quindi allocare un chunk più grande della nuova dimensione del top chunk. Nota che `free` non viene mai chiamato per ottenere il top chunk nell'unsorted bin.

Il vecchio top chunk è ora nell'unsorted bin. Supponendo di poter leggere i dati al suo interno (possibilmente a causa di una vulnerabilità che ha causato anche l'overflow), è possibile ottenere perdite di indirizzi di Libc da esso e ottenere l'indirizzo di **\_IO\_list\_all**.

Viene eseguito un attacco all'unsorted bin abusando dell'overflow per scrivere `topChunk->bk->fwd = _IO_list_all - 0x10`. Quando viene allocato un nuovo chunk, il vecchio top chunk verrà diviso e un puntatore all'unsorted bin verrà scritto in **`_IO_list_all`**.

Il passo successivo comporta la riduzione della dimensione del vecchio top chunk per adattarla a un bin piccolo, impostando specificamente la sua dimensione su **0x61**. Questo serve a due scopi:

1. **Inserimento nel Small Bin 4**: Quando `malloc` esamina l'unsorted bin e vede questo chunk, cercherà di inserirlo nel small bin 4 a causa delle sue dimensioni ridotte. Questo fa sì che il chunk finisca all'inizio della lista del small bin 4 che è la posizione del puntatore FD del chunk di **`_IO_list_all`** poiché abbiamo scritto un indirizzo vicino in **`_IO_list_all`** tramite l'attacco all'unsorted bin.
2. **Attivazione di un Controllo Malloc**: Questa manipolazione della dimensione del chunk causerà a `malloc` di eseguire controlli interni. Quando controlla la dimensione del falso chunk in avanti, che sarà zero, attiva un errore e chiama `malloc_printerr`.

La manipolazione del bin piccolo ti permetterà di controllare il puntatore in avanti del chunk. L'overlap con **\_IO\_list\_all** viene utilizzato per forgiare una falsa struttura **\_IO\_FILE**. La struttura è attentamente progettata per includere campi chiave come `_IO_write_base` e `_IO_write_ptr` impostati su valori che superano i controlli interni in libc. Inoltre, viene creato una tabella di salto all'interno della struttura falsa, dove un puntatore di istruzione è impostato sull'indirizzo in cui può essere eseguito del codice arbitrario (ad esempio, la funzione `system`).

Per riassumere la parte rimanente della tecnica:

* **Riduci il Vecchio Top Chunk**: Regola la dimensione del vecchio top chunk a **0x61** per adattarlo a un bin piccolo.
* **Configura la Falsa Struttura `_IO_FILE`**: Sovrapporre il vecchio top chunk con la falsa struttura **\_IO\_FILE** e impostare i campi in modo appropriato per dirottare il flusso di esecuzione.

Il passo successivo comporta la forgiatura di una falsa struttura **\_IO\_FILE** che si sovrappone al vecchio top chunk attualmente nell'unsorted bin. I primi byte di questa struttura sono attentamente progettati per includere un puntatore a un comando (ad esempio, "/bin/sh") che verrà eseguito.

I campi chiave nella falsa struttura **\_IO\_FILE**, come `_IO_write_base` e `_IO_write_ptr`, sono impostati su valori che superano i controlli interni in libc. Inoltre, viene creato una tabella di salto all'interno della falsa struttura, dove un puntatore di istruzione è impostato sull'indirizzo in cui può essere eseguito del codice arbitrario. Tipicamente, questo sarebbe l'indirizzo della funzione `system` o un'altra funzione che può eseguire comandi shell.

L'attacco culmina quando una chiamata a `malloc` attiva l'esecuzione del codice attraverso la struttura **\_IO\_FILE** manipolata. Ciò consente efficacemente l'esecuzione di codice arbitrario, che di solito porta alla creazione di una shell o all'esecuzione di un altro payload dannoso.

**Sommario dell'Attacco:**

1. **Configura il top chunk**: Alloca un chunk e modifica la dimensione del top chunk.
2. **Forza il top chunk nell'unsorted bin**: Alloca un chunk più grande.
3. **Perdite di indirizzi di Libc**: Usa la vulnerabilità per leggere dall'unsorted bin.
4. **Esegui l'attacco all'unsorted bin**: Scrivi in **\_IO\_list\_all** utilizzando un overflow.
5. **Riduci il vecchio top chunk**: Regola la sua dimensione per adattarla a un bin piccolo.
6. **Configura una falsa struttura \_IO\_FILE**: Forgia una falsa struttura file per dirottare il flusso di controllo.
7. **Attiva l'esecuzione del codice**: Alloca un chunk per eseguire l'attacco ed eseguire del codice arbitrario.

Questo approccio sfrutta i meccanismi di gestione dell'heap, le perdite di informazioni di Libc e gli overflow dell'heap per ottenere l'esecuzione del codice senza chiamare direttamente `free`. Creando attentamente la falsa struttura **\_IO\_FILE** e posizionandola nella posizione corretta, l'attacco può dirottare il flusso di controllo durante le operazioni standard di allocazione di memoria. Ciò consente l'esecuzione di codice arbitrario, potenzialmente portando alla creazione di una shell o ad altre attività dannose.
## Riferimenti

* [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_orange/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_orange/)
* [https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html](https://guyinatuxedo.github.io/43-house\_of\_orange/house\_orange\_exp/index.html)

{% hint style="success" %}
Impara e pratica l'Hacking su AWS:<img src="/.gitbook/assets/arte.png" alt="" data-size="line">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="/.gitbook/assets/arte.png" alt="" data-size="line">\
Impara e pratica l'Hacking su GCP: <img src="/.gitbook/assets/grte.png" alt="" data-size="line">[**HackTricks Training GCP Red Team Expert (GRTE)**<img src="/.gitbook/assets/grte.png" alt="" data-size="line">](https://training.hacktricks.xyz/courses/grte)

<details>

<summary>Sostieni HackTricks</summary>

* Controlla i [**piani di abbonamento**](https://github.com/sponsors/carlospolop)!
* **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 trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.

</details>
{% endhint %}