CVE-2026-99568 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
iommufd/iova_bitmap: Ensure that iova_bitmap_set() handles the full IOVA
Generally userspace is going to step the dirty bitmap through the IOVA space. However if the bitmap ends in the middle of a large PTE this is problematic. The first step will clear the dirty bit and report dirty to the end of its bitmap while the second step will see the clear'd dirty and report clean for the start of the bitmap. If it happens this ends up losing dirties.
Further this function is missing bounds checking so if this does happen ther is a good chance it will write memory beyond what the userspace was expecting.
Return an error code if this illegal condition happens.
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel vulnerability identified in the iommufd/iova_bitmap subsystem represents a critical flaw in how dirty page tracking and bounds checking are managed during I/O Virtual Address space operations. This issue specifically affects the interaction between userspace applications, which typically manage memory protection and virtualization tasks through ioctls provided by the VFIO framework, and the kernel's internal bitmap management for tracking modified pages. The core technical flaw lies in the iova_bitmap_set function, which is responsible for marking specific ranges within an IOVA as dirty or clean. Under normal operational conditions, userspace steps through the IOVA space to update a dirty bitmap that tracks which memory regions have been written to since the last synchronization point. However, when this stepping process results in a boundary condition where the requested range ends precisely in the middle of a large Page Table Entry, the current implementation fails to handle the partial coverage correctly. This misalignment leads to two distinct but related failure modes: logical data loss and potential memory corruption.
From a functional perspective, the first consequence of this flaw is the loss of dirty page information, which can severely impact performance and correctness in virtualization scenarios that rely on accurate dirty tracking for live migration or checkpointing. When the bitmap operation spans across PTE boundaries incorrectly, the kernel may clear the dirty bit prematurely while reporting it as set to userspace, or vice versa depending on the specific execution path taken during subsequent steps. This inconsistency means that certain modified pages are not flagged as needing synchronization, leading to data corruption when state is transferred between virtual machines or hosts. The root cause here is a lack of atomicity and proper boundary handling in the bitmap manipulation logic, where the granularity of the dirty tracking does not align with the underlying memory management structures without explicit validation.
More critically, the vulnerability introduces a severe security risk due to missing bounds checking within the iova_bitmap_set function. Because the code assumes that the input parameters will always fall neatly within expected limits or handle partial PTEs gracefully, it fails to validate whether the requested operation exceeds the allocated memory for the bitmap structure itself. If an attacker can manipulate userspace inputs to trigger this specific boundary condition where the calculation wraps around or extends beyond the intended allocation, the kernel may write data to memory locations outside the bounds of the expected buffer. This constitutes a classic out-of-bounds write vulnerability, which allows for arbitrary code execution, privilege escalation, or denial of service by corrupting adjacent kernel structures such as other bitmaps, task descriptors, or control flow pointers. The absence of rigorous input validation transforms what might otherwise be a logical error into an exploitable memory safety violation.
In terms of industry standard classifications, this vulnerability aligns with CWE-125 Out-of-bounds Read and CWE-787 Out-of-bounds Write, as the primary danger stems from writing beyond allocated boundaries due to insufficient checks on input parameters. Additionally, it relates to CWE-697 Incorrect Comparison, given that the logic fails to properly account for partial overlaps with large page table entries. From an offensive security perspective, this flaw could be leveraged via ATT&CK technique T1055 Process Injection or T1068 Privilege Escalation if an attacker can exploit the out-of-bounds write to overwrite kernel function pointers or credentials within a privileged process context. The vulnerability is particularly dangerous in cloud environments where userspace applications have elevated privileges relative to standard unprivileged processes but are still sandboxed, as breaking this boundary provides full root access to the host system.
To mitigate this risk, it is imperative that developers implement strict bounds checking before any bitmap manipulation occurs within the iommufd subsystem. The fix involves validating that the requested IOVA range does not exceed the allocated size of the dirty bitmap and ensuring that partial overlaps with large PTEs are handled atomically without losing state information. Returning an error code for illegal conditions, as described in the resolution, prevents the kernel from proceeding with invalid operations that could lead to memory corruption. System administrators should apply the latest kernel updates immediately to patch this flaw. Furthermore, organizations utilizing VFIO-based virtualization solutions should audit their userspace applications to ensure they adhere strictly to API contracts and avoid passing malformed or excessively large ranges in ioctls related to dirty page tracking. Regular security audits focusing on input validation in kernel interfaces are essential to prevent similar out-of-bounds vulnerabilities from being introduced in future updates.