/

CVE-2025-52347

Severity:

HIGH RISK

(7.8)

Privilege Escalation via Insecure Kernel Driver Interface

CVE-2025-52347

Awaiting Analysis

Vulnerability type

Category:

Privilege Escalation via Insecure Kernel Driver Interface

CWE:

CWE-20, CWE-269

Impact:

Local Privilege Escalation to Kernel/System Level

Severity:

HIGH RISK

(7.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A vulnerability in the DirectIo64.sys kernel driver used by PassMark BurnInTest, OSForensics, and PerformanceTest allows attackers to access arbitrary kernel memory through a specially crafted IOCTL request.

By abusing this unsafe driver interface from a lower-privileged context, an attacker can escalate to kernel-level privileges on the affected system.

Affected context

The issue occurs in environments where the vulnerable DirectIo64.sys driver is installed and loaded as part of PassMark BurnInTest, OSForensics, or PerformanceTest.

Systems are at risk when:

  • The driver exposes the affected device interface to user-mode processes
  • Unprivileged or low-privilege users can open a handle to the driver device
  • IOCTL 0x8011E044 requests are processed without sufficient validation

In such setups, standard user accounts or code running under them may be able to interact with the driver and trigger the flaw.

Exploit preconditions

  • Attack surface: Local, via the DirectIo64.sys device interface exposed to user-mode.
  • Required access: Ability to execute code on the target system under a non-administrative or limited account.
  • Trigger point: Sending a crafted IOCTL request with code 0x8011E044 to the driver, typically via standard Windows APIs such as CreateFile and DeviceIoControl.
  • Why exploitation is possible: The driver trusts caller-controlled parameters and fails to adequately validate or restrict memory access, enabling user-mode input to drive sensitive kernel operations and access kernel memory.

Why this happens

The vulnerability stems from insecure design and implementation of a kernel driver interface.

The DirectIo64.sys driver exposes IOCTL 0x8011E044 that allows user-mode callers to influence kernel-mode memory operations without sufficient validation of input arguments, target addresses, or access rights.

This maps to:

  • CWE-269: Improper Privilege Management — kernel-level capabilities are unintentionally exposed to less-privileged callers through an over-permissive driver interface.
  • CWE-20: Improper Input Validation — driver code does not adequately check or sanitize user-provided parameters before using them in sensitive operations.

Together, these flaws let an attacker leverage a benign-looking hardware/testing driver as a conduit to perform arbitrary kernel memory access and elevate privileges.

Potential impact

  • Local escalation from standard user to SYSTEM or equivalent kernel-level privileges
  • Arbitrary read and/or write of kernel memory, enabling manipulation of OS data structures
  • Disabling or bypassing security controls such as endpoint protection or integrity checks
  • Installing persistent kernel-mode backdoors or rootkits
  • Full compromise of the affected host, including all user data and processes

General mitigation guidance

Effective mitigation focuses on hardening the driver interface and reducing the privilege boundary it exposes:

  • Restrict which user accounts and processes can open handles to the driver device, aligning with least-privilege principles.
  • Introduce strict validation for all IOCTL parameters, including lengths, buffer addresses, and access modes, rejecting any unsafe or out-of-range values.
  • Remove or limit IOCTL operations that provide direct or raw access to kernel memory; where needed, wrap them in higher-level, tightly scoped operations.
  • Ensure kernel-mode operations are mediated by robust privilege checks so that only callers with appropriate authorization can perform sensitive actions.
  • Consider designing user-mode components to perform non-critical operations, reserving kernel-mode code only for functions that truly require it.

Combined, these patterns reduce the attack surface and make it harder for untrusted user-mode code to gain kernel-level influence via drivers.

How teams detect issues like this

Organizations can use multiple approaches to identify and monitor this class of vulnerability:

  • Static analysis and code review: Search driver code for IOCTL handlers that:
  • Use user-controlled pointers or addresses directly in kernel context
  • Provide arbitrary memory read/write or mapping capabilities
  • Lack robust boundary, range, and privilege checks
  • Driver interface audits: Enumerate exposed device objects and IOCTLs, documenting which ones can be called from unprivileged user-mode code, and verify intended access controls.
  • Behavioral monitoring: Use endpoint monitoring to detect unusual patterns, such as low-privileged processes repeatedly opening handles to diagnostic/test drivers and issuing uncommon IOCTLs.
  • Policy enforcement: Apply driver signing and loading policies that limit the use of third-party diagnostic or test drivers in production environments, and integrate security checks into your driver development lifecycle.

Automated tools for kernel driver analysis and specialized SAST solutions can assist by flagging dangerous use of user-mode buffers and over-privileged IOCTL interfaces.

Sources

SourceLink
github.comgithub.com/netero1010/Vulnerability-Disclosure/tree/main/CVE-2025-52347
osforensics.comosforensics.com/whats-new.html
passmark.compassmark.com/products/burnintest/history.php
passmark.compassmark.com/products/performancetest/history.php

Frequently asked

questions

Not by itself. Exploitation typically requires the attacker to already have the ability to run code on the target system. However, it is frequently used in combination with remote code execution or initial access vulnerabilities to achieve full system compromise.

A local, non-administrative account (or code executing under such an account) is usually sufficient, provided it can open a handle to the DirectIo64.sys device interface and issue IOCTL 0x8011E044.

The safest pattern is to redesign the driver interface to eliminate direct kernel memory access via IOCTLs, enforce strict input validation and access control in all driver entry points, and ensure only appropriately privileged callers can invoke sensitive operations.

Adopt a secure driver development lifecycle that includes threat modeling for driver IOCTLs, rigorous input validation, least-privilege design for exposed capabilities, code reviews focused on user-to-kernel transitions, and regular security testing of kernel components.

Find out what's already
exploitable in your codebase.