HIGH
tls AsyncHold Queue Leak
CVE-2026-23414
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
KernelScan AI7.5HIGH
01Description
In the Linux kernel, the following vulnerability has been resolved: tls: Purge async_hold in tls_decrypt_async_wait() The async_hold queue pins encrypted input skbs while the AEAD engine references their scatterlist data. Once tls_decrypt_async_wait() returns, every AEAD operation has completed and the engine no longer references those skbs, so they can be freed unconditionally. A subsequent patch adds batch async decryption to tls_sw_read_sock(), introducing a new call site that must drain pending AEAD operations and release held skbs. Move __skb_queue_purge(&ctx->async_hold) into tls_decrypt_async_wait() so the purge is centralized and every caller -- recvmsg's drain path, the -EBUSY fallback in tls_do_decryption(), and the new read_sock batch path -- releases held skbs on synchronization without each site managing the purge independently. This fixes a leak when tls_strp_msg_hold() fails part-way through, after having added some cloned skbs to the async_hold queue. tls_decrypt_sg() will then call tls_decrypt_async_wait() to process all pending decrypts, and drop back to synchronous mode, but tls_sw_recvmsg() only flushes the async_hold queue when one record has been processed in "fully-async" mode, which may not be the case here. [pabeni@redhat.com: added leak comment]
02KernelScan AI Analysis
Risk summary
A memory leak in the Linux kernel's TLS implementation can cause socket buffers to accumulate when async decryption operations fail partway through processing. While this doesn't directly compromise system security, it can lead to memory exhaustion over time, potentially causing denial of service conditions on systems handling many TLS connections.
Vulnerability analysis
Root Cause: The TLS async decryption code fails to properly clean up socket buffers (skbs) in the async_hold queue when tls_strp_msg_hold() fails partway through processing. When this failure occurs after some cloned skbs have already been added to the async_hold queue, tls_decrypt_async_wait() is called to process pending decrypts and drop back to synchronous mode, but the async_hold queue is only purged in tls_sw_recvmsg() when operating in 'fully-async' mode, which may not be the case during this error path.
Attack Surface: This vulnerability affects TLS socket operations and requires local access to create TLS connections. The leak occurs during normal TLS receive operations when memory allocation failures trigger the error path, making it reachable through standard socket APIs without requiring elevated privileges.
Fix Mechanism: The patch centralizes the cleanup by moving __skb_queue_purge(&ctx->async_hold) from tls_sw_recvmsg() into tls_decrypt_async_wait(). This ensures that every caller of tls_decrypt_async_wait() automatically releases held skbs when synchronization completes, eliminating the need for each call site to manage the purge independently.
03Fix Versions
| Branch | Fixed in | Patch commit |
|---|---|---|
| 6.1 | 6.1.168 | ac435be7c761 |
| 6.12 | 6.12.80 | 6dc11e0bd0a5 |
| 6.18 | 6.18.21 | 9f557c7eae12 |
| 6.19 | 6.19.11 | fd8037e1f18c |
| 6.6 | 6.6.131 | 2dcf324855c3 |
| mainline | 7.0 | 84a8335d8300 |