Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain write access to tracefs trigger files
-
DeliveryCreate compatible histogram matched on keys only
-
ExploitAdd target histogram with field variable referencing it
-
ExecutionRemove the compatible trigger, freeing its object
-
ImpactAccess 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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 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
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
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.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
2DescriptionCVE.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.
Articles & Coverage 1
Executive ViewAI
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.
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
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-115277
GHSA-26q8-79pw-ggjf
NVD
CVE.org
VulDB
Exploit-DB