Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain standard-privilege shell in gVisor sandbox
-
ExploitCreate in-sandbox overlay filesystem and detach its mount
-
ExecutionTrigger double-free of backing MemoryFile (use-after-free)
-
ImpactExecute arbitrary code in host sentry process
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the attacker to already have standard (unprivileged) container-user access inside a running gVisor sandbox on a vulnerable build (prior to release 20260831.0, all platforms), and the ability to create and manipulate an in-sandbox overlay filesystem to drive the backing MemoryFile into a double-free. The upstream patch pinpoints the trigger: binding a lazily-detached mount (held open via an fd re-referenced through /proc/self/fd after umount2 MNT_DETACH) to another mount point, exercising the nsfs/cgroupfs/cgroup2fs bind path in VFS. Limiting factors that reduce real-world risk: it is local-only with no network vector, needs authenticated in-sandbox code execution (PR:L), and the resulting code execution lands in a sentry process that is still boxed in by host Linux seccomp and namespace restrictions, so a single exploitation does not automatically reach the host kernel or other tenants. |
| Impact | This is a credible, exploitation-worthy container-escape primitive but not an emergency-patch-tonight issue for most environments. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:L/UI:N) confirms it is strictly local and requires already holding standard privileges inside a gVisor sandbox - there is no network-reachable path, which substantially caps mass-exploitation potential. Technical impact is high (VC:H/VI:H/VA:H): a use-after-free/double-free (CWE-416) yielding code execution in the host-side sentry process, i.e. compromise of the sandbox's own security monitor. Importantly, both the description and the CVSS author constrain the blast radius: SC:N/SI:N/SA:N and the explicit note that 'the sentry process remains confined by host-level Linux seccomp and namespace boundaries' mean this escapes the guest into the sentry but NOT (by itself) onto the host OS - it is a sandbox-integrity break, not a full host takeover. No EPSS score, KEV listing, or public POC was provided, so there is no evidence of active or at-scale exploitation; the signal set is 'serious capability, no observed exploitation.' The strongest corroboration is the three upstream fix commits with regression tests, confirming the bug is real and vendor-acknowledged. Net: prioritize patching for multi-tenant gVisor deployments where untrusted workloads share a host, but treat it as a defense-in-depth erosion rather than an immediately weaponized threat. |
| Exploit ScenarioDerived | An attacker who already has a foothold with ordinary user privileges inside a gVisor-sandboxed container crafts an in-sandbox overlay filesystem and manipulates its backing MemoryFile so it is freed twice, corrupting sentry memory. By controlling the reused allocation they hijack execution in the host sentry process, breaking out of the guest's intended isolation. No public exploit code was identified at time of analysis, though the upstream patch and its regression tests disclose the triggering mount sequence. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 09, 2026
Code execution inside the gVisor sentry process is achievable by a local attacker holding standard container privileges on any platform running a gVisor build prior to release 20260831.0, due to a use-after-free/double-free of the MemoryFile backing an in-sandbox overlay filesystem in the virtual filesystem (VFS) mount layer. The issue is local-only and requires authenticated in-sandbox access (CVSS 4.0 vector AV:L/PR:L), and the resulting code execution lands in the sentry, which remains confined by host-level Linux seccomp and namespace boundaries rather than directly in the host kernel, so a single exploitation does not automatically yield host-kernel compromise or cross-tenant escape. No public exploit code was identified at time of analysis, but the trigger path is documented in the upstream fix's regression tests.
RemediationAI
Vendor-released patch: upgrade to gVisor release 20260831.0 or later, which incorporates the VFS fixes in commits 90bc4fc36fe442257a06ba15df00371561c183ed, 25c75149bc0eeaa6a3a49b9bbe3473588b2af6df, and e4efb89c787ef15b09e68d561f1303380e1d5a77 (see https://github.com/google/gvisor/commit/90bc4fc36fe442257a06ba15df00371561c183ed). Because exploitation depends on abusing the mount/umount and /proc/self/fd bind-mount path against a lazily detached mount, environments that cannot upgrade immediately can reduce exposure by not granting untrusted in-sandbox workloads the ability to perform mount, umount, or bind operations (drop CAP_SYS_ADMIN inside the sandbox or disable the mount/overlay feature surface) and by avoiding overlay-backed filesystems for untrusted tenants where a plain rootfs is workable; both measures degrade compatibility, since image layering and many container build patterns rely on overlay mounts. Running each untrusted workload in its own sandbox and monitoring the sentry process for crashes or abnormal memory-fault terminations (a likely symptom of the double-free) provides detection while patching is scheduled. Given the local-only vector, required authenticated in-sandbox access, and the fact that sentry code execution remains bound by host seccomp and namespace confinement, this does not warrant emergency patching in most environments, but should be prioritised wherever hostile or multi-tenant code shares a gVisor host.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
gVisor reimplements the Linux filesystem syscall surface in a user-space 'sentry' process that mediates guest container access to host resources, with the VFS layer (pkg/sentry/vfs) tracking Mount objects, dentries, and mount namespaces; overlay filesystems inside the sandbox are backed by MemoryFile objects whose lifetime is reference-counted. CWE-416 (Use After Free) in this code allows a freed MemoryFile reference to be released a second time, corrupting the sentry's heap. The upstream patch localizes the defect to mount handling: cloneMountTree now skips child mounts marked umounted, and BindAt returns EINVAL when the source mount is umounted 'regardless of the filesystem type'. The patch also tightens the long-standing exemption that let nsfs, cgroupfs, and cgroup2fs be bind-mounted even when not valid in the current mount namespace, restricting that exemption to non-recursive binds only. The added regression tests (Cgroup.DetachedMountBindFails and Cgroup2Test.DetachedMountBindFails) show the precise trigger: hold an open fd on a cgroup/cgroup2 mount, lazily detach it with umount2(MNT_DETACH), re-name it through /proc/self/fd, then attempt a bind mount, which previously exercised the stale-mount path instead of failing cleanly. Affected product data is a wildcard CPE (cpe:2.3:a:google:gvisor:*:*:*:*:*:*:*:*), confirming all gVisor builds before the fixed release are in scope across every supported platform (Linux/KVM, ptrace, and related runtimes).
Know when Gvisor gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Local in-sandbox attacker with ordinary container privileges (AV:L/PR:L); escaping the guest into the sentry crosses a trust boundary (S:C) with full code-execution impact (C/I/A:H).
Primary rating from Vendor (Google).
CVSS VectorVendor: Google
Lifecycle Timeline
2DescriptionCVE.org
Use-after-free vulnerability in VFS in Google gVisor prior to release 20260831.0 on all platforms allows a local attacker with standard container privileges to achieve code execution in the host sentry process by double-freeing the backing MemoryFile from an in-sandbox overlay filesystem. The sentry process remains confined by host-level Linux seccomp and namespace boundaries.
Executive ViewAI
A memory-safety flaw in gVisor's sandboxed container runtime (builds prior to release 20260831.0) allows an attacker who already has a foothold inside a container to run code within the gVisor sentry - the component that enforces isolation between containers and the host. The weakness is exploitable only by an attacker who already holds authenticated local container privileges, and a successful attack does not by itself break out to the host kernel or cross into other tenants. Leadership should care because every gVisor-isolated workload - particularly multi-tenant, serverless, or untrusted-code platforms built on this runtime - loses its core isolation guarantee until workloads are moved onto the fixed build, and no vendor patch is available today.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict container creation and exec access on affected hosts to trusted, authenticated operators only (the flaw is local and requires PR:L); move the highest-risk untrusted or multi-tenant workloads to patched nodes or an alternative hardened runtime; monitor for anomalous sentry crashes, restarts, or core dumps that may indicate a double-free trigger; retain and verify host-level seccomp profiles and namespace boundaries, which continue to contain sentry code execution from reaching the host kernel or other tenants; plan migration to gVisor release 20260831.0 or later as the durable fix.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
pkg/sentry/kernel/shm/shm.go in Google gVisor before 2018-11-01 allows attackers to overwrite memory locations in proces
Host root code execution is reachable from inside a Google gVisor sandbox built prior to commit 573a9e73cf844f when the
Google gVisor's runsc component exhibited a local privilege escalation vulnerability due to incorrect handling of file a
Google gVisor before 2018-08-23, within the seccomp sandbox, permits access to the renameat system call, which allows at
Google gVisor before 2018-08-22 reuses a pagetable in a different level with the paging-structure cache intact, which al
Weaknesses in the generation of TCP/UDP source ports and some other header values in Google's gVisor allowed them to be
A weak hashing algorithm and small sizes of seeds/secrets in Google's gVisor allowed for a remote attacker to calculate
EUVD-2026-95816
GHSA-hv4v-f9v2-r8c2
NVD
CVE.org
EPSS
Exploit-DB