CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-72137

CVE-2026-72137: Double Free in Linux Kernel XFRM NAT Keepalive

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 6, 2026·7 min read·18 visits

Executive Summary (TL;DR)

A double-free vulnerability in the Linux kernel XFRM subsystem allows error-handling paths to release a socket buffer twice, causing kernel crashes or potential local privilege escalation.

CVE-2026-72137 is a critical double-free vulnerability in the Linux kernel's XFRM (IPsec) subsystem. The vulnerability occurs when the kernel attempts to send NAT keepalive packets over UDP. Under specific transmission failure conditions, both the downstream networking stack and the upstream keepalive dispatcher attempt to free the same socket buffer (sk_buff) structure, leading to kernel memory corruption, denial of service, or potential local privilege escalation.

Vulnerability Overview

The Linux kernel IPsec framework (XFRM) subsystem implements Network Address Translation (NAT) keepalives to maintain stateful NAT bindings for UDP-encapsulated Encapsulating Security Payload (ESP) traffic. When configured, this subsystem periodically generates keepalive packets to prevent intermediate NAT gateways from expiring connection states.

This background keepalive mechanism uses nat_keepalive_send() to allocate, format, and dispatch socket buffer structures (sk_buff) down the network stack. A critical software flaw in this interface allows an allocated socket buffer to be freed twice under specific error conditions. This vulnerability is classified as a double-free memory corruption issue (CWE-415).

The vulnerability is triggered when the IPv4 or IPv6 helper functions encounter a transmission error after the networking stack has assumed ownership of the socket buffer. An attacker capable of inducing network-level or routing-level errors during keepalive transmission can exploit this vulnerability to corrupt kernel memory allocator structures, resulting in a system crash or potentially local privilege escalation.

Root Cause Analysis

In the Linux kernel's networking stack, socket buffer (sk_buff or skb) lifetime management is governed by strict ownership rules. When a socket buffer is passed to a downstream transmission function such as ip_build_and_send_pkt() or ip6_xmit(), the ownership of that structure is transferred to the receiving subsystem. If an error occurs during downstream processing, the receiving subsystem is responsible for freeing the skb and propagating the error code back up the execution chain.

Prior to the patch, the nat_keepalive_send() function in net/xfrm/xfrm_nat_keepalive.c violated these ownership rules. The function dispatched the skb to family-specific helper functions (nat_keepalive_send_ipv4() or nat_keepalive_send_ipv6()) and monitored the return code. If the helpers returned an error, the caller assumed it still owned the packet and invoked kfree_skb(skb) to clean up the buffer.

However, if the error was encountered after the helper had already passed the skb to the downstream transmission functions, those downstream functions had already executed their own cleanup paths, freeing the skb internally. Consequently, the secondary call to kfree_skb() inside nat_keepalive_send() attempted to free an already deallocated memory chunk. This pattern triggers a classic double-free condition within the kernel slab or slub allocator.

Code-Level Patch Analysis

The remediation of this vulnerability involves restructuring the boundaries of socket buffer ownership within the NAT keepalive execution path. The patch moves the cleanup responsibility of the sk_buff structure into the individual IPv4 and IPv6 helper functions, isolating the main caller from downstream state changes.

// In net/xfrm/xfrm_nat_keepalive.c
static int nat_keepalive_send_ipv4(struct sk_buff *skb,
				   struct nat_keepalive *ka)
{
	// ...
	rt = ip_route_output_key(net, &fl4);
- 	if (IS_ERR(rt))
+ 	if (IS_ERR(rt)) {
+ 		kfree_skb(skb); // Free skb if route lookup fails before handoff
		return PTR_ERR(rt);
+ 	}
static void nat_keepalive_send(struct nat_keepalive *ka)
{
	// ...
	switch (ka->family) {
	case AF_INET:
- 		err = nat_keepalive_send_ipv4(skb, ka);
+ 		nat_keepalive_send_ipv4(skb, ka); // Caller no longer tracks error for cleanup
		break;
#if IS_ENABLED(CONFIG_IPV6)
	case AF_INET6:
- 		err = nat_keepalive_send_ipv6(skb, ka, uh);
+ 		nat_keepalive_send_ipv6(skb, ka, uh);
		break;
#endif
+	default:
+		kfree_skb(skb); // Clean up only if address family is completely unsupported
+		break;
	}
- 	if (err)
- 		kfree_skb(skb); // REMOVED: No longer double-frees skb on downstream errors
}

By refactoring the code, the caller nat_keepalive_send() is restricted to allocating the buffer, dispatching it to the helpers, and freeing it only in the default case where the IP family is unsupported. If a routing or translation error occurs pre-handoff inside nat_keepalive_send_ipv4() or nat_keepalive_send_ipv6(), the helper frees the buffer locally. If the handoff is successful, the downstream networking layers handle memory deallocation entirely, ensuring no double-free condition can be triggered.

Exploitation Mechanics and Prerequisites

Exploitation of this vulnerability requires specific environmental and configuration prerequisites. The target system must be configured to use IPsec (XFRM) with NAT keepalives active. This occurs typically in environments using UDP-encapsulated ESP (IPsec NAT-Traversal) to bypass network address translation gateways.

To trigger the vulnerable code path, an attacker must induce a transmission error after the socket buffer has been handed off to the IP routing or output queues. This state can be forced by dynamically altering the host's routing tables, or by inducing rapid link-state transitions (interface flapping) during the keepalive interval. If the downstream stack encounters a routing lookup or transmission failure, it frees the packet and returns an error code, triggering the second free in the unpatched keepalive caller.

No public proof-of-concept (PoC) code or weaponized exploits currently exist for this vulnerability. In a local privilege escalation scenario, an attacker could attempt a heap spray attack targeting the kmalloc-X slab caches used for socket buffers. By placing structured payloads in the deallocated memory slot between the first and second free operations, the second free could release a control-structure buffer, facilitating a use-after-free (UAF) condition that enables kernel control-flow hijacking.

Security and System Impact

The security impact of a kernel-level double-free vulnerability is severe, as reflected in its CVSS score of 9.8. Because the flaw exists within the core memory allocator of the Linux kernel, any execution of the vulnerable path corrupts the allocator's internal tracking lists (such as the SLUB freelist pointers). This corruption typically leads to immediate kernel panic, causing a complete denial of service (DoS) for the affected host.

Beyond denial of service, memory corruption vulnerabilities of this class can be leveraged for privilege escalation. If an attacker can control the layout of the kernel heap during the execution of the double-free sequence, they may manipulate allocator metadata to return overlapping memory chunks. This enables arbitrary write capabilities in kernel space, allowing an unprivileged local user to escalate privileges to root or execute arbitrary kernel code.

The remote exploitation vector is limited by the requirement to trigger a send error on the keepalive path. While the CVSS vector identifies Network (AV:N) access, triggering the failure path from a remote position is highly complex and depends on the attacker's ability to manipulate the host's route resolution or network interfaces. Consequently, the practical risk is highest in scenarios where a local attacker or a compromised container has access to raw sockets or routing parameters.

Remediation and Defensive Strategies

The primary and recommended mitigation is the application of the official Linux kernel patches. The vulnerability has been resolved in the main development branch and backported to active stable branches. Systems running the 6.12, 6.13, 6.18, or 7.1 stable branches must be upgraded to version 6.12.101, 6.18.40, 7.1.5, or newer, respectively.

In environments where immediate kernel upgrades are not feasible, administrative workarounds can be applied to reduce exposure. Administrators can disable UDP-encapsulated IPsec (NAT-Traversal) if it is not strictly required by the environment's network architecture. Disabling NAT-T prevents the initialization of the XFRM keepalive workers, effectively closing the vulnerable code path.

Additionally, restricting access to network configuration capabilities helps mitigate local exploitation. Ensuring that containers and unprivileged local users do not possess the CAP_NET_ADMIN capability limits their ability to manipulate routing tables or interface states. This restriction prevents the dynamic network manipulation required to trigger the downstream transmission errors that lead to the double-free condition.

Fix Analysis (2)

Technical Appendix

CVSS Score
9.8/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
EPSS Probability
0.67%
Top 50% most exploited

Affected Systems

Linux Kernel versions 6.11 through 6.12.100Linux Kernel versions 6.13 through 6.18.39Linux Kernel versions 6.19 through 7.1.4

Affected Versions Detail

Product
Affected Versions
Fixed Version
Linux Kernel
Linux
[6.11.0, 6.12.101)6.12.101
Linux Kernel
Linux
[6.13.0, 6.18.40)6.18.40
Linux Kernel
Linux
[6.19.0, 7.1.5)7.1.5
AttributeDetail
CWE IDCWE-415 (Double Free)
Attack VectorNetwork (AV:N)
CVSS Score9.8 (Critical)
EPSS Score0.00671 (Percentile: 50.32%)
Exploit StatusNone (No public exploit available)
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-415
Double Free

Double-freeing a socket buffer (sk_buff) when handling NAT keepalive failures.

Vulnerability Timeline

Mainline patch proposed and committed in torvalds/linux (226f4a490d1a938fc838d8f8c46a4eca864c0d78)
2026-06-25
Backported fix committed to stable branch (d0a4dc7efa825bce60a8da8f7d43c864a159abde)
2026-07-27
CVE-2026-72137 officially published
2026-08-15
NVD updates and analyzes the vulnerability record
2026-08-17

References & Sources

  • [1]Official NVD Registry
  • [2]Official CVE Record
  • [3]Kernel Mainline Patch
  • [4]Wiz Vulnerability Database Listing

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•42 minutes ago•CVE-2026-77369
9.6

CVE-2026-77369: Broken Access Control in Daptin YJS Collaboration Endpoint

CVE-2026-77369 is a broken access control and Insecure Direct Object Reference (IDOR) vulnerability in Daptin, an open-source headless CMS. Affected versions from 0.11.4 through 0.12.29 expose a generic YJS real-time collaboration WebSocket endpoint (`GET /yjs/:documentName`) that verifies user authentication but fails to enforce row-level authorization when supplied with a canonical database room identifier (`{typename}.{referenceId}.{columnName}`). This allows any low-privileged authenticated user to read or modify restricted database columns of type `file.*` across all entities.

Alon Barad
Alon Barad
0 views•9 min read
•about 2 hours ago•CVE-2026-77376
6.1

CVE-2026-77376: Open Redirect in Bolt CMS LoginFormAuthenticator

CVE-2026-77376 is an open redirect vulnerability (CWE-601) in the core framework of Bolt CMS prior to version 6.1.4. The vulnerability resides within the LoginFormAuthenticator class, which processes post-authentication redirection for both successful and failed login attempts. Due to a lack of destination validation, the application accepts untrusted target paths from user sessions and directly reflects unvalidated HTTP Referer headers into HTTP Location response headers. Attackers can exploit this behavior to redirect users to arbitrary external domains after interacting with the Bolt login endpoint, facilitating credential harvesting and phishing attacks.

Amit Schendel
Amit Schendel
2 views•9 min read
•about 3 hours ago•CVE-2026-77377
5.2

CVE-2026-77377: Authenticated Server-Side Request Forgery in Bolt CMS Backend Asynchronous Endpoints

Bolt CMS (bolt/core) versions prior to 6.1.4 contain a Server-Side Request Forgery (SSRF) vulnerability in the authenticated URL-upload (/async/upload-url) and media embed (/async/embed) endpoints. Backend users with file upload or media embedding privileges can supply arbitrary URLs that the application fetches without destination IP validation. This allows authenticated attackers to force the server to initiate HTTP requests to loopback interfaces, RFC 1918 private networks, and cloud instance metadata services.

Amit Schendel
Amit Schendel
2 views•10 min read
•about 4 hours ago•CVE-2026-77379
5.3

CVE-2026-77379: Information Disclosure in Bolt CMS Public Relation API

Bolt CMS prior to version 6.1.4 contains an information disclosure vulnerability in its public Relation API endpoints. The Doctrine ORM query extension (ContentExtension) fails to filter out unpublished, draft, or viewless content when querying the Relation entity. Because the Relation resource is configured with public read access (PUBLIC_ACCESS) via API Platform REST and GraphQL endpoints, unauthenticated remote attackers can enumerate relationship graphs, entity identifiers, and metadata associated with private content.

Alon Barad
Alon Barad
2 views•9 min read
•about 5 hours ago•CVE-2026-77380
5.2

CVE-2026-77380: Server-Side Request Forgery via Unchecked Redirects in Bolt CMS

Bolt CMS prior to version 6.1.5 is vulnerable to Server-Side Request Forgery (SSRF) in its asynchronous URL upload and media embed endpoints. While the application validates the initial user-supplied URL against internal network ranges using UrlSafetyChecker, the underlying HTTP transport libraries automatically follow HTTP 3xx redirects and HTML meta refresh directives without re-validating the target destinations. An authenticated user with editor privileges can exploit this discrepancy via an open redirector or DNS rebinding to access internal network resources and cloud metadata services.

Alon Barad
Alon Barad
5 views•10 min read
•about 6 hours ago•CVE-2026-77378
6.5

CVE-2026-77378: Authenticated SQL Injection in Bolt CMS ListFormatHelper

CVE-2026-77378 (GHSA-r7h9-qx4h-77j5) is an authenticated SQL injection vulnerability affecting the bolt/core package of Bolt CMS in versions prior to 6.1.4. The flaw resides in the ListFormatHelper utility class, where content-type slugs are dynamically interpolated into raw SQL query strings via sprintf rather than bound as parameterized inputs. When the general/caching/list_format configuration directive is enabled, an authenticated user with upload privileges can exploit the /async/select-options endpoint to inject arbitrary SQL commands and query the underlying database.

Alon Barad
Alon Barad
6 views•11 min read