added browser support for signing

fixed tests

Author: rzcoder

README.md

@@ -22,6 +22,10 @@ npm install node-rsa
 npm test
 ```
 
+## Work environment
+
+This library developed and tested primary for Node.js, but it still can work in browsers with [browserify](http://browserify.org/).
+
 ## Usage
 
 ### Create instance
@@ -32,7 +36,8 @@ 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'*
+ * **environment** - working environment, `'browser'` or `'node'`. Default autodetect.
+ * **signingAlgorithm** - hash algorithm used for signing and verifying. Can by `'sha1'`, `'sha256'`, `'md5'`. Default `'sha256'`.
 
 #### "Empty" key
 ```js
@@ -78,23 +83,23 @@ key.getPublicPEM();
 key.isPrivate();
 key.isPublic([strict]);
 ```
-**strict** - if true method will return false if key pair have private exponent. Default *false*.
+**strict** - if true method will return false if key pair have private exponent. Default `false`.
 
 ### Encrypting/decrypting
 ```js
 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/>
-**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/>
+**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/>
 
 ```js
 key.decrypt(buffer, [encoding]);
 ```
 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. Default *'buffer'*.
+**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
@@ -105,16 +110,29 @@ Return signature for buffer. All the arguments are the same as for `encrypt` met
 ```js
 key.verify(buffer, signature, [source_encoding], [signature_encoding])
 ```
-Return result of check, _true_ or _false_.<br/>
+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'*.
+**signature_encoding** - encoding of given signature. May be `'buffer'`, `'binary'`, `'hex'` or `'base64'`. Default `'buffer'`.
 
 ## Contributing
 
 Questions, comments, bug reports, and pull requests are all welcome.
 
+## Changelog
+
+### 0.1.50
+ * Implemented native js signing and verifying for browsers
+ * `.loadFromPublicPEM` and `.loadFromPrivatePEM` methods marked as private
+
+### 0.1.40
+ * Added signing/verifying
+
+### 0.1.30
+ * Added long message support
+
+
 ## License for NodeRSA.js
 
 Copyright (c) 2014  rzcoder<br/>

package.json

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

src/NodeRSA.js

@@ -25,7 +25,8 @@ module.exports = (function() {
         this.$cache = {};
 
         this.options = _.merge({
-            signingAlgorithm: 'RSA-SHA256'
+            signingAlgorithm: 'sha256',
+            environment: utils.detectEnvironment()
         }, options  || {});
 
         if (_.isObject(key)) {
@@ -57,9 +58,9 @@ module.exports = (function() {
      */
     NodeRSA.prototype.loadFromPEM = function(pem) {
         if (/^-----BEGIN RSA PRIVATE KEY-----\s([A-Za-z0-9+/=]+\s)+-----END RSA PRIVATE KEY-----$/g.test(pem)) {
-            this.loadFromPrivatePEM(pem, 'base64');
+            this.$loadFromPrivatePEM(pem, 'base64');
         } else if (/^-----BEGIN PUBLIC KEY-----\s([A-Za-z0-9+/=]+\s)+-----END PUBLIC KEY-----$/g.test(pem)) {
-            this.loadFromPublicPEM(pem, 'base64');
+            this.$loadFromPublicPEM(pem, 'base64');
         } else
             throw Error('Invalid PEM format');
 
@@ -69,13 +70,13 @@ module.exports = (function() {
     /**
      * Make key form private PEM string
      *
-     * @param publicPEM {string}
+     * @param privatePEM {string}
      */
-    NodeRSA.prototype.loadFromPrivatePEM = function(privatePEM, encoding) {
+    NodeRSA.prototype.$loadFromPrivatePEM = function(privatePEM, encoding) {
         var pem = privatePEM
             .replace('-----BEGIN RSA PRIVATE KEY-----','')
             .replace('-----END RSA PRIVATE KEY-----','')
-            .replace(/\s+|\n|\r$/gm, '');
+            .replace(/\s+|\n\r|\n|\r$/gm, '');
         var reader = new ber.Reader(new Buffer(pem, 'base64'));
 
         reader.readSequence();
@@ -96,13 +97,13 @@ module.exports = (function() {
     /**
      * Make key form public PEM string
      *
-     * @param privatePEM {string}
+     * @param publicPEM {string}
      */
-    NodeRSA.prototype.loadFromPublicPEM = function(publicPEM, encoding) {
+    NodeRSA.prototype.$loadFromPublicPEM = function(publicPEM, encoding) {
         var pem = publicPEM
             .replace('-----BEGIN PUBLIC KEY-----','')
             .replace('-----END PUBLIC KEY-----','')
-            .replace(/\s+|\n|\r$/gm, '');
+            .replace(/\s+|\n\r|\n|\r$/gm, '');
         var reader = new ber.Reader(new Buffer(pem, 'base64'));
 
         reader.readSequence();
@@ -178,10 +179,19 @@ module.exports = (function() {
             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);
+        if (this.options.environment == 'browser') {
+            var res = this.keyPair.sign(this.$getDataForEcrypt(buffer, source_encoding), this.options.signingAlgorithm.toLowerCase());
+            if (encoding && encoding != 'buffer') {
+                return res.toString(encoding);
+            } else {
+                return res;
+            }
+        } else {
+            encoding = (!encoding || encoding == 'buffer' ? null : encoding);
+            var signer = crypt.createSign('RSA-' + this.options.signingAlgorithm.toUpperCase());
+            signer.update(this.$getDataForEcrypt(buffer, source_encoding));
+            return signer.sign(this.getPrivatePEM(), encoding);
+        }
     };
 
     /**
@@ -194,10 +204,19 @@ module.exports = (function() {
      * @returns {*}
      */
     NodeRSA.prototype.verify = function(buffer, signature, source_encoding, signature_encoding) {
+        if (!this.isPublic()) {
+            throw Error("It is not public key");
+        }
+
         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);
+
+        if (this.options.environment == 'browser') {
+            return this.keyPair.verify(this.$getDataForEcrypt(buffer, source_encoding), signature, signature_encoding, this.options.signingAlgorithm.toLowerCase());
+        } else {
+            var verifier = crypt.createVerify('RSA-' + this.options.signingAlgorithm.toUpperCase());
+            verifier.update(this.$getDataForEcrypt(buffer, source_encoding));
+            return verifier.verify(this.getPublicPEM(), signature, signature_encoding);
+        }
     };
 
     NodeRSA.prototype.getPrivatePEM = function () {
@@ -253,7 +272,6 @@ module.exports = (function() {
         }
     };
 
-
     /**
      * private
      * Recalculating properties

src/libs/rsa.js

@@ -32,13 +32,23 @@
  */
 
 /*
- * Node.js adaptation, long message support implementation
+ * Node.js adaptation
+ * long message support implementation
+ * signing/verifying
+ *
  * 2014 rzcoder
  */
 
 var crypt = require('crypto');
 var BigInteger = require("./jsbn.js");
 var utils = require('../utils.js');
+var _ = require('lodash');
+
+var SIGNINFOHEAD = {
+    sha1:   new Buffer('3021300906052b0e03021a05000414','hex'),
+    sha256: new Buffer('3031300d060960864801650304020105000420','hex'),
+    md5:    new Buffer('3020300c06082a864886f70d020505000410','hex')
+};
 
 exports.BigInteger = BigInteger;
 module.exports.Key = (function() {
@@ -192,8 +202,8 @@ module.exports.Key = (function() {
         var results = [];
 
         var bufferSize = buffer.length;
-        var buffersCount = Math.ceil(bufferSize / this.maxMessageLength); // total buffers count for encrypt
-        var dividedSize = Math.ceil(bufferSize / buffersCount); // each buffer size
+        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) {
             buffers.push(buffer);
@@ -206,7 +216,7 @@ module.exports.Key = (function() {
         for(var i in buffers) {
             var buf = buffers[i];
 
-            var m = this.$$pkcs1pad2(buf, this.encryptedDataLength);
+            var m = this.$$pkcs1pad2(buf);
 
             if (m === null) {
                 return null;
@@ -246,23 +256,53 @@ module.exports.Key = (function() {
 
         var buffersCount = buffer.length / this.encryptedDataLength;
 
-
         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 = this.$doPrivate(c);
+
             if (m === null) {
                 return null;
             }
 
-            result.push(this.$$pkcs1unpad2(m, this.encryptedDataLength));
+            result.push(this.$$pkcs1unpad2(m));
         }
 
         return Buffer.concat(result);
     };
 
+    RSAKey.prototype.sign = function (buffer, hashAlgorithm) {
+        var hasher = crypt.createHash(hashAlgorithm);
+        hasher.update(buffer);
+        var hash = this.$$pkcs1(hasher.digest(), hashAlgorithm);
+        var encryptedBuffer = this.$doPrivate(new BigInteger(hash)).toBuffer(true);
+
+        while (encryptedBuffer.length < this.encryptedDataLength) {
+            encryptedBuffer = Buffer.concat([new Buffer([0]), encryptedBuffer]);
+        }
+
+        return encryptedBuffer;
+
+    };
+
+    RSAKey.prototype.verify = function (buffer, signature, signature_encoding, hashAlgorithm) {
+
+        if (signature_encoding) {
+            signature = new Buffer(signature, signature_encoding);
+        }
+
+        var hasher = crypt.createHash(hashAlgorithm);
+        hasher.update(buffer);
+
+        var hash = this.$$pkcs1(hasher.digest(), hashAlgorithm);
+        var m = this.$doPublic(new BigInteger(signature));
+
+        return m.toBuffer().toString('hex') == hash.toString('hex');
+    };
+
     Object.defineProperty(RSAKey.prototype, 'encryptedDataLength', {
         get: function() { return this.cache.keyByteLength; }
     });
@@ -282,26 +322,53 @@ module.exports.Key = (function() {
     };
 
     /**
-     * PKCS#1 (type 2, random) pad input buffer to n bytes, and return a bigint
-     * @param buffer
+     * PKCS#1 pad input buffer to max data length
+     * @param hashBuf
+     * @param hashAlgorithm
      * @param n
      * @returns {*}
      */
-    RSAKey.prototype.$$pkcs1pad2 = function (buffer, n) {
-        if (n < buffer.length + 11) {
-            throw new Error("Message too long for RSA (n=" + n + ", l=" + buffer.length + ")");
+    RSAKey.prototype.$$pkcs1 = function (hashBuf, hashAlgorithm, n) {
+        if(!SIGNINFOHEAD[hashAlgorithm])
+            throw Error('Unsupported hash algorithm');
+
+        var data = Buffer.concat([SIGNINFOHEAD[hashAlgorithm], hashBuf]);
+
+        if (data.length + 10 > this.encryptedDataLength) {
+            throw Error('Key is too short for signing algorithm (' + hashAlgorithm + ')');
+        }
+
+        var filled = new Buffer(this.encryptedDataLength - data.length - 1);
+        filled.fill(0xff, 0, filled.length - 1);
+        filled[0] = 1;
+        filled[filled.length - 1] = 0;
+
+        var res = Buffer.concat([filled, data]);
+
+        return res;
+    };
+
+    /**
+     * PKCS#1 (type 2, random) pad input buffer to encryptedDataLength bytes, and return a bigint
+     * @param buffer
+     * @returns {*}
+     */
+    RSAKey.prototype.$$pkcs1pad2 = function (buffer) {
+        if (buffer.length > this.maxMessageLength) {
+            throw new Error("Message too long for RSA (n=" + this.encryptedDataLength + ", l=" + buffer.length + ")");
         }
 
         // TO-DO: make n-length buffer
         var ba = Array.prototype.slice.call(buffer, 0);
 
         // random padding
         ba.unshift(0);
-        var rand = crypt.randomBytes(n - ba.length - 2);
+        var rand = crypt.randomBytes(this.encryptedDataLength - ba.length - 2);
         for(var i = 0; i < rand.length; i++) {
             var r = rand[i];
-            while (r === 0) // non-zero only
+            while (r === 0) { // non-zero only
                 r = crypt.randomBytes(1)[0];
+            }
             ba.unshift(r);
         }
         ba.unshift(2);
@@ -313,17 +380,16 @@ module.exports.Key = (function() {
     /**
      * Undo PKCS#1 (type 2, random) padding and, if valid, return the plaintext
      * @param d
-     * @param n
      * @returns {Buffer}
      */
-    RSAKey.prototype.$$pkcs1unpad2 = function (d, n) {
+    RSAKey.prototype.$$pkcs1unpad2 = function (d) {
         var b = d.toByteArray();
         var i = 0;
         while (i < b.length && b[i] === 0) {
             ++i;
         }
 
-        if (b.length - i != n - 1 || b[i] != 2) {
+        if (b.length - i != this.encryptedDataLength - 1 || b[i] != 2) {
             return null;
         }
 

src/utils.js

@@ -19,6 +19,16 @@ module.exports.linebrk = function (str, maxLen) {
     return res + str.substring(i, str.length);
 };
 
+module.exports.detectEnvironment = function() {
+    if (process && process.title != 'browser') {
+        return 'node';
+    } else if (window) {
+        return 'browser';
+    }
+
+    return 'node';
+};
+
 /**
  * Trying get a 32-bit unsigned integer from the partial buffer
  * @param buffer