feat(std/hash): reimplement all hashes in WASM (#6292)

15 files changed, 1299 insertions, 41 deletions

diff --git a/.prettierignore b/.prettierignore
index 7795c3666..12d3a7aa7 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -6,3 +6,4 @@ cli/tests/swc_syntax_error.ts
 std/**/testdata
 std/**/vendor
 std/node_modules
+std/hash/_wasm
diff --git a/Cargo.toml b/Cargo.toml
index b273e4222..c26258ee8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,3 +6,6 @@ members = [
   "deno_typescript",
   "test_plugin"
 ]
+exclude = [
+  "std/hash/_wasm"
+]
diff --git a/cli/tests/hash.ts b/cli/tests/hash.ts
new file mode 100644
index 000000000..9c230dcfc
--- /dev/null
+++ b/cli/tests/hash.ts
@@ -0,0 +1,62 @@
+/* eslint-disable @typescript-eslint/camelcase, @typescript-eslint/no-explicit-any */
+
+const { args } = Deno;
+import { createHash, SupportedAlgorithm } from "../../std/hash/mod.ts";
+import { Md5 } from "../../std/hash/md5.ts";
+import { Sha1 } from "../../std/hash/sha1.ts";
+import { Sha256 } from "../../std/hash/sha256.ts";
+import { Sha512 } from "../../std/hash/sha512.ts";
+import { Sha3_224, Sha3_256, Sha3_384, Sha3_512 } from "../../std/hash/sha3.ts";
+
+if (args.length < 3) Deno.exit(0);
+
+const method = args[0];
+const alg = args[1];
+const inputFile = args[2];
+
+function getJsHash(alg: string): any {
+  switch (alg) {
+    case "md5":
+      return new Md5();
+    case "sha1":
+      return new Sha1();
+    case "sha224":
+      return new Sha256(true);
+    case "sha256":
+      return new Sha256();
+    case "sha3-224":
+      return new Sha3_224();
+    case "sha3-256":
+      return new Sha3_256();
+    case "sha3-384":
+      return new Sha3_384();
+    case "sha3-512":
+      return new Sha3_512();
+    case "sha512":
+      return new Sha512();
+    default:
+      return null;
+  }
+}
+
+const f = Deno.openSync(inputFile, { read: true });
+const buffer = Deno.readAllSync(f);
+f.close();
+
+let hash = null;
+
+console.time("hash");
+if (method === "rust") {
+  hash = createHash(alg as SupportedAlgorithm);
+} else if (method === "js") {
+  hash = getJsHash(alg);
+}
+
+if (hash === null) {
+  console.log(`unknown hash: ${alg}`);
+  Deno.exit(1);
+}
+
+hash.update(buffer);
+hash.digest();
+console.timeEnd("hash");
diff --git a/std/hash/README.md b/std/hash/README.md
index 5e511a97c..1716f0ffc 100644
--- a/std/hash/README.md
+++ b/std/hash/README.md
@@ -1,66 +1,83 @@
 # std/hash
 
-## MD5
+## Usage
 
-**Uses:**
+### Creating new hash instance
+
+You can create a new Hasher instance by calling `createHash` defined in mod.ts.
 
 ```ts
-import { Md5 } from "https://deno.land/std/hash/md5.ts";
+import { createHash } from "https://deno.land/std/hash/mod.ts";
 
-const md5 = new Md5();
-const md5Instance = md5.update("中文"); // return instance of `Md5`
-console.log(md5Instance instanceof Md5); // true
-console.log(md5Instance.toString()); // a7bac2239fcdcb3a067903d8077c4a07
+const hash = createHash("md5");
+// ...
 ```
 
-Calling `update` method, It will update internal state based on the input
-provided. Once you call `md5Instance.toString()`, it will return the
-`hash string`. You can provide format as `hash` or `base64`. The default format
-is `hex`.
+### Using hash instance
 
-**sample:**
+You can use `update` method to feed data into your hash instance. Call `digest`
+method to retrive final hash value in ArrayBuffer.
 
 ```ts
-console.log(md5Instance.toString("base64")); // MNgWOD+FHGO3Fff/HDCY2w==
-```
-
-## SHA1
+import { createHash } from "https://deno.land/std/hash/mod.ts";
 
-**Uses:**
+const hash = createHash("md5");
+hash.update("Your data here");
+const final = hash.digest(); // returns ArrayBuffer
+```
 
-Creating `sha1` hash is simple. You can use `Sha1` class instance and update the
-digest. Calling `hex` method will return the sha1 in hex value. You can also use
-`toString` method.
+Please note that `digest` invalidates the hash instance's internal state.
+Calling `digest` more than once will throw an Error.
 
 ```ts
-import { Sha1 } from "https://deno.land/std/hash/sha1.ts";
+import { createHash } from "https://deno.land/std/hash/mod.ts";
 
-const sha1 = new Sha1().update("中文");
-console.log(sha1.hex()); // 7be2d2d20c106eee0836c9bc2b939890a78e8fb3
-console.log(sha1.toString()); // same as above
+const hash = createHash("md5");
+hash.update("Your data here");
+const final1 = hash.digest(); // returns ArrayBuffer
+const final2 = hash.digest(); // throws Error
 ```
 
-## Sha256 and HmacSha256
-
-**Uses:**
+If you need final hash in string formats, call `toString` method with output
+format.
 
-Creating `Sha256` hash is simple. You can use `Sha256` class instance and update
-the digest. Calling the `hex` method will return the sha256 in `hex` value. You
-can also use the `toString` method.
-
-**Note:** For `HmacSha256`, you can pass the secret `key` while creating an
-instance of the object.
+Supported formats are `hex` and `base64` and default format is `hex`.
 
 ```ts
-import { Sha256, HmacSha256 } from "https://deno.land/std/hash/sha256.ts";
+import { createHash } from "https://deno.land/std/hash/mod.ts";
 
-const sha256 = new Sha256().update("中文");
-console.log(sha256.hex());
-console.log(sha256.toString()); // Same as above
+const hash = createHash("md5");
+hash.update("Your data here");
+const hashInHex = hash.toString(); // returns 5fe084ee423ff7e0c7709e9437cee89d
+```
 
-const key = "Hi There";
-const hmac = new HmacSha256(key).update("中文");
+```ts
+import { createHash } from "https://deno.land/std/hash/mod.ts";
 
-console.log(hmac.hex());
-console.log(hmac.toString()); // Same as above
+const hash = createHash("md5");
+hash.update("Your data here");
+const hashInBase64 = hash.toString("base64"); // returns X+CE7kI/9+DHcJ6UN87onQ==
 ```
+
+### Supported algorithms
+
+Following algorithms are supported.
+
+- md2
+- md4
+- md5
+- ripemd160
+- ripemd320
+- sha1
+- sha224
+- sha256
+- sha384
+- sha512
+- sha3-224
+- sha3-256
+- sha3-384
+- sha3-512
+- keccak224
+- keccak256
+- keccak384
+- keccak512
diff --git a/std/hash/_wasm/Cargo.lock b/std/hash/_wasm/Cargo.lock
new file mode 100644
index 000000000..884c29a74
--- /dev/null
+++ b/std/hash/_wasm/Cargo.lock
@@ -0,0 +1,301 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "block-buffer"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
+dependencies = [
+ "block-padding",
+ "byte-tools",
+ "byteorder",
+ "generic-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
+dependencies = [
+ "byte-tools",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e8c087f005730276d1096a652e92a8bacee2e2472bcc9715a74d2bec38b5820"
+
+[[package]]
+name = "byte-tools"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
+
+[[package]]
+name = "byteorder"
+version = "1.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "deno-hash"
+version = "0.1.0"
+dependencies = [
+ "digest",
+ "md-5",
+ "md2",
+ "md4",
+ "ripemd160",
+ "ripemd320",
+ "sha-1",
+ "sha2",
+ "sha3",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "digest"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "fake-simd"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
+
+[[package]]
+name = "generic-array"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c68f0274ae0e023facc3c97b2e00f076be70e254bc851d972503b328db79b2ec"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "keccak"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67c21572b4949434e4fc1e1978b99c5f77064153c59d998bf13ecd96fb5ecba7"
+
+[[package]]
+name = "lazy_static"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+
+[[package]]
+name = "log"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "md-5"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a18af3dcaf2b0219366cdb4e2af65a6101457b415c3d1a5c71dd9c2b7c77b9c8"
+dependencies = [
+ "block-buffer",
+ "digest",
+ "opaque-debug",
+]
+
+[[package]]
+name = "md2"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f130b74b5f0b05ffd405280ed1a9c2e4539fc3ca01f37b9ea947cd64922116e9"
+dependencies = [
+ "block-buffer",
+ "digest",
+ "opaque-debug",
+]
+
+[[package]]
+name = "md4"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4030c65cf2aab7ada769cae7d1e7159f8d034d6ded4f39afba037f094bfd9a1"
+dependencies = [
+ "block-buffer",
+ "digest",
+ "fake-simd",
+ "opaque-debug",
+]
+
+[[package]]
+name = "opaque-debug"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "beae6331a816b1f65d04c45b078fd8e6c93e8071771f41b8163255bbd8d7c8fa"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ripemd160"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad5112e0dbbb87577bfbc56c42450235e3012ce336e29c5befd7807bd626da4a"
+dependencies = [
+ "block-buffer",
+ "digest",
+ "opaque-debug",
+]
+
+[[package]]
+name = "ripemd320"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d1df357078db685e0a2d14b0eac053da79878026bb205da7050d8a5168e208b"
+dependencies = [
+ "block-buffer",
+ "digest",
+ "opaque-debug",
+]
+
+[[package]]
+name = "sha-1"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7d94d0bede923b3cea61f3f1ff57ff8cdfd77b400fb8f9998949e0cf04163df"
+dependencies = [
+ "block-buffer",
+ "digest",
+ "fake-simd",
+ "opaque-debug",
+]
+
+[[package]]
+name = "sha2"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a256f46ea78a0c0d9ff00077504903ac881a1dafdc20da66545699e7776b3e69"
+dependencies = [
+ "block-buffer",
+ "digest",
+ "fake-simd",
+ "opaque-debug",
+]
+
+[[package]]
+name = "sha3"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd26bc0e7a2e3a7c959bc494caf58b72ee0c71d67704e9520f736ca7e4853ecf"
+dependencies = [
+ "block-buffer",
+ "byte-tools",
+ "digest",
+ "keccak",
+ "opaque-debug",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5304cfdf27365b7585c25d4af91b35016ed21ef88f17ced89c7093b43dba8b6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-xid",
+]
+
+[[package]]
+name = "typenum"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "373c8a200f9e67a0c95e62a4f52fbf80c23b4381c05a17845531982fa99e6b33"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c2dc4aa152834bc334f506c1a06b866416a8b6697d5c9f75b9a689c8486def0"
+dependencies = [
+ "cfg-if",
+ "wasm-bindgen-macro",
+]
+
+[[package]]
+name = "wasm-bindgen-backend"
+version = "0.2.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ded84f06e0ed21499f6184df0e0cb3494727b0c5da89534e0fcc55c51d812101"
+dependencies = [
+ "bumpalo",
+ "lazy_static",
+ "log",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "838e423688dac18d73e31edce74ddfac468e37b1506ad163ffaf0a46f703ffe3"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3156052d8ec77142051a533cdd686cba889537b213f948cd1d20869926e68e92"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-backend",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.63"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9ba19973a58daf4db6f352eda73dc0e289493cd29fb2632eb172085b6521acd"
diff --git a/std/hash/_wasm/Cargo.toml b/std/hash/_wasm/Cargo.toml
new file mode 100644
index 000000000..d18df157b
--- /dev/null
+++ b/std/hash/_wasm/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "deno-hash"
+version = "0.1.0"
+authors = ["the Deno authors"]
+edition = "2018"
+license = "MIT"
+repository = "https://github.com/denoland/deno"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+digest = "0.8.1"
+md2 = "0.8"
+md4 = "0.8"
+md-5 = "0.8"
+ripemd160 = "0.8.0"
+ripemd320 = "0.8.0"
+sha-1 = "0.8.2"
+sha2 = "0.8.2"
+sha3 = "0.8.2"
+wasm-bindgen = "0.2.63"
+
+[profile.release]
+lto = true
+opt-level = "z"
diff --git a/std/hash/_wasm/README.md b/std/hash/_wasm/README.md
new file mode 100644
index 000000000..721e496d2
--- /dev/null
+++ b/std/hash/_wasm/README.md
@@ -0,0 +1,17 @@
+# How to build
+
+## Prerequisite
+
+`wasm-pack` is required.
+
+```sh
+cargo install wasm-pack
+```
+
+## Build
+
+```sh
+deno run --allow-read --allow-write --allow-run ./build.ts
+```
+
+`wasm.js` will be generated.
diff --git a/std/hash/_wasm/build.ts b/std/hash/_wasm/build.ts
new file mode 100644
index 000000000..eaa6a21dd
--- /dev/null
+++ b/std/hash/_wasm/build.ts
@@ -0,0 +1,48 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+import { encode as base64Encode } from "../../encoding/base64.ts";
+
+// 1. build wasm
+async function buildWasm(path: string): Promise<void> {
+  const cmd = [
+    "wasm-pack",
+    "build",
+    "--target",
+    "web",
+    "--release",
+    "-d",
+    path,
+  ];
+  const builder = Deno.run({ cmd });
+  const status = await builder.status();
+
+  if (!status.success) {
+    console.error(`Failed to build wasm: ${status.code}`);
+    Deno.exit(1);
+  }
+}
+
+// 2. encode wasm
+async function encodeWasm(wasmPath: string): Promise<string> {
+  const wasm = await Deno.readFile(`${wasmPath}/deno_hash_bg.wasm`);
+  return base64Encode(wasm);
+}
+
+// 3. generate script
+async function generate(wasm: string, output: string): Promise<void> {
+  const initScript = await Deno.readTextFile(`${output}/deno_hash.js`);
+  const denoHashScript =
+    "/* eslint-disable */\n" +
+    "//deno-fmt-ignore-file\n" +
+    `import * as base64 from "../../encoding/base64.ts";` +
+    `export const source = base64.decode("${wasm}");` +
+    initScript;
+
+  await Deno.writeFile("wasm.js", new TextEncoder().encode(denoHashScript));
+}
+
+const OUTPUT_DIR = "./out";
+
+await buildWasm(OUTPUT_DIR);
+const wasm = await encodeWasm(OUTPUT_DIR);
+await generate(wasm, OUTPUT_DIR);
diff --git a/std/hash/_wasm/hash.ts b/std/hash/_wasm/hash.ts
new file mode 100644
index 000000000..d04a4d4a0
--- /dev/null
+++ b/std/hash/_wasm/hash.ts
@@ -0,0 +1,76 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+import init, {
+  source,
+  create_hash as createHash,
+  update_hash as updateHash,
+  digest_hash as digestHash,
+  DenoHash,
+} from "./wasm.js";
+
+import * as hex from "../../encoding/hex.ts";
+import * as base64 from "../../encoding/base64.ts";
+import { Hasher, Message, OutputFormat } from "../hasher.ts";
+
+await init(source);
+
+const TYPE_ERROR_MSG = "hash: `data` is invalid type";
+
+export class Hash implements Hasher {
+  #hash: DenoHash;
+  #digested: boolean;
+
+  constructor(algorithm: string) {
+    this.#hash = createHash(algorithm);
+    this.#digested = false;
+  }
+
+  /**
+   * Update internal state
+   * @param data data to update
+   */
+  update(data: Message): this {
+    let msg: Uint8Array;
+
+    if (typeof data === "string") {
+      msg = new TextEncoder().encode(data as string);
+    } else if (typeof data === "object") {
+      if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+        msg = new Uint8Array(data);
+      } else {
+        throw new Error(TYPE_ERROR_MSG);
+      }
+    } else {
+      throw new Error(TYPE_ERROR_MSG);
+    }
+
+    updateHash(this.#hash, msg);
+
+    return this;
+  }
+
+  /** Returns final hash */
+  digest(): ArrayBuffer {
+    if (this.#digested) throw new Error("hash: already digested");
+
+    this.#digested = true;
+    return digestHash(this.#hash);
+  }
+
+  /**
+   * Returns hash as a string of given format
+   * @param format format of output string (hex or base64). Default is hex
+   */
+  toString(format: OutputFormat = "hex"): string {
+    const finalized = new Uint8Array(this.digest());
+
+    switch (format) {
+      case "hex":
+        return hex.encodeToString(finalized);
+      case "base64":
+        return base64.encode(finalized);
+      default:
+        throw new Error("hash: invalid format");
+    }
+  }
+}
diff --git a/std/hash/_wasm/src/lib.rs b/std/hash/_wasm/src/lib.rs
new file mode 100644
index 000000000..5ada7e68a
--- /dev/null
+++ b/std/hash/_wasm/src/lib.rs
@@ -0,0 +1,51 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+use digest::{Digest, DynDigest};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub struct DenoHash {
+  inner: Box<dyn DynDigest>,
+}
+
+#[wasm_bindgen]
+pub fn create_hash(algorithm: &str) -> Result<DenoHash, JsValue> {
+  let hash: Option<Box<dyn DynDigest>> = match algorithm {
+    "md2" => Some(Box::new(md2::Md2::new())),
+    "md4" => Some(Box::new(md4::Md4::new())),
+    "md5" => Some(Box::new(md5::Md5::new())),
+    "ripemd160" => Some(Box::new(ripemd160::Ripemd160::new())),
+    "ripemd320" => Some(Box::new(ripemd320::Ripemd320::new())),
+    "sha1" => Some(Box::new(sha1::Sha1::new())),
+    "sha224" => Some(Box::new(sha2::Sha224::new())),
+    "sha256" => Some(Box::new(sha2::Sha256::new())),
+    "sha384" => Some(Box::new(sha2::Sha384::new())),
+    "sha512" => Some(Box::new(sha2::Sha512::new())),
+    "sha3-224" => Some(Box::new(sha3::Sha3_224::new())),
+    "sha3-256" => Some(Box::new(sha3::Sha3_256::new())),
+    "sha3-384" => Some(Box::new(sha3::Sha3_384::new())),
+    "sha3-512" => Some(Box::new(sha3::Sha3_512::new())),
+    "keccak224" => Some(Box::new(sha3::Keccak224::new())),
+    "keccak256" => Some(Box::new(sha3::Keccak256::new())),
+    "keccak384" => Some(Box::new(sha3::Keccak384::new())),
+    "keccak512" => Some(Box::new(sha3::Keccak512::new())),
+    _ => None,
+  };
+
+  if let Some(h) = hash {
+    Ok(DenoHash { inner: h })
+  } else {
+    let err_msg = format!("unsupported hash algorithm: {}", algorithm);
+    Err(JsValue::from_str(&err_msg))
+  }
+}
+
+#[wasm_bindgen]
+pub fn update_hash(hash: &mut DenoHash, data: &[u8]) {
+  hash.inner.input(data)
+}
+
+#[wasm_bindgen]
+pub fn digest_hash(hash: &mut DenoHash) -> Box<[u8]> {
+  hash.inner.result_reset()
+}
diff --git a/std/hash/_wasm/wasm.js b/std/hash/_wasm/wasm.js
new file mode 100644
index 000000000..e8cddfad3
--- /dev/null
+++ b/std/hash/_wasm/wasm.js
@@ -0,0 +1,247 @@
+/* eslint-disable */
+//deno-fmt-ignore-file
+import * as base64 from "../../encoding/base64.ts";export const source = base64.decode("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");
+let wasm;
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+let cachegetUint8Memory0 = null;
+function getUint8Memory0() {
+    if (cachegetUint8Memory0 === null || cachegetUint8Memory0.buffer !== wasm.memory.buffer) {
+        cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachegetUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+const heap = new Array(32).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function dropObject(idx) {
+    if (idx < 36) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let cachedTextEncoder = new TextEncoder('utf-8');
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length);
+        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len);
+
+    const mem = getUint8Memory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3);
+        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+        const ret = encodeString(arg, view);
+
+        offset += ret.written;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+/**
+* @param {string} algorithm
+* @returns {DenoHash}
+*/
+export function create_hash(algorithm) {
+    var ptr0 = passStringToWasm0(algorithm, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ret = wasm.create_hash(ptr0, len0);
+    return DenoHash.__wrap(ret);
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+    return instance.ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1);
+    getUint8Memory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+* @param {DenoHash} hash
+* @param {Uint8Array} data
+*/
+export function update_hash(hash, data) {
+    _assertClass(hash, DenoHash);
+    var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+    var len0 = WASM_VECTOR_LEN;
+    wasm.update_hash(hash.ptr, ptr0, len0);
+}
+
+let cachegetInt32Memory0 = null;
+function getInt32Memory0() {
+    if (cachegetInt32Memory0 === null || cachegetInt32Memory0.buffer !== wasm.memory.buffer) {
+        cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachegetInt32Memory0;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
+}
+/**
+* @param {DenoHash} hash
+* @returns {Uint8Array}
+*/
+export function digest_hash(hash) {
+    _assertClass(hash, DenoHash);
+    wasm.digest_hash(8, hash.ptr);
+    var r0 = getInt32Memory0()[8 / 4 + 0];
+    var r1 = getInt32Memory0()[8 / 4 + 1];
+    var v0 = getArrayU8FromWasm0(r0, r1).slice();
+    wasm.__wbindgen_free(r0, r1 * 1);
+    return v0;
+}
+
+/**
+*/
+export class DenoHash {
+
+    static __wrap(ptr) {
+        const obj = Object.create(DenoHash.prototype);
+        obj.ptr = ptr;
+
+        return obj;
+    }
+
+    free() {
+        const ptr = this.ptr;
+        this.ptr = 0;
+
+        wasm.__wbg_denohash_free(ptr);
+    }
+}
+
+async function load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+async function init(input) {
+    if (typeof input === 'undefined') {
+        input = import.meta.url.replace(/\.js$/, '_bg.wasm');
+    }
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        var ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_rethrow = function(arg0) {
+        throw takeObject(arg0);
+    };
+
+    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
+        input = fetch(input);
+    }
+
+    const { instance, module } = await load(await input, imports);
+
+    wasm = instance.exports;
+    init.__wbindgen_wasm_module = module;
+
+    return wasm;
+}
+
+export default init;
+
diff --git a/std/hash/hash_test.ts b/std/hash/hash_test.ts
new file mode 100644
index 000000000..5169c2107
--- /dev/null
+++ b/std/hash/hash_test.ts
@@ -0,0 +1,316 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+import { assertEquals, assertThrows } from "../testing/asserts.ts";
+import { createHash, SupportedAlgorithm } from "./mod.ts";
+
+const millionAs = "a".repeat(1000000);
+
+const testSetHex: Record<string, string[][]> = {
+  md5: [
+    ["", "d41d8cd98f00b204e9800998ecf8427e"],
+    ["abc", "900150983cd24fb0d6963f7d28e17f72"],
+    ["deno", "c8772b401bc911da102a5291cc4ec83b"],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "9e107d9d372bb6826bd81d3542a419d6",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "3b0c8ac703f828b04c6c197006d17218",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "014842d480b571495a4a0363793f7367",
+    ],
+    [millionAs, "7707d6ae4e027c70eea2a935c2296f21"],
+  ],
+  sha1: [
+    ["", "da39a3ee5e6b4b0d3255bfef95601890afd80709"],
+    ["abc", "a9993e364706816aba3e25717850c26c9cd0d89d"],
+    ["deno", "bb3d8e712d9e7ad4af08d4a38f3f52d9683d58eb"],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "c2db330f6083854c99d4b5bfb6e8f29f201be699",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "0098ba824b5c16427bd7a1122a5a442a25ec644d",
+    ],
+    [millionAs, "34aa973cd4c4daa4f61eeb2bdbad27316534016f"],
+  ],
+  sha256: [
+    ["", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"],
+    ["abc", "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"],
+    [
+      "deno",
+      "e872e7bd2ae6abcf13a4c834029a342c882c1162ebf77b6720968b2000312ffb",
+    ],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "b35439a4ac6f0948b6d6f9e3c6af0f5f590ce20f1bde7090ef7970686ec6738a",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "ffe054fe7ae0cb6dc65c3af9b61d5209f439851db43d0ba5997337df154668eb",
+    ],
+    [
+      millionAs,
+      "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0",
+    ],
+  ],
+  sha512: [
+    [
+      "",
+      "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e",
+    ],
+    [
+      "abc",
+      "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f",
+    ],
+    [
+      "deno",
+      "05b6ef7b13673c57c455d968cb7acbdd4fe10e24f25520763d69025d768d14124987b14e3aff8ff1565aaeba1c405fc89cc435938ff46a426f697b0f509e3799",
+    ],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb642e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "962b64aae357d2a4fee3ded8b539bdc9d325081822b0bfc55583133aab44f18bafe11d72a7ae16c79ce2ba620ae2242d5144809161945f1367f41b3972e26e04",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "01d35c10c6c38c2dcf48f7eebb3235fb5ad74a65ec4cd016e2354c637a8fb49b695ef3c1d6f7ae4cd74d78cc9c9bcac9d4f23a73019998a7f73038a5c9b2dbde",
+    ],
+    [
+      millionAs,
+      "e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b",
+    ],
+  ],
+  "sha3-256": [
+    ["", "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a"],
+    ["abc", "3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532"],
+    [
+      "deno",
+      "74a6286af90f8775d74080f864cf80b11eecf6f14d325c5ef8c9f7ccc8055517",
+    ],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "69070dda01975c8c120c3aada1b282394e7f032fa9cf32f4cb2259a0897dfc04",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "f6fe8de5c8f5014786f07e9f7b08130f920dd55e587d47021686b26cf2323deb",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "043d104b5480439c7acff8831ee195183928d9b7f8fcb0c655a086a87923ffee",
+    ],
+    [
+      millionAs,
+      "5c8875ae474a3634ba4fd55ec85bffd661f32aca75c6d699d0cdcb6c115891c1",
+    ],
+  ],
+  "sha3-512": [
+    [
+      "",
+      "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26",
+    ],
+    [
+      "abc",
+      "b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0",
+    ],
+    [
+      "deno",
+      "9e248199d744a8d810e7fda8207f98f27453bd6cb5a02965b5477d3d07516bbac6831009eedddadc8901d742dbfe3fd4afa770230a84e4d51bf30a0c99efa03c",
+    ],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "01dedd5de4ef14642445ba5f5b97c15e47b9ad931326e4b0727cd94cefc44fff23f07bf543139939b49128caf436dc1bdee54fcb24023a08d9403f9b4bf0d450",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "302d75b7947aa354a54872df954dc0dfe673cf60faedebdea7e9b22263a3bdf39e346a4f2868639836955396f186a67b02ec8e3365bdf59867070f81849c2c35",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "2141e94c719955872c455c83eb83e7618a9b523a0ee9f118e794fbff8b148545c8e8caabef08d8cfdb1dfb36b4dd81cc48bfc77e7f85632197b882fd9c4384e0",
+    ],
+    [
+      millionAs,
+      "3c3a876da14034ab60627c077bb98f7e120a2a5370212dffb3385a18d4f38859ed311d0a9d5141ce9cc5c66ee689b266a8aa18ace8282a0e0db596c90b0a7b87",
+    ],
+  ],
+};
+
+const testSetBase64: Record<string, string[][]> = {
+  md5: [
+    ["", "1B2M2Y8AsgTpgAmY7PhCfg=="],
+    ["abc", "kAFQmDzST7DWlj99KOF/cg=="],
+    ["deno", "yHcrQBvJEdoQKlKRzE7IOw=="],
+    ["The quick brown fox jumps over the lazy dog", "nhB9nTcrtoJr2B01QqQZ1g=="],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "OwyKxwP4KLBMbBlwBtFyGA==",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "AUhC1IC1cUlaSgNjeT9zZw==",
+    ],
+    [millionAs, "dwfWrk4CfHDuoqk1wilvIQ=="],
+  ],
+  sha1: [
+    ["", "2jmj7l5rSw0yVb/vlWAYkK/YBwk="],
+    ["abc", "qZk+NkcGgWq6PiVxeFDCbJzQ2J0="],
+    ["deno", "uz2OcS2eetSvCNSjjz9S2Wg9WOs="],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "L9ThxnotKPzthJ7hu3bnORuT6xI=",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "wtszD2CDhUyZ1LW/tujynyAb5pk=",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "AJi6gktcFkJ716ESKlpEKiXsZE0=",
+    ],
+    [millionAs, "NKqXPNTE2qT2Husr260nMWU0AW8="],
+  ],
+  sha256: [
+    ["", "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU="],
+    ["abc", "ungWv48Bz+pBQUDeXa4iI7ADYaOWF3qctBD/YfIAFa0="],
+    ["deno", "6HLnvSrmq88TpMg0Apo0LIgsEWLr93tnIJaLIAAxL/s="],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "16j7swfXgJRpypq8sAguT41WUeRtPNt2LQLQvzfJ5ZI=",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "s1Q5pKxvCUi21vnjxq8PX1kM4g8b3nCQ73lwaG7Gc4o=",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "/+BU/nrgy23GXDr5th1SCfQ5hR20PQulmXM33xVGaOs=",
+    ],
+    [millionAs, "zcduXJkU+5KBocfihNc+Z/GAmkiklyAOBG05zMcRLNA="],
+  ],
+  sha512: [
+    [
+      "",
+      "z4PhNX7vuL3xVChQ1m2AB9Yg5AULVxXcg/SpIdNs6c5H0NE8XYXysP+DGNKHfuwvY7kxvUdBeoGlODJ6+SfaPg==",
+    ],
+    [
+      "abc",
+      "3a81oZNherrMQXNJriBBMRLm+k6JqX6iCp7u5ktV05ohkpkqJ0/BqDa6PCOj/uu9RU1EI2Q86A4qmslPpUyknw==",
+    ],
+    [
+      "deno",
+      "BbbvexNnPFfEVdloy3rL3U/hDiTyVSB2PWkCXXaNFBJJh7FOOv+P8VZarrocQF/InMQ1k4/0akJvaXsPUJ43mQ==",
+    ],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "B+VH2VhvanP3P7rAQ17XaVEhj7fQyNeIownXhUNru2Quk6JSqVTyORJUfR6KO17W4b/XCXghIz+gU489uFT+5g==",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "litkquNX0qT+497YtTm9ydMlCBgisL/FVYMTOqtE8Yuv4R1yp64Wx5ziumIK4iQtUUSAkWGUXxNn9Bs5cuJuBA==",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "AdNcEMbDjC3PSPfuuzI1+1rXSmXsTNAW4jVMY3qPtJtpXvPB1veuTNdNeMycm8rJ1PI6cwGZmKf3MDilybLb3g==",
+    ],
+    [
+      millionAs,
+      "5xhIPQznaWROLkLHvBW0Y44fmLE7IEQoVjKoA6+pc+veD/JEh36mCkywQyzld8Mb6wCcXCxJqi5OrbIXrYzAmw==",
+    ],
+  ],
+  "sha3-256": [
+    ["", "p//G+L8e12ZRwUdWoGHWYvWA/03kO0n6gtgKS4D4Q0o="],
+    ["abc", "Ophdp0/iJbIEXBcta9OQvYVfCG4+nVJbRr/iRRFDFTI="],
+    ["deno", "dKYoavkPh3XXQID4ZM+AsR7s9vFNMlxe+Mn3zMgFVRc="],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "aQcN2gGXXIwSDDqtobKCOU5/Ay+pzzL0yyJZoIl9/AQ=",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "9v6N5cj1AUeG8H6fewgTD5IN1V5YfUcCFoaybPIyPes=",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "BD0QS1SAQ5x6z/iDHuGVGDko2bf4/LDGVaCGqHkj/+4=",
+    ],
+    [millionAs, "XIh1rkdKNjS6T9VeyFv/1mHzKsp1xtaZ0M3LbBFYkcE="],
+  ],
+  "sha3-512": [
+    [
+      "",
+      "pp9zzKI6msXItWfcGFp1bpfJghZP4lhZ4NHcwUdcgKYVshI68fX5TBHj6UAsOsVY9QAZnZW20+MBdYWGKB3NJg==",
+    ],
+    [
+      "abc",
+      "t1GFCxpXFopWk82SS2sJbgj2IYJ0RPcNiE9dAkDScS4Q4RbpGSrzyRp+xXZH45NAVzQLTPQI1aVlkvgnTuxT8A==",
+    ],
+    [
+      "deno",
+      "niSBmddEqNgQ5/2oIH+Y8nRTvWy1oClltUd9PQdRa7rGgxAJ7t3a3IkB10Lb/j/Ur6dwIwqE5NUb8woMme+gPA==",
+    ],
+    [
+      "The quick brown fox jumps over the lazy dog",
+      "Ad7dXeTvFGQkRbpfW5fBXke5rZMTJuSwcnzZTO/ET/8j8Hv1QxOZObSRKMr0Ntwb3uVPyyQCOgjZQD+bS/DUUA==",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "MC11t5R6o1SlSHLflU3A3+Zzz2D67evep+myImOjvfOeNGpPKGhjmDaVU5bxhqZ7AuyOM2W99ZhnBw+BhJwsNQ==",
+    ],
+    [
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "IUHpTHGZVYcsRVyD64PnYYqbUjoO6fEY55T7/4sUhUXI6Mqr7wjYz9sd+za03YHMSL/Hfn+FYyGXuIL9nEOE4A==",
+    ],
+    [
+      millionAs,
+      "PDqHbaFANKtgYnwHe7mPfhIKKlNwIS3/szhaGNTziFntMR0KnVFBzpzFxm7mibJmqKoYrOgoKg4NtZbJCwp7hw==",
+    ],
+  ],
+};
+
+Deno.test("[hash/all/hex] testAllHex", () => {
+  for (const algorithm in testSetHex) {
+    for (const [input, output] of testSetHex[algorithm]) {
+      const hash = createHash(algorithm as SupportedAlgorithm);
+      assertEquals(hash.update(input).toString(), output);
+    }
+  }
+});
+
+Deno.test("[hash/all/base64] testAllHex", () => {
+  for (const algorithm in testSetBase64) {
+    for (const [input, output] of testSetBase64[algorithm]) {
+      const hash = createHash(algorithm as SupportedAlgorithm);
+      assertEquals(hash.update(input).toString("base64"), output);
+    }
+  }
+});
+
+Deno.test("[hash/double_digest] testDoubleDigest", () => {
+  assertThrows(
+    (): void => {
+      const hash = createHash("md5");
+      hash.update("test");
+      const h1 = hash.digest();
+      const h2 = hash.digest();
+      assertEquals(h1, h2);
+    },
+    Error,
+    "hash: already digested"
+  );
+});
diff --git a/std/hash/hasher.ts b/std/hash/hasher.ts
new file mode 100644
index 000000000..2d941d38f
--- /dev/null
+++ b/std/hash/hasher.ts
@@ -0,0 +1,10 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+export type Message = string | ArrayBuffer;
+export type OutputFormat = "hex" | "base64";
+
+export interface Hasher {
+  update(data: Message): this;
+  digest(): ArrayBuffer;
+  toString(format?: OutputFormat): string;
+}
diff --git a/std/hash/mod.ts b/std/hash/mod.ts
new file mode 100644
index 000000000..946769f03
--- /dev/null
+++ b/std/hash/mod.ts
@@ -0,0 +1,34 @@
+// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+
+import { Hash } from "./_wasm/hash.ts";
+import { Hasher } from "./hasher.ts";
+
+export { Hasher } from "./hasher.ts";
+export type SupportedAlgorithm =
+  | "md2"
+  | "md4"
+  | "md5"
+  | "ripemd160"
+  | "ripemd320"
+  | "sha1"
+  | "sha224"
+  | "sha256"
+  | "sha384"
+  | "sha512"
+  | "sha3-224"
+  | "sha3-256"
+  | "sha3-384"
+  | "sha3-512"
+  | "keccak224"
+  | "keccak256"
+  | "keccak384"
+  | "keccak512";
+
+/**
+ * Creates a new `Hash` instance.
+ *
+ * @param algorithm name of hash algorithm to use
+ */
+export function createHash(algorithm: SupportedAlgorithm): Hasher {
+  return new Hash(algorithm as string);
+}
diff --git a/tools/hash_benchmark.py b/tools/hash_benchmark.py
new file mode 100644
index 000000000..8dd3ccf0b
--- /dev/null
+++ b/tools/hash_benchmark.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+# Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
+# Performs benchmark on hash algorithms
+
+import os
+import sys
+import time
+import subprocess
+
+algorithms = [
+    "md5",
+    "sha1",
+    "sha224",
+    "sha256",
+    "sha512",
+    "sha3-224",
+    "sha3-256",
+    "sha3-384",
+    "sha3-512",
+]
+
+
+def run_benchmark(deno_exe, method, input_file):
+    # compile
+    subprocess.call([deno_exe, "run", "cli/tests/hash.ts"])
+
+    for alg in algorithms:
+        args = [
+            deno_exe, "run", "--allow-read", "cli/tests/hash.ts", method, alg,
+            input_file
+        ]
+
+        p = subprocess.Popen(args, stdout=subprocess.PIPE)
+        (out, _) = p.communicate()
+
+        elapsed = out.split(':')[1].strip()
+        print "[{}] {}".format(alg, elapsed)
+
+
+def main():
+    if len(sys.argv) < 4:
+        print "Usage ./tools/hash_benchmark.py path/to/deno method input"
+        sys.exit(1)
+
+    run_benchmark(sys.argv[1], sys.argv[2], sys.argv[3])
+
+
+if __name__ == '__main__':
+    main()