Beta 7 with some repo names changed.

Client/node_modules/public-encrypt/browser.js

@@ -0,0 +1,10 @@
+exports.publicEncrypt = require('./publicEncrypt')
+exports.privateDecrypt = require('./privateDecrypt')
+
+exports.privateEncrypt = function privateEncrypt (key, buf) {
+  return exports.publicEncrypt(key, buf, true)
+}
+
+exports.publicDecrypt = function publicDecrypt (key, buf) {
+  return exports.privateDecrypt(key, buf, true)
+}

Client/node_modules/public-encrypt/index.js

@@ -0,0 +1,18 @@
+var crypto = require('crypto')
+if (typeof crypto.publicEncrypt !== 'function') {
+  crypto = require('./browser')
+}
+exports.publicEncrypt = crypto.publicEncrypt
+exports.privateDecrypt = crypto.privateDecrypt
+
+if (typeof crypto.privateEncrypt !== 'function') {
+  exports.privateEncrypt = require('./browser').privateEncrypt
+} else {
+  exports.privateEncrypt = crypto.privateEncrypt
+}
+
+if (typeof crypto.publicDecrypt !== 'function') {
+  exports.publicDecrypt = require('./browser').publicDecrypt
+} else {
+  exports.publicDecrypt = crypto.publicDecrypt
+}

Client/node_modules/public-encrypt/mgf.js

@@ -0,0 +1,19 @@
+var createHash = require('create-hash')
+var Buffer = require('safe-buffer').Buffer
+
+module.exports = function (seed, len) {
+  var t = Buffer.alloc(0)
+  var i = 0
+  var c
+  while (t.length < len) {
+    c = i2ops(i++)
+    t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()])
+  }
+  return t.slice(0, len)
+}
+
+function i2ops (c) {
+  var out = Buffer.allocUnsafe(4)
+  out.writeUInt32BE(c, 0)
+  return out
+}

Client/node_modules/public-encrypt/package.json

@@ -0,0 +1,64 @@
+{
+  "_from": "public-encrypt@^4.0.0",
+  "_id": "public-encrypt@4.0.3",
+  "_inBundle": false,
+  "_integrity": "sha512-zVpa8oKZSz5bTMTFClc1fQOnyyEzpl5ozpi1B5YcvBrdohMjH2rfsBtyXcuNuwjsDIXmBYlF2N5FlJYhR29t8Q==",
+  "_location": "/public-encrypt",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "public-encrypt@^4.0.0",
+    "name": "public-encrypt",
+    "escapedName": "public-encrypt",
+    "rawSpec": "^4.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^4.0.0"
+  },
+  "_requiredBy": [
+    "/crypto-browserify"
+  ],
+  "_resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.3.tgz",
+  "_shasum": "4fcc9d77a07e48ba7527e7cbe0de33d0701331e0",
+  "_spec": "public-encrypt@^4.0.0",
+  "_where": "C:\\Users\\Luis\\source\\repos\\AAMasters\\BackendServers\\node_modules\\crypto-browserify",
+  "author": {
+    "name": "Calvin Metcalf"
+  },
+  "browser": "browser.js",
+  "bugs": {
+    "url": "https://github.com/crypto-browserify/publicEncrypt/issues"
+  },
+  "bundleDependencies": false,
+  "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"
+  },
+  "deprecated": false,
+  "description": "browserify version of publicEncrypt & privateDecrypt",
+  "devDependencies": {
+    "standard": "^12.0.0",
+    "tap-spec": "^2.1.2",
+    "tape": "^3.0.3"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "homepage": "https://github.com/crypto-browserify/publicEncrypt",
+  "license": "MIT",
+  "main": "index.js",
+  "name": "public-encrypt",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/crypto-browserify/publicEncrypt.git"
+  },
+  "scripts": {
+    "lint": "standard",
+    "test": "node test/index.js | tspec"
+  },
+  "version": "4.0.3"
+}

Client/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
+}

Client/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
+}

Client/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)
+}

Client/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()
+})

Client/node_modules/public-encrypt/withPublic.js

@@ -0,0 +1,12 @@
+var BN = require('bn.js')
+var Buffer = require('safe-buffer').Buffer
+
+function withPublic (paddedMsg, key) {
+  return Buffer.from(paddedMsg
+    .toRed(BN.mont(key.modulus))
+    .redPow(new BN(key.publicExponent))
+    .fromRed()
+    .toArray())
+}
+
+module.exports = withPublic

Client/node_modules/public-encrypt/xor.js

@@ -0,0 +1,8 @@
+module.exports = function xor (a, b) {
+  var len = a.length
+  var i = -1
+  while (++i < len) {
+    a[i] ^= b[i]
+  }
+  return a
+}