fixup! crypto: add a generic MAC API

Author: panva

benchmark/crypto/mac.js

@@ -17,7 +17,19 @@ if (!hasOpenSSL(3) ||
   process.exit(0);
 }
 
-const isTest = process.argv.includes('--test');
+const operations = [
+  'get-macs-cold',
+  'get-macs-warm',
+  'create-cold',
+  'create-warm',
+  'hmac-lifecycle',
+  'mac-lifecycle',
+  'mac-stream-lifecycle',
+  'update',
+  'stream',
+  'final-buffer',
+  'final-hex',
+];
 const configurations = {
   'hmac-sha256': {
     algorithm: 'HMAC',
@@ -32,24 +44,12 @@ const configurations = {
 };
 
 const bench = common.createBenchmark(main, {
-  operation: [
-    'get-macs-cold',
-    'get-macs-warm',
-    'create-cold',
-    'create-warm',
-    'create-hmac',
-    'update',
-    'stream',
-  ],
+  operation: operations,
   algorithm: Object.keys(configurations),
   length: [0, 64, 4096],
   n: [1, 10_000, 20_000, 500_000],
 }, {
   combinationFilter({ operation, algorithm, length, n }) {
-    if (isTest) {
-      return algorithm === 'hmac-sha256' && length === 0 && n === 1;
-    }
-
     if (operation === 'get-macs-cold') {
       return algorithm === 'hmac-sha256' && length === 0 && n === 1;
     }
@@ -60,11 +60,25 @@ const bench = common.createBenchmark(main, {
       return length === 0 && n === 1;
     if (operation === 'create-warm')
       return length === 0 && n === 20_000;
-    if (operation === 'create-hmac' && algorithm !== 'hmac-sha256')
-      return false;
-    return n === 10_000;
+    if (operation === 'hmac-lifecycle') {
+      return algorithm === 'hmac-sha256' && n === 10_000;
+    }
+    if (operation === 'mac-lifecycle' ||
+        operation === 'mac-stream-lifecycle') {
+      return n === 10_000;
+    }
+    if (operation === 'update' || operation === 'stream') {
+      return length === 64 && n === 500_000;
+    }
+    if (operation === 'final-buffer' || operation === 'final-hex') {
+      return algorithm === 'hmac-sha256' &&
+             length === 64 &&
+             n === 20_000;
+    }
+    return false;
   },
   test: {
+    operation: ['get-macs-cold', 'create-cold'],
     algorithm: ['hmac-sha256'],
     length: [0],
     n: [1],
@@ -88,15 +102,27 @@ function main({ operation, algorithm, length, n }) {
     case 'create-warm':
       measureCreate(configuration, n, true);
       break;
-    case 'create-hmac':
-      measureCreateHmac(configuration, data, n);
+    case 'hmac-lifecycle':
+      measureHmacLifecycle(configuration, data, n);
+      break;
+    case 'mac-lifecycle':
+      measureMacLifecycle(configuration, data, n);
+      break;
+    case 'mac-stream-lifecycle':
+      measureMacStreamLifecycle(configuration, data, n);
       break;
     case 'update':
       measureUpdate(configuration, data, n);
       break;
     case 'stream':
       measureStream(configuration, data, n);
       break;
+    case 'final-buffer':
+      measureFinal(configuration, data, n);
+      break;
+    case 'final-hex':
+      measureFinal(configuration, data, n, 'hex');
+      break;
     default:
       throw new Error(`unknown operation: ${operation}`);
   }
@@ -128,7 +154,7 @@ function measureCreate({ algorithm, key, options }, n, warm) {
   assert.strictEqual(typeof contexts[n - 1], 'object');
 }
 
-function measureCreateHmac({ key, options }, data, n) {
+function measureHmacLifecycle({ key, options }, data, n) {
   createHmac(options.digest, key).update(data).digest();
 
   let result;
@@ -140,7 +166,7 @@ function measureCreateHmac({ key, options }, data, n) {
   assert(Buffer.isBuffer(result));
 }
 
-function measureUpdate({ algorithm, key, options }, data, n) {
+function measureMacLifecycle({ algorithm, key, options }, data, n) {
   createMac(algorithm, key, options).update(data).final();
 
   let result;
@@ -152,7 +178,7 @@ function measureUpdate({ algorithm, key, options }, data, n) {
   assert(Buffer.isBuffer(result));
 }
 
-function measureStream({ algorithm, key, options }, data, n) {
+function measureMacStreamLifecycle({ algorithm, key, options }, data, n) {
   const warmup = createMac(algorithm, key, options);
   warmup.end(data);
   warmup.read();
@@ -168,3 +194,61 @@ function measureStream({ algorithm, key, options }, data, n) {
 
   assert(Buffer.isBuffer(result));
 }
+
+function measureUpdate({ algorithm, key, options }, data, n) {
+  const warmup = createMac(algorithm, key, options);
+  warmup.update(data).final();
+
+  const context = createMac(algorithm, key, options);
+  bench.start();
+  for (let i = 0; i < n; ++i)
+    context.update(data);
+  bench.end(n);
+
+  assert(Buffer.isBuffer(context.final()));
+}
+
+function measureStream({ algorithm, key, options }, data, n) {
+  const warmup = createMac(algorithm, key, options);
+  warmup.end(data);
+  warmup.read();
+
+  const context = createMac(algorithm, key, options);
+  bench.start();
+  for (let i = 0; i < n; ++i)
+    context.write(data);
+  bench.end(n);
+
+  context.end();
+  assert(Buffer.isBuffer(context.read()));
+}
+
+function measureFinal({ algorithm, key, options }, data, n, encoding) {
+  const warmup = createMac(algorithm, key, options).update(data);
+  if (encoding === undefined)
+    warmup.final();
+  else
+    warmup.final(encoding);
+
+  const contexts = new Array(n);
+  for (let i = 0; i < n; ++i)
+    contexts[i] = createMac(algorithm, key, options).update(data);
+
+  let result;
+  if (encoding === undefined) {
+    bench.start();
+    for (let i = 0; i < n; ++i)
+      result = contexts[i].final();
+    bench.end(n);
+  } else {
+    bench.start();
+    for (let i = 0; i < n; ++i)
+      result = contexts[i].final(encoding);
+    bench.end(n);
+  }
+
+  if (encoding === undefined)
+    assert(Buffer.isBuffer(result));
+  else
+    assert.strictEqual(typeof result, 'string');
+}

lib/internal/crypto/provider_mac.js

@@ -13,7 +13,6 @@ const {
 } = internalBinding('crypto');
 
 const {
-  getArrayBufferOrView,
   getCachedMacId,
   getMacCache,
   kHandle,
@@ -69,7 +68,7 @@ function normalizeBytes(value, name) {
     throw new ERR_INVALID_ARG_TYPE(
       name, ['ArrayBuffer', 'Buffer', 'TypedArray', 'DataView'], value);
   }
-  return getArrayBufferOrView(value, name);
+  return value;
 }
 
 function createHandle(algorithm, key, options) {
@@ -80,6 +79,7 @@ function createHandle(algorithm, key, options) {
   let customization;
   let salt;
   let outputLength;
+  let hasExtendedOptions = false;
 
   if (options !== undefined) {
     validateObject(options, 'options');
@@ -91,31 +91,39 @@ function createHandle(algorithm, key, options) {
     const cipherOption = options.cipher;
     if (cipherOption !== undefined) {
       cipher = validateName(cipherOption, 'options.cipher');
+      hasExtendedOptions = true;
     }
     const ivOption = options.iv;
     if (ivOption !== undefined) {
       iv = normalizeBytes(ivOption, 'options.iv');
+      hasExtendedOptions = true;
     }
     const customizationOption = options.customization;
     if (customizationOption !== undefined) {
       customization = normalizeBytes(
         customizationOption, 'options.customization');
+      hasExtendedOptions = true;
     }
     const saltOption = options.salt;
     if (saltOption !== undefined) {
       salt = normalizeBytes(saltOption, 'options.salt');
+      hasExtendedOptions = true;
     }
     const outputLengthOption = options.outputLength;
     if (outputLengthOption !== undefined) {
       outputLength = outputLengthOption;
       validateUint32(outputLength, 'options.outputLength');
       outputLength += 0;
+      hasExtendedOptions = true;
     }
   }
 
   key = normalizeKey(key);
   const id = getCachedMacId(name);
   const cache = getMacCache();
+  if (!hasExtendedOptions) {
+    return new _Mac(name, id, cache, key, digest);
+  }
   return new _Mac(
     name,
     id,
@@ -142,7 +150,7 @@ function normalizeKey(key) {
     throw new ERR_INVALID_ARG_TYPE(
       'key', ['ArrayBuffer', 'Buffer', 'TypedArray', 'DataView', 'KeyObject'], key);
   }
-  return getArrayBufferOrView(key, 'key');
+  return key;
 }
 
 function normalizeOutputEncoding(outputEncoding) {
@@ -167,10 +175,6 @@ function normalizeInputEncoding(data, inputEncoding) {
   return normalized;
 }
 
-function encodeOutput(result, outputEncoding) {
-  return outputEncoding === 'buffer' ? result : result.toString(outputEncoding);
-}
-
 function updateHandle(mac, data, encoding) {
   const state = mac[kState];
   let updated;
@@ -186,10 +190,10 @@ function updateHandle(mac, data, encoding) {
   }
 }
 
-function finalizeHandle(mac) {
+function finalizeHandle(mac, outputEncoding) {
   const state = mac[kState];
   state[kFinalized] = true;
-  return mac[kHandle].final();
+  return mac[kHandle].final(outputEncoding);
 }
 
 function Mac(algorithm, key, options) {
@@ -249,7 +253,8 @@ Mac.prototype.final = function final(outputEncoding) {
   if (this[kState][kFinalized]) throw new ERR_CRYPTO_MAC_FINALIZED();
   if (outputEncoding === undefined) return finalizeHandle(this);
   outputEncoding = normalizeOutputEncoding(outputEncoding);
-  return encodeOutput(finalizeHandle(this), outputEncoding);
+  if (outputEncoding === 'buffer') return finalizeHandle(this);
+  return finalizeHandle(this, outputEncoding);
 };
 
 module.exports = {