Skip to main content
Vulnerability Database/CVE-2026-96812

CVE-2026-96812: Google gVisor RCE Vulnerability

CVE-2026-96812 is a remote code execution flaw in Google gVisor affecting Linux platforms with CUSE enabled. Attackers with container deployment privileges can achieve root code execution on the host. This article covers technical details, affected versions, impact, and mitigation steps.

Published:

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

CVE-2026-96812 Overview

CVE-2026-96812 is a container escape vulnerability in Google gVisor's host file helper (gofer) on Linux systems with Character Device in Userspace (CUSE) enabled. The flaw stems from improper exposure of a resource to the wrong sphere [CWE-269], where opening a /dev/cuse character device node inside a container passes through to the host kernel. A local attacker with privileges to deploy container images can register a host CUSE device and abuse unrestricted ioctl handling to overwrite memory in the root udev helper, leading to code execution on the host. The issue is fixed in gVisor commit 573a9e73cf844f.

Critical Impact

An attacker who can deploy a container image breaks out of the gVisor sandbox and achieves root code execution on the underlying host.

Affected Products

  • Google gVisor on Linux platforms with CUSE enabled
  • gVisor builds prior to commit 573a9e73cf844f
  • Container runtimes using the vulnerable gofer (runsc) implementation

Discovery Timeline

  • 2026-09-25 - CVE-2026-96812 published to NVD
  • 2026-09-25 - Last updated in NVD database

Technical Details for CVE-2026-96812

Vulnerability Analysis

gVisor is a user-space kernel that sandboxes containers by intercepting syscalls through the Sentry process and proxying filesystem operations through a gofer. The gofer's directfs inode path handled device special files by passing the open directly to the host kernel without routing it through the Sentry. When the container filesystem contained a /dev/cuse character device node, opening that node bound the sandboxed process to the host's CUSE subsystem.

CUSE lets userspace register character devices and service their ioctl calls. Once bound to the host CUSE instance, the attacker registers a malicious character device that the host's root-privileged udev helper will subsequently open and interact with. Because CUSE does not restrict which ioctl commands can be delivered to the registered device, the attacker's userspace handler receives raw ioctl buffers from the udev helper and can corrupt its memory, culminating in root code execution on the host.

Root Cause

The gofer's directfs_inode logic opened device nodes with host semantics instead of dispatching them to the Sentry for policy enforcement. Device special files were treated as regular pass-through opens, erasing the sandbox boundary for character devices such as /dev/cuse.

Attack Vector

Exploitation requires local access with the ability to deploy a container image. The attacker crafts an image containing a CUSE character device node, launches the sandboxed workload, opens the device to register a host-side CUSE provider, and waits for the root udev helper to interact with the new device so unrestricted ioctl traffic can be leveraged to overwrite its memory.

go
// Security patch excerpt from pkg/sentry/fsimpl/gofer/directfs_inode.go
// Populates rdev major/minor so the Sentry can identify and gate device opens.
                    fs:        fs,
                    inoKey:    inoKey,
                    ino:       fs.inoFromKey(inoKey),
+                   rdevMajor: stat.Rdev_major,
+                   rdevMinor: stat.Rdev_minor,
                    mode:      atomicbitops.FromUint32(uint32(stat.Mode)),
                    uid:       atomicbitops.FromUint32(uint32(fs.opts.dfltuid)),
                    gid:       atomicbitops.FromUint32(uint32(fs.opts.dfltgid)),
// Source: https://github.com/google/gvisor/commit/573a9e73cf844f
go
// Security patch excerpt from pkg/sentry/fsimpl/gofer/filesystem.go
// Adds explicit handling and logging for unimplemented character device opens.
 var logRejectedFifoOpenOnce sync.Once

+// Used to log an open of an unimplemented character device, once.
+var logUnimplementedCharDevOpenOnce sync.Once
+
 // Preconditions: The caller must hold no locks (since opening pipes may block
 // indefinitely).
 func (d *dentry) open(ctx context.Context, rp *vfs.ResolvingPath, opts *vfs.OpenOptions) (*vfs.FileDescription, error) {
// Source: https://github.com/google/gvisor/commit/573a9e73cf844f

Stop Remote Code Execution Before It Runs

Singularity™ Endpoint detects and blocks exploit attempts at machine speed, including zero-days and novel attack techniques.

Stop Exploit Attempts

Detection Methods for CVE-2026-96812

Indicators of Compromise

  • Container images that include a /dev/cuse character device node or other unexpected device special files in their rootfs layers.
  • Host-side cuse module activity originating from processes inside gVisor-sandboxed containers.
  • Unexpected registrations of new character devices on hosts running runsc workloads, followed by root udev helper crashes or anomalous memory behavior.

Detection Strategies

  • Scan container image layers at build and admission time for character device nodes, rejecting any image that ships /dev/cuse or similarly privileged nodes.
  • Audit host kernel logs for cuse device registrations correlated with runsc sandbox PIDs.
  • Monitor execution and crash telemetry for systemd-udevd and related root helpers on hosts that run gVisor.

Monitoring Recommendations

  • Collect runsc gofer logs for the new logUnimplementedCharDevOpenOnce message indicating a sandboxed process attempted to open an unsupported character device.
  • Alert on loads of the cuse kernel module on container hosts where CUSE is not an operational requirement.
  • Track ioctl volume and anomalous syscall patterns between sandboxed workloads and host device nodes using endpoint telemetry.

How to Mitigate CVE-2026-96812

Immediate Actions Required

  • Upgrade gVisor to a build that includes commit 573a9e73cf844f or later and restart all runsc workloads.
  • Disable or unload the cuse kernel module on hosts running gVisor where CUSE is not required.
  • Enforce admission controls that reject container images containing character or block device nodes.

Patch Information

The fix is landed in the gVisor repository as commit 573a9e73cf844f ("gofer: dispatch device special file opens to the sentry"). The patch records rdevMajor and rdevMinor on gofer dentries and routes device special file opens through the Sentry, where unsupported character device opens are logged and rejected instead of passed to the host. See the GitHub gVisor commit for the full change set.

Workarounds

  • Remove the cuse module from the host (rmmod cuse) and blacklist it to prevent auto-load until patched gVisor binaries are deployed.
  • Restrict container image deployment privileges to trusted principals and require image scanning that denies device nodes in layers.
  • Run image inspection to strip /dev/* nodes from untrusted container images before they are scheduled on gVisor hosts.
bash
# Block the CUSE kernel module on gVisor hosts
echo 'blacklist cuse' | sudo tee /etc/modprobe.d/blacklist-cuse.conf
sudo rmmod cuse 2>/dev/null || true

# Inspect a container image for device special files before deployment
docker create --name inspect-img <image>:<tag>
docker export inspect-img | tar -tv | awk '$1 ~ /^c/ || $1 ~ /^b/'
docker rm inspect-img

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

Experience the Most Advanced Cybersecurity Platform

See how the world’s most intelligent, autonomous cybersecurity platform can protect your organization today and into the future.