@meebon/meebon-crypto 1.2.3 → 1.2.4

package/dist/ExpressEncryptionMiddleware.js

@@ -0,0 +1,115 @@
+// lib/MeebonCrypto.ts
+import forge from "node-forge";
+var MeebonCrypto = class _MeebonCrypto {
+  privateKeyPem;
+  publicKeyPem;
+  privateKey;
+  publicKey;
+  schema;
+  constructor({ privateKeyPem, publicKeyPem, schema }) {
+    this.privateKeyPem = privateKeyPem;
+    this.publicKeyPem = publicKeyPem;
+    this.privateKey = forge.pki.privateKeyFromPem(privateKeyPem);
+    this.publicKey = forge.pki.publicKeyFromPem(publicKeyPem);
+    this.schema = schema ?? "RSAES-PKCS1-V1_5";
+  }
+  /**
+   * Initializes a new instance of MeebonCrypto.
+   * @param props - The crypto properties including keys and optional encryption scheme.
+   * @returns {MeebonCrypto} The initialized MeebonCrypto instance.
+   */
+  static init(props) {
+    return new _MeebonCrypto(props);
+  }
+  /**
+   * Encrypts data using the instance's public key.
+   * @param {string} plainText - The data to encrypt.
+   * @returns {string} The Base64-encoded encrypted data.
+   */
+  encrypt(plainText) {
+    const encryptedBytes = this.publicKey.encrypt(plainText, this.schema);
+    return forge.util.encode64(encryptedBytes);
+  }
+  /**
+   * Decrypts data using the instance's private key.
+   * @param {string} encryptedData - The Base64-encoded encrypted data.
+   * @returns {string} The decrypted data.
+   */
+  decrypt(encryptedData) {
+    const encryptedBytes = forge.util.decode64(encryptedData);
+    return this.privateKey.decrypt(encryptedBytes, this.schema);
+  }
+  /**
+   * Generates an RSA key pair with the specified key size.
+   *
+   * @param {number} [length=3072] - The length of the RSA key in bits (defaults to 3072).
+   * @returns {MeebonCryptoKeyPair} An object containing the generated public and private keys in PEM format.
+   */
+  static generateKeyPair(length = 3072) {
+    const keyPair = forge.pki.rsa.generateKeyPair({ bits: length, e: 65537 });
+    return {
+      publicKey: forge.pki.publicKeyToPem(keyPair.publicKey),
+      privateKey: forge.pki.privateKeyToPem(keyPair.privateKey)
+    };
+  }
+  /**
+   * Encrypts data with a provided public key.
+   * @param {string} data - The data to encrypt.
+   * @param {string} publicKey - The public key in PEM format.
+   * @param {string} [scheme='RSA-OAEP'] - The encryption scheme to use (defaults to 'RSA-OAEP').
+   * @returns {string} The Base64-encoded encrypted data.
+   */
+  static encryptData(data, publicKey, scheme = "RSA-OAEP") {
+    const publicKeyObj = forge.pki.publicKeyFromPem(publicKey);
+    const encryptedBytes = publicKeyObj.encrypt(data, scheme);
+    return forge.util.encode64(encryptedBytes);
+  }
+  /**
+   * Decrypts data with a provided private key.
+   * @param {string} encryptedData - The Base64-encoded encrypted data.
+   * @param {string} privateKey - The private key in PEM format.
+   * @param {string} [scheme='RSA-OAEP'] - The decryption scheme to use (defaults to 'RSA-OAEP').
+   * @returns {string} The decrypted data.
+   */
+  static decryptData(encryptedData, privateKey, scheme = "RSA-OAEP") {
+    const privateKeyObj = forge.pki.privateKeyFromPem(privateKey);
+    const decodedBytes = forge.util.decode64(encryptedData);
+    return privateKeyObj.decrypt(decodedBytes, scheme);
+  }
+};
+
+// lib/ExpressEncryptionMiddleware.ts
+var encryptionMiddleware = ({ privateKey, publicKey }) => {
+  return (req, res, next) => {
+    if (req.body && req.body.data) {
+      try {
+        const plainText = JSON.stringify(req.body.data);
+        const encrypted = MeebonCrypto.encryptData(plainText, publicKey);
+        req.body.data = encrypted;
+      } catch (error) {
+        return next(new Error(error?.message || "Encryption failed."));
+      }
+    }
+    const originalSend = res.send.bind(res);
+    res.send = (body) => {
+      try {
+        if (typeof body === "string") {
+          const decrypted = MeebonCrypto.decryptData(body, privateKey);
+          try {
+            body = JSON.parse(decrypted);
+          } catch {
+            body = decrypted;
+          }
+        }
+      } catch (error) {
+        throw new Error(error?.message ?? "Decryption failed");
+      }
+      return originalSend(body);
+    };
+    return next();
+  };
+};
+var ExpressEncryptionMiddleware_default = encryptionMiddleware;
+export {
+  ExpressEncryptionMiddleware_default as default
+};

package/dist/MeebonCrypto.js

@@ -0,0 +1,82 @@
+// lib/MeebonCrypto.ts
+import forge from "node-forge";
+var MeebonCrypto = class _MeebonCrypto {
+  privateKeyPem;
+  publicKeyPem;
+  privateKey;
+  publicKey;
+  schema;
+  constructor({ privateKeyPem, publicKeyPem, schema }) {
+    this.privateKeyPem = privateKeyPem;
+    this.publicKeyPem = publicKeyPem;
+    this.privateKey = forge.pki.privateKeyFromPem(privateKeyPem);
+    this.publicKey = forge.pki.publicKeyFromPem(publicKeyPem);
+    this.schema = schema ?? "RSAES-PKCS1-V1_5";
+  }
+  /**
+   * Initializes a new instance of MeebonCrypto.
+   * @param props - The crypto properties including keys and optional encryption scheme.
+   * @returns {MeebonCrypto} The initialized MeebonCrypto instance.
+   */
+  static init(props) {
+    return new _MeebonCrypto(props);
+  }
+  /**
+   * Encrypts data using the instance's public key.
+   * @param {string} plainText - The data to encrypt.
+   * @returns {string} The Base64-encoded encrypted data.
+   */
+  encrypt(plainText) {
+    const encryptedBytes = this.publicKey.encrypt(plainText, this.schema);
+    return forge.util.encode64(encryptedBytes);
+  }
+  /**
+   * Decrypts data using the instance's private key.
+   * @param {string} encryptedData - The Base64-encoded encrypted data.
+   * @returns {string} The decrypted data.
+   */
+  decrypt(encryptedData) {
+    const encryptedBytes = forge.util.decode64(encryptedData);
+    return this.privateKey.decrypt(encryptedBytes, this.schema);
+  }
+  /**
+   * Generates an RSA key pair with the specified key size.
+   *
+   * @param {number} [length=3072] - The length of the RSA key in bits (defaults to 3072).
+   * @returns {MeebonCryptoKeyPair} An object containing the generated public and private keys in PEM format.
+   */
+  static generateKeyPair(length = 3072) {
+    const keyPair = forge.pki.rsa.generateKeyPair({ bits: length, e: 65537 });
+    return {
+      publicKey: forge.pki.publicKeyToPem(keyPair.publicKey),
+      privateKey: forge.pki.privateKeyToPem(keyPair.privateKey)
+    };
+  }
+  /**
+   * Encrypts data with a provided public key.
+   * @param {string} data - The data to encrypt.
+   * @param {string} publicKey - The public key in PEM format.
+   * @param {string} [scheme='RSA-OAEP'] - The encryption scheme to use (defaults to 'RSA-OAEP').
+   * @returns {string} The Base64-encoded encrypted data.
+   */
+  static encryptData(data, publicKey, scheme = "RSA-OAEP") {
+    const publicKeyObj = forge.pki.publicKeyFromPem(publicKey);
+    const encryptedBytes = publicKeyObj.encrypt(data, scheme);
+    return forge.util.encode64(encryptedBytes);
+  }
+  /**
+   * Decrypts data with a provided private key.
+   * @param {string} encryptedData - The Base64-encoded encrypted data.
+   * @param {string} privateKey - The private key in PEM format.
+   * @param {string} [scheme='RSA-OAEP'] - The decryption scheme to use (defaults to 'RSA-OAEP').
+   * @returns {string} The decrypted data.
+   */
+  static decryptData(encryptedData, privateKey, scheme = "RSA-OAEP") {
+    const privateKeyObj = forge.pki.privateKeyFromPem(privateKey);
+    const decodedBytes = forge.util.decode64(encryptedData);
+    return privateKeyObj.decrypt(decodedBytes, scheme);
+  }
+};
+export {
+  MeebonCrypto
+};

package/dist/index.d.ts

@@ -1,4 +1,3 @@
 import { MeebonCrypto } from './MeebonCrypto';
-export declare const EncryptionMiddleware: ({ privateKey, publicKey }: import("../types/global").MeebonCryptoKeyPair) => import("express").RequestHandler;
 export default MeebonCrypto;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,eAAO,MAAM,oBAAoB,gHAAuB,CAAC;AACzD,eAAe,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,eAAe,YAAY,CAAC"}

package/dist/index.js

@@ -78,43 +78,8 @@ var MeebonCrypto = class _MeebonCrypto {
   }
 };
 
-// lib/ExpressEncryptionMiddleware.ts
-var encryptionMiddleware = ({ privateKey, publicKey }) => {
-  return (req, res, next) => {
-    if (req.body && req.body.data) {
-      try {
-        const plainText = JSON.stringify(req.body.data);
-        const encrypted = MeebonCrypto.encryptData(plainText, publicKey);
-        req.body.data = encrypted;
-      } catch (error) {
-        return next(new Error(error?.message || "Encryption failed."));
-      }
-    }
-    const originalSend = res.send.bind(res);
-    res.send = (body) => {
-      try {
-        if (typeof body === "string") {
-          const decrypted = MeebonCrypto.decryptData(body, privateKey);
-          try {
-            body = JSON.parse(decrypted);
-          } catch {
-            body = decrypted;
-          }
-        }
-      } catch (error) {
-        throw new Error(error?.message ?? "Decryption failed");
-      }
-      return originalSend(body);
-    };
-    return next();
-  };
-};
-var ExpressEncryptionMiddleware_default = encryptionMiddleware;
-
 // lib/index.ts
-var EncryptionMiddleware = ExpressEncryptionMiddleware_default;
 var index_default = MeebonCrypto;
 export {
-  EncryptionMiddleware,
   index_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meebon/meebon-crypto",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "",
   "author": "kajalanS <103587022+kajalanS@users.noreply.github.com>",
   "homepage": "https://github.com/KsoftmHub/meebon-crypto?tab=readme-ov-file#getting-started",