openhim-core/lib/api/certificateAuthority.js

The OpenHIM core application that provides logging and routing of http requests

var Certificate, Keystore, Q, authorisation, createCertificate, extractCertMetadata, generateClientCert, generateServerCert, getFingerprint, getRandomInt, logger, pem, readCertificateInfo, utils;

Keystore = require('../model/keystore').Keystore;

Certificate = require('../model/keystore').Certificate;

Q = require('q');

logger = require('winston');

utils = require("../utils");

pem = require("pem");

authorisation = require('./authorisation');

readCertificateInfo = Q.denodeify(pem.readCertificateInfo);

getFingerprint = Q.denodeify(pem.getFingerprint);

exports.generateCert = function*() {
  var options, result;
  if (authorisation.inGroup('admin', this.authenticated) === false) {
    utils.logAndSetResponse(this, 403, "User " + this.authenticated.email + " is not an admin, API access to getServerKey by id denied.", 'info');
    return;
  }
  options = this.request.body;
  if (options.type === 'server') {
    logger.info('Generating server cert');
    result = (yield generateServerCert(options));
  } else {
    logger.info('Generating client cert');
    result = (yield generateClientCert(options));
  }
  this.status = 201;
  return this.body = result;
};

generateClientCert = function*(options) {
  var certInfo, err, error, keystoreDoc;
  keystoreDoc = (yield Keystore.findOne().exec());
  options.selfSigned = true;
  try {
    this.body = (yield createCertificate(options));
    certInfo = (yield extractCertMetadata(this.body.certificate));
    keystoreDoc.ca.push(certInfo);
    (yield Q.ninvoke(keystoreDoc, 'save'));
    this.status = 201;
    logger.info('Client certificate created');
  } catch (error) {
    err = error;
    utils.logAndSetResponse(this, 'internal server error', "Could not create a client cert via the API: " + err, 'error');
  }
  return this.body;
};

generateServerCert = function*(options) {
  var err, error, keystoreDoc;
  keystoreDoc = (yield Keystore.findOne().exec());
  options.selfSigned = true;
  try {
    this.body = (yield createCertificate(options));
    keystoreDoc.cert = (yield extractCertMetadata(this.body.certificate));
    keystoreDoc.key = this.body.key;
    (yield Q.ninvoke(keystoreDoc, 'save'));
    this.status = 201;
    logger.info('Server certificate created');
  } catch (error) {
    err = error;
    utils.logAndSetResponse(this, 'internal server error', "Could not create a client cert via the API: " + err, 'error');
  }
  return this.body;
};

createCertificate = function(options) {
  var deferred;
  deferred = Q.defer();
  pem.createCertificate(options, function(err, cert) {
    var response;
    if (err) {
      response = {
        err: err
      };
      return deferred.resolve(response);
    } else {
      response = {
        certificate: cert.certificate,
        key: cert.clientKey
      };
      return deferred.resolve(response);
    }
  });
  return deferred.promise;
};

extractCertMetadata = function*(cert) {
  var certInfo, fingerprint;
  certInfo = (yield readCertificateInfo(cert));
  fingerprint = (yield getFingerprint(cert));
  certInfo.data = this.body.certificate;
  certInfo.fingerprint = fingerprint.fingerprint;
  return certInfo;
};

getRandomInt = function(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
};

//# sourceMappingURL=certificateAuthority.js.map