@softtynet/zca-js 2.2.8 → 2.2.10

package/dist/cjs/constants/defaults.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+/**
+ * Tập trung toàn bộ các hằng số vận hành, giới hạn phân trang, thời gian chờ (Timeouts)
+ * và cấu hình Codec mặc định cho Gọi Thoại / Video.
+ */
+const ZALO_DEFAULTS = {
+    OPTIONS: {
+        SELF_LISTEN: false,
+        CHECK_UPDATE: true,
+        LOGGING: true,
+    },
+    BROWSER: {
+        DEFAULT_LANGUAGE: "vi",
+        DEFAULT_PLATFORM: "Windows",
+        DEFAULT_CHROME_VERSION: "133",
+        COMPUTER_NAME: "Web",
+        DEFAULT_USER_AGENT: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36",
+        ACCEPT_LANGUAGE_VI: "vi-VN,vi;q=0.9,en-US;q=0.8,en;q=0.7",
+        ACCEPT_LANGUAGE_EN: "en-US,en;q=0.9,vi;q=0.8",
+    },
+    CHAT: {
+        MAX_MESSAGES_PER_SEND: 50,
+    },
+    SOCKET: {
+        /** Khoảng thời gian tối thiểu gửi gói tin Ping (ms) */
+        MIN_PING_INTERVAL_MS: 10_000,
+        PING_INTERVAL_MIN_MS: 10_000,
+        /** Khoảng thời gian tối đa gửi gói tin Ping (ms) */
+        MAX_PING_INTERVAL_MS: 25_000,
+        PING_INTERVAL_MAX_MS: 25_000,
+        DEFAULT_PING_INTERVAL_MS: 25_000,
+        /** Thời gian Watchdog tự động ép kết nối lại nếu không nhận được gói tin nào (ms) */
+        WATCHDOG_TIMEOUT_MS: 50_000,
+        /** Thời gian chờ tối đa khi xoay vòng thử lại kết nối (ms) */
+        MAX_RETRY_BACKOFF_MS: 30_000,
+        /** Số lần lỗi 1006 liên tiếp trước khi xoay sang WebSocket endpoint tiếp theo */
+        CONSECUTIVE_1006_ROTATE_THRESHOLD: 2,
+        /** Con trỏ mặc định khi bắt đầu kéo hàng đợi tin nhắn cũ (cmd 510 / 511) */
+        OLD_MSG_INITIAL_CURSOR: "10000000000000000",
+        INITIAL_OLD_MESSAGES_CURSOR: "10000000000000000",
+    },
+    UPLOAD: {
+        /** Thời gian sống tối đa của uploadCallback trong bộ nhớ trước khi tự hủy (5 phút) */
+        CALLBACK_TTL_MS: 5 * 60 * 1000,
+        /** Kích thước mỗi khối tính MD5 cho file lớn (2MB) */
+        MD5_CHUNK_SIZE_BYTES: 2 * 1024 * 1024,
+    },
+    ZCLOUD: {
+        /** Thời gian cache cặp khóa { viewer_key, enk } trong phiên (15 phút) */
+        VIEWER_KEY_CACHE_TTL_MS: 15 * 60 * 1000,
+    },
+    PAGINATION: {
+        /** Kích thước ảnh đại diện mặc định (px) */
+        DEFAULT_AVATAR_SIZE: 120,
+        /** Số lượng tin nhắn lịch sử nhóm mặc định mỗi lần tải */
+        DEFAULT_GROUP_HISTORY_COUNT: 50,
+        /** Giới hạn an toàn tối đa khi tải lịch sử tin nhắn nhóm */
+        MAX_GROUP_HISTORY_COUNT: 200,
+        /** Số lượng tin nhắn tối đa mỗi trang của Zalo Cloud Message */
+        GROUP_CLOUD_PAGE_SIZE: 50,
+    },
+    VOICECALL: {
+        /** Danh sách Audio Codec chuẩn của binary C++ ZaloCall */
+        AUDIO_CODECS: [
+            { channels: 1, clockrate: 16000, name: "speex", payload: 99 },
+            { channels: 1, clockrate: 8000, name: "speex", payload: 98 },
+            { channels: 1, clockrate: 8000, name: "opus", payload: 109 },
+            { channels: 1, clockrate: 8000, name: "AMR-NB", payload: 106 },
+            { channels: 1, clockrate: 16000, name: "opus", payload: 112 },
+        ],
+        /** Danh sách Video Codec H.264 chuẩn của binary C++ ZaloCall */
+        VIDEO_CODECS: [{ clockrate: 90000, name: "h264", payload: 97 }],
+    },
+};
+
+exports.ZALO_DEFAULTS = ZALO_DEFAULTS;

package/dist/cjs/constants/domains.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+/**
+ * Danh mục tập trung toàn bộ các Domain gốc & Domain dự phòng (Fallback) của Zalo.
+ * Thay vì viết cứng rải rác trong hàng trăm file API, toàn bộ hệ thống tham chiếu từ đây.
+ */
+const ZALO_DOMAINS = {
+    /** Domain gốc của Zalo Chat Web (dùng cho Cookie, Origin, Referer) */
+    CHAT_WEB: "https://chat.zalo.me",
+    DEFAULT_COOKIE_DOMAIN: "chat.zalo.me",
+    /** Domain xác thực tài khoản và đăng nhập QR */
+    AUTH_ID: "https://id.zalo.me",
+    ID_ZALO: "https://id.zalo.me",
+    /** Domain WPA mặc định (dùng cho login, getServerInfo, getCloudViewerKey, getFamilyViewerKey) */
+    WPA_CHAT: "https://wpa.chat.zalo.me",
+    /** Domain dự phòng (Fallback) cho dịch vụ ánh xạ ZNoise ID (command 12390) */
+    ZWID_API: "https://zwid.api.zalo.me",
+    ZNOISE_FALLBACK: "https://zwid.api.zalo.me",
+    /** Domain mặc định cho hệ sinh thái ZCloud (nếu zpwServiceMap.zcloud chưa trả về) */
+    ZCLOUD_FALLBACK: "https://zcld.chat.zalo.me",
+    ZCLOUD_DEFAULT: "https://zcld.chat.zalo.me",
+    /** Domain mặc định cho hệ sinh thái ZFamily (nếu zpwServiceMap.zfamily chưa trả về) */
+    ZFAMILY_FALLBACK: "https://zfml.chat.zalo.me",
+    ZFAMILY_DEFAULT: "https://zfml.chat.zalo.me",
+    /** Domain mặc định cho tính năng AI (Voice-to-Text command 13394) */
+    AI_FEATURES_FALLBACK: "https://tt-ai-features-wpa.chat.zalo.me",
+    AI_FEATURES_DEFAULT: "https://tt-ai-features-wpa.chat.zalo.me",
+    /** Domain mặc định cho dịch vụ Emoji Status (command 16300 / 16301) */
+    EMOJI_STATUS_FALLBACK: "https://emoji-status.chat.zalo.me",
+    EMOJI_STATUS_DEFAULT: "https://emoji-status.chat.zalo.me",
+    /** Domain TransferSync tải file sao lưu .db.crypt từ điện thoại */
+    TRANSFER_SYNC: "https://transfersync.zaloapp.com",
+    /** Domain kiểm tra phiên bản NPM */
+    NPM_REGISTRY: "https://registry.npmjs.org/@softtynet/zca-js",
+    NPM_REGISTRY_PACKAGE: "https://registry.npmjs.org/@softtynet/zca-js",
+};
+
+exports.ZALO_DOMAINS = ZALO_DOMAINS;

package/dist/cjs/constants/endpoints.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+/**
+ * Bảng định danh đường dẫn Endpoint (Endpoint Registry) theo từng miền dịch vụ của Zalo PC 26.7.10.
+ * Giúp tra cứu nhanh và cập nhật tập trung khi Zalo thay đổi đường dẫn API.
+ */
+const ZALO_ENDPOINTS = {
+    WPA: {
+        LOGIN_GET_LOGIN_INFO: "/api/login/getLoginInfo",
+        LOGIN_GET_SERVER_INFO: "/api/login/getServerInfo",
+        SETTING_ME: "/api/setting/me",
+        SETTING_UPDATE: "/api/setting/update",
+        GET_CLOUD_VIEWER_KEY: "/api/getCloudViewerKey",
+        GET_FAMILY_VIEWER_KEY: "/api/getFamilyViewerKey",
+    },
+    ZWID: {
+        ZNOISE: "/api/znoise",
+    },
+    TRANSFER_SYNC: {
+        DOWNLOAD_V2: "/api/transfer-sync-v2/download",
+    },
+    AUTH: {
+        LOGIN_GET_LOGIN_INFO: "/api/login/getLoginInfo",
+        LOGIN_GET_SERVER_INFO: "/api/login/getServerInfo",
+        KEEP_ALIVE: "/keepalive",
+    },
+    ZCLOUD: {
+        GET_CLOUD_VIEWER_KEY: "/api/getCloudViewerKey",
+        GET_FAMILY_VIEWER_KEY: "/api/getFamilyViewerKey",
+        USAGE_V2: "/cloudmedia/info/pc/v2/usage",
+        USAGE_MYCLOUD: "/cloudmedia/info/pc/v1/usage-mycloud",
+        CLOUD_SETTINGS: "/cloudmedia/info/pc/v1/cloud-settings",
+        CLOUD_INFO: "/zalocloud/cloudinfopcweb/v1/info",
+        FAMILY_USAGE: "/cloudmedia/info/pc/v1/family-usage",
+        VERIFY_QUEUE: "/cloudmedia/queue/pc/verify",
+        FAMILY_PROFILE: "/zfamily/pc/family-profile/v1/family",
+    },
+    SYNC: {
+        PRELOAD_CONVERSATIONS: "/api/preloadconvers/get-last-msgs",
+        GET_LAST_SEEN: "/api/preloadconvers/get-last-seen",
+        PULL_MOBILE_MSG: "/api/message/pull_mobile_msg",
+        CANCEL_PULL_MOBILE_MSG: "/api/message/cancel_pull_mobile_msg",
+        ZNOISE: "/api/znoise",
+        ENCRYPT_GIDS: "/api/gid/encrypt",
+        DECRYPT_GIDS: "/api/gid/decrypt",
+    },
+    CALL: {
+        REQUEST_CALL: "/api/voicecall/requestcall",
+        SEND_REQUEST: "/api/voicecall/request",
+        CANCEL_CALL: "/api/voicecall/cancel",
+        END_CALL: "/api/voicecall/endcall",
+    },
+    AI: {
+        VOICE_TO_TEXT: "/api/aifeatures/voice2text",
+    },
+    EMOJI_STATUS: {
+        RESOURCE_CONFIG: "/api/v1/emoji-status/resource-config",
+        FRIENDS_LIST: "/api/v1/emoji-status/friends",
+    },
+    MEDIA_STORE: {
+        LIST: "/api/mediastore/list",
+        PREVIEW: "/api/mediastore/preview",
+        REMOVE: "/api/mediastore/remove",
+    },
+    RECENT_SEARCH: {
+        LIST: "/api/recentsearch/list",
+        UPDATE: "/api/recentsearch/update",
+    },
+};
+
+exports.ZALO_ENDPOINTS = ZALO_ENDPOINTS;

package/dist/cjs/constants/protocol.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+/**
+ * Chuẩn tham số giao thức cốt lõi của Zalo Web / Zalo PC (Single Source of Truth)
+ * Khi Zalo nâng cấp phiên bản giao thức mới, chỉ cần cập nhật tại file này.
+ */
+const ZALO_PROTOCOL = {
+    /** Loại thiết bị mặc định (30 = Zalo Web / PC) */
+    API_TYPE: 30,
+    DEFAULT_API_TYPE: 30,
+    /** Phiên bản giao thức mặc định (689 = Zalo PC 26.7.10) */
+    API_VERSION: 689,
+    DEFAULT_API_VERSION: 689,
+    /** Phiên bản SDK hiện tại */
+    SDK_VERSION: "2.2.10",
+    /** Mã zpw_type đặc thù dành riêng cho phân hệ Gọi Thoại & Video (binary C++ ZaloCall) */
+    VOICECALL_API_TYPE: 24,
+    /** Phiên bản mã hóa ZCID (ParamDecryptor) */
+    ENCRYPT_VERSION: "v2",
+    /** Tiền tố khóa ký MD5 cho tham số đăng nhập */
+    SIGN_KEY_PREFIX: "zsecure",
+    /** Khóa tĩnh dùng để mã hóa ZCID trong ParamCipher của Zalo PC */
+    PARAM_CIPHER_KEY: "3FC4F0D2AB50057BCE0D90D9187A22B1",
+    /** Chữ ký nhận diện định dạng container sao lưu từ điện thoại */
+    ZDB_MAGIC_HEADER: "ZDB4.0",
+    /** Kích thước mỗi khối (chunk) giải mã AES-256-CBC của file sao lưu .db.crypt (64KB) */
+    ZDB_CHUNK_SIZE: 0x10000,
+    /** Độ dài Vector khởi tạo ngẫu nhiên (IV) ghép ở đầu bản mã ZCloud / ZFamily (module 98yS) */
+    ZCLOUD_IV_BYTE_LENGTH: 16,
+    /** Độ dài khóa AES-256 tính theo byte */
+    AES_256_KEY_BYTE_LENGTH: 32,
+};
+
+exports.ZALO_PROTOCOL = ZALO_PROTOCOL;

package/dist/cjs/context.cjs

@@ -1,6 +1,9 @@
 'use strict';
 
-const _5_MINUTES = 5 * 60 * 1000;
+var protocol = require('./constants/protocol.cjs');
+var defaults = require('./constants/defaults.cjs');
+
+const _5_MINUTES = defaults.ZALO_DEFAULTS.UPLOAD.CALLBACK_TTL_MS;
 class CallbacksMap extends Map {
     /**
      * @param ttl Time to live in milliseconds. Default is 5 minutes.
@@ -12,14 +15,14 @@ class CallbacksMap extends Map {
         return super.set(key, value);
     }
 }
-const createContext = (apiType = 30, apiVersion = 689) => ({
+const createContext = (apiType = protocol.ZALO_PROTOCOL.API_TYPE, apiVersion = protocol.ZALO_PROTOCOL.API_VERSION) => ({
     API_TYPE: apiType,
     API_VERSION: apiVersion,
     uploadCallbacks: new CallbacksMap(),
     options: {
-        selfListen: false,
-        checkUpdate: true,
-        logging: true,
+        selfListen: defaults.ZALO_DEFAULTS.OPTIONS.SELF_LISTEN,
+        checkUpdate: defaults.ZALO_DEFAULTS.OPTIONS.CHECK_UPDATE,
+        logging: defaults.ZALO_DEFAULTS.OPTIONS.LOGGING,
         polyfill: global.fetch,
     },
     secretKey: null,
@@ -27,7 +30,7 @@ const createContext = (apiType = 30, apiVersion = 689) => ({
 function isContextSession(ctx) {
     return !!ctx.secretKey;
 }
-const MAX_MESSAGES_PER_SEND = 50;
+const MAX_MESSAGES_PER_SEND = defaults.ZALO_DEFAULTS.CHAT.MAX_MESSAGES_PER_SEND;
 
 exports.MAX_MESSAGES_PER_SEND = MAX_MESSAGES_PER_SEND;
 exports.createContext = createContext;

package/dist/cjs/core/service-router.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * Lấy danh sách toàn bộ các endpoint của một service từ `zpwServiceMap` (hoặc fallback về domain mặc định).
+ * Hỗ trợ cơ chế Multi-Endpoint Failover khi endpoint đầu tiên gặp sự cố mạng hoặc bảo trì.
+ */
+function getServiceEndpoints(zpwServiceMap, serviceKey, fallbackDomain) {
+    const list = zpwServiceMap?.[serviceKey];
+    if (Array.isArray(list) && list.length > 0) {
+        return list;
+    }
+    return [fallbackDomain];
+}
+/**
+ * Lấy endpoint chính (primary) của một service từ `zpwServiceMap` (hoặc fallback về domain mặc định).
+ */
+function getServiceEndpoint(zpwServiceMap, serviceKey, fallbackDomain) {
+    return getServiceEndpoints(zpwServiceMap, serviceKey, fallbackDomain)[0];
+}
+
+exports.getServiceEndpoint = getServiceEndpoint;
+exports.getServiceEndpoints = getServiceEndpoints;

package/dist/cjs/core/zcloud-client.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+require('crypto-js');
+require('node:crypto');
+var zcloudCipher = require('../crypto/zcloud-cipher.cjs');
+require('pako');
+require('json-bigint');
+
+/**
+ * Thực thi request tới hệ sinh thái ZCloud (`zcld.chat.zalo.me`) kèm cơ chế:
+ * 1. Tự động lấy `viewer_key` & `enk` từ bộ nhớ đệm (`ctx.zcloudViewerKeyCache`) nếu người dùng không truyền.
+ * 2. Tự động thử lại (Auto-Retry 1 lần với `forceRefresh = true`) nếu khóa `viewer_key` trong cache bị máy chủ từ chối do hết hạn sớm.
+ * 3. Tự động giải mã payload AES-256-CBC (Random 16-byte IV - module `98yS`).
+ */
+async function requestZCloudDecrypted(api, utils, options) {
+    const executeOnce = async (keyInfo) => {
+        if (!keyInfo?.viewer_key || !keyInfo?.enk) {
+            throw new ZaloApiError.ZaloApiError("Invalid CloudViewerKey");
+        }
+        const targetUrl = options.paramsPayload
+            ? utils.makeURL(options.url, {
+                params: zcloudCipher.encryptZCloudAES(JSON.stringify(options.paramsPayload), keyInfo.enk),
+            })
+            : options.url;
+        const response = await utils.request(targetUrl, {
+            method: options.method ?? "GET",
+            headers: {
+                "cloud-viewer-key": keyInfo.viewer_key,
+            },
+            ...(options.body ? { body: options.body } : {}),
+        });
+        const json = (await response.json());
+        return { json, keyInfo };
+    };
+    const initialKey = options.viewerKeyInfo ?? (await api.getCloudViewerKey(false));
+    let { json, keyInfo } = await executeOnce(initialKey);
+    if (!options.viewerKeyInfo && json.error_code !== 0 && json.error_code !== -904) {
+        const refreshedKey = await api.getCloudViewerKey(true);
+        ({ json, keyInfo } = await executeOnce(refreshedKey));
+    }
+    if (json.error_code !== 0 && json.error_code !== -904) {
+        throw new ZaloApiError.ZaloApiError(json.error_message || "ZCloud request failed", json.error_code);
+    }
+    if (!json.data) {
+        if (options.allowEmptyDataOn904) {
+            return {};
+        }
+        throw new ZaloApiError.ZaloApiError("Empty ZCloud response data", json.error_code);
+    }
+    const decrypted = zcloudCipher.decryptZCloudAES(json.data, keyInfo.enk);
+    return JSON.parse(decrypted);
+}
+/**
+ * Thực thi request tới hệ sinh thái ZFamily (`zfml.chat.zalo.me`) kèm cơ chế tự động quản lý khóa,
+ * tự động làm mới khi khóa hết hạn và giải mã AES-256-CBC (Random 16-byte IV - module `98yS`).
+ */
+async function requestZFamilyDecrypted(api, utils, options) {
+    const executeOnce = async (keyInfo) => {
+        if (!keyInfo?.viewer_key || !keyInfo?.enk) {
+            throw new ZaloApiError.ZaloApiError("Invalid FamilyViewerKey");
+        }
+        const response = await utils.request(options.url, {
+            method: options.method ?? "GET",
+            headers: {
+                "zfamily-viewer-key": keyInfo.viewer_key,
+            },
+            ...(options.body ? { body: options.body } : {}),
+        });
+        const json = (await response.json());
+        return { json, keyInfo };
+    };
+    const initialKey = options.viewerKeyInfo ?? (await api.getFamilyViewerKey(false));
+    let { json, keyInfo } = await executeOnce(initialKey);
+    if (!options.viewerKeyInfo && json.error_code !== 0 && json.error_code !== -904) {
+        const refreshedKey = await api.getFamilyViewerKey(true);
+        ({ json, keyInfo } = await executeOnce(refreshedKey));
+    }
+    if (json.error_code !== 0 && json.error_code !== -904) {
+        throw new ZaloApiError.ZaloApiError(json.error_message || "ZFamily request failed", json.error_code);
+    }
+    if (!json.data) {
+        if (options.allowEmptyDataOn904) {
+            return {};
+        }
+        throw new ZaloApiError.ZaloApiError("Empty ZFamily response data", json.error_code);
+    }
+    const decrypted = zcloudCipher.decryptZCloudAES(json.data, keyInfo.enk);
+    return JSON.parse(decrypted);
+}
+
+exports.requestZCloudDecrypted = requestZCloudDecrypted;
+exports.requestZFamilyDecrypted = requestZFamilyDecrypted;

package/dist/cjs/crypto/aes.cjs

@@ -0,0 +1,181 @@
+'use strict';
+
+var cryptojs = require('crypto-js');
+var crypto = require('node:crypto');
+var protocol = require('../constants/protocol.cjs');
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+
+class ParamsEncryptor {
+    zcid = null;
+    enc_ver;
+    zcid_ext;
+    encryptKey;
+    constructor({ type, imei, firstLaunchTime }) {
+        this.enc_ver = protocol.ZALO_PROTOCOL.ENCRYPT_VERSION;
+        this.zcid = null;
+        this.encryptKey = null;
+        this.createZcid(type, imei, firstLaunchTime);
+        this.zcid_ext = ParamsEncryptor.randomString();
+        this.createEncryptKey();
+    }
+    getEncryptKey() {
+        if (!this.encryptKey)
+            throw new ZaloApiError.ZaloApiError("getEncryptKey: didn't create encryptKey yet");
+        return this.encryptKey;
+    }
+    createZcid(type, imei, firstLaunchTime) {
+        if (!type || !imei || !firstLaunchTime)
+            throw new ZaloApiError.ZaloApiError("createZcid: missing params");
+        const msg = `${type},${imei},${firstLaunchTime}`;
+        const s = ParamsEncryptor.encodeAES("3FC4F0D2AB50057BCE0D90D9187A22B1", msg, "hex", true);
+        this.zcid = s;
+    }
+    createEncryptKey(e = 0) {
+        const t = (e, t) => {
+            const { even: n } = ParamsEncryptor.processStr(e), { even: a, odd: s } = ParamsEncryptor.processStr(t);
+            if (!n || !a || !s)
+                return false;
+            const i = n.slice(0, 8).join("") + a.slice(0, 12).join("") + s.reverse().slice(0, 12).join("");
+            return (this.encryptKey = i), true;
+        };
+        if (!this.zcid || !this.zcid_ext)
+            throw new ZaloApiError.ZaloApiError("createEncryptKey: zcid or zcid_ext is null");
+        try {
+            const n = cryptojs.MD5(this.zcid_ext).toString().toUpperCase();
+            if (t(n, this.zcid) || !(e < 3))
+                return !1;
+            this.createEncryptKey(e + 1);
+        }
+        catch {
+            if (e < 3)
+                this.createEncryptKey(e + 1);
+        }
+        return true;
+    }
+    getParams() {
+        return this.zcid
+            ? {
+                zcid: this.zcid,
+                zcid_ext: this.zcid_ext,
+                enc_ver: this.enc_ver,
+            }
+            : null;
+    }
+    static processStr(e) {
+        if (!e || "string" != typeof e)
+            return {
+                even: null,
+                odd: null,
+            };
+        const [t, n] = [...e].reduce((e, t, n) => (e[n % 2].push(t), e), [[], []]);
+        return {
+            even: t,
+            odd: n,
+        };
+    }
+    static randomString(e, t) {
+        const n = e || 6, a = t && e && t > e ? t : 12;
+        let s = Math.floor(Math.random() * (a - n + 1)) + n;
+        if (s > 12) {
+            let e = "";
+            for (; s > 0;) {
+                e += Math.random()
+                    .toString(16)
+                    .substr(2, s > 12 ? 12 : s);
+                s -= 12;
+            }
+            return e;
+        }
+        return Math.random().toString(16).substr(2, s);
+    }
+    static encodeAES(e, message, type, uppercase, s = 0) {
+        if (!message)
+            return null;
+        try {
+            const encoder = "hex" == type ? cryptojs.enc.Hex : cryptojs.enc.Base64;
+            const key = cryptojs.enc.Utf8.parse(e);
+            const cfg = {
+                words: [0, 0, 0, 0],
+                sigBytes: 16,
+            };
+            const encrypted = cryptojs.AES.encrypt(message, key, {
+                iv: cfg,
+                mode: cryptojs.mode.CBC,
+                padding: cryptojs.pad.Pkcs7,
+            }).ciphertext.toString(encoder);
+            return uppercase ? encrypted.toUpperCase() : encrypted;
+        }
+        catch {
+            return s < 3 ? ParamsEncryptor.encodeAES(e, message, type, uppercase, s + 1) : null;
+        }
+    }
+}
+function decodeRespAES(key, data) {
+    data = decodeURIComponent(data);
+    const parsedKey = cryptojs.enc.Utf8.parse(key);
+    const n = {
+        words: [0, 0, 0, 0],
+        sigBytes: 16,
+    };
+    return cryptojs.AES.decrypt({
+        ciphertext: cryptojs.enc.Base64.parse(data),
+    }, parsedKey, {
+        iv: n,
+        mode: cryptojs.mode.CBC,
+        padding: cryptojs.pad.Pkcs7,
+    }).toString(cryptojs.enc.Utf8);
+}
+function decryptResp(key, data) {
+    let n = null;
+    try {
+        n = decodeRespAES(key, data);
+        const parsed = JSON.parse(n);
+        return parsed;
+    }
+    catch {
+        return n;
+    }
+}
+function encodeAES(secretKey, data, t = 0) {
+    try {
+        const key = cryptojs.enc.Base64.parse(secretKey);
+        return cryptojs.AES.encrypt(data, key, {
+            iv: cryptojs.enc.Hex.parse("00000000000000000000000000000000"),
+            mode: cryptojs.mode.CBC,
+            padding: cryptojs.pad.Pkcs7,
+        }).ciphertext.toString(cryptojs.enc.Base64);
+    }
+    catch {
+        return t < 3 ? encodeAES(secretKey, data, t + 1) : null;
+    }
+}
+function decodeAES(secretKey, data, t = 0) {
+    try {
+        data = decodeURIComponent(data);
+        const key = cryptojs.enc.Base64.parse(secretKey);
+        return cryptojs.AES.decrypt({
+            ciphertext: cryptojs.enc.Base64.parse(data),
+        }, key, {
+            iv: cryptojs.enc.Hex.parse("00000000000000000000000000000000"),
+            mode: cryptojs.mode.CBC,
+            padding: cryptojs.pad.Pkcs7,
+        }).toString(cryptojs.enc.Utf8);
+    }
+    catch {
+        return t < 3 ? decodeAES(secretKey, data, t + 1) : null;
+    }
+}
+function encryptPin(pin) {
+    return crypto.createHash("md5").update(pin).digest("hex");
+}
+function validatePin(encryptedPin, pin) {
+    const hash = crypto.createHash("md5").update(pin).digest("hex");
+    return hash === encryptedPin;
+}
+
+exports.ParamsEncryptor = ParamsEncryptor;
+exports.decodeAES = decodeAES;
+exports.decryptResp = decryptResp;
+exports.encodeAES = encodeAES;
+exports.encryptPin = encryptPin;
+exports.validatePin = validatePin;

package/dist/cjs/crypto/ws-cipher.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var crypto = require('node:crypto');
+var pako = require('pako');
+var JSONBig = require('json-bigint');
+var ZaloApiError = require('../Errors/ZaloApiError.cjs');
+
+function decodeBase64ToBuffer(data) {
+    return Buffer.from(data, "base64");
+}
+function decodeUnit8Array(data) {
+    try {
+        return new TextDecoder().decode(data);
+    }
+    catch {
+        return null;
+    }
+}
+async function decodeEventData(parsed, cipherKey) {
+    if (typeof parsed.data !== "string")
+        throw new ZaloApiError.ZaloApiError(`Invalid data, expected string but got ${typeof parsed.data}`);
+    if (typeof parsed.encrypt !== "number")
+        throw new ZaloApiError.ZaloApiError(`Invalid encrypt type, expected number but got ${typeof parsed.encrypt}`);
+    if (parsed.encrypt < 0 || parsed.encrypt > 3)
+        throw new ZaloApiError.ZaloApiError(`Invalid encrypt type, expected 0-3 but got ${parsed.encrypt}`);
+    const rawData = parsed.data;
+    const encryptType = parsed.encrypt;
+    if (encryptType === 0)
+        return JSON.parse(rawData);
+    const decodedBuffer = decodeBase64ToBuffer(encryptType === 1 ? rawData : decodeURIComponent(rawData));
+    let decryptedBuffer = decodedBuffer;
+    if (encryptType !== 1) {
+        if (cipherKey && decodedBuffer.length >= 48) {
+            const algorithm = {
+                name: "AES-GCM",
+                iv: decodedBuffer.subarray(0, 16),
+                tagLength: 128,
+                additionalData: decodedBuffer.subarray(16, 32),
+            };
+            const dataSource = decodedBuffer.subarray(32);
+            const cryptoKey = await crypto.subtle.importKey("raw", decodeBase64ToBuffer(cipherKey), algorithm, false, [
+                "decrypt",
+            ]);
+            decryptedBuffer = await crypto.subtle.decrypt(algorithm, cryptoKey, dataSource);
+        }
+        else {
+            throw new ZaloApiError.ZaloApiError("Invalid data length or missing cipher key");
+        }
+    }
+    const decompressedBuffer = encryptType === 3 ? new Uint8Array(decryptedBuffer) : pako.inflate(decryptedBuffer);
+    const decodedData = decodeUnit8Array(decompressedBuffer);
+    if (!decodedData)
+        return;
+    return JSONBig.parse(decodedData);
+}
+
+exports.decodeBase64ToBuffer = decodeBase64ToBuffer;
+exports.decodeEventData = decodeEventData;
+exports.decodeUnit8Array = decodeUnit8Array;

package/dist/cjs/crypto/zcloud-cipher.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var crypto = require('node:crypto');
+var protocol = require('../constants/protocol.cjs');
+
+/**
+ * Encrypts a plaintext string for ZCloud / ZFamily APIs (`CLOUD_API` / `CLOUD_FAMILY_API`, module `"98yS"`),
+ * using AES-256-CBC with a random 16-byte IV prepended to the ciphertext before Base64 encoding.
+ */
+function encryptZCloudAES(plainText, base64Key) {
+    const key = Buffer.from(base64Key, "base64");
+    const iv = crypto.randomBytes(protocol.ZALO_PROTOCOL.ZCLOUD_IV_BYTE_LENGTH);
+    const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+    const encrypted = Buffer.concat([cipher.update(plainText, "utf8"), cipher.final()]);
+    return Buffer.concat([iv, encrypted]).toString("base64");
+}
+/**
+ * Decrypts a Base64 payload from ZCloud / ZFamily APIs (`CLOUD_API` / `CLOUD_FAMILY_API`, module `"98yS"`),
+ * extracting the first 16 bytes as the AES-256-CBC IV and the remainder as PKCS#7-padded ciphertext.
+ */
+function decryptZCloudAES(base64CipherText, base64Key) {
+    const key = Buffer.from(base64Key, "base64");
+    const raw = Buffer.from(base64CipherText, "base64");
+    const ivLen = protocol.ZALO_PROTOCOL.ZCLOUD_IV_BYTE_LENGTH;
+    const iv = raw.subarray(0, ivLen);
+    const ciphertext = raw.subarray(ivLen);
+    const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+}
+
+exports.decryptZCloudAES = decryptZCloudAES;
+exports.encryptZCloudAES = encryptZCloudAES;