@etsoo/appscript 1.1.68 → 1.1.72

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
@@ -235,6 +250,12 @@ export interface ICoreApp<S extends IAppSettings, N, C extends NotificationCallP
      * @returns Result
      */
     hasPermission(roles: number | UserRole | number[] | UserRole[]): boolean;
+    /**
+     * Init call
+     * @param callback Callback
+     * @returns Result
+     */
+    initCall(callback?: (result: boolean) => void): Promise<void>;
     /**
      * Callback where exit a page
      */
@@ -387,9 +408,10 @@ export declare abstract class CoreApp<S extends IAppSettings, N, C extends Notif
     protected setApi(api: IApi): void;
     /**
      * Init call
+     * @param callback Callback
      * @returns Result
      */
-    protected initCall(): Promise<void>;
+    initCall(callback?: (result: boolean) => void): Promise<void>;
     /**
      * Init call update
      * @param data Result data
@@ -427,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
@@ -445,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

@@ -119,19 +119,25 @@ class CoreApp {
     }
     /**
      * Init call
+     * @param callback Callback
      * @returns Result
      */
-    async initCall() {
+    async initCall(callback) {
         var _a;
         const data = {
             timestamp: new Date().getTime(),
             deviceId: this.deviceId === '' ? undefined : this.deviceId
         };
         const result = await this.api.put('Auth/WebInitCall', data);
-        if (result == null)
+        if (result == null) {
+            if (callback)
+                callback(false);
             return;
+        }
         if (result.data == null) {
             this.notifier.alert(this.get('noData'));
+            if (callback)
+                callback(false);
             return;
         }
         if (!result.ok) {
@@ -146,9 +152,13 @@ class CoreApp {
             else {
                 this.alertResult(result);
             }
+            if (callback)
+                callback(false);
             return;
         }
         this.initCallUpdate(result.data, data.timestamp);
+        if (callback)
+            callback(true);
     }
     /**
      * Init call update
@@ -160,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
@@ -170,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);
             }
         }
@@ -284,16 +294,41 @@ 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)
+        const pos = messageEncrypted.indexOf('!');
+        // Miliseconds chars are longer than 8
+        if (pos < 8 || 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)
@@ -305,23 +340,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
@@ -366,19 +387,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, {
@@ -388,6 +405,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
@@ -235,6 +250,12 @@ export interface ICoreApp<S extends IAppSettings, N, C extends NotificationCallP
      * @returns Result
      */
     hasPermission(roles: number | UserRole | number[] | UserRole[]): boolean;
+    /**
+     * Init call
+     * @param callback Callback
+     * @returns Result
+     */
+    initCall(callback?: (result: boolean) => void): Promise<void>;
     /**
      * Callback where exit a page
      */
@@ -387,9 +408,10 @@ export declare abstract class CoreApp<S extends IAppSettings, N, C extends Notif
     protected setApi(api: IApi): void;
     /**
      * Init call
+     * @param callback Callback
      * @returns Result
      */
-    protected initCall(): Promise<void>;
+    initCall(callback?: (result: boolean) => void): Promise<void>;
     /**
      * Init call update
      * @param data Result data
@@ -427,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
@@ -445,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

@@ -116,19 +116,25 @@ export class CoreApp {
     }
     /**
      * Init call
+     * @param callback Callback
      * @returns Result
      */
-    async initCall() {
+    async initCall(callback) {
         var _a;
         const data = {
             timestamp: new Date().getTime(),
             deviceId: this.deviceId === '' ? undefined : this.deviceId
         };
         const result = await this.api.put('Auth/WebInitCall', data);
-        if (result == null)
+        if (result == null) {
+            if (callback)
+                callback(false);
             return;
+        }
         if (result.data == null) {
             this.notifier.alert(this.get('noData'));
+            if (callback)
+                callback(false);
             return;
         }
         if (!result.ok) {
@@ -143,9 +149,13 @@ export class CoreApp {
             else {
                 this.alertResult(result);
             }
+            if (callback)
+                callback(false);
             return;
         }
         this.initCallUpdate(result.data, data.timestamp);
+        if (callback)
+            callback(true);
     }
     /**
      * Init call update
@@ -157,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
@@ -167,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);
             }
         }
@@ -281,16 +291,41 @@ 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)
+        const pos = messageEncrypted.indexOf('!');
+        // Miliseconds chars are longer than 8
+        if (pos < 8 || 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)
@@ -302,23 +337,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
@@ -363,19 +384,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, {
@@ -385,6 +402,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.68",
+    "version": "1.1.72",
     "description": "Applications shared TypeScript framework",
     "main": "lib/cjs/index.js",
     "module": "lib/mjs/index.js",
@@ -70,8 +70,8 @@
         "eslint": "^8.4.1",
         "eslint-config-airbnb-base": "^15.0.0",
         "eslint-plugin-import": "^2.25.3",
-        "jest": "^27.4.3",
-        "ts-jest": "^27.1.0",
-        "typescript": "^4.5.2"
+        "jest": "^27.4.4",
+        "ts-jest": "^27.1.1",
+        "typescript": "^4.5.3"
     }
 }

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
@@ -326,6 +347,13 @@ export interface ICoreApp<
      */
     hasPermission(roles: number | UserRole | number[] | UserRole[]): boolean;
 
+    /**
+     * Init call
+     * @param callback Callback
+     * @returns Result
+     */
+    initCall(callback?: (result: boolean) => void): Promise<void>;
+
     /**
      * Callback where exit a page
      */
@@ -588,9 +616,10 @@ export abstract class CoreApp<
 
     /**
      * Init call
+     * @param callback Callback
      * @returns Result
      */
-    protected async initCall() {
+    async initCall(callback?: (result: boolean) => void) {
         const data: InitCallDto = {
             timestamp: new Date().getTime(),
             deviceId: this.deviceId === '' ? undefined : this.deviceId
@@ -599,10 +628,14 @@ export abstract class CoreApp<
             'Auth/WebInitCall',
             data
         );
-        if (result == null) return;
+        if (result == null) {
+            if (callback) callback(false);
+            return;
+        }
 
         if (result.data == null) {
             this.notifier.alert(this.get<string>('noData')!);
+            if (callback) callback(false);
             return;
         }
 
@@ -623,10 +656,14 @@ export abstract class CoreApp<
                 this.alertResult(result);
             }
 
+            if (callback) callback(false);
+
             return;
         }
 
         this.initCallUpdate(result.data, data.timestamp);
+
+        if (callback) callback(true);
     }
 
     /**
@@ -639,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
@@ -657,8 +690,7 @@ export abstract class CoreApp<
         if (data.previousPassphrase) {
             const prev = this.decrypt(
                 data.previousPassphrase,
-                timestamp.toString(),
-                120
+                timestamp.toString()
             );
 
             // Update
@@ -671,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);
             }
         }
@@ -803,20 +839,49 @@ 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
     ) {
         // Timestamp splitter
-        const pos = messageEncrypted.indexOf('+');
-        if (pos === -1 || messageEncrypted.length <= 66) return undefined;
+        const pos = messageEncrypted.indexOf('!');
+
+        // Miliseconds chars are longer than 8
+        if (pos < 8 || 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);
@@ -831,29 +896,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);
     }
 
     /**
@@ -907,25 +956,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) +
@@ -937,6 +977,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