mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-25 22:20:43 +00:00
Translated ['binary-exploitation/heap/house-of-einherjar.md', 'binary-ex
This commit is contained in:
Translator
parent
96400eb924
commit
4243f2af28
5 changed files with 103 additions and 57 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)
|
||||
|
|
|
|||
|
|
@ -2,15 +2,15 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Erlernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Lernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Andere Möglichkeiten, HackTricks zu unterstützen:
|
||||
|
||||
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks im PDF-Format herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks in PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
|
||||
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.
|
||||
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositorys einreichen.
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -19,6 +19,7 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
|
|||
### Code
|
||||
|
||||
* Überprüfen Sie das Beispiel unter [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)
|
||||
* Oder das unter [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) (möglicherweise müssen Sie den tcache füllen)
|
||||
|
||||
### Ziel
|
||||
|
||||
|
|
@ -26,36 +27,30 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
|
|||
|
||||
### Anforderungen
|
||||
|
||||
* Off um eins über dem Header des nächsten Chunks, um das prev in use zu ändern
|
||||
* In der Lage sein, die Daten `prev_size` zu ändern, die Teil des aktuellen Chunks sind (am Ende)
|
||||
* Heap-Leak
|
||||
* Erstellen Sie einen gefälschten Chunk, wenn wir einen Chunk zuweisen möchten:
|
||||
* Setzen Sie Zeiger so, dass sie auf sich selbst zeigen, um die Integritätsprüfungen zu umgehen
|
||||
* Off-by-one von einem Chunk zum anderen, um das vorherige in Benutzung zu ändern
|
||||
* Geben Sie im `prev_size` des missbrauchten off-by-one-Chunks den Unterschied zwischen sich selbst und dem gefälschten Chunk an
|
||||
* Die Größe des gefälschten Chunks muss auch auf die gleiche Größe gesetzt worden sein, um die Integritätsprüfungen zu umgehen
|
||||
* Für die Konstruktion dieser Chunks benötigen Sie ein Heap-Leak.
|
||||
|
||||
### Angriff
|
||||
|
||||
* Es wird ein gefälschter Chunk innerhalb eines vom Angreifer kontrollierten Chunks erstellt, der mit `fd` und `bk` auf den ursprünglichen Chunk zeigt, um Schutzmechanismen zu umgehen
|
||||
* 2 weitere Chunks (`B` und `C`) werden erstellt.
|
||||
* Durch Ausnutzen des Off-by-One im `B` wird das `prev in use`-Bit gelöscht und die `prev_size`-Daten mit dem Unterschied zwischen dem Ort, an dem der `C`-Chunk allokiert ist, und dem zuvor generierten gefälschten `A`-Chunk überschrieben.
|
||||
* Diese `prev_size` und die Größe des gefälschten Chunks `A` müssen gleich sein, um Überprüfungen zu umgehen.
|
||||
* Dann wird der Tcache gefüllt
|
||||
* 2 weitere Chunks (`B` und `C`) werden allokiert
|
||||
* Durch Ausnutzen des Off-by-One im `B` wird das `prev in use`-Bit gelöscht und die `prev_size`-Daten mit dem Unterschied zwischen dem Ort, an dem der `C`-Chunk allokiert ist, und dem zuvor generierten gefälschten `A`-Chunk überschrieben
|
||||
* Diese `prev_size` und die Größe im gefälschten Chunk `A` müssen gleich sein, um die Prüfungen zu umgehen.
|
||||
* Dann wird der tcache gefüllt
|
||||
* Dann wird `C` freigegeben, damit es sich mit dem gefälschten Chunk `A` konsolidiert
|
||||
* Dann wird ein neuer Chunk `D` erstellt, der im gefälschten `A`-Chunk beginnt und den `B`-Chunk abdeckt
|
||||
* Dann wird `B` freigegeben und sein `fd` wird auf die Zieladresse überschrieben, sodass es auf die Zieladresse zeigt und den `D`-Chunk missbraucht, der ihn enthält.
|
||||
* Dann werden 2 mallocs durchgeführt, da der zweite die Zieladresse enthalten wird
|
||||
* Das Haus von Einherjar endet hier
|
||||
* Dies kann mit einem Fast-Bin-Angriff fortgesetzt werden:
|
||||
* Geben Sie `B` frei, um es dem Fast-Bin hinzuzufügen
|
||||
* Das `fd` von `B` wird überschrieben, sodass es auf die Zieladresse zeigt und den `D`-Chunk missbraucht (da er `B` enthält) 
|
||||
* Dann werden 2 mallocs durchgeführt und der zweite wird die **Zieladresse zuweisen**
|
||||
|
||||
## Referenzen
|
||||
## Referenzen und weitere Beispiele
|
||||
|
||||
* [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)
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Erlernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Andere Möglichkeiten, HackTricks zu unterstützen:
|
||||
|
||||
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks im PDF-Format herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
|
||||
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.
|
||||
|
||||
</details>
|
||||
* [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)
|
||||
* Nachdem Zeiger freigegeben wurden, werden sie nicht nullifiziert, sodass es immer noch möglich ist, auf ihre Daten zuzugreifen. Daher wird ein Chunk in den unsortierten Bin platziert und die darin enthaltenen Zeiger geleakt (libc leak) und dann wird ein neuer Heap im unsortierten Bin platziert und eine Heap-Adresse aus dem Zeiger geleakt, den er erhält.
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# House of Lore
|
||||
# House of Lore | Small bin Attack
|
||||
|
||||
<details>
|
||||
|
||||
|
|
@ -18,33 +18,43 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
|
|||
|
||||
### Code
|
||||
|
||||
* Überprüfen Sie den von [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/)
|
||||
* Dies funktioniert nicht
|
||||
* Überprüfen Sie den von [https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/house\_of\_lore/) bereitgestellten Code
|
||||
* Oder: [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)
|
||||
* Dies funktioniert nicht, auch wenn versucht wird, einige Überprüfungen zu umgehen und den Fehler zu erhalten: `malloc(): unaligned tcache chunk detected`
|
||||
* Dieses Beispiel funktioniert immer noch**:** [**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) 
|
||||
|
||||
### Ziel
|
||||
|
||||
* Fügen Sie gefälschte kleine Chunks in den Small Bin ein, damit sie allokiert werden können.
|
||||
* Fügen Sie einen **gefälschten kleinen Chunk in den kleinen Bin ein, damit es möglich ist, ihn zuzuweisen**.\
|
||||
Beachten Sie, dass der hinzugefügte kleine Chunk der gefälschte ist, den der Angreifer erstellt, nicht einer an einer beliebigen Position.
|
||||
|
||||
### Anforderungen
|
||||
|
||||
* Erstellen von gefälschten Chunks
|
||||
* Kenntnis der Adresse des Opferchunks und der gefälschten Chunks
|
||||
* In der Lage sein, die `bk`- und `fd`-Zeiger zu modifizieren
|
||||
* Erstellen Sie 2 gefälschte Chunks und verknüpfen Sie sie miteinander und mit dem legitimen Chunk im kleinen Bin:
|
||||
* `fake0.bk` -> `fake1`
|
||||
* `fake1.fd` -> `fake0`
|
||||
* `fake0.fd` -> `legit` (Sie müssen einen Zeiger im freigegebenen kleinen Bin-Chunk über eine andere Schwachstelle ändern)
|
||||
* `legit.bk` -> `fake0`
|
||||
|
||||
Dann können Sie `fake0` zuweisen.
|
||||
|
||||
### Angriff
|
||||
|
||||
* Ein Opfer-Small-Chunk wird allokiert
|
||||
* Ein Angreifer generiert ein paar gefälschte Small Chunks und lässt den ersten gefälschten Chunk auf einen echten Chunk zeigen und den `bk` auf den zweiten gefälschten Chunk zeigen. Der zweite gefälschte Chunk zeigt wiederum auf den ersten.
|
||||
* Dann wird ein neuer großer Chunk allokiert, um zu verhindern, dass der erste in den Top Chunk fusioniert wird, wenn er freigegeben wird.
|
||||
* Dann wird der anfängliche Zeiger freigegeben und ein zweiter Zeiger einer größeren Größe allokiert, damit der freigegebene anfängliche Small Chunk im Small Bin platziert wird.
|
||||
* Der echte Small Chunk wird so modifiziert, dass sein `bk`-Zeiger auf den gefälschten zeigt.
|
||||
* Dann, wenn 2 Chunks dieser Größe allokiert werden, erhält der erste gültige Chunk und dann der ungültige Chunk, der irgendwie vom Angreifer kontrolliert wird.
|
||||
* Ein kleiner Chunk (`legit`) wird zugewiesen, dann wird ein weiterer zugewiesen, um eine Konsolidierung mit dem Top-Chunk zu verhindern. Dann wird `legit` freigegeben (wodurch es in die ungeordnete Liste verschoben wird) und ein größerer Chunk wird zugewiesen, **wodurch `legit` in den kleinen Bin verschoben wird.**
|
||||
* Ein Angreifer generiert ein paar gefälschte kleine Chunks und erstellt die erforderlichen Verknüpfungen, um die Integritätsprüfungen zu umgehen:
|
||||
* `fake0.bk` -> `fake1`
|
||||
* `fake1.fd` -> `fake0`
|
||||
* `fake0.fd` -> `legit` (Sie müssen einen Zeiger im freigegebenen kleinen Bin-Chunk über eine andere Schwachstelle ändern)
|
||||
* `legit.bk` -> `fake0`
|
||||
* Ein kleiner Chunk wird zugewiesen, um `legit` zu erhalten, wodurch **`fake0`** in die Top-Liste der kleinen Bins gelangt
|
||||
* Ein weiterer kleiner Chunk wird zugewiesen, wodurch `fake0` als Chunk erhalten wird, was potenziell das Lesen/Schreiben von Zeigern darin ermöglicht.
|
||||
|
||||
## Referenzen
|
||||
|
||||
* [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>
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
|
|||
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
|
||||
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) Github-Repositorys senden.
|
||||
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.
|
||||
|
||||
</details>
|
||||
|
||||
|
|
@ -69,16 +69,51 @@ return 0;
|
|||
|
||||
### Ziel
|
||||
|
||||
* In der Lage sein, eine beliebige Adresse in den tcache / fast bin hinzuzufügen, damit sie beim Aufruf von malloc in einem Chunk verwendet wird
|
||||
* In der Lage sein, eine Adresse in den tcache / fast bin hinzuzufügen, damit es später möglich ist, sie zuzuweisen
|
||||
|
||||
### Anforderungen
|
||||
|
||||
* Dieser Angriff erfordert, dass ein Angreifer in der Lage ist, ein paar gefälschte schnelle Chunks zu erstellen, die den Größenwert korrekt angeben, und einen schnellen Chunk dieser Größe zu überschreiben, der freigegeben wird, sodass der Chunk des Angreifers tatsächlich derjenige ist, der in den schnellen Bin gelangt.
|
||||
* Dieser Angriff erfordert, dass ein Angreifer in der Lage ist, ein paar gefälschte schnelle Chunks zu erstellen, die den Größenwert korrekt anzeigen, und dann den ersten gefälschten Chunk freizugeben, damit er in den Bin gelangt.
|
||||
|
||||
### Angriff
|
||||
|
||||
* Erstellen Sie einen gefälschten Chunk, der Sicherheitsüberprüfungen umgeht (Sie benötigen 2 gefälschte Chunks)
|
||||
* Bevor ein Zeiger freigegeben wird, überschreiben Sie ihn mit dem gefälschten Chunk, damit dieser in den Bin gelangt
|
||||
* Erstellen von gefälschten Chunks, die Sicherheitsüberprüfungen umgehen: Sie benötigen im Grunde genommen 2 gefälschte Chunks, die an den richtigen Positionen die richtigen Größen anzeigen
|
||||
* Auf irgendeine Weise den ersten gefälschten Chunk freigeben, damit er in den schnellen oder tcache bin gelangt und dann ihn zuweisen, um diese Adresse zu überschreiben
|
||||
|
||||
**Der Code von** [**guyinatuxedo**](https://guyinatuxedo.github.io/39-house\_of\_spirit/house\_spirit\_exp/index.html) **ist großartig, um den Angriff zu verstehen.** Obwohl dieses Schema aus dem Code es ziemlich gut zusammenfasst:
|
||||
```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" %}
|
||||
Beachten Sie, dass es notwendig ist, den zweiten Chunk zu erstellen, um einige Integritätsprüfungen zu umgehen.
|
||||
{% endhint %}
|
||||
|
||||
## Beispiele
|
||||
|
||||
* 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**: Über einen Überlauf ist es möglich, einen Zeiger zu ändern, um auf eine GOT-Adresse zu zeigen, um eine libc-Adresse über die Leseaktion des CTFs preiszugeben.
|
||||
* **House of Spirit**: Durch den Missbrauch eines Zählers, der die Anzahl der "Gewehre" zählt, ist es möglich, eine gefälschte Größe des ersten gefälschten Chunks zu generieren. Dann, durch den Missbrauch einer "Nachricht", ist es möglich, die zweite Größe eines Chunks zu fälschen und schließlich durch einen Überlauf ist es möglich, einen Zeiger zu ändern, der freigegeben wird, sodass unser erster gefälschter Chunk freigegeben wird. Dann können wir ihn zuweisen und darin wird die Adresse gespeichert, an der die "Nachricht" gespeichert ist. Dann ist es möglich, dies auf den `scanf`-Eintrag im GOT-Table zu zeigen, sodass wir ihn mit der Adresse zu `system` überschreiben können.\
|
||||
Das nächste Mal, wenn `scanf` aufgerufen wird, können wir die Eingabe `"/bin/sh"` senden und eine Shell erhalten.
|
||||
|
||||
## Referenzen
|
||||
|
||||
|
|
@ -90,10 +125,10 @@ return 0;
|
|||
|
||||
Andere Möglichkeiten, HackTricks zu unterstützen:
|
||||
|
||||
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks in PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks im PDF-Format herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
|
||||
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merch**](https://peass.creator-spring.com)
|
||||
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
|
||||
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositorys einreichen.
|
||||
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.
|
||||
|
||||
</details>
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Erlernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Erlernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Andere Möglichkeiten, HackTricks zu unterstützen:
|
||||
|
||||
|
|
@ -24,30 +24,36 @@ Für weitere Informationen darüber, was ein Tcache-Bin ist, siehe diese Seite:
|
|||
|
||||
Zunächst einmal ist zu beachten, dass der Tcache in der glibc-Version 2.26 eingeführt wurde.
|
||||
|
||||
Der **Tcache**-Angriff, der auf der [**guyinatuxido-Seite**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) vorgeschlagen wird, ähnelt sehr dem Fast-Bin-Angriff, bei dem das Ziel darin besteht, den Zeiger auf den nächsten Chunk im Bin innerhalb eines freigegebenen Chunks an eine beliebige Adresse zu überschreiben, sodass es später möglich ist, **diese spezifische Adresse zuzuweisen und möglicherweise Zeiger zu überschreiben**.
|
||||
Der **Tcache**-Angriff, der auf der [**guyinatuxido-Seite**](https://guyinatuxedo.github.io/29-tcache/tcache\_explanation/index.html) vorgeschlagen wird, ähnelt sehr dem Fast-Bin-Angriff, bei dem das Ziel darin besteht, den Zeiger auf den nächsten Chunk im Bin innerhalb eines freigegebenen Chunks auf eine beliebige Adresse zu überschreiben, um später diese spezifische Adresse zu **allokieren und potenziell Zeiger zu überschreiben**.
|
||||
|
||||
Heutzutage erhalten Sie jedoch einen Fehler, wenn Sie den genannten Code ausführen: **`malloc(): unaligned tcache chunk detected`**. Daher ist es erforderlich, eine ausgerichtete Adresse als Adresse im neuen Zeiger zu schreiben (oder das Binärprogramm oft genug auszuführen, damit die geschriebene Adresse tatsächlich ausgerichtet ist).
|
||||
|
||||
### Tcache-Index-Angriff
|
||||
|
||||
Normalerweise ist es möglich, am Anfang des Heaps einen Chunk zu finden, der die **Anzahl der Chunks pro Index** im Tcache und die Adresse zum **Head-Chunk jedes Tcache-Index** enthält. Wenn es aus irgendeinem Grund möglich ist, diese Informationen zu ändern, wäre es möglich, **den Head-Chunk eines bestimmten Index auf eine gewünschte Adresse zeigen zu lassen** (z. B. malloc-Hook), um dann einen Chunk der Größe des Index zuzuweisen und den Inhalt des malloc-Hooks in diesem Fall zu überschreiben.
|
||||
Normalerweise ist es möglich, am Anfang des Heaps einen Chunk zu finden, der die **Anzahl der Chunks pro Index** im Tcache und die Adresse zum **Head-Chunk jedes Tcache-Index** enthält. Wenn es aus irgendeinem Grund möglich ist, diese Informationen zu ändern, wäre es möglich, den Head-Chunk eines bestimmten Index auf eine gewünschte Adresse zeigen zu lassen (z. B. malloc-Hook), um dann einen Chunk der Größe des Index zu allokieren und den Inhalt des malloc-Hooks in diesem Fall zu überschreiben.
|
||||
|
||||
## Beispiele
|
||||
|
||||
* CTF [https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html](https://guyinatuxedo.github.io/29-tcache/dcquals19\_babyheap/index.html)
|
||||
* **Libc-Info-Leak**: Es ist möglich, die Tcaches zu füllen, einen Chunk in die unsortierte Liste einzufügen, die Tcache zu leeren und den Chunk aus dem unsortierten Bin **erneut zuzuweisen**, wobei nur die ersten 8B überschrieben werden, wobei die **zweite Adresse zu libc aus dem Chunk intakt bleibt, sodass wir sie lesen können**.
|
||||
* **Tcache-Angriff**: Das Binärprogramm ist anfällig für einen 1B-Heap-Überlauf. Dies wird missbraucht, um den **Größen-Header** eines allokierten Chunks zu ändern und ihn größer zu machen. Dann wird dieser Chunk **freigegeben**, wodurch er der Tcache von Chunks der gefälschten Größe hinzugefügt wird. Anschließend wird ein Chunk mit der gefälschten Größe allokiert, und der vorherige Chunk wird **zurückgegeben, wobei bekannt ist, dass dieser Chunk tatsächlich kleiner war**, und dies bietet die Möglichkeit, **den nächsten Chunk im Speicher zu überschreiben**.\
|
||||
Dies wird missbraucht, um den **FD-Zeiger des nächsten Chunks zu überschreiben**, sodass er auf **`malloc_hook`** zeigt, sodass es möglich ist, 2 Zeiger zuzuweisen: zuerst den legitimen Zeiger, den wir gerade geändert haben, und dann wird die zweite Allokation einen Chunk in **`malloc_hook`** zurückgeben, den wir missbrauchen können, um ein **One-Gadget** zu schreiben.
|
||||
* **Tcache-Angriff**: Das Binärprogramm ist anfällig für einen 1B-Heap-Überlauf. Dies wird ausgenutzt, um den **Größen-Header** eines allokierten Chunks zu ändern und ihn größer zu machen. Anschließend wird dieser Chunk **freigegeben**, wodurch er der Tcache von Chunks der gefälschten Größe hinzugefügt wird. Dann wird ein Chunk mit der gefälschten Größe allokiert, und der vorherige Chunk wird **zurückgegeben, wobei bekannt ist, dass dieser Chunk tatsächlich kleiner war**, und dies bietet die Möglichkeit, den **nächsten Chunk im Speicher zu überschreiben**.\
|
||||
Dies wird ausgenutzt, um den **FD-Zeiger des nächsten Chunks zu überschreiben**, um auf **`malloc_hook`** zu zeigen, sodass es möglich ist, 2 Zeiger zu allokieren: zuerst den legitimen Zeiger, den wir gerade geändert haben, und dann wird die zweite Allokation einen Chunk in **`malloc_hook`** zurückgeben, den es möglich ist, zu missbrauchen, um ein **One-Gadget** zu schreiben.
|
||||
* CTF [https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html](https://guyinatuxedo.github.io/29-tcache/plaid19\_cpp/index.html)
|
||||
* **Libc-Info-Leak**: Es gibt ein Use-After-Free und ein Double-Free. In diesem Writeup hat der Autor eine libc-Adresse durch das Lesen der Adresse eines Chunks in einem kleinen Bin geleakt (ähnlich wie das Leaken aus dem unsortierten Bin, aber aus dem kleinen Bin).
|
||||
* **Tcache-Angriff**: Ein Tcache wird über ein **Double-Free** durchgeführt. Derselbe Chunk wird zweimal freigegeben, sodass der Chunk im Tcache auf sich selbst zeigt. Anschließend wird er allokiert, sein FD-Zeiger wird geändert, um auf den **Free-Hook** zu zeigen, und dann wird er erneut allokiert, sodass der nächste Chunk in der Liste im Free-Hook sein wird. Dann wird auch dieser allokiert, und es ist möglich, hier die Adresse von `system` zu schreiben, sodass beim Freigeben eines mallocs, das `"/bin/sh"` enthält, eine Shell erhalten wird.
|
||||
* **Libc-Info-Leak**: Es gibt ein Use-After-Free und ein Double-Free. In diesem Writeup hat der Autor eine libc-Adresse durch das Lesen der Adresse eines Chunks in einem kleinen Bin geleakt (ähnlich wie beim Leaken aus dem unsortierten Bin, aber aus dem kleinen Bin).
|
||||
* **Tcache-Angriff**: Ein Tcache wird über einen **Double-Free** durchgeführt. Derselbe Chunk wird zweimal freigegeben, sodass der Chunk im Tcache auf sich selbst zeigt. Anschließend wird er allokiert, sein FD-Zeiger wird geändert, um auf den **Free-Hook** zu zeigen, und dann wird er erneut allokiert, sodass der nächste Chunk in der Liste im Free-Hook sein wird. Dann wird auch dieser allokiert, und es ist möglich, hier die Adresse von `system` zu schreiben, sodass beim Freigeben eines mallocs, das `"/bin/sh"` enthält, eine Shell erhalten wird.
|
||||
* 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)
|
||||
* **Tcache-Index-Angriff**: Es ist möglich, einen Chunk einer Größe zu allozieren und freizugeben, sodass beim Speichern der Informationen im Tcache-Info eine **Position mit dem Wert 0x100** generiert wird (weil das Byte, das anzeigt, wie viele Chunks in diesem Index gespeichert sind, dies angibt). Dann ist es möglich, diese Adresse freizugeben, da sie wie ein Chunk der Größe 0x100 aussieht. Dies fügt diese Adresse dem Index der Chunks der Größe 0x100 im Tcache hinzu.\
|
||||
Anschließend, durch Allokation eines Chunks der Größe 0x100, ist es möglich, die Anfangsadresse eines anderen Tcache-Index zu überschreiben. Wenn beispielsweise die Adresse des malloc-Hooks in einem von ihnen platziert wird und ein Chunk der Größe dieses Index allokiert wird, wird ein Chunk im calloc-Hook gewährt, was es ermöglicht, ein One-Gadget zu schreiben, um eine Shell zu erhalten.
|
||||
* Die Hauptlücke hier besteht darin, dass es möglich ist, eine Adresse im Heap durch Angabe ihres Offsets zu `free`.
|
||||
* **Tcache-Index-Angriff**: Es ist möglich, einen Chunk einer Größe zu allozieren und freizugeben, sodass beim Speichern im Tcache-Chunk (dem Chunk mit den Informationen der Tcache-Bins) eine **Adresse mit dem Wert 0x100** generiert wird. Dies liegt daran, dass der Tcache die Anzahl der Chunks in jedem Bin in verschiedenen Bytes speichert, sodass ein Chunk in einem bestimmten Index den Wert 0x100 generiert.
|
||||
* Dann sieht es so aus, als ob es einen Chunk der Größe 0x100 gibt. Dies ermöglicht es, diesen durch `free` zu missbrauchen. Dies wird **diese Adresse dem Index der Chunks der Größe 0x100 im Tcache hinzufügen**.
|
||||
* Dann wird ein Chunk der Größe **0x100 allokiert**, und die vorherige Adresse wird als Chunk zurückgegeben, was es ermöglicht, andere Tcache-Indizes zu überschreiben.\
|
||||
Indem beispielsweise die Adresse des malloc-Hooks in einen von ihnen platziert wird und ein Chunk der Größe dieses Index allokiert wird, wird ein Chunk im calloc-Hook gewährt, was das Schreiben eines One-Gadgets ermöglicht, um eine Shell zu erhalten.
|
||||
* 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)
|
||||
* Derselbe Schwachpunkt wie zuvor mit einer zusätzlichen Einschränkung
|
||||
* **Tcache-Index-Angriff**: Ähnlicher Angriff wie der vorherige, jedoch mit weniger Schritten, indem der **Chunk freigegeben wird, der die Tcache-Informationen enthält**, sodass seine Adresse dem Tcache-Index seiner Größe hinzugefügt wird, sodass es möglich ist, diese Größe zu allozieren und die Tcache-Chunk-Informationen als Chunk zu erhalten, was es ermöglicht, den Free-Hook als Adresse eines Index hinzuzufügen, ihn zu allozieren und ein One-Gadget darauf zu schreiben.
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Erlernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Erlernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Andere Möglichkeiten, HackTricks zu unterstützen:
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue