Deno's TLS retry copies stale upgrade hook, risking plaintext traffic

@@ -20,14 +20,9 @@ use deno_core::v8;
 use libnghttp2 as ffi;
 use serde::Serialize;
 
-/// Type alias matching the C `ssize_t` type used by nghttp2 callbacks.
-/// On Unix, `ssize_t` equals `isize`. On 64-bit Windows MSVC, `ssize_t`
-/// is defined as `long long` (`i64`), which bindgen emits as `i64`
-/// rather than `isize`.
-#[cfg(not(windows))]
-type CSsizeT = isize;
-#[cfg(windows)]
-type CSsizeT = i64;
+/// Match the exact callback return type generated by libnghttp2 bindings on
+/// the current platform instead of guessing the Windows `ssize_t` mapping.
+type CSsizeT = ffi::nghttp2_ssize;
 
 use super::stream::Http2Headers;
 use super::stream::Http2Priority;
@@ -1342,7 +1337,7 @@ fn create_callbacks() -> *mut ffi::nghttp2_session_callbacks {
       callbacks,
       Some(on_frame_send_callback),
     );
-    ffi::nghttp2_session_callbacks_set_select_padding_callback(
+    ffi::nghttp2_session_callbacks_set_select_padding_callback2(
       callbacks,
       Some(on_select_padding),
     );
@@ -1826,7 +1821,7 @@ impl Http2Session {
     options: i32,
   ) -> i32 {
     let has_data = (options & STREAM_OPTION_EMPTY_PAYLOAD) == 0;
-    let mut data_provider = ffi::nghttp2_data_provider {
+    let mut data_provider = ffi::nghttp2_data_provider2 {
       source: ffi::nghttp2_data_source {
         ptr: std::ptr::null_mut(),
       },
@@ -1841,7 +1836,7 @@ impl Http2Session {
 
     // SAFETY: self.session, priority, headers, and data_provider are valid
     let ret = unsafe {
-      ffi::nghttp2_submit_request(
+      ffi::nghttp2_submit_request2(
         self.session,
         &priority.spec,
         headers.data(),

@@ -332,7 +332,7 @@ impl Http2Stream {
     }
 
     let has_data = (options & STREAM_OPTION_EMPTY_PAYLOAD) == 0;
-    let mut data_provider = ffi::nghttp2_data_provider {
+    let mut data_provider = ffi::nghttp2_data_provider2 {
       source: ffi::nghttp2_data_source {
         ptr: std::ptr::null_mut(),
       },
@@ -347,7 +347,7 @@ impl Http2Stream {
 
     // SAFETY: session pointer is valid during stream lifetime
     unsafe {
-      ffi::nghttp2_submit_response(
+      ffi::nghttp2_submit_response2(
         session_ptr,
         self.id,
         headers.data(),
@@ -438,7 +438,7 @@ impl Http2Stream {
     let session_ptr = self.nghttp2_session();
 
     if headers.1 == 0 {
-      let mut data_provider = ffi::nghttp2_data_provider {
+      let mut data_provider = ffi::nghttp2_data_provider2 {
         source: ffi::nghttp2_data_source {
           ptr: std::ptr::null_mut(),
         },
@@ -447,7 +447,7 @@ impl Http2Stream {
 
       // SAFETY: session pointer is valid during stream lifetime
       unsafe {
-        ffi::nghttp2_submit_data(
+        ffi::nghttp2_submit_data2(
           session_ptr,
           ffi::NGHTTP2_FLAG_END_STREAM as u8,
           self.id,

@@ -1799,7 +1799,15 @@ Socket.prototype[kReinitializeHandle] = function (handle) {
   this._handle?.close();
 
   // Make sure TLS wrap works after reinitialize.
-  handle.afterConnectTls = this._handle.afterConnectTls;
+  if (typeof this._handle?.afterConnectTls === "function") {
+    const { promise, resolve } = Promise.withResolvers();
+    handle.afterConnectTls = this._handle.afterConnectTls;
+    handle.afterConnectTlsResolve = resolve;
+    handle.upgrading = promise;
+    handle.verifyError = this._handle.verifyError;
+    handle._parent = handle;
+    handle._parentWrap = this._handle._parentWrap;
+  }
 
   this._handle = handle;
   this._handle[ownerSymbol] = this;

@@ -198,7 +198,7 @@ export class TLSSocket extends net.Socket {
       const { promise, resolve } = Promise.withResolvers();
 
       // Set `afterConnectTls` hook. This is called in the `afterConnect` method of net.Socket
-      handle.afterConnectTls = async () => {
+      handle.afterConnectTls = async function () {
         options.hostname ??= undefined; // coerce to undefined if null, startTls expects hostname to be undefined
         if (tlssock._needsSockInitWorkaround) {
           tlssock.emit("secure");
@@ -209,7 +209,7 @@ export class TLSSocket extends net.Socket {
         try {
           const conn = await startTls(
             wrap,
-            handle,
+            this,
             options,
           );
           try {
@@ -225,13 +225,14 @@ export class TLSSocket extends net.Socket {
           }
 
           // Assign the TLS connection to the handle and resume reading.
-          handle[kStreamBaseField] = conn;
-          handle.upgrading = false;
-          if (!handle.pauseOnCreate) {
-            handle.readStart();
+          this[kStreamBaseField] = conn;
+          this.upgrading = false;
+          if (!this.pauseOnCreate) {
+            this.readStart();
           }
 
-          resolve();
+          this.afterConnectTlsResolve?.();
+          delete this.afterConnectTlsResolve;
 
           tlssock.emit("secure");
           tlssock.removeListener("end", onConnectEnd);
@@ -240,6 +241,7 @@ export class TLSSocket extends net.Socket {
         }
       };
 
+      handle.afterConnectTlsResolve = resolve;
       handle.upgrading = promise;
       handle.verifyError = function () {
         return null; // Never fails, rejectUnauthorized is always true in Deno.

@@ -319,6 +319,48 @@ Deno.test("tlssocket._handle._parentWrap is set", () => {
   assertInstanceOf(parentWrap, stream.PassThrough);
 });
 
+Deno.test("net.Socket reinitialize preserves TLS upgrade state", () => {
+  const socket = new net.Socket();
+  const reinitializeHandle = Object.getOwnPropertySymbols(net.Socket.prototype)
+    .find((symbol) => symbol.description === "kReinitializeHandle");
+
+  assert(reinitializeHandle, "expected kReinitializeHandle symbol");
+  const reinitializeHandleSymbol = reinitializeHandle as symbol;
+
+  let closed = false;
+  const afterConnectTls = function () {};
+  const verifyError = () => null;
+  const parentWrap = new stream.PassThrough();
+
+  // deno-lint-ignore no-explicit-any
+  (socket as any)._handle = {
+    close() {
+      closed = true;
+    },
+    afterConnectTls,
+    verifyError,
+    _parentWrap: parentWrap,
+  };
+
+  const newHandle = {};
+  // deno-lint-ignore no-explicit-any
+  (socket as any)[reinitializeHandleSymbol](newHandle);
+
+  assert(closed);
+  // deno-lint-ignore no-explicit-any
+  assertEquals((newHandle as any).afterConnectTls, afterConnectTls);
+  // deno-lint-ignore no-explicit-any
+  assertEquals(typeof (newHandle as any).afterConnectTlsResolve, "function");
+  // deno-lint-ignore no-explicit-any
+  assert((newHandle as any).upgrading instanceof Promise);
+  // deno-lint-ignore no-explicit-any
+  assertEquals((newHandle as any).verifyError, verifyError);
+  // deno-lint-ignore no-explicit-any
+  assertEquals((newHandle as any)._parent, newHandle);
+  // deno-lint-ignore no-explicit-any
+  assertEquals((newHandle as any)._parentWrap, parentWrap);
+});
+
 Deno.test({
   name: "tls connect upgrade js socket wrapper",
   sanitizeOps: false,

@@ -90,6 +90,7 @@ import {
 import { timerId } from "ext:deno_web/03_abort_signal.js";
 import { clearTimeout as webClearTimeout } from "ext:deno_web/02_timers.js";
 import { resourceForReadableStream } from "ext:deno_web/06_streams.js";
+import { kReinitializeHandle } from "ext:deno_node/internal/net.ts";
 import {
   kDestroyed,
   kEnded,
@@ -471,7 +472,9 @@ class ClientRequest extends OutgoingMessage {
             // we apply sock-init-workaround
             // This covers npm:ws and npm:mqtt
             // https://github.com/denoland/deno/issues/27694
-            newSocket._needsSockInitWorkaround = true;
+            if (newSocket.encrypted !== true) {
+              newSocket._needsSockInitWorkaround = true;
+            }
             oncreate(null, newSocket);
           }
         } catch (err) {
@@ -706,9 +709,41 @@ class ClientRequest extends OutgoingMessage {
               port: info[3],
             },
           );
-          const socket = new Socket({
-            handle: new TCP(constants.SOCKET, conn),
-          });
+          const upgradeHandle = new TCP(constants.SOCKET, conn);
+          let socket = this.socket;
+          // Only reuse the existing socket when it was provided via
+          // createConnection (encrypted TLS socket). For plain HTTP
+          // upgrades, create a fresh Socket to avoid dangling state.
+          if (
+            socket?.encrypted === true &&
+            socket?.[kReinitializeHandle]
+          ) {
+            if (this._socketErrorListener) {
+              socket.removeListener("error", this._socketErrorListener);
+              this._socketErrorListener = null;
+            }
+            socket.emit("agentRemove");
+            const tlsWrapState = socket.encrypted === true &&
+                socket._tlsUpgraded &&
+                socket._handle
+              ? {
+                verifyError: socket._handle.verifyError,
+                parentWrap: socket._handle._parentWrap,
+              }
+              : null;
+            if (tlsWrapState) {
+              delete socket._handle.afterConnectTls;
+            }
+            socket[kReinitializeHandle](upgradeHandle);
+            if (tlsWrapState) {
+              upgradeHandle.verifyError = tlsWrapState.verifyError;
+              upgradeHandle._parent = upgradeHandle;
+              upgradeHandle._parentWrap = tlsWrapState.parentWrap;
+              socket._tlsUpgraded = true;
+            }
+          } else {
+            socket = new Socket({ handle: upgradeHandle });
+          }
 
           this.upgradeOrConnect = true;
 
@@ -867,7 +902,9 @@ class ClientRequest extends OutgoingMessage {
         };
         this._socketErrorListener = socketErrorListener;
         socket.once("error", socketErrorListener);
-        if (socket.readyState === "opening") {
+        if (socket.encrypted === true && socket.secureConnecting) {
+          socket.once("secureConnect", onConnect);
+        } else if (socket.readyState === "opening") {
           socket.on("connect", onConnect);
         } else {
           onConnect();

@@ -226,6 +226,7 @@ export class TLSSocket extends net.Socket {
 
           // Assign the TLS connection to the handle and resume reading.
           this[kStreamBaseField] = conn;
+          tlssock._tlsUpgraded = true;
           this.upgrading = false;
           if (!this.pauseOnCreate) {
             this.readStart();

@@ -0,0 +1,81 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+
+import { once } from "node:events";
+import https from "node:https";
+import tls from "node:tls";
+import type { AddressInfo } from "node:net";
+import type { Duplex } from "node:stream";
+
+import { assert, assertStrictEquals } from "@std/assert";
+
+Deno.test({
+  name: "[node/https] client upgrade reuses TLSSocket from createConnection",
+  permissions: {
+    net: true,
+    read: [
+      "tests/testdata/tls/localhost.crt",
+      "tests/testdata/tls/localhost.key",
+    ],
+  },
+}, async () => {
+  const cert = Deno.readTextFileSync("tests/testdata/tls/localhost.crt");
+  const key = Deno.readTextFileSync("tests/testdata/tls/localhost.key");
+  let serverSocket: Duplex | undefined;
+
+  const server = https.createServer({ cert, key });
+  server.on("upgrade", (_req, socket, _head) => {
+    serverSocket = socket;
+    socket.write(
+      "HTTP/1.1 101 Switching Protocols\r\n" +
+        "Connection: Upgrade\r\n" +
+        "Upgrade: websocket\r\n" +
+        "\r\n",
+    );
+  });
+
+  server.listen(0, "127.0.0.1");
+  await once(server, "listening");
+
+  const { port } = server.address() as AddressInfo;
+  const tlsSocket = tls.connect({
+    host: "127.0.0.1",
+    port,
+    rejectUnauthorized: false,
+    servername: "localhost",
+  });
+
+  const req = https.request({
+    host: "127.0.0.1",
+    port,
+    method: "GET",
+    createConnection: () => tlsSocket,
+    headers: {
+      Connection: "Upgrade",
+      Upgrade: "websocket",
+      "Sec-WebSocket-Key": "dGhlIHNhbXBsZSBub25jZQ==",
+      "Sec-WebSocket-Version": "13",
+    },
+  });
+
+  const [_res, socket, _head] = await new Promise<
+    [unknown, Duplex, unknown]
+  >((resolve, reject) => {
+    req.on("upgrade", (...args) => resolve(args));
+    req.on("error", reject);
+    req.end();
+  });
+
+  assertStrictEquals(socket, tlsSocket);
+  // @ts-ignore TLSSocket-specific property
+  assert(socket.encrypted);
+
+  const socketClosed = once(socket, "close");
+  const peerClosed = serverSocket
+    ? once(serverSocket, "close")
+    : Promise.resolve();
+  const serverClosed = once(server, "close");
+  socket.destroy();
+  serverSocket?.destroy();
+  server.close();
+  await Promise.all([socketClosed, peerClosed, serverClosed]);
+});