@edirect/encrypt-modules 11.0.62-beta.0 → 11.0.62-beta.2

package/dist/README.md

@@ -0,0 +1,149 @@
+# @edirect/encrypt-modules
+
+Encryption utilities for eDirect NestJS applications. Provides four NestJS modules for different encryption algorithms: **PGP**, **Binary PGP**, **AES-256**, and **RSA** — plus a **ZIP** module for password-protected archive creation.
+
+## Features
+
+- **PGP** encryption/decryption using OpenPGP.js (`openpgp`)
+- **Binary PGP** for binary data encryption
+- **AES-256-CBC** (and other AES variants) using Node.js native `crypto`
+- **RSA** encryption/decryption using `node-rsa`
+- **ZIP** password-protected archive creation
+- NestJS module integration for each encryption type
+
+## Installation
+
+```sh
+pnpm add @edirect/encrypt-modules
+# or
+npm install @edirect/encrypt-modules
+```
+
+## Available Modules
+
+### PGP Encryption (`PgpEncryptModule`)
+
+Asymmetric encryption using OpenPGP keys:
+
+```ts
+import { Module } from '@nestjs/common';
+import { PgpEncryptModule } from '@edirect/encrypt-modules';
+
+@Module({
+  imports: [PgpEncryptModule],
+})
+export class AppModule {}
+```
+
+```ts
+import { Injectable } from '@nestjs/common';
+import { PgpEncryptService } from '@edirect/encrypt-modules';
+
+@Injectable()
+export class SecureDataService {
+  constructor(private readonly pgp: PgpEncryptService) {}
+
+  async encryptPayload(data: string, publicKey: string): Promise<string> {
+    return this.pgp.encrypt(publicKey, data);
+  }
+
+  async decryptPayload(
+    encryptedData: string,
+    privateKey: string,
+    passphrase?: string
+  ): Promise<string> {
+    return this.pgp.decrypt(privateKey, encryptedData, passphrase);
+  }
+}
+```
+
+**`PgpEncryptService` API:**
+
+| Method    | Signature                                                                       | Description                          |
+| --------- | ------------------------------------------------------------------------------- | ------------------------------------ |
+| `encrypt` | `(pgpKey: string, dataToEncrypt: string): Promise<string>`                      | Encrypt data using a PGP public key  |
+| `decrypt` | `(pgpKey: string, encryptedData: string, passphrase?: string): Promise<string>` | Decrypt data using a PGP private key |
+
+### AES Encryption (`AesEncryptModule`)
+
+Symmetric encryption using Node.js `crypto`:
+
+```ts
+import { AesEncryptModule } from '@edirect/encrypt-modules';
+
+@Module({ imports: [AesEncryptModule] })
+export class AppModule {}
+```
+
+```ts
+import { AesEncryptService } from '@edirect/encrypt-modules';
+
+// Default: AES-256-CBC
+const encrypted = aesService.encrypt(
+  'secret data',
+  'my-32-char-passphrase-here!!!!!'
+);
+const decrypted = aesService.decrypt(
+  encrypted,
+  'my-32-char-passphrase-here!!!!!'
+);
+
+// With custom IV and encoding
+const encrypted2 = aesService.encrypt('data', passphrase, {
+  iv: customIv,
+  encryptionMethod: 'aes-256-cbc',
+  outputEncoding: 'base64',
+});
+```
+
+**`AesEncryptService` API:**
+
+| Method    | Signature                                                                                             | Description                |
+| --------- | ----------------------------------------------------------------------------------------------------- | -------------------------- |
+| `encrypt` | `(message: string, passphrase: CipherKey, options?: IaesEncryptOptionalParameters): string`           | Synchronous AES encryption |
+| `decrypt` | `(encryptedMessage: string, passphrase: BinaryLike, options?: IaesDecryptOptionalParameters): string` | Synchronous AES decryption |
+
+### RSA Encryption (`RsaEncryptModule`)
+
+Asymmetric encryption using `node-rsa`:
+
+```ts
+import { RsaEncryptModule } from '@edirect/encrypt-modules';
+
+@Module({ imports: [RsaEncryptModule] })
+export class AppModule {}
+```
+
+```ts
+import { RsaEncryptService } from '@edirect/encrypt-modules';
+
+const encrypted = rsaService.encrypt(data, 512, 'utf8');
+const decrypted = rsaService.decrypt(encrypted, privateKey, 'utf8');
+```
+
+### ZIP with Password (`ZipEncryptModule`)
+
+Create password-protected ZIP archives:
+
+```ts
+import { ZipEncryptModule } from '@edirect/encrypt-modules';
+
+@Module({ imports: [ZipEncryptModule] })
+export class AppModule {}
+```
+
+## AES Optional Parameters
+
+| Option             | Type               | Default         | Description                        |
+| ------------------ | ------------------ | --------------- | ---------------------------------- |
+| `iv`               | `BinaryLike`       | Random          | Initialization vector              |
+| `encryptionMethod` | `string`           | `'aes-256-cbc'` | Cipher algorithm                   |
+| `inputEncoding`    | `Encoding`         | `'utf8'`        | Input data encoding                |
+| `outputEncoding`   | `Encoding`         | `'hex'`         | Output encoding for encrypted data |
+| `options`          | `TransformOptions` | —               | Additional stream options          |
+
+## Security Notes
+
+- Never hardcode encryption keys in source code. Use environment variables.
+- For PGP keys, store them in secure secret management (e.g., Kubernetes Secrets, AWS Secrets Manager).
+- AES keys must be exactly 32 bytes for AES-256. Use a key derivation function (KDF) if your passphrase is shorter.

package/dist/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@edirect/encrypt-modules",
+  "version": "11.0.62-beta.2",
+  "description": "Encrypt Modules",
+  "main": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/src/index.js",
+      "default": "./dist/src/index.js",
+      "require": "./dist/src/index.js",
+      "types": "./dist/src/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nestjs/common": "^11.1.19",
+    "archiver": "8.0.0",
+    "archiver-zip-encrypted": "^2.0.0",
+    "node-rsa": "1.1.1",
+    "openpgp": "^6.3.0",
+    "stream-buffers": "^3.0.3",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@types/archiver": "^7.0.0",
+    "@types/node": "^25.6.2",
+    "@types/node-rsa": "^1.1.4",
+    "@types/stream-buffers": "^3.0.8"
+  },
+  "type": "commonjs"
+}

package/dist/src/aes-encrypt/aes-encrypt.interface.d.ts

@@ -0,0 +1,23 @@
+import { BinaryLike, CipherCCMTypes, CipherKey, Encoding } from 'crypto';
+import { TransformOptions } from 'stream';
+type encryptionMethods = CipherCCMTypes | 'aes-256-cbc';
+export interface IaesEncryptOptionalParameters {
+    iv?: BinaryLike;
+    encryptionMethod?: encryptionMethods;
+    inputEncoding?: Encoding;
+    outputEncoding?: Encoding;
+    options?: TransformOptions;
+}
+export interface IaesDecryptOptionalParameters {
+    iv?: BinaryLike;
+    encryptionMethod?: encryptionMethods;
+    inputEncoding?: Encoding;
+    outputEncoding?: Encoding;
+    options?: TransformOptions;
+}
+export interface AesEncryptInterface {
+    encrypt(message: string, passphrase: CipherKey, optionalParameters?: IaesEncryptOptionalParameters): string;
+    decrypt(encryptedMessage: string, passphrase: BinaryLike, optionalParameters?: IaesDecryptOptionalParameters): string;
+}
+export {};
+//# sourceMappingURL=aes-encrypt.interface.d.ts.map

package/dist/src/aes-encrypt/aes-encrypt.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes-encrypt.interface.d.ts","sourceRoot":"","sources":["../../../src/aes-encrypt/aes-encrypt.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAE1C,KAAK,iBAAiB,GAAG,cAAc,GAAG,aAAa,CAAC;AAExD,MAAM,WAAW,6BAA6B;IAC5C,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;IACrC,aAAa,CAAC,EAAE,QAAQ,CAAC;IACzB,cAAc,CAAC,EAAE,QAAQ,CAAC;IAC1B,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AAED,MAAM,WAAW,6BAA6B;IAC5C,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,gBAAgB,CAAC,EAAE,iBAAiB,CAAC;IACrC,aAAa,CAAC,EAAE,QAAQ,CAAC;IACzB,cAAc,CAAC,EAAE,QAAQ,CAAC;IAC1B,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,CACL,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,SAAS,EACrB,kBAAkB,CAAC,EAAE,6BAA6B,GACjD,MAAM,CAAC;IAEV,OAAO,CACL,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,UAAU,EACtB,kBAAkB,CAAC,EAAE,6BAA6B,GACjD,MAAM,CAAC;CACX"}

package/dist/src/aes-encrypt/aes-encrypt.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/aes-encrypt/aes-encrypt.module.d.ts

@@ -0,0 +1,3 @@
+export declare class AesEncryptModule {
+}
+//# sourceMappingURL=aes-encrypt.module.d.ts.map

package/dist/src/aes-encrypt/aes-encrypt.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes-encrypt.module.d.ts","sourceRoot":"","sources":["../../../src/aes-encrypt/aes-encrypt.module.ts"],"names":[],"mappings":"AAGA,qBAIa,gBAAgB;CAAG"}

package/dist/src/aes-encrypt/aes-encrypt.module.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AesEncryptModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const aes_encrypt_service_1 = require("./aes-encrypt.service");
+let AesEncryptModule = class AesEncryptModule {
+};
+exports.AesEncryptModule = AesEncryptModule;
+exports.AesEncryptModule = AesEncryptModule = tslib_1.__decorate([
+    (0, common_1.Module)({
+        providers: [aes_encrypt_service_1.AesEncryptService],
+        exports: [aes_encrypt_service_1.AesEncryptService],
+    })
+], AesEncryptModule);

package/dist/src/aes-encrypt/aes-encrypt.service.d.ts

@@ -0,0 +1,7 @@
+import { BinaryLike, CipherKey } from 'crypto';
+import { AesEncryptInterface, IaesDecryptOptionalParameters, IaesEncryptOptionalParameters } from './aes-encrypt.interface';
+export declare class AesEncryptService implements AesEncryptInterface {
+    encrypt(message: string, passphrase: CipherKey, optionalParameters?: IaesEncryptOptionalParameters): string;
+    decrypt(encryptedMessage: string, passphrase: BinaryLike, optionalParameters?: IaesDecryptOptionalParameters): string;
+}
+//# sourceMappingURL=aes-encrypt.service.d.ts.map

package/dist/src/aes-encrypt/aes-encrypt.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes-encrypt.service.d.ts","sourceRoot":"","sources":["../../../src/aes-encrypt/aes-encrypt.service.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,SAAS,EAIV,MAAM,QAAQ,CAAC;AAEhB,OAAO,EACL,mBAAmB,EACnB,6BAA6B,EAC7B,6BAA6B,EAC9B,MAAM,yBAAyB,CAAC;AAEjC,qBACa,iBAAkB,YAAW,mBAAmB;IACpD,OAAO,CACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,SAAS,EACrB,kBAAkB,GAAE,6BAAkC,GACrD,MAAM;IAyBF,OAAO,CACZ,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,UAAU,EACtB,kBAAkB,GAAE,6BAAkC,GACrD,MAAM;CAwBV"}

package/dist/src/aes-encrypt/aes-encrypt.service.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AesEncryptService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+let AesEncryptService = class AesEncryptService {
+    encrypt(message, passphrase, optionalParameters = {}) {
+        optionalParameters = {
+            ...{
+                iv: Buffer.alloc(16).fill(0),
+                encryptionMethod: 'aes-256-cbc',
+                inputEncoding: 'utf8',
+                outputEncoding: 'hex',
+            },
+            ...optionalParameters,
+        };
+        const cipher = (0, crypto_1.createCipheriv)(optionalParameters.encryptionMethod, passphrase, optionalParameters.iv, optionalParameters.options);
+        let result = cipher.update(message, optionalParameters.inputEncoding, optionalParameters.outputEncoding);
+        result += cipher.final(optionalParameters.outputEncoding);
+        return result;
+    }
+    decrypt(encryptedMessage, passphrase, optionalParameters = {}) {
+        optionalParameters = {
+            ...{
+                encryptionMethod: 'aes-256-cbc',
+                iv: Buffer.alloc(16).fill(0),
+                inputEncoding: 'hex',
+                outputEncoding: 'utf8',
+            },
+            ...optionalParameters,
+        };
+        const decipher = (0, crypto_1.createDecipheriv)(optionalParameters.encryptionMethod, passphrase, optionalParameters.iv, optionalParameters.options);
+        let result = decipher.update(encryptedMessage, optionalParameters.inputEncoding, optionalParameters.outputEncoding);
+        result += decipher.final(optionalParameters.outputEncoding);
+        return result;
+    }
+};
+exports.AesEncryptService = AesEncryptService;
+exports.AesEncryptService = AesEncryptService = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], AesEncryptService);

package/dist/src/bin-pgp-encrypt/bin-pgp-encrypt.interface.d.ts

@@ -0,0 +1,5 @@
+export interface IBinPgpEncryptModuleInterface {
+    encrypt(pgpKey: string, dataToEncrypt: unknown): Promise<string>;
+    decrypt(pgpKey: string, encryptedData: Buffer | Uint8Array | string, passphrase?: string): Promise<string>;
+}
+//# sourceMappingURL=bin-pgp-encrypt.interface.d.ts.map

package/dist/src/bin-pgp-encrypt/bin-pgp-encrypt.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin-pgp-encrypt.interface.d.ts","sourceRoot":"","sources":["../../../src/bin-pgp-encrypt/bin-pgp-encrypt.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,6BAA6B;IAC5C,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACjE,OAAO,CACL,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,EAC3C,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,CAAC;CACpB"}

package/dist/src/bin-pgp-encrypt/bin-pgp-encrypt.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/bin-pgp-encrypt/bin-pgp-encrypt.module.d.ts

@@ -0,0 +1,3 @@
+export declare class BinPgpEncryptModule {
+}
+//# sourceMappingURL=bin-pgp-encrypt.module.d.ts.map

package/dist/src/bin-pgp-encrypt/bin-pgp-encrypt.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin-pgp-encrypt.module.d.ts","sourceRoot":"","sources":["../../../src/bin-pgp-encrypt/bin-pgp-encrypt.module.ts"],"names":[],"mappings":"AAGA,qBAIa,mBAAmB;CAAG"}

package/dist/src/bin-pgp-encrypt/bin-pgp-encrypt.module.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinPgpEncryptModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const bin_pgp_encrypt_service_1 = require("./bin-pgp-encrypt.service");
+let BinPgpEncryptModule = class BinPgpEncryptModule {
+};
+exports.BinPgpEncryptModule = BinPgpEncryptModule;
+exports.BinPgpEncryptModule = BinPgpEncryptModule = tslib_1.__decorate([
+    (0, common_1.Module)({
+        providers: [bin_pgp_encrypt_service_1.BinPgpEncryptService],
+        exports: [bin_pgp_encrypt_service_1.BinPgpEncryptService],
+    })
+], BinPgpEncryptModule);

package/dist/src/bin-pgp-encrypt/bin-pgp-encrypt.service.d.ts

@@ -0,0 +1,6 @@
+import { IBinPgpEncryptModuleInterface } from './bin-pgp-encrypt.interface';
+export declare class BinPgpEncryptService implements IBinPgpEncryptModuleInterface {
+    encrypt(pgpKey: string, dataToEncrypt: any): Promise<string>;
+    decrypt(pgpKey: string, encryptedData: Buffer | Uint8Array | string, passphrase?: string): Promise<string>;
+}
+//# sourceMappingURL=bin-pgp-encrypt.service.d.ts.map

package/dist/src/bin-pgp-encrypt/bin-pgp-encrypt.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin-pgp-encrypt.service.d.ts","sourceRoot":"","sources":["../../../src/bin-pgp-encrypt/bin-pgp-encrypt.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAE5E,qBACa,oBAAqB,YAAW,6BAA6B;IAC3D,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAiB5D,OAAO,CAClB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,EAC3C,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC;CA4CnB"}

package/dist/src/bin-pgp-encrypt/bin-pgp-encrypt.service.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinPgpEncryptService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+let BinPgpEncryptService = class BinPgpEncryptService {
+    async encrypt(pgpKey, dataToEncrypt) {
+        try {
+            const openpgp = await import('openpgp');
+            const publicKey = await openpgp.readKey({
+                armoredKey: pgpKey,
+            });
+            const encrypted = await openpgp.encrypt({
+                message: await openpgp.createMessage({ text: dataToEncrypt }),
+                encryptionKeys: publicKey,
+                format: 'binary',
+            });
+            return encrypted.toString();
+        }
+        catch (error) {
+            throw new Error(`File encryption error: \n ${error}`);
+        }
+    }
+    async decrypt(pgpKey, encryptedData, passphrase) {
+        try {
+            const openpgp = await import('openpgp');
+            const openpgpPrivatekey = await openpgp.readPrivateKey({
+                armoredKey: pgpKey,
+            });
+            const decryptKeyOptions = {
+                privateKey: openpgpPrivatekey,
+                config: {
+                    allowInsecureDecryptionWithSigningKeys: true,
+                    allowUnauthenticatedMessages: true,
+                },
+            };
+            let privateKey = openpgpPrivatekey;
+            if (passphrase) {
+                decryptKeyOptions.passphrase = passphrase;
+                privateKey = await openpgp.decryptKey(decryptKeyOptions);
+            }
+            const message = await openpgp.readMessage({
+                binaryMessage: encryptedData,
+            });
+            const { data: decryptedData } = await openpgp.decrypt({
+                message,
+                decryptionKeys: privateKey,
+                format: 'utf8',
+                config: {
+                    allowInsecureDecryptionWithSigningKeys: true,
+                    allowUnauthenticatedMessages: true,
+                },
+            });
+            return decryptedData.toString();
+        }
+        catch (error) {
+            throw new Error(`File decryption error: \n ${error}`);
+        }
+    }
+};
+exports.BinPgpEncryptService = BinPgpEncryptService;
+exports.BinPgpEncryptService = BinPgpEncryptService = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], BinPgpEncryptService);

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+export { AesEncryptModule } from './aes-encrypt/aes-encrypt.module';
+export { AesEncryptService } from './aes-encrypt/aes-encrypt.service';
+export { RsaEncryptModule } from './rsa-encrypt/rsa-encrypt.module';
+export { RsaEncryptService } from './rsa-encrypt/rsa-encrypt.service';
+export { PgpEncryptModule } from './pgp-encrypt/pgp-encrypt.module';
+export { PgpEncryptService } from './pgp-encrypt/pgp-encrypt.service';
+export { BinPgpEncryptModule } from './bin-pgp-encrypt/bin-pgp-encrypt.module';
+export { BinPgpEncryptService } from './bin-pgp-encrypt/bin-pgp-encrypt.service';
+export { ZipEncryptModule } from './zip-encrypt/zipencrypt.module';
+export { ZipEncryptService } from './zip-encrypt/zipencrypt.service';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipEncryptService = exports.ZipEncryptModule = exports.BinPgpEncryptService = exports.BinPgpEncryptModule = exports.PgpEncryptService = exports.PgpEncryptModule = exports.RsaEncryptService = exports.RsaEncryptModule = exports.AesEncryptService = exports.AesEncryptModule = void 0;
+var aes_encrypt_module_1 = require("./aes-encrypt/aes-encrypt.module");
+Object.defineProperty(exports, "AesEncryptModule", { enumerable: true, get: function () { return aes_encrypt_module_1.AesEncryptModule; } });
+var aes_encrypt_service_1 = require("./aes-encrypt/aes-encrypt.service");
+Object.defineProperty(exports, "AesEncryptService", { enumerable: true, get: function () { return aes_encrypt_service_1.AesEncryptService; } });
+var rsa_encrypt_module_1 = require("./rsa-encrypt/rsa-encrypt.module");
+Object.defineProperty(exports, "RsaEncryptModule", { enumerable: true, get: function () { return rsa_encrypt_module_1.RsaEncryptModule; } });
+var rsa_encrypt_service_1 = require("./rsa-encrypt/rsa-encrypt.service");
+Object.defineProperty(exports, "RsaEncryptService", { enumerable: true, get: function () { return rsa_encrypt_service_1.RsaEncryptService; } });
+var pgp_encrypt_module_1 = require("./pgp-encrypt/pgp-encrypt.module");
+Object.defineProperty(exports, "PgpEncryptModule", { enumerable: true, get: function () { return pgp_encrypt_module_1.PgpEncryptModule; } });
+var pgp_encrypt_service_1 = require("./pgp-encrypt/pgp-encrypt.service");
+Object.defineProperty(exports, "PgpEncryptService", { enumerable: true, get: function () { return pgp_encrypt_service_1.PgpEncryptService; } });
+var bin_pgp_encrypt_module_1 = require("./bin-pgp-encrypt/bin-pgp-encrypt.module");
+Object.defineProperty(exports, "BinPgpEncryptModule", { enumerable: true, get: function () { return bin_pgp_encrypt_module_1.BinPgpEncryptModule; } });
+var bin_pgp_encrypt_service_1 = require("./bin-pgp-encrypt/bin-pgp-encrypt.service");
+Object.defineProperty(exports, "BinPgpEncryptService", { enumerable: true, get: function () { return bin_pgp_encrypt_service_1.BinPgpEncryptService; } });
+var zipencrypt_module_1 = require("./zip-encrypt/zipencrypt.module");
+Object.defineProperty(exports, "ZipEncryptModule", { enumerable: true, get: function () { return zipencrypt_module_1.ZipEncryptModule; } });
+var zipencrypt_service_1 = require("./zip-encrypt/zipencrypt.service");
+Object.defineProperty(exports, "ZipEncryptService", { enumerable: true, get: function () { return zipencrypt_service_1.ZipEncryptService; } });

package/dist/src/pgp-encrypt/pgp-encrypt.interface.d.ts

@@ -0,0 +1,5 @@
+export interface IPgpEncryptModuleInterface {
+    encrypt(pgpKey: any, dataToEncrypt: any): Promise<string>;
+    decrypt(pgpKey: any, encryptedData: any, passphrase?: string): Promise<string>;
+}
+//# sourceMappingURL=pgp-encrypt.interface.d.ts.map

package/dist/src/pgp-encrypt/pgp-encrypt.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgp-encrypt.interface.d.ts","sourceRoot":"","sources":["../../../src/pgp-encrypt/pgp-encrypt.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1D,OAAO,CACL,MAAM,EAAE,GAAG,EACX,aAAa,EAAE,GAAG,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC,CAAC;CACpB"}

package/dist/src/pgp-encrypt/pgp-encrypt.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/pgp-encrypt/pgp-encrypt.module.d.ts

@@ -0,0 +1,3 @@
+export declare class PgpEncryptModule {
+}
+//# sourceMappingURL=pgp-encrypt.module.d.ts.map

package/dist/src/pgp-encrypt/pgp-encrypt.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgp-encrypt.module.d.ts","sourceRoot":"","sources":["../../../src/pgp-encrypt/pgp-encrypt.module.ts"],"names":[],"mappings":"AAGA,qBAIa,gBAAgB;CAAG"}

package/dist/src/pgp-encrypt/pgp-encrypt.module.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgpEncryptModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const pgp_encrypt_service_1 = require("./pgp-encrypt.service");
+let PgpEncryptModule = class PgpEncryptModule {
+};
+exports.PgpEncryptModule = PgpEncryptModule;
+exports.PgpEncryptModule = PgpEncryptModule = tslib_1.__decorate([
+    (0, common_1.Module)({
+        providers: [pgp_encrypt_service_1.PgpEncryptService],
+        exports: [pgp_encrypt_service_1.PgpEncryptService],
+    })
+], PgpEncryptModule);

package/dist/src/pgp-encrypt/pgp-encrypt.service.d.ts

@@ -0,0 +1,6 @@
+import { IPgpEncryptModuleInterface } from './pgp-encrypt.interface';
+export declare class PgpEncryptService implements IPgpEncryptModuleInterface {
+    encrypt(pgpKey: any, dataToEncrypt: any): Promise<string>;
+    decrypt(pgpKey: any, encryptedData: any, passphrase?: string): Promise<string>;
+}
+//# sourceMappingURL=pgp-encrypt.service.d.ts.map

package/dist/src/pgp-encrypt/pgp-encrypt.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pgp-encrypt.service.d.ts","sourceRoot":"","sources":["../../../src/pgp-encrypt/pgp-encrypt.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAErE,qBACa,iBAAkB,YAAW,0BAA0B;IACrD,OAAO,CAAC,MAAM,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAiBzD,OAAO,CAClB,MAAM,EAAE,GAAG,EACX,aAAa,EAAE,GAAG,EAClB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC;CAkDnB"}

package/dist/src/pgp-encrypt/pgp-encrypt.service.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgpEncryptService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+let PgpEncryptService = class PgpEncryptService {
+    async encrypt(pgpKey, dataToEncrypt) {
+        try {
+            const openpgp = await import('openpgp');
+            const publicKey = await openpgp.readKey({
+                armoredKey: pgpKey,
+            });
+            const encrypted = await openpgp.encrypt({
+                message: await openpgp.createMessage({ text: dataToEncrypt }),
+                encryptionKeys: publicKey,
+                format: 'armored',
+            });
+            return encrypted.toString();
+        }
+        catch (error) {
+            throw new Error(`File encryption error: \n ${error}`);
+        }
+    }
+    async decrypt(pgpKey, encryptedData, passphrase) {
+        try {
+            const openpgp = await import('openpgp');
+            const openpgpPrivatekey = await openpgp.readPrivateKey({
+                armoredKey: pgpKey,
+            });
+            const decryptKeyOptions = {
+                privateKey: openpgpPrivatekey,
+                config: {
+                    allowInsecureDecryptionWithSigningKeys: true,
+                    allowUnauthenticatedMessages: true,
+                },
+            };
+            let privateKey = openpgpPrivatekey;
+            if (passphrase) {
+                decryptKeyOptions.passphrase = passphrase;
+                privateKey = await openpgp.decryptKey(decryptKeyOptions);
+            }
+            const armoredMessage = (await openpgp.createMessage({
+                text: encryptedData,
+                format: 'utf8',
+            })).getText();
+            const message = await openpgp.readMessage({
+                armoredMessage,
+            });
+            const { data: decryptedData } = await openpgp.decrypt({
+                message,
+                decryptionKeys: privateKey,
+                format: 'utf8',
+                config: {
+                    allowInsecureDecryptionWithSigningKeys: true,
+                    allowUnauthenticatedMessages: true,
+                },
+            });
+            return decryptedData.toString();
+        }
+        catch (error) {
+            throw new Error(`File decryption error: \n ${error}`);
+        }
+    }
+};
+exports.PgpEncryptService = PgpEncryptService;
+exports.PgpEncryptService = PgpEncryptService = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], PgpEncryptService);

package/dist/src/rsa-encrypt/rsa-encrypt.interface.d.ts

@@ -0,0 +1,6 @@
+import * as NodeRSA from 'node-rsa';
+export interface RsaEncryptInterface {
+    encrypt(message: NodeRSA.Data, key: NodeRSA.KeyBits, messageEncoding: NodeRSA.Encoding): string;
+    decrypt(message: string | Buffer, key: NodeRSA.Key, messageEncoding: NodeRSA.Encoding): string;
+}
+//# sourceMappingURL=rsa-encrypt.interface.d.ts.map

package/dist/src/rsa-encrypt/rsa-encrypt.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsa-encrypt.interface.d.ts","sourceRoot":"","sources":["../../../src/rsa-encrypt/rsa-encrypt.interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,UAAU,CAAC;AAEpC,MAAM,WAAW,mBAAmB;IAClC,OAAO,CACL,OAAO,EAAE,OAAO,CAAC,IAAI,EACrB,GAAG,EAAE,OAAO,CAAC,OAAO,EACpB,eAAe,EAAE,OAAO,CAAC,QAAQ,GAChC,MAAM,CAAC;IAEV,OAAO,CACL,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,GAAG,EAAE,OAAO,CAAC,GAAG,EAChB,eAAe,EAAE,OAAO,CAAC,QAAQ,GAChC,MAAM,CAAC;CACX"}

package/dist/src/rsa-encrypt/rsa-encrypt.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/rsa-encrypt/rsa-encrypt.module.d.ts

@@ -0,0 +1,3 @@
+export declare class RsaEncryptModule {
+}
+//# sourceMappingURL=rsa-encrypt.module.d.ts.map

package/dist/src/rsa-encrypt/rsa-encrypt.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsa-encrypt.module.d.ts","sourceRoot":"","sources":["../../../src/rsa-encrypt/rsa-encrypt.module.ts"],"names":[],"mappings":"AAGA,qBAIa,gBAAgB;CAAG"}

package/dist/src/rsa-encrypt/rsa-encrypt.module.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RsaEncryptModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const rsa_encrypt_service_1 = require("./rsa-encrypt.service");
+let RsaEncryptModule = class RsaEncryptModule {
+};
+exports.RsaEncryptModule = RsaEncryptModule;
+exports.RsaEncryptModule = RsaEncryptModule = tslib_1.__decorate([
+    (0, common_1.Module)({
+        providers: [rsa_encrypt_service_1.RsaEncryptService],
+        exports: [rsa_encrypt_service_1.RsaEncryptService],
+    })
+], RsaEncryptModule);

package/dist/src/rsa-encrypt/rsa-encrypt.service.d.ts

@@ -0,0 +1,7 @@
+import NodeRSA from 'node-rsa';
+import { RsaEncryptInterface } from './rsa-encrypt.interface';
+export declare class RsaEncryptService implements RsaEncryptInterface {
+    encrypt(message: NodeRSA.Data, key: NodeRSA.KeyBits, messageEncoding?: NodeRSA.Encoding): string;
+    decrypt(message: string | Buffer, key: NodeRSA.Key, messageEncoding?: NodeRSA.Encoding): string;
+}
+//# sourceMappingURL=rsa-encrypt.service.d.ts.map

package/dist/src/rsa-encrypt/rsa-encrypt.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsa-encrypt.service.d.ts","sourceRoot":"","sources":["../../../src/rsa-encrypt/rsa-encrypt.service.ts"],"names":[],"mappings":"AACA,OAAO,OAAO,MAAM,UAAU,CAAC;AAE/B,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,qBACa,iBAAkB,YAAW,mBAAmB;IACpD,OAAO,CACZ,OAAO,EAAE,OAAO,CAAC,IAAI,EACrB,GAAG,EAAE,OAAO,CAAC,OAAO,EACpB,eAAe,GAAE,OAAO,CAAC,QAAmB,GAC3C,MAAM;IAMF,OAAO,CACZ,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,GAAG,EAAE,OAAO,CAAC,GAAG,EAChB,eAAe,GAAE,OAAO,CAAC,QAAmB,GAC3C,MAAM;CAKV"}

package/dist/src/rsa-encrypt/rsa-encrypt.service.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RsaEncryptService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const node_rsa_1 = tslib_1.__importDefault(require("node-rsa"));
+let RsaEncryptService = class RsaEncryptService {
+    encrypt(message, key, messageEncoding = 'base64') {
+        const rsa = new node_rsa_1.default(key);
+        const encryptedData = rsa.encrypt(message, messageEncoding);
+        return encryptedData;
+    }
+    decrypt(message, key, messageEncoding = 'buffer') {
+        const rsa = new node_rsa_1.default(key);
+        const decrypt = rsa.decrypt(message, messageEncoding).toString();
+        return decrypt;
+    }
+};
+exports.RsaEncryptService = RsaEncryptService;
+exports.RsaEncryptService = RsaEncryptService = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], RsaEncryptService);

package/dist/src/zip-encrypt/zipencrypt.interface.d.ts

@@ -0,0 +1,10 @@
+import { ArchiverOptions } from 'archiver';
+export type encryptionMethodType = 'zip20' | 'aes256';
+export type archiverOptionsZipEncrypted = ArchiverOptions & {
+    encryptionMethod: encryptionMethodType;
+};
+export interface FileFormat {
+    content: any;
+    filename: string;
+}
+//# sourceMappingURL=zipencrypt.interface.d.ts.map

package/dist/src/zip-encrypt/zipencrypt.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipencrypt.interface.d.ts","sourceRoot":"","sources":["../../../src/zip-encrypt/zipencrypt.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE3C,MAAM,MAAM,oBAAoB,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEtD,MAAM,MAAM,2BAA2B,GAAG,eAAe,GAAG;IAC1D,gBAAgB,EAAE,oBAAoB,CAAC;CACxC,CAAC;AAEF,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,GAAG,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB"}

package/dist/src/zip-encrypt/zipencrypt.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/zip-encrypt/zipencrypt.module.d.ts

@@ -0,0 +1,3 @@
+export declare class ZipEncryptModule {
+}
+//# sourceMappingURL=zipencrypt.module.d.ts.map

package/dist/src/zip-encrypt/zipencrypt.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipencrypt.module.d.ts","sourceRoot":"","sources":["../../../src/zip-encrypt/zipencrypt.module.ts"],"names":[],"mappings":"AAGA,qBAIa,gBAAgB;CAAG"}

package/dist/src/zip-encrypt/zipencrypt.module.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipEncryptModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const zipencrypt_service_1 = require("./zipencrypt.service");
+let ZipEncryptModule = class ZipEncryptModule {
+};
+exports.ZipEncryptModule = ZipEncryptModule;
+exports.ZipEncryptModule = ZipEncryptModule = tslib_1.__decorate([
+    (0, common_1.Module)({
+        providers: [zipencrypt_service_1.ZipEncryptService],
+        exports: [zipencrypt_service_1.ZipEncryptService],
+    })
+], ZipEncryptModule);

package/dist/src/zip-encrypt/zipencrypt.service.d.ts

@@ -0,0 +1,5 @@
+import { encryptionMethodType, FileFormat } from './zipencrypt.interface';
+export declare class ZipEncryptService {
+    encryptFiles(files: FileFormat[], password: string, encryptionMethod?: encryptionMethodType): Promise<Buffer | false>;
+}
+//# sourceMappingURL=zipencrypt.service.d.ts.map

package/dist/src/zip-encrypt/zipencrypt.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipencrypt.service.d.ts","sourceRoot":"","sources":["../../../src/zip-encrypt/zipencrypt.service.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,oBAAoB,EACpB,UAAU,EACX,MAAM,wBAAwB,CAAC;AAEhC,qBACa,iBAAiB;IACf,YAAY,CACvB,KAAK,EAAE,UAAU,EAAE,EACnB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,GAAE,oBAA8B,GAC/C,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC;CA0B3B"}

package/dist/src/zip-encrypt/zipencrypt.service.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZipEncryptService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const archiver_1 = require("archiver");
+const stream_buffers_1 = require("stream-buffers");
+let ZipEncryptService = class ZipEncryptService {
+    async encryptFiles(files, password, encryptionMethod = 'zip20') {
+        const output = new stream_buffers_1.WritableStreamBuffer({
+            initialSize: 1000,
+            incrementAmount: 1000,
+        });
+        if (!(0, archiver_1.isRegisteredFormat)('zip-encrypted')) {
+            (0, archiver_1.registerFormat)('zip-encrypted', require('archiver-zip-encrypted'));
+        }
+        const archive = (0, archiver_1.create)('zip-encrypted', {
+            zlib: { level: 8 },
+            encryptionMethod,
+            password,
+        });
+        archive.pipe(output);
+        files.map((file) => {
+            archive.append(file.content, { name: file.filename });
+        });
+        await archive.finalize();
+        output.end();
+        return output.getContents();
+    }
+};
+exports.ZipEncryptService = ZipEncryptService;
+exports.ZipEncryptService = ZipEncryptService = tslib_1.__decorate([
+    (0, common_1.Injectable)()
+], ZipEncryptService);

package/dist/tsconfig.lib.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.9.3"}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@edirect/encrypt-modules",
-  "version": "11.0.62-beta.0",
+  "version": "11.0.62-beta.2",
   "description": "Encrypt Modules",
+  "packageScope": "@edirect",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
   "exports": {
@@ -26,10 +27,27 @@
     "tslib": "^2.8.1"
   },
   "devDependencies": {
+    "@nestjs/cli": "^11.0.21",
     "@types/archiver": "^7.0.0",
     "@types/node": "^25.6.2",
     "@types/node-rsa": "^1.1.4",
     "@types/stream-buffers": "^3.0.8"
   },
-  "type": "commonjs"
+  "nx": {
+    "name": "@edirect/encrypt-modules",
+    "targets": {
+      "build": {
+        "executor": "@nx/js:tsc",
+        "options": {
+          "main": "{workspaceRoot}/packages/edirect-encrypt-modules/src/index.ts",
+          "tsConfig": "{workspaceRoot}/packages/edirect-encrypt-modules/tsconfig.lib.json",
+          "outputPath": "{workspaceRoot}/packages/edirect-encrypt-modules/dist",
+          "assets": [
+            "{workspaceRoot}/packages/edirect-encrypt-modules/package.json",
+            "{workspaceRoot}/packages/edirect-encrypt-modules/README.md"
+          ]
+        }
+      }
+    }
+  }
 }