crypto/tls: apply QUIC session event flag to QUICResumeSession events

Go 1.23 adds two new events to QUICConns: QUICStoreSessionEvent and
QUICResumeSessionEvent. We added a QUICConfig.EnableStoreSessionEvent
flag to control whether the store-session event is provided or not,
because receiving this event requires additional action from the caller:
the session must be explicitly stored with QUICConn.StoreSession.

We did not add a control for whether the resume-session event is
provided, because this event requires no action and the caller is
expected to ignore unknown events.

However, we never documented the expectation that callers ignore
unknown events, and quic-go produces an error when receiving an
unexpected event. So change the EnableStoreSessionEvent flag to
apply to both new events.

Fixes #68124
For #63691

Change-Id: I84af487e52b3815f7b648e09884608f8915cd645
Reviewed-on: https://go-review.googlesource.com/c/go/+/594475
Reviewed-by: Marten Seemann <martenseemann@gmail.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Roland Shoemaker <roland@golang.org>

diff --git a/api/go1.23.txt b/api/go1.23.txt
index dc92d3fe56b137b8547fa7047b33715948cb8ce7..9363bd41f3ce4681020fa83c0f54a19ec792377b 100644 (file)
--- a/api/go1.23.txt
+++ b/api/go1.23.txt
@@ -18,7 +18,7 @@ pkg crypto/tls, type Config struct, EncryptedClientHelloRejectionVerify func(Con
 pkg crypto/tls, type ConnectionState struct, ECHAccepted bool #63369
 pkg crypto/tls, type ECHRejectionError struct #63369
 pkg crypto/tls, type ECHRejectionError struct, RetryConfigList []uint8 #63369
-pkg crypto/tls, type QUICConfig struct, EnableStoreSessionEvent bool #63691
+pkg crypto/tls, type QUICConfig struct, EnableSessionEvents bool #63691
 pkg crypto/tls, type QUICEvent struct, SessionState *SessionState #63691
 pkg crypto/tls, type QUICSessionTicketOptions struct, Extra [][]uint8 #63691
 pkg crypto/x509, func ParseOID(string) (OID, error) #66249

diff --git a/src/crypto/tls/handshake_client.go b/src/crypto/tls/handshake_client.go
index 553d2dde01de2d275f391cf24a0352945297c743..5025657590d32c5a9fab8d4ade234820b123a7dc 100644 (file)
--- a/src/crypto/tls/handshake_client.go
+++ b/src/crypto/tls/handshake_client.go
@@ -478,7 +478,9 @@ func (c *Conn) loadSession(hello *clientHelloMsg) (
        }
 
        if c.quic != nil {
-               c.quicResumeSession(session)
+               if c.quic.enableSessionEvents {
+                       c.quicResumeSession(session)
+               }
 
                // For 0-RTT, the cipher suite has to match exactly, and we need to be
                // offering the same ALPN.

diff --git a/src/crypto/tls/handshake_client_tls13.go b/src/crypto/tls/handshake_client_tls13.go
index 6744e713c9ffa8952f67f7dbf1195e52a8d60190..db5e35d9a46c2e1deef7ecf05c49eba87a4b56c9 100644 (file)
--- a/src/crypto/tls/handshake_client_tls13.go
+++ b/src/crypto/tls/handshake_client_tls13.go
@@ -900,7 +900,7 @@ func (c *Conn) handleNewSessionTicket(msg *newSessionTicketMsgTLS13) error {
        session.ageAdd = msg.ageAdd
        session.EarlyData = c.quic != nil && msg.maxEarlyData == 0xffffffff // RFC 9001, Section 4.6.1
        session.ticket = msg.label
-       if c.quic != nil && c.quic.enableStoreSessionEvent {
+       if c.quic != nil && c.quic.enableSessionEvents {
                c.quicStoreSession(session)
                return nil
        }

diff --git a/src/crypto/tls/handshake_server_tls13.go b/src/crypto/tls/handshake_server_tls13.go
index f24c2671acd4353d2cd5682c23de38677a3f0314..503a732e05765ec86f68027eaa1fd890c8009771 100644 (file)
--- a/src/crypto/tls/handshake_server_tls13.go
+++ b/src/crypto/tls/handshake_server_tls13.go
@@ -377,7 +377,7 @@ func (hs *serverHandshakeStateTLS13) checkForResumption() error {
                        continue
                }
 
-               if c.quic != nil {
+               if c.quic != nil && c.quic.enableSessionEvents {
                        if err := c.quicResumeSession(sessionState); err != nil {
                                return err
                        }

diff --git a/src/crypto/tls/quic.go b/src/crypto/tls/quic.go
index 8e722c6a590578881e66d0d906a68c033e59ef7c..9dd6168b62356ebac3f911cecb5b7f9284757a78 100644 (file)
--- a/src/crypto/tls/quic.go
+++ b/src/crypto/tls/quic.go
@@ -50,12 +50,12 @@ type QUICConn struct {
 type QUICConfig struct {
        TLSConfig *Config
 
-       // EnableStoreSessionEvent may be set to true to enable the
-       // [QUICStoreSession] event for client connections.
+       // EnableSessionEvents may be set to true to enable the
+       // [QUICStoreSession] and [QUICResumeSession] events for client connections.
        // When this event is enabled, sessions are not automatically
        // stored in the client session cache.
        // The application should use [QUICConn.StoreSession] to store sessions.
-       EnableStoreSessionEvent bool
+       EnableSessionEvents bool
 }
 
 // A QUICEventKind is a type of operation on a QUIC connection.
@@ -113,7 +113,7 @@ const (
        // QUICStoreSession indicates that the server has provided state permitting
        // the client to resume the session.
        // [QUICEvent.SessionState] is set.
-       // The application should use [QUICConn.Store] session to store the [SessionState].
+       // The application should use [QUICConn.StoreSession] session to store the [SessionState].
        // The application may modify the [SessionState] before storing it.
        // This event only occurs on client connections.
        QUICStoreSession
@@ -165,7 +165,7 @@ type quicState struct {
 
        transportParams []byte // to send to the peer
 
-       enableStoreSessionEvent bool
+       enableSessionEvents bool
 }
 
 // QUICClient returns a new TLS client side connection using QUICTransport as the
@@ -186,9 +186,9 @@ func QUICServer(config *QUICConfig) *QUICConn {
 
 func newQUICConn(conn *Conn, config *QUICConfig) *QUICConn {
        conn.quic = &quicState{
-               signalc:                 make(chan struct{}),
-               blockedc:                make(chan struct{}),
-               enableStoreSessionEvent: config.EnableStoreSessionEvent,
+               signalc:             make(chan struct{}),
+               blockedc:            make(chan struct{}),
+               enableSessionEvents: config.EnableSessionEvents,
        }
        conn.quic.events = conn.quic.eventArr[:0]
        return &QUICConn{

diff --git a/src/crypto/tls/quic_test.go b/src/crypto/tls/quic_test.go
index 5a6f66e4deaeb4624a2ca5721ae0c99deb2b06d7..1bb2e55bddcbeac5a1841c3a312a67e6e583a689 100644 (file)
--- a/src/crypto/tls/quic_test.go
+++ b/src/crypto/tls/quic_test.go
@@ -24,22 +24,22 @@ type testQUICConn struct {
        complete          bool
 }
 
-func newTestQUICClient(t *testing.T, config *Config) *testQUICConn {
-       q := &testQUICConn{t: t}
-       q.conn = QUICClient(&QUICConfig{
-               TLSConfig: config,
-       })
+func newTestQUICClient(t *testing.T, config *QUICConfig) *testQUICConn {
+       q := &testQUICConn{
+               t:    t,
+               conn: QUICClient(config),
+       }
        t.Cleanup(func() {
                q.conn.Close()
        })
        return q
 }
 
-func newTestQUICServer(t *testing.T, config *Config) *testQUICConn {
-       q := &testQUICConn{t: t}
-       q.conn = QUICServer(&QUICConfig{
-               TLSConfig: config,
-       })
+func newTestQUICServer(t *testing.T, config *QUICConfig) *testQUICConn {
+       q := &testQUICConn{
+               t:    t,
+               conn: QUICServer(config),
+       }
        t.Cleanup(func() {
                q.conn.Close()
        })
@@ -140,6 +140,11 @@ func runTestQUICConnection(ctx context.Context, cli, srv *testQUICConn, onEvent
                                        return err
                                }
                        }
+               case QUICStoreSession:
+                       if a != cli {
+                               return errors.New("unexpected QUICStoreSession event received by server")
+                       }
+                       a.conn.StoreSession(e.SessionState)
                case QUICResumeSession:
                        if a.onResumeSession != nil {
                                a.onResumeSession(e.SessionState)
@@ -154,8 +159,8 @@ func runTestQUICConnection(ctx context.Context, cli, srv *testQUICConn, onEvent
 }
 
 func TestQUICConnection(t *testing.T) {
-       config := testConfig.Clone()
-       config.MinVersion = VersionTLS13
+       config := &QUICConfig{TLSConfig: testConfig.Clone()}
+       config.TLSConfig.MinVersion = VersionTLS13
 
        cli := newTestQUICClient(t, config)
        cli.conn.SetTransportParameters(nil)
@@ -196,13 +201,13 @@ func TestQUICConnection(t *testing.T) {
 }
 
 func TestQUICSessionResumption(t *testing.T) {
-       clientConfig := testConfig.Clone()
-       clientConfig.MinVersion = VersionTLS13
-       clientConfig.ClientSessionCache = NewLRUClientSessionCache(1)
-       clientConfig.ServerName = "example.go.dev"
+       clientConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       clientConfig.TLSConfig.MinVersion = VersionTLS13
+       clientConfig.TLSConfig.ClientSessionCache = NewLRUClientSessionCache(1)
+       clientConfig.TLSConfig.ServerName = "example.go.dev"
 
-       serverConfig := testConfig.Clone()
-       serverConfig.MinVersion = VersionTLS13
+       serverConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       serverConfig.TLSConfig.MinVersion = VersionTLS13
 
        cli := newTestQUICClient(t, clientConfig)
        cli.conn.SetTransportParameters(nil)
@@ -228,13 +233,13 @@ func TestQUICSessionResumption(t *testing.T) {
 }
 
 func TestQUICFragmentaryData(t *testing.T) {
-       clientConfig := testConfig.Clone()
-       clientConfig.MinVersion = VersionTLS13
-       clientConfig.ClientSessionCache = NewLRUClientSessionCache(1)
-       clientConfig.ServerName = "example.go.dev"
+       clientConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       clientConfig.TLSConfig.MinVersion = VersionTLS13
+       clientConfig.TLSConfig.ClientSessionCache = NewLRUClientSessionCache(1)
+       clientConfig.TLSConfig.ServerName = "example.go.dev"
 
-       serverConfig := testConfig.Clone()
-       serverConfig.MinVersion = VersionTLS13
+       serverConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       serverConfig.TLSConfig.MinVersion = VersionTLS13
 
        cli := newTestQUICClient(t, clientConfig)
        cli.conn.SetTransportParameters(nil)
@@ -260,8 +265,8 @@ func TestQUICFragmentaryData(t *testing.T) {
 
 func TestQUICPostHandshakeClientAuthentication(t *testing.T) {
        // RFC 9001, Section 4.4.
-       config := testConfig.Clone()
-       config.MinVersion = VersionTLS13
+       config := &QUICConfig{TLSConfig: testConfig.Clone()}
+       config.TLSConfig.MinVersion = VersionTLS13
        cli := newTestQUICClient(t, config)
        cli.conn.SetTransportParameters(nil)
        srv := newTestQUICServer(t, config)
@@ -288,8 +293,8 @@ func TestQUICPostHandshakeClientAuthentication(t *testing.T) {
 
 func TestQUICPostHandshakeKeyUpdate(t *testing.T) {
        // RFC 9001, Section 6.
-       config := testConfig.Clone()
-       config.MinVersion = VersionTLS13
+       config := &QUICConfig{TLSConfig: testConfig.Clone()}
+       config.TLSConfig.MinVersion = VersionTLS13
        cli := newTestQUICClient(t, config)
        cli.conn.SetTransportParameters(nil)
        srv := newTestQUICServer(t, config)
@@ -312,8 +317,8 @@ func TestQUICPostHandshakeKeyUpdate(t *testing.T) {
 }
 
 func TestQUICPostHandshakeMessageTooLarge(t *testing.T) {
-       config := testConfig.Clone()
-       config.MinVersion = VersionTLS13
+       config := &QUICConfig{TLSConfig: testConfig.Clone()}
+       config.TLSConfig.MinVersion = VersionTLS13
        cli := newTestQUICClient(t, config)
        cli.conn.SetTransportParameters(nil)
        srv := newTestQUICServer(t, config)
@@ -334,13 +339,13 @@ func TestQUICPostHandshakeMessageTooLarge(t *testing.T) {
 }
 
 func TestQUICHandshakeError(t *testing.T) {
-       clientConfig := testConfig.Clone()
-       clientConfig.MinVersion = VersionTLS13
-       clientConfig.InsecureSkipVerify = false
-       clientConfig.ServerName = "name"
+       clientConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       clientConfig.TLSConfig.MinVersion = VersionTLS13
+       clientConfig.TLSConfig.InsecureSkipVerify = false
+       clientConfig.TLSConfig.ServerName = "name"
 
-       serverConfig := testConfig.Clone()
-       serverConfig.MinVersion = VersionTLS13
+       serverConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       serverConfig.TLSConfig.MinVersion = VersionTLS13
 
        cli := newTestQUICClient(t, clientConfig)
        cli.conn.SetTransportParameters(nil)
@@ -360,9 +365,9 @@ func TestQUICHandshakeError(t *testing.T) {
 // and that it reports the application protocol as soon as it has been
 // negotiated.
 func TestQUICConnectionState(t *testing.T) {
-       config := testConfig.Clone()
-       config.MinVersion = VersionTLS13
-       config.NextProtos = []string{"h3"}
+       config := &QUICConfig{TLSConfig: testConfig.Clone()}
+       config.TLSConfig.MinVersion = VersionTLS13
+       config.TLSConfig.NextProtos = []string{"h3"}
        cli := newTestQUICClient(t, config)
        cli.conn.SetTransportParameters(nil)
        srv := newTestQUICServer(t, config)
@@ -391,10 +396,10 @@ func TestQUICStartContextPropagation(t *testing.T) {
        const key = "key"
        const value = "value"
        ctx := context.WithValue(context.Background(), key, value)
-       config := testConfig.Clone()
-       config.MinVersion = VersionTLS13
+       config := &QUICConfig{TLSConfig: testConfig.Clone()}
+       config.TLSConfig.MinVersion = VersionTLS13
        calls := 0
-       config.GetConfigForClient = func(info *ClientHelloInfo) (*Config, error) {
+       config.TLSConfig.GetConfigForClient = func(info *ClientHelloInfo) (*Config, error) {
                calls++
                got, _ := info.Context().Value(key).(string)
                if got != value {
@@ -415,13 +420,13 @@ func TestQUICStartContextPropagation(t *testing.T) {
 }
 
 func TestQUICDelayedTransportParameters(t *testing.T) {
-       clientConfig := testConfig.Clone()
-       clientConfig.MinVersion = VersionTLS13
-       clientConfig.ClientSessionCache = NewLRUClientSessionCache(1)
-       clientConfig.ServerName = "example.go.dev"
+       clientConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       clientConfig.TLSConfig.MinVersion = VersionTLS13
+       clientConfig.TLSConfig.ClientSessionCache = NewLRUClientSessionCache(1)
+       clientConfig.TLSConfig.ServerName = "example.go.dev"
 
-       serverConfig := testConfig.Clone()
-       serverConfig.MinVersion = VersionTLS13
+       serverConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       serverConfig.TLSConfig.MinVersion = VersionTLS13
 
        cliParams := "client params"
        srvParams := "server params"
@@ -449,8 +454,8 @@ func TestQUICDelayedTransportParameters(t *testing.T) {
 }
 
 func TestQUICEmptyTransportParameters(t *testing.T) {
-       config := testConfig.Clone()
-       config.MinVersion = VersionTLS13
+       config := &QUICConfig{TLSConfig: testConfig.Clone()}
+       config.TLSConfig.MinVersion = VersionTLS13
 
        cli := newTestQUICClient(t, config)
        cli.conn.SetTransportParameters(nil)
@@ -475,8 +480,8 @@ func TestQUICEmptyTransportParameters(t *testing.T) {
 }
 
 func TestQUICCanceledWaitingForData(t *testing.T) {
-       config := testConfig.Clone()
-       config.MinVersion = VersionTLS13
+       config := &QUICConfig{TLSConfig: testConfig.Clone()}
+       config.TLSConfig.MinVersion = VersionTLS13
        cli := newTestQUICClient(t, config)
        cli.conn.SetTransportParameters(nil)
        cli.conn.Start(context.Background())
@@ -489,8 +494,8 @@ func TestQUICCanceledWaitingForData(t *testing.T) {
 }
 
 func TestQUICCanceledWaitingForTransportParams(t *testing.T) {
-       config := testConfig.Clone()
-       config.MinVersion = VersionTLS13
+       config := &QUICConfig{TLSConfig: testConfig.Clone()}
+       config.TLSConfig.MinVersion = VersionTLS13
        cli := newTestQUICClient(t, config)
        cli.conn.Start(context.Background())
        for cli.conn.NextEvent().Kind != QUICTransportParametersRequired {
@@ -502,15 +507,15 @@ func TestQUICCanceledWaitingForTransportParams(t *testing.T) {
 }
 
 func TestQUICEarlyData(t *testing.T) {
-       clientConfig := testConfig.Clone()
-       clientConfig.MinVersion = VersionTLS13
-       clientConfig.ClientSessionCache = NewLRUClientSessionCache(1)
-       clientConfig.ServerName = "example.go.dev"
-       clientConfig.NextProtos = []string{"h3"}
+       clientConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       clientConfig.TLSConfig.MinVersion = VersionTLS13
+       clientConfig.TLSConfig.ClientSessionCache = NewLRUClientSessionCache(1)
+       clientConfig.TLSConfig.ServerName = "example.go.dev"
+       clientConfig.TLSConfig.NextProtos = []string{"h3"}
 
-       serverConfig := testConfig.Clone()
-       serverConfig.MinVersion = VersionTLS13
-       serverConfig.NextProtos = []string{"h3"}
+       serverConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       serverConfig.TLSConfig.MinVersion = VersionTLS13
+       serverConfig.TLSConfig.NextProtos = []string{"h3"}
 
        cli := newTestQUICClient(t, clientConfig)
        cli.conn.SetTransportParameters(nil)
@@ -528,7 +533,14 @@ func TestQUICEarlyData(t *testing.T) {
        cli2.conn.SetTransportParameters(nil)
        srv2 := newTestQUICServer(t, serverConfig)
        srv2.conn.SetTransportParameters(nil)
-       if err := runTestQUICConnection(context.Background(), cli2, srv2, nil); err != nil {
+       onEvent := func(e QUICEvent, src, dst *testQUICConn) bool {
+               switch e.Kind {
+               case QUICStoreSession, QUICResumeSession:
+                       t.Errorf("with EnableSessionEvents=false, got unexpected event %v", e.Kind)
+               }
+               return false
+       }
+       if err := runTestQUICConnection(context.Background(), cli2, srv2, onEvent); err != nil {
                t.Fatalf("error during second connection handshake: %v", err)
        }
        if !cli2.conn.ConnectionState().DidResume {
@@ -557,15 +569,17 @@ func TestQUICEarlyDataDeclined(t *testing.T) {
 }
 
 func testQUICEarlyDataDeclined(t *testing.T, server bool) {
-       clientConfig := testConfig.Clone()
-       clientConfig.MinVersion = VersionTLS13
-       clientConfig.ClientSessionCache = NewLRUClientSessionCache(1)
-       clientConfig.ServerName = "example.go.dev"
-       clientConfig.NextProtos = []string{"h3"}
-
-       serverConfig := testConfig.Clone()
-       serverConfig.MinVersion = VersionTLS13
-       serverConfig.NextProtos = []string{"h3"}
+       clientConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       clientConfig.EnableSessionEvents = true
+       clientConfig.TLSConfig.MinVersion = VersionTLS13
+       clientConfig.TLSConfig.ClientSessionCache = NewLRUClientSessionCache(1)
+       clientConfig.TLSConfig.ServerName = "example.go.dev"
+       clientConfig.TLSConfig.NextProtos = []string{"h3"}
+
+       serverConfig := &QUICConfig{TLSConfig: testConfig.Clone()}
+       serverConfig.EnableSessionEvents = true
+       serverConfig.TLSConfig.MinVersion = VersionTLS13
+       serverConfig.TLSConfig.NextProtos = []string{"h3"}
 
        cli := newTestQUICClient(t, clientConfig)
        cli.conn.SetTransportParameters(nil)