Added support for loading PEM key from Buffer (fs.readFileSync output)

Added isEmpty() method

Author: rzcoder

README.md

@@ -81,7 +81,7 @@ Also you can use next methods:
 
 ```javascript
 key.generateKeyPair([bits], [exp]);
-key.loadFromPEM(pem_string);
+key.loadFromPEM(pem_string|buffer_contains_pem);
 ```
 **bits** - key size in bits. 2048 by default.  
 **exp** - public exponent. 65537 by default.
@@ -101,6 +101,11 @@ key.isPublic([strict]);
 ```
 **strict** - if true method will return false if key pair have private exponent. Default `false`.
 
+```javascript
+key.isEmpty();
+```
+Return `true` if key pair doesn't have any data.
+
 #### Key info
 ```javascript
 key.getKeySize();
@@ -150,6 +155,13 @@ Questions, comments, bug reports, and pull requests are all welcome.
 
 ## Changelog
 
+### 0.1.54
+ * Added support for loading PEM key from Buffer (fs.readFileSync output)
+ * Added `isEmpty()` method
+
+### 0.1.54
+ * Improve work with not properly trimming PEM strings
+
 ### 0.1.50
  * Implemented native js signing and verifying for browsers
  * `options.signingAlgorithm` now takes only hash-algorithm name

package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-rsa",
-  "version": "0.1.53",
+  "version": "0.1.54",
   "description": "Node.js RSA library",
   "main": "src/NodeRSA.js",
   "scripts": {

src/NodeRSA.js

@@ -17,10 +17,14 @@ var PUBLIC_RSA_OID = '1.2.840.113549.1.1.1';
 
 module.exports = (function() {
     /**
-     * @param key {string|object} Key in PEM format, or data for generate key {b: bits, e: exponent}
+     * @param key {string|buffer|object} Key in PEM format, or data for generate key {b: bits, e: exponent}
      * @constructor
      */
     function NodeRSA(key, options) {
+        if (! this instanceof NodeRSA) {
+            return new NodeRSA(key, options);
+        }
+
         this.keyPair = new rsa.Key();
         this.$cache = {};
 
@@ -29,10 +33,10 @@ module.exports = (function() {
             environment: utils.detectEnvironment()
         }, options  || {});
 
-        if (_.isObject(key)) {
-            this.generateKeyPair(key.b, key.e);
-        } else if (_.isString(key)) {
+        if (Buffer.isBuffer(key) || _.isString(key)) {
             this.loadFromPEM(key);
+        } else if (_.isObject(key)) {
+            this.generateKeyPair(key.b, key.e);
         }
     }
 
@@ -61,9 +65,13 @@ module.exports = (function() {
      * @param pem {string}
      */
     NodeRSA.prototype.loadFromPEM = function(pem) {
-        if (/^\s*-----BEGIN RSA PRIVATE KEY-----\s([A-Za-z0-9+/=]+\s)+-----END RSA PRIVATE KEY-----\s*$/g.test(pem)) {
+        if (Buffer.isBuffer(pem)) {
+            pem = pem.toString('utf8');
+        }
+
+        if (/^\s*-----BEGIN RSA PRIVATE KEY-----\s*([A-Za-z0-9+/=]+\s*)+-----END RSA PRIVATE KEY-----\s*$/g.test(pem)) {
             this.$loadFromPrivatePEM(pem, 'base64');
-        } else if (/^\s*-----BEGIN PUBLIC KEY-----\s([A-Za-z0-9+/=]+\s)+-----END PUBLIC KEY-----\s*$/g.test(pem)) {
+        } else if (/^\s*-----BEGIN PUBLIC KEY-----\s*([A-Za-z0-9+/=]+\s*)+-----END PUBLIC KEY-----\s*$/g.test(pem)) {
             this.$loadFromPublicPEM(pem, 'base64');
         } else
             throw Error('Invalid PEM format');
@@ -126,20 +134,27 @@ module.exports = (function() {
     };
 
     /**
-     * Check if keypair contains private key
+     * Check if key pair contains private key
      */
     NodeRSA.prototype.isPrivate = function() {
         return this.keyPair.n && this.keyPair.e && this.keyPair.d || false;
     };
 
     /**
-     * Check if keypair contains public key
+     * Check if key pair contains public key
      * @param strict {boolean} - public key only, return false if have private exponent
      */
     NodeRSA.prototype.isPublic = function(strict) {
         return this.keyPair.n && this.keyPair.e && !(strict && this.keyPair.d) || false;
     };
 
+    /**
+     * Check if key pair doesn't contains any data
+     */
+    NodeRSA.prototype.isEmpty = function(strict) {
+        return !(this.keyPair.n || this.keyPair.e || this.keyPair.d);
+    };
+
     /**
      * Encrypting data method
      *

test/private.key

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXAIBAAKBgQCCdY+EpDC/vPa335l751SBM8d5Lf4z4QZX4bc+DqTY9zVY/rmP
+GbTkCueKnIKApuOGMXJOaCwNH9wUftNt7T0foEwjl16uIC8m4hwSjjNL5TKqMVey
+Syv04oBuidv76u5yNiLC4J85lbmW3WAyYkTCbm/VJZAXNJuqCm7AVWmQMQIDAQAB
+AoGAEYR3oPfrE9PrzQTZNyn4zuCFCGCEobK1h1dno42T1Q5cu3Z4tB5fi79rF9Gs
+NFo0cvBwyNZ0E88TXi0pdrlEW6mdPgQFd3CFxrOgKt9AGpOtI1zzVOb1Uddywq/m
+WBPyETwEKzq7lC2nAcMUr0rlFrrDmUT2dafHeuWnFMZ/1YECQQDCtftsH9/prbgu
+Q4F2lOWsLz96aix/jnI8FhBmukKmfLMXjCZYYv+Dsr8TIl/iriGqcSgGkBHHoGe1
+nmLUZ4EHAkEAq4YcB8T9DLIYUeaS+JRWwLOejU6/rYdgxBIaGn2m0Ldp/z7lLM7g
+b0H5Al+7POajkAdnDclBDhyxqInHO4VvBwJBAJ25jNEpgNhqQKg5RsYoF2RDYchn
++WPan+7McLzGZPc4TFrmzKkMiK7GPMHjNokJRXwr7aBjVAPBjEEy7BvjPEECQFOJ
+4rcKAzEewGeLREObg9Eg6nTqSMLMb52vL1V9ozR+UDrHuDilnXuyhwPX+kqEDl+E
+q3V0cqHb6c8rI4TizRsCQANIyhoJ33ughNzbCIknkMPKtgvLOUARnbya/bkfRexL
+icyYzXPNuqZDY8JZQHlshN8cCcZcYjGPYYscd2LKB6o=
+-----END RSA PRIVATE KEY-----

test/tests.js

@@ -2,10 +2,12 @@
  * TODO: tests for compatibility with other rsa libraries
  */
 
+var fs = require('fs');
 var assert = require("chai").assert;
 var _ = require("lodash");
 var NodeRSA = require("../src/NodeRSA");
 
+
 describe("NodeRSA", function(){
     var keySizes = [
         {b: 512, e: 3},
@@ -60,15 +62,27 @@ describe("NodeRSA", function(){
         describe("Generating keys", function() {
             for (var size in keySizes) {
                 (function(size){
-                    it("should make key pair " + size.b + "-bit length and public exponent is " + (size.e ? size.e : size.e + ' and should be 65537'), function () {
+                    it("should make key pair " + size.b + "-bit length and public exponent is " + (size.e ? size.e : size.e + " and should be 65537"), function () {
                         generatedKeys.push(new NodeRSA({b: size.b, e: size.e}));
                         assert.instanceOf(generatedKeys[generatedKeys.length - 1].keyPair, Object);
+                        assert.equal(generatedKeys[generatedKeys.length - 1].isEmpty(), false);
                         assert.equal(generatedKeys[generatedKeys.length - 1].getKeySize(), size.b);
                         assert.equal(generatedKeys[generatedKeys.length - 1].getMaxMessageSize(), (size.b / 8 - 11));
                         assert.equal(generatedKeys[generatedKeys.length - 1].keyPair.e, size.e || 65537);
                     });
                 })(keySizes[size]);
             }
+
+            it("should make empty key pair", function () {
+                var key = new NodeRSA(null);
+                assert.equal(key.isEmpty(), true);
+            });
+
+            it("should make empty key pair with md5 signing option", function () {
+                var key = new NodeRSA(null, {signingAlgorithm: 'md5'});
+                assert.equal(key.isEmpty(), true);
+                assert.equal(key.options.signingAlgorithm, 'md5');
+            });
         });
 
         describe("PEM", function(){
@@ -120,6 +134,23 @@ describe("NodeRSA", function(){
             var privateKeyPEMNotTrimmed = '     \n\n    \n\n ' + privateKeyPEM + '\n \n  \n\n  ';
             var publicKeyPEMNotTrimmed = '\n\n\n\n ' + publicKeyPEM + '\n \n\n\n  ';
 
+            var fileKey = __dirname + "/private.key";
+            var fileKeyPEM = "-----BEGIN RSA PRIVATE KEY-----\n"+
+                "MIICXAIBAAKBgQCCdY+EpDC/vPa335l751SBM8d5Lf4z4QZX4bc+DqTY9zVY/rmP\n"+
+                "GbTkCueKnIKApuOGMXJOaCwNH9wUftNt7T0foEwjl16uIC8m4hwSjjNL5TKqMVey\n"+
+                "Syv04oBuidv76u5yNiLC4J85lbmW3WAyYkTCbm/VJZAXNJuqCm7AVWmQMQIDAQAB\n"+
+                "AoGAEYR3oPfrE9PrzQTZNyn4zuCFCGCEobK1h1dno42T1Q5cu3Z4tB5fi79rF9Gs\n"+
+                "NFo0cvBwyNZ0E88TXi0pdrlEW6mdPgQFd3CFxrOgKt9AGpOtI1zzVOb1Uddywq/m\n"+
+                "WBPyETwEKzq7lC2nAcMUr0rlFrrDmUT2dafHeuWnFMZ/1YECQQDCtftsH9/prbgu\n"+
+                "Q4F2lOWsLz96aix/jnI8FhBmukKmfLMXjCZYYv+Dsr8TIl/iriGqcSgGkBHHoGe1\n"+
+                "nmLUZ4EHAkEAq4YcB8T9DLIYUeaS+JRWwLOejU6/rYdgxBIaGn2m0Ldp/z7lLM7g\n"+
+                "b0H5Al+7POajkAdnDclBDhyxqInHO4VvBwJBAJ25jNEpgNhqQKg5RsYoF2RDYchn\n"+
+                "+WPan+7McLzGZPc4TFrmzKkMiK7GPMHjNokJRXwr7aBjVAPBjEEy7BvjPEECQFOJ\n"+
+                "4rcKAzEewGeLREObg9Eg6nTqSMLMb52vL1V9ozR+UDrHuDilnXuyhwPX+kqEDl+E\n"+
+                "q3V0cqHb6c8rI4TizRsCQANIyhoJ33ughNzbCIknkMPKtgvLOUARnbya/bkfRexL\n"+
+                "icyYzXPNuqZDY8JZQHlshN8cCcZcYjGPYYscd2LKB6o=\n"+
+                "-----END RSA PRIVATE KEY-----";
+
             describe("Good cases", function () {
                 it(".loadFromPrivatePEM() should load private key from (not trimmed) PEM string", function(){
                     privateNodeRSA = new NodeRSA(privateKeyPEMNotTrimmed);
@@ -148,6 +179,19 @@ describe("NodeRSA", function(){
                 it(".getPublicPEM() from private key should return public PEM string", function(){
                     assert.equal(privateNodeRSA.getPublicPEM(), publicKeyPEM);
                 });
+
+                it("should create key from buffer/fs.readFileSync output", function(){
+                    var key = new NodeRSA(fs.readFileSync(fileKey));
+                    assert.equal(key.getPrivatePEM(), fileKeyPEM);
+                });
+
+                it("should load PEM from buffer/fs.readFileSync output", function(){
+                    var key = new NodeRSA();
+                    assert.equal(key.isEmpty(), true);
+                    key.loadFromPEM(fs.readFileSync(fileKey));
+                    assert.equal(key.isEmpty(), false);
+                    assert.equal(key.getPrivatePEM(), fileKeyPEM);
+                });
             });
 
             describe("Bad cases", function () {