German - Ht
HackTricks Training Twitter Linkedin Sponsor

House of Roman

Unterstützen Sie HackTricks

Grundlegende Informationen

Dies war eine sehr interessante Technik, die RCE ohne Leaks über gefälschte Fastbins, den unsorted_bin-Angriff und relative Überschreibungen ermöglichte. Es wurde jedoch gepatcht.

Code

Ziel

  • RCE durch Ausnutzung relativer Zeiger

Anforderungen

  • Bearbeiten von Fastbin- und Unsorted-Bin-Zeigern

  • 12 Bits Zufälligkeit müssen erraten werden (0,02% Erfolgschance)

Angriffsschritte

Teil 1: Fastbin-Chunk zeigt auf __malloc_hook

Erstellen mehrerer Chunks:

  • fastbin_victim (0x60, Offset 0): UAF-Chunk, der später bearbeitet wird, um den Heap-Zeiger auf den LibC-Wert zu zeigen.

  • chunk2 (0x80, Offset 0x70): Für gute Ausrichtung

  • main_arena_use (0x80, Offset 0x100)

  • relative_offset_heap (0x60, Offset 0x190): Relativer Offset auf dem 'main_arena_use'-Chunk

Dann free(main_arena_use), was diesen Chunk in die unsortierte Liste platziert und einen Zeiger auf main_arena + 0x68 in sowohl den fd als auch bk Zeigern erhält.

Nun wird ein neuer Chunk fake_libc_chunk(0x60) allokiert, da er die Zeiger auf main_arena + 0x68 in fd und bk enthalten wird.

Dann werden relative_offset_heap und fastbin_victim freigegeben.

/*
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 hat ein fd, das auf relative_offset_heap zeigt

  • relative_offset_heap ist ein Offset von der Entfernung zu fake_libc_chunk, der einen Zeiger auf main_arena + 0x68 enthält

  • Durch Ändern des letzten Bytes von fastbin_victim.fd ist es möglich, dass fastbin_victim auf main_arena + 0x68 zeigt

Für die vorherigen Aktionen muss der Angreifer in der Lage sein, den fd-Zeiger von fastbin_victim zu ändern.

Dann ist main_arena + 0x68 nicht so interessant, also ändern wir es so, dass der Zeiger auf __malloc_hook zeigt.

Beachten Sie, dass __memalign_hook normalerweise mit 0x7f beginnt und Nullen davor hat, dann ist es möglich, es als Wert im 0x70 Fastbin zu fälschen. Da die letzten 4 Bits der Adresse zufällig sind, gibt es 2^4=16 Möglichkeiten für den Wert, um dorthin zu zeigen, wo wir interessiert sind. Daher wird hier ein BF-Angriff durchgeführt, damit der Chunk wie folgt endet: 0x70: fastbin_victim -> fake_libc_chunk -> (__malloc_hook - 0x23).

(Weitere Informationen zu den restlichen Bytes finden Sie in der Erklärung im how2heap Beispiel). Wenn der BF nicht funktioniert, stürzt das Programm einfach ab (also starten Sie erneut, bis es funktioniert).

Dann werden 2 mallocs durchgeführt, um die 2 anfänglichen Fastbin-Chunks zu entfernen, und dann wird ein dritter allokiert, um einen Chunk im __malloc_hook: zu erhalten.

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

Teil 2: Unsorted_bin Angriff

Für weitere Informationen kannst du überprüfen:

Unsorted Bin Attack

Aber im Grunde erlaubt es, main_arena + 0x68 an jede Stelle zu schreiben, die in chunk->bk angegeben ist. Und für den Angriff wählen wir __malloc_hook. Dann, nachdem wir es überschrieben haben, werden wir eine relative Überschreibung verwenden, um auf ein one_gadget zu zeigen.

Dafür beginnen wir damit, einen Chunk zu erhalten und ihn in den unsorted bin zu platzieren:

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);

Verwenden Sie einen UAF in diesem Abschnitt, um unsorted_bin_ptr->bk auf die Adresse von __malloc_hook zu zeigen (wir haben dies zuvor durch Brute-Force ermittelt).

Beachten Sie, dass dieser Angriff den unsortierten Bin beschädigt (und somit auch den kleinen und großen Bin). Daher können wir jetzt nur Zuweisungen aus dem Fast Bin verwenden (ein komplexeres Programm könnte andere Zuweisungen durchführen und abstürzen), und um dies auszulösen, müssen wir die gleiche Größe zuweisen, oder das Programm wird abstürzen.

Um also das Schreiben von main_arena + 0x68 in __malloc_hook auszulösen, führen wir nach dem Setzen von __malloc_hook in unsorted_bin_ptr->bk einfach aus: malloc(0x80)

Schritt 3: Setzen von __malloc_hook auf system

Im ersten Schritt kontrollierten wir einen Chunk, der __malloc_hook enthält (in der Variablen malloc_hook_chunk) und im zweiten Schritt gelang es uns, main_arena + 0x68 hierhin zu schreiben.

Nun nutzen wir eine teilweise Überschreibung in malloc_hook_chunk, um die libc-Adresse, die wir dort geschrieben haben (main_arena + 0x68), zu verwenden, um eine one_gadget-Adresse zu zeigen.

Hier ist es erforderlich, 12 Bits Zufälligkeit zu bruteforcen (weitere Informationen im how2heap Beispiel).

Schließlich, sobald die richtige Adresse überschrieben ist, rufen Sie malloc auf und lösen Sie den one_gadget aus.

Referenzen

Unterstützen Sie HackTricks
PreviousHouse of RabbitNextCommon Binary Exploitation Protections & Bypasses

Last updated