llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Maven · io.netty:netty-codec-classes-quic

GHSA-MJ35-3QQM-Q387

Incomplete fix for CVE-2026-50010: QUIC clients still bypass hostname verification with a plain X509TrustManager

Parche disponible
Descargar PNG JSON
CVSS 3.1
7.5
Alta
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -1 d de la divulgación
Exposición72 dDesde la divulgación, 9 sept 2026, 7:51 p. m.
Detección70 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir
Remediar en la ventana regular de mantenimiento
Estimación de Llama con el árbol SSVC de CISA a partir de vector CVSS 3.1 y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
No es drama, es prevención. Hazme caso.Ponle fecha: las tareas sin fecha son leyendas.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 4.2.18.Final
Monitoreo
Detectada +1
9 sept 26
10 sept 26
19 nov 26
21 nov 26
9 sept 26
27 sept 26
15 oct 26
3 nov 26
21 nov 26
FechaFaseEventoDetalle
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
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

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:N

Suggested 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 test

The 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.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:H
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:N
AltoBajoNinguno
Score de explotaciónQué tan fácil y probable es que la exploten
10.0/ 10Muy alto
Vector 10.0 (muy fácil) · sin evidencia de explotación.
Versiones

Rangos afectados

Afectada Corregida Última
io.netty:netty-codec-classes-quic≥ 4.2.11.Final < 4.2.18.Final
4.2.11.Final
4.2.18.Final
4.2.20.Final
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
mavenio.netty:netty-codec-classes-quic
Corregida 4.2.18.Final -1 d 4.2.20.Final no afectada
Versiones corregidas4.2.18.Final
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/netty/netty/security/advisories/GHSA-mj35-3qqm-q387

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.