pem.js

- Jump To … +
  lib/helper.js lib/openssl.js lib/pem.js

- # pem.js

- ¶

      'use strict'

      /**
       * pem module
       *
       * @module pem
       */

      const { promisify } = require('es6-promisify')
      var net = require('net')
      var helper = require('./helper.js')
      var openssl = require('./openssl.js')

      module.exports.createPrivateKey = createPrivateKey
      module.exports.createDhparam = createDhparam
      module.exports.createEcparam = createEcparam
      module.exports.createCSR = createCSR
      module.exports.createCertificate = createCertificate
      module.exports.readCertificateInfo = readCertificateInfo
      module.exports.getPublicKey = getPublicKey
      module.exports.getFingerprint = getFingerprint
      module.exports.getModulus = getModulus
      module.exports.getDhparamInfo = getDhparamInfo
      module.exports.createPkcs12 = createPkcs12
      module.exports.readPkcs12 = readPkcs12
      module.exports.verifySigningChain = verifySigningChain
      module.exports.checkCertificate = checkCertificate
      module.exports.checkPkcs12 = checkPkcs12
      module.exports.config = config

      /**
       * quick access the convert module
       * @type {module:convert}
       */
      module.exports.convert = require('./convert.js')

      var KEY_START = '-----BEGIN PRIVATE KEY-----'
      var KEY_END = '-----END PRIVATE KEY-----'
      var RSA_KEY_START = '-----BEGIN RSA PRIVATE KEY-----'
      var RSA_KEY_END = '-----END RSA PRIVATE KEY-----'
      var ENCRYPTED_KEY_START = '-----BEGIN ENCRYPTED PRIVATE KEY-----'
      var ENCRYPTED_KEY_END = '-----END ENCRYPTED PRIVATE KEY-----'
      var CERT_START = '-----BEGIN CERTIFICATE-----'
      var CERT_END = '-----END CERTIFICATE-----'

      /**
       * Creates a private key
       *
       * @static
       * @param {Number} [keyBitsize=2048] Size of the key, defaults to 2048bit
       * @param {Object} [options] object of cipher and password {cipher:'aes128',password:'xxx'}, defaults empty object
       * @param {String} [options.cipher] string of the cipher for the encryption - needed with password
       * @param {String} [options.password] string of the cipher password for the encryption needed with cipher
       * @param {Function} callback Callback function with an error object and {key}
       */
      function createPrivateKey (keyBitsize, options, callback) {
        if (!callback && !options && typeof keyBitsize === 'function') {
          callback = keyBitsize
          keyBitsize = undefined
          options = {}
        } else if (!callback && keyBitsize && typeof options === 'function') {
          callback = options
          options = {}
        }

        keyBitsize = Number(keyBitsize) || 2048

        var params = ['genrsa']
        var delTempPWFiles = []

        if (options && options.cipher && (Number(helper.ciphers.indexOf(options.cipher)) !== -1) && options.password) {
          helper.createPasswordFile({ cipher: options.cipher, password: options.password, passType: 'out' }, params, delTempPWFiles)
        }

        params.push(keyBitsize)

        openssl.exec(params, 'RSA PRIVATE KEY', function (sslErr, key) {
          function done (err) {
            if (err) {
              return callback(err)
            }
            callback(null, {
              key: key
            })
          }
          helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
            done(sslErr || fsErr)
          })
        })
      }

      /**
       * Creates a dhparam key
       *
       * @static
       * @param {Number} [keyBitsize=512] Size of the key, defaults to 512bit
       * @param {Function} callback Callback function with an error object and {dhparam}
       */
      function createDhparam (keyBitsize, callback) {
        if (!callback && typeof keyBitsize === 'function') {
          callback = keyBitsize
          keyBitsize = undefined
        }

        keyBitsize = Number(keyBitsize) || 512

        var params = ['dhparam',
          '-outform',
          'PEM',
          keyBitsize
        ]

        openssl.exec(params, 'DH PARAMETERS', function (error, dhparam) {
          if (error) {
            return callback(error)
          }
          return callback(null, {
            dhparam: dhparam
          })
        })
      }

      /**
       * Creates a ecparam key
       * @static
       * @param {String} [keyName=secp256k1] Name of the key, defaults to secp256k1
       * @param {String} [paramEnc=explicit] Encoding of the elliptic curve parameters, defaults to explicit
       * @param {Boolean} [noOut=false] This option inhibits the output of the encoded version of the parameters.
       * @param {Function} callback Callback function with an error object and {ecparam}
       */
      function createEcparam (keyName, paramEnc, noOut, callback) {
        if (!callback && typeof noOut === 'undefined' && !paramEnc && typeof keyName === 'function') {
          callback = keyName
          keyName = undefined
        } else if (!callback && typeof noOut === 'undefined' && keyName && typeof paramEnc === 'function') {
          callback = paramEnc
          paramEnc = undefined
        } else if (!callback && typeof noOut === 'function' && keyName && paramEnc) {
          callback = noOut
          noOut = undefined
        }

        keyName = keyName || 'secp256k1'
        paramEnc = paramEnc || 'explicit'
        noOut = noOut || false

        var params = ['ecparam',
          '-name',
          keyName,
          '-genkey',
          '-param_enc',
          paramEnc
        ]

        var searchString = 'EC PARAMETERS'
        if (noOut) {
          params.push('-noout')
          searchString = 'EC PRIVATE KEY'
        }

        openssl.exec(params, searchString, function (error, ecparam) {
          if (error) {
            return callback(error)
          }
          return callback(null, {
            ecparam: ecparam
          })
        })
      }

      /**
       * Creates a Certificate Signing Request
       * If client key is undefined, a new key is created automatically. The used key is included
       * in the callback return as clientKey
       * @static
       * @param {Object} [options] Optional options object
       * @param {String} [options.clientKey] Optional client key to use
       * @param {Number} [options.keyBitsize] If clientKey is undefined, bit size to use for generating a new key (defaults to 2048)
       * @param {String} [options.hash] Hash function to use (either md5 sha1 or sha256, defaults to sha256)
       * @param {String} [options.country] CSR country field
       * @param {String} [options.state] CSR state field
       * @param {String} [options.locality] CSR locality field
       * @param {String} [options.organization] CSR organization field
       * @param {String} [options.organizationUnit] CSR organizational unit field
       * @param {String} [options.commonName='localhost'] CSR common name field
       * @param {String} [options.emailAddress] CSR email address field
       * @param {String} [options.csrConfigFile] CSR config file
       * @param {Array}  [options.altNames] is a list of subjectAltNames in the subjectAltName field
       * @param {Function} callback Callback function with an error object and {csr, clientKey}
       */
      function createCSR (options, callback) {
        if (!callback && typeof options === 'function') {
          callback = options
          options = undefined
        }

        options = options || {}

- ¶

  http://stackoverflow.com/questions/14089872/why-does-node-js-accept-ip-addresses-in-certificates-only-for-san-not-for-cn

        if (options.commonName && (net.isIPv4(options.commonName) || net.isIPv6(options.commonName))) {
          if (!options.altNames) {
            options.altNames = [options.commonName]
          } else if (options.altNames.indexOf(options.commonName) === -1) {
            options.altNames = options.altNames.concat([options.commonName])
          }
        }

        if (!options.clientKey) {
          createPrivateKey(options.keyBitsize || 2048, function (error, keyData) {
            if (error) {
              return callback(error)
            }
            options.clientKey = keyData.key
            createCSR(options, callback)
          })
          return
        }

        var params = ['req',
          '-new',
          '-' + (options.hash || 'sha256')
        ]

        if (options.csrConfigFile) {
          params.push('-config')
          params.push(options.csrConfigFile)
        } else {
          params.push('-subj')
          params.push(generateCSRSubject(options))
        }

        params.push('-key')
        params.push('--TMPFILE--')

        var tmpfiles = [options.clientKey]
        var config = null

        if (options.altNames && Array.isArray(options.altNames) && options.altNames.length) {
          params.push('-extensions')
          params.push('v3_req')
          params.push('-config')
          params.push('--TMPFILE--')
          var altNamesRep = []
          for (var i = 0; i < options.altNames.length; i++) {
            altNamesRep.push((net.isIP(options.altNames[i]) ? 'IP' : 'DNS') + '.' + (i + 1) + ' = ' + options.altNames[i])
          }

          tmpfiles.push(config = [
            '[req]',
            'req_extensions = v3_req',
            'distinguished_name = req_distinguished_name',
            '[v3_req]',
            'subjectAltName = @alt_names',
            '[alt_names]',
            altNamesRep.join('\n'),
            '[req_distinguished_name]',
            'commonName = Common Name',
            'commonName_max = 64'
          ].join('\n'))
        } else if (options.config) {
          config = options.config
        }

        var delTempPWFiles = []
        if (options.clientKeyPassword) {
          helper.createPasswordFile({ cipher: '', password: options.clientKeyPassword, passType: 'in' }, params, delTempPWFiles)
        }

        openssl.exec(params, 'CERTIFICATE REQUEST', tmpfiles, function (sslErr, data) {
          function done (err) {
            if (err) {
              return callback(err)
            }
            callback(null, {
              csr: data,
              config: config,
              clientKey: options.clientKey
            })
          }
          helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
            done(sslErr || fsErr)
          })
        })
      }

      /**
       * Creates a certificate based on a CSR. If CSR is not defined, a new one
       * will be generated automatically. For CSR generation all the options values
       * can be used as with createCSR.
       * @static
       * @param {Object} [options] Optional options object
       * @param {String} [options.serviceCertificate] PEM encoded certificate
       * @param {String} [options.serviceKey] Private key for signing the certificate, if not defined a new one is generated
       * @param {String} [options.serviceKeyPassword] Password of the service key
       * @param {Boolean} [options.selfSigned] If set to true and serviceKey is not defined, use clientKey for signing
       * @param {String|Number} [options.serial] Set a serial max. 20 octets - only together with options.serviceCertificate
       * @param {String} [options.serialFile] Set the name of the serial file, without extension. - only together with options.serviceCertificate and never in tandem with options.serial
       * @param {String} [options.hash] Hash function to use (either md5 sha1 or sha256, defaults to sha256)
       * @param {String} [options.csr] CSR for the certificate, if not defined a new one is generated
       * @param {Number} [options.days] Certificate expire time in days
       * @param {String} [options.clientKeyPassword] Password of the client key
       * @param {String} [options.extFile] extension config file - without '-extensions v3_req'
       * @param {String} [options.config] extension config file - with '-extensions v3_req'
       * @param {String} [options.csrConfigFile] CSR config file - only used if no options.csr is provided
       * @param {Array}  [options.altNames] is a list of subjectAltNames in the subjectAltName field - only used if no options.csr is provided
       * @param {Function} callback Callback function with an error object and {certificate, csr, clientKey, serviceKey}
       */
      function createCertificate (options, callback) {
        if (!callback && typeof options === 'function') {
          callback = options
          options = undefined
        }

        options = options || {}

        if (!options.csr) {
          createCSR(options, function (error, keyData) {
            if (error) {
              return callback(error)
            }
            options.csr = keyData.csr
            options.config = keyData.config
            options.clientKey = keyData.clientKey
            createCertificate(options, callback)
          })
          return
        }

        if (!options.clientKey) {
          options.clientKey = ''
        }

        if (!options.serviceKey) {
          if (options.selfSigned) {
            options.serviceKey = options.clientKey
          } else {
            createPrivateKey(options.keyBitsize || 2048, function (error, keyData) {
              if (error) {
                return callback(error)
              }
              options.serviceKey = keyData.key
              createCertificate(options, callback)
            })
            return
          }
        }

        readCertificateInfo(options.csr, function (error2, data2) {
          if (error2) {
            return callback(error2)
          }

          var params = ['x509',
            '-req',
            '-' + (options.hash || 'sha256'),
            '-days',
            Number(options.days) || '365',
            '-in',
            '--TMPFILE--'
          ]
          var tmpfiles = [options.csr]
          var delTempPWFiles = []

          if (options.serviceCertificate) {
            params.push('-CA')
            params.push('--TMPFILE--')
            params.push('-CAkey')
            params.push('--TMPFILE--')
            if (options.serial) {
              params.push('-set_serial')
              if (helper.isNumber(options.serial)) {

- ¶

  set the serial to the max lenth of 20 octets () A certificate serial number is not decimal conforming. That is the bytes in a serial number do not necessarily map to a printable ASCII character. eg: 0x00 is a valid serial number and can not be represented in a human readable format (atleast one that can be directly mapped to the ACSII table).

                params.push('0x' + ('0000000000000000000000000000000000000000' + options.serial.toString(16)).slice(-40))
              } else {
                if (helper.isHex(options.serial)) {
                  if (options.serial.startsWith('0x')) {
                    options.serial = options.serial.substring(2, options.serial.length)
                  }
                  params.push('0x' + ('0000000000000000000000000000000000000000' + options.serial).slice(-40))
                } else {
                  params.push('0x' + ('0000000000000000000000000000000000000000' + helper.toHex(options.serial)).slice(-40))
                }
              }
            } else {
              params.push('-CAcreateserial')
              if (options.serialFile) {
                params.push('-CAserial')
                params.push(options.serialFile + '.srl')
              }
            }
            if (options.serviceKeyPassword) {
              helper.createPasswordFile({ cipher: '', password: options.serviceKeyPassword, passType: 'in' }, params, delTempPWFiles)
            }
            tmpfiles.push(options.serviceCertificate)
            tmpfiles.push(options.serviceKey)
          } else {
            params.push('-signkey')
            params.push('--TMPFILE--')
            if (options.serviceKeyPassword) {
              helper.createPasswordFile({ cipher: '', password: options.serviceKeyPassword, passType: 'in' }, params, delTempPWFiles)
            }
            tmpfiles.push(options.serviceKey)
          }

          if (options.config) {
            params.push('-extensions')
            params.push('v3_req')
            params.push('-extfile')
            params.push('--TMPFILE--')
            tmpfiles.push(options.config)
          } else if (options.extFile) {
            params.push('-extfile')
            params.push(options.extFile)
          } else {
            var altNamesRep = []
            if (data2 && data2.san) {
              for (var i = 0; i < data2.san.dns.length; i++) {
                altNamesRep.push('DNS' + '.' + (i + 1) + ' = ' + data2.san.dns[i])
              }
              for (var i2 = 0; i2 < data2.san.ip.length; i2++) {
                altNamesRep.push('IP' + '.' + (i2 + 1) + ' = ' + data2.san.ip[i2])
              }
              for (var i3 = 0; i3 < data2.san.email.length; i3++) {
                altNamesRep.push('email' + '.' + (i3 + 1) + ' = ' + data2.san.email[i3])
              }
              params.push('-extensions')
              params.push('v3_req')
              params.push('-extfile')
              params.push('--TMPFILE--')
              tmpfiles.push([
                '[v3_req]',
                'subjectAltName = @alt_names',
                '[alt_names]',
                altNamesRep.join('\n')
              ].join('\n'))
            }
          }

          if (options.clientKeyPassword) {
            helper.createPasswordFile({ cipher: '', password: options.clientKeyPassword, passType: 'in' }, params, delTempPWFiles)
          }

          openssl.exec(params, 'CERTIFICATE', tmpfiles, function (sslErr, data) {
            function done (err) {
              if (err) {
                return callback(err)
              }
              var response = {
                csr: options.csr,
                clientKey: options.clientKey,
                certificate: data,
                serviceKey: options.serviceKey
              }
              return callback(null, response)
            }

            helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
              done(sslErr || fsErr)
            })
          })
        })
      }

      /**
       * Exports a public key from a private key, CSR or certificate
       * @static
       * @param {String} certificate PEM encoded private key, CSR or certificate
       * @param {Function} callback Callback function with an error object and {publicKey}
       */
      function getPublicKey (certificate, callback) {
        if (!callback && typeof certificate === 'function') {
          callback = certificate
          certificate = undefined
        }

        certificate = (certificate || '').toString()

        var params

        if (certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/)) {
          params = ['req',
            '-in',
            '--TMPFILE--',
            '-pubkey',
            '-noout'
          ]
        } else if (certificate.match(/BEGIN RSA PRIVATE KEY/) || certificate.match(/BEGIN PRIVATE KEY/)) {
          params = ['rsa',
            '-in',
            '--TMPFILE--',
            '-pubout'
          ]
        } else {
          params = ['x509',
            '-in',
            '--TMPFILE--',
            '-pubkey',
            '-noout'
          ]
        }

        openssl.exec(params, 'PUBLIC KEY', certificate, function (error, key) {
          if (error) {
            return callback(error)
          }
          return callback(null, {
            publicKey: key
          })
        })
      }

      /**
       * Reads subject data from a certificate or a CSR
       * @static
       * @param {String} certificate PEM encoded CSR or certificate
       * @param {Function} callback Callback function with an error object and {country, state, locality, organization, organizationUnit, commonName, emailAddress}
       */
      function readCertificateInfo (certificate, callback) {
        if (!callback && typeof certificate === 'function') {
          callback = certificate
          certificate = undefined
        }

        certificate = (certificate || '').toString()
        var isMatch = certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/)
        var type = isMatch ? 'req' : 'x509'
        var params = [type,
          '-noout',
          '-nameopt',
          'RFC2253,sep_multiline,space_eq,-esc_msb,utf8',
          '-text',
          '-in',
          '--TMPFILE--'
        ]
        openssl.spawnWrapper(params, certificate, function (err, code, stdout, stderr) {
          if (err) {
            return callback(err)
          } else if (stderr) {
            return callback(stderr)
          }
          return fetchCertificateData(stdout, callback)
        })
      }

      /**
       * get the modulus from a certificate, a CSR or a private key
       * @static
       * @param {String} certificate PEM encoded, CSR PEM encoded, or private key
       * @param {String} [password] password for the certificate
       * @param {String} [hash] hash function to use (up to now `md5` supported) (default: none)
       * @param {Function} callback Callback function with an error object and {modulus}
       */
      function getModulus (certificate, password, hash, callback) {
        if (!callback && !hash && typeof password === 'function') {
          callback = password
          password = undefined
          hash = false
        } else if (!callback && hash && typeof hash === 'function') {
          callback = hash
          hash = false

- ¶

  password will be falsy if not provided

        }

- ¶

  adding hash function to params, is not supported by openssl. process piping would be the right way (… | openssl md5) No idea how this can be achieved in easy with the current build in methods of pem.

        if (hash && hash !== 'md5') {
          hash = false
        }

        certificate = (Buffer.isBuffer(certificate) && certificate.toString()) || certificate

        var type = ''
        if (certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/)) {
          type = 'req'
        } else if (certificate.match(/BEGIN RSA PRIVATE KEY/) || certificate.match(/BEGIN PRIVATE KEY/)) {
          type = 'rsa'
        } else {
          type = 'x509'
        }
        var params = [
          type,
          '-noout',
          '-modulus',
          '-in',
          '--TMPFILE--'
        ]
        var delTempPWFiles = []
        if (password) {
          helper.createPasswordFile({ cipher: '', password: password, passType: 'in' }, params, delTempPWFiles)
        }

        openssl.spawnWrapper(params, certificate, function (sslErr, code, stdout, stderr) {
          function done (err) {
            if (err) {
              return callback(err)
            }
            var match = stdout.match(/Modulus=([0-9a-fA-F]+)$/m)
            if (match) {
              return callback(null, {
                modulus: hash ? require(hash)(match[1]) : match[1]
              })
            } else {
              return callback(new Error('No modulus'))
            }
          }
          helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
            done(sslErr || fsErr || stderr)
          })
        })
      }

      /**
       * get the size and prime of DH parameters
       * @static
       * @param {String} DH parameters PEM encoded
       * @param {Function} callback Callback function with an error object and {size, prime}
       */
      function getDhparamInfo (dh, callback) {
        dh = (Buffer.isBuffer(dh) && dh.toString()) || dh

        var params = [
          'dhparam',
          '-text',
          '-in',
          '--TMPFILE--'
        ]

        openssl.spawnWrapper(params, dh, function (err, code, stdout, stderr) {
          if (err) {
            return callback(err)
          } else if (stderr) {
            return callback(stderr)
          }

          var result = {}
          var match = stdout.match(/Parameters: \((\d+) bit\)/)

          if (match) {
            result.size = Number(match[1])
          }

          var prime = ''
          stdout.split('\n').forEach(function (line) {
            if (/\s+([0-9a-f][0-9a-f]:)+[0-9a-f]?[0-9a-f]?/g.test(line)) {
              prime += line.trim()
            }
          })

          if (prime) {
            result.prime = prime
          }

          if (!match && !prime) {
            return callback(new Error('No DH info found'))
          }

          return callback(null, result)
        })
      }

      /**
       * config the pem module
       * @static
       * @param {Object} options
       */
      function config (options) {
        Object.keys(options).forEach(function (k) {
          openssl.set(k, options[k])
        })
      }

      /**
       * Gets the fingerprint for a certificate
       * @static
       * @param {String} PEM encoded certificate
       * @param {String} [hash] hash function to use (either `md5`, `sha1` or `sha256`, defaults to `sha1`)
       * @param {Function} callback Callback function with an error object and {fingerprint}
       */
      function getFingerprint (certificate, hash, callback) {
        if (!callback && typeof hash === 'function') {
          callback = hash
          hash = undefined
        }

        hash = hash || 'sha1'

        var params = ['x509',
          '-in',
          '--TMPFILE--',
          '-fingerprint',
          '-noout',
          '-' + hash
        ]

        openssl.spawnWrapper(params, certificate, function (err, code, stdout, stderr) {
          if (err) {
            return callback(err)
          } else if (stderr) {
            return callback(stderr)
          }
          var match = stdout.match(/Fingerprint=([0-9a-fA-F:]+)$/m)
          if (match) {
            return callback(null, {
              fingerprint: match[1]
            })
          } else {
            return callback(new Error('No fingerprint'))
          }
        })
      }

      /**
       * Export private key and certificate to a PKCS12 keystore
       * @static
       * @param {String} PEM encoded private key
       * @param {String} PEM encoded certificate
       * @param {String} Password of the result PKCS12 file
       * @param {Object} [options] object of cipher and optional client key password {cipher:'aes128', clientKeyPassword: 'xxxx', certFiles: ['file1','file2']}
       * @param {Function} callback Callback function with an error object and {pkcs12}
       */
      function createPkcs12 (key, certificate, password, options, callback) {
        if (!callback && typeof options === 'function') {
          callback = options
          options = {}
        }

        var params = ['pkcs12', '-export']
        var delTempPWFiles = []

        if (options.cipher && options.clientKeyPassword) {

- ¶

  NOTICE: The password field is needed! self if it is empty. create password file for the import “-passin”

          helper.createPasswordFile({ cipher: options.cipher, password: options.clientKeyPassword, passType: 'in' }, params, delTempPWFiles)
        }

- ¶

  NOTICE: The password field is needed! self if it is empty. create password file for the password “-password”

        helper.createPasswordFile({ cipher: '', password: password, passType: 'word' }, params, delTempPWFiles)

        params.push('-in')
        params.push('--TMPFILE--')
        params.push('-inkey')
        params.push('--TMPFILE--')

        var tmpfiles = [certificate, key]

        if (options.certFiles) {
          tmpfiles.push(options.certFiles.join(''))

          params.push('-certfile')
          params.push('--TMPFILE--')
        }

        openssl.execBinary(params, tmpfiles, function (sslErr, pkcs12) {
          function done (err) {
            if (err) {
              return callback(err)
            }
            return callback(null, {
              pkcs12: pkcs12
            })
          }
          helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
            done(sslErr || fsErr)
          })
        })
      }

      /**
       * read sslcert data from Pkcs12 file. Results are provided in callback response in object notation ({cert: .., ca:..., key:...})
       * @static
       * @param  {Buffer|String}   bufferOrPath Buffer or path to file
       * @param  {Object}   [options]      openssl options
       * @param  {Function} callback     Called with error object and sslcert bundle object
       */
      function readPkcs12 (bufferOrPath, options, callback) {
        if (!callback && typeof options === 'function') {
          callback = options
          options = {}
        }

        options.p12Password = options.p12Password || ''

        var tmpfiles = []
        var delTempPWFiles = []
        var args = ['pkcs12', '-in', bufferOrPath]

        helper.createPasswordFile({ cipher: '', password: options.p12Password, passType: 'in' }, args, delTempPWFiles)

        if (Buffer.isBuffer(bufferOrPath)) {
          tmpfiles = [bufferOrPath]
          args[2] = '--TMPFILE--'
        }

        if (options.clientKeyPassword) {
          helper.createPasswordFile({ cipher: '', password: options.clientKeyPassword, passType: 'out' }, args, delTempPWFiles)
        } else {
          args.push('-nodes')
        }

        openssl.execBinary(args, tmpfiles, function (sslErr, stdout) {
          function done (err) {
            var keybundle = {}

            if (err && err.message.indexOf('No such file or directory') !== -1) {
              err.code = 'ENOENT'
            }

            if (!err) {
              var certs = readFromString(stdout, CERT_START, CERT_END)
              keybundle.cert = certs.shift()
              keybundle.ca = certs
              keybundle.key = readFromString(stdout, KEY_START, KEY_END).pop()

              if (keybundle.key) {

- ¶

  convert to RSA key

                return openssl.exec(['rsa', '-in', '--TMPFILE--'], 'RSA PRIVATE KEY', [keybundle.key], function (err, key) {
                  keybundle.key = key

                  return callback(err, keybundle)
                })
              }

              if (options.clientKeyPassword) {
                keybundle.key = readFromString(stdout, ENCRYPTED_KEY_START, ENCRYPTED_KEY_END).pop()
              } else {
                keybundle.key = readFromString(stdout, RSA_KEY_START, RSA_KEY_END).pop()
              }
            }

            return callback(err, keybundle)
          }
          helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
            done(sslErr || fsErr)
          })
        })
      }

      /**
       * Check a certificate
       * @static
       * @param {String} PEM encoded certificate
       * @param {String} [passphrase] password for the certificate
       * @param {Function} callback Callback function with an error object and a boolean valid
       */
      function checkCertificate (certificate, passphrase, callback) {
        var params
        var delTempPWFiles = []

        if (!callback && typeof passphrase === 'function') {
          callback = passphrase
          passphrase = undefined
        }
        certificate = (certificate || '').toString()

        if (certificate.match(/BEGIN(\sNEW)? CERTIFICATE REQUEST/)) {
          params = ['req', '-text', '-noout', '-verify', '-in', '--TMPFILE--']
        } else if (certificate.match(/BEGIN RSA PRIVATE KEY/) || certificate.match(/BEGIN PRIVATE KEY/)) {
          params = ['rsa', '-noout', '-check', '-in', '--TMPFILE--']
        } else {
          params = ['x509', '-text', '-noout', '-in', '--TMPFILE--']
        }
        if (passphrase) {
          helper.createPasswordFile({ cipher: '', password: passphrase, passType: 'in' }, params, delTempPWFiles)
        }

        openssl.spawnWrapper(params, certificate, function (sslErr, code, stdout, stderr) {
          function done (err) {
            if (err && err.toString().trim() !== 'verify OK') {
              return callback(err)
            }
            var result
            switch (params[0]) {
              case 'rsa':
                result = /^Rsa key ok$/i.test(stdout.trim())
                break
              default:
                result = /Signature Algorithm/im.test(stdout)
                break
            }

            callback(null, result)
          }
          helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
            done(sslErr || fsErr || stderr)
          })
        })
      }

      /**
       * check a PKCS#12 file (.pfx or.p12)
       * @static
       * @param {Buffer|String} bufferOrPath PKCS#12 certificate
       * @param {String} [passphrase] optional passphrase which will be used to open the keystore
       * @param {Function} callback Callback function with an error object and a boolean valid
       */
      function checkPkcs12 (bufferOrPath, passphrase, callback) {
        if (!callback && typeof passphrase === 'function') {
          callback = passphrase
          passphrase = ''
        }

        var tmpfiles = []
        var delTempPWFiles = []
        var args = ['pkcs12', '-info', '-in', bufferOrPath, '-noout', '-maciter', '-nodes']

        helper.createPasswordFile({ cipher: '', password: passphrase, passType: 'in' }, args, delTempPWFiles)

        if (Buffer.isBuffer(bufferOrPath)) {
          tmpfiles = [bufferOrPath]
          args[3] = '--TMPFILE--'
        }

        openssl.spawnWrapper(args, tmpfiles, function (sslErr, code, stdout, stderr) {
          function done (err) {
            if (err) {
              return callback(err)
            }
            callback(null, (/MAC verified OK/im.test(stderr) || (!(/MAC verified OK/im.test(stderr)) && !(/Mac verify error/im.test(stderr)))))
          }
          helper.deleteTempFiles(delTempPWFiles, function (fsErr) {
            done(sslErr || fsErr)
          })
        })
      }

      /**
       * Verifies the signing chain of the passed certificate
       * @static
       * @param {String|Array} PEM encoded certificate include intermediate certificates
       * @param {String|Array} [List] of CA certificates
       * @param {Function} callback Callback function with an error object and a boolean valid
       */
      function verifySigningChain (certificate, ca, callback) {
        if (!callback && typeof ca === 'function') {
          callback = ca
          ca = undefined
        }
        if (!Array.isArray(certificate)) {
          certificate = [certificate]
        }
        if (!Array.isArray(ca) && ca !== undefined) {
          if (ca !== '') {
            ca = [ca]
          }
        }

        var files = []

        if (ca !== undefined) {

- ¶

  ca certificates

          files.push(ca.join('\n'))
        }

- ¶

  certificate incl. intermediate certificates

        files.push(certificate.join('\n'))

        var params = ['verify']

        if (ca !== undefined) {

- ¶

  ca certificates

          params.push('-CAfile')
          params.push('--TMPFILE--')
        }

- ¶

  certificate incl. intermediate certificates

        params.push('--TMPFILE--')

        openssl.spawnWrapper(params, files, function (err, code, stdout, stderr) {
          if (err) {
            return callback(err)
          }

          callback(null, stdout.trim().slice(-4) === ': OK')
        })
      }

- ¶

  HELPER FUNCTIONS

      function fetchCertificateData (certData, callback) {

- ¶

  try catch : if something will fail in parsing it won’t crash the calling code

        try {
          certData = (certData || '').toString()

          var serial, subject, tmp, issuer
          var certValues = {
            issuer: {}
          }
          var validity = {}
          var san

          var ky, i

- ¶

  serial

          if ((serial = certData.match(/\s*Serial Number:\r?\n?\s*([^\r\n]*)\r?\n\s*\b/)) && serial.length > 1) {
            certValues.serial = serial[1]
          }

          if ((subject = certData.match(/\s*Subject:\r?\n(\s*(([a-zA-Z0-9.]+)\s=\s[^\r\n]+\r?\n))*\s*\b/)) && subject.length > 1) {
            subject = subject[0]
            tmp = matchAll(subject, /\s([a-zA-Z0-9.]+)\s=\s([^\r\n].*)/g)
            if (tmp) {
              for (i = 0; i < tmp.length; i++) {
                ky = tmp[i][1].trim()
                if (ky.match('(C|ST|L|O|OU|CN|emailAddress|DC)') || ky === '') {
                  continue
                }
                certValues[ky] = tmp[i][2].trim()
              }
            }

- ¶

  country

            tmp = subject.match(/\sC\s=\s([^\r\n].*?)[\r\n]/)
            certValues.country = (tmp && tmp[1]) || ''

- ¶

  state

            tmp = subject.match(/\sST\s=\s([^\r\n].*?)[\r\n]/)
            certValues.state = (tmp && tmp[1]) || ''

- ¶

  locality

            tmp = subject.match(/\sL\s=\s([^\r\n].*?)[\r\n]/)
            certValues.locality = (tmp && tmp[1]) || ''

- ¶

  organization

            tmp = matchAll(subject, /\sO\s=\s([^\r\n].*)/g)
            certValues.organization = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
              var e = t[1].toUpperCase()
              var r = n[1].toUpperCase()
              return r > e ? -1 : e > r ? 1 : 0
            }).sort(function (t, n) {
              return t[1].length - n[1].length
            }).map(function (t) {
              return t[1]
            }) : tmp[0][1]) : ''

- ¶

  unit

            tmp = matchAll(subject, /\sOU\s=\s([^\r\n].*)/g)
            certValues.organizationUnit = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
              var e = t[1].toUpperCase()
              var r = n[1].toUpperCase()
              return r > e ? -1 : e > r ? 1 : 0
            }).sort(function (t, n) {
              return t[1].length - n[1].length
            }).map(function (t) {
              return t[1]
            }) : tmp[0][1]) : ''

- ¶

  common name

            tmp = matchAll(subject, /\sCN\s=\s([^\r\n].*)/g)
            certValues.commonName = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
              var e = t[1].toUpperCase()
              var r = n[1].toUpperCase()
              return r > e ? -1 : e > r ? 1 : 0
            }).sort(function (t, n) {
              return t[1].length - n[1].length
            }).map(function (t) {
              return t[1]
            }) : tmp[0][1]) : ''

- ¶

  email

            tmp = matchAll(subject, /emailAddress\s=\s([^\r\n].*)/g)
            certValues.emailAddress = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
              var e = t[1].toUpperCase()
              var r = n[1].toUpperCase()
              return r > e ? -1 : e > r ? 1 : 0
            }).sort(function (t, n) {
              return t[1].length - n[1].length
            }).map(function (t) {
              return t[1]
            }) : tmp[0][1]) : ''

- ¶

  DC name

            tmp = matchAll(subject, /\sDC\s=\s([^\r\n].*)/g)
            certValues.dc = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
              var e = t[1].toUpperCase()
              var r = n[1].toUpperCase()
              return r > e ? -1 : e > r ? 1 : 0
            }).sort(function (t, n) {
              return t[1].length - n[1].length
            }).map(function (t) {
              return t[1]
            }) : tmp[0][1]) : ''
          }

          if ((issuer = certData.match(/\s*Issuer:\r?\n(\s*([a-zA-Z0-9.]+)\s=\s[^\r\n].*\r?\n)*\s*\b/)) && issuer.length > 1) {
            issuer = issuer[0]
            tmp = matchAll(issuer, /\s([a-zA-Z0-9.]+)\s=\s([^\r\n].*)/g)
            for (i = 0; i < tmp.length; i++) {
              ky = tmp[i][1].toString()
              if (ky.match('(C|ST|L|O|OU|CN|emailAddress|DC)')) {
                continue
              }
              certValues.issuer[ky] = tmp[i][2].toString()
            }

- ¶

  country

            tmp = issuer.match(/\sC\s=\s([^\r\n].*?)[\r\n]/)
            certValues.issuer.country = (tmp && tmp[1]) || ''

- ¶

  state

            tmp = issuer.match(/\sST\s=\s([^\r\n].*?)[\r\n]/)
            certValues.issuer.state = (tmp && tmp[1]) || ''

- ¶

  locality

            tmp = issuer.match(/\sL\s=\s([^\r\n].*?)[\r\n]/)
            certValues.issuer.locality = (tmp && tmp[1]) || ''

- ¶

  organization

            tmp = matchAll(issuer, /\sO\s=\s([^\r\n].*)/g)
            certValues.issuer.organization = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
              var e = t[1].toUpperCase()
              var r = n[1].toUpperCase()
              return r > e ? -1 : e > r ? 1 : 0
            }).sort(function (t, n) {
              return t[1].length - n[1].length
            }).map(function (t) {
              return t[1]
            }) : tmp[0][1]) : ''

- ¶

  unit

            tmp = matchAll(issuer, /\sOU\s=\s([^\r\n].*)/g)
            certValues.issuer.organizationUnit = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
              var e = t[1].toUpperCase()
              var
                r = n[1].toUpperCase()
              return r > e ? -1 : e > r ? 1 : 0
            }).sort(function (t, n) {
              return t[1].length - n[1].length
            }).map(function (t) {
              return t[1]
            }) : tmp[0][1]) : ''

- ¶

  common name

            tmp = matchAll(issuer, /\sCN\s=\s([^\r\n].*)/g)
            certValues.issuer.commonName = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
              var e = t[1].toUpperCase()
              var
                r = n[1].toUpperCase()
              return r > e ? -1 : e > r ? 1 : 0
            }).sort(function (t, n) {
              return t[1].length - n[1].length
            }).map(function (t) {
              return t[1]
            }) : tmp[0][1]) : ''

- ¶

  DC name

            tmp = matchAll(issuer, /\sDC\s=\s([^\r\n].*)/g)
            certValues.issuer.dc = tmp ? (tmp.length > 1 ? tmp.sort(function (t, n) {
              var e = t[1].toUpperCase()
              var
                r = n[1].toUpperCase()
              return r > e ? -1 : e > r ? 1 : 0
            }).sort(function (t, n) {
              return t[1].length - n[1].length
            }).map(function (t) {
              return t[1]
            }) : tmp[0][1]) : ''
          }

- ¶

  SAN

          if ((san = certData.match(/X509v3 Subject Alternative Name: \r?\n([^\r\n]*)\r?\n/)) && san.length > 1) {
            san = san[1].trim() + '\n'
            certValues.san = {}

- ¶

  hostnames

            tmp = pregMatchAll('DNS:([^,\\r\\n].*?)[,\\r\\n\\s]', san)
            certValues.san.dns = tmp || ''

- ¶

  IP-Addresses IPv4 & IPv6

            tmp = pregMatchAll('IP Address:([^,\\r\\n].*?)[,\\r\\n\\s]', san)
            certValues.san.ip = tmp || ''

- ¶

  Email Addresses

            tmp = pregMatchAll('email:([^,\\r\\n].*?)[,\\r\\n\\s]', san)
            certValues.san.email = tmp || ''
          }

- ¶

  Validity

          if ((tmp = certData.match(/Not Before\s?:\s?([^\r\n]*)\r?\n/)) && tmp.length > 1) {
            validity.start = Date.parse((tmp && tmp[1]) || '')
          }

          if ((tmp = certData.match(/Not After\s?:\s?([^\r\n]*)\r?\n/)) && tmp.length > 1) {
            validity.end = Date.parse((tmp && tmp[1]) || '')
          }

          if (validity.start && validity.end) {
            certValues.validity = validity
          }

- ¶

  Validity end

- ¶

  Signature Algorithm

          if ((tmp = certData.match(/Signature Algorithm: ([^\r\n]*)\r?\n/)) && tmp.length > 1) {
            certValues.signatureAlgorithm = (tmp && tmp[1]) || ''
          }

- ¶

  Public Key

          if ((tmp = certData.match(/Public[ -]Key: ([^\r\n]*)\r?\n/)) && tmp.length > 1) {
            certValues.publicKeySize = ((tmp && tmp[1]) || '').replace(/[()]/g, '')
          }

- ¶

  Public Key Algorithm

          if ((tmp = certData.match(/Public Key Algorithm: ([^\r\n]*)\r?\n/)) && tmp.length > 1) {
            certValues.publicKeyAlgorithm = (tmp && tmp[1]) || ''
          }

          callback(null, certValues)
        } catch (err) {
          callback(err)
        }
      }

      function matchAll (str, regexp) {
        var matches = []
        str.replace(regexp, function () {
          var arr = ([]).slice.call(arguments, 0)
          var extras = arr.splice(-2)
          arr.index = extras[0]
          arr.input = extras[1]
          matches.push(arr)
        })
        return matches.length ? matches : null
      }

      function pregMatchAll (regex, haystack) {
        var globalRegex = new RegExp(regex, 'g')
        var globalMatch = haystack.match(globalRegex) || []
        var matchArray = []
        var nonGlobalRegex, nonGlobalMatch
        for (var i = 0; i < globalMatch.length; i++) {
          nonGlobalRegex = new RegExp(regex)
          nonGlobalMatch = globalMatch[i].match(nonGlobalRegex)
          matchArray.push(nonGlobalMatch[1])
        }
        return matchArray
      }

      function generateCSRSubject (options) {
        options = options || {}

        var csrData = {
          C: options.country || options.C,
          ST: options.state || options.ST,
          L: options.locality || options.L,
          O: options.organization || options.O,
          OU: options.organizationUnit || options.OU,
          CN: options.commonName || options.CN || 'localhost',
          DC: options.dc || options.DC || '',
          emailAddress: options.emailAddress
        }

        var csrBuilder = Object.keys(csrData).map(function (key) {
          if (csrData[key]) {
            if (typeof csrData[key] === 'object' && csrData[key].length >= 1) {
              var tmpStr = ''
              csrData[key].map(function (o) {
                tmpStr += '/' + key + '=' + o.replace(/[^\w .*\-,@']+/g, ' ').trim()
              })
              return tmpStr
            } else {
              return '/' + key + '=' + csrData[key].replace(/[^\w .*\-,@']+/g, ' ').trim()
            }
          }
        })

        return csrBuilder.join('')
      }

      function readFromString (string, start, end) {
        if (Buffer.isBuffer(string)) {
          string = string.toString('utf8')
        }

        var output = []

        if (!string) {
          return output
        }

        var offset = string.indexOf(start)

        while (offset !== -1) {
          string = string.substring(offset)

          var endOffset = string.indexOf(end)

          if (endOffset === -1) {
            break
          }

          endOffset += end.length

          output.push(string.substring(0, endOffset))
          offset = string.indexOf(start, endOffset)
        }

        return output
      }

- ¶

  promisify not tested yet

      /**
       * Verifies the signing chain of the passed certificate
       * @namespace
       * @name promisified
       * @property {function}  createPrivateKey               @see createPrivateKey
       * @property {function}  createDhparam       - The default number of players.
       * @property {function}  createEcparam         - The default level for the party.
       * @property {function}  createCSR      - The default treasure.
       * @property {function}  createCertificate - How much gold the party starts with.
       */
      module.exports.promisified = {
        createPrivateKey: promisify(createPrivateKey),
        createDhparam: promisify(createDhparam),
        createEcparam: promisify(createEcparam),
        createCSR: promisify(createCSR),
        createCertificate: promisify(createCertificate),
        readCertificateInfo: promisify(readCertificateInfo),
        getPublicKey: promisify(getPublicKey),
        getFingerprint: promisify(getFingerprint),
        getModulus: promisify(getModulus),
        getDhparamInfo: promisify(getDhparamInfo),
        createPkcs12: promisify(createPkcs12),
        readPkcs12: promisify(readPkcs12),
        verifySigningChain: promisify(verifySigningChain),
        checkCertificate: promisify(checkCertificate),
        checkPkcs12: promisify(checkPkcs12)
      }