CVE-2026-64046: Linux Kernel TLS Scatterlist Vulnerability

CVE-2026-64046 Overview

CVE-2026-64046 is a Linux kernel vulnerability in the TLS (Transport Layer Security) subsystem. The flaw resides in the plain text scatterlist (SG) handling code, where a chain link can be improperly created after another chain link. When end = 0 and start != 0, the existing code produces a chain where the wrap link points directly to another chain link. The sg_next scatterlist iterator does not recursively resolve consecutive chain links, so this construction is illegal input to the kernel crypto API. The issue affects the kernel net/tls module used by applications leveraging kTLS offload.

Critical Impact
An attacker leveraging the network attack vector can trigger malformed scatterlist chains in the kernel crypto path, potentially impacting confidentiality, integrity, and availability of TLS-protected communications.

Affected Products

Linux kernel net/tls subsystem (kTLS)
Distributions shipping affected upstream kernel versions
TLS 1.2 and TLS 1.3 workloads relying on kernel TLS offload

Discovery Timeline

2026-07-19 - CVE-2026-64046 published to NVD
2026-07-20 - Last updated in NVD database

Technical Details for CVE-2026-64046

Vulnerability Analysis

The vulnerability exists in the Linux kernel TLS layer, specifically in how plain text scatterlists are constructed before being handed off to the crypto subsystem. Scatterlists in the kernel use a linked structure where a final entry can either terminate the list (END marker) or chain to another list segment. The net/tls code reserves a wrapping slot to enable such chaining.

When end = 0 but start != 0, the code path unconditionally emits a chain link at the wrap slot, then chains again to attach the content type entry. This produces two consecutive chain links. The sg_next iterator in the kernel does not recursively follow chain-to-chain transitions, so the crypto API receives malformed input and cannot correctly walk the scatterlist.

Root Cause

The root cause is incorrect ordering and unconditional emission of scatterlist wrap chaining in the TLS plain text SG builder. The wrap link becomes unnecessary when end = 0 because no entries follow the wrap slot. TLS 1.3 can safely reuse the wrapping slot for its own chaining when end = 0, avoiding the illegal chain-after-chain pattern. The fix skips wrap chaining in this case and reorders the wrap chaining to occur before marking END and chaining the content type entry.

Attack Vector

The attack vector is network-based. TLS traffic processed through kernel TLS with specific message layouts can trigger the condition where end = 0 and start != 0. Malformed scatterlist input to the crypto subsystem can produce undefined behavior in the kernel crypto path. The vulnerability manifests during TLS record processing rather than through a specific user-space syscall pattern.

The fix is described in the upstream Linux kernel commits, including Kernel Patch Commit 410351158dfe and Kernel Patch Commit ff26a0e8377d. Refer to the security advisories for technical details of the scatterlist reordering.

Detection Methods for CVE-2026-64046

Indicators of Compromise

Unexpected kernel crashes or oops messages referencing sg_next, scatterwalk, or tls_sw functions.
Crypto API errors logged in dmesg during TLS record processing on kTLS-enabled sockets.
Anomalous termination of processes using TLS_TX or TLS_RX socket options.

Detection Strategies

Inventory running kernel versions across Linux hosts and compare against the fixed commits listed in the kernel stable tree.
Monitor dmesg and journalctl -k for kernel warnings originating in net/tls/tls_sw.c or the crypto subsystem.
Correlate kTLS usage (via setsockopt with SOL_TLS) with kernel-mode fault telemetry.

Monitoring Recommendations

Enable kernel audit logging and forward kernel messages to a centralized logging platform for retention and search.
Track scatterlist-related BUG or WARN events, which are unusual under normal workloads.
Baseline TLS workload behavior so that new patterns of connection resets or crypto failures are surfaced quickly.

How to Mitigate CVE-2026-64046

Immediate Actions Required

Apply the upstream Linux kernel patches referenced in the stable tree commits and reboot affected systems.
Prioritize patching hosts that terminate TLS in the kernel, including load balancers, reverse proxies, and file servers using kTLS.
Validate distribution vendor advisories (Red Hat, SUSE, Ubuntu, Debian) for backported fixes matching your kernel branch.

Patch Information

The fix is available in the Linux kernel stable tree across multiple maintained branches. Relevant commits include 410351158dfe, 49a5faaa471d, 91359966e247, 929b1548e63a, acdc12b71c9a, af855f4c966a, b9c015ef1a7b, and ff26a0e8377d. Apply the patch matching your kernel series.

Workarounds

Disable kernel TLS offload where feasible by moving TLS termination back to user space (for example, OpenSSL in-process).
Remove the tls kernel module from hosts that do not require kTLS: modprobe -r tls and blacklist the module until patched.
Restrict which local users and containers can invoke setsockopt(SOL_TLS) through seccomp or LSM policies to limit exposure.

bash

# Verify current kernel version and check for the tls module
uname -r
lsmod | grep '^tls'

# Temporarily disable the kernel TLS module until patched
sudo modprobe -r tls
echo 'blacklist tls' | sudo tee /etc/modprobe.d/blacklist-tls.conf