Skip to main content

Linux kernel EUVDEUVD-2026-108827

| CVE-2026-99032 HIGH
2026-10-23 Linux GHSA-7g97-v76m-w626
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Local user opens AF_SMC socket
  2. Exploit
    Trigger link-group termination via shutdown(SHUT_WR)
  3. Execution
    Race getsockname() against clcsock release
  4. Impact
    UAF 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – 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

Linux patch: 7.2.11
Linux patch: 0
Linux b03faa1fafc8018295401dc558bdc76362d860a4 <c223da71abfaea2ebb1c7208ae9ebf15038f9388
Linux b03faa1fafc8018295401dc558bdc76362d860a4 <1512e3714b3946bda75a160a34f22a51710daa43
Linux patch: 6.18.57
Linux b03faa1fafc8018295401dc558bdc76362d860a4 <64a6b36b0e1855288080bc5f89769f27d6dc03c8
Linux 4.19.299 <4.20
Linux patch: 6.12.113
Linux 5.1
Linux b03faa1fafc8018295401dc558bdc76362d860a4 <e607017a553d2a48e428ec8b8ffb06bf3bb92ce9
Linux patch: 7.3
Linux 0b6153d04c96a1d4b6284692386aa21d04d7956c
Linux b03faa1fafc8018295401dc558bdc76362d860a4 <6a1833f0d7dc037c8e876b9178ba69d5d107c086
Linux patch: 6.6.160

Affected Packages

euvd linux fix: 4.20

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

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.3 MEDIUM

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.

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

4
CVSS changed
Oct 24, 2026 - 14:22 NVD
7.8 (HIGH)
Patch available
Oct 23, 2026 - 13:17 EUVD
CVE Published
Oct 23, 2026 - 12:21 cve.org
HIGH 7.8
CVE Published
Oct 23, 2026 - 12:21 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Ubiquitous
Linux kernel runs everywhere, though the affected AF_SMC subsystem is rarely enabled
Data Quality
4 sources
Confidence: Medium

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 0.2%
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
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

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