encrypt-rsa 3.0.0 → 3.1.0

package/README.md

@@ -1,73 +1,212 @@
+# NodeRSA
 
-# Encrypt By RSA Algorithm
+**NodeRSA** is a library that provides easy-to-use methods for RSA encryption and decryption. It allows generating RSA key pairs, encrypting, and decrypting strings with RSA public and private keys. This library is ideal for secure data transmission, authentication systems, and any application requiring cryptographic security.
 
-[![npm version](https://badge.fury.io/js/encrypt-rsa.svg)](https://badge.fury.io/js/encrypt-rsa) 
-![https://img.shields.io/npm/dm/encrypt-rsa.svg](https://img.shields.io/npm/dm/encrypt-rsa.svg)
+## Installation
+```bash
+npm install node-rsa
+// OR
+yarn add node-rsa
+```
 
-This package works fine with web browsers and servers
+## Usage
+**Importing the Library**
 
-> RSA is a public-key cryptoSystem that is widely used for secure data transmission. It is also one of the oldest. The acronym RSA comes from the surnames of Ron Rivest, Adi Shamir and Leonard Adleman, who publicly described the algorithm in 1977. [Wikipedia](https://en.wikipedia.org/wiki/RSA_(cryptosystem))
+```ts
+import NodeRSA from 'node-rsa';
+```
 
-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.
+## Creating an Instance
 
-### For more explanation about RSA Algorithm visit 
+You can create an instance of the NodeRSA class with optional public and private keys and modulus length.
 
-- [Rsa Algorithm](https://milad-ezzat.vercel.app/blog/encrypt-by-rsa-algorithm)
+```ts
+const nodeRSA = new NodeRSA(publicKey, privateKey, modulusLength);
+```
 
-1. [Installation](#installation)
-2. [Usage](#usage)
+## Generating RSA Key Pairs
+To generate a new pair of RSA keys:
 
-## Installation
+```ts
+const { publicKey, privateKey } = nodeRSA.createPrivateAndPublicKeys(modulusLength);
+console.log('Public Key:', publicKey);
+console.log('Private Key:', privateKey);
+```
 
-```bash
-  npm i encrypt-rsa --only=production
-  // OR
-  yarn add encrypt-rsa --only=production
+## Encrypting and Decrypting Strings
+### Encrypting with RSA Public Key
+```ts
+const text = "Hello, World!";
+const encryptedString = nodeRSA.encryptStringWithRsaPublicKey({ text, publicKey });
+console.log('Encrypted:', encryptedString);
 ```
 
-## Usage
+### Decrypting with RSA Private Key
+```ts
+const decryptedString = nodeRSA.decryptStringWithRsaPrivateKey({ text: encryptedString, privateKey });
+console.log('Decrypted:', decryptedString);
+```
 
-```js
-import EncryptRsa from 'encrypt-rsa';
+### Encrypting with RSA Private Key
+```ts
+const text = "Hello, World!";
+const encryptedString = nodeRSA.encrypt({ text, privateKey });
+console.log('Encrypted with Private Key:', encryptedString);
+```
 
-//OR
+### Decrypting with RSA Public Key
+```ts
+const decryptedString = nodeRSA.decrypt({ text: encryptedString, publicKey });
+console.log('Decrypted with Public Key:', decryptedString);
+```
 
-const EncryptRsa = require('encrypt-rsa').default;
+## API
+### NodeRSA Class
 
-// create instance
-const encryptRsa = new EncryptRsa();
+### Constructor
+```ts
+constructor(publicKey?: string, privateKey?: string, modulusLength?: number)
+```
+- `publicKey`: Optional. The RSA public key.
+- `privateKey`: Optional. The RSA private key.
+- `modulusLength`: Optional. The modulus length for the RSA key pair (default is 2048).
+
+### Methods
+1. `createPrivateAndPublicKeys(modulusLength: number = this.modulusLength): returnCreateKeys`
+    - Generates a new pair of RSA keys.
+    - `modulusLength`: Optional. The modulus length for the RSA key pair (default is the instance's modulus length).
+    - Returns an object containing the `publicKey` and `privateKey`.
+2. `encryptStringWithRsaPublicKey(args: parametersOfEncrypt): string`
+   - Encrypts a string with the given RSA public key.
+   - `args`: Object containing `text` and optionally `publicKey`.
+   - Returns the encrypted string in base64 format.
+  
+3. `decryptStringWithRsaPrivateKey(args: parametersOfDecrypt): string`
+    - Decrypts a string with the given RSA private key.
+    - `args`: Object containing `text` and optionally `privateKey`.
+    - Returns the decrypted string.
+  
+4. `encrypt(args: parametersOfEncryptPrivate): string`
+    - Encrypts a string with the given RSA private key.
+    - `args`: Object containing `text` and optionally `privateKey`.
+    - Returns the encrypted string in base64 format.
+    - 
+5. `decrypt(args: parametersOfDecryptPublic): string`
+    - Decrypts a string with the given RSA public key.
+    - `args`: Object containing `text` and optionally `publicKey`.
+    - Returns the decrypted string.
+  
+### Types
+1. parametersOfEncrypt
+```ts
+{
+  text: string;
+  publicKey?: string;
+}
+```
+2. parametersOfDecrypt
+```ts
+{
+  text: string;
+  privateKey?: string;
+}
 ```
+3. parametersOfEncryptPrivate
+```ts
+{
+  text: string;
+  privateKey?: string;
+}
+```
+4. parametersOfDecryptPublic
+```ts
+{
+  text: string;
+  publicKey?: string;
+}
+```
+5. returnCreateKeys
+```ts
+{
+  publicKey: string;
+  privateKey: string;
+}
+```
+
+### Utilities
+1. `convertKetToBase64(key: string): string` 
+   Converts a given key to base64 format.
 
-### Create Private and Public keys
+### Helper Functions
+1. `encode`
+Encodes a string to base64.
 
-```js
-const { privateKey, publicKey } = nodeRSA.createPrivateAndPublicKeys();
+2. `decode`
+Decodes a base64 string.
+
+### Use Cases
+
+#### Secure Data Transmission
+
+NodeRSA can be used to securely transmit sensitive data over insecure channels. Encrypt data with the recipient's public key before sending it. Only the recipient can decrypt the data with their private key.
+
+
+```ts
+// Sender
+const encryptedMessage = nodeRSA.encryptStringWithRsaPublicKey({ text: "Sensitive data", publicKey: recipientPublicKey });
+// Send `encryptedMessage` to the recipient
+
+// Recipient
+const decryptedMessage = nodeRSA.decryptStringWithRsaPrivateKey({ text: encryptedMessage, privateKey: recipientPrivateKey });
+console.log('Decrypted Message:', decryptedMessage);
 ```
 
-### Encrypt Text
+#### Authentication Systems
+NodeRSA can be used in authentication systems to encrypt credentials and sensitive information.
+
+
+```ts
+// Encrypting user credentials
+const encryptedCredentials = nodeRSA.encryptStringWithRsaPublicKey({ text: "username:password", publicKey: serverPublicKey });
 
-```js
-const encryptedText = encryptRsa.encrypt({ 
-  text: 'hello world',   
-  privateKey,
-});
-console.log(encryptedText);
+// Decrypting credentials on the server
+const decryptedCredentials = nodeRSA.decryptStringWithRsaPrivateKey({ text: encryptedCredentials, privateKey: serverPrivateKey });
+console.log('Decrypted Credentials:', decryptedCredentials);
 ```
 
-### Decrypt Encrypted Text
+#### Digital Signatures
+
+Although not directly covered by the current implementation, RSA can also be used for creating and verifying digital signatures to ensure data integrity and authenticity.
+
 
-```js
-const decryptedText = nodeRSA.decrypt({ 
-  text: encryptedText, 
-  publicKey
-});
-console.log(decryptedText);
-// hello world
+## Contribution
+We welcome contributions to the NodeRSA library! If you'd like to contribute, please follow these steps:
+
+1. Fork the repository on GitHub.
+2. Clone your forked repository to your local machine.
+```bash
+git clone https://github.com/your-username/node-rsa.git
 ```
+3. Create a new branch for your feature or bugfix.
+```bash
+git checkout -b feature/your-feature-name
+```
+4. Make your changes to the codebase.
+5. Commit your changes with a clear and descriptive commit message.
+```bash
+git commit -m "Description of your feature or fix"
+```
+6. Push your changes to your forked repository.
+```bash
+git push origin feature/your-feature-name
+```
+7. Create a pull request on the original repository. Be sure to include a detailed description of your changes and the problem they solve.
+
+## Code of Conduct
+Please note that this project is released with a [Contributor Code of Conduct](./CODE_OF_CONDUCT.md). By participating in this project you agree to abide by its terms.
 
-## Rsa Algorithm:
-- [RSA Algorithm](https://simple.wikipedia.org/wiki/RSA_algorithm)
 
+## Reporting Issues
+If you encounter any issues, please report them using the GitHub issue tracker. Include details about the problem and your environment (OS, Node.js version, etc.).
 
-### Contributions
-feel free to open an [issue](https://github.com/miladezzat/encrypt-rsa/issues) and make a [pull request](https://github.com/miladezzat/encrypt-rsa/pulls)
+Thank you for contributing to NodeRSA!

package/build/functions/convertKetToBase64.d.ts

@@ -0,0 +1,2 @@
+export declare function convertKetToBase64(key: string): string;
+export default convertKetToBase64;

package/build/functions/convertKetToBase64.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertKetToBase64 = void 0;
+var helpers_1 = require("../utils/helpers");
+function convertKetToBase64(key) {
+    return (0, helpers_1.encode)(key.replace(/^ +/gm, ''));
+}
+exports.convertKetToBase64 = convertKetToBase64;
+exports.default = convertKetToBase64;

package/build/functions/createPrivateAndPublicKeys.d.ts

@@ -0,0 +1,3 @@
+import { returnCreateKeys } from '../utils/types';
+export declare function createPrivateAndPublicKeys(modulusLength?: number): returnCreateKeys;
+export default createPrivateAndPublicKeys;

package/build/functions/createPrivateAndPublicKeys.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrivateAndPublicKeys = void 0;
+var crypto = __importStar(require("crypto"));
+function createPrivateAndPublicKeys(modulusLength) {
+    if (modulusLength === void 0) { modulusLength = 2048; }
+    if (typeof crypto.generateKeyPairSync === 'function') {
+        var _a = crypto.generateKeyPairSync('rsa', {
+            modulusLength: modulusLength,
+            publicKeyEncoding: {
+                type: 'spki',
+                format: 'pem',
+            },
+            privateKeyEncoding: {
+                type: 'pkcs8',
+                format: 'pem',
+            },
+        }), privateKey = _a.privateKey, publicKey = _a.publicKey;
+        return { publicKey: publicKey, privateKey: privateKey };
+    }
+    return { privateKey: '', publicKey: '' };
+}
+exports.createPrivateAndPublicKeys = createPrivateAndPublicKeys;
+exports.default = createPrivateAndPublicKeys;

package/build/functions/decrypt.d.ts

@@ -0,0 +1,3 @@
+import { parametersOfDecryptPublic } from '../utils/types';
+export declare function decrypt(args: parametersOfDecryptPublic): string;
+export default decrypt;

package/build/functions/decrypt.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = void 0;
+var crypto = __importStar(require("crypto"));
+var helpers_1 = require("../utils/helpers");
+function decrypt(args) {
+    var text = args.text, publicKey = args.publicKey;
+    var publicKeyDecoded = (0, helpers_1.decode)(publicKey);
+    var buffer = Buffer.from(text, 'base64');
+    var decrypted = crypto.publicDecrypt(publicKeyDecoded, buffer);
+    return decrypted.toString('utf8');
+}
+exports.decrypt = decrypt;
+exports.default = decrypt;

package/build/functions/decryptStringWithRsaPrivateKey.d.ts

@@ -0,0 +1,3 @@
+import { parametersOfDecrypt } from '../utils/types';
+export declare function decryptStringWithRsaPrivateKey(args: parametersOfDecrypt): string;
+export default decryptStringWithRsaPrivateKey;

package/build/functions/decryptStringWithRsaPrivateKey.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptStringWithRsaPrivateKey = void 0;
+var crypto = __importStar(require("crypto"));
+var helpers_1 = require("../utils/helpers");
+function decryptStringWithRsaPrivateKey(args) {
+    var text = args.text, privateKey = args.privateKey;
+    var privateKeyDecoded = (0, helpers_1.decode)(privateKey);
+    var buffer = Buffer.from(text, 'base64');
+    var decrypted = crypto.privateDecrypt(privateKeyDecoded, buffer);
+    return decrypted.toString('utf8');
+}
+exports.decryptStringWithRsaPrivateKey = decryptStringWithRsaPrivateKey;
+exports.default = decryptStringWithRsaPrivateKey;

package/build/functions/encrypt.d.ts

@@ -0,0 +1,3 @@
+import { parametersOfEncryptPrivate } from '../utils/types';
+export declare function encrypt(args: parametersOfEncryptPrivate): string;
+export default encrypt;

package/build/functions/encrypt.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = void 0;
+var crypto = __importStar(require("crypto"));
+var helpers_1 = require("../utils/helpers");
+function encrypt(args) {
+    var text = args.text, privateKey = args.privateKey;
+    var privateKeyDecoded = (0, helpers_1.decode)(privateKey);
+    var buffer = Buffer.from(text);
+    var encrypted = crypto.privateEncrypt(privateKeyDecoded, buffer);
+    return encrypted.toString('base64');
+}
+exports.encrypt = encrypt;
+exports.default = encrypt;

package/build/functions/encryptStringWithRsaPublicKey.d.ts

@@ -0,0 +1,3 @@
+import { parametersOfEncrypt } from '../utils/types';
+export declare function encryptStringWithRsaPublicKey(args: parametersOfEncrypt): string;
+export default encryptStringWithRsaPublicKey;

package/build/functions/encryptStringWithRsaPublicKey.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptStringWithRsaPublicKey = void 0;
+var crypto = __importStar(require("crypto"));
+var helpers_1 = require("../utils/helpers");
+function encryptStringWithRsaPublicKey(args) {
+    var text = args.text, publicKey = args.publicKey;
+    var publicKeyDecoded = (0, helpers_1.decode)(publicKey);
+    var buffer = Buffer === null || Buffer === void 0 ? void 0 : Buffer.from(text);
+    var encrypted = crypto === null || crypto === void 0 ? void 0 : crypto.publicEncrypt(publicKeyDecoded, buffer);
+    return encrypted.toString('base64');
+}
+exports.encryptStringWithRsaPublicKey = encryptStringWithRsaPublicKey;
+exports.default = encryptStringWithRsaPublicKey;

package/build/functions/index.d.ts

@@ -0,0 +1,5 @@
+export * from './createPrivateAndPublicKeys';
+export * from './decrypt';
+export * from './decryptStringWithRsaPrivateKey';
+export * from './encrypt';
+export * from './encryptStringWithRsaPublicKey';

package/build/functions/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./createPrivateAndPublicKeys"), exports);
+__exportStar(require("./decrypt"), exports);
+__exportStar(require("./decryptStringWithRsaPrivateKey"), exports);
+__exportStar(require("./encrypt"), exports);
+__exportStar(require("./encryptStringWithRsaPublicKey"), exports);

package/build/index.d.ts

@@ -1,52 +1,14 @@
-import { parametersOfDecrypt, parametersOfEncrypt, returnCreateKeys } from './utils/types';
+import { parametersOfDecrypt, parametersOfDecryptPublic, parametersOfEncrypt, parametersOfEncryptPrivate, returnCreateKeys } from './utils/types';
 declare class NodeRSA {
     private publicKey;
     private privateKey;
     private modulusLength;
     private keyBase64;
-    /**
-       *
-       * @param publicKey
-       * @param privateKey
-       */
     constructor(publicKey?: string, privateKey?: string, modulusLength?: number);
-    /**
-       *
-       * @param {Object} args
-       * @param {String} args.privateKey
-       * @param {String} args.text the text that you need to encrypt
-       * @deprecated
-       * @returns {String}
-       */
     encryptStringWithRsaPublicKey(args: parametersOfEncrypt): string;
-    /**
-       *
-       * @param {Object} args
-       * @param {String} args.privateKey
-       * @param {String} args.text the text that you need to decrypt
-       * @deprecated
-       * @returns {String}
-       */
     decryptStringWithRsaPrivateKey(args: parametersOfDecrypt): string;
-    /**
-     *
-     * @param {Object} args
-     * @param {String} args.privateKey
-     * @param {String} args.text the text that you need to encrypt
-     *
-     * @returns {String}
-     */
-    encrypt(args: parametersOfEncrypt): string;
-    /**
-       *
-       * @param {Object} args
-       * @param {String} args.privateKey
-       * @param {String} args.text the text that you need to decrypt
-       *
-       * @returns {String}
-       */
-    decrypt(args: parametersOfDecrypt): string;
+    encrypt(args: parametersOfEncryptPrivate): string;
+    decrypt(args: parametersOfDecryptPublic): string;
     createPrivateAndPublicKeys(modulusLength?: number): returnCreateKeys;
-    private convertKetToBase64;
 }
 export default NodeRSA;

package/build/index.js

@@ -1,122 +1,51 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var crypto = __importStar(require("crypto"));
-var helpers_1 = require("./utils/helpers");
+var convertKetToBase64_1 = __importDefault(require("./functions/convertKetToBase64"));
+var createPrivateAndPublicKeys_1 = __importDefault(require("./functions/createPrivateAndPublicKeys"));
+var decrypt_1 = __importDefault(require("./functions/decrypt"));
+var decryptStringWithRsaPrivateKey_1 = __importDefault(require("./functions/decryptStringWithRsaPrivateKey"));
+var encrypt_1 = __importDefault(require("./functions/encrypt"));
+var encryptStringWithRsaPublicKey_1 = __importDefault(require("./functions/encryptStringWithRsaPublicKey"));
 var NodeRSA = /** @class */ (function () {
-    /**
-       *
-       * @param publicKey
-       * @param privateKey
-       */
     function NodeRSA(publicKey, privateKey, modulusLength) {
         this.publicKey = publicKey;
         this.privateKey = privateKey;
         this.modulusLength = modulusLength || 2048;
-        this.keyBase64 = '';
+        this.keyBase64 = 'base64';
     }
-    /**
-       *
-       * @param {Object} args
-       * @param {String} args.privateKey
-       * @param {String} args.text the text that you need to encrypt
-       * @deprecated
-       * @returns {String}
-       */
     NodeRSA.prototype.encryptStringWithRsaPublicKey = function (args) {
-        var text = args.text, _a = args.privateKey, privateKey = _a === void 0 ? this.privateKey : _a;
-        var publicKeyDecoded = (0, helpers_1.decode)(this.convertKetToBase64(privateKey));
-        var buffer = Buffer.from(text);
-        var encrypted = crypto === null || crypto === void 0 ? void 0 : crypto.publicEncrypt(publicKeyDecoded, buffer);
-        return encrypted.toString('base64');
+        var _a = args.publicKey, publicKey = _a === void 0 ? this.publicKey : _a;
+        return (0, encryptStringWithRsaPublicKey_1.default)(__assign(__assign({}, args), { publicKey: (0, convertKetToBase64_1.default)(publicKey) }));
     };
-    /**
-       *
-       * @param {Object} args
-       * @param {String} args.privateKey
-       * @param {String} args.text the text that you need to decrypt
-       * @deprecated
-       * @returns {String}
-       */
     NodeRSA.prototype.decryptStringWithRsaPrivateKey = function (args) {
-        var text = args.text, _a = args.publicKey, publicKey = _a === void 0 ? this.publicKey : _a;
-        var publicKeyDecoded = (0, helpers_1.decode)(this.convertKetToBase64(publicKey));
-        var buffer = Buffer.from(text, 'base64');
-        var decrypted = crypto === null || crypto === void 0 ? void 0 : crypto.privateDecrypt(publicKeyDecoded, buffer);
-        return decrypted.toString('utf8');
+        var _a = args.privateKey, privateKey = _a === void 0 ? this.privateKey : _a;
+        return (0, decryptStringWithRsaPrivateKey_1.default)(__assign(__assign({}, args), { privateKey: (0, convertKetToBase64_1.default)(privateKey) }));
     };
-    /**
-     *
-     * @param {Object} args
-     * @param {String} args.privateKey
-     * @param {String} args.text the text that you need to encrypt
-     *
-     * @returns {String}
-     */
     NodeRSA.prototype.encrypt = function (args) {
-        var text = args.text, _a = args.privateKey, privateKey = _a === void 0 ? this.privateKey : _a;
-        var publicKeyDecoded = (0, helpers_1.decode)(this.convertKetToBase64(privateKey));
-        var buffer = Buffer.from(text);
-        var encrypted = crypto === null || crypto === void 0 ? void 0 : crypto.publicEncrypt(publicKeyDecoded, buffer);
-        return encrypted.toString('base64');
+        var _a = args.privateKey, privateKey = _a === void 0 ? this.privateKey : _a;
+        return (0, encrypt_1.default)(__assign(__assign({}, args), { privateKey: (0, convertKetToBase64_1.default)(privateKey) }));
     };
-    /**
-       *
-       * @param {Object} args
-       * @param {String} args.privateKey
-       * @param {String} args.text the text that you need to decrypt
-       *
-       * @returns {String}
-       */
     NodeRSA.prototype.decrypt = function (args) {
-        var text = args.text, _a = args.publicKey, publicKey = _a === void 0 ? this.publicKey : _a;
-        var publicKeyDecoded = (0, helpers_1.decode)(this.convertKetToBase64(publicKey));
-        var buffer = Buffer.from(text, 'base64');
-        var decrypted = crypto === null || crypto === void 0 ? void 0 : crypto.privateDecrypt(publicKeyDecoded, buffer);
-        return decrypted.toString('utf8');
+        var _a = args.publicKey, publicKey = _a === void 0 ? this.publicKey : _a;
+        return (0, decrypt_1.default)(__assign(__assign({}, args), { publicKey: (0, convertKetToBase64_1.default)(publicKey) }));
     };
     NodeRSA.prototype.createPrivateAndPublicKeys = function (modulusLength) {
         if (modulusLength === void 0) { modulusLength = this.modulusLength; }
-        if (typeof crypto.generateKeyPairSync === 'function') {
-            var _a = crypto.generateKeyPairSync('rsa', {
-                modulusLength: modulusLength,
-                publicKeyEncoding: {
-                    type: 'spki',
-                    format: 'pem',
-                },
-                privateKeyEncoding: {
-                    type: 'pkcs8',
-                    format: 'pem',
-                },
-            }), privateKey = _a.privateKey, publicKey = _a.publicKey;
-            return { publicKey: privateKey, privateKey: publicKey };
-        }
-        return { privateKey: '', publicKey: '' };
-    };
-    NodeRSA.prototype.convertKetToBase64 = function (key) {
-        return (0, helpers_1.encode)(key.replace(/^ +/gm, '') || this.keyBase64);
+        return (0, createPrivateAndPublicKeys_1.default)(modulusLength);
     };
     return NodeRSA;
 }());

package/build/utils/helpers.js

@@ -1,7 +1,21 @@
 "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'); };
+var decode = function (str) {
+    try {
+        return Buffer.from(str, 'base64').toString('utf-8');
+    }
+    catch (error) {
+        throw new Error('Failed to decode base64 string');
+    }
+};
 exports.decode = decode;
-var encode = function (str) { return Buffer.from(str, 'utf-8').toString('base64'); };
+var encode = function (str) {
+    try {
+        return Buffer.from(str, 'utf-8').toString('base64');
+    }
+    catch (error) {
+        throw new Error('Failed to encode string to base64');
+    }
+};
 exports.encode = encode;

package/build/utils/types.d.ts

@@ -1,12 +1,20 @@
-export declare type returnCreateKeys = {
+export type returnCreateKeys = {
     privateKey: string;
     publicKey: string;
 };
-export declare type parametersOfEncrypt = {
+export type parametersOfEncrypt = {
+    text: string;
+    publicKey?: string;
+};
+export type parametersOfDecrypt = {
+    text: string;
+    privateKey?: string;
+};
+export type parametersOfEncryptPrivate = {
     text: string;
     privateKey?: string;
 };
-export declare type parametersOfDecrypt = {
+export type parametersOfDecryptPublic = {
     text: string;
     publicKey?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "encrypt-rsa",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "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",
@@ -11,7 +11,7 @@
   "source": "./src/index.ts",
   "scripts": {
     "test": "mocha -r ts-node/register tests/**/*.spec.ts",
-    "depcheck": "npm-check",
+    "depcheck": "npm-check -u",
     "prepare": "husky install",
     "build": "tsc",
     "commit": "git-cz",
@@ -26,8 +26,8 @@
   },
   "devDependencies": {
     "@types/chai": "^4.2.21",
-    "@types/mocha": "^9.1.1",
-    "@types/node": "^17.0.38",
+    "@types/mocha": "^10.0.7",
+    "@types/node": "^20.14.11",
     "@typescript-eslint/eslint-plugin": "^5.27.0",
     "@typescript-eslint/parser": "^5.27.0",
     "chai": "^4.3.4",
@@ -41,9 +41,10 @@
     "git-cz": "^4.7.6",
     "husky": "^8.0.1",
     "mocha": "^10.0.0",
+    "npm-check": "^6.0.1",
     "pinst": "^3.0.0",
-    "ts-node": "^10.1.0",
     "standard-version": "^9.5.0",
+    "ts-node": "^10.1.0",
     "typescript": "^4.3.5"
   },
   "keywords": [
@@ -79,8 +80,5 @@
   "bugs": {
     "url": "https://github.com/miladezzat/encrypt-rsa/issues"
   },
-  "homepage": "https://encrypt-rsa.js.org",
-  "dependencies": {
-    "npm-check": "^6.0.1"
-  }
+  "homepage": "https://encrypt-rsa.js.org"
 }