Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach TIPC-enabled host over network
-
DeliverySend crafted TIPC packet
-
ExploitTrigger node-reset trace race vs bearer teardown
-
ExecutionDereference freed link pointer
-
ImpactKernel crash or freed-memory disclosure
Vulnerability Assessment
| Exploitation Conditions | Two non-default prerequisites must both hold: (1) the TIPC subsystem must be enabled/in use on the target (not loaded by default on typical distributions), and (2) the tipc_node_reset_links tracepoint must be enabled, which normally requires local privileged access to tracefs or an active tracing/monitoring configuration. Beyond those, the attacker must win a genuine race (AC:H) against tipc_node_link_down()/bearer teardown freeing the link. These factors - niche protocol, enabled tracepoint, and timing-dependent race - sharply limit realistic exploitation despite the network-reachable trigger; the leaked freed-memory data is written to the local trace buffer rather than returned to the remote attacker. |
| Impact | This is a use-after-free (effectively CWE-416, though CWE is listed N/A) in the Linux kernel TIPC subsystem: the tipc_node_reset_links trace event walks node link entries without holding the node lock, racing bearer teardown that frees a link. The input CVSS of 8.1 (AV:N/AC:H/PR:N/UI:N/C:H/I:H/A:H) frames this as a high-severity network-reachable flaw, but several real-world signals pull the priority down. There is no KEV listing, no EPSS score provided, and no public exploit reference in the input, so exploitation is not confirmed and the only supportable status is 'no public exploit identified at time of analysis.' The vuln.today decision label is 'this_week' rather than act_now/emergency, consistent with a patch-available, not-actively-exploited issue. Critically, the C:H/I:H/A:H impact rating looks generous: the primary observable effect is a KASAN-reported read of freed slab memory, whose data lands in the kernel trace buffer (locally readable, so limited remote confidentiality) and whose deref of a stale pointer realistically causes a kernel crash (DoS). AC:H correctly reflects that the description shows a genuine two-CPU race. The biggest caveat the raw score hides: the vulnerable code path only runs when the TIPC subsystem is enabled AND the tipc_node_reset_links tracepoint is active, neither of which is default, so this is a high-CVSS issue with a narrow real-world attack surface rather than a broad emergency. |
| Exploit ScenarioDerived | On a host where the TIPC subsystem is enabled and the tipc_node_reset_links tracepoint is turned on, a remote attacker sends crafted TIPC traffic (reaching tipc_rcv via tipc_udp_recv) to force node link resets while bearer teardown concurrently frees a link structure. Winning this race causes the trace dump to dereference a freed link pointer, crashing the kernel or exposing freed slab contents in the trace buffer. No public exploit is identified at time of analysis; the KASAN report in the description is a developer reproducer, not distributed exploit code. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 03, 2026
Use-after-free in the Linux kernel TIPC subsystem: the tipc_node_reset_links trace event calls tipc_node_dump() to walk the node's link array without holding the node lock, so concurrent bearer teardown (tipc_node_link_down/delete=true) can free a link and null the array entry while the dump is in progress, after which tipc_link_dump() dereferences the stale pointer - KASAN reports a slab-use-after-free of size 4. Practical exploitation requires two non-default preconditions, namely that TIPC is enabled and actually in use on the target (it is not loaded by default on typical distributions) and that the tipc_node_reset_links tracepoint is armed, which normally implies privileged tracefs access or an active tracing/monitoring configuration; on top of that the attacker must win a genuine race, so the realistic impact is a locally-buffered memory disclosure and potential denial of service rather than data returned to the remote sender. No public exploit was identified at time of analysis, and vendor patches have been released across the listed stable branches.
RemediationAI
Vendor-released patches address the flaw: upgrade to Linux 5.10.273, 5.15.224, 6.1.191, 6.6.161, 6.12.115, 6.18.59, 7.2.13 or 7.3 (or later) on the corresponding branch, per the stable commits referenced at https://git.kernel.org/stable/c/c8b72ca0918e95f708f67c8b3e69b05290f2b6d2 and the NVD record https://nvd.nist.gov/vuln/detail/CVE-2026-99246; distributions shipping a backported kernel should track their own erratum rather than the upstream version numbers. Where patching must be delayed, the exploitation prerequisites can be removed directly: do not enable the tipc_node_reset_links tracepoint (and audit existing ftrace/perf/tracing configurations for tipc_node_class events), which costs observability of TIPC node reset activity; restrict write access to tracefs so unprivileged users cannot arm the event; and, if TIPC is not operationally required, unload or blacklist the tipc module so the receive path cannot be reached at all, at the cost of breaking any TIPC-dependent clustering workloads. Note that the upstream fix is the complete remedy - the trace-event workaround only closes the specific dump path.
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
TIPC (Transparent Inter-Process Communication) is a Linux kernel clustering protocol whose node objects hold an array of link pointers (n->links[i].link) protected by a per-node read/write lock. Several tracepoints in the tipc_node_class ask tipc_node_dump() to serialize link data, and those call sites take the node lock; the tipc_node_reset_links event, raised from the receive path (tipc_rcv → tipc_node_reset_links via tipc_udp_recv in the reported splat), did not. Because bearer teardown frees link structures under tipc_node_write_lock() in tipc_node_link_down()/tipc_node_delete_links(), a dump running locklessly can read a link that has already been kfree()'d and set to NULL. The fix wraps the trace event in the node write lock, serializing the dump against the freeing path. The bug class is a use-after-free (effectively CWE-416, although the CVE record lists CWE as N/A); the affected object is the link allocated in tipc_link_create() during destination discovery and freed during bearer_disable(). Severity assessment is complicated by the fact that the freed-memory contents are written into the local ftrace buffer, not transmitted back to the packet sender, and that the race window plus the tracepoint and protocol prerequisites make the flaw timing-dependent (AC:H).
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:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
Network-triggered via a TIPC packet but needs a race (AC:H) and non-default tracing; freed data lands in the local trace buffer (C:L), no integrity impact (I:N), stale-pointer deref crashes the kernel (A:H).
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
3DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
tipc: protect node reset trace dump with node lock
The tipc_node_reset_links trace event asks tipc_node_dump() to walk the node's link entries. Unlike the other node events that request link data, this event runs without the node lock.
This permits bearer teardown to free a link while the trace callback is dumping it:
CPU 0 CPU 1 trace_tipc_node_reset_links() tipc_node_dump() l = n->links[0].link tipc_node_write_lock() kfree(l) n->links[0].link = NULL tipc_node_write_unlock() tipc_link_dump(l)
tipc_link_dump() then dereferences the stale pointer. KASAN reported:
BUG: KASAN: slab-use-after-free in tipc_link_dump Read of size 4 by task poc/115 Call Trace: tipc_link_dump+0x10cb/0x16b0 tipc_node_dump+0x4bb/0x740 trace_event_raw_event_tipc_node_class+0x258/0x360 tipc_node_reset_links+0x14d/0x1a0 tipc_rcv+0x13f5/0x3030 tipc_udp_recv+0x4e3/0x670 Allocated by task 0: tipc_link_create+0x1e1/0x1020 tipc_node_check_dest+0x7d2/0x11a0 tipc_disc_rcv+0xdbf/0x1430 Freed by task 89: kfree+0x131/0x3c0 tipc_node_link_down+0x267/0x4b0 tipc_node_delete_links+0xec/0x160 bearer_disable+0x107/0x260
Take the node write lock around the trace event. This serializes the dump against tipc_node_link_down(delete=true), which frees the link under the same write lock.
Articles & Coverage 1
Executive ViewAI
A high-severity use-after-free vulnerability (CVE-2026-99246) in the Linux kernel's TIPC subsystem could allow local attackers with privileged access to cause memory disclosure or denial of service, but only under non-default conditions. The risk is confined to environments that actively use TIPC and have tracing enabled, meaning most standard enterprise Linux deployments are not exposed. Leadership should prioritize patching for any systems running TIPC or involved in network tracing/monitoring.
Apply vendor patch.
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-115776
GHSA-qwfh-hpch-ph73
NVD
CVE.org
Exploit-DB