crypto: avoid TLSWrap callbacks during GC

TLSWrap destructors can run from V8 weak callbacks. Avoid invoking
queued write callbacks from that path because StreamReq::Done mutates
JS-visible objects and may allocate on the V8 heap during weak callback
processing.

Refs: #62393
Made-with: Cursor

Author: alexkozy

src/crypto/crypto_tls.cc

@@ -438,7 +438,9 @@ TLSWrap::TLSWrap(Environment* env,
 }
 
 TLSWrap::~TLSWrap() {
-  Destroy();
+  // Destructors can run from V8 weak callbacks during garbage collection.
+  // Do not invoke JS-visible write callbacks from here.
+  Destroy(false);
 }
 
 MaybeLocal<ArrayBufferView> TLSWrap::ocsp_response() const {
@@ -1307,15 +1309,21 @@ void TLSWrap::DestroySSL(const FunctionCallbackInfo<Value>& args) {
   Debug(wrap, "DestroySSL() finished");
 }
 
-void TLSWrap::Destroy() {
+void TLSWrap::Destroy(bool invoke_queued) {
   if (!ssl_)
     return;
 
-  // If there is a write happening, mark it as finished.
-  write_callback_scheduled_ = true;
+  if (invoke_queued) {
+    // If there is a write happening, mark it as finished.
+    write_callback_scheduled_ = true;
 
-  // And destroy
-  InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
+    // And destroy
+    InvokeQueued(UV_ECANCELED, "Canceled because of SSL destruction");
+  } else {
+    current_write_.reset();
+    current_empty_write_.reset();
+    write_callback_scheduled_ = false;
+  }
 
   env()->external_memory_accounter()->Decrease(env()->isolate(), kExternalSize);
   ssl_.reset();

src/crypto/crypto_tls.h

@@ -159,7 +159,7 @@ class TLSWrap : public AsyncWrap,
   void EncOut();  // Write encrypted data from enc_out_ to underlying stream.
   void ClearIn();  // SSL_write() clear data "in" to SSL.
   void ClearOut();  // SSL_read() clear text "out" from SSL.
-  void Destroy();
+  void Destroy(bool invoke_queued = true);
 
   // Call Done() on outstanding WriteWrap request.
   void InvokeQueued(int status, const char* error_str = nullptr);

test/parallel/test-tls-gc-pending-write.js

@@ -0,0 +1,73 @@
+'use strict';
+// Flags: --expose-gc
+
+// Regression coverage for TLS sockets that become collectable after a queued
+// write. TLSWrap destruction can run from V8 weak callbacks, so destructor-time
+// cleanup must not invoke JS-visible write callbacks.
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('node:assert');
+const fixtures = require('../common/fixtures');
+const { gcUntil } = require('../common/gc');
+const tls = require('node:tls');
+
+const kClientCount = 32;
+const kPayload = Buffer.alloc(512 * 1024);
+
+let finalized = 0;
+let queuedWrites = 0;
+
+const registry = new FinalizationRegistry(() => {
+  finalized++;
+});
+
+const server = tls.createServer({
+  key: fixtures.readKey('agent1-key.pem'),
+  cert: fixtures.readKey('agent1-cert.pem'),
+}, (socket) => {
+  socket.destroy();
+});
+
+function queueWriteAndAbandon(port) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let socket = tls.connect({ port, rejectUnauthorized: false });
+
+    socket.on('error', (err) => {
+      if (!settled) {
+        settled = true;
+        reject(err);
+      }
+    });
+
+    socket.once('secureConnect', () => {
+      socket.write(kPayload);
+      queuedWrites++;
+      registry.register(socket);
+      settled = true;
+      resolve();
+      socket = null;
+    });
+  });
+}
+
+server.listen(0, common.mustCall(async () => {
+  try {
+    const port = server.address().port;
+
+    await Promise.all(
+      Array.from({ length: kClientCount }, () => queueWriteAndAbandon(port)));
+
+    assert.strictEqual(queuedWrites, kClientCount);
+
+    await gcUntil('abandoned TLS client socket', () => finalized > 0, 50, {
+      type: 'major',
+      execution: 'sync',
+    });
+  } finally {
+    server.close();
+  }
+}));