设为首页收藏本站
查看: 3888|回复: 15

【一个很简单的例子】虎牙pwdencrypt加密分析

[复制链接]
  • TA的每日心情

    昨天 10:44
  • 签到天数: 343 天

    [LV.8]以坛为家I

    发表于 2018-3-25 21:58:03 | 显示全部楼层 |阅读模式 赞助商
    本帖最后由 xietao2007gg 于 2018-3-25 22:03 编辑


    密码加密抓包得到
    1. pwdencrypt:6394f4540a1f64cf0ec05d374d4a187501ede650e62ed1a733abffed4c3bdc88071bfd07936b45686bb7c2214863b4a34030dd60dee2e8a5649a4a3295caaeb8a60210e2fe2f21049da52dfbc8948fe07bb9b01d4fa12489d216cad0a1ba650901f78582423403040a1db2578c201fa75569b7a19bbb46314d1a40bfe38168e6
    复制代码


    我们搜索一下pwdencrypt 看看哪一些js包含pwdencrypt发现有一段JS里面包含了pwdencrypt 我们双击进入查看

    我们分析赋值
    1. udbBase.getLocalMxcAll("mm",function(res, code){
    2.                 var succ,nsucc;
    3.                         var post = {
    4.                                 username: acct,
    5.                                 //password: passwd,
    6.                                 pwdencrypt: pwdencryptVal,
    7.                                 oauth_token: opts.oauth_token,
    8.                                 denyCallbackURL: opts.denyCallbackURL,
    9.                                 UIStyle: opts.UIStyle,
    10.                                 appid: opts.appId,
    11.                                 cssid: opts.cssid,
    12.                                 mxc: res,
    13.                                 vk: vktype,
    14.                                 isRemMe: isRemMe,
    15.                                 mmc: res,
    16.                                 vv: ""
    17.                         }
    复制代码

    pwdencrypt: pwdencryptVal,
    找到pwdencryptVal下一个断点

    断下来后发现
    1. UDB.SDK.rsa.RSAUtils.encryptedString()
    复制代码
    函数加密了我们的密码
    进入后查看

    1. RSAUtils.encryptedString(s)
    复制代码
    用户输入密码后 返回加密的密码
    我们把js全部复制粘贴下来进行修改后放入调试器进行验证

    以上是我调试过程,修改了一下js,粘贴复制并不能解决问题,还得学会修改js
    1. var window=window||{};
    2. var that = {};
    3. var RSAUtils = {};
    4. var biRadixBase = 2;
    5. var biRadixBits = 16;
    6. var bitsPerDigit = biRadixBits;
    7. var biRadix = 1 << 16; // = 2^16 = 65536
    8. var biHalfRadix = biRadix >>> 1;
    9. var biRadixSquared = biRadix * biRadix;
    10. var maxDigitVal = biRadix - 1;
    11. var maxInteger = 9999999999999998;

    12. //maxDigits:
    13. //Change this to accommodate your largest number size. Use setMaxDigits()
    14. //to change it!
    15. //
    16. //In general, if you're working with numbers of size N bits, you'll need 2*N
    17. //bits of storage. Each digit holds 16 bits. So, a 1024-bit key will need
    18. //
    19. //1024 * 2 / 16 = 128 digits of storage.
    20. //
    21. var maxDigits;
    22. var ZERO_ARRAY;
    23. var bigZero, bigOne;
    24. var rsaPubkey_m = "b5f53d3e7ab166d99b91bdee1414364e97a5569d9a4da971dcf241e9aec4ee4ee7a27b203f278be7cc695207d19b9209f0e50a3ea367100e06ad635e4ccde6f8a7179d84b7b9b7365a6a7533a9909695f79f3f531ea3c329b7ede2cd9bb9722104e95c0f234f1a72222b0210579f6582fcaa9d8fa62c431a37d88a4899ebce3d";
    25. var rsaPubkey_e = "10001";

    26. var BigInt = that.BigInt = function(flag) {
    27.     if (typeof flag == "boolean" && flag == true) {
    28.         this.digits = null;
    29.     } else {
    30.         this.digits = ZERO_ARRAY.slice(0);
    31.     }
    32.     this.isNeg = false;
    33. };

    34. RSAUtils.setMaxDigits = function(value) {
    35.     maxDigits = value;
    36.     ZERO_ARRAY = new Array(maxDigits);
    37.     for (var iza = 0; iza < ZERO_ARRAY.length; iza++) ZERO_ARRAY[iza] = 0;
    38.     bigZero = new BigInt();
    39.     bigOne = new BigInt();
    40.     bigOne.digits[0] = 1;
    41. };
    42. RSAUtils.setMaxDigits(20);

    43. //The maximum number of digits in base 10 you can convert to an
    44. //integer without JavaScript throwing up on you.
    45. var dpl10 = 15;

    46. RSAUtils.biFromNumber = function(i) {
    47.     var result = new BigInt();
    48.     result.isNeg = i < 0;
    49.     i = Math.abs(i);
    50.     var j = 0;
    51.     while (i > 0) {
    52.         result.digits[j++] = i & maxDigitVal;
    53.         i = Math.floor(i / biRadix);
    54.     }
    55.     return result;
    56. };

    57. //lr10 = 10 ^ dpl10
    58. var lr10 = RSAUtils.biFromNumber(1000000000000000);

    59. RSAUtils.biFromDecimal = function(s) {
    60.     var isNeg = s.charAt(0) == '-';
    61.     var i = isNeg ? 1 : 0;
    62.     var result;
    63.     // Skip leading zeros.
    64.     while (i < s.length && s.charAt(i) == '0') ++i;
    65.     if (i == s.length) {
    66.         result = new BigInt();
    67.     }
    68.     else {
    69.         var digitCount = s.length - i;
    70.         var fgl = digitCount % dpl10;
    71.         if (fgl == 0) fgl = dpl10;
    72.         result = RSAUtils.biFromNumber(Number(s.substr(i, fgl)));
    73.         i += fgl;
    74.         while (i < s.length) {
    75.             result = RSAUtils.biAdd(RSAUtils.biMultiply(result, lr10),
    76.                     RSAUtils.biFromNumber(Number(s.substr(i, dpl10))));
    77.             i += dpl10;
    78.         }
    79.         result.isNeg = isNeg;
    80.     }
    81.     return result;
    82. };

    83. RSAUtils.biCopy = function(bi) {
    84.     var result = new BigInt(true);
    85.     result.digits = bi.digits.slice(0);
    86.     result.isNeg = bi.isNeg;
    87.     return result;
    88. };

    89. RSAUtils.reverseStr = function(s) {
    90.     var result = "";
    91.     for (var i = s.length - 1; i > -1; --i) {
    92.         result += s.charAt(i);
    93.     }
    94.     return result;
    95. };

    96. var hexatrigesimalToChar = [
    97.     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    98.     'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
    99.     'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
    100.     'u', 'v', 'w', 'x', 'y', 'z'
    101. ];

    102. RSAUtils.biToString = function(x, radix) { // 2 <= radix <= 36
    103.     var b = new BigInt();
    104.     b.digits[0] = radix;
    105.     var qr = RSAUtils.biDivideModulo(x, b);
    106.     var result = hexatrigesimalToChar[qr[1].digits[0]];
    107.     while (RSAUtils.biCompare(qr[0], bigZero) == 1) {
    108.         qr = RSAUtils.biDivideModulo(qr[0], b);
    109.         digit = qr[1].digits[0];
    110.         result += hexatrigesimalToChar[qr[1].digits[0]];
    111.     }
    112.     return (x.isNeg ? "-" : "") + RSAUtils.reverseStr(result);
    113. };

    114. RSAUtils.biToDecimal = function(x) {
    115.     var b = new BigInt();
    116.     b.digits[0] = 10;
    117.     var qr = RSAUtils.biDivideModulo(x, b);
    118.     var result = String(qr[1].digits[0]);
    119.     while (RSAUtils.biCompare(qr[0], bigZero) == 1) {
    120.         qr = RSAUtils.biDivideModulo(qr[0], b);
    121.         result += String(qr[1].digits[0]);
    122.     }
    123.     return (x.isNeg ? "-" : "") + RSAUtils.reverseStr(result);
    124. };

    125. var hexToChar = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    126.         'a', 'b', 'c', 'd', 'e', 'f'];

    127. RSAUtils.digitToHex = function(n) {
    128.     var mask = 0xf;
    129.     var result = "";
    130.     for (i = 0; i < 4; ++i) {
    131.         result += hexToChar[n & mask];
    132.         n >>>= 4;
    133.     }
    134.     return RSAUtils.reverseStr(result);
    135. };

    136. RSAUtils.biToHex = function(x) {
    137.     var result = "";
    138.     var n = RSAUtils.biHighIndex(x);
    139.     for (var i = RSAUtils.biHighIndex(x); i > -1; --i) {
    140.         result += RSAUtils.digitToHex(x.digits[i]);
    141.     }
    142.     return result;
    143. };

    144. RSAUtils.charToHex = function(c) {
    145.     var ZERO = 48;
    146.     var NINE = ZERO + 9;
    147.     var littleA = 97;
    148.     var littleZ = littleA + 25;
    149.     var bigA = 65;
    150.     var bigZ = 65 + 25;
    151.     var result;

    152.     if (c >= ZERO && c <= NINE) {
    153.         result = c - ZERO;
    154.     } else if (c >= bigA && c <= bigZ) {
    155.         result = 10 + c - bigA;
    156.     } else if (c >= littleA && c <= littleZ) {
    157.         result = 10 + c - littleA;
    158.     } else {
    159.         result = 0;
    160.     }
    161.     return result;
    162. };

    163. RSAUtils.hexToDigit = function(s) {
    164.     var result = 0;
    165.     var sl = Math.min(s.length, 4);
    166.     for (var i = 0; i < sl; ++i) {
    167.         result <<= 4;
    168.         result |= RSAUtils.charToHex(s.charCodeAt(i));
    169.     }
    170.     return result;
    171. };

    172. RSAUtils.biFromHex = function(s) {
    173.     var result = new BigInt();
    174.     var sl = s.length;
    175.     for (var i = sl, j = 0; i > 0; i -= 4, ++j) {
    176.         result.digits[j] = RSAUtils.hexToDigit(s.substr(Math.max(i - 4, 0), Math.min(i, 4)));
    177.     }
    178.     return result;
    179. };

    180. RSAUtils.biFromString = function(s, radix) {
    181.     var isNeg = s.charAt(0) == '-';
    182.     var istop = isNeg ? 1 : 0;
    183.     var result = new BigInt();
    184.     var place = new BigInt();
    185.     place.digits[0] = 1; // radix^0
    186.     for (var i = s.length - 1; i >= istop; i--) {
    187.         var c = s.charCodeAt(i);
    188.         var digit = RSAUtils.charToHex(c);
    189.         var biDigit = RSAUtils.biMultiplyDigit(place, digit);
    190.         result = RSAUtils.biAdd(result, biDigit);
    191.         place = RSAUtils.biMultiplyDigit(place, radix);
    192.     }
    193.     result.isNeg = isNeg;
    194.     return result;
    195. };

    196. RSAUtils.biDump = function(b) {
    197.     return (b.isNeg ? "-" : "") + b.digits.join(" ");
    198. };

    199. RSAUtils.biAdd = function(x, y) {
    200.     var result;

    201.     if (x.isNeg != y.isNeg) {
    202.         y.isNeg = !y.isNeg;
    203.         result = RSAUtils.biSubtract(x, y);
    204.         y.isNeg = !y.isNeg;
    205.     }
    206.     else {
    207.         result = new BigInt();
    208.         var c = 0;
    209.         var n;
    210.         for (var i = 0; i < x.digits.length; ++i) {
    211.             n = x.digits[i] + y.digits[i] + c;
    212.             result.digits[i] = n % biRadix;
    213.             c = Number(n >= biRadix);
    214.         }
    215.         result.isNeg = x.isNeg;
    216.     }
    217.     return result;
    218. };

    219. RSAUtils.biSubtract = function(x, y) {
    220.     var result;
    221.     if (x.isNeg != y.isNeg) {
    222.         y.isNeg = !y.isNeg;
    223.         result = RSAUtils.biAdd(x, y);
    224.         y.isNeg = !y.isNeg;
    225.     } else {
    226.         result = new BigInt();
    227.         var n, c;
    228.         c = 0;
    229.         for (var i = 0; i < x.digits.length; ++i) {
    230.             n = x.digits[i] - y.digits[i] + c;
    231.             result.digits[i] = n % biRadix;
    232.             // Stupid non-conforming modulus operation.
    233.             if (result.digits[i] < 0) result.digits[i] += biRadix;
    234.             c = 0 - Number(n < 0);
    235.         }
    236.         // Fix up the negative sign, if any.
    237.         if (c == -1) {
    238.             c = 0;
    239.             for (var i = 0; i < x.digits.length; ++i) {
    240.                 n = 0 - result.digits[i] + c;
    241.                 result.digits[i] = n % biRadix;
    242.                 // Stupid non-conforming modulus operation.
    243.                 if (result.digits[i] < 0) result.digits[i] += biRadix;
    244.                 c = 0 - Number(n < 0);
    245.             }
    246.             // Result is opposite sign of arguments.
    247.             result.isNeg = !x.isNeg;
    248.         } else {
    249.             // Result is same sign.
    250.             result.isNeg = x.isNeg;
    251.         }
    252.     }
    253.     return result;
    254. };

    255. RSAUtils.biHighIndex = function(x) {
    256.     var result = x.digits.length - 1;
    257.     while (result > 0 && x.digits[result] == 0) --result;
    258.     return result;
    259. };

    260. RSAUtils.biNumBits = function(x) {
    261.     var n = RSAUtils.biHighIndex(x);
    262.     var d = x.digits[n];
    263.     var m = (n + 1) * bitsPerDigit;
    264.     var result;
    265.     for (result = m; result > m - bitsPerDigit; --result) {
    266.         if ((d & 0x8000) != 0) break;
    267.         d <<= 1;
    268.     }
    269.     return result;
    270. };

    271. RSAUtils.biMultiply = function(x, y) {
    272.     var result = new BigInt();
    273.     var c;
    274.     var n = RSAUtils.biHighIndex(x);
    275.     var t = RSAUtils.biHighIndex(y);
    276.     var u, uv, k;

    277.     for (var i = 0; i <= t; ++i) {
    278.         c = 0;
    279.         k = i;
    280.         for (j = 0; j <= n; ++j, ++k) {
    281.             uv = result.digits[k] + x.digits[j] * y.digits[i] + c;
    282.             result.digits[k] = uv & maxDigitVal;
    283.             c = uv >>> biRadixBits;
    284.             //c = Math.floor(uv / biRadix);
    285.         }
    286.         result.digits[i + n + 1] = c;
    287.     }
    288.     // Someone give me a logical xor, please.
    289.     result.isNeg = x.isNeg != y.isNeg;
    290.     return result;
    291. };

    292. RSAUtils.biMultiplyDigit = function(x, y) {
    293.     var n, c, uv;

    294.     result = new BigInt();
    295.     n = RSAUtils.biHighIndex(x);
    296.     c = 0;
    297.     for (var j = 0; j <= n; ++j) {
    298.         uv = result.digits[j] + x.digits[j] * y + c;
    299.         result.digits[j] = uv & maxDigitVal;
    300.         c = uv >>> biRadixBits;
    301.         //c = Math.floor(uv / biRadix);
    302.     }
    303.     result.digits[1 + n] = c;
    304.     return result;
    305. };

    306. RSAUtils.arrayCopy = function(src, srcStart, dest, destStart, n) {
    307.     var m = Math.min(srcStart + n, src.length);
    308.     for (var i = srcStart, j = destStart; i < m; ++i, ++j) {
    309.         dest[j] = src[i];
    310.     }
    311. };

    312. var highBitMasks = [0x0000, 0x8000, 0xC000, 0xE000, 0xF000, 0xF800,
    313.         0xFC00, 0xFE00, 0xFF00, 0xFF80, 0xFFC0, 0xFFE0,
    314.         0xFFF0, 0xFFF8, 0xFFFC, 0xFFFE, 0xFFFF];

    315. RSAUtils.biShiftLeft = function(x, n) {
    316.     var digitCount = Math.floor(n / bitsPerDigit);
    317.     var result = new BigInt();
    318.     RSAUtils.arrayCopy(x.digits, 0, result.digits, digitCount,
    319.               result.digits.length - digitCount);
    320.     var bits = n % bitsPerDigit;
    321.     var rightBits = bitsPerDigit - bits;
    322.     for (var i = result.digits.length - 1, i1 = i - 1; i > 0; --i, --i1) {
    323.         result.digits[i] = ((result.digits[i] << bits) & maxDigitVal) |
    324.                            ((result.digits[i1] & highBitMasks[bits]) >>>
    325.                             (rightBits));
    326.     }
    327.     result.digits[0] = ((result.digits[i] << bits) & maxDigitVal);
    328.     result.isNeg = x.isNeg;
    329.     return result;
    330. };

    331. var lowBitMasks = [0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F,
    332.         0x003F, 0x007F, 0x00FF, 0x01FF, 0x03FF, 0x07FF,
    333.         0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF];

    334. RSAUtils.biShiftRight = function(x, n) {
    335.     var digitCount = Math.floor(n / bitsPerDigit);
    336.     var result = new BigInt();
    337.     RSAUtils.arrayCopy(x.digits, digitCount, result.digits, 0,
    338.               x.digits.length - digitCount);
    339.     var bits = n % bitsPerDigit;
    340.     var leftBits = bitsPerDigit - bits;
    341.     for (var i = 0, i1 = i + 1; i < result.digits.length - 1; ++i, ++i1) {
    342.         result.digits[i] = (result.digits[i] >>> bits) |
    343.                            ((result.digits[i1] & lowBitMasks[bits]) << leftBits);
    344.     }
    345.     result.digits[result.digits.length - 1] >>>= bits;
    346.     result.isNeg = x.isNeg;
    347.     return result;
    348. };

    349. RSAUtils.biMultiplyByRadixPower = function(x, n) {
    350.     var result = new BigInt();
    351.     RSAUtils.arrayCopy(x.digits, 0, result.digits, n, result.digits.length - n);
    352.     return result;
    353. };

    354. RSAUtils.biDivideByRadixPower = function(x, n) {
    355.     var result = new BigInt();
    356.     RSAUtils.arrayCopy(x.digits, n, result.digits, 0, result.digits.length - n);
    357.     return result;
    358. };

    359. RSAUtils.biModuloByRadixPower = function(x, n) {
    360.     var result = new BigInt();
    361.     RSAUtils.arrayCopy(x.digits, 0, result.digits, 0, n);
    362.     return result;
    363. };

    364. RSAUtils.biCompare = function(x, y) {
    365.     if (x.isNeg != y.isNeg) {
    366.         return 1 - 2 * Number(x.isNeg);
    367.     }
    368.     for (var i = x.digits.length - 1; i >= 0; --i) {
    369.         if (x.digits[i] != y.digits[i]) {
    370.             if (x.isNeg) {
    371.                 return 1 - 2 * Number(x.digits[i] > y.digits[i]);
    372.             } else {
    373.                 return 1 - 2 * Number(x.digits[i] < y.digits[i]);
    374.             }
    375.         }
    376.     }
    377.     return 0;
    378. };

    379. RSAUtils.biDivideModulo = function(x, y) {
    380.     var nb = RSAUtils.biNumBits(x);
    381.     var tb = RSAUtils.biNumBits(y);
    382.     var origYIsNeg = y.isNeg;
    383.     var q, r;
    384.     if (nb < tb) {
    385.         // |x| < |y|
    386.         if (x.isNeg) {
    387.             q = RSAUtils.biCopy(bigOne);
    388.             q.isNeg = !y.isNeg;
    389.             x.isNeg = false;
    390.             y.isNeg = false;
    391.             r = biSubtract(y, x);
    392.             // Restore signs, 'cause they're references.
    393.             x.isNeg = true;
    394.             y.isNeg = origYIsNeg;
    395.         } else {
    396.             q = new BigInt();
    397.             r = RSAUtils.biCopy(x);
    398.         }
    399.         return [q, r];
    400.     }

    401.     q = new BigInt();
    402.     r = x;

    403.     // Normalize Y.
    404.     var t = Math.ceil(tb / bitsPerDigit) - 1;
    405.     var lambda = 0;
    406.     while (y.digits[t] < biHalfRadix) {
    407.         y = RSAUtils.biShiftLeft(y, 1);
    408.         ++lambda;
    409.         ++tb;
    410.         t = Math.ceil(tb / bitsPerDigit) - 1;
    411.     }
    412.     // Shift r over to keep the quotient constant. We'll shift the
    413.     // remainder back at the end.
    414.     r = RSAUtils.biShiftLeft(r, lambda);
    415.     nb += lambda; // Update the bit count for x.
    416.     var n = Math.ceil(nb / bitsPerDigit) - 1;

    417.     var b = RSAUtils.biMultiplyByRadixPower(y, n - t);
    418.     while (RSAUtils.biCompare(r, b) != -1) {
    419.         ++q.digits[n - t];
    420.         r = RSAUtils.biSubtract(r, b);
    421.     }
    422.     for (var i = n; i > t; --i) {
    423.     var ri = (i >= r.digits.length) ? 0 : r.digits[i];
    424.     var ri1 = (i - 1 >= r.digits.length) ? 0 : r.digits[i - 1];
    425.     var ri2 = (i - 2 >= r.digits.length) ? 0 : r.digits[i - 2];
    426.     var yt = (t >= y.digits.length) ? 0 : y.digits[t];
    427.     var yt1 = (t - 1 >= y.digits.length) ? 0 : y.digits[t - 1];
    428.         if (ri == yt) {
    429.             q.digits[i - t - 1] = maxDigitVal;
    430.         } else {
    431.             q.digits[i - t - 1] = Math.floor((ri * biRadix + ri1) / yt);
    432.         }

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

    440.         b = RSAUtils.biMultiplyByRadixPower(y, i - t - 1);
    441.         r = RSAUtils.biSubtract(r, RSAUtils.biMultiplyDigit(b, q.digits[i - t - 1]));
    442.         if (r.isNeg) {
    443.             r = RSAUtils.biAdd(r, b);
    444.             --q.digits[i - t - 1];
    445.         }
    446.     }
    447.     r = RSAUtils.biShiftRight(r, lambda);
    448.     // Fiddle with the signs and stuff to make sure that 0 <= r < y.
    449.     q.isNeg = x.isNeg != origYIsNeg;
    450.     if (x.isNeg) {
    451.         if (origYIsNeg) {
    452.             q = RSAUtils.biAdd(q, bigOne);
    453.         } else {
    454.             q = RSAUtils.biSubtract(q, bigOne);
    455.         }
    456.         y = RSAUtils.biShiftRight(y, lambda);
    457.         r = RSAUtils.biSubtract(y, r);
    458.     }
    459.     // Check for the unbelievably stupid degenerate case of r == -0.
    460.     if (r.digits[0] == 0 && RSAUtils.biHighIndex(r) == 0) r.isNeg = false;

    461.     return [q, r];
    462. };

    463. RSAUtils.biDivide = function(x, y) {
    464.     return RSAUtils.biDivideModulo(x, y)[0];
    465. };

    466. RSAUtils.biModulo = function(x, y) {
    467.     return RSAUtils.biDivideModulo(x, y)[1];
    468. };

    469. RSAUtils.biMultiplyMod = function(x, y, m) {
    470.     return RSAUtils.biModulo(RSAUtils.biMultiply(x, y), m);
    471. };

    472. RSAUtils.biPow = function(x, y) {
    473.     var result = bigOne;
    474.     var a = x;
    475.     while (true) {
    476.         if ((y & 1) != 0) result = RSAUtils.biMultiply(result, a);
    477.         y >>= 1;
    478.         if (y == 0) break;
    479.         a = RSAUtils.biMultiply(a, a);
    480.     }
    481.     return result;
    482. };

    483. RSAUtils.biPowMod = function(x, y, m) {
    484.     var result = bigOne;
    485.     var a = x;
    486.     var k = y;
    487.     while (true) {
    488.         if ((k.digits[0] & 1) != 0) result = RSAUtils.biMultiplyMod(result, a, m);
    489.         k = RSAUtils.biShiftRight(k, 1);
    490.         if (k.digits[0] == 0 && RSAUtils.biHighIndex(k) == 0) break;
    491.         a = RSAUtils.biMultiplyMod(a, a, m);
    492.     }
    493.     return result;
    494. };


    495. that.BarrettMu = function(m) {
    496.     this.modulus = RSAUtils.biCopy(m);
    497.     this.k = RSAUtils.biHighIndex(this.modulus) + 1;
    498.     var b2k = new BigInt();
    499.     b2k.digits[2 * this.k] = 1; // b2k = b^(2k)
    500.     this.mu = RSAUtils.biDivide(b2k, this.modulus);
    501.     this.bkplus1 = new BigInt();
    502.     this.bkplus1.digits[this.k + 1] = 1; // bkplus1 = b^(k+1)
    503.     this.modulo = BarrettMu_modulo;
    504.     this.multiplyMod = BarrettMu_multiplyMod;
    505.     this.powMod = BarrettMu_powMod;
    506. };

    507. function BarrettMu_modulo(x) {
    508.     var $dmath = RSAUtils;
    509.     var q1 = $dmath.biDivideByRadixPower(x, this.k - 1);
    510.     var q2 = $dmath.biMultiply(q1, this.mu);
    511.     var q3 = $dmath.biDivideByRadixPower(q2, this.k + 1);
    512.     var r1 = $dmath.biModuloByRadixPower(x, this.k + 1);
    513.     var r2term = $dmath.biMultiply(q3, this.modulus);
    514.     var r2 = $dmath.biModuloByRadixPower(r2term, this.k + 1);
    515.     var r = $dmath.biSubtract(r1, r2);
    516.     if (r.isNeg) {
    517.         r = $dmath.biAdd(r, this.bkplus1);
    518.     }
    519.     var rgtem = $dmath.biCompare(r, this.modulus) >= 0;
    520.     while (rgtem) {
    521.         r = $dmath.biSubtract(r, this.modulus);
    522.         rgtem = $dmath.biCompare(r, this.modulus) >= 0;
    523.     }
    524.     return r;
    525. }

    526. function BarrettMu_multiplyMod(x, y) {
    527.     /*
    528.     x = this.modulo(x);
    529.     y = this.modulo(y);
    530.     */
    531.     var xy = RSAUtils.biMultiply(x, y);
    532.     return this.modulo(xy);
    533. }

    534. function BarrettMu_powMod(x, y) {
    535.     var result = new BigInt();
    536.     result.digits[0] = 1;
    537.     var a = x;
    538.     var k = y;
    539.     while (true) {
    540.         if ((k.digits[0] & 1) != 0) result = this.multiplyMod(result, a);
    541.         k = RSAUtils.biShiftRight(k, 1);
    542.         if (k.digits[0] == 0 && RSAUtils.biHighIndex(k) == 0) break;
    543.         a = this.multiplyMod(a, a);
    544.     }
    545.     return result;
    546. }

    547. var RSAKeyPair = function(encryptionExponent, decryptionExponent, modulus) {
    548.     var $dmath = RSAUtils;
    549.     this.e = $dmath.biFromHex(encryptionExponent);
    550.     this.d = $dmath.biFromHex(decryptionExponent);
    551.     this.m = $dmath.biFromHex(modulus);
    552.     // We can do two bytes per digit, so
    553.     // chunkSize = 2 * (number of digits in modulus - 1).
    554.     // Since biHighIndex returns the high index, not the number of digits, 1 has
    555.     // already been subtracted.
    556.     this.chunkSize = 2 * $dmath.biHighIndex(this.m);
    557.     this.radix = 16;
    558.     this.barrett = new that.BarrettMu(this.m);
    559. };

    560. RSAUtils.getKeyPair = function(encryptionExponent, decryptionExponent, modulus) {
    561.     return new RSAKeyPair(encryptionExponent, decryptionExponent, modulus);
    562. };

    563. if(typeof that.twoDigit === 'undefined') {
    564.     that.twoDigit = function(n) {
    565.         return (n < 10 ? "0" : "") + String(n);
    566.     };
    567. }

    568. // Altered by Rob Saunders (rob@robsaunders.net). New routine pads the
    569. // string after it has been converted to an array. This fixes an
    570. // incompatibility with Flash MX's ActionScript.
    571. RSAUtils.encryptedString = function(s) {
    572.     if(s == null || RSAUtils.containsChinese(s)){// do not encrypt when contains chinese
    573.         return "";
    574.     }
    575.     s = s.split("").reverse().join("");
    576.     var key = new RSAUtils.getKeyPair(rsaPubkey_e, "", rsaPubkey_m);
    577.     var a = [];
    578.     var sl = s.length;
    579.     var i = 0;
    580.     while (i < sl) {
    581.         a[i] = s.charCodeAt(i);
    582.         i++;
    583.     }

    584.     while (a.length % key.chunkSize != 0) {
    585.         a[i++] = 0;
    586.     }

    587.     var al = a.length;
    588.     var result = "";
    589.     var j, k, block;
    590.     for (i = 0; i < al; i += key.chunkSize) {
    591.         block = new BigInt();
    592.         j = 0;
    593.         for (k = i; k < i + key.chunkSize; ++j) {
    594.             block.digits[j] = a[k++];
    595.             block.digits[j] += a[k++] << 8;
    596.         }
    597.         var crypt = key.barrett.powMod(block, key.e);
    598.         var text = key.radix == 16 ? RSAUtils.biToHex(crypt) : RSAUtils.biToString(crypt, key.radix);
    599.         result += text + " ";
    600.     }
    601.     result = result.substring(0, result.length - 1);// Remove last space.
    602.     if(result.length == 256){// when result.length not pubkey.length, it is wrong!
    603.         return result;
    604.     }else if(result.length == 252){  // 个别特殊字符串(如dlknfk101) 加密左边会少4个0000,补齐
    605.         return "0000" + result;
    606.     }else{
    607.         return "";
    608.     }
    609.    
    610. };

    611. RSAUtils.decryptedString = function(key, s) {
    612.     var blocks = s.split(" ");
    613.     var result = "";
    614.     var i, j, block;
    615.     for (i = 0; i < blocks.length; ++i) {
    616.         var bi;
    617.         if (key.radix == 16) {
    618.             bi = RSAUtils.biFromHex(blocks[i]);
    619.         }
    620.         else {
    621.             bi = RSAUtils.biFromString(blocks[i], key.radix);
    622.         }
    623.         block = key.barrett.powMod(bi, key.d);
    624.         for (j = 0; j <= RSAUtils.biHighIndex(block); ++j) {
    625.             result += String.fromCharCode(block.digits[j] & 255,
    626.                                           block.digits[j] >> 8);
    627.         }
    628.     }
    629.     // Remove trailing null, if any.
    630.     if (result.charCodeAt(result.length - 1) == 0) {
    631.         result = result.substring(0, result.length - 1);
    632.     }
    633.     return result;
    634. };

    635. RSAUtils.containsChinese = function(data) {
    636.     if(data == null || data.length == 0){
    637.         return false;
    638.     }
    639.    
    640.     var dataArr = data.split("");
    641.     for(var i = 0; i < dataArr.length; i++){
    642.        var tmp = dataArr[i];
    643.        if(RSAUtils.isChinese(dataArr[i])){
    644.            return true;
    645.        }
    646.    }
    647.    return false;
    648. };
    649.    
    650. RSAUtils.isChinese = function(temp) {
    651.    if(temp.charCodeAt(0) > 255){
    652.         return true ;
    653.    }else  {
    654.         return false;
    655.    }
    656. };


    657. var NS = function(ns, hld) {
    658.     var arr = ['window'];
    659.     ns = ns.split(".");
    660.    
    661.     while(ns.length != 1) {
    662.         arr.push(ns.shift());

    663.         if (eval(arr.join('.')) == null) {
    664.             eval(arr.join(".") + " = {};");
    665.         }
    666.     }

    667.     arr.push(ns.shift());
    668.     eval(arr.join(".") + " = hld;");
    669. }
    670. //RSAUtils.setMaxDigits(130);
    671. RSAUtils.setMaxDigits(200);
    672. that.registerNS = NS;
    673. that.RSAUtils = RSAUtils;
    674. that.registerNS("UDB.SDK.rsa", that);
    复制代码

    本帖子中包含更多资源

    您需要 登录 才可以下载或查看,没有帐号?注册

    x

    点评

    大佬厉害~!  发表于 2018-3-26 09:37
  • TA的每日心情

    昨天 10:44
  • 签到天数: 343 天

    [LV.8]以坛为家I

     楼主| 发表于 2018-3-25 22:01:58 | 显示全部楼层 赞助商
    这里主要掌握的就是 断点调试 和 js的修改 我觉得可能让很多新手朋友很难掌握 下次有时间录个视频给各位 希望能帮助各位学到更多知识
    授人以鱼,不如授之以渔
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    慵懒
    2019-5-25 20:06
  • 签到天数: 14 天

    [LV.3]偶尔看看II

    发表于 2018-3-25 22:34:56 | 显示全部楼层
    大佬今天没直播么?
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    奋斗
    2019-12-2 23:16
  • 签到天数: 282 天

    [LV.8]以坛为家I

    发表于 2018-3-25 22:35:10 | 显示全部楼层
    授人以鱼,不如授之以渔
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    昨天 10:44
  • 签到天数: 343 天

    [LV.8]以坛为家I

     楼主| 发表于 2018-3-25 22:43:45 | 显示全部楼层 赞助商
    asdasfsf 发表于 2018-3-25 22:34
    大佬今天没直播么?

    我不是讲师
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    开心
    2018-7-19 22:34
  • 签到天数: 65 天

    [LV.6]常住居民II

    发表于 2018-3-25 23:43:33 | 显示全部楼层
    多谢,长见识了,下次可以试下
    回复 支持 反对

    使用道具 举报

  • TA的每日心情

    2018-9-27 14:29
  • 签到天数: 129 天

    [LV.7]常住居民III

    发表于 2018-4-4 16:23:01 | 显示全部楼层
    谢谢楼主分享心得
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    郁闷
    2018-9-27 11:18
  • 签到天数: 26 天

    [LV.4]偶尔看看III

    发表于 2018-5-25 16:58:13 | 显示全部楼层
    开阔了眼界。
    回复 支持 反对

    使用道具 举报

  • TA的每日心情
    慵懒
    昨天 09:27
  • 签到天数: 484 天

    [LV.9]以坛为家II

    发表于 2018-5-26 09:39:12 来自手机 | 显示全部楼层
    怎么才能知道加密方式呢?
    回复 支持 反对

    使用道具 举报

    您需要登录后才可以回帖 登录 | 注册

    本版积分规则

    关闭

    站长推荐 上一条 /1 下一条

    红盟社区--中国红客联盟 

    Processed in 0.087506 second(s), 31 queries.

    站点统计| 举报| Archiver| 手机版| 黑屋 |   

    Powered by HUC © 2001-2017 Comsenz Inc.

    手机扫我进入移动触屏客户端

    关注我们可获取更多热点资讯

    Honor accompaniments. theme macfee

    快速回复 返回顶部 返回列表