test: split test-crypto-dh to avoid timeout on slow machines in the CI

Locally this speeds up running test-crypto-dh* from 7s to 2s. This was previously timing out in CI (took more than 2 minutes) so should see a bigger gap in the CI. PR-URL: #49492 Refs: #49202 Refs: nodejs/reliability#655 Reviewed-By: Michaël Zasso <[email protected]> Reviewed-By: Antoine du Hamel <[email protected]> Reviewed-By: Chemi Atlow <[email protected]> Reviewed-By: Filip Skokan <[email protected]> Reviewed-By: Yagiz Nizipli <[email protected]> Reviewed-By: Luigi Pinca <[email protected]>

Author: joyeecheung

test/parallel/test-crypto-dh-errors.js

@@ -0,0 +1,111 @@
+'use strict';
+constcommon=require('../common');
+if(!common.hasCrypto)
+common.skip('missing crypto');
+
+constassert=require('assert');
+constcrypto=require('crypto');
+
+// https://github.com/nodejs/node/issues/32738
+// XXX(bnoordhuis) validateInt32() throwing ERR_OUT_OF_RANGE and RangeError
+// instead of ERR_INVALID_ARG_TYPE and TypeError is questionable, IMO.
+assert.throws(()=>crypto.createDiffieHellman(13.37),{
+code: 'ERR_OUT_OF_RANGE',
+name: 'RangeError',
+message: 'The value of "sizeOrKey" is out of range. '+
+'It must be an integer. Received 13.37',
+});
+
+assert.throws(()=>crypto.createDiffieHellman('abcdef',13.37),{
+code: 'ERR_OUT_OF_RANGE',
+name: 'RangeError',
+message: 'The value of "generator" is out of range. '+
+'It must be an integer. Received 13.37',
+});
+
+for(constbitsof[-1,0,1]){
+if(common.hasOpenSSL3){
+assert.throws(()=>crypto.createDiffieHellman(bits),{
+code: 'ERR_OSSL_DH_MODULUS_TOO_SMALL',
+name: 'Error',
+message: /modulustoosmall/,
+});
+}else{
+assert.throws(()=>crypto.createDiffieHellman(bits),{
+code: 'ERR_OSSL_BN_BITS_TOO_SMALL',
+name: 'Error',
+message: /bitstoosmall/,
+});
+}
+}
+
+for(constgof[-1,1]){
+constex={
+code: 'ERR_OSSL_DH_BAD_GENERATOR',
+name: 'Error',
+message: /badgenerator/,
+};
+assert.throws(()=>crypto.createDiffieHellman('abcdef',g),ex);
+assert.throws(()=>crypto.createDiffieHellman('abcdef','hex',g),ex);
+}
+
+for(constgof[Buffer.from([]),
+Buffer.from([0]),
+Buffer.from([1])]){
+constex={
+code: 'ERR_OSSL_DH_BAD_GENERATOR',
+name: 'Error',
+message: /badgenerator/,
+};
+assert.throws(()=>crypto.createDiffieHellman('abcdef',g),ex);
+assert.throws(()=>crypto.createDiffieHellman('abcdef','hex',g),ex);
+}
+
+[
+[0x1,0x2],
+()=>{},
+/abc/,
+{},
+].forEach((input)=>{
+assert.throws(
+()=>crypto.createDiffieHellman(input),
+{
+code: 'ERR_INVALID_ARG_TYPE',
+name: 'TypeError',
+}
+);
+});
+
+// Invalid test: curve argument is undefined
+assert.throws(
+()=>crypto.createECDH(),
+{
+code: 'ERR_INVALID_ARG_TYPE',
+name: 'TypeError',
+message: 'The "curve" argument must be of type string. '+
+'Received undefined'
+});
+
+assert.throws(
+function(){
+crypto.getDiffieHellman('unknown-group');
+},
+{
+name: 'Error',
+code: 'ERR_CRYPTO_UNKNOWN_DH_GROUP',
+message: 'Unknown DH group'
+},
+'crypto.getDiffieHellman(\'unknown-group\') '+
+'failed to throw the expected error.'
+);
+
+assert.throws(
+()=>crypto.createDiffieHellman('',true),
+{
+code: 'ERR_INVALID_ARG_TYPE'
+}
+);
+[true,Symbol(),{},()=>{},[]].forEach((generator)=>assert.throws(
+()=>crypto.createDiffieHellman('','base64',generator),
+{code: 'ERR_INVALID_ARG_TYPE'}
+));

test/parallel/test-crypto-dh-generate-keys.js

@@ -0,0 +1,63 @@
+'use strict';
+
+constcommon=require('../common');
+if(!common.hasCrypto)
+common.skip('missing crypto');
+
+constassert=require('assert');
+constcrypto=require('crypto');
+
+{
+constsize=common.hasFipsCrypto||common.hasOpenSSL3 ? 1024 : 256;
+
+functionunlessInvalidState(f){
+try{
+returnf();
+}catch(err){
+if(err.code!=='ERR_CRYPTO_INVALID_STATE'){
+throwerr;
+}
+}
+}
+
+functiontestGenerateKeysChangesKeys(setup,expected){
+constdh=crypto.createDiffieHellman(size);
+setup(dh);
+constfirstPublicKey=unlessInvalidState(()=>dh.getPublicKey());
+constfirstPrivateKey=unlessInvalidState(()=>dh.getPrivateKey());
+dh.generateKeys();
+constsecondPublicKey=dh.getPublicKey();
+constsecondPrivateKey=dh.getPrivateKey();
+functionchanged(shouldChange,first,second){
+if(shouldChange){
+assert.notDeepStrictEqual(first,second);
+}else{
+assert.deepStrictEqual(first,second);
+}
+}
+changed(expected.includes('public'),firstPublicKey,secondPublicKey);
+changed(expected.includes('private'),firstPrivateKey,secondPrivateKey);
+}
+
+// Both the private and the public key are missing: generateKeys() generates both.
+testGenerateKeysChangesKeys(()=>{
+// No setup.
+},['public','private']);
+
+// Neither key is missing: generateKeys() does nothing.
+testGenerateKeysChangesKeys((dh)=>{
+dh.generateKeys();
+},[]);
+
+// Only the public key is missing: generateKeys() generates only the public key.
+testGenerateKeysChangesKeys((dh)=>{
+dh.setPrivateKey(Buffer.from('01020304','hex'));
+},['public']);
+
+// The public key is outdated: generateKeys() generates only the public key.
+testGenerateKeysChangesKeys((dh)=>{
+constoldPublicKey=dh.generateKeys();
+dh.setPrivateKey(Buffer.from('01020304','hex'));
+assert.deepStrictEqual(dh.getPublicKey(),oldPublicKey);
+},['public']);
+}