roar-sdk/lib/roar-sdk.js

Node.js SDK for developing Roar inspectors

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof2 = require('babel-runtime/helpers/typeof');

var _typeof3 = _interopRequireDefault(_typeof2);

var _isNan = require('babel-runtime/core-js/number/is-nan');

var _isNan2 = _interopRequireDefault(_isNan);

var _assign = require('babel-runtime/core-js/object/assign');

var _assign2 = _interopRequireDefault(_assign);

var _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

var _bytes = require('bytes');

var _bytes2 = _interopRequireDefault(_bytes);

var _crypto = require('crypto');

var _crypto2 = _interopRequireDefault(_crypto);

var _events = require('events');

var _events2 = _interopRequireDefault(_events);

var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

var _roarPidusage = require('roar-pidusage');

var _roarPidusage2 = _interopRequireDefault(_roarPidusage);

var _requestretry = require('requestretry');

var _requestretry2 = _interopRequireDefault(_requestretry);

var _unhandledRejection = require('unhandled-rejection');

var _unhandledRejection2 = _interopRequireDefault(_unhandledRejection);

var _util = require('util');

var _util2 = _interopRequireDefault(_util);

var _configure = require('./configure');

var _configure2 = _interopRequireDefault(_configure);

var _Logger = require('./resources/Logger');

var _Logger2 = _interopRequireDefault(_Logger);

var _Node = require('./resources/Node');

var _utils = require('./utils');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

// --- Modules
// --- Libraries
var ALGORITHM = 'AES-256-CBC';
var HMAC_ALGORITHM = 'SHA256';

var program = {};

global.sdkEventEmitter = new _events2.default.EventEmitter();
global.startTime = new Date().getTime();

var testPayload = void 0;
var stats = {
  cpu: 0,
  cpuCount: 0,
  memory: 0
};

var rejectionEmitter = (0, _unhandledRejection2.default)({
  timeout: 120
});

global.sdkEventEmitter.on('update-pid', function (pid) {
  console.log('changing pid', pid);
  if (global.currentPid) {
    _roarPidusage2.default.unmonitor(global.currentPid);
  }

  global.currentPid = pid;

  if (global.currentPid) {
    setTimeout(function () {
      _roarPidusage2.default.stat(global.currentPid, function (err, stat) {
        if (stat) {
          if (stat.cpu && stat.cpu > stats.cpu) {
            stats.cpu += stat.cpu;
            stats.cpuCount++;
          }

          if (stat.memory && stat.memory > stats.memory) {
            stats.memory = stat.memory;
          }
        }

        global.gc();
      });
    }, 1000);
  }
});
global.sdkEventEmitter.emit('update-pid', process.pid);

function processPayload(data) {
  // logger.log(program.data.TimelineID, program.data.ACCESS_KEY, { Status: 'Packaging', PackagedOn: new Date() });
  console.log('HELLO INSPECTOR #1', program.data.ACCESS_KEY_SECRET);
  // logger.inspector('update', configure.inspector.name, 'Completed handler for all templates in the payload');
  // logger.output(6, 'Inspector Start', 'Recieved payload, starting inspector...', 20, { '_InspectorName': configure.inspector.name, '_InspectorVersion': configure.inspector.version });
  var IV = new Buffer(_crypto2.default.randomBytes(16)); // ensure that the IV (initialization vector) is random

  // Need to serialize our nodes for sending across the wire
  //payload.nodes = payload.nodes.map(node => node.serialize());
  console.log('HELLO INSPECTOR #1a', program.data.ACCESS_KEY_SECRET);
  //console.log('HELLO INSPECTOR #1b', util.inspect(payload, { showHidden: false, depth: null }));

  console.log('HELLO INSPECTOR #2', ALGORITHM, Buffer.from(program.data.ACCESS_KEY_SECRET, 'hex'), IV);
  var encryptor = _crypto2.default.createCipheriv(ALGORITHM, Buffer.from(program.data.ACCESS_KEY_SECRET, 'hex'), IV);
  console.log('HELLO INSPECTOR #2a');
  encryptor.setEncoding('hex');
  console.log('HELLO INSPECTOR #2b');
  encryptor.write((0, _stringify2.default)((0, _assign2.default)({
    TimelineID: program.data.TimelineID,
    ServiceProviderID: program.data.ServiceProviderID,
    ScannerID: program.data.ScannerID,
    ScannerVersion: program.data.ScannerVersion,
    ControllerDeploymentID: program.data.ControllerDeploymentID
  }, data)).replace(/[^\x00-\x7F]/g, ''));
  console.log('HELLO INSPECTOR #2c');
  encryptor.end();

  console.log('HELLO INSPECTOR #2', data);
  var cipherText = encryptor.read();

  console.log('HELLO INSPECTOR #3', 'cipherText', program.data.ACCESS_KEY_SECRET);
  var hmac = _crypto2.default.createHmac(HMAC_ALGORITHM, program.data.ACCESS_KEY_SECRET);
  hmac.update(cipherText);
  hmac.update(IV.toString('hex'));

  console.log('HELLO INSPECTOR #4', program.data.ACCESS_KEY, process.env.NODE_ENV);
  /*console.log('HELLO INSPECTOR #111', `${configure.apiURL()}/scan`, JSON.stringify({
    content: cipherText + '$' + IV.toString('hex') + '$' + hmac.digest('hex')
  }));*/

  return new _bluebird2.default(function (resolve, reject) {
    if (process.env.NODE_ENV === 'prod') {
      console.log('HELLO INSPECTOR #5', _configure2.default.apiURL() + '/scan');
      //console.log('HELLO INSPECTOR #a', cipherText);
      console.log('HELLO INSPECTOR #b', IV.toString('hex'));

      var hmacFinal = hmac.digest('hex');
      console.log('HELLO INSPECTOR #c', hmacFinal);

      var theContent = cipherText + '$' + IV.toString('hex') + '$' + hmacFinal;
      var ss = theContent.split('$');
      console.log('cipher length', Buffer.byteLength(theContent, 'utf8'), ss.length);
      console.log('1', ss[1]);
      console.log('2', ss[2]);

      (0, _requestretry2.default)({
        method: 'POST',
        url: _configure2.default.apiURL() + '/scan',
        json: true,
        timeout: 60000,
        body: {
          content: theContent
        },
        gzip: true,
        maxAttempts: 1,
        retryDelay: 60000, // (default) wait for 60s before trying again
        retryStrategy: _requestretry2.default.RetryStrategies.HTTPOrNetworkError, // (default) retry on 5xx or network errors
        headers: {
          'Authorization': program.data.ACCESS_KEY,
          'Accept': 'application/json'
        }
      }, function (error, response, body) {
        console.log('abc', response, error, body);
        if (error) {
          _Logger2.default.log(program.data.TimelineID, program.data.ACCESS_KEY, { Status: 'Failed', log: { Level: _Logger.LEVELS.ERROR, Message: 'Inspector failed to send payload to Roar API successfully, exiting...\n\n' + (error ? (0, _utils.formatError)(error) : '') } });
          reject();
        }

        resolve();
      });
    } else {
      resolve();
    }
  });
}

function run(handler, options) {
  var startTime = new Date().getTime();

  program.data = {};
  program.data = process.argv[3];

  program.data = JSON.parse(new Buffer(program.data, 'hex').toString('ascii'));

  process.on('uncaughtException', function (err) {
    console.error('uncaughtException', err ? (0, _utils.formatError)(err) : '');
    _Logger2.default.log(program.data.TimelineID, program.data.ACCESS_KEY, { Status: 'Failed', log: { Level: _Logger.LEVELS.ERROR, Message: 'Unknown failure occurred for inspector, exiting...\n\n' + (err ? (0, _utils.formatError)(err) : '') } });
    process.exit(1);
  });

  rejectionEmitter.on('unhandledRejection', function (error, promise) {
    console.error('unhandledRejection', error ? (0, _utils.formatError)(error) : '');
    _Logger2.default.log(program.data.TimelineID, program.data.ACCESS_KEY, { Status: 'Failed', log: { Level: _Logger.LEVELS.ERROR, Message: 'Unknown failure occurred for inspector, exiting...\n\n' + (error ? (0, _utils.formatError)(error) : '') } });
    process.exit(1);
  });

  console.log('HELLO INSPECTOR #0', _util2.default.inspect(program.data, { showHidden: false, depth: null }));
  //logger.output(6, 'Inspector Start', 'Recieved payload, starting inspector...', 20, { '_InspectorName': configure.inspector.name, '_InspectorVersion': configure.inspector.version, '_ServiceProviderID': `${program.data.ServiceProviderID}`, '_ScannerID': `${program.data.ScannerID}`, '_ControllerDeploymentID': `${program.data.ControllerDeploymentID}` });

  global.ACCESS_KEY = program.data.ACCESS_KEY;
  global.ACCESS_KEY_SECRET = program.data.ACCESS_KEY_SECRET;

  options = options || {};
  _bluebird2.default.map(program.data.templates, function (d) {
    return new _bluebird2.default(function (resolve, reject) {
      (0, _Node.setTemplate)(d);
      if (!options.pause) {
        handler(program.data, d, resolve, reject);
      } else {
        setTimeout(function () {
          handler(program.data, d, resolve, reject);
        }, options.pause);
      }
    });
  }).then(function () {
    if (options.limit) {
      var startIndex = 0;
      _bluebird2.default.mapSeries(_Node.payload.nodes, function (node, index) {
        var endTime = new Date().getTime();
        var totalTime = endTime - global.startTime;
        if (Buffer.byteLength((0, _stringify2.default)(_Node.payload.nodes.slice(startIndex, index + 1)), 'utf8') >= (0, _bytes2.default)(options.limit)) {
          // need to make into promises
          var oldStartIndex = startIndex;
          startIndex = index + 1;
          var nodeSet = _Node.payload.nodes.slice(oldStartIndex, index + 1).map(function (node) {
            return node.serialize();
          });
          return processPayload({
            nodes: nodeSet,
            relationships: [],
            stats: (0, _assign2.default)({}, { StartTime: global.startTime, EndTime: new Date().getTime(), TotalTime: totalTime, AvgCPU: (0, _isNan2.default)(stats.cpu / stats.cpuCount) ? 0 : stats.cpu / stats.cpuCount, MaxMemory: stats.memory })
          });
        } else {
          return _bluebird2.default.resolve();
        }
      }).then(function () {
        var endTime = new Date().getTime();
        var totalTime = endTime - global.startTime;
        global.sdkEventEmitter.emit('update-pid', null);

        processPayload({
          nodes: [],
          relationships: _Node.payload.relationships,
          stats: (0, _assign2.default)({}, { StartTime: global.startTime, EndTime: new Date().getTime(), TotalTime: totalTime, AvgCPU: (0, _isNan2.default)(stats.cpu / stats.cpuCount) ? 0 : stats.cpu / stats.cpuCount, MaxMemory: stats.memory })
        }).then(function () {
          process.exit(0);
        });
      });
    } else {
      if (!testPayload) {
        _Node.payload.nodes = _Node.payload.nodes.map(function (node) {
          return node.serialize();
        });
      }

      var endTime = new Date().getTime();
      var totalTime = endTime - global.startTime;
      global.sdkEventEmitter.emit('update-pid', null);

      processPayload(testPayload ? testPayload : (0, _assign2.default)(_Node.payload, { stats: { StartTime: global.startTime, EndTime: new Date().getTime(), TotalTime: totalTime, AvgCPU: stats.cpu / stats.cpuCount, MaxMemory: stats.memory } })).then(function () {
        process.exit(0);
      });
    }
  }).catch(function (err) {
    console.error('caught error', err ? (0, _utils.formatError)(err) : '');
    _Logger2.default.log(program.data.TimelineID, program.data.ACCESS_KEY, { Status: 'Failed', log: { Level: _Logger.LEVELS.ERROR, Message: 'Inspector failed during running of handler, exiting...\n\n' + (err ? (0, _utils.formatError)(err) : '') } });
    global.sdkEventEmitter.emit('update-pid', null);
    process.exit(1);
  });
}

function addRelationship(entity, node1, node2, relationship, configuration) {
  _Node.payload.relationships.push({
    EntityID: entity,
    Node1: (typeof node1 === 'undefined' ? 'undefined' : (0, _typeof3.default)(node1)) === 'object' ? node1.getUniqueCompositeKey() : node1,
    Node2: (typeof node1 === 'undefined' ? 'undefined' : (0, _typeof3.default)(node1)) === 'object' ? node2.getUniqueCompositeKey() : node2,
    Relationship: relationship
  });
}

function addSuggestion(obj) {
  _Node.payload.suggestions.push(obj);
}

function overridePayload(obj) {
  testPayload = obj;
}

function getPayload() {
  return _Node.payload;
}

function payloadToJSONString() {
  return {
    nodes: _Node.payload.nodes.map(function (node) {
      return node.serialize();
    }),
    relationships: _Node.payload.relationships,
    suggestions: _Node.payload.suggestions
  };
}

exports.default = {
  version: _configure2.default.version,
  run: run,
  addRelationship: addRelationship,
  addSuggestion: addSuggestion,
  getPayload: getPayload,
  overridePayload: overridePayload,
  payloadToJSONString: payloadToJSONString,

  // -- Modules
  CloudItem: require('./resources/CloudItem'),
  CloudService: require('./resources/CloudService'),
  Data: require('./resources/Data'),
  DHCP: require('./resources/DHCP'),
  Firewall: require('./resources/Firewall'),
  Host: require('./resources/Host'),
  LocalDNS: require('./resources/LocalDNS'),
  LocalService: require('./resources/LocalService'),
  NetworkDevice: require('./resources/NetworkDevice'),
  NetworkNode: require('./resources/NetworkNode'),
  Policy: require('./resources/Policy'),
  PublicDNS: require('./resources/PublicDNS'),
  RegisteredDomain: require('./resources/RegisteredDomain'),
  Registrar: require('./resources/Registrar'),
  Router: require('./resources/Router'),
  SecurityDevice: require('./resources/SecurityDevice'),
  Subnet: require('./resources/Subnet'),
  Switch: require('./resources/Switch'),
  User: require('./resources/User'),

  SecurityZones: _Node.SecurityZones,

  // --- Helpers
  logger: _Logger2.default,
  LEVELS: _Logger.LEVELS,
  formatError: _utils.formatError, formatErrorToJSON: _utils.formatErrorToJSON, execScript: _utils.execScript, generateHash: _utils.generateHash, parsePowershellOutput: _utils.parsePowershellOutput
};
module.exports = exports['default'];
//# sourceMappingURL=roar-sdk.js.map