|
| 1 | +'use strict'; |
| 2 | + |
| 3 | +const common = require('../common.js'); |
| 4 | +const crypto = require('node:crypto'); |
| 5 | +const fs = require('node:fs'); |
| 6 | +const path = require('node:path'); |
| 7 | +const { pathToFileURL } = require('node:url'); |
| 8 | +const { hasOpenSSL, isBoringSSL } = require('../../test/common/crypto.js'); |
| 9 | + |
| 10 | +const inputs = [ |
| 11 | + 'public-keyobject', 'public-keyobject-wrapped', 'public-pem-buffer-wrapped', |
| 12 | + 'private-keyobject', 'private-keyobject-wrapped', |
| 13 | + 'private-pem-string', 'private-pem-buffer', 'private-pem-arraybuffer', |
| 14 | + 'private-pem-string-wrapped', 'private-pem-buffer-wrapped', 'private-pem-arraybuffer-wrapped', |
| 15 | + 'private-jwk', |
| 16 | + 'public-der-pkcs1-bytes', 'private-der-pkcs1-bytes', 'private-pem-pkcs8-bytes', |
| 17 | + 'private-der-pkcs8-bytes', 'private-der-pkcs8-base64', 'private-der-pkcs8-hex', |
| 18 | + 'public-der-spki-bytes', 'private-der-sec1-bytes', |
| 19 | + 'raw-public-ec-buffer', 'raw-public-ed25519-buffer', |
| 20 | + 'raw-private-ec-buffer', 'raw-private-ec-arraybuffer', 'raw-private-ed25519-buffer', |
| 21 | + 'pem-passphrase-absent', 'pem-passphrase-empty', 'pem-passphrase-string', |
| 22 | + 'pem-passphrase-base64', 'pem-passphrase-buffer', 'pem-passphrase-arraybuffer', |
| 23 | + 'file-passphrase-absent', 'file-passphrase-string', 'file-direct', |
| 24 | + 'provider-passphrase-absent', 'provider-passphrase-absent-properties', |
| 25 | + 'provider-passphrase-empty', 'provider-passphrase-string', 'provider-passphrase-base64', |
| 26 | + 'provider-passphrase-buffer', 'provider-passphrase-arraybuffer', 'provider-direct', |
| 27 | +]; |
| 28 | + |
| 29 | +if (hasOpenSSL(3, 5) || isBoringSSL) |
| 30 | + inputs.push('raw-seed-ml-dsa-44-buffer'); |
| 31 | + |
| 32 | +const bench = common.createBenchmark(main, { |
| 33 | + input: inputs, |
| 34 | + context: ['consume-public', 'consume-private', 'create-public'], |
| 35 | + n: [1e6], |
| 36 | +}, { |
| 37 | + flags: ['--expose-internals'], |
| 38 | + combinationFilter({ input, context }) { |
| 39 | + if (input === 'private-keyobject' || input === 'private-keyobject-wrapped') |
| 40 | + return true; |
| 41 | + if (input.startsWith('public-') || input.startsWith('raw-public-')) |
| 42 | + return context === 'consume-public'; |
| 43 | + return context === 'consume-private'; |
| 44 | + }, |
| 45 | +}); |
| 46 | + |
| 47 | +function main({ input, context, n }) { |
| 48 | + const { |
| 49 | + prepareAsymmetricKey, |
| 50 | + kConsumePublic, |
| 51 | + kConsumePrivate, |
| 52 | + kCreatePublic, |
| 53 | + } = require('internal/crypto/keys'); |
| 54 | + const ctx = { |
| 55 | + 'consume-public': kConsumePublic, |
| 56 | + 'consume-private': kConsumePrivate, |
| 57 | + 'create-public': kCreatePublic, |
| 58 | + }[context]; |
| 59 | + const fixtureDir = path.resolve(__dirname, '../../test/fixtures/keys'); |
| 60 | + const privateKeyPath = path.join(fixtureDir, 'rsa_private_2048.pem'); |
| 61 | + const privateKey = crypto.createPrivateKey(fs.readFileSync(privateKeyPath)); |
| 62 | + const publicKey = crypto.createPublicKey(privateKey); |
| 63 | + const pem = privateKey.export({ format: 'pem', type: 'pkcs8' }); |
| 64 | + const buffer = Buffer.from(pem); |
| 65 | + const arraybuffer = Uint8Array.from(buffer).buffer; |
| 66 | + const fileURL = pathToFileURL(privateKeyPath); |
| 67 | + const providerURL = new URL('pkcs11:object=signing-key;type=private'); |
| 68 | + const passphrase = Buffer.from('password'); |
| 69 | + |
| 70 | + let key; |
| 71 | + switch (input) { |
| 72 | + case 'public-keyobject': key = publicKey; break; |
| 73 | + case 'public-keyobject-wrapped': key = { key: publicKey }; break; |
| 74 | + case 'public-pem-buffer-wrapped': |
| 75 | + key = { key: Buffer.from(publicKey.export({ format: 'pem', type: 'spki' })) }; |
| 76 | + break; |
| 77 | + case 'private-keyobject': key = privateKey; break; |
| 78 | + case 'private-keyobject-wrapped': key = { key: privateKey }; break; |
| 79 | + case 'private-pem-string': key = pem; break; |
| 80 | + case 'private-pem-buffer': key = buffer; break; |
| 81 | + case 'private-pem-arraybuffer': key = arraybuffer; break; |
| 82 | + case 'private-pem-string-wrapped': key = { key: pem }; break; |
| 83 | + case 'private-pem-buffer-wrapped': key = { key: buffer }; break; |
| 84 | + case 'private-pem-arraybuffer-wrapped': key = { key: arraybuffer }; break; |
| 85 | + case 'private-jwk': key = { key: privateKey.export({ format: 'jwk' }), format: 'jwk' }; break; |
| 86 | + case 'public-der-pkcs1-bytes': key = { key: publicKey, format: 'der', type: 'pkcs1' }; break; |
| 87 | + case 'private-der-pkcs1-bytes': key = { key: privateKey, format: 'der', type: 'pkcs1' }; break; |
| 88 | + case 'private-pem-pkcs8-bytes': key = { key: privateKey, format: 'pem', type: 'pkcs8' }; break; |
| 89 | + case 'private-der-pkcs8-bytes': key = { key: privateKey, format: 'der', type: 'pkcs8' }; break; |
| 90 | + case 'private-der-pkcs8-base64': |
| 91 | + key = { key: privateKey, format: 'der', type: 'pkcs8', encoding: 'base64' }; |
| 92 | + break; |
| 93 | + case 'private-der-pkcs8-hex': |
| 94 | + key = { key: privateKey, format: 'der', type: 'pkcs8', encoding: 'hex' }; |
| 95 | + break; |
| 96 | + case 'public-der-spki-bytes': key = { key: publicKey, format: 'der', type: 'spki' }; break; |
| 97 | + case 'private-der-sec1-bytes': |
| 98 | + key = { |
| 99 | + key: crypto.createPrivateKey(fs.readFileSync(path.join(fixtureDir, 'ec_p256_private.pem'))), |
| 100 | + format: 'der', type: 'sec1', |
| 101 | + }; |
| 102 | + break; |
| 103 | + case 'raw-public-ec-buffer': |
| 104 | + case 'raw-public-ed25519-buffer': |
| 105 | + case 'raw-private-ec-buffer': |
| 106 | + case 'raw-private-ec-arraybuffer': |
| 107 | + case 'raw-private-ed25519-buffer': { |
| 108 | + const asymmetricKeyType = input.includes('-ec-') ? 'ec' : 'ed25519'; |
| 109 | + const fixture = asymmetricKeyType === 'ec' ? 'ec_p256_private.pem' : 'ed25519_private.pem'; |
| 110 | + let rawKey = crypto.createPrivateKey(fs.readFileSync(path.join(fixtureDir, fixture))); |
| 111 | + const format = input.startsWith('raw-public-') ? 'raw-public' : 'raw-private'; |
| 112 | + if (format === 'raw-public') rawKey = crypto.createPublicKey(rawKey); |
| 113 | + const bytes = rawKey.export({ format }); |
| 114 | + key = { |
| 115 | + key: input.endsWith('-arraybuffer') ? Uint8Array.from(bytes).buffer : bytes, |
| 116 | + format, |
| 117 | + asymmetricKeyType, |
| 118 | + namedCurve: asymmetricKeyType === 'ec' ? 'prime256v1' : undefined, |
| 119 | + }; |
| 120 | + break; |
| 121 | + } |
| 122 | + case 'raw-seed-ml-dsa-44-buffer': { |
| 123 | + const seedKey = crypto.createPrivateKey( |
| 124 | + fs.readFileSync(path.join(fixtureDir, 'ml_dsa_44_private_seed_only.pem'))); |
| 125 | + key = { key: seedKey.export({ format: 'raw-seed' }), format: 'raw-seed', asymmetricKeyType: 'ml-dsa-44' }; |
| 126 | + break; |
| 127 | + } |
| 128 | + case 'pem-passphrase-absent': key = { key: privateKey }; break; |
| 129 | + case 'pem-passphrase-empty': key = { key: privateKey, passphrase: '' }; break; |
| 130 | + case 'pem-passphrase-string': key = { key: privateKey, passphrase: 'password' }; break; |
| 131 | + case 'pem-passphrase-base64': |
| 132 | + key = { key: privateKey, passphrase: passphrase.toString('base64'), encoding: 'base64' }; |
| 133 | + break; |
| 134 | + case 'pem-passphrase-buffer': key = { key: privateKey, passphrase }; break; |
| 135 | + case 'pem-passphrase-arraybuffer': |
| 136 | + key = { key: privateKey, passphrase: Uint8Array.from(passphrase).buffer }; |
| 137 | + break; |
| 138 | + case 'file-passphrase-absent': key = { key: fileURL }; break; |
| 139 | + case 'file-passphrase-string': key = { key: fileURL, passphrase: 'password' }; break; |
| 140 | + case 'file-direct': key = fileURL; break; |
| 141 | + case 'provider-passphrase-absent': key = { key: providerURL }; break; |
| 142 | + case 'provider-passphrase-absent-properties': key = { key: providerURL, properties: 'provider=default' }; break; |
| 143 | + case 'provider-passphrase-empty': key = { key: providerURL, passphrase: '' }; break; |
| 144 | + case 'provider-passphrase-string': key = { key: providerURL, passphrase: 'password' }; break; |
| 145 | + case 'provider-passphrase-base64': |
| 146 | + key = { key: providerURL, passphrase: passphrase.toString('base64'), encoding: 'base64' }; |
| 147 | + break; |
| 148 | + case 'provider-passphrase-buffer': key = { key: providerURL, passphrase }; break; |
| 149 | + case 'provider-passphrase-arraybuffer': |
| 150 | + key = { key: providerURL, passphrase: Uint8Array.from(passphrase).buffer }; |
| 151 | + break; |
| 152 | + case 'provider-direct': key = providerURL; break; |
| 153 | + default: throw new Error(`Unsupported input: ${input}`); |
| 154 | + } |
| 155 | + |
| 156 | + if (input.startsWith('pem-passphrase-')) { |
| 157 | + const bytes = key.passphrase === undefined ? undefined : |
| 158 | + typeof key.passphrase === 'string' ? Buffer.from(key.passphrase, key.encoding) : |
| 159 | + Buffer.from(key.passphrase); |
| 160 | + key = { |
| 161 | + key: Buffer.from(privateKey.export({ |
| 162 | + format: 'pem', type: 'pkcs8', |
| 163 | + ...(bytes === undefined ? {} : { cipher: 'aes-256-cbc', passphrase: bytes }), |
| 164 | + })), |
| 165 | + format: 'pem', type: 'pkcs8', passphrase: key.passphrase, encoding: key.encoding, |
| 166 | + }; |
| 167 | + } else if (key.key instanceof crypto.KeyObject && key.format !== undefined) { |
| 168 | + const bytes = Buffer.from(key.key.export({ format: key.format, type: key.type })); |
| 169 | + key.key = key.encoding === undefined ? bytes : bytes.toString(key.encoding); |
| 170 | + } |
| 171 | + |
| 172 | + prepareAsymmetricKey(key, ctx); |
| 173 | + bench.start(); |
| 174 | + for (let index = 0; index < n; index++) { |
| 175 | + prepareAsymmetricKey(key, ctx); |
| 176 | + } |
| 177 | + bench.end(n); |
| 178 | +} |
0 commit comments