encrypt-rsa 1.2.0 → 2.0.1

package/CHANGELOG.md

@@ -1,3 +1,36 @@
+#### 2.0.1 (2022-03-23)
+
+##### Documentation Changes
+
+*  update docs ([c06781e3](https://github.com/miladezzat/encrypt-rsa/commit/c06781e34ec15219f12c1be880005b0ab6696d4a))
+
+## 2.0.0 (2022-03-23)
+
+##### Documentation Changes
+
+*  update docs ([e4e3f254](https://github.com/miladezzat/encrypt-rsa/commit/e4e3f254a4819922138f1e1763415207dc1591c6))
+*  update docs ([de0f8024](https://github.com/miladezzat/encrypt-rsa/commit/de0f8024aad85c591273f93b50952cd72e230693))
+
+##### New Features
+
+*  make methods to take public and private keys as strings ([d47af0f5](https://github.com/miladezzat/encrypt-rsa/commit/d47af0f5c39d49cfb1589b0e236cc7c995bfb395))
+*  add new helper methods to decode and encode keys to base64 ([d3cba4c0](https://github.com/miladezzat/encrypt-rsa/commit/d3cba4c0f36d42e615f22c4ed4b828ed151faecb))
+*  update the docs ([4e470c6f](https://github.com/miladezzat/encrypt-rsa/commit/4e470c6feabfc828172bc484285239a24df064a4))
+
+##### Tests
+
+*  add tests ([373d6c12](https://github.com/miladezzat/encrypt-rsa/commit/373d6c125184bd2e1394091def64280a5392413e))
+
+#### 1.2.1 (2022-02-11)
+
+##### Documentation Changes
+
+*  update docs ([846687b4](https://github.com/miladezzat/encrypt-rsa/commit/846687b4226bad946b2c0a20636ebec433c9005a))
+
+##### New Features
+
+*  add encrypt-rsa.js.org ([3f6b0b4e](https://github.com/miladezzat/encrypt-rsa/commit/3f6b0b4e1fbc8082b9416f3dadd3be277a6e5c3f))
+
 ### 1.2.0 (2022-02-09)
 
 ##### Documentation Changes

package/README.md

@@ -8,7 +8,7 @@
 
 RSA algorithm is asymmetric cryptography algorithm. Asymmetric actually means that it works on two different keys i.e. Public Key and Private Key. As the name describes that the Public Key is given to everyone and Private key is kept private.
 
-### For more explanation about RSA Algorithm visit [https://milad-ezzat.vercel.app/posts/rsa-encryption-algorithm](https://milad-ezzat.vercel.app/posts/rsa-encryption-algorithm)
+## For more explanation about RSA Algorithm visit [RSA algorithm](https://milad-ezzat.vercel.app/blog/encrypt-by-rsa-algorithm)
 
 1. [Installation](#installation)
 2. [Usage](#usage)
@@ -41,16 +41,12 @@ const nodeRSA = new NodeRSA();
 
 const { privateKey, publicKey } = nodeRSA.createPrivateAndPublicKeys()
 
-// to save your keys
-fs.writeFileSync('./private-key', privateKey);
-fs.writeFileSync('./public-key', publicKey);
-
 
 // you must have 'public-key' file the key you want to encrypt by it
 
 const encryptedText = nodeRSA.encryptStringWithRsaPublicKey({ 
   text: 'hello', 
-  keyPath: path.join(__dirname, './public-key') 
+  publicKey: public 
 });
 
 console.log({ encryptedText });
@@ -63,12 +59,10 @@ console.log({ encryptedText });
 
 const decryptedText = nodeRSA.decryptStringWithRsaPrivateKey({ 
   text: encryptedText, 
-  keyPath: path.join(__dirname, './private-key') 
+  privateKey: private 
 });
 
 console.log({ decryptedText });
 // result: { decryptedText: 'hello' }
 
 ```
-for more information about RSA:
-[https://simple.wikipedia.org/wiki/RSA_algorithm](https://simple.wikipedia.org/wiki/RSA_algorithm)

package/build/index.d.ts

@@ -1,32 +1,34 @@
-import { parametersOfEncryptAndDecrypt, returnCreateKeys } from './utils/types';
+import { parametersOfDecrypt, parametersOfEncrypt, returnCreateKeys } from './utils/types';
 declare class NodeRSA {
-    private publicKeyPath;
-    private privateKeyPath;
+    private publicKey;
+    private privateKey;
     private modulusLength;
+    private keyBase64;
     /**
      *
-     * @param publicKeyPath this should be absolute path
-     * @param privateKeyPath this should be absolute path
+     * @param publicKey
+     * @param privateKey
      */
-    constructor(publicKeyPath?: string, privateKeyPath?: string, modulusLength?: number);
+    constructor(publicKey?: string, privateKey?: string, modulusLength?: number);
     /**
      *
      * @param {Object} args
-     * @param {String} args.publicKeyPath
+     * @param {String} args.publicKey
      * @param {String} args.text the text that you need to encrypt
      *
      * @returns {String}
      */
-    encryptStringWithRsaPublicKey(args: parametersOfEncryptAndDecrypt): string;
+    encryptStringWithRsaPublicKey(args: parametersOfEncrypt): string;
     /**
      *
      * @param {Object} args
-     * @param {String} args.privateKeyPath
+     * @param {String} args.privateKey
      * @param {String} args.text the text that you need to decrypt
      *
      * @returns {String}
      */
-    decryptStringWithRsaPrivateKey(args: parametersOfEncryptAndDecrypt): string;
+    decryptStringWithRsaPrivateKey(args: parametersOfDecrypt): string;
     createPrivateAndPublicKeys(modulusLength?: number): returnCreateKeys;
+    private convertKetToBase64;
 }
 export default NodeRSA;

package/build/index.js

@@ -1,57 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var crypto_1 = require("crypto");
-var fs_1 = require("fs");
-var path_1 = require("path");
-var generateKeyPairSync = require('crypto').generateKeyPairSync;
+var helpers_1 = require("./utils/helpers");
 var NodeRSA = /** @class */ (function () {
     /**
      *
-     * @param publicKeyPath this should be absolute path
-     * @param privateKeyPath this should be absolute path
+     * @param publicKey
+     * @param privateKey
      */
-    function NodeRSA(publicKeyPath, privateKeyPath, modulusLength) {
-        if (publicKeyPath === void 0) { publicKeyPath = ''; }
-        if (privateKeyPath === void 0) { privateKeyPath = ''; }
-        this.publicKeyPath = publicKeyPath;
-        this.privateKeyPath = privateKeyPath;
+    function NodeRSA(publicKey, privateKey, modulusLength) {
+        this.publicKey = publicKey;
+        this.privateKey = privateKey;
         this.modulusLength = modulusLength || 2048;
+        this.keyBase64 = '';
     }
     /**
      *
      * @param {Object} args
-     * @param {String} args.publicKeyPath
+     * @param {String} args.publicKey
      * @param {String} args.text the text that you need to encrypt
      *
      * @returns {String}
      */
     NodeRSA.prototype.encryptStringWithRsaPublicKey = function (args) {
-        var text = args.text, _a = args.keyPath, keyPath = _a === void 0 ? this.publicKeyPath : _a;
-        var absolutePath = path_1.resolve(keyPath);
-        var publicKey = fs_1.readFileSync(absolutePath, 'utf8');
+        var text = args.text, _a = args.publicKey, publicKey = _a === void 0 ? this.publicKey : _a;
+        var publicKeyDecoded = helpers_1.decode(this.convertKetToBase64(publicKey));
         var buffer = Buffer.from(text);
-        var encrypted = crypto_1.publicEncrypt(publicKey, buffer);
+        var encrypted = crypto_1.publicEncrypt(publicKeyDecoded, buffer);
         return encrypted.toString('base64');
     };
     /**
      *
      * @param {Object} args
-     * @param {String} args.privateKeyPath
+     * @param {String} args.privateKey
      * @param {String} args.text the text that you need to decrypt
      *
      * @returns {String}
      */
     NodeRSA.prototype.decryptStringWithRsaPrivateKey = function (args) {
-        var text = args.text, _a = args.keyPath, keyPath = _a === void 0 ? this.privateKeyPath : _a;
-        var absolutePath = path_1.resolve(keyPath);
-        var privateKey = fs_1.readFileSync(absolutePath, 'utf8');
+        var text = args.text, _a = args.privateKey, privateKey = _a === void 0 ? this.privateKey : _a;
+        var privateKeyDecoded = helpers_1.decode(this.convertKetToBase64(privateKey));
         var buffer = Buffer.from(text, 'base64');
-        var decrypted = crypto_1.privateDecrypt(privateKey, buffer);
+        var decrypted = crypto_1.privateDecrypt(privateKeyDecoded, buffer);
         return decrypted.toString('utf8');
     };
     NodeRSA.prototype.createPrivateAndPublicKeys = function (modulusLength) {
         if (modulusLength === void 0) { modulusLength = this.modulusLength; }
-        var _a = generateKeyPairSync('rsa', {
+        var _a = crypto_1.generateKeyPairSync('rsa', {
             modulusLength: modulusLength,
             publicKeyEncoding: {
                 type: 'spki',
@@ -64,6 +59,9 @@ var NodeRSA = /** @class */ (function () {
         }), privateKey = _a.privateKey, publicKey = _a.publicKey;
         return { privateKey: privateKey, publicKey: publicKey };
     };
+    NodeRSA.prototype.convertKetToBase64 = function (key) {
+        return helpers_1.encode(key.replace(/^ +/gm, '') || this.keyBase64);
+    };
     return NodeRSA;
 }());
 exports.default = NodeRSA;

package/build/utils/helpers.d.ts

@@ -0,0 +1,2 @@
+export declare const decode: (str: string) => string;
+export declare const encode: (str: string) => string;

package/build/utils/helpers.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = exports.decode = void 0;
+var decode = function (str) { return Buffer.from(str, 'base64').toString('utf-8'); };
+exports.decode = decode;
+var encode = function (str) { return Buffer.from(str, 'utf-8').toString('base64'); };
+exports.encode = encode;

package/build/utils/types.d.ts

@@ -2,7 +2,11 @@ export declare type returnCreateKeys = {
     privateKey: string;
     publicKey: string;
 };
-export declare type parametersOfEncryptAndDecrypt = {
+export declare type parametersOfEncrypt = {
     text: string;
-    keyPath: string;
+    publicKey?: string;
+};
+export declare type parametersOfDecrypt = {
+    text: string;
+    privateKey?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "encrypt-rsa",
-  "version": "1.2.0",
+  "version": "2.0.1",
   "description": "this is a little module use to encrypt and decrypt strings with RSA keys (public and private keys)",
   "main": "./build/index.js",
   "module": "./build/index.js",
@@ -80,5 +80,5 @@
   "bugs": {
     "url": "https://github.com/miladezzat/encrypt-rsa/issues"
   },
-  "homepage": "https://miladezzat.github.io/encrypt-rsa/"
+  "homepage": "https://encrypt-rsa.js.org"
 }