Current Dev State

static/js/ketcher2/node_modules/pem/test/convert.spec.js

@@ -0,0 +1,255 @@
+'use strict'
+
+var pem = require('..')
+var pemHelper = require('../lib/helper.js')
+var fs = require('fs')
+var hlp = require('./pem.helper.js')
+var chai = require('chai')
+var dirtyChai = require('dirty-chai')
+var expect = chai.expect
+chai.use(dirtyChai)
+
+describe('convert.js tests', function () {
+  after(function (done) {
+    var tmpfiles
+    tmpfiles = [
+      './test/fixtures/tmp.der',
+      './test/fixtures/tmp.pem',
+      './test/fixtures/tmp.p7b',
+      './test/fixtures/tmp.pfx'
+    ]
+    pemHelper.deleteTempFiles(tmpfiles, function (fsErr) {
+      hlp.checkError(fsErr)
+      done()
+    })
+  })
+
+  describe('trigger error case', function () {
+    before(function () {
+      pem.config({
+        pathOpenSSL: 'zzzzzzzzzzz'
+      })
+    })
+    it('#.PEM2DER()', function (done) {
+      pem.convert.PEM2DER('./test/fixtures/nopkey.pem', './test/fixtures/tmp.der', function (error, result) {
+        hlp.checkError(error, true)
+        done()
+      })
+    })
+    it('#.DER2PEM()', function (done) {
+      pem.convert.DER2PEM('./test/fixtures/tmp.der', './test/fixtures/tmp.pem', function (error, result) {
+        hlp.checkError(error, true)
+        done()
+      })
+    })
+    it('#.PEM2P7B()', function (done) {
+      pem.convert.PEM2P7B({cert: './test/fixtures/nopkey.pem'}, './test/fixtures/tmp.p7b', function (error, result) {
+        hlp.checkError(error, true)
+        done()
+      })
+    })
+    it('#.P7B2PEM()', function (done) {
+      pem.convert.P7B2PEM('./test/fixtures/tmp.p7b', './test/fixtures/tmp.pem', function (error, result) {
+        hlp.checkError(error, true)
+        done()
+      })
+    })
+    it('#.PEM2PFX()', function (done) {
+      var pathIN = {
+        cert: './test/fixtures/test.crt',
+        key: './test/fixtures/testnopw.key'
+      }
+      // password is required to encrypt the .pfx file; enforced by openssl
+      pem.convert.PEM2PFX(pathIN, './test/fixtures/tmp.pfx', 'password', function (error, result) {
+        hlp.checkError(error, true)
+        done()
+      })
+    })
+    it('#.PFX2PEM()', function (done) {
+      pem.convert.PFX2PEM('./test/fixtures/tmp.pfx', './test/fixtures/tmp.pem', 'password', function (error, result) {
+        hlp.checkError(error, true)
+        done()
+      })
+    })
+    it('#.P7B2PFX() [error in 1st step]', function (done) {
+      pem.convert.P7B2PFX({cert: './test/fixtures/test.p7b', key: './test/fixtures/test.key', ca: './test/fixtures/GeoTrust_Primary_CA.pem'}, './test/fixtures/tmp.pfx', 'password', function (error, result) {
+        hlp.checkError(error, true)
+        done()
+      })
+    })
+    it('#.P7B2PFX() [error in 2nd step]', function (done) {
+      pem.config({
+        pathOpenSSL: process.env.OPENSSL_BIN || 'openssl'
+      })
+      pem.convert.P7B2PFX({cert: './test/fixtures/test.p7b', key: './test/fixtures/test404.key', ca: './test/fixtures/ca404.pem'}, './test/fixtures/tmp.pfx', 'password', function (error, result) {
+        hlp.checkError(error, true)
+        done()
+      })
+    })
+  })
+
+  describe('check all success cases', function () {
+    it('#.PEM2DER() [not providing type]', function (done) {
+      pem.convert.PEM2DER('./test/fixtures/nopkey.pem', './test/fixtures/tmp.der', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.PEM2DER() [providing type]', function (done) {
+      pem.convert.PEM2DER('./test/fixtures/nopkey.pem', './test/fixtures/tmp.der', 'x509', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.DER2PEM() [not providing type]', function (done) {
+      pem.convert.DER2PEM('./test/fixtures/tmp.der', './test/fixtures/tmp.pem', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        var f1 = fs.readFileSync('./test/fixtures/nopkey.pem').toString()
+        var f2 = fs.readFileSync('./test/fixtures/tmp.pem').toString()
+        expect(f1).to.equal(f2)
+        done()
+      })
+    })
+
+    it('#.DER2PEM() [providing type]', function (done) {
+      pem.convert.DER2PEM('./test/fixtures/tmp.der', './test/fixtures/tmp.pem', 'x509', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        var f1 = fs.readFileSync('./test/fixtures/nopkey.pem').toString()
+        var f2 = fs.readFileSync('./test/fixtures/tmp.pem').toString()
+        expect(f1).to.equal(f2)
+        done()
+      })
+    })
+
+    it('#.PEM2P7B() [providing a CA cert; no array format]', function (done) {
+      pem.convert.PEM2P7B({cert: './test/fixtures/nopkey.pem', ca: './test/fixtures/GeoTrust_Primary_CA.pem'}, './test/fixtures/tmp.p7b', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.PEM2P7B() [providing a CA cert; array format]', function (done) {
+      pem.convert.PEM2P7B({cert: './test/fixtures/nopkey.pem', ca: ['./test/fixtures/GeoTrust_Primary_CA.pem']}, './test/fixtures/tmp.p7b', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.PEM2P7B() [not providing a CA cert]', function (done) {
+      pem.convert.PEM2P7B({cert: './test/fixtures/nopkey.pem'}, './test/fixtures/tmp.p7b', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.P7B2PEM()', function (done) {
+      pem.convert.P7B2PEM('./test/fixtures/tmp.p7b', './test/fixtures/tmp.pem', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        var f1 = fs.readFileSync('./test/fixtures/nopkey.pem').toString()
+        var f2 = fs.readFileSync('./test/fixtures/tmp.pem').toString()
+        // can't directly compare as f2 comes with x509v3 header which might not be included in source file
+        pem.readCertificateInfo(f1, function (error, d1) {
+          hlp.checkError(error)
+          pem.readCertificateInfo(f2, function (error, d2) {
+            hlp.checkError(error)
+            expect(d1).to.eql(d2)
+          })
+          done()
+        })
+      })
+    })
+
+    it('#.PEM2PFX() [no password protected key file]', function (done) {
+      var pathIN = {
+        cert: './test/fixtures/test.crt',
+        key: './test/fixtures/testnopw.key'
+      }
+      // password is required to encrypt the .pfx file; enforced by openssl
+      pem.convert.PEM2PFX(pathIN, './test/fixtures/tmp.pfx', 'password', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.PEM2PFX() [password protected key file]', function (done) {
+      var pathIN = {
+        cert: './test/fixtures/test.crt',
+        key: './test/fixtures/test.key'
+      }
+      pem.convert.PEM2PFX(pathIN, './test/fixtures/tmp.pfx', 'password', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.PEM2PFX() [providing CA cert; no array format]', function (done) {
+      var pathIN = {
+        cert: './test/fixtures/test.crt',
+        key: './test/fixtures/test.key',
+        ca: './test/fixtures/GeoTrust_Primary_CA.pem'
+      }
+      pem.convert.PEM2PFX(pathIN, './test/fixtures/tmp.pfx', 'password', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.PEM2PFX() [providing CA cert; array format]', function (done) {
+      var pathIN = {
+        cert: './test/fixtures/test.crt',
+        key: './test/fixtures/test.key',
+        ca: ['./test/fixtures/GeoTrust_Primary_CA.pem']
+      }
+      pem.convert.PEM2PFX(pathIN, './test/fixtures/tmp.pfx', 'password', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.PFX2PEM()', function (done) {
+      pem.convert.PFX2PEM('./test/fixtures/tmp.pfx', './test/fixtures/tmp.pem', 'password', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.P7B2PFX() [providing ca cert; no array format]', function (done) {
+      pem.convert.P7B2PFX({cert: './test/fixtures/test.p7b', key: './test/fixtures/test.key', ca: './test/fixtures/GeoTrust_Primary_CA.pem'}, './test/fixtures/tmp.pfx', 'password', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.P7B2PFX() [providing ca cert; array format]', function (done) {
+      pem.convert.P7B2PFX({cert: './test/fixtures/test.p7b', key: './test/fixtures/test.key', ca: ['./test/fixtures/GeoTrust_Primary_CA.pem']}, './test/fixtures/tmp.pfx', 'password', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+
+    it('#.P7B2PFX() [not providing ca cert]', function (done) {
+      pem.convert.P7B2PFX({cert: './test/fixtures/test.p7b', key: './test/fixtures/test.key'}, './test/fixtures/tmp.pfx', 'password', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.true()
+        done()
+      })
+    })
+  })
+})

static/js/ketcher2/node_modules/pem/test/fixtures/GeoTrust_Primary_CA.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDfDCCAmSgAwIBAgIQGKy1av1pthU6Y2yv2vrEoTANBgkqhkiG9w0BAQUFADBY
+MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjExMC8GA1UEAxMo
+R2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEx
+MjcwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMFgxCzAJBgNVBAYTAlVTMRYwFAYDVQQK
+Ew1HZW9UcnVzdCBJbmMuMTEwLwYDVQQDEyhHZW9UcnVzdCBQcmltYXJ5IENlcnRp
+ZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
+AQEAvrgVe//UfH1nrYNke8hCUy3f9oQIIGHWAVlqnEQRr+92/ZV+zmEwu3qDXwK9
+AWbK7hWNb6EwnL2hhZ6UOvNWiAAxz9juapYC2e0DjPt1befquFUWBRaa9OBesYjA
+ZIVcFU2Ix7e64HXprQU9nceJSOC7KMgD4TCTZF5SwFlwIjVXiIrxlQqD17wxcwE0
+7e9GceBrAqg1cmuXm2bgyxx5X9gaBGgeRwLmnWDiNpcB3841kt++Z8dtd1k7j53W
+kBWUvEI0EME5+bEnPn7WinXFsq+W06Lem+SYvn3h6YGttm/81w7a4DSwDRp35+MI
+mO9Y+pyEtzavwt+s0vQQBnBxNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G
+A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQULNVQQZcVi/CPNmFbSvtr2ZnJM5IwDQYJ
+KoZIhvcNAQEFBQADggEBAFpwfyzdtzRP9YZRqSa+S7iq8XEN3GHHoOo0Hnp3DwQ1
+6CePbJC/kRYkRj5KTs4rFtULUh38H2eiAkUxT87z+gOneZ1TatnaYzr4gNfTmeGl
+4b7UVXGYNTq+k+qurUKykG/g/CFNNWMziUnWm07Kx+dOCQD32sfvmWKZd7aVIl6K
+oKv0uHiYyjgZmclynnjNS6yvGaBzEi38wkG6gZHaFloxt/m0cYASSJlyc1pZU8Fj
+UjPtp8nSOQJw+uCxQmYpqptR7TBUIhRf2asdweSU8Pj1K/fqynhG1riR/aYNKxoU
+AT6A8EKglQdebc3MS6RFjasS6LPeWuWgfOgPIh1a6Vk=
+-----END CERTIFICATE-----

static/js/ketcher2/node_modules/pem/test/fixtures/google.com.pem

@@ -0,0 +1,68 @@
+-----BEGIN CERTIFICATE-----
+MIIDwjCCAqqgAwIBAgIIMPfmgdxQ04QwDQYJKoZIhvcNAQELBQAwSTELMAkGA1UE
+BhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMTHEdvb2dsZSBJbnRl
+cm5ldCBBdXRob3JpdHkgRzIwHhcNMTcwOTI2MTA1OTAwWhcNMTcxMjE5MTA1OTAw
+WjBoMQswCQYDVQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwN
+TW91bnRhaW4gVmlldzETMBEGA1UECgwKR29vZ2xlIEluYzEXMBUGA1UEAwwOd3d3
+Lmdvb2dsZS5jb20wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAQptqSsDzHdgCpE
+2bLsaN1aKT/np0r/I2bQ2QZueQvOWKwaJD5Kt6s6HE1LUZ/omxTwacgT7HDWmj8f
+bhMEZ45No4IBWDCCAVQwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMAsG
+A1UdDwQEAwIHgDAZBgNVHREEEjAQgg53d3cuZ29vZ2xlLmNvbTBoBggrBgEFBQcB
+AQRcMFowKwYIKwYBBQUHMAKGH2h0dHA6Ly9wa2kuZ29vZ2xlLmNvbS9HSUFHMi5j
+cnQwKwYIKwYBBQUHMAGGH2h0dHA6Ly9jbGllbnRzMS5nb29nbGUuY29tL29jc3Aw
+HQYDVR0OBBYEFD1fAbfuUfW5VEUWBvJeq8hsdnzlMAwGA1UdEwEB/wQCMAAwHwYD
+VR0jBBgwFoAUSt0GFhu89mi1dvWBtrtiGrpagS8wIQYDVR0gBBowGDAMBgorBgEE
+AdZ5AgUBMAgGBmeBDAECAjAwBgNVHR8EKTAnMCWgI6Ahhh9odHRwOi8vcGtpLmdv
+b2dsZS5jb20vR0lBRzIuY3JsMA0GCSqGSIb3DQEBCwUAA4IBAQBEd6FLPzPDnVVS
+HLBtKfb5Gv3rkLku4wy13QORTK1yU+c2cbWCiVXyU8rXUqWLeFfjNw5Z6/2vvNRF
+SQ2G/isM+GdT42UI0cPxYV+oLfxcQU9pu2FnsIaq1mSu0ckIe7gFSXRnUZWOHMur
+WkSP+4EwUZlXgK/h06fy3Ran1NmBglwWGF3MXAGgNeFeKSRtszn8pClOaWOmjNt8
+pzp6KfJIaZV0y1ss1I8x1XnR7EFbG+9vPQpsB2xhEPqyC78QoazaCS3y9AyFrpzb
+Ig2jZRLdtq9bLhsEb1jSM3qIECCiPu0AwNLU+508PVyYXlvRTfwMVo1PfllWhiMP
+Ub8Y7gCe
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIEKDCCAxCgAwIBAgIQAQAhJYiw+lmnd+8Fe2Yn3zANBgkqhkiG9w0BAQsFADBC
+MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMS
+R2VvVHJ1c3QgR2xvYmFsIENBMB4XDTE3MDUyMjExMzIzN1oXDTE4MTIzMTIzNTk1
+OVowSTELMAkGA1UEBhMCVVMxEzARBgNVBAoTCkdvb2dsZSBJbmMxJTAjBgNVBAMT
+HEdvb2dsZSBJbnRlcm5ldCBBdXRob3JpdHkgRzIwggEiMA0GCSqGSIb3DQEBAQUA
+A4IBDwAwggEKAoIBAQCcKgR3XNhQkToGo4Lg2FBIvIk/8RlwGohGfuCPxfGJziHu
+Wv5hDbcyRImgdAtTT1WkzoJile7rWV/G4QWAEsRelD+8W0g49FP3JOb7kekVxM/0
+Uw30SvyfVN59vqBrb4fA0FAfKDADQNoIc1Fsf/86PKc3Bo69SxEE630k3ub5/DFx
++5TVYPMuSq9C0svqxGoassxT3RVLix/IGWEfzZ2oPmMrhDVpZYTIGcVGIvhTlb7j
+gEoQxirsupcgEcc5mRAEoPBhepUljE5SdeK27QjKFPzOImqzTs9GA5eXA37Asd57
+r0Uzz7o+cbfe9CUlwg01iZ2d+w4ReYkeN8WvjnJpAgMBAAGjggERMIIBDTAfBgNV
+HSMEGDAWgBTAephojYn7qwVkDBF9qn1luMrMTjAdBgNVHQ4EFgQUSt0GFhu89mi1
+dvWBtrtiGrpagS8wDgYDVR0PAQH/BAQDAgEGMC4GCCsGAQUFBwEBBCIwIDAeBggr
+BgEFBQcwAYYSaHR0cDovL2cuc3ltY2QuY29tMBIGA1UdEwEB/wQIMAYBAf8CAQAw
+NQYDVR0fBC4wLDAqoCigJoYkaHR0cDovL2cuc3ltY2IuY29tL2NybHMvZ3RnbG9i
+YWwuY3JsMCEGA1UdIAQaMBgwDAYKKwYBBAHWeQIFATAIBgZngQwBAgIwHQYDVR0l
+BBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMA0GCSqGSIb3DQEBCwUAA4IBAQDKSeWs
+12Rkd1u+cfrP9B4jx5ppY1Rf60zWGSgjZGaOHMeHgGRfBIsmr5jfCnC8vBk97nsz
+qX+99AXUcLsFJnnqmseYuQcZZTTMPOk/xQH6bwx+23pwXEz+LQDwyr4tjrSogPsB
+E4jLnD/lu3fKOmc2887VJwJyQ6C9bgLxRwVxPgFZ6RGeGvOED4Cmong1L7bHon8X
+fOGLVq7uZ4hRJzBgpWJSwzfVO+qFKgE4h6LPcK2kesnE58rF2rwjMvL+GMJ74N87
+L9TQEOaWTPtEtyFkDbkAlDASJodYmDkFOA/MgkgMCkdm7r+0X8T/cKjhf4t5K7hl
+MqO5tzHpCvX2HzLc
+-----END CERTIFICATE-----
+-----BEGIN CERTIFICATE-----
+MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT
+MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i
+YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG
+EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg
+R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9
+9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq
+fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv
+iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU
+1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+
+bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW
+MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA
+ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l
+uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn
+Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS
+tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF
+PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un
+hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV
+5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw==
+-----END CERTIFICATE-----

static/js/ketcher2/node_modules/pem/test/fixtures/inclpkey.pem

@@ -0,0 +1,86 @@
+-----BEGIN RSA PRIVATE KEY-----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=
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----

static/js/ketcher2/node_modules/pem/test/fixtures/nopkey.pem

@@ -0,0 +1,23 @@
+-----BEGIN CERTIFICATE-----
+MIIDwTCCAyqgAwIBAgICDh4wDQYJKoZIhvcNAQEFBQAwgZsxCzAJBgNVBAYTAkpQ
+MQ4wDAYDVQQIEwVUb2t5bzEQMA4GA1UEBxMHQ2h1by1rdTERMA8GA1UEChMIRnJh
+bms0REQxGDAWBgNVBAsTD1dlYkNlcnQgU3VwcG9ydDEYMBYGA1UEAxMPRnJhbms0
+REQgV2ViIENBMSMwIQYJKoZIhvcNAQkBFhRzdXBwb3J0QGZyYW5rNGRkLmNvbTAi
+GA8wMDAwMDEwMTAwMDAwMVoYDzk5OTkxMjMxMjM1OTU5WjCBgTELMAkGA1UEBhMC
+SlAxDjAMBgNVBAgTBVRva3lvMREwDwYDVQQKEwhGcmFuazRERDEQMA4GA1UECxMH
+U3VwcG9ydDEiMCAGCSqGSIb3DQEJARYTcHVibGljQGZyYW5rNGRkLmNvbTEZMBcG
+A1UEAxMQd3d3LmZyYW5rNGRkLmNvbTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkC
+gYEA4rkBL30FzR2ZHZ1vpF9kGBO0DMwhu2pcrkcLJ0SEuf52ggo+md0tPis8f1KN
+Tchxj6DtxWT3c7ECW0c1ALpu6mNVE+GaM94KsckSDehoPfbLjT9Apcc/F0mqvDsC
+N6fPdDixWrjx6xKT7xXi3lCy1yIKRMHA6Ha+T4qPyyCyMPECAwEAAaOCASYwggEi
+MAwGA1UdEwEB/wQCMAAwCwYDVR0PBAQDAgWgMB0GA1UdDgQWBBRWKE5tXPIyS0pC
+fE5taGO5Q84gyTCB0AYDVR0jBIHIMIHFgBRi83vtBtSx1Zx/SOXvxckVYf3ZEaGB
+oaSBnjCBmzELMAkGA1UEBhMCSlAxDjAMBgNVBAgTBVRva3lvMRAwDgYDVQQHEwdD
+aHVvLWt1MREwDwYDVQQKEwhGcmFuazRERDEYMBYGA1UECxMPV2ViQ2VydCBTdXBw
+b3J0MRgwFgYDVQQDEw9GcmFuazRERCBXZWIgQ0ExIzAhBgkqhkiG9w0BCQEWFHN1
+cHBvcnRAZnJhbms0ZGQuY29tggkAxscECbwiW6AwEwYDVR0lBAwwCgYIKwYBBQUH
+AwEwDQYJKoZIhvcNAQEFBQADgYEAfXCfXcePJwnMKc06qLa336cEPpXEsPed1bw4
+xiIXfgZ39duBnN+Nv4a49Yl2kbh4JO8tcr5h8WYAI/a/69w8qBFQBUAjTEY/+lcw
+9/6wU7UA3kh7yexeqDiNTRflnPUv3sfiVdLDTjqLWWAxGS8L26PjVaCUFfJLNiYJ
+jerREgM=
+-----END CERTIFICATE-----

static/js/ketcher2/node_modules/pem/test/fixtures/test.cnf

@@ -0,0 +1,26 @@
+[ req ]
+default_bits           = 4096
+days                   = 9999
+distinguished_name     = req_distinguished_name
+attributes             = req_attributes
+prompt                 = no
+x509_extensions        = v3_ca
+
+[ req_distinguished_name ]
+C                      = EE
+ST                     = Harjumaa
+L                      = Tallinn
+O                      = Node.ee
+OU                     = test
+CN                     = www.node.ee
+emailAddress           = andris@node.ee
+
+[ req_attributes ]
+challengePassword      = challengePass
+
+[ v3_ca ]
+authorityInfoAccess = @issuer_info
+
+[ issuer_info ]
+OCSP;URI.0 = http://ocsp.node.ee/
+caIssuers;URI.0 = http://node.ee/ca.cert

static/js/ketcher2/node_modules/pem/test/fixtures/test.crt

@@ -0,0 +1,16 @@
+-----BEGIN CERTIFICATE-----
+MIIChTCCAe4CCQDbGP0P9s69azANBgkqhkiG9w0BAQsFADCBhjELMAkGA1UEBhMC
+WlcxGzAZBgNVBAgMEk1hdGViZWxlbGFuZCBOb3J0aDERMA8GA1UEBwwIQnVsYXdh
+eW8xDDAKBgNVBAoMA0J5bzELMAkGA1UECwwCSVQxDzANBgNVBAMMBmJ5by56dzEb
+MBkGCSqGSIb3DQEJARYMYWRtaW5AYnlvLnp3MB4XDTE1MDQxMDA5NTM1OVoXDTE2
+MDQwOTA5NTM1OVowgYYxCzAJBgNVBAYTAlpXMRswGQYDVQQIDBJNYXRlYmVsZWxh
+bmQgTm9ydGgxETAPBgNVBAcMCEJ1bGF3YXlvMQwwCgYDVQQKDANCeW8xCzAJBgNV
+BAsMAklUMQ8wDQYDVQQDDAZieW8uencxGzAZBgkqhkiG9w0BCQEWDGFkbWluQGJ5
+by56dzCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0q4cDxLRslRKvG2pw5Gx
+7fsq7YyiTokoBaDavNold5Vvayi02Mc7dqIanr/ckc0AqgiDd5Kw2bBAYmQpWiDn
+pZxp79JIV+gGh7pkiB4wDzvRBXMcew72B9uuYEeUQ8eonE/Yro0ZnD0ZGmBiuk/6
+5xyWNikBhfPLnb2V+Cr/EKsCAwEAATANBgkqhkiG9w0BAQsFAAOBgQAwigr+o+Y+
+5BiL6MuHLTaC+lcv9r2GTHb7wNea674Db3Bi3u6FgmyMsZ8npPSlR0t/YZcFWtRM
+y4uXmw5zUutGZTbO/JFxts6kPV+a76mnNm71fF4QINkemmojvJyPZq9N+hV16dba
+v1m+dTK7hDZvpd/sM5bMtqWEq4aHkGhujw==
+-----END CERTIFICATE-----

static/js/ketcher2/node_modules/pem/test/fixtures/test.csr

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE REQUEST-----
+MIIB3jCCAUcCAQAwgYYxCzAJBgNVBAYTAlpXMRswGQYDVQQIDBJNYXRlYmVsZWxh
+bmQgTm9ydGgxETAPBgNVBAcMCEJ1bGF3YXlvMQwwCgYDVQQKDANCeW8xCzAJBgNV
+BAsMAklUMQ8wDQYDVQQDDAZieW8uencxGzAZBgkqhkiG9w0BCQEWDGFkbWluQGJ5
+by56dzCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0q4cDxLRslRKvG2pw5Gx
+7fsq7YyiTokoBaDavNold5Vvayi02Mc7dqIanr/ckc0AqgiDd5Kw2bBAYmQpWiDn
+pZxp79JIV+gGh7pkiB4wDzvRBXMcew72B9uuYEeUQ8eonE/Yro0ZnD0ZGmBiuk/6
+5xyWNikBhfPLnb2V+Cr/EKsCAwEAAaAXMBUGCSqGSIb3DQEJAjEIDAZCeW8gQ28w
+DQYJKoZIhvcNAQELBQADgYEAxP+4Z2POlTlCBYpGhhKpTBbRDeAQakXqGBlB7ZC2
+0K4fSxuAGVArLV5rbPDHlzNCtmF8mvt55F7zVny4YQ8BHE7ujV3SWtiAr0Otq9VV
+WG5LmBLAbyrrUZloHJEpX0wPgQDmMdLhkDkbcjcKOT6WKNW5q36MW+Q9nViStGD5
+lJg=
+-----END CERTIFICATE REQUEST-----

static/js/ketcher2/node_modules/pem/test/fixtures/test.dh

@@ -0,0 +1,5 @@
+-----BEGIN DH PARAMETERS-----
+MIGHAoGBAMYXwgiuPY6TqxODWXbRRWx6eWoJuGkjKN8RjhBiLxFJzwgpdfONv5iG
+IHHGI8/IfhHI78Mqq+5z3z8L16fuOYnpbaDa2BSUdHZQQmFiCV748lOv9he08UJ5
+qgrFgdgi56V4FdRs2EHJnezvYmviAbIsi8imn+9TVed4DnOmuE1rAgEC
+-----END DH PARAMETERS-----

static/js/ketcher2/node_modules/pem/test/fixtures/test.key

@@ -0,0 +1,18 @@
+-----BEGIN RSA PRIVATE KEY-----
+Proc-Type: 4,ENCRYPTED
+DEK-Info: DES-EDE3-CBC,8D7649F2550A3AD6
+
+iD68IbbRZDJuiYBqiEMLSfQQqcbXr4CeHFVkAYxCKN785tg+icShBeYXP2H2Oa7m
+dmFBNrtuPclUjk1VFeDcRhd1WwabuSbKJkV26bqIwYKSa1blDcgviSvIc8OgN06G
+K7kX+3jQzUMeSj+B1phyysCSoSU059oJvcNknBOEe67ersYZhXWFDOxVOeCnpsVA
+xDPRGVWa5g5jj0WqcXey/oC/hUccX8w8RZJLSBurIxfWBGy1QtsnopNRaxs5gqXj
+FCucQtYTMwRzA0c65/6yDrYrnv3v0mmCKBKXoTvhcmxkE/Ejrk0+ydxlgWXoMjOD
+CzuDy8xQ2KN2/62fb0Eb6LwnI3EHceXAO9GbgpCTXDZt0yoKMBDZFYA1+TuYBXJj
+RRcKDcF+gt1VdloSkAWIaDwypnPi0xngsJbzNIHKoSKYPuxWdUXB5rThbSdPki5x
+r8La88LBK6/WarJevce8Ggg/KCAx5ng/w9XzQDlMSNVT6Ht+gGe6+69XjBA5IyIo
+bymu9PlwRMMYEeEcH53tGXcCgSkzlDs2Cc+1+JUypZpX4oggNV5YhsmLZS5BtPFs
+9i3lA7RsxXoV0u1BTgHIqrH58IKaXN9xs0ceie3cLR5tcSiSsU9sh3wpjZ2AZ/Q5
+zjoHuyzQVxY14qlE3uWzI9vJtc/kCkQ4D8wdBRVM8uRzf+YGYKRbI6vvsSICeLuW
+n82E2zin77HnIOGVHPJ5aNaTQD91Ubxxv7lVeuxZf2tgejs2DbJraKOtOmHLd9GA
+Zb5G9TdFMxVcXq18xUMm/Rbkj8ugALxRy8CGNSrTFTPHaEwYxqhnAQ==
+-----END RSA PRIVATE KEY-----

static/js/ketcher2/node_modules/pem/test/fixtures/test.p7b

@@ -0,0 +1,17 @@
+-----BEGIN PKCS7-----
+MIICtgYJKoZIhvcNAQcCoIICpzCCAqMCAQExADALBgkqhkiG9w0BBwGgggKJMIIC
+hTCCAe4CCQDbGP0P9s69azANBgkqhkiG9w0BAQsFADCBhjELMAkGA1UEBhMCWlcx
+GzAZBgNVBAgMEk1hdGViZWxlbGFuZCBOb3J0aDERMA8GA1UEBwwIQnVsYXdheW8x
+DDAKBgNVBAoMA0J5bzELMAkGA1UECwwCSVQxDzANBgNVBAMMBmJ5by56dzEbMBkG
+CSqGSIb3DQEJARYMYWRtaW5AYnlvLnp3MB4XDTE1MDQxMDA5NTM1OVoXDTE2MDQw
+OTA5NTM1OVowgYYxCzAJBgNVBAYTAlpXMRswGQYDVQQIDBJNYXRlYmVsZWxhbmQg
+Tm9ydGgxETAPBgNVBAcMCEJ1bGF3YXlvMQwwCgYDVQQKDANCeW8xCzAJBgNVBAsM
+AklUMQ8wDQYDVQQDDAZieW8uencxGzAZBgkqhkiG9w0BCQEWDGFkbWluQGJ5by56
+dzCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0q4cDxLRslRKvG2pw5Gx7fsq
+7YyiTokoBaDavNold5Vvayi02Mc7dqIanr/ckc0AqgiDd5Kw2bBAYmQpWiDnpZxp
+79JIV+gGh7pkiB4wDzvRBXMcew72B9uuYEeUQ8eonE/Yro0ZnD0ZGmBiuk/65xyW
+NikBhfPLnb2V+Cr/EKsCAwEAATANBgkqhkiG9w0BAQsFAAOBgQAwigr+o+Y+5BiL
+6MuHLTaC+lcv9r2GTHb7wNea674Db3Bi3u6FgmyMsZ8npPSlR0t/YZcFWtRMy4uX
+mw5zUutGZTbO/JFxts6kPV+a76mnNm71fF4QINkemmojvJyPZq9N+hV16dbav1m+
+dTK7hDZvpd/sM5bMtqWEq4aHkGhuj6EAMQA=
+-----END PKCS7-----

static/js/ketcher2/node_modules/pem/test/fixtures/testnopw.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXQIBAAKBgQDSrhwPEtGyVEq8banDkbHt+yrtjKJOiSgFoNq82iV3lW9rKLTY
+xzt2ohqev9yRzQCqCIN3krDZsEBiZClaIOelnGnv0khX6AaHumSIHjAPO9EFcxx7
+DvYH265gR5RDx6icT9iujRmcPRkaYGK6T/rnHJY2KQGF88udvZX4Kv8QqwIDAQAB
+AoGALuEtPzFp1eupwaoJR4pI9HKaR8euahlc/XugkLtd8PEgnNCvBTm4Aprpn3+D
+3jGmvy8rydSrY5UzjnFJPlPqF2kWkQaBFtqBJpQFjCPDbQ3nwVoaEN7X/lz3v91M
+BdoMT36CPvzDwtdrA3U16Jd1JOV09DxP/7jAuvrP3zvuoOkCQQD/eXu/UL++xUb8
+BH4hkookSWrRJHIsRw5gktMoo2tGhe0AXVDh+3Eg8KNfvy2T/PqI7z/pn3QTcjn6
+hJlG7ujVAkEA0x0KUstDNB8FEn64xfmmbCWJ/kyYm3dtiR1ByvqNBJ4Dt3IAIwnP
+1ww9NWJfZta34nUzI97rDLyvBubaN0rTfwJBAM1kDOIt+EpWbpBUyFcTai5sPA1y
+4LvKULvBrzQ/1hI3v+gIHevg6/3QmXhzyh/tRjrrJpYb1QWBUy2eh2Bo2RUCQQCl
+hPROG62yFMwORyqpleXkjr4VkopoAgfwY+7srOqZfyZc0tXGou/ApIjs7Rbtc1Wz
+CL6y1hkl4F2+JItcpJ8TAkBUGA1T46IMHtQ4D7HaemPup+ve7gwYx2c1EDlLYAc/
+M9y+va/N+2k6DAMHUNIRktmgYsA5inGT/QCftLql4v+5
+-----END RSA PRIVATE KEY-----

static/js/ketcher2/node_modules/pem/test/helper.spec.js

@@ -0,0 +1,77 @@
+'use strict'
+
+var fs = require('fs')
+var helper = require('../lib/helper.js')
+var hlp = require('./pem.helper.js')
+var chai = require('chai')
+var dirtyChai = require('dirty-chai')
+chai.use(dirtyChai)
+
+// NOTE: we cover here only the test cases left in coverage report
+describe('helper.js tests', function () {
+  describe('#.createPasswordFile()', function () {
+    it('invalid options [not sufficient object keys]', function (done) {
+      var tmpfiles = []
+      var bufferOrPath = fs.readFileSync('./test/fixtures/idsrv3test.pfx')
+      helper.createPasswordFile(
+        {},
+        ['pkcs12', '-info', '-in', bufferOrPath, '-noout', '-maciter', '-nodes'],
+        tmpfiles[tmpfiles.length]
+      )
+      helper.deleteTempFiles(tmpfiles, function (fsErr) {
+        hlp.checkError(fsErr)
+        done()
+      })
+    })
+    it('invalid options [no password and passType option]', function (done) {
+      var tmpfiles = []
+      var bufferOrPath = fs.readFileSync('./test/fixtures/idsrv3test.pfx')
+      helper.createPasswordFile(
+        {cipher: '', bla: true, blub: true},
+        ['pkcs12', '-info', '-in', bufferOrPath, '-noout', '-maciter', '-nodes'],
+        tmpfiles[tmpfiles.length]
+      )
+      helper.deleteTempFiles(tmpfiles, function (fsErr) {
+        hlp.checkError(fsErr)
+        done()
+      })
+    })
+    it('mustPass option', function (done) {
+      var tmpfiles = []
+      var bufferOrPath = fs.readFileSync('./test/fixtures/idsrv3test.pfx')
+      helper.createPasswordFile(
+        {cipher: '', password: 'gregegegeg', passType: 'in', mustPass: 'password'},
+        ['pkcs12', '-info', '-in', bufferOrPath, '-noout', '-maciter', '-nodes'],
+        tmpfiles[tmpfiles.length]
+      )
+      helper.deleteTempFiles(tmpfiles, function (fsErr) {
+        hlp.checkError(fsErr)
+        done()
+      })
+    })
+  })
+
+  describe('#.deleteTempFiles()', function () {
+    it('files argument typeof string', function (done) {
+      helper.deleteTempFiles('404.pem', function (fsErr) {
+        hlp.checkError(fsErr)
+        done()
+      })
+    })
+    it('files argument invalid type', function (done) {
+      helper.deleteTempFiles(true, function (fsErr) {
+        hlp.checkError(fsErr, true)
+        done()
+      })
+    })
+    it('files argument array contains non-string value', function (done) {
+      helper.deleteTempFiles([true], function (fsErr) {
+        hlp.checkError(fsErr)
+        done()
+      })
+    })
+    it.skip('other error than ENOENT occured', function (done) {
+      // TODO
+    })
+  })
+})

static/js/ketcher2/node_modules/pem/test/openssl.spec.js

@@ -0,0 +1,47 @@
+'use strict'
+
+var openssl = require('../lib/openssl.js')
+var hlp = require('./pem.helper.js')
+var chai = require('chai')
+var dirtyChai = require('dirty-chai')
+var expect = chai.expect
+chai.use(dirtyChai)
+
+// NOTE: we cover here only the test cases left in coverage report
+describe('openssl.js tests', function () {
+  describe('#.exec()', function () {
+    it('search string not found', function (done) {
+      openssl.exec([
+        'dhparam',
+        '-outform',
+        'PEM',
+        128
+      ], 'DH PARAMETERS 404', function (error) {
+        hlp.checkError(error, true)
+        done()
+      })
+    })
+  })
+
+  describe('#.execBinary()', function () {
+    it('no tmpfiles parameter', function (done) {
+      openssl.execBinary([
+        'dhparam',
+        '-outform',
+        'PEM',
+        128
+      ], function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.ok()
+        done()
+      })
+    })
+  })
+
+  describe('#.spawn()', function () {
+    it.skip('error case [openssl return code 2]', function (done) {
+      // TODO; couldn't figure an example out
+    })
+    // TODO; I expect some more cases in here or code cleanup required
+  })
+})

static/js/ketcher2/node_modules/pem/test/pem.helper.js

@@ -0,0 +1,122 @@
+'use strict'
+
+var fs = require('fs')
+var chai = require('chai')
+var dirtyChai = require('dirty-chai')
+var expect = chai.expect
+chai.use(dirtyChai)
+
+process.env.PEMJS_TMPDIR = './tmp'
+
+if (process.env.TRAVIS === 'true' && process.env.OPENSSL_DIR !== '') {
+  process.env.OPENSSL_BIN = '/openssl/bin/openssl'
+}
+
+function checkTmpEmpty () {
+  expect(fs.readdirSync(process.env.PEMJS_TMPDIR)).to.be.empty()
+}
+
+function checkError (error, expectError) {
+  if (expectError) {
+    expect(error).to.be.ok()
+    if (expectError !== true) { // object
+      Object.keys(expectError).forEach(function (k) {
+        expect(error[k]).to.equal(expectError[k]) // code, message, ...
+      })
+    }
+  } else { expect(error).to.not.be.ok() }
+}
+
+function checkEcparam (data, min, max) {
+  expect(data).to.be.an('object').that.has.property('ecparam')
+  expect(data.ecparam).to.be.a('string')
+  expect(/^\r?\n*-----BEGIN EC PARAMETERS-----\r?\n/.test(data.ecparam)).to.be.true()
+  expect(/\r?\n-----END EC PARAMETERS-----\r?\n/.test(data.ecparam)).to.be.true()
+  expect(/\r?\n-----BEGIN EC PRIVATE KEY-----\r?\n/.test(data.ecparam)).to.be.true()
+  expect(/\r?\n-----END EC PRIVATE KEY-----\r?\n*$/.test(data.ecparam)).to.be.true()
+  var matchup = /-----BEGIN EC PRIVATE KEY-----[\s\S]+-----END EC PRIVATE KEY-----/.exec(data.ecparam)
+  expect(matchup[0].trim().length).to.be.within(min + 1, max - 1)
+}
+
+function checkDhparam (data, min, max) {
+  expect(data).to.be.an('object').that.has.property('dhparam')
+  expect(data.dhparam).to.be.a('string')
+  expect(/^\r?\n*-----BEGIN DH PARAMETERS-----\r?\n/.test(data.dhparam)).to.be.true()
+  expect(/\r?\n-----END DH PARAMETERS-----\r?\n*$/.test(data.dhparam)).to.be.true()
+  expect(data.dhparam.trim().length).to.be.within(min + 1, max - 1)
+}
+
+function checkPrivateKey (data, min, max, encrypted) {
+  expect(data).to.be.an('object').that.has.property('key')
+  expect(data.key).to.be.a('string')
+  if (encrypted) { expect(/ENCRYPTED\r?\n/.test(data.key)).to.be.true() }
+  expect(/^\r?\n*-----BEGIN RSA PRIVATE KEY-----\r?\n/.test(data.key)).to.be.true()
+  expect(/\r?\n-----END RSA PRIVATE KEY-----\r?\n*$/.test(data.key)).to.be.true()
+  expect(data.key.trim().length).to.be.within(min + 1, max - 1)
+}
+
+function checkCSR (data, expectClientKey) {
+  expect(data).to.be.an('object');
+  ['clientKey', 'csr'].forEach(function (k) {
+    expect(data).to.have.property(k)
+    expect(data[k]).to.be.a('string')
+  })
+  if (expectClientKey) { expect(data.clientKey).to.equal(expectClientKey) }
+  expect(/^\r?\n*-----BEGIN CERTIFICATE REQUEST-----\r?\n/.test(data.csr)).to.be.true()
+  expect(/\r?\n-----END CERTIFICATE REQUEST-----\r?\n*$/.test(data.csr)).to.be.true()
+}
+
+function checkCertificate (data, selfsigned) {
+  expect(data).to.be.an('object');
+  ['certificate', 'clientKey', 'serviceKey', 'csr'].forEach(function (k) {
+    expect(data).to.have.property(k)
+    expect(data[k]).to.be.a('string')
+  })
+  expect(/^\r?\n*-----BEGIN CERTIFICATE-----\r?\n/.test(data.certificate)).to.be.true()
+  expect(/\r?\n-----END CERTIFICATE-----\r?\n*$/.test(data.certificate)).to.be.true()
+  if (selfsigned) { expect(data.clientKey).to.equal(data.serviceKey) } else { expect(data.clientKey).to.not.equal(data.serviceKey) }
+}
+
+function checkCertificateData (data, info) {
+  expect(data).to.deep.equal(info)
+}
+
+function checkPublicKey (data) {
+  expect(data).to.be.an('object').that.has.property('publicKey')
+  expect(data.publicKey).to.be.a('string')
+  expect(/^\r?\n*-----BEGIN PUBLIC KEY-----\r?\n/.test(data.publicKey)).to.be.true()
+  expect(/\r?\n-----END PUBLIC KEY-----\r?\n*$/.test(data.publicKey)).to.be.true()
+}
+
+function checkFingerprint (data) {
+  expect(data).to.be.an('object').that.has.property('fingerprint')
+  expect(data.fingerprint).to.be.a('string')
+  expect(/^[0-9A-F]{2}(:[0-9A-F]{2}){19}$/.test(data.fingerprint)).to.be.true()
+}
+
+function checkModulus (data, encryptAlgorithm) {
+  expect(data).to.be.an('object').that.has.property('modulus')
+  expect(data.modulus).to.be.a('string')
+  switch (encryptAlgorithm) {
+    case 'md5':
+      expect(/^[a-f0-9]{32}$/i.test(data.modulus)).to.be.true()
+      break
+    default:
+      expect(/^[0-9A-F]*$/.test(data.modulus)).to.be.true()
+      break
+  }
+}
+
+module.exports = {
+  checkTmpEmpty: checkTmpEmpty,
+  checkError: checkError,
+  checkDhparam: checkDhparam,
+  checkEcparam: checkEcparam,
+  checkPrivateKey: checkPrivateKey,
+  checkCSR: checkCSR,
+  checkCertificate: checkCertificate,
+  checkCertificateData: checkCertificateData,
+  checkPublicKey: checkPublicKey,
+  checkFingerprint: checkFingerprint,
+  checkModulus: checkModulus
+}

static/js/ketcher2/node_modules/pem/test/pem.spec.js

@@ -0,0 +1,800 @@
+'use strict'
+
+var pem = require('..')
+var fs = require('fs')
+var hlp = require('./pem.helper.js')
+var chai = require('chai')
+var dirtyChai = require('dirty-chai')
+var expect = chai.expect
+chai.use(dirtyChai)
+
+describe('General Tests', function () {
+  this.timeout(300000)// 5 minutes
+  this.slow(2000)// 2 seconds
+
+  describe('Requirements', function () {
+    it('Create tmp folder', function () {
+      expect(function () {
+        if (!fs.existsSync(process.env.PEMJS_TMPDIR)) {
+          fs.mkdirSync(process.env.PEMJS_TMPDIR)
+        }
+      }).to.not.throw()
+    })
+
+    it('Return an error if openssl was not found', function (done) {
+      pem.config({
+        pathOpenSSL: 'zzzzzzzzzzz'
+      })
+      pem.createPrivateKey(function (error) {
+        hlp.checkError(error, true)
+        pem.config({
+          pathOpenSSL: process.env.OPENSSL_BIN || 'openssl'
+        })
+        pem.createPrivateKey(function (error) {
+          hlp.checkError(error)
+          done()
+        })
+      })
+    })
+  })
+
+  describe('#.createDhparam tests', function () {
+    it('Create default sized dhparam key', function (done) {
+      pem.createDhparam(function (error, data) {
+        hlp.checkError(error)
+        hlp.checkDhparam(data, 150, 160)
+        hlp.checkTmpEmpty()
+        done()
+      })
+    })
+    it('Create 1024bit dhparam key', function (done) {
+      this.timeout(600000)// 10 minutes
+      pem.createDhparam(1024, function (error, data) {
+        hlp.checkError(error)
+        hlp.checkDhparam(data, 240, 250)
+        hlp.checkTmpEmpty()
+        done()
+      })
+    })
+  })
+
+  describe('#.createEcparam tests', function () {
+    it('Create default ecparam key', function (done) {
+      pem.createEcparam(function (error, data) {
+        hlp.checkError(error)
+        hlp.checkEcparam(data, 430, 470)
+        hlp.checkTmpEmpty()
+        done()
+      })
+    })
+    it('Create secp521k1 ecparam key', function (done) {
+      pem.createEcparam('secp521r1', function (error, data) {
+        hlp.checkError(error)
+        hlp.checkEcparam(data, 960, 1000)
+        hlp.checkTmpEmpty()
+        done()
+      })
+    })
+    it('Create prime256v1 ecparam key', function (done) {
+      pem.createEcparam('prime256v1', function (error, data) {
+        hlp.checkError(error)
+        hlp.checkEcparam(data, 430, 570)
+        hlp.checkTmpEmpty()
+        done()
+      })
+    })
+  })
+
+  describe('#.createPrivateKey tests', function () {
+    describe('default sized private key', function () {
+      var pkey
+      it('create private key', function (done) {
+        pem.createPrivateKey(function (error, data) {
+          hlp.checkError(error)
+          hlp.checkPrivateKey(data, 850, 1900)
+          hlp.checkTmpEmpty()
+          pkey = data
+          done()
+        })
+      })
+
+      it('get its public key', function (done) {
+        pem.getPublicKey(pkey.key, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkPublicKey(data)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+
+      it('create csr and check key', function (done) {
+        pem.createCSR({
+          clientKey: pkey.key
+        }, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCSR(data, pkey.key)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+
+      it('create pkcs12 w/o password', function (done) {
+        pem.createCertificate({
+          clientKey: pkey.key,
+          selfSigned: true
+        }, function (error, data) {
+          hlp.checkError(error)
+
+          pem.createPkcs12(data.clientKey, data.certificate, 'mypassword', function (error, pkcs12) {
+            hlp.checkError(error)
+            expect(pkcs12).to.be.ok()
+            hlp.checkTmpEmpty()
+            done()
+          })
+        })
+      })
+    })
+
+    describe('2048bit Private key', function () {
+      var pwkey
+      it('create private key', function (done) {
+        pem.createPrivateKey(2048, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkPrivateKey(data, 1650, 1710)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+
+      it('create private key with password', function (done) {
+        pem.createPrivateKey(2048, {
+          cipher: 'aes128',
+          password: 'min4chars'
+        }, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkPrivateKey(data, 1700, 1800, true)
+          hlp.checkTmpEmpty()
+          pwkey = data
+          done()
+        })
+      })
+
+      it('create csr using private key with password', function (done) {
+        pem.createCSR({
+          clientKey: pwkey.key,
+          clientKeyPassword: 'min4chars'
+        }, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCSR(data, pwkey.key)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+
+      it('create cert using pkey w/ password; create pkcs12', function (done) {
+        pem.createCertificate({
+          clientKey: pwkey.key,
+          clientKeyPassword: 'min4chars',
+          selfSigned: true
+        }, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificate(data, true)
+          hlp.checkTmpEmpty()
+
+          pem.createPkcs12(data.clientKey, data.certificate, 'mypassword', {
+            cipher: 'aes256',
+            clientKeyPassword: 'min4chars'
+          }, function (error, pkcs12) {
+            hlp.checkError(error)
+            expect(pkcs12).to.be.ok()
+            hlp.checkTmpEmpty()
+            done()
+          })
+        })
+      })
+    })
+  })
+
+  describe('#.createCSR tests', function () {
+    it('Create default CSR; get its public key; read its data', function (done) {
+      pem.createCSR(function (error, data1) {
+        hlp.checkError(error)
+        hlp.checkCSR(data1)
+        hlp.checkTmpEmpty()
+
+        pem.getPublicKey(data1.clientKey, function (error, data2) {
+          hlp.checkError(error)
+          hlp.checkPublicKey(data2)
+          hlp.checkTmpEmpty()
+
+          pem.readCertificateInfo(data1.csr, function (error, data3) {
+            hlp.checkError(error)
+            hlp.checkCertificateData(data3, {
+              issuer: {},
+              country: '',
+              state: '',
+              locality: '',
+              organization: '',
+              organizationUnit: '',
+              commonName: 'localhost',
+              emailAddress: '',
+              dc: '',
+              signatureAlgorithm: 'sha256WithRSAEncryption',
+              publicKeyAlgorithm: 'rsaEncryption',
+              publicKeySize: '2048 bit'
+            })
+            hlp.checkTmpEmpty()
+            done()
+          })
+        })
+      })
+    })
+
+    it('Create CSR using config file', function (done) {
+      pem.createCSR({
+        csrConfigFile: './test/fixtures/test.cnf'
+      }, function (error, data) {
+        hlp.checkError(error)
+        hlp.checkCSR(data)
+        hlp.checkTmpEmpty()
+
+        pem.readCertificateInfo(data.csr, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificateData(data, {
+            issuer: {},
+            country: 'EE',
+            state: 'Harjumaa',
+            locality: 'Tallinn',
+            organization: 'Node.ee',
+            organizationUnit: 'test',
+            commonName: 'www.node.ee',
+            emailAddress: 'andris@node.ee',
+            dc: '',
+            signatureAlgorithm: 'sha256WithRSAEncryption',
+            publicKeyAlgorithm: 'rsaEncryption',
+            publicKeySize: '2048 bit'
+          })
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+    })
+
+    it('Create CSR with multiple organizations using config file', function (done) {
+      pem.createCSR({
+        issuer: {},
+        country: 'EE',
+        state: 'Harjumaa',
+        locality: 'Tallinn',
+        organization: ['Node2.ee', 'Node.ee'],
+        organizationUnit: 'test',
+        commonName: 'www.node.ee',
+        emailAddress: 'andris@node.ee',
+        dc: '',
+        signatureAlgorithm: 'sha256WithRSAEncryption',
+        publicKeyAlgorithm: 'rsaEncryption',
+        publicKeySize: '2048 bit'
+      }, function (error, data) {
+        hlp.checkError(error)
+        hlp.checkCSR(data)
+        hlp.checkTmpEmpty()
+
+        pem.readCertificateInfo(data.csr, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificateData(data, {
+            issuer: {},
+            country: 'EE',
+            state: 'Harjumaa',
+            locality: 'Tallinn',
+            organization: ['Node.ee', 'Node2.ee'],
+            organizationUnit: 'test',
+            commonName: 'www.node.ee',
+            emailAddress: 'andris@node.ee',
+            dc: '',
+            signatureAlgorithm: 'sha256WithRSAEncryption',
+            publicKeyAlgorithm: 'rsaEncryption',
+            publicKeySize: '2048 bit'
+          })
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+    })
+
+    it('Read edited cert data from CSR', function (done) {
+      var certInfo = {
+        issuer: {},
+        country: 'EE',
+        state: 'Harjumaa',
+        locality: 'Tallinn',
+        organization: 'Node.ee',
+        organizationUnit: 'test',
+        commonName: 'www.node.ee',
+        emailAddress: 'andris@node.ee',
+        dc: '',
+        signatureAlgorithm: 'sha256WithRSAEncryption',
+        publicKeyAlgorithm: 'rsaEncryption',
+        publicKeySize: '2048 bit'
+      }
+      pem.createCSR(Object.create(certInfo), function (error, data) {
+        hlp.checkError(error)
+        hlp.checkCSR(data)
+        hlp.checkTmpEmpty()
+
+        pem.readCertificateInfo(data.csr, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificateData(data, certInfo)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+    })
+  })
+
+  describe('#.createCertificate tests', function () {
+    describe('Default certificate', function () {
+      var cert
+      it('Create default certificate', function (done) {
+        pem.createCertificate(function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificate(data)
+          hlp.checkTmpEmpty()
+          cert = data
+          done()
+        })
+      })
+
+      it('get its public key', function (done) {
+        pem.getPublicKey(cert.clientKey, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkPublicKey(data)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+
+      it('get its fingerprint', function (done) {
+        pem.getFingerprint(cert.certificate, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkFingerprint(data)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+
+      it('get its modulus [not hashed]', function (done) {
+        pem.getModulus(cert.certificate, function (error,
+          data) {
+          hlp.checkError(error)
+          hlp.checkModulus(data)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+
+      it('get its modulus [md5 hashed]', function (done) {
+        pem.getModulus(cert.certificate, null, 'md5',
+          function (error, data) {
+            hlp.checkError(error)
+            hlp.checkModulus(data, 'md5')
+            hlp.checkTmpEmpty()
+            done()
+          })
+      })
+
+      it('read its data', function (done) {
+        pem.readCertificateInfo(cert.certificate, function (
+          error, data) {
+          hlp.checkError(error);
+          ['validity', 'serial', 'signatureAlgorithm',
+            'publicKeySize', 'publicKeyAlgorithm'
+          ].forEach(function (k) {
+            if (data[k]) { delete data[k] }
+          })
+          hlp.checkCertificateData(data, {
+            issuer: {
+              country: '',
+              state: '',
+              locality: '',
+              organization: '',
+              organizationUnit: '',
+              commonName: 'localhost',
+              dc: ''
+            },
+            country: '',
+            state: '',
+            locality: '',
+            organization: '',
+            organizationUnit: '',
+            commonName: 'localhost',
+            emailAddress: '',
+            dc: ''
+          })
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+    })
+
+    describe('CA certificate', function () {
+      var ca
+      it('create ca certificate', function (done) {
+        pem.createCertificate({
+          commonName: 'CA Certificate'
+        },
+        function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificate(data)
+          hlp.checkTmpEmpty()
+          ca = data
+          done()
+        })
+      })
+      it('create certificate with text serial "demo-serial"', function (done) {
+        pem.createCertificate({
+          serviceKey: ca.serviceKey,
+          serviceCertificate: ca.certificate,
+          serial: 'demo-serial'
+        },
+        function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificate(data)
+          hlp.checkTmpEmpty()
+          pem.readCertificateInfo(data.certificate, function (error, data) {
+            hlp.checkError(error);
+            ['validity', 'serial'].forEach(function (k) {
+              if (data[k]) {
+                delete data[k]
+              }
+            })
+            hlp.checkTmpEmpty()
+            done()
+          })
+        })
+      })
+      it('create certificate with hex serial "0x1234567890abcdef"', function (done) {
+        pem.createCertificate({
+          serviceKey: ca.serviceKey,
+          serviceCertificate: ca.certificate,
+          serial: '0x1234567890abcdef'
+        },
+        function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificate(data)
+          hlp.checkTmpEmpty()
+          pem.readCertificateInfo(data.certificate, function (error, data) {
+            hlp.checkError(error);
+            ['validity', 'serial'].forEach(function (k) {
+              if (data[k]) {
+                delete data[k]
+              }
+            })
+            hlp.checkTmpEmpty()
+            done()
+          })
+        })
+      })
+      it('create certificate with hex serial "1234567890abcdef"', function (done) {
+        pem.createCertificate({
+          serviceKey: ca.serviceKey,
+          serviceCertificate: ca.certificate,
+          serial: '1234567890abcdef'
+        },
+        function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificate(data)
+          hlp.checkTmpEmpty()
+          pem.readCertificateInfo(data.certificate, function (error, data) {
+            hlp.checkError(error);
+            ['validity', 'serial'].forEach(function (k) {
+              if (data[k]) {
+                delete data[k]
+              }
+            })
+            hlp.checkTmpEmpty()
+            done()
+          })
+        })
+      })
+      it('create certificate with number serial "1234567890"', function (done) {
+        pem.createCertificate({
+          serviceKey: ca.serviceKey,
+          serviceCertificate: ca.certificate,
+          serial: 1234567890
+        },
+        function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificate(data)
+          hlp.checkTmpEmpty()
+          pem.readCertificateInfo(data.certificate, function (error, data) {
+            hlp.checkError(error);
+            ['validity', 'serial'].forEach(function (k) {
+              if (data[k]) {
+                delete data[k]
+              }
+            })
+            hlp.checkTmpEmpty()
+            done()
+          })
+        })
+      })
+      it('verify signing chain; create and read PKCS12', function (done) {
+        pem.createCertificate({
+          serviceKey: ca.serviceKey,
+          serviceCertificate: ca.certificate,
+          serial: Date.now()
+        }, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificate(data)
+          hlp.checkTmpEmpty()
+
+          pem.verifySigningChain(data.certificate,
+            ca.certificate,
+            function (error, valid) {
+              hlp.checkError(error)
+              expect(valid).to.be.true()
+
+              pem.createPkcs12(data.clientKey,
+                data.certificate, '', {
+                  certFiles: [ca.certificate]
+                },
+                function (error, d) {
+                  hlp.checkError(error)
+                  expect(d).to.be.ok()
+                  hlp.checkTmpEmpty()
+
+                  pem.readPkcs12(d.pkcs12,
+                    function (error, keystore) {
+                      hlp.checkError(error)
+                      expect(keystore).to.be.an('object')
+                      expect(keystore).to.have.property('ca')
+                      expect(keystore).to.have.property('cert')
+                      expect(keystore).to.have.property('key')
+                      expect(keystore.ca).to.be.an('array')
+                      expect(keystore.cert).to.be.an('string')
+                      expect(keystore.key).to.be.an('string')
+                      expect(keystore.ca[0]).to.equal(ca.certificate)
+                      expect(keystore.cert).to.equal(data.certificate)
+                      expect(keystore.key).to.equal(data.clientKey)
+                      done()
+                    })
+                })
+            })
+        })
+      })
+      it('Fail to verify invalid sigining chain', function (done) {
+        pem.createCertificate({
+          serviceKey: ca.serviceKey,
+          serviceCertificate: ca.certificate,
+          serial: Date.now()
+        }, function (error, data) {
+          hlp.checkError(error)
+          hlp.checkCertificate(data)
+          hlp.checkTmpEmpty()
+
+          pem.verifySigningChain(data.certificate,
+            data.certificate,
+            function (error, valid) {
+              hlp.checkError(error)
+              expect(valid).to.be.false()
+              done()
+            })
+        })
+      })
+      it('Verify google.com certificate without provided CA certificates', function (done) {
+        var certificate = fs.readFileSync('./test/fixtures/google.com.pem').toString()
+        pem.verifySigningChain(certificate, function (error, valid) {
+          hlp.checkError(error)
+          expect(valid).to.be.false()
+          done()
+        })
+      })
+      it('Verify deep sigining chain', function (done) {
+        pem.createCertificate({
+          commonName: 'Intermediate CA Certificate',
+          serviceKey: ca.serviceKey,
+          serviceCertificate: ca.certificate,
+          serial: Date.now()
+        }, function (error, intermediate) {
+          hlp.checkError(error)
+          hlp.checkCertificate(intermediate)
+          hlp.checkTmpEmpty()
+
+          pem.createCertificate({
+            serviceKey: intermediate.clientKey,
+            serviceCertificate: intermediate.certificate,
+            serial: Date.now()
+            // days: 1024
+          }, function (error, cert) {
+            hlp.checkError(error)
+            hlp.checkCertificate(cert)
+            hlp.checkTmpEmpty()
+
+            // chain check ok
+            pem.verifySigningChain([intermediate.certificate, cert.certificate], [
+              ca.certificate, intermediate.certificate
+            ], function (error, valid) {
+              hlp.checkError(error)
+              expect(valid).to.be.true()
+
+              // chain check fails -> missing ca cert in chain
+              pem.verifySigningChain(cert.certificate, [
+                intermediate.certificate
+              ], function (error, valid) {
+                hlp.checkError(error)
+                expect(valid).to.be.false()
+
+                // chain check fails -> missing intermediate cert in chain
+                pem.verifySigningChain(
+                  cert.certificate, [
+                    ca.certificate
+                  ],
+                  function (error,
+                    valid) {
+                    hlp.checkError(error)
+                    expect(valid).to.be.false()
+                    done()
+                  })
+              })
+            })
+          })
+        })
+      })
+    })
+
+    it('Create self signed certificate', function (done) {
+      pem.createCertificate({
+        selfSigned: true
+      }, function (error, data) {
+        hlp.checkError(error)
+        hlp.checkCertificate(data, true)
+        hlp.checkTmpEmpty()
+        done()
+      })
+    })
+    it('Create and verify wildcard certificate', function (done) {
+      var certInfo = {
+        commonName: '*.node.ee'
+      }
+      pem.createCertificate(Object.create(certInfo), function (error, data) {
+        hlp.checkError(error)
+        hlp.checkCertificate(data)
+        hlp.checkTmpEmpty()
+
+        pem.readCertificateInfo(data.certificate, function (error, data) {
+          hlp.checkError(error)
+          expect(data).to.be.an('object').that.has.property('commonName')
+          expect(data.commonName).to.equal(certInfo.commonName)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+    })
+    it('Read edited cert data from certificate', function (done) {
+      var certInfo = {
+        issuer: {
+          country: 'EE',
+          state: 'Harjumaa',
+          locality: 'Tallinn',
+          organization: 'Node.ee',
+          organizationUnit: 'test',
+          commonName: 'www.node.ee',
+          dc: ''
+        },
+        country: 'EE',
+        state: 'Harjumaa',
+        locality: 'Tallinn',
+        organization: 'Node.ee',
+        organizationUnit: 'test',
+        commonName: 'www.node.ee',
+        emailAddress: 'andris@node.ee',
+        dc: '',
+        signatureAlgorithm: 'sha256WithRSAEncryption',
+        publicKeyAlgorithm: 'rsaEncryption',
+        publicKeySize: '2048 bit'
+      }
+      pem.createCertificate(Object.create(certInfo), function (error, data) {
+        hlp.checkError(error)
+        hlp.checkCertificate(data)
+        hlp.checkTmpEmpty()
+
+        pem.readCertificateInfo(data.certificate, function (error, data) {
+          hlp.checkError(error);
+          ['validity', 'serial'].forEach(function (k) {
+            if (data[k]) { delete data[k] }
+          })
+          hlp.checkCertificateData(data, certInfo)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+    })
+  })
+
+  describe('#.checkCertificate tests', function () {
+    it('Check certificate file @ ./test/fixtures/test.key', function (done) {
+      var d = fs.readFileSync('./test/fixtures/test.key').toString()
+      pem.checkCertificate(d, 'password', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.ok()
+        done()
+      })
+    })
+    it('Check certificate file @ ./test/fixtures/test.crt', function (done) {
+      var d = fs.readFileSync('./test/fixtures/test.crt').toString()
+      pem.checkCertificate(d, function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.ok()
+        done()
+      })
+    })
+    it('Check certificate file @ ./test/fixtures/test.csr', function (done) {
+      var d = fs.readFileSync('./test/fixtures/test.csr').toString()
+      pem.checkCertificate(d, function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.ok()
+        done()
+      })
+    })
+  })
+
+  describe('#.getModulus tests', function () {
+    it('Check matching modulus of  key and cert file', function (done) {
+      var f = fs.readFileSync('./test/fixtures/test.crt').toString()
+      pem.getModulus(f, function (error, data1) {
+        hlp.checkError(error)
+        hlp.checkModulus(data1)
+        hlp.checkTmpEmpty()
+
+        f = fs.readFileSync('./test/fixtures/test.key').toString()
+        pem.getModulus(f, 'password', function (error, data2) {
+          hlp.checkError(error)
+          hlp.checkModulus(data2)
+          expect(data1.modulus).to.equal(data2.modulus)
+          hlp.checkTmpEmpty()
+          done()
+        })
+      })
+    })
+  })
+
+  describe('#.getDhparamInfo tests', function () {
+    it('Get DH param info', function (done) {
+      var dh = fs.readFileSync('./test/fixtures/test.dh').toString()
+      pem.getDhparamInfo(dh, function (error, data) {
+        hlp.checkError(error)
+        var size = (data && data.size) || 0
+        var prime = ((data && data.prime) || '').toString()
+        expect(size).to.be.a('number')
+        expect(size).to.equal(1024)
+        expect(prime).to.be.a('string')
+        expect(/([0-9a-f][0-9a-f]:)+[0-9a-f][0-9a-f]$/g.test(prime)).to.be.true()
+        hlp.checkTmpEmpty()
+        done()
+      })
+    })
+  })
+
+  describe('#.readPkcs12 tests', function () {
+    it('Respond with ENOENT for missing PKCS12 file', function (
+      done) {
+      pem.readPkcs12('/i/do/not/exist.p12', function (error) {
+        hlp.checkError(error, {
+          code: 'ENOENT'
+        })
+        done()
+      })
+    })
+  })
+
+  describe('#.checkPkcs12 tests', function () {
+    it('Check PKCS12 keystore', function (done) {
+      var pkcs12 = fs.readFileSync('./test/fixtures/idsrv3test.pfx')
+      pem.checkPkcs12(pkcs12, 'idsrv3test', function (error, result) {
+        hlp.checkError(error)
+        expect(result).to.be.ok()
+        done()
+      })
+    })
+  })
+})