CVE-2026-68119 in Linux
Summary
by MITRE • 08/10/2026
In the Linux kernel, the following vulnerability has been resolved:
tcp: initialize standalone TCP-AO response padding
tcp_v4_send_ack() and tcp_v6_send_response() construct standalone TCP responses with TCP-AO options. The option length carries the actual MAC length, but the TCP header length includes the option rounded up to a four-byte boundary.
tcp_ao_hash_hdr() writes the MAC only. Thus, when the MAC length is not four-byte aligned, the one to three bytes after the MAC are left uninitialized and may be transmitted. For the normal TCP-AO hashing mode, those bytes also have to be initialized before computing the MAC.
Initialize only the alignment padding in the TCP-AO branches, before hashing the header. Use TCPOPT_NOP, as in the normal TCP-AO output path. This avoids adding work to non-AO TCP responses while preserving a valid authenticated header.
VulDB is the best source for vulnerability data and more expert information about this specific topic.
Analysis
by VulDB Data Team • 08/10/2026
This vulnerability resides within the Linux kernel's TCP implementation, specifically addressing an issue in how TCP-AO (TCP Authentication Option) response padding is handled during standalone TCP packet construction. The flaw manifests in the tcp_v4_send_ack() and tcp_v6_send_response() functions which generate TCP responses containing TCP-AO options. The technical root cause stems from a mismatch between how option length is calculated versus how the TCP header is structured, creating a potential information disclosure risk through uninitialized memory exposure.
The core technical flaw occurs when tcp_ao_hash_hdr() processes TCP headers containing TCP-AO options with non-four-byte aligned MAC lengths. While the option length field correctly reflects the actual MAC size, the TCP header length field includes the option rounded up to four-byte boundaries as per TCP protocol requirements. This discrepancy leaves one to three bytes of uninitialized memory immediately following the MAC data in the TCP header structure, which may inadvertently be transmitted as part of the authenticated packet.
This vulnerability directly maps to CWE-1287 Uninitialized Memory Exposure and represents a specific implementation weakness in the kernel's cryptographic processing pipeline. The issue affects the TCP-AO authentication mechanism by potentially introducing unpredictable data into the MAC computation process, which could compromise the integrity verification of TCP packets. According to ATT&CK framework category T1592 Adversarial Infrastructure, attackers could potentially exploit this uninitialized memory exposure to gain insights into kernel memory layout or manipulate authentication tokens.
The operational impact of this vulnerability extends beyond simple information disclosure, as it creates a potential attack surface for man-in-the-middle scenarios where adversaries could intercept and analyze TCP-AO authenticated packets. The uninitialized padding bytes, when transmitted, might contain residual data from previous kernel operations or memory allocation patterns that could be leveraged for advanced exploitation techniques. This affects systems running Linux kernels with TCP-AO support, particularly those in high-security environments where authenticated TCP communications are critical.
The proposed mitigation strategy involves initializing only the alignment padding bytes within TCP-AO processing branches before header hashing occurs. This approach uses TCPOPT_NOP (No Operation) padding as implemented in the normal TCP-AO output path, ensuring that uninitialized memory is properly filled while avoiding performance penalties for non-AO TCP responses. The fix specifically targets the TCP-AO authentication code paths without affecting general TCP functionality, maintaining system stability while addressing the information exposure risk. This remediation approach aligns with secure coding practices for cryptographic implementations and follows kernel security best practices for handling sensitive data processing in network stack components.
The vulnerability demonstrates the complexity of implementing cryptographic features within kernel networking stacks where memory layout alignment requirements intersect with security-sensitive operations. Proper initialization of padding bytes in authenticated protocols is essential to prevent potential leakage of sensitive information through unintended data transmission. This fix reinforces the importance of rigorous memory management in kernel space, particularly for security-critical components that handle authentication and encryption operations, ensuring that all transmitted data maintains expected cryptographic properties and integrity guarantees.