Skip to main content

Linux Kernel EUVDEUVD-2026-115794

| CVE-2026-99269 HIGH
2026-11-03 Linux GHSA-mv2r-pvjc-x9r3
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Local access on host running sched_ext scheduler
  2. Delivery
    Trigger task dispatch and dequeue concurrently
  3. Exploit
    Win race before SCX_OPSS_DISPATCHING cleared
  4. Execution
    Consume/move path operates on in-flight task
  5. Persist
    Corrupt scheduler task state
  6. Impact
    Privilege escalation or kernel crash

Vulnerability Assessment

Exploitation Conditions

Requires the Linux kernel to be built with sched_ext (CONFIG_SCHED_CLASS_EXT) AND a BPF struct_ops scheduler actually loaded and active - loading such a scheduler normally requires CAP_SYS_ADMIN, and when no sched_ext scheduler is attached the affected functions (scx_move_local_task_to_local_dsq, unlink_dsq_and_switch_rq_lock, move_task_between_dsqs) are not exercised, so the flaw is unreachable. Exploitation further requires a local presence on the host and winning the concurrency window between the dispatcher running ops.dequeue() and clearing SCX_OPSS_DISPATCHING; this is a timing-dependent race, so success is not guaranteed on a single attempt. Net limiting factors: local-only access, non-default sched_ext deployment, and a narrow race window - these materially reduce realistic exploitability below the raw 7.8 score for typical servers that do not run custom schedulers.

Impact

Available signals point to a genuine but situational local-privilege issue rather than a mass-exploitation emergency. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8 HIGH) describes a local, low-privilege flaw with full confidentiality, integrity and availability impact - consistent with a kernel memory-safety race in the sched_ext scheduler that can corrupt task state. No EPSS probability was supplied, the CVE is not listed in CISA KEV, and no SSVC decision tree (automatable / technical impact) was provided; the only prioritization signal present is the vuln.today 'this_week' label, which indicates near-term patching but explicitly not act_now/emergency. No public exploit is identified - the only references are the two kernel.org stable fix commits, not proof-of-concept code. The practical ceiling on risk is the attack surface: the vulnerable code paths (scx_move_local_task_to_local_dsq(), unlink_dsq_and_switch_rq_lock(), move_task_between_dsqs()) are only reachable when a sched_ext BPF scheduler is loaded and active, which is uncommon in default production deployments. Conflicting metadata to verify: the 'Information Disclosure' tag understates the vendor-assigned I:H/A:H impact, which indicates corruption/availability effects, not confidentiality alone - treat the tag as incomplete rather than authoritative. Overall this is a legitimate local-escalation/DoS hardening fix to schedule for patching this week, not a widely-weaponized remote threat.

Exploit ScenarioDerived

On a Linux system running an active sched_ext (SCX) BPF scheduler, a local user induces scheduling activity that causes a task to be consumed or moved off a non-local DSQ while the dispatching CPU is still executing ops.dequeue() and has not cleared SCX_OPSS_DISPATCHING. Winning that timing window lets the consume/move path operate on the task concurrently with the dispatcher, corrupting task scheduler state and potentially yielding local privilege escalation or a kernel crash. No public exploit code is identified; the only published artifacts are the stable-tree fix commits.

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 03, 2026

Local attackers on Linux kernels built with sched_ext can race task migration against a dispatcher still inside ops.dequeue(), causing unsynchronized access to a task's dispatch-queue state with potential confidentiality, integrity and availability impact. The flaw is reachable only when CONFIG_SCHED_CLASS_EXT is enabled and a BPF struct_ops scheduler is loaded and active, which normally requires CAP_SYS_ADMIN; the assessed AV:L/AC:H/PR:L vector reflects the timing-dependent race, and EUVD lists Linux 7.1 as affected with fixed releases 7.2.14 and 7.3. No public exploit identified at time of analysis and the supplied data does not confirm CISA KEV status; the vuln.today decision is this_week.

RemediationAI

Update to a kernel release that contains commits 2935062be77113c1c4565ca9d0c72180449aafee and cc2839946328c1618b3870d521b32bb9483d49d0; EUVD lists fixed versions 7.3 and 7.2.14, plus a separate patch: 0 entry whose version mapping is not clear from the supplied data, so administrators should use the vendor branch that matches their kernel and verify the commit is present. If sched_ext is not needed, build without CONFIG_SCHED_CLASS_EXT or refrain from loading any BPF struct_ops scheduler; this removes reachability because the affected paths are not exercised without an active sched_ext scheduler, at the cost of losing the extensible scheduling feature. For hosts that must run these schedulers, limit BPF struct_ops scheduler loading to trusted CAP_SYS_ADMIN holders while patching, which narrows the local attack surface but does not substitute for the fix. Treat this as a this-week priority per the supplied decision label and consult https://git.kernel.org/stable/c/2935062be77113c1c4565ca9d0c72180449aafee and https://git.kernel.org/stable/c/cc2839946328c1618b3870d521b32bb9483d49d0 for the exact patch.

Affected VersionsENISA

Linux ebf1ccff79c43f860cbd2f9d6cfab9a462d0cb2d <2935062be77113c1c4565ca9d0c72180449aafee
Linux patch: 7.3
Linux ebf1ccff79c43f860cbd2f9d6cfab9a462d0cb2d <cc2839946328c1618b3870d521b32bb9483d49d0
Linux patch: 0
Linux patch: 7.2.14
Linux 7.1

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

sched_ext is the Linux extensible scheduler class that lets a BPF struct_ops program implement scheduling policy. Dispatch queues (DSQs) hold runnable tasks, and SCX_OPSS_DISPATCHING marks a DSQ operation in progress while a CPU runs ops.dequeue(). The fix notes that a task can be found on a non-local DSQ while the dispatching CPU has not cleared that flag; scx_move_local_task_to_local_dsq(), unlink_dsq_and_switch_rq_lock() and move_task_between_dsqs() previously acted without waiting, so the DSQ consume and move paths could operate concurrently with the dispatcher. The remedy adds scx_wait_dispatching() before those paths, and before scx_resolve_local_dsq() in scx_move_local_task_to_local_dsq() because that resolver may update p->scx.flags. No CWE was supplied; by mechanism this is a synchronization and race-condition issue in the scheduler dispatch state machine. CPE cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:* identifies the kernel broadly but does not encode the sched_ext configuration prerequisite.

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-only kernel path (AV:L); the described concurrent DSQ-vs-dispatch window is a timing race so AC:H; any local task on a sched_ext host suffices (PR:L); scheduler state 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:H/AT:N/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

3
Patch available
Nov 03, 2026 - 13:16 EUVD
CVE Published
Nov 03, 2026 - 11:48 cve.org
HIGH 7.8
CVE Published
Nov 03, 2026 - 11:48 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

In the Linux kernel, the following vulnerability has been resolved:

sched_ext: Wait for SCX_OPSS_DISPATCHING before moving tasks off DSQs

A task can be found on a non-local DSQ while the CPU which dispatched it is still running ops.dequeue() and hasn't cleared SCX_OPSS_DISPATCHING. The DSQ consume and move paths don't wait for the dispatch to finish and can operate on the task concurrently with the dispatcher.

Call scx_wait_dispatching() in scx_move_local_task_to_local_dsq(), unlink_dsq_and_switch_rq_lock() and move_task_between_dsqs() before they operate on the task. In scx_move_local_task_to_local_dsq(), wait before scx_resolve_local_dsq() as it may update p->scx.flags.

Executive ViewAI

Why It Matters

A high-severity race condition in the Linux kernel's sched_ext framework (CVE-2026-99269) could allow a local attacker with limited privileges to compromise system confidentiality, integrity, and availability, but only on systems running a custom BPF scheduler with elevated administrative access. Because the flaw requires CONFIG_SCHED_CLASS_EXT and a loaded BPF struct_ops scheduler, its exploitability is largely confined to specialized Linux environments; however, given kernel-level impact, security leadership should prioritize patching affected systems to eliminate the risk of privilege escalation or denial of service.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

Prevalence
Ubiquitous
Linux kernel; but vulnerable sched_ext path active in few deployments
Data Quality
3 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
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

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