Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain local unprivileged account
-
DeliverySubmit io_uring waitid request
-
ExploitFlood failed cancellations to wrap 31-bit refcount
-
ExecutionTrigger second completion (use-after-free)
-
ImpactCorrupt kernel memory to escalate privileges
Vulnerability Assessment
| Exploitation Conditions | Requires local access to a system where the io_uring subsystem is available and not disabled (e.g. not blocked via io_uring_disabled sysctl or seccomp policy), and the ability to submit an io_uring waitid operation and its cancellation. Per the description, the flaw is reached by issuing repeated FAILED cancellation attempts against a request owned by another path until the 31-bit reference counter (bits 30:0 of ->refs) wraps to zero, after which a later cancellation can claim ownership and complete the request a second time. Limiting factors: exploitation needs a local low-privileged account (PR:L), the counter wrap demands a very large volume of cancellation attempts (~2^31) making it timing- and resource-intensive, and winning the completion-ownership handoff is a race - all of which constrain reliability well below a simple one-shot trigger. Environments that disable io_uring for unprivileged users are not exposed. |
| Impact | Signals point to a genuine but non-emergency local kernel memory-corruption issue rather than a mass-exploitation threat. The input CVSS of 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects full confidentiality, integrity and availability impact reachable by a low-privileged local user, consistent with an io_uring reference-count wrap that leads to a second completion of the same request (a double-completion / use-after-free class flaw). However, several escalation signals are ABSENT: no EPSS score is provided, the CVE is NOT listed in CISA KEV, and no public exploit or PoC reference is supplied (the four references are all kernel.org stable git commits, i.e. the fix itself). The vuln.today decision label is 'this_week', not 'act_now' or 'emergency', which is coherent with a patchable local bug lacking confirmed exploitation. A notable tension: the description shows the mechanism requires wrapping a 31-bit reference counter via repeated failed cancellation attempts - on the order of 2^31 operations plus winning a completion-ownership race - which materially raises real-world exploitation difficulty beyond what the input's AC:L implies; this is reflected in my independent assessed vector below. Also note the 'Information Disclosure' tag understates the issue: the described double-completion is a memory-corruption primitive (matching the C:H/I:H/A:H rating), not merely an info leak. Net: a real priority to patch in normal cycles, but not an actively-exploited internet-facing emergency. |
| Exploit ScenarioDerived | A low-privileged local user with access to the io_uring interface submits a waitid request, then issues a very large number of failed cancellation attempts so that the 31-bit reference field wraps to zero; a subsequent cancellation then claims ownership and completes the same request a second time. This double completion yields a use-after-free style primitive that could be groomed toward kernel memory corruption and local privilege escalation. No public exploit or PoC was identified at time of analysis - the trigger details beyond the counter wrap and completion race are not described in the available sources. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 02, 2026
The io_uring waitid implementation in the Linux kernel can be driven into a 31-bit reference-counter wrap by a local user, allowing a waitid request to be claimed and completed a second time, corrupting kernel state. Kernels built with io_uring and waitid support are affected wherever unprivileged users can submit and cancel io_uring waitid operations; systems that disable io_uring for unprivileged users (io_uring_disabled sysctl or seccomp policy) are not exposed. The assessed vector is local with high attack complexity (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H) because the wrap demands on the order of 2^31 failed cancellation attempts and winning the completion-ownership handoff; no public exploit code or active exploitation has been identified at time of analysis, and priority is this_week rather than emergency.
RemediationAI
Vendor fixes are published as upstream stable commits: 20b67288574c7c3df6b8ea7ed3b7af90a868006f, 5bfeee1774791602a0d53eb717f00f172127a017, 857aa2012b91cad6fdef54a4b6c632d9d0b6e64f, and 22fb4a4518e305164c7f203608287564de292f34 (see https://git.kernel.org/stable/c/20b67288574c7c3df6b8ea7ed3b7af90a868006f and the sibling links), so the primary action is to update to a kernel build in your distribution that contains the corresponding backport; because only commit references are supplied, the exact released kernel version is not independently confirmed and must be checked against your vendor's advisory. Where an updated kernel cannot yet be deployed, the exposure can be removed by denying unprivileged io_uring: setting kernel.io_uring_disabled=2 disables io_uring for users without CAP_SYS_ADMIN, with the trade-off that any application relying on unprivileged io_uring (some runtimes and databases do) will break; alternatively apply a seccomp policy that blocks io_uring_setup and io_uring_register for untrusted workloads, which carries the same functional trade-off and must be scoped per workload. Neither workaround addresses the flawed code, so kernel updates remain the complete fix.
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
io_uring is the Linux kernel's asynchronous I/O submission/completion subsystem, and io_waitid implements waitid(2) as an io_uring operation. Its request object packs two pieces of state into a single ->refs word: bit 31 (IO_WAITID_CANCEL_FLAG) marks the request as canceled, while bits 30:0 (IO_WAITID_REF_MASK) form a 31-bit reference counter. In the flawed version, __io_waitid_cancel() flags the request as canceled and then increments the low counter bits to claim completion ownership; when another path already owns the request, the increment is left in place even though the function returns false and the request stays discoverable by cancellation. Repeating failed cancellation attempts therefore monotonically advances the counter until it wraps to zero, after which a later cancellation can claim ownership and complete the request a second time. The upstream fix replaces the flag setting with atomic_fetch_or() and inspects the returned old value: the first cancellation still performs the ownership increment and preserves wake/handoff semantics, while later attempts observe the cancel flag and return without touching the reference field, making repeated failed cancellations idempotent. No CWE identifier is assigned in the supplied data; the defect class is a reference-count/lifecycle management error in kernel request cancellation, and the affected CPE is the generic linux:linux product entry.
Know when the next one hits your stack
- 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
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Local io_uring access needs an unprivileged account (AV:L, PR:L); wrapping a 31-bit refcount via ~2^31 attempts plus a completion race makes reliable triggering hard, so AC:H; double-completion corruption yields full C/I/A.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
2DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
io_uring/waitid: prevent cancel reference wrap
io_waitid packs the cancellation state into bit 31 of ->refs and uses bits 30:0 as a 31-bit reference counter:
#define IO_WAITID_CANCEL_FLAG BIT(31) #define IO_WAITID_REF_MASK GENMASK(30, 0)
__io_waitid_cancel() marks a request canceled, then increments the low bits of ->refs to claim completion ownership. When another path owns the request, the increment remains even though cancellation returns false. The request remains discoverable by cancellation, so repeated failed attempts can wrap the 31-bit reference field to zero. A later cancellation can claim ownership and complete the request a second time.
Use atomic_fetch_or() when setting the cancel flag and inspect the old flag value. The first cancel attempt continues to the existing ownership increment, preserving its wake and issuer handoff semantics. Later attempts see the cancel flag and return without incrementing the reference field.
This makes repeated failed cancellation attempts idempotent while leaving the first-cancel state transitions unchanged.
Articles & Coverage 1
Executive ViewAI
A high-severity flaw in the Linux kernel's io_uring waitid subsystem allows a local user to corrupt kernel state through reference-counter manipulation, creating a credible path to elevated privileges and system instability. Leadership should care because any multi-tenant, containerized, or shared-hosting environment running affected kernels could see a determined local user compromise host integrity - though the practical exploitation bar is high and no active attacks are known. This is a this-week hardening item, not an emergency, and can be largely neutralized through configuration without waiting on a vendor fix.
No vendor-released patch identified at time of analysis. Interim mitigations: disable io_uring for unprivileged users via the io_uring_disabled sysctl, and/or block io_uring syscalls with seccomp/AppArmor/SELinux for containerized and untrusted workloads; restrict local access and apply least-privilege separation on affected hosts.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-115269
GHSA-4rq4-jvm7-h89f
NVD
CVE.org
Exploit-DB