CVE-2026-40369: vulnerabilidad crítica en Windows que permite escapar del sandbox de navegadores

Introducción

El 12 de agosto de 2026, Ori Nimron (@orinimron123) publicó en GitHub un exploit funcional para CVE-2026-40369, una vulnerabilidad de escritura arbitraria en el kernel de Windows que permite escapar del sandbox de procesos de renderizado de cualquier navegador. La explotación requiere solo acceso local sin privilegios especiales, lo que la convierte en un vector de ataque crítico para entornos empresariales donde los usuarios trabajan con navegadores en modo sandbox.

El exploit aprovecha una debilidad en la función NtQuerySystemInformation cuando se invoca con el InfoClass 253 (SystemProcessInformationExtension). Esta clase, introducida en Windows 10, está diseñada para extender la información disponible sobre procesos, pero carece de validación adecuada en su implementación. El resultado es una escritura no controlada en memoria kernel, que puede ser aprovechada para sobrescribir estructuras críticas y escapar del sandbox.

Qué ocurrió

El exploit publicado por Nimron demuestra cómo un atacante sin privilegios puede escalar privilegios desde un entorno sandboxed (como un navegador moderno en modo protegido) hasta ejecutar código en modo kernel. La vulnerabilidad reside en la función ExpGetProcessInformation, llamada internamente por ExpQuerySystemInformation cuando se solicita información sobre procesos con el InfoClass 253.

El fallo técnico

La vulnerabilidad se activa cuando se invoca NtQuerySystemInformation(SystemProcessInformationExtension, ...) con un buffer de tamaño cero. La función ProbeForWrite (que valida el buffer) devuelve inmediatamente si la longitud es cero, omitendo cualquier validación. Sin embargo, el código de ExpGetProcessInformation continúa ejecutándose y itera sobre todos los procesos del sistema.

Para cada proceso, la función intenta incrementar un contador en un puntero no validado (*v95), lo que provoca:

1. Una escritura arbitraria en memoria kernel (en la dirección proporcionada).
2. Un crash (BSOD) si el puntero apunta a una dirección no mapeada.

El exploit aprovecha esto para sobrescribir direcciones críticas en memoria kernel, como la tabla de descriptores de interrupción (IDT) o la tabla de descriptores globales (GDT), permitiendo ejecutar código arbitrario con privilegios de SYSTEM.

Reproducción del exploit

El exploit no requiere privilegios especiales ni tokens especiales. Un atacante puede ejecutarlo desde un navegador sandboxed para escapar y ejecutar código en el host. El código mínimo para reproducir el fallo es:

// Reproducción mínima (sin privilegios)
NTSTATUS status = NtQuerySystemInformation(
    253,                // SystemProcessInformationExtension
    arbitraryKernelAddr,  // Puntero a memoria kernel (ej: 0xFFFFF...000)
    0,                  // Longitud = 0 → omite ProbeForWrite
    &needed            // Puntero a tamaño requerido (ignorado)
);

Esto provoca un write a *arbitraryKernelAddr en cada proceso, llevando a un BSOD si la dirección no es válida.

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Riesgo para entornos empresariales

• CVSS v3.1: 9.3 (Crítico) – Vector: Local (AV:L/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H)
• Afecta: Windows 10 (21H2 y posteriores), Windows 11, Windows Server 2019, 2022, 2025.
• Parche disponible: No hay parche oficial de Microsoft al momento de publicación (12/08/2026). Se recomienda aplicar mitigaciones inmediatas.

Servicios y componentes impactados

La función vulnerable: ExpGetProcessInformation

La vulnerabilidad reside en ntoskrnl.exe!ExpGetProcessInformation, llamada por ntoskrnl.exe!ExpQuerySystemInformation cuando el InfoClass es 253. El código relevante (desensamblado) muestra el problema:

; Offset: ExpQuerySystemInformation+0xD7A (Windows 11 24H2)
mov     r12, [rsp+arg_8]      ; buffer
test    r12, r12                ; ¿Buffer NULL?
jz      short loc_D7A           ; Si es NULL, salta a la validación
mov     rcx, r12               ; Puntero a memoria kernel
call    ProbeForWrite           ; Solo se ejecuta si Length > 0
test    eax, eax
jnz     short loc_D7A

El problema es que ProbeForWrite solo valida el buffer si Length > 0. Al pasar Length=0, se omite la validación y el puntero a memoria kernel se usa directamente.

El bucle de iteración

Dentro de ExpGetProcessInformation, el código itera sobre todos los procesos del sistema:

for (each_process) {
    if (length < 12) {
        status = STATUS_INFO_LENGTH_MISMATCH;
        // NO RETORNA AQUÍ. CONTINÚA EL BUCLE.
    }
    *v95 = *v95 + 1;  // Escritura arbitraria en memoria kernel
}

La función no retorna temprano tras establecer STATUS_INFO_LENGTH_MISMATCH, lo que permite que el bucle continúe y escriba en *v95 para cada proceso.

Vector de ataque: Escritura arbitraria en kernel

El exploit aprovecha esto para:

1. Identificar direcciones kernel válidas (ej: la IDT o la GDT).
2. Sobrescribir la dirección de una syscall con un puntero a shellcode.
3. Ejecutar código arbitrario cuando se invoque esa syscall.

Ejemplo de código del exploit (simplificado):

// Ubicar la IDT
PULONG_PTR idt_addr = get_idt_address();  // 0xFFFFF...000 en x64

// Sobrescribir una entrada de syscall (ej: NtCreateFile)
PVOID original_syscall = idt_addr[0x2B]; // Número de syscall para NtCreateFile
idt_addr[0x2B] = (ULONG_PTR)shellcode_address;

// Ejecutar syscall maliciosa
NTSTATUS status = NtCreateFile(..., shellcode_address, ...);

¿Por qué funciona en todos los navegadores?

Los navegadores modernos (Chrome, Edge, Firefox) ejecutan el proceso de renderizado en sandboxes estrictos. Sin embargo:

• Chrome/Edge: Usan Win32k Lockdown para restringir llamadas a APIs peligrosas.
• Firefox: Usa Windows Job Objects para aislar procesos.

La vulnerabilidad elude estas protecciones porque:

1. No requiere llamadas a APIs restringidas (usa NtQuerySystemInformation).
2. El sandbox permite llamadas a syscalls (aunque estén limitadas).

Qué deberían hacer los administradores y equipos técnicos

1. Bloquear el InfoClass 253 (SystemProcessInformationExtension)

Para Windows 10/11/Server:

# Deshabilitar PatchGuard temporalmente (requiere reinicio)
bcdedit /set testsigning on
bcdedit /set nointegritychecks on
# Reiniciar

# Descargar Process Hacker (https://processhacker.sourceforge.io/)
# Crear una regla para bloquear NtQuerySystemInformation(253)

Para entornos empresariales (GPO):

# Política de Grupo: Configurar "Disable Win32k Syscall Filtering"
# Ruta: Computer Configuration → Administrative Templates → System → Kernel
# Valor: Enable "Disable Win32k Syscall Filtering"

2. Aplicar mitigaciones de sandbox en navegadores

Chrome/Edge:

# Habilitar Site Isolation Strict y reducir permisos del sandbox
# Política: "SitePerProcess" y "RendererCodeIntegrity"
# Ejemplo para Chrome:
"C:\Program Files\Google\Chrome\Application\chrome.exe" --site-per-process --no-sandbox --disable-features=Win32kSystemCalls

Firefox:

# En about:config, establecer:
security.sandbox.content.level = 4  ; Máximo aislamiento
security.sandbox.windows.log = true  ; Para depuración

3. Monitorear logs de BSOD y eventos de kernel

# Filtrar eventos de BSOD relacionados con NtQuerySystemInformation
Get-WinEvent -FilterHashtable @{
    LogName='System'
    ID=1001
    Provider='Microsoft-Windows-Kernel-General'
} | Where-Object {$_.Message -like "*NtQuerySystemInformation*"}

# Monitorizar escrituras arbitrarias en kernel (requiere ETW)
$provider = "Microsoft-Windows-Kernel-General"
Register-ObjectEvent -Query "Event[System[Provider[@Name='$provider'] and (EventID=10)]]" -Action {
    $event.MessageData | Out-File -FilePath "C:\Logs\KernelWrites.log" -Append
}

4. Actualizar a versiones parcheadas (cuando estén disponibles)

• No exponer cuentas locales con permisos elevados.
• Usar firewalls para limitar acceso a estaciones de trabajo.
• Aplicar principios de menor privilegio en todos los usuarios.

5. Implementar capas de defensa adicionales

CVE-2026-40369 representa un riesgo crítico para entornos Windows, especialmente en navegadores modernos donde los usuarios interactúan diariamente. La combinación de:

1. Escritura arbitraria en kernel sin privilegios.
2. Escape de sandbox en todos los navegadores.
3. Ausencia de parche oficial.

Hace que esta vulnerabilidad sea un vector de ataque prioritario para actores maliciosos. Los equipos de DevOps, Seguridad e Infraestructura deben aplicar mitigaciones inmediatas, como bloquear el InfoClass 253, endurecer los sandboxes de navegadores y monitorear eventos de kernel sospechosos.

Hasta que Microsoft libere un parche, la prevención depende de capas de defensa adicionales y configuraciones proactivas. No subestimen el riesgo: un exploit funcional ya está disponible en GitHub, y su explotación es trivial para atacantes con acceso local.

FIN