Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-26 14:40:37 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/binary-exploitation/libc-heap/house-of-roman.md

8.1 KiB
Raw Blame History

House of Roman

{% hint style="success" %} Impara e pratica l'Hacking su AWS: HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'Hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks
{% endhint %}

Informazioni di Base

Questa è stata una tecnica molto interessante che ha permesso l'esecuzione di codice remoto senza perdite tramite fake fastbins, l'attacco unsorted_bin e sovrascritture relative. Tuttavia è stata corretta.

Codice

Obiettivo

  • Esecuzione di codice remoto sfruttando puntatori relativi

Requisiti

  • Modifica dei puntatori fastbin e unsorted bin
  • Devono essere forzati 12 bit di casualità (0,02% di probabilità) per funzionare

Passaggi dell'Attacco

Parte 1: Il Chunk Fastbin punta a __malloc_hook

Creare diversi chunk:

  • fastbin_victim (0x60, offset 0): Chunk UAF successivamente da modificare per far puntare il puntatore dell'heap al valore di LibC.
  • chunk2 (0x80, offset 0x70): Per un buon allineamento
  • main_arena_use (0x80, offset 0x100)
  • relative_offset_heap (0x60, offset 0x190): offset relativo sul chunk 'main_arena_use'

Poi free(main_arena_use) che metterà questo chunk nella lista non ordinata e otterrà un puntatore a main_arena + 0x68 sia nei puntatori fd che bk.

Ora viene allocato un nuovo chunk fake_libc_chunk(0x60) perché conterrà i puntatori a main_arena + 0x68 nei puntatori fd e bk.

Poi vengono liberati relative_offset_heap e fastbin_victim.

/*
Current heap layout:
0x0:   fastbin_victim       - size 0x70
0x70:  alignment_filler     - size 0x90
0x100: fake_libc_chunk      - size 0x70 (contains a fd ptr to main_arena + 0x68)
0x170: leftover_main        - size 0x20
0x190: relative_offset_heap - size 0x70

bin layout:
fastbin:  fastbin_victim -> relative_offset_heap
unsorted: leftover_main
*/
  • fastbin_victim ha un fd che punta a relative_offset_heap
  • relative_offset_heap è un offset di distanza da fake_libc_chunk, che contiene un puntatore a main_arena + 0x68
  • Cambiando l'ultimo byte di fastbin_victim.fd è possibile far sì che fastbin_victim punti a main_arena + 0x68

Per le azioni precedenti, l'attaccante deve essere in grado di modificare il puntatore fd di fastbin_victim.

Quindi, main_arena + 0x68 non è così interessante, quindi modifichiamolo in modo che il puntatore punti a __malloc_hook.

Nota che __memalign_hook di solito inizia con 0x7f e zeri prima di esso, quindi è possibile falsificarlo come un valore nel fast bin 0x70. Poiché gli ultimi 4 bit dell'indirizzo sono casuali ci sono 2^4=16 possibilità affinché il valore finisca puntando dove siamo interessati. Quindi qui viene eseguito un attacco BF in modo che il chunk finisca come: 0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23).

(Per ulteriori informazioni sugli altri byte, controlla la spiegazione nell'esempio how2heap). Se il BF non funziona, il programma crasha (quindi riprova finché non funziona).

Quindi, vengono eseguiti 2 malloc per rimuovere i 2 chunk iniziali del fast bin e viene allocato un terzo per ottenere un chunk nel __malloc_hook:

malloc(0x60);
malloc(0x60);
uint8_t* malloc_hook_chunk = malloc(0x60);

Parte 2: Attacco unsorted_bin

Per ulteriori informazioni puoi controllare:

{% content-ref url="unsorted-bin-attack.md" %} unsorted-bin-attack.md {% endcontent-ref %}

Ma fondamentalmente consente di scrivere main_arena + 0x68 in qualsiasi posizione specificata in chunk->bk. E per l'attacco scegliamo __malloc_hook. Quindi, dopo averlo sovrascritto, utilizzeremo una sovrascrittura relativa per puntare a un one_gadget.

Per questo iniziamo ottenendo un chunk e mettendolo nell'unsorted bin:

uint8_t* unsorted_bin_ptr = malloc(0x80);
malloc(0x30); // Don't want to consolidate

puts("Put chunk into unsorted_bin\n");
// Free the chunk to create the UAF
free(unsorted_bin_ptr);

Usa un UAF in questo chunk per puntare unsorted_bin_ptr->bk all'indirizzo di __malloc_hook (abbiamo già forzato questo in precedenza).

{% hint style="danger" %} Nota che questo attacco corrompe il bin non ordinato (quindi anche small e large). Quindi possiamo utilizzare solo allocazioni dal fast bin ora (un programma più complesso potrebbe fare altre allocazioni e bloccarsi), e per attivare questo dobbiamo allocare la stessa dimensione o il programma si bloccherà. {% endhint %}

Quindi, per attivare la scrittura di main_arena + 0x68 in __malloc_hook eseguiamo dopo aver impostato __malloc_hook in unsorted_bin_ptr->bk dobbiamo semplicemente fare: malloc(0x80)

Passo 3: Imposta __malloc_hook su system

Nel primo passo abbiamo finito per controllare un chunk contenente __malloc_hook (nella variabile malloc_hook_chunk) e nel secondo passo siamo riusciti a scrivere main_arena + 0x68 qui.

Ora, sfruttiamo una sovrascrittura parziale in malloc_hook_chunk per utilizzare l'indirizzo libc che abbiamo scritto lì (main_arena + 0x68) per puntare a un indirizzo one_gadget.

Qui è necessario forzare 12 bit di casualità (ulteriori informazioni nell'how2heap esempio).

Infine, una volta sovrascritto l'indirizzo corretto, chiama malloc e attiva il one_gadget.

Riferimenti

{% hint style="success" %} Impara e pratica l'Hacking su AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'Hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks
{% endhint %}