Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain local eBPF map-load capability
-
DeliveryCreate array-of-maps with percpu array inner template
-
ExploitReplace inner map with smaller max_entries
-
ExecutionTrigger lookup using stale JIT index_mask
-
ImpactOut-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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
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).
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.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
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.
Apply vendor patch.
Threat Intelligence Overview
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.
EUVD-2026-95531
GHSA-69ch-wm32-w5g8
NVD
CVE.org
EPSS
VulDB
Exploit-DB