Linux KVM Flaw CVE-2026-99312 Exposes Host Memory on AMD Cloud Hosts

A newly disclosed vulnerability in KVM, the hypervisor that ships as part of the Linux kernel, allowed researchers to read roughly 127 GB of a cloud server's memory from inside a virtual machine they controlled. Because that server was shared with other tenants, the accessible memory could have included data belonging to other customers' virtual machines.

The flaw is tracked as CVE-2026-99312 and was reported by The Hacker News. Fixed kernels have since been released, but the disclosure is a reminder of how thin the isolation boundary between cloud tenants can become when hypervisor bugs surface.

What the vulnerability is

KVM turns the Linux kernel into a hypervisor, letting a single physical machine host many isolated virtual machines. That isolation depends on hardware virtualization extensions and on the correctness of the kernel code that manages them. When a bug breaks the boundary, a guest VM can reach memory it should never see — including the host kernel's memory and, by extension, memory belonging to sibling guests.

CVE-2026-99312 is precisely this class of defect. The researchers demonstrated the impact by reading approximately 127 GB of a DigitalOcean server's memory from within their own VM. On a multi-tenant host, that window into host memory is a window into other customers' workloads.

Who is affected

The flaw is narrower than it first appears, which limits but does not eliminate the risk:

  • AMD hosts only. The bug is specific to hosts running on AMD processors.
  • Nested virtualization required. The vulnerable path is reachable when nested virtualization is enabled on the host.
  • Shared, multi-tenant environments are the highest concern. A single-tenant host exposes only the operator's own data; a public cloud host can expose neighbors.

Organizations running their own KVM infrastructure on AMD hardware with nested virtualization turned on should treat this as urgent. Cloud customers cannot patch the issue themselves — they depend on their provider to apply fixed kernels.

Why nested virtualization matters

Nested virtualization lets a guest hypervisor run inside a host VM, which is useful for development, testing, and certain CI workflows. It also deepens the call stack between the guest and the physical hardware, and every additional layer is another place for memory-isolation logic to go wrong. The combination of AMD's virtualization extensions and nested guests appears to be where this defect lives.

The practical lesson is that features which expand the attack surface should be enabled deliberately. If nested virtualization is not required on a given host, disabling it removes exposure to this bug entirely.

The multi-tenant stakes

Cloud providers invest heavily in isolation guarantees, and the shared-responsibility model assumes the hypervisor holds. A memory-disclosure bug of this scale undermines that assumption for the duration of exposure. Even where an attacker cannot write to host memory, read access alone can leak credentials, cryptographic material, session tokens, and proprietary data from co-located tenants.

The researchers' demonstration on DigitalOcean is significant because it shows the bug is not merely theoretical in a production cloud. Providers have presumably patched affected infrastructure, but customers should confirm with their vendors rather than assume.

Remediation and mitigation

  • Apply the fixed kernels. Patched kernel versions have shipped; host operators should update and reboot into them promptly.
  • Verify provider patching. Cloud customers should check status pages and advisories from their providers for confirmation that hosts running AMD CPUs have been updated.
  • Disable nested virtualization where unnecessary. This removes the vulnerable configuration on hosts that do not need it.
  • Audit for exposure windows. If you operate KVM hosts, review logs and consider whether any unusual guest behavior occurred before patching.
  • Track the CVE. Consult your distribution's advisory for the specific kernel versions that carry the fix.

The bigger picture

Hypervisor vulnerabilities are rare relative to application-layer bugs, but their blast radius is disproportionate. A single defect in KVM can cross every tenant boundary on a physical server at once. CVE-2026-99312 joins a short list of bugs that have forced cloud providers into emergency kernel updates, and it reinforces a durable principle: virtualization is a security boundary, but it is software, and software fails.

For defenders, the takeaways are familiar but worth repeating. Keep host kernels current, minimize enabled features, and treat cloud isolation as a strong control rather than an absolute one. For cloud customers, vendor transparency during hypervisor incidents matters as much as the patch itself — you cannot remediate what you are not told about.

Original reporting: The Hacker News