first commit

function/common.js

@@ -0,0 +1,280 @@
+let request = require('request');
+let CryptoJS = require('crypto-js');
+let qs = require('querystring');
+let urls = require('url');
+let path = require('path');
+let notify = require('./sendNotify');
+let mainEval = require("./eval");
+let assert = require('assert');
+let jxAlgo = require("./jxAlgo");
+let config = require("./config");
+let user = {}
+try {
+    user = require("./user")
+} catch (e) {}
+class env {
+    constructor(name) {
+        this.config = { ...config,
+            ...process.env,
+            ...user,
+        };
+        this.name = name;
+        this.message = [];
+        this.sharecode = [];
+        this.code = [];
+        this.timestamp = new Date().getTime();
+        this.time = this.start = parseInt(this.timestamp / 1000);
+        this.options = {
+            'headers': {}
+        };
+        console.log(`\n🔔${this.name}, 开始!\n`)
+        console.log(`=========== 脚本执行-北京时间(UTC+8)：${new Date(new Date().getTime() + new Date().getTimezoneOffset()*60*1000 + 8*60*60*1000).toLocaleString()} ===========\n`)
+    }
+    done() {
+        let timestamp = new Date().getTime();
+        let work = ((timestamp - this.timestamp) / 1000).toFixed(2)
+        console.log(`=========================脚本执行完成,耗时${work}s============================\n`)
+        console.log(`🔔${this.name}, 结束!\n`)
+    }
+    notify(array) {
+        let text = [];
+        let type = 0
+        for (let i of array) {
+            text.push(`${i.user} -- ${i.msg}`)
+            type = i.type
+        }
+        console.log(`\n=============================开始发送提醒消息=============================`)
+        if (type == 1) {
+            for (let i of text) {
+                notify.sendNotify(this.name + "消息提醒", i)
+            }
+        } else {
+            notify.sendNotify(this.name + "消息提醒", text.join('\n'))
+        }
+    }
+    wait(t) {
+        return new Promise(e => setTimeout(e, t))
+    }
+    setOptions(params) {
+        this.options = params;
+    }
+    setCookie(cookie) {
+        this.options.headers.cookie = cookie
+    }
+    jsonParse(str) {
+        try {
+            return JSON.parse(str);
+        } catch (e) {
+            try {
+                let data = this.match([/try\s*\{\w+\s*\(([^\)]+)/, /\w+\s*\(([^\)]+)/], str)
+                return JSON.parse(data);
+            } catch (ee) {
+                try {
+                    let cb = this.match(/try\s*\{\s*(\w+)/, str)
+                    if (cb) {
+                        let func = "";
+                        let data = str.replace(cb, `func=`)
+                        eval(data);
+                        return func
+                    }
+                } catch (eee) {
+                    return str
+                }
+            }
+        }
+    }
+    curl(params, extra = '') {
+        if (typeof(params) != 'object') {
+            params = {
+                'url': params
+            }
+        }
+        params = Object.assign({ ...this.options
+        }, params);
+        params.method = params.body ? 'POST' : 'GET';
+        if (params.hasOwnProperty('cookie')) {
+            params.headers.cookie = params.cookie
+        }
+        if (params.hasOwnProperty('ua') || params.hasOwnProperty('useragent')) {
+            params.headers['user-agent'] = params.ua
+        }
+        if (params.hasOwnProperty('referer')) {
+            params.headers.referer = params.referer
+        }
+        if (params.hasOwnProperty('params')) {
+            params.url += '?' + qs.stringify(params.params)
+        }
+        if (params.hasOwnProperty('form')) {
+            params.method = 'POST'
+        }
+        return new Promise(resolve => {
+            request(params, async (err, resp, data) => {
+                try {
+                    if (params.console) {
+                        console.log(data)
+                    }
+                    this.source = this.jsonParse(data);
+                    if (extra) {
+                        this[extra] = this.source
+                    }
+                } catch (e) {
+                    console.log(e, resp)
+                } finally {
+                    resolve(data);
+                }
+            })
+        })
+    }
+    dumps(dict) {
+        return JSON.stringify(dict)
+    }
+    loads(str) {
+        return JSON.parse(str)
+    }
+    notice(msg, type = 0) {
+        this.message.push({
+            'index': this.index,
+            'user': this.user,
+            'msg': msg,
+            type
+        })
+    }
+    notices(msg, user, type = 0) {
+        this.message.push({
+            'user': user,
+            'msg': msg,
+            // 'index': index,
+            type
+        })
+    }
+    urlparse(url) {
+        return urls.parse(url, true, true)
+    }
+    md5(encryptString) {
+        return CryptoJS.MD5(encryptString).toString()
+    }
+    haskey(data, key, value) {
+        value = typeof value !== 'undefined' ? value : '';
+        var spl = key.split('.');
+        for (var i of spl) {
+            i = !isNaN(i) ? parseInt(i) : i;
+            try {
+                data = data[i];
+            } catch (error) {
+                return '';
+            }
+        }
+        if (data == undefined) {
+            return ''
+        }
+        if (value !== '') {
+            return data === value ? true : false;
+        } else {
+            return data
+        }
+    }
+    match(pattern, string) {
+        pattern = (pattern instanceof Array) ? pattern : [pattern];
+        for (let pat of pattern) {
+            // var match = string.match(pat);
+            var match = pat.exec(string)
+            if (match) {
+                var len = match.length;
+                if (len == 1) {
+                    return match;
+                } else if (len == 2) {
+                    return match[1];
+                } else {
+                    var r = [];
+                    for (let i = 1; i < len; i++) {
+                        r.push(match[i])
+                    }
+                    return r;
+                }
+                break;
+            }
+            // console.log(pat.exec(string))
+        }
+        return '';
+    }
+    matchall(pattern, string) {
+        pattern = (pattern instanceof Array) ? pattern : [pattern];
+        var match;
+        var result = [];
+        for (var pat of pattern) {
+            while ((match = pat.exec(string)) != null) {
+                var len = match.length;
+                if (len == 1) {
+                    result.push(match);
+                } else if (len == 2) {
+                    result.push(match[1]);
+                } else {
+                    var r = [];
+                    for (let i = 1; i < len; i++) {
+                        r.push(match[i])
+                    }
+                    result.push(r);
+                }
+            }
+        }
+        return result;
+    }
+    compare(property) {
+        return function(a, b) {
+            var value1 = a[property];
+            var value2 = b[property];
+            return value1 - value2;
+        }
+    }
+    filename(file, rename = '') {
+        if (!this.runfile) {
+            this.runfile = path.basename(file).replace(".js", '').replace(/-/g, '_')
+        }
+        if (rename) {
+            rename = `_${rename}`;
+        }
+        return path.basename(file).replace(".js", rename).replace(/-/g, '_');
+    }
+    rand(n, m) {
+        var random = Math.floor(Math.random() * (m - n + 1) + n);
+        return random;
+    }
+    random(arr, num) {
+        var temp_array = new Array();
+        for (var index in arr) {
+            temp_array.push(arr[index]);
+        }
+        var return_array = new Array();
+        for (var i = 0; i < num; i++) {
+            if (temp_array.length > 0) {
+                var arrIndex = Math.floor(Math.random() * temp_array.length);
+                return_array[i] = temp_array[arrIndex];
+                temp_array.splice(arrIndex, 1);
+            } else {
+                break;
+            }
+        }
+        return return_array;
+    }
+    compact(lists, keys) {
+        let array = {};
+        for (let i of keys) {
+            if (lists[i]) {
+                array[i] = lists[i];
+            }
+        }
+        return array;
+    }
+    unique(arr) {
+        return Array.from(new Set(arr));
+    }
+    end(args) {
+        return args[args.length - 1]
+    }
+}
+module.exports = {
+    env,
+    eval: mainEval,
+    assert,
+    jxAlgo,
+}

function/config.js

@@ -0,0 +1 @@
+module.exports = {"ThreadJs":[],"invokeKey":"RtKLB8euDo7KwsO0"}

function/eval.js

@@ -0,0 +1,86 @@
+function mainEval($) {
+    return `
+!(async () => {
+    jdcookie = process.env.JD_COOKIE ? process.env.JD_COOKIE.split("&") : require("./function/jdcookie").cookie;
+    cookies={
+        'all':jdcookie,
+        'help': typeof(help) != 'undefined' ? [...jdcookie].splice(0,parseInt(help)):[]
+    }
+    $.sleep=cookies['all'].length * 500
+    taskCookie=cookies['all']
+    if($.config[\`\${$.runfile}_limit\`]){
+        taskCookie = cookies['all'].slice(0,parseInt($.config[\`\${$.runfile}_limit\`]))
+    }
+    jxAlgo = new common.jxAlgo();
+    if ($.readme) {
+            console.log(\`使用说明:\\n\${$.readme}\\n以上内容仅供参考,有需求自行添加\\n\`,)
+    }
+    console.log(\`======================本次任务共\${taskCookie.length}个京东账户Cookie======================\\n\`)
+    try{
+        await prepare();
+
+        if ($.sharecode.length > 0) {
+            $.sharecode = $.sharecode.filter(d=>d && JSON.stringify(d)!='{}')
+            console.log('助力码', $.sharecode )
+        }
+    }catch(e1){console.log("初始函数不存在,将继续执行主函数Main\\n")}
+    if (typeof(main) != 'undefined') {
+        try{
+            for (let i = 0; i < taskCookie.filter(d => d).length; i++) {
+                $.cookie = taskCookie[i];
+                $.user = decodeURIComponent($.cookie.match(/pt_pin=([^;]+)/)[1])
+                $.index = parseInt(i) + 1;
+                let info = {
+                    'index': $.index,
+                    'user': $.user,
+                    'cookie': $.cookie
+                }
+                if (!$.thread) {
+                    console.log(\`\n******开始【京东账号\${$.index}】\${$.user} 任务*********\n\`);
+                }
+                if ($.config[\`\${$.runfile}_except\`] && $.config[\`\${$.runfile}_except\`].includes(\$.user)) {
+                    console.log(\`全局变量\${$.runfile}_except中配置了该账号pt_pin,跳过此次任务\`)
+                }else{
+                    $.setCookie($.cookie)
+                    try{
+                        if ($.sharecode.length > 0) {
+                            for (let smp of $.sharecode) {
+                                smp = Object.assign({ ...info}, smp);
+                                $.thread ? main(smp) : await main(smp);
+                            }
+                        }else{
+                            $.thread ? main(info) : await main(info);
+                        }
+                    }
+                    catch(em){
+                        console.log(em.message)
+                    }
+                }
+
+
+            }
+        }catch(em){console.log(em.message)}
+        if ($.thread) {
+            await $.wait($.sleep)
+        }
+    }
+    if (typeof(extra) != 'undefined') {
+        console.log(\`============================开始运行额外任务============================\`)
+        try{
+            await extra();
+        }catch(e4){console.log(e4.message)}
+    }
+})().catch((e) => {
+    console.log(e.message)
+}).finally(() => {
+    if ($.message.length > 0) {
+        $.notify($.message)
+    }
+    $.done();
+});
+
+`
+}
+module.exports = {
+    mainEval
+}

function/jdValidate.js

@@ -0,0 +1,466 @@
+const https = require('https');
+const http = require('http');
+const stream = require('stream');
+const zlib = require('zlib');
+const vm = require('vm');
+const PNG = require('png-js');
+const UA = 'jdapp;iPhone;9.4.6;14.2;965af808880443e4c1306a54afdd5d5ae771de46;network/wifi;supportApplePay/0;hasUPPay/0;hasOCPay/0;model/iPhone8,4;addressid/;supportBestPay/0;appBuild/167618;jdSupportDarkMode/0;Mozilla/5.0 (iPhone; CPU iPhone OS 14_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148;supportJDSHWK/1';
+Math.avg = function average() {
+    var sum = 0;
+    var len = this.length;
+    for (var i = 0; i < len; i++) {
+        sum += this[i];
+    }
+    return sum / len;
+};
+
+function sleep(timeout) {
+    return new Promise((resolve) => setTimeout(resolve, timeout));
+}
+class PNGDecoder extends PNG {
+    constructor(args) {
+        super(args);
+        this.pixels = [];
+    }
+    decodeToPixels() {
+        return new Promise((resolve) => {
+            this.decode((pixels) => {
+                this.pixels = pixels;
+                resolve();
+            });
+        });
+    }
+    getImageData(x, y, w, h) {
+        const {
+            pixels
+        } = this;
+        const len = w * h * 4;
+        const startIndex = x * 4 + y * (w * 4);
+        return {
+            data: pixels.slice(startIndex, startIndex + len)
+        };
+    }
+}
+const PUZZLE_GAP = 8;
+const PUZZLE_PAD = 10;
+class PuzzleRecognizer {
+    constructor(bg, patch, y) {
+        // console.log(bg);
+        const imgBg = new PNGDecoder(Buffer.from(bg, 'base64'));
+        const imgPatch = new PNGDecoder(Buffer.from(patch, 'base64'));
+        // console.log(imgBg);
+        this.bg = imgBg;
+        this.patch = imgPatch;
+        this.rawBg = bg;
+        this.rawPatch = patch;
+        this.y = y;
+        this.w = imgBg.width;
+        this.h = imgBg.height;
+    }
+    async run() {
+        await this.bg.decodeToPixels();
+        await this.patch.decodeToPixels();
+        return this.recognize();
+    }
+    recognize() {
+        const {
+            ctx,
+            w: width,
+            bg
+        } = this;
+        const {
+            width: patchWidth,
+            height: patchHeight
+        } = this.patch;
+        const posY = this.y + PUZZLE_PAD + ((patchHeight - PUZZLE_PAD) / 2) - (PUZZLE_GAP / 2);
+        // const cData = ctx.getImageData(0, a.y + 10 + 20 - 4, 360, 8).data;
+        const cData = bg.getImageData(0, posY, width, PUZZLE_GAP).data;
+        const lumas = [];
+        for (let x = 0; x < width; x++) {
+            var sum = 0;
+            // y xais
+            for (let y = 0; y < PUZZLE_GAP; y++) {
+                var idx = x * 4 + y * (width * 4);
+                var r = cData[idx];
+                var g = cData[idx + 1];
+                var b = cData[idx + 2];
+                var luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+                sum += luma;
+            }
+            lumas.push(sum / PUZZLE_GAP);
+        }
+        const n = 2; // minium macroscopic image width (px)
+        const margin = patchWidth - PUZZLE_PAD;
+        const diff = 20; // macroscopic brightness difference
+        const radius = PUZZLE_PAD;
+        for (let i = 0, len = lumas.length - 2 * 4; i < len; i++) {
+            const left = (lumas[i] + lumas[i + 1]) / n;
+            const right = (lumas[i + 2] + lumas[i + 3]) / n;
+            const mi = margin + i;
+            const mLeft = (lumas[mi] + lumas[mi + 1]) / n;
+            const mRigth = (lumas[mi + 2] + lumas[mi + 3]) / n;
+            if (left - right > diff && mLeft - mRigth < -diff) {
+                const pieces = lumas.slice(i + 2, margin + i + 2);
+                const median = pieces.sort((x1, x2) => x1 - x2)[20];
+                const avg = Math.avg(pieces);
+                // noise reducation
+                if (median > left || median > mRigth) return;
+                if (avg > 100) return;
+                // console.table({left,right,mLeft,mRigth,median});
+                // ctx.fillRect(i+n-radius, 0, 1, 360);
+                // console.log(i+n-radius);
+                return i + n - radius;
+            }
+        }
+        // not found
+        return -1;
+    }
+    runWithCanvas() {
+        const {
+            createCanvas,
+            Image
+        } = require('canvas');
+        const canvas = createCanvas();
+        const ctx = canvas.getContext('2d');
+        const imgBg = new Image();
+        const imgPatch = new Image();
+        const prefix = 'data:image/png;base64,';
+        imgBg.src = prefix + this.rawBg;
+        imgPatch.src = prefix + this.rawPatch;
+        const {
+            naturalWidth: w,
+            naturalHeight: h
+        } = imgBg;
+        canvas.width = w;
+        canvas.height = h;
+        ctx.clearRect(0, 0, w, h);
+        ctx.drawImage(imgBg, 0, 0, w, h);
+        const width = w;
+        const {
+            naturalWidth,
+            naturalHeight
+        } = imgPatch;
+        const posY = this.y + PUZZLE_PAD + ((naturalHeight - PUZZLE_PAD) / 2) - (PUZZLE_GAP / 2);
+        // const cData = ctx.getImageData(0, a.y + 10 + 20 - 4, 360, 8).data;
+        const cData = ctx.getImageData(0, posY, width, PUZZLE_GAP).data;
+        const lumas = [];
+        for (let x = 0; x < width; x++) {
+            var sum = 0;
+            // y xais
+            for (let y = 0; y < PUZZLE_GAP; y++) {
+                var idx = x * 4 + y * (width * 4);
+                var r = cData[idx];
+                var g = cData[idx + 1];
+                var b = cData[idx + 2];
+                var luma = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+                sum += luma;
+            }
+            lumas.push(sum / PUZZLE_GAP);
+        }
+        const n = 2; // minium macroscopic image width (px)
+        const margin = naturalWidth - PUZZLE_PAD;
+        const diff = 20; // macroscopic brightness difference
+        const radius = PUZZLE_PAD;
+        for (let i = 0, len = lumas.length - 2 * 4; i < len; i++) {
+            const left = (lumas[i] + lumas[i + 1]) / n;
+            const right = (lumas[i + 2] + lumas[i + 3]) / n;
+            const mi = margin + i;
+            const mLeft = (lumas[mi] + lumas[mi + 1]) / n;
+            const mRigth = (lumas[mi + 2] + lumas[mi + 3]) / n;
+            if (left - right > diff && mLeft - mRigth < -diff) {
+                const pieces = lumas.slice(i + 2, margin + i + 2);
+                const median = pieces.sort((x1, x2) => x1 - x2)[20];
+                const avg = Math.avg(pieces);
+                // noise reducation
+                if (median > left || median > mRigth) return;
+                if (avg > 100) return;
+                // console.table({left,right,mLeft,mRigth,median});
+                // ctx.fillRect(i+n-radius, 0, 1, 360);
+                // console.log(i+n-radius);
+                return i + n - radius;
+            }
+        }
+        // not found
+        return -1;
+    }
+}
+const DATA = {
+    "appId": "17839d5db83",
+    "scene": "cww",
+    "product": "embed",
+    "lang": "zh_CN",
+};
+let SERVER = 'iv.jd.com';
+if (process.env.JDJR_SERVER) {
+    SERVER = process.env.JDJR_SERVER
+}
+class JDJRValidator {
+    constructor() {
+        this.data = {};
+        this.x = 0;
+        this.t = Date.now();
+        this.n = 0;
+    }
+    async run() {
+        const tryRecognize = async () => {
+            const x = await this.recognize();
+            if (x > 0) {
+                return x;
+            }
+            // retry
+            return await tryRecognize();
+        };
+        const puzzleX = await tryRecognize();
+        console.log(puzzleX);
+        const pos = new MousePosFaker(puzzleX).run();
+        const d = getCoordinate(pos);
+        // console.log(pos[pos.length-1][2] -Date.now());
+        await sleep(3000);
+        //await sleep(pos[pos.length - 1][2] - Date.now());
+        const result = await JDJRValidator.jsonp('/slide/s.html', {
+            d,
+            ...this.data
+        });
+        if (result.message === 'success') {
+            // console.log(result);
+            // console.log('JDJRValidator: %fs', (Date.now() - this.t) / 1000);
+            return result;
+        } else {
+            if (this.n > 60) {
+                return;
+            }
+            this.n++;
+            return await this.run();
+        }
+    }
+    async recognize() {
+        const data = await JDJRValidator.jsonp('/slide/g.html', {
+            e: ''
+        });
+        const {
+            bg,
+            patch,
+            y
+        } = data;
+        // const uri = 'data:image/png;base64,';
+        // const re = new PuzzleRecognizer(uri+bg, uri+patch, y);
+        const re = new PuzzleRecognizer(bg, patch, y);
+        const puzzleX = await re.run();
+        if (puzzleX > 0) {
+            this.data = {
+                c: data.challenge,
+                w: re.w,
+                e: '',
+                s: '',
+                o: '',
+            };
+            this.x = puzzleX;
+        }
+        return puzzleX;
+    }
+    async report(n) {
+        console.time('PuzzleRecognizer');
+        let count = 0;
+        for (let i = 0; i < n; i++) {
+            const x = await this.recognize();
+            if (x > 0) count++;
+            if (i % 50 === 0) {
+                console.log('%f\%', (i / n) * 100);
+            }
+        }
+        console.log('successful: %f\%', (count / n) * 100);
+        console.timeEnd('PuzzleRecognizer');
+    }
+    static jsonp(api, data = {}) {
+        return new Promise((resolve, reject) => {
+            const fnId = `jsonp_${String(Math.random()).replace('.', '')}`;
+            const extraData = {
+                callback: fnId
+            };
+            const query = new URLSearchParams({ ...DATA,
+                ...extraData,
+                ...data
+            }).toString();
+            const url = `http://${SERVER}${api}?${query}`;
+            const headers = {
+                'Accept': '*/*',
+                'Accept-Encoding': 'gzip,deflate,br',
+                'Accept-Language': 'zh-CN,en-US',
+                'Connection': 'keep-alive',
+                'Host': SERVER,
+                'Proxy-Connection': 'keep-alive',
+                'Referer': 'https://h5.m.jd.com/babelDiy/Zeus/2wuqXrZrhygTQzYA7VufBEpj4amH/index.html',
+                'User-Agent': UA,
+            };
+            const req = http.get(url, {
+                headers
+            }, (response) => {
+                let res = response;
+                if (res.headers['content-encoding'] === 'gzip') {
+                    const unzipStream = new stream.PassThrough();
+                    stream.pipeline(response, zlib.createGunzip(), unzipStream, reject, );
+                    res = unzipStream;
+                }
+                res.setEncoding('utf8');
+                let rawData = '';
+                res.on('data', (chunk) => rawData += chunk);
+                res.on('end', () => {
+                    try {
+                        const ctx = {
+                            [fnId]: (data) => ctx.data = data,
+                            data: {},
+                        };
+                        vm.createContext(ctx);
+                        vm.runInContext(rawData, ctx);
+                        // console.log(ctx.data);
+                        res.resume();
+                        resolve(ctx.data);
+                    } catch (e) {
+                        reject(e);
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.end();
+        });
+    }
+}
+
+function getCoordinate(c) {
+    function string10to64(d) {
+        var c = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-~".split(""),
+            b = c.length,
+            e = +d,
+            a = [];
+        do {
+            mod = e % b;
+            e = (e - mod) / b;
+            a.unshift(c[mod])
+        } while (e);
+        return a.join("")
+    }
+
+    function prefixInteger(a, b) {
+        return (Array(b).join(0) + a).slice(-b)
+    }
+
+    function pretreatment(d, c, b) {
+        var e = string10to64(Math.abs(d));
+        var a = "";
+        if (!b) {
+            a += (d > 0 ? "1" : "0")
+        }
+        a += prefixInteger(e, c);
+        return a
+    }
+    var b = new Array();
+    for (var e = 0; e < c.length; e++) {
+        if (e == 0) {
+            b.push(pretreatment(c[e][0] < 262143 ? c[e][0] : 262143, 3, true));
+            b.push(pretreatment(c[e][1] < 16777215 ? c[e][1] : 16777215, 4, true));
+            b.push(pretreatment(c[e][2] < 4398046511103 ? c[e][2] : 4398046511103, 7, true))
+        } else {
+            var a = c[e][0] - c[e - 1][0];
+            var f = c[e][1] - c[e - 1][1];
+            var d = c[e][2] - c[e - 1][2];
+            b.push(pretreatment(a < 4095 ? a : 4095, 2, false));
+            b.push(pretreatment(f < 4095 ? f : 4095, 2, false));
+            b.push(pretreatment(d < 16777215 ? d : 16777215, 4, true))
+        }
+    }
+    return b.join("")
+}
+const HZ = 32;
+class MousePosFaker {
+    constructor(puzzleX) {
+        this.x = parseInt(Math.random() * 20 + 20, 10);
+        this.y = parseInt(Math.random() * 80 + 80, 10);
+        this.t = Date.now();
+        this.pos = [
+            [this.x, this.y, this.t]
+        ];
+        this.minDuration = parseInt(1000 / HZ, 10);
+        // this.puzzleX = puzzleX;
+        this.puzzleX = puzzleX + parseInt(Math.random() * 2 - 1, 10);
+        this.STEP = parseInt(Math.random() * 6 + 5, 10);
+        this.DURATION = parseInt(Math.random() * 7 + 12, 10) * 100;
+        // [9,1600] [10,1400]
+        this.STEP = 9;
+        // this.DURATION = 2000;
+        console.log(this.STEP, this.DURATION);
+    }
+    run() {
+        const perX = this.puzzleX / this.STEP;
+        const perDuration = this.DURATION / this.STEP;
+        const firstPos = [this.x - parseInt(Math.random() * 6, 10), this.y + parseInt(Math.random() * 11, 10), this.t];
+        this.pos.unshift(firstPos);
+        this.stepPos(perX, perDuration);
+        this.fixPos();
+        const reactTime = parseInt(60 + Math.random() * 100, 10);
+        const lastIdx = this.pos.length - 1;
+        const lastPos = [this.pos[lastIdx][0], this.pos[lastIdx][1], this.pos[lastIdx][2] + reactTime];
+        this.pos.push(lastPos);
+        return this.pos;
+    }
+    stepPos(x, duration) {
+        let n = 0;
+        const sqrt2 = Math.sqrt(2);
+        for (let i = 1; i <= this.STEP; i++) {
+            n += 1 / i;
+        }
+        for (let i = 0; i < this.STEP; i++) {
+            x = this.puzzleX / (n * (i + 1));
+            const currX = parseInt((Math.random() * 30 - 15) + x, 10);
+            const currY = parseInt(Math.random() * 7 - 3, 10);
+            const currDuration = parseInt((Math.random() * 0.4 + 0.8) * duration, 10);
+            this.moveToAndCollect({
+                x: currX,
+                y: currY,
+                duration: currDuration,
+            });
+        }
+    }
+    fixPos() {
+        const actualX = this.pos[this.pos.length - 1][0] - this.pos[1][0];
+        const deviation = this.puzzleX - actualX;
+        if (Math.abs(deviation) > 4) {
+            this.moveToAndCollect({
+                x: deviation,
+                y: parseInt(Math.random() * 8 - 3, 10),
+                duration: 100,
+            });
+        }
+    }
+    moveToAndCollect({
+        x,
+        y,
+        duration
+    }) {
+        let movedX = 0;
+        let movedY = 0;
+        let movedT = 0;
+        const times = duration / this.minDuration;
+        let perX = x / times;
+        let perY = y / times;
+        let padDuration = 0;
+        if (Math.abs(perX) < 1) {
+            padDuration = duration / Math.abs(x) - this.minDuration;
+            perX = 1;
+            perY = y / Math.abs(x);
+        }
+        while (Math.abs(movedX) < Math.abs(x)) {
+            const rDuration = parseInt(padDuration + Math.random() * 16 - 4, 10);
+            movedX += perX + Math.random() * 2 - 1;
+            movedY += perY;
+            movedT += this.minDuration + rDuration;
+            const currX = parseInt(this.x + 20, 10);
+            const currY = parseInt(this.y + 20, 10);
+            const currT = this.t + movedT;
+            this.pos.push([currX, currY, currT]);
+        }
+        this.x += x;
+        this.y += y;
+        this.t += Math.max(duration, movedT);
+    }
+}
+exports.JDJRValidator = JDJRValidator

function/jdcookie.js

@@ -0,0 +1,6 @@
+// 本地测试在这边填写cookie
+let cookie = [
+];
+module.exports = {
+    cookie
+}

function/jxAlgo.js

@@ -0,0 +1,204 @@
+let request = require("request");
+let CryptoJS = require('crypto-js');
+let qs = require("querystring");
+Date.prototype.Format = function(fmt) {
+    var e,
+        n = this,
+        d = fmt,
+        l = {
+            "M+": n.getMonth() + 1,
+            "d+": n.getDate(),
+            "D+": n.getDate(),
+            "h+": n.getHours(),
+            "H+": n.getHours(),
+            "m+": n.getMinutes(),
+            "s+": n.getSeconds(),
+            "w+": n.getDay(),
+            "q+": Math.floor((n.getMonth() + 3) / 3),
+            "S+": n.getMilliseconds()
+        };
+    /(y+)/i.test(d) && (d = d.replace(RegExp.$1, "".concat(n.getFullYear()).substr(4 - RegExp.$1.length)));
+    for (var k in l) {
+        if (new RegExp("(".concat(k, ")")).test(d)) {
+            var t, a = "S+" === k ? "000" : "00";
+            d = d.replace(RegExp.$1, 1 == RegExp.$1.length ? l[k] : ("".concat(a) + l[k]).substr("".concat(l[k]).length))
+        }
+    }
+    return d;
+}
+
+function generateFp() {
+    let e = "0123456789";
+    let a = 13;
+    let i = '';
+    for (; a--;) i += e[Math.random() * e.length | 0];
+    return (i + Date.now()).slice(0, 16)
+}
+
+function getUrlData(url, name) {
+    if (typeof URL !== "undefined") {
+        let urls = new URL(url);
+        let data = urls.searchParams.get(name);
+        return data ? data : '';
+    } else {
+        const query = url.match(/\?.*/)[0].substring(1)
+        const vars = query.split('&')
+        for (let i = 0; i < vars.length; i++) {
+            const pair = vars[i].split('=')
+            if (pair[0] === name) {
+                return vars[i].substr(vars[i].indexOf('=') + 1);
+            }
+        }
+        return ''
+    }
+}
+class jxAlgo {
+    constructor(params = {}) {
+        this.appId = 10001
+        this.result = {}
+        this.timestamp = Date.now();
+        for (let i in params) {
+            this[i] = params[i]
+        }
+    }
+    set(params = {}) {
+        for (let i in params) {
+            this[i] = params[i]
+        }
+    }
+    get(key) {
+        return this[key]
+    }
+    async dec(url) {
+        if (!this.tk) {
+            this.fingerprint = generateFp();
+            await this.requestAlgo()
+        }
+        let obj = qs.parse(url.split("?")[1]);
+        let stk = obj['_stk'];
+        return this.h5st(this.timestamp, stk, url)
+    }
+    h5st(time, stk, url) {
+        stk = stk || (url ? getUrlData(url, '_stk') : '')
+        const timestamp = new Date(time).Format("yyyyMMddhhmmssSSS");
+        let hash1 = this.enCryptMethodJD(this.tk, this.fingerprint.toString(), timestamp.toString(), this.appId.toString(), CryptoJS).toString(CryptoJS.enc.Hex);
+        let st = '';
+        stk.split(',').map((item, index) => {
+            st += `${item}:${getUrlData(url, item)}${index === stk.split(',').length - 1 ? '' : '&'}`;
+        })
+        const hash2 = CryptoJS.HmacSHA256(st, hash1.toString()).toString(CryptoJS.enc.Hex);
+        const enc = (["".concat(timestamp.toString()), "".concat(this.fingerprint.toString()), "".concat(this.appId.toString()), "".concat(this.tk), "".concat(hash2)].join(";"))
+        this.result['fingerprint'] = this.fingerprint;
+        this.result['timestamp'] = this.timestamp
+        this.result['stk'] = stk;
+        this.result['h5st'] = enc
+        let sp = url.split("?");
+        let obj = qs.parse(sp[1])
+        if (obj.callback) {
+            delete obj.callback
+        }
+        let params = Object.assign(obj, {
+            '_time': this.timestamp,
+            '_': this.timestamp,
+            'timestamp': this.timestamp,
+            'sceneval': 2,
+            'g_login_type': 1,
+            'h5st': enc,
+        })
+        this.result['url'] = `${sp[0]}?${qs.stringify(params)}`
+        return this.result
+    }
+    token(user) {
+        let nickname = user.includes('pt_pin') ? user.match(/pt_pin=([^;]+)/)[1] : user;
+        let phoneId = this.createuuid(40, 'lc');
+
+        let token = this.md5(decodeURIComponent(nickname) + this.timestamp + phoneId + 'tPOamqCuk9NLgVPAljUyIHcPRmKlVxDy');
+        return {
+            'strPgtimestamp': this.timestamp,
+            'strPhoneID': phoneId,
+            'strPgUUNum': token
+        }
+    }
+    md5(encryptString) {
+        return CryptoJS.MD5(encryptString).toString()
+    }
+    createuuid(a, c) {
+        switch (c) {
+            case "a":
+                c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+                break;
+            case "n":
+                c = "0123456789";
+                break;
+            case "c":
+                c = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+                break;
+            case "l":
+                c = "abcdefghijklmnopqrstuvwxyz";
+                break;
+            case 'cn':
+            case 'nc':
+                c = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+                break;
+            case "lc":
+            case "cl":
+                c = "abcdefghijklmnopqrstuvwxyz0123456789";
+                break;
+            default:
+                c = "0123456789abcdef"
+        }
+        var e = "";
+        for (var g = 0; g < a; g++) e += c[Math.ceil(1E8 * Math.random()) % c.length];
+        return e
+    }
+    async requestAlgo() {
+        const options = {
+            "url": `https://cactus.jd.com/request_algo?g_ty=ajax`,
+            "headers": {
+                'Authority': 'cactus.jd.com',
+                'Pragma': 'no-cache',
+                'Cache-Control': 'no-cache',
+                'Accept': 'application/json',
+                'User-Agent': 'jdpingou;iPhone;4.9.4;12.4;ae49fae72d0a8976f5155267f56ec3a5b0da75c3;network/wifi;model/iPhone8,4;appBuild/100579;ADID/00000000-0000-0000-0000-000000000000;supportApplePay/1;hasUPPay/0;pushNoticeIsOpen/0;hasOCPay/0;supportBestPay/0;session/1;pap/JA2019_3111789;brand/apple;supportJDSHWK/1;Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
+                'Content-Type': 'application/json',
+                'Origin': 'https://st.jingxi.com',
+                'Sec-Fetch-Site': 'cross-site',
+                'Sec-Fetch-Mode': 'cors',
+                'Sec-Fetch-Dest': 'empty',
+                'Referer': 'https://st.jingxi.com/pingou/dream_factory/index.html?ptag=7155.9.4',
+                'Accept-Language': 'zh-CN,zh;q=0.9,zh-TW;q=0.8,en;q=0.7'
+            },
+            'body': JSON.stringify({
+                "version": "1.0",
+                "fp": this.fingerprint,
+                "appId": this.appId.toString(),
+                "timestamp": this.timestamp,
+                "platform": "web",
+                "expandParams": ""
+            })
+        }
+        return new Promise(async resolve => {
+            request.post(options, (err, resp, data) => {
+                try {
+                    if (data) {
+                        data = JSON.parse(data);
+                        if (data['status'] === 200) {
+                            let result = data.data.result
+                            this.tk = result.tk;
+                            let enCryptMethodJDString = result.algo;
+                            if (enCryptMethodJDString) {
+                                this.enCryptMethodJD = new Function(`return ${enCryptMethodJDString}`)();
+                            }
+                            this.result = result
+                        }
+                    }
+                } catch (e) {
+                    console.log(e)
+                } finally {
+                    resolve(this.result);
+                }
+            })
+        })
+    }
+}
+module.exports = jxAlgo

function/ql.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const got = require('got');
+require('dotenv').config();
+const { readFile } = require('fs/promises');
+const path = require('path');
+
+const qlDir = '/ql';
+const authFile = path.join(qlDir, 'config/auth.json');
+
+const api = got.extend({
+  prefixUrl: 'http://localhost:5600',
+  retry: { limit: 0 },
+});
+
+async function getToken() {
+  const authConfig = JSON.parse(await readFile(authFile));
+  return authConfig.token;
+}
+
+module.exports.getEnvs = async () => {
+  const token = await getToken();
+  const body = await api({
+    url: 'api/envs',
+    searchParams: {
+      searchValue: 'JD_COOKIE',
+      t: Date.now(),
+    },
+    headers: {
+      Accept: 'application/json',
+      authorization: `Bearer ${token}`,
+    },
+  }).json();
+  return body.data;
+};
+
+module.exports.getEnvsCount = async () => {
+  const data = await this.getEnvs();
+  return data.length;
+};
+
+module.exports.addEnv = async (cookie, remarks) => {
+  const token = await getToken();
+  const body = await api({
+    method: 'post',
+    url: 'api/envs',
+    params: { t: Date.now() },
+    json: [{
+      name: 'JD_COOKIE',
+      value: cookie,
+      remarks,
+    }],
+    headers: {
+      Accept: 'application/json',
+      authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json;charset=UTF-8',
+    },
+  }).json();
+  return body;
+};
+
+module.exports.updateEnv = async (cookie, eid, remarks) => {
+  const token = await getToken();
+  const body = await api({
+    method: 'put',
+    url: 'api/envs',
+    params: { t: Date.now() },
+    json: {
+      name: 'JD_COOKIE',
+      value: cookie,
+      _id: eid,
+      remarks,
+    },
+    headers: {
+      Accept: 'application/json',
+      authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json;charset=UTF-8',
+    },
+  }).json();
+  return body;
+};
+
+module.exports.DisableCk = async (eid) => {
+  const token = await getToken();
+  const body = await api({
+    method: 'put',
+    url: 'api/envs/disable',
+    params: { t: Date.now() },	
+    body: JSON.stringify([eid]),
+    headers: {
+      Accept: 'application/json',
+      authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json;charset=UTF-8',
+    },
+  }).json();
+  return body;
+};
+
+module.exports.EnableCk = async (eid) => {
+  const token = await getToken();
+  const body = await api({
+    method: 'put',
+    url: 'api/envs/enable',
+    params: { t: Date.now() },	
+    body: JSON.stringify([eid]),
+    headers: {
+      Accept: 'application/json',
+      authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json;charset=UTF-8',
+    },
+  }).json();
+  return body;
+};
+
+module.exports.getstatus = async (eid) => {
+  const envs = await this.getEnvs();
+  for (let i = 0; i < envs.length; i++) {	 
+	if(envs[i]._id==eid){
+		 return envs[i].status; 
+	  }
+  }  
+  return 99;
+};
+
+module.exports.getEnvById = async (eid) => {
+  const envs = await this.getEnvs();
+  for (let i = 0; i < envs.length; i++) {	 
+	if(envs[i]._id==eid){		 
+		 return envs[i].value; 
+	  }
+  }  
+  return "";
+};
+
+module.exports.delEnv = async (eid) => {
+  const token = await getToken();
+  const body = await api({
+    method: 'delete',
+    url: 'api/envs',
+    params: { t: Date.now() },
+    body: JSON.stringify([eid]),
+    headers: {
+      Accept: 'application/json',
+      authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json;charset=UTF-8',
+    },
+  }).json();
+  return body;
+};