https: distinguish PFX object-array agent keys

Signed-off-by: RafaelGSS <rafael.nunu@hotmail.com>
PR-URL: nodejs-private/node-private#930
Refs: https://hackerone.com/reports/3816840
CVE-ID: CVE-2026-56850

Author: RafaelGSS

lib/https.js

@@ -22,6 +22,7 @@
 'use strict';
 
 const {
+  ArrayIsArray,
   ArrayPrototypeIndexOf,
   ArrayPrototypePush,
   ArrayPrototypeShift,
@@ -471,6 +472,20 @@ ObjectSetPrototypeOf(Agent.prototype, HttpAgent.prototype);
 ObjectSetPrototypeOf(Agent, HttpAgent);
 Agent.prototype.createConnection = createConnection;
 
+function getPfxAgentKey(pfx, passphrase) {
+  if (!ArrayIsArray(pfx))
+    return pfx;
+
+  let key = '';
+  for (let i = 0; i < pfx.length; i++) {
+    const value = pfx[i];
+    const raw = value?.buf || value;
+    const pass = value?.passphrase || passphrase;
+    key += `:${raw}:${pass}`;
+  }
+  return key;
+}
+
 /**
  * Gets a unique name for a set of options.
  * @param {{
@@ -506,7 +521,7 @@ Agent.prototype.getName = function getName(options = kEmptyObject) {
 
   name += ':';
   if (options.pfx)
-    name += options.pfx;
+    name += getPfxAgentKey(options.pfx, options.passphrase);
 
   name += ':';
   if (options.rejectUnauthorized !== undefined)

test/parallel/test-https-agent-getname.js

@@ -6,6 +6,7 @@ if (!common.hasCrypto)
 
 const assert = require('assert');
 const https = require('https');
+const fixtures = require('../common/fixtures');
 
 const agent = new https.Agent();
 
@@ -52,3 +53,46 @@ assert.strictEqual(
     '::secureProtocol:c,r,l:false:ecdhCurve:dhparam:0:sessionIdContext:' +
     '"sigalgs":privateKeyIdentifier:privateKeyEngine'
 );
+
+{
+  const baseOptions = {
+    host: '0.0.0.0',
+    port: 443,
+  };
+
+  const agent1 = fixtures.readKey('agent1.pfx');
+  const agent6 = fixtures.readKey('agent6.pfx');
+
+  assert.notStrictEqual(
+    agent.getName({
+      ...baseOptions,
+      pfx: [{ buf: agent1, passphrase: 'sample' }],
+    }),
+    agent.getName({
+      ...baseOptions,
+      pfx: [{ buf: agent6, passphrase: 'sample' }],
+    })
+  );
+
+  assert.notStrictEqual(
+    agent.getName({
+      ...baseOptions,
+      pfx: [{ buf: agent1, passphrase: 'sample' }],
+    }),
+    agent.getName({
+      ...baseOptions,
+      pfx: [{ buf: agent1, passphrase: 'different' }],
+    })
+  );
+
+  assert.notStrictEqual(
+    agent.getName({
+      ...baseOptions,
+      pfx: [{ __proto__: { buf: agent1, passphrase: 'sample' } }],
+    }),
+    agent.getName({
+      ...baseOptions,
+      pfx: [{ __proto__: { buf: agent6, passphrase: 'sample' } }],
+    })
+  );
+}

test/parallel/test-https-agent-pfx-object-array-reuse.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const https = require('https');
+const fixtures = require('../common/fixtures');
+
+const server = https.createServer({
+  key: fixtures.readKey('agent2-key.pem'),
+  cert: fixtures.readKey('agent2-cert.pem'),
+  requestCert: true,
+  rejectUnauthorized: false,
+}, common.mustCall((req, res) => {
+  res.end(req.socket.getPeerCertificate().subject.CN);
+}, 2));
+
+server.listen(0, common.mustCall(async () => {
+  const agent = new https.Agent({ keepAlive: true, maxSockets: 1 });
+  const port = server.address().port;
+
+  const first = await request({
+    agent,
+    port,
+    pfx: [{ buf: fixtures.readKey('agent1.pfx'), passphrase: 'sample' }],
+  });
+  assert.strictEqual(first.body, 'agent1');
+  assert.strictEqual(first.reusedSocket, false);
+
+  const second = await request({
+    agent,
+    port,
+    pfx: [{ buf: fixtures.readKey('agent10.pfx'), passphrase: 'sample' }],
+  });
+  assert.strictEqual(second.body, 'agent10.example.com');
+  assert.strictEqual(second.reusedSocket, false);
+
+  agent.destroy();
+  server.close();
+}));
+
+function request(options) {
+  return new Promise((resolve, reject) => {
+    const req = https.get({
+      ...options,
+      rejectUnauthorized: false,
+    }, common.mustCall((res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => body += chunk);
+      res.on('end', common.mustCall(() => {
+        resolve({ body, reusedSocket: req.reusedSocket });
+      }));
+    }));
+    req.on('error', reject);
+  });
+}