Remove minimum parameter checks and exported limits

Author: ranisalt

argon2.cjs

@@ -27,22 +27,14 @@ const names = Object.freeze({
   [types.argon2id]: "argon2id",
 });
 
-const defaults = Object.freeze({
+const defaults = {
   hashLength: 32,
   timeCost: 3,
   memoryCost: 1 << 16,
   parallelism: 4,
   type: argon2id,
   version: 0x13,
-});
-
-const limits = Object.freeze({
-  hashLength: { min: 4, max: 2 ** 32 - 1 },
-  memoryCost: { min: 1 << 10, max: 2 ** 32 - 1 },
-  timeCost: { min: 2, max: 2 ** 32 - 1 },
-  parallelism: { min: 1, max: 2 ** 24 - 1 },
-});
-module.exports.limits = limits;
+};
 
 /**
  * @typedef {Object} Options
@@ -80,12 +72,20 @@ module.exports.limits = limits;
 async function hash(password, options) {
   let { raw, salt, ...rest } = { ...defaults, ...options };
 
-  for (const [key, { min, max }] of Object.entries(limits)) {
-    const value = rest[key];
-    assert(
-      min <= value && value <= max,
-      `Invalid ${key}, must be between ${min} and ${max}.`,
-    );
+  if (rest.hashLength > 2 ** 32 - 1) {
+    throw new RangeError("Hash length is too large");
+  }
+
+  if (rest.memoryCost > 2 ** 32 - 1) {
+    throw new RangeError("Memory cost is too large");
+  }
+
+  if (rest.timeCost > 2 ** 32 - 1) {
+    throw new RangeError("Time cost is too large");
+  }
+
+  if (rest.parallelism > 2 ** 24 - 1) {
+    throw new RangeError("Parallelism is too large");
   }
 
   salt = salt ?? (await generateSalt(16));

test.cjs

@@ -2,7 +2,7 @@ const assert = require("node:assert/strict");
 const { describe, it } = require("node:test");
 const argon2 = require("./argon2.cjs");
 
-const { argon2i, argon2d, argon2id, limits } = argon2;
+const { argon2i, argon2d, argon2id } = argon2;
 
 const password = "password";
 const salt = Buffer.alloc(16, "salt");
@@ -121,17 +121,11 @@ describe("set options", () => {
     assert.match(await argon2.hash(password, { timeCost: 4 }), /t=4/);
   });
 
-  it("hash with low time cost", async () => {
+  it("hash with high time cost", () => {
     assert.rejects(
-      argon2.hash(password, { timeCost: limits.timeCost.min - 1 }),
-      /invalid timeCost.+between \d+ and \d+/i,
-    );
-  });
-
-  it("hash with high time cost", async () => {
-    assert.rejects(
-      argon2.hash(password, { timeCost: limits.timeCost.max + 1 }),
-      /invalid timeCost.+between \d+ and \d+/i,
+      argon2.hash(password, { timeCost: Number.MAX_SAFE_INTEGER }),
+      RangeError,
+      "Time cost is too large",
     );
   });
 
@@ -140,17 +134,11 @@ describe("set options", () => {
     assert.match(await argon2.hash(password, { hashLength: 4 }), /\$[^$]{6}$/);
   });
 
-  it("hash with low hash length", async () => {
-    assert.rejects(
-      argon2.hash(password, { hashLength: limits.hashLength.min - 1 }),
-      /invalid hashLength.+between \d+ and \d+/i,
-    );
-  });
-
-  it("hash with high hash length", async () => {
+  it("hash with high hash length", () => {
     assert.rejects(
-      argon2.hash(password, { hashLength: limits.hashLength.max + 1 }),
-      /invalid hashLength.+between \d+ and \d+/i,
+      argon2.hash(password, { hashLength: Number.MAX_SAFE_INTEGER }),
+      RangeError,
+      "Hash length is too large",
     );
   });
 
@@ -161,35 +149,23 @@ describe("set options", () => {
     );
   });
 
-  it("hash with low memory cost", async () => {
+  it("hash with high memory cost", () => {
     assert.rejects(
-      argon2.hash(password, { memoryCost: limits.memoryCost.min / 2 }),
-      /invalid memoryCost.+between \d+ and \d+/i,
-    );
-  });
-
-  it("hash with high memory cost", async () => {
-    assert.rejects(
-      argon2.hash(password, { memoryCost: limits.memoryCost.max * 2 }),
-      /invalid memoryCost.+between \d+ and \d+/i,
+      argon2.hash(password, { memoryCost: Number.MAX_SAFE_INTEGER }),
+      RangeError,
+      "Memory cost is too large",
     );
   });
 
   it("hash with parallelism", async () => {
     assert.match(await argon2.hash(password, { parallelism: 2 }), /p=2/);
   });
 
-  it("hash with low parallelism", async () => {
-    assert.rejects(
-      argon2.hash(password, { parallelism: limits.parallelism.min - 1 }),
-      /invalid parallelism.+between \d+ and \d+/i,
-    );
-  });
-
-  it("hash with high parallelism", async () => {
+  it("hash with high parallelism", () => {
     assert.rejects(
-      argon2.hash(password, { parallelism: limits.parallelism.max + 1 }),
-      /invalid parallelism.+between \d+ and \d+/i,
+      argon2.hash(password, { parallelism: Number.MAX_SAFE_INTEGER }),
+      RangeError,
+      "Parallelism is too large",
     );
   });