Go straight to an AI summary of this blog post instead

  • Summarize this post with Perplexity
  • Summarize this post with Gemini

The Short Version

Jump to the Long Version ↓

What it is: Januscape (CVE-2026-53359) is a use-after-free in the Linux kernel’s KVM/x86 shadow MMU. A malicious guest can drive KVM into reusing a cached shadow page that no longer matches the mapping being built, which leaves a stale reverse-map entry pointing into memory KVM later frees. Jump to the long version →

Impact: The reliable, public outcome is a host crash. Public research describes a full guest-to-host escape – code inside a malicious guest running on the host as root. We independently confirmed the host-memory corruption and the denial-of-service primitive on AlmaLinux 9 and Ubuntu 24.04, though we have not reproduced the complete escape chain. On RHEL-family systems where /dev/kvm is world-accessible, the same bug serves as local privilege escalation to root. Jump to the long version →

Status: Fixed upstream (commit 81ccda30b4e8, merged to mainline June 2026). NVD published the CVE on July 4, 2026, and the embargo lifted July 6. It was a zero-day kvmCTF submission; for defenders today it is an N-day with a public proof-of-concept. Jump to the long version →

Severity: NVD had not assigned a CVSS score at publication. The missing score is not a signal of low impact. Score it internally as high and do not wait for a colored box. Jump to the long version →

Who’s affected: KVM/x86 hosts, Intel and AMD, that expose nested virtualization to guests. The escape path needs one thing beyond guest root: nested virtualization. Jump to the long version →

Related flaw: Januscape needs a second fix, CVE-2026-46113, to fully close. Patching the earlier flaw alone does not stop Januscape. Jump to the long version →

Do this now: Patch affected KVM hosts with a fixed kernel or a rebootless patch. Hosts that run no VMs can unload and block the KVM modules. Hosts that run VMs but do not need nested virtualization should disable it, which removes the untrusted-guest escape path. Hosts that need both cannot be closed by config alone. Jump to the long version →

Need to Patch KVM Hosts Without Rebooting Every VM?

KernelCare applies Linux kernel security patches without downtime, workload disruption, or emergency maintenance windows.
KernelCare status: As of July 7, 2026, rebootless patches covering both CVE-2026-53359 and its required companion CVE-2026-46113 are shipping together for several kernel families, with more in active development. Full release state and K-tags are listed below.

Get KernelCare →

The Long Version

Januscape attacks the central promise of virtualization.

A guest VM may be compromised, customer-controlled, obsolete, intentionally hostile, or just misconfigured. None of that should let it touch memory belonging to the host. KVM’s job is to translate guest memory safely while holding that separation. Januscape breaks the bookkeeping behind the translation.

The bug lives in arch/x86/kvm/mmu/mmu.c, in the KVM shadow MMU. This code maintains the host-side page-table structures that map addresses a guest uses onto memory the host has authorized. Under a controlled sequence of guest mapping changes, KVM reuses an existing shadow page even though its recorded role no longer matches the mapping being built. That reuse leaves a reverse-map entry pointing at a structure KVM later frees, and a subsequent reverse-map walk dereferences the freed page.

One point up front, because it decides who is exposed. This is not a data race in the classic sense, and it is not the same defect as its sibling. The kernel classifies Januscape as a use-after-free caused by an unexpected shadow-page role. The trigger involves changing a guest mapping asynchronously, from outside the guest’s own page walk, so hitting the window takes timing pressure. But the root cause is a missing comparison, not a lock bug. Keep that distinction, because the fix and the mitigations follow from it.

How Januscape Works

At a high level:

[Guest with root + nested virtualization exposed]
│  forces KVM back through the legacy shadow MMU
▼
[Guest creates a large 2 MB mapping → KVM builds a direct shadow page]
│
▼
[Guest rewrites the mapping to a 4 KB page-table path]
│  new mapping needs a non-direct (direct=0) page
▼
[kvm_mmu_get_child_sp() reuses the old direct page – gfn matches, role NOT compared]
│
▼
[Cleanup computes the wrong frame number → reverse-map entry not removed]
│
▼
[Shadow page freed; stale reverse-map entry left behind]
│  later rmap walk (dirty logging / MMU-notifier invalidation)
▼
[Use-after-free write of a fixed marker into freed memory]
▼
[Host crash (public PoC)  →  or guest-to-host escape, root on host (withheld exploit)]

Walking that path in detail: the sequence starts with a guest page-directory entry describing a large 2 MB mapping. KVM builds a kvm_mmu_page covering 512 individual 4 KB entries and, because the guest mapping is a contiguous large page, marks the shadow page direct.

The mapping is then changed outside the guest’s normal execution flow. Instead of a large page, the same page-directory entry now points to another page table holding individual 4 KB mappings. KVM needs a different kind of shadow page for that structure: the original has a direct role, the new mapping needs a non-direct one. The vulnerable kvm_mmu_get_child_sp() path does not compare that full role before deciding to reuse the existing page. The frame number matches, so the page is accepted, and KVM installs a new leaf entry and records a reverse-map entry for the frame resolved through the new walk.

The damage surfaces during cleanup. Because the reused parent page still claims to be direct, KVM computes the frame for the new 4 KB entry as sp->gfn + index instead of using the stored shadowed translation. It then searches for the reverse-map entry under the wrong frame number and fails to remove it. The shadow page is freed, and the stale reverse-map entry stays behind. Any later operation that walks that reverse map dereferences an entry inside the freed page. The kernel record names dirty logging and MMU-notifier invalidation as the operations that do this.

There is a detail that explains both the public PoC and the withheld exploit. During teardown, KVM writes a fixed marker constant into what may now be reallocated memory. That is a real use-after-free write, but a constrained one: a fixed value at an address the attacker has to line up with a useful kernel object. Racing that alignment reliably is hard, which is why the public code stops at crashing the host and the full escape has not been released.

The guest reaches this code through nested virtualization. On a modern host running guests on hardware paging (EPT on Intel, NPT on AMD), the software shadow MMU is not normally exercised. Exposing nested virtualization is what forces KVM back through the legacy shadow MMU, which is where Januscape sits. That is the reason a host can look modern and still be squarely in scope.

What We Confirmed

Our testing confirmed the vulnerable state is reachable on both an Enterprise Linux kernel and Ubuntu 24.04. We reproduced the host-DoS and the memory corruption. We did not run the end-to-end escape, which is the researcher’s withheld exploit.

On AlmaLinux 9 with kernel 5.14.0-687.5.3.el9_8, the trigger reached a fatal kernel BUG in pte_list_remove(). The host panicked within seconds to minutes while the active process was qemu-kvm. That is a reliable guest-triggered host denial of service on the tested kernel.

On Ubuntu 24.04 with kernel 6.8.0-111-generic, the same corruption produced a warning rather than an immediate panic. The kernel reported a GFN mismatch in kvm_mmu_page_set_translation() – the root-cause frame confusion becoming visible – followed by a downstream pte_list_remove() warning. The host survived because those consistency checks are warning-class on this Ubuntu build rather than fatal BUG checks, so it kept running with a corrupt shadow-MMU state (Tainted: G W).

A surviving warning is not safety. It means the host-managed translation state went inconsistent and the machine limped past its own assertion. For controlled crash-dump collection, you can make warning-class reproductions fatal:

sudo sysctl kernel.panic_on_warn=1

That is a testing and vmcore aid. It is not a mitigation.

What the Upstream Fix Changes

The fix adds the missing role check before KVM reuses a shadow page. Before the patch, a matching guest frame number could be enough to accept an existing page. After it, kvm_mmu_get_child_sp() compares the page’s full role (role.word) alongside the frame number, and reuses a page only when both match. When the role is incompatible, KVM zaps the existing entry and builds the correct shadow page instead of carrying a stale interpretation forward. KVM maintainers Paolo Bonzini and Sean Christopherson wrote the patch.

Conceptually:

Before:  matching gfn → reuse shadow page → role mismatch ignored → stale reverse map → use-after-free
After:   matching gfn → compare role.word → reject incompatible page → zap old entry → build correct page

The upstream Januscape fix is commit 81ccda30b4e83d8f5cc4fd50503c44e3a33abfeb. Its companion, the CVE-2026-46113 fix, is commit 0cb2af2ea66ad8ff195c156ea690f11216285bdf. Each closes a different stale-shadow-page condition, so both belong in a patched kernel.

Vendor and rebootless-patch records do not always label them separately. Some earlier KernelCare builds shipped the Januscape role fix as a non-CVE’d companion under the CVE-2026-46113 label, so the absence of a distinct CVE-2026-53359 string does not by itself mean the role fix is missing.

The Sibling: CVE-2026-46113

Januscape did not appear alone. Before it was fixed, kernel developers closed CVE-2026-46113, another KVM/x86 shadow-paging use-after-free in the same part of the MMU. The two flaws should be discussed together and never conflated, because the two fixes cover different holes and a host needs both.

CVE-2026-46113 happens when KVM reuses a shadow page built for the wrong guest frame number. A guest mapping changes between VM entries, KVM keeps using a shadow page built for the original mapping, and a new page-table entry gets recorded under a frame outside the range KVM later searches during cleanup. The cleanup misses it. The shadow page is freed. The stale reverse-map entry survives. A later reverse-map walk dereferences the freed page.

The CVE-2026-46113 fix, commit 0cb2af2ea66a, added a guest-frame-number check: when KVM sees that an existing page belongs to the wrong frame, it zaps the old entry instead of reusing it. Januscape showed that check was not enough.

In the Januscape path the frame number can look correct. The mismatch is in the shadow page’s role:

  • The original mapping creates a direct shadow page for a large 2 MB mapping (direct=1).
  • The guest changes that mapping to point through a lower-level page table.
  • The new path needs a non-direct shadow page for 4 KB mappings (direct=0).
  • KVM finds a matching frame number and reuses the old page.
  • The frame matches, but the interpretation of the page does not.

CVE-2026-46113 closed the wrong-frame case. Januscape closed the wrong-role case. The earlier fix is context; Januscape is the vulnerability this article is about. Taking the earlier patch alone does not close Januscape.

Who Is Affected

Januscape affects Linux systems using the KVM/x86 shadow MMU. That includes both Intel and AMD hosts, because the vulnerable code sits in the shared KVM/x86 MMU logic rather than in kvm_intel or kvm_amd alone. The researcher demonstrated the same trigger on both, swapping only the architecture-specific page-table bits. Several distinctions decide how exposed a given host is.

KVM hypervisors running guests with nested virtualization. Highest priority. A malicious or compromised guest with root in its own VM can reach the vulnerable host-kernel path through nested virtualization. This is the guest-to-host escape scenario, and it is where a single rented instance can crash the physical host or, with the withheld exploit, take over co-located guests. In our lab the guest reproduction loads a module that drives raw VMX/SVM state, which is exactly the nested-virt path.

KVM hosts that run guests but do not expose nested virtualization. Lower exposure to the guest-to-host vector, because the software shadow MMU is not being forced into play for those guests. Confirm that nested virt is actually off before relying on this.

Hosts with KVM available but no running VMs. These can still expose a local path if an untrusted local user can open /dev/kvm and drive KVM directly. If KVM is unused, unload and block the modules.

Containers and CloudLinux LVE. A normal container does not automatically have KVM access. Container and LVE environments are not vulnerable merely because they share a host kernel. Exposure depends on whether the container can reach /dev/kvm, control QEMU, or use nested virtualization. We have not tested these environments and are not calling them clear by inheritance. Check the actual device and privilege configuration.

Enterprise kernel versions. Do not decide exposure from uname -r alone. Enterprise distributions backport KVM changes into older baselines, so a 5.14-based EL9 kernel carries the affected MMU logic while a numerically newer kernel may already hold a targeted backport. Confirm the vendor fix, KernelCare coverage, or the source pattern for the exact running kernel.

The version trap here runs backward from the usual one. It is not “our kernel is too old.” It is “our hardware is too new.” A host on EPT or NPT feels modern and safe right up until it exposes nested virtualization and quietly routes guests back through 16-year-old shadow-MMU code. Reason from what the host exposes, not from the silicon it runs on.

Check the KVM Attack Surface

Check whether KVM modules are loaded:

lsmod | grep -E '^kvm|kvm_(intel|amd)'

Check whether the KVM device exists and who can reach it:

ls -l /dev/kvm

Check for active QEMU/KVM workloads:

pgrep -a -f 'qemu-system|qemu-kvm'

Check whether nested virtualization is enabled:

cat /sys/module/kvm_intel/parameters/nested   # Intel
cat /sys/module/kvm_amd/parameters/nested      # AMD

For libvirt-managed hosts:

virsh list --all

These commands tell you whether KVM is exposed, in use, and exposing nested virt. They do not prove whether Januscape is patched.

Mitigate Now

There are real config mitigations here, and each closes a specific vector. None of them closes all of them, which is the whole point.

Hosts that do not run VMs. If the system does not need KVM, unload the modules and block them from loading. Use install … /bin/false rather than a plain blacklist line, because blacklist alone does not stop an explicit or dependency-driven load.

# unload now (fails if a VM is running, in which case this host isn't a candidate)
sudo modprobe -r kvm_intel kvm      # kvm_amd on AMD hardware

# prevent load on boot
printf 'install kvm_intel /bin/false\ninstall kvm_amd /bin/false\n' \
| sudo tee /etc/modprobe.d/disable-kvm.conf

Verify with lsmod | grep kvm returning nothing and ls /dev/kvm reporting no such file. To revert, delete /etc/modprobe.d/disable-kvm.conf and modprobe kvm_intel (or kvm_amd), or reboot.

Hosts that run VMs but do not need nested virtualization. This is the strongest mitigation short of the patch. Turning nested virt off removes the guest-to-host path, because the shadow MMU only comes into play for nested guests:

# Intel
echo 'options kvm_intel nested=0' | sudo tee /etc/modprobe.d/disable-nested-virt.conf
# AMD
echo 'options kvm_amd nested=0' | sudo tee /etc/modprobe.d/disable-nested-virt.conf

The change takes effect after the KVM module is reloaded (which requires no running VMs) or after a reboot. Confirm with cat /sys/module/kvm_intel/parameters/nested returning N or 0.

RHEL-family hosts that must keep VMs and nested virt. On these distros /dev/kvm ships world-accessible (mode 0666), which is what lets an unprivileged local user drive the bug directly. Tighten it:

echo 'KERNEL=="kvm", GROUP="kvm", MODE="0660"' \
| sudo tee /etc/udev/rules.d/65-kvm.rules
sudo udevadm control --reload-rules
sudo udevadm trigger --name-match=kvm

Verify with ls -l /dev/kvm and getent group kvm, and put only accounts that need KVM into the kvm group. This closes the unprivileged-local vector. It does not stop a malicious guest, which reaches the shadow MMU through its authorized QEMU process regardless of host device permissions.

Decision moment. If a host runs no guests, unload and block KVM. If it runs guests that do not need nested virt, disable nested virt now and patch on your normal cadence. If it runs untrusted guests and needs nested virt – multi-tenant cloud, hosting, CI that builds nested VMs – no config change fully covers you, so move a rebootless patch or a fixed kernel to the front of the queue. And treat a warning-only reproduction as confirmation of exposure, not evidence of safety.

Detection

Januscape leaves no reliable on-disk signature. The corruption happens in host-kernel memory while KVM manages shadow page tables and reverse mappings, so file-integrity tooling can stay clean even after the vulnerable state is triggered. That pushes detection into behavioral territory, and each of the following is a lead, not proof.

  • Kernel BUGs or warnings in arch/x86/kvm/mmu/mmu.c, especially involving pte_list_remove().
  • GFN-mismatch messages, or warnings from kvm_mmu_page_set_translation() – the role and frame confusion becoming visible before the free.
  • Host panics or repeated crashes while qemu-kvm or qemu-system-* is active, with no matching hardware failure.
  • A kernel tainted with W following a KVM MMU warning.
  • Nested-virtualization activity where you did not expect it, or /dev/kvm accessed by unusual accounts or processes.
  • A local host account or service gaining privileges shortly after a burst of KVM-MMU instability, with no matching sudo or login event.

Review recent kernel messages:

journalctl -k --since "24 hours ago" \
| grep -Ei 'kvm|mmu|gfn|pte_list_remove|BUG|WARNING'

Review the current boot:

dmesg -T | grep -Ei 'kvm|mmu|gfn|pte_list_remove|BUG|WARNING'

The absence of these messages does not prove the host is patched. An attacker can avoid tripping the consistency check, and a vulnerable path may simply not have been exercised yet. If untrusted guests run on an exposed host and you see KVM-MMU instability, treat the host as warranting a closer look – new accounts, altered auth config, unexpected services on the host – rather than reading clean guest file hashes as evidence the host is fine.

Why Januscape Matters

Januscape is a different class of problem from a local kernel privilege-escalation bug. A conventional local LPE needs the attacker to already have code execution on the host. A guest escape starts from code the organization deliberately allowed to run inside a VM, on the assumption that KVM would contain it. Removing that assumption is the whole event.

That is why this lands hardest where guest isolation is the product: public and private clouds, hosting providers, multi-tenant clusters, CI and build infrastructure, security-research environments, developer clouds, and any platform running customer-controlled VMs. The age of the underlying assumption widens it. The behavior traces back to 2010 and has been carried through many enterprise kernel generations, so “we run a modern distro” is not a defense.

The reason it is easy to misjudge is the reason it is dangerous. Three plausible signals all point toward “safe” and all mislead. Hardware EPT or NPT feels like it retired the shadow MMU, but nested virtualization drags guests right back into it. The GFN fix (CVE-2026-46113) feels like it closed this corner of the MMU, but it closed the other half of the defect and left the role case open. And a PoC that only crashes a box you own reads like harmless self-DoS, when the crash is the public demonstration rather than the ceiling. Trust any one of them and you file a vulnerable host as clear.

The relationship with CVE-2026-46113 is the sharpest source of false confidence. A team that patched the earlier unexpected-GFN use-after-free may conclude the shadow-paging issue is handled. It is not. The earlier fix checked whether KVM had found the right frame. Januscape showed KVM also had to verify it had found the right kind of shadow page. One match was not enough, and one CVE closed is not both.

Prioritized Remediation Checklist

  1. Track this as CVE-2026-53359 (Januscape), not CVE-2026-46113.
  2. Confirm affected hosts carry both the Januscape fix and the companion CVE-2026-46113 fix. Both are required.
  3. Inventory hosts with KVM modules loaded, /dev/kvm present, or active QEMU workloads, and flag which expose nested virtualization.
  4. Prioritize multi-tenant hosts and any host running untrusted guests with nested virt enabled.
  5. Disable KVM entirely on hosts that do not use virtualization.
  6. Disable nested virtualization where it is not needed – it removes the untrusted-guest escape path.
  7. Restrict /dev/kvm to trusted accounts and the kvm group on RHEL-family hosts. This stops the local-unprivileged vector only, not a malicious guest.
  8. Verify AMD hosts explicitly – they are affected even where an Intel-only test came back quiet.
  9. Do not infer safety from the kernel version alone, and treat a warning-only reproduction as exposure.
  10. Hunt for KVM GFN warnings, pte_list_remove() failures, and unexplained host panics, and treat clean guest file hashes as insufficient evidence about the host.
  11. Apply a fixed vendor kernel and reboot, or use the KernelCare rebootless patch for the exact running kernel, prioritizing the hosts hardest to reboot.
  12. Verify explicit CVE coverage for both fixes rather than relying on build dates.

Rebootless Patching

Januscape is the kind of hypervisor bug that stays exposed long after a fixed package is available. Installing the package is only step one. The host still has to boot into the replacement kernel, and on a KVM cluster that means draining nodes, migrating guests, coordinating tenants, holding capacity margins, and rotating machines through maintenance. Those constraints can stretch a known guest escape into weeks or months of residual exposure, and they are heaviest on exactly the multi-tenant hosts most at risk.

The change is a good rebootless-patch candidate: a small correction in the MMU fault and reverse-map path with no persistent state to carry across. KernelCare ports both required fixes – the Januscape role fix (81ccda30b4e8) and the companion GFN fix (0cb2af2ea66a) – into the running kernel together, with variants per kernel family for the EL 5.14 backport lines and the mainline-based 6.x kernels. LibCare does not apply, because this is a kernel-only bug with no userspace-library component.

Release state as of July 29, 2026.

KernelCare ships the Januscape role fix and the required CVE-2026-46113 companion fix together, so availability is stated per kernel family rather than per CVE.

Stable, fully promoted

RHEL 10 – patchset K20260703_15

Oracle Linux 10 – K20260703_16

Rocky Linux 10 – K20260703_17

AlmaLinux 10 – K20260703_18

Debian 13 – K20260706_09

Ubuntu 22.04 – K20260706_01 (_02 for arm64, _03 for Azure, _04 for AWS)

Ubuntu 20.04 on the Jammy HWE kernel – K20260706_06 (Azure: _05, AWS:  _07)

Ubuntu 24.04 – K20260707_01 (AWS: _02)

Proxmox VE 7 (5.15) – K20260706_08

Proxmox VE 8 (6.8) – K20260707_03

Enterprise Linux 9, released July 2026

RHEL 9 – K20260710_58

AlmaLinux 9 and CloudLinux 9 – K20260710_60

Oracle Linux 9 – K20260710_63

Rocky Linux 9 – K20260710_65

Staged rollout

Debian 12 – K20260709_25

Debian 11 – K20260710_11

Ubuntu 20.04 standard kernel – K20260710_10

CloudLinux 8 – K20260709_27

In testing

RHEL 8 – K20260710_31

AlmaLinux 8 – K20260710_41

Rocky Linux 8 – K20260710_43

CentOS 8 – K20260710_33

Oracle Linux 8 – K20260710_35

CloudLinux 7 hybrid – K20260710_39

Still open

Oracle UEK6, Oracle UEK7, Amazon Linux 2, Ubuntu 18.04.

Enterprise Linux 7 is affected but not scheduled for a patch. The practical impact there is denial of service only: a tenant-to-host DoS is impractical because nested VMX is slow enough to make the race unreliable, and the local privilege-escalation path is gated by CONFIG_BUG_ON_DATA_CORRUPTION. Hosts on EL7 should still use the configuration mitigations above.

Enterprise Linux 9 coverage has landed for RHEL 9, AlmaLinux 9 and CloudLinux 9, Oracle Linux 9, and Rocky Linux 9. That matters because EL9 is the platform that took a fatal host panic in our lab, so exposed EL9 hosts remain the first ones to patch — but they no longer have to sit behind configuration mitigations while waiting for a patch to exist. The remaining uncovered platforms are Oracle UEK6 and UEK7, Amazon Linux 2, and Ubuntu 18.04; those hosts still depend on the mitigations above or a fixed vendor kernel.

Apply from the testing feed:

sudo kcarectl --update --prefix test

Apply from the production feed once promoted:

sudo kcarectl --update

Confirm the running patch build:

kcarectl --info | grep kpatch-build-time      # build dated 2026-07 or later

Because Januscape needs both fixes, confirm both are present rather than trusting a date:

kcarectl --patch-info | grep -E
'CVE-2026-53359|CVE-2026-46113'

Two hits is a clean answer. A hit on CVE-2026-46113 alone is not, on its own, evidence that the role fix is absent, because of the labeling history noted earlier — in that case check the installed K-tag against the release list above, or the KernelCare coverage record for that kernel family. A build date alone proves nothing. A kernel compiled after mid-June does not automatically carry this fix, and it does not guarantee both fixes are present. Verify the CVE mapping, the K-tag, the vendor erratum, or the source directly.

Januscape turns a subtle KVM shadow-page mismatch into a failure of the guest-host boundary. For virtualization fleets that cannot absorb emergency reboots, a rebootless patch closes that boundary in the running kernel without draining every node or interrupting its guests.

Get KernelCare today →

References

Join 4,500+ Linux & Open Source Professionals!

2x a month. No spam.

Table of Contents
Get the open-source security answers you need

Join 4,500+ Linux & Open Source Professionals!

2x a month. No spam.