mythix 2.8.11 → 2.8.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix",
-  "version": "2.8.11",
+  "version": "2.8.12",
   "description": "Mythix is a NodeJS web-app framework",
   "main": "src/index",
   "scripts": {

package/src/utils/crypto-utils.js

@@ -2,7 +2,42 @@
 
 /* global Buffer */
 
-const { createHash, randomFillSync } = require('crypto');
+const { createHash, randomFillSync } = require('node:crypto');
+
+const URL_SAFE_ENCODING_KEYS  = { '+': '-', '/': '_', '-': '+', '_': '/' };
+const ENCRYPTION_ALGORITHM    = 'aes-256-ctr';
+
+function toBase64(_data) {
+  var data = _data;
+  if (data instanceof Uint8Array)
+    data = Buffer.from(data);
+
+  if (!Buffer.isBuffer(data))
+    data = Buffer.from(('' + _data), 'utf8');
+
+  return data.toString('base64');
+}
+
+function convertBase64ToURLSafe(encodedData) {
+  return encodedData.replace(/[+/]/g, (m) => {
+    return URL_SAFE_ENCODING_KEYS[m];
+  });
+}
+
+function convertBase64FromURLSafe(encodedData) {
+  return encodedData.replace(/[_-]/g, (m) => {
+    return URL_SAFE_ENCODING_KEYS[m];
+  });
+}
+
+function toURLSafeBase64(data) {
+  return convertBase64ToURLSafe(toBase64(data));
+}
+
+function fromURLSafeBase64(data, encoding) {
+  var buffer = Buffer.from(convertBase64FromURLSafe(data), 'base64');
+  return (encoding == null) ? buffer : buffer.toString(encoding);
+}
 
 function randomBytes(length) {
   let buffer = Buffer.alloc(length);
@@ -38,7 +73,67 @@ function randomHash(type = 'sha256', length = 128) {
   return hash.digest('hex');
 }
 
+function hashToken(token, salt) {
+  if (!salt)
+    throw new TypeError('Utils::hashToken: "salt" can not be empty');
+
+  // eslint-disable-next-line new-cap
+  return SHA512(`${salt}${token}`);
+}
+
+function getSaltProperties(salt) {
+  let raw   = fromURLSafeBase64(salt, 'utf8');
+  let props = JSON.parse(raw);
+  return props;
+}
+
+function generateSalt() {
+  let props = {
+    // eslint-disable-next-line no-magic-numbers
+    secretKey:  toURLSafeBase64(randomBytes(32)),
+    iv:         toURLSafeBase64(randomBytes(16)),
+  };
+
+  return toURLSafeBase64(JSON.stringify(props));
+}
+
+// secretKey = 32 chars (base64)
+// iv = 32 chars (base64)
+function encrypt(value, salt) {
+  const {
+    secretKey,
+    iv,
+  } = getSaltProperties(salt);
+
+  const cypher    = Crypto.createCipheriv(ENCRYPTION_ALGORITHM, fromURLSafeBase64(secretKey), fromURLSafeBase64(iv));
+  const encrypted = Buffer.concat([cypher.update(value), cypher.final()]);
+
+  return toURLSafeBase64(encrypted);
+}
+
+function decrypt(value, salt) {
+  const {
+    secretKey,
+    iv,
+  } = getSaltProperties(salt);
+
+  const decipher  = Crypto.createDecipheriv(ENCRYPTION_ALGORITHM, fromURLSafeBase64(secretKey), fromURLSafeBase64(iv));
+  const decrpyted = Buffer.concat([decipher.update(fromURLSafeBase64(value)), decipher.final()]);
+
+  return decrpyted.toString('utf8');
+}
+
 module.exports = {
+  toBase64,
+  convertBase64ToURLSafe,
+  convertBase64FromURLSafe,
+  toURLSafeBase64,
+  fromURLSafeBase64,
+  getSaltProperties,
+  generateSalt,
+  encrypt,
+  decrypt,
+  hashToken,
   randomBytes,
   randomHash,
   MD5,