visaljs 0.0.0-stage → 0.0.2

package/node/prelude/internal/crypto/asym.js

@@ -0,0 +1,333 @@
+// node:crypto's asymmetric operations (ADR 0018): Sign and Verify (Writable streams, as Node's),
+// sign and verify, publicEncrypt, privateDecrypt, privateEncrypt and publicDecrypt, ECDH,
+// diffieHellman and getCurves: Node's lib/internal/crypto/{sig,cipher,diffiehellman}.js over the
+// runtime's C (crypto_asym.c), which signs digests: the hashing is the Hash primitives'.
+import {
+  cryptoDigestFinal, cryptoDigestUpdate, cryptoEcdh, cryptoEcPoint, cryptoEcPrivate, cryptoHashNew, cryptoKeyGenerate, cryptoKeyParts,
+  cryptoRsaCrypt, cryptoSign, cryptoVerify,
+} from "visaljs:host";
+import { Writable } from "../../stream.js";
+import { codeError, invalidArgType, invalidArgValue, validateFunction, validateString } from "../errors.js";
+import { asymmetricKeyTypeOf, KeyObject, preparePrivateKey, preparePublicOrPrivateKey, pssParamsOf } from "./keys.js";
+import { isAnyArrayBuffer, isArrayBufferView, kHandle, stringBytes, validateEncoding, validateObject } from "./util.js";
+
+const later = (fn) => setTimeout(fn, 0);
+
+/* the runtime's error codes (JS_ASYM_ERR_*), as Node reports each */
+function asymError(code, digest) {
+  switch (code) {
+    case 1: return codeError(Error, "ERR_OSSL_EVP_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE", "error:03000096:digital envelope routines::operation not supported for this keytype");
+    case 2: return codeError(TypeError, "ERR_CRYPTO_INVALID_DIGEST", digest === undefined ? "Invalid digest" : "Invalid digest: " + digest);
+    case 4: return codeError(Error, "ERR_OSSL_INVALID_SALT_LENGTH", "error:1C800070:Provider routines::invalid salt length");
+    case 5: return codeError(Error, "ERR_OSSL_RSA_DATA_TOO_LARGE_FOR_KEY_SIZE", "error:0200006E:rsa routines::data too large for key size");
+    case 6: return codeError(Error, "ERR_OSSL_RSA_DATA_TOO_SMALL_FOR_KEY_SIZE", "error:0200007A:rsa routines::data too small for key size");
+    case 7: return codeError(Error, "ERR_OSSL_RSA_OAEP_DECODING_ERROR", "error:02000079:rsa routines::oaep decoding error");
+    case 8: return codeError(Error, "ERR_OSSL_RSA_PADDING_CHECK_FAILED", "error:02000072:rsa routines::padding check failed");
+    case 9: return codeError(Error, "ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY", "Public key is not valid for specified curve");
+    case 10: return codeError(TypeError, "ERR_CRYPTO_INVALID_CURVE", "Invalid EC curve name");
+    default: return new Error("Crypto operation failed");
+  }
+}
+
+/** getArrayBufferOrView: a string in `encoding`, or the buffer or view. */
+function bytesOf(value, name, encoding) {
+  if (isAnyArrayBuffer(value) || isArrayBufferView(value)) return value;
+  if (typeof value === "string") return Buffer.from(value, encoding === undefined || encoding === "buffer" ? "utf8" : encoding);
+  throw invalidArgType(name, "of type string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView", value);
+}
+
+const encode = (buffer, encoding) => (encoding && encoding !== "buffer" ? buffer.toString(encoding) : buffer);
+
+/* ---- signing options --------------------------------------------------------------------------- */
+
+function getIntOption(name, options) {
+  const value = options[name];
+  if (value !== undefined) {
+    if (value === value >> 0) return value;
+    throw invalidArgValue(`options.${name}`, "is invalid", value);
+  }
+  return undefined;
+}
+
+function getDSASignatureEncoding(options) {
+  if (typeof options === "object") {
+    const { dsaEncoding = "der" } = options;
+    if (dsaEncoding === "der") return false;
+    if (dsaEncoding === "ieee-p1363") return true;
+    throw invalidArgValue("options.dsaEncoding", "is invalid", dsaEncoding);
+  }
+  return false;
+}
+
+/* The hash a signature uses: the one named, else the key's default (its PSS parameters', or SHA-256) */
+function hashFor(algorithm, handle) {
+  if (algorithm != null) return algorithm;
+  const pss = pssParamsOf(handle);
+  return pss ? pss[0] : "sha256";
+}
+
+function digestOf(hash, data) {
+  const h = cryptoHashNew(hash, undefined);
+  if (h === null) return null;
+  cryptoDigestUpdate(h, data);
+  return cryptoDigestFinal(h);
+}
+
+function signDigest(handle, hash, digest, options) {
+  const sig = cryptoSign(handle, hash, digest, getIntOption("padding", options), getIntOption("saltLength", options), getDSASignatureEncoding(options));
+  if (typeof sig === "number") throw asymError(sig, hash);
+  return sig;
+}
+
+function verifyDigest(handle, hash, digest, signature, options) {
+  const ok = cryptoVerify(handle, hash, digest, signature, getIntOption("padding", options), getIntOption("saltLength", options),
+    getDSASignatureEncoding(options));
+  if (typeof ok === "number") throw asymError(ok, hash);
+  return ok;
+}
+
+/* ---- Sign and Verify --------------------------------------------------------------------------- */
+
+const notInitialised = () => codeError(Error, "ERR_CRYPTO_INVALID_STATE", "Not initialised");
+
+function initDigest(self, algorithm, options) {
+  validateString(algorithm, "algorithm");
+  const handle = cryptoHashNew(algorithm, undefined);
+  if (handle === null) throw codeError(TypeError, "ERR_CRYPTO_INVALID_DIGEST", "Invalid digest");
+  self[kHandle] = { hash: handle, algorithm };
+  Writable.call(self, options);
+}
+
+function update(data, encoding) {
+  if (typeof data === "string") validateEncoding(data, encoding);
+  else if (!isArrayBufferView(data)) throw invalidArgType("data", "of type string or an instance of Buffer, TypedArray, or DataView", data);
+  if (this[kHandle].hash === null) throw notInitialised();
+  cryptoDigestUpdate(this[kHandle].hash, typeof data === "string" ? stringBytes(data, encoding) : data);
+  return this;
+}
+
+function _write(chunk, encoding, callback) {
+  this.update(chunk, encoding);
+  callback();
+}
+
+/* the accumulated digest, once */
+function takeDigest(self) {
+  const state = self[kHandle];
+  if (state.hash === null) throw notInitialised();
+  const digest = cryptoDigestFinal(state.hash);
+  state.hash = null;
+  return digest;
+}
+
+export function Sign(algorithm, options) {
+  if (!(this instanceof Sign)) return new Sign(algorithm, options);
+  initDigest(this, algorithm, options);
+}
+Object.setPrototypeOf(Sign.prototype, Writable.prototype);
+Object.setPrototypeOf(Sign, Writable);
+Sign.prototype._write = _write;
+Sign.prototype.update = update;
+Sign.prototype.sign = function sign(options, encoding) {
+  if (!options) throw codeError(Error, "ERR_CRYPTO_SIGN_KEY_REQUIRED", "No key provided to sign");
+  const handle = preparePrivateKey(options);
+  const ret = signDigest(handle, this[kHandle].algorithm, takeDigest(this), options);
+  return encode(ret, encoding);
+};
+
+export function Verify(algorithm, options) {
+  if (!(this instanceof Verify)) return new Verify(algorithm, options);
+  initDigest(this, algorithm, options);
+}
+Object.setPrototypeOf(Verify.prototype, Writable.prototype);
+Object.setPrototypeOf(Verify, Writable);
+Verify.prototype._write = _write;
+Verify.prototype.update = update;
+Verify.prototype.verify = function verify(options, signature, sigEncoding) {
+  const handle = preparePublicOrPrivateKey(options);
+  signature = bytesOf(signature, "signature", sigEncoding);
+  return verifyDigest(handle, this[kHandle].algorithm, takeDigest(this), signature, options);
+};
+
+export function createSign(algorithm, options) {
+  return new Sign(algorithm, options);
+}
+
+export function createVerify(algorithm, options) {
+  return new Verify(algorithm, options);
+}
+
+export function sign(algorithm, data, key, callback) {
+  if (algorithm != null) validateString(algorithm, "algorithm");
+  if (callback !== undefined) validateFunction(callback, "callback");
+  data = bytesOf(data, "data");
+  if (!key) throw codeError(Error, "ERR_CRYPTO_SIGN_KEY_REQUIRED", "No key provided to sign");
+  getIntOption("padding", key);
+  getIntOption("saltLength", key);
+  getDSASignatureEncoding(key);
+  const handle = preparePrivateKey(key);
+  const hash = hashFor(algorithm, handle);
+  const digest = digestOf(hash, data);
+  if (digest === null) throw asymError(2, hash);
+  if (callback === undefined) return signDigest(handle, hash, digest, key);
+  let result;
+  try {
+    result = signDigest(handle, hash, digest, key);
+  } catch (e) {
+    later(() => callback(e));
+    return;
+  }
+  later(() => callback(null, result));
+}
+
+export function verify(algorithm, data, key, signature, callback) {
+  if (algorithm != null) validateString(algorithm, "algorithm");
+  if (callback !== undefined) validateFunction(callback, "callback");
+  data = bytesOf(data, "data");
+  if (!isArrayBufferView(data)) throw invalidArgType("data", "an instance of Buffer, TypedArray, or DataView", data);
+  getIntOption("padding", key);
+  getIntOption("saltLength", key);
+  getDSASignatureEncoding(key);
+  if (!isArrayBufferView(signature)) throw invalidArgType("signature", "an instance of Buffer, TypedArray, or DataView", signature);
+  const handle = preparePublicOrPrivateKey(key);
+  const hash = hashFor(algorithm, handle);
+  const digest = digestOf(hash, data);
+  if (digest === null) throw asymError(2, hash);
+  if (callback === undefined) return verifyDigest(handle, hash, digest, signature, key);
+  let result;
+  try {
+    result = verifyDigest(handle, hash, digest, signature, key);
+  } catch (e) {
+    later(() => callback(e));
+    return;
+  }
+  later(() => callback(null, result));
+}
+
+/* ---- RSA encryption ---------------------------------------------------------------------------- */
+
+const OAEP = 4, PKCS1 = 1;
+
+function rsaFunctionFor(op, defaultPadding, wantPrivate) {
+  return (options, buffer) => {
+    const handle = wantPrivate ? preparePrivateKey(options) : preparePublicOrPrivateKey(options);
+    const padding = options.padding || defaultPadding;
+    const { oaepHash, encoding } = options;
+    let { oaepLabel } = options;
+    if (oaepHash !== undefined) validateString(oaepHash, "key.oaepHash");
+    if (oaepLabel !== undefined) oaepLabel = bytesOf(oaepLabel, "key.oaepLabel", encoding);
+    buffer = bytesOf(buffer, "buffer", encoding);
+    const ret = cryptoRsaCrypt(handle, op, buffer, padding, oaepHash, oaepLabel);
+    if (typeof ret === "number") throw asymError(ret, oaepHash);
+    return ret;
+  };
+}
+
+export const publicEncrypt = rsaFunctionFor(0, OAEP, false);
+export const privateDecrypt = rsaFunctionFor(1, OAEP, true);
+export const privateEncrypt = rsaFunctionFor(2, PKCS1, true);
+export const publicDecrypt = rsaFunctionFor(3, PKCS1, false);
+
+/* ---- ECDH -------------------------------------------------------------------------------------- */
+
+const CURVES = ["prime256v1", "secp384r1", "secp521r1"];
+
+export function getCurves() {
+  return CURVES.slice();
+}
+
+function getFormat(format) {
+  if (format) {
+    if (format === "compressed") return 2;
+    if (format === "hybrid") return 6;
+    if (format !== "uncompressed") throw codeError(TypeError, "ERR_CRYPTO_ECDH_INVALID_FORMAT", "Invalid ECDH format: " + format);
+  }
+  return 4;
+}
+
+export function ECDH(curve) {
+  if (!(this instanceof ECDH)) return new ECDH(curve);
+  validateString(curve, "curve");
+  if (!CURVES.includes(curve)) throw asymError(10);
+  this[kHandle] = { curve, key: null, publicPoint: null };
+}
+
+ECDH.prototype.generateKeys = function generateKeys(encoding, format) {
+  this[kHandle].key = cryptoKeyGenerate("ec", this[kHandle].curve);
+  this[kHandle].publicPoint = null;
+  return this.getPublicKey(encoding, format);
+};
+
+ECDH.prototype.getPublicKey = function getPublicKey(encoding, format) {
+  const f = getFormat(format);
+  const state = this[kHandle];
+  const point = state.key !== null ? cryptoKeyParts(state.key)[0] : state.publicPoint;
+  if (point == null) throw codeError(Error, "ERR_CRYPTO_OPERATION_FAILED", "Failed to get ECDH public key");
+  return encode(cryptoEcPoint(state.curve, point, f), encoding);
+};
+
+ECDH.prototype.getPrivateKey = function getPrivateKey(encoding) {
+  const state = this[kHandle];
+  if (state.key === null) throw codeError(Error, "ERR_CRYPTO_OPERATION_FAILED", "Failed to get ECDH private key");
+  return encode(cryptoKeyParts(state.key)[1], encoding);
+};
+
+ECDH.prototype.setPrivateKey = function setPrivateKey(key, encoding) {
+  key = bytesOf(key, "key", encoding);
+  const handle = cryptoEcPrivate(this[kHandle].curve, key);
+  if (typeof handle === "number") throw codeError(Error, "ERR_CRYPTO_INVALID_KEYTYPE", "Private key is not valid for specified curve.");
+  this[kHandle].key = handle;
+  this[kHandle].publicPoint = null;
+  return this;
+};
+
+ECDH.prototype.setPublicKey = function setPublicKey(key, encoding) {
+  key = bytesOf(key, "key", encoding);
+  const point = cryptoEcPoint(this[kHandle].curve, key, 4);
+  if (typeof point === "number") throw asymError(9);
+  this[kHandle].publicPoint = point;
+  return this;
+};
+
+ECDH.prototype.computeSecret = function computeSecret(key, inEnc, outEnc) {
+  key = bytesOf(key, "key", inEnc);
+  if (this[kHandle].key === null) throw codeError(Error, "ERR_CRYPTO_OPERATION_FAILED", "Failed to compute ECDH key");
+  const ret = cryptoEcdh(this[kHandle].key, key);
+  if (typeof ret === "number") throw asymError(9);
+  return encode(ret, outEnc);
+};
+
+ECDH.convertKey = function convertKey(key, curve, inEnc, outEnc, format) {
+  validateString(curve, "curve");
+  key = bytesOf(key, "key", inEnc);
+  const f = getFormat(format);
+  const ret = cryptoEcPoint(curve, key, f);
+  if (typeof ret === "number") throw asymError(ret === 10 ? 10 : 9);
+  return encode(ret, outEnc);
+};
+
+export function createECDH(curve) {
+  return new ECDH(curve);
+}
+
+/* ---- diffieHellman ----------------------------------------------------------------------------- */
+
+const keyObjectType = (actual, expected) =>
+  codeError(TypeError, "ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE", `Invalid key object type ${actual}, expected ${expected}.`);
+
+export function diffieHellman(options) {
+  validateObject(options, "options");
+  const { privateKey, publicKey } = options;
+  if (!(privateKey instanceof KeyObject)) throw invalidArgValue("options.privateKey", "is invalid", privateKey);
+  if (!(publicKey instanceof KeyObject)) throw invalidArgValue("options.publicKey", "is invalid", publicKey);
+  if (privateKey.type !== "private") throw keyObjectType(privateKey.type, "private");
+  if (publicKey.type !== "public" && publicKey.type !== "private") throw keyObjectType(publicKey.type, "private or public");
+  const privateType = asymmetricKeyTypeOf(privateKey[kHandle]);
+  const publicType = asymmetricKeyTypeOf(publicKey[kHandle]);
+  if (privateType !== publicType || (privateType !== "ec" && privateType !== "x25519")) {
+    throw codeError(Error, "ERR_CRYPTO_INCOMPATIBLE_KEY", `Incompatible key types for Diffie-Hellman: ${privateType} and ${publicType}`);
+  }
+  const ret = cryptoEcdh(privateKey[kHandle], publicKey[kHandle]);
+  if (typeof ret === "number") throw asymError(9);
+  return ret;
+}

package/node/prelude/internal/crypto/cipher.js

@@ -0,0 +1,205 @@
+// node:crypto's ciphers (ADR 0018): Cipheriv and Decipheriv (lazy Transform streams, as Node's),
+// getCiphers and getCipherInfo, Node's lib/internal/crypto/cipher.js over the runtime's C cipher
+// context. Output encodings go through a StringDecoder, so a multi-byte character or a base64
+// group isn't split between update and final.
+import {
+  cryptoCipherFinal, cryptoCipherGetAuthTag, cryptoCipherInfo, cryptoCipherNew, cryptoCiphers, cryptoCipherSetAAD,
+  cryptoCipherSetAuthTag, cryptoCipherSetPadding, cryptoCipherUpdate,
+} from "visaljs:host";
+import { codeError, invalidArgType, invalidArgValue, outOfRange, validateString } from "../errors.js";
+import { StringDecoder } from "../../string_decoder.js";
+import { prepareSecretKey } from "./keys.js";
+import { isAnyArrayBuffer, isArrayBufferView, kHandle, LazyTransform, stringBytes, validateEncoding, validateNumber, validateObject } from "./util.js";
+
+/* the C side's error codes (JS_CIPHER_ERR_*), as Node reports each */
+function cipherError(code, name, detail) {
+  switch (code) {
+    case -1: return codeError(Error, "ERR_CRYPTO_UNKNOWN_CIPHER", "Unknown cipher");
+    case 1: return codeError(RangeError, "ERR_CRYPTO_INVALID_KEYLEN", "Invalid key length");
+    case 2: return codeError(TypeError, "ERR_CRYPTO_INVALID_IV", "Invalid initialization vector");
+    case 3: return codeError(TypeError, "ERR_CRYPTO_INVALID_AUTH_TAG", "authTagLength required for " + name);
+    case 4: return codeError(TypeError, "ERR_CRYPTO_INVALID_AUTH_TAG", "Invalid authentication tag length: " + detail);
+    case 5: return new Error("Trying to add data in unsupported state");
+    case 6: return codeError(Error, "ERR_CRYPTO_INVALID_STATE", "Invalid state");
+    case 7: return codeError(Error, "ERR_OSSL_WRONG_FINAL_BLOCK_LENGTH", "error:1C80006B:Provider routines::wrong final block length");
+    case 8: return codeError(Error, "ERR_OSSL_BAD_DECRYPT", "error:1C800064:Provider routines::bad decrypt");
+    case 9: return new Error("Unsupported state or unable to authenticate data");
+    case 10: return codeError(Error, "ERR_OSSL_TAG_NOT_SET", "error:1C800077:Provider routines::tag not set");
+    case 11: return codeError(RangeError, "ERR_CRYPTO_INVALID_MESSAGELEN", "Invalid message length");
+    case 12: return codeError(TypeError, "ERR_MISSING_ARGS", "options.plaintextLength required for CCM mode with AAD");
+    default: return new Error("Cipher operation failed");
+  }
+}
+
+const invalidState = (op) => codeError(Error, "ERR_CRYPTO_INVALID_STATE", "Invalid state for operation " + op);
+
+function getUIntOption(options, key) {
+  let value;
+  if (options && (value = options[key]) != null) {
+    if (value >>> 0 !== value) throw invalidArgValue(`options.${key}`, "is invalid", value);
+    return value;
+  }
+  return -1;
+}
+
+function getStringOption(options, key) {
+  let value;
+  if (options && (value = options[key]) != null) validateString(value, `options.${key}`);
+  return value;
+}
+
+/** getArrayBufferOrView: a string in `encoding` (UTF-8 by default), or the buffer or view. */
+function bytesOf(value, name, encoding) {
+  if (isAnyArrayBuffer(value) || isArrayBufferView(value)) return value;
+  if (typeof value === "string") return Buffer.from(value, encoding === undefined || encoding === "buffer" ? "utf8" : encoding);
+  throw invalidArgType(name, "of type string or an instance of ArrayBuffer, Buffer, TypedArray, or DataView", value);
+}
+
+function getDecoder(decoder, encoding) {
+  decoder ||= new StringDecoder(encoding);
+  if (decoder.encoding !== new StringDecoder(encoding).encoding) {
+    throw codeError(Error, "ERR_INTERNAL_ASSERTION", "Cannot change encoding\nThis is caused by either a bug in Node.js or incorrect " +
+      "usage of Node.js internals.\nPlease open an issue with this stack trace at https://github.com/nodejs/node/issues\n");
+  }
+  return decoder;
+}
+
+function createCipherWithIV(self, cipher, key, options, encrypt, iv) {
+  validateString(cipher, "cipher");
+  const encoding = getStringOption(options, "encoding");
+  key = prepareSecretKey(key, encoding);
+  iv = iv === null ? null : bytesOf(iv, "iv");
+  const authTagLength = getUIntOption(options, "authTagLength");
+  const handle = cryptoCipherNew(cipher, encrypt, key, iv, authTagLength);
+  if (typeof handle === "number") throw cipherError(handle, cipher, authTagLength);
+  self[kHandle] = handle;
+  self._decoder = null;
+  LazyTransform.call(self, options);
+}
+
+function update(data, inputEncoding, outputEncoding) {
+  if (typeof data === "string") validateEncoding(data, inputEncoding);
+  else if (!isArrayBufferView(data)) throw invalidArgType("data", "of type string or an instance of Buffer, TypedArray, or DataView", data);
+  const ret = cryptoCipherUpdate(this[kHandle], typeof data === "string" ? stringBytes(data, inputEncoding) : data);
+  if (typeof ret === "number") throw cipherError(ret);
+  if (outputEncoding && outputEncoding !== "buffer") {
+    this._decoder = getDecoder(this._decoder, outputEncoding);
+    return this._decoder.write(ret);
+  }
+  return ret;
+}
+
+function final(outputEncoding) {
+  const ret = cryptoCipherFinal(this[kHandle]);
+  if (typeof ret === "number") throw cipherError(ret);
+  if (outputEncoding && outputEncoding !== "buffer") {
+    this._decoder = getDecoder(this._decoder, outputEncoding);
+    return this._decoder.end(ret);
+  }
+  return ret;
+}
+
+function setAutoPadding(ap) {
+  if (!cryptoCipherSetPadding(this[kHandle], !!ap)) throw invalidState("setAutoPadding");
+  return this;
+}
+
+function setAAD(aadbuf, options) {
+  const encoding = getStringOption(options, "encoding");
+  const plaintextLength = getUIntOption(options, "plaintextLength");
+  aadbuf = bytesOf(aadbuf, "aadbuf", encoding);
+  const code = cryptoCipherSetAAD(this[kHandle], aadbuf, plaintextLength);
+  if (code === 5) throw invalidState("setAAD");
+  if (code !== 0) throw cipherError(code);
+  return this;
+}
+
+function _transform(chunk, encoding, callback) {
+  this.push(update.call(this, chunk, encoding));
+  callback();
+}
+
+function _flush(callback) {
+  try {
+    this.push(final.call(this));
+  } catch (e) {
+    callback(e);
+    return;
+  }
+  callback();
+}
+
+export function Cipheriv(cipher, key, iv, options) {
+  if (!(this instanceof Cipheriv)) return new Cipheriv(cipher, key, iv, options);
+  createCipherWithIV(this, cipher, key, options, true, iv);
+}
+Object.setPrototypeOf(Cipheriv.prototype, LazyTransform.prototype);
+Object.setPrototypeOf(Cipheriv, LazyTransform);
+Object.assign(Cipheriv.prototype, { _transform, _flush, update, final, setAutoPadding });
+Cipheriv.prototype.getAuthTag = function getAuthTag() {
+  const ret = cryptoCipherGetAuthTag(this[kHandle]);
+  if (ret === undefined) throw invalidState("getAuthTag");
+  return ret;
+};
+Cipheriv.prototype.setAAD = setAAD;
+
+export function Decipheriv(cipher, key, iv, options) {
+  if (!(this instanceof Decipheriv)) return new Decipheriv(cipher, key, iv, options);
+  createCipherWithIV(this, cipher, key, options, false, iv);
+}
+Object.setPrototypeOf(Decipheriv.prototype, LazyTransform.prototype);
+Object.setPrototypeOf(Decipheriv, LazyTransform);
+Object.assign(Decipheriv.prototype, { _transform, _flush, update, final, setAutoPadding });
+Decipheriv.prototype.setAuthTag = function setAuthTag(tagbuf, encoding) {
+  tagbuf = bytesOf(tagbuf, "buffer", encoding);
+  const code = cryptoCipherSetAuthTag(this[kHandle], tagbuf);
+  if (code === 5) throw invalidState("setAuthTag");
+  if (code !== 0) throw cipherError(code, undefined, tagbuf.byteLength);
+  return this;
+};
+Decipheriv.prototype.setAAD = setAAD;
+
+export function createCipheriv(cipher, key, iv, options) {
+  return new Cipheriv(cipher, key, iv, options);
+}
+
+export function createDecipheriv(cipher, key, iv, options) {
+  return new Decipheriv(cipher, key, iv, options);
+}
+
+export function getCiphers() {
+  return cryptoCiphers();
+}
+
+function validateInt32(value, name) {
+  validateNumber(value, name);
+  if (!Number.isInteger(value)) throw outOfRange(name, "an integer", value);
+  if (value < -2147483648 || value > 2147483647) throw outOfRange(name, ">= -2147483648 && <= 2147483647", value);
+}
+
+export function getCipherInfo(nameOrNid, options) {
+  if (typeof nameOrNid !== "string" && typeof nameOrNid !== "number") {
+    throw invalidArgType("nameOrNid", "one of type string or number", nameOrNid);
+  }
+  if (typeof nameOrNid === "number") validateInt32(nameOrNid, "nameOrNid");
+  let keyLength, ivLength;
+  if (options !== undefined) {
+    validateObject(options, "options");
+    ({ keyLength, ivLength } = options);
+    if (keyLength !== undefined) validateInt32(keyLength, "options.keyLength");
+    if (ivLength !== undefined) validateInt32(ivLength, "options.ivLength");
+  }
+  const info = cryptoCipherInfo(nameOrNid);
+  if (info === null) return undefined;
+  const [name, nid, mode, blockSize, ivLen, keyLen] = info;
+  if (keyLength !== undefined && keyLength !== keyLen) return undefined;
+  if (ivLength !== undefined) {
+    const ok = mode === "gcm" ? ivLength > 0 : mode === "ccm" ? ivLength >= 7 && ivLength <= 13 : ivLength === ivLen;
+    if (!ok) return undefined;
+  }
+  const ret = { mode, name, nid };
+  if (mode !== "stream") ret.blockSize = blockSize;
+  if (ivLen !== 0) ret.ivLength = ivLength ?? ivLen;
+  ret.keyLength = keyLen;
+  return ret;
+}

package/node/prelude/internal/crypto/hash.js

@@ -0,0 +1,137 @@
+// node:crypto's Hash and Hmac, and crypto.hash() (ADR 0018): Node's lib/internal/crypto/hash.js
+// over the host primitives, which hash in C (BearSSL, and SHA-3 of our own).
+import {
+  cryptoDigestFinal, cryptoDigestUpdate, cryptoHashCopy, cryptoHashes, cryptoHashInfo, cryptoHashNew, cryptoHmacNew,
+} from "visaljs:host";
+import { codeError, invalidArgType, invalidArgValue, outOfRange, validateString } from "../errors.js";
+import {
+  encodeOutput, isArrayBufferView, kFinalized, kHandle, kState, LazyTransform, stringBytes, validateEncoding, validateNumber,
+} from "./util.js";
+import { prepareSecretKey } from "./keys.js";
+
+const finalized = () => codeError(Error, "ERR_CRYPTO_HASH_FINALIZED", "Digest already called");
+
+function validateUint32(value, name) {
+  validateNumber(value, name);
+  if (!Number.isInteger(value)) throw outOfRange(name, "an integer", value);
+  if (value < 0 || value > 4294967295) throw outOfRange(name, ">= 0 && <= 4294967295", value);
+}
+
+/** The output length option: undefined, or a length the algorithm can give. */
+function outputLength(algorithm, options) {
+  const xofLen = typeof options === "object" && options !== null ? options.outputLength : undefined;
+  if (xofLen === undefined) return undefined;
+  validateUint32(xofLen, "options.outputLength");
+  const info = cryptoHashInfo(algorithm);
+  if (info >= 0 && xofLen !== info) {
+    throw codeError(Error, "ERR_OSSL_EVP_NOT_XOF_OR_INVALID_LENGTH", "error:030000B2:digital envelope routines::not XOF or invalid length");
+  }
+  return xofLen;
+}
+
+export function Hash(algorithm, options) {
+  if (!new.target) return new Hash(algorithm, options);
+  const copyOf = algorithm !== null && typeof algorithm === "object" && kHandle in algorithm ? algorithm : null;
+  if (copyOf) {
+    this[kHandle] = cryptoHashCopy(copyOf[kHandle], outputLength(copyOf._algorithm, options));
+    this._algorithm = copyOf._algorithm;
+  } else {
+    validateString(algorithm, "algorithm");
+    const handle = cryptoHashNew(algorithm, cryptoHashInfo(algorithm) === -1 ? undefined : outputLength(algorithm, options));
+    if (handle === null) throw new Error("Digest method not supported");
+    this[kHandle] = handle;
+    Object.defineProperty(this, "_algorithm", { value: algorithm, writable: true });  /* not shown, as Node keeps it in C++ */
+  }
+  this[kState] = { [kFinalized]: false };
+  LazyTransform.call(this, options);
+}
+Object.setPrototypeOf(Hash.prototype, LazyTransform.prototype);
+Object.setPrototypeOf(Hash, LazyTransform);
+
+Hash.prototype.copy = function copy(options) {
+  if (this[kState][kFinalized]) throw finalized();
+  return new Hash(this, options);
+};
+
+Hash.prototype._transform = function _transform(chunk, encoding, callback) {
+  cryptoDigestUpdate(this[kHandle], typeof chunk === "string" ? stringBytes(chunk, encoding) : chunk);
+  callback();
+};
+
+Hash.prototype._flush = function _flush(callback) {
+  this.push(cryptoDigestFinal(this[kHandle]));
+  callback();
+};
+
+Hash.prototype.update = function update(data, encoding) {
+  if (this[kState][kFinalized]) throw finalized();
+  if (typeof data === "string") validateEncoding(data, encoding);
+  else if (!isArrayBufferView(data)) throw invalidArgType("data", "of type string or an instance of Buffer, TypedArray, or DataView", data);
+  cryptoDigestUpdate(this[kHandle], typeof data === "string" ? stringBytes(data, encoding) : data);
+  return this;
+};
+
+Hash.prototype.digest = function digest(outputEncoding) {
+  if (this[kState][kFinalized]) throw finalized();
+  const ret = encodeOutput(cryptoDigestFinal(this[kHandle]), outputEncoding && `${outputEncoding}`);
+  this[kState][kFinalized] = true;
+  return ret;
+};
+
+export function Hmac(hmac, key, options) {
+  if (!(this instanceof Hmac)) return new Hmac(hmac, key, options);
+  validateString(hmac, "hmac");
+  const encoding = options !== null && typeof options === "object" ? options.encoding : undefined;
+  const handle = cryptoHmacNew(hmac, prepareSecretKey(key, encoding));
+  if (handle === null) throw codeError(TypeError, "ERR_CRYPTO_INVALID_DIGEST", "Invalid digest: " + hmac);
+  this[kHandle] = handle;
+  this[kState] = { [kFinalized]: false };
+  LazyTransform.call(this, options);
+}
+Object.setPrototypeOf(Hmac.prototype, LazyTransform.prototype);
+Object.setPrototypeOf(Hmac, LazyTransform);
+
+Hmac.prototype.update = Hash.prototype.update;
+
+Hmac.prototype.digest = function digest(outputEncoding) {
+  if (this[kState][kFinalized]) {
+    const buf = Buffer.from("");
+    return outputEncoding && outputEncoding !== "buffer" ? buf.toString(outputEncoding) : buf;
+  }
+  const ret = encodeOutput(cryptoDigestFinal(this[kHandle]), outputEncoding && `${outputEncoding}`);
+  this[kState][kFinalized] = true;
+  return ret;
+};
+
+Hmac.prototype._flush = Hash.prototype._flush;
+Hmac.prototype._transform = Hash.prototype._transform;
+
+export function createHash(algorithm, options) {
+  return new Hash(algorithm, options);
+}
+
+export function createHmac(hmac, key, options) {
+  return new Hmac(hmac, key, options);
+}
+
+/** crypto.hash(algorithm, data, outputEncoding = "hex"): a one-shot digest. */
+export function hash(algorithm, input, outputEncoding = "hex") {
+  validateString(algorithm, "algorithm");
+  if (typeof input !== "string" && !isArrayBufferView(input)) {
+    throw invalidArgType("input", "of type string or an instance of Buffer, TypedArray, or DataView", input);
+  }
+  let encoding = outputEncoding;
+  if (outputEncoding !== "hex") {
+    validateString(outputEncoding, "outputEncoding");
+    if (outputEncoding.toLowerCase() === "buffer") encoding = "buffer";
+    else if (!Buffer.isEncoding(outputEncoding)) throw invalidArgValue("outputEncoding", "is invalid", outputEncoding);
+  }
+  const handle = cryptoHashNew(algorithm, undefined);
+  if (handle === null) throw new Error("Digest method " + algorithm + " is not supported");
+  cryptoDigestUpdate(handle, input);
+  return encodeOutput(cryptoDigestFinal(handle), encoding);
+}
+
+export function getHashes() {
+  return cryptoHashes();
+}