精华内容
下载资源
问答
  • jQ当乐网搜索是一款基于jQuery实现的当乐网官网搜索。
  • jQuery当乐网搜索.zip

    2019-07-04 22:25:49
    jQ当乐网搜索是一款基于jQuery实现的当乐网官网搜索。
  • 当乐网接入sdk

    2014-12-27 17:11:17
    sdk 当乐,如果移动app或者游戏要接入当乐网需要接入这个sdk
  • 目标:当乐网登录 主页:https://oauth.d.cn/auth/goLogin.html 接口:https://oauth.d.cn/auth/login 逆向参数: Query String Parameters: pwd:26fac08e6b524bef29c09479fdefe604ea7b2c4d7285a3e01f0969a...



    声明

    本文章中所有内容仅供学习交流,严禁用于商业用途和非法用途,否则由此产生的一切后果均与作者无关,若有侵权,请联系我立即删除!

    逆向目标

    • 目标:当乐网登录

    • 主页:https://oauth.d.cn/auth/goLogin.html

    • 接口:https://oauth.d.cn/auth/login

    • 逆向参数:

      Query String Parameters:

      pwd:26fac08e6b524bef29c09479fdefe604ea7b2c4d7285a3e01f0969a9230a4e9af1b8ed23ca840978f61bf0e7850c72ece07dc95ef3f7484a5086284f825bd420da19ecd8b832877b113f21181bc9a22cc795c92f8d4c8dc6ca8b21309c674220e365ab67475a299277b0aa7842e09517c7ab3c5e693e51c4d9d9935f6ec430cb
      

    逆向过程

    抓包分析

    随便输入一个账号密码,点击登陆,抓包定位到登录接口为 https://oauth.d.cn/auth/login ,GET 请求,Query String Parameters 里,密码 pwd 被加密处理了。

    参数逆向

    全局搜索 pwd 关键字,在首页就可以找到一段 submitData 提交数据的函数,埋下断点进行调试,可以发现明文密码是经过 RSA 加密后得到的:

    跟进这个 rsa 加密函数:

      var rsa = function (arg) {
          setMaxDigits(130);
          var PublicExponent = "10001";
          var modulus = "be44aec4d73408f6b60e6fe9e3dc55d0e1dc53a1e171e071b547e2e8e0b7da01c56e8c9bcf0521568eb111adccef4e40124b76e33e7ad75607c227af8f8e0b759c30ef283be8ab17a84b19a051df5f94c07e6e7be5f77866376322aac944f45f3ab532bb6efc70c1efa524d821d16cafb580c5a901f0defddea3692a4e68e6cd";
          var key = new RSAKeyPair(PublicExponent, "", modulus);
          return encryptedString(key, arg);
      };
    

    setMaxDigits 这个函数在 BigInt.js 里面可以找到,而 RSAKeyPairencryptedString 都可以在 RSA.js 里面找到,由于这两个 JS 都比较复杂,所以直接将两个 JS 源码全部复制下来直接调用即可。

    在本地调试的过程中发现 RSA.js 里面会提示 BarrettMu 未定义,经过调试可以发现这个函数在 Barrett.js 里面,所以直接把 Barrett.js 也全部复制下来即可。

    完整代码

    完整代码可在 GitHub 下载:https://github.com/kuaidaili/crawler/tree/main/oauth_d_cn

    d_cn_encrypt.js

    var RSAAPP = {};
    
    RSAAPP.NoPadding = "NoPadding";
    RSAAPP.PKCS1Padding = "PKCS1Padding";
    RSAAPP.RawEncoding = "RawEncoding";
    RSAAPP.NumericEncoding = "NumericEncoding"
    
    function RSAKeyPair(encryptionExponent, decryptionExponent, modulus, keylen) {
    
        this.e = biFromHex(encryptionExponent);
        this.d = biFromHex(decryptionExponent);
        this.m = biFromHex(modulus);
    
        if (typeof (keylen) != 'number') {
            this.chunkSize = 2 * biHighIndex(this.m);
        } else {
            this.chunkSize = keylen / 8;
        }
    
        this.radix = 16;
    
        this.barrett = new BarrettMu(this.m);
    }
    
    function encryptedString(key, s, pad, encoding) {
        var a = new Array();
        var sl = s.length;
        var i, j, k;
        var padtype;
        var encodingtype;
        var rpad;
        var al;
        var result = "";
        var block;
        var crypt;
        var text;
    
        if (typeof (pad) == 'string') {
            if (pad == RSAAPP.NoPadding) {
                padtype = 1;
            } else if (pad == RSAAPP.PKCS1Padding) {
                padtype = 2;
            } else {
                padtype = 0;
            }
        } else {
            padtype = 0;
        }
    
        if (typeof (encoding) == 'string' && encoding == RSAAPP.RawEncoding) {
            encodingtype = 1;
        } else {
            encodingtype = 0;
        }
    
        if (padtype == 1) {
            if (sl > key.chunkSize) {
                sl = key.chunkSize;
            }
        } else if (padtype == 2) {
            if (sl > (key.chunkSize - 11)) {
                sl = key.chunkSize - 11;
            }
        }
    
        i = 0;
    
        if (padtype == 2) {
            j = sl - 1;
        } else {
            j = key.chunkSize - 1;
        }
    
        while (i < sl) {
            if (padtype) {
                a[j] = s.charCodeAt(i);
            } else {
                a[i] = s.charCodeAt(i);
            }
    
            i++;
            j--;
        }
    
        if (padtype == 1) {
            i = 0;
        }
    
        j = key.chunkSize - (sl % key.chunkSize);
    
        while (j > 0) {
            if (padtype == 2) {
                rpad = Math.floor(Math.random() * 256);
    
                while (!rpad) {
                    rpad = Math.floor(Math.random() * 256);
                }
    
                a[i] = rpad;
            } else {
                a[i] = 0;
            }
    
            i++;
            j--;
        }
    
        if (padtype == 2) {
            a[sl] = 0;
            a[key.chunkSize - 2] = 2;
            a[key.chunkSize - 1] = 0;
        }
    
        al = a.length;
    
        for (i = 0; i < al; i += key.chunkSize) {
    
            block = new BigInt();
    
            j = 0;
    
            for (k = i; k < (i + key.chunkSize); ++j) {
                block.digits[j] = a[k++];
                block.digits[j] += a[k++] << 8;
            }
    
            crypt = key.barrett.powMod(block, key.e);
            if (encodingtype == 1) {
                text = biToBytes(crypt);
            } else {
                text = (key.radix == 16) ? biToHex(crypt) : biToString(crypt, key.radix);
            }
            result += text;
        }
    
        return result;
    }
    
    function decryptedString(key, c) {
        var blocks = c.split(" ");
        var b;
        var i, j;
        var bi;
        var result = "";
    
        for (i = 0; i < blocks.length; ++i) {
            if (key.radix == 16) {
                bi = biFromHex(blocks[i]);
            } else {
                bi = biFromString(blocks[i], key.radix);
            }
    
            b = key.barrett.powMod(bi, key.d);
    
            for (j = 0; j <= biHighIndex(b); ++j) {
                result += String.fromCharCode(b.digits[j] & 255, b.digits[j] >> 8);
            }
        }
    
        if (result.charCodeAt(result.length - 1) == 0) {
            result = result.substring(0, result.length - 1);
        }
    
        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;
    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);
    
    var dpl10 = 15;
    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 >>= biRadixBits;
        }
        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) {
        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 biToBytes(x)
    // Returns a string containing raw bytes.
    {
        var result = "";
        for (var i = biHighIndex(x); i > -1; --i) {
            result += digitToBytes(x.digits[i]);
        }
        return result;
    }
    
    function digitToBytes(n)
    // Convert two-byte digit to string containing both bytes.
    {
        var c1 = String.fromCharCode(n & 0xff);
        n >>>= 8;
        var c2 = String.fromCharCode(n & 0xff);
        return c2 + c1;
    }
    
    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 & 0xffff;
                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 & 0xffff;
                // 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 & 0xffff;
                    // 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;
            }
            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;
        }
        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 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;
    }
    
    function getEncryptedPassword (arg) {
        setMaxDigits(130);
        var PublicExponent = "10001";
        var modulus = "be44aec4d73408f6b60e6fe9e3dc55d0e1dc53a1e171e071b547e2e8e0b7da01c56e8c9bcf0521568eb111adccef4e40124b76e33e7ad75607c227af8f8e0b759c30ef283be8ab17a84b19a051df5f94c07e6e7be5f77866376322aac944f45f3ab532bb6efc70c1efa524d821d16cafb580c5a901f0defddea3692a4e68e6cd";
        var key = new RSAKeyPair(PublicExponent, "", modulus);
        return encryptedString(key, arg);
    }
    
    // 测试样例
    // console.log(getEncryptedPassword("2543534534"))
    

    d_cn_login.py

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    
    import execjs
    import requests
    
    
    def get_encrypted_password(password):
        with open('d_cn_encrypt.js', 'r', encoding='utf-8') as f:
            weibo_js = f.read()
        encrypted_password = execjs.compile(weibo_js).call('getEncryptedPassword', password)
        return encrypted_password
    
    
    def login(encrypted_password, username):
        login_url = 'https://oauth.d.cn/auth/login'
        headers = {
            'Host': 'oauth.d.cn',
            'Referer': 'https://oauth.d.cn/auth/goLogin.html',
            'sec-ch-ua': '" Not;A Brand";v="99", "Google Chrome";v="91", "Chromium";v="91"',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
        }
        params = {
            'display': 'web',
            'name': username,
            'pwd': encrypted_password,
            'to': 'https%3A%2F%2Fwww.d.cn%2F'
        }
        response = requests.get(url=login_url, params=params, headers=headers).json()
        print(response)
    
    
    def main():
        username = input('请输入登录账号: ')
        password = input('请输入登录密码: ')
        encrypted_password = get_encrypted_password(password)
        login(encrypted_password, username)
    
    
    if __name__ == '__main__':
        main()
    

    展开全文
  • http://android.d.cn/ 当乐网不错诶 http://android.d.cn/‘’ posted on 2013-01-27 01:36le...

    http://android.d.cn/‘’

    posted on 2013-01-27 01:36  lexus 阅读( ...) 评论( ...) 编辑 收藏

    转载于:https://www.cnblogs.com/lexus/archive/2013/01/27/2878430.html

    展开全文
  • 当乐网JAVA工程师笔试经历

    千次阅读 2012-03-24 23:13:17
    前几天在63就业网看到当乐网的招聘信息,我对其中的服务器端开发工程师还是比较感兴趣的,因为它所要求的技能我几乎都会。于是网投了简历,在邮件了还问了个问题,我想问他们是否招实习生,那时很天真,以为HR会回我...

    前几天在63就业网看到当乐网的招聘信息,我对其中的服务器端开发工程师还是比较感兴趣的,因为它所要求的技能我几乎都会。于是网投了简历,在邮件了还问了个问题,我想问他们是否招实习生,那时很天真,以为HR会回我的邮件,可是等了N天,还是没有回信。就在今天(20120324日)学校举行了双选会。由于规定早上只能凭票进场,票只给毕业生,下午可以免票进入。

    早上考完数据库四级,吃了饭,就找了几个同学一起去观摩一下,随便体验下招聘的氛围,前几天本来想去应聘一下当乐的服务器开发工程师的,可是一直都不知道是否招实习生;今天却有点犹豫了,因为我没有怎么准备,简历上写的东西,还没有认真梳理一遍,而且还没有简历过求职历程,有点害怕,但是同学让我去试试,反正我本来就没有打算能应聘上,我只不过是想去感受一下这个应聘的流程及氛围,于是把自己花了好几天改了N遍的简历打印出来了,一份普通纸打印的,一份是彩打的;那份普通的本来是想在坐车的时候自己看的,可是长沙的公交车超多人,等了好几辆都不停。最后勉强挤上了一辆,今天长沙天气变的格外的好,太阳好大,下了N个星期的雨。

    去到了本部,由于穿的有点多,所以先去买了瓶可乐喝,然后大家一起悠闲的走去立业厅,第一次来到招聘现场,感觉中南大学搞得有点小气,几十个企业都就那么两三个厅;进去的时候,感觉人还不算特别多(还可以挤得进去),跟我想象中的不太一样,可能应该是早上该去的都去了吧;在里面给我的感觉是招聘会也不过如此嘛,有什么好怕的,以前很害怕招聘这中场面,或许可能自己没有那种压力吧,毕竟那里没有什么我想进的公司,我几乎把所有的公司都逛遍了;有些公司已经收摊了,有些公司还在排着比较长的队伍;我稍微有点兴趣的当乐网,也收摊了,还在那里写着,java工程师今晚湖大***笔试;还写着可以直接参加,那时我在想,是不是HR受不了里面的空气了啊(今天气温有点高,而人又比较多),又或者是已经招的差不多了,但是又不想打击大家所以才出这招啊?然后我再逛了一下,还在旁听HR是怎么面试的,给我的感觉就是,在你提交简历到面试完几乎不到一分钟,我在猜ta是如何判断一个人的呢?简历,相貌,礼仪,还是其他?在我观察了N个之后,终于摸清了一点了,首先当ta接到简历的时候,会在简历的头部标上一个等级,我看的有B3BA2;我想ta标这个是根据简历的舒服感,因为就几秒,ta不可能知道你的内容写什么,所以一份简历的美感很重要,要让人看着舒服;至于面试的问题就只是一些基本情况,还有自己的优势什么的,我想只要稍微有点准备的人都会回答这些问题;或许这就是传说中的海选吧,只要看的还是简历美感,问问题只不过是象征性的过程而已。

    逛了半个小时,同学都说要走了,里面太闷了,在走了的时候,在当乐网的招聘桌子上拿了个笔试地点的条子还有该公司的简介,在我们走时候,我和同学说,今晚我们一起去参加笔试吧,反正又不要钱,玩玩而已;但是他们都说他们不会java,只有一个同学自学过一点,我也N久没有用过java了,最后我们决定两个人去,如是到新校找了本JAVA教程大概浏览了一下,一个小时就看完了一本书,觉得自己还是对里面的知识比较熟悉的。

    吃完饭,我们坐车到了湖大,问了人找到了教室,通知上说630,我们到那的时候是625,到那看到有二十来个人在门口等着了,有些人还在看书,我真服了他们了,走廊灯都没有开,黑黑的,眼睛就不难受吗,我对这个公司的HR有点不满,他妈的,他们居然迟到了10分钟,开了们还不知道灯的开关在哪,找了N分钟;唉,他们怎么做事的啊?有点郁闷!!!!!

    参加笔试的大概有五十多个吧,这又和我想象的又不一样,我想像中的是至少有好几百人,或许是这个公司确实有点搓。卷子发下来了,一看,我靠,这和java压根的就沾不上边啊?只要有点智商的人几乎都可以做了;不过最后交完以后和同学谈起那些题目时,发现我还是做错了不少,交卷的时候是把简历和试卷一起交上去的,同学没有写简历,所以只是交了试卷!由于别人只是招聘应届生,而我不是,我只是想找个实习单位,然后拿它来试试水平的!简历上写的学历是本科在读,不知道HR看到会有啥感想,肯定觉得我是来找茬的!至于会不会有面试的机会,我无所谓了,我只是重在参与,我的目标不是它!

    今天的收获是,感受到了招聘现场的氛围,虽然不是很浩荡,但是也有几十个企业,还参加了一个企业的笔试,最后觉得自己做的确实有点搓,虽然不难!教训就是,永远不要小看了HR的智商,ta既然出了这些题目,那代表这些题目有值得ta出的地方!

    笔试题目(7道简答题,时间1个小时):

    1、左右括号匹配应该使用什么数据结构,为什么?

        这个题目学过数据结构的人都知道用什么了,没有什么技术含量。

    2、有C1,C2,C3,...Cn(分)的硬币,用程序实现K分的使用硬币最少数目的方案

            这个题目思想基本都会,可要用程序来实现的话,而且还是用纸来写代码

      (没有草稿纸啊,他妈的,一个公司连草稿纸都发不起吗)估计一时半会还是

       写不出来的

    3、玩具车购入36元,卖出45元,一个小孩拿了100元去买了个玩具,由于老板

           没有零钱,于是把那100元从邻居那找了100元的零钱,事后,邻居发现100

           元是假的,要老板还回了100元,问最后老板亏了多少钱?

                这个题目,哥那时思想短路了,可能是觉得太简单了,就一下写好了,但

           是最后发现自己算错了

    4、求1+2+4+8+16+32+...+(反正总共14项),并说明方法

            这个题目更无语,估计初中生都会,这不是等比数列吗?

    5、设计一个购物车的接口(只写了方法和参数)

                这题目学过面向对象的、用过网购的几乎都会写出一点点,哥当时就写了

           CURD的几个操作方法。。。

    6、假设你下班时接到上级的一个任务,但是并不知道任务是否重要,但是你已经

       答应了同学晚上一起吃饭,你会怎么做?

             坑爹啊?这难道是一个陷阱

    7、交换ab的值,但不能使用中间变量

                 这个题目,老得不能再老了!

    展开全文
  • ”12月9日,在《中国企业家》杂志举办的“中国企业家领袖”年会——“APP,黄金时代如何掘金”圆桌分论坛上,当乐网CEO肖永泉短短一句话,便语惊四座。在诸多开发商苦苦寻找赢利模式时,相信“赚钱”二字会引起不少...






    “手机游戏的最大特点就是太容易赚到钱。”12月9日,在《中国企业家》杂志举办的“中国企业家领袖”年会——“APP,黄金时代如何掘金”圆桌分论坛上,当乐网CEO肖永泉短短一句话,便语惊四座。在诸多开发商苦苦寻找赢利模式时,相信“赚钱”二字会引起不少人的艳羡。

    手机游戏成移动互联最赚钱模式

    主持人徐浩然指出,将移动互联网单独做为一个话题进行讨论,是在历届“领袖”年会都没有过的。这足以说明“这个时代已经从电脑和TV转移到了掌心,2012可以说是移动网的元年。但是如何赚钱,是否赚钱却是大家最关注的一个话题。”

    今夜酒店特价的创始人任鑫谈到这个问题时委婉的指出:“目前是赚到一些钱,但花的比赚的多。”墨迹天气的创始人金犁,在现场拥有最多的用户数量,但是也坦诚“赢利模式正在摸索中。”VIVA创始人韩颖则认为“目前还没有到赢利的时候。”

    虽然移动互联网市场火热,但台上的移动互联从业者们提到掘金时大多愁眉不展,而当乐网肖永泉聊到这个话题时,话语间却流露着一种喜悦:“手机游戏的最大特点就是太容易赚到钱。手机游戏已经在赚钱,在我们的平台上,今年就上线了三款以上收入过千万的游戏。”几句话博得了台下热烈的掌声。

    无疑,手机游戏已经成为移动互联网最赚钱的模式之一。

    手游掘金,要看好市场机遇

    同时,肖永泉也指出并不是所有的游戏都赚钱,虽然手机游戏赚钱已经不成问题,但是许多开发商开始蜂拥而至,导致手机游戏同质化严重。肖永泉指出,目前当乐网会帮助开发商细分模式、策划运营、做营销及活动等帮助游戏开发者推广自己的游戏,类似B2C的模式来经营。

    而对于移动互联网平台的商机,肖永泉也总结了一条市场规律:“在你没有看清楚的时候,可能还是机会。但等你看明白了,知道他们在做什么了,就已经不是机会了。”移动互联网更新非常快,抓住时机也非常重要。

    找到模式,大流量APP定会赚钱

    徐浩然直言,目前许多PC巨头也已经转战移动互联网,庞大的用户群体给APP开发商也带来不少压力。肖永泉则抱有不同见解:“PC与移动互联网是完全不同的两个平台。Facebook再强大,谷歌(微博)、亚马逊苹果等依然发展的很好,每个企业都有自己的生存之道。当乐从事手机游戏已经8年,许多用户都是跟着当乐一起成长的,粘度非常高,而PC企业因为模式限制,有许多赢利模式他们是做不来的。”

    在论坛的最后,肖永泉指出。“移动互联网史无前例的增加了许多用户群体,例如白发苍苍的老人,甚至一两岁的小孩。移动APP有许多创新,例如位置服务等都是PC做不到的,因此移动互联网的未来是不可否认的,只要有流量。无论你做什么将来都可能会赚到钱,但首先要找到合适的模式。”






    展开全文
  • 人们反应过时了 经过核实的确属实 但任然是开发人员学习的好列子 喜欢研究电脑和手机交互的友友可以带走 ( 该软件已过时,只供代码参考 )
  • 类库整理 jieba分词 github传送门 ...来源说明:来自当乐游戏中心,为啥我不找腾讯的?我找不到。。。这个是api的形式,比较好处理。 爬取说明,直接利用requests请求链接,拿到部分有用的字段存储到 ...
  •  当乐越狱助手的核心功能来自于Evasi0n越狱工具,Evasi0n来自于越狱梦之队打造的作品,当乐网在此基础上针对国内用户,重新在功能以及界面上进行了优化,目的就是为了更符合中国越狱用户的习惯。 4:强大的“售后...
  • 当乐作为老牌的手机游戏平台中心,在资源,质量,资讯等方面在国内一直都是处于最前面的位置,越狱成功之后,你可以尽情的浏览当乐网带给你的软件,游戏大餐,还有丰富的资讯可看,让你及时了解手机平台的发展趋势。...
  • 中国手机游戏用户研究报告2010 本报告由易观国际及当乐网联合发布
  • 本文将从历史、规模、玩家质量等方面全面评测当乐折扣端。曾几何时,当乐在塞班游戏时代(也就是Java手机时代,那个时候还...同时当乐网也是作为网游第一公会,聚集了很多VIP玩家,在各种充值,代充的商人氛围中,...
  • 当乐网自2004年成立,看看2004年有什么,手机还是诺基亚一家独大,大部分玩家可能玩的最多的游戏就是集成在诺基亚手机ROM中的汇编版的贪吃蛇。资深玩家可能还有玩过推箱子,也就不能再多了。 先上干货:当乐网...
  • 当乐APP V8.2新春喜来 约你17来玩!候鸟回迁,游子归乡,中国传统节日春节即将来临。在这个辞旧迎新忙碌的日子里,我们当乐APP也给玩家朋友们做了一点微小的贡献——春节前发布了农历年最后一个版本,希望能给大家带...
  • 程序需要调用以下重要权限:更新组件使用情况统计- 允许程序更新组件使用情况统计请求安装文件包- 允许程序请求安装文件包卸载快捷方式- 允许程序卸载快捷方式安装快捷方式- 允许程序安装快捷方式控制近距离通信- ...
  • [提要] 由成都市人民政府、移动游戏发展联盟、中国移动通信联合会主办,人民网、腾讯网、当乐网共同协办的“2012移动游戏大会”12月20日在成都川投国际酒店隆重举行。Unity 中国区总经理符国新出席2012移动游戏大会...
  • 下载安卓游戏尽在当乐网安卓门户 安卓玩机必备软件钛备份使用教程图文 钛备份玩机必备利器功能强大可以备份手机上任何程序及数据但我们平时用得最多的 就是用来备份自己安装的程序以及程序里的数据这样在刷机的时候...
  • 2007第三届中国优秀无线互联网站点TOP50名单 1 3G门户 2 空中网 3 手机腾讯网 4 手机新浪网 5 当乐网 6 天下网 7 手机搜狐网 8 捉鱼网 9 3G泡泡 10 易查搜索 10 乐讯 11 百度搜索 12 摩网 13 万蝶 14...
  •  顽石CEO吴刚于12月20日参加由当乐网(D.CN)主办的2011“第六届移动游戏产业高峰论坛”,并在大会做主题演讲。本届论坛的主题为:创新、融合、展望。国内外移动游戏界及PC网游大佬,百余高管将聚首成都,共谋移动...
  • * * 从用户职业情况来看学生群体占比达47.3%工人服务业从业人员及军人也成为手机游戏用户重要组成部分 * * 根据艾瑞咨询与当乐网即将联合发布的2008年中国手机游戏用户行为调查报告数据显示男性用户成为手机游戏用户...
  • 最短CN域名在干啥?

    2010-04-28 10:50:00
    a.cn 没有任何网页,经查询该域名已被列入限制注册名单b.cn 中,北京澳美新投资顾问有限公司所有c.cn 中,北京澳美新投资顾问有限公司d.cn 当乐网,手机游戏下载网站e.cn 没有任何网页,经查询该域名已被列入限制...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 327
精华内容 130
关键字:

当乐网