spice-js 2.7.39 → 2.7.40

package/build/utility/Crypt.js

@@ -8,6 +8,23 @@ exports.default = void 0;
 function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
 function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
 var crypto = require("crypto");
+var util = require("util");
+var pbkdf2 = util.promisify(crypto.pbkdf2);
+var randomBytes = util.promisify(crypto.randomBytes);
+
+// crypto.pbkdf2 throws synchronously on a non-string value or a missing salt.
+// Inside a Promise executor that throw was swallowed and the promise never
+// settled, hanging the request. Numbers hash as their string form; anything
+// else rejects.
+function toHashInput(value, name) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "string" || Buffer.isBuffer(value)) {
+    return value;
+  }
+  throw new TypeError(name + " must be a string");
+}
 class Crypt {
   constructor() {
     this.salt = "";
@@ -16,69 +33,26 @@ class Crypt {
   encrypt(value) {
     var _this = this;
     return _asyncToGenerator(function* () {
-      var that = _this;
-      return new Promise(/*#__PURE__*/function () {
-        var _ref = _asyncToGenerator(function* (resolve, reject) {
-          try {
-            if (!value) {
-              reject(new Error('Value must not be empty'));
-            }
-            var salt = yield that.generateRandumString(128);
-            var hash_obj = yield that.findHash(value, salt);
-            resolve(hash_obj);
-          } catch (e) {
-            reject(e);
-          }
-        });
-        return function (_x, _x2) {
-          return _ref.apply(this, arguments);
-        };
-      }());
+      if (!value) {
+        throw new Error('Value must not be empty');
+      }
+      var salt = yield _this.generateRandumString(128);
+      return _this.findHash(value, salt);
     })();
   }
   generateRandumString(length) {
     return _asyncToGenerator(function* () {
-      return new Promise(/*#__PURE__*/function () {
-        var _ref2 = _asyncToGenerator(function* (resolve, reject) {
-          if (!length) {
-            length = 64;
-          }
-          crypto.randomBytes(length, function (err, bytes) {
-            if (err) {
-              reject(err);
-            }
-            var ran_bytes = new Buffer(bytes).toString('hex');
-            resolve(ran_bytes);
-          });
-        });
-        return function (_x3, _x4) {
-          return _ref2.apply(this, arguments);
-        };
-      }());
+      var bytes = yield randomBytes(length || 64);
+      return bytes.toString('hex');
     })();
   }
   findHash(value, salt) {
     return _asyncToGenerator(function* () {
-      try {
-        return new Promise(/*#__PURE__*/function () {
-          var _ref3 = _asyncToGenerator(function* (resolve, reject) {
-            crypto.pbkdf2(value, salt, 7000, 256, 'sha512', (err, hash) => {
-              if (err) {
-                reject(err);
-              }
-              var object = {};
-              object.hash = new Buffer(hash).toString('hex');
-              object.salt = salt;
-              resolve(object);
-            });
-          });
-          return function (_x5, _x6) {
-            return _ref3.apply(this, arguments);
-          };
-        }());
-      } catch (e) {
-        return Promise.reject(e);
-      }
+      var hash = yield pbkdf2(toHashInput(value, 'Value'), toHashInput(salt, 'Salt'), 7000, 256, 'sha512');
+      return {
+        hash: hash.toString('hex'),
+        salt: salt
+      };
     })();
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-js",
-  "version": "2.7.39",
+  "version": "2.7.40",
   "description": "spice",
   "main": "build/index.js",
   "repository": {

package/src/utility/Crypt.js

@@ -4,6 +4,24 @@
  */
 
 var crypto = require("crypto");
+var util = require("util");
+
+var pbkdf2 = util.promisify(crypto.pbkdf2);
+var randomBytes = util.promisify(crypto.randomBytes);
+
+// crypto.pbkdf2 throws synchronously on a non-string value or a missing salt.
+// Inside a Promise executor that throw was swallowed and the promise never
+// settled, hanging the request. Numbers hash as their string form; anything
+// else rejects.
+function toHashInput(value, name) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return String(value);
+    }
+    if (typeof value === "string" || Buffer.isBuffer(value)) {
+        return value;
+    }
+    throw new TypeError(name + " must be a string");
+}
 
 export default class Crypt {
     constructor() {
@@ -12,54 +30,22 @@ export default class Crypt {
     }
 
     async encrypt(value) {
-        let that = this;
-        return new Promise(async (resolve, reject) => {
-            try {
-                if (!value) {
-                    reject(new Error('Value must not be empty'))
-                }
-                var salt = await that.generateRandumString(128);
-                var hash_obj = await that.findHash(value, salt);
-                resolve(hash_obj);
-            } catch (e) {
-                reject(e);
-            }
-        });
+        if (!value) {
+            throw new Error('Value must not be empty');
+        }
+        var salt = await this.generateRandumString(128);
+        return this.findHash(value, salt);
     }
 
 
     async generateRandumString(length) {
-        return new Promise(async (resolve, reject) => {
-            if (!length) {
-                length = 64;
-            }
-            crypto.randomBytes(length, function (err, bytes) {
-                if (err) {
-                    reject(err);
-                }
-                var ran_bytes = new Buffer(bytes).toString('hex');
-                resolve(ran_bytes);
-            });
-        });
+        var bytes = await randomBytes(length || 64);
+        return bytes.toString('hex');
     }
 
 
     async findHash(value, salt) {
-        try {
-            return new Promise(async (resolve, reject) => {
-                crypto.pbkdf2(value, salt, 7000, 256, 'sha512',
-                    (err, hash) => {
-                        if (err) {
-                            reject(err);
-                        }
-                        var object = {};
-                        object.hash = new Buffer(hash).toString('hex');
-                        object.salt = salt;
-                        resolve(object);
-                    });
-            });
-        } catch (e) {
-            return Promise.reject(e);
-        }
+        var hash = await pbkdf2(toHashInput(value, 'Value'), toHashInput(salt, 'Salt'), 7000, 256, 'sha512');
+        return { hash: hash.toString('hex'), salt: salt };
     }
-}
+}