CVE-2026-33150: 
Homebrew vulnerability analysis and mitigation

CVE-2026-33150 is a use-after-free (UAF) vulnerability in the io_uring subsystem of libfuse, the reference implementation of the Linux FUSE (Filesystem in Userspace) interface. It affects libfuse versions 3.18.0 through 3.18.1 (before 3.18.2) and was discovered and reported by Abhinav Agarwal, a Senior Software Developer at Rubrik. The advisory was published on March 19–20, 2026, with a patch released in version 3.18.2. It carries a CVSS v3.1 base score of 7.8 (High) (GitHub Advisory, Feedly).

The root cause is a use-after-free (CWE-416) in lib/fuse_uring.c within the fuse_uring_start() function. When io_uring thread creation fails due to resource exhaustion — for example, when pthread_create returns EAGAIN because cgroup pids.max is reached — the error path calls fuse_session_destruct_uring() to free the fuse_ring structure, but then incorrectly stores the now-freed pointer in se->uring.pool. On session shutdown, both fuse_loop.c and fuse_loop_mt.c check if (se->uring.pool) and call fuse_uring_stop(), which dereferences the freed memory. The freed 192-byte heap chunk can be reallocated with attacker-influenced content during the session's lifetime (from startup failure to session exit, potentially hours), and the destructor then reads the reallocated memory as struct fields and executes free(), close(), and pthread_cancel() on those values — providing standard primitives for code execution. The fix sets se->uring.pool = NULL in the error path to prevent the dangling pointer from being dereferenced (GitHub Advisory, Patch Commit).

A local attacker with low privileges can reliably crash any FUSE filesystem process using the io_uring transport on session shutdown, resulting in denial of service. Beyond availability, the vulnerability provides exploitation primitives (via free(), close(), and pthread_cancel() on attacker-influenced memory) that could enable arbitrary code execution with the privileges of the FUSE daemon — which commonly runs as root for system-wide mounts. Kubernetes CSI drivers using libfuse are especially exposed, as cgroup pids.max pod constraints are a natural and reliable trigger for the vulnerability, potentially enabling privilege escalation or lateral movement within containerized environments (GitHub Advisory).

No confirmed in-the-wild exploitation has been observed, and no functional public exploit code is available — a repository flagged as a potential PoC was determined to be an unrelated Jekyll theme template with no exploit content (Feedly). The advisory notes that a PoC is available upon request from the discoverer. The EPSS score is approximately 0.012% (0.000120), indicating a low probability of exploitation in the near term. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. Detection plugins are available from Nessus (plugin 303272) and Qualys (plugin 711163) (Feedly).

1. Identify target: Locate a system running a FUSE filesystem daemon built against libfuse 3.18.0 or 3.18.1 with io_uring transport explicitly enabled (e.g., a Kubernetes pod using a CSI driver backed by libfuse).
2. Trigger resource exhaustion: As a low-privileged local user, exhaust the process ID limit enforced by the container's cgroup pids.max setting (e.g., by spawning many threads or processes) so that pthread_create returns EAGAIN when fuse_uring_start() attempts to create io_uring worker threads.
3. Induce UAF condition: The failed thread creation causes fuse_uring_start() to free fuse_ring via fuse_session_destruct_uring() but store the dangling pointer in se->uring.pool, leaving the freed 192-byte heap chunk available for reallocation.
4. Heap grooming (for code execution): During the window between startup failure and session shutdown (potentially hours), perform heap spray or grooming operations to reallocate the freed chunk with attacker-controlled content that mimics the expected struct layout, placing crafted function pointers or addresses in the fields that will be passed to free(), close(), or pthread_cancel().
5. Trigger session shutdown: Cause the FUSE session to shut down (e.g., unmount the filesystem or terminate the daemon). The cleanup code checks if (se->uring.pool) (non-NULL dangling pointer), calls fuse_uring_stop() on the freed/reallocated memory, and executes the attacker-controlled values as function arguments — achieving denial of service or arbitrary code execution (GitHub Advisory, Patch Commit).

• Logs: AddressSanitizer (ASan) reports of use-after-free in fuse_session_destruct_uring() or fuse_uring_stop() in FUSE daemon logs; kernel logs showing EAGAIN from pthread_create in the context of a FUSE process during startup.
• Process Behavior: FUSE filesystem daemon processes crashing unexpectedly on shutdown, particularly in containerized environments; abnormal termination of CSI driver pods or FUSE-backed mount daemons.
• System: Repeated FUSE daemon restarts or mount failures in Kubernetes CSI driver pods; cgroup pids.max limit being hit by FUSE-related processes (visible in /sys/fs/cgroup/.../pids.current vs pids.max).
• Network: No specific network indicators — this is a local privilege escalation/DoS vulnerability with no network-facing component.

Upgrade libfuse to version 3.18.2 or later, which fixes the UAF by setting se->uring.pool = NULL in the error path of fuse_uring_start() (libfuse Release, Patch Commit). For environments where immediate patching is not possible, consider disabling the io_uring transport in libfuse (the vulnerability only triggers when io_uring is explicitly enabled), or increase cgroup pids.max limits in containerized environments to prevent the thread creation failure that triggers the bug. Kubernetes administrators should audit CSI drivers using libfuse and prioritize updating affected deployments (GitHub Advisory).

The vulnerability was discussed on Hacker News and noted on security-focused Bluesky and Mastodon accounts shortly after disclosure (Feedly). The oss-security mailing list carried multiple threads on the issue, and it was covered by German Linux news outlet Pro-Linux.de in the context of two FUSE security fixes in the 3.18.2 release (Pro-Linux). Gentoo Linux issued a security update covering the affected FUSE package, and Tenable published a Nessus detection plugin (303272) for the vulnerability (Tenable).