Skip to main content

Google gVisor CVE-2026-95702

| EUVDEUVD-2026-95816 HIGH
Use After Free (CWE-416)
2026-10-09 Google GHSA-hv4v-f9v2-r8c2
8.5
CVSS 4.0 · Vendor: Google
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Obtain standard-privilege shell in gVisor sandbox
  2. Exploit
    Create in-sandbox overlay filesystem and detach its mount
  3. Execution
    Trigger double-free of backing MemoryFile (use-after-free)
  4. Impact
    Execute 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Gvisor 0 <20260831.0

Affected Packages

euvd gvisor fix: 20260831.0

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

Vendor (Google) PRIMARY 8.5 HIGH
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
vuln.today AI 8.8 HIGH

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).

3.1 AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (Google).

CVSS VectorVendor: Google

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
Low
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Oct 09, 2026 - 16:02 EUVD
CVE Published
Oct 09, 2026 - 14:44 cve.org
HIGH 8.5

DescriptionCVE.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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.1%
Top 100% exploitable
Prevalence
Medium
container sandbox runtime; common in Google Cloud and some multi-tenant platforms, not everywhere
Data Quality
5 sources
Confidence: Medium

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy