JS逆向-抠代码的第一天【手把手学会抠代码】

时间 2021-03-14

标签 python jquery git 算法 json 浏览器服务器 cookie app dom 栏目 JavaScript 繁體版

原文原文链接

　　首先声明，本人通过无数次摸爬滚打及翻阅各种资料，理论知识极其丰富，可是抠代码怎么都抠不会。python

　　无奈之下，只能认可：这个活，须要熟练度。jquery

　　本文仅对部分参数进行解析，有须要调用，请自行根据现实状况调整。git

　　第一步，首先要打开网站，伪装输入公司名：111111，用户名：111111，密码：222222，点击登陆，开始抓包。拿到数据包以后，对内部数据进行简单的梳理。算法

　　headers里面没有什么特别的特别的，要注意的是content-type显示，参数是json格式；接下来看参数方面，这里面一共11个参数，通过屡次抓包会发现，只有clientinfo/password/username三个参数在变化，并且很明显，这不是明文，是加密模式，那么模拟登陆的关键点应该就是在与找这三个参数。json

　　第二步，经过全局搜索变量名来定位。变量赋值通常分两种，就是username= 和username:，先拿username=，发现没找到东西；拿username:搜索，结果以下图：浏览器

　　明显发现，480/748处是一个函数处理username。分别看下这两个位置，对应函数，发现函数相同，在这一行函数上下浏览，发现480处有咱们数据包里面全部参数，显然，这里就是处理参数的地方，作下断点，稍后进行调试。同时打开鬼鬼JS工具，定义一个函数，用于接收处理后username值，因为这里是处理输入值，咱们须要给函数一个参数。服务器

1 function test(username) {
2 var user = encryptedString(key, encodeURIComponent(username));
3 return user
4 }

　　当逻辑处理完毕后，经过python调用该函数，该函数就应该返回user值，即对111111进行加密后的结果。encodeURIComponent()函数是自带函数，即进行urlencode编码处理，在上一层还有一个encryptedString函数，并且该函数除了username参数外，还有个key参数，发现key在上面一丢丢：key = new RSAKeyPair();复制过来，放在函数前面，同时发现上面还有一行函数调用【setMaxDigits(129)】，怀疑有用，但没证据~~~先记下，若是右面报错，就拿过来,加载代码，发现提示有函数未定义：cookie

　　继续经过全局查找，因为这个是函数，那么他定义的附近应该有function字符，很容易能够找到2个，点进去发现两个js文件同样，那就随意了，同时发现给该js文件不大，可是仔细看下，发现里面的内容都有用！把他所有复制过来，放在函数前面。
　　
app

　　而后继续用鬼鬼js工具加载代码，发现提示缺乏对象，点击v8运行，发现biFromHex未定义，经查看，这也是个函数，缺啥补啥，继续到网页里面找。dom

　　发现这俩定义文件也是有同样的，经对biFromHex函数内部查看，发现整个文件都是互相依赖函数，所有拿走，所有拿走。注意把后拿的内容（非同一文件内放在已有代码的最前方，防止由于变量定义问题形成代码错误），而后继续调用加载，发现还缺函数BarrettMu，重复上述步骤

　　文件不大，也是相互依赖函数，直接拿走，放到最前面！而后继续加载，看是否缺乏内容：这个时候鬼鬼JS工具一直报错，一直没法加载成功，把前面怀疑的那行代码拿过来，放到运行函数前面：加载成功了，没有提示缺乏函数，这个时候调用函数，参数传入111111（注意加引号），发现调用成功，返回256长度的加密密文，格式与网页数据包一致，每次运行返回结果不一样。至此，username加密逆向成功！

　　接下来是password参数。同理password参数原行代码为：password: encryptedString(key, $('#password').val()),其中$('#password').val()是jQuery的语法，及获取网页输入的密码值，那就是222222，其余方法与username同样，直接在上面添加一个获取password参数的函数，测试调用发现成功~~~~

　　最后就是clientinfo值，经过username出的代码发现该值已经产生了，这里仅仅是一个简单的赋值过程，那么产生数据。全局进行搜索，发现以下内容：

　　这个地方疑似，进入源码，打下断点，准备调试（清除以前的断点），点击登陆，发现没断，说明在这以前，该数据已经产生了，产生数据每每伴随着动做，在咱们点击登陆以前的网页动做，那就只有加载网页了。刷新网页发现断点触发。

　　这里能够发现是经过base64encode函数处理一个info值，而info到这里是一个很长的字符串，上一行，对info进行了定义。咱们尝试着进入dogetinfo函数，发现该函数大部分地方都是在定义值和获取值，并未看到什么调用函数处理值的地方，那么在他return的地方打下断点，再次刷新进入dogetinfo函数内部，查看返回内容，发现是很长的字符串，并且返回处代码为：eFlash.join("^^") + "^^" + eNavigator.join("^^");

　　对应结果值来看，这个函数好像仅仅作了拼接动做，那么查看值，发现不少熟悉的字眼，例如navigator/screenDPI/appCodeName/appVersion/userAgent等等，这显然是本地信息，经过控制台将该内容取出，按照“^^”符号断开，发现确实是计算机信息，并且取的十分简单。经百度，这种获取浏览器主要信息的数据指纹算法（这里信息不多，属于极为简单的指纹信息），服务器经过对该信息认证，发现一样指纹在同一时间内大量申请数据，会认为异常。若是要改，咱们这里能够userAgent，假装更改浏览器版本88.0.4324.190这个数据。到这里就很明白了 clientinfo = base64encode(info)，而info 即上面的拼接后的字符串。但要注意的是，base64ecode不是JS内置函数，写入JS的话，须要找下该函数，不然直接python中使用base64库。

　　至此，三个加密参数均被解析。

　　具体代码在下方。

　　具体分析步骤即操做步骤在代码注释部分，JS的文件拼接和复制在JS文件的最后

 1 '''
 2 管家婆登陆网址：http://login.wsgjp.com/
 3 网站对userName、password、clientinfo 三个参数进行了加密
 4 如今对这三个参数进行js逆向，抠代码：使用鬼鬼js调试工具
 5 
 6 userName ---->  使用userName = 查找，找到的都是赋值的地方，不是生成参数的地方
 7                 使用 userName: 查找，发现代码 userName: encryptedString(key, encodeURIComponent(username)),
 8 password ---->  进入代码所在进行定位 发现password也在这里产生
 9                 因此，一块儿操做了
10 
11                 如下转JS文件
12 
13 clientinfo -->  对这个值进行解析，发现上面代码处，这个值只是赋值所在，说明在这一步以前，这个值就已经生成了
14                 再次搜索该值，发现一处代码疑似： clientinfo = base64encode(info) 显然是对info值进行了base64编码
15                 那么info是多少，上一行对info进行了定义：var info = doGetInfo();下一步就是寻找doGetInfo函数
16                 查找后进入doGetInfo函数，发现该函数量不大，且没有参数，没参数意味着不受输入值的影响，初步检查改函数，
17                 发现该函数前一半以定义为主，获取数据，咱们直接在return的地方打断点。再次点击登陆，发现没有断下来！
18                 思考为何中！ 在登陆以前就生成了，登陆以前生成，生成数据是个动做行为，要伴随着网页动做，怀疑是打开网页、
19                 即加载网页的时候生成的，直接刷新网页，成功！
20                 获取该函数返回值以下：
21                 flash:begin^^
22                 navigator:begin^^
23                 screenDPI:undefined^^
24                 cookieEnabled:true^^
25                 platform:Win32^^
26                 appCodeName:Mozilla^^
27                 appMinorVersion:undefined^^
28                 appName:Netscape^^
29                 appVersion:5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36^^
30                 browserLanguage:undefined^^
31                 cpuClass:undefined^^
32                 systemLanguage:undefined^^
33                 userAgent:Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36^^
34                 userLanguage:undefined^^
35                 language:zh-CN^^
36                 language:zh-CN^^
37                 oscpu:undefined
38 
39                 结合eFlash.join("^^") + "^^" + eNavigator.join("^^")这行代码，没学过js都应该猜获得，是用^^对数据进行拼接，
40                 断开后，发现不少很熟悉的东西，这些都是浏览器信息，undefined即未获取到，那么有效信息即appVersion、userAgent
41                 这里基本上就是固定值了。
42                 经百度，这种获取浏览器主要信息的数据  指纹算法（这里信息不多，属于极为简单的指纹信息），
43                 服务器经过对该信息认证，发现一样指纹在同一时间内大量申请数据，会认为异常。若是要改，咱们这里能够userAgent，
44                 假装更改浏览器版本88.0.4324.190这个数据。
45                 那么 clientinfo = base64encode(info)，而info 即上面的拼接后的字符串
46 
47                 注意：将函数直接写进JS的话，请把base64encode函数也复制进去，不能少参数，注意调试，不然请直接在python中
48                 调用base64方法
49 
50 
51 '''
52 
53 import execjs
54 
55 def read_js(file):
56     with open(file, 'r', encoding='utf8') as f:
57         js_data = f.read()
58         return js_data
59 
60 
61 
62 
63 if __name__ == '__main__':
64     # 先读取js文件
65     js_r = read_js('getsome.js')
66     # 使用execjs方法获取js文件内容
67     js_o = execjs.compile(js_r)
68     # call方法调用函数，参数：函数名， 参数值
69     _username = js_o.call('getusername','111111')
70     print(_username)
71     print(len(_username))
72     _password = js_o.call('getpwd', '222222')
73     print(_password)
74     print(len(_password))
75 
76     _clientinfo = js_o.call('getCL')
77     print(_clientinfo)

　　JS 代码以下，这里就折叠了，由于行数太多。

var base64EncodeChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
function base64encode(str) {
    try {
        var out, i, len;
        var c1, c2, c3;
        len = str.length;
        i = 0;
        out = "";
        while (i < len) {
            c1 = str.charCodeAt(i++) & 0xff;
            if (i == len) {
                out += base64EncodeChars.charAt(c1 >> 2);
                out += base64EncodeChars.charAt((c1 & 0x3) << 4);
                out += "==";
                break;
            }
            c2 = str.charCodeAt(i++);
            if (i == len) {
                out += base64EncodeChars.charAt(c1 >> 2);
                out += base64EncodeChars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4));
                out += base64EncodeChars.charAt((c2 & 0xF) << 2);
                out += "=";
                break;
            }
            c3 = str.charCodeAt(i++);
            out += base64EncodeChars.charAt(c1 >> 2);
            out += base64EncodeChars.charAt(((c1 & 0x3) << 4) | ((c2 & 0xF0) >> 4));
            out += base64EncodeChars.charAt(((c2 & 0xF) << 2) | ((c3 & 0xC0) >> 6));
            out += base64EncodeChars.charAt(c3 & 0x3F);
        }

    } catch (e) {
    }
    return out;
}

function BarrettMu(m)
{
    this.modulus = biCopy(m);
    this.k = biHighIndex(this.modulus) + 1;
    var b2k = new BigInt();
    b2k.digits[2 * this.k] = 1; // b2k = b^(2k)
    this.mu = biDivide(b2k, this.modulus);
    this.bkplus1 = new BigInt();
    this.bkplus1.digits[this.k + 1] = 1; // bkplus1 = b^(k+1)
    this.modulo = BarrettMu_modulo;
    this.multiplyMod = BarrettMu_multiplyMod;
    this.powMod = BarrettMu_powMod;
}

function BarrettMu_modulo(x)
{
    var q1 = biDivideByRadixPower(x, this.k - 1);
    var q2 = biMultiply(q1, this.mu);
    var q3 = biDivideByRadixPower(q2, this.k + 1);
    var r1 = biModuloByRadixPower(x, this.k + 1);
    var r2term = biMultiply(q3, this.modulus);
    var r2 = biModuloByRadixPower(r2term, this.k + 1);
    var r = biSubtract(r1, r2);
    if (r.isNeg) {
        r = biAdd(r, this.bkplus1);
    }
    var rgtem = biCompare(r, this.modulus) >= 0;
    while (rgtem) {
        r = biSubtract(r, this.modulus);
        rgtem = biCompare(r, this.modulus) >= 0;
    }
    return r;
}

function BarrettMu_multiplyMod(x, y)
{
    /*
    x = this.modulo(x);
    y = this.modulo(y);
    */
    var xy = biMultiply(x, y);
    return this.modulo(xy);
}

function BarrettMu_powMod(x, y)
{
    var result = new BigInt();
    result.digits[0] = 1;
    var a = x;
    var k = y;
    while (true) {
        if ((k.digits[0] & 1) != 0) result = this.multiplyMod(result, a);
        k = biShiftRight(k, 1);
        if (k.digits[0] == 0 && biHighIndex(k) == 0) break;
        a = this.multiplyMod(a, a);
    }
    return result;
}







var biRadixBase = 2;
var biRadixBits = 16;
var bitsPerDigit = biRadixBits;
var biRadix = 1 << 16; // = 2^16 = 65536
var biHalfRadix = biRadix >>> 1;
var biRadixSquared = biRadix * biRadix;
var maxDigitVal = biRadix - 1;
var maxInteger = 9999999999999998;

// maxDigits:
// Change this to accommodate your largest number size. Use setMaxDigits()
// to change it!
//
// In general, if you're working with numbers of size N bits, you'll need 2*N
// bits of storage. Each digit holds 16 bits. So, a 1024-bit key will need
//
// 1024 * 2 / 16 = 128 digits of storage.
//

var maxDigits;
var ZERO_ARRAY;
var bigZero, bigOne;

function setMaxDigits(value)
{
    maxDigits = value;
    ZERO_ARRAY = new Array(maxDigits);
    for (var iza = 0; iza < ZERO_ARRAY.length; iza++) ZERO_ARRAY[iza] = 0;
    bigZero = new BigInt();
    bigOne = new BigInt();
    bigOne.digits[0] = 1;
}

setMaxDigits(20);

// The maximum number of digits in base 10 you can convert to an
// integer without JavaScript throwing up on you.
var dpl10 = 15;
// lr10 = 10 ^ dpl10
var lr10 = biFromNumber(1000000000000000);

function BigInt(flag)
{
    if (typeof flag == "boolean" && flag == true) {
        this.digits = null;
    }
    else {
        this.digits = ZERO_ARRAY.slice(0);
    }
    this.isNeg = false;
}

function biFromDecimal(s)
{
    var isNeg = s.charAt(0) == '-';
    var i = isNeg ? 1 : 0;
    var result;
    // Skip leading zeros.
    while (i < s.length && s.charAt(i) == '0') ++i;
    if (i == s.length) {
        result = new BigInt();
    }
    else {
        var digitCount = s.length - i;
        var fgl = digitCount % dpl10;
        if (fgl == 0) fgl = dpl10;
        result = biFromNumber(Number(s.substr(i, fgl)));
        i += fgl;
        while (i < s.length) {
            result = biAdd(biMultiply(result, lr10),
                           biFromNumber(Number(s.substr(i, dpl10))));
            i += dpl10;
        }
        result.isNeg = isNeg;
    }
    return result;
}

function biCopy(bi)
{
    var result = new BigInt(true);
    result.digits = bi.digits.slice(0);
    result.isNeg = bi.isNeg;
    return result;
}

function biFromNumber(i)
{
    var result = new BigInt();
    result.isNeg = i < 0;
    i = Math.abs(i);
    var j = 0;
    while (i > 0) {
        result.digits[j++] = i & maxDigitVal;
        i = Math.floor(i / biRadix);
    }
    return result;
}

function reverseStr(s)
{
    var result = "";
    for (var i = s.length - 1; i > -1; --i) {
        result += s.charAt(i);
    }
    return result;
}

var hexatrigesimalToChar = new Array(
 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
 'u', 'v', 'w', 'x', 'y', 'z'
);

function biToString(x, radix)
    // 2 <= radix <= 36
{
    var b = new BigInt();
    b.digits[0] = radix;
    var qr = biDivideModulo(x, b);
    var result = hexatrigesimalToChar[qr[1].digits[0]];
    while (biCompare(qr[0], bigZero) == 1) {
        qr = biDivideModulo(qr[0], b);
        digit = qr[1].digits[0];
        result += hexatrigesimalToChar[qr[1].digits[0]];
    }
    return (x.isNeg ? "-" : "") + reverseStr(result);
}

function biToDecimal(x)
{
    var b = new BigInt();
    b.digits[0] = 10;
    var qr = biDivideModulo(x, b);
    var result = String(qr[1].digits[0]);
    while (biCompare(qr[0], bigZero) == 1) {
        qr = biDivideModulo(qr[0], b);
        result += String(qr[1].digits[0]);
    }
    return (x.isNeg ? "-" : "") + reverseStr(result);
}

var hexToChar = new Array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                          'a', 'b', 'c', 'd', 'e', 'f');

function digitToHex(n)
{
    var mask = 0xf;
    var result = "";
    for (i = 0; i < 4; ++i) {
        result += hexToChar[n & mask];
        n >>>= 4;
    }
    return reverseStr(result);
}

function biToHex(x)
{
    var result = "";
    var n = biHighIndex(x);
    for (var i = biHighIndex(x); i > -1; --i) {
        result += digitToHex(x.digits[i]);
    }
    return result;
}

function charToHex(c)
{
    var ZERO = 48;
    var NINE = ZERO + 9;
    var littleA = 97;
    var littleZ = littleA + 25;
    var bigA = 65;
    var bigZ = 65 + 25;
    var result;

    if (c >= ZERO && c <= NINE) {
        result = c - ZERO;
    } else if (c >= bigA && c <= bigZ) {
        result = 10 + c - bigA;
    } else if (c >= littleA && c <= littleZ) {
        result = 10 + c - littleA;
    } else {
        result = 0;
    }
    return result;
}

function hexToDigit(s)
{
    var result = 0;
    var sl = Math.min(s.length, 4);
    for (var i = 0; i < sl; ++i) {
        result <<= 4;
        result |= charToHex(s.charCodeAt(i))
    }
    return result;
}

function biFromHex(s)
{
    var result = new BigInt();
    var sl = s.length;
    for (var i = sl, j = 0; i > 0; i -= 4, ++j) {
        result.digits[j] = hexToDigit(s.substr(Math.max(i - 4, 0), Math.min(i, 4)));
    }
    return result;
}

function biFromString(s, radix)
{
    var isNeg = s.charAt(0) == '-';
    var istop = isNeg ? 1 : 0;
    var result = new BigInt();
    var place = new BigInt();
    place.digits[0] = 1; // radix^0
    for (var i = s.length - 1; i >= istop; i--) {
        var c = s.charCodeAt(i);
        var digit = charToHex(c);
        var biDigit = biMultiplyDigit(place, digit);
        result = biAdd(result, biDigit);
        place = biMultiplyDigit(place, radix);
    }
    result.isNeg = isNeg;
    return result;
}

function biDump(b)
{
    return (b.isNeg ? "-" : "") + b.digits.join(" ");
}

function biAdd(x, y)
{
    var result;

    if (x.isNeg != y.isNeg) {
        y.isNeg = !y.isNeg;
        result = biSubtract(x, y);
        y.isNeg = !y.isNeg;
    }
    else {
        result = new BigInt();
        var c = 0;
        var n;
        for (var i = 0; i < x.digits.length; ++i) {
            n = x.digits[i] + y.digits[i] + c;
            result.digits[i] = n % biRadix;
            c = Number(n >= biRadix);
        }
        result.isNeg = x.isNeg;
    }
    return result;
}

function biSubtract(x, y)
{
    var result;
    if (x.isNeg != y.isNeg) {
        y.isNeg = !y.isNeg;
        result = biAdd(x, y);
        y.isNeg = !y.isNeg;
    } else {
        result = new BigInt();
        var n, c;
        c = 0;
        for (var i = 0; i < x.digits.length; ++i) {
            n = x.digits[i] - y.digits[i] + c;
            result.digits[i] = n % biRadix;
            // Stupid non-conforming modulus operation.
            if (result.digits[i] < 0) result.digits[i] += biRadix;
            c = 0 - Number(n < 0);
        }
        // Fix up the negative sign, if any.
        if (c == -1) {
            c = 0;
            for (var i = 0; i < x.digits.length; ++i) {
                n = 0 - result.digits[i] + c;
                result.digits[i] = n % biRadix;
                // Stupid non-conforming modulus operation.
                if (result.digits[i] < 0) result.digits[i] += biRadix;
                c = 0 - Number(n < 0);
            }
            // Result is opposite sign of arguments.
            result.isNeg = !x.isNeg;
        } else {
            // Result is same sign.
            result.isNeg = x.isNeg;
        }
    }
    return result;
}

function biHighIndex(x)
{
    var result = x.digits.length - 1;
    while (result > 0 && x.digits[result] == 0) --result;
    return result;
}

function biNumBits(x)
{
    var n = biHighIndex(x);
    var d = x.digits[n];
    var m = (n + 1) * bitsPerDigit;
    var result;
    for (result = m; result > m - bitsPerDigit; --result) {
        if ((d & 0x8000) != 0) break;
        d <<= 1;
    }
    return result;
}

function biMultiply(x, y)
{
    var result = new BigInt();
    var c;
    var n = biHighIndex(x);
    var t = biHighIndex(y);
    var u, uv, k;

    for (var i = 0; i <= t; ++i) {
        c = 0;
        k = i;
        for (j = 0; j <= n; ++j, ++k) {
            uv = result.digits[k] + x.digits[j] * y.digits[i] + c;
            result.digits[k] = uv & maxDigitVal;
            c = uv >>> biRadixBits;
            //c = Math.floor(uv / biRadix);
        }
        result.digits[i + n + 1] = c;
    }
    // Someone give me a logical xor, please.
    result.isNeg = x.isNeg != y.isNeg;
    return result;
}

function biMultiplyDigit(x, y)
{
    var n, c, uv;

    result = new BigInt();
    n = biHighIndex(x);
    c = 0;
    for (var j = 0; j <= n; ++j) {
        uv = result.digits[j] + x.digits[j] * y + c;
        result.digits[j] = uv & maxDigitVal;
        c = uv >>> biRadixBits;
        //c = Math.floor(uv / biRadix);
    }
    result.digits[1 + n] = c;
    return result;
}

function arrayCopy(src, srcStart, dest, destStart, n)
{
    var m = Math.min(srcStart + n, src.length);
    for (var i = srcStart, j = destStart; i < m; ++i, ++j) {
        dest[j] = src[i];
    }
}

var highBitMasks = new Array(0x0000, 0x8000, 0xC000, 0xE000, 0xF000, 0xF800,
                             0xFC00, 0xFE00, 0xFF00, 0xFF80, 0xFFC0, 0xFFE0,
                             0xFFF0, 0xFFF8, 0xFFFC, 0xFFFE, 0xFFFF);

function biShiftLeft(x, n)
{
    var digitCount = Math.floor(n / bitsPerDigit);
    var result = new BigInt();
    arrayCopy(x.digits, 0, result.digits, digitCount,
              result.digits.length - digitCount);
    var bits = n % bitsPerDigit;
    var rightBits = bitsPerDigit - bits;
    for (var i = result.digits.length - 1, i1 = i - 1; i > 0; --i, --i1) {
        result.digits[i] = ((result.digits[i] << bits) & maxDigitVal) |
                           ((result.digits[i1] & highBitMasks[bits]) >>>
                            (rightBits));
    }
    result.digits[0] = ((result.digits[i] << bits) & maxDigitVal);
    result.isNeg = x.isNeg;
    return result;
}

var lowBitMasks = new Array(0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F,
                            0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF,
                            0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF);

function biShiftRight(x, n)
{
    var digitCount = Math.floor(n / bitsPerDigit);
    var result = new BigInt();
    arrayCopy(x.digits, digitCount, result.digits, 0,
              x.digits.length - digitCount);
    var bits = n % bitsPerDigit;
    var leftBits = bitsPerDigit - bits;
    for (var i = 0, i1 = i + 1; i < result.digits.length - 1; ++i, ++i1) {
        result.digits[i] = (result.digits[i] >>> bits) |
                           ((result.digits[i1] & lowBitMasks[bits]) << leftBits);
    }
    result.digits[result.digits.length - 1] >>>= bits;
    result.isNeg = x.isNeg;
    return result;
}

function biMultiplyByRadixPower(x, n)
{
    var result = new BigInt();
    arrayCopy(x.digits, 0, result.digits, n, result.digits.length - n);
    return result;
}

function biDivideByRadixPower(x, n)
{
    var result = new BigInt();
    arrayCopy(x.digits, n, result.digits, 0, result.digits.length - n);
    return result;
}

function biModuloByRadixPower(x, n)
{
    var result = new BigInt();
    arrayCopy(x.digits, 0, result.digits, 0, n);
    return result;
}

function biCompare(x, y)
{
    if (x.isNeg != y.isNeg) {
        return 1 - 2 * Number(x.isNeg);
    }
    for (var i = x.digits.length - 1; i >= 0; --i) {
        if (x.digits[i] != y.digits[i]) {
            if (x.isNeg) {
                return 1 - 2 * Number(x.digits[i] > y.digits[i]);
            } else {
                return 1 - 2 * Number(x.digits[i] < y.digits[i]);
            }
        }
    }
    return 0;
}

function biDivideModulo(x, y)
{
    var nb = biNumBits(x);
    var tb = biNumBits(y);
    var origYIsNeg = y.isNeg;
    var q, r;
    if (nb < tb) {
        // |x| < |y|
        if (x.isNeg) {
            q = biCopy(bigOne);
            q.isNeg = !y.isNeg;
            x.isNeg = false;
            y.isNeg = false;
            r = biSubtract(y, x);
            // Restore signs, 'cause they're references.
            x.isNeg = true;
            y.isNeg = origYIsNeg;
        } else {
            q = new BigInt();
            r = biCopy(x);
        }
        return new Array(q, r);
    }

    q = new BigInt();
    r = x;

    // Normalize Y.
    var t = Math.ceil(tb / bitsPerDigit) - 1;
    var lambda = 0;
    while (y.digits[t] < biHalfRadix) {
        y = biShiftLeft(y, 1);
        ++lambda;
        ++tb;
        t = Math.ceil(tb / bitsPerDigit) - 1;
    }
    // Shift r over to keep the quotient constant. We'll shift the
    // remainder back at the end.
    r = biShiftLeft(r, lambda);
    nb += lambda; // Update the bit count for x.
    var n = Math.ceil(nb / bitsPerDigit) - 1;

    var b = biMultiplyByRadixPower(y, n - t);
    while (biCompare(r, b) != -1) {
        ++q.digits[n - t];
        r = biSubtract(r, b);
    }
    for (var i = n; i > t; --i) {
    var ri = (i >= r.digits.length) ? 0 : r.digits[i];
    var ri1 = (i - 1 >= r.digits.length) ? 0 : r.digits[i - 1];
    var ri2 = (i - 2 >= r.digits.length) ? 0 : r.digits[i - 2];
    var yt = (t >= y.digits.length) ? 0 : y.digits[t];
    var yt1 = (t - 1 >= y.digits.length) ? 0 : y.digits[t - 1];
        if (ri == yt) {
            q.digits[i - t - 1] = maxDigitVal;
        } else {
            q.digits[i - t - 1] = Math.floor((ri * biRadix + ri1) / yt);
        }

        var c1 = q.digits[i - t - 1] * ((yt * biRadix) + yt1);
        var c2 = (ri * biRadixSquared) + ((ri1 * biRadix) + ri2);
        while (c1 > c2) {
            --q.digits[i - t - 1];
            c1 = q.digits[i - t - 1] * ((yt * biRadix) | yt1);
            c2 = (ri * biRadix * biRadix) + ((ri1 * biRadix) + ri2);
        }

        b = biMultiplyByRadixPower(y, i - t - 1);
        r = biSubtract(r, biMultiplyDigit(b, q.digits[i - t - 1]));
        if (r.isNeg) {
            r = biAdd(r, b);
            --q.digits[i - t - 1];
        }
    }
    r = biShiftRight(r, lambda);
    // Fiddle with the signs and stuff to make sure that 0 <= r < y.
    q.isNeg = x.isNeg != origYIsNeg;
    if (x.isNeg) {
        if (origYIsNeg) {
            q = biAdd(q, bigOne);
        } else {
            q = biSubtract(q, bigOne);
        }
        y = biShiftRight(y, lambda);
        r = biSubtract(y, r);
    }
    // Check for the unbelievably stupid degenerate case of r == -0.
    if (r.digits[0] == 0 && biHighIndex(r) == 0) r.isNeg = false;

    return new Array(q, r);
}

function biDivide(x, y)
{
    return biDivideModulo(x, y)[0];
}

function biModulo(x, y)
{
    return biDivideModulo(x, y)[1];
}

function biMultiplyMod(x, y, m)
{
    return biModulo(biMultiply(x, y), m);
}

function biPow(x, y)
{
    var result = bigOne;
    var a = x;
    while (true) {
        if ((y & 1) != 0) result = biMultiply(result, a);
        y >>= 1;
        if (y == 0) break;
        a = biMultiply(a, a);
    }
    return result;
}

function biPowMod(x, y, m)
{
    var result = bigOne;
    var a = x;
    var k = y;
    while (true) {
        if ((k.digits[0] & 1) != 0) result = biMultiplyMod(result, a, m);
        k = biShiftRight(k, 1);
        if (k.digits[0] == 0 && biHighIndex(k) == 0) break;
        a = biMultiplyMod(a, a, m);
    }
    return result;
}





function RSAKeyPair() {
    var encryptionExponent = "010001";
    var decryptionExponent = "";
    var modulus = "9A568982EE4BF010C38B5195A6F2DC7D66D5E6C02098CF25044CDD031AC08C6569D7063BB8959CB3FCB5AF572DE355AFA684AF7187948744E673275B494F394AF7F158841CA8B63BF65F185883F8D773A57ED731EDCD1AF2E0E57CD45F5F3CB4EBDD38F4A267E5ED02E7B44B93EDFFDADBDC8368019CD496BEC735BAF9E57125";
    this.e = biFromHex(encryptionExponent);
    this.d = biFromHex(decryptionExponent);
    this.m = biFromHex(modulus);
    this.digitSize = 2 * biHighIndex(this.m) + 2;
    this.chunkSize = this.digitSize - 11;
    this.radix = 16;
    this.barrett = new BarrettMu(this.m);
}

function twoDigit(n) {
    return (n < 10 ? "0" : "") + String(n);
}

function encryptedString(key, s) {
    if (key.chunkSize > key.digitSize - 11) {
        return "Error";
    }
    var a = new Array();
    var sl = s.length;

    var i = 0;
    while (i < sl) {
        a[i] = s.charCodeAt(i);
        i++;
    }
    var al = a.length;
    var result = "";
    var j, k, block;
    for (i = 0; i < al; i += key.chunkSize) {
        block = new BigInt();
        j = 0;
        var x;
        var msgLength = (i + key.chunkSize) > al ? al % key.chunkSize : key.chunkSize;
        var b = new Array();
        for (x = 0; x < msgLength; x++) {
            b[x] = a[i + msgLength - 1 - x];
        }
        b[msgLength] = 0; // marker
        var paddedSize = Math.max(8, key.digitSize - 3 - msgLength);

        for (x = 0; x < paddedSize; x++) {
            b[msgLength + 1 + x] = Math.floor(Math.random() * 254) + 1;
        }

        b[key.digitSize - 2] = 2; // marker
        b[key.digitSize - 1] = 0; // marker

        for (k = 0; k < key.digitSize; ++j) {
            block.digits[j] = b[k++];
            block.digits[j] += b[k++] << 8;
        }
        var crypt = key.barrett.powMod(block, key.e);
        var text = key.radix == 16 ? biToHex(crypt) : biToString(crypt, key.radix);
        result += text + " ";
    }
    return result.substring(0, result.length - 1); // Remove last space.
}



setMaxDigits(129);
var key = new RSAKeyPair();
// 第一步在这里建立函数，username，必然是获取到的，因此须要传个值，
// 同理，处理password

function getusername(username) {
    // 很明显，username是被urlencode处理过的，直接使用方法
    var user = encryptedString(key, encodeURIComponent(username));
    return user
}

function getpwd(password) {
    // 原文中的 $('#password').val() jquery写法，它的意思是，从password标签中获取value值，
    // val的()中没有对象，即为取值，有东西即为赋值
    var pwd = encryptedString(key, password);
    return pwd
}
var info = 'flash:begin^^navigator:begin^^screenDPI:undefined^^cookieEnabled:true^^platform:Win32^^appCodeName:Mozilla^^appMinorVersion:undefined^^appName:Netscape^^appVersion:5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36^^browserLanguage:undefined^^cpuClass:undefined^^systemLanguage:undefined^^userAgent:Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36^^userLanguage:undefined^^language:zh-CN^^language:zh-CN^^oscpu:undefined'
function getCL() {
    var cl = base64encode(info);
    return cl
}


// 经对这俩函数初步解析（眼睛看），发现这个是个函数encryptedString 能够直接搜索这个函数
// 即 function encryptedString的地方，也能够经过打断点进入函数，
// 将函数总体复制过来，发现文件不大，检查下文件内部数据，基本都是有用数据，
// 就所有拿过来，放置到自定义函数前面
// 调用后，发现key未定义，再看源码，发现就在上面，复制过来，
// 他的上一行setMaxDigits(129);看起来是个单独调用，也取过来
// 继续调用自定义函数，发现函数setMaxDigits不存，将改行注释掉后，发现biFromHex函数不存在，
// 经查找，这俩函数在一块儿，干脆全拿来放在前面，恢复注释
// 继续调用（鬼鬼JS 直接点加载也会提醒，但有时不会提醒详细，须要点V8运行）发现BarrettMu未定义，继续找
// 发现这个文件很小，内部代码均为关联代码，全复制过来
// 至此，鬼鬼JS工具提示完成，工具中调用函数能够获得与浏览器相似结果
// 咱们回到py文件中，利用execJS工具调用试试

View Code