GHSA-MJ35-3QQM-Q387
Incomplete fix for CVE-2026-50010: QUIC clients still bypass hostname verification with a plain X509TrustManager
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Remediación | Parche 4.2.18.Final | io.netty:netty-codec-classes-quic · -1 d desde divulgación | |
| Divulgación | Publicada | GHSA-MJ35-3QQM-Q387 divulgada · CVSS 7.5 (GitHub) | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
Summary
The public advisory `GHSA-c653-97m9-rcg9` / `CVE-2026-50010` fixed a Netty 4.2 hostname-verification bypass in `io.netty:netty-handler`: a plain `X509TrustManager` was wrapped in a way that discarded the `SSLEngine`, so endpoint identification could not run.
The same trust-manager shape still exists in the QUIC certificate-verification path after the public fixed release. Since `4.2.11.Final`, `QuicSslContextBuilder.forClient()` defaults the QUIC client endpoint identification algorithm to `HTTPS`. However, `BoringSSLCertificateVerifyCallback` only calls the engine-aware `checkServerTrusted(chain, authType, engine)` overload when the selected trust manager is already an `X509ExtendedTrustManager`. If the application supplies a plain `X509TrustManager`, the QUIC callback calls only the two-argument `checkServerTrusted(chain, authType)` overload.
That plain-manager branch drops the `QuicheQuicSslEngine` carrying the peer host and `SSLParameters`, so the configured `HTTPS` endpoint identification is not enforced. A QUIC client can therefore accept a certificate chain that the plain trust manager accepts even when the certificate identity does not match the requested peer host.
Technical Details
`QuicSslContextBuilder` enables endpoint identification for client contexts by default:
if (!forServer) {
this.endpointIdentificationAlgorithm =
QuicheQuicSslContext.defaultEndpointVerificationAlgorithm;
}It documents the setting as the hostname-verification algorithm clients use while authenticating servers, and passes the setting into `QuicheQuicSslContext`.
`QuicheQuicSslContext.newEngine(alloc, peerHost, peerPort)` then creates a `QuicheQuicSslEngine` with the peer host and the endpoint-identification algorithm. `QuicheQuicSslEngine.getSSLParameters()` exposes the algorithm, and the engine session exposes the peer host.
The vulnerable branch is in `BoringSSLCertificateVerifyCallback.verify(...)`:
if (engine.getUseClientMode()) {
if (TRY_USING_EXTENDED_TRUST_MANAGER && manager instanceof X509ExtendedTrustManager) {
((X509ExtendedTrustManager) manager).checkServerTrusted(peerCerts, authAlgorithm, engine);
} else {
manager.checkServerTrusted(peerCerts, authAlgorithm);
}
}The `else` branch has no access to the peer host or endpoint-identification algorithm. It can validate only whatever the custom plain trust manager chooses to validate.
The public `netty-handler` fix removed the wrapper that caused this exact loss of engine-aware validation for the normal TLS path. The QUIC path has a sibling gap: `QuicheQuicSslContext.chooseTrustManager(...)` returns the first `X509TrustManager` directly, and the QUIC BoringSSL callback still falls back to the two-argument trust-manager method when the selected manager is plain.
Impact
A Netty QUIC client using `QuicSslContextBuilder.forClient()` with a custom plain `X509TrustManager` can accept a server certificate chain for the wrong hostname. This defeats the hostname-authentication part of TLS/QUIC server authentication for that configuration.
The practical threat model is the same as the public Netty hostname-verification advisory: an on-path attacker or misdirected endpoint can present a certificate chain accepted by the application's plain trust manager but not valid for the requested peer host. The QUIC client accepts it because endpoint identification does not run on the plain-manager branch.
Suggested Fix
Preferred fix: make the QUIC certificate-verification path preserve engine-aware endpoint identification for plain `X509TrustManager` instances.
Possible implementation directions:
- in `QuicheQuicSslContext.chooseTrustManager(...)`, wrap plain `X509TrustManager` instances with the same kind of engine-aware trust-manager support used by Netty's OpenSSL client path;
- or reject/avoid plain `X509TrustManager` in QUIC client contexts when endpoint identification is enabled, unless the caller explicitly disables it;
- add regression coverage where a QUIC client with a plain trust manager, `endpointIdentificationAlgorithm("HTTPS")`, and a mismatched peer host must fail certificate verification;
- keep the insecure trust-manager factory behavior explicit, so intentional trust-all configurations remain distinguishable from ordinary plain custom managers.
Affected Package/Versions
`io.netty:netty-codec-classes-quic`
Confirmed affected:
- current `4.2` branch at `7bae566a93e69409697fe57fa807910ba5c9720e`
- `4.2.15.Final` at `a41f7b289ce1d697c50846f3ade3983e22b2ed40`
Suggested affected range:
- `>= 4.2.11.Final`
`4.1.x` was checked for the fixed release line used by the public advisory, and the QUIC classes/native modules are not present there. This report is therefore limited to the 4.2 QUIC artifacts.
References
- Netty public advisory `GHSA-c653-97m9-rcg9` / `CVE-2026-50010`: https://github.com/netty/netty/security/advisories/GHSA-c653-97m9-rcg9
- Public fix commit `09e72c4fd8`: https://github.com/netty/netty/commit/09e72c4fd8007277121ed48db63a124b112b96fe
- QUIC endpoint-identification support commit `994e887ed9`: https://github.com/netty/netty/commit/994e887ed9
- Netty `QuicSslContextBuilder` API docs: https://netty.io/4.2/api/io/netty/handler/codec/quic/QuicSslContextBuilder.html
- Java `SSLParameters.setEndpointIdentificationAlgorithm(...)` docs: https://docs.oracle.com/javase/8/docs/api/javax/net/ssl/SSLParameters.html
- Netty security policy: https://github.com/netty/netty/security/policy
CWE and CVSS
Primary CWE: `CWE-297` (Improper Validation of Certificate with Host Mismatch).
Secondary CWE: `CWE-295` (Improper Certificate Validation).
Suggested CVSS v3.1:
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:NSuggested severity: High, score 7.5.
This matches the public Netty hostname-verification advisory's severity shape. The impact is confidentiality loss through hostname-authentication bypass for a network client configuration. The PoV is fully local and does not target any third-party system.
Duplicate Boundary
This is an incomplete-fix / sibling-module variant of `GHSA-c653-97m9-rcg9` / `CVE-2026-50010`, not a duplicate of the already published `io.netty:netty-handler` advisory.
The published advisory is for `io.netty:netty-handler`, with affected ranges `<= 4.1.134.Final` and `<= 4.2.14.Final`, and patched versions `4.1.135.Final` and `4.2.15.Final`.
This report is for `io.netty:netty-codec-classes-quic`, and the PoV reproduces on `4.2.15.Final`, the public fixed release. Local and live advisory checks did not find an existing private or public advisory for the QUIC callback path.
Local PoV
PoV file:
`QuicPlainTrustManagerHostnameVerificationPovTest.java`
Run from a Netty checkout:
./mvnw -q -pl codec-native-quic -am \
-Dtest=QuicPlainTrustManagerHostnameVerificationPovTest \
-Dsurefire.failIfNoSpecifiedTests=false testThe PoV creates a QUIC client context with:
- `QuicSslContextBuilder.forClient()`
- explicit `endpointIdentificationAlgorithm("HTTPS")`
- peer host `wrong.example`
- a plain `X509TrustManager` that accepts the supplied certificate chain
It then invokes `BoringSSLCertificateVerifyCallback.verify(...)` locally with Netty's test certificate. The expected secure behavior is a non-OK verification result because `HTTPS` endpoint identification is configured for a peer host that does not match the certificate.
Observed on current `4.2` head:
Tests run: 2, Failures: 1, Errors: 0, Skipped: 0
HTTPS endpoint identification should reject a certificate for the wrong peer host
expected: not equal but was: <0>`0` is `BoringSSL.X509_V_OK`.
The same PoV includes a control test using an `X509ExtendedTrustManager`. That control receives the `SSLEngine`, rejects the peer, and passes. This isolates the bypass to the plain-manager branch rather than to the test certificate or the callback plumbing.
Observed on `4.2.15.Final`:
Tests run: 2, Failures: 1, Errors: 0, Skipped: 0
HTTPS endpoint identification should reject a certificate for the wrong peer host
expected: not equal but was: <0>Why This Is Not Intended Behavior
Netty's current QUIC API documentation describes `endpointIdentificationAlgorithm(...)` as the hostname-verification algorithm clients use when authenticating servers. The method explicitly supports `"HTTPS"` and says `null` disables hostname verification.
The Java `SSLParameters.setEndpointIdentificationAlgorithm(...)` contract says that a non-null/non-empty algorithm requires endpoint identification during the TLS handshake to prevent man-in-the-middle attacks.
The public `GHSA-c653-97m9-rcg9` / `CVE-2026-50010` advisory also establishes Netty's security intent for this exact class: a client configured with a plain trust manager must not silently lose hostname verification when Netty 4.2 has `endpointIdentificationAlgorithm="HTTPS"` enabled.
The QUIC path violates that intent in the fixed release line: the engine and its peer host are available, but the callback discards them for plain `X509TrustManager` instances.
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
mavenio.netty:netty-codec-classes-quic |
Corregida | 4.2.18.Final | -1 d | 4.2.20.Final no afectada |
4.2.18.FinalArsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/netty/netty/security/advisories/GHSA-mj35-3qqm-q387Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
