Translated ['src/network-services-pentesting/5353-udp-multicast-dns-mdns

2025-10-10 18:36:50 +00:00 · 2025-08-20 14:37:56 +00:00 · 2025-08-20 14:37:56 +00:00 · 6a87ed0cfe
commit 6a87ed0cfe
parent 6e884bd5d7
2 changed files with 97 additions and 45 deletions
--- a/src/network-services-pentesting/5353-udp-multicast-dns-mdns.md
+++ b/src/network-services-pentesting/5353-udp-multicast-dns-mdns.md
@ -66,14 +66,14 @@ Esempio con Pholus:
 # Block new devices from taking names by auto-faking responses
 sudo python3 pholus3.py <iface> -afre -stimeout 1000
 ```
-### Service spoofing and impersonation (MitM)
+### Spoofing e impersonificazione del servizio (MitM)

 Impersonare i servizi DNS-SD pubblicizzati (stampanti, AirPlay, HTTP, condivisioni di file) per costringere i client a connettersi a te. Questo è particolarmente utile per:
- Catturare documenti simulando _ipp._tcp o _printer._tcp.
+- Catturare documenti spoofando _ipp._tcp o _printer._tcp.
 - Attirare i client verso servizi HTTP/HTTPS per raccogliere token/cookie o consegnare payload.
- Combinare con tecniche di relay NTLM quando i client Windows negoziano l'autenticazione con servizi falsificati.
+- Combinare con tecniche di relay NTLM quando i client Windows negoziano l'autenticazione con servizi spoofati.

-Con il modulo zerogod di bettercap (mDNS/DNS-SD spoofer/impersonator):
+Con il modulo zerogod di bettercap (spoofatore/impostore mDNS/DNS-SD):
 ```bash
 # Start mDNS/DNS-SD discovery
 sudo bettercap -iface <iface> -eval "zerogod.discovery on"
@ -105,18 +105,18 @@ Anche vedere le metodologie generiche di spoofing LLMNR/NBNS/mDNS/WPAD e flussi

 ## Considerazioni difensive e OPSEC

- Confini di segmento: Non instradare 224.0.0.251/FF02::FB tra zone di sicurezza a meno che un gateway mDNS non sia esplicitamente richiesto. Se devi collegare la scoperta, preferisci le liste di autorizzazione e i limiti di frequenza.
+- Confini di segmento: Non instradare 224.0.0.251/FF02::FB tra le zone di sicurezza a meno che un gateway mDNS non sia esplicitamente richiesto. Se devi collegare la scoperta, preferisci le liste di autorizzazione e i limiti di frequenza.
 - Endpoint/server Windows:
 - Per disabilitare completamente la risoluzione dei nomi tramite mDNS, imposta il valore del registro e riavvia:
 ```
 HKLM\SYSTEM\CurrentControlSet\Services\Dnscache\Parameters\EnableMDNS = 0 (DWORD)
 ```
- In ambienti gestiti, disabilita la regola del firewall di Windows Defender “mDNS (UDP-In)” integrata (almeno sul profilo di dominio) per prevenire l'elaborazione mDNS in entrata mantenendo la funzionalità di home/roaming.
+- Negli ambienti gestiti, disabilita la regola del firewall di Windows Defender “mDNS (UDP-In)” (almeno sul profilo di dominio) per prevenire l'elaborazione mDNS in entrata mantenendo la funzionalità di home/roaming.
 - Su versioni più recenti di Windows 11/temi GPO, utilizza la policy “Configurazione computer > Modelli amministrativi > Rete > Client DNS > Configura il protocollo DNS multicast (mDNS)” e impostala su Disabilitato.
 - Linux (Avahi):
 - Limita la pubblicazione quando non necessaria: imposta `disable-publishing=yes` e restringi le interfacce con `allow-interfaces=` / `deny-interfaces=` in `/etc/avahi/avahi-daemon.conf`.
- Considera `check-response-ttl=yes` e evita `enable-reflector=yes` a meno che non sia strettamente necessario; preferisci le liste di autorizzazione `reflect-filters=` quando rifletti.
- macOS: Limita l'inbound mDNS nei firewall host/rete quando la scoperta Bonjour non è necessaria per subnet specifiche.
+- Considera `check-response-ttl=yes` ed evita `enable-reflector=yes` a meno che non sia strettamente necessario; preferisci le liste di autorizzazione `reflect-filters=` quando rifletti.
+- macOS: Limita l'mDNS in entrata nei firewall host/rete quando la scoperta Bonjour non è necessaria per subnet specifiche.
 - Monitoraggio: Allerta su picchi insoliti nelle query `_services._dns-sd._udp.local` o cambiamenti improvvisi in SRV/TXT di servizi critici; questi sono indicatori di spoofing o impersonificazione del servizio.

 ## Riferimenti rapidi agli strumenti
--- a/src/pentesting-web/deserialization/README.md
+++ b/src/pentesting-web/deserialization/README.md
@ -1,12 +1,12 @@
-# Deserializzazione
+# Deserialization

 {{#include ../../banners/hacktricks-training.md}}

-## Informazioni di base
+## Basic Information

-**La serializzazione** è intesa come il metodo di conversione di un oggetto in un formato che può essere preservato, con l'intento di memorizzare l'oggetto o trasmetterlo come parte di un processo di comunicazione. Questa tecnica è comunemente impiegata per garantire che l'oggetto possa essere ricreato in un secondo momento, mantenendo la sua struttura e stato.
+**Serialization** è intesa come il metodo di conversione di un oggetto in un formato che può essere preservato, con l'intento di memorizzare l'oggetto o trasmetterlo come parte di un processo di comunicazione. Questa tecnica è comunemente impiegata per garantire che l'oggetto possa essere ricreato in un secondo momento, mantenendo la sua struttura e stato.

-**La deserializzazione**, al contrario, è il processo che contrasta la serializzazione. Comporta il prendere dati che sono stati strutturati in un formato specifico e ricostruirli nuovamente in un oggetto.
+**Deserialization**, al contrario, è il processo che contrasta la serializzazione. Comporta il prendere dati che sono stati strutturati in un formato specifico e ricostruirli nuovamente in un oggetto.

 La deserializzazione può essere pericolosa perché **consente potenzialmente agli attaccanti di manipolare i dati serializzati per eseguire codice dannoso** o causare comportamenti imprevisti nell'applicazione durante il processo di ricostruzione dell'oggetto.

@ -14,11 +14,11 @@ La deserializzazione può essere pericolosa perché **consente potenzialmente ag

 In PHP, specifici metodi magici sono utilizzati durante i processi di serializzazione e deserializzazione:

- `__sleep`: Invocato quando un oggetto viene serializzato. Questo metodo dovrebbe restituire un array dei nomi di tutte le proprietà dell'oggetto che devono essere serializzate. È comunemente usato per impegnare dati in sospeso o eseguire compiti di pulizia simili.
+- `__sleep`: Invocato quando un oggetto viene serializzato. Questo metodo dovrebbe restituire un array dei nomi di tutte le proprietà dell'oggetto che dovrebbero essere serializzate. È comunemente usato per impegnare dati in sospeso o eseguire compiti di pulizia simili.
 - `__wakeup`: Chiamato quando un oggetto viene deserializzato. Viene utilizzato per ristabilire eventuali connessioni al database che potrebbero essere state perse durante la serializzazione e per eseguire altri compiti di reinizializzazione.
 - `__unserialize`: Questo metodo viene chiamato invece di `__wakeup` (se esiste) quando un oggetto viene deserializzato. Fornisce un maggiore controllo sul processo di deserializzazione rispetto a `__wakeup`.
 - `__destruct`: Questo metodo viene chiamato quando un oggetto sta per essere distrutto o quando lo script termina. È tipicamente usato per compiti di pulizia, come la chiusura di handle di file o connessioni al database.
- `__toString`: Questo metodo consente a un oggetto di essere trattato come una stringa. Può essere utilizzato per leggere un file o altri compiti basati sulle chiamate di funzione al suo interno, fornendo efficacemente una rappresentazione testuale dell'oggetto.
+- `__toString`: Questo metodo consente a un oggetto di essere trattato come una stringa. Può essere utilizzato per leggere un file o altri compiti basati sulle chiamate di funzione al suo interno, fornendo effettivamente una rappresentazione testuale dell'oggetto.
 ```php
 <?php
 class test {
@ -77,7 +77,7 @@ This is a test<br />
 Se guardi i risultati, puoi vedere che le funzioni **`__wakeup`** e **`__destruct`** vengono chiamate quando l'oggetto viene deserializzato. Nota che in diversi tutorial troverai che la funzione **`__toString`** viene chiamata quando si cerca di stampare un attributo, ma apparentemente **non sta più accadendo**.

 > [!WARNING]
-> Il metodo **`__unserialize(array $data)`** viene chiamato **invece di `__wakeup()`** se è implementato nella classe. Ti consente di deserializzare l'oggetto fornendo i dati serializzati come array. Puoi utilizzare questo metodo per deserializzare le proprietà e svolgere eventuali compiti necessari al momento della deserializzazione.
+> Il metodo **`__unserialize(array $data)`** viene chiamato **invece di `__wakeup()`** se è implementato nella classe. Ti consente di deserializzare l'oggetto fornendo i dati serializzati come un array. Puoi utilizzare questo metodo per deserializzare le proprietà e svolgere eventuali compiti necessari al momento della deserializzazione.
 >
 > ```php
 > class MyClass {
@ -137,7 +137,7 @@ $object = unserialize($userControlledData, [
 ```
 Se **`allowed_classes` è omesso _o_ il codice viene eseguito su PHP < 7.0**, la chiamata diventa **pericolosa** poiché un attaccante può creare un payload che sfrutta metodi magici come `__wakeup()` o `__destruct()` per ottenere l'Esecuzione Remota di Codice (RCE).

-#### Esempio del mondo reale: Everest Forms (WordPress) CVE-2025-52709
+#### Esempio reale: Everest Forms (WordPress) CVE-2025-52709

 Il plugin WordPress **Everest Forms ≤ 3.2.2** ha cercato di essere difensivo con un wrapper di supporto ma ha dimenticato le versioni legacy di PHP:
 ```php
@ -197,7 +197,7 @@ print(base64.b64encode(pickle.dumps(P())))
 ```
 Prima di controllare la tecnica di bypass, prova a usare `print(base64.b64encode(pickle.dumps(P(),2)))` per generare un oggetto compatibile con python2 se stai eseguendo python3.

-Per ulteriori informazioni su come evadere dalle **pickle jails** controlla:
+Per ulteriori informazioni su come evadere da **pickle jails** controlla:

 {{#ref}}
 ../../generic-methodologies-and-resources/python/bypass-python-sandboxes/
@ -222,7 +222,7 @@ python-yaml-deserialization.md
 ### JS Magic Functions

 JS **non ha funzioni "magiche"** come PHP o Python che vengono eseguite solo per creare un oggetto. Ma ha alcune **funzioni** che sono **frequentemente usate anche senza chiamarle direttamente** come **`toString`**, **`valueOf`**, **`toJSON`**.\
-Se abusando di una deserializzazione puoi **compromettere queste funzioni per eseguire altro codice** (potenzialmente abusando delle inquinamenti del prototipo) potresti eseguire codice arbitrario quando vengono chiamate.
+Se abusando di una deserializzazione puoi **compromettere queste funzioni per eseguire altro codice** (potenzialmente abusando delle inquinamenti di prototipo) potresti eseguire codice arbitrario quando vengono chiamate.

 Un altro **modo "magico" per chiamare una funzione** senza chiamarla direttamente è **compromettendo un oggetto restituito da una funzione async** (promise). Perché, se **trasformi** quell'**oggetto di ritorno** in un'altra **promise** con una **proprietà** chiamata **"then" di tipo funzione**, verrà **eseguito** solo perché è restituito da un'altra promise. _Segui_ [_**questo link**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _per ulteriori informazioni._
 ```javascript
@ -248,7 +248,7 @@ test_ressolve()
 test_then()
 //For more info: https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/
 ```
-### `__proto__` e inquinamento di `prototype`
+### `__proto__` e inquinamento del `prototype`

 Se vuoi imparare su questa tecnica **dai un'occhiata al seguente tutorial**:

@ -356,7 +356,7 @@ deserialize(test)
 ```
 **Per**[ **maggiori informazioni leggi questa fonte**](https://www.acunetix.com/blog/web-security-zone/deserialization-vulnerabilities-attacking-deserialization-in-js/)**.**

-### Cryo library
+### Libreria Cryo

 Nelle pagine seguenti puoi trovare informazioni su come abusare di questa libreria per eseguire comandi arbitrari:

@ -367,7 +367,7 @@ Nelle pagine seguenti puoi trovare informazioni su come abusare di questa librer

 In Java, **i callback di deserializzazione vengono eseguiti durante il processo di deserializzazione**. Questa esecuzione può essere sfruttata da attaccanti che creano payload dannosi che attivano questi callback, portando a potenziali esecuzioni di azioni dannose.

-### Fingerprints
+### Impronte

 #### White Box

@ -394,7 +394,7 @@ Per il testing black box, cerca specifiche **firme o "Magic Bytes"** che denotan
 - Intestazioni di risposta HTTP con `Content-type` impostato su `application/x-java-serialized-object`.
 - Modello esadecimale che indica una compressione precedente: `1F 8B 08 00`.
 - Modello Base64 che indica una compressione precedente: `H4sIA`.
- File web con estensione `.faces` e il parametro `faces.ViewState`. Scoprire questi modelli in un'applicazione web dovrebbe indurre a un esame come dettagliato nel [post sulla deserializzazione di Java JSF ViewState](java-jsf-viewstate-.faces-deserialization.md).
+- File web con estensione `.faces` e il parametro `faces.ViewState`. Scoprire questi modelli in un'applicazione web dovrebbe indurre a un esame come dettagliato nel [post sulla Deserializzazione del ViewState di Java JSF](java-jsf-viewstate-.faces-deserialization.md).
 ```
 javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
 ```
@ -411,11 +411,11 @@ grep -R InvokeTransformer .
 ```
 Potresti provare a **controllare tutte le librerie** note per essere vulnerabili e per le quali [**Ysoserial**](https://github.com/frohoff/ysoserial) può fornire un exploit. Oppure potresti controllare le librerie indicate su [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json).\
 Puoi anche usare [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) per cercare possibili catene di gadget che possono essere sfruttate.\
-Quando esegui **gadgetinspector** (dopo averlo costruito), non preoccuparti dei tonnellate di avvisi/errori che sta attraversando e lascialo finire. Scriverà tutti i risultati sotto _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_. Si prega di notare che **gadgetinspector non creerà un exploit e potrebbe indicare falsi positivi**.
+Quando esegui **gadgetinspector** (dopo averlo costruito) non preoccuparti dei tonnellate di avvisi/errori che sta attraversando e lascialo finire. Scriverà tutti i risultati sotto _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_. Si prega di notare che **gadgetinspector non creerà un exploit e potrebbe indicare falsi positivi**.

 #### Test Black Box

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

@ -507,7 +507,7 @@ generate('Linux', 'ping -c 1 nix.REPLACE.server.local')
 ```
 #### serialkillerbypassgadgets

-Puoi **usare** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **insieme a ysoserial per creare più exploit**. Maggiori informazioni su questo strumento nelle **diapositive del talk** in cui è stato presentato: [https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1](https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1)
+Puoi **usare** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **insieme a ysoserial per creare più exploit**. Maggiori informazioni su questo strumento nelle **diapositive del talk** in cui lo strumento è stato presentato: [https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1](https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1)

 #### marshalsec

@ -545,9 +545,9 @@ Leggi di più su questa libreria Java JSON: [https://www.alphabot.com/security/b

 Java utilizza molto la serializzazione per vari scopi come:

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

@ -637,7 +637,8 @@ ObjectInputFilter.Config.setSerialFilter(filter);
 - [https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr](https://dzone.com/articles/why-runtime-compartmentalization-is-the-most-compr)
 - [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
 - [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
- Deserializzazioni CVE: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
+- Deserializzazione Java e .Net **documento:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
+- CVE di deserializzazione: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)

 ## Iniezione JNDI & log4Shell

@ -649,7 +650,7 @@ jndi-java-naming-and-directory-interface-and-log4shell.md

 ## JMS - Java Message Service

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

 ### Prodotti

@ -661,7 +662,7 @@ Ci sono diversi prodotti che utilizzano questo middleware per inviare messaggi:

 ### Sfruttamento

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

 Dovresti ricordare che anche se un servizio è vulnerabile (perché deserializza in modo insicuro l'input dell'utente) devi comunque trovare gadget validi per sfruttare la vulnerabilità.
@ -692,7 +693,7 @@ L'attenzione dovrebbe essere rivolta ai serializer che consentono di determinare

 #### BlackBox

-La ricerca dovrebbe mirare alla stringa codificata in Base64 **AAEAAAD/////** o a qualsiasi modello simile che potrebbe subire deserializzazione sul lato server, concedendo il controllo sul tipo da deserializzare. Questo potrebbe includere, ma non è limitato a, strutture **JSON** o **XML** con `TypeObject` o `$type`.
+La ricerca dovrebbe mirare alla stringa codificata in Base64 **AAEAAAD/////** o a qualsiasi schema simile che potrebbe subire deserializzazione sul lato server, concedendo il controllo sul tipo da deserializzare. Questo potrebbe includere, ma non è limitato a, strutture **JSON** o **XML** con `TypeObject` o `$type`.

 ### ysoserial.net

@ -703,7 +704,7 @@ Se vuoi sapere **come ysoserial.net crea il suo exploit** puoi [**controllare qu
 Le principali opzioni di **ysoserial.net** sono: **`--gadget`**, **`--formatter`**, **`--output`** e **`--plugin`.**

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

@ -747,7 +748,7 @@ Debugging.ShowErrors(inputArgs, err);
 }
 }
 ```
-Questo significa che per testare l'exploit, il codice chiamerà [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539)
+Questo significa che, per testare l'exploit, il codice chiamerà [serializersHelper.JsonNet_deserialize](https://github.com/pwntester/ysoserial.net/blob/c53bd83a45fb17eae60ecc82f7147b5c04b07e42/ysoserial/Helpers/SerializersHelper.cs#L539)
 ```java
 public static object JsonNet_deserialize(string str)
 {
@ -759,27 +760,27 @@ return obj;
 }
 ```
 Nel **codice precedente è vulnerabile all'exploit creato**. Quindi, se trovi qualcosa di simile in un'applicazione .Net, significa che probabilmente anche quell'applicazione è vulnerabile.\
-Pertanto, il parametro **`--test`** ci consente di capire **quali parti di codice sono vulnerabili** all'exploit di deserializzazione che **ysoserial.net** può creare.
+Pertanto, il **`--test`** parametro ci consente di capire **quali parti di codice sono vulnerabili** all'exploit di deserializzazione che **ysoserial.net** può creare.

 ### ViewState

 Dai un'occhiata a [questo POST su **come provare a sfruttare il parametro \_\_ViewState di .Net**](exploiting-__viewstate-parameter.md) per **eseguire codice arbitrario.** Se **conosci già i segreti** utilizzati dalla macchina vittima, [**leggi questo post per sapere come eseguire codice**](exploiting-__viewstate-knowing-the-secret.md)**.**

-### Prevenzione
+### Prevention

 Per mitigare i rischi associati alla deserializzazione in .Net:

 - **Evitare di consentire ai flussi di dati di definire i propri tipi di oggetto.** Utilizzare `DataContractSerializer` o `XmlSerializer` quando possibile.
 - **Per `JSON.Net`, impostare `TypeNameHandling` su `None`:** `TypeNameHandling = TypeNameHandling.None`
 - **Evitare di utilizzare `JavaScriptSerializer` con un `JavaScriptTypeResolver`.**
- **Limitare i tipi che possono essere deserializzati**, comprendendo i rischi intrinseci con i tipi .Net, come `System.IO.FileInfo`, che possono modificare le proprietà dei file del server, portando potenzialmente ad attacchi di denial of service.
+- **Limitare i tipi che possono essere deserializzati**, comprendendo i rischi intrinseci con i tipi .Net, come `System.IO.FileInfo`, che possono modificare le proprietà dei file del server, portando potenzialmente a attacchi di denial of service.
 - **Essere cauti con i tipi che hanno proprietà rischiose**, come `System.ComponentModel.DataAnnotations.ValidationException` con la sua proprietà `Value`, che può essere sfruttata.
 - **Controllare in modo sicuro l'istanza dei tipi** per prevenire che gli attaccanti influenzino il processo di deserializzazione, rendendo vulnerabili anche `DataContractSerializer` o `XmlSerializer`.
 - **Implementare controlli di white list** utilizzando un `SerializationBinder` personalizzato per `BinaryFormatter` e `JSON.Net`.
 - **Rimanere informati sui gadget di deserializzazione insicuri noti** all'interno di .Net e assicurarsi che i deserializzatori non istanzino tali tipi.
 - **Isolare il codice potenzialmente rischioso** dal codice con accesso a Internet per evitare di esporre gadget noti, come `System.Windows.Data.ObjectDataProvider` nelle applicazioni WPF, a fonti di dati non attendibili.

-### **Riferimenti**
+### **References**

 - Documento sulla deserializzazione JSON di Java e .Net **: [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** talk: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) e slide: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
 - [https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html#net-csharp)
@ -790,7 +791,7 @@ Per mitigare i rischi associati alla deserializzazione in .Net:

 In Ruby, la serializzazione è facilitata da due metodi all'interno della libreria **marshal**. Il primo metodo, noto come **dump**, viene utilizzato per trasformare un oggetto in un flusso di byte. Questo processo è noto come serializzazione. Al contrario, il secondo metodo, **load**, viene impiegato per riportare un flusso di byte indietro in un oggetto, un processo noto come deserializzazione.

-Per garantire la sicurezza degli oggetti serializzati, **Ruby utilizza HMAC (Hash-Based Message Authentication Code)**, assicurando l'integrità e l'autenticità dei dati. La chiave utilizzata per questo scopo è memorizzata in uno dei diversi possibili luoghi:
+Per garantire la sicurezza degli oggetti serializzati, **Ruby utilizza HMAC (Hash-Based Message Authentication Code)**, assicurando l'integrità e l'autenticità dei dati. La chiave utilizzata per questo scopo è memorizzata in una delle diverse posizioni possibili:

 - `config/environment.rb`
 - `config/initializers/secret_token.rb`
@ -907,7 +908,7 @@ Controlla come potrebbe essere possibile [inquinare una classe Ruby e abusarne q

 ### Inquinamento _json di Ruby

-Quando si inviano nel corpo alcuni valori non hashable come un array, verranno aggiunti a una nuova chiave chiamata `_json`. Tuttavia, è possibile per un attaccante impostare nel corpo un valore chiamato `_json` con i valori arbitrari che desidera. Quindi, se il backend, ad esempio, controlla la veridicità di un parametro ma poi utilizza anche il parametro `_json` per eseguire qualche azione, potrebbe verificarsi un bypass dell'autorizzazione.
+Quando si inviano nel corpo alcuni valori non hashable come un array, verranno aggiunti a una nuova chiave chiamata `_json`. Tuttavia, è possibile per un attaccante impostare nel corpo un valore chiamato `_json` con i valori arbitrari che desidera. Quindi, se il backend, ad esempio, controlla la veridicità di un parametro ma poi utilizza anche il parametro `_json` per eseguire un'azione, potrebbe verificarsi un bypass dell'autorizzazione.

 Controlla ulteriori informazioni nella [pagina di inquinamento _json di Ruby](ruby-_json-pollution.md).

@ -917,7 +918,7 @@ Questa tecnica è stata presa [**da questo post del blog**](https://github.blog/

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

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

 Esempio base:
 ```ruby
@ -941,7 +942,7 @@ puts json_payload
 # Sink vulnerable inside the code accepting user input as json_payload
 Oj.load(json_payload)
 ```
-Nel caso in cui si tenti di abusare di Oj, è stato possibile trovare una classe gadget che all'interno della sua funzione `hash` chiamerà `to_s`, che chiamerà spec, che chiamerà fetch_path, il quale è stato possibile farlo recuperare un URL casuale, fornendo un ottimo rilevatore di questo tipo di vulnerabilità di deserializzazione non sanificate.
+Nel caso di tentare di abusare di Oj, è stato possibile trovare una classe gadget che all'interno della sua funzione `hash` chiamerà `to_s`, che chiamerà spec, che chiamerà fetch_path, il quale è stato possibile farlo recuperare un URL casuale, fornendo un ottimo rilevatore di questo tipo di vulnerabilità di deserializzazione non sanificate.
 ```json
 {
 "^o": "URI::HTTP",
@ -989,11 +990,11 @@ La funzionalità di upload di file dell'app Rails consente a un attaccante di sc

 - Comprendere il Meccanismo di Cache di Bootsnap

-Bootsnap accelera i tempi di avvio di Rails memorizzando nella cache il codice Ruby compilato, i file YAML e JSON. Memorizza file di cache che includono un'intestazione della chiave di cache (con campi come versione di Ruby, dimensione del file, mtime, opzioni di compilazione, ecc.) seguita dal codice compilato. Questa intestazione viene utilizzata per convalidare la cache durante l'avvio dell'app.
+Bootsnap accelera i tempi di avvio di Rails memorizzando nella cache il codice Ruby compilato, i file YAML e JSON. Memorizza file di cache che includono un'intestazione della chiave di cache (con campi come versione Ruby, dimensione del file, mtime, opzioni di compilazione, ecc.) seguita dal codice compilato. Questa intestazione viene utilizzata per convalidare la cache durante l'avvio dell'app.

 - Raccogliere i Metadati del File

-L'attaccante seleziona prima un file target che è probabile venga caricato durante l'avvio di Rails (ad esempio, set.rb dalla libreria standard di Ruby). Eseguendo codice Ruby all'interno del contenitore, estrae metadati critici (come RUBY_VERSION, RUBY_REVISION, dimensione, mtime e compile_option). Questi dati sono essenziali per creare una chiave di cache valida.
+L'attaccante seleziona prima un file di destinazione che è probabile venga caricato durante l'avvio di Rails (ad esempio, set.rb dalla libreria standard di Ruby). Eseguendo codice Ruby all'interno del contenitore, estrae metadati critici (come RUBY_VERSION, RUBY_REVISION, dimensione, mtime e compile_option). Questi dati sono essenziali per creare una chiave di cache valida.

 - Calcolare il Percorso del File di Cache

@ -1003,13 +1004,64 @@ Replicando il meccanismo di hash FNV-1a a 64 bit di Bootsnap, viene determinato

 L'attaccante prepara un payload che:

- Esegue comandi arbitrari (ad esempio, eseguendo id per mostrare informazioni sul processo).
+- Esegue comandi arbitrari (ad esempio, eseguendo id per mostrare le informazioni sul processo).
 - Rimuove la cache malevola dopo l'esecuzione per prevenire sfruttamenti ricorsivi.
 - Carica il file originale (ad esempio, set.rb) per evitare di far crashare l'applicazione.

 Questo payload viene compilato in codice Ruby binario e concatenato con un'intestazione della chiave di cache accuratamente costruita (utilizzando i metadati raccolti in precedenza e il numero di versione corretto per Bootsnap).

 - Sovrascrivere e Attivare l'Esecuzione
-Utilizzando la vulnerabilità di scrittura di file arbitraria, l'attaccante scrive il file di cache creato nella posizione calcolata. Successivamente, attivano un riavvio del server (scrivendo in tmp/restart.txt, che è monitorato da Puma). Durante il riavvio, quando Rails richiede il file target, il file di cache malevolo viene caricato, risultando in un'esecuzione di codice remoto (RCE).
+Utilizzando la vulnerabilità di scrittura di file arbitraria, l'attaccante scrive il file di cache creato nella posizione calcolata. Successivamente, attivano un riavvio del server (scrivendo in tmp/restart.txt, che è monitorato da Puma). Durante il riavvio, quando Rails richiede il file mirato, il file di cache malevolo viene caricato, risultando in un'esecuzione di codice remoto (RCE).
+
+### Sfruttamento di Ruby Marshal in pratica (aggiornato)
+
+Tratta qualsiasi percorso in cui byte non attendibili raggiungono `Marshal.load`/`marshal_load` come un sink RCE. Marshal ricostruisce grafi di oggetti arbitrari e attiva callback di librerie/gem durante la materializzazione.
+
+- Percorso di codice Rails vulnerabile minimo:
+```ruby
+class UserRestoreController < ApplicationController
+def show
+user_data = params[:data]
+if user_data.present?
+deserialized_user = Marshal.load(Base64.decode64(user_data))
+render plain: "OK: #{deserialized_user.inspect}"
+else
+render plain: "No data", status: :bad_request
+end
+end
+end
+```
+- Classi di gadget comuni viste in catene reali: `Gem::SpecFetcher`, `Gem::Version`, `Gem::RequestSet::Lockfile`, `Gem::Resolver::GitSpecification`, `Gem::Source::Git`.
+- Marcatori di effetti collaterali tipici incorporati nei payload (eseguiti durante l'unmarshal):
+```
+*-TmTT="$(id>/tmp/marshal-poc)"any.zip
+```
+Dove si presenta nelle app reali:
+- I cache store di Rails e i session store storicamente utilizzano Marshal
+- Backend di lavori in background e oggetti memorizzati su file
+- Qualsiasi persistenza personalizzata o trasporto di blob di oggetti binari
+
+Scoperta industrializzata di gadget:
+- Grep per costruttori, `hash`, `_load`, `init_with`, o metodi con effetti collaterali invocati durante l'unmarshal
+- Utilizzare le query di deserializzazione non sicura di Ruby di CodeQL per tracciare fonti → sink e scoprire gadget
+- Validare con PoC pubblici multi-formato (JSON/XML/YAML/Marshal)
+
+
+## Riferimenti
+
+- Trail of Bits – Marshal madness: A brief history of Ruby deserialization exploits: https://blog.trailofbits.com/2025/08/20/marshal-madness-a-brief-history-of-ruby-deserialization-exploits/
+- elttam – Ruby 2.x Universal RCE Deserialization Gadget Chain: https://www.elttam.com/blog/ruby-deserialization/
+- Phrack #69 – Rails 3/4 Marshal chain: https://phrack.org/issues/69/12.html
+- CVE-2019-5420 (Rails 5.2 insecure deserialization): https://nvd.nist.gov/vuln/detail/CVE-2019-5420
+- ZDI – RCE via Ruby on Rails Active Storage insecure deserialization: https://www.zerodayinitiative.com/blog/2019/6/20/remote-code-execution-via-ruby-on-rails-active-storage-insecure-deserialization
+- Include Security – Discovering gadget chains in Rubyland: https://blog.includesecurity.com/2024/03/discovering-deserialization-gadget-chains-in-rubyland/
+- GitHub Security Lab – Ruby unsafe deserialization (query help): https://codeql.github.com/codeql-query-help/ruby/rb-unsafe-deserialization/
+- GitHub Security Lab – PoCs repo: https://github.com/GitHubSecurityLab/ruby-unsafe-deserialization
+- Doyensec PR – Ruby 3.4 gadget: https://github.com/GitHubSecurityLab/ruby-unsafe-deserialization/pull/1
+- Luke Jahnke – Ruby 3.4 universal chain: https://nastystereo.com/security/ruby-3.4-deserialization.html
+- Luke Jahnke – Gem::SafeMarshal escape: https://nastystereo.com/security/ruby-safe-marshal-escape.html
+- Ruby 3.4.0-rc1 release: https://github.com/ruby/ruby/releases/tag/v3_4_0_rc1
+- Ruby fix PR #12444: https://github.com/ruby/ruby/pull/12444
+- Trail of Bits – Auditing RubyGems.org (Marshal findings): https://blog.trailofbits.com/2024/12/11/auditing-the-ruby-ecosystems-central-package-repository/

 {{#include ../../banners/hacktricks-training.md}}