@wener/common 1.0.4 → 2.0.1

package/lib/password/PHC.test.js

@@ -0,0 +1,539 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    }
+    catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    }
+    else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function () {
+        var self = this, args = arguments;
+        return new Promise(function (resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function () {
+            if (t[0] & 1)
+                throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+        return this;
+    }), g;
+    function verb(n) {
+        return function (v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f)
+            throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _)
+            try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+                    return t;
+                if (y = 0, t)
+                    op = [
+                        op[0] & 2,
+                        t.value
+                    ];
+                switch (op[0]) {
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return {
+                            value: op[1],
+                            done: false
+                        };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [
+                            0
+                        ];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2])
+                            _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            }
+            catch (e) {
+                op = [
+                    6,
+                    e
+                ];
+                y = 0;
+            }
+            finally {
+                f = t = 0;
+            }
+        if (op[0] & 5)
+            throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { ArrayBuffers } from "@wener/utils";
+import { describe, expect, it } from "vitest";
+import { PHC } from "./PHC.js";
+var deserialize = PHC.deserialize, serialize = PHC.serialize;
+describe("deserialize", function () {
+    it("should deserialize correct phc strings", function () {
+        sdData.serialized.forEach(function (serialized, i) {
+            expect(deserialize(serialized), "Failed to deserialize ".concat(serialized)).toEqual(sdData.deserialized[i]);
+        });
+    });
+    it("should throw errors if trying to deserialize an invalid phc string", function () {
+        return _async_to_generator(function () {
+            return _ts_generator(this, function (_state) {
+                expect(function () {
+                    return deserialize(null);
+                }).toThrow("pchstr must be a non-empty string");
+                expect(function () {
+                    return deserialize("a$invalid");
+                }).toThrow("pchstr must contain a $ as first char");
+                expect(function () {
+                    return deserialize("$b$c$d$e$f");
+                }).toThrow("pchstr contains too many fileds: 5/4");
+                expect(function () {
+                    return deserialize("invalid");
+                }).toThrow("pchstr must contain a $ as first char");
+                expect(function () {
+                    return deserialize("$i_n_v_a_l_i_d");
+                }).toThrowError(/id must satisfy/);
+                expect(function () {
+                    return deserialize("$pbkdf2$rounds_=1000");
+                }).toThrowError(/params names must satisfy/);
+                expect(function () {
+                    return deserialize("$pbkdf2$rounds=1000@");
+                }).toThrowError(/params values must satisfy/);
+                expect(function () {
+                    return deserialize("$pbkdf2$rounds:1000");
+                }).toThrowError(/params must be in the format name=value/);
+                expect(function () {
+                    return deserialize("$argon2i$unrecognized$m=120,t=5000,p=2$EkCWX6pSTqWruiR0");
+                }).toThrowError(/pchstr contains unrecognized fileds/);
+                expect(function () {
+                    return deserialize("$argon2i$unrecognized$v=19$m=120,t=5000,p=2$EkCWX6pSTqWruiR0");
+                }).toThrow("pchstr contains too many fileds: 5/4");
+                expect(function () {
+                    return deserialize("$argon2i$v=19$unrecognized$m=120,t=5000,p=2$EkCWX6pSTqWruiR0");
+                }).toThrowError(/pchstr contains unrecognized fileds/);
+                return [
+                    2
+                ];
+            });
+        })();
+    });
+});
+describe("serialize", function () {
+    it("should serialize correct phc objects", function () {
+        sdData.deserialized.forEach(function (_, i) {
+            expect(serialize(sdData.deserialized[i])).toEqual(sdData.serialized[i]);
+        });
+        sData.deserialized.forEach(function (_, i) {
+            expect(serialize(sData.deserialized[i])).toEqual(sData.serialized[i]);
+        });
+    });
+    it("should throw errors if trying to serialize with invalid arguments", function () {
+        return _async_to_generator(function () {
+            return _ts_generator(this, function (_state) {
+                expect(function () {
+                    return serialize(null);
+                }).toThrow("opts must be an object");
+                expect(function () {
+                    return serialize({});
+                }).toThrow("id must be a string");
+                expect(function () {
+                    return serialize({
+                        id: "i_n_v_a_l_i_d"
+                    });
+                }).toThrowError(/id must satisfy/);
+                expect(function () {
+                    return serialize({
+                        id: "pbkdf2",
+                        params: null
+                    });
+                }).toThrow("params must be an object");
+                expect(function () {
+                    return serialize({
+                        id: "pbkdf2",
+                        params: {
+                            i: {}
+                        }
+                    });
+                }).toThrow("params values must be strings");
+                expect(function () {
+                    return serialize({
+                        id: "pbkdf2",
+                        params: {
+                            rounds_: "1000"
+                        }
+                    });
+                }).toThrowError(/params names must satisfy/);
+                expect(function () {
+                    return serialize({
+                        id: "pbkdf2",
+                        params: {
+                            rounds: "1000@"
+                        }
+                    });
+                }).toThrowError(/params values must satisfy/);
+                expect(function () {
+                    return serialize({
+                        id: "pbkdf2",
+                        params: {
+                            rounds: "1000"
+                        },
+                        salt: "string"
+                    });
+                }).toThrow("salt must be a Buffer");
+                expect(function () {
+                    return serialize({
+                        id: "argon2id",
+                        version: -10
+                    });
+                }).toThrow("version must be a positive integer number");
+                expect(function () {
+                    return serialize({
+                        id: "pbkdf2",
+                        params: {
+                            rounds: "1000"
+                        },
+                        salt: bufferFrom("string"),
+                        hash: "string"
+                    });
+                }).toThrow("hash must be a Buffer");
+                return [
+                    2
+                ];
+            });
+        })();
+    });
+});
+var bufferFrom = function (a, b) {
+    return ArrayBuffers.from(a, b, Uint8Array);
+};
+var sdData = {
+    serialized: [
+        "$argon2i$m=120,t=5000,p=2",
+        "$argon2i$m=120,t=4294967295,p=2",
+        "$argon2i$m=2040,t=5000,p=255",
+        "$argon2i$m=120,t=5000,p=2,keyid=Hj5+dsK0",
+        "$argon2i$m=120,t=5000,p=2,keyid=Hj5+dsK0ZQ",
+        "$argon2i$m=120,t=5000,p=2,keyid=Hj5+dsK0ZQA",
+        "$argon2i$m=120,t=5000,p=2,data=sRlHhRmKUGzdOmXn01XmXygd5Kc",
+        "$argon2i$m=120,t=5000,p=2,keyid=Hj5+dsK0,data=sRlHhRmKUGzdOmXn01XmXygd5Kc",
+        "$argon2i$m=120,t=5000,p=2$/LtFjH5rVL8",
+        "$argon2i$m=120,t=5000,p=2$4fXXG0spB92WPB1NitT8/OH0VKI",
+        "$argon2i$m=120,t=5000,p=2$BwUgJHHQaynE+a4nZrYRzOllGSjjxuxNXxyNRUtI6Dlw/zlbt6PzOL8Onfqs6TcG",
+        "$argon2i$m=120,t=5000,p=2,keyid=Hj5+dsK0$4fXXG0spB92WPB1NitT8/OH0VKI",
+        "$argon2i$m=120,t=5000,p=2,data=sRlHhRmKUGzdOmXn01XmXygd5Kc$4fXXG0spB92WPB1NitT8/OH0VKI",
+        "$argon2i$m=120,t=5000,p=2,keyid=Hj5+dsK0,data=sRlHhRmKUGzdOmXn01XmXygd5Kc$4fXXG0spB92WPB1NitT8/OH0VKI",
+        "$argon2i$m=120,t=5000,p=2$4fXXG0spB92WPB1NitT8/OH0VKI$iPBVuORECm5biUsjq33hn9/7BKqy9aPWKhFfK2haEsM",
+        "$argon2i$m=120,t=5000,p=2,keyid=Hj5+dsK0$4fXXG0spB92WPB1NitT8/OH0VKI$iPBVuORECm5biUsjq33hn9/7BKqy9aPWKhFfK2haEsM",
+        "$argon2i$m=120,t=5000,p=2,data=sRlHhRmKUGzdOmXn01XmXygd5Kc$4fXXG0spB92WPB1NitT8/OH0VKI$iPBVuORECm5biUsjq33hn9/7BKqy9aPWKhFfK2haEsM",
+        "$argon2i$m=120,t=5000,p=2,keyid=Hj5+dsK0,data=sRlHhRmKUGzdOmXn01XmXygd5Kc$4fXXG0spB92WPB1NitT8/OH0VKI$iPBVuORECm5biUsjq33hn9/7BKqy9aPWKhFfK2haEsM",
+        "$argon2i$m=120,t=5000,p=2,keyid=Hj5+dsK0,data=sRlHhRmKUGzdOmXn01XmXygd5Kc$iHSDPHzUhPzK7rCcJgOFfg$EkCWX6pSTqWruiR0",
+        "$argon2i$m=120,t=5000,p=2,keyid=Hj5+dsK0,data=sRlHhRmKUGzdOmXn01XmXygd5Kc$iHSDPHzUhPzK7rCcJgOFfg$J4moa2MM0/6uf3HbY2Tf5Fux8JIBTwIhmhxGRbsY14qhTltQt+Vw3b7tcJNEbk8ium8AQfZeD4tabCnNqfkD1g",
+        "$scrypt$ln=1,r=16,p=1$$d9ZXYjhleyA7GcpCwYoEl/FrSETjB0ro39/6P+3iFEL80Aad7QlI+DJqdToPyB8X6NPg+y4NNijPNeIMONGJBg",
+        "$argon2i$v=19$m=120,t=5000,p=2,keyid=Hj5+dsK0,data=sRlHhRmKUGzdOmXn01XmXygd5Kc$iHSDPHzUhPzK7rCcJgOFfg$J4moa2MM0/6uf3HbY2Tf5Fux8JIBTwIhmhxGRbsY14qhTltQt+Vw3b7tcJNEbk8ium8AQfZeD4tabCnNqfkD1g"
+    ],
+    deserialized: [
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2
+            }
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 4294967295,
+                p: 2
+            }
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 2040,
+                t: 5000,
+                p: 255
+            }
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0"
+            }
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0ZQ"
+            }
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0ZQA"
+            }
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                data: "sRlHhRmKUGzdOmXn01XmXygd5Kc"
+            }
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0",
+                data: "sRlHhRmKUGzdOmXn01XmXygd5Kc"
+            }
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2
+            },
+            salt: bufferFrom("/LtFjH5rVL8", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2
+            },
+            salt: bufferFrom("4fXXG0spB92WPB1NitT8/OH0VKI", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2
+            },
+            salt: bufferFrom("BwUgJHHQaynE+a4nZrYRzOllGSjjxuxNXxyNRUtI6Dlw/zlbt6PzOL8Onfqs6TcG", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0"
+            },
+            salt: bufferFrom("4fXXG0spB92WPB1NitT8/OH0VKI", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                data: "sRlHhRmKUGzdOmXn01XmXygd5Kc"
+            },
+            salt: bufferFrom("4fXXG0spB92WPB1NitT8/OH0VKI", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0",
+                data: "sRlHhRmKUGzdOmXn01XmXygd5Kc"
+            },
+            salt: bufferFrom("4fXXG0spB92WPB1NitT8/OH0VKI", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2
+            },
+            salt: bufferFrom("4fXXG0spB92WPB1NitT8/OH0VKI", "base64"),
+            hash: bufferFrom("iPBVuORECm5biUsjq33hn9/7BKqy9aPWKhFfK2haEsM", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0"
+            },
+            salt: bufferFrom("4fXXG0spB92WPB1NitT8/OH0VKI", "base64"),
+            hash: bufferFrom("iPBVuORECm5biUsjq33hn9/7BKqy9aPWKhFfK2haEsM", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                data: "sRlHhRmKUGzdOmXn01XmXygd5Kc"
+            },
+            salt: bufferFrom("4fXXG0spB92WPB1NitT8/OH0VKI", "base64"),
+            hash: bufferFrom("iPBVuORECm5biUsjq33hn9/7BKqy9aPWKhFfK2haEsM", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0",
+                data: "sRlHhRmKUGzdOmXn01XmXygd5Kc"
+            },
+            salt: bufferFrom("4fXXG0spB92WPB1NitT8/OH0VKI", "base64"),
+            hash: bufferFrom("iPBVuORECm5biUsjq33hn9/7BKqy9aPWKhFfK2haEsM", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0",
+                data: "sRlHhRmKUGzdOmXn01XmXygd5Kc"
+            },
+            salt: bufferFrom("iHSDPHzUhPzK7rCcJgOFfg", "base64"),
+            hash: bufferFrom("EkCWX6pSTqWruiR0", "base64")
+        },
+        {
+            id: "argon2i",
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0",
+                data: "sRlHhRmKUGzdOmXn01XmXygd5Kc"
+            },
+            salt: bufferFrom("iHSDPHzUhPzK7rCcJgOFfg", "base64"),
+            hash: bufferFrom("J4moa2MM0/6uf3HbY2Tf5Fux8JIBTwIhmhxGRbsY14qhTltQt+Vw3b7tcJNEbk8ium8AQfZeD4tabCnNqfkD1g", "base64")
+        },
+        {
+            id: "scrypt",
+            params: {
+                ln: 1,
+                r: 16,
+                p: 1
+            },
+            salt: bufferFrom("", "hex"),
+            hash: bufferFrom("d9ZXYjhleyA7GcpCwYoEl/FrSETjB0ro39/6P+3iFEL80Aad7QlI+DJqdToPyB8X6NPg+y4NNijPNeIMONGJBg", "base64")
+        },
+        {
+            id: "argon2i",
+            version: 19,
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0",
+                data: "sRlHhRmKUGzdOmXn01XmXygd5Kc"
+            },
+            salt: bufferFrom("iHSDPHzUhPzK7rCcJgOFfg", "base64"),
+            hash: bufferFrom("J4moa2MM0/6uf3HbY2Tf5Fux8JIBTwIhmhxGRbsY14qhTltQt+Vw3b7tcJNEbk8ium8AQfZeD4tabCnNqfkD1g", "base64")
+        }
+    ]
+};
+var sData = {
+    serialized: [
+        "$argon2i$v=19$m=120,t=5000,p=2,keyid=Hj5+dsK0,data=sRlHhRmKUGzdOmXn01XmXygd5Kc$iHSDPHzUhPzK7rCcJgOFfg$J4moa2MM0/6uf3HbY2Tf5Fux8JIBTwIhmhxGRbsY14qhTltQt+Vw3b7tcJNEbk8ium8AQfZeD4tabCnNqfkD1g"
+    ],
+    deserialized: [
+        {
+            id: "argon2i",
+            version: 19,
+            params: {
+                m: 120,
+                t: 5000,
+                p: 2,
+                keyid: "Hj5+dsK0",
+                data: bufferFrom("sRlHhRmKUGzdOmXn01XmXygd5Kc", "base64")
+            },
+            salt: bufferFrom("iHSDPHzUhPzK7rCcJgOFfg", "base64"),
+            hash: bufferFrom("J4moa2MM0/6uf3HbY2Tf5Fux8JIBTwIhmhxGRbsY14qhTltQt+Vw3b7tcJNEbk8ium8AQfZeD4tabCnNqfkD1g", "base64")
+        }
+    ]
+};