meteor-node-stubs 1.2.16 → 1.2.18

package/node_modules/public-encrypt/node_modules/bn.js/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "bn.js",
+  "version": "4.12.2",
+  "description": "Big number implementation in pure javascript",
+  "main": "lib/bn.js",
+  "scripts": {
+    "lint": "semistandard",
+    "unit": "mocha --reporter=spec test/*-test.js",
+    "test": "npm run lint && npm run unit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:indutny/bn.js"
+  },
+  "keywords": [
+    "BN",
+    "BigNum",
+    "Big number",
+    "Modulo",
+    "Montgomery"
+  ],
+  "author": "Fedor Indutny <fedor@indutny.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/indutny/bn.js/issues"
+  },
+  "homepage": "https://github.com/indutny/bn.js",
+  "browser": {
+    "buffer": false
+  },
+  "devDependencies": {
+    "istanbul": "^0.3.5",
+    "mocha": "^2.1.0",
+    "semistandard": "^7.0.4"
+  }
+}

package/node_modules/public-encrypt/node_modules/bn.js/util/genCombMulTo.js

@@ -0,0 +1,65 @@
+'use strict';
+
+// NOTE: This could be potentionally used to generate loop-less multiplications
+function genCombMulTo (alen, blen) {
+  var len = alen + blen - 1;
+  var src = [
+    'var a = self.words;',
+    'var b = num.words;',
+    'var o = out.words;',
+    'var c = 0;',
+    'var lo;',
+    'var mid;',
+    'var hi;'
+  ];
+  for (var i = 0; i < alen; i++) {
+    src.push('var a' + i + ' = a[' + i + '] | 0;');
+    src.push('var al' + i + ' = a' + i + ' & 0x1fff;');
+    src.push('var ah' + i + ' = a' + i + ' >>> 13;');
+  }
+  for (i = 0; i < blen; i++) {
+    src.push('var b' + i + ' = b[' + i + '] | 0;');
+    src.push('var bl' + i + ' = b' + i + ' & 0x1fff;');
+    src.push('var bh' + i + ' = b' + i + ' >>> 13;');
+  }
+  src.push('');
+  src.push('out.negative = self.negative ^ num.negative;');
+  src.push('out.length = ' + len + ';');
+
+  for (var k = 0; k < len; k++) {
+    var minJ = Math.max(0, k - alen + 1);
+    var maxJ = Math.min(k, blen - 1);
+
+    src.push('\/* k = ' + k + ' *\/');
+    src.push('var w' + k + ' = c;');
+    src.push('c = 0;');
+    for (var j = minJ; j <= maxJ; j++) {
+      i = k - j;
+
+      src.push('lo = Math.imul(al' + i + ', bl' + j + ');');
+      src.push('mid = Math.imul(al' + i + ', bh' + j + ');');
+      src.push('mid = (mid + Math.imul(ah' + i + ', bl' + j + ')) | 0;');
+      src.push('hi = Math.imul(ah' + i + ', bh' + j + ');');
+
+      src.push('w' + k + ' = (w' + k + ' + lo) | 0;');
+      src.push('w' + k + ' = (w' + k + ' + ((mid & 0x1fff) << 13)) | 0;');
+      src.push('c = (c + hi) | 0;');
+      src.push('c = (c + (mid >>> 13)) | 0;');
+      src.push('c = (c + (w' + k + ' >>> 26)) | 0;');
+      src.push('w' + k + ' &= 0x3ffffff;');
+    }
+  }
+  // Store in separate step for better memory access
+  for (k = 0; k < len; k++) {
+    src.push('o[' + k + '] = w' + k + ';');
+  }
+  src.push('if (c !== 0) {',
+           '  o[' + k + '] = c;',
+           '  out.length++;',
+           '}',
+           'return out;');
+
+  return src.join('\n');
+}
+
+console.log(genCombMulTo(10, 10));

package/node_modules/public-encrypt/node_modules/bn.js/util/genCombMulTo10.js

@@ -0,0 +1,65 @@
+'use strict';
+
+function genCombMulTo (alen, blen) {
+  var len = alen + blen - 1;
+  var src = [
+    'var a = self.words;',
+    'var b = num.words;',
+    'var o = out.words;',
+    'var c = 0;',
+    'var lo;',
+    'var mid;',
+    'var hi;'
+  ];
+  for (var i = 0; i < alen; i++) {
+    src.push('var a' + i + ' = a[' + i + '] | 0;');
+    src.push('var al' + i + ' = a' + i + ' & 0x1fff;');
+    src.push('var ah' + i + ' = a' + i + ' >>> 13;');
+  }
+  for (i = 0; i < blen; i++) {
+    src.push('var b' + i + ' = b[' + i + '] | 0;');
+    src.push('var bl' + i + ' = b' + i + ' & 0x1fff;');
+    src.push('var bh' + i + ' = b' + i + ' >>> 13;');
+  }
+  src.push('');
+  src.push('out.negative = self.negative ^ num.negative;');
+  src.push('out.length = ' + len + ';');
+
+  for (var k = 0; k < len; k++) {
+    var minJ = Math.max(0, k - alen + 1);
+    var maxJ = Math.min(k, blen - 1);
+
+    src.push('\/* k = ' + k + ' *\/');
+    src.push('lo = Math.imul(al' + (k - minJ) + ', bl' + minJ + ');');
+    src.push('mid = Math.imul(al' + (k - minJ) + ', bh' + minJ + ');');
+    src.push(
+        'mid = (mid + Math.imul(ah' + (k - minJ) + ', bl' + minJ + ')) | 0;');
+    src.push('hi = Math.imul(ah' + (k - minJ) + ', bh' + minJ + ');');
+
+    for (var j = minJ + 1; j <= maxJ; j++) {
+      i = k - j;
+
+      src.push('lo = (lo + Math.imul(al' + i + ', bl' + j + ')) | 0;');
+      src.push('mid = (mid + Math.imul(al' + i + ', bh' + j + ')) | 0;');
+      src.push('mid = (mid + Math.imul(ah' + i + ', bl' + j + ')) | 0;');
+      src.push('hi = (hi + Math.imul(ah' + i + ', bh' + j + ')) | 0;');
+    }
+
+    src.push('var w' + k + ' = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;');
+    src.push('c = (((hi + (mid >>> 13)) | 0) + (w' + k + ' >>> 26)) | 0;');
+    src.push('w' + k + ' &= 0x3ffffff;');
+  }
+  // Store in separate step for better memory access
+  for (k = 0; k < len; k++) {
+    src.push('o[' + k + '] = w' + k + ';');
+  }
+  src.push('if (c !== 0) {',
+           '  o[' + k + '] = c;',
+           '  out.length++;',
+           '}',
+           'return out;');
+
+  return src.join('\n');
+}
+
+console.log(genCombMulTo(10, 10));

package/node_modules/public-encrypt/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "public-encrypt",
+  "version": "4.0.3",
+  "description": "browserify version of publicEncrypt & privateDecrypt",
+  "main": "index.js",
+  "browser": "browser.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "node test/index.js | tspec",
+    "lint": "standard"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/crypto-browserify/publicEncrypt.git"
+  },
+  "author": "Calvin Metcalf",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/crypto-browserify/publicEncrypt/issues"
+  },
+  "homepage": "https://github.com/crypto-browserify/publicEncrypt",
+  "dependencies": {
+    "bn.js": "^4.1.0",
+    "browserify-rsa": "^4.0.0",
+    "create-hash": "^1.1.0",
+    "parse-asn1": "^5.0.0",
+    "randombytes": "^2.0.1",
+    "safe-buffer": "^5.1.2"
+  },
+  "devDependencies": {
+    "standard": "^12.0.0",
+    "tap-spec": "^2.1.2",
+    "tape": "^3.0.3"
+  }
+}

package/node_modules/public-encrypt/privateDecrypt.js

@@ -0,0 +1,105 @@
+var parseKeys = require('parse-asn1')
+var mgf = require('./mgf')
+var xor = require('./xor')
+var BN = require('bn.js')
+var crt = require('browserify-rsa')
+var createHash = require('create-hash')
+var withPublic = require('./withPublic')
+var Buffer = require('safe-buffer').Buffer
+
+module.exports = function privateDecrypt (privateKey, enc, reverse) {
+  var padding
+  if (privateKey.padding) {
+    padding = privateKey.padding
+  } else if (reverse) {
+    padding = 1
+  } else {
+    padding = 4
+  }
+
+  var key = parseKeys(privateKey)
+  var k = key.modulus.byteLength()
+  if (enc.length > k || new BN(enc).cmp(key.modulus) >= 0) {
+    throw new Error('decryption error')
+  }
+  var msg
+  if (reverse) {
+    msg = withPublic(new BN(enc), key)
+  } else {
+    msg = crt(enc, key)
+  }
+  var zBuffer = Buffer.alloc(k - msg.length)
+  msg = Buffer.concat([zBuffer, msg], k)
+  if (padding === 4) {
+    return oaep(key, msg)
+  } else if (padding === 1) {
+    return pkcs1(key, msg, reverse)
+  } else if (padding === 3) {
+    return msg
+  } else {
+    throw new Error('unknown padding')
+  }
+}
+
+function oaep (key, msg) {
+  var k = key.modulus.byteLength()
+  var iHash = createHash('sha1').update(Buffer.alloc(0)).digest()
+  var hLen = iHash.length
+  if (msg[0] !== 0) {
+    throw new Error('decryption error')
+  }
+  var maskedSeed = msg.slice(1, hLen + 1)
+  var maskedDb = msg.slice(hLen + 1)
+  var seed = xor(maskedSeed, mgf(maskedDb, hLen))
+  var db = xor(maskedDb, mgf(seed, k - hLen - 1))
+  if (compare(iHash, db.slice(0, hLen))) {
+    throw new Error('decryption error')
+  }
+  var i = hLen
+  while (db[i] === 0) {
+    i++
+  }
+  if (db[i++] !== 1) {
+    throw new Error('decryption error')
+  }
+  return db.slice(i)
+}
+
+function pkcs1 (key, msg, reverse) {
+  var p1 = msg.slice(0, 2)
+  var i = 2
+  var status = 0
+  while (msg[i++] !== 0) {
+    if (i >= msg.length) {
+      status++
+      break
+    }
+  }
+  var ps = msg.slice(2, i - 1)
+
+  if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !== '0001' && reverse)) {
+    status++
+  }
+  if (ps.length < 8) {
+    status++
+  }
+  if (status) {
+    throw new Error('decryption error')
+  }
+  return msg.slice(i)
+}
+function compare (a, b) {
+  a = Buffer.from(a)
+  b = Buffer.from(b)
+  var dif = 0
+  var len = a.length
+  if (a.length !== b.length) {
+    dif++
+    len = Math.min(a.length, b.length)
+  }
+  var i = -1
+  while (++i < len) {
+    dif += (a[i] ^ b[i])
+  }
+  return dif
+}

package/node_modules/public-encrypt/publicEncrypt.js

@@ -0,0 +1,88 @@
+var parseKeys = require('parse-asn1')
+var randomBytes = require('randombytes')
+var createHash = require('create-hash')
+var mgf = require('./mgf')
+var xor = require('./xor')
+var BN = require('bn.js')
+var withPublic = require('./withPublic')
+var crt = require('browserify-rsa')
+var Buffer = require('safe-buffer').Buffer
+
+module.exports = function publicEncrypt (publicKey, msg, reverse) {
+  var padding
+  if (publicKey.padding) {
+    padding = publicKey.padding
+  } else if (reverse) {
+    padding = 1
+  } else {
+    padding = 4
+  }
+  var key = parseKeys(publicKey)
+  var paddedMsg
+  if (padding === 4) {
+    paddedMsg = oaep(key, msg)
+  } else if (padding === 1) {
+    paddedMsg = pkcs1(key, msg, reverse)
+  } else if (padding === 3) {
+    paddedMsg = new BN(msg)
+    if (paddedMsg.cmp(key.modulus) >= 0) {
+      throw new Error('data too long for modulus')
+    }
+  } else {
+    throw new Error('unknown padding')
+  }
+  if (reverse) {
+    return crt(paddedMsg, key)
+  } else {
+    return withPublic(paddedMsg, key)
+  }
+}
+
+function oaep (key, msg) {
+  var k = key.modulus.byteLength()
+  var mLen = msg.length
+  var iHash = createHash('sha1').update(Buffer.alloc(0)).digest()
+  var hLen = iHash.length
+  var hLen2 = 2 * hLen
+  if (mLen > k - hLen2 - 2) {
+    throw new Error('message too long')
+  }
+  var ps = Buffer.alloc(k - mLen - hLen2 - 2)
+  var dblen = k - hLen - 1
+  var seed = randomBytes(hLen)
+  var maskedDb = xor(Buffer.concat([iHash, ps, Buffer.alloc(1, 1), msg], dblen), mgf(seed, dblen))
+  var maskedSeed = xor(seed, mgf(maskedDb, hLen))
+  return new BN(Buffer.concat([Buffer.alloc(1), maskedSeed, maskedDb], k))
+}
+function pkcs1 (key, msg, reverse) {
+  var mLen = msg.length
+  var k = key.modulus.byteLength()
+  if (mLen > k - 11) {
+    throw new Error('message too long')
+  }
+  var ps
+  if (reverse) {
+    ps = Buffer.alloc(k - mLen - 3, 0xff)
+  } else {
+    ps = nonZero(k - mLen - 3)
+  }
+  return new BN(Buffer.concat([Buffer.from([0, reverse ? 1 : 2]), ps, Buffer.alloc(1), msg], k))
+}
+function nonZero (len) {
+  var out = Buffer.allocUnsafe(len)
+  var i = 0
+  var cache = randomBytes(len * 2)
+  var cur = 0
+  var num
+  while (i < len) {
+    if (cur === cache.length) {
+      cache = randomBytes(len * 2)
+      cur = 0
+    }
+    num = cache[cur++]
+    if (num) {
+      out[i++] = num
+    }
+  }
+  return out
+}

package/node_modules/public-encrypt/readme.md

@@ -0,0 +1,8 @@
+publicEncrypt
+===
+
+[![Build Status](https://travis-ci.org/crypto-browserify/publicEncrypt.svg)](https://travis-ci.org/crypto-browserify/publicEncrypt)
+
+publicEncrypt/privateDecrypt for browserify
+
+[Blog post about the moving parts that have gone into this.](http://calvinmetcalf.com/post/109301244759/porting-nodejs-crypto-to-the-browser-part-3)

package/node_modules/public-encrypt/test/1024.priv

@@ -0,0 +1,16 @@
+-----BEGIN PRIVATE KEY-----
+MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAKulUTZ8B1qccZ8c
+DXRGSY08gW8KvLlcxxxGC4gZHNT3CBUF8n5R4KE30aZyYZ/rtsQZu05juZJxaJ0q
+mbe75dlQ5d+Xc9BMXeQg/MpTZw5TAN7OIdGYYpFBe+1PLZ6wEfjkYrMqMUcfq2Lq
+hTLdAbvBJnuRcYZLqmBeOQ8FTrKrAgMBAAECgYEAnkHRbEPU3/WISSQrP36iyCb2
+S/SBZwKkzmvCrBxDWhPeDswp9c/2JY76rNWfLzy8iXgUG8WUzvHje61Qh3gmBcKe
+bUaTGl4Vy8Ha1YBADo5RfRrdm0FE4tvgvu/TkqFqpBBZweu54285hk5zlG7n/D7Y
+dnNXUpu5MlNb5x3gW0kCQQDUL//cwcXUxY/evaJP4jSe+ZwEQZo+zXRLiPUulBoV
+aw28CVMuxdgwqAo1X1IKefPeUaf7RQu8gCKaRnpGuEuXAkEAzxZTfMmvmCUDIew4
+5Gk6bK265XQWdhcgiq254lpBGOYmDj9yCE7yA+zmASQwMsXTdQOi1hOCEyrXuSJ5
+c++EDQJAFh3WrnzoEPByuYXMmET8tSFRWMQ5vpgNqh3haHR5b4gUC2hxaiunCBNL
+1RpVY9AoUiDywGcG/SPh93CnKB3niwJBAKP7AtsifZgVXtiizB4aMThTjVYaSZrz
+D0Kg9DuHylpkDChmFu77TGrNUQgAVuYtfhb/bRblVa/F0hJ4eQHT3JUCQBVT68tb
+OgRUk0aP9tC3021VN82X6+klowSQN8oBPX8+TfDWSUilp/+j24Hky+Z29Do7yR/R
+qutnL92CvBlVLV4=
+-----END PRIVATE KEY-----

package/node_modules/public-encrypt/test/1024.pub

@@ -0,0 +1,6 @@
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCrpVE2fAdanHGfHA10RkmNPIFv
+Cry5XMccRguIGRzU9wgVBfJ+UeChN9GmcmGf67bEGbtOY7mScWidKpm3u+XZUOXf
+l3PQTF3kIPzKU2cOUwDeziHRmGKRQXvtTy2esBH45GKzKjFHH6ti6oUy3QG7wSZ7
+kXGGS6pgXjkPBU6yqwIDAQAB
+-----END PUBLIC KEY-----

package/node_modules/public-encrypt/test/ec.pass.priv

@@ -0,0 +1,7 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIHeMEkGCSqGSIb3DQEFDTA8MBsGCSqGSIb3DQEFDDAOBAi9LqZQx4JFXAICCAAw
+HQYJYIZIAWUDBAECBBA+js1fG4Rv/yRN7oZvxbgyBIGQ/D4yj86M1x8lMsnAHQ/K
+7/ryb/baDNHqN9LTZanEGBuyxgrTzt08SiL+h91yFGMoaly029K1VgEI8Lxu5Np/
+A+LK7ewh73ABzsbuxYdcXI+rKnrvLN9Tt6veDs4GlqTTsWwq5wF0C+6gaYRBXA74
+T1b6NykGh2UNL5U5pHZEYdOVLz+lRJL7gYqlweNHP/S3
+-----END ENCRYPTED PRIVATE KEY-----

package/node_modules/public-encrypt/test/ec.priv

@@ -0,0 +1,5 @@
+-----BEGIN EC PRIVATE KEY-----
+MHQCAQEEIDF6Xv8Sv//wGUWD+c780ppGrU0QdZWCAzxAQPQX8r/uoAcGBSuBBAAK
+oUQDQgAEIZeowDylls4K/wfBjO18bYo7gGx8nYQRija4e/qEMikOHJai7geeUreU
+r5Xky/Ax7s2dGtegsPNsPgGe5MpQvg==
+-----END EC PRIVATE KEY-----

package/node_modules/public-encrypt/test/ec.pub

@@ -0,0 +1,4 @@
+-----BEGIN PUBLIC KEY-----
+MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEIZeowDylls4K/wfBjO18bYo7gGx8nYQR
+ija4e/qEMikOHJai7geeUreUr5Xky/Ax7s2dGtegsPNsPgGe5MpQvg==
+-----END PUBLIC KEY-----

package/node_modules/public-encrypt/test/index.js

@@ -0,0 +1,113 @@
+var test = require('tape')
+var fs = require('fs')
+var parseKeys = require('parse-asn1')
+var Buffer = require('safe-buffer').Buffer
+var path = require('path')
+
+require('./nodeTests')
+var rsa1024 = {
+  private: fs.readFileSync(path.join(__dirname, 'rsa.1024.priv')),
+  public: fs.readFileSync(path.join(__dirname, 'rsa.1024.pub'))
+}
+var rsa1024priv = {
+  private: fs.readFileSync(path.join(__dirname, 'rsa.1024.priv')),
+  public: fs.readFileSync(path.join(__dirname, 'rsa.1024.priv'))
+}
+
+var rsa2028 = {
+  private: fs.readFileSync(path.join(__dirname, 'rsa.2028.priv')),
+  public: fs.readFileSync(path.join(__dirname, 'rsa.2028.pub'))
+}
+var nonrsa1024 = {
+  private: fs.readFileSync(path.join(__dirname, '1024.priv')),
+  public: fs.readFileSync(path.join(__dirname, '1024.pub'))
+}
+var nonrsa1024str = {
+  private: fs.readFileSync(path.join(__dirname, '1024.priv')).toString(),
+  public: fs.readFileSync(path.join(__dirname, '1024.pub')).toString()
+}
+var pass1024 = {
+  private: {
+    passphrase: 'fooo',
+    key: fs.readFileSync(path.join(__dirname, 'pass.1024.priv'))
+  },
+  public: fs.readFileSync(path.join(__dirname, 'pass.1024.pub'))
+}
+var pass2028 = {
+  private: {
+    passphrase: 'password',
+    key: fs.readFileSync(path.join(__dirname, 'rsa.pass.priv'))
+  },
+  public: fs.readFileSync(path.join(__dirname, 'rsa.pass.pub'))
+}
+
+var nodeCrypto = require('../')
+var myCrypto = require('../browser')
+function _testIt (keys, message, t) {
+  var pub = keys.public
+  var priv = keys.private
+  t.test(message.toString(), function (t) {
+    t.plan(8)
+
+    var myEnc = myCrypto.publicEncrypt(pub, message)
+    var nodeEnc = nodeCrypto.publicEncrypt(pub, message)
+    t.equals(myCrypto.privateDecrypt(priv, myEnc).toString('hex'), message.toString('hex'), 'my decrypter my message')
+    t.equals(myCrypto.privateDecrypt(priv, nodeEnc).toString('hex'), message.toString('hex'), 'my decrypter node\'s message')
+    t.equals(nodeCrypto.privateDecrypt(priv, myEnc).toString('hex'), message.toString('hex'), 'node decrypter my message')
+    t.equals(nodeCrypto.privateDecrypt(priv, nodeEnc).toString('hex'), message.toString('hex'), 'node decrypter node\'s message')
+    myEnc = myCrypto.privateEncrypt(priv, message)
+    nodeEnc = nodeCrypto.privateEncrypt(priv, message)
+    t.equals(myCrypto.publicDecrypt(pub, myEnc).toString('hex'), message.toString('hex'), 'reverse methods my decrypter my message')
+    t.equals(myCrypto.publicDecrypt(pub, nodeEnc).toString('hex'), message.toString('hex'), 'reverse methods my decrypter node\'s message')
+    t.equals(nodeCrypto.publicDecrypt(pub, myEnc).toString('hex'), message.toString('hex'), 'reverse methods node decrypter my message')
+    t.equals(nodeCrypto.publicDecrypt(pub, nodeEnc).toString('hex'), message.toString('hex'), 'reverse methods node decrypter node\'s message')
+  })
+}
+function testIt (keys, message, t) {
+  _testIt(keys, message, t)
+  _testIt(paddingObject(keys, 1), Buffer.concat([message, Buffer.from(' with RSA_PKCS1_PADDING')]), t)
+  var parsedKey = parseKeys(keys.public)
+  var k = parsedKey.modulus.byteLength()
+  var zBuf = Buffer.alloc(k)
+  var msg = Buffer.concat([zBuf, message, Buffer.from(' with no padding')]).slice(-k)
+  _testIt(paddingObject(keys, 3), msg, t)
+}
+function paddingObject (keys, padding) {
+  return {
+    public: addPadding(keys.public, padding),
+    private: addPadding(keys.private, padding)
+  }
+}
+function addPadding (key, padding) {
+  if (typeof key === 'string' || Buffer.isBuffer(key)) {
+    return {
+      key: key,
+      padding: padding
+    }
+  }
+  var out = {
+    key: key.key,
+    padding: padding
+  }
+  if ('passphrase' in key) {
+    out.passphrase = key.passphrase
+  }
+  return out
+}
+function testRun (i) {
+  test('run ' + i, function (t) {
+    testIt(rsa1024priv, Buffer.from('1024 2 private keys'), t)
+    testIt(rsa1024, Buffer.from('1024 keys'), t)
+    testIt(rsa2028, Buffer.from('2028 keys'), t)
+    testIt(nonrsa1024, Buffer.from('1024 keys non-rsa key'), t)
+    testIt(pass1024, Buffer.from('1024 keys and password'), t)
+    testIt(nonrsa1024str, Buffer.from('1024 keys non-rsa key as a string'), t)
+    testIt(pass2028, Buffer.from('2028 rsa key with variant passwords'), t)
+  })
+}
+
+var i = 0
+var num = 20
+while (++i <= num) {
+  testRun(i)
+}

package/node_modules/public-encrypt/test/nodeTests.js

@@ -0,0 +1,51 @@
+var crypto = require('../browser')
+var test = require('tape')
+var fs = require('fs')
+var Buffer = require('safe-buffer').Buffer
+var path = require('path')
+// Test RSA encryption/decryption
+test('node tests', function (t) {
+  var keyPem = fs.readFileSync(path.join(__dirname, 'test_key.pem'), 'ascii')
+  var rsaPubPem = fs.readFileSync(path.join(__dirname, 'test_rsa_pubkey.pem'),
+    'ascii')
+  var rsaKeyPem = fs.readFileSync(path.join(__dirname, 'test_rsa_privkey.pem'),
+    'ascii')
+  var rsaKeyPemEncrypted = fs.readFileSync(path.join(
+    __dirname, 'test_rsa_privkey_encrypted.pem'), 'ascii')
+  var input = 'I AM THE WALRUS'
+  var bufferToEncrypt = Buffer.from(input)
+
+  var encryptedBuffer = crypto.publicEncrypt(rsaPubPem, bufferToEncrypt)
+
+  var decryptedBuffer = crypto.privateDecrypt(rsaKeyPem, encryptedBuffer)
+  t.equal(input, decryptedBuffer.toString())
+
+  var decryptedBufferWithPassword = crypto.privateDecrypt({
+    key: rsaKeyPemEncrypted,
+    passphrase: 'password'
+  }, encryptedBuffer)
+  t.equal(input, decryptedBufferWithPassword.toString())
+
+  // encryptedBuffer = crypto.publicEncrypt(certPem, bufferToEncrypt);
+
+  // decryptedBuffer = crypto.privateDecrypt(keyPem, encryptedBuffer);
+  // t.equal(input, decryptedBuffer.toString());
+
+  encryptedBuffer = crypto.publicEncrypt(keyPem, bufferToEncrypt)
+
+  decryptedBuffer = crypto.privateDecrypt(keyPem, encryptedBuffer)
+  t.equal(input, decryptedBuffer.toString())
+
+  encryptedBuffer = crypto.privateEncrypt(keyPem, bufferToEncrypt)
+
+  decryptedBuffer = crypto.publicDecrypt(keyPem, encryptedBuffer)
+  t.equal(input, decryptedBuffer.toString())
+
+  t.throws(function () {
+    crypto.privateDecrypt({
+      key: rsaKeyPemEncrypted,
+      passphrase: 'wrong'
+    }, encryptedBuffer)
+  })
+  t.end()
+})

package/node_modules/public-encrypt/test/pass.1024.priv

@@ -0,0 +1,18 @@
+-----BEGIN ENCRYPTED PRIVATE KEY-----
+MIICzzBJBgkqhkiG9w0BBQ0wPDAbBgkqhkiG9w0BBQwwDgQIji3ZZ6JbsA4CAggA
+MB0GCWCGSAFlAwQBFgQQC6MKblq8zyX90/KmgotsMQSCAoDghNf+yxPC/KRh7F3O
+k0lMgtDkV+wCLDv7aBvUqy8Ry2zqFPIlfLb8XtSW943XEu6KUI13IZPEr8p9h1ve
+Iye6L0g6uAgbFxBE2DwBBSI7mYr7lokr4v0k+inMKf4JeRdI9XWgwOILKTGf1vH7
+PhvBnqLhOg6BIOuF426qpiyYlmRda74d0Th4o6ZyhyMSzPI1XbWSg719Ew3N/tLe
+OHdYl0eFrgNjq+xO4Ev+W7eNIh/XBMQtk9wo+mxeNdldRnX822HxTsL8fSSPs+9T
+W5M/2EBTJMSsswSjZyFkq8ehtxovI2u0IBX1IiPulyUZLnSNPDV1eUVClK6rk+q1
+kVsfJhUr2qvIjNlQWlbEXQj4VwGtgl0++l8vdpj59MuN2J3Nx5TNMLjA6BYAa/tr
+Bu928QoT7ET+SGx5XKCwKb5fwXmDlV5zZC4kZWTaF/d/Icvj5F+fDZuYFg1JOXNZ
++q2oA1qMYaHGX6lF3pbO84ebg1iwQTDM8iIqFeSMGUJTnk/3a7sqfaWQbEQwGb+X
+fXnSTwkF+wO2rriPbFvWyzecWu67zDCP0ZWUgGb86sSJCM7xRGShESwCjOrb88F1
+5SZjyIqogrkc3IWiLH9gc5U8d86qoFjJnP6BfwYks1UIyXNGKfZTCqICpMphV+IS
+b0N2jprjLTkWR6nxYGSH1bkKMs7x1M0FBLWWLAZqPn9X3pe6JwIBds04O6XjF0un
+oxwDjcJdoxVs7PgRiM5d1Tubqu2zmpCCmXNiqi9B0+rV9/jHg9IA5gUfvYdCcEv+
+oAr90I+2+PuBFa9lgdbDV6DtZk4bSYluqamxVeLPg/vrewYfVfDv6jftfY1D0DEy
+69H0
+-----END ENCRYPTED PRIVATE KEY-----

package/node_modules/public-encrypt/test/pass.1024.pub

@@ -0,0 +1,6 @@
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDSK/7i5BV0x+gmX16Wrm7kRkCZ
+y1QUt6wiM2g+SAZTYR0381VnSMX2cv7CpN3499lZj1rL5S7YTaZZwX3RvU5fz56/
+eDX6ciL/PZsbclN2KdkMWYgmcb9J1zUeoMQ3cjfFUCdQZ/ZvDWa+wY2Zg8os2Bow
+AoufHtYHm3eOly/cWwIDAQAB
+-----END PUBLIC KEY-----

package/node_modules/public-encrypt/test/rsa.1024.priv

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICVAIBAAJ/OwswbFo/uyC8ltGf/yA1A+gV5IGdnAgPbUSI3GzbHCA+x+TLG/tL
+vbRw3r1smppY/jkkpiVW1ErSMuN0uixp5gb78Z9rH1XpWb5WWgp3WaY/9EHMjMdO
+kQ/9LVZvRvl/M/Fi6owP+q+amJI1BEjECYfbhGL3rmlVdq4qXc40QwIDAQABAn8I
+VZ0BPoAOhyF33KFMHxy8r28fsVgxJUYgM3NqQgdv4fFawCYXjhJz9duU5YJGFJGJ
+WUGeHlkyYFlpi4f3m7tY7JawmQUWB0MNSoKHI3cgDX4/tfBN8ni+cO0eSoR5czBY
+EsAHBU47p1awNFAHwd+ZEuv9H4RmMn7p279rQTtpAkAH3Nqs2/vrRF2cZUN4fIXf
+4xHsQBByUayGq8a3J0UGaSFWv68zTUKFherr9uZotNp7NJ4jBXiARw0q8docXUG1
+AkAHgmOKHoORtAmikqpmFEJZOtsXMaLCIm4EszPo5ciYoLMBcVit09AdiQlt7ZJL
+DY02svU1b0agCZ97kDkmHDkXAkACa8M9JELuDs/P/vIGYDkMVatIFfW6bWF02eFG
+taWwMqCcSEsWvbw0xqYt34jURpNbCjmCyQVwYfAw/+TLhP9dAkAFwRjdwjw37qpj
+ddg1mNiu37b7swFxmkiMOXZRxaNNsfb56A14RpN3zob3QdGUybGodMIKTFbmU/lu
+CjqAxafJAkAG2yf6RWbwFIWfMyt7WYCh0VaGBCcgy574AinVieEo3ZZyFfC63+xm
+3uoaNy4iLoJv4GCjqUBz3ZfcVaO/DDWG
+-----END RSA PRIVATE KEY-----

package/node_modules/public-encrypt/test/rsa.1024.pub

@@ -0,0 +1,5 @@
+-----BEGIN RSA PUBLIC KEY-----
+MIGGAn87CzBsWj+7ILyW0Z//IDUD6BXkgZ2cCA9tRIjcbNscID7H5Msb+0u9tHDe
+vWyamlj+OSSmJVbUStIy43S6LGnmBvvxn2sfVelZvlZaCndZpj/0QcyMx06RD/0t
+Vm9G+X8z8WLqjA/6r5qYkjUESMQJh9uEYveuaVV2ripdzjRDAgMBAAE=
+-----END RSA PUBLIC KEY-----