https: bind identity checks to session reuse

PR-URL: nodejs-private/node-private#904
Refs: https://hackerone.com/reports/3811980
CVE-ID: CVE-2026-58040

Author: mcollina

doc/api/https.md

@@ -100,6 +100,10 @@ changes:
 
  See [`Session Resumption`][] for information about TLS session reuse.
 
+Requests that specify a custom `checkServerIdentity` option are not eligible
+for connection reuse or TLS session reuse by an `https.Agent`, unless the
+`checkServerIdentity` option was specified when constructing the Agent.
+
 #### Event: `'keylog'`
 
 <!-- YAML

lib/https.js

@@ -35,6 +35,7 @@ const {
  ObjectSetPrototypeOf,
  ReflectApply,
  ReflectConstruct,
+ Symbol,
  SymbolAsyncDispose,
 }=primordials;
 
@@ -48,6 +49,8 @@ const { ERR_PROXY_TUNNEL } = require('internal/errors').codes;
 assertCrypto();
 
 consttls=require('tls');
+constkPerRequestCheckServerIdentity=Symbol('per-request checkServerIdentity');
+letperRequestCheckServerIdentityIndex=0;
 const{
  kProxyConfig,
  checkShouldUseProxy,
@@ -281,6 +284,8 @@ function establishTunnel(agent, socket, options, tunnelConfig, afterSocket) {
 tunneldSocket.removeListener('error',onTLSHandshakeError);
 afterSocket(null,tunneldSocket);
 });
+if(requestOptions[kPerRequestCheckServerIdentity])
+tunneldSocket[kPerRequestCheckServerIdentity]=true;
 tunneldSocket.on('free',()=>{
 debug('Propagate free event from tunneled socket to tunnel socket');
 socket.emit('free');
@@ -349,7 +354,9 @@ function createConnection(...args) {
 
 debug('createConnection',options);
 
-if(options._agentKey){
+constreuseSession=options._agentKey&&
+!options[kPerRequestCheckServerIdentity];
+if(reuseSession){
 constsession=this._getSession(options._agentKey);
 if(session){
 debug('reuse session for %j',options._agentKey);
@@ -416,7 +423,10 @@ function createConnection(...args) {
 socket[kWaitForProxyTunnel]=true;
 }
 
-if(options._agentKey){
+if(options[kPerRequestCheckServerIdentity])
+socket[kPerRequestCheckServerIdentity]=true;
+
+if(reuseSession){
 // Cache new session for reuse
 socket.on('session',(session)=>{
 this._cacheSession(options._agentKey,session);
@@ -471,6 +481,12 @@ function Agent(options) {
 ObjectSetPrototypeOf(Agent.prototype,HttpAgent.prototype);
 ObjectSetPrototypeOf(Agent,HttpAgent);
 Agent.prototype.createConnection=createConnection;
+Agent.prototype.keepSocketAlive=functionkeepSocketAlive(socket){
+if(socket[kPerRequestCheckServerIdentity])
+returnfalse;
+
+returnFunctionPrototypeCall(HttpAgent.prototype.keepSocketAlive,this,socket);
+};
 
 functiongetPfxAgentKey(pfx,passphrase){
 if(!ArrayIsArray(pfx))
@@ -579,6 +595,9 @@ Agent.prototype.getName = function getName(options = kEmptyObject) {
 if(options.privateKeyEngine)
 name+=options.privateKeyEngine;
 
+if(options[kPerRequestCheckServerIdentity])
+name+=`:${options[kPerRequestCheckServerIdentity]}`;
+
 returnname;
 };
 
@@ -619,6 +638,20 @@ Agent.prototype._evictSession = function _evictSession(key) {
 
 constglobalAgent=getGlobalAgent(getOptionValue('--use-env-proxy') ? process.env : undefined,Agent);
 
+functionhasAgentCheckServerIdentity(options){
+let{ agent }=options;
+if(agent===false)
+returnfalse;
+
+if(agent===null||agent===undefined){
+if(typeofoptions.createConnection==='function')
+returnfalse;
+agent=module.exports.globalAgent;
+}
+
+returnagent?.options?.checkServerIdentity!==undefined;
+}
+
 /**
  * Makes a request to a secure web server.
  * @param {...any} args
@@ -638,6 +671,13 @@ function request(...args) {
 ObjectAssign(options,ArrayPrototypeShift(args));
 }
 
+if(options.checkServerIdentity!==undefined&&
+options.checkServerIdentity!==tls.checkServerIdentity&&
+!hasAgentCheckServerIdentity(options)){
+options[kPerRequestCheckServerIdentity]=
+++perRequestCheckServerIdentityIndex;
+}
+
 options._defaultAgent=module.exports.globalAgent;
 ArrayPrototypeUnshift(args,options);
 

test/parallel/test-https-agent-checkserveridentity-reuse.js

@@ -0,0 +1,113 @@
+'use strict';
+constcommon=require('../common');
+if(!common.hasCrypto)
+common.skip('missing crypto');
+
+constassert=require('assert');
+constfixtures=require('../common/fixtures');
+consthttps=require('https');
+const{ once }=require('events');
+
+constkey=fixtures.readKey('agent1-key.pem');
+constcert=fixtures.readKey('agent1-cert.pem');
+constca=fixtures.readKey('ca1-cert.pem');
+constexpectedError=/rejectedbycallback/;
+
+functionrequest(options){
+returnnewPromise((resolve,reject)=>{
+constreq=https.get({
+host: '127.0.0.1',
+servername: 'agent1',
+ca: [ca],
+ ...options,
+},(res)=>{
+constsocket=res.socket;
+res.resume();
+res.on('end',()=>resolve({
+ socket,
+reusedSocket: req.reusedSocket,
+}));
+});
+
+req.on('error',reject);
+});
+}
+
+constserver=https.createServer({
+ key,
+ cert,
+minVersion: 'TLSv1.2',
+maxVersion: 'TLSv1.2',
+},(req,res)=>{
+res.end('ok');
+});
+
+(asyncfunction(){
+server.listen(0);
+awaitonce(server,'listening');
+
+constport=server.address().port;
+letacceptCalls=0;
+letrejectCalls=0;
+constacceptingCheck=()=>{
+acceptCalls++;
+};
+constrejectingCheck=()=>{
+rejectCalls++;
+returnnewError('rejected by callback');
+};
+
+constsessionAgent=newhttps.Agent();
+constkeepAliveAgent=newhttps.Agent({
+keepAlive: true,
+maxCachedSessions: 0,
+});
+constagentLevelAgent=newhttps.Agent({
+checkServerIdentity: acceptingCheck,
+});
+
+try{
+awaitrequest({
+ port,
+agent: sessionAgent,
+checkServerIdentity: acceptingCheck,
+});
+assert.deepStrictEqual(sessionAgent._sessionCache.map,{});
+awaitassert.rejects(request({
+ port,
+agent: sessionAgent,
+checkServerIdentity: rejectingCheck,
+}),expectedError);
+
+awaitrequest({
+ port,
+agent: keepAliveAgent,
+checkServerIdentity: acceptingCheck,
+});
+awaitassert.rejects(request({
+ port,
+agent: keepAliveAgent,
+checkServerIdentity: rejectingCheck,
+}),expectedError);
+
+constfirst=awaitrequest({
+ port,
+agent: agentLevelAgent,
+});
+assert.strictEqual(first.socket.isSessionReused(),false);
+constsecond=awaitrequest({
+ port,
+agent: agentLevelAgent,
+});
+assert.strictEqual(second.socket.isSessionReused(),true);
+
+assert.strictEqual(acceptCalls,3);
+assert.strictEqual(rejectCalls,2);
+}finally{
+sessionAgent.destroy();
+keepAliveAgent.destroy();
+agentLevelAgent.destroy();
+server.close();
+awaitonce(server,'close');
+}
+})().then(common.mustCall());