CVE-2026-74692
Received Received - Intake

Race Condition in Linux Kernel SMC Module

Vulnerability report for CVE-2026-74692, including description, CVSS score, EPSS score, affected products, exploitability, helpful resources, and attack-flow context.

Publication date: 2026-08-22

Last updated on: 2026-08-22

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: net/smc: fix TOCTOU race between smc_listen_out() and listener close smc_listen_out() reads lsmc->sk.sk_state without the listener lock, then acquires lock_sock_nested() only after the check passes. This opens a window where smc_close_active() can transition the listener to SMC_CLOSED, call smc_close_cleanup_listen() to drain the accept queue, and release the lock, all between the lockless read and the delayed lock acquisition: smc_listen_work (smc_hs_wq) smc_close_active() ------------------------------- ------------------------- release_sock(child) if (sk_state == SMC_LISTEN) TRUE lock_sock(listener) sk_state = SMC_CLOSED smc_close_cleanup_listen() release_sock(listener) flush_work(tcp_listen_work) lock_sock_nested(listener) smc_accept_enqueue(listener, child) /* child enqueued on dead listener */ smc_close_active() flushes only tcp_listen_work. Work items already dispatched onto smc_hs_wq for the CLC handshake continue running unguarded. smc_accept_enqueue() takes a sock_hold() on the child that is never released, so the child smc_sock, its clcsock, and the reference all leak. A remote peer that opens TCP connections while the server calls close() can exhaust kernel memory. Move lock_sock_nested() to before the sk_state check so that the test and the enqueue are atomic under the listener lock.

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-08-22
Last Modified
2026-08-22
Generated
2026-08-22
AI Q&A
2026-08-22
EPSS Evaluated
N/A
NVD
EUVD

Affected Vendors & Products

Showing 1 associated CPE
Vendor Product Version / Range
linux linux_kernel *

Helpful Resources

Exploitability

CWE
CWE Icon
KEV
KEV Icon
CWE ID Description
CWE-UNKNOWN

Attack-Flow Graph

AI Quick Actions

Instant insights powered by AI
Executive Summary

This is a race condition in the Linux kernel's SMC (Socket Messaging Channel) implementation. It occurs when smc_listen_out() checks the socket state without proper locking, allowing smc_close_active() to close the listener and drain the accept queue before the check completes. This can lead to memory leaks as child sockets are enqueued on a dead listener.

Detection Guidance

This vulnerability involves a race condition in the Linux kernel's SMC (Socket Direct) implementation. Detection requires kernel-level monitoring for memory leaks or unexpected socket states. Check for kernel logs for smc-related errors or use tools like 'ss -tulnp' to inspect listening sockets. Monitor memory usage for unexplained growth.

Impact Analysis

An attacker could exploit this to cause a kernel memory leak by repeatedly opening TCP connections while the server is closing. This may lead to denial of service by exhausting available memory, potentially crashing the system or degrading performance.

Mitigation Strategies

Apply the latest Linux kernel patches addressing this issue. If immediate patching is not possible, consider disabling SMC protocol usage temporarily. Monitor system memory and socket states for anomalies. Restrict network access to services using SMC to reduce exposure.

Chat Assistant

Ask questions about this CVE
Hi! I’m here to help you understand CVE-2026-74692. Ask me anything about the vulnerability, its impact, or mitigation strategies.
0/70

EPSS Chart