Skip to main content

Linux Kernel CVE-2026-99227

| EUVDEUVD-2026-115269 HIGH
2026-11-02 Linux GHSA-4rq4-jvm7-h89f
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Obtain local unprivileged account
  2. Delivery
    Submit io_uring waitid request
  3. Exploit
    Flood failed cancellations to wrap 31-bit refcount
  4. Execution
    Trigger second completion (use-after-free)
  5. Impact
    Corrupt 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available

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

Alert me

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

Linux 6.7
Linux patch: 7.3.1
Linux f31ecf671ddc498f20219453395794ff2383e06b <22fb4a4518e305164c7f203608287564de292f34
Linux f31ecf671ddc498f20219453395794ff2383e06b <20b67288574c7c3df6b8ea7ed3b7af90a868006f
Linux f31ecf671ddc498f20219453395794ff2383e06b <857aa2012b91cad6fdef54a4b6c632d9d0b6e64f
Linux patch: 0
Linux patch: 6.18.60
Linux f31ecf671ddc498f20219453395794ff2383e06b <5bfeee1774791602a0d53eb717f00f172127a017
Linux patch: 6.12.115
Linux patch: 7.2.14

Affected Packages

euvd linux no fix

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

Vendor (Linux) PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.0 HIGH

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.

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

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

Attack Vector
Local
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

2
Patch available
Nov 02, 2026 - 17:18 EUVD
CVE Published
Nov 02, 2026 - 16:06 cve.org
HIGH 7.8

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

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

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

Prevalence
Ubiquitous
Linux kernel; io_uring present across the vast majority of modern Linux systems
Data Quality
2 sources
Confidence: Low

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 N/A
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

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

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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