integration.js

'use strict';

const request = require('postman-request');
const config = require('./config/config');
const async = require('async');
const fs = require('fs');

let Logger;
let requestWithDefaults;

const MAX_PARALLEL_LOOKUPS = 10;

/**
 *
 * @param entities
 * @param options
 * @param cb
 */
function doLookup(entities, options, cb) {
  const lookupResults = [];
  const tasks = [];

  Logger.trace({ entities }, 'doLookup');

  entities.forEach((entity) => {
    //do the lookup
    let url = options.url;
    if (!url.endsWith('/')) {
      url += '/';
    }

    const requestOptions = {
      uri: url + '/api/cve/' + entity.value,
      method: 'GET',
      json: true
    };

    tasks.push(function (done) {
      Logger.debug({ requestOptions: requestOptions }, 'Sending GET Request');
      requestWithDefaults(requestOptions, function (error, res, body) {
        if (error) {
          Logger.error({ error: error, res: res, body: body }, 'HTTP Request Error');
          done(error);
          return;
        }

        if (res.statusCode === 200) {
          done(null, {
            entity: entity,
            body: body
          });
        } else {
          done(body);
        }
      });
    });
  });

  async.parallelLimit(tasks, MAX_PARALLEL_LOOKUPS, (err, results) => {
    if (err) {
      cb(err);
      return;
    }

    results.forEach((result) => {
      if (result.body === null) {
        lookupResults.push({
          entity: result.entity,
          data: null
        });
      } else {
        lookupResults.push({
          entity: result.entity,
          data: {
            summary: getSummaryTags(result.body),
            details: result.body
          }
        });
      }
    });
    Logger.debug({ lookupResults }, 'Results');
    cb(null, lookupResults);
  });
}

function getSummaryTags(body) {
  const tags = [];

  if (body.cvss && body.access.authentication) {
    tags.push(`CVSS Score: ${body.cvss}`);
  }

  if (body.access && body.access.authentication) {
    if (body.access.authentication === 'NONE') {
      tags.push('No Auth Required');
    } else {
      tags.push('Auth Required');
    }
  }

  if (body.access && body.access.vector) {
    tags.push(`Vector: ${body.access.vector}`);
  }

  if (tags.length === 0) {
    if (body.cwe) {
      tags.push(body.cwe);
    }
  }

  if(tags.length === 0){
    tags.push('1 result');
  }


  return tags;
}

function startup(logger) {
  Logger = logger;

  let requestOptions = {};

  if (typeof config.request.cert === 'string' && config.request.cert.length > 0) {
    requestOptions.cert = fs.readFileSync(config.request.cert);
  }

  if (typeof config.request.key === 'string' && config.request.key.length > 0) {
    requestOptions.key = fs.readFileSync(config.request.key);
  }

  if (typeof config.request.passphrase === 'string' && config.request.passphrase.length > 0) {
    requestOptions.passphrase = config.request.passphrase;
  }

  if (typeof config.request.ca === 'string' && config.request.ca.length > 0) {
    requestOptions.ca = fs.readFileSync(config.request.ca);
  }

  if (typeof config.request.proxy === 'string' && config.request.proxy.length > 0) {
    requestOptions.proxy = config.request.proxy;
  }

  if (typeof config.request.rejectUnauthorized === 'boolean') {
    requestOptions.rejectUnauthorized = config.request.rejectUnauthorized;
  }

  requestWithDefaults = request.defaults(requestOptions);
}

function validateOptions(userOptions, cb) {
  let errors = [];
  if (
    typeof userOptions.url.value !== 'string' ||
    (typeof userOptions.url.value === 'string' && userOptions.url.value.length === 0)
  ) {
    errors.push({
      key: 'url',
      message: 'You must provide a server URL'
    });
  }

  cb(null, errors);
}

module.exports = {
  doLookup: doLookup,
  startup: startup,
  validateOptions: validateOptions
};