Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessClient configured with EchMode::Enable
-
DeliveryApplication buffers early plaintext via writer()
-
ExploitServer rejects stale ECH config
-
Executionstart_traffic() queues data before ech_required alert
-
Persistwrite_tls() sends encrypted data to outer server
-
Impactpublic_name server decrypts inner-intended plaintext
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Incorrect behavior order
|
| Exploitation Conditions | Disclosure occurs ONLY when all of these hold on the client: (1) the client uses EchMode::Enable - GREASE ECH is explicitly NOT affected; (2) the application writes application data before the TLS handshake completes; and (3) it connects to a server that rejects the client's ECH config (e.g. a stale config, the same case where the server returns retry configs). Limiting factors sharply narrow real risk: the recipient of the leaked plaintext is the public_name (outer) server, which is properly authenticated - not an unauthenticated or arbitrary attacker - so an adversary must actually operate or legitimately present the certificate for that public_name server. The bug is only reachable at or after 0.23.44 because the pre-0.23.44 certificate check against the inner name failed verification first and sent no data. Affected versions: 0.23.44 and 0.23.45 only. |
| Impact | This is a genuinely low-to-moderate severity information-disclosure issue, not an emergency, and the signals are internally consistent. The provided CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:H/UI:N/VC:L/VI:N/VA:N) yields 4.6 (Medium) and correctly reflects that the data leaks only to an already-authenticated party (PR:H) with limited confidentiality impact (VC:L) and no integrity or availability effect. There is no CISA KEV listing and no EPSS score supplied, so there is no evidence of active or widespread exploitation; exploitation status is 'no public exploit identified at time of analysis,' though two vendor/advisory references (rustls GHSA and VulnCheck) document the flaw in detail. The vuln.today priority is 'this_month,' not 'act_now'/'emergency,' which matches the picture of a real but non-urgent correctness bug. Crucially, per the GHSA advisory the recipient of the leaked plaintext is the properly authenticated public_name (outer) server - 'this is not an attack by an unauthenticated party' - so real-world risk depends on a specific, uncommon client configuration rather than opportunistic remote attack. The NVD CWE (CWE-696, incorrect behavior order) and the GHSA CWE (CWE-200, information exposure) differ but are complementary rather than conflicting: the ordering bug (sending data before the ech_required alert) is the mechanism, information disclosure is the consequence. |
| Exploit ScenarioDerived | A client application built on rustls uses EchMode::Enable and writes application data (via ClientConnection::writer()) before the handshake completes; it connects to a server whose ECH config it holds is stale, so the server rejects ECH. At the end of the handshake start_traffic() encrypts and queues that buffered plaintext before the ech_required alert is queued, so when the application calls write_tls() the inner-server-intended data is delivered to and decrypted by the authenticated public_name outer server before it receives the fatal alert. No working exploit code is published; the two references are advisories, not verified exploits. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Nov 08, 2026
Information disclosure in rustls 0.23.44 and 0.23.45 causes application data that a client buffers before the TLS handshake completes to be encrypted and transmitted to the client-facing (outer) server when that server rejects Encrypted Client Hello, instead of being discarded before the fatal ech_required alert is sent. Only clients that use EchMode::Enable (GREASE ECH is explicitly not affected), write application data before the handshake finishes, and connect to a server that rejects their ECH config are exposed, and the recipient is the properly authenticated public_name server rather than an arbitrary or unauthenticated party, which sharply limits real-world risk. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor has released fixes in 0.23.46 and 0.24.0-dev.2.
RemediationAI
Vendor-released patch: upgrade to rustls 0.23.46 (or 0.24.0-dev.2 on the 0.24 development line), which fixes the ordering so the ech_required alert is queued before any buffered application data; the fixes are in https://github.com/rustls/rustls/pull/3300 and https://github.com/rustls/rustls/pull/3354 and are described in https://github.com/rustls/rustls/security/advisories/GHSA-vp88-798v-h67f. Where an upgrade cannot be applied immediately, exposure can be removed by changing application behaviour to match the documented preconditions: because the flaw only triggers when plaintext is queued via ClientConnection::writer() before the handshake completes, defer all application writes until the handshake has finished, and because only EchMode::Enable is affected, clients that do not require non-GREASE ECH can avoid enabling it (GREASE ECH is unaffected), at the cost of losing ECH privacy protection on those connections. Rotating stale ECH configs reduces how often servers reject the client's ECH and return retry configs, but does not by itself fix the data-before-alert ordering. Per the advisory, the leaked plaintext reaches only the authenticated public_name server, so a compromise requires an adversary that legitimately operates or presents the certificate for that outer server.
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
rustls is a memory-safe TLS implementation written in Rust and used as a library across client and server software. Encrypted Client Hello (ECH) splits a connection into an outer ClientHello carrying a public_name and an inner ClientHello naming the real destination; when a server rejects the client's ECH config it returns retry configs and the client must abort with an ech_required alert. The flaw is an ordering problem (CWE-696, Incorrect Behavior Order; the upstream advisory classifies it as CWE-200 information exposure): at the end of the handshake, start_traffic() encrypts and queues plaintext previously buffered through ClientConnection::writer() before checking for EchStatus::Rejected and queueing the ech_required alert, so the subsequent required write_tls() call flushes both the application data and the alert, and the server decrypts the data before seeing the alert. This violates RFC 9849 Section 6.1.6, which requires the client to abort with ech_required before sending any application data, and Section 6.1.7, which requires the connection not be reported as successful (rustls does correctly surface Error::PeerIncompatible(ServerRejectedEncryptedClientHello); only the data-before-alert ordering is wrong). The ordering bug predates 0.23.44, but before that release the client validated the server certificate against the inner server name, so a correctly configured server failed certificate verification first and no data was sent; 0.23.44 fixed that check, making the ordinary rejection path reachable.
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:L/AC:L/AT:N/PR:H/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
Plaintext leaks only to the authenticated public_name server (PR:H), requires a specific ECH-enabled client writing early data plus server ECH rejection (AC:H), limited confidentiality only, no integrity/availability impact.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
1DescriptionCVE.org
rustls 0.23.44 and 0.23.45 contain an information disclosure vulnerability that sends application data buffered before the handshake completes to the client-facing server when Encrypted Client Hello is rejected. Because start_traffic() queues plaintext from ClientConnection::writer() before sending the ech_required alert, the authenticated public_name server receives data intended for the inner server.
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-119371
GHSA-jrx3-hh25-gg3m
NVD
CVE.org
EPSS
Exploit-DB