/

CVE-2026-80118

Severity:

HIGH RISK

(7.1)

Physical Memory Disclosure (CWE-497) in DirectIo64.sys

CVE-2026-80118

Awaiting Analysis

Vulnerability type

Category:

Information Disclosure

CWE:

CWE-73, CWE-476, CWE-497

Impact:

Physical memory disclosure, security boundary bypass, KASLR defeat, and potential denial of service

Severity:

HIGH RISK

(7.1)

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 driver used by several PassMark products allows an unprivileged local user to request a file containing physical memory and sensitive kernel metadata without authentication. The same IOCTL may also trigger a kernel crash when an internal structure lookup fails, while the caller-controlled output path can enable writes to locations normally outside the user's permissions.

Affected context

The issue may occur in PassMark PerformanceTest, BurnInTest, and OSForensics deployments that install a vulnerable DirectIo64.sys driver. Risk depends on whether an unprivileged local user can access the driver's IOCTL interface and whether the handler runs with SYSTEM privileges while accepting a caller-controlled output path. Systems using the affected driver may expose memory from other processes, kernel metadata, and failure paths capable of crashing the operating system.

Exploit preconditions

  • Attack surface: A locally accessible device-driver IOCTL exposed by DirectIo64.sys
  • Required access: An unprivileged local account; no driver-level authentication is required
  • Trigger point: A single IOCTL handled by the driver
  • Relevant input: A caller-supplied file path and request parameters
  • Why exploitation is possible: The handler lacks caller-identity authorization checks, performs privileged file output, and exposes physical memory through a crash-dump-format image
  • Availability condition: A kernel-structure locator can return NULL on defined failure paths, after which the handler dereferences the result without checking it

Why this happens

The primary flaw is an authorization and information-disclosure failure in a privileged driver. A kernel IOCTL accepts requests from unprivileged local users without verifying whether the caller is authorized to access physical memory, then emits a SYSTEM-context image to a path selected by the caller. This maps primarily to CWE-497, Exposure of Sensitive System Information, because memory belonging to other processes and kernel structures becomes observable across security boundaries. The caller-controlled path also relates to CWE-73, External Control of File Name or Path, while the unchecked result of an internal locator reflects CWE-476, NULL Pointer Dereference.

Potential impact

  • An attacker may recover secrets, credentials, tokens, or other sensitive data from physical memory.
  • An attacker could inspect kernel metadata and defeat address-space layout randomization.
  • A standard user may cause privileged files to be created in locations that would otherwise be inaccessible.
  • The exposed memory could enable follow-on attacks against other processes or kernel components.
  • The driver may crash the operating system when an internal structure lookup returns NULL.

General mitigation guidance

Mitigation generally focuses on removing unauthorized access to physical memory

and reducing privilege in driver operations.

Common defensive patterns include:

  • Restricting device-object and IOCTL access with explicit caller authorization and least-privilege security descriptors.
  • Ensuring diagnostic or dump functionality is disabled by default unless a trusted administrative workflow enables it.
  • Replacing raw physical-memory exposure with narrowly scoped, validated diagnostic data.
  • Treating file paths and output destinations as trusted policy-controlled values rather than caller-controlled inputs.
  • Validating all internal locator results before dereferencing them and handling failure paths safely.
  • Applying driver allowlisting, code-integrity policy, and endpoint controls to limit unnecessary kernel components.
  • Separating diagnostic output from SYSTEM privileges where possible and constraining filesystem access.

How teams detect issues like this

Detection approaches may include:

  • Static analysis for IOCTL handlers that omit caller authorization or access checks.
  • Searches for physical-memory mapping, kernel-memory copying, privileged file creation, and caller-controlled path handling.
  • Code review of every pointer returned by internal lookup or discovery routines, with particular attention to NULL-handling paths.
  • Runtime monitoring for unprivileged processes opening driver device objects or requesting unusual diagnostic IOCTLs.
  • File-integrity and endpoint telemetry for crash-dump-format files containing large physical-memory images.
  • Policy enforcement requiring administrative approval, signed drivers, and allowlisted kernel interfaces.

Automated security review tools can help identify unchecked pointers and dangerous privileged I/O patterns, but should be complemented by driver-specific testing.

Sources

SourceLink
dkom.devdkom.dev/posts/directio64-disclosure/
github.comgithub.com/floppywiggler/directio64-disclosure
osforensics.comosforensics.com/whats-new.html
passmark.compassmark.com/products/burnintest/history.php
passmark.compassmark.com/products/performancetest/history.php
vulncheck.comvulncheck.com/advisories/passmark-performancetest-burnintest-and-osforensics-kernel-null-pointer-dereference-via-directio64-sys-ioctl

Frequently asked

questions

The described attack surface is local. Exploitation generally requires an

unprivileged account on a system where the vulnerable driver is installed and

its device interface is accessible.

No driver-level authentication or caller-identity check is described. The

attacker still needs local execution access and must be able to reach the

driver's IOCTL interface.

Prevent unprivileged access to physical-memory functionality, enforce

authorization at the driver boundary, validate output destinations, and handle

all failed kernel-structure lookups before dereferencing their results.

Use least-privilege device permissions, minimize kernel diagnostic capabilities,

avoid exposing raw memory, validate all caller-controlled paths, and combine

static analysis with runtime monitoring of sensitive IOCTL activity.

Find out what's already
exploitable in your codebase.