Commit eb86d28a426 for nodejs
commit eb86d28a4261b92ea09b9d0c4014ca0f5d488723
Author: Paolo Insogna <paolo@cowtech.it>
Date: Sun Nov 22 12:56:58 2026 +0100
tls: fix newSession after destroy and OCSP cert
The callback of the `newSession` event only checked that the handle was
still set. If a TLS error destroyed the socket while the callback was
pending, calling it afterwards still completed the handshake and
emitted `'secure'` and `'secureConnection'` on the destroyed socket.
Return early from it if the socket is already destroyed.
The callbacks of `OCSPRequest`, `SNICallback` and `resumeSession` do not
need the same check: the handshake does not read while they are
pending, so a TLS error cannot destroy the socket in the meantime, and
if the socket is closed some other way the existing `_handle` checks
already cover it.
Also, when the `SNICallback` returns a context that has no certificate,
for example one that only provides CAs, the handshake uses the
certificate of the server. The `OCSPRequest` event was still emitted
with the certificate and the issuer of that context, which are both
`null`. Use the context of the server in that case, so that the event
reports the certificate that is actually in use.
Assisted-By: OpenAI GPT-5.6 Sol <openai/gpt-5.6-sol>
Signed-off-by: Paolo Insogna <paolo@cowtech.it>
PR-URL: https://github.com/nodejs/node/pull/67650
Reviewed-By: Ethan Arrowood <ethan@arrowood.dev>
Reviewed-By: Matteo Collina <matteo.collina@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 9444652c66d..cb55387f9b7 100644
--- a/lib/internal/tls/wrap.js
+++ b/lib/internal/tls/wrap.js
@@ -406,6 +406,12 @@ function requestOCSP(socket, info) {
let ctx = socket._handle.sni_context;
+ // A context selected by the SNI callback may not have a certificate, for
+ // example when it only provides the CAs. The handshake then uses the
+ // default certificate, so report that one.
+ if (ctx && !(ctx.context ?? ctx).getCertificate())
+ ctx = undefined;
+
if (!ctx) {
ctx = socket.server._sharedCreds;
@@ -491,6 +497,9 @@ function onnewsession(sessionId, session) {
return;
once = true;
+ if (owner.destroyed)
+ return;
+
if (owner._handle === null)
return owner.destroy(new ERR_SOCKET_CLOSED());
diff --git a/test/parallel/test-tls-handshake-complete-after-destroy-newsession.js b/test/parallel/test-tls-handshake-complete-after-destroy-newsession.js
new file mode 100644
index 00000000000..51232c4d678
--- /dev/null
+++ b/test/parallel/test-tls-handshake-complete-after-destroy-newsession.js
@@ -0,0 +1,76 @@
+'use strict';
+
+// A socket that failed during the handshake does not complete it when the
+// callback of the `newSession` event is called afterwards.
+
+const common = require('../common');
+if (!common.hasCrypto)
+ common.skip('missing crypto');
+
+const assert = require('assert');
+const net = require('net');
+const tls = require('tls');
+const { constants } = require('crypto');
+const fixtures = require('../common/fixtures');
+
+const key = fixtures.readKey('agent1-key.pem');
+const cert = fixtures.readKey('agent1-cert.pem');
+
+const server = tls.createServer({
+ key,
+ cert,
+ maxVersion: 'TLSv1.2',
+ secureOptions: constants.SSL_OP_NO_TICKET,
+});
+
+// An invalid TLS record is appended to the client chunk that follows the
+// ClientHello, which is expected to carry ClientKeyExchange, ChangeCipherSpec
+// and Finished in a single `data` event. The server then fails with a TLS
+// error after it has requested the callback of the `newSession` event.
+const invalidRecord = Buffer.from([0x17, 0x03, 0x03, 0x00, 0x05, 1, 2, 3, 4, 5]);
+const proxy = net.createServer(common.mustCall((downstream) => {
+ const upstream = net.connect(server.address().port);
+ let first = true;
+ let injected = false;
+ downstream.on('data', (chunk) => {
+ // Handshake records have the content type 0x16.
+ if (!first && !injected && chunk[0] === 0x16) {
+ injected = true;
+ chunk = Buffer.concat([chunk, invalidRecord]);
+ }
+ first = false;
+ upstream.write(chunk);
+ });
+ upstream.pipe(downstream);
+ downstream.on('error', () => {});
+ upstream.on('error', () => {});
+ downstream.on('close', () => upstream.destroy());
+ upstream.on('close', () => downstream.destroy());
+}));
+
+let done;
+server.on('secureConnection', common.mustNotCall());
+server.on('newSession', common.mustCall((id, data, callback) => {
+ done = callback;
+}));
+server.on('tlsClientError', common.mustCall((err, socket) => {
+ assert.ok(socket.destroyed);
+ socket.on('secure', common.mustNotCall());
+ done();
+ setImmediate(common.mustCall(() => {
+ proxy.close();
+ server.close();
+ }));
+}));
+
+server.listen(0, common.mustCall(() => {
+ proxy.listen(0, common.mustCall(() => {
+ const client = tls.connect({
+ port: proxy.address().port,
+ maxVersion: 'TLSv1.2',
+ secureOptions: constants.SSL_OP_NO_TICKET,
+ rejectUnauthorized: false,
+ });
+ client.on('error', () => {});
+ }));
+}));
diff --git a/test/parallel/test-tls-ocsp-request-sni-without-certificate.js b/test/parallel/test-tls-ocsp-request-sni-without-certificate.js
new file mode 100644
index 00000000000..e1e1f50a87e
--- /dev/null
+++ b/test/parallel/test-tls-ocsp-request-sni-without-certificate.js
@@ -0,0 +1,46 @@
+'use strict';
+
+// The OCSPRequest event reports the certificate that the connection uses,
+// also when the SNI context only carries a CA.
+
+const common = require('../common');
+if (!common.hasCrypto)
+ common.skip('missing crypto');
+
+const assert = require('assert');
+const crypto = require('crypto');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+const key = fixtures.readKey('agent1-key.pem');
+const cert = fixtures.readKey('agent1-cert.pem');
+const ca = fixtures.readKey('ca1-cert.pem');
+
+const server = tls.createServer({
+ key,
+ cert,
+ SNICallback: common.mustCall((servername, callback) => {
+ callback(null, tls.createSecureContext({ ca }));
+ }),
+});
+
+server.on('OCSPRequest', common.mustCall((certificate, issuer, callback) => {
+ assert.deepStrictEqual(
+ certificate,
+ new crypto.X509Certificate(cert).raw);
+ callback(null, null);
+}));
+
+server.listen(0, common.mustCall(() => {
+ const client = tls.connect({
+ port: server.address().port,
+ servername: 'sni.example.com',
+ requestOCSP: true,
+ rejectUnauthorized: false,
+ });
+
+ client.on('OCSPResponse', common.mustCall(() => {
+ client.destroy();
+ server.close();
+ }));
+}));