Implement crypto.DigestStream

Author: mrbbot

packages/core/src/standards/crypto.ts

@@ -1,5 +1,50 @@
 import { createHash, webcrypto } from "crypto";
+import { WritableStream } from "stream/web";
+import { DOMException } from "@miniflare/core";
 import { viewToBuffer } from "@miniflare/shared";
+import {
+  bufferSourceToArray,
+  buildNotBufferSourceError,
+  isBufferSource,
+} from "./helpers";
+
+// https://developers.cloudflare.com/workers/runtime-apis/web-crypto#supported-algorithms
+const supportedDigests = ["sha-1", "sha-256", "sha-384", "sha-512", "md5"];
+
+export class DigestStream extends WritableStream<BufferSource> {
+  readonly digest: Promise<ArrayBuffer>;
+
+  constructor(algorithm: AlgorithmIdentifier) {
+    // Check algorithm supported by Cloudflare Workers
+    let name = typeof algorithm === "string" ? algorithm : algorithm?.name;
+    if (!(name && supportedDigests.includes(name.toLowerCase()))) {
+      throw new DOMException("Unrecognized name.", "NotSupportedError");
+    }
+    // createHash expects "shaN" instead of "sha-N"
+    name = name.replace("-", "");
+
+    // Create deferred promise to resolve digest once stream is closed
+    let digestResolve: (digest: ArrayBuffer) => void;
+    const digest = new Promise<ArrayBuffer>((r) => (digestResolve = r));
+
+    // Create hasher and initialise stream
+    const hash = createHash(name);
+    super({
+      write(chunk: unknown) {
+        if (isBufferSource(chunk)) {
+          hash.update(bufferSourceToArray(chunk));
+        } else {
+          throw new TypeError(buildNotBufferSourceError(chunk));
+        }
+      },
+      close() {
+        digestResolve(viewToBuffer(hash.digest()));
+      },
+    });
+
+    this.digest = digest;
+  }
+}
 
 // Workers support non-standard MD5 digests
 function digest(
@@ -27,6 +72,7 @@ const subtle = new Proxy(webcrypto.subtle, {
 export const crypto = new Proxy(webcrypto, {
   get(target, propertyKey, receiver) {
     if (propertyKey === "subtle") return subtle;
+    if (propertyKey === "DigestStream") return DigestStream;
     return Reflect.get(target, propertyKey, receiver);
   },
 });

packages/core/src/standards/helpers.ts

@@ -0,0 +1,24 @@
+export function isBufferSource(chunk: unknown): chunk is BufferSource {
+  return chunk instanceof ArrayBuffer || ArrayBuffer.isView(chunk);
+}
+
+export function bufferSourceToArray(chunk: BufferSource): Uint8Array {
+  if (chunk instanceof Uint8Array) {
+    return chunk;
+  } else if (chunk instanceof ArrayBuffer) {
+    return new Uint8Array(chunk);
+  } else {
+    return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+  }
+}
+
+export function buildNotBufferSourceError(value: unknown): string {
+  const isString = typeof value === "string";
+  return (
+    "This TransformStream is being used as a byte stream, but received " +
+    (isString
+      ? "a string on its writable side. If you wish to write a string, " +
+        "you'll probably want to explicitly UTF-8-encode it with TextEncoder."
+      : "an object of non-ArrayBuffer/ArrayBufferView type on its writable side.")
+  );
+}

packages/core/src/standards/http.ts

@@ -43,6 +43,11 @@ import {
 // @ts-expect-error we need these for making Request's Headers immutable
 import fetchSymbols from "undici/lib/fetch/symbols.js";
 import { IncomingRequestCfProperties, RequestInitCfProperties } from "./cf";
+import {
+  bufferSourceToArray,
+  buildNotBufferSourceError,
+  isBufferSource,
+} from "./helpers";
 
 const inspect = Symbol.for("nodejs.util.inspect.custom");
 const nonEnumerable = Object.create(null);
@@ -117,20 +122,6 @@ export function _isByteStream(
   return false;
 }
 
-function isBufferSource(chunk: unknown): chunk is BufferSource {
-  return chunk instanceof ArrayBuffer || ArrayBuffer.isView(chunk);
-}
-
-function bufferSourceToArray(chunk: BufferSource): Uint8Array {
-  if (chunk instanceof Uint8Array) {
-    return chunk;
-  } else if (chunk instanceof ArrayBuffer) {
-    return new Uint8Array(chunk);
-  } else {
-    return new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-  }
-}
-
 const enumerableBodyKeys: (keyof Body<any>)[] = ["body", "bodyUsed", "headers"];
 export class Body<Inner extends BaseRequest | BaseResponse> {
   /** @internal */
@@ -213,15 +204,8 @@ export class Body<Inner extends BaseRequest | BaseResponse> {
           }
         } else if (value) {
           // Otherwise, if it's not an ArrayBuffer(View), throw
-          const isString = typeof value === "string";
           return controller.error(
-            new TypeError(
-              "This TransformStream is being used as a byte stream, but received " +
-                (isString
-                  ? "a string on its writable side. If you wish to write a string, " +
-                    "you'll probably want to explicitly UTF-8-encode it with TextEncoder."
-                  : "an object of non-ArrayBuffer/ArrayBufferView type on its writable side.")
-            )
+            new TypeError(buildNotBufferSourceError(value))
           );
         }
 
@@ -422,7 +406,7 @@ export interface ResponseInit extends BaseResponseInit {
 const kWaitUntil = Symbol("kWaitUntil");
 
 // From https://github.com/nodejs/undici/blob/3f6b564b7d3023d506cad75b16207006b23956a8/lib/fetch/constants.js#L28, minus 101
-const nullBodyStatus = new Set<number | undefined>([204, 205, 304]);
+const nullBodyStatus: (number | undefined)[] = [204, 205, 304];
 
 const enumerableResponseKeys: (keyof Response)[] = [
   "encodeBody",
@@ -493,7 +477,7 @@ export class Response<
         // This zero-length body behavior is allowed because it was previously
         // the only way to construct a Response with a null body status. It may
         // change in the future.
-        if (nullBodyStatus.has(init.status) && body === "") body = null;
+        if (nullBodyStatus.includes(init.status) && body === "") body = null;
       }
       super(new BaseResponse(body, init));
     }

packages/core/test/standards/crypto.spec.ts

@@ -1,8 +1,72 @@
 import { TextEncoder } from "util";
-import { crypto } from "@miniflare/core";
+import { DOMException, DigestStream, crypto } from "@miniflare/core";
 import { utf8Encode } from "@miniflare/shared-test";
 import test, { Macro } from "ava";
 
+const digestStreamMacro: Macro<[AlgorithmIdentifier]> = async (
+  t,
+  algorithm
+) => {
+  const stream = new DigestStream(algorithm);
+  const writer = stream.getWriter();
+  await writer.write(utf8Encode("a"));
+  await writer.write(utf8Encode("bb"));
+  await writer.write(utf8Encode("ccc"));
+  await writer.close();
+  const digest = await stream.digest;
+
+  const expected = await crypto.subtle.digest(algorithm, utf8Encode("abbccc"));
+
+  t.deepEqual(digest, expected);
+};
+digestStreamMacro.title = (providedTitle, algorithm) =>
+  `DigestStream: computes ${JSON.stringify(algorithm)} digest`;
+test(digestStreamMacro, "SHA-1");
+test(digestStreamMacro, "Sha-256");
+test(digestStreamMacro, "sha-384");
+test(digestStreamMacro, "SHA-512");
+test(digestStreamMacro, "mD5");
+test(digestStreamMacro, { name: "ShA-1" });
+
+test("DigestStream: throws on unsupported algorithm", (t) => {
+  // Note md5 IS supported by Node's createHash
+  t.throws(() => new DigestStream("md4"), {
+    instanceOf: DOMException,
+    name: "NotSupportedError",
+    message: "Unrecognized name.",
+  });
+});
+
+test("DigestStream: throws on string chunks", async (t) => {
+  const stream = new DigestStream("sha-1");
+  const writer = stream.getWriter();
+  // @ts-expect-error intentionally testing incorrect types
+  await t.throwsAsync(async () => writer.write("a"), {
+    instanceOf: TypeError,
+    message:
+      "This TransformStream is being used as a byte stream, " +
+      "but received a string on its writable side. " +
+      "If you wish to write a string, you'll probably want to " +
+      "explicitly UTF-8-encode it with TextEncoder.",
+  });
+});
+test("DigestStream: throws on non-ArrayBuffer/ArrayBufferView chunks", async (t) => {
+  const stream = new DigestStream("sha-1");
+  const writer = stream.getWriter();
+  // @ts-expect-error intentionally testing incorrect types
+  await t.throwsAsync(async () => writer.write(42), {
+    instanceOf: TypeError,
+    message:
+      "This TransformStream is being used as a byte stream, " +
+      "but received an object of non-ArrayBuffer/ArrayBufferView " +
+      "type on its writable side.",
+  });
+});
+
+test("crypto: provides DigestStream", (t) => {
+  t.is(crypto.DigestStream, DigestStream);
+});
+
 const md5Macro: Macro<[BufferSource]> = async (t, data) => {
   const digest = await crypto.subtle.digest("md5", data);
   t.is(Buffer.from(digest).toString("hex"), "098f6bcd4621d373cade4e832627b4f6");

types/crypto.d.ts

@@ -45,5 +45,10 @@ declare module "crypto" {
   namespace webcrypto {
     const subtle: SubtleCrypto;
     function getRandomValues<T extends ArrayBufferView>(array: T): T;
+
+    class DigestStream {
+      constructor(algorithm: AlgorithmIdentifier);
+      readonly digest: Promise<ArrayBuffer>;
+    }
   }
 }