Commit 5884b8e766f for nodejs

commit 5884b8e766f486fcf92202e0c31f7a80204ce61c
Author: Efe Karasakal <hi@efe.dev>
Date:   Fri Nov 20 09:41:26 2026 +0100

    quic: honor enableEarlyData on servers

    Signed-off-by: Efe Karasakal <hi@efe.dev>
    PR-URL: https://github.com/nodejs/node/pull/67562
    Reviewed-By: James M Snell <jasnell@gmail.com>
    Reviewed-By: Tim Perry <pimterry@gmail.com>

diff --git a/src/quic/tlscontext.cc b/src/quic/tlscontext.cc
index 75caa193f5e..267e9fe02dd 100644
--- a/src/quic/tlscontext.cc
+++ b/src/quic/tlscontext.cc
@@ -277,8 +277,8 @@ bool OSSLContext::set_verify_hostname(std::string_view hostname) const {
   }
 }

-bool OSSLContext::set_early_data_enabled() const {
-  return SSL_set_quic_tls_early_data_enabled(*this, 1) == 1;
+bool OSSLContext::set_early_data_enabled(bool enabled) const {
+  return SSL_set_quic_tls_early_data_enabled(*this, enabled) == 1;
 }

 bool OSSLContext::set_transport_params(const ngtcp2_vec& tp) const {
@@ -303,10 +303,10 @@ bool OSSLContext::set_session_ticket(const ncrypto::SSLSessionPointer& ticket) {
   return SSL_SESSION_get_max_early_data(ticket.get()) != 0;
 }

-bool OSSLContext::ConfigureServer() const {
+bool OSSLContext::ConfigureServer(bool enable_early_data) const {
   if (ngtcp2_crypto_ossl_configure_server_session(*this) != 0) return false;
   SSL_set_accept_state(*this);
-  return set_early_data_enabled();
+  return set_early_data_enabled(enable_early_data);
 }

 bool OSSLContext::ConfigureClient() const {
@@ -904,7 +904,8 @@ void TLSSession::Initialize(

   switch (ctx.side()) {
     case Side::SERVER: {
-      if (!ossl_context_.ConfigureServer()) [[unlikely]] {
+      if (!ossl_context_.ConfigureServer(options.enable_early_data))
+          [[unlikely]] {
         validation_error_ = "Failed to configure server session";
         ossl_context_.reset();
         return;
@@ -952,7 +953,7 @@ void TLSSession::Initialize(
             ngtcp2_vec rtp = sessionTicket.transport_params();
             if (ngtcp2_conn_decode_and_set_0rtt_transport_params(
                     *session_, rtp.base, rtp.len) == 0) {
-              if (!ossl_context_.set_early_data_enabled()) {
+              if (!ossl_context_.set_early_data_enabled(true)) {
                 validation_error_ = "Failed to enable early data";
                 ossl_context_.reset();
                 return;
diff --git a/src/quic/tlscontext.h b/src/quic/tlscontext.h
index 451d1b293ef..db4c7e97843 100644
--- a/src/quic/tlscontext.h
+++ b/src/quic/tlscontext.h
@@ -53,7 +53,7 @@ class OSSLContext final {
   bool set_alpn_protocols(std::string_view protocols) const;
   bool set_hostname(std::string_view hostname) const;
   bool set_verify_hostname(std::string_view hostname) const;
-  bool set_early_data_enabled() const;
+  bool set_early_data_enabled(bool enabled) const;
   bool set_transport_params(const ngtcp2_vec& tp) const;

   bool get_early_data_accepted() const;
@@ -64,7 +64,7 @@ class OSSLContext final {
   // ticket was set successfully and the ticket supports early data.
   bool set_session_ticket(const ncrypto::SSLSessionPointer& ticket);

-  bool ConfigureServer() const;
+  bool ConfigureServer(bool enable_early_data) const;
   bool ConfigureClient() const;

   void reset();
diff --git a/test/parallel/test-quic-zero-rtt-disabled-server.mjs b/test/parallel/test-quic-zero-rtt-disabled-server.mjs
index c2164d7c8b3..b1190e8379e 100644
--- a/test/parallel/test-quic-zero-rtt-disabled-server.mjs
+++ b/test/parallel/test-quic-zero-rtt-disabled-server.mjs
@@ -22,71 +22,114 @@ const cert = fixtures.readKey('agent1-cert.pem');
 const sni = { '*': { keys: [key], certs: [cert] } };
 const alpn = ['quic-test'];

-// Use the same tokenSecret for both servers so the token is valid.
-const tokenSecret = randomBytes(16);
-
-let savedTicket;
-let savedToken;
-const gotTicket = Promise.withResolvers();
-const gotToken = Promise.withResolvers();
-
-// First server: enableEarlyData: true (default) to generate a valid ticket.
-const serverEndpoint1 = await listen((serverSession) => {
-  serverSession.onstream = async (stream) => {
-    for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars
-    stream.writer.endSync();
-    await stream.closed;
+{
+  // Use the same tokenSecret for both servers so the token is valid.
+  const tokenSecret = randomBytes(16);
+
+  let savedTicket;
+  let savedToken;
+  const gotTicket = Promise.withResolvers();
+  const gotToken = Promise.withResolvers();
+
+  // First server: enableEarlyData: true (default) to generate a valid ticket.
+  const serverEndpoint1 = await listen((serverSession) => {
+    serverSession.onstream = async (stream) => {
+      for await (const _ of stream) { /* drain */ } // eslint-disable-line no-unused-vars
+      stream.writer.endSync();
+      await stream.closed;
+      serverSession.close();
+    };
+  }, {
+    sni,
+    alpn,
+    endpoint: { tokenSecret },
+  });
+
+  const cs1 = await connect(serverEndpoint1.address, {
+    alpn: 'quic-test',
+    verifyPeer: 'manual',
+    onsessionticket(ticket) {
+      savedTicket = ticket;
+      gotTicket.resolve();
+    },
+    onnewtoken(token) {
+      savedToken = token;
+      gotToken.resolve();
+    },
+  });
+  await Promise.all([cs1.opened, gotTicket.promise, gotToken.promise]);
+  await cs1.close();
+  await serverEndpoint1.close();
+
+  // Second server: enableEarlyData: false — rejects 0-RTT.
+  const serverEndpoint2 = await listen(async (serverSession) => {
+    await serverSession.opened;
     serverSession.close();
-  };
-}, {
-  sni,
-  alpn,
-  endpoint: { tokenSecret },
-});
-
-const cs1 = await connect(serverEndpoint1.address, {
-  alpn: 'quic-test',
-  verifyPeer: 'manual',
-  onsessionticket(ticket) {
-    savedTicket = ticket;
-    gotTicket.resolve();
-  },
-  onnewtoken(token) {
-    savedToken = token;
-    gotToken.resolve();
-  },
-});
-await Promise.all([cs1.opened, gotTicket.promise, gotToken.promise]);
-await cs1.close();
-await serverEndpoint1.close();
-
-// Second server: enableEarlyData: false — rejects 0-RTT.
-const serverEndpoint2 = await listen(async (serverSession) => {
-  await serverSession.opened;
-  serverSession.close();
-  await serverSession.closed;
-}, {
-  sni,
-  alpn,
-  enableEarlyData: false,
-  endpoint: { tokenSecret },
-  onerror: mustNotCall(),
-});
-
-const cs2 = await connect(serverEndpoint2.address, {
-  alpn: 'quic-test',
-  verifyPeer: 'manual',
-  sessionTicket: savedTicket,
-  token: savedToken,
-});
-
-// The deferred handshake needs a send to trigger. Use sendDatagram
-// since it's simpler than a stream for this test.
-await cs2.sendDatagram(new Uint8Array([1]));
-
-const info2 = await cs2.opened;
-assert.strictEqual(info2.earlyDataAttempted, true);
-assert.strictEqual(info2.earlyDataAccepted, false);
-
-await cs2.closed;
-await serverEndpoint2.close();
+    await serverSession.closed;
+  }, {
+    sni,
+    alpn,
+    enableEarlyData: false,
+    endpoint: { tokenSecret },
+    onerror: mustNotCall(),
+  });
+
+  const cs2 = await connect(serverEndpoint2.address, {
+    alpn: 'quic-test',
+    verifyPeer: 'manual',
+    sessionTicket: savedTicket,
+    token: savedToken,
+  });
+
+  // The deferred handshake needs a send to trigger. Use sendDatagram
+  // since it's simpler than a stream for this test.
+  await cs2.sendDatagram(new Uint8Array([1]));
+
+  const info2 = await cs2.opened;
+  assert.strictEqual(info2.earlyDataAttempted, true);
+  assert.strictEqual(info2.earlyDataAccepted, false);
+
+  await cs2.closed;
+  await serverEndpoint2.close();
+}
+
+// A server with early data disabled must issue tickets that do not permit
+// 0-RTT. Reusing the ticket on the same endpoint must fall back to 1-RTT.
+{
+  const ticketReady = Promise.withResolvers();
+  const endpoint = await listen(() => {}, {
+    sni,
+    alpn,
+    enableEarlyData: false,
+    onerror: mustNotCall(),
+  });
+
+  const client = await connect(endpoint.address, {
+    alpn: 'quic-test',
+    verifyPeer: 'manual',
+    onsessionticket(ticket) {
+      ticketReady.resolve(ticket);
+    },
+  });
+
+  await client.opened;
+  const ticket = await ticketReady.promise;
+  await client.close();
+
+  const client2 = await connect(endpoint.address, {
+    alpn: 'quic-test',
+    verifyPeer: 'manual',
+    sessionTicket: ticket,
+  });
+
+  await client2.createUnidirectionalStream({
+    body: 'hello from 0-RTT',
+  });
+
+  const info = await client2.opened;
+  assert.strictEqual(info.earlyDataAttempted, false);
+  assert.strictEqual(info.earlyDataAccepted, false);
+
+  await client2.close();
+  await endpoint.close();
+}