deno.land / std@0.166.0 / node / internal / crypto / hash.ts
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.// Copyright Joyent, Inc. and Node.js contributors. All rights reserved. MIT license.
import { DigestAlgorithm, DigestContext, instantiateWasm,} from "../../../crypto/_wasm/mod.ts";import { Buffer } from "../../buffer.ts";import { Transform } from "../../stream.ts";import { encode as encodeToHex } from "../../../encoding/hex.ts";import { encode as encodeToBase64 } from "../../../encoding/base64.ts";import { encode as encodeToBase64Url } from "../../../encoding/base64url.ts";import type { TransformOptions } from "../../_stream.d.ts";import { validateString } from "../validators.mjs";import type { BinaryToTextEncoding, Encoding } from "./types.ts";import { KeyObject, prepareSecretKey } from "./keys.ts";import { notImplemented } from "../../_utils.ts";
const coerceToBytes = (data: string | BufferSource): Uint8Array => { if (data instanceof Uint8Array) { return data; } else if (typeof data === "string") { // This assumes UTF-8, which may not be correct. return new TextEncoder().encode(data); } else if (ArrayBuffer.isView(data)) { return new Uint8Array(data.buffer, data.byteOffset, data.byteLength); } else if (data instanceof ArrayBuffer) { return new Uint8Array(data); } else { throw new TypeError("expected data to be string | BufferSource"); }};
/** * The Hash class is a utility for creating hash digests of data. It can be used in one of two ways: * * - As a stream that is both readable and writable, where data is written to produce a computed hash digest on the readable side, or * - Using the hash.update() and hash.digest() methods to produce the computed hash. * * The crypto.createHash() method is used to create Hash instances. Hash objects are not to be created directly using the new keyword. */export class Hash extends Transform { #context: DigestContext;
constructor( algorithm: string | DigestContext, _opts?: TransformOptions, ) { super({ transform(chunk: string, _encoding: string, callback: () => void) { context.update(coerceToBytes(chunk)); callback(); }, flush(callback: () => void) { this.push(context.digest(undefined)); callback(); }, });
if (typeof algorithm === "string") { // Node/OpenSSL and WebCrypto format some digest names differently; // we attempt to handle those here. algorithm = algorithm.toUpperCase(); if (opensslToWebCryptoDigestNames[algorithm]) { algorithm = opensslToWebCryptoDigestNames[algorithm]; } this.#context = new (instantiateWasm().DigestContext)( algorithm as DigestAlgorithm, ); } else { this.#context = algorithm; }
const context = this.#context; }
copy(): Hash { return new Hash(this.#context.clone()); }
/** * Updates the hash content with the given data. */ update(data: string | ArrayBuffer, _encoding?: string): this { let bytes; if (typeof data === "string") { data = new TextEncoder().encode(data); bytes = coerceToBytes(data); } else { bytes = coerceToBytes(data); }
this.#context.update(bytes);
return this; }
/** * Calculates the digest of all of the data. * * If encoding is provided a string will be returned; otherwise a Buffer is returned. * * Supported encodings are currently 'hex', 'binary', 'base64', 'base64url'. */ digest(encoding?: string): Buffer | string { const digest = this.#context.digest(undefined); if (encoding === undefined) { return Buffer.from(digest); }
switch (encoding) { case "hex": return new TextDecoder().decode(encodeToHex(new Uint8Array(digest))); case "binary": return String.fromCharCode(...digest); case "base64": return encodeToBase64(digest); case "base64url": return encodeToBase64Url(digest); case "buffer": return Buffer.from(digest); default: return Buffer.from(digest).toString(encoding); } }}
export function Hmac( hmac: string, key: string | ArrayBuffer | KeyObject, options?: TransformOptions,): Hmac { return new HmacImpl(hmac, key, options);}
type Hmac = HmacImpl;
class HmacImpl extends Transform { #ipad: Uint8Array; #opad: Uint8Array; #ZEROES = Buffer.alloc(128); #algorithm: string; #hash: Hash;
constructor( hmac: string, key: string | ArrayBuffer | KeyObject, options?: TransformOptions, ) { super({ transform(chunk: string, encoding: string, callback: () => void) { // deno-lint-ignore no-explicit-any self.update(coerceToBytes(chunk), encoding as any); callback(); }, flush(callback: () => void) { this.push(self.digest()); callback(); }, }); // deno-lint-ignore no-this-alias const self = this; if (key instanceof KeyObject) { notImplemented("Hmac: KeyObject key is not implemented"); }
validateString(hmac, "hmac"); const u8Key = prepareSecretKey(key, options?.encoding) as Buffer;
const alg = hmac.toLowerCase(); this.#hash = new Hash(alg, options); this.#algorithm = alg; const blockSize = (alg === "sha512" || alg === "sha384") ? 128 : 64; const keySize = u8Key.length;
let bufKey: Buffer;
if (keySize > blockSize) { bufKey = this.#hash.update(u8Key).digest() as Buffer; } else { bufKey = Buffer.concat([u8Key, this.#ZEROES], blockSize); }
this.#ipad = Buffer.allocUnsafe(blockSize); this.#opad = Buffer.allocUnsafe(blockSize);
for (let i = 0; i < blockSize; i++) { this.#ipad[i] = bufKey[i] ^ 0x36; this.#opad[i] = bufKey[i] ^ 0x5C; }
this.#hash = new Hash(alg); this.#hash.update(this.#ipad); }
digest(): Buffer; digest(encoding: BinaryToTextEncoding): string; digest(encoding?: BinaryToTextEncoding): Buffer | string { const result = this.#hash.digest();
return new Hash(this.#algorithm).update(this.#opad).update(result).digest( encoding, ); }
update(data: string | ArrayBuffer, inputEncoding?: Encoding): this { this.#hash.update(data, inputEncoding); return this; }}
Hmac.prototype = HmacImpl.prototype;
/** * Supported digest names that OpenSSL/Node and WebCrypto identify differently. */const opensslToWebCryptoDigestNames: Record<string, DigestAlgorithm> = { BLAKE2B256: "BLAKE2B-256", BLAKE2B384: "BLAKE2B-384", BLAKE2B512: "BLAKE2B", BLAKE2S256: "BLAKE2S", RIPEMD160: "RIPEMD-160", RMD160: "RIPEMD-160", SHA1: "SHA-1", SHA224: "SHA-224", SHA256: "SHA-256", SHA384: "SHA-384", SHA512: "SHA-512",};
/** * Creates and returns a Hash object that can be used to generate hash digests * using the given `algorithm`. Optional `options` argument controls stream behavior. */export function createHash(algorithm: string, opts?: TransformOptions) { return new Hash(algorithm, opts);}
export default { Hash, Hmac, createHash,};
std
Version Info
a year ago
