Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain local access to tracefs histogram interface
-
DeliveryRegister histogram on basename-colliding non-synthetic event
-
ExploitCreate then remove matching synthetic event
-
ExecutionImbalanced refcount frees synth_event early
-
PersistTrigger use-after-free via dangling pointer
-
ImpactCorrupt kernel memory / escalate privileges
Vulnerability Assessment
| Exploitation Conditions | Requires a kernel built with histogram-trigger support (CONFIG_HIST_TRIGGERS) and local access to the ftrace/tracefs event-trigger interface (typically /sys/kernel/tracing), which is normally privileged. The specific trigger stated in the description: a histogram must be registered on a NON-synthetic trace event whose basename matches a synthetic event BEFORE that synthetic event is created, and then removed AFTERWARDS - this ordering causes se->ref to be decremented without a matching increment, freeing the synthetic event while an active histogram action still holds a pointer. Limiting factors: exploitation is local-only (no remote vector), needs the attacker to control the event-registration/removal sequence and to engineer a name collision, and depends on access to the tracing subsystem rather than any default network-facing service. |
| Impact | This is a local-only Linux kernel use-after-free in the tracing/histogram subsystem, and the signals are internally consistent rather than conflicting. The supplied CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8) indicates an attacker already on the system with some privilege and the ability to reach the ftrace/tracefs histogram-trigger interface; there is no network vector. No EPSS score was provided, there is no CISA KEV listing (so this is NOT confirmed actively exploited), and no PoC or exploit reference appears in the input - the six references are all git.kernel.org stable commits (the fix), not exploit code. The vuln.today decision label is 'this_week', which is an elevated-but-not-emergency priority consistent with a patched, locally-exploitable kernel UAF rather than a mass-exploited internet-facing flaw. Net assessment: a genuine local privilege-escalation/kernel-memory-corruption risk worth patching on schedule, but not an emergency - real-world exploitation is gated by needing privileged access to tracefs and a precise event-registration sequence, and no in-the-wild activity is evidenced. Note one labeling tension: the input Tags mark this 'Information Disclosure', whereas the described primitive (freeing a synth_event while an active histogram action still holds a pointer) is a use-after-free that typically enables more than disclosure; treat the impact tag as understating the mechanism. |
| Exploit ScenarioDerived | A local, low-privileged user with access to the ftrace histogram-trigger interface registers a histogram on a non-synthetic trace event whose basename collides with a synthetic event, then creates and later removes the synthetic event; because the refcount was decremented without a matching increment, the synthetic event is freed while an active histogram action still references it, producing a use-after-free in kernel memory. Given AV:L/AC:L, this requires only local access and a controllable event-registration sequence, no user interaction. No public exploit identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 02, 2026
Local use-after-free in the Linux kernel's tracing/histogram subsystem allows a local user with access to the ftrace event-trigger interface to free a synthetic event while an active histogram action still holds a pointer to it, creating a kernel memory-corruption risk. Affected kernels must be built with CONFIG_HIST_TRIGGERS and permit local access to tracefs; exploitation requires registering a histogram on a non-synthetic trace event whose basename collides with a synthetic event before that synthetic event is created, then removing the histogram afterward so se->ref is decremented without a matching increment. No public exploit identified at time of analysis, and there is no CISA KEV confirmation of active exploitation.
RemediationAI
Apply the upstream stable fixes referenced at https://git.kernel.org/stable/c/381f543ed35c434d5b707369aa5dcd69ecf440af, https://git.kernel.org/stable/c/4472579bd1c83708b6fe623c870cdf728e947205, https://git.kernel.org/stable/c/23b4106e8b35823acc79e206c7745f55b9cfd78b, https://git.kernel.org/stable/c/06e816bed499fe47f39f12044382cc5d064485fb, https://git.kernel.org/stable/c/5597bb8db6855fcb97a67196d227fea359bcd81c, and https://git.kernel.org/stable/c/cf4e31d5da80fae4c9cdbe7af55b7c3ad213f0e4; an upstream fix is available via commit, but a released patched kernel version is not independently confirmed in the provided data. As compensating controls, restrict access to the tracefs/ftrace event-trigger interface (typically /sys/kernel/tracing) to trusted users, noting that this removes tracing visibility for less-privileged users, or build kernels without CONFIG_HIST_TRIGGERS where histogram triggers are not required, accepting loss of that functionality. Remediation should be scheduled consistent with the this_week priority label.
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 issue sits in the Linux tracing histogram-trigger code, which is exposed through tracefs/ftrace interfaces and depends on CONFIG_HIST_TRIGGERS. Synthetic events are reference-counted objects, and event_hist_trigger_parse() and hist_unreg_all() previously called find_synth_event() using trace_event_name(file->event_call); because that lookup compared only the event basename, a histogram attached to a non-synthetic trace event with the same basename as a synthetic event could incorrectly adjust the synthetic event's se->ref count. The root cause is therefore an identity-verification and reference-counting error that can produce a use-after-free when the synthetic event is freed while a histogram action still references it. The upstream fix introduces find_synth_event_call() to confirm that &se->call matches file->event_call before changing se->ref. The provided CPE data identifies linux:linux without version qualifiers, so exact affected kernel version ranges are not specified in the available sources.
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
Local tracefs access required (AV:L, PR:L); attacker fully controls the event registration/removal sequence (AC:L); the use-after-free can corrupt kernel memory, yielding high C/I/A.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
2DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
tracing/histograms: Verify event_call identity when updating synth_event refcount
In event_hist_trigger_parse() and hist_unreg_all(), the histogram registration and unregistration paths look up find_synth_event() using trace_event_name(file->event_call) and adjust se->ref if a match is found.
Because find_synth_event() only compares the event basename, registering or removing a histogram on a non-synthetic trace event whose basename matches a synthetic event erroneously modifies the synthetic event's reference count. If a histogram is registered on the non-synthetic event before the synthetic event is created and removed afterwards, se->ref is decremented without a matching increment, allowing the synthetic event to be freed while an active histogram action still holds a pointer to it.
Introduce find_synth_event_call() to verify that &se->call matches file->event_call before adjusting se->ref.
Articles & Coverage 1
Executive ViewAI
A high-severity local privilege escalation vulnerability (CVE-2026-99233) in the Linux kernel's tracing subsystem allows an authenticated local user with ftrace access to trigger a use-after-free, potentially corrupting kernel memory. This risk is elevated on multi-user servers and container hosts where unprivileged users can access tracefs; exploitation could lead to privilege escalation or system instability, undermining host integrity and availability.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict ftrace/tracefs access to privileged users, disable CONFIG_HIST_TRIGGERS if not required, or unmount tracefs where possible; monitor for suspicious use of ftrace event 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-115275
GHSA-hqr3-rh3c-f6xh
NVD
CVE.org
VulDB
Exploit-DB