opticore-webapp-core 1.0.20 → 1.0.22

package/dist/index.d.cts

@@ -1,5 +1,8 @@
 import { StackTraceError } from 'opticore-catch-exception-error';
 import { ServerResponse, IncomingMessage } from 'node:http';
+import * as express from 'express';
+import * as qs from 'qs';
+import * as express_serve_static_core from 'express-serve-static-core';
 
 declare class SAsymmetricCryptionDataWithPrivateRSAKey {
     private readonly log;
@@ -337,6 +340,7 @@ declare class LocalLanguageLoader {
 
 interface IBodyParserOptions {
     type: string;
+    limit?: number;
 }
 
 interface IResponseBodyEndFromResponseEvent {
@@ -372,7 +376,7 @@ type TParseFunction = (rawBody: string) => any;
  * in express, it can be used like this: app.use(TJSONBodyParser({ type: 'application/vnd.custom-type' }));
  *
  */
-declare function TJSONBodyParser(options: IBodyParserOptions, localLanguage: string, environnementPath: any): void;
+declare function TJSONBodyParser(options: IBodyParserOptions, localLanguage: string, environnementPath: any): (req: express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, res: express.Response<any, Record<string, any>>, next: express.NextFunction) => void;
 
 /**
  *
@@ -385,7 +389,7 @@ declare function TJSONBodyParser(options: IBodyParserOptions, localLanguage: str
  * in express, it can be used like this: app.use(rawBodyParserType({ type: 'application/vnd.custom-type' }));
  *
  */
-declare function TRawBodyParser(options: IBodyParserOptions, localLanguage: string, environnementPath: any): void;
+declare function TRawBodyParser(options: IBodyParserOptions, localLanguage: string, environnementPath: any): (req: express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, res: express.Response<any, Record<string, any>>, next: express.NextFunction) => void;
 
 /**
  *
@@ -398,7 +402,7 @@ declare function TRawBodyParser(options: IBodyParserOptions, localLanguage: stri
  * in express, it can be used like this: app.use(textBodyParserType({ type: 'text/html' }));
  *
  */
-declare function TTextBodyParser(options: IBodyParserOptions, localLanguage: string, environmentPath: any): void;
+declare function TTextBodyParser(options: IBodyParserOptions, localLanguage: string, environmentPath: any): (req: express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, res: express.Response<any, Record<string, any>>, next: express.NextFunction) => void;
 
 /**
  *
@@ -411,6 +415,6 @@ declare function TTextBodyParser(options: IBodyParserOptions, localLanguage: str
  * in express, it can be used like this: app.use(urlencodedBodyParserType({ type: 'application/x-www-form-urlencoded' }));
  *
  */
-declare function TUrlencodedBodyParser(options: IBodyParserOptions, localLanguage: string, environmentPath: any): void;
+declare function TUrlencodedBodyParser(options: IBodyParserOptions, localLanguage: string, environmentPath: any): (req: express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, res: express.Response<any, Record<string, any>>, next: express.NextFunction) => void;
 
 export { CLogLevel, CSignRSAKeyComponent, Environment, type IBodyParserOptions, type IResponseBodyEndFromResponseEvent, type IResponseBodyWriteFromResponseEvent, type IWrappingBodyResponse, LocalLanguageLoader, PathModuleVerifier, RSAKeyDecryption, RSAKeyEncryption, SAsymmetricCryptionDataWithPrivateRSAKey, SAsymmetricCryptionDataWithPublicRSAKey, TJSONBodyParser, type TLogLevel, type TOriginalWriteEncoding, type TParseFunction, TRawBodyParser, TTextBodyParser, TUrlencodedBodyParser, Utility, YamlParsing, dateTimeFormatted, loggerConfig };

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 import { StackTraceError } from 'opticore-catch-exception-error';
 import { ServerResponse, IncomingMessage } from 'node:http';
+import * as express from 'express';
+import * as qs from 'qs';
+import * as express_serve_static_core from 'express-serve-static-core';
 
 declare class SAsymmetricCryptionDataWithPrivateRSAKey {
     private readonly log;
@@ -337,6 +340,7 @@ declare class LocalLanguageLoader {
 
 interface IBodyParserOptions {
     type: string;
+    limit?: number;
 }
 
 interface IResponseBodyEndFromResponseEvent {
@@ -372,7 +376,7 @@ type TParseFunction = (rawBody: string) => any;
  * in express, it can be used like this: app.use(TJSONBodyParser({ type: 'application/vnd.custom-type' }));
  *
  */
-declare function TJSONBodyParser(options: IBodyParserOptions, localLanguage: string, environnementPath: any): void;
+declare function TJSONBodyParser(options: IBodyParserOptions, localLanguage: string, environnementPath: any): (req: express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, res: express.Response<any, Record<string, any>>, next: express.NextFunction) => void;
 
 /**
  *
@@ -385,7 +389,7 @@ declare function TJSONBodyParser(options: IBodyParserOptions, localLanguage: str
  * in express, it can be used like this: app.use(rawBodyParserType({ type: 'application/vnd.custom-type' }));
  *
  */
-declare function TRawBodyParser(options: IBodyParserOptions, localLanguage: string, environnementPath: any): void;
+declare function TRawBodyParser(options: IBodyParserOptions, localLanguage: string, environnementPath: any): (req: express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, res: express.Response<any, Record<string, any>>, next: express.NextFunction) => void;
 
 /**
  *
@@ -398,7 +402,7 @@ declare function TRawBodyParser(options: IBodyParserOptions, localLanguage: stri
  * in express, it can be used like this: app.use(textBodyParserType({ type: 'text/html' }));
  *
  */
-declare function TTextBodyParser(options: IBodyParserOptions, localLanguage: string, environmentPath: any): void;
+declare function TTextBodyParser(options: IBodyParserOptions, localLanguage: string, environmentPath: any): (req: express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, res: express.Response<any, Record<string, any>>, next: express.NextFunction) => void;
 
 /**
  *
@@ -411,6 +415,6 @@ declare function TTextBodyParser(options: IBodyParserOptions, localLanguage: str
  * in express, it can be used like this: app.use(urlencodedBodyParserType({ type: 'application/x-www-form-urlencoded' }));
  *
  */
-declare function TUrlencodedBodyParser(options: IBodyParserOptions, localLanguage: string, environmentPath: any): void;
+declare function TUrlencodedBodyParser(options: IBodyParserOptions, localLanguage: string, environmentPath: any): (req: express.Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, res: express.Response<any, Record<string, any>>, next: express.NextFunction) => void;
 
 export { CLogLevel, CSignRSAKeyComponent, Environment, type IBodyParserOptions, type IResponseBodyEndFromResponseEvent, type IResponseBodyWriteFromResponseEvent, type IWrappingBodyResponse, LocalLanguageLoader, PathModuleVerifier, RSAKeyDecryption, RSAKeyEncryption, SAsymmetricCryptionDataWithPrivateRSAKey, SAsymmetricCryptionDataWithPublicRSAKey, TJSONBodyParser, type TLogLevel, type TOriginalWriteEncoding, type TParseFunction, TRawBodyParser, TTextBodyParser, TUrlencodedBodyParser, Utility, YamlParsing, dateTimeFormatted, loggerConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opticore-webapp-core",
-  "version": "1.0.20",
+  "version": "1.0.22",
   "description": "opticore Web Application core module",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -30,13 +30,12 @@
     "dotenv": "^16.5.0",
     "mongodb": "^6.6.1",
     "mysql": "^2.18.1",
-    "opticore-catch-exception-error": "^1.0.25",
-    "opticore-env-access": "^1.0.12",
-    "opticore-express": "^1.0.7",
-    "opticore-http-response": "^1.0.9",
-    "opticore-inject-dependency": "^1.0.12",
-    "opticore-logger": "^1.0.17",
-    "opticore-translator": "^1.0.10",
+    "opticore-catch-exception-error": "^1.0.30",
+    "opticore-env-access": "^1.0.25",
+    "opticore-express": "^1.0.9",
+    "opticore-http-response": "^1.0.11",
+    "opticore-logger": "^1.0.33",
+    "opticore-translator": "^1.0.17",
     "pg": "^8.15.6"
   },
   "devDependencies": {

package/src/application/middlewares/bodyParser.middleware.ts

@@ -0,0 +1,74 @@
+import { express, NextFunction } from "opticore-express";
+import { LoggerCore } from "opticore-logger";
+import { HttpStatusCode } from "opticore-http-response";
+import { TranslationLoader } from "opticore-translator";
+
+import { IBodyParserOptions } from "@webAppCore/interfaces/bodyParserOptions.interface";
+import { TParseFunction } from "@webAppCore/types/parseFunction.type";
+import { loggerConfig } from "@webAppCore/core/config/logger/logger.config";
+import { SLoggerFileConfiguration } from "@webAppCore/application/services/loggerFileConfiguration.service";
+
+
+/**
+ *
+ * @param localeLanguage
+ * @param parseFunction
+ * @param options
+ * @param environmentPath
+ *
+ * This is a middleware that allows parsing data
+ *
+ */
+export function MBodyParser(parseFunction: TParseFunction,
+                            options: IBodyParserOptions,
+                            localeLanguage: string,
+                            environmentPath: any): (req: express.Request,
+                                                    res: express.Response,
+                                                    next: NextFunction) => void {
+    const logger: LoggerCore = SLoggerFileConfiguration(environmentPath);
+
+    return function (req: express.Request, res: express.Response, next: NextFunction): void {
+        if (!req.headers['content-type']?.includes(options.type)) {
+            return next();
+        }
+
+        const maxSize: number = options.limit ?? 1024 * 1024;
+        let body: Uint8Array[] = [];
+        let totalSize: number = 0;
+
+        req.on("data", (chunk: any): void => {
+            totalSize += chunk.length;
+            if (totalSize > maxSize) {
+                req.destroy();
+                res.status(HttpStatusCode.PAYLOAD_TOO_LARGE).json({
+                    message: TranslationLoader.t("payloadTooLarge", localeLanguage, loggerConfig)
+                });
+                return;
+            }
+            body.push(chunk);
+        });
+
+        req.on("end", (): void => {
+            const rawBody: string = Buffer.concat(body).toString();
+            try {
+                req.body = parseFunction(rawBody);
+                next();
+            } catch (error: any) {
+                res.status(HttpStatusCode.BAD_REQUEST).json({
+                    message: TranslationLoader.t("invalidRequest", localeLanguage, loggerConfig)
+                });
+            }
+        });
+
+        req.on("error", (err: any): void => {
+            logger.error({
+                message: err.message,
+                title: "Content Type error",
+                errorType: TranslationLoader.t("invalidRequest", localeLanguage, loggerConfig),
+                stackTrace: err.stack,
+                httpCodeValue: HttpStatusCode.BAD_REQUEST
+            });
+            next(err);
+        });
+    }
+}

package/src/application/services/asymmetricCryptionDataWithPrivateRSAKey.service.ts

@@ -0,0 +1,194 @@
+import crypto from "crypto";
+import { BinaryToTextEncoding } from "node:crypto";
+import { HttpStatusCode as status } from "opticore-http-response";
+import { LoggerCore } from "opticore-logger";
+import { TranslationLoader } from "opticore-translator";
+import { StackTraceError as ErrorHandler } from "opticore-catch-exception-error";
+
+import { RSAKeyEncryption } from "@webAppCore/utils/cryptography/encryption/rsaKey.encryption";
+import { RSAKeyDecryption } from "@webAppCore/utils/cryptography/decryption/rsaKey.decryption";
+import { CSignRSAKeyComponent } from "@webAppCore/core/constants/signRSAKeyComponent.constant";
+import { SLoggerFileConfiguration } from "@webAppCore/application/services/loggerFileConfiguration.service";
+
+
+export class SAsymmetricCryptionDataWithPrivateRSAKey {
+    private readonly log: LoggerCore;
+    private readonly localeLanguage: string;
+
+    constructor(localeLanguage: string, environnementPath: any) {
+        this.localeLanguage = localeLanguage;
+        this.log = SLoggerFileConfiguration(environnementPath)
+    }
+
+
+    /**
+     * 
+     * @param rsaKey
+     * @param keyType
+     * @protected
+     * 
+     * Return ErrorHandler | string
+     */
+    protected verifyExistingKey(rsaKey: string, keyType: string): string | ErrorHandler {
+        if (!rsaKey) {
+            const stackTrace: ErrorHandler = this.traceError(
+                keyType +" "+ TranslationLoader.t("rsaKeyNotFound", this.localeLanguage, this.log),
+                TranslationLoader.t("erBadDbError", this.localeLanguage, this.log),
+                status.NOT_FOUND
+            );
+
+            this.log.error({
+                message: TranslationLoader.t("rsaKeyNotFound", this.localeLanguage, this.log),
+                title: TranslationLoader.t("verifyExistingKey", this.localeLanguage, this.log),
+                errorType: TranslationLoader.t("erBadDbError", this.localeLanguage, this.log),
+                stackTrace: stackTrace.stack,
+                httpCodeValue: status.NOT_FOUND
+            });
+        }
+
+        return rsaKey;
+    }
+
+    /**
+     *
+     * @param privateKey
+     * @param payload
+     * @private
+     *
+     * Return Buffer
+     */
+    private encryptionWithPrivateKey(privateKey: string, payload: any): Buffer {
+        this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private);
+
+        try {
+            const bufferedData: Buffer = Buffer.from(payload, Number(CSignRSAKeyComponent.encodingFormat));
+            return RSAKeyEncryption.privateEncrypt(privateKey, bufferedData);
+        } catch (err: any) {
+            const stackTrace: ErrorHandler = this.traceError(
+                TranslationLoader.t("encryptionWithPrivateKeyFailed", this.localeLanguage, this.log),
+                TranslationLoader.t("encryptionFailed", this.localeLanguage, this.log),
+                status.NOT_FOUND
+            );
+
+            this.log.error({
+                message: err.message,
+                title: TranslationLoader.t("encryptionFailed", this.localeLanguage, this.log),
+                errorType: TranslationLoader.t("encryptionWithPrivateKeyFailed", this.localeLanguage, this.log),
+                stackTrace: stackTrace.stack,
+                httpCodeValue: status.NOT_FOUND
+            });
+            process.exit();
+        }
+    }
+
+    /**
+     *
+     * @param privateKey
+     * @param publicKey
+     * @param payload
+     * @private
+     */
+    private decryptionWithPublicKey(privateKey: string, publicKey: string, payload: any): Buffer {
+        this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+
+        try {
+            const encryptedPayload: Buffer = this.encryptionWithPrivateKey(privateKey, payload);
+
+            return RSAKeyDecryption.publicDecrypt(publicKey, encryptedPayload);
+        } catch (error: any) {
+            const stackTrace: ErrorHandler = this.traceError(
+                TranslationLoader.t("errorDecryption", this.localeLanguage, this.log),
+                TranslationLoader.t("decryptionFailed", this.localeLanguage, this.log),
+                status.NOT_ACCEPTABLE
+            );
+
+            this.log.error({
+                message: TranslationLoader.t("decryptionWithPublicKeyFailed", this.localeLanguage, this.log),
+                title: TranslationLoader.t("decryptionFailed", this.localeLanguage, this.log),
+                errorType: TranslationLoader.t("errorDecryption", this.localeLanguage, this.log),
+                stackTrace: stackTrace.stack,
+                httpCodeValue: status.NOT_ACCEPTABLE
+            });
+            process.exit();
+        }
+    }
+
+    /**
+     *
+     * @param privateKey
+     * @param payload
+     * @private
+     */
+    private signWithRSAKey(privateKey: string, payload: any): string {
+        this.verifyExistingKey(privateKey, CSignRSAKeyComponent.keyType.private);
+
+        const sign: crypto.Sign = crypto.createSign(CSignRSAKeyComponent.algorithm.sha256);
+        sign.update(payload);
+
+        return sign.sign(privateKey, CSignRSAKeyComponent.outputFormat.base64 as BinaryToTextEncoding);
+    }
+
+    /**
+     *
+     * @param privateKey
+     * @param publicKey
+     * @param payload
+     */
+    public verifyRSAKey(privateKey: string, publicKey: string, payload: any): string | Error {
+        try {
+            const verify: crypto.Verify = crypto.createVerify(CSignRSAKeyComponent.algorithm.sha256);
+            verify.update(payload);
+
+            const signature: string = this.signWithRSAKey(privateKey, payload);
+            const isVerified: boolean = verify.verify(publicKey, signature, CSignRSAKeyComponent.outputFormat.base64 as BinaryToTextEncoding);
+
+            if (isVerified) {
+                const decryptedData: Buffer = this.decryptionWithPublicKey(privateKey, publicKey, payload);
+
+                return decryptedData.toString(CSignRSAKeyComponent.encodingFormat.utf_8 as BufferEncoding);
+            } else {
+                const stackTrace: ErrorHandler = this.traceError(
+                    TranslationLoader.t("signatureRSAKeyFailed", this.localeLanguage, this.log),
+                    TranslationLoader.t("verifyRSAKeyFailed", this.localeLanguage, this.log),
+                    status.NOT_ACCEPTABLE
+                );
+
+                this.log.error({
+                    message: TranslationLoader.t("verifyRSAKey", this.localeLanguage, this.log),
+                    title: TranslationLoader.t("verifyRSAKeyFailed", this.localeLanguage, this.log),
+                    errorType: TranslationLoader.t("signatureRSAKeyFailed", this.localeLanguage, this.log),
+                    stackTrace: stackTrace.stack,
+                    httpCodeValue: status.NOT_FOUND
+                });
+                process.exit();
+            }
+
+        } catch (err: any) {
+            const stackTrace: ErrorHandler = this.traceError(
+                err.name,
+                TranslationLoader.t("signatureRSAKeysError", this.localeLanguage, this.log),
+                status.NOT_ACCEPTABLE
+            );
+
+            this.log.error({
+                message: TranslationLoader.t("signatureRSAKeysError", this.localeLanguage, this.log),
+                title: TranslationLoader.t("errorNameNotVerifyingRSAKey", this.localeLanguage, this.log),
+                errorType: err.name,
+                stackTrace: stackTrace.stack,
+                httpCodeValue: status.NOT_FOUND
+            });
+            process.exit();
+        }
+    }
+
+    /**
+     *
+     * @param props
+     * @param name
+     * @param status
+     * @private
+     */
+    private traceError(props: string, name: string, status: number): ErrorHandler {
+        return new ErrorHandler(props, name, status, true);
+    }
+}

package/src/application/services/asymmetricCryptionDataWithPublicRSAKey.service.ts

@@ -0,0 +1,188 @@
+import crypto from "crypto";
+import { BinaryToTextEncoding } from "node:crypto";
+import { LoggerCore } from "opticore-logger";
+import { TranslationLoader } from "opticore-translator";
+import { HttpStatusCode } from "opticore-http-response";
+
+import { StackTraceError } from "opticore-catch-exception-error";
+import { RSAKeyEncryption } from "@webAppCore/utils/cryptography/encryption/rsaKey.encryption";
+import { CSignRSAKeyComponent } from "@webAppCore/core/constants/signRSAKeyComponent.constant";
+import { RSAKeyDecryption } from "@webAppCore/utils/cryptography/decryption/rsaKey.decryption";
+import { SLoggerFileConfiguration } from "@webAppCore/application/services/loggerFileConfiguration.service";
+
+
+export class SAsymmetricCryptionDataWithPublicRSAKey {
+    private readonly logger: LoggerCore;
+    private readonly localeLanguage: string;
+
+    constructor(localeLanguage: string, environnementPath: any) {
+        this.localeLanguage = localeLanguage;
+        this.logger = SLoggerFileConfiguration(environnementPath);
+    }
+    
+    /**
+     *
+     * @param rsaKey
+     * @param keyType
+     * 
+     * @protected
+     */
+    protected verifyExistingKey(rsaKey: string, keyType: string): string | Error {
+        if (!rsaKey) {
+            const stackTrace: StackTraceError = this.traceError(
+                keyType + TranslationLoader.t("verifyExistingKey", this.localeLanguage),
+                TranslationLoader.t("verifyExistingKey", this.localeLanguage),
+                HttpStatusCode.NOT_FOUND
+            );
+
+            this.logger.error({
+                message: TranslationLoader.t("verifyExistingKey", this.localeLanguage),
+                title: "key verification",
+                errorType: TranslationLoader.t("verifyExistingKeyError", this.localeLanguage),
+                stackTrace: stackTrace.stack!,
+                httpCodeValue: HttpStatusCode.NOT_FOUND
+            });
+        }
+
+        return rsaKey;
+    }
+
+
+    /**
+     *
+     * @param publicKey
+     * @param payload
+     * 
+     * @private
+     */
+    private encryptionWithPublicKey(publicKey: string, payload: any): Buffer {
+        this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+
+        try {
+            const bufferedData: Buffer = Buffer.from(payload, Number(CSignRSAKeyComponent.encodingFormat));
+            return RSAKeyEncryption.publicEncrypt(publicKey, bufferedData);
+        } catch (err: any) {
+            const stackTrace: StackTraceError = this.traceError(
+                err.message,
+                TranslationLoader.t("encryptionWithPublicKey", this.localeLanguage),
+                HttpStatusCode.NOT_ACCEPTABLE
+            );
+
+            this.logger.error({
+                message: TranslationLoader.t("errorEncryptionPublicKey", this.localeLanguage),
+                title: TranslationLoader.t("encryptionWithPublicKey", this.localeLanguage),
+                errorType: err.code,
+                stackTrace: stackTrace.stack,
+                httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+            });
+            process.exit();
+        }
+    }
+
+
+    /**
+     *
+     * @param privateKey
+     * @param publicKey
+     * @param payload
+     * 
+     * @private
+     */
+    private decryptionWithPrivateKey(privateKey: string, publicKey: string, payload: any): Buffer {
+        this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.public);
+
+        try {
+            const encryptedPayload: Buffer = this.encryptionWithPublicKey(publicKey, payload);
+            return RSAKeyDecryption.privateDecrypt(privateKey, encryptedPayload);
+        } catch (err: any) {
+            const stackTrace: StackTraceError = this.traceError(
+                err.code,
+                TranslationLoader.t("errorDecryption", this.localeLanguage),
+                HttpStatusCode.NOT_ACCEPTABLE
+            );
+
+            this.logger.error({
+                message: TranslationLoader.t("errorDecryptionWithPrivateKey", this.localeLanguage),
+                title: TranslationLoader.t("errorDecryption", this.localeLanguage),
+                errorType: err.message,
+                stackTrace: stackTrace.stack,
+                httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+            });
+            process.exit();
+        }
+    }
+
+
+    /**
+     *
+     * @param publicKey
+     * @param payload
+     * 
+     * @private
+     */
+    private signWithPublicRSAKey(publicKey: string, payload: any): string {
+        this.verifyExistingKey(publicKey, CSignRSAKeyComponent.keyType.private);
+
+        const sign: crypto.Sign = crypto.createSign(CSignRSAKeyComponent.algorithm.sha256);
+        sign.update(payload);
+
+        return sign.sign(publicKey, CSignRSAKeyComponent.outputFormat.base64 as BinaryToTextEncoding);
+    }
+
+
+    /**
+     *
+     * @param privateKey
+     * @param publicKey
+     * @param payload
+     * 
+     */
+    public verifyPublicRSAKey(privateKey: string, publicKey: string, payload: any): string | StackTraceError {
+        try {
+            const verify: crypto.Verify = crypto.createVerify(CSignRSAKeyComponent.algorithm.sha256);
+            verify.update(payload);
+
+            const signature: string = this.signWithPublicRSAKey(publicKey, payload);
+            const isVerified: boolean = verify.verify(publicKey, signature, CSignRSAKeyComponent.outputFormat.base64 as BinaryToTextEncoding);
+
+            if (isVerified) {
+                const decryptedData: Buffer = this.decryptionWithPrivateKey(privateKey, publicKey, payload);
+                return decryptedData.toString(CSignRSAKeyComponent.encodingFormat.utf_8 as BufferEncoding | undefined);
+            } else {
+                const stackTrace: StackTraceError = this.traceError(
+                    TranslationLoader.t("verifyPublicRSAKeyError", this.localeLanguage),
+                    TranslationLoader.t("signatureRSAKeyFailed", this.localeLanguage),
+                    HttpStatusCode.NOT_FOUND
+                );
+                this.logger.error({
+                    message: TranslationLoader.t("verifyPublicRSAKey", this.localeLanguage),
+                    title: TranslationLoader.t("signatureRSAKeyFailed", this.localeLanguage),
+                    errorType: TranslationLoader.t("verifyPublicRSAKeyError", this.localeLanguage),
+                    stackTrace: stackTrace.stack,
+                    httpCodeValue: HttpStatusCode.NOT_FOUND
+                });
+                
+                return stackTrace;
+            }
+        } catch (err: any) {
+            const stackTrace: StackTraceError = this.traceError(
+                err.code,
+                TranslationLoader.t("verifyPublicRSAKey", this.localeLanguage),
+                HttpStatusCode.NOT_ACCEPTABLE
+            );
+
+            this.logger.error({
+                message: TranslationLoader.t("verifyPublicRSAKey", this.localeLanguage),
+                title: TranslationLoader.t("errorDecryption", this.localeLanguage),
+                errorType: err.message,
+                stackTrace: stackTrace.stack,
+                httpCodeValue: HttpStatusCode.NOT_ACCEPTABLE
+            });
+            process.exit();
+        }
+    }
+
+    private traceError(props: string, name: string, HttpStatusCode: number): StackTraceError {
+        return new StackTraceError(props, name, HttpStatusCode, true);
+    }
+}

package/src/application/services/loggerFileConfiguration.service.ts

@@ -0,0 +1,6 @@
+import { ILoggerConfig, LoggerCore } from "opticore-logger";
+import { loggerConfig } from "@webAppCore/core/config/logger/logger.config";
+
+export const SLoggerFileConfiguration: (environmentPath: any) => LoggerCore = (environmentPath: any): LoggerCore => {
+    return new LoggerCore(loggerConfig(environmentPath) as ILoggerConfig);
+}