Skip to main content

Linux Kernel CVE-2026-74611

| EUVDEUVD-2026-64548 CRITICAL
2026-08-22 Linux GHSA-g4xp-j3j4-vmrq
9.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Establish TLS 1.3 session to kTLS receiver with TLS_RX_EXPECT_NO_PAD
  2. Delivery
    Send crafted non-application control record
  3. Exploit
    Trigger optimistic zero-copy map then skb retry
  4. Execution
    Iterator left advanced past mapped bytes
  5. Persist
    Decrypted bytes written beyond returned length
  6. Impact
    Corrupt/expose later iovec data in receiver

Vulnerability Assessment

Exploitation Conditions

Exploitation requires the receiving socket to have kernel-TLS (kTLS) receive offload active on a TLS 1.3 connection AND to have explicitly enabled the TLS_RX_EXPECT_NO_PAD socket option - this is the exact configuration named in the description and is not the default. The attacker must be the TLS peer and must get the receiver to process a record that is not unpadded application data (e.g., a TLS 1.3 control record) so the code takes the non-zero-copy retry path. Limiting factors: the bug does not fire on default kTLS or user-space TLS stacks, requires the specific opt-in no-pad mode, and the impact is confined to the receiving process's own iovec buffers rather than kernel memory or other processes; the receiver must also be using scatter/multi-segment recvmsg buffers for the misplacement to matter.

Impact

The published CVSS 9.8 (AV:N/AC:L/PR:N/UI:N/C:H/I:H/A:H) substantially overstates real-world risk and appears to be a default maximal kernel scoring. Corroborating signals contradict it: EPSS is only 0.21% (11th percentile), the CVE is not in CISA KEV, and no public exploit is identified - only an in-tree selftest reproducer was added. Critically, the CVSS vector implies unauthenticated, default-configuration network exploitation, but the description states the bug is only reachable 'after the receiver enables TLS_RX_EXPECT_NO_PAD,' a non-default, opt-in kTLS setting - verify with vendor, as AC:L/PR:N does not reflect this precondition. The actual impact is corruption/misplacement of decrypted data inside the receiving application's own user-space buffers (tagged Information Disclosure), not kernel-level RCE or privilege escalation, so C:H/I:H/A:H is not supported by the mechanism described. Net assessment: a genuine data-integrity/disclosure bug worth patching on hosts that use kTLS with TLS_RX_EXPECT_NO_PAD, but far lower operational priority than the 9.8 suggests for the general fleet.

Exploit ScenarioDerived

A receiving application enables kernel-TLS with TLS_RX_EXPECT_NO_PAD on a TLS 1.3 connection and calls recvmsg() with a multi-segment iovec. A malicious or malfunctioning TLS peer sends a crafted control-type record that triggers the optimistic zero-copy decrypt followed by the kernel-skb retry; the leftover-advanced iterator causes decrypted bytes to be written past the returned length into later iovec segments, corrupting or leaking data the application did not expect to receive. No public exploit is identified, though an in-tree kernel selftest reproduces the misbehavior.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Aug 25, 2026

Improper handling of the receive-side message iterator in the Linux kernel's kernel-TLS (kTLS) subsystem lets a remote TLS peer cause recvmsg() to write decrypted bytes into the wrong offsets of a receiver's user-space iovec buffers. When the optimistic TLS 1.3 zero-copy path maps user pages and then falls back to a kernel skb, the iterator is left advanced, so bytes are written a second time past the length recvmsg() reports. Exploitation requires the receiver to have enabled the TLS_RX_EXPECT_NO_PAD socket option; there is no public exploit identified at time of analysis and EPSS is low (0.21%).

RemediationAI

Vendor-released patch: update to Linux stable 6.18.45, 7.1.9, or 7.2 (or later), which apply the fix that reverts msg_iter before the non-zero-copy retry (mainline commit 3c837266a734). Apply the kernel updates your distribution ships that incorporate these stable commits (see the git.kernel.org references above). If you cannot patch immediately, a concrete compensating control is to disable the trigger by not enabling the TLS_RX_EXPECT_NO_PAD socket option (setsockopt on the kTLS RX socket) in applications you control, or disable kernel-TLS receive offload entirely and fall back to user-space TLS termination - the trade-off is losing the CPU/zero-copy performance benefit of kTLS and, for TLS_RX_EXPECT_NO_PAD, its no-padding optimization. Restrict which peers can establish kTLS-offloaded TLS 1.3 sessions with affected receivers where feasible. These are workarounds only; upgrading the kernel is the durable fix.

Affected VersionsENISA

Linux patch: 0
Linux patch: 7.1.9
Linux ce61327ce989b63c0bd1cc7afee00e218ee696ac <3c837266a734e2a22b24d2d567404a501d405835
Linux patch: 7.2
Linux 6.0
Linux ce61327ce989b63c0bd1cc7afee00e218ee696ac <1c8629651cb54f7b51db8fc0b1a9944e4a4b0f5e
Linux ce61327ce989b63c0bd1cc7afee00e218ee696ac <68787940274ec89f41dc91b1a68ee1a16a90735f
Linux patch: 6.18.45

Affected Packages

euvd linux no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The affected component is kernel-TLS (kTLS), the in-kernel implementation of TLS record processing on the socket receive path (net/tls). For TLS 1.3, kTLS attempts a zero-copy 'optimistic' decrypt in tls_decrypt_sg(), which maps the caller's user pages directly and advances msg->msg_iter as it does so. If the decrypted record is not unpadded application data (for example a TLS 1.3 control/handshake-type record surfaced because TLS_RX_EXPECT_NO_PAD was set), tls_decrypt_sw() retries the decrypt into a kernel skb but does not rewind the already-advanced iterator. The later copy from the skb therefore lands at a position further into the caller iovecs than intended, while recvmsg() returns only the post-retry byte count. The root-cause class is an iterator/offset state-management error leading to an out-of-bounds write within the caller's own iovec memory (functionally a CWE-787-style buffer misplacement / CWE-665 improper state initialization); NVD lists CWE as N/A. The fix reverts msg_iter by the number of bytes consumed by the optimistic mapping before retrying without zero-copy.

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (Linux) PRIMARY 9.8 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 7.0 HIGH

Remote TLS peer triggers it (AV:N/PR:N) but only under the non-default TLS_RX_EXPECT_NO_PAD config (AC:H); impact is misplaced writes into the app's own iovec buffers - integrity high, limited disclosure and disruption.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:L
4.0 AV:N/AC:H/AT:N/PR:N/UI:N/VC:L/VI:H/VA:L/SC:N/SI:N/SA:N
SUSE 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Red Hat 7.0 HIGH

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

4
CVSS changed
Aug 25, 2026 - 06:22 NVD
9.8 (CRITICAL)
Patch available
Aug 22, 2026 - 16:32 EUVD
CVE Published
Aug 22, 2026 - 15:31 cve.org
CRITICAL 9.8
CVE Published
Aug 22, 2026 - 15:31 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

In the Linux kernel, the following vulnerability has been resolved:

tls: rx: restore msg_iter before TLS 1.3 optimistic retry

tls_decrypt_sg() advances msg->msg_iter when it maps user pages for the optimistic TLS 1.3 zero-copy path. If the decrypted record turns out not to be unpadded application data, tls_decrypt_sw() retries into a kernel skb, but leaves the iterator advanced.

The subsequent copy from the skb then writes decrypted bytes again at a later point in the caller iovecs while recvmsg() reports only the post-retry length. A TLS peer can trigger this after the receiver enables TLS_RX_EXPECT_NO_PAD.

Revert the iterator by the number of bytes consumed by the optimistic mapping before retrying without zero-copy.

Add a selftest which sends a TLS 1.3 control record with TLS_RX_EXPECT_NO_PAD enabled and verifies that recvmsg() does not overwrite later iovecs beyond the returned length.

Executive ViewAI

Why It Matters

A critical buffer overflow in Linux kernel TLS receive path (CVE-2026-74611) allows remote attackers to corrupt memory during encrypted traffic handling; however, exploitation requires the TLS_RX_EXPECT_NO_PAD socket option to be enabled and no public exploit exists, limiting practical organizational risk to systems with this specific configuration.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Medium
Linux is ubiquitous, but kTLS with TLS_RX_EXPECT_NO_PAD is a niche opt-in feature
Data Quality
6 sources
Confidence: High

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

49
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +49
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Vendor StatusVendor

SUSE

Severity: Important
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 16.0 Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy