public-encrypt - npm Package Compare versions

Comparing version 4.0.2 to 4.0.3

browser.js

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

index.js

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

mgf.js

@@ -1,16 +0,19 @@
-var createHash = require('create-hash');
+var createHash = require('create-hash')
+var Buffer = require('safe-buffer').Buffer
+
 module.exports = function (seed, len) {
-  var t = new Buffer('');
-  var  i = 0, c;
+  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()]);
+    c = i2ops(i++)
+    t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()])
   }
-  return t.slice(0, len);
-};
+  return t.slice(0, len)
+}
 
-function i2ops(c) {
-  var out = new Buffer(4);
-  out.writeUInt32BE(c,0);
-  return out;
-}
+function i2ops (c) {
+  var out = Buffer.allocUnsafe(4)
+  out.writeUInt32BE(c, 0)
+  return out
+}

package.json

 {
   "name": "public-encrypt",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "description": "browserify version of publicEncrypt & privateDecrypt",
@@ -11,3 +11,4 @@ "main": "index.js",
   "scripts": {
-    "test": "node test/index.js | tspec"
+    "test": "node test/index.js | tspec",
+    "lint": "standard"
   },
@@ -29,8 +30,10 @@ "repository": {
     "parse-asn1": "^5.0.0",
-    "randombytes": "^2.0.1"
+    "randombytes": "^2.0.1",
+    "safe-buffer": "^5.1.2"
   },
   "devDependencies": {
-    "tape": "^3.0.3",
-    "tap-spec": "^2.1.2"
+    "standard": "^12.0.0",
+    "tap-spec": "^2.1.2",
+    "tape": "^3.0.3"
   }
 }

privateDecrypt.js

@@ -1,108 +0,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');
-module.exports = function privateDecrypt(private_key, enc, reverse) {
-  var padding;
-  if (private_key.padding) {
-    padding = private_key.padding;
+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;
+    padding = 1
   } else {
-    padding = 4;
+    padding = 4
   }
-  
-  var key = parseKeys(private_key);
-  var k = key.modulus.byteLength();
-  if (enc.length > k || new bn(enc).cmp(key.modulus) >= 0) {
-    throw new Error('decryption error');
+
+  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;
+  var msg
   if (reverse) {
-    msg = withPublic(new bn(enc), key);
+    msg = withPublic(new BN(enc), key)
   } else {
-    msg = crt(enc, key);
+    msg = crt(enc, key)
   }
-  var zBuffer = new Buffer(k - msg.length);
-  zBuffer.fill(0);
-  msg = Buffer.concat([zBuffer, msg], k);
+  var zBuffer = Buffer.alloc(k - msg.length)
+  msg = Buffer.concat([zBuffer, msg], k)
   if (padding === 4) {
-    return oaep(key, msg);
+    return oaep(key, msg)
   } else if (padding === 1) {
-    return pkcs1(key, msg, reverse);
+    return pkcs1(key, msg, reverse)
   } else if (padding === 3) {
-    return msg;
+    return msg
   } else {
-    throw new Error('unknown padding');
+    throw new Error('unknown padding')
   }
-};
+}
 
-function oaep(key, msg){
-  var n = key.modulus;
-  var k = key.modulus.byteLength();
-  var mLen = msg.length;
-  var iHash = createHash('sha1').update(new Buffer('')).digest();
-  var hLen = iHash.length;
-  var hLen2 = 2 * hLen;
+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');
+    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));
+  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');
+    throw new Error('decryption error')
   }
-  var i = hLen;
+  var i = hLen
   while (db[i] === 0) {
-    i++;
+    i++
   }
   if (db[i++] !== 1) {
-    throw new Error('decryption error');
+    throw new Error('decryption error')
   }
-  return db.slice(i);
+  return db.slice(i)
 }
 
-function pkcs1(key, msg, reverse){
-  var p1 = msg.slice(0, 2);
-  var i = 2;
-  var status = 0;
+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;
+      status++
+      break
     }
   }
-  var ps = msg.slice(2, i - 1);
-  var p2 = msg.slice(i - 1, i);
+  var ps = msg.slice(2, i - 1)
 
-  if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !== '0001' && reverse)){
-    status++;
+  if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !== '0001' && reverse)) {
+    status++
   }
   if (ps.length < 8) {
-    status++;
+    status++
   }
   if (status) {
-    throw new Error('decryption error');
+    throw new Error('decryption error')
   }
-  return  msg.slice(i);
+  return msg.slice(i)
 }
-function compare(a, b){
-  a = new Buffer(a);
-  b = new Buffer(b);
-  var dif = 0;
-  var len = a.length;
+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);
+    dif++
+    len = Math.min(a.length, b.length)
   }
-  var i = -1;
+  var i = -1
   while (++i < len) {
-    dif += (a[i] ^ b[i]);
+    dif += (a[i] ^ b[i])
   }
-  return dif;
-}
+  return dif
+}

publicEncrypt.js

@@ -1,95 +0,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 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
 
-var constants = {
-  RSA_PKCS1_OAEP_PADDING: 4,
-  RSA_PKCS1_PADDIN: 1,
-  RSA_NO_PADDING: 3
-};
-
-module.exports = function publicEncrypt(public_key, msg, reverse) {
-  var padding;
-  if (public_key.padding) {
-    padding = public_key.padding;
+module.exports = function publicEncrypt (publicKey, msg, reverse) {
+  var padding
+  if (publicKey.padding) {
+    padding = publicKey.padding
   } else if (reverse) {
-    padding = 1;
+    padding = 1
   } else {
-    padding = 4;
+    padding = 4
   }
-  var key = parseKeys(public_key);
-  var paddedMsg;
+  var key = parseKeys(publicKey)
+  var paddedMsg
   if (padding === 4) {
-    paddedMsg = oaep(key, msg);
+    paddedMsg = oaep(key, msg)
   } else if (padding === 1) {
-    paddedMsg = pkcs1(key, msg, reverse);
+    paddedMsg = pkcs1(key, msg, reverse)
   } else if (padding === 3) {
-    paddedMsg = new bn(msg);
+    paddedMsg = new BN(msg)
     if (paddedMsg.cmp(key.modulus) >= 0) {
-      throw new Error('data too long for modulus');
+      throw new Error('data too long for modulus')
     }
   } else {
-    throw new Error('unknown padding');
+    throw new Error('unknown padding')
   }
   if (reverse) {
-    return crt(paddedMsg, key);
+    return crt(paddedMsg, key)
   } else {
-    return withPublic(paddedMsg, key);
+    return withPublic(paddedMsg, key)
   }
-};
+}
 
-function oaep(key, msg){
-  var k = key.modulus.byteLength();
-  var mLen = msg.length;
-  var iHash = createHash('sha1').update(new Buffer('')).digest();
-  var hLen = iHash.length;
-  var hLen2 = 2 * hLen;
+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');
+    throw new Error('message too long')
   }
-  var ps = new Buffer(k - mLen - hLen2 - 2);
-  ps.fill(0);
-  var dblen = k - hLen - 1;
-  var seed = randomBytes(hLen);
-  var maskedDb = xor(Buffer.concat([iHash, ps, new Buffer([1]), msg], dblen), mgf(seed, dblen));
-  var maskedSeed = xor(seed, mgf(maskedDb, hLen));
-  return new bn(Buffer.concat([new Buffer([0]), maskedSeed, maskedDb], k));
+  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();
+function pkcs1 (key, msg, reverse) {
+  var mLen = msg.length
+  var k = key.modulus.byteLength()
   if (mLen > k - 11) {
-    throw new Error('message too long');
+    throw new Error('message too long')
   }
-  var ps;
+  var ps
   if (reverse) {
-    ps = new Buffer(k - mLen - 3);
-    ps.fill(0xff);
+    ps = Buffer.alloc(k - mLen - 3, 0xff)
   } else {
-    ps = nonZero(k - mLen - 3);
+    ps = nonZero(k - mLen - 3)
   }
-  return new bn(Buffer.concat([new Buffer([0, reverse?1:2]), ps, new Buffer([0]), msg], k));
+  return new BN(Buffer.concat([Buffer.from([0, reverse ? 1 : 2]), ps, Buffer.alloc(1), msg], k))
 }
-function nonZero(len, crypto) {
-  var out = new Buffer(len);
-  var i = 0;
-  var cache = randomBytes(len*2);
-  var cur = 0;
-  var num;
+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;
+      cache = randomBytes(len * 2)
+      cur = 0
     }
-    num = cache[cur++];
+    num = cache[cur++]
     if (num) {
-      out[i++] = num;
+      out[i++] = num
     }
   }
-  return out;
-}
+  return out
+}

readme.md

@@ -6,2 +6,4 @@ publicEncrypt
 
-publicEncrypt/privateDecrypt for browserify
+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)

test/index.js

@@ -1,86 +0,82 @@
-var test = require('tape');
-var fs = require('fs');
-var constants = require('constants');
-var parseKeys = require('parse-asn1');
-require('./nodeTests');
-var priv1024 = fs.readFileSync(__dirname + '/rsa.1024.priv');
+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(__dirname + '/rsa.1024.priv'),
-  public: fs.readFileSync(__dirname + '/rsa.1024.pub')
-};
+  private: fs.readFileSync(path.join(__dirname, 'rsa.1024.priv')),
+  public: fs.readFileSync(path.join(__dirname, 'rsa.1024.pub'))
+}
 var rsa1024priv = {
-  private: fs.readFileSync(__dirname + '/rsa.1024.priv'),
-  public: fs.readFileSync(__dirname + '/rsa.1024.priv')
-};
-var rsa1024 = {
-  private: fs.readFileSync(__dirname + '/rsa.1024.priv'),
-  public: fs.readFileSync(__dirname + '/rsa.1024.pub')
-};
+  private: fs.readFileSync(path.join(__dirname, 'rsa.1024.priv')),
+  public: fs.readFileSync(path.join(__dirname, 'rsa.1024.priv'))
+}
+
 var rsa2028 = {
-  private: fs.readFileSync(__dirname + '/rsa.2028.priv'),
-  public: fs.readFileSync(__dirname + '/rsa.2028.pub')
-};
+  private: fs.readFileSync(path.join(__dirname, 'rsa.2028.priv')),
+  public: fs.readFileSync(path.join(__dirname, 'rsa.2028.pub'))
+}
 var nonrsa1024 = {
-  private: fs.readFileSync(__dirname + '/1024.priv'),
-  public: fs.readFileSync(__dirname + '/1024.pub')
-};
+  private: fs.readFileSync(path.join(__dirname, '1024.priv')),
+  public: fs.readFileSync(path.join(__dirname, '1024.pub'))
+}
 var nonrsa1024str = {
-  private: fs.readFileSync(__dirname + '/1024.priv').toString(),
-  public: fs.readFileSync(__dirname + '/1024.pub').toString()
-};
+  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(__dirname + '/pass.1024.priv')
+    key: fs.readFileSync(path.join(__dirname, 'pass.1024.priv'))
   },
-  public: fs.readFileSync(__dirname + '/pass.1024.pub')
-};
+  public: fs.readFileSync(path.join(__dirname, 'pass.1024.pub'))
+}
 var pass2028 = {
   private: {
     passphrase: 'password',
-    key:fs.readFileSync(__dirname + '/rsa.pass.priv')
+    key: fs.readFileSync(path.join(__dirname, 'rsa.pass.priv'))
   },
-  public: fs.readFileSync(__dirname + '/rsa.pass.pub')
-};
+  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;
+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);
+    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');
-
-  });
+    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, new Buffer(' with RSA_PKCS1_PADDING')]), t);
-  var parsedKey = parseKeys(keys.public);
-  var k = parsedKey.modulus.byteLength();
-  var zBuf = new Buffer(k);
-  zBuf.fill(0);
-  var msg = Buffer.concat([zBuf, message, new Buffer(' with no padding')]).slice(-k);
-  _testIt(paddingObject(keys, 3), msg, t);
+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) {
+function paddingObject (keys, padding) {
   return {
     public: addPadding(keys.public, padding),
     private: addPadding(keys.private, padding)
-  };
+  }
 }
-function addPadding(key, padding) {
+function addPadding (key, padding) {
   if (typeof key === 'string' || Buffer.isBuffer(key)) {
@@ -90,29 +86,29 @@ return {
       padding: padding
-    };
+    }
   }
   var out = {
     key: key.key,
-    padding:padding
-  };
+    padding: padding
+  }
   if ('passphrase' in key) {
-    out.passphrase = key.passphrase;
+    out.passphrase = key.passphrase
   }
-  return out;
+  return out
 }
-function testRun(i) {
+function testRun (i) {
   test('run ' + i, function (t) {
-    testIt(rsa1024priv, new Buffer('1024 2 private keys'), t);
-    testIt(rsa1024, new Buffer('1024 keys'), t);
-    testIt(rsa2028, new Buffer('2028 keys'), t);
-    testIt(nonrsa1024, new Buffer('1024 keys non-rsa key'), t);
-    testIt(pass1024, new Buffer('1024 keys and password'), t);
-    testIt(nonrsa1024str, new Buffer('1024 keys non-rsa key as a string'), t);
-    testIt(pass2028, new Buffer('2028 rsa key with variant passwords'), 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 <= 20) {
-  testRun(i);
+var i = 0
+var num = 20
+while (++i <= num) {
+  testRun(i)
 }

test/nodeTests.js

@@ -1,22 +0,22 @@
-var crypto = require('../browser');
-var test = require('tape');
-var fs = require('fs');
-
+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 certPem = fs.readFileSync(__dirname + '/test_cert.pem', 'ascii');
-  var keyPem = fs.readFileSync(__dirname + '/test_key.pem', 'ascii');
-  var rsaPubPem = fs.readFileSync(__dirname + '/test_rsa_pubkey.pem',
-      'ascii');
-  var rsaKeyPem = fs.readFileSync(__dirname + '/test_rsa_privkey.pem',
-      'ascii');
-  var rsaKeyPemEncrypted = fs.readFileSync(
-  __dirname + '/test_rsa_privkey_encrypted.pem', 'ascii');
-  var input = 'I AM THE WALRUS';
-  var bufferToEncrypt = new Buffer(input);
+  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 encryptedBuffer = crypto.publicEncrypt(rsaPubPem, bufferToEncrypt)
 
-  var decryptedBuffer = crypto.privateDecrypt(rsaKeyPem, encryptedBuffer);
-  t.equal(input, decryptedBuffer.toString());
+  var decryptedBuffer = crypto.privateDecrypt(rsaKeyPem, encryptedBuffer)
+  t.equal(input, decryptedBuffer.toString())
 
@@ -26,4 +26,4 @@ var decryptedBufferWithPassword = crypto.privateDecrypt({
     passphrase: 'password'
-  }, encryptedBuffer);
-  t.equal(input, decryptedBufferWithPassword.toString());
+  }, encryptedBuffer)
+  t.equal(input, decryptedBufferWithPassword.toString())
 
@@ -35,19 +35,19 @@ // encryptedBuffer = crypto.publicEncrypt(certPem, bufferToEncrypt);
 
-  encryptedBuffer = crypto.publicEncrypt(keyPem, bufferToEncrypt);
+  encryptedBuffer = crypto.publicEncrypt(keyPem, bufferToEncrypt)
 
-  decryptedBuffer = crypto.privateDecrypt(keyPem, encryptedBuffer);
-  t.equal(input, decryptedBuffer.toString());
+  decryptedBuffer = crypto.privateDecrypt(keyPem, encryptedBuffer)
+  t.equal(input, decryptedBuffer.toString())
 
-  encryptedBuffer = crypto.privateEncrypt(keyPem, bufferToEncrypt);
+  encryptedBuffer = crypto.privateEncrypt(keyPem, bufferToEncrypt)
 
-  decryptedBuffer = crypto.publicDecrypt(keyPem, encryptedBuffer);
-  t.equal(input, decryptedBuffer.toString());
+  decryptedBuffer = crypto.publicDecrypt(keyPem, encryptedBuffer)
+  t.equal(input, decryptedBuffer.toString())
 
-  t.throws(function() {
+  t.throws(function () {
     crypto.privateDecrypt({
       key: rsaKeyPemEncrypted,
       passphrase: 'wrong'
-    }, encryptedBuffer);
-  });
-  t.end();
-});
+    }, encryptedBuffer)
+  })
+  t.end()
+})

withPublic.js

@@ -1,10 +0,12 @@
-var bn = require('bn.js');
-function withPublic(paddedMsg, key) {
-  return new Buffer(paddedMsg
-    .toRed(bn.mont(key.modulus))
-    .redPow(new bn(key.publicExponent))
+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());
+    .toArray())
 }
 
-module.exports = withPublic;
+module.exports = withPublic

xor.js

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

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

27803

increased by0.01%

Number of lines in readme file

9

increased by50%

Worsened metrics

Dependency count

6

increased by20%

Dev dependency count

3

increased by50%

Lines of code

394

decreased by-0.76%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Addedsafe-buffer@^5.1.2