一、站点分析

  MTime 时光网是一个电影媒体与电商服务平台,而这次做的模拟登录则是依靠其手机端站点,站点地址为:https://m.mtime.cn/#。切换到登录页面,再分别输入账号和错误的密码,点击登录,登录失败,截图如下:

  【Python3爬虫】破解时光网登录加密参数并实现模拟登录 Python 第1张

SRE实战 互联网时代守护先锋,助力企业售后服务体系运筹帷幄!一键直达领取阿里云限量特价优惠。

  打开开发者工具, 选择“Network”,切换到“XHR”选项,找到一条名为 login.api 的请求,打开后可以发现就是登录所发送的请求,再查看该请求的参数部分,截图如下:

  【Python3爬虫】破解时光网登录加密参数并实现模拟登录 Python 第2张

 

二、参数破解

1.参数分析

  经过前面的分析可知有五个参数需要获取,分别是 t、name、password、code 和 codeId,其中 code 和 codeId 目前看来是空的,无须处理,而 name 就是输入的手机号,password 应该是输入的密码加密后的结果,剩下一个 t 还不知道是什么含义。

2.参数获取

  在开发者工具中,Ctrl + F 全局搜索“password”,找到如下的 JavaScript 文件:

https://static3.mtime.cn/html5/20200116143308/js/views/member/signin.js

  打开该文件后搜索“password”,首先是获取 name 属性为“password”的输入框,在下文中还发现了 vcode 和 vcodeId,这两个就是后面请求所需的 code 和 vcode 参数的值,截图如下:

  【Python3爬虫】破解时光网登录加密参数并实现模拟登录 Python 第3张

  继续搜索“password”,可以找到一个 getPassword() 方法,用于获取输入的密码内容,截图如下:   

  【Python3爬虫】破解时光网登录加密参数并实现模拟登录 Python 第4张

  接着搜索“password”,找到如下内容:

  【Python3爬虫】破解时光网登录加密参数并实现模拟登录 Python 第5张

  这就是登录请求时的参数部分,其中密码 password 是将输入的密码进行加密后的结果,使用的是 f.desEcbPkcs7 方法,那这个方法具体是什么呢?

3.加密方法

  在上面的 JS 文件中的 217 行打上断点,然后刷新页面并重新登录,页面会进入 debugger 模式,然后选中 desEcbPkcs7 部分,点击后跳转到 app.all.min.js 中的如下代码部分:

  【Python3爬虫】破解时光网登录加密参数并实现模拟登录 Python 第6张

  这个 af 函数就是加密方法了,其中用到了一个变量 CryptoJS,要获取这个变量的定义,就在上面代码中的1033行打上断点,再重新登录一遍,定位到 CryptoJS 的定义部分,截图如下:

  【Python3爬虫】破解时光网登录加密参数并实现模拟登录 Python 第7张

  对于变量 CryptoJS 的定义包含在 libs.all.min.js 中,但这个文件中的代码量比较大,若全部复制下来使用会不方便,而我们也只需要得到对变量 CryptoJS 进行定义的代码就够了,所以建议先把该 JS 文件保存到本地,再用编辑器打开,就能很快地得到我们所需要的代码了,即使如此还是有一千四百多行(汗~)。

【Python3爬虫】破解时光网登录加密参数并实现模拟登录 Python 第8张
   1 var CryptoJS = CryptoJS || function (g, w) {
   2     var m = {}
   3         , q = m.lib = {}
   4         , j = q.Base = function () {
   5         function a() {
   6         }
   7 
   8         return {
   9             extend: function (e) {
  10                 a.prototype = this;
  11                 var c = new a;
  12                 return e && c.mixIn(e),
  13                     c.$super = this,
  14                     c
  15             },
  16             create: function () {
  17                 var c = this.extend();
  18                 return c.init.apply(c, arguments),
  19                     c
  20             },
  21             init: function () {
  22             },
  23             mixIn: function (c) {
  24                 for (var f in c) {
  25                     c.hasOwnProperty(f) && (this[f] = c[f])
  26                 }
  27                 c.hasOwnProperty("toString") && (this.toString = c.toString)
  28             },
  29             clone: function () {
  30                 return this.$super.extend(this)
  31             }
  32         }
  33     }()
  34         , v = q.WordArray = j.extend({
  35         init: function (a, c) {
  36             a = this.words = a || [],
  37                 this.sigBytes = c != w ? c : 4 * a.length
  38         },
  39         toString: function (a) {
  40             return (a || x).stringify(this)
  41         },
  42         concat: function (a) {
  43             var o = this.words
  44                 , f = a.words
  45                 , l = this.sigBytes
  46                 , a = a.sigBytes;
  47             this.clamp();
  48             if (l % 4) {
  49                 for (var c = 0; c < a; c++) {
  50                     o[l + c >>> 2] |= (f[c >>> 2] >>> 24 - 8 * (c % 4) & 255) << 24 - 8 * ((l + c) % 4)
  51                 }
  52             } else {
  53                 if (65535 < f.length) {
  54                     for (c = 0; c < a; c += 4) {
  55                         o[l + c >>> 2] = f[c >>> 2]
  56                     }
  57                 } else {
  58                     o.push.apply(o, f)
  59                 }
  60             }
  61             return this.sigBytes += a,
  62                 this
  63         },
  64         clamp: function () {
  65             var c = this.words
  66                 , a = this.sigBytes;
  67             c[a >>> 2] &= 4294967295 << 32 - 8 * (a % 4),
  68                 c.length = g.ceil(a / 4)
  69         },
  70         clone: function () {
  71             var a = j.clone.call(this);
  72             return a.words = this.words.slice(0),
  73                 a
  74         },
  75         random: function (e) {
  76             for (var a = [], c = 0; c < e; c += 4) {
  77                 a.push(4294967296 * g.random() | 0)
  78             }
  79             return v.create(a, e)
  80         }
  81     })
  82         , p = m.enc = {}
  83         , x = p.Hex = {
  84         stringify: function (a) {
  85             for (var o = a.words, a = a.sigBytes, f = [], l = 0; l < a; l++) {
  86                 var c = o[l >>> 2] >>> 24 - 8 * (l % 4) & 255;
  87                 f.push((c >>> 4).toString(16)),
  88                     f.push((c & 15).toString(16))
  89             }
  90             return f.join("")
  91         },
  92         parse: function (a) {
  93             for (var i = a.length, c = [], f = 0; f < i; f += 2) {
  94                 c[f >>> 3] |= parseInt(a.substr(f, 2), 16) << 24 - 4 * (f % 8)
  95             }
  96             return v.create(c, i / 2)
  97         }
  98     }
  99         , b = p.Latin1 = {
 100         stringify: function (a) {
 101             for (var i = a.words, a = a.sigBytes, c = [], f = 0; f < a; f++) {
 102                 c.push(String.fromCharCode(i[f >>> 2] >>> 24 - 8 * (f % 4) & 255))
 103             }
 104             return c.join("")
 105         },
 106         parse: function (a) {
 107             for (var i = a.length, c = [], f = 0; f < i; f++) {
 108                 c[f >>> 2] |= (a.charCodeAt(f) & 255) << 24 - 8 * (f % 4)
 109             }
 110             return v.create(c, i)
 111         }
 112     }
 113         , h = p.Utf8 = {
 114         stringify: function (a) {
 115             try {
 116                 return decodeURIComponent(escape(b.stringify(a)))
 117             } catch (c) {
 118                 throw Error("Malformed UTF-8 data")
 119             }
 120         },
 121         parse: function (a) {
 122             return b.parse(unescape(encodeURIComponent(a)))
 123         }
 124     }
 125         , k = q.BufferedBlockAlgorithm = j.extend({
 126         reset: function () {
 127             this._data = v.create(),
 128                 this._nDataBytes = 0
 129         },
 130         _append: function (a) {
 131             "string" == typeof a && (a = h.parse(a)),
 132                 this._data.concat(a),
 133                 this._nDataBytes += a.sigBytes
 134         },
 135         _process: function (y) {
 136             var f = this._data
 137                 , s = f.words
 138                 , e = f.sigBytes
 139                 , l = this.blockSize
 140                 , z = e / (4 * l)
 141                 , z = y ? g.ceil(z) : g.max((z | 0) - this._minBufferSize, 0)
 142                 , y = z * l
 143                 , e = g.min(4 * y, e);
 144             if (y) {
 145                 for (var c = 0; c < y; c += l) {
 146                     this._doProcessBlock(s, c)
 147                 }
 148                 c = s.splice(0, y),
 149                     f.sigBytes -= e
 150             }
 151             return v.create(c, e)
 152         },
 153         clone: function () {
 154             var a = j.clone.call(this);
 155             return a._data = this._data.clone(),
 156                 a
 157         },
 158         _minBufferSize: 0
 159     });
 160     q.Hasher = k.extend({
 161         init: function () {
 162             this.reset()
 163         },
 164         reset: function () {
 165             k.reset.call(this),
 166                 this._doReset()
 167         },
 168         update: function (a) {
 169             return this._append(a),
 170                 this._process(),
 171                 this
 172         },
 173         finalize: function (a) {
 174             return a && this._append(a),
 175                 this._doFinalize(),
 176                 this._hash
 177         },
 178         clone: function () {
 179             var a = k.clone.call(this);
 180             return a._hash = this._hash.clone(),
 181                 a
 182         },
 183         blockSize: 16,
 184         _createHelper: function (a) {
 185             return function (e, c) {
 186                 return a.create(c).finalize(e)
 187             }
 188         },
 189         _createHmacHelper: function (a) {
 190             return function (e, c) {
 191                 return d.HMAC.create(a, c).finalize(e)
 192             }
 193         }
 194     });
 195     var d = m.algo = {};
 196     return m
 197 }(Math)
 198     , CryptoJS = CryptoJS || function (g, w) {
 199     var m = {}
 200         , q = m.lib = {}
 201         , j = q.Base = function () {
 202         function a() {
 203         }
 204 
 205         return {
 206             extend: function (e) {
 207                 a.prototype = this;
 208                 var c = new a;
 209                 return e && c.mixIn(e),
 210                     c.$super = this,
 211                     c
 212             },
 213             create: function () {
 214                 var c = this.extend();
 215                 return c.init.apply(c, arguments),
 216                     c
 217             },
 218             init: function () {
 219             },
 220             mixIn: function (c) {
 221                 for (var f in c) {
 222                     c.hasOwnProperty(f) && (this[f] = c[f])
 223                 }
 224                 c.hasOwnProperty("toString") && (this.toString = c.toString)
 225             },
 226             clone: function () {
 227                 return this.$super.extend(this)
 228             }
 229         }
 230     }()
 231         , v = q.WordArray = j.extend({
 232         init: function (a, c) {
 233             a = this.words = a || [],
 234                 this.sigBytes = c != w ? c : 4 * a.length
 235         },
 236         toString: function (a) {
 237             return (a || x).stringify(this)
 238         },
 239         concat: function (a) {
 240             var o = this.words
 241                 , f = a.words
 242                 , l = this.sigBytes
 243                 , a = a.sigBytes;
 244             this.clamp();
 245             if (l % 4) {
 246                 for (var c = 0; c < a; c++) {
 247                     o[l + c >>> 2] |= (f[c >>> 2] >>> 24 - 8 * (c % 4) & 255) << 24 - 8 * ((l + c) % 4)
 248                 }
 249             } else {
 250                 if (65535 < f.length) {
 251                     for (c = 0; c < a; c += 4) {
 252                         o[l + c >>> 2] = f[c >>> 2]
 253                     }
 254                 } else {
 255                     o.push.apply(o, f)
 256                 }
 257             }
 258             return this.sigBytes += a,
 259                 this
 260         },
 261         clamp: function () {
 262             var c = this.words
 263                 , a = this.sigBytes;
 264             c[a >>> 2] &= 4294967295 << 32 - 8 * (a % 4),
 265                 c.length = g.ceil(a / 4)
 266         },
 267         clone: function () {
 268             var a = j.clone.call(this);
 269             return a.words = this.words.slice(0),
 270                 a
 271         },
 272         random: function (e) {
 273             for (var a = [], c = 0; c < e; c += 4) {
 274                 a.push(4294967296 * g.random() | 0)
 275             }
 276             return v.create(a, e)
 277         }
 278     })
 279         , p = m.enc = {}
 280         , x = p.Hex = {
 281         stringify: function (a) {
 282             for (var o = a.words, a = a.sigBytes, f = [], l = 0; l < a; l++) {
 283                 var c = o[l >>> 2] >>> 24 - 8 * (l % 4) & 255;
 284                 f.push((c >>> 4).toString(16)),
 285                     f.push((c & 15).toString(16))
 286             }
 287             return f.join("")
 288         },
 289         parse: function (a) {
 290             for (var i = a.length, c = [], f = 0; f < i; f += 2) {
 291                 c[f >>> 3] |= parseInt(a.substr(f, 2), 16) << 24 - 4 * (f % 8)
 292             }
 293             return v.create(c, i / 2)
 294         }
 295     }
 296         , b = p.Latin1 = {
 297         stringify: function (a) {
 298             for (var i = a.words, a = a.sigBytes, c = [], f = 0; f < a; f++) {
 299                 c.push(String.fromCharCode(i[f >>> 2] >>> 24 - 8 * (f % 4) & 255))
 300             }
 301             return c.join("")
 302         },
 303         parse: function (a) {
 304             for (var i = a.length, c = [], f = 0; f < i; f++) {
 305                 c[f >>> 2] |= (a.charCodeAt(f) & 255) << 24 - 8 * (f % 4)
 306             }
 307             return v.create(c, i)
 308         }
 309     }
 310         , h = p.Utf8 = {
 311         stringify: function (a) {
 312             try {
 313                 return decodeURIComponent(escape(b.stringify(a)))
 314             } catch (c) {
 315                 throw Error("Malformed UTF-8 data")
 316             }
 317         },
 318         parse: function (a) {
 319             return b.parse(unescape(encodeURIComponent(a)))
 320         }
 321     }
 322         , k = q.BufferedBlockAlgorithm = j.extend({
 323         reset: function () {
 324             this._data = v.create(),
 325                 this._nDataBytes = 0
 326         },
 327         _append: function (a) {
 328             "string" == typeof a && (a = h.parse(a)),
 329                 this._data.concat(a),
 330                 this._nDataBytes += a.sigBytes
 331         },
 332         _process: function (y) {
 333             var f = this._data
 334                 , s = f.words
 335                 , e = f.sigBytes
 336                 , l = this.blockSize
 337                 , z = e / (4 * l)
 338                 , z = y ? g.ceil(z) : g.max((z | 0) - this._minBufferSize, 0)
 339                 , y = z * l
 340                 , e = g.min(4 * y, e);
 341             if (y) {
 342                 for (var c = 0; c < y; c += l) {
 343                     this._doProcessBlock(s, c)
 344                 }
 345                 c = s.splice(0, y),
 346                     f.sigBytes -= e
 347             }
 348             return v.create(c, e)
 349         },
 350         clone: function () {
 351             var a = j.clone.call(this);
 352             return a._data = this._data.clone(),
 353                 a
 354         },
 355         _minBufferSize: 0
 356     });
 357     q.Hasher = k.extend({
 358         init: function () {
 359             this.reset()
 360         },
 361         reset: function () {
 362             k.reset.call(this),
 363                 this._doReset()
 364         },
 365         update: function (a) {
 366             return this._append(a),
 367                 this._process(),
 368                 this
 369         },
 370         finalize: function (a) {
 371             return a && this._append(a),
 372                 this._doFinalize(),
 373                 this._hash
 374         },
 375         clone: function () {
 376             var a = k.clone.call(this);
 377             return a._hash = this._hash.clone(),
 378                 a
 379         },
 380         blockSize: 16,
 381         _createHelper: function (a) {
 382             return function (e, c) {
 383                 return a.create(c).finalize(e)
 384             }
 385         },
 386         _createHmacHelper: function (a) {
 387             return function (e, c) {
 388                 return d.HMAC.create(a, c).finalize(e)
 389             }
 390         }
 391     });
 392     var d = m.algo = {};
 393     return m
 394 }(Math);
 395 (function () {
 396         var a = CryptoJS
 397             , b = a.lib.WordArray;
 398         a.enc.Base64 = {
 399             stringify: function (c) {
 400                 var k = c.words
 401                     , f = c.sigBytes
 402                     , h = this._map;
 403                 c.clamp();
 404                 for (var c = [], d = 0; d < f; d += 3) {
 405                     for (var j = (k[d >>> 2] >>> 24 - 8 * (d % 4) & 255) << 16 | (k[d + 1 >>> 2] >>> 24 - 8 * ((d + 1) % 4) & 255) << 8 | k[d + 2 >>> 2] >>> 24 - 8 * ((d + 2) % 4) & 255, g = 0; 4 > g && d + 0.75 * g < f; g++) {
 406                         c.push(h.charAt(j >>> 6 * (3 - g) & 63))
 407                     }
 408                 }
 409                 if (k = h.charAt(64)) {
 410                     for (; c.length % 4;) {
 411                         c.push(k)
 412                     }
 413                 }
 414                 return c.join("")
 415             },
 416             parse: function (d) {
 417                 var d = d.replace(/\s/g, "")
 418                     , h = d.length
 419                     , j = this._map
 420                     , k = j.charAt(64);
 421                 k && (k = d.indexOf(k),
 422                 -1 != k && (h = k));
 423                 for (var k = [], i = 0, l = 0; l < h; l++) {
 424                     if (l % 4) {
 425                         var c = j.indexOf(d.charAt(l - 1)) << 2 * (l % 4)
 426                             , g = j.indexOf(d.charAt(l)) >>> 6 - 2 * (l % 4);
 427                         k[i >>> 2] |= (c | g) << 24 - 8 * (i % 4),
 428                             i++
 429                     }
 430                 }
 431                 return b.create(k, i)
 432             },
 433             _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
 434         }
 435     }
 436 )(),
 437     function (c) {
 438         function m(a, x, q, v, f, w, u) {
 439             return a = a + (x & q | ~x & v) + f + u,
 440             (a << w | a >>> 32 - w) + x
 441         }
 442 
 443         function h(a, x, q, v, f, w, u) {
 444             return a = a + (x & v | q & ~v) + f + u,
 445             (a << w | a >>> 32 - w) + x
 446         }
 447 
 448         function k(a, x, q, v, f, w, u) {
 449             return a = a + (x ^ q ^ v) + f + u,
 450             (a << w | a >>> 32 - w) + x
 451         }
 452 
 453         function g(a, x, q, v, f, w, u) {
 454             return a = a + (q ^ (x | ~v)) + f + u,
 455             (a << w | a >>> 32 - w) + x
 456         }
 457 
 458         var l = CryptoJS
 459             , j = l.lib
 460             , p = j.WordArray
 461             , j = j.Hasher
 462             , b = l.algo
 463             , d = [];
 464         (function () {
 465                 for (var a = 0; 64 > a; a++) {
 466                     d[a] = 4294967296 * c.abs(c.sin(a + 1)) | 0
 467                 }
 468             }
 469         )(),
 470             b = b.MD5 = j.extend({
 471                 _doReset: function () {
 472                     this._hash = p.create([1732584193, 4023233417, 2562383102, 271733878])
 473                 },
 474                 _doProcessBlock: function (q, v) {
 475                     for (var t = 0; 16 > t; t++) {
 476                         var w = v + t
 477                             , f = q[w];
 478                         q[w] = (f << 8 | f >>> 24) & 16711935 | (f << 24 | f >>> 8) & 4278255360
 479                     }
 480                     for (var w = this._hash.words, f = w[0], r = w[1], i = w[2], n = w[3], t = 0; 64 > t; t += 4) {
 481                         16 > t ? (f = m(f, r, i, n, q[v + t], 7, d[t]),
 482                             n = m(n, f, r, i, q[v + t + 1], 12, d[t + 1]),
 483                             i = m(i, n, f, r, q[v + t + 2], 17, d[t + 2]),
 484                             r = m(r, i, n, f, q[v + t + 3], 22, d[t + 3])) : 32 > t ? (f = h(f, r, i, n, q[v + (t + 1) % 16], 5, d[t]),
 485                             n = h(n, f, r, i, q[v + (t + 6) % 16], 9, d[t + 1]),
 486                             i = h(i, n, f, r, q[v + (t + 11) % 16], 14, d[t + 2]),
 487                             r = h(r, i, n, f, q[v + t % 16], 20, d[t + 3])) : 48 > t ? (f = k(f, r, i, n, q[v + (3 * t + 5) % 16], 4, d[t]),
 488                             n = k(n, f, r, i, q[v + (3 * t + 8) % 16], 11, d[t + 1]),
 489                             i = k(i, n, f, r, q[v + (3 * t + 11) % 16], 16, d[t + 2]),
 490                             r = k(r, i, n, f, q[v + (3 * t + 14) % 16], 23, d[t + 3])) : (f = g(f, r, i, n, q[v + 3 * t % 16], 6, d[t]),
 491                             n = g(n, f, r, i, q[v + (3 * t + 7) % 16], 10, d[t + 1]),
 492                             i = g(i, n, f, r, q[v + (3 * t + 14) % 16], 15, d[t + 2]),
 493                             r = g(r, i, n, f, q[v + (3 * t + 5) % 16], 21, d[t + 3]))
 494                     }
 495                     w[0] = w[0] + f | 0,
 496                         w[1] = w[1] + r | 0,
 497                         w[2] = w[2] + i | 0,
 498                         w[3] = w[3] + n | 0
 499                 },
 500                 _doFinalize: function () {
 501                     var a = this._data
 502                         , o = a.words
 503                         , f = 8 * this._nDataBytes
 504                         , i = 8 * a.sigBytes;
 505                     o[i >>> 5] |= 128 << 24 - i % 32,
 506                         o[(i + 64 >>> 9 << 4) + 14] = (f << 8 | f >>> 24) & 16711935 | (f << 24 | f >>> 8) & 4278255360,
 507                         a.sigBytes = 4 * (o.length + 1),
 508                         this._process(),
 509                         a = this._hash.words;
 510                     for (o = 0; 4 > o; o++) {
 511                         f = a[o],
 512                             a[o] = (f << 8 | f >>> 24) & 16711935 | (f << 24 | f >>> 8) & 4278255360
 513                     }
 514                 }
 515             }),
 516             l.MD5 = j._createHelper(b),
 517             l.HmacMD5 = j._createHmacHelper(b)
 518     }(Math),
 519     function () {
 520         var a = CryptoJS
 521             , f = a.lib
 522             , c = f.Base
 523             , d = f.WordArray
 524             , f = a.algo
 525             , b = f.EvpKDF = c.extend({
 526             cfg: c.extend({
 527                 keySize: 4,
 528                 hasher: f.MD5,
 529                 iterations: 1
 530             }),
 531             init: function (g) {
 532                 this.cfg = this.cfg.extend(g)
 533             },
 534             compute: function (h, q) {
 535                 for (var l = this.cfg, k = l.hasher.create(), p = d.create(), m = p.words, r = l.keySize, l = l.iterations; m.length < r;) {
 536                     g && k.update(g);
 537                     var g = k.update(h).finalize(q);
 538                     k.reset();
 539                     for (var j = 1; j < l; j++) {
 540                         g = k.finalize(g),
 541                             k.reset()
 542                     }
 543                     p.concat(g)
 544                 }
 545                 return p.sigBytes = 4 * r,
 546                     p
 547             }
 548         });
 549         a.EvpKDF = function (g, i, h) {
 550             return b.create(h).compute(g, i)
 551         }
 552     }(),
 553 CryptoJS.lib.Cipher || function (k) {
 554     var C = CryptoJS
 555         , x = C.lib
 556         , A = x.Base
 557         , v = x.WordArray
 558         , B = x.BufferedBlockAlgorithm
 559         , y = C.enc.Base64
 560         , D = C.algo.EvpKDF
 561         , b = x.Cipher = B.extend({
 562         cfg: A.extend(),
 563         createEncryptor: function (a, c) {
 564             return this.create(this._ENC_XFORM_MODE, a, c)
 565         },
 566         createDecryptor: function (a, c) {
 567             return this.create(this._DEC_XFORM_MODE, a, c)
 568         },
 569         init: function (a, d, c) {
 570             this.cfg = this.cfg.extend(c),
 571                 this._xformMode = a,
 572                 this._key = d,
 573                 this.reset()
 574         },
 575         reset: function () {
 576             B.reset.call(this),
 577                 this._doReset()
 578         },
 579         process: function (a) {
 580             return this._append(a),
 581                 this._process()
 582         },
 583         finalize: function (a) {
 584             return a && this._append(a),
 585                 this._doFinalize()
 586         },
 587         keySize: 4,
 588         ivSize: 4,
 589         _ENC_XFORM_MODE: 1,
 590         _DEC_XFORM_MODE: 2,
 591         _createHelper: function () {
 592             return function (a) {
 593                 return {
 594                     encrypt: function (e, c, d) {
 595                         return ("string" == typeof c ? j : z).encrypt(a, e, c, d)
 596                     },
 597                     decrypt: function (e, c, d) {
 598                         return ("string" == typeof c ? j : z).decrypt(a, e, c, d)
 599                     }
 600                 }
 601             }
 602         }()
 603     });
 604     x.StreamCipher = b.extend({
 605         _doFinalize: function () {
 606             return this._process(!0)
 607         },
 608         blockSize: 1
 609     });
 610     var m = C.mode = {}
 611         , w = x.BlockCipherMode = A.extend({
 612         createEncryptor: function (a, c) {
 613             return this.Encryptor.create(a, c)
 614         },
 615         createDecryptor: function (a, c) {
 616             return this.Decryptor.create(a, c)
 617         },
 618         init: function (a, c) {
 619             this._cipher = a,
 620                 this._iv = c
 621         }
 622     })
 623         , m = m.CBC = function () {
 624         function c(l, e, f) {
 625             var d = this._iv;
 626             d ? this._iv = k : d = this._prevBlock;
 627             for (var h = 0; h < f; h++) {
 628                 l[e + h] ^= d[h]
 629             }
 630         }
 631 
 632         var a = w.extend();
 633         return a.Encryptor = a.extend({
 634             processBlock: function (d, h) {
 635                 var l = this._cipher
 636                     , f = l.blockSize;
 637                 c.call(this, d, h, f),
 638                     l.encryptBlock(d, h),
 639                     this._prevBlock = d.slice(h, h + f)
 640             }
 641         }),
 642             a.Decryptor = a.extend({
 643                 processBlock: function (d, h) {
 644                     var l = this._cipher
 645                         , f = l.blockSize
 646                         , o = d.slice(h, h + f);
 647                     l.decryptBlock(d, h),
 648                         c.call(this, d, h, f),
 649                         this._prevBlock = o
 650                 }
 651             }),
 652             a
 653     }()
 654         , g = (C.pad = {}).Pkcs7 = {
 655         pad: function (a, i) {
 656             for (var c = 4 * i, c = c - a.sigBytes % c, f = c << 24 | c << 16 | c << 8 | c, h = [], d = 0; d < c; d += 4) {
 657                 h.push(f)
 658             }
 659             c = v.create(h, c),
 660                 a.concat(c)
 661         },
 662         unpad: function (a) {
 663             a.sigBytes -= a.words[a.sigBytes - 1 >>> 2] & 255
 664         }
 665     };
 666     x.BlockCipher = b.extend({
 667         cfg: b.cfg.extend({
 668             mode: m,
 669             padding: g
 670         }),
 671         reset: function () {
 672             b.reset.call(this);
 673             var a = this.cfg
 674                 , d = a.iv
 675                 , a = a.mode;
 676             if (this._xformMode == this._ENC_XFORM_MODE) {
 677                 var c = a.createEncryptor
 678             } else {
 679                 c = a.createDecryptor,
 680                     this._minBufferSize = 1
 681             }
 682             this._mode = c.call(a, this, d && d.words)
 683         },
 684         _doProcessBlock: function (a, c) {
 685             this._mode.processBlock(a, c)
 686         },
 687         _doFinalize: function () {
 688             var a = this.cfg.padding;
 689             if (this._xformMode == this._ENC_XFORM_MODE) {
 690                 a.pad(this._data, this.blockSize);
 691                 var c = this._process(!0)
 692             } else {
 693                 c = this._process(!0),
 694                     a.unpad(c)
 695             }
 696             return c
 697         },
 698         blockSize: 4
 699     });
 700     var q = x.CipherParams = A.extend({
 701         init: function (a) {
 702             this.mixIn(a)
 703         },
 704         toString: function (a) {
 705             return (a || this.formatter).stringify(this)
 706         }
 707     })
 708         , m = (C.format = {}).OpenSSL = {
 709         stringify: function (a) {
 710             var c = a.ciphertext
 711                 , a = a.salt
 712                 , c = (a ? v.create([1398893684, 1701076831]).concat(a).concat(c) : c).toString(y);
 713             return c = c.replace(/(.{64})/g, "$1\n")
 714         },
 715         parse: function (a) {
 716             var a = y.parse(a)
 717                 , d = a.words;
 718             if (1398893684 == d[0] && 1701076831 == d[1]) {
 719                 var c = v.create(d.slice(2, 4));
 720                 d.splice(0, 4),
 721                     a.sigBytes -= 16
 722             }
 723             return q.create({
 724                 ciphertext: a,
 725                 salt: c
 726             })
 727         }
 728     }
 729         , z = x.SerializableCipher = A.extend({
 730         cfg: A.extend({
 731             format: m
 732         }),
 733         encrypt: function (a, h, d, f) {
 734             var f = this.cfg.extend(f)
 735                 , c = a.createEncryptor(d, f)
 736                 , h = c.finalize(h)
 737                 , c = c.cfg;
 738             return q.create({
 739                 ciphertext: h,
 740                 key: d,
 741                 iv: c.iv,
 742                 algorithm: a,
 743                 mode: c.mode,
 744                 padding: c.padding,
 745                 blockSize: a.blockSize,
 746                 formatter: f.format
 747             })
 748         },
 749         decrypt: function (a, f, c, d) {
 750             return d = this.cfg.extend(d),
 751                 f = this._parse(f, d.format),
 752                 a.createDecryptor(c, d).finalize(f.ciphertext)
 753         },
 754         _parse: function (a, c) {
 755             return "string" == typeof a ? c.parse(a) : a
 756         }
 757     })
 758         , C = (C.kdf = {}).OpenSSL = {
 759         compute: function (a, f, c, d) {
 760             return d || (d = v.random(8)),
 761                 a = D.create({
 762                     keySize: f + c
 763                 }).compute(a, d),
 764                 c = v.create(a.words.slice(f), 4 * c),
 765                 a.sigBytes = 4 * f,
 766                 q.create({
 767                     key: a,
 768                     iv: c,
 769                     salt: d
 770                 })
 771         }
 772     }
 773         , j = x.PasswordBasedCipher = z.extend({
 774         cfg: z.cfg.extend({
 775             kdf: C
 776         }),
 777         encrypt: function (a, f, c, d) {
 778             return d = this.cfg.extend(d),
 779                 c = d.kdf.compute(c, a.keySize, a.ivSize),
 780                 d.iv = c.iv,
 781                 a = z.encrypt.call(this, a, f, c.key, d),
 782                 a.mixIn(c),
 783                 a
 784         },
 785         decrypt: function (a, f, c, d) {
 786             return d = this.cfg.extend(d),
 787                 f = this._parse(f, d.format),
 788                 c = d.kdf.compute(c, a.keySize, a.ivSize, f.salt),
 789                 d.iv = c.iv,
 790                 z.decrypt.call(this, a, f, c.key, d)
 791         }
 792     })
 793 }(),
 794     function () {
 795         function g(a, f) {
 796             var c = (this._lBlock >>> a ^ this._rBlock) & f;
 797             this._rBlock ^= c,
 798                 this._lBlock ^= c << a
 799         }
 800 
 801         function w(a, f) {
 802             var c = (this._rBlock >>> a ^ this._lBlock) & f;
 803             this._lBlock ^= c,
 804                 this._rBlock ^= c << a
 805         }
 806 
 807         var m = CryptoJS
 808             , q = m.lib
 809             , j = q.WordArray
 810             , q = q.BlockCipher
 811             , v = m.algo
 812             ,
 813             p = [57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36, 63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4]
 814             ,
 815             x = [14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2, 41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48, 44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32]
 816             , b = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28]
 817             , h = [{
 818                 0: 8421888,
 819                 268435456: 32768,
 820                 536870912: 8421378,
 821                 805306368: 2,
 822                 1073741824: 512,
 823                 1342177280: 8421890,
 824                 1610612736: 8389122,
 825                 1879048192: 8388608,
 826                 2147483648: 514,
 827                 2415919104: 8389120,
 828                 2684354560: 33280,
 829                 2952790016: 8421376,
 830                 3221225472: 32770,
 831                 3489660928: 8388610,
 832                 3758096384: 0,
 833                 4026531840: 33282,
 834                 134217728: 0,
 835                 402653184: 8421890,
 836                 671088640: 33282,
 837                 939524096: 32768,
 838                 1207959552: 8421888,
 839                 1476395008: 512,
 840                 1744830464: 8421378,
 841                 2013265920: 2,
 842                 2281701376: 8389120,
 843                 2550136832: 33280,
 844                 2818572288: 8421376,
 845                 3087007744: 8389122,
 846                 3355443200: 8388610,
 847                 3623878656: 32770,
 848                 3892314112: 514,
 849                 4160749568: 8388608,
 850                 1: 32768,
 851                 268435457: 2,
 852                 536870913: 8421888,
 853                 805306369: 8388608,
 854                 1073741825: 8421378,
 855                 1342177281: 33280,
 856                 1610612737: 512,
 857                 1879048193: 8389122,
 858                 2147483649: 8421890,
 859                 2415919105: 8421376,
 860                 2684354561: 8388610,
 861                 2952790017: 33282,
 862                 3221225473: 514,
 863                 3489660929: 8389120,
 864                 3758096385: 32770,
 865                 4026531841: 0,
 866                 134217729: 8421890,
 867                 402653185: 8421376,
 868                 671088641: 8388608,
 869                 939524097: 512,
 870                 1207959553: 32768,
 871                 1476395009: 8388610,
 872                 1744830465: 2,
 873                 2013265921: 33282,
 874                 2281701377: 32770,
 875                 2550136833: 8389122,
 876                 2818572289: 514,
 877                 3087007745: 8421888,
 878                 3355443201: 8389120,
 879                 3623878657: 0,
 880                 3892314113: 33280,
 881                 4160749569: 8421378
 882             }, {
 883                 0: 1074282512,
 884                 16777216: 16384,
 885                 33554432: 524288,
 886                 50331648: 1074266128,
 887                 67108864: 1073741840,
 888                 83886080: 1074282496,
 889                 100663296: 1073758208,
 890                 117440512: 16,
 891                 134217728: 540672,
 892                 150994944: 1073758224,
 893                 167772160: 1073741824,
 894                 184549376: 540688,
 895                 201326592: 524304,
 896                 218103808: 0,
 897                 234881024: 16400,
 898                 251658240: 1074266112,
 899                 8388608: 1073758208,
 900                 25165824: 540688,
 901                 41943040: 16,
 902                 58720256: 1073758224,
 903                 75497472: 1074282512,
 904                 92274688: 1073741824,
 905                 109051904: 524288,
 906                 125829120: 1074266128,
 907                 142606336: 524304,
 908                 159383552: 0,
 909                 176160768: 16384,
 910                 192937984: 1074266112,
 911                 209715200: 1073741840,
 912                 226492416: 540672,
 913                 243269632: 1074282496,
 914                 260046848: 16400,
 915                 268435456: 0,
 916                 285212672: 1074266128,
 917                 301989888: 1073758224,
 918                 318767104: 1074282496,
 919                 335544320: 1074266112,
 920                 352321536: 16,
 921                 369098752: 540688,
 922                 385875968: 16384,
 923                 402653184: 16400,
 924                 419430400: 524288,
 925                 436207616: 524304,
 926                 452984832: 1073741840,
 927                 469762048: 540672,
 928                 486539264: 1073758208,
 929                 503316480: 1073741824,
 930                 520093696: 1074282512,
 931                 276824064: 540688,
 932                 293601280: 524288,
 933                 310378496: 1074266112,
 934                 327155712: 16384,
 935                 343932928: 1073758208,
 936                 360710144: 1074282512,
 937                 377487360: 16,
 938                 394264576: 1073741824,
 939                 411041792: 1074282496,
 940                 427819008: 1073741840,
 941                 444596224: 1073758224,
 942                 461373440: 524304,
 943                 478150656: 0,
 944                 494927872: 16400,
 945                 511705088: 1074266128,
 946                 528482304: 540672
 947             }, {
 948                 0: 260,
 949                 1048576: 0,
 950                 2097152: 67109120,
 951                 3145728: 65796,
 952                 4194304: 65540,
 953                 5242880: 67108868,
 954                 6291456: 67174660,
 955                 7340032: 67174400,
 956                 8388608: 67108864,
 957                 9437184: 67174656,
 958                 10485760: 65792,
 959                 11534336: 67174404,
 960                 12582912: 67109124,
 961                 13631488: 65536,
 962                 14680064: 4,
 963                 15728640: 256,
 964                 524288: 67174656,
 965                 1572864: 67174404,
 966                 2621440: 0,
 967                 3670016: 67109120,
 968                 4718592: 67108868,
 969                 5767168: 65536,
 970                 6815744: 65540,
 971                 7864320: 260,
 972                 8912896: 4,
 973                 9961472: 256,
 974                 11010048: 67174400,
 975                 12058624: 65796,
 976                 13107200: 65792,
 977                 14155776: 67109124,
 978                 15204352: 67174660,
 979                 16252928: 67108864,
 980                 16777216: 67174656,
 981                 17825792: 65540,
 982                 18874368: 65536,
 983                 19922944: 67109120,
 984                 20971520: 256,
 985                 22020096: 67174660,
 986                 23068672: 67108868,
 987                 24117248: 0,
 988                 25165824: 67109124,
 989                 26214400: 67108864,
 990                 27262976: 4,
 991                 28311552: 65792,
 992                 29360128: 67174400,
 993                 30408704: 260,
 994                 31457280: 65796,
 995                 32505856: 67174404,
 996                 17301504: 67108864,
 997                 18350080: 260,
 998                 19398656: 67174656,
 999                 20447232: 0,
1000                 21495808: 65540,
1001                 22544384: 67109120,
1002                 23592960: 256,
1003                 24641536: 67174404,
1004                 25690112: 65536,
1005                 26738688: 67174660,
1006                 27787264: 65796,
1007                 28835840: 67108868,
1008                 29884416: 67109124,
1009                 30932992: 67174400,
1010                 31981568: 4,
1011                 33030144: 65792
1012             }, {
1013                 0: 2151682048,
1014                 65536: 2147487808,
1015                 131072: 4198464,
1016                 196608: 2151677952,
1017                 262144: 0,
1018                 327680: 4198400,
1019                 393216: 2147483712,
1020                 458752: 4194368,
1021                 524288: 2147483648,
1022                 589824: 4194304,
1023                 655360: 64,
1024                 720896: 2147487744,
1025                 786432: 2151678016,
1026                 851968: 4160,
1027                 917504: 4096,
1028                 983040: 2151682112,
1029                 32768: 2147487808,
1030                 98304: 64,
1031                 163840: 2151678016,
1032                 229376: 2147487744,
1033                 294912: 4198400,
1034                 360448: 2151682112,
1035                 425984: 0,
1036                 491520: 2151677952,
1037                 557056: 4096,
1038                 622592: 2151682048,
1039                 688128: 4194304,
1040                 753664: 4160,
1041                 819200: 2147483648,
1042                 884736: 4194368,
1043                 950272: 4198464,
1044                 1015808: 2147483712,
1045                 1048576: 4194368,
1046                 1114112: 4198400,
1047                 1179648: 2147483712,
1048                 1245184: 0,
1049                 1310720: 4160,
1050                 1376256: 2151678016,
1051                 1441792: 2151682048,
1052                 1507328: 2147487808,
1053                 1572864: 2151682112,
1054                 1638400: 2147483648,
1055                 1703936: 2151677952,
1056                 1769472: 4198464,
1057                 1835008: 2147487744,
1058                 1900544: 4194304,
1059                 1966080: 64,
1060                 2031616: 4096,
1061                 1081344: 2151677952,
1062                 1146880: 2151682112,
1063                 1212416: 0,
1064                 1277952: 4198400,
1065                 1343488: 4194368,
1066                 1409024: 2147483648,
1067                 1474560: 2147487808,
1068                 1540096: 64,
1069                 1605632: 2147483712,
1070                 1671168: 4096,
1071                 1736704: 2147487744,
1072                 1802240: 2151678016,
1073                 1867776: 4160,
1074                 1933312: 2151682048,
1075                 1998848: 4194304,
1076                 2064384: 4198464
1077             }, {
1078                 0: 128,
1079                 4096: 17039360,
1080                 8192: 262144,
1081                 12288: 536870912,
1082                 16384: 537133184,
1083                 20480: 16777344,
1084                 24576: 553648256,
1085                 28672: 262272,
1086                 32768: 16777216,
1087                 36864: 537133056,
1088                 40960: 536871040,
1089                 45056: 553910400,
1090                 49152: 553910272,
1091                 53248: 0,
1092                 57344: 17039488,
1093                 61440: 553648128,
1094                 2048: 17039488,
1095                 6144: 553648256,
1096                 10240: 128,
1097                 14336: 17039360,
1098                 18432: 262144,
1099                 22528: 537133184,
1100                 26624: 553910272,
1101                 30720: 536870912,
1102                 34816: 537133056,
1103                 38912: 0,
1104                 43008: 553910400,
1105                 47104: 16777344,
1106                 51200: 536871040,
1107                 55296: 553648128,
1108                 59392: 16777216,
1109                 63488: 262272,
1110                 65536: 262144,
1111                 69632: 128,
1112                 73728: 536870912,
1113                 77824: 553648256,
1114                 81920: 16777344,
1115                 86016: 553910272,
1116                 90112: 537133184,
1117                 94208: 16777216,
1118                 98304: 553910400,
1119                 102400: 553648128,
1120                 106496: 17039360,
1121                 110592: 537133056,
1122                 114688: 262272,
1123                 118784: 536871040,
1124                 122880: 0,
1125                 126976: 17039488,
1126                 67584: 553648256,
1127                 71680: 16777216,
1128                 75776: 17039360,
1129                 79872: 537133184,
1130                 83968: 536870912,
1131                 88064: 17039488,
1132                 92160: 128,
1133                 96256: 553910272,
1134                 100352: 262272,
1135                 104448: 553910400,
1136                 108544: 0,
1137                 112640: 553648128,
1138                 116736: 16777344,
1139                 120832: 262144,
1140                 124928: 537133056,
1141                 129024: 536871040
1142             }, {
1143                 0: 268435464,
1144                 256: 8192,
1145                 512: 270532608,
1146                 768: 270540808,
1147                 1024: 268443648,
1148                 1280: 2097152,
1149                 1536: 2097160,
1150                 1792: 268435456,
1151                 2048: 0,
1152                 2304: 268443656,
1153                 2560: 2105344,
1154                 2816: 8,
1155                 3072: 270532616,
1156                 3328: 2105352,
1157                 3584: 8200,
1158                 3840: 270540800,
1159                 128: 270532608,
1160                 384: 270540808,
1161                 640: 8,
1162                 896: 2097152,
1163                 1152: 2105352,
1164                 1408: 268435464,
1165                 1664: 268443648,
1166                 1920: 8200,
1167                 2176: 2097160,
1168                 2432: 8192,
1169                 2688: 268443656,
1170                 2944: 270532616,
1171                 3200: 0,
1172                 3456: 270540800,
1173                 3712: 2105344,
1174                 3968: 268435456,
1175                 4096: 268443648,
1176                 4352: 270532616,
1177                 4608: 270540808,
1178                 4864: 8200,
1179                 5120: 2097152,
1180                 5376: 268435456,
1181                 5632: 268435464,
1182                 5888: 2105344,
1183                 6144: 2105352,
1184                 6400: 0,
1185                 6656: 8,
1186                 6912: 270532608,
1187                 7168: 8192,
1188                 7424: 268443656,
1189                 7680: 270540800,
1190                 7936: 2097160,
1191                 4224: 8,
1192                 4480: 2105344,
1193                 4736: 2097152,
1194                 4992: 268435464,
1195                 5248: 268443648,
1196                 5504: 8200,
1197                 5760: 270540808,
1198                 6016: 270532608,
1199                 6272: 270540800,
1200                 6528: 270532616,
1201                 6784: 8192,
1202                 7040: 2105352,
1203                 7296: 2097160,
1204                 7552: 0,
1205                 7808: 268435456,
1206                 8064: 268443656
1207             }, {
1208                 0: 1048576,
1209                 16: 33555457,
1210                 32: 1024,
1211                 48: 1049601,
1212                 64: 34604033,
1213                 80: 0,
1214                 96: 1,
1215                 112: 34603009,
1216                 128: 33555456,
1217                 144: 1048577,
1218                 160: 33554433,
1219                 176: 34604032,
1220                 192: 34603008,
1221                 208: 1025,
1222                 224: 1049600,
1223                 240: 33554432,
1224                 8: 34603009,
1225                 24: 0,
1226                 40: 33555457,
1227                 56: 34604032,
1228                 72: 1048576,
1229                 88: 33554433,
1230                 104: 33554432,
1231                 120: 1025,
1232                 136: 1049601,
1233                 152: 33555456,
1234                 168: 34603008,
1235                 184: 1048577,
1236                 200: 1024,
1237                 216: 34604033,
1238                 232: 1,
1239                 248: 1049600,
1240                 256: 33554432,
1241                 272: 1048576,
1242                 288: 33555457,
1243                 304: 34603009,
1244                 320: 1048577,
1245                 336: 33555456,
1246                 352: 34604032,
1247                 368: 1049601,
1248                 384: 1025,
1249                 400: 34604033,
1250                 416: 1049600,
1251                 432: 1,
1252                 448: 0,
1253                 464: 34603008,
1254                 480: 33554433,
1255                 496: 1024,
1256                 264: 1049600,
1257                 280: 33555457,
1258                 296: 34603009,
1259                 312: 1,
1260                 328: 33554432,
1261                 344: 1048576,
1262                 360: 1025,
1263                 376: 34604032,
1264                 392: 33554433,
1265                 408: 34603008,
1266                 424: 0,
1267                 440: 34604033,
1268                 456: 1049601,
1269                 472: 1024,
1270                 488: 33555456,
1271                 504: 1048577
1272             }, {
1273                 0: 134219808,
1274                 1: 131072,
1275                 2: 134217728,
1276                 3: 32,
1277                 4: 131104,
1278                 5: 134350880,
1279                 6: 134350848,
1280                 7: 2048,
1281                 8: 134348800,
1282                 9: 134219776,
1283                 10: 133120,
1284                 11: 134348832,
1285                 12: 2080,
1286                 13: 0,
1287                 14: 134217760,
1288                 15: 133152,
1289                 2147483648: 2048,
1290                 2147483649: 134350880,
1291                 2147483650: 134219808,
1292                 2147483651: 134217728,
1293                 2147483652: 134348800,
1294                 2147483653: 133120,
1295                 2147483654: 133152,
1296                 2147483655: 32,
1297                 2147483656: 134217760,
1298                 2147483657: 2080,
1299                 2147483658: 131104,
1300                 2147483659: 134350848,
1301                 2147483660: 0,
1302                 2147483661: 134348832,
1303                 2147483662: 134219776,
1304                 2147483663: 131072,
1305                 16: 133152,
1306                 17: 134350848,
1307                 18: 32,
1308                 19: 2048,
1309                 20: 134219776,
1310                 21: 134217760,
1311                 22: 134348832,
1312                 23: 131072,
1313                 24: 0,
1314                 25: 131104,
1315                 26: 134348800,
1316                 27: 134219808,
1317                 28: 134350880,
1318                 29: 133120,
1319                 30: 2080,
1320                 31: 134217728,
1321                 2147483664: 131072,
1322                 2147483665: 2048,
1323                 2147483666: 134348832,
1324                 2147483667: 133152,
1325                 2147483668: 32,
1326                 2147483669: 134348800,
1327                 2147483670: 134217728,
1328                 2147483671: 134219808,
1329                 2147483672: 134350880,
1330                 2147483673: 134217760,
1331                 2147483674: 134219776,
1332                 2147483675: 0,
1333                 2147483676: 133120,
1334                 2147483677: 2080,
1335                 2147483678: 131104,
1336                 2147483679: 134350848
1337             }]
1338             , k = [4160749569, 528482304, 33030144, 2064384, 129024, 8064, 504, 2147483679]
1339             , d = v.DES = q.extend({
1340                 _doReset: function () {
1341                     for (var a = this._key.words, u = [], f = 0; 56 > f; f++) {
1342                         var l = p[f] - 1;
1343                         u[f] = a[l >>> 5] >>> 31 - l % 32 & 1
1344                     }
1345                     a = this._subKeys = [];
1346                     for (l = 0; 16 > l; l++) {
1347                         for (var c = a[l] = [], o = b[l], f = 0; 24 > f; f++) {
1348                             c[f / 6 | 0] |= u[(x[f] - 1 + o) % 28] << 31 - f % 6,
1349                                 c[4 + (f / 6 | 0)] |= u[28 + (x[f + 24] - 1 + o) % 28] << 31 - f % 6
1350                         }
1351                         c[0] = c[0] << 1 | c[0] >>> 31;
1352                         for (f = 1; 7 > f; f++) {
1353                             c[f] >>>= 4 * (f - 1) + 3
1354                         }
1355                         c[7] = c[7] << 5 | c[7] >>> 27
1356                     }
1357                     u = this._invSubKeys = [];
1358                     for (f = 0; 16 > f; f++) {
1359                         u[f] = a[15 - f]
1360                     }
1361                 },
1362                 encryptBlock: function (a, c) {
1363                     this._doCryptBlock(a, c, this._subKeys)
1364                 },
1365                 decryptBlock: function (a, c) {
1366                     this._doCryptBlock(a, c, this._invSubKeys)
1367                 },
1368                 _doCryptBlock: function (y, A, t) {
1369                     this._lBlock = y[A],
1370                         this._rBlock = y[A + 1],
1371                         g.call(this, 4, 252645135),
1372                         g.call(this, 16, 65535),
1373                         w.call(this, 2, 858993459),
1374                         w.call(this, 8, 16711935),
1375                         g.call(this, 1, 1431655765);
1376                     for (var B = 0; 16 > B; B++) {
1377                         for (var z = t[B], C = this._lBlock, e = this._rBlock, f = 0, l = 0; 8 > l; l++) {
1378                             f |= h[l][((e ^ z[l]) & k[l]) >>> 0]
1379                         }
1380                         this._lBlock = e,
1381                             this._rBlock = C ^ f
1382                     }
1383                     t = this._lBlock,
1384                         this._lBlock = this._rBlock,
1385                         this._rBlock = t,
1386                         g.call(this, 1, 1431655765),
1387                         w.call(this, 8, 16711935),
1388                         w.call(this, 2, 858993459),
1389                         g.call(this, 16, 65535),
1390                         g.call(this, 4, 252645135),
1391                         y[A] = this._lBlock,
1392                         y[A + 1] = this._rBlock
1393                 },
1394                 keySize: 2,
1395                 ivSize: 2,
1396                 blockSize: 2
1397             });
1398         m.DES = q._createHelper(d),
1399             v = v.TripleDES = q.extend({
1400                 _doReset: function () {
1401                     var a = this._key.words;
1402                     this._des1 = d.createEncryptor(j.create(a.slice(0, 2))),
1403                         this._des2 = d.createEncryptor(j.create(a.slice(2, 4))),
1404                         this._des3 = d.createEncryptor(j.create(a.slice(4, 6)))
1405                 },
1406                 encryptBlock: function (a, c) {
1407                     this._des1.encryptBlock(a, c),
1408                         this._des2.decryptBlock(a, c),
1409                         this._des3.encryptBlock(a, c)
1410                 },
1411                 decryptBlock: function (a, c) {
1412                     this._des3.decryptBlock(a, c),
1413                         this._des2.encryptBlock(a, c),
1414                         this._des1.decryptBlock(a, c)
1415                 },
1416                 keySize: 6,
1417                 ivSize: 2,
1418                 blockSize: 2
1419             }),
1420             m.TripleDES = q._createHelper(v)
1421     }();
1422 CryptoJS.mode.ECB = function () {
1423     var a = CryptoJS.lib.BlockCipherMode.extend();
1424     return a.Encryptor = a.extend({
1425         processBlock: function (b, c) {
1426             this._cipher.encryptBlock(b, c)
1427         }
1428     }),
1429     a.Decryptor = a.extend({
1430         processBlock: function (b, c) {
1431             this._cipher.decryptBlock(b, c)
1432         }
1433     }),
1434     a
1435 }();
View Code

  得到了加密代码之后,我们只需要使用 execjs 进行编译和调用就可以了,使用方法可以参考上一篇博客

 

三、模拟登录

  通过前面的步骤,我们已经能够得到登录所需要的参数了,编写好加密方法之后,可以使用 Postman 进行测试,下面是用 Postman 进行登录的 POST 请求的响应结果:

【Python3爬虫】破解时光网登录加密参数并实现模拟登录 Python 第10张

  从图中可以看到,返回的是一个 JSON 文件,其中包含了登录请求是否成功、登录的结果信息和用户信息等内容。 下面就是使用 Python 编写的模拟登录时光网的代码:

 1 """
 2 Version: Python3.7
 3 Author: OniOn
 4 Site: http://www.cnblogs.com/TM0831/
 5 Time: 2020/7/5 14:19
 6 """
 7 import execjs
 8 import requests
 9 
10 
11 class MTimeSpider:
12     def __init__(self, username, password):
13         self.username = username
14         self.password = password
15 
16     def encrypted(self):
17         """
18         use JavaScript to encrypt the password
19         :return:
20         """
21         with open("encrypt.js", "r", encoding="utf-8") as f:
22             ctx = execjs.compile(f.read())
23             self.password = ctx.call("encrypt", self.password)
24 
25     def request(self):
26         """
27         send request and get the response
28         :return:
29         """
30         self.encrypted()
31         login_api = "https://m.mtime.cn/Service/callback-comm.mi/user/login.api"
32         data = {
33             "t": "20207515574379774",
34             "name": self.username,
35             "password": self.password,
36             "code": "",
37             "codeId": ""
38         }
39         res = requests.post(url=login_api, data=data)
40         status, msg = res.json()["data"]["status"], res.json()["data"]["msg"]
41         # print(status, msg)
42         if status == 1:
43             name = res.json()["data"]["user"]["nickname"]
44             print("用户: {} 登录成功!".format(name))
45         else:
46             print("登录失败!{}".format(msg))
47 
48 
49 if __name__ == '__main__':
50     print("请输入账号:")
51     usr = input()
52     print("请输入密码:")
53     pwd = input()
54     spider = MTimeSpider(usr, pwd)
55     spider.request()

  运行后的截图如下:

  【Python3爬虫】破解时光网登录加密参数并实现模拟登录 Python 第11张

 

完整代码已上传到 GitHub

扫码关注我们
微信号:SRE实战
拒绝背锅 运筹帷幄