Commit d53c5810abe for nodejs

commit d53c5810abeb325ad2e45869bdd5e35627ee3ba8
Author: Fatih Güzel <fatihguzeldev@gmail.com>
Date:   Sun Nov 22 14:20:06 2026 +0300

    net: validate onread buffers before each read

    an onread buffer can be detached after registration while native code
    still holds its address. validate the current view before each read
    and report an error instead of writing into the former backing store.

    Fixes: https://github.com/nodejs/node/issues/67397
    Signed-off-by: Fatih Güzel <fatihguzeldev@gmail.com>
    PR-URL: https://github.com/nodejs/node/pull/67407
    Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
    Reviewed-By: Paolo Insogna <paolo@cowtech.it>
    Reviewed-By: James M Snell <jasnell@gmail.com>

diff --git a/src/crypto/crypto_tls.cc b/src/crypto/crypto_tls.cc
index e092cb24468..c5cc3db68c0 100644
--- a/src/crypto/crypto_tls.cc
+++ b/src/crypto/crypto_tls.cc
@@ -901,13 +901,17 @@ void TLSWrap::ClearOut() {
   int length = 0;
   int read;

-  // Emits out[0, length). Returns false if JS destroyed the SSL context.
+  // Emits out[0, length). Returns false if reading cannot continue.
   auto emit = [&]() {
     char* current = out;
     while (length > 0) {
       int avail = length;

       uv_buf_t buf = EmitAlloc(avail);
+      if (buf.base == nullptr || buf.len == 0) {
+        EmitRead(UV_ENOBUFS, buf);
+        return false;
+      }
       if (static_cast<int>(buf.len) < avail)
         avail = buf.len;
       memcpy(buf.base, current, avail);
diff --git a/src/stream_base.cc b/src/stream_base.cc
index 629d4613bf0..fb16da9b5a9 100644
--- a/src/stream_base.cc
+++ b/src/stream_base.cc
@@ -19,6 +19,7 @@ namespace node {

 using v8::Array;
 using v8::ArrayBuffer;
+using v8::ArrayBufferView;
 using v8::BackingStore;
 using v8::BackingStoreInitializationMode;
 using v8::ConstructorBehavior;
@@ -163,10 +164,8 @@ int StreamBase::ReadStopJS(const FunctionCallbackInfo<Value>& args) {
 int StreamBase::UseUserBuffer(const FunctionCallbackInfo<Value>& args) {
   CHECK(Buffer::HasInstance(args[0]));

-  uv_buf_t buf = uv_buf_init(Buffer::Data(args[0]), Buffer::Length(args[0]));
-  Local<ArrayBuffer> array_buffer = args[0].As<v8::ArrayBufferView>()->Buffer();
   PushStreamListener(
-      new CustomBufferJSListener(array_buffer->GetBackingStore(), buf));
+      new CustomBufferJSListener(args.This(), args[0].As<ArrayBufferView>()));
   return 0;
 }

@@ -797,9 +796,47 @@ void EmitToJSStreamListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf_) {
   stream->CallJSOnreadMethod(nread, ab, offset);
 }

+CustomBufferJSListener::CustomBufferJSListener(Local<Object> object,
+                                               Local<ArrayBufferView> view) {
+  SetBuffer(object, view);
+}
+
+void CustomBufferJSListener::SetBuffer(Local<Object> object,
+                                       Local<ArrayBufferView> view) {
+  // Keep the view's lifetime tied to the wrapper without a strong global root.
+  object->SetInternalField(StreamBase::kUserBufferField, view);
+  backing_store_ = view->Buffer()->GetBackingStore();
+}

 uv_buf_t CustomBufferJSListener::OnStreamAlloc(size_t suggested_size) {
-  return buffer_;
+  CHECK_NOT_NULL(stream_);
+  StreamBase* stream = static_cast<StreamBase*>(stream_);
+  Environment* env = stream->stream_env();
+  Isolate* isolate = env->isolate();
+  HandleScope handle_scope(isolate);
+
+  Local<ArrayBufferView> view =
+      stream->GetAsyncWrap()
+          ->object()
+          ->GetInternalField(StreamBase::kUserBufferField)
+          .As<Value>()
+          .As<ArrayBufferView>();
+  if (!backing_store_->IsImmutable()) {
+    // SetBuffer() materializes the backing store, so this cannot copy.
+    const auto contents = view->GetContents({});
+    // An attached empty backing store can also have a null data pointer.
+    if (contents.data() != nullptr || (backing_store_->MaxByteLength() == 0 &&
+                                       !view->Buffer()->WasDetached())) {
+      buffer_ = uv_buf_init(reinterpret_cast<char*>(contents.data()),
+                            contents.size());
+      return buffer_;
+    }
+  }
+
+  // Allocation must return a usable buffer. Report the invalid view when the
+  // read completes, without writing into the user's former backing store.
+  using_fallback_buffer_ = true;
+  return env->allocate_managed_buffer(suggested_size);
 }


@@ -811,6 +848,13 @@ void CustomBufferJSListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
   HandleScope handle_scope(env->isolate());
   Context::Scope context_scope(env->context());

+  if (using_fallback_buffer_) {
+    using_fallback_buffer_ = false;
+    env->recycle_managed_buffer(env->release_managed_buffer(buf));
+    stream->CallJSOnreadMethod(UV_EINVAL, Local<ArrayBuffer>());
+    return;
+  }
+
   // In the case that there's an error and buf is null, return immediately.
   // This can happen on unices when POLLHUP is received and UV_EOF is returned
   // or when getting an error while performing a UV_HANDLE_ZERO_READ on Windows.
@@ -827,11 +871,9 @@ void CustomBufferJSListener::OnStreamRead(ssize_t nread, const uv_buf_t& buf) {
                              StreamBase::SKIP_NREAD_CHECKS);
   Local<Value> next_buf_v;
   if (ret.ToLocal(&next_buf_v) && !next_buf_v->IsUndefined()) {
-    Local<ArrayBuffer> array_buffer =
-        next_buf_v.As<v8::ArrayBufferView>()->Buffer();
-    buffer_.base = Buffer::Data(next_buf_v);
-    buffer_.len = Buffer::Length(next_buf_v);
-    backing_store_ = array_buffer->GetBackingStore();
+    CHECK(Buffer::HasInstance(next_buf_v));
+    SetBuffer(stream->GetAsyncWrap()->object(),
+              next_buf_v.As<ArrayBufferView>());
   }
 }

diff --git a/src/stream_base.h b/src/stream_base.h
index 146047439b5..a46348c26df 100644
--- a/src/stream_base.h
+++ b/src/stream_base.h
@@ -11,6 +11,7 @@
 #include "v8.h"

 #include <climits>  // INT_MIN
+#include <memory>

 namespace node {

@@ -211,18 +212,17 @@ class CustomBufferJSListener : public ReportWritesToJSStreamListener {
   void OnStreamRead(ssize_t nread, const uv_buf_t& buf) override;
   void OnStreamDestroy() override { delete this; }

-  explicit CustomBufferJSListener(
-      std::shared_ptr<v8::BackingStore> backing_store, uv_buf_t buffer)
-      : backing_store_(std::move(backing_store)), buffer_(buffer) {}
+  CustomBufferJSListener(v8::Local<v8::Object> object,
+                         v8::Local<v8::ArrayBufferView> view);

  private:
-  // Retain the backing store for the lifetime of the listener. The raw address
-  // in `buffer_` is derived from it, so retaining the backing store guarantees
-  // the address does not dangle even if application code later transfers (and
-  // thereby detaches) the buffer, e.g. by enqueuing a view into a byte
-  // `ReadableStream`.
+  void SetBuffer(v8::Local<v8::Object> object,
+                 v8::Local<v8::ArrayBufferView> view);
+
+  // Retain the backing store so the address in buffer_ cannot dangle.
   std::shared_ptr<v8::BackingStore> backing_store_;
-  uv_buf_t buffer_;
+  uv_buf_t buffer_ = uv_buf_init(nullptr, 0);
+  bool using_fallback_buffer_ = false;
 };


@@ -322,6 +322,7 @@ class StreamBase : public StreamResource {
     kSlot = BaseObject::kSlot,
     kStreamBaseField = AsyncWrap::kInternalFieldCount,
     kOnReadFunctionField,
+    kUserBufferField,
     kInternalFieldCount
   };

diff --git a/test/parallel/test-net-onread-buffer-lifetime.js b/test/parallel/test-net-onread-buffer-lifetime.js
new file mode 100644
index 00000000000..a527ef46e3b
--- /dev/null
+++ b/test/parallel/test-net-onread-buffer-lifetime.js
@@ -0,0 +1,179 @@
+// Flags: --js-immutable-arraybuffer
+'use strict';
+
+// Reads must not modify an immutable ArrayBuffer created by transferring a
+// registered onread buffer.
+
+const common = require('../common');
+const assert = require('node:assert');
+const { once } = require('node:events');
+const net = require('node:net');
+const { test } = require('node:test');
+
+for (const mode of ['before first read', 'between reads', 'replacement buffer']) {
+  test(`onread buffer transferred ${mode}`, async (t) => {
+    const backing = new ArrayBuffer(8);
+    new Uint8Array(backing).fill(42);
+    const buffer = mode === 'replacement buffer' ?
+      Buffer.from(backing, 2, 4) : new Uint8Array(backing, 2, 4);
+    const firstBuffer = new Uint8Array(1);
+    const connections = new Set();
+    let peer;
+    let socket;
+    let immutable;
+    let expected;
+    let factoryCalls = 0;
+    let readError;
+    const closed = Promise.withResolvers();
+
+    const server = net.createServer(common.mustCall((connection) => {
+      peer = connection;
+      connection.on('error', (error) => {
+        if (error.code !== 'ECONNRESET') throw error;
+      });
+      if (mode === 'before first read') {
+        connection.end('test');
+      } else {
+        connection.write('a');
+      }
+    }));
+    server.on('connection', (connection) => {
+      connections.add(connection);
+      connection.on('close', () => connections.delete(connection));
+    });
+    t.after(async () => {
+      socket?.destroy();
+      for (const connection of connections) connection.destroy();
+      if (server.listening) {
+        await new Promise((resolve) => server.close(resolve));
+      }
+    });
+    server.listen(0, '127.0.0.1');
+    await once(server, 'listening');
+
+    function transfer() {
+      expected = [...new Uint8Array(backing)];
+      immutable = backing.transferToImmutable();
+      assert.strictEqual(buffer.byteLength, 0);
+      assert.strictEqual(immutable.immutable, true);
+    }
+
+    socket = net.connect({
+      host: '127.0.0.1',
+      port: server.address().port,
+      onread: {
+        buffer: mode === 'replacement buffer' ? common.mustCall(() => {
+          return ++factoryCalls === 1 ? firstBuffer : buffer;
+        }, 2) : buffer,
+        callback: common.mustCall((nread, view) => {
+          try {
+            if (immutable !== undefined) {
+              assert.deepStrictEqual([...new Uint8Array(immutable)], expected);
+              assert.fail('onread called after the buffer was transferred');
+            }
+            assert.strictEqual(nread, 1);
+            assert.strictEqual(view, mode === 'replacement buffer' ? firstBuffer : buffer);
+            assert.strictEqual(view[0], 97);
+            // Transfer after onStreamRead checks for detachment and registers
+            // any replacement buffer returned by the factory.
+            setImmediate(common.mustCall(() => {
+              transfer();
+              peer.end('test');
+            }));
+          } catch (error) {
+            closed.reject(error);
+            return false;
+          }
+        }, mode === 'before first read' ? 0 : 1),
+      },
+    });
+    socket.on('data', common.mustNotCall());
+    socket.on('end', common.mustNotCall());
+    socket.on('error', common.mustCall((error) => {
+      readError = error;
+    }));
+    socket.on('close', common.mustCall(closed.resolve));
+    if (mode === 'before first read') transfer();
+    assert.strictEqual(await closed.promise, true);
+    assert.strictEqual(readError.code, 'EINVAL');
+    assert.strictEqual(readError.syscall, 'read');
+    assert.deepStrictEqual([...new Uint8Array(immutable)], expected);
+  });
+}
+
+test('onread factory replaces buffers transferred after each read', async (t) => {
+  const message = Buffer.from('test');
+  const chunks = [];
+  const closed = Promise.withResolvers();
+  let peer;
+  let socket;
+
+  const server = net.createServer(common.mustCall((connection) => {
+    peer = connection;
+    connection.on('error', (error) => {
+      if (error.code !== 'ECONNRESET') throw error;
+    });
+    connection.end(message);
+  }));
+  t.after(async () => {
+    socket?.destroy();
+    peer?.destroy();
+    if (server.listening) {
+      await new Promise((resolve) => server.close(resolve));
+    }
+  });
+  server.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  socket = net.connect({
+    host: '127.0.0.1',
+    port: server.address().port,
+    onread: {
+      buffer: common.mustCall(() => new Uint8Array(1), message.length + 1),
+      callback: common.mustCall((nread, view) => {
+        try {
+          assert.strictEqual(nread, 1);
+          const immutable = view.buffer.transferToImmutable();
+          assert.strictEqual(view.byteLength, 0);
+          assert.strictEqual(immutable.immutable, true);
+          chunks.push(immutable);
+        } catch (error) {
+          closed.reject(error);
+          return false;
+        }
+      }, message.length),
+    },
+  });
+  socket.on('data', common.mustNotCall());
+  socket.on('end', common.mustCall());
+  socket.on('error', closed.reject);
+  socket.on('close', common.mustCall(closed.resolve));
+  assert.strictEqual(await closed.promise, false);
+  assert.deepStrictEqual(chunks.flatMap((chunk) => [...new Uint8Array(chunk)]), [...message]);
+});
+
+test('empty onread buffer reports ENOBUFS', async (t) => {
+  let socket;
+  const server = net.createServer(common.mustCall((connection) => {
+    connection.on('error', (error) => {
+      if (error.code !== 'ECONNRESET') throw error;
+    });
+    connection.end('test');
+  }));
+  t.after(async () => {
+    socket?.destroy();
+    await new Promise((resolve) => server.close(resolve));
+  });
+  server.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  socket = net.connect({
+    host: '127.0.0.1',
+    port: server.address().port,
+    onread: { buffer: new Uint8Array(0), callback: common.mustNotCall() },
+  });
+  await assert.rejects(once(socket, 'close'), {
+    code: 'ENOBUFS',
+    syscall: 'read',
+  });
+});
diff --git a/test/parallel/test-tls-onread-buffer-lifetime.js b/test/parallel/test-tls-onread-buffer-lifetime.js
new file mode 100644
index 00000000000..a04c4fd0df5
--- /dev/null
+++ b/test/parallel/test-tls-onread-buffer-lifetime.js
@@ -0,0 +1,141 @@
+// Flags: --js-immutable-arraybuffer
+'use strict';
+
+// TLS reads must not modify an immutable ArrayBuffer created by transferring a
+// registered onread buffer.
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const fixtures = require('../common/fixtures');
+const assert = require('node:assert');
+const { once } = require('node:events');
+const { test } = require('node:test');
+const tls = require('node:tls');
+
+const options = {
+  key: fixtures.readKey('agent2-key.pem'),
+  cert: fixtures.readKey('agent2-cert.pem'),
+};
+
+for (const mode of ['before first read', 'between reads', 'replacement buffer']) {
+  test(`tls onread buffer transferred ${mode}`, async (t) => {
+    const backing = new ArrayBuffer(8);
+    new Uint8Array(backing).fill(42);
+    const buffer = mode === 'replacement buffer' ?
+      Buffer.from(backing, 2, 4) : new Uint8Array(backing, 2, 4);
+    const firstBuffer = new Uint8Array(1);
+    const connections = new Set();
+    let peer;
+    let socket;
+    let immutable;
+    let expected;
+    let factoryCalls = 0;
+    let readError;
+    const closed = Promise.withResolvers();
+
+    const server = tls.createServer(options, common.mustCall((connection) => {
+      peer = connection;
+      connections.add(connection);
+      connection.on('close', () => connections.delete(connection));
+      connection.on('error', (error) => {
+        if (error.code !== 'ECONNRESET') throw error;
+      });
+      if (mode === 'before first read') {
+        connection.end('test');
+      } else {
+        connection.write('a');
+      }
+    }));
+    server.on('connection', (connection) => {
+      connections.add(connection);
+      connection.on('close', () => connections.delete(connection));
+    });
+    t.after(async () => {
+      socket?.destroy();
+      for (const connection of connections) connection.destroy();
+      if (server.listening) {
+        await new Promise((resolve) => server.close(resolve));
+      }
+    });
+    server.listen(0, '127.0.0.1');
+    await once(server, 'listening');
+
+    function transfer() {
+      expected = [...new Uint8Array(backing)];
+      immutable = backing.transferToImmutable();
+      assert.strictEqual(buffer.byteLength, 0);
+      assert.strictEqual(immutable.immutable, true);
+    }
+
+    socket = tls.connect({
+      host: '127.0.0.1',
+      port: server.address().port,
+      rejectUnauthorized: false,
+      onread: {
+        buffer: mode === 'replacement buffer' ? common.mustCall(() => {
+          return ++factoryCalls === 1 ? firstBuffer : buffer;
+        }, 2) : buffer,
+        callback: common.mustCall((nread, view) => {
+          try {
+            if (immutable !== undefined) {
+              assert.deepStrictEqual([...new Uint8Array(immutable)], expected);
+              assert.fail('onread called after the buffer was transferred');
+            }
+            assert.strictEqual(nread, 1);
+            assert.strictEqual(view, mode === 'replacement buffer' ? firstBuffer : buffer);
+            assert.strictEqual(view[0], 97);
+            // Transfer after onStreamRead checks for detachment and registers
+            // any replacement buffer returned by the factory.
+            setImmediate(common.mustCall(() => {
+              transfer();
+              peer.end('test');
+            }));
+          } catch (error) {
+            closed.reject(error);
+            return false;
+          }
+        }, mode === 'before first read' ? 0 : 1),
+      },
+    });
+    socket.on('data', common.mustNotCall());
+    socket.on('end', common.mustNotCall());
+    socket.on('error', common.mustCall((error) => {
+      readError = error;
+    }));
+    socket.on('close', common.mustCall(closed.resolve));
+    if (mode === 'before first read') transfer();
+    assert.strictEqual(await closed.promise, true);
+    assert.strictEqual(readError.code, 'EINVAL');
+    assert.strictEqual(readError.syscall, 'read');
+    assert.deepStrictEqual([...new Uint8Array(immutable)], expected);
+  });
+}
+
+test('empty TLS onread buffer reports ENOBUFS', async (t) => {
+  let socket;
+  const server = tls.createServer(options, common.mustCall((connection) => {
+    connection.on('error', (error) => {
+      if (error.code !== 'ECONNRESET') throw error;
+    });
+    connection.end('test');
+  }));
+  t.after(async () => {
+    socket?.destroy();
+    await new Promise((resolve) => server.close(resolve));
+  });
+  server.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+
+  socket = tls.connect({
+    host: '127.0.0.1',
+    port: server.address().port,
+    rejectUnauthorized: false,
+    onread: { buffer: new Uint8Array(0), callback: common.mustNotCall() },
+  });
+  await assert.rejects(once(socket, 'close'), {
+    code: 'ENOBUFS',
+    syscall: 'read',
+  });
+});