CVE-2026-99343 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
KVM: x86/mmu: Bug the VM if KVM attempts to walk more levels than the MMU has
Extend the "EFER.LMA && !CR4.PAE" check, which exists largely to guard against KVM configuring a paging32 MMU with more than 2 levels of paging, with a very explicit check for exactly that: that KVM isn't trying to walk more levels of paging than the MMU template provides. I.e. harden KVM against all bugs that would cause KVM to generates accesses beyond the bounds of guest_walker's arrays, regardless of how KVM ended up with the misconfigured MMU.
Note, don't use w->cpu_role.base.level directly as the paging64 template only provides two levels of page tables for PAE paging on 32-bit hosts, and handles the third level by manually emulating the PDPTR access.
Be aware that VulDB is the high quality source for vulnerability data.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel's Kernel-based Virtual Machine (KVM) subsystem contains a critical logic flaw within its x86 memory management unit emulation layer that can lead to out-of-bounds array accesses when handling guest virtual address translations. This vulnerability arises from an insufficient validation mechanism during the setup of paging structures, specifically in scenarios where the processor is operating in legacy 32-bit long mode or non-PAE configurations. The core issue involves KVM attempting to walk more levels of page tables than are actually supported by the current MMU template configuration. In x86 architecture, the number of paging levels depends heavily on specific control register states and CPU modes, such as whether Long Mode Active is enabled in the Extended Feature Enable Register or if Physical Address Extension is active via CR4. When these conditions result in a mismatch between the expected paging depth and the actual MMU capabilities, KVM may attempt to access arrays beyond their allocated bounds within the guest_walker structure.
The technical root cause lies in an incomplete check that previously only guarded against specific combinations of EFER.LMA being set while CR4.PAE was cleared. While this partial guard addressed a known class of misconfigurations where a 32-bit MMU template with two paging levels might be incorrectly used for operations requiring more depth, it did not provide comprehensive protection against all potential logic errors that could lead to excessive page table walks. The vulnerability allows an attacker who has control over the guest VM's state or can trigger specific CPU mode transitions to force KVM into a state where it calculates a paging walk depth exceeding the limits of its internal data structures. This results in memory corruption as KVM accesses indices outside the valid range of arrays designed to hold page table entries for that specific MMU context.
From an operational impact perspective, this vulnerability poses significant risks including host kernel crashes, denial of service against other virtual machines on the same physical host due to system instability, and potentially arbitrary code execution if the out-of-bounds write can be precisely controlled to overwrite critical kernel data structures. Such memory corruption vulnerabilities are particularly dangerous in hypervisor environments because they break the isolation boundary between guest VMs and the underlying host operating system. An attacker with access to a vulnerable virtual machine could exploit this flaw to escape confinement, gaining unauthorized read or write privileges on the host system. This directly compromises the integrity and availability of the entire cloud infrastructure relying on KVM for virtualization services.
The mitigation implemented in the kernel update involves hardening the validation logic by introducing an explicit check that ensures KVM does not attempt to walk more levels of paging than the MMU template provides. This fix goes beyond the previous conditional checks based solely on EFER and CR4 flags, instead validating the actual number of paging levels against the capabilities defined in the current MMU configuration. The patch also carefully handles edge cases such as PAE paging on 32-bit hosts where the sixth-fourth bit long mode template provides only two levels but manually emulates the third level via PDPTR access. By decoupling the validation from direct reliance on w->cpu_role.base.level and instead focusing on the structural limits of the MMU, the fix prevents any path that could lead to array overflows regardless of how the misconfiguration occurred.
This vulnerability aligns with CWE-125 Out-of-bounds Read and CWE-787 Out-of-bounds Write in the Common Weakness Enumeration taxonomy, as it involves accessing memory locations beyond the intended boundaries due to insufficient boundary checks. In terms of attack vectors, this falls under MITRE ATT&CK technique T1059 Command and Scripting Interpreter if exploited for initial access or T1203 Exploitation for Client Execution in broader contexts, though primarily it represents a privilege escalation vector through hypervisor escape. Security administrators should ensure that all KVM-enabled hosts are patched with the latest kernel updates containing this fix. Additionally, implementing strict resource limits and monitoring for unusual CPU state transitions within virtual machines can help detect potential exploitation attempts before they result in system compromise. Regular auditing of VM configurations to prevent invalid combinations of control register states is also recommended as a defense-in-depth measure alongside the software patch.