Commit 2feb5c8aad7 for nodejs

commit 2feb5c8aad782fcfd65c51a17cbdc0214a8190ec
Author: Matteo Collina <hello@matteocollina.com>
Date:   Mon Nov 16 01:31:32 2026 +0100

    tls: normalize session buffer views

    Client sessions can be supplied as ArrayBuffer views, but session state
    checks only recognize Buffers. Normalize views to Buffers before
    applying those checks, preserving their byte offset and length.

    This hardens session reuse handling and keeps tagged sessions reusable
    when stored as typed arrays.

    Assisted-by: Codex
    Signed-off-by: Matteo Collina <hello@matteocollina.com>
    PR-URL: https://github.com/nodejs/node/pull/67251
    Reviewed-By: Robert Nagy <ronagy@icloud.com>
    Reviewed-By: James M Snell <jasnell@gmail.com>
    Reviewed-By: Filip Skokan <panva.ip@gmail.com>
    Reviewed-By: Gürgün Dayıoğlu <hey@gurgun.day>

diff --git a/lib/internal/tls/wrap.js b/lib/internal/tls/wrap.js
index 4e295d9f8ca..2d5886ea801 100644
--- a/lib/internal/tls/wrap.js
+++ b/lib/internal/tls/wrap.js
@@ -175,6 +175,9 @@ function getSessionForReuse(session, options) {
   if (options?.isServer)
     return session;

+  if (!Buffer.isBuffer(session) && isArrayBufferView(session))
+    session = Buffer.from(session.buffer, session.byteOffset, session.byteLength);
+
   const wrappedSession = unwrapSessionState(session);
   if (wrappedSession !== undefined) {
     const servername = getSessionServerIdentity(options);
diff --git a/test/parallel/test-tls-session-arraybuffer-view.js b/test/parallel/test-tls-session-arraybuffer-view.js
new file mode 100644
index 00000000000..2853c7a2239
--- /dev/null
+++ b/test/parallel/test-tls-session-arraybuffer-view.js
@@ -0,0 +1,127 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const { once } = require('events');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+async function connect(options, useSetter = false, captureSession = false) {
+  const { session, ...connectOptions } = options;
+  const socket = tls.connect(useSetter ? connectOptions : options);
+  const closed = new Promise((resolve) => {
+    socket.once('close', common.mustCall(resolve));
+  });
+  if (useSetter)
+    socket.setSession(session);
+  const sessionPromise = captureSession ? once(socket, 'session') : undefined;
+  socket.resume();
+
+  try {
+    await once(socket, 'secureConnect');
+    const result = {
+      reused: socket.isSessionReused(),
+      authorized: socket.authorized,
+      session: captureSession ? (await sessionPromise)[0] : undefined,
+    };
+    await closed;
+    return result;
+  } finally {
+    socket.destroy();
+  }
+}
+
+function offsetView(session, View) {
+  // Keep unrelated bytes on both sides to check that only the view is used.
+  const buffer = new ArrayBuffer(session.length + 16);
+  new Uint8Array(buffer).fill(0xff);
+  new Uint8Array(buffer, 8, session.length).set(session);
+  return new View(buffer, 8, session.length);
+}
+
+async function testVersion(version) {
+  const server = tls.createServer({
+    key: fixtures.readKey('agent1-key.pem'),
+    cert: fixtures.readKey('agent1-cert.pem'),
+    minVersion: version,
+    maxVersion: version,
+  }, (socket) => socket.end('ok'));
+  server.listen(0);
+  await once(server, 'listening');
+
+  try {
+    const options = {
+      port: server.address().port,
+      host: '127.0.0.1',
+      servername: 'agent1',
+      ca: fixtures.readKey('ca1-cert.pem'),
+      minVersion: version,
+      maxVersion: version,
+    };
+    const first = await connect(options, false, true);
+    assert.strictEqual(first.authorized, true);
+    assert.strictEqual(first.reused, false);
+
+    const tagged = first.session;
+    const prefix = Buffer.from('\0nodejs:tls:session:1\0');
+    assert.deepStrictEqual(tagged.subarray(0, prefix.length), prefix);
+    const raw = tagged.subarray(
+      prefix.length + 2 + tagged.readUInt16BE(prefix.length));
+
+    const conversions = [
+      (session) => session,
+      (session) => session.toString('latin1'),
+      (session) => new Uint8Array(session),
+      (session) => new Uint8ClampedArray(session),
+      (session) => new Int8Array(session),
+      (session) => offsetView(session, Uint8Array),
+      (session) => offsetView(session, DataView),
+    ];
+
+    for (const convert of conversions) {
+      for (const useSetter of [false, true]) {
+        // Untagged sessions must cause a full handshake on verified clients.
+        const fresh = await connect({
+          ...options,
+          session: convert(raw),
+        }, useSetter);
+        assert.strictEqual(fresh.authorized, true);
+        assert.strictEqual(fresh.reused, false);
+
+        // A tagged session still resumes for its authenticated host.
+        const resumed = await connect({
+          ...options,
+          session: convert(tagged),
+        }, useSetter);
+        assert.strictEqual(resumed.authorized, true);
+        assert.strictEqual(resumed.reused, true);
+
+        for (const session of [raw, tagged]) {
+          await assert.rejects(connect({
+            ...options,
+            servername: 'bank.example',
+            session: convert(session),
+          }, useSetter), { code: 'ERR_TLS_CERT_ALTNAME_INVALID' });
+        }
+
+        // Raw sessions remain usable when verification is explicitly disabled.
+        const unverified = await connect({
+          ...options,
+          session: convert(raw),
+          rejectUnauthorized: false,
+        }, useSetter);
+        assert.strictEqual(unverified.reused, true);
+      }
+    }
+  } finally {
+    server.close();
+    await once(server, 'close');
+  }
+}
+
+(async () => {
+  await testVersion('TLSv1.2');
+  await testVersion('TLSv1.3');
+})().then(common.mustCall());