diff --git a/doc/api/deprecations.md b/doc/api/deprecations.md
index b31bfffc11bc..669d1d276130 100644
--- a/doc/api/deprecations.md
+++ b/doc/api/deprecations.md
@@ -4861,6 +4861,55 @@ Type: Documentation-only
`node:util`'s `util.TextDecoder` and `util.TextEncoder` are deprecated.
Use global `TextDecoder` and `TextEncoder` instead.
+### DEP0213: TLS renegotiation
+
+
+
+Type: Documentation-only (supports [`--pending-deprecation`][])
+
+TLS renegotiation is deprecated and will be disabled by default in future.
+This functionality will be largely removed in a subsequent release. Only a
+client accepting server-initiated renegotiation requests is expected to
+remain supported, and on an opt-in basis for legacy server compatibility.
+
+This only affects TLS 1.2. TLS 1.3 removed renegotiation from the standard,
+and so this has never been supported.
+
+Avoid using TLS renegotiation. A server that needs a client certificate should
+request it in the initial configuration, with the `requestCert` option of
+[`tls.createServer()`][]. A client that needs to change the configuration of
+an existing connection should create a new connection.
+
+This affects multiple TLS APIs:
+
+* Node.js TLS clients needing to initiate renegotiation locally, or accept
+ renegotiation requested by the server, should opt in by setting the
+ `allowRenegotiation` option of [`tls.connect()`][].
+* Node.js TLS servers needing to initiate renegotiation locally, or accept
+ renegotiation requested by the client, should opt in by setting the
+ `allowRenegotiation` option of [`tls.createServer()`][].
+ If renegotiation by clients is removed in future, setting this option to
+ `true` on a server will throw an error.
+* In either case, initiating renegotiation ([`tlsSocket.renegotiate()`][])
+ should be avoided by using alternative mechanisms. When renegotiation is
+ disabled by default this method will only work on connections created
+ with the `allowRenegotiation` option, and will throw an error if not.
+ If initiating renegotiation is removed in future, this method will throw
+ an error.
+* Using [`tlsSocket.disableRenegotiation()`][] to disable renegotiation will
+ no longer be necessary when it is disabled by default. This will become a
+ no-op in most configurations.
+* The `tls.CLIENT_RENEG_LIMIT` and `tls.CLIENT_RENEG_WINDOW` properties which
+ limit renegotiation will become unused in default configurations.
+ If renegotiation by clients is removed in future these are likely to be
+ removed.
+
[DEP0142]: #dep0142-repl_builtinlibs
[DEP0156]: #dep0156-aborted-property-and-abort-aborted-event-in-http
[NIST SP 800-38D]: https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38d.pdf
@@ -4985,8 +5034,11 @@ Use global `TextDecoder` and `TextEncoder` instead.
[`tls.SecureContext`]: tls.md#tlscreatesecurecontextoptions
[`tls.TLSSocket`]: tls.md#class-tlstlssocket
[`tls.checkServerIdentity()`]: tls.md#tlscheckserveridentityhostname-cert
+[`tls.connect()`]: tls.md#tlsconnectoptions-callback
[`tls.createSecureContext()`]: tls.md#tlscreatesecurecontextoptions
[`tls.createServer()`]: tls.md#tlscreateserveroptions-secureconnectionlistener
+[`tlsSocket.disableRenegotiation()`]: tls.md#tlssocketdisablerenegotiation
+[`tlsSocket.renegotiate()`]: tls.md#tlssocketrenegotiateoptions-callback
[`url.format()`]: url.md#urlformaturlobject
[`url.format(urlString)`]: url.md#urlformaturlstring
[`url.parse()`]: url.md#urlparseurlstring-parsequerystring-slashesdenotehost
diff --git a/doc/api/errors.md b/doc/api/errors.md
index e6ab55bab058..80bcadab826a 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -3358,8 +3358,8 @@ disabled.
### `ERR_TLS_RENEGOTIATION_UNSUPPORTED`
-An attempt was made to renegotiate TLS, but the TLS implementation does not
-support caller-initiated renegotiation.
+An attempt was made to renegotiate TLS, or to allow renegotiation on a server,
+but the TLS implementation does not support it.
diff --git a/doc/api/https.md b/doc/api/https.md
index d9de65813733..2d3426778eb8 100644
--- a/doc/api/https.md
+++ b/doc/api/https.md
@@ -474,7 +474,8 @@ Makes a request to a secure web server.
The following additional `options` from [`tls.connect()`][] are also accepted:
`ca`, `cert`, `ciphers`, `crl`, `dhparam`, `ecdhCurve`, `honorCipherOrder`,
`key`, `passphrase`, `pfx`, `rejectUnauthorized`, `secureOptions`,
-`secureProtocol`, `servername`, `sessionIdContext`, `highWaterMark`.
+`secureProtocol`, `servername`, `sessionIdContext`, `highWaterMark`,
+`allowRenegotiation`.
`options` can be an object, a string, or a [`URL`][] object. If `options` is a
string, it is automatically parsed with [`new URL()`][]. If it is a [`URL`][]
diff --git a/doc/api/tls.md b/doc/api/tls.md
index 032aa4764175..08c5e66ef629 100644
--- a/doc/api/tls.md
+++ b/doc/api/tls.md
@@ -235,6 +235,11 @@ understanding of the implications and risks.
TLSv1.3 does not support renegotiation.
+Renegotiation is deprecated (see [DEP0213][]). A future version of Node.js will
+disable it by default, for servers and clients. The `allowRenegotiation` option
+of [`tls.createServer()`][] and [`tls.connect()`][] can be set to `false` to
+disable it now, or to `true` to keep it enabled when that default changes.
+
### Session resumption
Establishing a TLS session can be relatively slow. The process can be sped
@@ -901,6 +906,9 @@ connection is open.
+> Stability: 0 - Deprecated. See [DEP0213][].
+
Disables TLS renegotiation for this `TLSSocket` instance. Once called, attempts
to renegotiate will trigger an `'error'` event on the `TLSSocket`.
+Set `allowRenegotiation: false` when creating the server or connection
+instead. This method has no effect on a connection created that way, where the
+peer's attempts to renegotiate are refused without an error.
+
### `tlsSocket.enableTrace()`
+> Stability: 0 - Deprecated. See [DEP0213][].
+
* `options` {Object}
* `rejectUnauthorized` {boolean} If not `false`, the server certificate is
verified against the list of supplied CAs. An `'error'` event is emitted if
@@ -1622,6 +1641,12 @@ When running as the server, the socket will be destroyed with an error after
For TLSv1.3, renegotiation cannot be initiated, it is not supported by the
protocol.
+If the connection was created with `allowRenegotiation: false`, this method
+returns `false` and `callback` is called with an
+[`ERR_TLS_RENEGOTIATION_DISABLED`][] error. A future version of Node.js will
+disable renegotiation by default, and this method will then only work on
+connections created with `allowRenegotiation: true`.
+
### `tlsSocket.servername`
* `options` {Object}
+ * `allowRenegotiation` {boolean} If `true`, connections to the server may be
+ renegotiated, either when requested by the client or through local calls to
+ [`tlsSocket.renegotiate()`][]. Renegotiation is deprecated (see
+ [DEP0213][]) and future versions will set this default to `false`.
+ Setting this to `true` throws [`ERR_TLS_RENEGOTIATION_UNSUPPORTED`][]
+ where the TLS library does not support renegotiation on servers.
+ **Default:** `true`.
* `ALPNProtocols` {string\[]|Buffer|TypedArray|DataView} An array of strings,
or a single `Buffer`, `TypedArray`, or `DataView` containing the supported
ALPN protocols. Buffers should have the format `[len][name][len][name]...`
@@ -2585,6 +2626,7 @@ added: v0.11.3
[CVE-2021-44531]: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44531
[Chrome's 'modern cryptography' setting]: https://www.chromium.org/Home/chromium-security/education/tls#TOC-Cipher-Suites
+[DEP0213]: deprecations.md#dep0213-tls-renegotiation
[DHE]: https://en.wikipedia.org/wiki/Diffie%E2%80%93Hellman_key_exchange
[ECDHE]: https://en.wikipedia.org/wiki/Elliptic_curve_Diffie%E2%80%93Hellman
[IANA TLS Supported Groups registry]: https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8
@@ -2617,6 +2659,8 @@ added: v0.11.3
[`--use-openssl-ca`]: cli.md#--use-bundled-ca---use-openssl-ca
[`--use-system-ca`]: cli.md#--use-system-ca
[`Duplex`]: stream.md#class-streamduplex
+[`ERR_TLS_RENEGOTIATION_DISABLED`]: errors.md#err_tls_renegotiation_disabled
+[`ERR_TLS_RENEGOTIATION_UNSUPPORTED`]: errors.md#err_tls_renegotiation_unsupported
[`NODE_EXTRA_CA_CERTS`]: cli.md#node_extra_ca_certsfile
[`NODE_OPTIONS`]: cli.md#node_optionsoptions
[`SSL_export_keying_material`]: https://www.openssl.org/docs/man3.0/man3/SSL_export_keying_material.html
@@ -2652,6 +2696,7 @@ added: v0.11.3
[`tls.getCACertificates()`]: #tlsgetcacertificatestype
[`tls.getCiphers()`]: #tlsgetciphers
[`tls.rootCertificates`]: #tlsrootcertificates
+[`tlsSocket.renegotiate()`]: #tlssocketrenegotiateoptions-callback
[`x509.checkHost()`]: crypto.md#x509checkhostname-options
[asn1.js]: https://www.npmjs.com/package/asn1.js
[certificate object]: #certificate-object
diff --git a/lib/https.js b/lib/https.js
index 38623d258a20..649c925daf4f 100644
--- a/lib/https.js
+++ b/lib/https.js
@@ -700,6 +700,10 @@ Agent.prototype.getName = function getName(options = kEmptyObject) {
if (options.session)
name += getTlsOptionKey(options.session);
+ name += ':';
+ if (options.allowRenegotiation !== undefined)
+ name += getTlsOptionKey(options.allowRenegotiation);
+
if (options[kPerRequestCheckServerIdentity])
name += `:${options[kPerRequestCheckServerIdentity]}`;
diff --git a/lib/internal/tls/wrap.js b/lib/internal/tls/wrap.js
index 2d5886ea8010..96e48210c14b 100644
--- a/lib/internal/tls/wrap.js
+++ b/lib/internal/tls/wrap.js
@@ -34,6 +34,8 @@ const {
const {
assertCrypto,
+ getDeprecationWarningEmitter,
+ isPendingDeprecation,
kEmptyObject,
} = require('internal/util');
@@ -101,10 +103,20 @@ const {
const {
InternalX509Certificate,
} = require('internal/crypto/x509');
+const emitRenegotiationDeprecation = getDeprecationWarningEmitter(
+ 'DEP0213',
+ 'TLS renegotiation is deprecated and will be disabled by default. Only ' +
+ "clients setting allowRenegotiation to accept a server's request will " +
+ 'remain supported.',
+ undefined,
+ false,
+ isPendingDeprecation,
+);
const traceTls = getOptionValue('--trace-tls');
const tlsKeylog = getOptionValue('--tls-keylog');
const { appendFile } = require('fs');
const kConnectOptions = Symbol('connect-options');
+const kAllowRenegotiation = Symbol('allowRenegotiation');
const kDisableRenegotiation = Symbol('disable-renegotiation');
const kErrorEmitted = Symbol('error-emitted');
const kHandshakeTimeout = Symbol('handshake-timeout');
@@ -234,6 +246,15 @@ function onhandshakestart(now) {
owner._emitTLSError(new ERR_TLS_RENEGOTIATION_DISABLED());
}
+function validateAllowRenegotiation(allowRenegotiation, isServer) {
+ if (allowRenegotiation === undefined)
+ return;
+ validateBoolean(allowRenegotiation, 'options.allowRenegotiation');
+ // BoringSSL servers always refuse renegotiation.
+ if (allowRenegotiation && isServer && isBoringSSL)
+ throw new ERR_TLS_RENEGOTIATION_UNSUPPORTED();
+}
+
function onhandshakedone() {
debug('server onhandshakedone');
@@ -655,6 +676,9 @@ function TLSSocket(socket, opts) {
if (tlsOptions.ALPNProtocols)
tls.convertALPNProtocols(tlsOptions.ALPNProtocols, tlsOptions);
+ validateAllowRenegotiation(tlsOptions.allowRenegotiation,
+ tlsOptions.isServer);
+
this._tlsOptions = tlsOptions;
this._secureEstablished = false;
this._securePending = false;
@@ -977,6 +1001,9 @@ TLSSocket.prototype._init = function(socket, wrap) {
if (requestCert || rejectUnauthorized)
ssl.setVerifyMode(requestCert, rejectUnauthorized);
+ if (options.allowRenegotiation === false)
+ ssl.disableRenegotiation();
+
// Only call .onkeylog if there is a keylog listener.
ssl.onkeylog = onkeylog;
@@ -1114,6 +1141,8 @@ TLSSocket.prototype.renegotiate = function(options, callback) {
validateFunction(callback, 'callback');
}
+ emitRenegotiationDeprecation();
+
debug('%s renegotiate()',
this._tlsOptions.isServer ? 'server' : 'client',
'destroyed?', this.destroyed,
@@ -1122,6 +1151,13 @@ TLSSocket.prototype.renegotiate = function(options, callback) {
if (this.destroyed)
return;
+ if (this._tlsOptions.allowRenegotiation === false) {
+ if (callback) {
+ process.nextTick(callback, new ERR_TLS_RENEGOTIATION_DISABLED());
+ }
+ return false;
+ }
+
let requestCert = !!this._requestCert;
let rejectUnauthorized = !!this._rejectUnauthorized;
@@ -1228,6 +1264,13 @@ TLSSocket.prototype._finishInit = function() {
'alpn', this.alpnProtocol,
'servername', this.servername);
+ // A second completed handshake is a renegotiation.
+ if (this._secureEstablished &&
+ (this._tlsOptions.isServer ||
+ this._tlsOptions.allowRenegotiation !== true)) {
+ emitRenegotiationDeprecation();
+ }
+
this._secureEstablished = true;
if (this._tlsOptions.handshakeTimeout > 0)
this.setTimeout(0, this._handleTimeout);
@@ -1412,6 +1455,7 @@ function tlsConnectionListener(rawSocket) {
ALPNCallback: this.ALPNCallback,
SNICallback: this[kSNICallback] || SNICallback,
enableTrace: this[kEnableTrace],
+ allowRenegotiation: this[kAllowRenegotiation],
pauseOnConnect: this.pauseOnConnect,
pskCallback: this[kPskCallback],
pskIdentityHint: this[kPskIdentityHint],
@@ -1532,6 +1576,9 @@ function Server(options, listener) {
validateNumber(this[kHandshakeTimeout], 'options.handshakeTimeout');
+ validateAllowRenegotiation(options.allowRenegotiation, true);
+ this[kAllowRenegotiation] = options.allowRenegotiation;
+
if (this[kSNICallback]) {
validateFunction(this[kSNICallback], 'options.SNICallback');
}
@@ -1901,6 +1948,7 @@ exports.connect = function connect(...args) {
ALPNProtocols: options.ALPNProtocols,
requestOCSP: options.requestOCSP,
enableTrace: options.enableTrace,
+ allowRenegotiation: options.allowRenegotiation,
pskCallback: options.pskCallback,
highWaterMark: options.highWaterMark,
onread: options.onread,
diff --git a/src/crypto/crypto_tls.cc b/src/crypto/crypto_tls.cc
index a0e883f00b49..e092cb244684 100644
--- a/src/crypto/crypto_tls.cc
+++ b/src/crypto/crypto_tls.cc
@@ -700,6 +700,16 @@ void TLSWrap::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
if (where & SSL_CB_HANDSHAKE_START) {
Debug(c, "SSLInfoCallback(SSL_CB_HANDSHAKE_START);");
+#ifndef OPENSSL_IS_BORINGSSL
+ // The TLS library answers a peer's attempt to renegotiate with a
+ // no_renegotiation alert when renegotiation is disabled, and then reports
+ // the handshake as done without having done one.
+ c->flags_.renegotiation_refused =
+ c->flags_.established &&
+ (SSL_get_options(ssl) & SSL_OP_NO_RENEGOTIATION) != 0;
+ if (c->flags_.renegotiation_refused) return;
+#endif
+
// Start is tracked to limit number and frequency of renegotiation attempts,
// since excessive renegotiation may be an attack.
Local callback;
@@ -717,6 +727,10 @@ void TLSWrap::SSLInfoCallback(const SSL* ssl_, int where, int ret) {
if (where & SSL_CB_HANDSHAKE_DONE && !SSL_renegotiate_pending(ssl)) {
Debug(c, "SSLInfoCallback(SSL_CB_HANDSHAKE_DONE);");
CHECK(!SSL_renegotiate_pending(ssl));
+ if (c->flags_.renegotiation_refused) {
+ c->flags_.renegotiation_refused = false;
+ return;
+ }
Local callback;
c->flags_.established = true;
@@ -1457,6 +1471,19 @@ void TLSWrap::EnableKeylogCallback(const FunctionCallbackInfo& args) {
# define HAVE_SSL_TRACE 1
#endif
+void TLSWrap::DisableRenegotiation(const FunctionCallbackInfo& args) {
+ TLSWrap* wrap;
+ ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
+ if (!wrap->ssl_) return;
+#if NCRYPTO_USE_OPENSSL_PROVIDER
+ SSL_set_options(wrap->ssl_.get(), SSL_OP_NO_RENEGOTIATION);
+#elif NCRYPTO_USE_BORINGSSL
+ SSL_set_renegotiate_mode(wrap->ssl_.get(), ssl_renegotiate_never);
+#else
+#error "Unsupported crypto backend"
+#endif
+}
+
void TLSWrap::EnableTrace(const FunctionCallbackInfo& args) {
TLSWrap* wrap;
ASSIGN_OR_RETURN_UNWRAP(&wrap, args.This());
@@ -2453,6 +2480,7 @@ void TLSWrap::Initialize(
SetProtoMethod(isolate, t, "certCbDone", CertCbDone);
SetProtoMethod(isolate, t, "clientHelloDone", ClientHelloDone);
SetProtoMethod(isolate, t, "destroySSL", DestroySSL);
+ SetProtoMethod(isolate, t, "disableRenegotiation", DisableRenegotiation);
SetProtoMethod(isolate, t, "enableCertCb", EnableCertCb);
SetProtoMethod(isolate, t, "enableALPNCb", EnableALPNCb);
SetProtoMethod(isolate, t, "enableKeylogCallback", EnableKeylogCallback);
@@ -2528,6 +2556,7 @@ void TLSWrap::RegisterExternalReferences(ExternalReferenceRegistry* registry) {
registry->Register(CertCbDone);
registry->Register(ClientHelloDone);
registry->Register(DestroySSL);
+ registry->Register(DisableRenegotiation);
registry->Register(EnableCertCb);
registry->Register(EnableALPNCb);
registry->Register(EnableKeylogCallback);
diff --git a/src/crypto/crypto_tls.h b/src/crypto/crypto_tls.h
index f49a4904f15f..7f5ac201a62c 100644
--- a/src/crypto/crypto_tls.h
+++ b/src/crypto/crypto_tls.h
@@ -238,6 +238,8 @@ class TLSWrap : public AsyncWrap,
static void CertCbDone(const v8::FunctionCallbackInfo& args);
static void ClientHelloDone(const v8::FunctionCallbackInfo& args);
static void DestroySSL(const v8::FunctionCallbackInfo& args);
+ static void DisableRenegotiation(
+ const v8::FunctionCallbackInfo& args);
static void EnableCertCb(const v8::FunctionCallbackInfo& args);
static void EnableALPNCb(const v8::FunctionCallbackInfo& args);
static void EnableKeylogCallback(
@@ -358,6 +360,9 @@ class TLSWrap : public AsyncWrap,
bool has_active_write_issued_by_prev_listener : 1;
bool alpn_callback_enabled : 1;
bool servername_pinned : 1;
+ // The handshake in progress is the peer's attempt to renegotiate, which
+ // the TLS library is refusing.
+ bool renegotiation_refused : 1;
};
Flags flags_{};
diff --git a/test/doctool/test-doc-api-json.mjs b/test/doctool/test-doc-api-json.mjs
index f0e7d2b3425f..ac56a415811c 100644
--- a/test/doctool/test-doc-api-json.mjs
+++ b/test/doctool/test-doc-api-json.mjs
@@ -158,5 +158,5 @@ for await (const dirent of await fs.opendir(new URL('../../out/doc/api/', import
assert.partialDeepStrictEqual(allExpectedKeys, findAllKeys(json));
}
-assert.strictEqual(numberOfDeprecatedSections, 49); // Increase this number every time a new API is deprecated.
+assert.strictEqual(numberOfDeprecatedSections, 51); // Increase this number every time a new API is deprecated.
assert.strictEqual(numberOfRemovedAPIs, 49); // Increase this number every time a section is marked as removed.
diff --git a/test/parallel/test-https-agent-getname.js b/test/parallel/test-https-agent-getname.js
index 4b6555724b09..7ae5b8479d1c 100644
--- a/test/parallel/test-https-agent-getname.js
+++ b/test/parallel/test-https-agent-getname.js
@@ -14,13 +14,13 @@ const agent = new https.Agent();
// empty argument
assert.strictEqual(
agent.getName(),
- 'localhost:::::::::::::::::::::::::::'
+ 'localhost::::::::::::::::::::::::::::'
);
// empty options
assert.strictEqual(
agent.getName({}),
- 'localhost:::::::::::::::::::::::::::'
+ 'localhost::::::::::::::::::::::::::::'
);
// Pass all options arguments
@@ -50,7 +50,7 @@ assert.strictEqual(
'0.0.0.0:443:192.168.1.1:s2:ca:s4:cert:ciphers:s3:key::' +
's3:pfx::false:localhost:::secureProtocol:' +
'a3:7:v1:Yw==:7:v1:cg==:7:v1:bA==:false:ecdhCurve:dhparam:0:' +
- 'sessionIdContext:"sigalgs"::::::::'
+ 'sessionIdContext:"sigalgs":::::::::'
);
{
@@ -105,6 +105,11 @@ assert.strictEqual(
agent.getName({ ...baseOptions, allowPartialTrustChain: false })
);
+ assert.notStrictEqual(
+ agent.getName(baseOptions),
+ agent.getName({ ...baseOptions, allowRenegotiation: false })
+ );
+
const secureContext1 = tls.createSecureContext({ ca: agent1 });
const secureContext2 = tls.createSecureContext({ ca: agent6 });
assert.strictEqual(
diff --git a/test/parallel/test-tls-allow-renegotiation.js b/test/parallel/test-tls-allow-renegotiation.js
new file mode 100644
index 000000000000..5292d794b6f4
--- /dev/null
+++ b/test/parallel/test-tls-allow-renegotiation.js
@@ -0,0 +1,139 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+ common.skip('missing crypto');
+
+// Tests the allowRenegotiation option of tls.createServer() and tls.connect().
+
+const assert = require('assert');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+const { hasOpenSSL, isBoringSSL } = require('../common/crypto');
+
+if (isBoringSSL) {
+ // BoringSSL servers always refuse renegotiation.
+ for (const create of [
+ () => tls.createServer({ allowRenegotiation: true }),
+ () => new tls.TLSSocket(null, { isServer: true, allowRenegotiation: true }),
+ ]) {
+ assert.throws(create, { code: 'ERR_TLS_RENEGOTIATION_UNSUPPORTED' });
+ }
+ require('../common/boringssl').testRenegotiationUnsupported();
+ return;
+}
+
+// Renegotiation as a protocol feature was dropped after TLS1.2.
+tls.DEFAULT_MAX_VERSION = 'TLSv1.2';
+
+const handshakeFailure = hasOpenSSL(4, 0) ?
+ 'ERR_SSL_TLS_ALERT_HANDSHAKE_FAILURE' : hasOpenSSL(3, 2) ?
+ 'ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE' :
+ 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE';
+
+const idleTimeout = common.platformTimeout(60_000);
+
+const serverOptions = {
+ key: fixtures.readKey('rsa_private.pem'),
+ cert: fixtures.readKey('rsa_cert.crt'),
+};
+
+for (const allowRenegotiation of [null, 0, 'false', {}]) {
+ const expected = { code: 'ERR_INVALID_ARG_TYPE' };
+ assert.throws(() => tls.createServer({ allowRenegotiation }), expected);
+ assert.throws(() => tls.connect({ port: 1, allowRenegotiation }), expected);
+}
+
+function connect(server, options, onSecure) {
+ const client = tls.connect({
+ port: server.address().port,
+ rejectUnauthorized: false,
+ ...options,
+ }, () => onSecure(client));
+ client.on('close', common.mustCall(() => server.close()));
+}
+
+// A side that does not allow renegotiation cannot start one itself.
+function assertCannotRenegotiate(socket) {
+ assert.strictEqual(socket.renegotiate({}, common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ERR_TLS_RENEGOTIATION_DISABLED');
+ })), false);
+}
+
+// A server that does not allow renegotiation refuses the client's attempt, and
+// the attempt leaves the server's side of the connection as it was.
+function testServerRefuses({ disableRenegotiation }) {
+ const server = tls.createServer({
+ ...serverOptions,
+ allowRenegotiation: false,
+ }, common.mustCall((socket) => {
+ socket.setTimeout(idleTimeout);
+ // Has no effect: the attempt is refused without an error on this side.
+ if (disableRenegotiation) socket.disableRenegotiation();
+ assertCannotRenegotiate(socket);
+ socket.on('secure', common.mustNotCall('renegotiation completed'));
+ // The client gives up on the connection once its attempt is refused.
+ socket.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, handshakeFailure);
+ assert.strictEqual(socket.timeout, idleTimeout);
+ socket.destroy();
+ }));
+ }));
+
+ server.listen(0, common.mustCall(() => {
+ connect(server, {}, common.mustCall((client) => {
+ client.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ERR_SSL_NO_RENEGOTIATION');
+ client.destroy();
+ }));
+ client.on('secure', common.mustNotCall('renegotiation completed'));
+ assert.strictEqual(client.renegotiate({}), true);
+ }));
+ }));
+}
+
+// A client that does not allow renegotiation refuses the server's request.
+function testClientRefuses() {
+ const server = tls.createServer(serverOptions, common.mustCall((socket) => {
+ socket.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, 'ERR_SSL_NO_RENEGOTIATION');
+ socket.destroy();
+ }));
+ socket.on('secure', common.mustNotCall('renegotiation completed'));
+ assert.strictEqual(socket.renegotiate({}), true);
+ }));
+
+ server.listen(0, common.mustCall(() => {
+ connect(server, { allowRenegotiation: false }, common.mustCall((client) => {
+ client.setTimeout(idleTimeout);
+ assertCannotRenegotiate(client);
+ client.on('secure', common.mustNotCall('renegotiation completed'));
+ // The server gives up on the connection once its request is refused.
+ client.on('error', common.mustCall((err) => {
+ assert.strictEqual(err.code, handshakeFailure);
+ assert.strictEqual(client.timeout, idleTimeout);
+ client.destroy();
+ }));
+ }));
+ }));
+}
+
+function testAllowed() {
+ const server = tls.createServer({
+ ...serverOptions,
+ allowRenegotiation: true,
+ }, common.mustCall((socket) => socket.resume()));
+
+ server.listen(0, common.mustCall(() => {
+ connect(server, { allowRenegotiation: true }, common.mustCall((client) => {
+ assert.strictEqual(client.renegotiate({}, common.mustSucceed(() => {
+ client.end();
+ })), true);
+ }));
+ }));
+}
+
+testServerRefuses({ disableRenegotiation: false });
+testServerRefuses({ disableRenegotiation: true });
+testClientRefuses();
+testAllowed();
diff --git a/test/parallel/test-tls-renegotiation-pending-deprecation.js b/test/parallel/test-tls-renegotiation-pending-deprecation.js
new file mode 100644
index 000000000000..f8f692299cd2
--- /dev/null
+++ b/test/parallel/test-tls-renegotiation-pending-deprecation.js
@@ -0,0 +1,106 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+ common.skip('missing crypto');
+
+const { isBoringSSL } = require('../common/crypto');
+if (isBoringSSL)
+ common.skip('BoringSSL does not support renegotiation');
+
+// With --pending-deprecation, renegotiation emits a deprecation warning unless
+// it is a client that set allowRenegotiation: true accepting a server's request.
+
+const assert = require('assert');
+const { fork } = require('child_process');
+const tls = require('tls');
+const fixtures = require('../common/fixtures');
+
+tls.DEFAULT_MAX_VERSION = 'TLSv1.2';
+
+const serverOptions = {
+ key: fixtures.readKey('rsa_private.pem'),
+ cert: fixtures.readKey('rsa_cert.crt'),
+};
+
+// The endpoint under test runs in a child process, as the warning is emitted
+// once per process and the peer would otherwise emit it too.
+if (process.argv[2] === 'child') {
+ const { role, allowRenegotiation, initiate, port } =
+ JSON.parse(process.argv[3]);
+
+ if (role === 'server') {
+ const server = tls.createServer({
+ ...serverOptions,
+ allowRenegotiation,
+ }, common.mustCall((socket) => {
+ socket.resume();
+ socket.on('close', common.mustCall(() => server.close()));
+ }));
+ server.listen(0, common.mustCall(() => {
+ process.send({ port: server.address().port });
+ }));
+ } else {
+ const client = tls.connect({
+ port,
+ rejectUnauthorized: false,
+ allowRenegotiation,
+ }, common.mustCall(() => {
+ if (initiate)
+ client.renegotiate({}, common.mustSucceed(() => client.end()));
+ }));
+ client.resume();
+ }
+ return;
+}
+
+function start(options, warns) {
+ const child = fork(__filename, ['child', JSON.stringify(options)], {
+ execArgv: ['--pending-deprecation'],
+ stdio: ['ignore', 'inherit', 'pipe', 'ipc'],
+ });
+ let stderr = '';
+ child.stderr.setEncoding('utf8');
+ child.stderr.on('data', (chunk) => { stderr += chunk; });
+ child.on('close', common.mustCall((code) => {
+ assert.strictEqual(code, 0, stderr);
+ assert.strictEqual(
+ stderr.includes('[DEP0213] DeprecationWarning: TLS renegotiation'),
+ warns,
+ stderr);
+ }));
+ return child;
+}
+
+function testServer(options, warns) {
+ const child = start({ role: 'server', ...options }, warns);
+ child.on('message', common.mustCall(({ port }) => {
+ const client = tls.connect({
+ port,
+ rejectUnauthorized: false,
+ }, common.mustCall(() => {
+ client.renegotiate({}, common.mustSucceed(() => client.end()));
+ }));
+ client.resume();
+ }));
+}
+
+function testClient(options, warns) {
+ const server = tls.createServer(serverOptions, common.mustCall((socket) => {
+ socket.resume();
+ socket.on('close', common.mustCall(() => server.close()));
+ if (!options.initiate)
+ socket.renegotiate({}, common.mustSucceed(() => socket.end()));
+ }));
+ server.listen(0, common.mustCall(() => {
+ start({ role: 'client', port: server.address().port, ...options }, warns);
+ }));
+}
+
+// A server completing a renegotiation, whether or not it set the option.
+testServer({ allowRenegotiation: true }, true);
+// Any call to renegotiate().
+testClient({ allowRenegotiation: true, initiate: true }, true);
+// A client accepting the server's request, unless it set the option.
+testClient({ initiate: false }, true);
+testClient({ allowRenegotiation: true, initiate: false }, false);