Tia N.List

KEV catalog · CISA Known Exploited Vulnerabilities

CVE-2025-39682 9.8
Linux · Kernel · Added 2026-09-18 · Published 2025-09-05
3-Day Required PoC Available KEV Automatable Active Exploitation

Details

VulnerabilityLinux Kernel Improper Check for Unusual or Exceptional Conditions Vulnerability
VendorLinux
ProductKernel
Date added2026-09-18
Due date2026-09-21
Required actionApply mitigations in accordance with vendor instructions, ensuring compliance with CISA’s BOD 26-04 Prioritizing Security Updates Based on Risk (see URL in Notes) guidance and CISA’s “Forensics Triage Requirements” (see URL in Notes). Follow applicable BOD 26-04 guidance for cloud services or discontinue use of the product if mitigations are unavailable. Stakeholders are responsible for evaluating each asset's internet exposure and ensuring adherence to BOD 26-04 patching guidelines.
CWECWE-754
CVSS vectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Descriptions

KEV: Linux Kernel contains an improper check for unusual or exceptional conditions vulnerability in the TLS receive path which allows a zero-length record retrieved from the rx_list to bypass the intended recvmsg() record-type handling, potentially causing subsequent TLS records to be processed using incorrect zero-copy and queuing assumptions. The impacted product(s) could be end-of-life (EoL) and/or end-of-service (EoS). Users are advised to discontinue use and/or transition to a supported version.

NVD: In the Linux kernel, the following vulnerability has been resolved: tls: fix handling of zero-length records on the rx_list Each recvmsg() call must process either - only contiguous DATA records (any number of them) - one non-DATA record If the next record has different type than what has already been processed we break out of the main processing loop. If the record has already been decrypted (which may be the case for TLS 1.3 where we don't know type until decryption) we queue the pending record to the rx_list. Next recvmsg() will pick it up from there. Queuing the skb to rx_list after zero-copy decrypt is not possible, since in that case we decrypted directly to the user space buffer, and we don't have an skb to queue (darg.skb points to the ciphertext skb for access to metadata like length). Only data records are allowed zero-copy, and we break the processing loop after each non-data record. So we should never zero-copy and then find out that the record type has changed. The corner case we missed is when the initial record comes from rx_list, and it's zero length.

Compliance SSVC + BOD 26-04

Automatableyes
Technical impacttotal
Exploitation statusactive
3-day qualifyingYes
Public timeline3 days + forensic
Non-public timeline3 days + forensic
Forensic (public)Required
Forensic (non-public)Required

Research metadata

Last researched2026-09-18 20:49 UTC
Wall time0.5s
Searches12
Component defaultyes

Hunting hypothesis agent

Hunt kernel logs for `skbuff_head_cache` UAF/slab splats after a socket enables kTLS RX via `setsockopt(TCP_ULP,"tls")` and its peer sends a zero-length TLS record then a non-DATA record — dmesg is the only stock source.

Research details

Componenttls_sw_recvmsg() in net/tls/tls_sw.c — software TLS zero-copy receive path handling zero-length records on the rx_list
PreconditionsNetwork reachability to a TCP endpoint with TLS (kTLS/sockmap) enabled via setsockopt TCP_ULP 'tls'; target must run a vulnerable kernel version (6.0 through 6.17 prior to backported fixes); the attacker needs to establish a TLS session (AES-GCM-256, TLS 1.2) and send a zero-length TLS record followed by a non-DATA record then a DATA record to trigger the zero-copy decryption path; no authentication is required for the TLS handshake from the attacker's side agent
DeliveryNetwork/local — a peer sends a zero-length TLS record then a non-DATA record to a socket using kTLS RX offload (setsockopt TCP_ULP 'tls' + SOL_TLS TLS_RX); the public kernelCTF exploit drives a loopback socket pair on the same host for local privesc
Public PoCyes
Exploit notesCVSS attack complexity: LOW | CRITICAL severity (CVSS >= 9.0) | Public PoC achieves 79/100 success rate on kernelCTF mitigation-v4-6.6 instance | Exploit is a client-server TLS tool (C++): server sends crafted TLS records including zero-length record to trigger zero-copy path, achieving kernel heap corruption via slab metadata manipulation. The exploit chains a race condition to bypass double-free detection and achieve kernel address space manipulation. The public exploit runs client and server as a loopback socket pair on the same host (kernelCTF local privesc); remote triggering requires a target service with kTLS RX offload enabled.
SummaryA use-after-free vulnerability in the Linux kernel's software TLS receive path (net/tls/tls_sw.c) allows a zero-length record retrieved from the rx_list to bypass recvmsg() record-type handling, causing subsequent TLS records to be processed with incorrect zero-copy assumptions and leading to kernel heap corruption. Reported by Muhammad Alifa Ramdhan and Billy Jheng Bing-Jhong of StarLabs. A public exploit exists (khoatran107/cve-2025-39682) that was used in Google's kernelCTF competitions with 79% success rate. Affected kernel versions 6.0 through 6.17; also affects Siemens SIMATIC CN 4100 before V5.0.

Tia coverage

First reported2026-09-04
First exploit report2026-09-18
Exploit report → KEV0 days before the listing

When Tia's reporting first covered this CVE and whether a report claimed exploitation before the KEV listing. Lead-time deltas are measured from the exploitation report only — plain coverage is not exploitation intel. See the story links under Mentioned in for coverage detail.

Mentioned in

cisa-alerts-of-active-exploitation-of-three-linux-kernel-flaws-hgoogle-fixes-actively-exploited-android-zero-day-on-pixel-device

Record schema v1.0. Enrichment is research-grade, not a substitute for analyst review.

Source on GitHub