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.

