node-rsa - npm Package Compare versions

Comparing version 0.1.32 to 0.1.40

package.json

 {
   "name": "node-rsa",
-  "version": "0.1.32",
+  "version": "0.1.40",
   "description": "Node.js RSA library",
@@ -19,3 +19,5 @@ "main": "src/NodeRSA.js",
     "encryption",
-    "decryption"
+    "decryption",
+    "sign",
+    "verify"
   ],
@@ -22,0 +24,0 @@ "author": "rzcoder",

README.md

@@ -8,6 +8,8 @@ # Node-RSA
 * No needed OpenSSL
+* Generating keys
 * Supports long messages for encrypt/decrypt
+* Signing and verifying
 
 
-## Building and Installing
+## Installing
 
@@ -18,3 +20,3 @@ ```shell
 
-#### Testing
+### Testing
 
@@ -28,2 +30,9 @@ ```shell
 ### Create instance
+```js
+var key = new NodeRSA([key], [options]);
+```
+**key** - parameters of a generated key or the key in PEM format.<br/>
+**options** - additional settings
+ * **signingAlgorithm** - algorithm used for signing and verifying. Default *'RSA-SHA256'*
+
 #### "Empty" key
@@ -36,3 +45,3 @@ ```js
 ```js
-var key =  NodeRSA({b: 512});
+var key = new NodeRSA({b: 512});
 ```
@@ -65,4 +74,4 @@
 ```js
-key.toPrivatePEM();
-key.toPublicPEM();
+key.getPrivatePEM();
+key.getPublicPEM();
 ```
@@ -79,7 +88,8 @@
 ```js
-key.encrypt(buffer, [source_encoding], [output_encoding]);
+key.encrypt(buffer, [encoding], [source_encoding]);
 ```
+Return encrypted data.<br/>
 **buffer** - data for encrypting, may be string, Buffer, or any object/array. Arrays and objects will encoded to JSON string first.<br/>
-**source_encoding** - source encoding, works only with string buffer. Can take standard Node.js Buffer encodings (hex, utf8, base64, etc). *Utf8* by default.<br/>
-**output_encoding** - encoding for output result, can also take 'buffer' to return Buffer object. Default *base64*.
+**encoding** - encoding for output result, may be 'buffer', 'binary', 'hex' or 'base64'. Default *buffer*.
+**source_encoding** - source encoding, works only with string buffer. Can take standard Node.js Buffer encodings (hex, utf8, base64, etc). *'utf8'* by default.<br/>
 
@@ -89,6 +99,21 @@ ```js
 ```
-
+Return decrypted data.<br/>
 **buffer** - data for decrypting. Takes Buffer object or base64 encoded string.<br/>
-**encoding** - encoding for result string. Can also take 'buffer' for raw Buffer object, or 'json' for automatic JSON.parse result.
+**encoding** - encoding for result string. Can also take 'buffer' for raw Buffer object, or 'json' for automatic JSON.parse result. Default *'buffer'*.
 
+### Signing/Verifying
+```js
+key.sign(buffer, [encoding], [source_encoding]);
+```
+Return signature for buffer. All the arguments are the same as for `encrypt` method.
+
+```js
+key.verify(buffer, signature, [source_encoding], [signature_encoding])
+```
+Return result of check, _true_ or _false_.<br/>
+**buffer** - data for check, same as `encrypt` method.<br/>
+**signature** - signature for check, result of `sign` method.<br/>
+**source_encoding** - same as for`encrypt` method.<br/>
+**signature_encoding** - encoding of given signature. May be 'buffer', 'binary', 'hex' or 'base64'. Default *'buffer'*.
+
 ## Contributing
@@ -95,0 +120,0 @@

src/NodeRSA.js

@@ -11,2 +11,3 @@ /*!
 var rsa = require('./libs/rsa.js');
+var crypt = require('crypto');
 var ber = require('asn1').Ber;
@@ -20,12 +21,17 @@ var _ = require('lodash');
     /**
-     * @param arg {string|object} Key in PEM format, or data for generate key {b: bits, e: exponent}
+     * @param key {string|object} Key in PEM format, or data for generate key {b: bits, e: exponent}
      * @constructor
      */
-    function NodeRSA(arg) {
+    function NodeRSA(key, options) {
         this.keyPair = new rsa.Key();
+        this.$cache = {};
 
-        if (_.isObject(arg)) {
-            this.generateKeyPair(arg.b, arg.e);
-        } else if (_.isString(arg)) {
-            this.loadFromPEM(arg);
+        this.options = _.merge({
+            signingAlgorithm: 'RSA-SHA256'
+        }, options  || {});
+
+        if (_.isObject(key)) {
+            this.generateKeyPair(key.b, key.e);
+        } else if (_.isString(key)) {
+            this.loadFromPEM(key);
         }
@@ -46,2 +52,3 @@ }
         this.keyPair.generate(bits, exp.toString(16));
+        this.$recalculateCache();
         return this;
@@ -61,2 +68,4 @@ };
             throw Error('Invalid PEM format');
+
+        this.$recalculateCache();
     };
@@ -113,5 +122,153 @@
     /**
+     * Check if keypair contains private key
+     */
+    NodeRSA.prototype.isPrivate = function() {
+        return this.keyPair.n && this.keyPair.e && this.keyPair.d || false;
+    };
+
+    /**
+     * Check if keypair 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;
+    };
+
+    /**
+     * Encrypting data method
+     *
+     * @param buffer {string|number|object|array|Buffer} - data for encrypting. Object and array will convert to JSON string.
+     * @param encoding {string} - optional. Encoding for output result, may be 'buffer', 'binary', 'hex' or 'base64'. Default 'buffer'.
+     * @param source_encoding {string} - optional. Encoding for given string. Default utf8.
+     * @returns {string|Buffer}
+     */
+    NodeRSA.prototype.encrypt = function(buffer, encoding, source_encoding) {
+        var res = this.keyPair.encrypt(this.$getDataForEcrypt(buffer, source_encoding));
+
+        if (encoding == 'buffer' || !encoding) {
+            return res;
+        } else {
+            return res.toString(encoding);
+        }
+    };
+
+    /**
+     * Decrypting data method
+     *
+     * @param buffer {Buffer} - buffer for decrypting
+     * @param encoding - encoding for result string, can also take 'json' or 'buffer' for the automatic conversion of this type
+     * @returns {Buffer|object|string}
+     */
+    NodeRSA.prototype.decrypt = function(buffer, encoding) {
+        buffer = _.isString(buffer) ? new Buffer(buffer, 'base64') : buffer;
+        return this.$getDecryptedData(this.keyPair.decrypt(buffer), encoding);
+    };
+
+    /**
+     *  Signing data
+     *
+     * @param buffer {string|number|object|array|Buffer} - data for signing. Object and array will convert to JSON string.
+     * @param encoding {string} - optional. Encoding for output result, may be 'buffer', 'binary', 'hex' or 'base64'. Default 'buffer'.
+     * @param source_encoding {string} - optional. Encoding for given string. Default utf8.
+     * @returns {string|Buffer}
+     */
+    NodeRSA.prototype.sign = function(buffer, encoding, source_encoding) {
+        if (!this.isPrivate()) {
+            throw Error("It is not private key");
+        }
+
+        encoding = (!encoding || encoding == 'buffer' ? null : encoding);
+        var signer = crypt.createSign(this.options.signingAlgorithm);
+        signer.update(this.$getDataForEcrypt(buffer, source_encoding));
+        return signer.sign(this.getPrivatePEM(), encoding);
+    };
+
+    /**
+     *  Verifying signed data
+     *
+     * @param buffer - signed data
+     * @param signature
+     * @param source_encoding {string} - optional. Encoding for given string. Default utf8.
+     * @param signature_encoding - optional. Encoding of given signature. May be 'buffer', 'binary', 'hex' or 'base64'. Default 'buffer'.
+     * @returns {*}
+     */
+    NodeRSA.prototype.verify = function(buffer, signature, source_encoding, signature_encoding) {
+        signature_encoding = (!signature_encoding || signature_encoding == 'buffer' ? null : signature_encoding);
+        var verifier = crypt.createVerify(this.options.signingAlgorithm);
+        verifier.update(this.$getDataForEcrypt(buffer, source_encoding));
+        return verifier.verify(this.getPublicPEM(), signature, signature_encoding);
+    };
+
+    NodeRSA.prototype.getPrivatePEM = function () {
+        if (!this.isPrivate()) {
+            throw Error("It is not private key");
+        }
+
+        return this.$cache.privatePEM;
+    };
+
+    NodeRSA.prototype.getPublicPEM = function () {
+        if (!this.isPublic()) {
+            throw Error("It is not public key");
+        }
+
+        return this.$cache.publicPEM;
+    };
+
+    /**
+     * Preparing given data for encrypting/signing. Just make new/return Buffer object.
+     *
+     * @param buffer {string|number|object|array|Buffer} - data for encrypting. Object and array will convert to JSON string.
+     * @param encoding {string} - optional. Encoding for given string. Default utf8.
+     * @returns {Buffer}
+     */
+    NodeRSA.prototype.$getDataForEcrypt = function(buffer, encoding) {
+        if (_.isString(buffer) || _.isNumber(buffer)) {
+            return new Buffer('' + buffer, encoding || 'utf8');
+        } else if (Buffer.isBuffer(buffer)) {
+            return buffer;
+        } else if (_.isObject(buffer)) {
+            return new Buffer(JSON.stringify(buffer));
+        } else {
+            throw Error("Unexpected data type");
+        }
+    };
+
+    /**
+     *
+     * @param buffer {Buffer} - decrypted data.
+     * @param encoding - optional. Encoding for result output. May be 'buffer', 'json' or any of Node.js Buffer supported encoding.
+     * @returns {*}
+     */
+    NodeRSA.prototype.$getDecryptedData = function(buffer, encoding) {
+        encoding = encoding || 'buffer';
+
+        if (encoding == 'buffer') {
+            return buffer;
+        } else if (encoding == 'json') {
+            return JSON.parse(buffer.toString());
+        } else {
+            return buffer.toString(encoding);
+        }
+    };
+
+
+    /**
+     * private
+     * Recalculating properties
+     */
+    NodeRSA.prototype.$recalculateCache = function() {
+        this.$cache.privatePEM = this.$makePrivatePEM();
+        this.$cache.publicPEM = this.$makePublicPEM();
+    };
+
+    /**
+     * private
      * @returns {string} private PEM string
      */
-    NodeRSA.prototype.toPrivatePEM = function() {
+    NodeRSA.prototype.$makePrivatePEM = function() {
+        if (!this.isPrivate()) {
+            return null;
+        }
+
         var n = this.keyPair.n.toBuffer();
@@ -146,5 +303,10 @@ var d = this.keyPair.d.toBuffer();
     /**
+     * private
      * @returns {string} public PEM string
      */
-    NodeRSA.prototype.toPublicPEM = function() {
+    NodeRSA.prototype.$makePublicPEM = function() {
+        if (!this.isPublic()) {
+            return null;
+        }
+
         var n = this.keyPair.n.toBuffer();
@@ -170,4 +332,2 @@ var length = n.length + 512; // magic
 
-        n = writer.buffer.toString('hex');
-
         return '-----BEGIN PUBLIC KEY-----\n' +
@@ -178,66 +338,3 @@ utils.linebrk(writer.buffer.toString('base64'), 64) +
 
-    /**
-     * Check if keypair contains private key
-     */
-    NodeRSA.prototype.isPrivate = function() {
-        return this.keyPair.n && this.keyPair.e && this.keyPair.d;
-    };
-
-    /**
-     * Check if keypair 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);
-    };
-
-    /**
-     * Encrypting data method
-     *
-     * @param buffer {string|number|object|array|Buffer} - data for encrypting. Object and array will convert to JSON string.
-     * @param source_encoding {string} - optional. Encoding for given string. Default utf8.
-     * @param output_encoding {string} - optional. Encoding for output result, can also take 'buffer' to return Buffer object. Default base64.
-     * @returns {string|Buffer}
-     */
-    NodeRSA.prototype.encrypt = function(buffer, source_encoding, output_encoding) {
-        var res = null;
-
-        if (_.isString(buffer) || _.isNumber(buffer)) {
-            res = this.keyPair.encrypt(new Buffer('' + buffer, source_encoding || 'utf8'));
-        } else if (Buffer.isBuffer(buffer)) {
-            res = this.keyPair.encrypt(buffer);
-        } else if (_.isObject(buffer)) {
-            res = this.keyPair.encrypt(new Buffer(JSON.stringify(buffer)));
-        }
-
-        if (output_encoding == 'buffer') {
-            return res;
-        } else {
-            return res.toString(output_encoding || 'base64');
-        }
-    };
-
-    /**
-     * Decrypting data method
-     *
-     * @param buffer {Buffer} - buffer for decrypting
-     * @param encoding - encoding for result string, can also take 'json' or 'buffer' for the automatic conversion of this type
-     * @returns {Buffer|object|string}
-     */
-    NodeRSA.prototype.decrypt = function(buffer, encoding) {
-        encoding = encoding || 'utf8';
-
-        buffer = _.isString(buffer) ? new Buffer(buffer, 'base64') : buffer;
-        var res = this.keyPair.decrypt(buffer);
-
-        if (encoding == 'buffer') {
-            return res;
-        } else if (encoding == 'json') {
-            return JSON.parse(res.toString());
-        } else {
-            return res.toString(encoding);
-        }
-    };
-
-     return NodeRSA;
+    return NodeRSA;
 })();

test/tests.js

@@ -5,89 +5,146 @@ /**
 
-var assert = require('chai').assert;
-var _ = require('lodash');
-var NodeRSA = (require('../src/NodeRSA'));
+var assert = require("chai").assert;
+var _ = require("lodash");
+var NodeRSA = require("../src/NodeRSA");
 
-describe('NodeRSA', function(){
-    var nodeRSA = null;
+describe("NodeRSA", function(){
+    var keySizes = [
+        {b: 512, e: 3},
+        {b: 512, e: 5},
+        {b: 512, e: 257},
+        {b: 512, e: 65537},
+        {b: 768}, // 'e' should be 65537
+        {b: 1024} // 'e' should be 65537
+    ];
+
+    var dataBundle = {
+        "string": {
+            data: "ascii + юникод スラ ⑨",
+            encoding: "utf8"            
+        },
+        "empty string": {
+            data: "",
+            encoding: ["utf8", "ascii", "hex", "base64"]
+        },
+        "long string": {
+            data: "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.",
+            encoding: ["utf8", "ascii"]
+        },
+        "buffer": {
+            data: new Buffer("ascii + юникод スラ ⑨"),
+            encoding: "buffer"
+        },
+        "json object": {
+            data: {str: "string", arr: ["a","r","r", "a", "y", true, "⑨"], int: 42, nested: {key: {key: 1}}},
+            encoding: "json"
+        },
+        "json array": {
+            data: [1,2,3,4,5,6,7,8,9,[10,11,12,[13],14,15,[16,17,[18]]]],
+            encoding: "json"
+        }
+    };
+
+    var generatedKeys = [];
     var privateNodeRSA = null;
     var publicNodeRSA = null;
 
-    describe('Work with keys', function(){
-        it('.generateKeyPair() should make key pair', function(){
-            nodeRSA = new NodeRSA({b: 1024});
-            assert.instanceOf(nodeRSA.keyPair, Object);
+    describe("Work with keys", function(){
+
+        describe("Generating keys", function() {
+            for (var i in keySizes) {
+                it("should make key pair " + keySizes[i].b + "-bit length and public exponent is " + (keySizes[i].e || 65537), function () {
+                    generatedKeys.push(new NodeRSA({b: keySizes[i].b, e: keySizes[i].e}));
+                    assert.instanceOf(generatedKeys[generatedKeys.length - 1].keyPair, Object);
+                });
+            }
         });
 
-        describe('PEM', function(){
-            var privateKeyPEM = '-----BEGIN RSA PRIVATE KEY-----\n'+
-                'MIIFwgIBAAKCAUEAsE1edyfToZRv6cFOkB0tAJ5qJor4YF5CccJAL0fS/o1Yk10V\n'+
-                'SXH4Xx4peSJgYQKkO0HqO1hAz6k9dFQB4U1CnWtRjtNEcIfycqrZrhu6you5syb6\n'+
-                'ScV3Zu/9bm7/DyaLlx/gJhUPR1OxOzaqsEvlu7hbDhNLIYo1zKFb/aUBbD6+UcaG\n'+
-                'xH2BfFNdzVAtVSVpc/s2Y3sboMN7rByUj7937iQlaMINvVjyasynYuzHNw6ZRP9J\n'+
-                'P9fwxrCyaxnTPWxVl0qvVaQO2+TtFMtDXH2OVZtWWeLHAL8cildw0G+u2qVqTqIG\n'+
-                'EwNyJlsAHykaPFAMW0xLueumrSlB+JUJPrRvvw4nBCd4GOrNSlPCE/xlk1Cb8JaI\n'+
-                'CTLvDUcYc3ZqL3jqAueBhkpw2uCz8xVJeOA1KY4kQIIx8JEBsAYzgyP2iy0CAwEA\n'+
-                'AQKCAUAjBcudShkdgRpWSmNr94/IDrAxpeu/YRo79QXBHriIftW4uIYRCAX6B0jf\n'+
-                '2ndg7iBn8Skxzs9ZMVqW8FVLR4jTMs2J3Og8npUIOG5zyuhpciZas4SHASY+GbCz\n'+
-                'rnMWtGaIh/mENyzI05RimfKAgSNLDk1wV17Wc9lKJEfc9Fl7Al/WaOS+xdviMcFx\n'+
-                'ltrajksLkjz0uDD917eKskbE45lULfGqeI0kYDadWp88pw6ikXJln2p3Y1PNQF3e\n'+
-                'y2cN+Snzd0jx/c5fD9B1zxKYv5bUo+UnTzBxV81e9xCJfkdXv+6D5qDn1gGLdZZa\n'+
-                '5FxtZbRgVh/ZlqP9xYr72as/WFmIA20wRgHPgWvLyHsh0XThqZf2/O3R8KmFv8aT\n'+
-                '+kmc5is6sVItIIi7ltorVapTkJai3zz/VSMBBaL+ytFN9jVl4QKBoQDfL8TMeZXu\n'+
-                'gBTN7yq6zZWN8+60MUaxz0/lKdzmo35z32rpVKdsYd922pmcsNYaoj/H9L3j/NP4\n'+
-                '9z+SHfYpWvTa7AvJfNlXYc3BRXIarpfnXsm65IzKzHaF9i2xdXxkfTEYIvOQDMLF\n'+
-                'SiiObWJMV+QqUxb3luu3/CR3IcbgeTOpdiC/T/Zl/YYl17JqZTHmLFZPq7xewttg\n'+
-                'zQorDRWIFDtlAoGhAMo4+uM9f4BpOHSmayhLhHArIGs4386BkXSeOLeQitaQJ/2c\n'+
-                'zb459O87XoCAonZbq+dI7XRnBU3toQvEsZgrtGkOFXCZJMWAQxD5BQ5vEYT6c86h\n'+
-                'uGpX6h3ODlJ6UGi+5CWyMQ1cFlBkfffFAarjSYTVlyj736sOeDuJWX133z5VQBQ8\n'+
-                '1xSH23kNF95vxB4I1fXG8WL11YZU7VEwSLC4aCkCgaAKRj+wDhTZ4umSRWVZLiep\n'+
-                'XkZp4y7W9q095nx13abvnKRmU3BVq/fGl++kZ/ujRD7dbKXlPflgJ7m0d06ivr4w\n'+
-                '6dbtEqNKw4TeVd0X31u82f89bFIS7/Cw4BFgbwEn+x9sdgdyZTP+MxjE3cI9s3oc\n'+
-                'fLC8+ySk1qWzGkn2gX3gWkDNrdexAEfRrClZfokaiIX8qvJEBoJk5WuHadXI6u2F\n'+
-                'AoGgByidOQ4kRVd0OCzr/jEuLwpXy3Pn+Fd93rL7LwRe5dmUkNXMMr+6e/2OCt6C\n'+
-                '4c28+CMMxOIgvfF7kf8Uil6BtHZbK/E/6/3uYdtu4mPsKtjy4I25CYqzLvrsZt8N\n'+
-                'maeoS+1S7zYjVBU6oFrJBFOndpxZDYpdEKEigHkMQfTMYliCPDUrJ/7nNhHQln8+\n'+
-                'YhHOATVZtjcdp/O5svYSnK7qgQKBoDd3lFWrPatgxpF1JXMEFFbaIRdNxHkKA4YY\n'+
-                'gMTM4MPgViunYX/yJ7SaX8jWnC231A9uVn4+kb+DvKjc+ZuTQvnIUK2u6LvIinVF\n'+
-                'snDEA+BbXwehAtwdHDMDtqYFdx4hvCWQwBNn4p3J0OO2tbYVMtvM5aOEfRSYagfm\n'+
-                'RywhDUAjW8U0RBnzlmXhQQ6B9bjqooS2MsRrJrS5CU682fb3hBo=\n'+
-                '-----END RSA PRIVATE KEY-----';
+        describe("PEM", function(){
+            var privateKeyPEM = "-----BEGIN RSA PRIVATE KEY-----\n"+
+                "MIIFwgIBAAKCAUEAsE1edyfToZRv6cFOkB0tAJ5qJor4YF5CccJAL0fS/o1Yk10V\n"+
+                "SXH4Xx4peSJgYQKkO0HqO1hAz6k9dFQB4U1CnWtRjtNEcIfycqrZrhu6you5syb6\n"+
+                "ScV3Zu/9bm7/DyaLlx/gJhUPR1OxOzaqsEvlu7hbDhNLIYo1zKFb/aUBbD6+UcaG\n"+
+                "xH2BfFNdzVAtVSVpc/s2Y3sboMN7rByUj7937iQlaMINvVjyasynYuzHNw6ZRP9J\n"+
+                "P9fwxrCyaxnTPWxVl0qvVaQO2+TtFMtDXH2OVZtWWeLHAL8cildw0G+u2qVqTqIG\n"+
+                "EwNyJlsAHykaPFAMW0xLueumrSlB+JUJPrRvvw4nBCd4GOrNSlPCE/xlk1Cb8JaI\n"+
+                "CTLvDUcYc3ZqL3jqAueBhkpw2uCz8xVJeOA1KY4kQIIx8JEBsAYzgyP2iy0CAwEA\n"+
+                "AQKCAUAjBcudShkdgRpWSmNr94/IDrAxpeu/YRo79QXBHriIftW4uIYRCAX6B0jf\n"+
+                "2ndg7iBn8Skxzs9ZMVqW8FVLR4jTMs2J3Og8npUIOG5zyuhpciZas4SHASY+GbCz\n"+
+                "rnMWtGaIh/mENyzI05RimfKAgSNLDk1wV17Wc9lKJEfc9Fl7Al/WaOS+xdviMcFx\n"+
+                "ltrajksLkjz0uDD917eKskbE45lULfGqeI0kYDadWp88pw6ikXJln2p3Y1PNQF3e\n"+
+                "y2cN+Snzd0jx/c5fD9B1zxKYv5bUo+UnTzBxV81e9xCJfkdXv+6D5qDn1gGLdZZa\n"+
+                "5FxtZbRgVh/ZlqP9xYr72as/WFmIA20wRgHPgWvLyHsh0XThqZf2/O3R8KmFv8aT\n"+
+                "+kmc5is6sVItIIi7ltorVapTkJai3zz/VSMBBaL+ytFN9jVl4QKBoQDfL8TMeZXu\n"+
+                "gBTN7yq6zZWN8+60MUaxz0/lKdzmo35z32rpVKdsYd922pmcsNYaoj/H9L3j/NP4\n"+
+                "9z+SHfYpWvTa7AvJfNlXYc3BRXIarpfnXsm65IzKzHaF9i2xdXxkfTEYIvOQDMLF\n"+
+                "SiiObWJMV+QqUxb3luu3/CR3IcbgeTOpdiC/T/Zl/YYl17JqZTHmLFZPq7xewttg\n"+
+                "zQorDRWIFDtlAoGhAMo4+uM9f4BpOHSmayhLhHArIGs4386BkXSeOLeQitaQJ/2c\n"+
+                "zb459O87XoCAonZbq+dI7XRnBU3toQvEsZgrtGkOFXCZJMWAQxD5BQ5vEYT6c86h\n"+
+                "uGpX6h3ODlJ6UGi+5CWyMQ1cFlBkfffFAarjSYTVlyj736sOeDuJWX133z5VQBQ8\n"+
+                "1xSH23kNF95vxB4I1fXG8WL11YZU7VEwSLC4aCkCgaAKRj+wDhTZ4umSRWVZLiep\n"+
+                "XkZp4y7W9q095nx13abvnKRmU3BVq/fGl++kZ/ujRD7dbKXlPflgJ7m0d06ivr4w\n"+
+                "6dbtEqNKw4TeVd0X31u82f89bFIS7/Cw4BFgbwEn+x9sdgdyZTP+MxjE3cI9s3oc\n"+
+                "fLC8+ySk1qWzGkn2gX3gWkDNrdexAEfRrClZfokaiIX8qvJEBoJk5WuHadXI6u2F\n"+
+                "AoGgByidOQ4kRVd0OCzr/jEuLwpXy3Pn+Fd93rL7LwRe5dmUkNXMMr+6e/2OCt6C\n"+
+                "4c28+CMMxOIgvfF7kf8Uil6BtHZbK/E/6/3uYdtu4mPsKtjy4I25CYqzLvrsZt8N\n"+
+                "maeoS+1S7zYjVBU6oFrJBFOndpxZDYpdEKEigHkMQfTMYliCPDUrJ/7nNhHQln8+\n"+
+                "YhHOATVZtjcdp/O5svYSnK7qgQKBoDd3lFWrPatgxpF1JXMEFFbaIRdNxHkKA4YY\n"+
+                "gMTM4MPgViunYX/yJ7SaX8jWnC231A9uVn4+kb+DvKjc+ZuTQvnIUK2u6LvIinVF\n"+
+                "snDEA+BbXwehAtwdHDMDtqYFdx4hvCWQwBNn4p3J0OO2tbYVMtvM5aOEfRSYagfm\n"+
+                "RywhDUAjW8U0RBnzlmXhQQ6B9bjqooS2MsRrJrS5CU682fb3hBo=\n"+
+                "-----END RSA PRIVATE KEY-----";
 
-            var publicKeyPEM = '-----BEGIN PUBLIC KEY-----\n'+
-                'MIIBYjANBgkqhkiG9w0BAQEFAAOCAU8AMIIBSgKCAUEAsE1edyfToZRv6cFOkB0t\n'+
-                'AJ5qJor4YF5CccJAL0fS/o1Yk10VSXH4Xx4peSJgYQKkO0HqO1hAz6k9dFQB4U1C\n'+
-                'nWtRjtNEcIfycqrZrhu6you5syb6ScV3Zu/9bm7/DyaLlx/gJhUPR1OxOzaqsEvl\n'+
-                'u7hbDhNLIYo1zKFb/aUBbD6+UcaGxH2BfFNdzVAtVSVpc/s2Y3sboMN7rByUj793\n'+
-                '7iQlaMINvVjyasynYuzHNw6ZRP9JP9fwxrCyaxnTPWxVl0qvVaQO2+TtFMtDXH2O\n'+
-                'VZtWWeLHAL8cildw0G+u2qVqTqIGEwNyJlsAHykaPFAMW0xLueumrSlB+JUJPrRv\n'+
-                'vw4nBCd4GOrNSlPCE/xlk1Cb8JaICTLvDUcYc3ZqL3jqAueBhkpw2uCz8xVJeOA1\n'+
-                'KY4kQIIx8JEBsAYzgyP2iy0CAwEAAQ==\n'+
-                '-----END PUBLIC KEY-----';
+            var publicKeyPEM = "-----BEGIN PUBLIC KEY-----\n"+
+                "MIIBYjANBgkqhkiG9w0BAQEFAAOCAU8AMIIBSgKCAUEAsE1edyfToZRv6cFOkB0t\n"+
+                "AJ5qJor4YF5CccJAL0fS/o1Yk10VSXH4Xx4peSJgYQKkO0HqO1hAz6k9dFQB4U1C\n"+
+                "nWtRjtNEcIfycqrZrhu6you5syb6ScV3Zu/9bm7/DyaLlx/gJhUPR1OxOzaqsEvl\n"+
+                "u7hbDhNLIYo1zKFb/aUBbD6+UcaGxH2BfFNdzVAtVSVpc/s2Y3sboMN7rByUj793\n"+
+                "7iQlaMINvVjyasynYuzHNw6ZRP9JP9fwxrCyaxnTPWxVl0qvVaQO2+TtFMtDXH2O\n"+
+                "VZtWWeLHAL8cildw0G+u2qVqTqIGEwNyJlsAHykaPFAMW0xLueumrSlB+JUJPrRv\n"+
+                "vw4nBCd4GOrNSlPCE/xlk1Cb8JaICTLvDUcYc3ZqL3jqAueBhkpw2uCz8xVJeOA1\n"+
+                "KY4kQIIx8JEBsAYzgyP2iy0CAwEAAQ==\n"+
+                "-----END PUBLIC KEY-----";
 
-            it('.loadFromPrivatePEM() should load private key from PEM string', function(){
-                privateNodeRSA = new NodeRSA(privateKeyPEM);
-                assert.instanceOf(privateNodeRSA.keyPair, Object);
-                assert(privateNodeRSA.isPrivate());
-                assert(privateNodeRSA.isPublic());
-                assert(!privateNodeRSA.isPublic(true));
-            });
+            describe("Good cases", function () {
+                it(".loadFromPrivatePEM() should load private key from PEM string", function(){
+                    privateNodeRSA = new NodeRSA(privateKeyPEM);
+                    assert.instanceOf(privateNodeRSA.keyPair, Object);
+                    assert(privateNodeRSA.isPrivate());
+                    assert(privateNodeRSA.isPublic());
+                    assert(!privateNodeRSA.isPublic(true));
+                });
 
-            it('.loadFromPublicPEM() should load public key from PEM string', function(){
-                publicNodeRSA = new NodeRSA(publicKeyPEM);
-                assert.instanceOf(privateNodeRSA.keyPair, Object);
-                assert(publicNodeRSA.isPublic());
-                assert(publicNodeRSA.isPublic(true));
-                assert(!publicNodeRSA.isPrivate());
-            });
+                it(".loadFromPublicPEM() should load public key from PEM string", function(){
+                    publicNodeRSA = new NodeRSA(publicKeyPEM);
+                    assert.instanceOf(privateNodeRSA.keyPair, Object);
+                    assert(publicNodeRSA.isPublic());
+                    assert(publicNodeRSA.isPublic(true));
+                    assert(!publicNodeRSA.isPrivate());
+                });
 
-            it('.toPrivatePEM() should return private PEM string', function(){
-                assert.equal(privateNodeRSA.toPrivatePEM(), privateKeyPEM);
-            });
+                it(".getPrivatePEM() should return private PEM string", function(){
+                    assert.equal(privateNodeRSA.getPrivatePEM(), privateKeyPEM);
+                });
 
-            it('.toPublicPEM() from public key should return public PEM string', function(){
-                assert.equal(publicNodeRSA.toPublicPEM(), publicKeyPEM);
+                it(".getPublicPEM() from public key should return public PEM string", function(){
+                    assert.equal(publicNodeRSA.getPublicPEM(), publicKeyPEM);
+                });
+
+                it(".getPublicPEM() from private key should return public PEM string", function(){
+                    assert.equal(privateNodeRSA.getPublicPEM(), publicKeyPEM);
+                });
             });
 
-            it('.toPublicPEM() from private key should return public PEM string', function(){
-                assert.equal(privateNodeRSA.toPublicPEM(), publicKeyPEM);
+            describe("Bad cases", function () {
+                it("not public key", function(){
+                    var key = new NodeRSA();
+                    assert.throw(function(){ key.getPrivatePEM(); }, Error, "It is not private key");
+                    assert.throw(function(){ key.getPublicPEM(); }, Error, "It is not public key");
+                });
+
+                it("not private key", function(){
+                    var key = new NodeRSA(publicKeyPEM);
+                    assert.throw(function(){ key.getPrivatePEM(); }, Error, "It is not private key");
+                    assert.doesNotThrow(function(){ key.getPublicPEM(); }, Error, "It is not public key");
+                });
             });
@@ -97,72 +154,89 @@ });
 
+    describe("Encrypting & decrypting", function(){
+        describe("Good cases", function () {
+            var encrypted = {};
+            var decrypted = {};
 
-    var dataForEncrypt = "ascii + юникод スラ ⑨";
-    var longDataForEncrypt = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
-    var JSONForEncrypt = {str: "string", arr: ["a","r","r", "a", "y", true, '⑨'], int: 42, nested: {key: {key: 1}}}
+            for(var i in dataBundle) {
+                var suit = dataBundle[i];
+                var key = null;
 
-    var encrypted = null;
-    var encryptedLong = null;
-    var encryptedBuffer = null;
-    var encryptedJSON = null;
+                it("should encrypt "+i, function(){
+                    key = generatedKeys[Math.round(Math.random()*1000) % generatedKeys.length];
+                    encrypted[i] = key.encrypt(suit.data);
+                    assert(Buffer.isBuffer(encrypted[i]));
+                    assert(encrypted[i].length > 0);
+                });
 
-    var decrypted = null;
-    var decryptedLong = null;
-    var decryptedJSON = null;
-
-    describe('Encrypting', function(){
-        it('.encrypt() should return Buffer object', function(){
-            encryptedBuffer = nodeRSA.encrypt(dataForEncrypt, null, 'buffer');
-            assert(Buffer.isBuffer(encryptedBuffer));
+                it("should decrypt "+i, function(){
+                    decrypted[i] = key.decrypt(encrypted[i], _.isArray(suit.encoding) ? suit.encoding[0] : suit.encoding);
+                    assert(_.isEqual(suit.data, decrypted[i]));
+                });
+            }
         });
 
-        it('.encrypt() should return base64 encrypted string', function(){
-            encrypted = nodeRSA.encrypt(dataForEncrypt);
-            assert.isString(encrypted);
-            assert.match(encrypted, /^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$/);
-        });
+        describe("Bad cases", function () {
+            it("unsupported data types", function(){
+                assert.throw(function(){ generatedKeys[0].encrypt(null); }, Error, "Unexpected data type");
+                assert.throw(function(){ generatedKeys[0].encrypt(undefined); }, Error, "Unexpected data type");
+                assert.throw(function(){ generatedKeys[0].encrypt(true); }, Error, "Unexpected data type");
+            });
 
-        it('.encrypt() should return encrypted Buffer for long message', function(){
-            encryptedLong = nodeRSA.encrypt(longDataForEncrypt, null, 'buffer');
-            assert(Buffer.isBuffer(encryptedLong));
+            it("incorrect key for decrypting", function(){
+                var encrypted = generatedKeys[0].encrypt('data');
+                assert.notEqual('data', generatedKeys[1].decrypt(encrypted));
+            });
         });
-
-        it('.encrypt() for js object. Should return Buffer object', function(){
-            encryptedJSON = nodeRSA.encrypt(JSONForEncrypt, null, 'buffer');
-            assert(Buffer.isBuffer(encryptedJSON));
-        });
     });
 
-    describe('Decrypting', function(){
-        it('.decrypt() should return decrypted Buffer', function(){
-            decrypted = nodeRSA.decrypt(encryptedBuffer, 'buffer');
-            assert(Buffer.isBuffer(decrypted));
-        });
+    describe("Signing & verifying", function () {
+        describe("Good cases", function () {
+            var signed = {};
+            var key = null;
 
-        it('.decrypt() should return decrypted string', function(){
-            decrypted = nodeRSA.decrypt(new Buffer(encrypted, 'base64'));
-            assert.isString(decrypted);
-        });
+            for(var i in dataBundle) {
+                var suit = dataBundle[i];
+                it("should sign "+i, function(){
+                    key = generatedKeys[Math.round(Math.random()*1000) % generatedKeys.length];
+                    signed[i] = key.sign(suit.data);
+                    assert(Buffer.isBuffer(signed[i]));
+                    assert(signed[i].length > 0);
+                });
 
-        it('.decrypt() should return decrypted string for long message', function(){
-            decryptedLong = nodeRSA.decrypt(encryptedLong);
-            assert.isString(decryptedLong);
-        });
+                it("should verify "+i, function(){
+                    assert(key.verify(suit.data, signed[i]));
+                });
+            }
 
-        it('.decrypt() for js object. Should return decrypted js object', function(){
-            decryptedJSON = nodeRSA.decrypt(encryptedJSON, 'json');
-            assert.isObject(decryptedJSON);
+            it("signing with custom algorithm", function(){
+                var key = new NodeRSA(generatedKeys[0].getPrivatePEM(), {signingAlgorithm: 'RSA-MD5'});
+                var signed = key.sign('data');
+                assert(key.verify('data', signed));
+            });
         });
 
-        it('source and decrypted should be the same', function(){
-            assert.equal(decrypted, dataForEncrypt);
-        });
+        describe("Bad cases", function () {
+            it("incorrect data for verifying", function(){
+                var signed = generatedKeys[0].sign('data1');
+                assert(! generatedKeys[0].verify('data2', signed));
+            });
 
-        it('long source and decrypted should be the same', function(){
-            assert.equal(decryptedLong, longDataForEncrypt);
-        });
+            it("incorrect key for signing", function(){
+                var key = new NodeRSA(generatedKeys[0].getPublicPEM());
+                assert.throw(function(){ key.sign('data'); }, Error, "It is not private key");
+            });
 
-        it('source JSON and decrypted JSON should be the same', function(){
-            assert(_.isEqual(decryptedJSON, JSONForEncrypt));
+            it("incorrect key for verifying", function(){
+                var signed = generatedKeys[0].sign('data');
+                assert(! generatedKeys[1].verify('data', signed));
+            });
+
+            it("different algorithms", function(){
+                var singKey = new NodeRSA(generatedKeys[0].getPrivatePEM(), {signingAlgorithm: 'RSA-MD5'});
+                var verifyKey = new NodeRSA(generatedKeys[0].getPrivatePEM(), {signingAlgorithm: 'RSA-SHA1'});
+                var signed = singKey.sign('data');
+                assert(! verifyKey.verify('data', signed));
+            });
         });
     });
 });

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

82125

increased by10.26%

Lines of code

2254

increased by7.38%

Number of lines in readme file

152

increased by19.69%

No dependency changes