encrypt-rsa 3.1.1 → 3.3.0

package/README.md

@@ -174,6 +174,31 @@ const decryptedCredentials = nodeRSA.decryptStringWithRsaPrivateKey({ text: encr
 console.log('Decrypted Credentials:', decryptedCredentials);
 ```
 
+### Buffer Encryption/Decryption Methods:
+
+1. `encryptBufferWithRsaPublicKey`: Converts a buffer to Base64 and then encrypts the Base64 string.
+2. `decryptBufferWithRsaPrivateKey`: Decrypts the Base64 string and converts it back to a buffer.
+
+#### Example Usage
+```ts
+const nodeRSA = new NodeRSA();
+
+// Generate keys
+const { publicKey, privateKey } = nodeRSA.createPrivateAndPublicKeys();
+
+// Example buffer
+const buffer = Buffer.from('This is some binary data');
+
+// Encrypt the buffer
+const encryptedBuffer = nodeRSA.encryptBufferWithRsaPublicKey(buffer, publicKey);
+console.log('Encrypted Buffer:', encryptedBuffer);
+
+// Decrypt back to buffer
+const decryptedBuffer = nodeRSA.decryptBufferWithRsaPrivateKey(encryptedBuffer, privateKey);
+console.log('Decrypted Buffer:', decryptedBuffer.toString());  // should log: 'This is some binary data'
+```
+
+
 #### 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.

package/build/functions/convertKetToBase64.d.ts

@@ -1,2 +1,11 @@
+/**
+ * Converts an RSA key to a base64-encoded string.
+ *
+ * This function removes any leading spaces from each line of the key and then
+ * encodes it to base64 format.
+ *
+ * @param {string} key - The RSA key to be converted to base64. It may contain leading spaces in each line.
+ * @returns {string} The base64-encoded version of the RSA key.
+ */
 export declare function convertKetToBase64(key: string): string;
 export default convertKetToBase64;

package/build/functions/convertKetToBase64.js

@@ -2,6 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertKetToBase64 = void 0;
 var helpers_1 = require("../utils/helpers");
+/**
+ * Converts an RSA key to a base64-encoded string.
+ *
+ * This function removes any leading spaces from each line of the key and then
+ * encodes it to base64 format.
+ *
+ * @param {string} key - The RSA key to be converted to base64. It may contain leading spaces in each line.
+ * @returns {string} The base64-encoded version of the RSA key.
+ */
 function convertKetToBase64(key) {
     return (0, helpers_1.encode)(key.replace(/^ +/gm, ''));
 }

package/build/functions/createPrivateAndPublicKeys.d.ts

@@ -1,3 +1,17 @@
 import { returnCreateKeys } from '../utils/types';
+/**
+ * Generates a pair of RSA private and public keys with the specified modulus length.
+ *
+ * If the `crypto.generateKeyPairSync` function is available, it generates the keys using the provided modulus length,
+ * otherwise, it returns empty strings for both keys.
+ *
+ * @param {number} [modulusLength=2048] - The length of the RSA modulus in bits. Defaults to 2048 bits.
+ * @returns {returnCreateKeys} An object containing the generated RSA public and private keys in PEM format.
+ *
+ * @example
+ * const { publicKey, privateKey } = createPrivateAndPublicKeys(4096);
+ * console.log(publicKey);  // Outputs the public key in PEM format
+ * console.log(privateKey); // Outputs the private key in PEM format
+ */
 export declare function createPrivateAndPublicKeys(modulusLength?: number): returnCreateKeys;
 export default createPrivateAndPublicKeys;

package/build/functions/createPrivateAndPublicKeys.js

@@ -25,6 +25,20 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPrivateAndPublicKeys = void 0;
 var crypto = __importStar(require("crypto"));
+/**
+ * Generates a pair of RSA private and public keys with the specified modulus length.
+ *
+ * If the `crypto.generateKeyPairSync` function is available, it generates the keys using the provided modulus length,
+ * otherwise, it returns empty strings for both keys.
+ *
+ * @param {number} [modulusLength=2048] - The length of the RSA modulus in bits. Defaults to 2048 bits.
+ * @returns {returnCreateKeys} An object containing the generated RSA public and private keys in PEM format.
+ *
+ * @example
+ * const { publicKey, privateKey } = createPrivateAndPublicKeys(4096);
+ * console.log(publicKey);  // Outputs the public key in PEM format
+ * console.log(privateKey); // Outputs the private key in PEM format
+ */
 function createPrivateAndPublicKeys(modulusLength) {
     if (modulusLength === void 0) { modulusLength = 2048; }
     if (typeof crypto.generateKeyPairSync === 'function') {

package/build/functions/decrypt.d.ts

@@ -1,3 +1,19 @@
 import { parametersOfDecryptPublic } from '../utils/types';
+/**
+ * Decrypts a base64-encoded string using an RSA public key.
+ *
+ * The function first decodes the provided RSA public key and the base64-encoded text,
+ * then decrypts the text using the RSA public key.
+ *
+ * @param {parametersOfDecryptPublic} args - An object containing the text to decrypt and the RSA public key.
+ * @param {string} args.text - The base64-encoded string to be decrypted.
+ * @param {string} [args.publicKey] - The RSA public key to use for decryption. If not provided, a default key may be used.
+ * @returns {string} The decrypted string in UTF-8 format.
+ * @throws {Error} If decryption fails due to invalid key or input.
+ *
+ * @example
+ * const decryptedText = decrypt({ text: 'base64EncryptedText', publicKey: 'publicKeyString' });
+ * console.log(decryptedText); // Outputs the decrypted string in UTF-8 format
+ */
 export declare function decrypt(args: parametersOfDecryptPublic): string;
 export default decrypt;

package/build/functions/decrypt.js

@@ -26,6 +26,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.decrypt = void 0;
 var crypto = __importStar(require("crypto"));
 var helpers_1 = require("../utils/helpers");
+/**
+ * Decrypts a base64-encoded string using an RSA public key.
+ *
+ * The function first decodes the provided RSA public key and the base64-encoded text,
+ * then decrypts the text using the RSA public key.
+ *
+ * @param {parametersOfDecryptPublic} args - An object containing the text to decrypt and the RSA public key.
+ * @param {string} args.text - The base64-encoded string to be decrypted.
+ * @param {string} [args.publicKey] - The RSA public key to use for decryption. If not provided, a default key may be used.
+ * @returns {string} The decrypted string in UTF-8 format.
+ * @throws {Error} If decryption fails due to invalid key or input.
+ *
+ * @example
+ * const decryptedText = decrypt({ text: 'base64EncryptedText', publicKey: 'publicKeyString' });
+ * console.log(decryptedText); // Outputs the decrypted string in UTF-8 format
+ */
 function decrypt(args) {
     var text = args.text, publicKey = args.publicKey;
     var publicKeyDecoded = (0, helpers_1.decode)(publicKey);

package/build/functions/decryptStringWithRsaPrivateKey.d.ts

@@ -1,3 +1,18 @@
 import { parametersOfDecrypt } from '../utils/types';
+/**
+ * Decrypts a base64-encoded string using an RSA private key.
+ *
+ * This function decodes the provided RSA private key, then uses it to decrypt the base64-encoded string.
+ *
+ * @param {parametersOfDecrypt} args - An object containing the text to decrypt and the RSA private key.
+ * @param {string} args.text - The base64-encoded string to be decrypted.
+ * @param {string} [args.privateKey] - The RSA private key to use for decryption. If not provided, a default key may be used.
+ * @returns {string} The decrypted string in UTF-8 format.
+ * @throws {Error} If decryption fails due to invalid key or input.
+ *
+ * @example
+ * const decryptedText = decryptStringWithRsaPrivateKey({ text: 'base64EncryptedText', privateKey: 'privateKeyString' });
+ * console.log(decryptedText); // Outputs the decrypted string in UTF-8 format
+ */
 export declare function decryptStringWithRsaPrivateKey(args: parametersOfDecrypt): string;
 export default decryptStringWithRsaPrivateKey;

package/build/functions/decryptStringWithRsaPrivateKey.js

@@ -26,6 +26,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.decryptStringWithRsaPrivateKey = void 0;
 var crypto = __importStar(require("crypto"));
 var helpers_1 = require("../utils/helpers");
+/**
+ * Decrypts a base64-encoded string using an RSA private key.
+ *
+ * This function decodes the provided RSA private key, then uses it to decrypt the base64-encoded string.
+ *
+ * @param {parametersOfDecrypt} args - An object containing the text to decrypt and the RSA private key.
+ * @param {string} args.text - The base64-encoded string to be decrypted.
+ * @param {string} [args.privateKey] - The RSA private key to use for decryption. If not provided, a default key may be used.
+ * @returns {string} The decrypted string in UTF-8 format.
+ * @throws {Error} If decryption fails due to invalid key or input.
+ *
+ * @example
+ * const decryptedText = decryptStringWithRsaPrivateKey({ text: 'base64EncryptedText', privateKey: 'privateKeyString' });
+ * console.log(decryptedText); // Outputs the decrypted string in UTF-8 format
+ */
 function decryptStringWithRsaPrivateKey(args) {
     var text = args.text, privateKey = args.privateKey;
     var privateKeyDecoded = (0, helpers_1.decode)(privateKey);

package/build/functions/encrypt.d.ts

@@ -1,3 +1,19 @@
 import { parametersOfEncryptPrivate } from '../utils/types';
+/**
+ * Encrypts a string using an RSA private key.
+ *
+ * This function encodes the provided RSA private key, converts the input text to a buffer,
+ * and encrypts it using the private key. The result is returned as a base64-encoded string.
+ *
+ * @param {parametersOfEncryptPrivate} args - An object containing the text to encrypt and the RSA private key.
+ * @param {string} args.text - The plain text to be encrypted.
+ * @param {string} [args.privateKey] - The RSA private key to use for encryption. If not provided, a default key may be used.
+ * @returns {string} The encrypted string in base64 format.
+ * @throws {Error} If encryption fails due to invalid key or input.
+ *
+ * @example
+ * const encryptedText = encrypt({ text: 'Hello, World!', privateKey: 'privateKeyString' });
+ * console.log(encryptedText); // Outputs the encrypted string in base64 format
+ */
 export declare function encrypt(args: parametersOfEncryptPrivate): string;
 export default encrypt;

package/build/functions/encrypt.js

@@ -26,6 +26,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.encrypt = void 0;
 var crypto = __importStar(require("crypto"));
 var helpers_1 = require("../utils/helpers");
+/**
+ * Encrypts a string using an RSA private key.
+ *
+ * This function encodes the provided RSA private key, converts the input text to a buffer,
+ * and encrypts it using the private key. The result is returned as a base64-encoded string.
+ *
+ * @param {parametersOfEncryptPrivate} args - An object containing the text to encrypt and the RSA private key.
+ * @param {string} args.text - The plain text to be encrypted.
+ * @param {string} [args.privateKey] - The RSA private key to use for encryption. If not provided, a default key may be used.
+ * @returns {string} The encrypted string in base64 format.
+ * @throws {Error} If encryption fails due to invalid key or input.
+ *
+ * @example
+ * const encryptedText = encrypt({ text: 'Hello, World!', privateKey: 'privateKeyString' });
+ * console.log(encryptedText); // Outputs the encrypted string in base64 format
+ */
 function encrypt(args) {
     var text = args.text, privateKey = args.privateKey;
     var privateKeyDecoded = (0, helpers_1.decode)(privateKey);

package/build/functions/encryptStringWithRsaPublicKey.d.ts

@@ -1,3 +1,19 @@
 import { parametersOfEncrypt } from '../utils/types';
+/**
+ * Encrypts a string using an RSA public key.
+ *
+ * This function decodes the provided RSA public key, converts the input text into a buffer,
+ * and encrypts it using the public key. The encrypted result is returned as a base64-encoded string.
+ *
+ * @param {parametersOfEncrypt} args - An object containing the text to encrypt and the RSA public key.
+ * @param {string} args.text - The plain text to be encrypted.
+ * @param {string} [args.publicKey] - The RSA public key to use for encryption. If not provided, a default key may be used.
+ * @returns {string} The encrypted string in base64 format.
+ * @throws {Error} If encryption fails due to invalid key or input.
+ *
+ * @example
+ * const encryptedText = encryptStringWithRsaPublicKey({ text: 'Hello, World!', publicKey: 'publicKeyString' });
+ * console.log(encryptedText); // Outputs the encrypted string in base64 format
+ */
 export declare function encryptStringWithRsaPublicKey(args: parametersOfEncrypt): string;
 export default encryptStringWithRsaPublicKey;

package/build/functions/encryptStringWithRsaPublicKey.js

@@ -26,6 +26,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.encryptStringWithRsaPublicKey = void 0;
 var crypto = __importStar(require("crypto"));
 var helpers_1 = require("../utils/helpers");
+/**
+ * Encrypts a string using an RSA public key.
+ *
+ * This function decodes the provided RSA public key, converts the input text into a buffer,
+ * and encrypts it using the public key. The encrypted result is returned as a base64-encoded string.
+ *
+ * @param {parametersOfEncrypt} args - An object containing the text to encrypt and the RSA public key.
+ * @param {string} args.text - The plain text to be encrypted.
+ * @param {string} [args.publicKey] - The RSA public key to use for encryption. If not provided, a default key may be used.
+ * @returns {string} The encrypted string in base64 format.
+ * @throws {Error} If encryption fails due to invalid key or input.
+ *
+ * @example
+ * const encryptedText = encryptStringWithRsaPublicKey({ text: 'Hello, World!', publicKey: 'publicKeyString' });
+ * console.log(encryptedText); // Outputs the encrypted string in base64 format
+ */
 function encryptStringWithRsaPublicKey(args) {
     var text = args.text, publicKey = args.publicKey;
     var publicKeyDecoded = (0, helpers_1.decode)(publicKey);

package/build/functions/index.d.ts

@@ -1,5 +1,10 @@
 export * from './createPrivateAndPublicKeys';
+export { default as createPrivateAndPublicKeys } from './decryptStringWithRsaPrivateKey';
 export * from './decrypt';
+export { default as decrypt } from './encryptStringWithRsaPublicKey';
 export * from './decryptStringWithRsaPrivateKey';
+export { default as decryptStringWithRsaPrivateKey } from './decrypt';
 export * from './encrypt';
+export { default as encrypt } from './decryptStringWithRsaPrivateKey';
 export * from './encryptStringWithRsaPublicKey';
+export { default as encryptStringWithRsaPublicKey } from './encrypt';

package/build/functions/index.js

@@ -13,9 +13,23 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 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);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.encryptStringWithRsaPublicKey = exports.encrypt = exports.decryptStringWithRsaPrivateKey = exports.decrypt = exports.createPrivateAndPublicKeys = void 0;
 __exportStar(require("./createPrivateAndPublicKeys"), exports);
+var decryptStringWithRsaPrivateKey_1 = require("./decryptStringWithRsaPrivateKey");
+Object.defineProperty(exports, "createPrivateAndPublicKeys", { enumerable: true, get: function () { return __importDefault(decryptStringWithRsaPrivateKey_1).default; } });
 __exportStar(require("./decrypt"), exports);
+var encryptStringWithRsaPublicKey_1 = require("./encryptStringWithRsaPublicKey");
+Object.defineProperty(exports, "decrypt", { enumerable: true, get: function () { return __importDefault(encryptStringWithRsaPublicKey_1).default; } });
 __exportStar(require("./decryptStringWithRsaPrivateKey"), exports);
+var decrypt_1 = require("./decrypt");
+Object.defineProperty(exports, "decryptStringWithRsaPrivateKey", { enumerable: true, get: function () { return __importDefault(decrypt_1).default; } });
 __exportStar(require("./encrypt"), exports);
+var decryptStringWithRsaPrivateKey_2 = require("./decryptStringWithRsaPrivateKey");
+Object.defineProperty(exports, "encrypt", { enumerable: true, get: function () { return __importDefault(decryptStringWithRsaPrivateKey_2).default; } });
 __exportStar(require("./encryptStringWithRsaPublicKey"), exports);
+var encrypt_1 = require("./encrypt");
+Object.defineProperty(exports, "encryptStringWithRsaPublicKey", { enumerable: true, get: function () { return __importDefault(encrypt_1).default; } });

package/build/index.d.ts

@@ -1,14 +1,92 @@
+/// <reference types="node" />
 import { parametersOfDecrypt, parametersOfDecryptPublic, parametersOfEncrypt, parametersOfEncryptPrivate, returnCreateKeys } from './utils/types';
+/**
+ * NodeRSA class provides encryption and decryption methods using RSA keys.
+ * It supports string and buffer encryption/decryption with both public and private keys.
+ */
 declare class NodeRSA {
+    /**
+       * @private
+       * @type {string | undefined}
+       * Public key used for encryption.
+       */
     private publicKey;
+    /**
+       * @private
+       * @type {string | undefined}
+       * Private key used for decryption.
+       */
     private privateKey;
+    /**
+       * @private
+       * @type {number}
+       * Length of the RSA modulus, defaults to 2048 bits.
+       */
     private modulusLength;
+    /**
+       * @private
+       * @type {'base64'}
+       * Encoding format for the keys.
+       */
     private keyBase64;
+    /**
+       * Constructs a new instance of the NodeRSA class.
+       *
+       * @param {string} [publicKey] - Optional public key for encryption.
+       * @param {string} [privateKey] - Optional private key for decryption.
+       * @param {number} [modulusLength=2048] - Length of the RSA modulus in bits.
+       */
     constructor(publicKey?: string, privateKey?: string, modulusLength?: number);
+    /**
+       * Encrypts a string using the RSA public key.
+       *
+       * @param {parametersOfEncrypt} args - Parameters for encryption, including the text and public key.
+       * @returns {string} Encrypted string in base64 format.
+       */
     encryptStringWithRsaPublicKey(args: parametersOfEncrypt): string;
+    /**
+       * Decrypts a string using the RSA private key.
+       *
+       * @param {parametersOfDecrypt} args - Parameters for decryption, including the encrypted text and private key.
+       * @returns {string} Decrypted plain text string.
+       */
     decryptStringWithRsaPrivateKey(args: parametersOfDecrypt): string;
+    /**
+       * Encrypts a string using the RSA private key.
+       *
+       * @param {parametersOfEncryptPrivate} args - Parameters for encryption, including the text and private key.
+       * @returns {string} Encrypted string in base64 format.
+       */
     encrypt(args: parametersOfEncryptPrivate): string;
+    /**
+       * Decrypts a string using the RSA public key.
+       *
+       * @param {parametersOfDecryptPublic} args - Parameters for decryption, including the encrypted text and public key.
+       * @returns {string} Decrypted plain text string.
+       */
     decrypt(args: parametersOfDecryptPublic): string;
+    /**
+       * Creates a pair of RSA private and public keys with the given modulus length.
+       *
+       * @param {number} [modulusLength=this.modulusLength] - Length of the RSA modulus in bits.
+       * @returns {returnCreateKeys} The generated RSA private and public keys.
+       */
     createPrivateAndPublicKeys(modulusLength?: number): returnCreateKeys;
+    /**
+       * Encrypts a buffer using the RSA public key.
+       *
+       * @param {Buffer} buffer - The buffer to encrypt.
+       * @param {string} [publicKey] - Optional public key for encryption.
+       * @returns {string} Encrypted buffer as a base64 string.
+       */
+    encryptBufferWithRsaPublicKey(buffer: Buffer, publicKey?: string): string;
+    /**
+       * Decrypts a buffer using the RSA private key.
+       *
+       * @param {string} encryptedText - The encrypted base64 string to decrypt.
+       * @param {string} [privateKey] - Optional private key for decryption.
+       * @returns {Buffer} Decrypted buffer.
+       */
+    decryptBufferWithRsaPrivateKey(encryptedText: string, privateKey?: string): Buffer;
 }
 export default NodeRSA;

package/build/index.js

@@ -20,33 +20,96 @@ 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"));
+/**
+ * NodeRSA class provides encryption and decryption methods using RSA keys.
+ * It supports string and buffer encryption/decryption with both public and private keys.
+ */
 var NodeRSA = /** @class */ (function () {
+    /**
+       * Constructs a new instance of the NodeRSA class.
+       *
+       * @param {string} [publicKey] - Optional public key for encryption.
+       * @param {string} [privateKey] - Optional private key for decryption.
+       * @param {number} [modulusLength=2048] - Length of the RSA modulus in bits.
+       */
     function NodeRSA(publicKey, privateKey, modulusLength) {
         this.publicKey = publicKey;
         this.privateKey = privateKey;
         this.modulusLength = modulusLength || 2048;
         this.keyBase64 = 'base64';
     }
+    /**
+       * Encrypts a string using the RSA public key.
+       *
+       * @param {parametersOfEncrypt} args - Parameters for encryption, including the text and public key.
+       * @returns {string} Encrypted string in base64 format.
+       */
     NodeRSA.prototype.encryptStringWithRsaPublicKey = function (args) {
         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) }));
     };
+    /**
+       * Decrypts a string using the RSA private key.
+       *
+       * @param {parametersOfDecrypt} args - Parameters for decryption, including the encrypted text and private key.
+       * @returns {string} Decrypted plain text string.
+       */
     NodeRSA.prototype.decryptStringWithRsaPrivateKey = function (args) {
         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) }));
     };
+    /**
+       * Encrypts a string using the RSA private key.
+       *
+       * @param {parametersOfEncryptPrivate} args - Parameters for encryption, including the text and private key.
+       * @returns {string} Encrypted string in base64 format.
+       */
     NodeRSA.prototype.encrypt = function (args) {
         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) }));
     };
+    /**
+       * Decrypts a string using the RSA public key.
+       *
+       * @param {parametersOfDecryptPublic} args - Parameters for decryption, including the encrypted text and public key.
+       * @returns {string} Decrypted plain text string.
+       */
     NodeRSA.prototype.decrypt = function (args) {
         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) }));
     };
+    /**
+       * Creates a pair of RSA private and public keys with the given modulus length.
+       *
+       * @param {number} [modulusLength=this.modulusLength] - Length of the RSA modulus in bits.
+       * @returns {returnCreateKeys} The generated RSA private and public keys.
+       */
     NodeRSA.prototype.createPrivateAndPublicKeys = function (modulusLength) {
         if (modulusLength === void 0) { modulusLength = this.modulusLength; }
         return (0, createPrivateAndPublicKeys_1.default)(modulusLength);
     };
+    /**
+       * Encrypts a buffer using the RSA public key.
+       *
+       * @param {Buffer} buffer - The buffer to encrypt.
+       * @param {string} [publicKey] - Optional public key for encryption.
+       * @returns {string} Encrypted buffer as a base64 string.
+       */
+    NodeRSA.prototype.encryptBufferWithRsaPublicKey = function (buffer, publicKey) {
+        var base64String = buffer.toString(this.keyBase64);
+        return this.encryptStringWithRsaPublicKey({ text: base64String, publicKey: publicKey });
+    };
+    /**
+       * Decrypts a buffer using the RSA private key.
+       *
+       * @param {string} encryptedText - The encrypted base64 string to decrypt.
+       * @param {string} [privateKey] - Optional private key for decryption.
+       * @returns {Buffer} Decrypted buffer.
+       */
+    NodeRSA.prototype.decryptBufferWithRsaPrivateKey = function (encryptedText, privateKey) {
+        var decryptedBase64 = this.decryptStringWithRsaPrivateKey({ text: encryptedText, privateKey: privateKey });
+        return Buffer.from(decryptedBase64, this.keyBase64);
+    };
     return NodeRSA;
 }());
 exports.default = NodeRSA;

package/build/utils/helpers.d.ts

@@ -1,2 +1,16 @@
+/**
+ * Decodes a base64-encoded string into a UTF-8 string.
+ *
+ * @param {string} str - The base64-encoded string to decode.
+ * @returns {string} The decoded UTF-8 string.
+ * @throws {Error} If the input string cannot be decoded.
+ */
 export declare const decode: (str: string) => string;
+/**
+   * Encodes a UTF-8 string into a base64-encoded string.
+   *
+   * @param {string} str - The UTF-8 string to encode.
+   * @returns {string} The base64-encoded string.
+   * @throws {Error} If the input string cannot be encoded.
+   */
 export declare const encode: (str: string) => string;

package/build/utils/helpers.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encode = exports.decode = void 0;
+/**
+ * Decodes a base64-encoded string into a UTF-8 string.
+ *
+ * @param {string} str - The base64-encoded string to decode.
+ * @returns {string} The decoded UTF-8 string.
+ * @throws {Error} If the input string cannot be decoded.
+ */
 var decode = function (str) {
     try {
         return Buffer.from(str, 'base64').toString('utf-8');
@@ -10,6 +17,13 @@ var decode = function (str) {
     }
 };
 exports.decode = decode;
+/**
+   * Encodes a UTF-8 string into a base64-encoded string.
+   *
+   * @param {string} str - The UTF-8 string to encode.
+   * @returns {string} The base64-encoded string.
+   * @throws {Error} If the input string cannot be encoded.
+   */
 var encode = function (str) {
     try {
         return Buffer.from(str, 'utf-8').toString('base64');

package/build/utils/types.d.ts

@@ -1,19 +1,54 @@
+/**
+ * Type representing the return value of a function that creates RSA keys.
+ *
+ * @typedef {Object} returnCreateKeys
+ * @property {string} privateKey - The generated RSA private key.
+ * @property {string} publicKey - The generated RSA public key.
+ */
 export type returnCreateKeys = {
     privateKey: string;
     publicKey: string;
 };
+/**
+ * Type representing the parameters required to encrypt text using a public key.
+ *
+ * @typedef {Object} parametersOfEncrypt
+ * @property {string} text - The plain text to be encrypted.
+ * @property {string} [publicKey] - Optional RSA public key for encryption. If not provided, a default key may be used.
+ */
 export type parametersOfEncrypt = {
     text: string;
     publicKey?: string;
 };
+/**
+ * Type representing the parameters required to decrypt text using a private key.
+ *
+ * @typedef {Object} parametersOfDecrypt
+ * @property {string} text - The base64-encoded string to be decrypted.
+ * @property {string} [privateKey] - Optional RSA private key for decryption. If not provided, a default key may be used.
+ */
 export type parametersOfDecrypt = {
     text: string;
     privateKey?: string;
 };
+/**
+ * Type representing the parameters required to encrypt text using a private key.
+ *
+ * @typedef {Object} parametersOfEncryptPrivate
+ * @property {string} text - The plain text to be encrypted.
+ * @property {string} [privateKey] - Optional RSA private key for encryption. If not provided, a default key may be used.
+ */
 export type parametersOfEncryptPrivate = {
     text: string;
     privateKey?: string;
 };
+/**
+ * Type representing the parameters required to decrypt text using a public key.
+ *
+ * @typedef {Object} parametersOfDecryptPublic
+ * @property {string} text - The base64-encoded string to be decrypted.
+ * @property {string} [publicKey] - Optional RSA public key for decryption. If not provided, a default key may be used.
+ */
 export type parametersOfDecryptPublic = {
     text: string;
     publicKey?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "encrypt-rsa",
-  "version": "3.1.1",
+  "version": "3.3.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",
@@ -22,6 +22,7 @@
     "prepublish": "npm run build",
     "husky": "husky",
     "lint": "eslint",
+    "docs": "npx @compodoc/compodoc -p tsconfig.json -d docs",
     "release": "standard-version"
   },
   "devDependencies": {