Skip to main content

Linux Kernel EUVDEUVD-2026-81803

| CVE-2026-90210 HIGH
2026-09-17 Linux GHSA-gj8p-gx9h-pwwh
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Gain local BPF-capable access (CAP_BPF/CAP_SYS_ADMIN)
  2. Delivery
    Attach fentry multi-attach trampoline
  3. Exploit
    Trigger bpf_trampoline_update() to fail on error path
  4. Execution
    old_image freed while ftrace still references it
  5. Persist
    Use-after-free corrupts kernel memory
  6. Impact
    Kernel crash / potential privilege escalation

Vulnerability Assessment

Exploitation Conditions

Requires local access with the ability to load and multi-attach BPF fentry trampolines, which in practice needs CAP_BPF and/or CAP_SYS_ADMIN. The attacker must also cause bpf_trampoline_update() to fail on the specific error path where the update aborts before modify_fentry_multi()/unregister_fentry_multi() runs, leaving cur_image==old_image so the erroneous free triggers. Limiting factors: exploitation is confined to kernels that ship the new BPF trampoline multi-attach (fentry_multi) code (7.2.x and 7.3-rc series), needs privileged BPF capability, and depends on hitting an error/failure corner rather than a normal success path - so it is not remotely reachable and not exploitable against default unprivileged users.

Impact

This is a use-after-free (CWE-416) in the Linux kernel BPF trampoline multi-attach teardown path, reported by Linux with a vendor CVSS3.1 of 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). Signals point to a LOW real-world priority despite the high base score: there is no EPSS score, no CISA KEV listing, and no public exploit identified - the only references are the two kernel.org stable commits and an NVD mirror, meaning this is a routine coordinated kernel fix with no exploitation evidence. The vendor vector is also optimistic on several axes. It rates C:H/I:H/A:H, but the resolved-description is a UAF that arises specifically when bpf_trampoline_update() fails on an error path (before modify_fentry_multi()/unregister_fentry_multi()) - this is crash-primary DoS behavior, and full confidentiality/integrity compromise via this freed image is not substantiated by the description. The vector's AC:L understates the difficulty: the attacker must force bpf_trampoline_update() to fail at the right moment to leave cur_image==old_image, which is an error-path corner, not a straight-line trigger. PR:L also understates reality - BPF trampoline/fentry multi-attach requires CAP_BPF/CAP_SYS_ADMIN, so this is effectively a privileged local operation. Net: a legitimate memory-safety bug worth patching on affected 7.2.x/7.3-rc kernels, but not an urgent widespread-exploitation risk.

Exploit ScenarioDerived

A local user with BPF privileges (CAP_BPF/CAP_SYS_ADMIN) attaches a multi-attach fentry BPF trampoline and drives a program update that fails inside bpf_trampoline_update() before the fentry image is modified or unregistered. Because cur_image still equals old_image and ftrace continues calling into it, the subsequent free of old_image produces a use-after-free that most reliably crashes the kernel (DoS). No public proof-of-concept exists at time of analysis.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.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 – Sep 18, 2026

A use-after-free in the Linux kernel BPF trampoline multi-attach teardown path allows a local user who already holds CAP_BPF and/or CAP_SYS_ADMIN to crash the kernel - and potentially corrupt kernel memory - by forcing bpf_trampoline_update() to abort on an error path that runs before modify_fentry_multi()/unregister_fentry_multi(), leaving the erroneous free of old_image in bpf_trampoline_multi_attach_free() to release an ftrace image that is still live. Exploitation is confined to kernels that ship the new fentry_multi trampoline code (7.2.x and the 7.3-rc series), requires privileged BPF capability plus the ability to make an update fail in that specific corner, and is not remotely reachable or available to default unprivileged users. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing); the vendor's CVSS 3.1 base score is 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), while our independent assessment scores it 6.4 (AV:L/AC:H/PR:H/UI:N/S:U/C:N/I:N/A:H), treating the realistic outcome as kernel availability loss rather than broad code execution.

RemediationAI

Apply the upstream stable fixes at https://git.kernel.org/stable/c/65c3939656fd7848e9274faa07c26748b5bf049c and https://git.kernel.org/stable/c/0253073fb7d79a2dd2eae9581ea16db2aef395a6, which correspond in EUVD's affected-version data to the 7.2.6 patch release and the 7.3-rc1 tag - upgrading to Linux 7.2.6 or later (or rebasing custom trees onto a commit that includes one of the two fixes) is the only complete remedy, since the defect is a logic error in bpf_trampoline_multi_attach_free() rather than a tunable. Until a kernel rebuild/upgrade is possible, the effective compensating control is to deny BPF program loading to anyone who should not have it: keep CAP_BPF and CAP_SYS_ADMIN restricted to fully trusted administrators, enforce kernel.unprivileged_bpf_disabled=1 (and audit setuid/privileged containers that retain CAP_BPF), and avoid granting CAP_BPF to container workloads - the trade-off is that legitimate observability, eBPF-based networking and security tooling running under those credentials will stop working. Where fentry-based tooling is not needed, disabling the loading of BPF tracing (fentry/fexit) programs via a restrictive LSM or BPF token policy removes the attack surface entirely, at the cost of losing fentry-based instrumentation; because reaching the flaw also requires inducing an update failure on that specific pre-modify_fentry_multi() error path, simply avoiding repeated/racy concurrent multi-attach updates of the same target lowers exposure but should not be relied on as a fix. Note that kernel.unprivileged_bpf_disabled offers no benefit against this specific flaw, as the bug is only reachable by already-privileged BPF users.

Affected VersionsENISA

Linux patch: 7.3-rc1
Linux 7.2
Linux patch: 7.2.6
Linux aef4dfa790b22d8052cfb78044eadbe03c876c39 <0253073fb7d79a2dd2eae9581ea16db2aef395a6
Linux patch: 0
Linux aef4dfa790b22d8052cfb78044eadbe03c876c39 <65c3939656fd7848e9274faa07c26748b5bf049c

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

BPF fentry/fexit trampolines are dynamically generated ftrace-based entry points that let BPF programs attach to kernel functions; the newer multi-attach implementation tracks the currently installed trampoline image in cur_image and the previously active one in old_image, and reuses cur_image when an update fails partway through. The bug is a textbook CWE-416 use-after-free: on the failure path where bpf_trampoline_update() aborts before modify_fentry_multi()/unregister_fentry_multi() is invoked, cur_image still equals old_image and ftrace continues to call into that image, yet bpf_trampoline_multi_attach_free() frees old_image unconditionally. The fix simply skips the free when old_image == cur_image, preserving the still-referenced trampoline until ftrace is genuinely switched away. The affected CPE strings (cpe:2.3:a:linux:linux) confirm this is the mainline Linux kernel, and the referenced stable commits 0253073fb7d79a2dd2eae9581ea16db2aef395a6 and 65c3939656fd7848e9274faa07c26748b5bf049c are the backported fixes; the vulnerable range is bounded by the introducing commit aef4dfa790b22d8052cfb78044eadbe03c876c39. Reaching the flawed code requires loading BPF tracing programs and successfully creating a multi-attached fentry trampoline, which is why the practical privilege bar (CAP_BPF and/or CAP_SYS_ADMIN) is higher than the vendor's PR:L rating suggests.

Know when Ebpf gets its next vulnerability

  • 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 4.1 MEDIUM

Local BPF trampoline attach needs CAP_BPF/CAP_SYS_ADMIN (PR:H) and an update-failure error-path corner (AC:H); crash-primary UAF gives A:H with C/I unsubstantiated.

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

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

4
CVSS changed
Sep 18, 2026 - 18:22 NVD
7.8 (HIGH)
Patch available
Sep 17, 2026 - 17:19 EUVD
CVE Published
Sep 17, 2026 - 16:07 cve.org
HIGH 7.8
CVE Published
Sep 17, 2026 - 16:07 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

bpf: Fix UAF in bpf_trampoline_multi_attach_free on update failure

When bpf_trampoline_update() fails before modify_fentry_multi()/ unregister_fentry_multi() is called, cur_image is unchanged (cur_image == old_image) and ftrace still calls into it. Freeing old_image in that case causes a UAF.

Only free old_image when it differs from cur_image.

Executive ViewAI

Why It Matters

A kernel memory-safety flaw in the Linux 7.2.x and 7.3-rc fentry_multi BPF trampoline teardown path can crash - and potentially corrupt memory on - hosts running those kernels. Only local users who already hold elevated BPF/kernel capabilities (CAP_BPF or CAP_SYS_ADMIN) can trigger it, so risk is concentrated in engineering, platform, and container-host environments where such privileges are granted rather than in the general user base; no public exploit code or active exploitation has been observed. Because exploitation can destabilize shared production infrastructure and weaken kernel integrity guarantees, leadership should treat this as a patch-management and privilege-governance priority rather than an emergency incident.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 91% exploitable
Prevalence
Low
Linux ubiquitous but BPF trampoline multi-attach (fentry_multi) is a brand-new niche feature
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 HIGH
CISA KEV No
Public POC No
EPSS 0.2%
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.

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 Not-Affected

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