Skip to main content

Linux Kernel EUVDEUVD-2026-86702

| CVE-2026-98049 MEDIUM
Incorrect Conversion between Numeric Types (CWE-681)
2026-09-25 Linux GHSA-wmcq-6rpv-m375
5.5
CVSS 3.1 · NVD
View

Attack ChainAIDerived

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

  1. Access
    Obtain local eBPF load capability
  2. Delivery
    Load program with arena 32-bit cmpxchg
  3. Exploit
    JIT skips required zero extension
  4. Execution
    Kernel operates on corrupted register value
  5. Impact
    Availability loss / instability

Vulnerability Assessment

Weakness
CWE
Exploitation Conditions

Requires local privileges sufficient to load eBPF programs (CAP_BPF/CAP_SYS_ADMIN, or a kernel configured to allow unprivileged BPF), and specifically the use of a BPF arena pointer with a 32-bit cmpxchg atomic operation that the context-access rewriter converts to BPF_PROBE_ATOMIC. Exploitation is architecture-sensitive - it manifests where 32-bit cmpxchg needs explicit zero extension of the destination register (e.g. x86-64 'lock cmpxchg' not updating %eax on a successful compare). Limiting factors: no remote vector (local only), privileged/config-gated BPF access is normally required, and impact is confined to availability/incorrect computation with no confidentiality or integrity exposure established.

Impact

All signals point to a low-to-moderate, locally-scoped reliability bug rather than an urgent priority. The vendor CVSS 3.1 vector (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H, base 5.5) describes a local, low-complexity flaw requiring low privileges, with impact confined to availability (C:N/I:N/A:H) - consistent with a BPF verifier/JIT correctness defect (CWE-681, incorrect numeric conversion) where a 32-bit arena cmpxchg misses the mandatory upper-half zero extension. EPSS is very low (0.15%, 4th percentile), the CVE is NOT in CISA KEV, and no public exploit is identified in the provided data, so exploitation status is 'no public exploit identified at time of analysis.' These signals are mutually consistent: low EPSS, no KEV, and local-only vector all indicate this is not a widespread exploitation target. One conflict to flag: the input Tag 'Information Disclosure' contradicts the authoritative CVSS impact metrics (C:N, I:N, A:H) and CWE-681 - the vendor-scored impact is availability/incorrect-computation, not confidentiality loss; treat the disclosure label as unverified. Overall this is a high-CVSS-relative-to-real-risk patch-hygiene item for kernel maintainers, not an emergency.

Exploit ScenarioDerived

A local user able to load eBPF programs (unprivileged BPF enabled or holding CAP_BPF) crafts a program that performs a 32-bit cmpxchg on a BPF arena pointer; because is_cmpxchg_insn() does not match BPF_PROBE_ATOMIC, the JIT omits the required zero extension of the destination register's upper 32 bits. On architectures like x86-64 where 'lock cmpxchg' leaves %eax unchanged on success, the resulting stale upper bits violate BPF semantics and can lead to incorrect kernel computation or instability. No public proof-of-concept is identified in the provided data.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 06, 2026

Incorrect zero extension of the result of a 32-bit atomic compare-exchange on a BPF arena pointer in the Linux kernel can leave stale bytes in the upper half of the destination register after a successful cmpxchg, so BPF programs reading that register observe wrong values on architectures where 32-bit cmpxchg does not implicitly clear the upper bits (notably x86-64 'lock cmpxchg', which leaves %eax unchanged on a successful compare). Triggering it requires local access with privileges sufficient to load eBPF programs (CVSS PR:L - CAP_BPF/CAP_SYS_ADMIN, or a kernel configured to permit unprivileged BPF) plus the specific combination of an arena pointer and a 32-bit cmpxchg that the context-access rewriter converts to BPF_PROBE_ATOMIC, so exploitation is both privileged/configuration-gated and architecture-sensitive. Impact is confined to incorrect computation and availability (C:N/I:N/A:H in the assessed vector); no public exploit identified at time of analysis, EPSS is 0.15% (4th percentile), and the issue is not listed in CISA KEV, making this a low-to-moderate, locally scoped reliability bug best handled through routine kernel updates.

RemediationAI

Vendor-released patch is available: upgrade to Linux stable 7.2.7 or mainline 7.3-rc2 (or later), or backport the upstream stable commits 4814ed6406f3493bd554ad046da5f7fc04833571 and 1c1b476d43a8b6c9bc04600369dd8cc39950d98e from git.kernel.org, which extend is_cmpxchg_insn() to match BPF_PROBE_ATOMIC so the 32-bit cmpxchg zero-extension is applied to arena atomics. Because the flaw is local, privileged, and architecture-sensitive, patching can follow normal kernel maintenance rather than emergency change control; the assessed vector is A:H with no confidentiality or integrity impact and EPSS is only 0.15% (4th percentile), with no KEV listing. Where immediate patching is not possible, the practical compensating control is to restrict who can load eBPF programs - set kernel.unprivileged_bpf_disabled=1 (or =2 to make it non-reversible without reboot) and ensure only trusted processes hold CAP_BPF/CAP_SYS_ADMIN - which removes the unprivileged trigger path but does not fix the underlying bug and will break unprivileged eBPF consumers such as some observability agents, container runtimes, and sandboxing tooling that depend on unprivileged BPF; note that an already-privileged BPF loader (including kernel-internal or root-owned loaders) is unaffected by this control. Avoiding arena-pointer 32-bit cmpxchg usage in BPF programs until the kernel is updated removes the exposure entirely but requires program-level changes and re-verification, and simply disabling the BPF JIT or the arena feature would carry broader performance and functionality trade-offs and is not recommended over patching. References: https://git.kernel.org/stable/c/4814ed6406f3493bd554ad046da5f7fc04833571, https://git.kernel.org/stable/c/1c1b476d43a8b6c9bc04600369dd8cc39950d98e, https://nvd.nist.gov/vuln/detail/CVE-2026-98049.

Affected VersionsENISA

Linux patch: 0
Linux 6.10
Linux d503a04f8bc0c75dc9db9452d8cc79d748afb752 <4814ed6406f3493bd554ad046da5f7fc04833571
Linux patch: 7.3-rc2
Linux d503a04f8bc0c75dc9db9452d8cc79d748afb752 <1c1b476d43a8b6c9bc04600369dd8cc39950d98e
Linux patch: 7.2.7

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

The affected component is the Linux kernel's BPF verifier/JIT pipeline. During verification, bpf_convert_ctx_accesses() rewrites an atomic operation on a BPF arena pointer from BPF_STX | BPF_ATOMIC to BPF_STX | BPF_PROBE_ATOMIC, and this rewrite runs before bpf_opt_subreg_zext_lo32_rnd_hi32(). That later optimization pass emits an explicit zero extension for a 32-bit cmpxchg even when bpf_jit_needs_zext() is false, because some architectures require it - on x86-64, for example, the 'lock cmpxchg' instruction does not modify %eax when the comparison succeeds, whereas BPF semantics require every operation on a 32-bit register to zero extend its upper half. The helper is_cmpxchg_insn() only matched BPF_MODE == BPF_ATOMIC, so an arena cmpxchg (rewritten to BPF_PROBE_ATOMIC) missed the zero-extension adjustment; the fix extends is_cmpxchg_insn() to also match BPF_PROBE_ATOMIC. The root cause is a type/numeric conversion mismatch (CWE-681, incorrect conversion between numeric types): the JIT-emitted native sequence does not satisfy the BPF register model's zero-extension contract. This is an internal kernel helper logic flaw in the eBPF arena atomics support rather than a memory-safety primitive, which is consistent with the assessed AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H vector - miscomputed register values and potential program misbehavior, with no confidentiality or integrity exposure established (note that some feed tags label the entry 'Information Disclosure', which the assessed vector does not substantiate).

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

NVD PRIMARY 5.5 MEDIUM
AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 5.5 MEDIUM

Triggering requires locally loading a crafted BPF program (AV:L, PR:L) with no user interaction; the correctness defect causes incorrect computation/instability so A:H, with no confidentiality or integrity impact.

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE MEDIUM
Red Hat 5.5 MEDIUM

Primary rating from NVD.

CVSS VectorNVD

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

Lifecycle Timeline

4
CVSS changed
Oct 06, 2026 - 12:52 NVD
5.5 (MEDIUM)
Patch available
Sep 25, 2026 - 11:02 EUVD
CVE Published
Sep 25, 2026 - 10:23 cve.org
UNKNOWN (no severity yet)
CVE Published
Sep 25, 2026 - 10:23 nvd
MEDIUM 5.5

DescriptionNVD

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

bpf: zero extend the result of an arena 32-bit cmpxchg

bpf_convert_ctx_accesses() rewrites an atomic on an arena pointer from BPF_STX | BPF_ATOMIC to BPF_STX | BPF_PROBE_ATOMIC, and it runs before bpf_opt_subreg_zext_lo32_rnd_hi32().

That pass emits an explicit zero extension for a 32-bit cmpxchg even when bpf_jit_needs_zext() is false. This is done because on some architectures 32-bit cmpxchg requires explicit zero extension for the dst register. E.g. on x86-64 'lock cmpxchg' does not change the %eax if comparison is successful, while BPF semantics declare that each operation on a 32-bit register zero extends it's upper half.

is_cmpxchg_insn() matches BPF_MODE == BPF_ATOMIC only, so an arena cmpxchg misses said zero extension adjustment. This patch adjusts is_cmpxchg_insn() to match BPF_PROBE_ATOMIC alongside BPF_ATOMIC.

Threat Intelligence Overview

EPSS Score
0.2%
Top 96% exploitable
Prevalence
Ubiquitous
Linux kernel runs across a huge fraction of production environments
Data Quality
5 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
High

Priority Score

28
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +28
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.

Vendor StatusVendor

SUSE

Severity: Moderate
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise Desktop 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Not-Affected
SUSE Linux Enterprise High Availability Extension 16.0 Affected

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