CVE-2026-53389

Awaiting Analysis Awaiting Analysis - Queue

Use-After-Free in Linux Kernel TCP-AO Implementation

Publication date: 2026-07-19

Last updated on: 2026-07-29

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: net/tcp-ao: fix use-after-free of key in del_async path In tcp_ao_delete_key(), the del_async path skips the current_key and rnext_key validity checks present in the synchronous path, assuming these pointers are always NULL on LISTEN sockets. However, if a key was added with set_current=1/set_rnext=1 while the socket was in CLOSE state, current_key and rnext_key will be non-NULL after listen() transitions the socket to LISTEN. When such a key is deleted with del_async=1, hlist_del_rcu() and call_rcu() free the key without clearing the dangling pointers. After the RCU grace period, getsockopt(TCP_AO_INFO) dereferences current_key->sndid and rnext_key->rcvid from freed slab memory. Clear current_key and rnext_key in the del_async path when they reference the key being deleted.

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published

2026-07-19

Last Modified

2026-07-29

Generated

2026-08-09

AI Q&A

2026-07-19

EPSS Evaluated

2026-08-08

NVD

CVE-2026-53389

EUVD

EUVD-2026-45511

Affected Vendors & Products

Vendor	Product	Version / Range
linux	linux_kernel	From 6.7 (inc) to 6.12.95 (exc)
linux	linux_kernel	From 6.13 (inc) to 6.18.38 (exc)
linux	linux_kernel	From 6.19 (inc) to 7.1.3 (exc)

Helpful Resources

Exploitability

CWE

KEV

CWE ID	Description
CWE-416	The product reuses or references memory after it has been freed. At some point afterward, the memory may be allocated again and saved in another pointer, while the original pointer references a location somewhere within the new allocation. Any operations using the original pointer are no longer valid because the memory "belongs" to the code that operates on the new pointer.

Attack-Flow Graph

Executive Summary

This vulnerability in the Linux kernel involves a use-after-free issue in the TCP Authentication Option (TCP-AO) implementation. When a socket transitions from CLOSE to LISTEN state after a key was added with specific flags, deleting the key asynchronously can leave dangling pointers. These pointers are later dereferenced when querying socket options, leading to potential memory corruption or crashes.

Detection Guidance

This vulnerability is specific to the Linux kernel's TCP-AO implementation and requires kernel-level inspection. Detection involves checking for use-after-free conditions in tcp_ao_delete_key() during asynchronous key deletion. No direct network commands exist for detection; instead, monitor kernel logs for slab corruption or memory access errors after TCP-AO key deletions.

Impact Analysis

This vulnerability could allow an attacker to cause a denial-of-service condition by crashing the system or potentially execute arbitrary code with kernel privileges. It may also lead to data corruption or unauthorized access if exploited successfully.

Compliance Impact

This vulnerability involves a use-after-free flaw in the Linux kernel's TCP-AO implementation, which could lead to memory corruption and potential unauthorized access. While not directly tied to GDPR or HIPAA, such vulnerabilities may impact compliance by compromising data integrity and confidentiality if exploited. Organizations handling sensitive data under these regulations could face increased risk of breaches.

Mitigation Strategies

Apply the Linux kernel patch that resolves this issue. Update to a patched kernel version where current_key and rnext_key are cleared in the del_async path. Avoid using TCP-AO features until patched. Monitor kernel logs for related errors as a temporary detection measure.

Hi! I’m here to help you understand CVE-2026-53389. Ask me anything about the vulnerability, its impact, or mitigation strategies.

0/70