diff options
| -rw-r--r-- | .prettierignore | 1 | ||||
| -rw-r--r-- | Cargo.toml | 3 | ||||
| -rw-r--r-- | cli/tests/hash.ts | 62 | ||||
| -rw-r--r-- | std/hash/README.md | 99 | ||||
| -rw-r--r-- | std/hash/_wasm/Cargo.lock | 301 | ||||
| -rw-r--r-- | std/hash/_wasm/Cargo.toml | 26 | ||||
| -rw-r--r-- | std/hash/_wasm/README.md | 17 | ||||
| -rw-r--r-- | std/hash/_wasm/build.ts | 48 | ||||
| -rw-r--r-- | std/hash/_wasm/hash.ts | 76 | ||||
| -rw-r--r-- | std/hash/_wasm/src/lib.rs | 51 | ||||
| -rw-r--r-- | std/hash/_wasm/wasm.js | 247 | ||||
| -rw-r--r-- | std/hash/hash_test.ts | 316 | ||||
| -rw-r--r-- | std/hash/hasher.ts | 10 | ||||
| -rw-r--r-- | std/hash/mod.ts | 34 | ||||
| -rw-r--r-- | tools/hash_benchmark.py | 49 |
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() |