Researchers have disclosed a flaw in KVM — the Kernel-based Virtual Machine built into the Linux kernel — that allowed them to read roughly 127 GB of memory from a cloud host, from inside a virtual machine they controlled, in testing against DigitalOcean infrastructure. On a shared multi-tenant host, that memory can include the contents of other customers' virtual machines: credentials, TLS private keys, database contents, session tokens, and anything else resident in RAM.
The flaw is tracked as CVE-2026-99312. It affects only hosts meeting two conditions simultaneously: AMD processors and nested virtualization enabled. Patched kernels have shipped. If you operate AMD-based hypervisors — whether you're a cloud provider, a hosting company, an enterprise running KVM/OpenStack/Proxmox on EPYC hardware, or a red-team lab using nested virt — this is a patch-this-week event. If you are a tenant of AMD-based cloud infrastructure, you have a different problem: you cannot patch your way out, and you need to assess your provider's exposure and your data-at-risk.
Cross-VM memory disclosure is the nightmare scenario for multi-tenant infrastructure. It breaks the fundamental isolation boundary that cloud economics are built on.
Technical Analysis
What's affected
| Attribute | Detail |
|---|---|
| CVE | CVE-2026-99312 |
| Component | KVM (Kernel-based Virtual Machine), Linux kernel |
| CPU requirement | AMD processors only (Zen-family EPYC/Ryzen/Threadripper hosts) |
| Configuration requirement | Nested virtualization enabled on the host (kvm_amd nested=1) |
| Attack vector | Malicious/controlled guest VM reads host physical memory |
| Impact | Confidentiality — cross-VM / guest-to-host memory disclosure |
| Demonstrated impact | ~127 GB of host memory read from a single guest on DigitalOcean |
| Intel hosts | Not affected |
| Hosts with nested virt disabled | Not affected by this CVE |
How the vulnerability works — defender's view
Nested virtualization allows a guest VM (L1) to itself act as a hypervisor and run its own guests (L2). To do this, KVM's AMD module (kvm_amd) emulates AMD-V (SVM) behavior for the L1 guest, including the machinery around Nested Page Tables (NPT) — the second-level address translation that maps guest physical addresses to host physical addresses.
The flaw lives in that emulation path. When nested virtualization is enabled, the L1 guest gains influence over how second-level translation structures are constructed and walked for L2 execution. The bug allows a guest to abuse this path to cause the hypervisor to map or leak host physical memory it has no right to access — memory belonging to the host kernel, QEMU processes of other tenants, or other guests' RAM. Because this is a translation/isolation failure rather than a code-execution bug, exploitation is quiet: there is no crash, no corruption, no obvious anomaly. A patient attacker can sit in a cheap cloud VM and slowly siphon the host's entire physical address space, then grep it offline for secrets.
Key exploitation characteristics:
- Requires a guest on the host. This is not remotely exploitable from the network. The attacker needs a VM on the target host — trivially satisfied on any public cloud by renting one.
- Requires nested virtualization to be enabled on the host. Many cloud providers enable this to support customers who run their own hypervisors (CI runners, Android emulators, Windows Sandbox/WSL2-style workloads, security sandboxes).
- AMD-only. Intel's VMX/EPT path is not implicated.
- Read primitive, not (publicly) write. The disclosed capability is memory reading. That is sufficient to steal keys and pivot — read the host page cache, QEMU memory of neighboring VMs, or kernel memory containing credentials.
- Low forensic footprint. Memory disclosure via hardware-assisted virtualization paths generates almost no traditional telemetry. Do not expect to catch this with generic EDR rules on the host — your primary defense is patching and disabling nested virt, with detection as a compensating layer.
Exploitation status
- The flaw was demonstrated by researchers against production cloud infrastructure (DigitalOcean) with a 127 GB read — this is a working, proven exploit, not a theoretical paper bug.
- At time of writing, no mass in-the-wild exploitation campaign has been publicly confirmed, and the CVE had not been listed in CISA's Known Exploited Vulnerabilities catalog — but a public, working guest-to-host memory read on shared infrastructure should be treated as exploitation imminent. Cloud tenants do not announce themselves.
Who is at risk
- Cloud and hosting providers running AMD EPYC fleets with nested virt enabled — direct cross-tenant exposure.
- Enterprises running KVM, OpenStack, Proxmox VE, oVirt, or libvirt-based virtualization on AMD hardware with nested enabled (labs, CI/CD runners, malware analysis sandboxes are common offenders).
- Cloud tenants whose workloads ran on affected AMD hosts — your VM's memory may already have been exposed. Treat long-lived secrets in memory (TLS keys, API keys, DB credentials) as potentially compromised if your provider was unpatched.
Detection & Response
Honest framing first: you will not reliably detect the memory read itself with a Sigma rule. The read happens in hardware translation paths below the OS's visibility. What you can detect and hunt for:
- Hosts that are vulnerable (AMD + nested enabled + unpatched kernel) — your highest-value "detection."
- Changes that enable nested virtualization (a pre-condition an attacker with host access would need, or a misconfiguration drift).
- Guest-side artifacts consistent with KVM exploitation tooling (nested virt module loads inside guests, suspicious use of
/dev/kvm, L2 guest creation in tenant VMs that have no business running hypervisors).
SIGMA Rules
---
title: KVM Nested Virtualization Enabled or Modified on AMD Host
id: 3f9a1c72-8b4e-4d21-9a67-2c5e8f103491
status: experimental
description: Detects loading or reconfiguration of the kvm_amd kernel module with nested virtualization parameters, a pre-condition for CVE-2026-99312 exploitation and a potential indicator of misconfiguration drift on AMD hypervisors.
references:
- https://thehackernews.com/2026/11/new-linux-kvm-flaw-cve-2026-99312-lets.html
- https://attack.mitre.org/techniques/T1068/
author: Security Arsenal
date: 2026/11/10
tags:
- attack.privilege_escalation
- attack.t1068
logsource:
category: process_creation
product: linux
detection:
selection_module:
Image|endswith:
- '/modprobe'
- '/insmod'
CommandLine|contains:
- 'kvm_amd'
selection_param:
CommandLine|contains:
- 'nested=1'
- 'nested=y'
- 'nested=on'
- 'npt=1'
condition: selection_module and selection_param
falsepositives:
- Legitimate hypervisor provisioning and lab configuration
- Automation that intentionally enables nested virt for CI/CD or sandboxing
level: medium
---
title: KVM Module Configuration Modified to Enable Nested Virtualization
id: 61b2d804-5c97-4a3f-b812-9e04d7a2c158
status: experimental
description: Detects writes to modprobe.d or sysfs kvm_amd nested parameter files, indicating nested virtualization being enabled persistently or at runtime — the enabling condition for CVE-2026-99312.
references:
- https://thehackernews.com/2026/11/new-linux-kvm-flaw-cve-2026-99312-lets.html
- https://attack.mitre.org/techniques/T1562/
author: Security Arsenal
date: 2026/11/10
tags:
- attack.defense_evasion
- attack.t1562
logsource:
category: file_event
product: linux
detection:
selection_path:
TargetFilename|contains:
- '/etc/modprobe.d/'
- '/sys/module/kvm_amd/parameters/nested'
selection_content:
TargetFilename|contains:
- 'kvm'
condition: selection_path or selection_content
falsepositives:
- Configuration management (Ansible/Puppet) applying intended hypervisor settings
level: medium
---
title: Unexpected KVM Device Access Inside Guest Workload VMs
id: 84c1f2a9-6d3b-4e58-aa14-7f02c9b5e673
status: experimental
description: Detects processes opening /dev/kvm or spawning hypervisor tooling (qemu, kvm) inside guest VMs that are not designated hypervisor/sandbox hosts — consistent with guest-side setup for nested-virtualization abuse such as CVE-2026-99312.
references:
- https://thehackernews.com/2026/11/new-linux-kvm-flaw-cve-2026-99312-lets.html
- https://attack.mitre.org/techniques/T1068/
author: Security Arsenal
date: 2026/11/10
tags:
- attack.privilege_escalation
- attack.t1068
logsource:
category: process_creation
product: linux
detection:
selection:
Image|endswith:
- '/qemu-system-x86_64'
- '/qemu-kvm'
- '/kvm'
- '/virt-install'
filter_known_hypervisors:
CommandLine|contains:
- '-machine q35' # refine to your approved VM templates
condition: selection and not filter_known_hypervisors
falsepositives:
- Legitimate nested-virt tenants (CI runners, Android emulator farms, sandbox services)
- Tune aggressively against an allowlist of hosts approved to run L2 guests
level: high
KQL (Microsoft Sentinel — via Syslog/CEF ingestion from Linux hosts)
Assumes hypervisors and guests forward syslog/auditd to Sentinel. This hunt surfaces both the vulnerability pre-condition and suspicious guest-side hypervisor activity.
// Hunt 1: Hosts loading kvm_amd with nested virtualization enabled (pre-condition for CVE-2026-99312)
Syslog
| where TimeGenerated > ago(30d)
| where ProcessName in~ ("modprobe", "insmod", "kernel")
| where SyslogMessage has_any ("kvm_amd", "kvm: nested")
| where SyslogMessage has_any ("nested=1", "nested=y", "nested virtualization", "npt=1")
| project TimeGenerated, Computer, ProcessName, SyslogMessage, HostIP
| order by TimeGenerated desc;
// Hunt 2: Guest VMs spawning hypervisor tooling (unexpected /dev/kvm consumers)
Syslog
| where TimeGenerated > ago(14d)
| where SyslogMessage has_any ("/dev/kvm", "qemu-system", "qemu-kvm")
| where ProcessName !in~ ("libvirtd", "virtqemud", "qemu-system-x86_64") // known host daemons
| summarize FirstSeen=min(TimeGenerated), LastSeen=max(TimeGenerated), Events=count(), SampleCommands=make_set(SyslogMessage, 10)
by Computer, ProcessName, HostIP
| order by Events desc;
// Hunt 3: Kernel version inventory — flag unpatched AMD KVM hosts (adjust fixed version per your distro advisory)
// Expected kernel release strings pushed via heartbeat/custom log or Syslog banner
Syslog
| where TimeGenerated > ago(1d)
| where SyslogMessage has "Linux version"
| extend KernelVersion = extract(@"Linux version ([0-9\.\-]+)", 1, SyslogMessage)
| distinct Computer, KernelVersion
| where KernelVersion startswith "5." or KernelVersion startswith "6.0" // example: flag legacy kernels; tighten to your fleet baseline
| project Computer, KernelVersion;
Velociraptor VQL — Fleet-Wide Vulnerability Posture Hunt
Deploy this as a hunt across Linux hosts to enumerate every endpoint that is (a) AMD-based, (b) has KVM loaded, and (c) has nested virtualization enabled — your actionable exposure list for CVE-2026-99312.
-- CVE-2026-99312 Exposure Hunt: AMD hosts with kvm_amd nested virtualization enabled
SELECT Hostname,
read_file(filename='/proc/cpuinfo') =~ 'AuthenticAMD' AS IsAMD,
read_file(filename='/sys/module/kvm_amd/parameters/nested') AS NestedParam,
read_file(filename='/proc/sys/kernel/osrelease') AS KernelRelease,
read_file(filename='/proc/modules') =~ 'kvm_amd' AS KvmAmdLoaded
FROM info()
WHERE read_file(filename='/proc/cpuinfo') =~ 'AuthenticAMD'
AND read_file(filename='/proc/modules') =~ 'kvm_amd'
A companion artifact to find guests running their own hypervisors (potential L1 abusers or legitimate nested tenants to inventory):
-- Find processes bound to /dev/kvm or running QEMU inside the estate
SELECT Pid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE CommandLine =~ 'qemu|/dev/kvm|kvm-amd|nested'
OR Exe =~ 'qemu-system|qemu-kvm'
Remediation
1. Patch — the only complete fix
Fixed kernels have shipped. Apply your distribution's current kernel update and reboot the host (a hypervisor flaw in a loaded kernel module is not fixed until the new kernel is running — live patching may not cover this path; check your vendor's note). Identify your running kernel and compare against the fixed versions published in your distro advisory:
- Ubuntu:
usn.ubuntu.com— current USN kernel updates for your release - RHEL/CentOS/Rocky/Alma:
access.redhat.com/security/cve/CVE-2026-99312 - Debian:
security-tracker.debian.org - SUSE:
suse.com/security/cve/CVE-2026-99312.html - Upstream: kernel.org stable tree announcements
2. Verify and remediate with this script
Run on every AMD host (or push via your config management). It reports exposure, disables nested virt as an immediate workaround, and verifies kernel state:
#!/bin/bash
# CVE-2026-99312 — KVM AMD nested-virt exposure check & interim hardening
# Run as root on every AMD virtualization host.
set -u
echo "=== CVE-2026-99312 Exposure Assessment ==="
# 1. CPU vendor
grep -q AuthenticAMD /proc/cpuinfo && echo "[INFO] AMD CPU detected" || { echo "[OK] Non-AMD host — not affected"; exit 0; }
# 2. kvm_amd loaded?
if ! lsmod | grep -q '^kvm_amd'; then
echo "[OK] kvm_amd not loaded — host not running KVM on AMD"
exit 0
fi
# 3. Nested virt state
NESTED=$(cat /sys/module/kvm_amd/parameters/nested 2>/dev/null || echo "unknown")
echo "[INFO] kvm_amd nested parameter: ${NESTED}"
echo "[INFO] Running kernel: $(uname -r)"
echo "[ACTION] Confirm this kernel is at or above the fixed version in your distro advisory for CVE-2026-99312."
# 4. IMMEDIATE WORKAROUND: disable nested virtualization (breaks L2 guests!)
if [ "$NESTED" = "1" ] || [ "$NESTED" = "Y" ]; then
echo "[WARN] Host is VULNERABLE if kernel is unpatched (AMD + nested enabled)"
echo "[ACTION] Disabling nested virt at runtime (no reboot required)..."
echo 0 > /sys/module/kvm_amd/parameters/nested
# Persist across reboots
cat > /etc/modprobe.d/kvm-amd-cve-2026-99312.conf <<'EOF'
# CVE-2026-99312 workaround — remove after patched kernel is deployed
options kvm_amd nested=0
EOF
echo "[OK] Nested virtualization disabled (runtime + persistent via /etc/modprobe.d/kvm-amd-cve-2026-99312.conf)"
else
echo "[OK] Nested virtualization already disabled — CVE-2026-99312 not exploitable on this host"
fi
# 5. Inventory tenants using nested virt (impact of the workaround)
echo "[INFO] Checking for active L2 (nested) guests that would be affected:"
ps aux | grep -E 'qemu-system' | grep -v grep | awk '{print " QEMU PID:", $2, $11, $12, $13}' || true
echo "=== Done. Reboot into the patched kernel at the earliest maintenance window. ==="
3. The workaround: disable nested virtualization
If you cannot patch immediately, disabling nested virt fully mitigates this CVE — the vulnerable code path is unreachable with nested=0. Cost: any tenant workloads that themselves run hypervisors (CI runners, emulators, WSL2-style use cases, security sandboxes) will fail. For most production hypervisor fleets, nested virt was enabled opportunistically and nothing will break. For providers selling nested-virt as a feature, schedule the kernel patch instead.
4. Cloud tenant actions
If you consume AMD-based cloud VMs rather than operate hypervisors:
- Ask your provider (in writing, through your TAM/support channel) whether their AMD fleet was exposed to CVE-2026-99312, when patched, and whether nested virt was enabled on hosts running your workloads.
- Rotate secrets that lived in guest memory during the exposure window if your provider confirms delayed patching: TLS private keys, API keys, database credentials, session signing keys.
- Prefer confidential-computing instance types (AMD SEV-SNP) for sensitive workloads — hardware memory encryption between tenants raises the bar substantially against exactly this class of host-side memory disclosure.
- Review your cloud architecture's blast radius assumptions: multi-tenant memory disclosure is a recurring failure mode, not a one-off.
5. Longer-term hardening
- Treat nested virt as a gated feature. Default
nested=0everywhere; enable per-cluster with a documented business reason and a tracking ticket. - Kernel currency on hypervisors is a Tier-1 control. Hypervisor kernels should ride your fastest patch ring, not your slowest — the isolation boundary is the thing every other control assumes.
- Vulnerability scan for the condition, not just the CVE. Your VM tooling should report "AMD + kvm_amd + nested=1 + kernel < fixed" as a compound finding; Velociraptor hunt above operationalizes this.
- Segment bare-metal pools by sensitivity: don't co-locate high-value tenants (payments, healthcare) with arbitrary public tenants on the same AMD hosts until patched.
Bottom Line
CVE-2026-99312 is a proven, working guest-to-host memory read on AMD KVM hosts with nested virtualization — demonstrated at 127 GB against real cloud infrastructure. There is no clever detection that substitutes for the fix: inventory AMD hosts, check the nested parameter, patch the kernel, reboot, and disable nested virt in the interim. Cloud tenants should treat in-memory secrets on potentially exposed hosts as compromised and rotate accordingly.
Related Resources
Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub
Is your security operations ready?
Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.