@mattywhite/skyscanner-api 1.0.0

package/src/px.js

@@ -0,0 +1,286 @@
+const crypto = require('crypto');
+const axios = require('axios');
+const config = require('./config');
+const { PerimeterXError } = require('./errors');
+const fs = require('fs');
+
+class ParseAppc {
+    constructor(appc) {
+        if (appc.length < 10) {
+            throw new PerimeterXError("Cannot parse AppC challenge, must be at least 10");
+        }
+        this.timestamp = parseInt(appc[2]);
+        this.hash = appc[3];
+        this.f24f = parseInt(appc[4]);
+        this.f25g = parseInt(appc[5]);
+        this.f21c = parseInt(appc[6]);
+        this.f22d = parseInt(appc[7]);
+        this.f23e = parseInt(appc[8]);
+        this.f26h = parseInt(appc[9]);
+    }
+
+    static a(i10, i11, i12, i13) {
+        const i14 = i13 % 10;
+        const i15 = i14 !== 0 ? i12 % i14 : i12 % 10;
+        const i16 = i10 * i10;
+        const i17 = i11 * i11;
+
+        switch (i15) {
+            case 0: return i16 + i11;
+            case 1: return i10 + i17;
+            case 2: return i16 * i11;
+            case 3: return i10 ^ i11;
+            case 4: return i10 - i17;
+            case 5:
+                const i18 = i10 + 783;
+                return (i18 * i18) + i17;
+            case 6: return (i10 ^ i11) + i11;
+            case 7: return i16 - i17;
+            case 8: return i10 * i11;
+            case 9: return (i11 * i10) - i10;
+            default: return -1;
+        }
+    }
+
+    encode(string1) {
+        const a10 = ParseAppc.a(
+            ParseAppc.a(this.f21c, this.f22d, this.f24f, this.f26h),
+            this.f23e,
+            this.f25g,
+            this.f26h
+        );
+
+        let intValue = 0;
+        try {
+            const buffer = Buffer.from(string1, 'utf-8');
+            if (buffer.length >= 4) {
+                intValue = buffer.readInt32BE(0);
+            }
+        } catch (e) {
+            intValue = 0;
+        }
+
+        return intValue ^ a10;
+    }
+}
+
+class PXSolver {
+    constructor(proxy = '', verify = true) {
+        this.proxy = proxy;
+        this.verify = verify;
+        this.deviceData = null;
+
+        this.headers = {
+            'Host': 'collector-pxrf8vapwa.perimeterx.net',
+            'User-Agent': 'PerimeterX Android SDK/3.4.4',
+            'Accept-Charset': 'UTF-8',
+            'Accept': '*/*',
+            'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8',
+            'Connection': 'keep-alive',
+        };
+    }
+
+    getDeviceData() {
+        if (this.deviceData) {
+            return this.deviceData;
+        }
+        const data = fs.readFileSync(config.PX_DEVICE_DATA_PATH, 'utf-8');
+        this.deviceData = JSON.parse(data);
+        return this.deviceData;
+    }
+
+    getFingerprint() {
+        const devices = this.getDeviceData();
+        return devices[Math.floor(Math.random() * devices.length)];
+    }
+
+    batteryPercentageToVoltage(percentage) {
+        if (percentage < 0 || percentage > 100) {
+            throw new Error("Percentage must be between 0 and 100.");
+        }
+        let voltage;
+        if (percentage <= 10) {
+            voltage = 3.0 + (percentage / 10) * 0.3;
+        } else if (percentage <= 70) {
+            voltage = 3.3 + ((percentage - 10) / 60) * 0.6;
+        } else {
+            voltage = 3.9 + ((percentage - 70) / 30) * 0.3;
+        }
+        return Math.round(voltage * 100) / 100;
+    }
+
+    randomHex(length) {
+        return crypto.randomBytes(length).toString('hex');
+    }
+
+    generateUUID() {
+        return crypto.randomUUID();
+    }
+
+    async genPxAuthorization() {
+        const fingerprint = this.getFingerprint();
+        const [auth, uuid] = await this.genPx(fingerprint);
+        return [auth, uuid];
+    }
+
+    async genPx(fingerprint) {
+        const PX326 = this.generateUUID();
+        const PX327 = PX326.split("-")[0].toUpperCase();
+        const batteryPercentage = Math.floor(Math.random() * (90 - 15 + 1)) + 15;
+        const connType = Math.random() > 0.5 ? "WiFi" : "Mobile";
+        const batteryStatus = ["charging", "discharging", "not charging"][Math.floor(Math.random() * 3)];
+
+        const fingerprintData = [
+            {
+                "t": "PX315",
+                "d": {
+                    "PX330": "new_session",
+                    "PX1214": this.randomHex(8),
+                    "PX91": fingerprint.height,
+                    "PX92": fingerprint.width,
+                    "PX21215": Math.floor(Math.random() * (255 - 150 + 1)) + 150,
+                    "PX316": true,
+                    "PX318": String(fingerprint.sdk_int),
+                    "PX319": fingerprint.os_version,
+                    "PX320": fingerprint.model,
+                    "PX339": fingerprint.brand,
+                    "PX321": fingerprint.build_device,
+                    "PX323": Math.floor(Date.now() / 1000),
+                    "PX322": "Android",
+                    "PX337": true,
+                    "PX336": true,
+                    "PX335": true,
+                    "PX334": true,
+                    "PX333": true,
+                    "PX331": true,
+                    "PX332": true,
+                    "PX421": "false",
+                    "PX442": "false",
+                    "PX21218": "[]",
+                    "PX21217": "[]",
+                    "PX21224": "true",
+                    "PX21221": "true",
+                    "PX317": connType,
+                    "PX344": "Android",
+                    "PX347": '["en_US"]',
+                    "PX343": "Unknown",
+                    "PX415": batteryPercentage,
+                    "PX413": "unknown",
+                    "PX416": batteryStatus !== "charging" ? "" : (Math.random() > 0.5 ? "USB" : "Wireless"),
+                    "PX414": batteryStatus,
+                    "PX419": "",
+                    "PX418": Math.round((Math.random() * (35.0 - 25.0) + 25.0) * 10) / 10,
+                    "PX420": this.batteryPercentageToVoltage(batteryPercentage),
+                    "PX340": "v3.4.4",
+                    "PX342": "7.146",
+                    "PX341": '"Skyscanner"',
+                    "PX348": "net.skyscanner.android.main",
+                    "PX1159": false,
+                    "PX345": 0,
+                    "PX351": 0,
+                    "PX326": PX326,
+                    "PX327": PX327,
+                    "PX328": crypto.createHash('sha1').update(`${fingerprint.model}${PX326}${PX327}`).digest('hex').toUpperCase(),
+                    "PX1208": "[]",
+                    "PX21219": "{}",
+                }
+            }
+        ];
+
+        const payload = Buffer.from(JSON.stringify(fingerprintData)).toString('base64');
+        const UUID = this.generateUUID();
+        const data = `payload=${payload}&uuid=${UUID}&appId=PXrf8vapwA&tag=mobile&ftag=22`;
+
+        const axiosConfig = {
+            headers: this.headers,
+            httpsAgent: this.proxy ? new (require('https-proxy-agent').HttpsProxyAgent)(this.proxy) : undefined
+        };
+
+        let firstReq;
+        try {
+            firstReq = await axios.post(
+                "https://collector-pxrf8vapwa.perimeterx.net/api/v1/collector/mobile",
+                data,
+                axiosConfig
+            );
+        } catch (error) {
+            throw new PerimeterXError(`Error while posting first payload: ${error.message}`);
+        }
+
+        if (firstReq.status !== 200) {
+            throw new PerimeterXError(`Error while posting first payload, code ${firstReq.status} message: ${firstReq.data}`);
+        }
+
+        const responseData = firstReq.data.do;
+
+        let vid = null;
+        let sid = null;
+        let appc = null;
+
+        for (const row of responseData) {
+            const args = row.split("|");
+            if (vid && sid && appc) break;
+
+            if (args[0] === "sid") {
+                sid = args[1];
+                continue;
+            }
+            if (args[0] === "vid") {
+                vid = args[1];
+                continue;
+            }
+            if (args[0] === "appc" && args.length >= 10) {
+                appc = args;
+                continue;
+            }
+        }
+
+        if (!vid || !sid || !appc) {
+            throw new PerimeterXError(`Cannot find vid, sid or appc. Data: ${responseData}`);
+        }
+
+        const encodedAppc = new ParseAppc(appc);
+        fingerprintData[0].t = 'PX329';
+        const d = fingerprintData[0].d;
+
+        delete d.PX1208;
+        delete d.PX21219;
+
+        d.PX259 = encodedAppc.timestamp;
+        d.PX256 = encodedAppc.hash;
+        d.PX257 = String(encodedAppc.encode(fingerprint.model));
+
+        d.PX1208 = '[]';
+        d.PX21219 = '{}';
+
+        const payload2 = Buffer.from(JSON.stringify(fingerprintData)).toString('base64');
+        const data2 = `payload=${payload2}&uuid=${UUID}&appId=PXrf8vapwA&tag=mobile&ftag=22&sid=${sid}&vid=${vid}`;
+
+        let secondReq;
+        try {
+            secondReq = await axios.post(
+                "https://collector-pxrf8vapwa.perimeterx.net/api/v1/collector/mobile",
+                data2,
+                axiosConfig
+            );
+        } catch (error) {
+            throw new PerimeterXError(`Error while posting second payload: ${error.message}`);
+        }
+
+        if (secondReq.status !== 200) {
+            throw new PerimeterXError(`Error while posting second payload, code ${secondReq.status} message: ${secondReq.data}`);
+        }
+
+        const finalData = secondReq.data.do;
+
+        if (finalData.length !== 1 || finalData[0].split("|")[0] !== "bake") {
+            throw new PerimeterXError(`Error parsing PX response: ${finalData}`);
+        }
+
+        const args = finalData[0].split("|");
+
+        return [`3:${args[3]}`, UUID];
+    }
+}
+
+module.exports = PXSolver;