@pirxpilot/argon2 1.0.0 → 1.0.2

package/argon2.d.ts

@@ -0,0 +1,76 @@
+declare module 'argon2' {
+  /**
+   * Hashes a password with Argon2, producing a raw hash
+   *
+   * @overload
+   * @param {Buffer | string} password The plaintext password to be hashed
+   * @param {Options & { raw: true }} options The parameters for Argon2
+   * @returns {Promise<Buffer>} The raw hash generated from `password`
+   */
+  export function hash(
+    password: Buffer | string,
+    options: Options & {
+      raw: true;
+    }
+  ): Promise<Buffer>;
+  /**
+   * Hashes a password with Argon2, producing an encoded hash
+   *
+   * @overload
+   * @param {Buffer | string} password The plaintext password to be hashed
+   * @param {Options & { raw?: boolean }} [options] The parameters for Argon2
+   * @returns {Promise<string>} The encoded hash generated from `password`
+   */
+  export function hash(
+    password: Buffer | string,
+    options?: Options & {
+      raw?: boolean;
+    }
+  ): Promise<string>;
+  /**
+   * @param {string} digest The digest to be checked
+   * @param {Object} [options] The current parameters for Argon2
+   * @param {number} [options.timeCost=3]
+   * @param {number} [options.memoryCost=65536]
+   * @param {number} [options.parallelism=4]
+   * @param {number} [options.version=0x13]
+   * @returns {boolean} `true` if the digest parameters do not match the parameters in `options`, otherwise `false`
+   */
+  export function needsRehash(
+    digest: string,
+    options?: {
+      timeCost?: number;
+      memoryCost?: number;
+      parallelism?: number;
+      version?: number;
+    }
+  ): boolean;
+  /**
+   * @param {string} digest The digest to be checked
+   * @param {Buffer | string} password The plaintext password to be verified
+   * @param {Object} [options] The current parameters for Argon2
+   * @param {Buffer} [options.secret]
+   * @returns {Promise<boolean>} `true` if the digest parameters matches the hash generated from `password`, otherwise `false`
+   */
+  export function verify(
+    digest: string,
+    password: Buffer | string,
+    options?: {
+      secret?: Buffer;
+    }
+  ): Promise<boolean>;
+  export const argon2d: 0;
+  export const argon2i: 1;
+  export const argon2id: 2;
+  export type Options = {
+    hashLength?: number;
+    timeCost?: number;
+    memoryCost?: number;
+    parallelism?: number;
+    type?: 0 | 1 | 2;
+    version?: number;
+    salt?: Buffer;
+    associatedData?: Buffer;
+    secret?: Buffer;
+  };
+}

package/argon2.js

@@ -2,6 +2,7 @@ import { argon2, randomBytes, timingSafeEqual } from 'node:crypto';
 import { promisify } from 'node:util';
 import { deserialize, serialize } from '@phc/format';
 
+/** @type {(id: string, options: object) => Promise<Buffer>} */
 const asyncArgon2 = promisify(argon2);
 
 /** @type {(size: number) => Promise<Buffer>} */
@@ -11,15 +12,7 @@ export const argon2d = 0;
 export const argon2i = 1;
 export const argon2id = 2;
 
-/** @enum {argon2i | argon2d | argon2id} */
-const types = Object.freeze({ argon2d, argon2i, argon2id });
-
-/** @enum {'argon2d' | 'argon2i' | 'argon2id'} */
-const names = Object.freeze({
-  [types.argon2d]: 'argon2d',
-  [types.argon2i]: 'argon2i',
-  [types.argon2id]: 'argon2id'
-});
+const names = ['argon2d', 'argon2i', 'argon2id'];
 
 const defaults = {
   hashLength: 32,
@@ -36,8 +29,8 @@ const defaults = {
  * @property {number} [timeCost=3]
  * @property {number} [memoryCost=65536]
  * @property {number} [parallelism=4]
- * @property {keyof typeof names} [type=argon2id]
- * @property {number} [version=19]
+ * @property {argon2d | argon2i | argon2id} [type=argon2id]
+ * @property {number} [version=0x13]
  * @property {Buffer} [salt]
  * @property {Buffer} [associatedData]
  * @property {Buffer} [secret]
@@ -150,7 +143,8 @@ export function needsRehash(digest, options = {}) {
  */
 export async function verify(digest, password, options = {}) {
   const { id, ...rest } = deserialize(digest);
-  if (!(id in types)) {
+  if (!names.includes(id)) {
+    console.error(`Unknown Argon2 id: ${id}`);
     return false;
   }
 
@@ -163,7 +157,7 @@ export async function verify(digest, password, options = {}) {
   const { secret = Buffer.alloc(0) } = options;
 
   return timingSafeEqual(
-    await asyncArgon2(names[types[id]], {
+    await asyncArgon2(id, {
       message: Buffer.from(password),
       nonce: salt,
       tagLength: hash.byteLength,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pirxpilot/argon2",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "An Argon2 library for Node",
   "keywords": [
     "argon2",
@@ -17,8 +17,10 @@
   "author": "Ranieri Althoff <ranisalt+argon2@gmail.com>",
   "type": "module",
   "exports": "./argon2.js",
+  "types": "./argon2.d.ts",
   "files": [
-    "argon2.js"
+    "argon2.js",
+    "argon2.d.ts"
   ],
   "scripts": {
     "test": "make check"