Linux 7.2-rc2 Strengthens Protections Against BPF JIT Spraying Attacks

As the release of Linux 7.2-rc2 approaches, measures to counter JIT spraying attacks have been introduced in the kernel’s BPF (Berkeley Packet Filter) code. A series of patches developed by Intel engineer Pawan Gupta has been merged after the merge window closed. These patches implement a mechanism to flush indirect branch predictors during memory reuse in the BPF JIT allocator. According to Phoronix, these changes are scheduled to be included in Linux 7.2-rc2, set to be released in the early hours of July 6, Japan time.

Why Address JIT Spraying Now?

JIT spraying attacks involve attackers embedding crafted code fragments into the executable code regions generated by JIT compilers. By manipulating indirect branch predictions, they exploit vulnerabilities in speculative execution mechanisms. One well-known example is branch target injection, associated with Spectre-v2 (CVE-2017-5715), which can contaminate the CPU’s branch prediction mechanism, leading to privilege escalation or data leaks.

Phoronix noted the “unusual timing” of these patches being incorporated after the merge window closed, though it remains unclear if a recent security discovery was the motivation. The site emphasized that “the surprising aspect is that BPF code had not been safeguarded against JIT spraying attacks until now.” BPF is widely used in container environments and cloud infrastructure, and can be accessed from unprivileged user space, making it a critical attack surface.

As previously reported in “Linux 7.2-rc1 Released, Integrating AMDGPU HDMI 2.1 FRL and Cache Aware Scheduling,” Linux 7.2-rc1 had already incorporated features like AMDGPU HDMI 2.1 FRL support and Cache Aware Scheduling. This recent security enhancement marks an important fix introduced between rc1 and rc2.

Patch Details: Two-Stage Hardening

The first patch posted by Gupta implements indirect branch predictor flushing in the BPF JIT allocator. The BPF JIT allocator packs numerous small programs into larger executable regions and reuses these regions during program loading and unloading. During reuse, leftover branch predictions from old programs could negatively affect the execution of new programs.

Specifically, a static key called bpf_arch_pred_flush_enabled and a static call named bpf_arch_pred_flush have been introduced. This design allows architecture-specific flushing functions to be hooked, with the default set to NOP (no operation) to avoid issuing extra CALL instructions. Larger allocations exceeding the pack size are excluded from flushing, as the attack surface for classic BPF (cBPF) programs from unprivileged users is safely within the pack size. If this assumption is violated, warnings are issued.

The second patch enables IBPB (Indirect Branch Predictor Barrier) flushing for BPF JIT allocations in environments where Spectre-v2 mitigations are active. Specifically, IBPB is issued when reusing BPF JIT memory. However, if the BPF dispatcher already uses retpoline (return trampoline), IBPB flushing is skipped. This hardening only applies when CONFIG_BPF_JIT is enabled, and builds with CONFIG_BPF_JIT=n are guarded to ensure bugs.c remains unaffected.

Security Impact and Industry Response

This update advances kernel defenses against speculative execution vulnerabilities. BPF is an essential component in cloud-native environments, underpinning network policies and observability tools in Docker and Kubernetes. For systems where unprivileged users can load BPF programs, the risk of JIT spraying attacks has been a tangible threat.

The fact that this patch was spearheaded by an Intel engineer is noteworthy. Since the disclosure of Spectre vulnerabilities, Intel has provided both hardware and software mitigations. This patch further extends those efforts. The design also allows AMD and Arm architectures to adopt similar protections by implementing appropriate flush functions.

As reported in “Linux Cache Aware Scheduling Boosts MySQL Performance by Up to 360%,” the Linux kernel continues to evolve on both performance and security fronts. The BPF JIT hardening represents a balanced design that minimizes performance impact while addressing speculative execution vulnerabilities.

Editorial Opinion

In the short term, these patches will primarily reduce the risk of speculative execution vulnerabilities arising during the reuse of BPF JIT buffers. For cloud providers and data center operators, this change contributes to stronger isolation in multi-tenant environments. Systems where unprivileged BPF is enabled should apply this update promptly. While the performance impact is expected to be minimal, increased IBPB flush frequency could lead to higher latency, warranting real-world testing.

From a long-term perspective, these measures can be seen as a transitional response extending the Spectre-v2 mitigations. Future CPU generations are expected to advance hardware-level branch prediction isolation, but ongoing software measures are essential to protect existing hardware. Additionally, addressing similar issues in Arm and RISC-V architectures remains a challenge. Kernel maintainers are likely to encourage the implementation of flush functions for these architectures.

The editorial team is most puzzled as to why such protections had not been implemented in BPF code until now.

References

• Phoronix: Linux 7.2-rc2 BPF Code Being Hardened Against JIT Spraying Attacks — Published on 2026-07-03