aboutsummaryrefslogtreecommitdiff
path: root/test/js/node/crypto/crypto-scrypt.test.js
diff options
context:
space:
mode:
Diffstat (limited to 'test/js/node/crypto/crypto-scrypt.test.js')
-rw-r--r--test/js/node/crypto/crypto-scrypt.test.js232
1 files changed, 232 insertions, 0 deletions
diff --git a/test/js/node/crypto/crypto-scrypt.test.js b/test/js/node/crypto/crypto-scrypt.test.js
new file mode 100644
index 000000000..4b7412251
--- /dev/null
+++ b/test/js/node/crypto/crypto-scrypt.test.js
@@ -0,0 +1,232 @@
+// most of these tests are taken from Node.js
+// thank you Node.js team for the tests
+import { expect, it } from "bun:test";
+const crypto = require("crypto");
+
+const good = [
+ // Zero-length key is legal, functions as a parameter validation check.
+ {
+ pass: "",
+ salt: "",
+ keylen: 0,
+ N: 16,
+ p: 1,
+ r: 1,
+ expected: "",
+ },
+ // Test vectors from https://tools.ietf.org/html/rfc7914#page-13 that
+ // should pass. Note that the test vector with N=1048576 is omitted
+ // because it takes too long to complete and uses over 1 GB of memory.
+ {
+ pass: "",
+ salt: "",
+ keylen: 64,
+ N: 16,
+ p: 1,
+ r: 1,
+ expected:
+ "77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442" +
+ "fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906",
+ },
+ {
+ pass: "password",
+ salt: "NaCl",
+ keylen: 64,
+ N: 1024,
+ p: 16,
+ r: 8,
+ expected:
+ "fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b373162" +
+ "2eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640",
+ },
+ {
+ pass: "pleaseletmein",
+ salt: "SodiumChloride",
+ keylen: 64,
+ N: 16384,
+ p: 1,
+ r: 8,
+ expected:
+ "7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2" +
+ "d5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887",
+ },
+ {
+ pass: "",
+ salt: "",
+ keylen: 64,
+ cost: 16,
+ parallelization: 1,
+ blockSize: 1,
+ expected:
+ "77d6576238657b203b19ca42c18a0497f16b4844e3074ae8dfdffa3fede21442" +
+ "fcd0069ded0948f8326a753a0fc81f17e8d3e0fb2e0d3628cf35e20c38d18906",
+ },
+ {
+ pass: "password",
+ salt: "NaCl",
+ keylen: 64,
+ cost: 1024,
+ parallelization: 16,
+ blockSize: 8,
+ expected:
+ "fdbabe1c9d3472007856e7190d01e9fe7c6ad7cbc8237830e77376634b373162" +
+ "2eaf30d92e22a3886ff109279d9830dac727afb94a83ee6d8360cbdfa2cc0640",
+ },
+ {
+ pass: "pleaseletmein",
+ salt: "SodiumChloride",
+ keylen: 64,
+ cost: 16384,
+ parallelization: 1,
+ blockSize: 8,
+ expected:
+ "7023bdcb3afd7348461c06cd81fd38ebfda8fbba904f8e3ea9b543f6545da1f2" +
+ "d5432955613f0fcf62d49705242a9af9e61e85dc0d651e40dfcf017b45575887",
+ },
+];
+
+// Test vectors that should fail.
+const bad = [
+ { N: 1, p: 1, r: 1 }, // N < 2
+ { N: 3, p: 1, r: 1 }, // Not power of 2.
+ { N: 1, cost: 1 }, // Both N and cost
+ // TODO: these should error, but I don't quite understand why.
+ // { p: 1, parallelization: 1 }, // Both p and parallelization
+ // { r: 1, blockSize: 1 }, // Both r and blocksize
+];
+
+// Test vectors where 128*N*r exceeds maxmem.
+const toobig = [
+ { N: 2 ** 16, p: 1, r: 1 }, // N >= 2**(r*16)
+ { N: 2, p: 2 ** 30, r: 1 }, // p > (2**30-1)/r
+ { N: 2 ** 20, p: 1, r: 8 },
+ { N: 2 ** 10, p: 1, r: 8, maxmem: 2 ** 20 },
+];
+
+const badargs = [
+ {
+ args: [],
+ expected: { code: "ERR_INVALID_ARG_TYPE" /*message: /"password"/ */ },
+ },
+ {
+ args: [null],
+ expected: { code: "ERR_INVALID_ARG_TYPE" /*message: /"password"/ */ },
+ },
+ {
+ args: [""],
+ expected: { code: "ERR_INVALID_ARG_TYPE" /*message: /"salt"/ */ },
+ },
+ {
+ args: ["", null],
+ expected: { code: "ERR_INVALID_ARG_TYPE" /*message: /"salt"/ */ },
+ },
+ {
+ args: ["", ""],
+ expected: { code: "ERR_INVALID_ARG_TYPE" /*message: /"keylen"/ */ },
+ },
+ {
+ args: ["", "", null],
+ expected: { code: "ERR_INVALID_ARG_TYPE" /*message: /"keylen"/ */ },
+ },
+ {
+ args: ["", "", 42, null],
+ expected: { code: "ERR_INVALID_ARG_TYPE" },
+ },
+ // TODO: throw on these
+ // {
+ // args: ["", "", 42, {}],
+ // expected: { code: "ERR_INVALID_ARG_TYPE" },
+ // },
+ // {
+ // args: ["", "", 42, {}, {}],
+ // expected: { code: "ERR_INVALID_ARG_TYPE" },
+ // },
+ // {
+ // args: ["", "", 42, {}, null],
+ // expected: { code: "ERR_INVALID_ARG_TYPE" },
+ // },
+ // {
+ // args: ["", "", 0.42],
+ // expected: { code: "ERR_OUT_OF_RANGE" /*message: /"keylen"/ */ },
+ // },
+ // {
+ // args: ["", "", -42],
+ // expected: { code: "ERR_OUT_OF_RANGE" /*message: /"keylen"/ */ },
+ // },
+ // {
+ // args: ["", "", 2147485780],
+ // expected: { code: "ERR_OUT_OF_RANGE" /*message: /"keylen"/ */ },
+ // },
+ // {
+ // args: ["", "", 0, { maxmem: 2 ** 53 }],
+ // expected: { code: "ERR_OUT_OF_RANGE" /*message: /"keylen"/ */ },
+ // },
+];
+
+it("scrypt good", () => {
+ for (const options of good) {
+ const { pass, salt, keylen, expected } = options;
+ const actual = crypto.scryptSync(pass, salt, keylen, options);
+ expect(actual.toString("hex")).toBe(expected);
+ }
+});
+
+it("scrypt bad", () => {
+ for (const options of bad) {
+ expect(() => crypto.scryptSync("pass", "salt", 1, options)).toThrow(/Invalid scrypt param/);
+ }
+});
+
+it("scrypt toobig", () => {
+ for (const options of toobig) {
+ expect(() => crypto.scryptSync("pass", "salt", 1, options)).toThrow(/Invalid scrypt param/);
+ }
+});
+
+it("scrypt defaults eql", () => {
+ const defaults = { N: 16384, p: 1, r: 8 };
+ const expected = crypto.scryptSync("pass", "salt", 1, defaults);
+ const actual = crypto.scryptSync("pass", "salt", 1);
+ expect(actual.toString("hex")).toBe(expected.toString("hex"));
+});
+
+// TODO: DEFAULT_ENCODING is read-only
+// it("scrypt defaults encoding", () => {
+// {
+// const defaultEncoding = crypto.DEFAULT_ENCODING;
+// const defaults = { N: 16384, p: 1, r: 8 };
+// const expected = crypto.scryptSync("pass", "salt", 1, defaults);
+
+// const testEncoding = "latin1";
+// crypto.DEFAULT_ENCODING = testEncoding;
+// const actual = crypto.scryptSync("pass", "salt", 1);
+// expect(actual).toBe(expected.toString(testEncoding));
+
+// crypto.DEFAULT_ENCODING = defaultEncoding;
+// }
+// });
+
+it("scrypt badargs", () => {
+ for (const { args, expected } of badargs) {
+ try {
+ crypto.scryptSync(...args);
+ expect(() => {}).toThrow();
+ } catch (e) {
+ if (!("code" in e)) throw e;
+ expect(e.code).toBe(expected.code);
+ }
+ }
+
+ // {
+ // // Values for maxmem that do not fit in 32 bits but that are still safe
+ // // integers should be allowed.
+ // crypto.scrypt(
+ // "",
+ // "",
+ // 4,
+ // { maxmem: 2 ** 52 },
+ // common.mustSucceed((actual) => {
+ // expect(actual.toString("hex")).toBe("d72c87d0");
+ // }),
+ // );
+});
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-29 07:18:34 +0000