@meebon/meebon-crypto 1.3.0 → 1.5.0

package/dist/ExpressEncryptionMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { RequestHandler } from 'express';
+import { Request, Response, NextFunction, RequestHandler } from 'express';
 import { MeebonCryptoKeyPair } from '../types/global';
 /**
  * Middleware to encrypt response bodies if the request header 'x-require-encryption' is present.
@@ -38,6 +38,6 @@ declare function encryptionMiddleware({ publicKey }: Omit<MeebonCryptoKeyPair, "
  * @param {string} param.privateKey - The private key used for decryption.
  * @returns {RequestHandler} The middleware function.
  */
-declare function decryptMiddleware({ privateKey }: Omit<MeebonCryptoKeyPair, "publicKey">): RequestHandler;
+declare function decryptMiddleware({ privateKey }: Omit<MeebonCryptoKeyPair, "publicKey">): (req: Request, res: Response, next: NextFunction) => void;
 export { encryptionMiddleware, decryptMiddleware };
 //# sourceMappingURL=ExpressEncryptionMiddleware.d.ts.map

package/dist/ExpressEncryptionMiddleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExpressEncryptionMiddleware.d.ts","sourceRoot":"","sources":["../lib/ExpressEncryptionMiddleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAmC,cAAc,EAAE,MAAM,SAAS,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iBAAS,oBAAoB,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,CAAC,mBAAmB,EAAE,YAAY,CAAC,GAAG,cAAc,CA0BpG;AAID;;;;;;;;;;;;GAYG;AACH,iBAAS,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAAE,IAAI,CAAC,mBAAmB,EAAE,WAAW,CAAC,GAAG,cAAc,CAYjG;AAED,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,CAAC"}
+{"version":3,"file":"ExpressEncryptionMiddleware.d.ts","sourceRoot":"","sources":["../lib/ExpressEncryptionMiddleware.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC1E,OAAO,EAAqC,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAEzF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iBAAS,oBAAoB,CAAC,EAAE,SAAS,EAAE,EAAE,IAAI,CAAC,mBAAmB,EAAE,YAAY,CAAC,GAAG,cAAc,CAkBpG;AAID;;;;;;;;;;;;GAYG;AACH,iBAAS,iBAAiB,CAAC,EAAE,UAAU,EAAE,EAAE,IAAI,CAAC,mBAAmB,EAAE,WAAW,CAAC,IACvE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,UAWxD;AAED,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/index.cjs

@@ -0,0 +1,157 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MeebonCrypto: () => MeebonCrypto,
+  decryptMiddleware: () => decryptMiddleware,
+  encryptionMiddleware: () => encryptionMiddleware
+});
+module.exports = __toCommonJS(index_exports);
+
+// lib/MeebonCrypto.ts
+var import_node_forge = __toESM(require("node-forge"), 1);
+var MeebonCrypto = class _MeebonCrypto {
+  privateKeyPem;
+  publicKeyPem;
+  privateKey;
+  publicKey;
+  schema;
+  constructor({ privateKeyPem, publicKeyPem, schema }) {
+    this.privateKeyPem = privateKeyPem;
+    this.publicKeyPem = publicKeyPem;
+    this.privateKey = import_node_forge.default.pki.privateKeyFromPem(privateKeyPem);
+    this.publicKey = import_node_forge.default.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 import_node_forge.default.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 = import_node_forge.default.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 = import_node_forge.default.pki.rsa.generateKeyPair({ bits: length, e: 65537 });
+    return {
+      publicKey: import_node_forge.default.pki.publicKeyToPem(keyPair.publicKey),
+      privateKey: import_node_forge.default.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 = import_node_forge.default.pki.publicKeyFromPem(publicKey);
+    const encryptedBytes = publicKeyObj.encrypt(data, scheme);
+    return import_node_forge.default.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 = import_node_forge.default.pki.privateKeyFromPem(privateKey);
+    const decodedBytes = import_node_forge.default.util.decode64(encryptedData);
+    return privateKeyObj.decrypt(decodedBytes, scheme);
+  }
+};
+
+// lib/ExpressEncryptionMiddleware.ts
+function encryptionMiddleware({ publicKey }) {
+  return (req, res, next) => {
+    const originalSend = res.send.bind(res);
+    const originalJson = res.json.bind(res);
+    res.send = function(body) {
+      let bodyString = typeof body === "object" ? JSON.stringify(body) : body.toString();
+      const encryptedBody = MeebonCrypto.encryptData(bodyString, publicKey);
+      res.set("Content-Type", "text/plain");
+      return originalSend(encryptedBody);
+    };
+    res.json = function(body) {
+      const bodyString = JSON.stringify(body);
+      const encryptedBody = MeebonCrypto.encryptData(bodyString, publicKey);
+      res.set("Content-Type", "text/plain");
+      return originalSend(encryptedBody);
+    };
+    next();
+  };
+}
+function decryptMiddleware({ privateKey }) {
+  return (req, res, next) => {
+    if (typeof req.body === "string") {
+      try {
+        const decryptedText = MeebonCrypto.decryptData(req.body, privateKey);
+        req.body = JSON.parse(decryptedText);
+      } catch (err) {
+        res.status(400).json({ error: "Invalid encrypted data" });
+      }
+    }
+    next();
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MeebonCrypto,
+  decryptMiddleware,
+  encryptionMiddleware
+});

package/dist/index.js

@@ -84,31 +84,23 @@ function encryptionMiddleware({ publicKey }) {
     const originalSend = res.send.bind(res);
     const originalJson = res.json.bind(res);
     res.send = function(body) {
-      if (req.headers["x-require-encryption"]) {
-        let bodyString = typeof body === "object" ? JSON.stringify(body) : body.toString();
-        const encryptedBody = MeebonCrypto.encryptData(bodyString, publicKey);
-        res.set("Content-Type", "text/plain");
-        return originalSend(encryptedBody);
-      } else {
-        return originalSend(body);
-      }
+      let bodyString = typeof body === "object" ? JSON.stringify(body) : body.toString();
+      const encryptedBody = MeebonCrypto.encryptData(bodyString, publicKey);
+      res.set("Content-Type", "text/plain");
+      return originalSend(encryptedBody);
     };
     res.json = function(body) {
-      if (req.headers["x-require-encryption"]) {
-        const bodyString = JSON.stringify(body);
-        const encryptedBody = MeebonCrypto.encryptData(bodyString, publicKey);
-        res.set("Content-Type", "text/plain");
-        return originalSend(encryptedBody);
-      } else {
-        return originalJson(body);
-      }
+      const bodyString = JSON.stringify(body);
+      const encryptedBody = MeebonCrypto.encryptData(bodyString, publicKey);
+      res.set("Content-Type", "text/plain");
+      return originalSend(encryptedBody);
     };
     next();
   };
 }
 function decryptMiddleware({ privateKey }) {
   return (req, res, next) => {
-    if (req.headers["x-encrypted"] && typeof req.body === "string") {
+    if (typeof req.body === "string") {
       try {
         const decryptedText = MeebonCrypto.decryptData(req.body, privateKey);
         req.body = JSON.parse(decryptedText);

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "@meebon/meebon-crypto",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "",
   "author": "kajalanS <103587022+kajalanS@users.noreply.github.com>",
   "homepage": "https://github.com/KsoftmHub/meebon-crypto?tab=readme-ov-file#getting-started",
   "license": "MIT",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "type": "module",
-  "types": "types",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "types": "dist/index.d.ts",
   "directories": {
     "lib": "lib",
     "tests": "tests",

package/types/global.d.ts

@@ -10,3 +10,11 @@ export interface MeebonCryptoKeyPair {
   privateKey: string;
   publicKey: string;
 }
+
+export interface IDecryptRequest extends Request {
+  decrypt: (data: any) => any;
+}
+
+export interface IEncryptResponse extends Response {
+  encrypt: (data: any) => any;
+}