@etsoo/appscript 1.1.70 → 1.1.71

package/__tests__/app/CoreApp.ts

@@ -12,6 +12,7 @@ import { AddressUtils } from '../../src/address/AddressUtils';
 import { IAppSettings } from '../../src/app/AppSettings';
 import { CoreApp } from '../../src/app/CoreApp';
 import { zhCN } from '../../src/i18n/zhCN';
+import { InitCallResultData } from '../../src/result/InitCallResult';
 
 // Detected country or region
 const { detectedCountry } = DomUtils;
@@ -108,6 +109,11 @@ class CoreAppTest extends CoreApp<IAppSettings, {}, NotificationCallProps> {
     freshCountdownUI(callback?: () => PromiseLike<unknown>): void {
         throw new Error('Method not implemented.');
     }
+
+    initCallUpdateLocal(data: InitCallResultData, timestamp: number) {
+        this.initCallUpdate(data, timestamp);
+        return this.passphrase;
+    }
 }
 
 const app = new CoreAppTest();
@@ -122,3 +128,17 @@ test('Tests for encrypt / decrypt', () => {
     const plain = app.decrypt(encrypted, passphrase);
     expect(plain).toEqual(input);
 });
+
+test('Tests for initCallUpdateLocal', () => {
+    // Act
+    const passphrase = app.initCallUpdateLocal(
+        {
+            deviceId:
+                'ZmNjZlov+10067A1520126643352C2022735B85DC8F380088468402C98A5631A8CFBE14E134zXfxmw77lFopTTlbqOfsK2KUqPSsTAQb35Ejrm1BAvUaQH3SuZcwGYu3+PQ/Rd56',
+            passphrase:
+                '01397BF28A93FC031BC8B9B808F880F12C398AB792DF2ADE7A8768CADD2259EB50HJuKhqGuLQO+SmvCVzuEGUN4TdkUuPMWR0E6lliszbNiXboCziXx5SdfX3lMpoBX'
+        },
+        1639282438620
+    );
+    expect(passphrase).not.toBeNull();
+});

package/lib/cjs/app/CoreApp.d.ts

@@ -118,10 +118,17 @@ export interface ICoreApp<S extends IAppSettings, N, C extends NotificationCallP
      * Decrypt message
      * @param messageEncrypted Encrypted message
      * @param passphrase Secret passphrase
+     * @returns Pure text
+     */
+    decrypt(messageEncrypted: string, passphrase?: string): string | undefined;
+    /**
+     * Enhanced decrypt message
+     * @param messageEncrypted Encrypted message
+     * @param passphrase Secret passphrase
      * @param durationSeconds Duration seconds, <= 12 will be considered as month
      * @returns Pure text
      */
-    decrypt(messageEncrypted: string, passphrase?: string, durationSeconds?: number): string | undefined;
+    decryptEnhanced(messageEncrypted: string, passphrase?: string, durationSeconds?: number): string | undefined;
     /**
      * Detect IP data, call only one time
      * @param callback Callback will be called when the IP is ready
@@ -135,6 +142,14 @@ export interface ICoreApp<S extends IAppSettings, N, C extends NotificationCallP
      * @returns Result
      */
     encrypt(message: string, passphrase?: string, iterations?: number): string;
+    /**
+     * Enhanced encrypt message
+     * @param message Message
+     * @param passphrase Secret passphrase
+     * @param iterations Iterations, 1000 times, 1 - 99
+     * @returns Result
+     */
+    encryptEnhanced(message: string, passphrase?: string, iterations?: number): string;
     /**
      * Format date to string
      * @param input Input date
@@ -434,10 +449,17 @@ export declare abstract class CoreApp<S extends IAppSettings, N, C extends Notif
      * Decrypt message
      * @param messageEncrypted Encrypted message
      * @param passphrase Secret passphrase
+     * @returns Pure text
+     */
+    decrypt(messageEncrypted: string, passphrase?: string): string | undefined;
+    /**
+     * Enhanced decrypt message
+     * @param messageEncrypted Encrypted message
+     * @param passphrase Secret passphrase
      * @param durationSeconds Duration seconds, <= 12 will be considered as month
      * @returns Pure text
      */
-    decrypt(messageEncrypted: string, passphrase?: string, durationSeconds?: number): string | undefined;
+    decryptEnhanced(messageEncrypted: string, passphrase?: string, durationSeconds?: number): string | undefined;
     /**
      * Detect IP data, call only one time
      * @param callback Callback will be called when the IP is ready
@@ -452,6 +474,14 @@ export declare abstract class CoreApp<S extends IAppSettings, N, C extends Notif
      * @returns Result
      */
     encrypt(message: string, passphrase?: string, iterations?: number): string;
+    /**
+     * Enhanced encrypt message
+     * @param message Message
+     * @param passphrase Secret passphrase
+     * @param iterations Iterations, 1000 times, 1 - 99
+     * @returns Result
+     */
+    encryptEnhanced(message: string, passphrase?: string, iterations?: number): string;
     /**
      * Enchance secret passphrase
      * @param passphrase Secret passphrase

package/lib/cjs/app/CoreApp.js

@@ -170,7 +170,7 @@ class CoreApp {
             return;
         // Decrypt
         // Should be done within 120 seconds after returning from the backend
-        const passphrase = this.decrypt(data.passphrase, timestamp.toString(), 120);
+        const passphrase = this.decrypt(data.passphrase, timestamp.toString());
         if (passphrase == null)
             return;
         // Update device id and cache it
@@ -180,17 +180,17 @@ class CoreApp {
         this.passphrase = passphrase;
         // Previous passphrase
         if (data.previousPassphrase) {
-            const prev = this.decrypt(data.previousPassphrase, timestamp.toString(), 120);
+            const prev = this.decrypt(data.previousPassphrase, timestamp.toString());
             // Update
             const fields = this.initCallUpdateFields();
             for (const field of fields) {
                 const currentValue = shared_1.StorageUtils.getLocalData(field, '');
                 if (currentValue === '' || currentValue.indexOf('+') === -1)
                     continue;
-                const newValueSource = this.decrypt(currentValue, prev, 12);
+                const newValueSource = this.decryptEnhanced(currentValue, prev, 12);
                 if (newValueSource == null)
                     continue;
-                const newValue = this.encrypt(newValueSource);
+                const newValue = this.encryptEnhanced(newValueSource);
                 shared_1.StorageUtils.setLocalData(field, newValue);
             }
         }
@@ -294,16 +294,40 @@ class CoreApp {
      * Decrypt message
      * @param messageEncrypted Encrypted message
      * @param passphrase Secret passphrase
+     * @returns Pure text
+     */
+    decrypt(messageEncrypted, passphrase) {
+        // Iterations
+        const iterations = parseInt(messageEncrypted.substring(0, 2), 10);
+        if (isNaN(iterations))
+            return undefined;
+        const salt = crypto_js_1.enc.Hex.parse(messageEncrypted.substring(2, 34));
+        const iv = crypto_js_1.enc.Hex.parse(messageEncrypted.substring(34, 66));
+        const encrypted = messageEncrypted.substring(66);
+        const key = (0, crypto_js_1.PBKDF2)(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, salt, {
+            keySize: 8,
+            hasher: crypto_js_1.algo.SHA256,
+            iterations: 1000 * iterations
+        });
+        return crypto_js_1.AES.decrypt(encrypted, key, {
+            iv,
+            padding: crypto_js_1.pad.Pkcs7,
+            mode: crypto_js_1.mode.CBC
+        }).toString(crypto_js_1.enc.Utf8);
+    }
+    /**
+     * Enhanced decrypt message
+     * @param messageEncrypted Encrypted message
+     * @param passphrase Secret passphrase
      * @param durationSeconds Duration seconds, <= 12 will be considered as month
      * @returns Pure text
      */
-    decrypt(messageEncrypted, passphrase, durationSeconds) {
+    decryptEnhanced(messageEncrypted, passphrase, durationSeconds) {
         // Timestamp splitter
         const pos = messageEncrypted.indexOf('+');
         if (pos === -1 || messageEncrypted.length <= 66)
             return undefined;
         const timestamp = messageEncrypted.substring(0, pos);
-        const message = messageEncrypted.substring(pos + 1);
         if (durationSeconds != null && durationSeconds > 0) {
             const milseconds = shared_1.Utils.charsToNumber(timestamp);
             if (isNaN(milseconds) || milseconds < 1)
@@ -315,23 +339,9 @@ class CoreApp {
                     timespan.totalSeconds > durationSeconds))
                 return undefined;
         }
-        // Iterations
-        const iterations = parseInt(message.substring(0, 2), 10);
-        if (isNaN(iterations))
-            return undefined;
-        const salt = crypto_js_1.enc.Hex.parse(message.substring(2, 34));
-        const iv = crypto_js_1.enc.Hex.parse(message.substring(34, 66));
-        const encrypted = message.substring(66);
-        const key = (0, crypto_js_1.PBKDF2)(this.encryptionEnhance(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, timestamp), salt, {
-            keySize: 8,
-            hasher: crypto_js_1.algo.SHA256,
-            iterations: 1000 * iterations
-        });
-        return crypto_js_1.AES.decrypt(encrypted, key, {
-            iv,
-            padding: crypto_js_1.pad.Pkcs7,
-            mode: crypto_js_1.mode.CBC
-        }).toString(crypto_js_1.enc.Utf8);
+        const message = messageEncrypted.substring(pos + 1);
+        passphrase = this.encryptionEnhance(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, timestamp);
+        return this.decrypt(message, passphrase);
     }
     /**
      * Detect IP data, call only one time
@@ -376,19 +386,15 @@ class CoreApp {
     encrypt(message, passphrase, iterations) {
         // Default 1 * 1000
         iterations !== null && iterations !== void 0 ? iterations : (iterations = 1);
-        // Timestamp
-        const timestamp = shared_1.Utils.numberToChars(new Date().getTime());
         const bits = 16; // 128 / 8
         const salt = crypto_js_1.lib.WordArray.random(bits);
-        const key = (0, crypto_js_1.PBKDF2)(this.encryptionEnhance(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, timestamp), salt, {
+        const key = (0, crypto_js_1.PBKDF2)(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, salt, {
             keySize: 8,
             hasher: crypto_js_1.algo.SHA256,
             iterations: 1000 * iterations
         });
         const iv = crypto_js_1.lib.WordArray.random(bits);
-        return (timestamp +
-            '+' +
-            iterations.toString().padStart(2, '0') +
+        return (iterations.toString().padStart(2, '0') +
             salt.toString(crypto_js_1.enc.Hex) +
             iv.toString(crypto_js_1.enc.Hex) +
             crypto_js_1.AES.encrypt(message, key, {
@@ -398,6 +404,19 @@ class CoreApp {
             }).toString() // enc.Base64
         );
     }
+    /**
+     * Enhanced encrypt message
+     * @param message Message
+     * @param passphrase Secret passphrase
+     * @param iterations Iterations, 1000 times, 1 - 99
+     * @returns Result
+     */
+    encryptEnhanced(message, passphrase, iterations) {
+        // Timestamp
+        const timestamp = shared_1.Utils.numberToChars(new Date().getTime());
+        passphrase = this.encryptionEnhance(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, timestamp);
+        return timestamp + '+' + this.encrypt(message, passphrase, iterations);
+    }
     /**
      * Enchance secret passphrase
      * @param passphrase Secret passphrase

package/lib/mjs/app/CoreApp.d.ts

@@ -118,10 +118,17 @@ export interface ICoreApp<S extends IAppSettings, N, C extends NotificationCallP
      * Decrypt message
      * @param messageEncrypted Encrypted message
      * @param passphrase Secret passphrase
+     * @returns Pure text
+     */
+    decrypt(messageEncrypted: string, passphrase?: string): string | undefined;
+    /**
+     * Enhanced decrypt message
+     * @param messageEncrypted Encrypted message
+     * @param passphrase Secret passphrase
      * @param durationSeconds Duration seconds, <= 12 will be considered as month
      * @returns Pure text
      */
-    decrypt(messageEncrypted: string, passphrase?: string, durationSeconds?: number): string | undefined;
+    decryptEnhanced(messageEncrypted: string, passphrase?: string, durationSeconds?: number): string | undefined;
     /**
      * Detect IP data, call only one time
      * @param callback Callback will be called when the IP is ready
@@ -135,6 +142,14 @@ export interface ICoreApp<S extends IAppSettings, N, C extends NotificationCallP
      * @returns Result
      */
     encrypt(message: string, passphrase?: string, iterations?: number): string;
+    /**
+     * Enhanced encrypt message
+     * @param message Message
+     * @param passphrase Secret passphrase
+     * @param iterations Iterations, 1000 times, 1 - 99
+     * @returns Result
+     */
+    encryptEnhanced(message: string, passphrase?: string, iterations?: number): string;
     /**
      * Format date to string
      * @param input Input date
@@ -434,10 +449,17 @@ export declare abstract class CoreApp<S extends IAppSettings, N, C extends Notif
      * Decrypt message
      * @param messageEncrypted Encrypted message
      * @param passphrase Secret passphrase
+     * @returns Pure text
+     */
+    decrypt(messageEncrypted: string, passphrase?: string): string | undefined;
+    /**
+     * Enhanced decrypt message
+     * @param messageEncrypted Encrypted message
+     * @param passphrase Secret passphrase
      * @param durationSeconds Duration seconds, <= 12 will be considered as month
      * @returns Pure text
      */
-    decrypt(messageEncrypted: string, passphrase?: string, durationSeconds?: number): string | undefined;
+    decryptEnhanced(messageEncrypted: string, passphrase?: string, durationSeconds?: number): string | undefined;
     /**
      * Detect IP data, call only one time
      * @param callback Callback will be called when the IP is ready
@@ -452,6 +474,14 @@ export declare abstract class CoreApp<S extends IAppSettings, N, C extends Notif
      * @returns Result
      */
     encrypt(message: string, passphrase?: string, iterations?: number): string;
+    /**
+     * Enhanced encrypt message
+     * @param message Message
+     * @param passphrase Secret passphrase
+     * @param iterations Iterations, 1000 times, 1 - 99
+     * @returns Result
+     */
+    encryptEnhanced(message: string, passphrase?: string, iterations?: number): string;
     /**
      * Enchance secret passphrase
      * @param passphrase Secret passphrase

package/lib/mjs/app/CoreApp.js

@@ -167,7 +167,7 @@ export class CoreApp {
             return;
         // Decrypt
         // Should be done within 120 seconds after returning from the backend
-        const passphrase = this.decrypt(data.passphrase, timestamp.toString(), 120);
+        const passphrase = this.decrypt(data.passphrase, timestamp.toString());
         if (passphrase == null)
             return;
         // Update device id and cache it
@@ -177,17 +177,17 @@ export class CoreApp {
         this.passphrase = passphrase;
         // Previous passphrase
         if (data.previousPassphrase) {
-            const prev = this.decrypt(data.previousPassphrase, timestamp.toString(), 120);
+            const prev = this.decrypt(data.previousPassphrase, timestamp.toString());
             // Update
             const fields = this.initCallUpdateFields();
             for (const field of fields) {
                 const currentValue = StorageUtils.getLocalData(field, '');
                 if (currentValue === '' || currentValue.indexOf('+') === -1)
                     continue;
-                const newValueSource = this.decrypt(currentValue, prev, 12);
+                const newValueSource = this.decryptEnhanced(currentValue, prev, 12);
                 if (newValueSource == null)
                     continue;
-                const newValue = this.encrypt(newValueSource);
+                const newValue = this.encryptEnhanced(newValueSource);
                 StorageUtils.setLocalData(field, newValue);
             }
         }
@@ -291,16 +291,40 @@ export class CoreApp {
      * Decrypt message
      * @param messageEncrypted Encrypted message
      * @param passphrase Secret passphrase
+     * @returns Pure text
+     */
+    decrypt(messageEncrypted, passphrase) {
+        // Iterations
+        const iterations = parseInt(messageEncrypted.substring(0, 2), 10);
+        if (isNaN(iterations))
+            return undefined;
+        const salt = enc.Hex.parse(messageEncrypted.substring(2, 34));
+        const iv = enc.Hex.parse(messageEncrypted.substring(34, 66));
+        const encrypted = messageEncrypted.substring(66);
+        const key = PBKDF2(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, salt, {
+            keySize: 8,
+            hasher: algo.SHA256,
+            iterations: 1000 * iterations
+        });
+        return AES.decrypt(encrypted, key, {
+            iv,
+            padding: pad.Pkcs7,
+            mode: mode.CBC
+        }).toString(enc.Utf8);
+    }
+    /**
+     * Enhanced decrypt message
+     * @param messageEncrypted Encrypted message
+     * @param passphrase Secret passphrase
      * @param durationSeconds Duration seconds, <= 12 will be considered as month
      * @returns Pure text
      */
-    decrypt(messageEncrypted, passphrase, durationSeconds) {
+    decryptEnhanced(messageEncrypted, passphrase, durationSeconds) {
         // Timestamp splitter
         const pos = messageEncrypted.indexOf('+');
         if (pos === -1 || messageEncrypted.length <= 66)
             return undefined;
         const timestamp = messageEncrypted.substring(0, pos);
-        const message = messageEncrypted.substring(pos + 1);
         if (durationSeconds != null && durationSeconds > 0) {
             const milseconds = Utils.charsToNumber(timestamp);
             if (isNaN(milseconds) || milseconds < 1)
@@ -312,23 +336,9 @@ export class CoreApp {
                     timespan.totalSeconds > durationSeconds))
                 return undefined;
         }
-        // Iterations
-        const iterations = parseInt(message.substring(0, 2), 10);
-        if (isNaN(iterations))
-            return undefined;
-        const salt = enc.Hex.parse(message.substring(2, 34));
-        const iv = enc.Hex.parse(message.substring(34, 66));
-        const encrypted = message.substring(66);
-        const key = PBKDF2(this.encryptionEnhance(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, timestamp), salt, {
-            keySize: 8,
-            hasher: algo.SHA256,
-            iterations: 1000 * iterations
-        });
-        return AES.decrypt(encrypted, key, {
-            iv,
-            padding: pad.Pkcs7,
-            mode: mode.CBC
-        }).toString(enc.Utf8);
+        const message = messageEncrypted.substring(pos + 1);
+        passphrase = this.encryptionEnhance(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, timestamp);
+        return this.decrypt(message, passphrase);
     }
     /**
      * Detect IP data, call only one time
@@ -373,19 +383,15 @@ export class CoreApp {
     encrypt(message, passphrase, iterations) {
         // Default 1 * 1000
         iterations !== null && iterations !== void 0 ? iterations : (iterations = 1);
-        // Timestamp
-        const timestamp = Utils.numberToChars(new Date().getTime());
         const bits = 16; // 128 / 8
         const salt = lib.WordArray.random(bits);
-        const key = PBKDF2(this.encryptionEnhance(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, timestamp), salt, {
+        const key = PBKDF2(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, salt, {
             keySize: 8,
             hasher: algo.SHA256,
             iterations: 1000 * iterations
         });
         const iv = lib.WordArray.random(bits);
-        return (timestamp +
-            '+' +
-            iterations.toString().padStart(2, '0') +
+        return (iterations.toString().padStart(2, '0') +
             salt.toString(enc.Hex) +
             iv.toString(enc.Hex) +
             AES.encrypt(message, key, {
@@ -395,6 +401,19 @@ export class CoreApp {
             }).toString() // enc.Base64
         );
     }
+    /**
+     * Enhanced encrypt message
+     * @param message Message
+     * @param passphrase Secret passphrase
+     * @param iterations Iterations, 1000 times, 1 - 99
+     * @returns Result
+     */
+    encryptEnhanced(message, passphrase, iterations) {
+        // Timestamp
+        const timestamp = Utils.numberToChars(new Date().getTime());
+        passphrase = this.encryptionEnhance(passphrase !== null && passphrase !== void 0 ? passphrase : this.passphrase, timestamp);
+        return timestamp + '+' + this.encrypt(message, passphrase, iterations);
+    }
     /**
      * Enchance secret passphrase
      * @param passphrase Secret passphrase

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@etsoo/appscript",
-    "version": "1.1.70",
+    "version": "1.1.71",
     "description": "Applications shared TypeScript framework",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",

package/src/app/CoreApp.ts

@@ -177,10 +177,18 @@ export interface ICoreApp<
      * Decrypt message
      * @param messageEncrypted Encrypted message
      * @param passphrase Secret passphrase
+     * @returns Pure text
+     */
+    decrypt(messageEncrypted: string, passphrase?: string): string | undefined;
+
+    /**
+     * Enhanced decrypt message
+     * @param messageEncrypted Encrypted message
+     * @param passphrase Secret passphrase
      * @param durationSeconds Duration seconds, <= 12 will be considered as month
      * @returns Pure text
      */
-    decrypt(
+    decryptEnhanced(
         messageEncrypted: string,
         passphrase?: string,
         durationSeconds?: number
@@ -201,6 +209,19 @@ export interface ICoreApp<
      */
     encrypt(message: string, passphrase?: string, iterations?: number): string;
 
+    /**
+     * Enhanced encrypt message
+     * @param message Message
+     * @param passphrase Secret passphrase
+     * @param iterations Iterations, 1000 times, 1 - 99
+     * @returns Result
+     */
+    encryptEnhanced(
+        message: string,
+        passphrase?: string,
+        iterations?: number
+    ): string;
+
     /**
      * Format date to string
      * @param input Input date
@@ -655,11 +676,7 @@ export abstract class CoreApp<
 
         // Decrypt
         // Should be done within 120 seconds after returning from the backend
-        const passphrase = this.decrypt(
-            data.passphrase,
-            timestamp.toString(),
-            120
-        );
+        const passphrase = this.decrypt(data.passphrase, timestamp.toString());
         if (passphrase == null) return;
 
         // Update device id and cache it
@@ -673,8 +690,7 @@ export abstract class CoreApp<
         if (data.previousPassphrase) {
             const prev = this.decrypt(
                 data.previousPassphrase,
-                timestamp.toString(),
-                120
+                timestamp.toString()
             );
 
             // Update
@@ -687,10 +703,14 @@ export abstract class CoreApp<
                 if (currentValue === '' || currentValue.indexOf('+') === -1)
                     continue;
 
-                const newValueSource = this.decrypt(currentValue, prev, 12);
+                const newValueSource = this.decryptEnhanced(
+                    currentValue,
+                    prev,
+                    12
+                );
                 if (newValueSource == null) continue;
 
-                const newValue = this.encrypt(newValueSource);
+                const newValue = this.encryptEnhanced(newValueSource);
                 StorageUtils.setLocalData(field, newValue);
             }
         }
@@ -819,10 +839,38 @@ export abstract class CoreApp<
      * Decrypt message
      * @param messageEncrypted Encrypted message
      * @param passphrase Secret passphrase
+     * @returns Pure text
+     */
+    decrypt(messageEncrypted: string, passphrase?: string) {
+        // Iterations
+        const iterations = parseInt(messageEncrypted.substring(0, 2), 10);
+        if (isNaN(iterations)) return undefined;
+
+        const salt = enc.Hex.parse(messageEncrypted.substring(2, 34));
+        const iv = enc.Hex.parse(messageEncrypted.substring(34, 66));
+        const encrypted = messageEncrypted.substring(66);
+
+        const key = PBKDF2(passphrase ?? this.passphrase, salt, {
+            keySize: 8, // 256 / 32
+            hasher: algo.SHA256,
+            iterations: 1000 * iterations
+        });
+
+        return AES.decrypt(encrypted, key, {
+            iv,
+            padding: pad.Pkcs7,
+            mode: mode.CBC
+        }).toString(enc.Utf8);
+    }
+
+    /**
+     * Enhanced decrypt message
+     * @param messageEncrypted Encrypted message
+     * @param passphrase Secret passphrase
      * @param durationSeconds Duration seconds, <= 12 will be considered as month
      * @returns Pure text
      */
-    decrypt(
+    decryptEnhanced(
         messageEncrypted: string,
         passphrase?: string,
         durationSeconds?: number
@@ -832,7 +880,6 @@ export abstract class CoreApp<
         if (pos === -1 || messageEncrypted.length <= 66) return undefined;
 
         const timestamp = messageEncrypted.substring(0, pos);
-        const message = messageEncrypted.substring(pos + 1);
 
         if (durationSeconds != null && durationSeconds > 0) {
             const milseconds = Utils.charsToNumber(timestamp);
@@ -847,29 +894,13 @@ export abstract class CoreApp<
                 return undefined;
         }
 
-        // Iterations
-        const iterations = parseInt(message.substring(0, 2), 10);
-        if (isNaN(iterations)) return undefined;
-
-        const salt = enc.Hex.parse(message.substring(2, 34));
-        const iv = enc.Hex.parse(message.substring(34, 66));
-        const encrypted = message.substring(66);
-
-        const key = PBKDF2(
-            this.encryptionEnhance(passphrase ?? this.passphrase, timestamp),
-            salt,
-            {
-                keySize: 8, // 256 / 32
-                hasher: algo.SHA256,
-                iterations: 1000 * iterations
-            }
+        const message = messageEncrypted.substring(pos + 1);
+        passphrase = this.encryptionEnhance(
+            passphrase ?? this.passphrase,
+            timestamp
         );
 
-        return AES.decrypt(encrypted, key, {
-            iv,
-            padding: pad.Pkcs7,
-            mode: mode.CBC
-        }).toString(enc.Utf8);
+        return this.decrypt(message, passphrase);
     }
 
     /**
@@ -923,25 +954,16 @@ export abstract class CoreApp<
         // Default 1 * 1000
         iterations ??= 1;
 
-        // Timestamp
-        const timestamp = Utils.numberToChars(new Date().getTime());
-
         const bits = 16; // 128 / 8
         const salt = lib.WordArray.random(bits);
-        const key = PBKDF2(
-            this.encryptionEnhance(passphrase ?? this.passphrase, timestamp),
-            salt,
-            {
-                keySize: 8, // 256 / 32
-                hasher: algo.SHA256,
-                iterations: 1000 * iterations
-            }
-        );
+        const key = PBKDF2(passphrase ?? this.passphrase, salt, {
+            keySize: 8, // 256 / 32
+            hasher: algo.SHA256,
+            iterations: 1000 * iterations
+        });
         const iv = lib.WordArray.random(bits);
 
         return (
-            timestamp +
-            '+' +
             iterations.toString().padStart(2, '0') +
             salt.toString(enc.Hex) +
             iv.toString(enc.Hex) +
@@ -953,6 +975,25 @@ export abstract class CoreApp<
         );
     }
 
+    /**
+     * Enhanced encrypt message
+     * @param message Message
+     * @param passphrase Secret passphrase
+     * @param iterations Iterations, 1000 times, 1 - 99
+     * @returns Result
+     */
+    encryptEnhanced(message: string, passphrase?: string, iterations?: number) {
+        // Timestamp
+        const timestamp = Utils.numberToChars(new Date().getTime());
+
+        passphrase = this.encryptionEnhance(
+            passphrase ?? this.passphrase,
+            timestamp
+        );
+
+        return timestamp + '+' + this.encrypt(message, passphrase, iterations);
+    }
+
     /**
      * Enchance secret passphrase
      * @param passphrase Secret passphrase