Security Resilience

CVE-2026-43009

Linux Kernel 5.12 – 6.19.12

Published
01 May 2026
Modified
21 October 2026
Patch / advisory
CVSS Score v3.1 7.8
Click a component to see what it means
Raw vectorCVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
EPSS Score 0.0016 5th percentile
Risk Priority 55 floored blend · peak EPSS

CVSS and EPSS are reproduced from their sources (NVD, FIRST EPSS). EPSS scores by FIRST (EPSS SIG), generated by Empirical Security. Risk Priority is our own derived reading, not an NVD score.

Summary

CVE-2026-43009 is a high-severity Incorrect Calculation (CWE-682) vulnerability in Linux Kernel. Its CVSS base score is 7.8 (High).

Operationally, ranked at the 5th percentile by exploit likelihood (below the median); it is not currently listed in the CISA KEV catalog.

Deeper analysis AI-assisted summary

Synthesised by an AI model from the NVD description and linked references — a reading aid, not an authoritative source.

CVE-2026-43009 is a vulnerability in the Linux kernel's BPF verifier, specifically in the backtrack_insn function's handling of BPF_STX instructions with BPF_ATOMIC and BPF_FETCH modifiers. The issue arises because the verifier fails to properly track precision for the destination register (which receives the old memory value in atomic fetch operations like atomic64_fetch_add), treating it like a regular store. This prevents precision propagation to stack locations, causing the verifier's path pruning logic to incorrectly deem two states equivalent despite differing stack states, potentially allowing invalid BPF programs to pass verification.

A local attacker with low privileges (PR:L) can exploit this by submitting a specially crafted BPF program that leverages atomic fetch operations on stack memory. Successful exploitation bypasses verifier restrictions, enabling the program to be loaded and executed in kernel context, which could result in high-impact confidentiality, integrity, and availability violations (C:H/I:H/A:H) as scored by CVSS 3.1 (7.8/AV:L/AC:L/PR:L/UI:N/S:U). No user interaction is required, and the attack is straightforward given low attack complexity.

Mitigation involves applying kernel patches from the referenced stable commits: https://git.kernel.org/stable/c/179ee84a89114b854ac2dd1d293633a7f6c8dac1 and https://git.kernel.org/stable/c/7ffbe45b1d227e24659998a91cfd4c27af457e71. These extend BPF_LDX handling in backtrack_insn to cover atomic fetch operations via an is_atomic_fetch_insn helper, ensuring proper precision propagation to stack slots and preventing incorrect pruning. Security practitioners should update affected Linux kernels promptly, particularly those using eBPF extensively.

EU & UK References

Vulnerability Data

In the Linux kernel, the following vulnerability has been resolved: bpf: Fix incorrect pruning due to atomic fetch precision tracking When backtrack_insn encounters a BPF_STX instruction with BPF_ATOMIC and BPF_FETCH, the src register (or r0 for BPF_CMPXCHG) also acts as…

more

a destination, thus receiving the old value from the memory location. The current backtracking logic does not account for this. It treats atomic fetch operations the same as regular stores where the src register is only an input. This leads the backtrack_insn to fail to propagate precision to the stack location, which is then not marked as precise! Later, the verifier's path pruning can incorrectly consider two states equivalent when they differ in terms of stack state. Meaning, two branches can be treated as equivalent and thus get pruned when they should not be seen as such. Fix it as follows: Extend the BPF_LDX handling in backtrack_insn to also cover atomic fetch operations via is_atomic_fetch_insn() helper. When the fetch dst register is being tracked for precision, clear it, and propagate precision over to the stack slot. For non-stack memory, the precision walk stops at the atomic instruction, same as regular BPF_LDX. This covers all fetch variants. Before: 0: (b7) r1 = 8 ; R1=8 1: (7b) *(u64 *)(r10 -8) = r1 ; R1=8 R10=fp0 fp-8=8 2: (b7) r2 = 0 ; R2=0 3: (db) r2 = atomic64_fetch_add((u64 *)(r10 -8), r2) ; R2=8 R10=fp0 fp-8=mmmmmmmm 4: (bf) r3 = r10 ; R3=fp0 R10=fp0 5: (0f) r3 += r2 mark_precise: frame0: last_idx 5 first_idx 0 subseq_idx -1 mark_precise: frame0: regs=r2 stack= before 4: (bf) r3 = r10 mark_precise: frame0: regs=r2 stack= before 3: (db) r2 = atomic64_fetch_add((u64 *)(r10 -8), r2) mark_precise: frame0: regs=r2 stack= before 2: (b7) r2 = 0 6: R2=8 R3=fp8 6: (b7) r0 = 0 ; R0=0 7: (95) exit After: 0: (b7) r1 = 8 ; R1=8 1: (7b) *(u64 *)(r10 -8) = r1 ; R1=8 R10=fp0 fp-8=8 2: (b7) r2 = 0 ; R2=0 3: (db) r2 = atomic64_fetch_add((u64 *)(r10 -8), r2) ; R2=8 R10=fp0 fp-8=mmmmmmmm 4: (bf) r3 = r10 ; R3=fp0 R10=fp0 5: (0f) r3 += r2 mark_precise: frame0: last_idx 5 first_idx 0 subseq_idx -1 mark_precise: frame0: regs=r2 stack= before 4: (bf) r3 = r10 mark_precise: frame0: regs=r2 stack= before 3: (db) r2 = atomic64_fetch_add((u64 *)(r10 -8), r2) mark_precise: frame0: regs= stack=-8 before 2: (b7) r2 = 0 mark_precise: frame0: regs= stack=-8 before 1: (7b) *(u64 *)(r10 -8) = r1 mark_precise: frame0: regs=r1 stack= before 0: (b7) r1 = 8 6: R2=8 R3=fp8 6: (b7) r0 = 0 ; R0=0 7: (95) exit

CWE(s)

Related Threats

CVEs Like This One

CVE-2026-43321Same product: Linux Linux Kernel
CVE-2026-43030Same product: Linux Linux Kernel
CVE-2024-42231Same product: Linux Linux Kernel
CVE-2026-64006Same product: Linux Linux Kernel
CVE-2026-53217Same product: Linux Linux Kernel
CVE-2026-43033Same product: Linux Linux Kernel
CVE-2026-53191Same product: Linux Linux Kernel
CVE-2023-2163Same product: Linux Linux Kernel
CVE-2026-52920Same product: Linux Linux Kernel
CVE-2026-45988Same product: Linux Linux Kernel

Affected Assets

linux
linux kernel
7.0 · 5.12 — 6.19.12

Mitigating Controls

Mitigating Controls (ISO/IEC 27001:2022 Annex A) AI

Derived directly from the weakness types (CWEs) cited in the NVD entry via our AI-authored CWE→ISO cross-walk (authority under review) — links open the control.

finds

Security testing in development and acceptance can detect calculation flaws before deployment.

prevents

Secure coding standards directly prohibit unsafe arithmetic and require defensive checks against incorrect results.

Hardening callouts derived

DISA STIG baselines are authored against specific weaknesses. Where this CVE cites a broad weakness class, the mapping is not asserted at that abstraction (owner ruling, 2026-09-25: grade only at Base and below), so no rule is shown here rather than a rule shown against the wrong grain.

  • No fine-grained STIG row for CWE-682, a pillar-level weakness, and none of its children carries one either.

References