Skip to navigation

Threat reportVulnerabilityTL-2026-2796

Spectre-v2 Branch Target Reuse (BTR) Attack Leaks Linux Kernel Memory Despite Existing Defenses (CVE-2026-64507, CVE-2026-64508)

highPATCHED

Researchers from VUSec (VU Amsterdam) and Scuola Superiore Sant'Anna disclosed Branch Target Reuse (BTR), a Spectre-v2 variant in which stale indirect branch prediction entries survive JIT code-cache reuse, giving a transient execute-after-free primitive. Two end-to-end exploits via the Linux kernel's unprivileged classic BPF (cBPF) JIT recover the root password hash in about 3-5 minutes on fully patched Intel systems; Linux fixes are merged. First disclosed .

Key facts

IdentifiersTL-2026-2796, CVE-2026-64507, CVE-2026-64508
Also known asBranch Target Reuse, BTR, Spectre-BTR
SeverityHIGH
CVSS5.5
First disclosed
EPSSCVE-2026-64508: 0.2% (10.6th percentile); CVE-2026-64507: 0.1% (4.6th percentile)
Affected productsLinux Linux kernel (x86 BPF JIT); Mozilla Firefox (SpiderMonkey JIT); Oracle GraalVM; Intel Processors (Raptor Cove, Lion Cove confirmed); AMD Processors with indirect branch prediction; Arm Processors with indirect branch prediction
MalwareSpectre
MITRE ATT&CK techniquesT1003.008 /etc/passwd and /etc/shadow, T1005 Data from Local System, T1203 Exploitation for Client Execution, T1212 Exploitation for Credential Access
MotivationUNKNOWN
Target sectorscloud, technology, government administration, finance, telecoms
Target regionsGlobal
Detection rules9 (1 shown free)
Sources8 cited sources

Detection coverage

As of 2026-09-29, Threadlinqs Intelligence publishes 9 detection rule(s) for TL-2026-2796 across Splunk SPL, Microsoft KQL and Sigma, covering 15 indicator(s) of compromise. The whole corpus is readable without an account. Every threat comes with one complete detection in Splunk SPL, Microsoft KQL and Sigma, free for everyone; a free account adds daily TL Creds to unlock the rest. Paid plans add a larger daily allowance, correlation and the MCP server. Threadlinqs MCP server · View plans.

Free detection: BTR Training Loop — Unprivileged Classic BPF Filter Load/Free Churn

Detects the exploit primitive of Branch Target Reuse (CVE-2026-64507 / CVE-2026-64508): an unprivileged process repeatedly installing and releasing classic BPF programs (seccomp filters, prctl(PR_SET_SECCOMP), SO_ATTACH/DETACH_FILTER) to train the indirect branch predictor, free the JIT chunk and re-emit different code over the same addresses. The constant-blinding-bypass variant still uses the same cBPF load path, so it is covered. No network IOCs exist; this behavioural signal is the only telemetry-visible part of the attack. Counts one-minute bursts per host/uid/exe on x86_64 auditd.

  • Languages: Splunk SPL, Microsoft KQL, Sigma
  • ATT&CK: T1068, T1212, T1211, T1106
  • Data sources: linux_auditd (index=linux, sourcetype=linux_audit), Splunk Add-on for Unix and Linux
  • Severity: medium
  • Confidence: medium

Splunk SPL

index=linux sourcetype=linux_audit type=SYSCALL arch=c000003e earliest=-24h
```x86_64 syscalls: seccomp=317 prctl=157 setsockopt=54; PR_SET_SECCOMP=0x16, SOL_SOCKET=1, SO_ATTACH_FILTER=0x1a, SO_DETACH_FILTER=0x1b```
| eval sc=lower(syscall)
| eval filter_op=case(in(sc,"317","seccomp"),"seccomp", in(sc,"157","prctl") AND a0="16","prctl_seccomp", in(sc,"54","setsockopt") AND a1="1" AND a2="1a","sock_attach_filter", in(sc,"54","setsockopt") AND a1="1" AND a2="1b","sock_detach_filter")
| where isnotnull(filter_op) AND uid!="0" AND uid!="root"
| where NOT match(exe,"(?i)/(chrome|chromium|chrome-sandbox|firefox|firefox-bin|systemd|systemd-journald|sshd|runc|containerd-shim-runc-v2|dockerd|snapd|bwrap|crio|podman|conmon)$")
| bin _time span=1m
| stats count as filter_ops dc(pid) as distinct_pids values(filter_op) as ops values(comm) as comms by _time host uid auid exe
| where filter_ops>=100
| sort - filter_ops

Microsoft KQL

// Requires auditd rules for seccomp/prctl/setsockopt forwarded to the Syslog table (AMA)
Syslog
| where TimeGenerated > ago(24h)
| where SyslogMessage has 'type=SYSCALL' and SyslogMessage has 'arch=c000003e'
| extend sc = tolower(extract(@' syscall=([^ ]+)', 1, SyslogMessage)),
         uid = extract(@' uid=([^ ]+)', 1, SyslogMessage),
         auid = extract(@' auid=([^ ]+)', 1, SyslogMessage),
         pid = extract(@' pid=([0-9]+)', 1, SyslogMessage),
         exe = extract(@'exe="?([^" ]+)', 1, SyslogMessage),
         a0 = extract(@' a0=([^ ]+)', 1, SyslogMessage),
         a1 = extract(@' a1=([^ ]+)', 1, SyslogMessage),
         a2 = extract(@' a2=([^ ]+)', 1, SyslogMessage)
| extend FilterOp = case(
    sc in ('317', 'seccomp'), 'seccomp',
    sc in ('157', 'prctl') and a0 == '16', 'prctl_seccomp',
    sc in ('54', 'setsockopt') and a1 == '1' and a2 == '1a', 'sock_attach_filter',
    sc in ('54', 'setsockopt') and a1 == '1' and a2 == '1b', 'sock_detach_filter',
    '')
| where FilterOp != '' and uid !in ('0', 'root')
| where exe !matches regex @'(?i)/(chrome|chromium|chrome-sandbox|firefox|firefox-bin|systemd|systemd-journald|sshd|runc|containerd-shim-runc-v2|dockerd|snapd|bwrap|crio|podman|conmon)$'
| summarize FilterOps = count(), DistinctPids = dcount(pid), Ops = make_set(FilterOp) by bin(TimeGenerated, 1m), Computer, uid, auid, exe
| where FilterOps >= 100
| order by FilterOps desc

Sigma

title: Unprivileged Seccomp or Socket Filter Load (BTR cBPF Training Primitive)
name: tl_2796_cbpf_filter_op
id: 7c3f2a1e-5b48-4d9a-a1c6-0e8b93d4f527
status: experimental
description: Detects unprivileged installation of classic BPF programs through seccomp(2), prctl(PR_SET_SECCOMP) or setsockopt(SO_ATTACH_FILTER/SO_DETACH_FILTER) on x86_64. Branch Target Reuse (CVE-2026-64507, CVE-2026-64508) trains the indirect branch predictor with unprivileged cBPF programs, frees them and reuses the JIT memory. A single event is normal so alert on the paired event_count correlation rule.
references:
    - https://www.vusec.net/projects/btr/
    - https://osv.dev/vulnerability/CVE-2026-64507
author: Threadlinqs Team
date: 2026-09-29
tags:
    - attack.privilege-escalation
    - attack.t1068
    - attack.credential-access
    - attack.t1212
    - attack.defense-evasion
    - attack.t1211
    - cve.2026-64507
    - cve.2026-64508
logsource:
    product: linux
    service: auditd
detection:
    selection_seccomp:
        type: 'SYSCALL'
        syscall:
            - '317'
            - 'seccomp'
    selection_prctl:
        type: 'SYSCALL'
        syscall:
            - '157'
            - 'prctl'
        a0: '16'
    selection_sockfilter:
        type: 'SYSCALL'
        syscall:
            - '54'
            - 'setsockopt'
        a1: '1'
        a2:
            - '1a'
            - '1b'
    filter_root:
        uid:
            - '0'
            - 'root'
    filter_sandbox:
        exe|endswith:
            - '/chrome'
            - '/chromium'
            - '/firefox'
            - '/firefox-bin'
            - '/systemd'
            - '/sshd'
            - '/runc'
            - '/dockerd'
            - '/snapd'
            - '/bwrap'
            - '/crio'
            - '/podman'
            - '/conmon'
    condition: 1 of selection_* and not 1 of filter_*
falsepositives:
    - Browsers, container runtimes and systemd services that install seccomp filters
level: low
---
title: Unprivileged cBPF Filter Load Churn (BTR Training Loop)
id: 2f9d64b8-1c37-4e05-8a72-b6d0e1c95a43
status: experimental
description: Fires when one uid on one host issues 100 or more unprivileged classic BPF load/detach operations within one minute, matching the train-free-reuse loop of Branch Target Reuse (CVE-2026-64507, CVE-2026-64508).
author: Threadlinqs Team
date: 2026-09-29
tags:
    - attack.privilege-escalation
    - attack.t1068
    - attack.credential-access
    - attack.t1212
    - attack.defense-evasion
    - attack.t1211
    - cve.2026-64507
    - cve.2026-64508
correlation:
    type: event_count
    rules:
        - tl_2796_cbpf_filter_op
    group-by:
        - host
        - uid
    timespan: 1m
    condition:
        gte: 100
falsepositives:
    - Sandbox-heavy workloads such as CI runners, build farms and fuzzers
level: medium

Known false positives:

  • Browsers, container runtimes and systemd services that legitimately install seccomp filters at high rates
  • CI runners, build farms and fuzzing harnesses that spawn many sandboxed processes

Tuning notes: Requires auditd rules such as: -a always,exit -F arch=b64 -S seccomp -F auid>=1000 -F auid!=unset; -a always,exit -F arch=b64 -S prctl -F a0=0x16; -a always,exit -F arch=b64 -S setsockopt -F a1=1 -F a2=0x1a. Syscall numbers are x86_64 only (arm64 uses different numbers). Baseline per-host filter_ops for a week, then set the 100/min threshold above the sandbox-heavy p99 and extend the exe allowlist. Auditd raw/interpreted (-i) output is handled for syscall names but argument values stay hex.

8 more detection rules (Splunk SPL, Microsoft KQL, Sigma) · unlock with TL Creds. Sign up free to unlock the detection rules or query them with the Threadlinqs MCP server (Purple)
  • Unprivileged eBPF Program Load (bpf BPF_PROG_LOAD) on Hosts Exposed to BTR · unlock with TL Creds
  • Command-Line Access to /etc/shadow by Non-Management Tooling (Root Hash Collection) · unlock with TL Creds
  • Spectre-v2 Mitigation Downgrade or Unprivileged BPF Re-Enablement · unlock with TL Creds
  • Spectre-v2 Mitigation State Reconnaissance by Non-Root Users · unlock with TL Creds
  • Offline Password Cracking Tooling (Post-Leak Root Hash Cracking) · unlock with TL Creds
  • Retrieval of BTR Research Proof of Concept via git, curl or wget · unlock with TL Creds
  • BTR Post-Exploitation — Unprivileged cBPF Churn Followed by /etc/shadow Access on the Same Host · unlock with TL Creds
  • BTR Follow-On — Root Authentication After Unprivileged cBPF Churn on the Same Host · unlock with TL Creds

Indicators of compromise

As of 2026-09-29, Threadlinqs Intelligence tracks 15 indicators of compromise for TL-2026-2796.

Sample indicators (3 of 15)

  • File hash: a3af84b0fa00ead01fcd0e28b5d773ff25990a0d
  • File hash: 25dbcd31781e2bc3cd63d873af1fcd06f863a126
  • File hash: cb27f3bf915cc0f20fc0c48da9059304e39ebd35

Defanged, TLP:CLEAR. Full set of 15 indicators: unlock with TL Creds.

15 indicators of compromise · unlock with TL Creds. Compare plans

Technical analysis

Branch Target Reuse (BTR) is a Spectre-v2 variant described in the paper 'Practical Spectre-v2 Attacks in JIT Engines via Stale Branch Prediction Entries' (Sander Wiebing, Yuhui Zhu, Alessandro Biondi, Cristiano Giuffrida; VUSec and Scuola Superiore Sant'Anna; accepted to ACM CCS 2026; embargo lifted 2026-09-29). The root cause is that modern CPUs restore architectural code coherence after self-modifying code but do not necessarily invalidate stale indirect branch prediction entries. In JIT engines, those stale targets outlive the original code and are reused when the code cache is repopulated, yielding a transient 'execute-after-free' primitive that hijacks speculative control flow into newly generated code at obsolete offsets.

The attack proceeds in four steps: (1) train a victim indirect branch to jump into attacker-controlled JIT code, (2) get that JIT chunk deallocated, (3) arrange for new code to be emitted over the same addresses, and (4) trigger the branch again so the CPU speculatively follows the stale BTB entry into misaligned offsets of the reallocated JIT memory. Against the Linux kernel, the exploit uses unprivileged classic BPF programs (created as seccomp filters for the training and target chunks) to train the prediction, free the original program, and place a different program in the reused memory. Two end-to-end exploits leak kernel memory at roughly 8 bytes per second and recover the root password hash in about 3 minutes on Intel Raptor Cove and about 5 minutes on Lion Cove, with default protections enabled. An adaptation defeats BPF constant blinding by encoding attacker bytes in forward jump offsets (a technique from Maisuradze et al., 2016) instead of 4-byte immediates, creating misaligned gadgets that decode differently at alternate alignment boundaries; the hash is still recovered within 5 minutes.

The behaviour was confirmed on every CPU tested, spanning Intel, AMD and Arm, and against three JIT engines: the Linux kernel cBPF JIT, Mozilla Firefox's SpiderMonkey (WebAssembly literal pools via f64.const; estimated tens of bytes per second, full browser exploit not achieved), and Oracle GraalVM (jumping past masking operations that protect sandbox boundaries into unmasked memory access). The same group had previously published an 'Interrupt Injection' attack in August 2026.

Mitigations: the Linux kernel fixes are CVE-2026-64507 ('x86/bugs: Enable IBPB flush on BPF JIT allocation', issuing an IBPB flush on BPF JIT memory reuse when Spectre-v2 mitigations are in use, skipped if the BPF dispatcher already uses retpolines, and only when BPF JIT is enabled) and CVE-2026-64508 (BPF hardening against JIT spraying by flushing branch predictors before reusing JIT memory). Both were published 2026-07-25 (OSV record modified 2026-08-21) and fixed in stable releases 6.1.183, 6.6.145, 6.12.97, 6.18.39 and 7.1.4 (affected since 5.18.0), and in mainline 7.2-rc2. Debian shipped fixes via DSA-6405-1, DLA-4724-1 and DLA-4777-1 (Bullseye not affected). Oracle GraalVM randomizes JIT code-cache locations; Mozilla is relying on site isolation and considering IBPB-based mitigations. Third-party trackers list CVE-2026-64507 at CVSS 5.5 (Medium); the sources reviewed do not publish a CVSS vector and no in-the-wild exploitation is reported. A public proof of concept and demo video accompany the research.

MITRE ATT&CK techniques by tactic:

Credential Access

T1003.008 /etc/passwd and /etc/shadow; T1212 Exploitation for Credential Access

Collection

T1005 Data from Local System

Execution

T1203 Exploitation for Client Execution

Remediation

Patches

  • Linux kernel: x86/bugs IBPB flush on BPF JIT allocation (CVE-2026-64507) and BPF JIT-spraying hardening (CVE-2026-64508)
  • Debian: DSA-6405-1, DLA-4724-1, DLA-4777-1 (e.g. 6.1.187-1, 6.12.107-1~deb12u1, 6.12.111-1)
  • Oracle GraalVM: randomized JIT code-cache locations

Immediate actions

  • Upgrade the Linux kernel to a release containing the CVE-2026-64507 and CVE-2026-64508 fixes (6.1.183, 6.6.145, 6.12.97, 6.18.39, 7.1.4 or later; mainline 7.2-rc2+)
  • Apply OS and CPU microcode/firmware updates from the hardware vendor

Workarounds

  • Restrict unprivileged BPF where feasible (kernel.unprivileged_bpf_disabled) until patched
  • Do not disable Spectre-v2 mitigations (mitigations=off) on multi-tenant or untrusted-code hosts

Longer-term hardening

  • Keep Spectre-v2 mitigations (IBPB/retpoline) enabled on hosts that run BPF JIT
  • Deploy Firefox site isolation and track Mozilla IBPB-based mitigation work

Affected and fixed versions

  • Linux — Linux kernel (x86 BPF JIT)
    Vulnerable versions: 5.18.0 to before 6.1.183; 6.2.0 to before 6.6.145; 6.7.0 to before 6.12.97; 6.13.0 to before 6.18.39; 6.19.0 to before 7.1.4
    Fixed in: 6.1.183; 6.6.145; 6.12.97; 6.18.39; 7.1.4; 7.2-rc2 (mainline)
  • Mozilla — Firefox (SpiderMonkey JIT)
    Vulnerable versions: Tested by researchers; version not stated
  • Oracle — GraalVM
    Vulnerable versions: Tested by researchers; version not stated
    Fixed in: JIT code-cache location randomization
  • Intel — Processors (Raptor Cove, Lion Cove confirmed)
    Vulnerable versions: Raptor Cove; Lion Cove
  • AMD — Processors with indirect branch prediction
    Vulnerable versions: Confirmed vulnerable; models not detailed
  • Arm — Processors with indirect branch prediction
    Vulnerable versions: Confirmed vulnerable; models not detailed

Timeline

  • Linux stable fixes released in 6.1.183, 6.6.145, 6.12.97, 6.18.39 and 7.1.4 (mainline fix in 7.2-rc2); vulnerable range starts at 5.18.0
  • CVE-2026-64507 (x86/bugs IBPB flush on BPF JIT allocation) and CVE-2026-64508 (BPF JIT-spraying hardening) published for the Linux kernel
  • OSV record for CVE-2026-64508 last modified, listing six fix commits across the affected stable branches
  • The Hacker News, BleepingComputer and HWBusters publish coverage; Debian tracker lists fixes via DSA-6405-1, DLA-4724-1 and DLA-4777-1
  • GraalVM randomizes JIT code-cache locations; Mozilla prioritizes site isolation and considers IBPB-based mitigations for SpiderMonkey; Linux issues IBPB on BPF JIT allocation
  • Researchers report BTR on Intel, AMD and Arm CPUs and in SpiderMonkey (WebAssembly f64.const literal pools) and GraalVM (bypass of sandbox masking); no complete browser exploit achieved
  • Two end-to-end Linux cBPF exploits recover the root password hash in ~3 minutes on Raptor Cove and ~5 minutes on Lion Cove at ~8 bytes/s, including a constant-blinding bypass via jump-offset encoding
  • Public proof of concept and demo video released alongside the paper; exploits target the Linux cBPF JIT, with SpiderMonkey and GraalVM also shown exposed
  • Embargo lifted; VUSec and Scuola Superiore Sant'Anna publish the Branch Target Reuse research (accepted to ACM CCS 2026)

Sources cited

Previous and next in vulnerability

Drafted by the Threadlinqs research pipeline from 8 sources; published ; last updated —.

Threadlinqs Intelligence — Real-Time Threat Detection Platform

// threat_feed
$ sort --newest
Showing all threats

Live intelligence console

Threat level

Latest Threats