Skip to main content

Linux Kernel CVE-2026-93148

| EUVDEUVD-2026-82256 HIGH
2026-09-17 Linux GHSA-q2v7-328v-qfqj
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 / local BPF access
  2. Delivery
    Craft BPF prog with MEM_ALLOC flex-array over-read
  3. Exploit
    Load: verifier accepts past-bounds access
  4. Execution
    Execute program to trigger OOB read/write
  5. Persist
    Corrupt kernel memory / leak data
  6. Impact
    Escalate privileges

Vulnerability Assessment

Exploitation Conditions

Requires local ability to load and run an eBPF program: either CAP_BPF (matching PR:L) or a system configured to allow unprivileged BPF (kernel.unprivileged_bpf_disabled=0). The attacker must craft a program that obtains a PTR_TO_BTF_ID | MEM_ALLOC object and drives a BTF struct walk through a trailing flexible-array member whose access range exceeds the object's static allocation size, or trigger the equivalent via kfunc/kptr struct-ID type checks. Affected kernels are ~6.2 through the versions before the fix (patched in 7.2.6 and 7.3-rc1). LIMITING FACTORS: no remote vector (AV:L, local only); CAP_BPF/unprivileged-BPF gating means default-hardened systems expose this only to already-privileged contexts; no user interaction and low complexity once BPF access is held.

Impact

Signals conflict between the vendor's high score and real-world reachability. The vendor CVSS of 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects a genuine memory-safety primitive: the BPF verifier wrongly extends its trailing-flexible-array struct-size relaxation to PTR_TO_BTF_ID | MEM_ALLOC objects, which are allocated at the STATIC BTF type size, letting a verified program read (and, via kfunc/kptr struct-ID matching, write) past the allocated object's bounds - an out-of-bounds access in kernel memory. This is a real, exploitable OOB primitive, unlike the many crash-only siblings in this Linux batch. However, no EPSS score, no CISA KEV listing, and no public POC are present, and exploitation is local-only (AV:L) and gated behind CAP_BPF (the ability to load and run a crafted eBPF program), captured as PR:L. That capability requirement plus local access materially reduces real-world risk below what the 7.8 implies: on hardened systems where unprivileged BPF is disabled (kernel.unprivileged_bpf_disabled=1, the modern default), the attack surface is limited to already-privileged/CAP_BPF contexts. Net: a legitimate local privilege-escalation building block worth patching on multi-tenant or BPF-exposed hosts, but not a mass-exploitation priority. My independent assessment lands around 6.5-7.5. Note the CWE is N/A in the input and should be CWE-125/CWE-787 (OOB read/write).

Exploit ScenarioDerived

A local attacker with CAP_BPF (or on a system permitting unprivileged BPF) loads a crafted eBPF program that obtains a PTR_TO_BTF_ID | MEM_ALLOC pointer to a kernel object and issues an access through a trailing flexible-array field whose range exceeds the object's statically-allocated size. The verifier's relaxation accepts it, so on execution the program reads or writes adjacent kernel memory, giving an out-of-bounds primitive usable for information disclosure or memory corruption toward privilege escalation. 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

Out-of-bounds memory access in the Linux kernel's eBPF verifier (bpf: Reject MEM_ALLOC BTF accesses past object bounds) allows a local attacker who can load BPF programs to walk BTF struct types past the bounds of a PTR_TO_BTF_ID | MEM_ALLOC object, producing reads and writes beyond the allocated static BTF type size and yielding high confidentiality, integrity, and availability impact within the kernel. Exploitation requires local access plus the ability to submit BPF programs - either holding CAP_BPF (matching the assessed CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H vector) or running on a system where kernel.unprivileged_bpf_disabled=0 permits unprivileged BPF; affected kernels are approximately 6.2 through the releases preceding the fix. Status: no public exploit identified at time of analysis, and no confirmed active exploitation (the issue does not appear in CISA KEV); vendor-released patches exist in Linux 7.2.6 and 7.3-rc1 (upstream commits 9c9ee0324c774490ae953162aaaf4561d222bd93 and e626a50d07d43421cbf7bfb5a084b33a5e276b6e), so priority should be driven by patch deployment rather than emergency exploitation response, with the caveat that the high vendor score overstates real-world reachability on default-hardened systems where only already-privileged contexts can reach the bug.

RemediationAI

Vendor-released patch: upgrade to Linux 7.2.6 or 7.3-rc1 (or later), or backport upstream commits 9c9ee0324c774490ae953162aaaf4561d222bd93 and e626a50d07d43421cbf7bfb5a084b33a5e276b6e from the stable tree (https://git.kernel.org/stable/c/9c9ee0324c774490ae953162aaaf4561d222bd93 and https://git.kernel.org/stable/c/e626a50d07d43421cbf7bfb5a084b33a5e276b6e); the NVD record at https://nvd.nist.gov/vuln/detail/CVE-2026-93148 tracks the CVE while the fix reference points to the stable branch. Where immediate kernel upgrade is not possible, the most effective compensating control is to ensure unprivileged BPF is disabled by setting kernel.unprivileged_bpf_disabled to 1 (per-boot, blocks new unprivileged program loads but is reversible) or 2 (cannot be reverted at runtime without reboot), which forces the attacker to already hold CAP_BPF and therefore removes the unprivileged path entirely - the trade-off is that legitimate unprivileged BPF consumers such as some observability, networking, or container tooling will break. In parallel, tighten CAP_BPF distribution: it should be withheld from container workloads, unprivileged users, and non-essential services (e.g., drop the capability from container runtimes and service units), accepting that any workload genuinely needing BPF cannot simply be assumed harmless for the duration of the exposure. Because exploitation is local and requires either CAP_BPF or unprivileged BPF enabled, there is no network-facing mitigation to apply and no need to block ports or endpoints; prioritise kernels with unprivileged BPF enabled, since those carry the widest exposure and should be patched first. There is no evidence of public exploit code or active exploitation to justify emergency measures beyond normal patch cycles, but verification after upgrade should confirm the two stable commits are present in the running kernel's changelog.

Affected VersionsENISA

Linux patch: 0
Linux 6.2
Linux patch: 7.3-rc1
Linux patch: 7.2.6
Linux 958cf2e273f0929c66169e0788031310e8118722 <9c9ee0324c774490ae953162aaaf4561d222bd93
Linux 958cf2e273f0929c66169e0788031310e8118722 <e626a50d07d43421cbf7bfb5a084b33a5e276b6e

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 flaw lives in the eBPF verifier's bounds-tracking logic for BPF Type Format (BTF) based memory access. When the verifier walks a BTF struct type, it normally relaxes the struct-size check for accesses that pass through a trailing flexible-array member, because such types are open-ended by design. That relaxation is correct for ordinary BTF type walking, but it is unsafe for values tagged PTR_TO_BTF_ID | MEM_ALLOC, which point at objects allocated using the static (non-flexible) BTF type size - there is no trailing array storage actually backing the object. The patch rejects an access before the flexible-array relaxation is applied whenever the access range extends past the struct size of a MEM_ALLOC object, and the same policy is applied to struct-ID matching so that kfunc and kptr type checks likewise cannot walk past the allocated object's bounds. Root cause class: out-of-bounds memory access / improper bounds validation in a kernel verifier, though no CWE identifier was assigned in the source data. The CPE data (cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:*) identifies the affected component generically as the Linux kernel rather than a specific subsystem, which is expected for an upstream kernel fix; the EUVD record EUVD-2026-82256 and the git.kernel.org stable commits are the authoritative pointers for the change. Exploitation is gated by BPF program-loading privilege: CAP_BPF (consistent with PR:L) or an unprivileged-BPF-enabled configuration, meaning the vulnerability is a privilege-escalation/kernel-memory-corruption primitive for callers that already hold some local privilege rather than a remotely reachable flaw (AV:L, no user interaction, low complexity once BPF access exists).

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.8 HIGH

Local-only via loadable BPF (AV:L), reliably triggered once loaded (AC:L), gated by CAP_BPF/unprivileged-BPF (PR:L); OOB read+write in kernel gives high C/I/A.

3.1 AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
SUSE HIGH
Red Hat 7.8 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: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: Reject MEM_ALLOC BTF accesses past object bounds

BTF struct walks relax the struct-size check for accesses through a trailing flexible array. That is valid for ordinary BTF type walking, but PTR_TO_BTF_ID | MEM_ALLOC values point to objects allocated with the static BTF type size.

When walking a MEM_ALLOC object, reject the access before applying the flexible-array relaxation if the access range extends past the struct size. Apply the same policy to struct ID matching so kfunc and kptr type checks do not walk past the allocated object bounds either.

Executive ViewAI

Why It Matters

Organizations running affected Linux kernels (approximately 6.2 through releases preceding the fix) face a high-severity local privilege escalation and kernel memory corruption risk in the eBPF verifier; a local user able to load BPF programs could read or write beyond allocated BTF object bounds and compromise kernel confidentiality, integrity, and availability. This matters because a compromised kernel can undermine isolation for containers, cloud workloads, and multi-tenant systems, potentially leading to data exposure, service disruption, or broader host compromise. No public exploit identified at time of analysis and no confirmed active exploitation (CISA KEV), but vendor patches are available and should be prioritized for systems that permit BPF program loading.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 95% exploitable
Prevalence
Low
Linux is ubiquitous but this needs BPF verifier path plus CAP_BPF exploit config
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
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.

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