Description

In the Linux kernel, the following vulnerability has been resolved: net/smc: fix socket use-after-free during link group termination __smc_lgr_terminate() drops conns_lock after finding a connection in lgr->conns_all, but before taking a reference on its socket. The connection is embedded in the socket, and its registration reference protects it only while the connection remains in the tree. A concurrent close can unregister the connection and drop that reference, freeing the socket before the termination worker reaches sock_hold(). The race is reachable when close overlaps link group termination. Local stress testing reproduced the use-after-free and KASAN reported: BUG: KASAN: slab-use-after-free in __smc_lgr_terminate.part.0 [smc] Write of size 4 by task kworker/3:3 Workqueue: events smc_lgr_terminate_work [smc] __smc_lgr_terminate.part.0 [smc] The socket was allocated by smc_create(), freed through slab_free_after_rcu_debug(), and was followed by: refcount_t: addition on 0; use-after-free. __smc_lgr_terminate.part.0 [smc] Take the socket reference while conns_lock still protects the tree entry. The unregister path then cannot drop the last reference until termination has finished using the socket.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "9.8",
  "pubDate": "2026-08-15T13:17:54.240Z",
  "pubdate": "2026-08-15T13:17:54.240Z",
  "executiveSummary": "A use-after-free vulnerability exists in the Linux kernel net/smc subsystem during link group termination. The vulnerability is classified as a concurrency-related memory safety issue leading to a use-after-free condition. It affects the Linux kernel's Shared Memory Communications (SMC) implementation.\nThe flaw allows a local attacker or concurrent process to trigger memory corruption and potential kernel crashes by exploiting a race condition between link group termination and socket closure. Successful exploitation results in kernel instability, denial of service, and potentially arbitrary code execution depending on kernel heap layout and hardening configurations.\nThe attack requires local access where a concurrent close operation overlaps with link group termination handled by the smc_lgr_terminate_work workqueue. No complex remote attack vector is described, but local stress testing successfully reproduced the defect, resulting in KASAN slab-use-after-free bug reports during refcount operations.",
  "technicalDetails": "The root cause of the vulnerability resides in the __smc_lgr_terminate() function within the net/smc subsystem of the Linux kernel. During the link group termination process, __smc_lgr_terminate() iterates over connections registered in lgr->conns_all and drops the conns_lock after identifying a connection, but before obtaining a reference on the corresponding socket via sock_hold().\nThe connection structure is embedded directly within the socket structure. The registration reference protects the connection only as long as the connection remains present in the tree. When the conns_lock is prematurely dropped, a concurrent close operation can execute, unregistering the connection and dropping the final reference. This frees the socket via slab_free_after_rcu_debug() before the termination worker thread is able to execute sock_hold().\nConsequently, when the termination worker subsequently attempts to acquire a reference on the freed socket, it triggers a refcount_t addition on a zero-initialized or recycled object, resulting in a slab-use-after-free condition detected by KASAN.\nThe attack flow proceeds as follows: 1) A link group termination is initiated, triggering __smc_lgr_terminate(). 2) The function locates a connection in lgr->conns_all while holding conns_lock. 3) The function drops conns_lock before invoking sock_hold() on the embedded socket. 4) A concurrent socket close operation unregisters the connection, drops the reference count to zero, and deallocates the socket memory. 5) The termination worker resumes, attempts to access or hold the freed socket, and triggers the use-after-free bug.\nThe vulnerable component is the SMC link group termination handler (__smc_lgr_terminate.part.0). The vulnerability requires local execution context where a socket close overlaps with link group termination. Authentication and privilege requirements depend on the local environment's ability to create and close SMC sockets and trigger link group terminations."
}