Skip to main content

Linux Kernel CVE-2026-93137

| EUVDEUVD-2026-82245 HIGH
2026-09-17 Linux GHSA-45wg-mg8v-jx77
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 CAP_BPF on local host
  2. Delivery
    Load BPF program calling bpf_find_vma on foreign task
  3. Exploit
    Race target task through exit_mm()
  4. Execution
    Trigger trylock on freed mm_struct
  5. Impact
    Kernel use-after-free crash (DoS)

Vulnerability Assessment

Exploitation Conditions

Requires local privilege to load and run a BPF program (CAP_BPF-class) that invokes bpf_find_vma() against a FOREIGN task - the current-task path is safe because task->mm is stable. Exploitation further requires winning a race: the foreign target must execute exit_mm() (freeing its mm_struct) precisely between the lockless task->mm read and the mmap_read_trylock() call. Limiting factors: needs CONFIG_MMU builds and non-irqs-disabled context on the foreign path (the fix rejects these), a tight timing window on a task the attacker must be able to reference, and BPF program load privileges typically unavailable to unprivileged users on hardened/locked-down kernels.

Impact

The vendor CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H = 7.8) overstates real-world risk for what is fundamentally a race-condition-driven use-after-free on a foreign task's mm_struct. The AC:L rating is questionable: exploitation requires winning a narrow TOCTOU window between the lockless read of task->mm and mmap_read_trylock() while a foreign task is concurrently executing exit_mm() - a genuine race, better modeled as AC:H. PR:L is appropriate because reaching bpf_find_vma() requires loading and running a BPF program (CAP_BPF-class privilege), which is not available to unprivileged users on hardened systems. The C:H/I:H/A:H triple is optimistic: a UAF on mm_struct most reliably yields a kernel crash (DoS), with information disclosure or corruption possible but far harder to weaponize. No EPSS score, no CISA KEV listing, and no public POC are provided; combined with the CAP_BPF gate and the tight race, real-world exploitation is unlikely and this is a high-CVSS-but-lower-real-risk issue. My independent assessment lands around 5.0-5.5. Note the input Tags label this 'Information Disclosure' which conflicts with the crash/DoS-primary nature of an mm_struct UAF.

Exploit ScenarioDerived

A local user with CAP_BPF loads a BPF program that calls bpf_find_vma() against a foreign task (e.g., a task iterator or via a pid), then races the target through exit_mm() so the mm_struct is freed between the lockless task->mm read and mmap_read_trylock(). Winning the race dereferences freed memory, typically crashing the kernel. No public exploit code is identified 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 race-condition-driven use-after-free in the Linux kernel BPF subsystem allows a local user able to load and run BPF programs to crash or potentially corrupt kernel memory by racing a foreign task's mm_struct teardown against the bpf_find_vma() helper. The bug affects kernels from the 5.17 era onward that expose bpf_find_vma() on the foreign-task path, and it is reachable only when the attacker can reference a target task that concurrently executes exit_mm(); the current-task path is safe because task->mm is stable there. There is no public exploit identified at time of analysis, the flaw is not listed in CISA KEV, and the vendor has published upstream and stable patches; the vendor CVSS vector (7.8) overstates real-world risk relative to the independently assessed local, high-complexity race (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:L/I:L/A:H), which reflects the tight timing window and the BPF load privileges required.

RemediationAI

Vendor-released patch: upgrade to Linux 6.1.188, 6.6.157, 6.12.110, 6.18.52 or 7.2.6, or to 7.3-rc1 or later on the development branch; the upstream fixes are the git.kernel.org stable commits referenced above (see also https://nvd.nist.gov/vuln/detail/CVE-2026-93137). Until a rebuilt kernel is deployed, the most effective compensating control is to remove the attack surface rather than try to patch the race: set kernel.unprivileged_bpf_disabled=1 (or 2, non-reversible without reboot) so only CAP_BPF/CAP_SYS_ADMIN holders can load the BPF programs needed to call bpf_find_vma(); the trade-off is that unprivileged BPF tooling such as certain eBPF-based observability and networking agents stops working, so inventory those consumers first. Enabling an LSM lockdown mode (kernel lockdown=integrity/confidentiality, or equivalent SELinux/AppArmor policy) additionally blocks privileged kernel memory and BPF manipulation paths at the cost of restricting debug, kexec and module-loading features. Restricting who holds CAP_BPF and CAP_SYS_ADMIN is the only durable mitigation for the privileged case, since the flaw is triggerable from any context permitted to run this helper against a foreign task. Note that the upstream fix also rejects irqs-disabled contexts and !CONFIG_MMU kernels on the foreign path, so systems whose BPF use depends on those configurations must validate behavior after patching; there is no configuration switch that safely restores the vulnerable fast path.

Affected VersionsENISA

Linux patch: 7.2.6
Linux 7c7e3d31e7856a8260a254f8c71db416f7f9f5a1 <86d54cf069fc5ae2e111c87933bebf6eb527978e
Linux 7c7e3d31e7856a8260a254f8c71db416f7f9f5a1 <db347840d6b6ee9bb9b8e4a985d4b4419f9f3200
Linux patch: 6.6.157
Linux 7c7e3d31e7856a8260a254f8c71db416f7f9f5a1 <c7ad910e987008e125eeff448892e86852173384
Linux patch: 0
Linux patch: 6.18.52
Linux 7c7e3d31e7856a8260a254f8c71db416f7f9f5a1 <2b2a903bee56d312539046d9defa8023eec94760
Linux 7c7e3d31e7856a8260a254f8c71db416f7f9f5a1 <47b079e2117a2ee52e21f8b72935900c702fc0b5
Linux patch: 6.12.110
Linux 5.17
Linux patch: 6.1.188
Linux patch: 7.3-rc1
Linux 7c7e3d31e7856a8260a254f8c71db416f7f9f5a1 <8e1101fc4118019a69c96ced4aec93164f89cbd5

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_find_vma() is a BPF helper used by tracing/iterator-style BPF programs to walk a task's virtual memory areas, typically to build user stack traces or inspect VMAs. The vulnerable code performed a lockless read of task->mm for a foreign task and then called mmap_read_trylock(mm) without holding a reference to that mm_struct. Because mm_struct is not SLAB_TYPESAFE_BY_RCU, a concurrent exit_mm() on the target task can set task->mm to NULL and drop the final reference via mmput(), freeing the object between the read and the trylock - a classic use-after-free (CWE-416) on a kernel memory object whose fields (mmap_lock, VMA tree) are then read or locked post-free. The upstream fix mirrors d8e27d2d22b6 ('bpf: fix mm lifecycle in open-coded task_vma iterator'): it pins the mm under task->alloc_lock using spin_trylock() instead of get_task_mm() so that BPF context does not block on the allocator lock, then releases the reference with mmput_async(). Because dropping an mm reference is not safe in all contexts, the fix also rejects irqs-disabled execution contexts and !CONFIG_MMU builds on the foreign-task path. The attack surface is the BPF verifier/helper interface, so reachability is gated by the ability to load a BPF program that invokes this helper.

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 5.8 MEDIUM

Local BPF helper (AV:L), CAP_BPF required (PR:L), narrow exit_mm() race (AC:H); mm_struct UAF is crash-primary (A:H) with only marginal read/corruption (C:L/I:L).

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

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:11 cve.org
UNKNOWN (no severity yet)
CVE Published
Sep 17, 2026 - 16:11 cve.org
HIGH 7.8

DescriptionCVE.org

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

bpf: Fix use-after-free on mm_struct in bpf_find_vma()

bpf_find_vma() reads task->mm and calls mmap_read_trylock(mm) without holding a reference on the mm. On a foreign task, a concurrent exit_mm() can free the mm_struct between the lockless read and the trylock, resulting in a use-after-free. mm_struct is not SLAB_TYPESAFE_BY_RCU.

For the current task, task->mm is stable. For a foreign task, pin the mm under task->alloc_lock and release it with mmput_async(), mirroring commit d8e27d2d22b6 ("bpf: fix mm lifecycle in open-coded task_vma iterator"). Use spin_trylock() instead of get_task_mm() so BPF context does not block on alloc_lock. Reject irqs-disabled contexts and !CONFIG_MMU on the foreign-task path because dropping the mm reference is not safe there.

Race:

CPU0 (BPF program) CPU1 (exiting task) ====== ======== bpf_find_vma(foreign_task): mm = task->mm exit_mm(): task->mm = NULL mmput(mm) -> frees mm_struct mmap_read_trylock(mm) // UAF on mm

Executive ViewAI

Why It Matters

Linux kernel 5.17 and later deployments that permit local users to load BPF programs carry a high-severity kernel memory corruption risk from CVE-2026-93137, which can crash or potentially corrupt kernel memory on affected hosts. The exposure is limited to authenticated local users with BPF privileges and a narrow timing window, and no public exploit identified at time of analysis; Patch available per vendor advisory. Leadership should prioritize patching any multi-tenant, container, or shared Linux environments because host disruption or memory corruption could affect multiple workloads and availability.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Low
BPF helper reachable only with CAP_BPF; niche foreign-task vma iteration path
Data Quality
4 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: Important
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 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