Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain local shell as unprivileged user
-
DeliveryRun 'unshare -Ur' to create user namespace
-
ExploitGain CAP_SYS_ADMIN within namespace
-
ExecutionOpen /dev/zfs and issue privileged ioctl
-
PersistOpenZFS policy accepts namespace-scoped capability as host root
-
ImpactExecute pool destroy, import, or zinject fault injection
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Authorization logic validation
MITRE ATT&CK
1 technique across 1 tactic: Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Two conditions must both be true simultaneously. First, the local user must be able to open /dev/zfs - on most Linux distributions the device is world-readable/writable or accessible to the 'disk' or 'zfs' group by default, but site-hardened systems that have restricted this permission are not exploitable via this path. Second, the kernel must permit unprivileged user namespace creation; this is controlled by kernel.unprivileged_userns_clone (Debian/Ubuntu) or user.max_user_namespaces sysctl and is enabled by default on Ubuntu 22.04+, Debian 11+, and most enterprise Linux distributions. No prior access to any ZFS pool or underlying block device is required. Exploitation is limited to local users with an interactive or programmatic shell session; remote exploitation requires a separate initial access vector. The condition that limits exploitation most in practice is the device permission on /dev/zfs - environments that have restricted it to root-only or a privileged group break the attack entirely without requiring a kernel parameter change. |
| Impact | The CVSS 4.0 score of 7.3 with vector AV:L/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H reflects accurate severity: local access with low privilege suffices, there is no user interaction, and all three CIA pillars are high within the vulnerable system. The AT:P (attack target: present) metric flags the one meaningful precondition - the kernel must allow unprivileged user namespace creation - which is enabled by default on Ubuntu, Debian, and most modern Linux server distributions, reducing that gate substantially. No KEV listing exists, meaning CISA has not confirmed active exploitation, and no public exploit code has been identified in the provided data. EPSS data is absent from the input and cannot be cited. Despite the absence of active exploitation indicators, the real-world risk is non-trivial: the attack requires no special tools beyond standard Linux utilities (unshare -Ur), the steps are mechanical and repeatable, and the impact allows a local user to destroy storage pools or inject faults - consequences that are catastrophic and difficult to recover from. Systems where untrusted local users exist (multi-tenant environments, shared compute, container hosts where user namespace creation is unrestricted) should treat this as a high-priority patch. Single-tenant or air-gapped storage appliances where no unprivileged shell access is granted to non-admin users have materially reduced exposure. |
| Exploit ScenarioDerived | An unprivileged user on a multi-user Linux server runs 'unshare -Ur zpool destroy tank' from their shell session. Within the new user namespace, the kernel grants them CAP_SYS_ADMIN scoped to that namespace; OpenZFS's ioctl handler accepts this as sufficient authorization and proceeds to destroy the production ZFS pool 'tank' without any further authentication. No root password, sudo rights, or prior ZFS access is required - only a valid local shell account and the ability to open /dev/zfs. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 26, 2026
Privilege escalation in OpenZFS on Linux allows any unprivileged local user to perform root-restricted ZFS pool operations - including pool creation, import, destruction, event log access, and fault injection via zinject - by exploiting a flaw in ioctl authorization that incorrectly treats CAP_SYS_ADMIN held within a user-created unprivileged namespace as equivalent to real host-level root privilege. The vulnerability requires only that the user can open /dev/zfs and that the kernel permits unprivileged user namespace creation, a configuration that is enabled by default on most modern Linux distributions. No public exploit has been identified at time of analysis, and the OpenZFS project has released patched versions 2.2.11, 2.3.9, and 2.4.4 addressing all affected branches.
RemediationAI
Upgrade OpenZFS to version 2.4.4 (if on the 2.4.x branch), 2.3.9 (2.3.x branch), or 2.2.11 (2.2.x branch) from the tagged releases at https://github.com/openzfs/zfs/releases. Distribution maintainers (Canonical, TrueNAS, etc.) should be consulted for packaged updates; Canonical was the reporter and is expected to issue Ubuntu Security Notices promptly. If an immediate upgrade is not possible, the most effective compensating control is to disable unprivileged user namespace creation by setting the kernel parameter kernel.unprivileged_userns_clone=0 (sysctl) or user.max_user_namespaces=0, though this will break containerized workloads (Docker, Podman, Flatpak, Chrome sandboxing) that depend on user namespaces. An alternative narrower control is to restrict /dev/zfs permissions so that only trusted users or groups can open the device (e.g., chmod 600 /dev/zfs), though this may break legitimate unprivileged ZFS snapshot or mount operations depending on site policy. The upstream fix PR is at https://github.com/openzfs/zfs/pull/18959.
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
OpenZFS implements a policy layer (module/os/linux/zfs/policy.c) that wraps Linux capability checks for ioctl authorization. The affected functions - secpolicy_sys_config (governing pool administration and event access) and secpolicy_zinject (governing fault injection) - previously invoked priv_policy() with CAP_SYS_ADMIN without verifying the credential's zone/namespace context. On Linux, CAP_SYS_ADMIN is granted to the 'root' user within an unprivileged user namespace created via unshare(1) or clone(2) with CLONE_NEWUSER. OpenZFS's priv_policy incorrectly treated this namespace-scoped capability as indistinguishable from the same capability held in the initial (host) namespace, violating the Linux kernel's security boundary between user namespaces and the host. CWE-863 (Incorrect Authorization) describes this root cause precisely: authorization decisions are made without validating that the credential has authority over the target resource in the correct security domain. The fix adds a zone check (crgetzoneid(cr) != GLOBAL_ZONEID) to both policy functions, ensuring that only credentials from the global/init namespace are accepted for these privileged operations. CPE cpe:2.3:a:openzfs:openzfs:*:*:*:*:*:*:*:* indicates all OpenZFS versions on Linux are affected prior to the fix.
Know when Openzfs 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:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Local access with low privilege suffices; scope changes because namespace-scoped capability escalates to host-level pool control affecting all users of shared storage.
Primary rating from Vendor (canonical).
CVSS VectorVendor: canonical
DescriptionCVE.org
On Linux, several OpenZFS ioctl authorization checks accept a capability held only within a user-created, unprivileged namespace as equivalent to real host privilege, allowing an unprivileged local user to perform operations that should require root. Affected operations include pool-administrative operations (eg create, import, destroy), pool event log access (zpool events) and fault injection (zinject). Exploiting the problem requires only that the local user is permitted to open /dev/zfs (governed by local device permissions) and that the kernel permits unprivileged user namespace creation. No prior access to the target pool or its underlying devices is needed.
Executive ViewAI
A privilege escalation vulnerability in OpenZFS on Linux (CVE-2026-79619, CVSS 7.3) allows unprivileged local users to perform root-restricted ZFS operations including pool management and fault injection by exploiting improper namespace authorization checks. No public exploit identified at time of analysis. Organizations running OpenZFS on Linux are at risk of unauthorized administrative access by any user with system shell access.
Apply vendor patch (OpenZFS 2.2.11, 2.3.9, or 2.4.4 per deployed branch). Interim mitigation for systems pending patching: disable unprivileged user namespace creation via kernel parameter kernel.unprivileged_userns_clone=0 to reduce attack surface.
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
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
OpenZFS before 2.0.0-rc1, when used on FreeBSD, misinterprets group permissions as user permissions, as demonstrated by
OpenZFS before 2.0.0-rc1, when used on FreeBSD, allows execute permissions for all directories. Rated high severity (CVS
OpenZFS through 2.1.13 and 2.2.x through 2.2.1, in certain scenarios involving applications that try to rely on efficien
EUVD-2026-66419
GHSA-5v2p-vxxv-r62r
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB