Basic Binary Exploitation Methodology

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

Altri modi per supportare HackTricks:

• Se vuoi vedere la tua azienda pubblicizzata in HackTricks o scaricare HackTricks in PDF Controlla i PIANI DI ABBONAMENTO!

• Ottieni il merchandising ufficiale di PEASS & HackTricks

• Scopri La Famiglia PEASS, la nostra collezione di NFT esclusivi

• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.

• Condividi i tuoi trucchi di hacking inviando PR a HackTricks e HackTricks Cloud repos di github.

Informazioni di base su ELF

Prima di iniziare a sfruttare qualsiasi cosa, è interessante comprendere parte della struttura di un binario ELF:

pageELF Basic Information

Strumenti di exploitazione

pageExploiting Tools

Metodologia dello stack overflow

Con così tante tecniche è utile avere uno schema in cui ogni tecnica sarà utile. Nota che le stesse protezioni influenzeranno tecniche diverse. È possibile trovare modi per aggirare le protezioni in ciascuna sezione di protezione ma non in questa metodologia.

Controllo del flusso

Ci sono diversi modi in cui potresti finire per controllare il flusso di un programma:

• Stack Overflows sovrascrivendo il puntatore di ritorno dallo stack o l'EBP -> ESP -> EIP.

• Potrebbe essere necessario abusare di un Integer Overflows per causare l'overflow

• Oppure tramite Scritture Arbitrarie + Scrivi Cosa Dove all'Esecuzione

• Stringhe di formato: Abusare di printf per scrivere contenuti arbitrari in indirizzi arbitrari.

• Indicizzazione di array: Abusare di un'indicizzazione mal progettata per poter controllare alcuni array e ottenere una scrittura arbitraria.

• Potrebbe essere necessario abusare di un Integer Overflows per causare l'overflow

• bof to WWW via ROP: Abusare di un buffer overflow per costruire un ROP e poter ottenere un WWW.

È possibile trovare le tecniche di Scrivi Cosa Dove all'Esecuzione in:

urlhttps://github.com/HackTricks-wiki/hacktricks/blob/it/binary-exploitation/arbitrary-write-2-exec/README.md

Loop eterni

Qualcosa da tenere in considerazione è che di solito un solo sfruttamento di una vulnerabilità potrebbe non essere sufficiente per eseguire con successo un exploit, specialmente se alcune protezioni devono essere aggirate. Pertanto, è interessante discutere alcune opzioni per rendere una singola vulnerabilità sfruttabile più volte nella stessa esecuzione del binario:

• Scrivere in una catena ROP l'indirizzo della funzione main o all'indirizzo in cui si verifica la vulnerabilità.

• Controllando una corretta catena ROP potresti essere in grado di eseguire tutte le azioni in quella catena

• Scrivere nell'indirizzo exit in GOT (o in qualsiasi altra funzione utilizzata dal binario prima della fine) l'indirizzo per tornare alla vulnerabilità

• Come spiegato in .fini_array, memorizzare qui 2 funzioni, una per richiamare nuovamente la vulnerabilità e un'altra per richiamare**__libc_csu_fini** che richiamerà nuovamente la funzione da .fini_array.

Obiettivi dell'exploit

Obiettivo: Chiamare una funzione esistente

• ret2win: C'è una funzione nel codice che devi chiamare (forse con alcuni parametri specifici) per ottenere la flag.

• In un bof regolare senza PIE e canary devi solo scrivere l'indirizzo nell'indirizzo di ritorno memorizzato nello stack.

• In un bof con PIE, dovrai aggirarlo

• In un bof con canary, dovrai aggirarlo

• Se è necessario impostare diversi parametri per chiamare correttamente la funzione ret2win puoi usare:

• Una catena ROP se ci sono abbastanza gadget per preparare tutti i parametri

• SROP (nel caso in cui puoi chiamare questa syscall) per controllare molti registri

• Gadget da ret2csu e ret2vdso per controllare diversi registri

• Attraverso un Scrivi Cosa Dove potresti abusare di altre vulnerabilità (non bof) per chiamare la funzione win.

• Reindirizzamento dei puntatori: Nel caso lo stack contenga puntatori a una funzione che verrà chiamata o a una stringa che verrà utilizzata da una funzione interessante (system o printf), è possibile sovrascrivere quell'indirizzo.

• ASLR o PIE potrebbero influenzare gli indirizzi.

• Variabili non inizializzate: Non si sa mai.

Obiettivo: RCE

Tramite shellcode, se nx disabilitato o mescolando shellcode con ROP:

• (Stack) Shellcode: Questo è utile per memorizzare uno shellcode nello stack prima o dopo la sovrascrittura del puntatore di ritorno e quindi saltare ad esso per eseguirlo:

• In ogni caso, se c'è un canary, in un bof regolare dovrai aggirarlo (leak)

• Senza ASLR e nx è possibile saltare all'indirizzo dello stack poiché non cambierà mai

• Con ASLR dovrai utilizzare tecniche come ret2esp/ret2reg per saltarci

• Con nx, dovrai utilizzare alcuni ROP per chiamare memprotect e rendere alcune pagine rwx, per poi memorizzare lo shellcode lì (chiamando ad esempio read) e poi saltare lì.

• Questo mescolerà lo shellcode con una catena ROP.

Attraverso le syscalls

• Ret2syscall: Utile per chiamare execve per eseguire comandi arbitrari. È necessario essere in grado di trovare i gadget per chiamare la specifica syscall con i parametri.

• Se ASLR o PIE sono abilitati, sarà necessario sconfiggerli per utilizzare i gadget ROP dal binario o dalle librerie.

• SROP può essere utile per preparare il ret2execve

• Gadget da ret2csu e ret2vdso per controllare diversi registri

Attraverso libc

• Ret2lib: Utile per chiamare una funzione da una libreria (di solito da libc) come system con alcuni argomenti preparati (ad es. '/bin/sh'). È necessario che il binario carichi la libreria con la funzione che si desidera chiamare (di solito libc).

• Se compilato staticamente e senza PIE, l'indirizzo di system e /bin/sh non cambieranno, quindi è possibile utilizzarli staticamente.

• Senza ASLR e conoscendo la versione di libc caricata, l'indirizzo di system e /bin/sh non cambieranno, quindi è possibile utilizzarli staticamente.

• Con ASLR ma senza PIE, conoscendo la libc e con il binario che utilizza la funzione system è possibile ret all'indirizzo di system nel GOT con l'indirizzo di '/bin/sh' nei parametri (bisognerà capire questo).

• Con ASLR ma senza PIE, conoscendo la libc e senza che il binario utilizzi il system:

• Utilizzare ret2dlresolve per risolvere l'indirizzo di system e chiamarlo

• Eludere ASLR e calcolare l'indirizzo di system e '/bin/sh' in memoria.

• Con ASLR e PIE e senza conoscere la libc: È necessario:

• Eludere PIE

• Trovare la versione di libc utilizzata (effettuare un leak di un paio di indirizzi di funzione)

• Controllare i scenari precedenti con ASLR per continuare.

Attraverso EBP/RBP

• Stack Pivoting / EBP2Ret / EBP Chaining: Controllare l'ESP per controllare RET attraverso l'EBP memorizzato nello stack.

• Utile per overflow dello stack di uno

• Utile come modo alternativo per controllare EIP mentre si abusa di EIP per costruire il payload in memoria e quindi saltare ad esso tramite EBP

Varie

• Riorientamento dei puntatori: Nel caso in cui lo stack contenga puntatori a una funzione che verrà chiamata o a una stringa che verrà utilizzata da una funzione interessante (system o printf), è possibile sovrascrivere quell'indirizzo.

• ASLR o PIE potrebbero influenzare gli indirizzi.

• Variabili non inizializzate: Non si sa mai