Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain on-path or malicious-peer position
-
DeliveryCraft TLS 1.3 record with ServerHello + plaintext EncryptedExtensions
-
Exploitrustls installs handshake keys then reads plaintext message
-
ExecutionMessage accepted across key-change boundary
-
ImpactPlaintext handshake data accepted without encryption
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
|
| Exploitation Conditions | Exploitation requires that the attacker be the connecting TLS 1.3 peer (e.g. a malicious server) or sit on-path, and that the target run rustls 0.23.13-0.23.44 processing a TLS 1.3 handshake; the attacker packs a key-changing message (ServerHello) and a following handshake message (EncryptedExtensions) into a single record so the trailing message crosses the key-change boundary in plaintext. No authentication, user interaction, or special configuration is needed (PR:N/UI:N), and default TLS 1.3 handshaking is affected. The decisive LIMITING factor is that the handshake transcript is still cryptographically authenticated, so the attacker cannot alter or complete a handshake, forge a peer, or downgrade the connection - impact is confined to rustls failing to reject plaintext handshake messages that should have been encrypted, which is why confidentiality impact is only Low and integrity/availability are None. |
| Impact | This is a genuine but moderate-severity TLS protocol-conformance flaw, not a top-tier emergency. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) with only VC:L and no integrity or availability impact correctly reflects a low-consequence issue: rustls (0.23.13-0.23.44) fails to enforce RFC 8446 §5.1 record-boundary alignment in Deframer::aligned, so a peer or on-path attacker can pack a plaintext EncryptedExtensions into the same record as the ServerHello and have rustls accept it unencrypted. Crucially, the vendor advisory states the handshake transcript remains authenticated, so a network-position attacker cannot alter or complete a handshake or downgrade security - the practical effect is limited to accepting handshake messages that should have been encrypted, consistent with the VC:L / VI:N / VA:N rating. No EPSS score, KEV listing, or confirmed working exploit code is present in the input; exploitation status is therefore 'no public exploit identified at time of analysis,' though a detailed root-cause report and a directly analogous Go bug (CVE-2025-61730) exist. The vuln.today Decision label is 'this_month' (not act_now/emergency), aligning with the moderate CVSS and absence of active-exploitation signals. Bottom line: a real correctness bug worth patching on a normal cadence, not a drop-everything priority. |
| Exploit ScenarioDerived | A malicious or on-path TLS server sends a TLS 1.3 server flight in which a plaintext EncryptedExtensions message is packed into the same record immediately following the ServerHello. A vulnerable rustls peer installs the handshake keys after the ServerHello but still pulls the trailing plaintext EncryptedExtensions from the buffer and accepts it, rather than terminating with an 'unexpected_message' alert as RFC 8446 requires. No public working exploit code is identified, but a detailed report describing the exact protocol flow exists and the issue was confirmed by a conformance test suite. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 08, 2026
rustls 0.23.13 through 0.23.44 accepts TLS 1.3 handshake messages delivered at the wrong encryption level when a key-changing message and a following handshake message are packed into the same record. The practical effect is that a malicious TLS peer (for example a hostile server) or an on-path attacker can deliver a plaintext EncryptedExtensions alongside the ServerHello and have rustls process it instead of terminating the connection with an unexpected_message alert, which is a limited information-disclosure style failure to enforce RFC 8446 record-boundary rules. The handshake transcript remains cryptographically authenticated, so the attacker cannot alter or complete a handshake, impersonate a peer, or downgrade the connection; no public exploit code was identified at time of analysis and the CVE is not in CISA KEV. Vendor-released patch: 0.23.45, and vuln.today triage places remediation in the this_month window rather than an emergency response.
RemediationAI
Upgrade rustls to 0.23.45 or later, which is the fixed version listed in the package data (vulnerable >= 0.23.13, < 0.23.45); downstream applications should bump their rustls dependency and rebuild, and crates that pin or vendor rustls transitively need the same bump. The fixes are the rustls commit https://github.com/rustls/rustls/commit/98456aea708a7e3c6151e00ca2d4428e7a58257a with the reference implementation from Go's fix at https://github.com/golang/go/commit/5046bdf8a612b35a2c1a9e168054c1d5c65e7dd7, and the advisory https://github.com/rustls/rustls/security/advisories/GHSA-2mjx-qc3c-rqvc should be consulted for confirmation. The available sources do not document a configuration-level workaround, so no feature toggle or port restriction is presented here as an alternative to updating; priority can follow the this_month decision label, since the retained handshake authentication limits the impact to acceptance of plaintext handshake messages that should have been encrypted.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in cargo
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 rustls' record deframer, specifically Deframer::aligned, which decides whether the buffered handshake bytes line up with record boundaries. Rustls' check considers the buffer aligned whenever all remaining messages are complete, so after processing a ServerHello and installing handshake keys it will still pull a complete but plaintext EncryptedExtensions out of the same record rather than rejecting it. RFC 8446 section 5.1 requires that handshake messages MUST NOT span key changes and that all messages immediately preceding a key change align with a record boundary, with a violation terminated by an unexpected_message alert; ClientHello, EndOfEarlyData, ServerHello, Finished and KeyUpdate are the messages permitted immediately before a key change and must be sent aligned. This is classified as CWE-20 (improper input validation) because the library fails to validate a structural property of untrusted protocol input rather than a cryptographic primitive. The reporter notes the issue closely mirrors Go's CVE-2025-61730, whose fix commit is cited alongside the rustls fix; other implementations tested (Botan, OpenSSL, BoringSSL, Go, wolfSSL) reject this protocol flow. Because the handshake transcript is still authenticated, the flaw does not enable handshake modification, impersonation, or downgrade, which is why the assessed vector is only AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N.
Know when Rustls gets its next vulnerability
- 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
Network-reachable and trivially triggered by a malicious peer (AV:N/AC:L/PR:N/UI:N); impact limited to acceptance of plaintext handshake messages (C:L), with no integrity or availability effect since the transcript stays authenticated.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Rustls from 0.23.13 before 0.23.45 accepts TLS 1.3 handshake messages at the wrong encryption level when they follow a key-changing message in the same record, because Deframer::aligned does not enforce RFC 8446 record-boundary alignment. A peer or on-path attacker can pack a plaintext EncryptedExtensions with the ServerHello, which rustls accepts unencrypted.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Related Vulnerabilities in Rustls Information Disclosure and Protocol Flaws
View all 5A flaw was found in Rustls 0.23.13 and related APIs. Rated high severity (CVSS 7.5), this vulnerability is remotely expl
rustls-mio/examples/tlsserver.rs in the rustls crate before 0.16.0 for Rust allows attackers to cause a denial of servic
EUVD-2026-119372
GHSA-rp7q-jxfg-4g6g
NVD
CVE.org
EPSS
Exploit-DB