llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Hex · quic

GHSA-CV3H-PHW9-VFJM

Session tickets are accepted across unrelated listeners, bypassing PSK authentication

Sin parche publicado
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
ParcheSin parcheEl fabricante no ha publicado corrección
Exposición25 dDesde la divulgación, 25 oct 2026, 11:50 a. m.
Detección24 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Monitoreo
Detectada +1
25 oct 26
18 nov 26
20 nov 26
25 oct 26
1 nov 26
7 nov 26
13 nov 26
20 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-CV3H-PHW9-VFJM divulgada
Divulgación Modificada Última actualización del registro
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

Session resumption tickets are stored in a VM-global ETS table and accepted by
ticket identity alone. A ticket issued by one QUIC listener can therefore be
used to authenticate to an unrelated listener in the same BEAM VM, even when
the second listener is protected by a different external PSK and uses a
different SNI and ALPN.

An attacker who can connect to any lower-trust listener and receive a normal
session ticket can use that ticket to complete a full handshake with a
higher-trust PSK-only listener without knowing the higher-trust listener's PSK.

Affected versions and environment

  • Confirmed affected: `quic` 1.9.1 and current `main` at
  • The global resumption-ticket implementation predates the named multi-server
  • Reproduced with Erlang/OTP 29, ERTS 17.0.2, rebar3 3.27.0, on Darwin 25.1.0

Impact

This crosses an authentication boundary between services. A client authorized
only to use a public listener can gain full access to an unrelated external-PSK
listener in the same VM. The reproduced connection completed on both sides and
delivered post-handshake 1-RTT application data to the protected service.

The attacker does not need to know or guess the protected listener's PSK. The
attacker needs one valid ticket issued to it by another listener in the same
BEAM VM. Ticket randomness, binder verification, and single-use deletion do not
prevent the issue because both the client and the global server-side table hold
the legitimate resumption secret from the lower-trust listener.

Root cause

  1. `quic_server_registry:init/1` creates one named, public
  2. Servers store issued tickets in that table through
  3. `quic_connection:validate_psk/4` falls back to
  4. In `do_server_client_hello_cont/6`, failure to match the victim listener's
  5. Once the foreign ticket binder verifies, the connection records it as the

`quic_listener_manager:init/1` already creates a per-listener-pool ticket table,
but that table is not used by this validation path or passed into the server
connection.

Reproduction

I reproduced this entirely through public APIs with two named servers in one
VM:

  1. Start a public certificate listener with SNI `public.example` and ALPN
  2. Connect without client authentication and retain the emitted
  3. Start a separate certificate-less listener with ALPN `victim-proto` and only

```erlang
#{psks => #{<<"victim-id">> => <<"victim-secret">>}}
```

  1. As a control, connect to the victim with identity `victim-id` and secret
  2. Connect again to the victim using SNI `victim.example`, ALPN

```erlang
AttackOpts = #{
server_name => <<"victim.example">>,
alpn => [<<"victim-proto">>],
verify => false,
session_ticket => Ticket
},
{ok, AttackConn} = quic:connect("127.0.0.1", VictimPort, AttackOpts, self()).
```

  1. Both endpoints report `connected`. Opening a stream and sending

The local Common Test reproducer is `test/quic_ticket_scope_SUITE.erl`. Its
focused result on the affected commit is:

$ rebar3 ct --suite=quic_ticket_scope_SUITE
All 1 tests passed.

The test first proves the wrong victim PSK is rejected, then proves the foreign
ticket completes the victim handshake and exchanges 1-RTT data.

Expected behavior

A resumption ticket should be accepted only by the listener and security
context that issued it. The victim listener should reject a ticket issued by
the public listener and require its configured external PSK.

Suggested remediation

  • Use the existing per-listener or per-pool ticket table instead of a VM-global
  • Namespace and bind each ticket to the issuing listener, SNI, negotiated ALPN,
  • Validate all bound context before selecting the resumption PSK.
  • Consume an accepted ticket atomically, for example with `ets:take/2`, so
  • Add a negative integration test with a public certificate listener and an

Immediate mitigation

Run differently trusted QUIC listeners in separate BEAM VMs. In particular, do
not colocate a public ticket-issuing listener with an external-PSK-protected
listener until ticket storage and validation are scoped per listener.

Credit

Found by GPT Cyber.

Versiones

Rangos afectados

Afectada Corregida
quic≥ 0.9.0 ≤ 2.1.1
0.9.0
2.1.1
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
Hexquic
Sin parche — — —
Explotación

Arsenal público

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

Referencias
Advisoryhttps://github.com/benoitc/erlang_quic/security/advisories/GHSA-cv3h-phw9-vfjm

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