rustls is becoming the default TLS library everywhere that cares about memory safety — Cloudflare’s rustls fork, AWS’s AWS-LC-RS alternatives, and a growing stack of Rust-native HTTP servers. On November 8, the project disclosed five CVEs in a single batch. Five different bugs. Same root cause: the TLS 1.3 state machine is harder to reason about than most people admit.
Let’s walk through each one.
CVE-2026-123611 — Key Exchange Downgrade (CVSS 6.3)
This is the one that matters for harvest-now-decrypt-later attackers. rustls records the server-selected key-exchange group per server name when it processes the ServerHello — before the server is authenticated. An on-path attacker can answer one connection attempt for a target name with a ServerHello that selects X25519 and close the connection. Later ClientHellos for that name carry one X25519 share while supported_groups still lists X25519MLKEM768 first.
If the genuine server accepts the classical X25519 share instead of sending a HelloRetryRequest for its preferred hybrid group, the handshake completes with classical key exchange only. No certificate, no completed handshake, no error. Just one parsed ClientHello, one crafted ServerHello, one closed connection.
The fix (0.23.46) came October 14 — about a month before disclosure. The real question: how many clients were caching that poisoned state between those dates?
CVE-2026-123613 — Record-Boundary Alignment (CVSS 5.5)
TLS 1.3’s Deframer::aligned doesn’t enforce RFC 8446 record-boundary alignment. A peer or on-path attacker can pack a plaintext EncryptedExtensions with the ServerHello in the same record. rustls accepts it unencrypted — so if your server sends application data before the handshake completes, that data reaches the client in the clear.
This matters most for servers that send early data (0-RTT) or HTTP/2 SETTINGS before handshake completion. The data isn’t lost — it’s just not encrypted when it should be.
CVE-2026-123612 — ECH Info Leak (CVSS 4.3)
When Encrypted Client Hello is rejected, 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. Two servers, one connection — the outer server sees what was meant for the inner one.
This requires ECH rejection (which happens when the inner server doesn’t support ECH or the token is expired), so it’s not a common path. But it’s a real leak in a protocol designed to prevent exactly this kind of server visibility.
CVE-2026-123610 — Brotli 1GiB DoS (CVSS 4.3)
rustls’s optional Brotli certificate decompression accepts an input-selected large history window. A malicious peer can send a certificate with a five-byte Brotli header requesting up to 1 GiB of decompression history before authentication. Clients or client-authenticating servers that can’t satisfy the allocation abort.
Simple. Effective. No authentication needed. This is the kind of DoS that lives in the “low severity but easy to exploit” category.
CVE-2026-123609 — Debug Format Key Leak (CVSS 4.5)
Custom ClientSessionStore implementations that log Tls12ClientSessionValue or Tls13ClientSessionValue can leak TLS 1.2 master secrets or TLS 1.3 resumption PSKs to log readers. The Debug formatting of client session values exposes secret key material.
This is a classic “it depends on your observability” bug. If you log session values (which many do for debugging), an attacker with read access to those logs gets your session keys.
What This Tells Us
Five CVEs from one library, all in the same disclosure cycle, all pointing at the same theme: TLS 1.3’s state machine has more corners than the TLS 1.2 spec. The record-boundary alignment bug and the key exchange prediction state both live in that thin slice of code between parsing a ServerHello and authenticating the server certificate. The ECH leak lives in the transition between encrypted and unencrypted traffic. The Brotli DoS lives in pre-authentication decompression. The Debug leak lives in observability.
rustls is one of the most carefully reviewed TLS libraries in existence. Five bugs in one disclosure isn’t a sign of a sloppy codebase — it’s a sign of a protocol complex enough that even careful review misses corners. The real takeaway: TLS 1.3 is not “done” as a protocol. It still has active attack surfaces that mature implementations are discovering.
For operators: upgrade to 0.23.46+ or 0.24.0-dev.2+ if you’re using rustls. Check your session stores for Debug-format key leaks. And if you’re using ECH, verify your inner/outer server pairing handles rejection gracefully.