Skip to main content

Linux Kernel EUVDEUVD-2026-95531

| CVE-2026-98376 HIGH
2026-10-09 Linux GHSA-69ch-wm32-w5g8
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 local eBPF map-load capability
  2. Delivery
    Create array-of-maps with percpu array inner template
  3. Exploit
    Replace inner map with smaller max_entries
  4. Execution
    Trigger lookup using stale JIT index_mask
  5. Impact
    Out-of-bounds pptrs[] access corrupts kernel memory

Vulnerability Assessment

Exploitation Conditions

Exploitation requires the ability to load eBPF programs and create BPF maps on the target (typically CAP_BPF/CAP_SYS_ADMIN or a configuration permitting such map operations), and specifically the use of a map-in-map (array-of-maps) whose inner-map template is a percpu array; the attacker must then replace that inner map with one having a smaller max_entries, which the generic bpf_map_meta_equal() check fails to reject. The out-of-bounds access only occurs because percpu_array_map_gen_lookup() inlines the original template's index_mask as a JIT immediate, so the condition is tied to this specific percpu-array inner-map replacement path. Limiting factors: no remote vector (local only), privileges to manipulate BPF maps are required, and systems that forbid unprivileged BPF or do not use percpu-array inner maps are not reachable. Updating the kernel to include the referenced fix commit is the remediation stated by the source.

Impact

Signals are consistent and point to a genuine but non-urgent local-privilege kernel issue rather than a mass-exploitation threat. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N, C:H/I:H/A:H, 7.8 HIGH) describes a locally-triggered flaw that already requires some privilege, so it is not remotely reachable. EPSS is very low (0.15%, 3rd percentile) and the CVE is not listed in CISA KEV, so there is no public exploit identified at time of analysis and no evidence of active exploitation. The vuln.today decision label is 'this_week', indicating a patch-this-cycle priority, not an emergency - which aligns with the low EPSS and the local, privilege-gated vector. No SSVC automatable/technical-impact fields were supplied, so that framework cannot be cross-referenced. Net: this is a real memory-safety defect in the eBPF verifier/map subsystem worth patching on a normal cycle, not a high-CVSS-but-hollow finding, but also not an actively exploited emergency. Note one metadata conflict: the input Tags label this 'Authentication Bypass', which the description does not support - it is an out-of-bounds access via inner-map replacement, not an auth bypass.

Exploit ScenarioDerived

A local actor able to load eBPF programs and create maps sets up a map-in-map (array-of-maps) whose inner-map template is a percpu array, then swaps in a replacement percpu array with fewer max_entries, which the generic metadata check fails to reject. Because percpu_array_map_gen_lookup() has inlined the original template's index_mask as a JIT immediate, a subsequent lookup on the smaller replacement map indexes pptrs[] out of bounds, yielding kernel memory corruption or disclosure. 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.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 24, 2026

Out-of-bounds memory access in the Linux kernel BPF subsystem affects kernels built from Linux 6.10 onward (from commit db69718b8efac802c7cc20d5a6c7dfc913f99c43) where a percpu array is used as an inner map in a map-in-map arrangement. A local attacker who can load eBPF programs and create BPF maps (typically requiring CAP_BPF/CAP_SYS_ADMIN or a configuration permitting such map operations) can replace the template inner map with a differently sized percpu array; because percpu_array_map_ops.map_meta_equal points at the generic bpf_map_meta_equal(), which does not compare max_entries, the replacement is accepted and percpu_array_map_gen_lookup() then performs a lookup using the original template's index_mask baked in as a JIT immediate, indexing pptrs[] out of bounds. No CISA KEV listing and no public exploit code were identified at time of analysis, and EPSS is very low at 0.15% (3rd percentile), consistent with a genuine but non-urgent local privilege issue rather than a mass-exploitation threat.

RemediationAI

Vendor-released patch: upstream fix commit 593980175389a05793f6060aa20e626330960395, which repoints percpu_array_map_ops.map_meta_equal to array_map_meta_equal() and adds a selftest; EUVD records the patched branch as Linux 7.1, so update the kernel to a release containing that commit (https://git.kernel.org/stable/c/593980175389a05793f6060aa20e626330960395) - per the source, updating is the stated remediation and no separate workaround is documented. Until the kernel is updated, the exposure is bounded by the prerequisites: the path is unreachable on systems that forbid unprivileged BPF or that do not use a percpu array as the inner map template of a map-in-map, so restricting BPF map creation and program loading to trusted processes (via CAP_BPF/CAP_SYS_ADMIN and kernel.unprivileged_bpf_disabled) removes reachability at the cost of denying legitimate BPF tooling to non-privileged users, and avoiding percpu-array inner maps in deployed map-in-map templates avoids the vulnerable replacement path at the cost of redesigning those BPF programs.

Affected VersionsENISA

Linux 6.10
Linux patch: 0
Linux db69718b8efac802c7cc20d5a6c7dfc913f99c43 <593980175389a05793f6060aa20e626330960395
Linux patch: 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

The flaw sits in the BPF map-in-map machinery, which lets a BPF program reference an outer map whose values are themselves map handles (an array of maps). When an inner map is created, the kernel records a template and, for certain map types, provides a map_meta_equal callback used to validate that a substituted inner map is compatible with the template. percpu_array_map_ops incorrectly wired that hook to the generic bpf_map_meta_equal(), which does not compare max_entries, so a percpu array with a smaller max_entries could be installed in place of the template. The safety of lookups on percpu array maps depends on percpu_array_map_gen_lookup(), which JIT-compiles a lookup that hardcodes the template's index_mask as an immediate; with the size check bypassed, that inlined mask can permit indexing beyond the replacement map's pptrs[] allocation. The fix points percpu_array_map_ops.map_meta_equal at array_map_meta_equal(), which already enforces max_entries equality, and adds a selftest asserting that a differently sized percpu array inner map is rejected. The vector is local (AV:L) with low attack complexity (AC:L) and low privileges required (PR:L), no user interaction, unchanged scope, and high confidentiality, integrity and availability impact; the trigger is the specific percpu-array inner-map replacement path rather than a generic race or heap-grooming scenario.

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 BPF map operations require privilege (AV:L, PR:L); the replacement-path trigger is deterministic (AC:L); kernel OOB access yields full memory disclosure, corruption and crash (C/I/A:H).

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

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
Oct 24, 2026 - 14:22 NVD
7.8 (HIGH)
Patch available
Oct 09, 2026 - 09:16 EUVD
CVE Published
Oct 09, 2026 - 07:34 cve.org
HIGH 7.8
CVE Published
Oct 09, 2026 - 07:34 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

bpf: Use array_map_meta_equal for percpu array inner map replacement

percpu_array_map_ops.map_meta_equal points to the generic bpf_map_meta_equal(), which does not compare max_entries. When a percpu array serves as an inner map, replacing it with one that has fewer max_entries bypasses the check. Since percpu_array_map_gen_lookup() inlines the original template's index_mask as a JIT immediate, a lookup on the replacement map can access pptrs[] out of bounds.

Point percpu_array_map_ops.map_meta_equal to array_map_meta_equal(), which already enforces the max_entries equality check.

Add a selftest to verify that replacing a percpu array inner map with a differently-sized one is rejected.

Executive ViewAI

Why It Matters

CVE-2026-98376 is a high-severity out-of-bounds memory access in the Linux kernel's BPF subsystem that can be triggered by a local attacker with elevated privileges (e.g., CAP_BPF/CAP_SYS_ADMIN) to potentially escalate privileges or disrupt system integrity. While no active exploitation has been observed and the EPSS score is very low (0.15%), the risk is concentrated in environments where unprivileged BPF is enabled or privileged access is broadly granted, making it important for security leadership to validate configurations and patch affected systems.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Ubiquitous
Linux kernel, present in nearly all server and device 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 HIGH
CISA KEV No
Public POC No
EPSS 0.1%
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

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