Normalize data to Uint8Array to avoid extra copies.

Author: dlongley

lib/httpDigest.js

@@ -9,21 +9,20 @@ import crypto from './crypto.js';
  * Creates a value suitable for the HTTP `Digest` header.
  *
  * @param {object} options - The options to use.
- * @param {string|object|Blob|Uint8Array} [options.data] - Input body to be
- *   hashed (typically a request body).
+ * @param {string|object|Blob|Uint8Array} [options.data] - The data to be
+ *   hashed (a request or response body).
  * @param {string} [options.algorithm] - Hash algorithm to use.
  *   (e.g. 'sha256').
- * @param {boolean} [options.useMultihash] - Whether to encode via multihash.
- *   If false, the hash will be base64 encoded (non-url).
+ * @param {boolean} [options.useMultihash=true] - Whether to encode via
+ *   multihash; if false, the hash will be base64-encoded (non-url).
  *
  * @returns {Promise<string>} Resolves to `Digest` header value.
  */
 export async function createHeaderValue({
   data, algorithm = 'sha256', useMultihash = true
 } = {}) {
-  const body = _normalizeData(data);
   const {key, encodedDigest} = await _createHeaderValueComponents({
-    body, algorithm, useMultihash
+    data, algorithm, useMultihash
   });
   return `${key}=${encodedDigest}`;
 }
@@ -32,7 +31,8 @@ export async function createHeaderValue({
  * Verifies the HTTP `Digest` header value against the given HTTP body `data`.
  *
  * @param {object} options - The options to use.
- * @param {string|object|Blob} options.data - The data to be verified.
+ * @param {string|object|Blob|Uint8Array} options.data - The data to be
+ *   verified (a request or response body).
  * @param {string} options.headerValue - The digest header value to verify
  *   the data against.
  *
@@ -42,35 +42,21 @@ export async function createHeaderValue({
 export async function verifyHeaderValue({data, headerValue}) {
   try {
     const {key, algorithm, encodedDigest} = _parseHeaderValue(headerValue);
-    const body = _normalizeData(data);
-    const {encodedDigest: expectedDigest} = await _createHeaderValueComponents(
-      {body, algorithm, useMultihash: key === 'mh'});
+    const {encodedDigest: expectedDigest} = await _createHeaderValueComponents({
+      data, algorithm, useMultihash: key === 'mh'
+    });
     return {verified: encodedDigest === expectedDigest};
   } catch(error) {
     return {verified: false, error};
   }
 }
 
-/**
- * Creates the digest header components.
- *
- * @param {object} options - The options to use.
- * @param {Blob} options.body - The request body.
- * @param {string} [options.algorithm] - The hash algorithm to use.
- * @param {boolean} [options.useMultihash=true] - Whether to serialize digest
- *   using multihash or not.
- *
- * @returns {Promise<object>} - The header key and encoded digest in an object.
- */
 async function _createHeaderValueComponents({
-  body, algorithm = 'sha256', useMultihash = true
+  data, algorithm = 'sha256', useMultihash = true
 }) {
   if(algorithm !== 'sha256') {
     throw new Error(`Algorithm "${algorithm}" is not supported.`);
   }
-  // `Blob.bytes()` is only available in node.js 22+;
-  // fallback to `Blob.arrayBuffer()`
-  const data = await (body?.bytes?.() ?? body.arrayBuffer());
   const digest = await _getDigest({data, algorithm});
   if(useMultihash) {
     return {key: 'mh', encodedDigest: _createMultihash({digest})};
@@ -112,25 +98,25 @@ function _parseHeaderValue(headerValue) {
 }
 
 async function _getDigest({data, algorithm}) {
+  data = await _normalizeData(data);
   if(algorithm === 'sha256') {
     return new Uint8Array(await crypto.subtle.digest({name: 'SHA-256'}, data));
   }
   throw new Error(`Algorithm "${algorithm}" is not unsupported.`);
 }
 
-// normalize all inputs to a Uint8Array for hashing
-function _normalizeData(data) {
+// normalize all inputs to a `Uint8Array` for hashing
+async function _normalizeData(data) {
   if(data instanceof Uint8Array) {
-    return new Blob([/** @type {ArrayBuffer} */ (data.buffer)]);
-  }
-  if(data instanceof ArrayBuffer) {
-    return new Blob([data]);
+    return data;
   }
-  if(typeof data === 'string') {
-    return new Blob([data], {type: 'application/json'});
+  if(data instanceof Blob) {
+    // `Blob.bytes()` is only available in node.js 22+;
+    // fallback to `Blob.arrayBuffer()`
+    return data?.bytes?.() ?? data.arrayBuffer();
   }
-  if(typeof data?.arrayBuffer === 'function') {
-    return data;
+  if(typeof data !== 'string') {
+    data = JSON.stringify(data);
   }
-  return new Blob([JSON.stringify(data)], {type: 'application/json'});
+  return (new TextEncoder()).encode(data);
 }

test/unit/httpDigest.spec.js

@@ -1,5 +1,5 @@
 /*!
- * Copyright (c) 2019-2020 Digital Bazaar, Inc. All rights reserved.
+ * Copyright (c) 2019-2025 Digital Bazaar, Inc. All rights reserved.
  */
 import {createHeaderValue, verifyHeaderValue} from '../../lib/index.js';
 
@@ -61,48 +61,31 @@ describe('http-signature-digest', () => {
     });
 
     it('should create a digest of a JSON blob', async () => {
-      const object = { hello: 'world' };
-      const data = new Blob([JSON.stringify(object)], { type: 'application/json' })
+      const object = {hello: 'world'};
+      const data = new Blob(
+        [JSON.stringify(object)], {type: 'application/json'});
       const objDigest = await createHeaderValue(
-        { data, algorithm: 'sha256', useMultihash: false }
-      );
+        {data, algorithm: 'sha256', useMultihash: false});
       objDigest.should
         .equal('SHA-256=k6I5cakU5erL8KjSUVTNownDwccvu5kU1Hxg88toFYg=');
     });
 
     it('should create a digest of a text/plain blob', async () => {
-      const object = { hello: 'world' };
-      const data = new Blob([JSON.stringify(object)], { type: 'text/plain' })
+      const object = {hello: 'world'};
+      const data = new Blob([JSON.stringify(object)], {type: 'text/plain'});
       const objDigest = await createHeaderValue(
-        { data, algorithm: 'sha256', useMultihash: false }
-      );
-      objDigest.should
-        .equal('SHA-256=k6I5cakU5erL8KjSUVTNownDwccvu5kU1Hxg88toFYg=');
-    });
-
-    it('should create a digest of an ArrayBuffer', async () => {
-      const object = { hello: 'world' };
-      const text = JSON.stringify(object)
-      const bytes = new TextEncoder().encode(text)
-      const data = bytes.buffer
-      should.equal(data instanceof ArrayBuffer, true, `data is a ArrayBuffer`)
-      should.equal(data instanceof Uint8Array, false, `data is not a Uint8Array`)
-      const objDigest = await createHeaderValue(
-        { data, algorithm: 'sha256', useMultihash: false }
-      );
+        {data, algorithm: 'sha256', useMultihash: false});
       objDigest.should
         .equal('SHA-256=k6I5cakU5erL8KjSUVTNownDwccvu5kU1Hxg88toFYg=');
     });
 
     it('should create a digest of a Uint8Array', async () => {
-      const object = { hello: 'world' };
-      const text = JSON.stringify(object)
-      const bytes = new TextEncoder().encode(text)
-      const data = bytes
-      should.equal(data instanceof Uint8Array, true, `data is a Uint8Array`)
+      const object = {hello: 'world'};
+      const text = JSON.stringify(object);
+      const data = new TextEncoder().encode(text);
+      should.equal(data instanceof Uint8Array, true, `data is a Uint8Array`);
       const objDigest = await createHeaderValue(
-        { data, algorithm: 'sha256', useMultihash: false }
-      );
+        {data, algorithm: 'sha256', useMultihash: false});
       objDigest.should
         .equal('SHA-256=k6I5cakU5erL8KjSUVTNownDwccvu5kU1Hxg88toFYg=');
     });