Use with Vite about argon2-browser HOT 2 OPEN

import argon2Wasm from "argon2-browser/dist/argon2-simd.wasm?url";
import argon2Js from "argon2-browser/dist/argon2.js?url";

interface Module {
  ALLOC_NORMAL: number;
  wasmBinary: ArrayBuffer;
  wasmJSMethod: string;
  wasmMemory: WebAssembly.Memory;
  buffer: ArrayBuffer;
  TOTAL_MEMORY: number;
  postRun: () => void;
  allocate: (array: Uint8Array, type: string, allocator: number) => Uint8Array;
  _free: (array: Uint8Array) => void;
  _argon2_hash_ext: (
    timeCost: number,
    memoryCost: number,
    parallelism: number,
    pass: Uint8Array,
    passLenght: number,
    salt: Uint8Array,
    saltLength: number,
    hash: Uint8Array,
    hashLength: number,
    encoded: Uint8Array,
    encodedLength: number,
    type: number,
    secret: Uint8Array | number,
    secretLength: number,
    ad: Uint8Array | number,
    adLenght: number,
    version: number,
  ) => number;
  _argon2_encodedlen: (
    timeCost: number,
    memoryCost: number,
    parallelism: number,
    saltLength: number,
    hashLength: number,
    type: number,
  ) => number;
  _argon2_error_message: (res: number) => Uint8Array;
  UTF8ToString: (array: Uint8Array) => string;
}

declare global {
  // eslint-disable-next-line
  var Module: Module;
}

const loadScript = (src: string) =>
  new Promise((resolve, reject) => {
    const element = document.createElement("script");
    element.src = src;
    element.onload = resolve;
    element.onerror = reject;
    document.body.appendChild(element);
  });

const encodeUtf8 = (str: string) => new TextEncoder().encode(str);

const allocate = (array: Uint8Array) =>
  globalThis.Module.allocate(array, "i8", globalThis.Module.ALLOC_NORMAL);

const initialize = async (memoryCost: number) => {
  if (globalThis.Module?._argon2_hash_ext !== undefined) {
    return;
  }

  const KB = 1024 * 1024;
  const MB = 1024 * KB;
  const GB = 1024 * MB;
  const WASM_PAGE_SIZE = 64 * 1024;

  const totalMemory = (2 * GB - 64 * KB) / 1024 / WASM_PAGE_SIZE;
  const initialMemory = Math.min(
    Math.max(Math.ceil((memoryCost * 1024) / WASM_PAGE_SIZE), 256) + 256,
    totalMemory,
  );

  const wasmMemory = new WebAssembly.Memory({
    initial: initialMemory,
    maximum: totalMemory,
  });

  const wasm = await fetch(argon2Wasm);
  const wasmBinary = await wasm.arrayBuffer();

  const moduleLoaded = new Promise((resolve) => {
    globalThis.Module = {
      wasmBinary,
      wasmJSMethod: "native-wasm",
      wasmMemory: wasmMemory,
      buffer: wasmMemory.buffer,
      TOTAL_MEMORY: initialMemory * WASM_PAGE_SIZE,
      postRun: resolve,
    } as Module;
  });

  await loadScript(argon2Js);
  await moduleLoaded;
};

const generateSalt = (length: number) => {
  const array = new Uint8Array(length);
  self.crypto.getRandomValues(array);
  return array;
};

export const hash = async (password: string) => {
  // NOTE: Using dovecot defaults with increased parallelism
  const type = 2;
  const timeCost = 3;
  const memoryCost = 65536;
  const parallelism = 4;
  const hashLength = 32;
  const saltLength = 16;

  await initialize(memoryCost);

  const passEncoded = encodeUtf8(password);
  const pwd = allocate(passEncoded);
  const salt = allocate(generateSalt(saltLength));

  const encodedLength = globalThis.Module._argon2_encodedlen(
    timeCost,
    memoryCost,
    parallelism,
    saltLength,
    hashLength,
    type,
  );

  const hash = allocate(new Uint8Array(hashLength));
  const encoded = allocate(new Uint8Array(encodedLength + 1));

  const result = globalThis.Module._argon2_hash_ext(
    timeCost,
    memoryCost,
    parallelism,
    pwd,
    passEncoded.length,
    salt,
    saltLength,
    hash,
    hashLength,
    encoded,
    encodedLength,
    type,
    0,
    0,
    0,
    0,
    0x13,
  );

  if (result !== 0) {
    throw Error(
      globalThis.Module.UTF8ToString(
        globalThis.Module._argon2_error_message(result),
      ),
    );
  }

  const output = globalThis.Module.UTF8ToString(encoded);

  globalThis.Module._free(pwd);
  globalThis.Module._free(salt);
  globalThis.Module._free(hash);
  globalThis.Module._free(encoded);

  return output;
};