@rockcarver/frodo-lib 0.11.0

package/src/ops/utils/Console.js

@@ -0,0 +1,434 @@
+import { SingleBar, Presets } from 'cli-progress';
+import { createSpinner } from 'nanospinner';
+import Table from 'cli-table3';
+// eslint-disable-next-line no-unused-vars
+import * as colors from '@colors/colors';
+import storage from '../../storage/SessionStorage.js';
+
+/**
+ * Output a data message
+ * @param {Object} message the message
+ */
+function data(message) {
+  switch (typeof message) {
+    case 'object':
+      console.dir(message, { depth: 3 });
+      break;
+    default:
+      console.log(message);
+  }
+}
+
+/**
+ * Output a text message
+ * @param {Object} message the message
+ */
+function text(message) {
+  switch (typeof message) {
+    case 'object':
+      console.dir(message, { depth: 3 });
+      break;
+    default:
+      console.error(message);
+  }
+}
+
+/**
+ * Output an info message
+ * @param {Object} message the message
+ */
+function info(message) {
+  switch (typeof message) {
+    case 'object':
+      console.dir(message, { depth: 3 });
+      break;
+    default:
+      console.error(message.brightCyan);
+  }
+}
+
+/**
+ * Output a warn message
+ * @param {Object} message the message
+ */
+function warn(message) {
+  switch (typeof message) {
+    case 'object':
+      console.dir(message, { depth: 3 });
+      break;
+    default:
+      console.error(message.yellow);
+  }
+}
+
+/**
+ * Output an error message
+ * @param {Object} message the message
+ */
+function error(message) {
+  switch (typeof message) {
+    case 'object':
+      console.dir(message, { depth: 4 });
+      break;
+    default:
+      console.error(message.brightRed);
+  }
+}
+
+/**
+ * Prints a string message to console
+ *
+ * @param {string} message The string message to print
+ * @param {string} [type=text] "text", "info", "warn", "error" or "data". All but
+ * type="data" will be written to stderr.
+ * @param {boolean} [newline=true] Whether to add a new at the end of message
+ *
+ */
+export function printMessage(message, type = 'text', newline = true) {
+  //   if (storage.session.getItem('scriptFriendly')) {
+  switch (type) {
+    case 'data':
+      if (newline) {
+        data(message);
+      } else {
+        process.stdout.write(message);
+      }
+      break;
+    case 'text':
+      if (newline) {
+        text(message);
+      } else {
+        process.stderr.write(message);
+      }
+      break;
+    case 'info':
+      if (newline) {
+        info(message);
+      } else {
+        process.stderr.write(message.brightCyan);
+      }
+      break;
+    case 'warn':
+      if (newline) {
+        warn(message);
+      } else {
+        process.stderr.write(message.yellow);
+      }
+      break;
+    case 'error':
+      if (newline) {
+        error(message);
+      } else {
+        process.stderr.write(message.brightRed);
+      }
+      break;
+    default:
+      if (newline) {
+        error(message);
+      } else {
+        process.stderr.write(message.bgBrightRed);
+      }
+  }
+}
+
+/**
+ * Creates a progress bar on stderr
+ *
+ * Example:
+ * [========================================] 100% | 49/49 | Analyzing journey - transactional_auth
+ *
+ * @param {Number} total The total number of entries to track progress for
+ * @param {String} message optional progress bar message
+ * @param {Object} options progress bar configuration options
+ *
+ */
+export function createProgressBar(
+  total,
+  message = null,
+  options = {
+    format: '[{bar}] {percentage}% | {value}/{total} | {data}',
+    noTTYOutput: true,
+  }
+) {
+  let opt = options;
+  if (message == null) {
+    opt = {
+      format: '[{bar}] {percentage}% | {value}/{total}',
+      noTTYOutput: true,
+    };
+  }
+  let pBar = storage.session.getItem('progressBar');
+  if (!pBar) pBar = new SingleBar(opt, Presets.legacy); // create only when needed
+  pBar.start(total, 0, {
+    data: message,
+  });
+  storage.session.setItem('progressBar', pBar);
+}
+
+/**
+ * Updates the progress bar by 1
+ * @param {string} message optional message to update the progress bar
+ *
+ */
+export function updateProgressBar(message = null) {
+  const pBar = storage.session.getItem('progressBar');
+  if (message)
+    pBar.increment({
+      data: message,
+    });
+  else pBar.increment();
+}
+
+/**
+ * Stop and hide the progress bar
+ * @param {*} message optional message to update the progress bar
+ */
+export function stopProgressBar(message = null) {
+  const pBar = storage.session.getItem('progressBar');
+  if (message)
+    pBar.update({
+      data: message,
+    });
+  pBar.stop();
+}
+
+/**
+ * Create the spinner
+ * @param {String} message optional spinner message
+ */
+export function showSpinner(message) {
+  const spinner = createSpinner(message).start();
+  storage.session.setItem('Spinner', spinner);
+}
+
+/**
+ * Stop the spinner
+ * @param {String} message optional message to update the spinner
+ */
+export function stopSpinner(message = null) {
+  const spinner = storage.session.getItem('Spinner');
+  if (spinner) {
+    let options = {};
+    if (message) options = { text: message };
+    spinner.stop(options);
+  }
+}
+
+/**
+ * Succeed the spinner. Stop and render success checkmark with optional message.
+ * @param {String} message optional message to update the spinner
+ */
+export function succeedSpinner(message = null) {
+  const spinner = storage.session.getItem('Spinner');
+  if (spinner) {
+    let options = {};
+    if (message) options = { text: message };
+    spinner.success(options);
+  }
+}
+
+/**
+ * Warn the spinner
+ * @param {String} message optional message to update the spinner
+ */
+export function warnSpinner(message = null) {
+  const spinner = storage.session.getItem('Spinner');
+  if (spinner) {
+    let options = {};
+    if (message) options = { text: message };
+    spinner.warn(options);
+  }
+}
+
+/**
+ * Fail the spinner
+ * @param {String} message optional message to update the spinner
+ */
+export function failSpinner(message = null) {
+  const spinner = storage.session.getItem('Spinner');
+  if (spinner) {
+    let options = {};
+    if (message) options = { text: message };
+    spinner.error(options);
+  }
+}
+
+/**
+ * Spin the spinner
+ * @param {String} message optional message to update the spinner
+ */
+export function spinSpinner(message = null) {
+  const spinner = storage.session.getItem('Spinner');
+  if (spinner) {
+    let options = {};
+    if (message) options = { text: message };
+    spinner.update(options);
+    spinner.spin();
+  }
+}
+
+/**
+ * Create an empty table
+ * @param {[String]} head header row as an array of strings
+ * @returns {CliTable3} an empty table
+ */
+export function createTable(head) {
+  return new Table({
+    head,
+    chars: {
+      top: '',
+      'top-mid': '',
+      'top-left': '',
+      'top-right': '',
+      bottom: '',
+      'bottom-mid': '',
+      'bottom-left': '',
+      'bottom-right': '',
+      left: '',
+      'left-mid': '',
+      mid: '',
+      'mid-mid': '',
+      right: '',
+      'right-mid': '',
+    },
+    style: { 'padding-left': 0, 'padding-right': 0, head: ['brightCyan'] },
+  });
+}
+
+/**
+ * Create a new key/value table
+ * @returns {CliTable3} an empty key/value table
+ */
+export function createKeyValueTable() {
+  return new Table({
+    chars: {
+      top: '',
+      'top-mid': '',
+      'top-left': '',
+      'top-right': '',
+      bottom: '',
+      'bottom-mid': '',
+      'bottom-left': '',
+      'bottom-right': '',
+      left: '',
+      'left-mid': '',
+      mid: '',
+      'mid-mid': '',
+      right: '',
+      'right-mid': '',
+    },
+    style: { 'padding-left': 0, 'padding-right': 0 },
+    wordWrap: true,
+  });
+}
+
+/**
+ * Helper function to determine the total depth of an object
+ * @param {Object} object input object
+ * @returns {Number} total depth of the input object
+ */
+function getObjectDepth(object) {
+  return Object(object) === object
+    ? 1 + Math.max(-1, ...Object.values(object).map(getObjectDepth))
+    : 0;
+}
+
+/**
+ * Helper function to determine if an object has values
+ * @param {Object} object input object
+ * @returns {boolean} true of the object or any of its sub-objects contain values, false otherwise
+ */
+function hasValues(object) {
+  let has = false;
+  const keys = Object.keys(object);
+  for (const key of keys) {
+    if (Object(object[key]) !== object[key]) {
+      return true;
+    }
+    has = has || hasValues(object[key]);
+  }
+  return has;
+}
+
+/**
+ * Helper function (recursive) to add rows to an object table
+ * @param {Object} object object to render
+ * @param {Number} depth total depth of initial object
+ * @param {Number} level current level
+ * @param {CliTable3} table the object table to add the rows to
+ * @returns the updated object table
+ */
+function addRows(object, depth, level, table, keyMap) {
+  const space = '  ';
+  const keys = Object.keys(object);
+  for (const key of keys) {
+    if (Object(object[key]) !== object[key]) {
+      if (level === 1) {
+        table.push([
+          keyMap[key] ? keyMap[key].brightCyan : key.brightCyan,
+          object[key],
+        ]);
+      } else {
+        table.push([
+          {
+            hAlign: 'right',
+            content: keyMap[key] ? keyMap[key].gray : key.gray,
+          },
+          object[key],
+        ]);
+      }
+    }
+  }
+  for (const key of keys) {
+    if (Object(object[key]) === object[key]) {
+      // only print header if there are any values below
+      if (hasValues(object[key])) {
+        let indention = new Array(level).fill(space).join('');
+        if (level < 3) indention = `\n${indention}`;
+        table.push([
+          indention.concat(
+            keyMap[key] ? keyMap[key].brightCyan : key.brightCyan
+          ),
+          '',
+        ]);
+      }
+      // eslint-disable-next-line no-param-reassign
+      table = addRows(object[key], depth, level + 1, table, keyMap);
+    }
+  }
+  return table;
+}
+
+/**
+ * Create and populate an object table from any JSON object. Use for describe commands.
+ * @param {Object} object JSON object to create
+ * @returns {CliTable3} a table that can be printed to the console
+ */
+export function createObjectTable(object, keyMap = {}) {
+  // eslint-disable-next-line no-param-reassign
+  const depth = getObjectDepth(object);
+  // eslint-disable-next-line no-param-reassign
+  const level = 0;
+  // eslint-disable-next-line no-param-reassign
+  const table = new Table({
+    chars: {
+      top: '',
+      'top-mid': '',
+      'top-left': '',
+      'top-right': '',
+      bottom: '',
+      'bottom-mid': '',
+      'bottom-left': '',
+      'bottom-right': '',
+      left: '',
+      'left-mid': '',
+      mid: '',
+      'mid-mid': '',
+      right: '',
+      'right-mid': '',
+    },
+    style: { 'padding-left': 0, 'padding-right': 0, head: ['brightCyan'] },
+  });
+  addRows(object, depth, level + 1, table, keyMap);
+  return table;
+}

package/src/ops/utils/DataProtection.js

@@ -0,0 +1,92 @@
+/**
+ * Data is stored in base64 format. Initially it was binary data
+ * Format used in this encryption module.
+ * inspired by AndiDittrich
+ * +--------------------+-----------------------+----------------+----------------+
+ * | SALT               | Initialization Vector | Auth Tag       | Payload        |
+ * | Used to derive key | AES GCM XOR Init      | Data Integrity | Encrypted Data |
+ * | 64 Bytes, random   | 16 Bytes, random      | 16 Bytes       | (N-96) Bytes   |
+ * +--------------------+-----------------------+----------------+----------------+
+ * This module doesn't take care of data persistence, it's assumed the consuming method/class/package will do so.
+ */
+import fs, { promises as fsp } from 'fs';
+import crypto from 'crypto';
+import { homedir } from 'os';
+import { promisify } from 'util';
+import { printMessage } from './Console.js';
+
+const scrypt = promisify(crypto.scrypt);
+// using WeakMaps for added security since  it gets garbage collected
+const _masterKey = new WeakMap();
+const _nonce = new WeakMap();
+const _salt = new WeakMap();
+const _key = new WeakMap();
+const _encrypt = new WeakMap();
+
+class DataProtection {
+  constructor() {
+    const masterKeyPath = () => `${homedir()}/.frodo/masterkey.key`;
+    // Generates a master key in base64 format. This master key will be used to derive the key for encryption. this key should be protected by an HSM or KMS
+    _masterKey.set(this, async () => {
+      try {
+        if (!fs.existsSync(masterKeyPath())) {
+          const masterKey = crypto.randomBytes(32).toString('base64');
+          await fsp.writeFile(masterKeyPath(), masterKey);
+        }
+        return await fsp.readFile(masterKeyPath(), 'utf8');
+      } catch (err) {
+        printMessage(err.message, 'error');
+        return '';
+      }
+    });
+
+    // the nonce for AES GCM
+    _nonce.set(this, () => crypto.randomBytes(16));
+
+    // The salt
+    _salt.set(this, () => crypto.randomBytes(64));
+
+    // The function that derives the key, this supports sync and async operations
+    _key.set(
+      this,
+      // eslint-disable-next-line no-return-await
+      async (masterKey, salt) => await scrypt(masterKey, salt, 32)
+    );
+
+    // private method to encrypt and return encrypted data. cleaner code
+    _encrypt.set(this, (key, nonce, data, salt) => {
+      const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce);
+      const encrypted = Buffer.concat([
+        cipher.update(JSON.stringify(data), 'utf8'),
+        cipher.final(),
+      ]);
+      const tag = cipher.getAuthTag();
+      const buffer = Buffer.concat([salt, nonce, tag, encrypted]);
+      return buffer.toString('base64');
+    });
+  }
+
+  async encrypt(data) {
+    const nonce = _nonce.get(this)();
+    const salt = _salt.get(this)();
+    const masterKey = await _masterKey.get(this)();
+    const key = await _key.get(this)(masterKey, salt);
+    return _encrypt.get(this)(key, nonce, data, salt);
+  }
+
+  async decrypt(data) {
+    const buffer = Buffer.from(data.toString(), 'base64');
+    const salt = buffer.slice(0, 64);
+    const nonce = buffer.slice(64, 80);
+    const tag = buffer.slice(80, 96);
+    const encrypted = buffer.slice(96);
+    const masterKey = await _masterKey.get(this)();
+    const key = await _key.get(this)(masterKey, salt);
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, nonce);
+    decipher.setAuthTag(tag);
+    return JSON.parse(
+      decipher.update(encrypted, 'binary', 'utf8') + decipher.final('utf8')
+    );
+  }
+}
+export default DataProtection;

package/src/ops/utils/DataProtection.test.js

@@ -0,0 +1,28 @@
+import DataProtection from './DataProtection.js';
+
+test('DataProtection to encrypt', async () => {
+  // Note this test checks that encyption happned not that encryption is correct
+  // this test relys on other tests to proove the likelyhood of successful encryption
+  // Arrange
+  const dp = new DataProtection();
+  const EXPECTED =
+    'aMLtCqK1b+d3d88DDKrmIV7A6pifP77IItLKX7N7/UTOPxf8YCQWHCpTrmNnM5wNXue8HllEFIS+sxXRb20oCb4HImpbQM0so5DrHIqcIlF5LYDKjvzBOz1PdlclhIuIV+Gr8M3GRbNkQxXJuUZ4th5ISLpOjM+k8bDAlnHsRx5LLlbLFnAKq8Pu9DaTYUkZABOCOjfkoTb6re1p9c7xE2pAe213';
+  const originalString =
+    'Go not to the Elves for counsel, for they will say both no and yes.';
+  // Act
+  const RESULT = await dp.encrypt(originalString);
+  // Assert
+  expect(RESULT.length).toBe(EXPECTED.length);
+});
+
+test('DataProtection to decrypt', async () => {
+  // Arrange
+  const dp = new DataProtection();
+  const originalString =
+    'Go not to the Elves for counsel, for they will say both no and yes.';
+  // Act
+  const encrypted = await dp.encrypt(originalString);
+  const RESULT = await dp.decrypt(encrypted);
+  // Assert
+  expect(RESULT).toBe(originalString);
+});

package/src/ops/utils/ExportImportUtils.js

@@ -0,0 +1,146 @@
+import fs from 'fs';
+import slugify from 'slugify';
+import storage from '../../storage/SessionStorage.js';
+import { FRODO_METADATA_ID } from '../../storage/StaticStorage.js';
+import {
+  encode,
+  decode,
+  encodeBase64Url,
+  decodeBase64Url,
+} from '../../api/utils/Base64.js';
+import { printMessage } from './Console.js';
+
+export function getCurrentTimestamp() {
+  const ts = new Date();
+  return ts.toISOString();
+}
+
+function getMetadata() {
+  const metadata = {
+    origin: storage.session.getTenant(),
+    exportedBy: storage.session.getUsername(),
+    exportDate: getCurrentTimestamp(),
+    exportTool: FRODO_METADATA_ID,
+    exportToolVersion: storage.session.getFrodoVersion(),
+  };
+  return metadata;
+}
+
+/*
+ * Output str in title case
+ *
+ * e.g.: 'ALL UPPERCASE AND all lowercase' = 'All Uppercase And All Lowercase'
+ */
+export function titleCase(input) {
+  const str = input.toString();
+  const splitStr = str.toLowerCase().split(' ');
+  for (let i = 0; i < splitStr.length; i += 1) {
+    splitStr[i] = splitStr[i].charAt(0).toUpperCase() + splitStr[i].slice(1);
+  }
+  return splitStr.join(' ');
+}
+
+export function getRealmString() {
+  const realm = storage.session.getRealm();
+  return realm
+    .split('/')
+    .reduce((result, item) => `${result}${titleCase(item)}`, '');
+}
+
+export function convertBase64TextToArray(b64text) {
+  let arrayOut = [];
+  let plainText = decode(b64text);
+  plainText = plainText.replace(/\t/g, '    ');
+  arrayOut = plainText.split('\n');
+  return arrayOut;
+}
+
+export function convertBase64UrlTextToArray(b64UTF8Text) {
+  let arrayOut = [];
+  let plainText = decodeBase64Url(b64UTF8Text);
+  plainText = plainText.replace(/\t/g, '    ');
+  arrayOut = plainText.split('\n');
+  return arrayOut;
+}
+
+export function convertTextArrayToBase64(textArray) {
+  const joinedText = textArray.join('\n');
+  const b64encodedScript = encode(joinedText);
+  return b64encodedScript;
+}
+
+export function convertTextArrayToBase64Url(textArray) {
+  const joinedText = textArray.join('\n');
+  const b64encodedScript = encodeBase64Url(joinedText);
+  return b64encodedScript;
+}
+
+// eslint-disable-next-line no-unused-vars
+export function validateImport(metadata) {
+  return true;
+}
+
+// eslint-disable-next-line no-unused-vars
+export function checkTargetCompatibility(type, source, target) {
+  // console.log(`source ${source}, target ${target}`);
+  //   compatibilityKeys[type].forEach((element) => {
+  //     if (source[element] != target[element]) {
+  //       console.warn(`${element} in ${type} mismatch between source and target`);
+  //     }
+  //   });
+}
+
+export function getTypedFilename(name, type, suffix = 'json') {
+  const slug = slugify(name.replace(/^http(s?):\/\//, ''));
+  return `${slug}.${type}.${suffix}`;
+}
+
+export function saveToFile(type, data, identifier, filename) {
+  const exportData = {};
+  exportData.meta = getMetadata();
+  exportData[type] = {};
+  if (Array.isArray(data)) {
+    data.forEach((element) => {
+      exportData[type][element[identifier]] = element;
+    });
+  } else {
+    exportData[type][data[identifier]] = data;
+  }
+  fs.writeFile(filename, JSON.stringify(exportData, null, 2), (err) => {
+    if (err) {
+      return printMessage(`ERROR - can't save ${type} to file`, 'error');
+    }
+    return '';
+  });
+}
+
+/**
+ * Save JSON object to file
+ * @param {Object} data data object
+ * @param {String} filename file name
+ */
+export function saveJsonToFile(data, filename) {
+  const exportData = data;
+  exportData.meta = getMetadata();
+  fs.writeFile(filename, JSON.stringify(exportData, null, 2), (err) => {
+    if (err) {
+      return printMessage(`ERROR - can't save ${filename}`, 'error');
+    }
+    return '';
+  });
+}
+
+/**
+ * Save text data to file
+ * @param {String} data text data
+ * @param {String} filename file name
+ */
+export function saveTextToFile(data, filename) {
+  fs.writeFile(filename, data, (err) => {
+    if (err) {
+      printMessage(`ERROR - can't save ${filename}`, 'error');
+      return false;
+    }
+    return true;
+  });
+}