Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessLocal user opens AF_SMC socket
-
ExploitTrigger link-group termination via shutdown(SHUT_WR)
-
ExecutionRace getsockname() against clcsock release
-
ImpactUAF read of freed clcsock (info leak) or NULL deref (crash)
Vulnerability Assessment
| Exploitation Conditions | Requires: (1) local access to the host and the ability to create AF_SMC sockets, which in turn requires the kernel to be built/loaded with SMC support (CONFIG_SMC) and typically SMC connectivity in use - not a default on most general-purpose distributions; (2) an established SMC socket whose link group is terminated (reachable via shutdown(SHUT_WR) driving smc_close_active_abort() / smc_clcsock_release()); and (3) winning a timing race between a getsockname()/getpeername() call and the termination worker that clears and frees smc->clcsock. LIMITING FACTORS: the vector is local-only (no network reachability), the SMC subsystem must be enabled and exercised (a significant filter, as most deployments never use SMC), and the race window is tight - KASAN required added timing instrumentation to hit it, so reliable exploitation against an unmodified kernel is non-trivial. Authentication: CVSS PR:L indicates a low-privilege (authenticated/local-user) requirement, not unauthenticated remote access. |
| Impact | Signals diverge, and the honest read is high-severity-but-constrained risk. The input CVSS of 7.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) is driven by local access with full CIA impact, but every real-world amplifier is low: EPSS is 0.21% (11th percentile), the CVE is NOT in CISA KEV, and no public exploit or PoC reference is present in the input (only kernel.org stable patch commits). The vuln.today decision label is 'this_week', consistent with a patch-promptly-but-not-emergency posture rather than act_now. Two tensions should be flagged explicitly: (1) the vector is AV:L (local only) - this is not remotely reachable, so exposure is limited to attackers who already have the ability to run code and open AF_SMC sockets on the host; (2) the CVSS claims I:H and A:H, but the described mechanism is a use-after-free READ in smc_getname() (an 8-byte load of freed clcsock) plus a possible NULL dereference, which maps cleanly to information disclosure and denial-of-service (crash) but weakly to integrity - the Tags even label this 'Information Disclosure', so the input's I:H appears overstated versus the described primitive. Additionally, exploitation requires winning a race: KASAN only reproduced this 'with test-only timing instrumentation', indicating a tight window. Net: a legitimate kernel bug worth patching on a normal cadence, not a widespread-exploitation emergency. |
| Exploit ScenarioDerived | A local unprivileged user on a host with SMC (AF_SMC) sockets in use opens an SMC connection, triggers link-group termination (e.g. via shutdown(SHUT_WR) leading to smc_close_active_abort()), and concurrently calls getsockname() on the socket, racing the termination worker that releases the CLC socket. If the worker frees clcsock after the syscall loads the pointer, the getname path reads freed slab memory (use-after-free, potential kernel info leak); if it clears the pointer first, the result is a NULL dereference and crash (DoS). No public exploit is identified; the reporter used a KASAN-instrumented reproducer, not a published tool. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 24, 2026
A local race in the Linux kernel's SMC (AF_SMC) socket stack lets a getsockname() caller dereference smc->clcsock after a link-group termination worker has cleared and released that CLC socket, producing a slab use-after-free or, if the pointer is cleared first, a NULL dereference. Exploitation is constrained: it requires a kernel built with SMC support (CONFIG_SMC) and an established SMC socket whose link group is torn down (reachable via shutdown(SHUT_WR) driving smc_close_active_abort()/smc_clcsock_release()), plus winning a tight timing window - the KASAN report was only obtained with added test-only timing instrumentation, so the race is not trivially reliable on an unmodified kernel. No public exploit identified at time of analysis; EPSS is low at 0.21% (11th percentile), and vendor fixes are available in the 6.6.160, 6.12.113, 6.18.57, 7.2.11 and 7.3 releases.
RemediationAI
Apply the vendor-released stable fixes: Linux 6.6.160, 6.12.113, 6.18.57 or 7.2.11 (mainline 7.3), each containing the change that holds clcsock_release_lock across the smc_getname() pointer check and getname() callback and returns -EBADF once the CLC socket has been released; commit references are 1512e3714b3946bda75a160a34f22a51710daa43, 64a6b36b0e1855288080bc5f89769f27d6dc03c8, e607017a553d2a48e428ec8b8ffb06bf3bb92ce9, c223da71abfaea2ebb1c7208ae9ebf15038f9388 and 6a1833f0d7dc037c8e876b9178ba69d5d107c086, with details at nvd.nist.gov/vuln/detail/CVE-2026-99032. Where the update cannot be deployed promptly and SMC is not required, the subsystem can be disabled at build time (CONFIG_SMC=n) or the module unloaded/blacklisted so AF_SMC sockets are unavailable; the trade-off is loss of SMC's shared-memory/RDMA acceleration and TCP fallback behavior for workloads that rely on it, and a local user who can load the module re-opens the exposure. Because the flaw is local-only and needs a live SMC socket to be terminated concurrently with a getsockname() call, limiting local shell access and untrusted users on hosts that have SMC enabled reduces exposure until the kernel is patched.
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
SMC (Shared Memory Communications) sockets are created via AF_SMC and are backed by an ordinary TCP "CLC" (client/server connection-layer) socket, stored as smc->clcsock; the SMC socket's lifetime and that of its CLC socket are not identical, which is the root of this defect. smc_getname() checked and dereferenced smc->clcsock (reading clcsock->ops and invoking the underlying getname callback) without holding clcsock_release_lock, so it could race with smc_clcsock_release(), which is invoked from smc_close_active_abort() during link-group termination (__smc_lgr_terminate) and calls sock_release() on the CLC socket. Because the syscall's file reference only pins the SMC socket, asynchronous release of the CLC socket remained possible while getsockname() was in flight, yielding a slab-use-after-free read of the clcsock operations pointer (or a NULL dereference if the pointer was cleared before the load). The fix holds clcsock_release_lock across both the pointer check and the getname() callback to serialize against smc_clcsock_release(), and returns -EBADF when the CLC socket has already been released while otherwise preserving the existing peer-state check and the callback's return value. The root-cause class is a race/lifetime (use-after-free, NULL dereference) issue; no CWE identifier was assigned in the source data. The independently assessed vector (AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:N/A:H) reflects a local, hard-to-win race with high confidentiality and availability impact, not a low-complexity, integrity-corrupting primitive.
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 AF_SMC socket needed (AV:L, PR:L); exploitation is a tight race per the timing-instrumentation note (AC:H); described primitive is a freed-memory read plus crash, so C:H/A:H but I:N.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
net/smc: protect clcsock lifetime in smc_getname
smc_getname() dereferences smc->clcsock without holding clcsock_release_lock. Link-group termination can release the CLC socket through smc_close_active_abort() while the SMC socket is still open, for example after shutdown(SHUT_WR).
A getsockname() caller can load smc->clcsock, then the termination worker can clear the pointer and call sock_release() before the caller accesses clcsock->ops or invokes getname(). This causes a use-after-free; if the worker clears the pointer before the load, it causes a NULL dereference. The syscall's file reference keeps the SMC socket alive but does not prevent asynchronous release of its CLC socket.
KASAN reported the following with test-only timing instrumentation:
BUG: KASAN: slab-use-after-free in smc_getname+0x19e/0x1b0 Read of size 8 at addr ffff888109abb4e0 by task poc/103 Call Trace: smc_getname+0x19e/0x1b0 do_getsockname+0xe5/0x170 __sys_getsockname+0x8c/0x100
Allocated by task 95: sock_alloc_inode+0x1e/0x280 sock_alloc+0x3d/0x240 __sock_create+0x7e/0x430 smc_create+0x121/0x240
Freed by task 0: kmem_cache_free+0xcc/0x340 rcu_core+0x50a/0x1850
Last potentially related work creation: evict+0x446/0x6c0 smc_clcsock_release+0xa8/0xd0 smc_close_active_abort+0x26a/0x3a0 __smc_lgr_terminate.part.0+0x137/0x2e0
Hold clcsock_release_lock across the pointer check and the getname() callback to serialize with smc_clcsock_release(). Return -EBADF if the CLC socket has already been released, preserving the existing peer state check and the callback's return value otherwise.
Executive ViewAI
A high-severity local race condition in the Linux kernel's SMC socket handling could allow an attacker with local access to crash systems or potentially gain elevated privileges. The vulnerability affects systems built with SMC support and requires a precise timing window, making exploitation difficult but not impossible. Leadership should prioritize patching because kernel-level flaws can lead to service disruptions and data compromise if exploited.
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-108827
GHSA-7g97-v76m-w626
NVD
CVE.org
EPSS
Exploit-DB