/

CVE-2025-67246

Severity:

HIGH RISK

(7.3)

Improper Access Control in Ludashi Driver Physical Memory

CVE-2025-67246

Modified

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-269, CWE-732

Impact:

Local Information Disclosure and Privilege Escalation Primitive

Severity:

HIGH RISK

(7.3)

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 local information disclosure vulnerability in the Ludashi driver before version 5.1025 allows unprivileged users to read arbitrary physical memory through an exposed IOCTL interface that lacks proper access control.

By supplying attacker-controlled physical address ranges to the driver, a normal user can map and copy kernel memory back into user space, potentially leaking kernel data structures, pointers, and security tokens and helping to bypass KASLR for further privilege escalation.

Affected context

The vulnerability occurs in the Ludashi kernel-mode driver's IOCTL handler, which exposes a device interface accessible to non-administrative users.

In affected environments, the handler accepts user-provided structures containing physical addresses in the lower 4GB and uses them to map physical memory via MmMapIoSpace without enforcing strict access checks or validating the requested address ranges.

Systems where the driver is installed and the device interface is reachable by standard user accounts are exposed to this risk.

Exploit preconditions

  • Attack surface: Local, via the Ludashi driver's device interface and IOCTL handler.
  • Required access: Ability to open the driver's device from an unprivileged (non-admin) user account.
  • Trigger point: Issuing crafted IOCTL requests containing attacker-controlled physical address ranges to the vulnerable handler.
  • Why exploitation is possible: The handler maps arbitrary physical memory and copies it back to user space without verifying the caller's privileges or constraining the physical address range to safe, non-sensitive regions, violating the intended kernel/user isolation model.

Why this happens

The core issue stems from insufficient authorization checks in a privileged kernel driver interface.

The IOCTL handler treats all callers as equally trusted and performs powerful operations—mapping arbitrary physical memory with MmMapIoSpace and copying the resulting contents into user space—without confirming that the caller is privileged or that the requested addresses fall within a legitimate, bounded region.

This aligns with CWE-269: Improper Privilege Management, where high-privilege capabilities are exposed to low-privilege contexts, and CWE-732: Incorrect Permission Assignment for Critical Resource, because the device interface effectively grants broad read access to critical kernel memory resources.

Abstractly, this is a pattern where a driver offers "debug-level" or "hardware-access" functionality on a device node that is readable and writable by regular users, turning the driver into an unintended information disclosure and exploitation primitive.

Potential impact

  • Local attackers may read arbitrary physical memory within the lower 4GB address space.
  • Kernel data structures and internal state can be exposed, aiding in reverse engineering of the kernel and installed drivers.
  • Disclosure of kernel pointers can be used to bypass Kernel Address Space Layout Randomization (KASLR).
  • Exposure of security tokens or credential-related structures can support construction of local privilege escalation chains.
  • Leakage of sensitive in-memory data, such as cryptographic material, configuration secrets, or other process-related information.

General mitigation guidance

Effective mitigation focuses on strictly limiting who can access powerful driver interfaces and constraining what those interfaces can do:

  • Enforce strong access control on the device interface: Ensure that only highly privileged accounts (e.g., administrators or system services) can open the driver's device object or invoke sensitive IOCTLs. Use robust ACLs and privilege checks in the driver code paths handling physical memory operations.
  • Restrict capabilities exposed to user mode: Avoid providing raw physical memory mapping or direct hardware access to untrusted callers. Where such functionality is required, gate it behind explicit privilege checks or internal-only interfaces.
  • Validate and constrain address ranges: Introduce strict validation of user-supplied structures, including bounding physical addresses and sizes to non-sensitive, well-defined regions or eliminating arbitrary physical memory access entirely.
  • Apply least-privilege design: Separate benign operations (available to regular users) from high-impact operations (restricted to trusted components), and design IOCTLs such that misuse cannot yield arbitrary physical memory read primitives.
  • Harden deployment policies: In environments where the driver is not essential, consider disabling or removing it, or limiting its installation to systems where its functionality is tightly controlled.

How teams detect issues like this

Organizations can look for this class of issue and its misuse through a combination of code-centric and behavior-centric approaches:

  • Static analysis and code review:
  • Flag kernel drivers that call MmMapIoSpace, MmMapIoSpaceEx, or similar primitives using user-controlled parameters.
  • Identify IOCTL handlers that copy kernel or physical memory contents directly back to user buffers without privilege checks.
  • Review device creation paths to confirm that security descriptors and ACLs restrict access to sensitive IOCTLs.
  • Policy and configuration review:
  • Audit installed third-party drivers for overly permissive device object permissions.
  • Enforce driver signing and security review policies for any kernel components introduced into the environment.
  • Runtime monitoring:
  • Monitor for unusual IOCTL traffic patterns from unprivileged processes to hardware or tuning-related drivers.
  • Use endpoint detection tools capable of profiling driver usage and highlighting drivers that expose physical memory access primitives.
  • Automated tooling:
  • Integrate kernel-specific security linters or driver verification tools into the development lifecycle to detect unsafe IOCTL patterns and missing access control paths.

Sources

SourceLink
github.comgithub.com/CDipper/CVE-2025-67246
github.comgithub.com/CDipper/CVE-Publication

Frequently asked

questions

No, this is a local vulnerability. An attacker must already have the ability to run code on the affected system to open the driver's device and issue crafted IOCTL requests.

The attacker typically only needs a standard, non-administrative user account with permission to access the driver's device interface. No kernel-mode or administrative privileges are required to trigger the vulnerable IOCTL handler.

The safest pattern is to remove or tightly restrict raw physical memory access from user-accessible IOCTLs, enforce strict privilege checks for any high-impact operations, and define secure ACLs on the device object so that only trusted, privileged components can invoke sensitive functionality.

Adopt a least-privilege design for all kernel interfaces, treat all user input (including IOCTL parameters and addresses) as untrusted, validate and constrain any memory access requests, and mandate security review or automated analysis for driver IOCTL handlers that interact with physical or kernel memory.

Find out what's already
exploitable in your codebase.