Skip to main content

Linux Kernel EUVDEUVD-2026-115277

| CVE-2026-99235 HIGH
2026-11-02 Linux GHSA-26q8-79pw-ggjf
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Gain write access to tracefs trigger files
  2. Delivery
    Create compatible histogram matched on keys only
  3. Exploit
    Add target histogram with field variable referencing it
  4. Execution
    Remove the compatible trigger, freeing its object
  5. Impact
    Access the dangling pointer to corrupt kernel memory

Vulnerability Assessment

Exploitation Conditions

Requires a kernel built with histogram triggers (CONFIG_HIST_TRIGGERS) and local access to the ftrace event-trigger interface under tracefs (typically /sys/kernel/tracing/events/.../trigger), which on standard distributions is writable only by root/CAP_SYS_ADMIN - this is the primary limiting factor and is in tension with the input's PR:L. The attacker must also perform a specific sequence: create a histogram whose keys match an existing event but that has no variables of its own, create a target histogram with a field variable via create_field_var_hist() that selects that compatible histogram (find_compatible_hist matches on keys alone), then remove the compatible trigger - check_var_refs() fails to protect it, so unregister_field_var_hists() later dereferences freed memory. Not remotely reachable (AV:L); no network path and no unauthenticated vector.

Impact

This is a use-after-free in the Linux kernel's ftrace histogram-trigger subsystem (event_hist_trigger_free), confirmed by the KASAN slab-use-after-free splat in the description and by eight upstream stable fix commits on git.kernel.org. The provided CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8) signals a local, low-complexity, full-CIA-impact memory-corruption bug - consistent with kernel UAF that can be steered toward privilege escalation. However, the signals point to constrained real-world risk rather than mass exploitation: the vuln.today decision label is 'this_week' (not act_now/emergency), there is no CISA KEV listing, no EPSS score was supplied, and no public exploit or PoC reference is present - the KASAN trace is a crash report, not an exploit. One tension to verify: the vector states PR:L, yet the trigger path lives under tracefs (/sys/kernel/tracing), which is normally writable only by root/CAP_SYS_ADMIN, so the realistic privilege prerequisite is likely higher than PR:L implies - verify the tracefs permission model in the target deployment. CWE is marked N/A in the input but the description and KASAN output unambiguously describe a use-after-free (CWE-416). Net: a legitimate kernel memory-corruption fix worth patching on a normal cadence, but not an in-the-wild emergency on current evidence.

Exploit ScenarioDerived

A local user with the ability to write ftrace histogram triggers creates a 'compatible' histogram (matched on keys alone, with no variables of its own), then creates a target histogram with a field variable that references it, then removes the compatible trigger - which is freed while the target still holds a pointer to it, producing a use-after-free on teardown that an attacker can shape toward kernel memory corruption and privilege escalation. No public exploit or PoC reference was identified at time of analysis; only the upstream crash (KASAN) report and fix commits are available. Exploitation is local (AV:L) and low-complexity (AC:L) once the attacker can reach the histogram-trigger interface.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available

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

Alert me

AnalysisAIv1 – Nov 02, 2026

A use-after-free in the Linux kernel's ftrace histogram-trigger code lets a local user who can write to the tracefs event-trigger interface create a target histogram with a field variable, have it latch onto an unrelated pre-existing histogram that merely shares the same keys, and then remove that other trigger - after which unregister_field_var_hists() dereferences the freed histogram, producing a KASAN slab-use-after-free read in event_hist_trigger_free. The assessed vector is AV:L/AC:L/PR:H with high confidentiality, integrity and availability impact, reflecting that tracefs trigger files are normally writable only by root or CAP_SYS_ADMIN, so the practical attack surface is privileged local access on kernels built with CONFIG_HIST_TRIGGERS. No public exploit has been identified at time of analysis; the flaw is fixed by a series of upstream stable commits on git.kernel.org, and the priority label is this_week.

RemediationAI

Apply the upstream stable fix for your kernel branch; the change is published as commits a6165126b1a1b26342b55be6eb6ee23af8756aba, 173914501b97236d7ea7dc2af7f30feddd4e1436, ac815a379644b2ad5008a009a3516ada31b5dd82, 8b307d64a60548e4a74cb746f74d7ed4bd49965e, 7a111ba0d1b74c99bc8f096565dc71945f694254, 3609ada3c12cecfb0ae5ee82ef4f86c5f18a2dea, 9631dbccd3c649b567a5aafffea6b00634183997 and 7cafc82e6153f05a221be678cd649d02e06ba909 on git.kernel.org, each corresponding to a stable branch, so select the one matching your kernel (see https://git.kernel.org/stable/c/a6165126b1a1b26342b55be6eb6ee23af8756aba and the sibling commit URLs). Until the patched kernel is running, the exposure is gated by write access to the tracefs event-trigger files: restrict that interface to root and CAP_SYS_ADMIN only, and keep tracefs unmounted on hosts that do not need ftrace (trade-off: no tracing or histogram-based observability on those systems). Rebuilding the kernel without CONFIG_HIST_TRIGGERS removes the vulnerable code path entirely, at the cost of losing histogram triggers and any tooling that depends on them. Note that these mitigations only narrow who can reach the buggy sequence; they do not repair the stale-pointer dereference, which requires the fixed kernel.

Affected VersionsENISA

Linux patch: 6.18.60
Linux patch: 0
Linux patch: 7.2.14
Linux patch: 5.15.224
Linux patch: 6.6.161
Linux 02205a6752f223779a1b0e9e8ffacbea6e717851 <173914501b97236d7ea7dc2af7f30feddd4e1436
Linux 4.17
Linux patch: 5.10.273
Linux 02205a6752f223779a1b0e9e8ffacbea6e717851 <a6165126b1a1b26342b55be6eb6ee23af8756aba
Linux patch: 6.1.191
Linux 02205a6752f223779a1b0e9e8ffacbea6e717851 <8b307d64a60548e4a74cb746f74d7ed4bd49965e
Linux 02205a6752f223779a1b0e9e8ffacbea6e717851 <7cafc82e6153f05a221be678cd649d02e06ba909
Linux 02205a6752f223779a1b0e9e8ffacbea6e717851 <9631dbccd3c649b567a5aafffea6b00634183997
Linux 02205a6752f223779a1b0e9e8ffacbea6e717851 <3609ada3c12cecfb0ae5ee82ef4f86c5f18a2dea
Linux patch: 7.3.1
Linux patch: 6.12.115
Linux 02205a6752f223779a1b0e9e8ffacbea6e717851 <ac815a379644b2ad5008a009a3516ada31b5dd82
Linux 02205a6752f223779a1b0e9e8ffacbea6e717851 <7a111ba0d1b74c99bc8f096565dc71945f694254

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 bug lives in the ftrace histogram-trigger subsystem (CONFIG_HIST_TRIGGERS), the tracing feature that attaches synthetic histograms to trace events through the per-event 'trigger' file in tracefs. Field variables are supplied by create_field_var_hist(), which builds a histogram on a matched event and stores a reference so the object can be torn down later: it calls find_compatible_hist() to locate an existing histogram on the target and writes that pointer into var_hist->hist_data. That pointer, however, is not the histogram the function creates - it is a pre-existing one whose keys the new histogram copies, and its only consumer is unregister_field_var_hists(), which runs when the target is removed and dereferences hist_data->field_var_hists[i]->hist_data->event_file. Because find_compatible_hist() matches on keys alone, it can select a histogram that has no variables of its own; check_var_refs() then returns false and the user is free to delete that trigger, leaving the target holding a dangling pointer that is dereferenced later. The trigger sequence is spelled out in the fix commit: build a key-compatible histogram with no variables, create a target histogram with a field variable that selects it, then remove the compatible trigger. The KASAN report confirms a slab-use-after-free read of size 8 in event_hist_trigger_free, with the object freed earlier via event_hist_trigger_free() from event_hist_trigger_parse() through trigger_process_regex(). The fix stores the event file itself rather than the compatible histogram - the only thing the dereference ever needed, and one that survives the user removing a trigger. No CWE identifier was supplied with the record.

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 6.7 MEDIUM

Exploiting the ftrace histogram-trigger interface requires write access to tracefs, normally root-only, so PR:H; local vector and a deterministic trigger sequence give AV:L/AC:L with full kernel-memory CIA impact.

3.1 AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:H/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

2
Patch available
Nov 02, 2026 - 17:18 EUVD
CVE Published
Nov 02, 2026 - 16:06 cve.org
HIGH 7.8

DescriptionCVE.org

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

tracing: Save the event file instead of the compatible histogram

create_field_var_hist() creates a histogram on the matched event to supply a field variable, and records it on the target so it can be torn down later:

hist_data = find_compatible_hist(target_hist_data, file); ... /* Save the compatible histogram information */ var_hist->hist_data = hist_data;

hist_data is not the histogram it creates. It is one that was already there, whose keys the new one copies. The saved pointer has a single user, unregister_field_var_hists(), which runs when the target is removed:

file = hist_data->field_var_hists[i]->hist_data->event_file;

find_compatible_hist() matches on keys alone, so it can pick one with no variables of its own. check_var_refs() then returns false and the user can remove it while the target still points at it:

BUG: KASAN: slab-use-after-free in event_hist_trigger_free+0x2b2/0x320 Read of size 8 at addr ffff8880093b90e0 by task init/1

Freed by task 1: kfree+0x154/0x420 event_hist_trigger_free+0x1d5/0x320 event_hist_trigger_parse+0x35f3/0x69e0 trigger_process_regex+0x1a6/0x250

Save the event file instead. It is all the dereference ever wanted, and it does not go away when the user removes a trigger.

Executive ViewAI

Why It Matters

A high-severity use-after-free vulnerability in the Linux kernel's ftrace histogram-trigger code (CVE-2026-99235) can be exploited by a privileged local user to crash or potentially compromise systems. This affects organizations running kernels with CONFIG_HIST_TRIGGERS enabled, typically enterprise Linux servers and cloud instances, and while exploitation requires elevated access, the potential for availability and integrity impact warrants immediate management attention.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: restrict local access to tracefs event-trigger files to trusted administrators only; consider disabling CONFIG_HIST_TRIGGERS if not required; monitor for unusual activity in ftrace triggers.

Threat Intelligence Overview

Prevalence
Ubiquitous
Linux kernel, present in nearly all server, cloud, and device environments
Social Media
1
Sightings
Data Quality
2 sources
Confidence: Low

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 N/A
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
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

39
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +39
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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