Function main

benchmark/crypto/oneshot-verify.js:106–177

({ n, mode, keyFormat, keyType })

}

function main({ n, mode, keyFormat, keyType }) {
  pems ||= [...Buffer.alloc(n)].map(() => keyFixtures[keyType].publicKey);
  keyObjects ||= pems.map(crypto.createPublicKey);

  // Warm up OpenSSL's provider operation cache for each key object
  const warmupDigest = keyType === 'rsa' || keyType === 'ec' ? 'sha256' : null;
  const warmupSig = crypto.sign(warmupDigest, data, keyFixtures[keyType].privateKey);
  for (const keyObject of keyObjects) {
    crypto.verify(warmupDigest, data, keyObject, warmupSig);
  }

  let publicKey, keys, digest;

  switch (keyType) {
    case 'rsa':
    case 'ec':
      digest = 'sha256';
      break;
    case 'ed25519':
    case 'ml-dsa-44':
      break;
    default:
      throw new Error('not implemented');
  }

  switch (keyFormat) {
    case 'keyObject':
      publicKey = keyObjects[0];
      break;
    case 'pem':
      publicKey = pems[0];
      break;
    case 'jwk': {
      publicKey = { key: keyObjects[0].export({ format: 'jwk' }), format: 'jwk' };
      break;
    }
    case 'der': {
      publicKey = { key: keyObjects[0].export({ format: 'der', type: 'spki' }), format: 'der', type: 'spki' };
      break;
    }
    case 'raw-public': {
      const exportedKey = keyObjects[0].export({ format: 'raw-public' });
      const keyOpts = { key: exportedKey, format: 'raw-public', asymmetricKeyType: keyType };
      if (keyType === 'ec') keyOpts.namedCurve = keyObjects[0].asymmetricKeyDetails.namedCurve;
      publicKey = keyOpts;
      break;
    }
    case 'keyObject.unique':
      keys = keyObjects;
      break;
    default:
      throw new Error('not implemented');
  }


  const { privateKey } = keyFixtures[keyType];
  const signature = crypto.sign(digest, data, privateKey);