House of Force

Lernen Sie AWS-Hacking:HackTricks Training AWS Red Team Expert (ARTE) Lernen Sie GCP-Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Unterstützen Sie HackTricks

• Überprüfen Sie die Abonnementpläne!

• Treten Sie der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie uns auf Twitter 🐦 @hacktricks_live.

• Teilen Sie Hacking-Tricks, indem Sie PRs an die HackTricks und HackTricks Cloud Github-Repositories einreichen.

Grundlegende Informationen

Code

• Diese Technik wurde gepatcht (hier) und führt zu diesem Fehler: malloc(): corrupted top size

• Sie können den Code von hier ausprobieren, um ihn zu testen, wenn Sie möchten.

Ziel

• Das Ziel dieses Angriffs ist es, einen Chunk an einer bestimmten Adresse zu allozieren.

Anforderungen

• Ein Überlauf, der es ermöglicht, die Größe des Top-Chunk-Headers zu überschreiben (z. B. -1).

• Die Fähigkeit, die Größe der Heap-Allokation zu kontrollieren.

Angriff

Wenn ein Angreifer einen Chunk an der Adresse P allozieren möchte, um einen Wert hier zu überschreiben, beginnt er damit, die Top-Chunk-Größe mit -1 zu überschreiben (möglicherweise mit einem Überlauf). Dies stellt sicher, dass malloc keine mmap für eine beliebige Allokation verwendet, da der Top-Chunk immer genügend Platz haben wird.

Berechnen Sie dann den Abstand zwischen der Adresse des Top-Chunks und dem Zielraum zur Allokation. Dies liegt daran, dass eine malloc mit dieser Größe durchgeführt wird, um den Top-Chunk an diese Position zu verschieben. So kann der Unterschied/Größe leicht berechnet werden:

// From https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c#L59C2-L67C5
/*
* The evil_size is calulcated as (nb is the number of bytes requested + space for metadata):
* new_top = old_top + nb
* nb = new_top - old_top
* req + 2sizeof(long) = new_top - old_top
* req = new_top - old_top - 2sizeof(long)
* req = target - 2sizeof(long) - old_top - 2sizeof(long)
* req = target - old_top - 4*sizeof(long)
*/

Daher wird die Zuweisung einer Größe von Ziel - old_top - 4*sizeof(long) (die 4 longs sind aufgrund der Metadaten des Top-Chunks und des neuen Chunks bei der Zuweisung) den Top-Chunk an die Adresse verschieben, die wir überschreiben möchten. Dann wird ein weiteres malloc durchgeführt, um einen Chunk an der Zieladresse zu erhalten.

Referenzen & Weitere Beispiele

• https://github.com/shellphish/how2heap/tree/master

• https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/

• https://heap-exploitation.dhavalkapil.com/attacks/house_of_force

• https://github.com/shellphish/how2heap/blob/master/glibc_2.27/house_of_force.c

• https://guyinatuxedo.github.io/41-house_of_force/house_force_exp/index.html

• https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house_of_force/#hitcon-training-lab-11

• Das Ziel dieses Szenarios ist ein ret2win, bei dem die Adresse einer Funktion, die von der Adresse der ret2win-Funktion aufgerufen wird, geändert werden muss.

• Die Binärdatei hat einen Überlauf, der ausgenutzt werden kann, um die Größe des Top-Chunks zu ändern, der auf -1 oder p64(0xffffffffffffffff) geändert wird.

• Dann wird die Adresse berechnet, an der der zu überschreibende Zeiger existiert, und der Unterschied von der aktuellen Position des Top-Chunks dorthin wird mit malloc allokiert.

• Schließlich wird ein neuer Chunk allokiert, der dieses gewünschte Ziel enthält, das durch die ret2win-Funktion überschrieben wird.

• https://shift--crops-hatenablog-com.translate.goog/entry/2016/03/21/171249?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp

• Im Geben Sie Ihren Namen ein: gibt es eine anfängliche Schwachstelle, die es ermöglicht, eine Adresse aus dem Heap zu leaken.

• Dann ist es in der Funktionalität Org: und Host: möglich, die 64B des s-Zeigers zu füllen, wenn nach dem Org-Namen gefragt wird, der im Stack von der Adresse von v2 gefolgt wird, die dann vom angegebenen Host-Namen gefolgt wird. Da dann strcpy die Inhalte von s in einen Chunk der Größe 64B kopiert, ist es möglich, die Größe des Top-Chunks mit den Daten zu überschreiben, die im Host-Namen platziert sind.

• Jetzt, da ein beliebiges Schreiben möglich ist, wurde das GOT von atoi mit der Adresse von printf überschrieben. Es war möglich, die Adresse von IO_2_1_stderr mit %24$p zu leaken. Und mit diesem libc-Leak war es möglich, das GOT von atoi erneut mit der Adresse von system zu überschreiben und es mit /bin/sh als Parameter aufzurufen.

• Eine alternative Methode die in diesem anderen Writeup vorgeschlagen wurde, besteht darin, free mit puts zu überschreiben und dann die Adresse von atoi@got in den Zeiger zu setzen, der später freigegeben wird, um sie zu leaken und mit diesem Leak erneut atoi@got mit system zu überschreiben und es mit /bin/sh aufzurufen.

• https://guyinatuxedo.github.io/41-house_of_force/bkp16_cookbook/index.html

• Es gibt eine UAF, die es ermöglicht, einen Chunk wiederzuverwenden, der ohne Löschen des Zeigers freigegeben wurde. Da es einige Lese-Methoden gibt, ist es möglich, eine libc-Adresse zu leaken, indem ein Zeiger auf die freie Funktion im GOT geschrieben und dann die Lese-Funktion aufgerufen wird.

• Dann wurde House of Force (unter Ausnutzung des UAF) verwendet, um die Größe des verbleibenden Speicherplatzes mit -1 zu überschreiben, einen ausreichend großen Chunk zu allozieren, um zum free-Hook zu gelangen, und dann einen weiteren Chunk zu allozieren, der den free-Hook enthält. Dann wird in den Hook die Adresse von system geschrieben, in einen Chunk "/bin/sh" geschrieben und schließlich der Chunk mit diesem String-Inhalt freigegeben.