· via Hacker News – Front Page (native)
KVM guest-to-host escape on AMD CPUs exposed 127 GB of host memory on a DigitalOcean droplet
Terra Security says a use-after-free in KVM's nested paging on AMD chips, live for nearly four years, let a cloud VM read about 127 GB of host memory on an ordinary DigitalOcean droplet.

What happened
Researchers at Terra Security say they broke out of a virtual machine on a routine rented cloud server and reached the memory of the physical host underneath — a working guest-to-host escape against KVM, the hypervisor built into the Linux kernel. The write-up, which circulated on Hacker News's front page, tracks the flaw as CVE-2026-99312.
According to Terra Security, the attack required nothing beyond what a standard cloud customer gets: a VM and root within it. From an ordinary DigitalOcean droplet, the team mapped about 127 GB of host RAM as read-only and pulled back the host kernel's version banner, something no guest can normally see. On a shared machine, that memory also belongs to other tenants.
The read was demonstrated on DigitalOcean's infrastructure. The more serious half, writing to host memory, was proven on a bare-metal AMD server the researchers control, where their VM deposited 32 chosen bytes into a live host kernel page; a witness module in the host kernel reported the page changing at someone else's hands. An arbitrary write into host kernel memory, the firm notes, is the stepping stone to executing code on the host.
A stale pointer, nearly four years old
The flaw affects KVM on AMD processors with nested virtualization enabled — the feature that lets one VM host another. Terra Security says the bug lived in the kernel for just under four years and was introduced by a security fix.
The mechanics center on AMD's nested paging. KVM maintains a page table in host kernel memory that converts the physical addresses a guest sees into real host addresses, and a pointer in the guest's control block names the top page of that table. The processor, not the guest, performs the walk.
When a nested VM exits to its parent the usual way, KVM refreshes that pointer. A reset signal called INIT bypasses that path. KVM has a fallback — rebuilding the entire memory map while handling the reset — but it runs only when paging was enabled beforehand, and the setting it inspects belongs to the nested VM, which the attacker authors and can run with paging off. Neither mechanism updates the pointer.
The exploit then reshapes the guest's memory map while the nested VM runs, forcing KVM to discard the page table and free its top page, and delivers INIT from a second virtual CPU. The guest resumes holding a pointer to freed kernel memory — a use-after-free.
Turning a freed page into a forged page table
In the first stage, the researchers touch guest memory KVM has not yet mapped, forcing an allocation. The just-freed page is likely to return — the same CPU freed it, so it sits near the front of that CPU's free list. KVM reuses it as a bottom-level table, but the stale pointer still names it, so the hardware treats a bottom-level table as the root of the walk. Those entries are correct at their own level, holding host addresses of guest pages, so the walk lands in an ordinary data page the attacker controls. The guest never modifies KVM's real tables; it supplies the level underneath.
Next, the guest must learn where its pages physically sit, something it is never told. The trick is the processor's Accessed bit. The researchers plant entries with that bit clear across roughly 262,144 guest pages, about a gigabyte, then feed guessed host addresses through the forged structure. A guess that lands on a marked page gets walked and flagged; silence means trying again. A few hundred probes, each costing microseconds, revealed the true host addresses of two guest pages.
With two verified addresses, the researchers assembled a complete replacement page table pointing anywhere in host physical memory. Every memory access the VM makes afterward lands where they choose — which is how the droplet read about 127 GB of host RAM.
Reliability
The reallocation step is a race, and a cloud host effectively allows one serious attempt per boot. On the large droplet used for the full chain, it worked on 6 of 12 boots — odds the researchers describe as workable for a patient attacker.
Why it matters
Cloud multi-tenancy rests entirely on the hypervisor's isolation. This demonstration shows that boundary failing on commodity public-cloud hardware, reachable by any tenant with root on an affected AMD host that allows nested virtualization. A read exposes the memory of every other customer on the machine; a write opens a path to code execution on the host and, from there, to every VM it runs. The flaw also sat upstream for almost four years, introduced by a fix meant to improve security — a reminder that in shared infrastructure, a hypervisor bug is every tenant's problem.
- #kvm
- #virtualization
- #security
- #cloud-computing
- #amd