@wener/common 1.0.1

package/lib/password/PHC.js

@@ -0,0 +1,200 @@
+import { ArrayBuffers } from "@wener/utils";
+(function(PHC) {
+    // https://github.com/simonepri/phc-format/blob/master/index.js
+    const idRegex = /^[a-z0-9-]{1,32}$/;
+    const nameRegex = /^[a-z0-9-]{1,32}$/;
+    const valueRegex = /^[a-zA-Z0-9/+.-]+$/;
+    const b64Regex = /^([a-zA-Z0-9/+.-]+|)$/;
+    const decimalRegex = /^((-)?[1-9]\d*|0)$/;
+    const versionRegex = /^v=(\d+)$/;
+    const fromBase64 = ArrayBuffers.fromBase64;
+    const toBase64 = ArrayBuffers.toBase64;
+    const isBuffer = (v)=>{
+        return v instanceof Uint8Array;
+    };
+    function objToKeyVal(obj) {
+        return objectKeys(obj).map((k)=>[
+                k,
+                obj[k]
+            ].join('=')).join(',');
+    }
+    function keyValtoObj(str) {
+        const obj = {};
+        str.split(',').forEach((ps)=>{
+            const pss = ps.split('=');
+            if (pss.length < 2) {
+                throw new TypeError(`params must be in the format name=value`);
+            }
+            const key = pss.shift();
+            if (key !== undefined) {
+                obj[key] = pss.join('=');
+            }
+        });
+        return obj;
+    }
+    function objectKeys(object) {
+        return Object.keys(object);
+    }
+    function objectValues(object) {
+        if (typeof Object.values === 'function') return Object.values(object);
+        return objectKeys(object).map((k)=>object[k]);
+    }
+    function serialize(opts) {
+        const fields = [
+            ''
+        ];
+        if (typeof opts !== 'object' || opts === null) {
+            throw new TypeError('opts must be an object');
+        }
+        // Identifier Validation
+        if (typeof opts.id !== 'string') {
+            throw new TypeError('id must be a string');
+        }
+        if (!idRegex.test(opts.id)) {
+            throw new TypeError(`id must satisfy ${idRegex}`);
+        }
+        fields.push(opts.id);
+        if (typeof opts.version !== 'undefined') {
+            if (typeof opts.version !== 'number' || opts.version < 0 || !Number.isInteger(opts.version)) {
+                throw new TypeError('version must be a positive integer number');
+            }
+            fields.push(`v=${opts.version}`);
+        }
+        // Parameters Validation
+        if (typeof opts.params !== 'undefined') {
+            if (typeof opts.params !== 'object' || opts.params === null) {
+                throw new TypeError('params must be an object');
+            }
+            const pk = objectKeys(opts.params);
+            if (!pk.every((p)=>nameRegex.test(p.toString()))) {
+                throw new TypeError(`params names must satisfy ${nameRegex}`);
+            }
+            // Convert Numbers into Numeric Strings and Buffers into B64 encoded strings.
+            pk.forEach((k)=>{
+                const value = opts.params[k];
+                if (typeof value === 'number') {
+                    opts.params[k] = value.toString();
+                } else if (value instanceof Uint8Array) {
+                    opts.params[k] = toBase64(value).split('=')[0];
+                }
+            });
+            const pv = objectValues(opts.params);
+            if (!pv.every((v)=>typeof v === 'string')) {
+                throw new TypeError('params values must be strings');
+            }
+            if (!pv.every((v)=>valueRegex.test(v))) {
+                throw new TypeError(`params values must satisfy ${valueRegex}`);
+            }
+            const strpar = objToKeyVal(opts.params);
+            fields.push(strpar);
+        }
+        if (typeof opts.salt !== 'undefined') {
+            // Salt Validation
+            if (!isBuffer(opts.salt)) {
+                throw new TypeError('salt must be a Buffer');
+            }
+            fields.push(toBase64(opts.salt).split('=')[0]);
+            if (typeof opts.hash !== 'undefined') {
+                // Hash Validation
+                if (!isBuffer(opts.hash)) {
+                    throw new TypeError('hash must be a Buffer');
+                }
+                fields.push(toBase64(opts.hash).split('=')[0]);
+            }
+        }
+        // Create the PHC formatted string
+        const phcstr = fields.join('$');
+        return phcstr;
+    }
+    /**
+   * Generates a PHC string using the data provided.
+   * @param  {SerializeOptions} opts Object that holds the data needed to generate the PHC string.
+   * @return {string} The hash string adhering to the PHC format.
+   */ PHC.serialize = serialize;
+    function deserialize(phcstr) {
+        if (typeof phcstr !== 'string' || phcstr === '') {
+            throw new TypeError('pchstr must be a non-empty string');
+        }
+        if (phcstr[0] !== '$') {
+            throw new TypeError('pchstr must contain a $ as first char');
+        }
+        const fields = phcstr.split('$');
+        // Remove first empty $
+        fields.shift();
+        // Parse Fields
+        let maxf = 5;
+        if (!versionRegex.test(fields[1])) maxf--;
+        if (fields.length > maxf) {
+            throw new TypeError(`pchstr contains too many fileds: ${fields.length}/${maxf}`);
+        }
+        // Parse Identifier
+        const id = fields.shift();
+        if (!id || !idRegex.test(id)) {
+            throw new TypeError(`id must satisfy ${idRegex}`);
+        }
+        let version;
+        // Parse Version
+        if (fields[0] && versionRegex.test(fields[0])) {
+            const versionMatch = fields.shift()?.match(versionRegex);
+            version = versionMatch ? parseInt(versionMatch[1], 10) : undefined;
+        }
+        let hash;
+        let salt;
+        if (fields[fields.length - 1] && b64Regex.test(fields[fields.length - 1])) {
+            if (fields.length > 1 && b64Regex.test(fields[fields.length - 2])) {
+                // Parse Hash
+                const hashStr = fields.pop();
+                if (hashStr) hash = fromBase64(hashStr);
+                // Parse Salt
+                const saltStr = fields.pop();
+                if (saltStr !== undefined) salt = fromBase64(saltStr);
+            } else {
+                // Parse Salt
+                const saltStr = fields.pop();
+                if (saltStr !== undefined) salt = fromBase64(saltStr);
+            }
+        }
+        // Parse Parameters
+        let params;
+        if (fields.length > 0) {
+            const parstr = fields.pop();
+            if (parstr) {
+                params = keyValtoObj(parstr);
+                if (!Object.keys(params).every((p)=>nameRegex.test(p))) {
+                    throw new TypeError(`params names must satisfy ${nameRegex}}`);
+                }
+                const pv = Object.values(params);
+                if (!pv.every((v)=>valueRegex.test(String(v)))) {
+                    throw new TypeError(`params values must satisfy ${valueRegex}`);
+                }
+                // Convert Decimal Strings into Numbers
+                Object.keys(params).forEach((k)=>{
+                    const value = params[k];
+                    if (typeof value === 'string' && decimalRegex.test(value)) {
+                        params[k] = parseInt(value, 10);
+                    }
+                });
+            }
+        }
+        if (fields.length > 0) {
+            throw new TypeError(`pchstr contains unrecognized fileds: ${fields}`);
+        }
+        // Build the output object
+        const phcobj = {
+            id
+        };
+        if (version !== undefined) phcobj.version = version;
+        if (params) phcobj.params = params;
+        if (salt) phcobj.salt = salt;
+        if (hash) phcobj.hash = hash;
+        return phcobj;
+    }
+    /**
+   * Parses data from a PHC string.
+   * @param  {string} phcstr A PHC string to parse.
+   * @return {DeserializeResult} The object containing the data parsed from the PHC string.
+   */ PHC.deserialize = deserialize;
+})(PHC || (PHC = {}));
+export var PHC;
+
+//# sourceMappingURL=PHC.js.map

package/lib/password/PHC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/password/PHC.ts"],"sourcesContent":["import { ArrayBuffers } from '@wener/utils';\n\nexport namespace PHC {\n  // https://github.com/simonepri/phc-format/blob/master/index.js\n\n  const idRegex = /^[a-z0-9-]{1,32}$/;\n  const nameRegex = /^[a-z0-9-]{1,32}$/;\n  const valueRegex = /^[a-zA-Z0-9/+.-]+$/;\n  const b64Regex = /^([a-zA-Z0-9/+.-]+|)$/;\n  const decimalRegex = /^((-)?[1-9]\\d*|0)$/;\n  const versionRegex = /^v=(\\d+)$/;\n\n  const fromBase64 = ArrayBuffers.fromBase64;\n  const toBase64 = ArrayBuffers.toBase64;\n  const isBuffer = (v: any): v is Uint8Array => {\n    return v instanceof Uint8Array;\n  };\n\n  function objToKeyVal(obj: Record<string, any>): string {\n    return objectKeys(obj)\n      .map((k) => [k, obj[k]].join('='))\n      .join(',');\n  }\n\n  function keyValtoObj(str: string): Record<string, string> {\n    const obj: Record<string, string> = {};\n    str.split(',').forEach((ps) => {\n      const pss = ps.split('=');\n      if (pss.length < 2) {\n        throw new TypeError(`params must be in the format name=value`);\n      }\n\n      const key = pss.shift();\n      if (key !== undefined) {\n        obj[key] = pss.join('=');\n      }\n    });\n    return obj;\n  }\n\n  function objectKeys<T extends object>(object: T): Array<keyof T> {\n    return Object.keys(object) as Array<keyof T>;\n  }\n\n  function objectValues<T extends object>(object: T): Array<T[keyof T]> {\n    if (typeof Object.values === 'function') return Object.values(object);\n    return objectKeys(object).map((k) => object[k]);\n  }\n\n  interface SerializeOptions {\n    id: string;\n    version?: number;\n    params?: Record<string, string | number | Uint8Array>;\n    salt?: Uint8Array;\n    hash?: Uint8Array;\n  }\n\n  /**\n   * Generates a PHC string using the data provided.\n   * @param  {SerializeOptions} opts Object that holds the data needed to generate the PHC string.\n   * @return {string} The hash string adhering to the PHC format.\n   */\n  export function serialize(opts: SerializeOptions): string {\n    const fields: string[] = [''];\n\n    if (typeof opts !== 'object' || opts === null) {\n      throw new TypeError('opts must be an object');\n    }\n\n    // Identifier Validation\n    if (typeof opts.id !== 'string') {\n      throw new TypeError('id must be a string');\n    }\n\n    if (!idRegex.test(opts.id)) {\n      throw new TypeError(`id must satisfy ${idRegex}`);\n    }\n\n    fields.push(opts.id);\n\n    if (typeof opts.version !== 'undefined') {\n      if (typeof opts.version !== 'number' || opts.version < 0 || !Number.isInteger(opts.version)) {\n        throw new TypeError('version must be a positive integer number');\n      }\n\n      fields.push(`v=${opts.version}`);\n    }\n\n    // Parameters Validation\n    if (typeof opts.params !== 'undefined') {\n      if (typeof opts.params !== 'object' || opts.params === null) {\n        throw new TypeError('params must be an object');\n      }\n\n      const pk = objectKeys(opts.params);\n      if (!pk.every((p) => nameRegex.test(p.toString()))) {\n        throw new TypeError(`params names must satisfy ${nameRegex}`);\n      }\n\n      // Convert Numbers into Numeric Strings and Buffers into B64 encoded strings.\n      pk.forEach((k) => {\n        const value = opts.params![k];\n        if (typeof value === 'number') {\n          opts.params![k] = value.toString();\n        } else if (value instanceof Uint8Array) {\n          opts.params![k] = toBase64(value).split('=')[0];\n        }\n      });\n      const pv = objectValues(opts.params);\n      if (!pv.every((v) => typeof v === 'string')) {\n        throw new TypeError('params values must be strings');\n      }\n\n      if (!pv.every((v) => valueRegex.test(v))) {\n        throw new TypeError(`params values must satisfy ${valueRegex}`);\n      }\n\n      const strpar = objToKeyVal(opts.params as Record<string, string>);\n      fields.push(strpar);\n    }\n\n    if (typeof opts.salt !== 'undefined') {\n      // Salt Validation\n      if (!isBuffer(opts.salt)) {\n        throw new TypeError('salt must be a Buffer');\n      }\n\n      fields.push(toBase64(opts.salt).split('=')[0]);\n\n      if (typeof opts.hash !== 'undefined') {\n        // Hash Validation\n        if (!isBuffer(opts.hash)) {\n          throw new TypeError('hash must be a Buffer');\n        }\n\n        fields.push(toBase64(opts.hash).split('=')[0]);\n      }\n    }\n\n    // Create the PHC formatted string\n    const phcstr = fields.join('$');\n\n    return phcstr;\n  }\n\n  interface DeserializeResult {\n    id: string;\n    version?: number;\n    params?: Record<string, string | number>;\n    salt?: Uint8Array;\n    hash?: Uint8Array;\n  }\n\n  /**\n   * Parses data from a PHC string.\n   * @param  {string} phcstr A PHC string to parse.\n   * @return {DeserializeResult} The object containing the data parsed from the PHC string.\n   */\n  export function deserialize(phcstr: string): DeserializeResult {\n    if (typeof phcstr !== 'string' || phcstr === '') {\n      throw new TypeError('pchstr must be a non-empty string');\n    }\n\n    if (phcstr[0] !== '$') {\n      throw new TypeError('pchstr must contain a $ as first char');\n    }\n\n    const fields = phcstr.split('$');\n    // Remove first empty $\n    fields.shift();\n\n    // Parse Fields\n    let maxf = 5;\n    if (!versionRegex.test(fields[1])) maxf--;\n    if (fields.length > maxf) {\n      throw new TypeError(`pchstr contains too many fileds: ${fields.length}/${maxf}`);\n    }\n\n    // Parse Identifier\n    const id = fields.shift();\n    if (!id || !idRegex.test(id)) {\n      throw new TypeError(`id must satisfy ${idRegex}`);\n    }\n\n    let version: number | undefined;\n    // Parse Version\n    if (fields[0] && versionRegex.test(fields[0])) {\n      const versionMatch = fields.shift()?.match(versionRegex);\n      version = versionMatch ? parseInt(versionMatch[1], 10) : undefined;\n    }\n\n    let hash: Uint8Array | undefined;\n    let salt: Uint8Array | undefined;\n    if (fields[fields.length - 1] && b64Regex.test(fields[fields.length - 1])) {\n      if (fields.length > 1 && b64Regex.test(fields[fields.length - 2])) {\n        // Parse Hash\n        const hashStr = fields.pop();\n        if (hashStr) hash = fromBase64(hashStr);\n        // Parse Salt\n        const saltStr = fields.pop();\n        if (saltStr !== undefined) salt = fromBase64(saltStr);\n      } else {\n        // Parse Salt\n        const saltStr = fields.pop();\n        if (saltStr !== undefined) salt = fromBase64(saltStr);\n      }\n    }\n\n    // Parse Parameters\n    let params: Record<string, string | number> | undefined;\n    if (fields.length > 0) {\n      const parstr = fields.pop();\n      if (parstr) {\n        params = keyValtoObj(parstr);\n        if (!Object.keys(params).every((p) => nameRegex.test(p))) {\n          throw new TypeError(`params names must satisfy ${nameRegex}}`);\n        }\n\n        const pv = Object.values(params);\n        if (!pv.every((v) => valueRegex.test(String(v)))) {\n          throw new TypeError(`params values must satisfy ${valueRegex}`);\n        }\n\n        // Convert Decimal Strings into Numbers\n        Object.keys(params).forEach((k) => {\n          const value = params![k];\n          if (typeof value === 'string' && decimalRegex.test(value)) {\n            params![k] = parseInt(value, 10);\n          }\n        });\n      }\n    }\n\n    if (fields.length > 0) {\n      throw new TypeError(`pchstr contains unrecognized fileds: ${fields}`);\n    }\n\n    // Build the output object\n    const phcobj: DeserializeResult = { id };\n    if (version !== undefined) phcobj.version = version;\n    if (params) phcobj.params = params;\n    if (salt) phcobj.salt = salt;\n    if (hash) phcobj.hash = hash;\n\n    return phcobj;\n  }\n}\n"],"names":["ArrayBuffers","PHC","idRegex","nameRegex","valueRegex","b64Regex","decimalRegex","versionRegex","fromBase64","toBase64","isBuffer","v","Uint8Array","objToKeyVal","obj","objectKeys","map","k","join","keyValtoObj","str","split","forEach","ps","pss","length","TypeError","key","shift","undefined","object","Object","keys","objectValues","values","serialize","opts","fields","id","test","push","version","Number","isInteger","params","pk","every","p","toString","value","pv","strpar","salt","hash","phcstr","deserialize","maxf","versionMatch","match","parseInt","hashStr","pop","saltStr","parstr","String","phcobj"],"mappings":"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"}

package/lib/password/Password.js

@@ -0,0 +1,83 @@
+import { Errors } from "@wener/utils";
+import { createPBKDF2PasswordAlgorithm } from "./createPBKDF2PasswordAlgorithm.js";
+import { PHC } from "./PHC.js";
+(function (Password) {
+    const Algorithms = {
+        1: "md5",
+        "2a": "bcrypt",
+        "2b": "bcrypt",
+        "2x": "bcrypt",
+        "2y": "bcrypt",
+        5: "sha256",
+        6: "sha512",
+        7: "scrypt"
+    };
+    let DefaultAlgorithm = "6";
+    function setDefaultAlgorithm(algorithm) {
+        Errors.BadRequest.check(Algorithms[algorithm], `Unknown algorithm ${algorithm}`);
+        DefaultAlgorithm = algorithm;
+    }
+    Password.setDefaultAlgorithm = setDefaultAlgorithm;
+    function getDefaultAlgorithm() {
+        return DefaultAlgorithm;
+    }
+    Password.getDefaultAlgorithm = getDefaultAlgorithm;
+    function addAlgorithm(algorithm) {
+        Algorithms[algorithm.name] = algorithm;
+        if (algorithm.ids) {
+            for (const id of algorithm.ids) {
+                Algorithms[id] = algorithm;
+            }
+        }
+    }
+    Password.addAlgorithm = addAlgorithm;
+    addAlgorithm(createPBKDF2PasswordAlgorithm({
+        id: "sha256",
+        digest: "SHA-256"
+    }));
+    addAlgorithm(createPBKDF2PasswordAlgorithm({
+        id: "sha512",
+        digest: "SHA-512"
+    }));
+    async function parse(hash) {
+        return PHC.deserialize(hash);
+    }
+    Password.parse = parse;
+    function resolveAlgorithm(id) {
+        let f = id;
+        while (typeof f === "string") {
+            f = Algorithms[f];
+        }
+        if (!f) {
+            throw new Error(`Unknown algorithm ${id}`);
+        }
+        return f;
+    }
+    async function check(password, hash) {
+        let res = await parse(hash);
+        let f = resolveAlgorithm(res.id);
+        return {
+            result: f.verify(password, hash, res),
+            parsed: res
+        };
+    }
+    Password.check = check;
+    async function verify(password, hash) {
+        let res = await parse(hash);
+        let f = resolveAlgorithm(res.id);
+        return f.verify(password, hash, res);
+    }
+    Password.verify = verify;
+    async function hash(password, { algorithm, ...opts } = {}) {
+        let f = resolveAlgorithm(algorithm ?? DefaultAlgorithm);
+        let id = algorithm ?? DefaultAlgorithm;
+        typeof id !== "string" && (id = f.name);
+        return f.hash(password, {
+            id,
+            ...opts
+        });
+    }
+    Password.hash = hash;
+})(Password || (Password = {}));
+export var Password;
+//# sourceMappingURL=Password.js.map

package/lib/password/Password.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/password/Password.ts"],"sourcesContent":["import { Errors } from '@wener/utils';\nimport { createPBKDF2PasswordAlgorithm } from './createPBKDF2PasswordAlgorithm';\nimport { PHC } from './PHC';\n\nexport namespace Password {\n  export interface ParsedPassword {\n    id: string;\n    version?: number;\n    params?: Record<string, string | number>;\n    salt?: Uint8Array;\n    hash?: Uint8Array;\n  }\n\n  type PasswordAlgorithmHashOptions = {\n    rounds?: number;\n    salt?: Uint8Array;\n    id?: string;\n  };\n  type PasswordAlgorithmVerifyOptions = ParsedPassword;\n  export type PasswordAlgorithm = {\n    readonly name: string;\n    readonly ids?: string[];\n    hash(password: string, opts?: PasswordAlgorithmHashOptions): Promise<string>;\n    verify(password: string, hash: string, opts: PasswordAlgorithmVerifyOptions): Promise<boolean>;\n  };\n\n  const Algorithms: Record<string, string | PasswordAlgorithm> = {\n    1: 'md5',\n    '2a': 'bcrypt', // original\n    '2b': 'bcrypt', // February 2014\n    '2x': 'bcrypt', // June 2011\n    '2y': 'bcrypt', // June 2011\n    5: 'sha256',\n    6: 'sha512',\n    7: 'scrypt',\n  };\n  let DefaultAlgorithm: string = '6';\n\n  export function setDefaultAlgorithm(algorithm: string) {\n    Errors.BadRequest.check(Algorithms[algorithm], `Unknown algorithm ${algorithm}`);\n    DefaultAlgorithm = algorithm;\n  }\n\n  export function getDefaultAlgorithm() {\n    return DefaultAlgorithm;\n  }\n\n  export function addAlgorithm(algorithm: PasswordAlgorithm) {\n    Algorithms[algorithm.name] = algorithm;\n    if (algorithm.ids) {\n      for (const id of algorithm.ids) {\n        Algorithms[id] = algorithm;\n      }\n    }\n  }\n\n  addAlgorithm(\n    createPBKDF2PasswordAlgorithm({\n      id: 'sha256',\n      digest: 'SHA-256',\n    }),\n  );\n  addAlgorithm(\n    createPBKDF2PasswordAlgorithm({\n      id: 'sha512',\n      digest: 'SHA-512',\n    }),\n  );\n\n  export async function parse(hash: string) {\n    return PHC.deserialize(hash);\n  }\n\n  function resolveAlgorithm(id: string | PasswordAlgorithm): PasswordAlgorithm {\n    let f = id;\n    while (typeof f === 'string') {\n      f = Algorithms[f];\n    }\n    if (!f) {\n      throw new Error(`Unknown algorithm ${id}`);\n    }\n    return f;\n  }\n\n  export async function check(password: string, hash: string) {\n    let res = await parse(hash);\n    let f = resolveAlgorithm(res.id);\n    return {\n      result: f.verify(password, hash, res),\n      parsed: res,\n    };\n  }\n\n  export async function verify(password: string, hash: string) {\n    let res = await parse(hash);\n    let f = resolveAlgorithm(res.id);\n    return f.verify(password, hash, res);\n  }\n\n  export type PasswordHashOptions = PasswordAlgorithmHashOptions & {\n    algorithm?: string | PasswordAlgorithm;\n  };\n\n  export async function hash(password: string, { algorithm, ...opts }: PasswordHashOptions = {}) {\n    let f = resolveAlgorithm(algorithm ?? DefaultAlgorithm);\n    let id = algorithm ?? DefaultAlgorithm;\n    typeof id !== 'string' && (id = f.name);\n    return f.hash(password, {\n      id,\n      ...opts,\n    });\n  }\n}\n"],"names":["Errors","createPBKDF2PasswordAlgorithm","PHC","Password","Algorithms","DefaultAlgorithm","setDefaultAlgorithm","algorithm","BadRequest","check","getDefaultAlgorithm","addAlgorithm","name","ids","id","digest","parse","hash","deserialize","resolveAlgorithm","f","Error","password","res","result","verify","parsed","opts"],"mappings":"AAAA,SAASA,MAAM,QAAQ,eAAe;AACtC,SAASC,6BAA6B,QAAQ,kCAAkC;AAChF,SAASC,GAAG,QAAQ,QAAQ;UAEXC;IAsBf,MAAMC,aAAyD;QAC7D,GAAG;QACH,MAAM;QACN,MAAM;QACN,MAAM;QACN,MAAM;QACN,GAAG;QACH,GAAG;QACH,GAAG;IACL;IACA,IAAIC,mBAA2B;IAExB,SAASC,oBAAoBC,SAAiB;QACnDP,OAAOQ,UAAU,CAACC,KAAK,CAACL,UAAU,CAACG,UAAU,EAAE,CAAC,kBAAkB,EAAEA,WAAW;QAC/EF,mBAAmBE;IACrB;aAHgBD,sBAAAA;IAKT,SAASI;QACd,OAAOL;IACT;aAFgBK,sBAAAA;IAIT,SAASC,aAAaJ,SAA4B;QACvDH,UAAU,CAACG,UAAUK,IAAI,CAAC,GAAGL;QAC7B,IAAIA,UAAUM,GAAG,EAAE;YACjB,KAAK,MAAMC,MAAMP,UAAUM,GAAG,CAAE;gBAC9BT,UAAU,CAACU,GAAG,GAAGP;YACnB;QACF;IACF;aAPgBI,eAAAA;IAShBA,aACEV,8BAA8B;QAC5Ba,IAAI;QACJC,QAAQ;IACV;IAEFJ,aACEV,8BAA8B;QAC5Ba,IAAI;QACJC,QAAQ;IACV;IAGK,eAAeC,MAAMC,IAAY;QACtC,OAAOf,IAAIgB,WAAW,CAACD;IACzB;aAFsBD,QAAAA;IAItB,SAASG,iBAAiBL,EAA8B;QACtD,IAAIM,IAAIN;QACR,MAAO,OAAOM,MAAM,SAAU;YAC5BA,IAAIhB,UAAU,CAACgB,EAAE;QACnB;QACA,IAAI,CAACA,GAAG;YACN,MAAM,IAAIC,MAAM,CAAC,kBAAkB,EAAEP,IAAI;QAC3C;QACA,OAAOM;IACT;IAEO,eAAeX,MAAMa,QAAgB,EAAEL,IAAY;QACxD,IAAIM,MAAM,MAAMP,MAAMC;QACtB,IAAIG,IAAID,iBAAiBI,IAAIT,EAAE;QAC/B,OAAO;YACLU,QAAQJ,EAAEK,MAAM,CAACH,UAAUL,MAAMM;YACjCG,QAAQH;QACV;IACF;aAPsBd,QAAAA;IASf,eAAegB,OAAOH,QAAgB,EAAEL,IAAY;QACzD,IAAIM,MAAM,MAAMP,MAAMC;QACtB,IAAIG,IAAID,iBAAiBI,IAAIT,EAAE;QAC/B,OAAOM,EAAEK,MAAM,CAACH,UAAUL,MAAMM;IAClC;aAJsBE,SAAAA;IAUf,eAAeR,KAAKK,QAAgB,EAAE,EAAEf,SAAS,EAAE,GAAGoB,MAA2B,GAAG,CAAC,CAAC;QAC3F,IAAIP,IAAID,iBAAiBZ,aAAaF;QACtC,IAAIS,KAAKP,aAAaF;QACtB,OAAOS,OAAO,YAAaA,CAAAA,KAAKM,EAAER,IAAI,AAAD;QACrC,OAAOQ,EAAEH,IAAI,CAACK,UAAU;YACtBR;YACA,GAAGa,IAAI;QACT;IACF;aARsBV,OAAAA;AASxB,GA5GiBd,aAAAA"}

package/lib/password/createArgon2PasswordAlgorithm.js

@@ -0,0 +1,53 @@
+import { maybeFunction } from "@wener/utils";
+export function createArgon2PasswordAlgorithm({ type, provide = async ()=>{
+    throw new Error('Please provide argon2');
+// const { default: wasm } = await import('argon2-browser/dist/argon2.wasm');
+// const argon2 = await WebAssembly.instantiateStreaming(fetch(wasm), {
+//   env: {
+//     memoryBase: 0,
+//     tableBase: 0,
+//     memory: new WebAssembly.Memory({ initial: 256 }),
+//     table: new WebAssembly.Table({ initial: 0, element: 'anyfunc' }),
+//     __memory_base: 0,
+//     __table_base: 0,
+//   },
+// });
+// console.log(argon2.instance.exports);
+// const { hash } = argon2.instance.exports as any as typeof import('argon2-browser');
+} } = {}) {
+    // 0=Argon2d, 1=Argon2i, 2=Argon2id
+    const toType = {
+        argon2d: 0,
+        argon2i: 1,
+        argon2id: 2
+    };
+    let mod;
+    const resolve = ()=>{
+        if (mod) return mod;
+        return Promise.resolve(maybeFunction(provide)).then((v)=>mod = v);
+    };
+    return {
+        name: 'argon2',
+        ids: [
+            'argon2i',
+            'argon2d',
+            'argon2id'
+        ],
+        async hash (password, opts) {
+            // const { hash } = await import('argon2');
+            const { hash } = await resolve();
+            const id = opts?.id;
+            return hash(password, {
+                salt: opts?.salt ? Buffer.from(opts.salt) : undefined,
+                raw: false,
+                type: toType[id || ''] ?? toType[type || '']
+            });
+        },
+        async verify (password, hash) {
+            const { verify } = await resolve();
+            return verify(hash, password);
+        }
+    };
+}
+
+//# sourceMappingURL=createArgon2PasswordAlgorithm.js.map

package/lib/password/createArgon2PasswordAlgorithm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/password/createArgon2PasswordAlgorithm.ts"],"sourcesContent":["import { maybeFunction, type MaybeFunction, type MaybePromise } from '@wener/utils';\nimport { Password } from './Password';\n\ntype Provide = {\n  hash: (password: string, options: { salt?: Buffer; raw?: boolean; type?: 0 | 1 | 2 }) => Promise<string>;\n  verify: (hash: string, password: string) => Promise<boolean>;\n};\n\nexport function createArgon2PasswordAlgorithm({\n  type,\n  provide = async () => {\n    throw new Error('Please provide argon2');\n    // const { default: wasm } = await import('argon2-browser/dist/argon2.wasm');\n    // const argon2 = await WebAssembly.instantiateStreaming(fetch(wasm), {\n    //   env: {\n    //     memoryBase: 0,\n    //     tableBase: 0,\n    //     memory: new WebAssembly.Memory({ initial: 256 }),\n    //     table: new WebAssembly.Table({ initial: 0, element: 'anyfunc' }),\n    //     __memory_base: 0,\n    //     __table_base: 0,\n    //   },\n    // });\n    // console.log(argon2.instance.exports);\n    // const { hash } = argon2.instance.exports as any as typeof import('argon2-browser');\n  },\n  // argon2-browser/dist/argon2-bundled.min.js\n  // import('argon2-browser').then(({ default: { hash, verify } }) => {\n  //   return {\n  //     hash(password, options) {\n  //       return hash({\n  //         pass: password,\n  //       });\n  //     },\n  //     verify(hash, password) {\n  //       return verify({\n  //         pass: password,\n  //         hash: hash,\n  //       })\n  //         .then(() => true)\n  //         .catch(() => false);\n  //     },\n  //   };\n  // }),\n  // provide = () => import('argon2'),\n}: {\n  type?: 'argon2d' | 'argon2i' | 'argon2id';\n  provide?: MaybeFunction<MaybePromise<Provide>>;\n} = {}): Password.PasswordAlgorithm {\n  // 0=Argon2d, 1=Argon2i, 2=Argon2id\n  const toType: Record<string, 0 | 1 | 2 | undefined> = {\n    argon2d: 0,\n    argon2i: 1,\n    argon2id: 2,\n  } as const;\n\n  let mod: Provide;\n  const resolve = () => {\n    if (mod) return mod;\n    return Promise.resolve(maybeFunction(provide)).then((v) => (mod = v));\n  };\n  return {\n    name: 'argon2',\n    ids: ['argon2i', 'argon2d', 'argon2id'],\n    async hash(password: string, opts) {\n      // const { hash } = await import('argon2');\n      const { hash } = await resolve();\n      const id = opts?.id;\n      return hash(password, {\n        salt: opts?.salt ? Buffer.from(opts.salt) : undefined,\n        raw: false,\n        type: toType[id || ''] ?? toType[type || ''],\n      });\n    },\n    async verify(password: string, hash: string) {\n      const { verify } = await resolve();\n      return verify(hash, password);\n    },\n  };\n}\n"],"names":["maybeFunction","createArgon2PasswordAlgorithm","type","provide","Error","toType","argon2d","argon2i","argon2id","mod","resolve","Promise","then","v","name","ids","hash","password","opts","id","salt","Buffer","from","undefined","raw","verify"],"mappings":"AAAA,SAASA,aAAa,QAA+C,eAAe;AAQpF,OAAO,SAASC,8BAA8B,EAC5CC,IAAI,EACJC,UAAU;IACR,MAAM,IAAIC,MAAM;AAChB,6EAA6E;AAC7E,uEAAuE;AACvE,WAAW;AACX,qBAAqB;AACrB,oBAAoB;AACpB,wDAAwD;AACxD,wEAAwE;AACxE,wBAAwB;AACxB,uBAAuB;AACvB,OAAO;AACP,MAAM;AACN,wCAAwC;AACxC,sFAAsF;AACxF,CAAC,EAuBF,GAAG,CAAC,CAAC;IACJ,mCAAmC;IACnC,MAAMC,SAAgD;QACpDC,SAAS;QACTC,SAAS;QACTC,UAAU;IACZ;IAEA,IAAIC;IACJ,MAAMC,UAAU;QACd,IAAID,KAAK,OAAOA;QAChB,OAAOE,QAAQD,OAAO,CAACV,cAAcG,UAAUS,IAAI,CAAC,CAACC,IAAOJ,MAAMI;IACpE;IACA,OAAO;QACLC,MAAM;QACNC,KAAK;YAAC;YAAW;YAAW;SAAW;QACvC,MAAMC,MAAKC,QAAgB,EAAEC,IAAI;YAC/B,2CAA2C;YAC3C,MAAM,EAAEF,IAAI,EAAE,GAAG,MAAMN;YACvB,MAAMS,KAAKD,MAAMC;YACjB,OAAOH,KAAKC,UAAU;gBACpBG,MAAMF,MAAME,OAAOC,OAAOC,IAAI,CAACJ,KAAKE,IAAI,IAAIG;gBAC5CC,KAAK;gBACLtB,MAAMG,MAAM,CAACc,MAAM,GAAG,IAAId,MAAM,CAACH,QAAQ,GAAG;YAC9C;QACF;QACA,MAAMuB,QAAOR,QAAgB,EAAED,IAAY;YACzC,MAAM,EAAES,MAAM,EAAE,GAAG,MAAMf;YACzB,OAAOe,OAAOT,MAAMC;QACtB;IACF;AACF"}

package/lib/password/createBase64PasswordAlgorithm.js

@@ -0,0 +1,14 @@
+import { ArrayBuffers } from "@wener/utils";
+export function createBase64PasswordAlgorithm({ id = 'base64' } = {}) {
+    return {
+        name: id,
+        async hash (password) {
+            return `$${id}$$${ArrayBuffers.toBase64(password).replace(/=/g, '')}`;
+        },
+        async verify (password, hash, opts) {
+            return Boolean(opts.hash) && ArrayBuffers.toString(opts.hash) === password;
+        }
+    };
+}
+
+//# sourceMappingURL=createBase64PasswordAlgorithm.js.map

package/lib/password/createBase64PasswordAlgorithm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/password/createBase64PasswordAlgorithm.ts"],"sourcesContent":["import { ArrayBuffers } from '@wener/utils';\nimport { Password } from './Password';\n\nexport function createBase64PasswordAlgorithm({ id = 'base64' }: { id?: string } = {}): Password.PasswordAlgorithm {\n  return {\n    name: id,\n    async hash(password: string) {\n      return `$${id}$$${ArrayBuffers.toBase64(password).replace(/=/g, '')}`;\n    },\n    async verify(password: string, hash: string, opts) {\n      return Boolean(opts.hash) && ArrayBuffers.toString(opts.hash!) === password;\n    },\n  };\n}\n"],"names":["ArrayBuffers","createBase64PasswordAlgorithm","id","name","hash","password","toBase64","replace","verify","opts","Boolean","toString"],"mappings":"AAAA,SAASA,YAAY,QAAQ,eAAe;AAG5C,OAAO,SAASC,8BAA8B,EAAEC,KAAK,QAAQ,EAAmB,GAAG,CAAC,CAAC;IACnF,OAAO;QACLC,MAAMD;QACN,MAAME,MAAKC,QAAgB;YACzB,OAAO,CAAC,CAAC,EAAEH,GAAG,EAAE,EAAEF,aAAaM,QAAQ,CAACD,UAAUE,OAAO,CAAC,MAAM,KAAK;QACvE;QACA,MAAMC,QAAOH,QAAgB,EAAED,IAAY,EAAEK,IAAI;YAC/C,OAAOC,QAAQD,KAAKL,IAAI,KAAKJ,aAAaW,QAAQ,CAACF,KAAKL,IAAI,MAAOC;QACrE;IACF;AACF"}

package/lib/password/createBcryptPasswordAlgorithm.js

@@ -0,0 +1,20 @@
+export function createBcryptPasswordAlgorithm({ // provider = () => import('bcrypt').then((v) => v.default),
+provider = ()=>import("bcryptjs").then((v)=>v.default) } = {}) {
+    // bcrypt or bcryptjs
+    return {
+        name: 'bcrypt',
+        async hash (password, opts) {
+            const { hash } = await provider();
+            return hash(password, opts?.rounds ?? 10);
+        },
+        async verify (password, hash) {
+            const { compare } = await provider();
+            if (hash.startsWith('$2y$')) {
+                hash = hash.replace(/^\$2y\$/, '$2a$');
+            }
+            return compare(password, hash);
+        }
+    };
+}
+
+//# sourceMappingURL=createBcryptPasswordAlgorithm.js.map

package/lib/password/createBcryptPasswordAlgorithm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/password/createBcryptPasswordAlgorithm.ts"],"sourcesContent":["import type { MaybePromise } from '@wener/utils';\nimport { Password } from './Password';\n\ntype ProviderType = () => MaybePromise<{\n  hash: (password: string, rounds: number | string) => Promise<string>;\n  compare: (password: string, hash: string) => Promise<boolean>;\n}>;\n\nexport function createBcryptPasswordAlgorithm({\n  // provider = () => import('bcrypt').then((v) => v.default),\n  provider = () => import('bcryptjs').then((v) => v.default),\n}: {\n  provider?: ProviderType;\n} = {}): Password.PasswordAlgorithm {\n  // bcrypt or bcryptjs\n  return {\n    name: 'bcrypt',\n    async hash(password: string, opts) {\n      const { hash } = await provider();\n      return hash(password, opts?.rounds ?? 10);\n    },\n    async verify(password: string, hash: string) {\n      const { compare } = await provider();\n      if (hash.startsWith('$2y$')) {\n        hash = hash.replace(/^\\$2y\\$/, '$2a$');\n      }\n      return compare(password, hash);\n    },\n  };\n}\n"],"names":["createBcryptPasswordAlgorithm","provider","then","v","default","name","hash","password","opts","rounds","verify","compare","startsWith","replace"],"mappings":"AAQA,OAAO,SAASA,8BAA8B,EAC5C,4DAA4D;AAC5DC,WAAW,IAAM,MAAM,CAAC,YAAYC,IAAI,CAAC,CAACC,IAAMA,EAAEC,OAAO,CAAC,EAG3D,GAAG,CAAC,CAAC;IACJ,qBAAqB;IACrB,OAAO;QACLC,MAAM;QACN,MAAMC,MAAKC,QAAgB,EAAEC,IAAI;YAC/B,MAAM,EAAEF,IAAI,EAAE,GAAG,MAAML;YACvB,OAAOK,KAAKC,UAAUC,MAAMC,UAAU;QACxC;QACA,MAAMC,QAAOH,QAAgB,EAAED,IAAY;YACzC,MAAM,EAAEK,OAAO,EAAE,GAAG,MAAMV;YAC1B,IAAIK,KAAKM,UAAU,CAAC,SAAS;gBAC3BN,OAAOA,KAAKO,OAAO,CAAC,WAAW;YACjC;YACA,OAAOF,QAAQJ,UAAUD;QAC3B;IACF;AACF"}

package/lib/password/createPBKDF2PasswordAlgorithm.js

@@ -0,0 +1,54 @@
+import { Errors } from "@wener/utils";
+import { PHC } from "./PHC.js";
+export function createPBKDF2PasswordAlgorithm({ id, digest, iterations = 100000, saltlen = 16, keylen = digest === "SHA-256" ? 32 : 64 }) {
+    return {
+        name: id,
+        async hash(password, opts) {
+            let salt;
+            if (opts?.salt) {
+                salt = opts.salt;
+            }
+            else {
+                salt = new Uint8Array(saltlen);
+                crypto.getRandomValues(salt);
+            }
+            const rounds = opts?.rounds ?? iterations;
+            let key = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, [
+                "deriveBits"
+            ]);
+            let hash = await crypto.subtle.deriveBits({
+                name: "PBKDF2",
+                iterations: rounds,
+                salt,
+                hash: digest
+            }, key, keylen * 8);
+            return PHC.serialize({
+                id: opts?.id ?? id,
+                params: {
+                    rounds
+                },
+                salt,
+                hash: new Uint8Array(hash)
+            });
+        },
+        async verify(password, _, opts) {
+            const rounds = opts?.params?.rounds ?? iterations;
+            const salt = opts.salt;
+            const storedHash = opts.hash;
+            Errors.BadRequest.check(typeof rounds === "number", "Invalid rounds");
+            Errors.BadRequest.check(salt instanceof Uint8Array, "Invalid salt");
+            Errors.BadRequest.check(storedHash instanceof Uint8Array, "Invalid hash");
+            let key = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, [
+                "deriveBits"
+            ]);
+            let hash = await crypto.subtle.deriveBits({
+                name: "PBKDF2",
+                iterations: rounds,
+                salt,
+                hash: digest
+            }, key, storedHash.length * 8);
+            return new Uint8Array(hash).every((v, i) => v === storedHash[i]);
+        }
+    };
+}
+//# sourceMappingURL=createPBKDF2PasswordAlgorithm.js.map

package/lib/password/createPBKDF2PasswordAlgorithm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/password/createPBKDF2PasswordAlgorithm.ts"],"sourcesContent":["import { Errors } from '@wener/utils';\nimport { Password } from './Password';\nimport { PHC } from './PHC';\n\nexport function createPBKDF2PasswordAlgorithm({\n  id,\n  digest,\n  iterations = 100000,\n  saltlen = 16,\n  keylen = digest === 'SHA-256' ? 32 : 64,\n}: {\n  id: string;\n  digest: 'SHA-256' | 'SHA-512';\n  iterations?: number;\n  keylen?: number;\n  saltlen?: number;\n}): Password.PasswordAlgorithm {\n  return {\n    name: id,\n    async hash(password: string, opts) {\n      let salt: Uint8Array;\n\n      if (opts?.salt) {\n        salt = opts.salt;\n      } else {\n        salt = new Uint8Array(saltlen);\n        crypto.getRandomValues(salt);\n      }\n\n      const rounds = opts?.rounds ?? iterations;\n\n      let key = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, [\n        'deriveBits',\n      ]);\n      let hash = await crypto.subtle.deriveBits(\n        { name: 'PBKDF2', iterations: rounds, salt, hash: digest },\n        key,\n        keylen * 8,\n      );\n      return PHC.serialize({\n        id: opts?.id ?? id,\n        params: {\n          rounds,\n        },\n        salt,\n        hash: new Uint8Array(hash),\n      });\n    },\n    async verify(password: string, _: string, opts) {\n      const rounds = opts?.params?.rounds ?? iterations;\n      const salt = opts.salt;\n      const storedHash = opts.hash;\n      Errors.BadRequest.check(typeof rounds === 'number', 'Invalid rounds');\n      Errors.BadRequest.check(salt instanceof Uint8Array, 'Invalid salt');\n      Errors.BadRequest.check(storedHash instanceof Uint8Array, 'Invalid hash');\n\n      let key = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, [\n        'deriveBits',\n      ]);\n      let hash = await crypto.subtle.deriveBits(\n        {\n          name: 'PBKDF2',\n          iterations: rounds,\n          salt,\n          hash: digest,\n        },\n        key,\n        storedHash.length * 8,\n      );\n      return new Uint8Array(hash).every((v, i) => v === storedHash![i]);\n    },\n  };\n}\n"],"names":["Errors","PHC","createPBKDF2PasswordAlgorithm","id","digest","iterations","saltlen","keylen","name","hash","password","opts","salt","Uint8Array","crypto","getRandomValues","rounds","key","subtle","importKey","TextEncoder","encode","deriveBits","serialize","params","verify","_","storedHash","BadRequest","check","length","every","v","i"],"mappings":"AAAA,SAASA,MAAM,QAAQ,eAAe;AAEtC,SAASC,GAAG,QAAQ,QAAQ;AAE5B,OAAO,SAASC,8BAA8B,EAC5CC,EAAE,EACFC,MAAM,EACNC,aAAa,MAAM,EACnBC,UAAU,EAAE,EACZC,SAASH,WAAW,YAAY,KAAK,EAAE,EAOxC;IACC,OAAO;QACLI,MAAML;QACN,MAAMM,MAAKC,QAAgB,EAAEC,IAAI;YAC/B,IAAIC;YAEJ,IAAID,MAAMC,MAAM;gBACdA,OAAOD,KAAKC,IAAI;YAClB,OAAO;gBACLA,OAAO,IAAIC,WAAWP;gBACtBQ,OAAOC,eAAe,CAACH;YACzB;YAEA,MAAMI,SAASL,MAAMK,UAAUX;YAE/B,IAAIY,MAAM,MAAMH,OAAOI,MAAM,CAACC,SAAS,CAAC,OAAO,IAAIC,cAAcC,MAAM,CAACX,WAAW,UAAU,OAAO;gBAClG;aACD;YACD,IAAID,OAAO,MAAMK,OAAOI,MAAM,CAACI,UAAU,CACvC;gBAAEd,MAAM;gBAAUH,YAAYW;gBAAQJ;gBAAMH,MAAML;YAAO,GACzDa,KACAV,SAAS;YAEX,OAAON,IAAIsB,SAAS,CAAC;gBACnBpB,IAAIQ,MAAMR,MAAMA;gBAChBqB,QAAQ;oBACNR;gBACF;gBACAJ;gBACAH,MAAM,IAAII,WAAWJ;YACvB;QACF;QACA,MAAMgB,QAAOf,QAAgB,EAAEgB,CAAS,EAAEf,IAAI;YAC5C,MAAMK,SAASL,MAAMa,QAAQR,UAAUX;YACvC,MAAMO,OAAOD,KAAKC,IAAI;YACtB,MAAMe,aAAahB,KAAKF,IAAI;YAC5BT,OAAO4B,UAAU,CAACC,KAAK,CAAC,OAAOb,WAAW,UAAU;YACpDhB,OAAO4B,UAAU,CAACC,KAAK,CAACjB,gBAAgBC,YAAY;YACpDb,OAAO4B,UAAU,CAACC,KAAK,CAACF,sBAAsBd,YAAY;YAE1D,IAAII,MAAM,MAAMH,OAAOI,MAAM,CAACC,SAAS,CAAC,OAAO,IAAIC,cAAcC,MAAM,CAACX,WAAW,UAAU,OAAO;gBAClG;aACD;YACD,IAAID,OAAO,MAAMK,OAAOI,MAAM,CAACI,UAAU,CACvC;gBACEd,MAAM;gBACNH,YAAYW;gBACZJ;gBACAH,MAAML;YACR,GACAa,KACAU,WAAWG,MAAM,GAAG;YAEtB,OAAO,IAAIjB,WAAWJ,MAAMsB,KAAK,CAAC,CAACC,GAAGC,IAAMD,MAAML,UAAW,CAACM,EAAE;QAClE;IACF;AACF"}

package/lib/password/createScryptPasswordAlgorithm.js

@@ -0,0 +1,66 @@
+import { randomBytes, scrypt, timingSafeEqual } from "node:crypto";
+import { Errors } from "@wener/utils";
+import { PHC } from "./PHC.js";
+export function createScryptPasswordAlgorithm(options = {}) {
+    let id = options.id || "scrypt";
+    options.cost ||= Math.pow(2, 14);
+    options.blocksize ||= 8;
+    options.parallelism ||= 1;
+    options.saltlen ||= 16;
+    options.keylen ||= 32;
+    return {
+        name: id,
+        async hash(password, opts) {
+            const salt = opts?.salt || randomBytes(options.saltlen);
+            return new Promise((resolve, reject) => {
+                let N = options.cost;
+                let r = options.blocksize;
+                let p = options.parallelism;
+                scrypt(password, salt, options.keylen, {
+                    N,
+                    r,
+                    p
+                }, (err, derivedKey) => {
+                    if (err)
+                        return reject(err);
+                    resolve(PHC.serialize({
+                        id: opts?.id ?? id,
+                        params: {
+                            ln: N,
+                            r: r,
+                            p: p
+                        },
+                        salt,
+                        hash: derivedKey
+                    }));
+                });
+            });
+        },
+        async verify(password, hash, opts) {
+            try {
+                const salt = Errors.BadRequest.require(opts.salt);
+                const storedHash = Errors.BadRequest.require(opts.hash);
+                const N = parseInt(opts.params?.ln, 10);
+                const r = parseInt(opts.params?.r, 10);
+                const p = parseInt(opts.params?.p, 10);
+                const keylen = storedHash.length;
+                return new Promise((resolve, reject) => {
+                    scrypt(password, salt, keylen, {
+                        N,
+                        r,
+                        p
+                    }, (err, derivedKey) => {
+                        if (err)
+                            return reject(err);
+                        const isMatch = timingSafeEqual(derivedKey, storedHash);
+                        resolve(isMatch);
+                    });
+                });
+            }
+            catch (error) {
+                return Promise.resolve(false);
+            }
+        }
+    };
+}
+//# sourceMappingURL=createScryptPasswordAlgorithm.js.map

package/lib/password/createScryptPasswordAlgorithm.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/password/createScryptPasswordAlgorithm.ts"],"sourcesContent":["import { randomBytes, scrypt, timingSafeEqual } from 'node:crypto';\nimport { Errors } from '@wener/utils';\nimport { Password } from './Password';\nimport { PHC } from './PHC';\n\nexport function createScryptPasswordAlgorithm(\n  options: {\n    id?: string;\n    cost?: number;\n    blocksize?: number;\n    parallelism?: number;\n    saltlen?: number;\n    keylen?: number;\n  } = {},\n): Password.PasswordAlgorithm {\n  let id = options.id || 'scrypt';\n  options.cost ||= Math.pow(2, 14);\n  options.blocksize ||= 8;\n  options.parallelism ||= 1;\n  options.saltlen ||= 16;\n  options.keylen ||= 32;\n  return {\n    name: id,\n    async hash(password: string, opts): Promise<string> {\n      const salt = opts?.salt || randomBytes(options.saltlen!);\n      return new Promise((resolve, reject) => {\n        let N = options.cost!;\n        let r = options.blocksize!;\n        let p = options.parallelism!;\n        scrypt(password, salt, options.keylen!, { N, r, p }, (err, derivedKey) => {\n          if (err) return reject(err);\n\n          resolve(\n            PHC.serialize({\n              id: opts?.id ?? id,\n              params: {\n                ln: N!,\n                r: r!,\n                p: p!,\n              },\n              salt,\n              hash: derivedKey,\n            }),\n          );\n        });\n      });\n    },\n\n    async verify(password: string, hash: string, opts): Promise<boolean> {\n      try {\n        const salt = Errors.BadRequest.require(opts.salt);\n        const storedHash = Errors.BadRequest.require(opts.hash);\n\n        const N = parseInt(opts.params?.ln as string, 10);\n        const r = parseInt(opts.params?.r as string, 10);\n        const p = parseInt(opts.params?.p as string, 10);\n        const keylen = storedHash.length;\n\n        return new Promise((resolve, reject) => {\n          scrypt(password, salt, keylen, { N, r, p }, (err, derivedKey) => {\n            if (err) return reject(err);\n\n            const isMatch = timingSafeEqual(derivedKey, storedHash);\n            resolve(isMatch);\n          });\n        });\n      } catch (error) {\n        return Promise.resolve(false);\n      }\n    },\n  };\n}\n"],"names":["randomBytes","scrypt","timingSafeEqual","Errors","PHC","createScryptPasswordAlgorithm","options","id","cost","Math","pow","blocksize","parallelism","saltlen","keylen","name","hash","password","opts","salt","Promise","resolve","reject","N","r","p","err","derivedKey","serialize","params","ln","verify","BadRequest","require","storedHash","parseInt","length","isMatch","error"],"mappings":"AAAA,SAASA,WAAW,EAAEC,MAAM,EAAEC,eAAe,QAAQ,cAAc;AACnE,SAASC,MAAM,QAAQ,eAAe;AAEtC,SAASC,GAAG,QAAQ,QAAQ;AAE5B,OAAO,SAASC,8BACdC,UAOI,CAAC,CAAC;IAEN,IAAIC,KAAKD,QAAQC,EAAE,IAAI;IACvBD,QAAQE,IAAI,KAAKC,KAAKC,GAAG,CAAC,GAAG;IAC7BJ,QAAQK,SAAS,KAAK;IACtBL,QAAQM,WAAW,KAAK;IACxBN,QAAQO,OAAO,KAAK;IACpBP,QAAQQ,MAAM,KAAK;IACnB,OAAO;QACLC,MAAMR;QACN,MAAMS,MAAKC,QAAgB,EAAEC,IAAI;YAC/B,MAAMC,OAAOD,MAAMC,QAAQnB,YAAYM,QAAQO,OAAO;YACtD,OAAO,IAAIO,QAAQ,CAACC,SAASC;gBAC3B,IAAIC,IAAIjB,QAAQE,IAAI;gBACpB,IAAIgB,IAAIlB,QAAQK,SAAS;gBACzB,IAAIc,IAAInB,QAAQM,WAAW;gBAC3BX,OAAOgB,UAAUE,MAAMb,QAAQQ,MAAM,EAAG;oBAAES;oBAAGC;oBAAGC;gBAAE,GAAG,CAACC,KAAKC;oBACzD,IAAID,KAAK,OAAOJ,OAAOI;oBAEvBL,QACEjB,IAAIwB,SAAS,CAAC;wBACZrB,IAAIW,MAAMX,MAAMA;wBAChBsB,QAAQ;4BACNC,IAAIP;4BACJC,GAAGA;4BACHC,GAAGA;wBACL;wBACAN;wBACAH,MAAMW;oBACR;gBAEJ;YACF;QACF;QAEA,MAAMI,QAAOd,QAAgB,EAAED,IAAY,EAAEE,IAAI;YAC/C,IAAI;gBACF,MAAMC,OAAOhB,OAAO6B,UAAU,CAACC,OAAO,CAACf,KAAKC,IAAI;gBAChD,MAAMe,aAAa/B,OAAO6B,UAAU,CAACC,OAAO,CAACf,KAAKF,IAAI;gBAEtD,MAAMO,IAAIY,SAASjB,KAAKW,MAAM,EAAEC,IAAc;gBAC9C,MAAMN,IAAIW,SAASjB,KAAKW,MAAM,EAAEL,GAAa;gBAC7C,MAAMC,IAAIU,SAASjB,KAAKW,MAAM,EAAEJ,GAAa;gBAC7C,MAAMX,SAASoB,WAAWE,MAAM;gBAEhC,OAAO,IAAIhB,QAAQ,CAACC,SAASC;oBAC3BrB,OAAOgB,UAAUE,MAAML,QAAQ;wBAAES;wBAAGC;wBAAGC;oBAAE,GAAG,CAACC,KAAKC;wBAChD,IAAID,KAAK,OAAOJ,OAAOI;wBAEvB,MAAMW,UAAUnC,gBAAgByB,YAAYO;wBAC5Cb,QAAQgB;oBACV;gBACF;YACF,EAAE,OAAOC,OAAO;gBACd,OAAOlB,QAAQC,OAAO,CAAC;YACzB;QACF;IACF;AACF"}

package/lib/password/index.js

@@ -0,0 +1,6 @@
+export { PHC } from "./PHC.js";
+export { Password } from "./Password.js";
+export { createArgon2PasswordAlgorithm } from "./createArgon2PasswordAlgorithm.js";
+export { createBase64PasswordAlgorithm } from "./createBase64PasswordAlgorithm.js";
+export { createBcryptPasswordAlgorithm } from "./createBcryptPasswordAlgorithm.js";
+//# sourceMappingURL=index.js.map

package/lib/password/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/password/index.ts"],"sourcesContent":["export { PHC } from './PHC';\nexport { Password } from './Password';\nexport { createArgon2PasswordAlgorithm } from './createArgon2PasswordAlgorithm';\nexport { createBase64PasswordAlgorithm } from './createBase64PasswordAlgorithm';\nexport { createBcryptPasswordAlgorithm } from './createBcryptPasswordAlgorithm';\n"],"names":["PHC","Password","createArgon2PasswordAlgorithm","createBase64PasswordAlgorithm","createBcryptPasswordAlgorithm"],"mappings":"AAAA,SAASA,GAAG,QAAQ,QAAQ;AAC5B,SAASC,QAAQ,QAAQ,aAAa;AACtC,SAASC,6BAA6B,QAAQ,kCAAkC;AAChF,SAASC,6BAA6B,QAAQ,kCAAkC;AAChF,SAASC,6BAA6B,QAAQ,kCAAkC"}

package/lib/password/server/index.js

@@ -0,0 +1,2 @@
+export { createScryptPasswordAlgorithm } from "../createScryptPasswordAlgorithm.js";
+//# sourceMappingURL=index.js.map

package/lib/password/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/password/server/index.ts"],"sourcesContent":["export { createScryptPasswordAlgorithm } from '../createScryptPasswordAlgorithm';\n"],"names":["createScryptPasswordAlgorithm"],"mappings":"AAAA,SAASA,6BAA6B,QAAQ,mCAAmC"}