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
0x8011E044to the driver, typically via standard Windows APIs such asCreateFileandDeviceIoControl. - 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.

