ismx-nexo-node-app 0.4.118 → 0.4.120

package/dist/js/business/utils/ArrayUtils.js

@@ -52,6 +52,18 @@ class ArrayUtils {
         const onlyInArr2 = ArrayUtils.subtract(arr2, arr1);
         return Array.from(new Set([...onlyInArr1, ...onlyInArr2]).values());
     }
+    /**
+     * Returns the intersection of two arrays.
+     * It will include only the elements that exist in both arrays.
+     *
+     * @param {T[]} arr1 - The first array to intersect.
+     * @param {T[]} arr2 - The second array to intersect.
+     * @return {T[]} An array containing only the elements present in both arr1 and arr2.
+     * @template T
+     */
+    static intersect(arr1, arr2) {
+        return arr1.filter(item => arr2.includes(item));
+    }
     /**
      * Toggles the presence of an item in an array. If the item exists in the array, it is removed;
      * if it does not exist, it is added.

package/dist/js/business/utils/CryptoUtils.js

@@ -37,7 +37,7 @@ class CryptoUtils {
         const pad = Buffer.alloc((blocksize - (buf.length % blocksize)) % blocksize, 0);
         return Buffer.concat([buf, pad]);
     }
-    static encrypt3DES(key, message) {
+    static symEncrypt(key, message) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             let crypto = (_a = this.crypto) !== null && _a !== void 0 ? _a : (yield Promise.resolve().then(() => __importStar(require("crypto")))).default;
@@ -54,11 +54,27 @@ class CryptoUtils {
             return encryptedBuf.slice(0, maxLength);
         });
     }
+    static symDecrypt(key, encrypted) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let crypto = (_a = this.crypto) !== null && _a !== void 0 ? _a : (yield Promise.resolve().then(() => __importStar(require("crypto")))).default;
+            const keyBuf = Buffer.from(key, 'base64');
+            const iv = Buffer.alloc(8, 0);
+            const decipher = crypto.createDecipheriv('des-ede3-cbc', keyBuf, iv);
+            decipher.setAutoPadding(false);
+            const decryptedBuf = Buffer.concat([
+                decipher.update(encrypted),
+                decipher.final()
+            ]);
+            // Remove zero padding
+            return decryptedBuf.toString('utf8').replace(/\x00+$/g, '');
+        });
+    }
     static sha256Sign(merchantKey, orderId, encodedOrder) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             let crypto = (_a = this.crypto) !== null && _a !== void 0 ? _a : (yield Promise.resolve().then(() => __importStar(require("crypto")))).default;
-            const orderKeyBuf = yield CryptoUtils.encrypt3DES(merchantKey, orderId);
+            const orderKeyBuf = yield CryptoUtils.symEncrypt(merchantKey, orderId);
             return crypto.createHmac('sha256', orderKeyBuf).update(encodedOrder).digest('base64');
         });
     }

package/dist/types/business/utils/ArrayUtils.d.ts

@@ -25,6 +25,16 @@ export default abstract class ArrayUtils {
      * @template T
      */
     static diff<T>(arr1: T[], arr2: T[]): T[];
+    /**
+     * Returns the intersection of two arrays.
+     * It will include only the elements that exist in both arrays.
+     *
+     * @param {T[]} arr1 - The first array to intersect.
+     * @param {T[]} arr2 - The second array to intersect.
+     * @return {T[]} An array containing only the elements present in both arr1 and arr2.
+     * @template T
+     */
+    static intersect<T>(arr1: T[], arr2: T[]): T[];
     /**
      * Toggles the presence of an item in an array. If the item exists in the array, it is removed;
      * if it does not exist, it is added.

package/dist/types/business/utils/CryptoUtils.d.ts

@@ -1,6 +1,7 @@
 export default abstract class CryptoUtils {
     private static crypto;
     static zeroPad(buf: Buffer, blocksize: number): Buffer;
-    static encrypt3DES(key: string, message: string): Promise<Buffer>;
+    static symEncrypt(key: string, message: string): Promise<Buffer>;
+    static symDecrypt(key: string, encrypted: Buffer): Promise<string>;
     static sha256Sign(merchantKey: string, orderId: string, encodedOrder: string): Promise<string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ismx-nexo-node-app",
-  "version": "0.4.118",
+  "version": "0.4.120",
   "description": "",
   "scripts": {
     "build": "rm -rf ./dist && npx tsc",

package/src/main/node/business/utils/ArrayUtils.ts

@@ -41,6 +41,19 @@ export default abstract class ArrayUtils {
 		return Array.from(new Set([...onlyInArr1, ...onlyInArr2]).values());
 	}
 
+    /**
+     * Returns the intersection of two arrays.
+     * It will include only the elements that exist in both arrays.
+     *
+     * @param {T[]} arr1 - The first array to intersect.
+     * @param {T[]} arr2 - The second array to intersect.
+     * @return {T[]} An array containing only the elements present in both arr1 and arr2.
+     * @template T
+     */
+    static intersect<T>(arr1: T[], arr2: T[]): T[] {
+        return arr1.filter(item => arr2.includes(item));
+    }
+
 	/**
 	 * Toggles the presence of an item in an array. If the item exists in the array, it is removed;
 	 * if it does not exist, it is added.

package/src/main/node/business/utils/CryptoUtils.ts

@@ -7,7 +7,7 @@ export default abstract class CryptoUtils {
 		return Buffer.concat([buf, pad]);
 	}
 
-	static async encrypt3DES(key: string, message: string)
+	static async symEncrypt(key: string, message: string): Promise<Buffer>
 	{
 		let crypto = this.crypto ?? (await import("crypto")).default;
 
@@ -27,9 +27,27 @@ export default abstract class CryptoUtils {
 		return encryptedBuf.slice(0, maxLength);
 	}
 
+    static async symDecrypt(key: string, encrypted: Buffer): Promise<string> {
+        let crypto = this.crypto ?? (await import("crypto")).default;
+
+        const keyBuf = Buffer.from(key, 'base64');
+        const iv = Buffer.alloc(8, 0);
+
+        const decipher = crypto.createDecipheriv('des-ede3-cbc', keyBuf, iv);
+        decipher.setAutoPadding(false);
+
+        const decryptedBuf = Buffer.concat([
+            decipher.update(encrypted),
+            decipher.final()
+        ]);
+
+        // Remove zero padding
+        return decryptedBuf.toString('utf8').replace(/\x00+$/g, '');
+    }
+
 	static async sha256Sign(merchantKey: string, orderId: string, encodedOrder: string) {
 		let crypto = this.crypto ?? (await import("crypto")).default;
-		const orderKeyBuf = await CryptoUtils.encrypt3DES(merchantKey, orderId);
+		const orderKeyBuf = await CryptoUtils.symEncrypt(merchantKey, orderId);
 		return crypto.createHmac('sha256', orderKeyBuf).update(encodedOrder).digest('base64');
 	}
 }