@lazyneoaz/testfca 1.0.0

package/src/utils/user-agents.js

@@ -0,0 +1,238 @@
+"use strict";
+const { getRandom } = require("./constants");
+
+const BROWSER_DATA = {
+    windows: {
+        platform: "Windows NT 10.0; Win64; x64",
+        chromeVersions: ["139.0.0.0", "131.0.6778.86", "130.0.6723.92", "129.0.6668.101", "128.0.6613.120", "127.0.6533.120"],
+        edgeVersions: ["139.0.0.0", "131.0.2903.51", "130.0.2849.68", "129.0.2792.89"],
+        platformVersion: '"15.0.0"'
+    },
+    mac: {
+        platform: "Macintosh; Intel Mac OS X 10_15_7",
+        chromeVersions: ["139.0.0.0", "131.0.6778.86", "130.0.6723.92", "129.0.6668.101", "128.0.6613.120", "127.0.6533.120"],
+        edgeVersions: ["139.0.0.0", "131.0.2903.51", "130.0.2849.68", "129.0.2792.89"],
+        platformVersion: '"14.7.0"'
+    },
+    linux: {
+        platform: "X11; Linux x86_64",
+        chromeVersions: ["139.0.0.0", "131.0.6778.86", "130.0.6723.92", "129.0.6668.101", "128.0.6613.120"],
+        edgeVersions: ["139.0.0.0", "131.0.2903.51", "130.0.2849.68"],
+        platformVersion: '""'
+    }
+};
+
+const defaultUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36";
+
+/**
+ * Generates a realistic, randomized User-Agent string and related Sec-CH headers.
+ * Supports Chrome and Edge browsers across Windows, macOS, and Linux.
+ * @returns {{userAgent: string, secChUa: string, secChUaFullVersionList: string, secChUaPlatform: string, secChUaPlatformVersion: string, browser: string}}
+ */
+function randomUserAgent() {
+    const os = getRandom(Object.keys(BROWSER_DATA));
+    const data = BROWSER_DATA[os];
+
+    const useEdge = Math.random() > 0.7 && data.edgeVersions;
+    const versions = useEdge ? data.edgeVersions : data.chromeVersions;
+    const version = getRandom(versions);
+    const majorVersion = version.split('.')[0];
+    const browserName = useEdge ? 'Microsoft Edge' : 'Google Chrome';
+    const browserIdentifier = useEdge ? 'Edg' : 'Chrome';
+
+    const userAgent = useEdge 
+        ? `Mozilla/5.0 (${data.platform}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${version} Safari/537.36 Edg/${version}`
+        : `Mozilla/5.0 (${data.platform}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${version} Safari/537.36`;
+
+    const greeseValue = Math.random() > 0.5 ? '99' : '8';
+    const brands = useEdge ? [
+        `"Chromium";v="${majorVersion}"`,
+        `"Not(A:Brand";v="${greeseValue}"`,
+        `"${browserName}";v="${majorVersion}"`
+    ] : [
+        `"${browserName}";v="${majorVersion}"`,
+        `"Not;A=Brand";v="${greeseValue}"`,
+        `"Chromium";v="${majorVersion}"`
+    ];
+
+    const secChUa = brands.join(', ');
+    const secChUaFullVersionList = brands.map(b => {
+        const match = b.match(/v="(\d+)"/);
+        if (match && match[1] === majorVersion) {
+            return b.replace(`v="${majorVersion}"`, `v="${version}"`);
+        }
+        return b;
+    }).join(', ');
+
+    const platformName = os === 'windows' ? 'Windows' : os === 'mac' ? 'macOS' : 'Linux';
+
+    return {
+        userAgent,
+        secChUa,
+        secChUaFullVersionList,
+        secChUaPlatform: `"${platformName}"`,
+        secChUaPlatformVersion: data.platformVersion,
+        browser: browserName
+    };
+}
+
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function randomChoice(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function randomBuildId() {
+    const prefixes = ["QP1A", "RP1A", "SP1A", "TP1A", "UP1A", "AP4A"];
+    return `${randomChoice(prefixes)}.${randomInt(180000, 250000)}.${randomInt(10, 99)}`;
+}
+
+function randomResolution() {
+    const presets = [
+        { width: 720, height: 1280, density: 2.0 },
+        { width: 1080, height: 1920, density: 2.625 },
+        { width: 1080, height: 2400, density: 3.0 },
+        { width: 1440, height: 3040, density: 3.5 },
+        { width: 1440, height: 3200, density: 4.0 }
+    ];
+    return randomChoice(presets);
+}
+
+function randomFbav() {
+    return `${randomInt(390, 499)}.${randomInt(0, 3)}.${randomInt(0, 2)}.${randomInt(10, 60)}.${randomInt(100, 999)}`;
+}
+
+function randomOrcaUA() {
+    const androidVersions = ["8.1.0", "9", "10", "11", "12", "13", "14"];
+    const devices = [
+        { brand: "samsung", model: "SM-G996B" },
+        { brand: "samsung", model: "SM-S908E" },
+        { brand: "Xiaomi", model: "M2101K9AG" },
+        { brand: "OPPO", model: "CPH2219" },
+        { brand: "vivo", model: "V2109" },
+        { brand: "HUAWEI", model: "VOG-L29" },
+        { brand: "asus", model: "ASUS_I001DA" },
+        { brand: "Google", model: "Pixel 6" },
+        { brand: "realme", model: "RMX2170" }
+    ];
+    const carriers = [
+        "Viettel Telecom", "Mobifone", "Vinaphone",
+        "T-Mobile", "Verizon", "AT&T",
+        "Telkomsel", "Jio", "NTT DOCOMO",
+        "Vodafone", "Orange"
+    ];
+    const locales = [
+        "vi_VN", "en_US", "en_GB", "id_ID",
+        "th_TH", "fr_FR", "de_DE", "es_ES", "pt_BR"
+    ];
+    const archs = ["arm64-v8a", "armeabi-v7a"];
+
+    const androidVersion = randomChoice(androidVersions);
+    const device = randomChoice(devices);
+    const buildId = randomBuildId();
+    const resolution = randomResolution();
+    const fbav = randomFbav();
+    const fbbv = randomInt(320000000, 520000000);
+    const arch = `${randomChoice(archs)}:${randomChoice(archs)}`;
+    const selectedLocale = randomChoice(locales);
+    const selectedCarrier = randomChoice(carriers);
+
+    const userAgent = `Dalvik/2.1.0 (Linux; U; Android ${androidVersion}; ${device.model} Build/${buildId}) ` +
+        `[FBAN/Orca-Android;FBAV/${fbav};FBPN/com.facebook.orca;` +
+        `FBLC/${selectedLocale};FBBV/${fbbv};FBCR/${selectedCarrier};` +
+        `FBMF/${device.brand};FBBD/${device.brand};FBDV/${device.model};` +
+        `FBSV/${androidVersion};FBCA/${arch};` +
+        `FBDM/{density=${resolution.density.toFixed(1)},width=${resolution.width},height=${resolution.height}};` +
+        `FB_FW/1;]`;
+
+    return {
+        userAgent,
+        androidVersion,
+        device,
+        buildId,
+        resolution,
+        fbav,
+        fbbv,
+        locale: selectedLocale,
+        carrier: selectedCarrier
+    };
+}
+
+function generateUserAgentByPersona(persona = 'desktop', options = {}) {
+    if (persona === 'android' || persona === 'mobile') {
+        if (options.cachedAndroidUA && options.cachedAndroidDevice) {
+            return {
+                userAgent: options.cachedAndroidUA,
+                androidVersion: options.cachedAndroidVersion,
+                device: options.cachedAndroidDevice,
+                buildId: options.cachedAndroidBuildId,
+                resolution: options.cachedAndroidResolution,
+                fbav: options.cachedAndroidFbav,
+                fbbv: options.cachedAndroidFbbv,
+                locale: options.cachedAndroidLocale,
+                carrier: options.cachedAndroidCarrier,
+                persona: 'android'
+            };
+        }
+
+        const androidData = randomOrcaUA();
+        return {
+            ...androidData,
+            persona: 'android'
+        };
+    }
+
+    if (options.cachedUserAgent && options.cachedSecChUa) {
+        return {
+            userAgent: options.cachedUserAgent,
+            secChUa: options.cachedSecChUa,
+            secChUaFullVersionList: options.cachedSecChUaFullVersionList,
+            secChUaPlatform: options.cachedSecChUaPlatform,
+            secChUaPlatformVersion: options.cachedSecChUaPlatformVersion,
+            browser: options.cachedBrowser || 'Google Chrome',
+            persona: 'desktop'
+        };
+    }
+
+    const desktopData = randomUserAgent();
+    return {
+        ...desktopData,
+        persona: 'desktop'
+    };
+}
+
+function cachePersonaData(options, personaData) {
+    if (personaData.persona === 'android') {
+        options.cachedAndroidUA = personaData.userAgent;
+        options.cachedAndroidVersion = personaData.androidVersion;
+        options.cachedAndroidDevice = personaData.device;
+        options.cachedAndroidBuildId = personaData.buildId;
+        options.cachedAndroidResolution = personaData.resolution;
+        options.cachedAndroidFbav = personaData.fbav;
+        options.cachedAndroidFbbv = personaData.fbbv;
+        options.cachedAndroidLocale = personaData.locale;
+        options.cachedAndroidCarrier = personaData.carrier;
+    } else {
+        options.cachedUserAgent = personaData.userAgent;
+        options.cachedSecChUa = personaData.secChUa;
+        options.cachedSecChUaFullVersionList = personaData.secChUaFullVersionList;
+        options.cachedSecChUaPlatform = personaData.secChUaPlatform;
+        options.cachedSecChUaPlatformVersion = personaData.secChUaPlatformVersion;
+        options.cachedBrowser = personaData.browser;
+    }
+    return options;
+}
+
+module.exports = {
+    defaultUserAgent,
+    windowsUserAgent: defaultUserAgent,
+    randomUserAgent,
+    randomBuildId,
+    randomResolution,
+    randomFbav,
+    randomOrcaUA,
+    generateUserAgentByPersona,
+    cachePersonaData,
+};

package/src/utils/validation.js

@@ -0,0 +1,157 @@
+"use strict";
+
+/**
+ * Input validation and sanitization utilities
+ */
+
+class InputValidator {
+  constructor() {
+    this.maxMessageLength = 10000;
+    this.maxThreadNameLength = 255;
+    this.maxNicknameLength = 50;
+  }
+
+  /**
+   * Validate thread ID
+   * @param {string|number} threadID
+   * @returns {boolean}
+   */
+  isValidThreadID(threadID) {
+    if (!threadID) return false;
+    const id = String(threadID).trim();
+    // Thread IDs are numeric, can be up to 20 digits
+    return /^\d{1,20}$/.test(id);
+  }
+
+  /**
+   * Validate user ID
+   * @param {string|number} userID
+   * @returns {boolean}
+   */
+  isValidUserID(userID) {
+    return this.isValidThreadID(userID); // Same format
+  }
+
+  /**
+   * Validate message content
+   * @param {string|object} message
+   * @returns {boolean}
+   */
+  isValidMessage(message) {
+    if (typeof message === 'string') {
+      return message.length > 0 && message.length <= this.maxMessageLength;
+    }
+    if (typeof message === 'object' && message !== null) {
+      return message.body || message.sticker || message.attachment || message.emoji;
+    }
+    return false;
+  }
+
+  /**
+   * Sanitize message content
+   * @param {string} message
+   * @returns {string}
+   */
+  sanitizeMessage(message) {
+    if (typeof message !== 'string') return message;
+    // Remove null bytes and control characters
+    return message.replace(/[\x00-\x1F\x7F]/g, '').trim();
+  }
+
+  /**
+   * Validate and sanitize thread name
+   * @param {string} name
+   * @returns {string|null}
+   */
+  sanitizeThreadName(name) {
+    if (typeof name !== 'string') return null;
+    const sanitized = name.trim();
+    return sanitized.length > 0 && sanitized.length <= this.maxThreadNameLength ? sanitized : null;
+  }
+
+  /**
+   * Validate and sanitize nickname
+   * @param {string} nickname
+   * @returns {string|null}
+   */
+  sanitizeNickname(nickname) {
+    if (typeof nickname !== 'string') return null;
+    const sanitized = nickname.trim();
+    return sanitized.length > 0 && sanitized.length <= this.maxNicknameLength ? sanitized : null;
+  }
+
+  /**
+   * Validate array of IDs
+   * @param {Array} ids
+   * @param {function} validator
+   * @returns {boolean}
+   */
+  validateIDArray(ids, validator = this.isValidThreadID.bind(this)) {
+    if (!Array.isArray(ids)) return false;
+    return ids.length > 0 && ids.length <= 100 && ids.every(validator);
+  }
+
+  /**
+   * Validate email
+   * @param {string} email
+   * @returns {boolean}
+   */
+  isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+  }
+
+  /**
+   * Validate URL
+   * @param {string} url
+   * @returns {boolean}
+   */
+  isValidUrl(url) {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Validate file path (basic check)
+   * @param {string} path
+   * @returns {boolean}
+   */
+  isValidFilePath(path) {
+    if (typeof path !== 'string') return false;
+    // Basic check - no null bytes, reasonable length
+    return path.length > 0 && path.length <= 255 && !path.includes('\x00');
+  }
+
+  /**
+   * Validate emoji
+   * @param {string} emoji
+   * @returns {boolean}
+   */
+  isValidEmoji(emoji) {
+    if (typeof emoji !== 'string') return false;
+    // Check if it's an emoji (basic check)
+    return /\p{Emoji}/u.test(emoji) || emoji.length === 1;
+  }
+}
+
+const globalValidator = new InputValidator();
+
+module.exports = {
+  InputValidator,
+  globalValidator,
+  validateThreadID: (id) => globalValidator.isValidThreadID(id),
+  validateUserID: (id) => globalValidator.isValidUserID(id),
+  validateMessage: (msg) => globalValidator.isValidMessage(msg),
+  sanitizeMessage: (msg) => globalValidator.sanitizeMessage(msg),
+  sanitizeThreadName: (name) => globalValidator.sanitizeThreadName(name),
+  sanitizeNickname: (nick) => globalValidator.sanitizeNickname(nick),
+  validateIDArray: (ids, validator) => globalValidator.validateIDArray(ids, validator),
+  isValidEmail: (email) => globalValidator.isValidEmail(email),
+  isValidUrl: (url) => globalValidator.isValidUrl(url),
+  isValidFilePath: (path) => globalValidator.isValidFilePath(path),
+  isValidEmoji: (emoji) => globalValidator.isValidEmoji(emoji)
+};