@softtynet/zca-js 2.2.8 → 2.2.10

package/dist/utils.js

@@ -2,14 +2,17 @@ import cryptojs from "crypto-js";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import pako from "pako";
 import SparkMD5 from "spark-md5";
 import toughCookie from "tough-cookie";
-import JSONBig from "json-bigint";
 import { isContextSession } from "./context.js";
 import { ZaloApiError, ZaloApiMissingImageMetadataGetter } from "./Errors/index.js";
 import { FriendEventType } from "./models/FriendEvent.js";
 import { GroupEventType } from "./models/GroupEvent.js";
+import { ZALO_DEFAULTS, ZALO_DOMAINS, ZALO_PROTOCOL } from "./constants/index.js";
+import { decodeAES, encodeAES } from "./crypto/index.js";
+export * from "./constants/index.js";
+export * from "./crypto/index.js";
+export * from "./core/index.js";
 export const isBun = typeof Bun !== "undefined";
 export function hasOwn(obj, key) {
     return Object.prototype.hasOwnProperty.call(obj, key);
@@ -20,7 +23,6 @@ export function hasOwn(obj, key) {
  * @param type
  * @param params
  * @returns MD5 hash
- *
  */
 export function getSignKey(type, params) {
     const n = [];
@@ -30,7 +32,7 @@ export function getSignKey(type, params) {
         }
     }
     n.sort();
-    let a = "zsecure" + type;
+    let a = ZALO_PROTOCOL.SIGN_KEY_PREFIX + type;
     for (let s = 0; s < n.length; s++)
         a += params[n[s]];
     return cryptojs.MD5(a).toString();
@@ -41,7 +43,6 @@ export function getSignKey(type, params) {
  * @param params
  * @param apiVersion automatically add zalo api version to url params
  * @returns
- *
  */
 export function makeURL(ctx, baseURL, params = {}, apiVersion = true) {
     const url = new URL(baseURL);
@@ -58,214 +59,32 @@ export function makeURL(ctx, baseURL, params = {}, apiVersion = true) {
     }
     return url.toString();
 }
-export class ParamsEncryptor {
-    constructor({ type, imei, firstLaunchTime }) {
-        this.zcid = null;
-        this.enc_ver = "v2";
-        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("getEncryptKey: didn't create encryptKey yet");
-        return this.encryptKey;
-    }
-    createZcid(type, imei, firstLaunchTime) {
-        if (!type || !imei || !firstLaunchTime)
-            throw new 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 !1;
-            const i = n.slice(0, 8).join("") + a.slice(0, 12).join("") + s.reverse().slice(0, 12).join("");
-            return (this.encryptKey = i), !0;
-        };
-        if (!this.zcid || !this.zcid_ext)
-            throw new 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 (_a) {
-            if (e < 3)
-                this.createEncryptKey(e + 1);
-        }
-        return !0;
-    }
-    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 (_a) {
-            return s < 3 ? ParamsEncryptor.encodeAES(e, message, type, uppercase, s + 1) : null;
-        }
-    }
-}
-export function decryptResp(key, data) {
-    let n = null;
-    try {
-        n = decodeRespAES(key, data);
-        const parsed = JSON.parse(n);
-        return parsed;
-    }
-    catch (_a) {
-        return n;
-    }
-}
-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);
-}
-export function decodeBase64ToBuffer(data) {
-    return Buffer.from(data, "base64");
-}
-export function decodeUnit8Array(data) {
-    try {
-        return new TextDecoder().decode(data);
-    }
-    catch (_a) {
-        return null;
-    }
-}
-export 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 (_a) {
-        return t < 3 ? encodeAES(secretKey, data, t + 1) : null;
-    }
-}
-export 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 (_a) {
-        return t < 3 ? decodeAES(secretKey, data, t + 1) : null;
-    }
-}
 /**
  * Suy luận nền tảng hệ điều hành (OS) từ chuỗi User-Agent.
  *
- * Hàm này được sinh ra để giải quyết vấn đề cốt lõi: thư viện zca-js trước đây
- * hardcode `sec-ch-ua-platform: "Windows"` ở 8 chỗ trong loginQR, trong khi
- * User-Agent có thể là Mac/Linux — tạo ra Browser Mismatch khiến Zalo ban session.
- *
- * Thứ tự ưu tiên nhận diện: Windows → macOS → Linux → mặc định Windows (an toàn nhất)
- *
  * @returns Chuỗi platform theo định dạng Sec-CH-UA-Platform, ví dụ: "Windows", "macOS", "Linux"
  */
 export function getPlatformFromUA(userAgent) {
     if (!userAgent)
-        return "Windows"; // Không có UA → mặc định Windows
+        return ZALO_DEFAULTS.BROWSER.DEFAULT_PLATFORM;
     if (/Windows/i.test(userAgent))
         return "Windows";
     if (/Macintosh|Mac OS X/i.test(userAgent))
         return "macOS";
     if (/Linux|X11/i.test(userAgent))
         return "Linux";
-    return "Windows"; // Không nhận diện được → fallback an toàn về Windows
+    return ZALO_DEFAULTS.BROWSER.DEFAULT_PLATFORM;
 }
 /**
  * Trích xuất phiên bản Chrome major từ chuỗi User-Agent.
  *
- * Dùng để điền vào header `sec-ch-ua` một cách động, đảm bảo Chrome version
- * trong header khớp với Chrome version trong User-Agent (tránh fingerprint anomaly).
- *
- * Lưu ý: Nếu UA không phải Chrome/Chromium (ví dụ Firefox, Safari thuần),
- * hàm trả về "130" làm giá trị mặc định an toàn thay vì throw error.
- *
  * @returns Phiên bản Chrome major dạng string, ví dụ: "130", "133"
  */
 export function getChromeVersionFromUA(userAgent) {
     if (!userAgent)
-        return "133"; // Không có UA → dùng version ổn định hiện đại
+        return ZALO_DEFAULTS.BROWSER.DEFAULT_CHROME_VERSION;
     const match = userAgent.match(/Chrome\/(\d+)/);
-    return match ? match[1] : "133"; // Không phải Chrome → fallback về "133"
+    return match ? match[1] : ZALO_DEFAULTS.BROWSER.DEFAULT_CHROME_VERSION;
 }
 /**
  * Chuẩn hóa chuỗi Accept-Language dựa theo thiết lập ngôn ngữ ngữ cảnh.
@@ -275,16 +94,13 @@ export function getChromeVersionFromUA(userAgent) {
  */
 export function getBrowserLanguage(language) {
     if (language === "en") {
-        return "en-US,en;q=0.9,vi;q=0.8";
+        return ZALO_DEFAULTS.BROWSER.ACCEPT_LANGUAGE_EN;
     }
-    return "vi-VN,vi;q=0.9,en-US;q=0.8,en;q=0.7";
+    return ZALO_DEFAULTS.BROWSER.ACCEPT_LANGUAGE_VI;
 }
 /**
  * Sinh bộ header Sec-CH-UA nhất quán theo User-Agent (chỉ khi là Chromium/Chrome).
  *
- * Nếu User-Agent là Firefox/Safari, hàm sẽ trả về object rỗng nhằm tránh
- * tạo ra dị thường Browser Mismatch.
- *
  * @param userAgent Chuỗi User-Agent của client
  * @returns Record chứa các header sec-ch-ua-* hoặc object rỗng
  */
@@ -299,23 +115,36 @@ export function getSecChUaHeaders(userAgent) {
         "sec-ch-ua-platform": `"${platform}"`,
     };
 }
-export async function getDefaultHeaders(ctx, origin = "https://chat.zalo.me") {
+export async function getDefaultHeaders(ctx, origin = ZALO_DOMAINS.CHAT_WEB) {
     if (!ctx.cookie)
         throw new ZaloApiError("Cookie is not available");
     if (!ctx.userAgent)
         throw new ZaloApiError("User agent is not available");
     const secChUa = getSecChUaHeaders(ctx.userAgent);
-    return Object.assign({ accept: "*/*", "accept-encoding": "gzip, deflate, br, zstd", "accept-language": getBrowserLanguage(ctx.language), "content-type": "application/x-www-form-urlencoded", cookie: await ctx.cookie.getCookieString(origin), origin: origin, priority: "u=1, i", referer: `${origin}/`, "user-agent": ctx.userAgent, "sec-fetch-dest": "empty", "sec-fetch-mode": "cors", "sec-fetch-site": origin === "https://id.zalo.me" ? "same-origin" : "same-site" }, secChUa);
+    return {
+        accept: "*/*",
+        "accept-encoding": "gzip, deflate, br, zstd",
+        "accept-language": getBrowserLanguage(ctx.language),
+        "content-type": "application/x-www-form-urlencoded",
+        cookie: await ctx.cookie.getCookieString(origin),
+        origin: origin,
+        priority: "u=1, i",
+        referer: `${origin}/`,
+        "user-agent": ctx.userAgent,
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": origin === ZALO_DOMAINS.AUTH_ID ? "same-origin" : "same-site",
+        ...secChUa,
+    };
 }
 export async function request(ctx, url, options, raw = false) {
-    var _a, _b;
     if (!ctx.cookie)
         ctx.cookie = new toughCookie.CookieJar();
     const origin = new URL(url).origin;
     const defaultHeaders = await getDefaultHeaders(ctx, origin);
     if (!raw) {
         if (options && options.headers) {
-            const mergedHeaders = Object.assign({}, defaultHeaders);
+            const mergedHeaders = { ...defaultHeaders };
             const inputHeaders = options.headers;
             for (const [key, value] of Object.entries(inputHeaders)) {
                 const lowerKey = key.toLowerCase();
@@ -329,37 +158,36 @@ export async function request(ctx, url, options, raw = false) {
             options.headers = mergedHeaders;
         }
         else {
-            options = Object.assign(Object.assign({}, (options || {})), { headers: defaultHeaders });
+            options = { ...(options || {}), headers: defaultHeaders };
         }
     }
-    const _options = Object.assign(Object.assign({}, (options !== null && options !== void 0 ? options : {})), (isBun
-        ? {
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-            // @ts-ignore
-            proxy: (_b = (_a = ctx.options.agent) === null || _a === void 0 ? void 0 : _a.proxy) === null || _b === void 0 ? void 0 : _b.href,
-        }
-        : {
-            agent: ctx.options.agent,
-            // Hỗ trợ Undici Dispatcher cho Node.js 18+ native fetch
-            dispatcher: ctx.options.agent,
-        }));
+    const _options = {
+        ...(options ?? {}),
+        ...(isBun
+            ? {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                proxy: ctx.options.agent?.proxy?.href,
+            }
+            : {
+                agent: ctx.options.agent,
+                dispatcher: ctx.options.agent,
+            }),
+    };
     const response = await ctx.options.polyfill(url, _options);
     const setCookieRaw = response.headers.get("set-cookie");
     if (setCookieRaw && !raw) {
         let cookieStrings = [];
         const headers = response.headers;
-        // Cách 1: Ưu tiên lấy Mảng Raw chuẩn gốc (Array) của thư viện node-fetch
         if (typeof headers.raw === "function") {
             const rawHeaders = headers.raw();
             if (rawHeaders && rawHeaders["set-cookie"]) {
                 cookieStrings = rawHeaders["set-cookie"];
             }
         }
-        // Cách 2: Nếu dùng Fetch API Native của NodeJS 18+
         else if (typeof headers.getSetCookie === "function") {
             cookieStrings = headers.getSetCookie();
         }
-        // Cách 3: Fallback dùng Regex Lookahead an toàn (Không bao giờ tách nhầm dấu phẩy của Expires date)
         else {
             cookieStrings = setCookieRaw.split(/,\s*(?=[a-zA-Z0-9_-]+\s*=)/);
         }
@@ -376,11 +204,11 @@ export async function request(ctx, url, options, raw = false) {
     }
     const redirectURL = response.headers.get("location");
     if (redirectURL) {
-        const redirectOptions = Object.assign({}, options);
+        const redirectOptions = { ...options };
         redirectOptions.method = "GET";
         if (!raw) {
             redirectOptions.headers = new Headers(redirectOptions.headers);
-            redirectOptions.headers.set("Referer", "https://id.zalo.me/");
+            redirectOptions.headers.set("Referer", `${ZALO_DOMAINS.AUTH_ID}/`);
         }
         return await request(ctx, redirectURL, redirectOptions);
     }
@@ -421,49 +249,11 @@ export async function getGifMetaData(ctx, filePath) {
         height: gifData.height,
     };
 }
-export async function decodeEventData(parsed, cipherKey) {
-    if (typeof parsed.data !== "string")
-        throw new ZaloApiError(`Invalid data, expected string but got ${typeof parsed.data}`);
-    if (typeof parsed.encrypt !== "number")
-        throw new ZaloApiError(`Invalid encrypt type, expected number but got ${typeof parsed.encrypt}`);
-    if (parsed.encrypt < 0 || parsed.encrypt > 3)
-        throw new 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("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);
-}
 export async function getMd5LargeFileObject(source, fileSize) {
     const buffer = typeof source == "string" ? await fs.promises.readFile(source) : source.data;
     return new Promise((resolve) => {
         let currentChunk = 0;
-        const chunkSize = 2097152, // Read in chunks of 2MB
-        chunks = Math.ceil(fileSize / chunkSize), spark = new SparkMD5.ArrayBuffer();
+        const chunkSize = ZALO_DEFAULTS.UPLOAD.MD5_CHUNK_SIZE_BYTES, chunks = Math.ceil(fileSize / chunkSize), spark = new SparkMD5.ArrayBuffer();
         function loadNext() {
             const start = currentChunk * chunkSize, end = start + chunkSize >= fileSize ? fileSize : start + chunkSize;
             spark.append(new Uint8Array(buffer.subarray(start, end)).buffer);
@@ -522,9 +312,9 @@ export function getClientMessageType(msgType) {
     if (msgType === "chat.recommended")
         return 38;
     if (msgType === "chat.link")
-        return 38; // don't know || if (msgType === "chat.link") return 1;
+        return 38;
     if (msgType === "chat.video.msg")
-        return 44; // not sure
+        return 44;
     if (msgType === "share.file")
         return 46;
     if (msgType === "chat.gif")
@@ -539,7 +329,6 @@ export function strPadLeft(e, t, n) {
 }
 export function formatTime(format, timestamp = Date.now()) {
     const date = new Date(timestamp);
-    // using lib Intl
     const options = {
         year: "numeric",
         month: "2-digit",
@@ -547,7 +336,6 @@ export function formatTime(format, timestamp = Date.now()) {
         hour: "2-digit",
         minute: "2-digit",
         second: "2-digit",
-        // hour12: false, // true or false is same <(")
     };
     const formatted = new Intl.DateTimeFormat("vi-VN", options).format(date);
     if (format.includes("%H") || format.includes("%d")) {
@@ -739,47 +527,15 @@ export function apiFactory() {
 export function generateZaloUUID(userAgent) {
     return crypto.randomUUID() + "-" + cryptojs.MD5(userAgent).toString();
 }
-/**
- * Encrypts a 4-digit PIN to a 32-character hex string
- * @param pin 4-digit PIN number
- * @returns 32-character hex string
- */
-export function encryptPin(pin) {
-    return crypto.createHash("md5").update(pin).digest("hex");
-}
-/**
- * Decrypts a 32-character hex string back to 4-digit PIN
- * Note: This is a one-way hash, so we can only verify if a PIN matches the hash
- * @param encryptedPin 32-character hex string
- * @param pin 4-digit PIN to verify
- * @returns true if the PIN matches the hash
- *
- * @example
- * const encryptedPin = (await api.getHiddenConversations()).pin;
- * checking pin created..
- * const isValid = validatePin(encryptedPin, "1234"); // true if pin created is 1234
- * const isInvalid = validatePin(encryptedPin, "5678"); // false if not pin created is 5678
- */
-export function validatePin(encryptedPin, pin) {
-    const hash = crypto.createHash("md5").update(pin).digest("hex");
-    return hash === encryptedPin;
-}
 /**
  * Converts a hex color code to a negative color number used by Zalo API
  * @param hex Hex color code (e.g. '#00FF00' or '00FF00')
  * @returns Negative color number (e.g. -16711936)
- *
- * @example
- * const negativeColor = hexToNegativeColor('#00FF00'); // Result: -16711936
  */
 export function hexToNegativeColor(hex) {
     if (!hex.startsWith("#")) {
         hex = "#" + hex;
     }
-    // rgb no alpha
-    // const decimal = parseInt(hex.slice(1), 16);
-    // return decimal - 4294967296;
-    // rgb with alpha
     let hexValue = hex.slice(1);
     if (hexValue.length === 6) {
         hexValue = "FF" + hexValue;
@@ -791,15 +547,10 @@ export function hexToNegativeColor(hex) {
  * Converts a negative color number from Zalo API to hex color code
  * @param negativeColor Negative color number (e.g. -16711936)
  * @returns Hex color code (e.g. '#00FF00')
- *
- * @example
- * const hexColor = negativeColorToHex(-16711936); // Result: '#00FF00'
  */
 export function negativeColorToHex(negativeColor) {
-    // Add 2^32 to get positive number
     const positiveColor = negativeColor + 4294967296;
-    // return "#" + positiveColor.toString(16).padStart(6, "0"); // rgb no alpha
-    return "#" + positiveColor.toString(16).slice(-6).padStart(6, "0"); // rgb with alpha
+    return "#" + positiveColor.toString(16).slice(-6).padStart(6, "0");
 }
 export function normalizeHolderName(input) {
     if (!input)
@@ -813,171 +564,3 @@ export function normalizeHolderName(input) {
         .trim();
     return normalized.length >= 5 ? normalized : undefined;
 }
-/**
- * Generates an RSA 2048-bit key pair for mobile message synchronization (`pull_mobile_msg`)
- * @returns Object containing public and private keys in both PEM and Base64 formats
- */
-export function generateRSAKeyPair() {
-    const { publicKey, privateKey } = crypto.generateKeyPairSync("rsa", {
-        modulusLength: 2048,
-        publicKeyEncoding: { type: "spki", format: "pem" },
-        privateKeyEncoding: { type: "pkcs8", format: "pem" },
-    });
-    const publicKeyBase64 = publicKey
-        .toString()
-        .replace(/-----BEGIN PUBLIC KEY-----/g, "")
-        .replace(/-----END PUBLIC KEY-----/g, "")
-        .replace(/\s+/g, "");
-    const privateKeyBase64 = privateKey
-        .toString()
-        .replace(/-----BEGIN PRIVATE KEY-----/g, "")
-        .replace(/-----END PRIVATE KEY-----/g, "")
-        .replace(/\s+/g, "");
-    return { publicKeyBase64, privateKeyBase64, publicKey: publicKey.toString(), privateKey: privateKey.toString() };
-}
-function b64urlToBigInt(value) {
-    return BigInt("0x" + Buffer.from(value, "base64url").toString("hex"));
-}
-function modPow(base, exp, mod) {
-    const zero = BigInt(0);
-    const one = BigInt(1);
-    let result = one;
-    base %= mod;
-    while (exp > zero) {
-        if (exp & one)
-            result = (result * base) % mod;
-        base = (base * base) % mod;
-        exp >>= one;
-    }
-    return result;
-}
-/**
- * Pure-BigInt RSA CRT PKCS#1 v1.5 decryption fallback for Node.js environments
- * where OpenSSL blocks `RSA_PKCS1_PADDING` in `crypto.privateDecrypt` (CVE-2023-46809).
- */
-export function rsaDecryptPkcs1Manual(privateKeyPem, cipher) {
-    const jwk = crypto.createPrivateKey(privateKeyPem).export({ format: "jwk" });
-    const n = b64urlToBigInt(jwk.n);
-    const p = b64urlToBigInt(jwk.p);
-    const q = b64urlToBigInt(jwk.q);
-    const dp = b64urlToBigInt(jwk.dp);
-    const dq = b64urlToBigInt(jwk.dq);
-    const qi = b64urlToBigInt(jwk.qi);
-    const c = BigInt("0x" + cipher.toString("hex"));
-    const m1 = modPow(c, dp, p);
-    const m2 = modPow(c, dq, q);
-    const h = (qi * (((m1 - m2) % p) + p)) % p;
-    const m = m2 + h * q;
-    const k = Math.ceil(n.toString(16).length / 2);
-    const em = Buffer.from(m.toString(16).padStart(k * 2, "0"), "hex");
-    if (em[0] !== 0x00 || em[1] !== 0x02)
-        throw new ZaloApiError("Invalid RSA PKCS#1 v1.5 padding");
-    const sep = em.indexOf(0x00, 2);
-    if (sep < 10)
-        throw new ZaloApiError("Invalid RSA PKCS#1 v1.5 padding separator");
-    return em.subarray(sep + 1);
-}
-/**
- * Decrypt `encrypted_key` from `syncmsg_info` using RSA private key with PKCS#1 v1.5 scheme.
- * Automatically falls back to pure-BigInt CRT decryption if OpenSSL disables `RSA_PKCS1_PADDING`.
- *
- * @param privateKey - RSA private key in PEM format
- * @param encryptedBase64 - Base64 encoded `encrypted_key` from `syncmsg_info`
- * @returns Raw decrypted bytes (typically 16-32 bytes; use `deriveZdbAesKey` for ZDB4.0 AES-256-CBC key)
- */
-export function decryptWithPrivateKey(privateKey, encryptedBase64) {
-    const cleanKey = privateKey.replace(/\\n/g, "\n");
-    const encryptedBuffer = Buffer.from(encryptedBase64, "base64");
-    try {
-        return crypto.privateDecrypt({
-            key: cleanKey,
-            padding: crypto.constants.RSA_PKCS1_PADDING,
-        }, encryptedBuffer);
-    }
-    catch (err) {
-        const errorObj = err;
-        const code = String((errorObj === null || errorObj === void 0 ? void 0 : errorObj.code) || "");
-        const msg = String((errorObj === null || errorObj === void 0 ? void 0 : errorObj.message) || "");
-        if (code.includes("INVALID_ARG") || /RSA_PKCS1_PADDING|security-revert|not supported/i.test(msg)) {
-            return rsaDecryptPkcs1Manual(cleanKey, encryptedBuffer);
-        }
-        throw err;
-    }
-}
-/**
- * Derives the 32-byte AES-256-CBC key for Zalo ZDB4.0 (`.db.crypt`) backup files
- * from the raw RSA-decrypted bytes: first 32 uppercase hex characters as ASCII bytes.
- */
-export function deriveZdbAesKey(decryptedRsaBytes) {
-    const upperHex = decryptedRsaBytes.toString("hex").toUpperCase();
-    if (upperHex.length < 32) {
-        throw new ZaloApiError(`Decrypted RSA key hex is too short (${upperHex.length} chars, expected >= 32)`);
-    }
-    return Buffer.from(upperHex.slice(0, 32), "ascii");
-}
-/**
- * Decrypts a Zalo ZDB4.0 (`.db.crypt`) backup buffer into its plaintext ZDB4.0 container
- * (header + table of contents + XZ stream) using 64KB independent AES-256-CBC chunks (`IV = 0`).
- */
-export function decryptZdbBuffer(zdbBuffer, aesKey) {
-    const ZDB_MAGIC = Buffer.from("ZDB4.0", "ascii");
-    const CHUNK_SIZE = 0x10000;
-    const zeroIv = Buffer.alloc(16, 0);
-    for (const startOffset of [0, 4]) {
-        const encryptedLength = Math.floor((zdbBuffer.length - startOffset) / 16) * 16;
-        if (encryptedLength < 16)
-            continue;
-        const firstChunkLen = Math.min(CHUNK_SIZE, encryptedLength);
-        const firstDecipher = crypto.createDecipheriv("aes-256-cbc", aesKey, zeroIv);
-        firstDecipher.setAutoPadding(false);
-        const firstPlain = Buffer.concat([
-            firstDecipher.update(zdbBuffer.subarray(startOffset, startOffset + firstChunkLen)),
-            firstDecipher.final(),
-        ]);
-        if (!firstPlain.subarray(0, ZDB_MAGIC.length).equals(ZDB_MAGIC)) {
-            continue;
-        }
-        const chunks = [firstPlain];
-        for (let offset = CHUNK_SIZE; offset < encryptedLength; offset += CHUNK_SIZE) {
-            const len = Math.min(CHUNK_SIZE, encryptedLength - offset);
-            const decipher = crypto.createDecipheriv("aes-256-cbc", aesKey, zeroIv);
-            decipher.setAutoPadding(false);
-            chunks.push(Buffer.concat([
-                decipher.update(zdbBuffer.subarray(startOffset + offset, startOffset + offset + len)),
-                decipher.final(),
-            ]));
-        }
-        return Buffer.concat(chunks);
-    }
-    throw new ZaloApiError("Invalid AES key or buffer is not in ZDB4.0 format");
-}
-/**
- * Parses the Table of Contents (TOC) from a decrypted ZDB4.0 container buffer,
- * returning the list of SQLite `.db` files (`<uid>.db` / `group_<gid>.db`) and the byte offset where the XZ stream starts.
- */
-export function parseZdbHeader(zdbPlaintext) {
-    const ZDB_MAGIC = Buffer.from("ZDB4.0", "ascii");
-    const COUNT_OFFSET = 14;
-    if (zdbPlaintext.length < COUNT_OFFSET + 4 || !zdbPlaintext.subarray(0, ZDB_MAGIC.length).equals(ZDB_MAGIC)) {
-        throw new ZaloApiError("Buffer is not a valid decrypted ZDB4.0 container");
-    }
-    const count = zdbPlaintext.readUInt32BE(COUNT_OFFSET);
-    let offset = COUNT_OFFSET + 4;
-    const entries = [];
-    for (let i = 0; i < count; i++) {
-        if (offset + 4 > zdbPlaintext.length) {
-            throw new ZaloApiError("Truncated ZDB4.0 header while reading entry name length");
-        }
-        const nameLen = zdbPlaintext.readUInt32BE(offset);
-        if (offset + 4 + nameLen + 4 > zdbPlaintext.length) {
-            throw new ZaloApiError("Truncated ZDB4.0 header while reading entry metadata");
-        }
-        const name = zdbPlaintext
-            .toString("utf8", offset + 4, offset + 4 + nameLen)
-            .replace(/\0+$/, "");
-        const size = zdbPlaintext.readUInt32BE(offset + 4 + nameLen);
-        entries.push({ name, size });
-        offset += 4 + nameLen + 4;
-    }
-    return { entries, xzOffset: offset };
-}