encrypt/decrypt methods now using native implementation if possible

rzcoder · rzcoder · commit e24877322127 · 2015-02-26T23:46:22.000+05:00
diff --git a/README.md b/README.md
@@ -29,7 +29,7 @@ console.log('decrypted: ', decrypted);
 ```shell
 npm install node-rsa
 ```
-*Requires nodejs >= 0.10.x*
+*Requires nodejs >= 0.10.x or io.js >= 1.x*
 
 ### Testing
 
@@ -58,10 +58,8 @@ var key = new NodeRSA([keyData, [format]], [options]);
 You can specify some options by second/third constructor argument, or over `key.setOptions()` method.
 
 * environment — working environment (default autodetect):
-    * `'browser'`,
-    * `'node10'` for `nodejs 0.10.x` — provide native sign/verify methods.
-    * `'node'` for `nodejs 0.12.x` — provide also native publicEncrypt/privateDecrypt methods.
-    * `'iojs'` for `io.js 1.x` — provide also native publicDecrypt/privateEncrypt methods.
+    * `'browser'` — will run pure js implementation of RSA algorithms.
+    * `'node'` for `nodejs >= 0.10.x or io.js >= 1.x` — provide some native methods like sign/verify and encrypt/decrypt.
 * encryptionScheme — padding scheme for encrypt/decrypt. Can be `'pkcs1_oaep'` or `'pkcs1'`. Default `'pkcs1_oaep'`.
 * signingScheme — scheme used for signing and verifying. Can be `'pkcs1'` or `'pss'` or 'scheme-hash' format string (eg `'pss-sha1'`). Default `'pkcs1-sha256'`, or, if chosen pss: `'pss-sha1'`.
 
@@ -187,6 +185,7 @@ Return max data size for encrypt in bytes.
 
 ```javascript
 key.encrypt(buffer, [encoding], [source_encoding]);
+key.encryptPrivate(buffer, [encoding], [source_encoding]); // using private key for encryption
 ```
 Return encrypted data.<br/>
 
@@ -196,6 +195,7 @@ Return encrypted data.<br/>
 
 ```javascript
 key.decrypt(buffer, [encoding]);
+key.decryptPublic(buffer, [encoding]); // using public key for decryption
 ```
 Return decrypted data.<br/>
 
@@ -224,6 +224,13 @@ Questions, comments, bug reports, and pull requests are all welcome.
 
 ## Changelog
 
+### 0.2.20
+ * Added `.encryptPrivate()` and `.decryptPublic()` methods
+ * Encrypt/decrypt methods in nodejs 0.12.x and io.js using native implementation (40x speed boost)
+ * **KNOWN ISSUES**:
+    * `encryptPrivate` and `decryptPublic` don't have native implementation in nodejs
+    * `encryptPrivate` and `decryptPublic` with pkcs1_oaep padding scheme don't work in io.js and using js implementation
+
 ### 0.2.10
  * **Methods `.exportPrivate()` and `.exportPublic()` was replaced by `.exportKey([format])`.**
     * By default `.exportKey()` returns private key as `.exportPrivate()`, if you need public key from `.exportPublic()` you must specify format as `'public'` or `'pkcs8-public-pem'`.
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "node-rsa",
-  "version": "0.2.13",
+  "version": "0.2.20",
   "description": "Node.js RSA library",
   "main": "src/NodeRSA.js",
   "scripts": {
diff --git a/src/encryptEngines/encryptEngines.js b/src/encryptEngines/encryptEngines.js
@@ -0,0 +1,19 @@
+var crypt = require('crypto');
+
+module.exports = {
+    getEngine: function (keyPair, options) {
+        var engine;
+        if (options.environment === 'browser') {
+            engine = require('./js.js');
+        } else {
+            if (typeof crypt.publicEncrypt === 'function' && typeof crypt.privateDecrypt === 'function') {
+                if (typeof crypt.privateEncrypt === 'function' && typeof crypt.publicDecrypt === 'function') {
+                    engine = require('./io.js');
+                } else {
+                    engine = require('./node12.js');
+                }
+            }
+        }
+        return engine(keyPair, options);
+    }
+};
diff --git a/src/encryptEngines/io.js b/src/encryptEngines/io.js
@@ -0,0 +1,56 @@
+var crypto = require('crypto');
+var constants = require('constants');
+
+module.exports = function (keyPair, options) {
+    var jsEngine = require('./js.js')(keyPair);
+
+    return {
+        encrypt: function (buffer, usePrivate) {
+            var padding = constants.RSA_PKCS1_OAEP_PADDING;
+            if (options.encryptionScheme === 'pkcs1') {
+                padding = constants.RSA_PKCS1_PADDING;
+            }
+
+            /* io.js 1.3.x bug */
+            if (padding === constants.RSA_PKCS1_OAEP_PADDING) {
+                return jsEngine.encrypt(buffer, usePrivate);
+            }
+
+            if (usePrivate) {
+                return crypto.privateEncrypt({
+                    key: options.rsaUtils.exportKey('private'),
+                    padding: padding
+                }, buffer);
+            } else {
+                return crypto.publicEncrypt({
+                    key: options.rsaUtils.exportKey('public'),
+                    padding: padding
+                }, buffer);
+            }
+        },
+
+        decrypt: function (buffer, usePublic) {
+            var padding = constants.RSA_PKCS1_OAEP_PADDING;
+            if (options.encryptionScheme === 'pkcs1') {
+                padding = constants.RSA_PKCS1_PADDING;
+            }
+
+            /* io.js 1.3.x bug */
+            if (padding === constants.RSA_PKCS1_OAEP_PADDING) {
+                return jsEngine.decrypt(buffer, usePrivate);
+            }
+
+            if (usePublic) {
+                return crypto.publicDecrypt({
+                    key: options.rsaUtils.exportKey('public'),
+                    padding: padding
+                }, buffer);
+            } else {
+                return crypto.privateDecrypt({
+                    key: options.rsaUtils.exportKey('private'),
+                    padding: padding
+                }, buffer);
+            }
+        }
+    };
+};
diff --git a/src/encryptEngines/js.js b/src/encryptEngines/js.js
@@ -0,0 +1,17 @@
+var BigInteger = require('../libs/jsbn.js');
+
+module.exports = function (keyPair, options) {
+    return {
+        encrypt: function (buffer, usePrivate) {
+            var m = new BigInteger(keyPair.encryptionScheme.encPad(buffer));
+            var c = usePrivate ? keyPair.$doPrivate(m) : keyPair.$doPublic(m);
+            return c.toBuffer(keyPair.encryptedDataLength);
+        },
+
+        decrypt: function (buffer, usePublic) {
+            var c = new BigInteger(buffer);
+            var m = usePublic ? keyPair.$doPublic(c) : keyPair.$doPrivate(c);
+            return keyPair.encryptionScheme.encUnPad(m.toBuffer(keyPair.encryptedDataLength));
+        }
+    };
+};
diff --git a/src/encryptEngines/node12.js b/src/encryptEngines/node12.js
@@ -0,0 +1,38 @@
+var crypto = require('crypto');
+var constants = require('constants');
+
+module.exports = function (keyPair, options) {
+    var jsEngine = require('./js.js')(keyPair);
+
+    return {
+        encrypt: function (buffer, usePrivate) {
+            if (usePrivate) {
+                return jsEngine.encrypt(buffer, usePrivate);
+            }
+            var padding = constants.RSA_PKCS1_OAEP_PADDING;
+            if (options.encryptionScheme === 'pkcs1') {
+                padding = constants.RSA_PKCS1_PADDING;
+            }
+
+            return crypto.publicEncrypt({
+                key: options.rsaUtils.exportKey('public'),
+                padding: padding
+            }, buffer);
+        },
+
+        decrypt: function (buffer, usePublic) {
+            if (usePublic) {
+                return jsEngine.decrypt(buffer, usePublic);
+            }
+            var padding = constants.RSA_PKCS1_OAEP_PADDING;
+            if (options.encryptionScheme === 'pkcs1') {
+                padding = constants.RSA_PKCS1_PADDING;
+            }
+
+            return crypto.privateDecrypt({
+                key: options.rsaUtils.exportKey('private'),
+                padding: padding
+            }, buffer);
+        }
+    };
+};
diff --git a/src/libs/rsa.js b/src/libs/rsa.js
@@ -44,9 +44,10 @@ var crypt = require('crypto');
 var BigInteger = require('./jsbn.js');
 var utils = require('../utils.js');
 var schemes = require('../schemes/schemes.js');
+var encryptEngines = require('../encryptEngines/encryptEngines.js');
 
 exports.BigInteger = BigInteger;
-module.exports.Key = (function() {
+module.exports.Key = (function () {
     /**
      * RSA key constructor
      *
@@ -80,6 +81,8 @@ module.exports.Key = (function() {
             this.encryptionScheme = encryptionSchemeProvider.makeScheme(this, options);
             this.signingScheme = signingSchemeProvider.makeScheme(this, options);
         }
+
+        this.encryptEngine = encryptEngines.getEngine(this, options);
     };
 
     /**
@@ -91,13 +94,13 @@ module.exports.Key = (function() {
         var qs = B >> 1;
         this.e = parseInt(E, 16);
         var ee = new BigInteger(E, 16);
-        for (; ;) {
-            for (; ;) {
+        while (true) {
+            while (true) {
                 this.p = new BigInteger(B - qs, 1);
                 if (this.p.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) === 0 && this.p.isProbablePrime(10))
                     break;
             }
-            for (; ;) {
+            while (true) {
                 this.q = new BigInteger(qs, 1);
                 if (this.q.subtract(BigInteger.ONE).gcd(ee).compareTo(BigInteger.ONE) === 0 && this.q.isProbablePrime(10))
                     break;
@@ -213,26 +216,16 @@ module.exports.Key = (function() {
         var buffersCount = Math.ceil(bufferSize / this.maxMessageLength) || 1; // total buffers count for encrypt
         var dividedSize = Math.ceil(bufferSize / buffersCount || 1); // each buffer size
 
-        if ( buffersCount == 1) {
+        if (buffersCount == 1) {
             buffers.push(buffer);
         } else {
             for (var bufNum = 0; bufNum < buffersCount; bufNum++) {
-                buffers.push(buffer.slice(bufNum * dividedSize, (bufNum+1) * dividedSize));
+                buffers.push(buffer.slice(bufNum * dividedSize, (bufNum + 1) * dividedSize));
             }
         }
 
-        for(var i = 0; i < buffers.length; i++) {
-            var buf = buffers[i];
-
-            var m = new BigInteger(this.encryptionScheme.encPad(buf));
-            var c = usePrivate ? this.$doPrivate(m) : this.$doPublic(m);
-
-            if (c === null) {
-                return null;
-            }
-
-            var encryptedBuffer = c.toBuffer(this.encryptedDataLength);
-            results.push(encryptedBuffer);
+        for (var i = 0; i < buffers.length; i++) {
+            results.push(this.encryptEngine.encrypt(buffers[i], usePrivate));
         }
 
         return Buffer.concat(results);
@@ -256,11 +249,7 @@ module.exports.Key = (function() {
         for (var i = 0; i < buffersCount; i++) {
             offset = i * this.encryptedDataLength;
             length = offset + this.encryptedDataLength;
-
-            var c = new BigInteger(buffer.slice(offset, Math.min(length, buffer.length)));
-            var m = usePublic ? this.$doPublic(c) : this.$doPrivate(c);
-
-            result.push(this.encryptionScheme.encUnPad(m.toBuffer(this.encryptedDataLength)));
+            result.push(this.encryptEngine.decrypt(buffer.slice(offset, Math.min(length, buffer.length)), usePublic));
         }
 
         return Buffer.concat(result);
@@ -290,15 +279,21 @@ module.exports.Key = (function() {
     };
 
     Object.defineProperty(RSAKey.prototype, 'keySize', {
-        get: function() { return this.cache.keyBitLength; }
+        get: function () {
+            return this.cache.keyBitLength;
+        }
     });
 
     Object.defineProperty(RSAKey.prototype, 'encryptedDataLength', {
-        get: function() { return this.cache.keyByteLength; }
+        get: function () {
+            return this.cache.keyByteLength;
+        }
     });
 
     Object.defineProperty(RSAKey.prototype, 'maxMessageLength', {
-        get: function() { return this.encryptionScheme.maxMessageLength(); }
+        get: function () {
+            return this.encryptionScheme.maxMessageLength();
+        }
     });
 
     /**
diff --git a/src/utils.js b/src/utils.js
@@ -23,13 +23,7 @@ module.exports.linebrk = function (str, maxLen) {
 
 module.exports.detectEnvironment = function () {
     if (process && process.title != 'browser') {
-        if (typeof crypt.publicEncrypt === 'function' && typeof crypt.privateDecrypt === 'function') {
-            if (typeof crypt.publicDecrypt === 'function' && typeof crypt.privateEncrypt === 'function') {
-                return 'iojs';
-            }
-            return 'node';
-        }
-        return 'node10';
+        return 'node';
     } else if (window) {
         return 'browser';
     }
diff --git a/test/tests.js b/test/tests.js
@@ -17,13 +17,11 @@ describe("NodeRSA", function(){
         {b: 1024} // 'e' should be 65537
     ];
 
-    var environments = ['browser', 'node10', 'node', 'iojs'];
+    var environments = ['browser', 'node'];
     var encryptSchemes = ['pkcs1', 'pkcs1_oaep'];
     var signingSchemes = ['pkcs1', 'pss'];
     var signHashAlgorithms = {
         'node': ['MD4', 'MD5', 'RIPEMD160', 'SHA', 'SHA1', 'SHA224', 'SHA256', 'SHA384', 'SHA512'],
-        'node10': ['MD4', 'MD5', 'RIPEMD160', 'SHA', 'SHA1', 'SHA224', 'SHA256', 'SHA384', 'SHA512'],
-        'iojs': ['MD4', 'MD5', 'RIPEMD160', 'SHA', 'SHA1', 'SHA224', 'SHA256', 'SHA384', 'SHA512'],
         'browser': ['MD5', 'RIPEMD160', 'SHA1', 'SHA256', 'SHA512']
     };
 

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "node-rsa",`
`3`		`- "version": "0.2.13",`
	`3`	`+ "version": "0.2.20",`
`4`	`4`	`"description": "Node.js RSA library",`
`5`	`5`	`"main": "src/NodeRSA.js",`
`6`	`6`	`"scripts": {`