mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
90 lines
6.1 KiB
Markdown
90 lines
6.1 KiB
Markdown
# WWW2Exec - GOT/PLT
|
|
|
|
{{#include ../../banners/hacktricks-training.md}}
|
|
|
|
## **Informazioni di Base**
|
|
|
|
### **GOT: Tabella degli Offset Globale**
|
|
|
|
La **Tabella degli Offset Globale (GOT)** è un meccanismo utilizzato nei binari collegati dinamicamente per gestire gli **indirizzi delle funzioni esterne**. Poiché questi **indirizzi non sono noti fino al runtime** (a causa del collegamento dinamico), la GOT fornisce un modo per **aggiornare dinamicamente gli indirizzi di questi simboli esterni** una volta risolti.
|
|
|
|
Ogni voce nella GOT corrisponde a un simbolo nelle librerie esterne che il binario può chiamare. Quando una **funzione viene chiamata per la prima volta, il suo indirizzo effettivo viene risolto dal linker dinamico e memorizzato nella GOT**. Le chiamate successive alla stessa funzione utilizzano l'indirizzo memorizzato nella GOT, evitando così il sovraccarico di risolvere nuovamente l'indirizzo.
|
|
|
|
### **PLT: Tabella di Collegamento delle Procedure**
|
|
|
|
La **Tabella di Collegamento delle Procedure (PLT)** lavora a stretto contatto con la GOT e funge da trampolino per gestire le chiamate a funzioni esterne. Quando un binario **chiama una funzione esterna per la prima volta, il controllo viene passato a un'entrata nella PLT associata a quella funzione**. Questa voce PLT è responsabile dell'invocazione del linker dinamico per risolvere l'indirizzo della funzione se non è già stato risolto. Dopo che l'indirizzo è stato risolto, viene memorizzato nella **GOT**.
|
|
|
|
**Pertanto,** le voci GOT vengono utilizzate direttamente una volta che l'indirizzo di una funzione o variabile esterna è stato risolto. **Le voci PLT vengono utilizzate per facilitare la risoluzione iniziale** di questi indirizzi tramite il linker dinamico.
|
|
|
|
## Ottenere Esecuzione
|
|
|
|
### Controlla la GOT
|
|
|
|
Ottieni l'indirizzo della tabella GOT con: **`objdump -s -j .got ./exec`**
|
|
|
|
.png>)
|
|
|
|
Osserva come dopo **il caricamento** dell'**eseguibile** in GEF puoi **vedere** le **funzioni** che sono nella **GOT**: `gef➤ x/20x 0xADDR_GOT`
|
|
|
|
 (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>)
|
|
|
|
Utilizzando GEF puoi **iniziare** una sessione di **debugging** ed eseguire **`got`** per vedere la tabella got:
|
|
|
|
.png>)
|
|
|
|
### GOT2Exec
|
|
|
|
In un binario la GOT ha gli **indirizzi delle funzioni o** della **sezione PLT** che caricherà l'indirizzo della funzione. L'obiettivo di questa scrittura arbitraria è **sovrascrivere una voce GOT** di una funzione che verrà eseguita successivamente **con** l'**indirizzo** della PLT della **funzione** **`system`** ad esempio.
|
|
|
|
Idealmente, dovresti **sovrascrivere** la **GOT** di una **funzione** che verrà **chiamata con parametri controllati da te** (quindi sarai in grado di controllare i parametri inviati alla funzione di sistema).
|
|
|
|
Se **`system`** **non è utilizzato** dal binario, la funzione di sistema **non avrà** un'entrata nella PLT. In questo scenario, dovrai **prima fare leak dell'indirizzo** della funzione `system` e poi sovrascrivere la GOT per puntare a questo indirizzo.
|
|
|
|
Puoi vedere gli indirizzi PLT con **`objdump -j .plt -d ./vuln_binary`**
|
|
|
|
## Voci GOT di libc
|
|
|
|
La **GOT di libc** è solitamente compilata con **RELRO parziale**, rendendola un buon obiettivo per questo supponendo sia possibile capire il suo indirizzo ([**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)).
|
|
|
|
Le funzioni comuni di libc chiameranno **altre funzioni interne** le cui GOT potrebbero essere sovrascritte per ottenere l'esecuzione del codice.
|
|
|
|
Trova [**maggiori informazioni su questa tecnica qui**](https://github.com/nobodyisnobody/docs/blob/main/code.execution.on.last.libc/README.md#1---targetting-libc-got-entries).
|
|
|
|
### **Free2system**
|
|
|
|
Nelle CTF di sfruttamento dell'heap è comune poter controllare il contenuto dei chunk e a un certo punto persino sovrascrivere la tabella GOT. Un trucco semplice per ottenere RCE se i gadget non sono disponibili è sovrascrivere l'indirizzo GOT di `free` per puntare a `system` e scrivere all'interno di un chunk `"/bin/sh"`. In questo modo, quando questo chunk viene liberato, eseguirà `system("/bin/sh")`.
|
|
|
|
### **Strlen2system**
|
|
|
|
Un'altra tecnica comune è sovrascrivere l'indirizzo GOT di **`strlen`** per puntare a **`system`**, quindi se questa funzione viene chiamata con input dell'utente è possibile passare la stringa `"/bin/sh"` e ottenere una shell.
|
|
|
|
Inoltre, se `puts` viene utilizzato con input dell'utente, è possibile sovrascrivere l'indirizzo GOT di `strlen` per puntare a `system` e passare la stringa `"/bin/sh"` per ottenere una shell perché **`puts` chiamerà `strlen` con l'input dell'utente**.
|
|
|
|
## **One Gadget**
|
|
|
|
{{#ref}}
|
|
../rop-return-oriented-programing/ret2lib/one-gadget.md
|
|
{{#endref}}
|
|
|
|
## **Abusare della GOT dall'Heap**
|
|
|
|
Un modo comune per ottenere RCE da una vulnerabilità dell'heap è abusare di un fastbin in modo da poter aggiungere la parte della tabella GOT nel fast bin, quindi ogni volta che quel chunk viene allocato sarà possibile **sovrascrivere il puntatore di una funzione, di solito `free`**.\
|
|
Poi, puntando `free` a `system` e liberando un chunk dove è stato scritto `/bin/sh\x00` eseguirà una shell.
|
|
|
|
È possibile trovare un [**esempio qui**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/chunk_extend_overlapping/#hitcon-trainging-lab13)**.**
|
|
|
|
## **Protezioni**
|
|
|
|
La protezione **Full RELRO** è progettata per proteggere contro questo tipo di tecnica risolvendo tutti gli indirizzi delle funzioni quando il binario viene avviato e rendendo la **tabella GOT di sola lettura** dopo:
|
|
|
|
{{#ref}}
|
|
../common-binary-protections-and-bypasses/relro.md
|
|
{{#endref}}
|
|
|
|
## Riferimenti
|
|
|
|
- [https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite](https://ir0nstone.gitbook.io/notes/types/stack/got-overwrite/exploiting-a-got-overwrite)
|
|
- [https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook](https://ir0nstone.gitbook.io/notes/types/stack/one-gadgets-and-malloc-hook)
|
|
|
|
{{#include ../../banners/hacktricks-training.md}}
|