js 破解 xxxx登录

aHR0cHM6Ly93d3cudGFwZC5jbi9jbG91ZF9sb2dpbnMvbG9naW4=

import requests
import execjs


url = 'https://www.tapd.cn/cloud_logins/login?ref=https%3A%2F%2Fwww.tapd.cn%2Fmy_worktable%3Fleft_tree%3D1'

phone = ''
password = ''

ctx = execjs.compile(open('get_pwd.js', 'r').read())
params = ctx.call('get_params',password)
print(params)

headers = {
    "Referer": "https://www.tapd.cn/cloud_logins/login?ref=https%3A%2F%2Fwww.tapd.cn%2Fmy_worktable%3Fleft_tree%3D1",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.163 Safari/537.36",
}
data = {
    'data[Login][ref]': 'https://www.tapd.cn/my_worktable?left_tree=1',
    'data[Login][encrypt_key]': params[2],
    'data[Login][encrypt_iv]':params[1],
    'data[Login][site]': 'TAPD',
    'data[Login][via]': 'encrypt_password',
    'data[Login][email]': phone,
    'data[Login][password]':params[0],
    'data[Login][login]': 'login',
    'dsc_token': 'rstmmCAzYguu6zvh',


}
s = requests.Session()
res = s.post(url,data=data,headers=headers)
res.encoding = res.apparent_encoding
# print('post请求:',res.text)

print('==='*20)
print('==='*20)
print('==='*20)

# html = s.get('https://www.tapd.cn/my_worktable?left_tree=1&left_tree=1')
# html.encoding = html.apparent_encoding
# print(html.text)

html = s.get('https://www.tapd.cn/43274983/workspaces/workspace_edit')
html.encoding = html.apparent_encoding
print(html.text)

 

var CryptoJS = CryptoJS || function(t, e) {
    var r = {}
        , i = r.lib = {}
        , n = function() {}
        , s = i.Base = {
        extend: function(t) {
            n.prototype = this;
            var e = new n;
            return t && e.mixIn(t),
            e.hasOwnProperty("init") || (e.init = function() {
                    e.$super.init.apply(this, arguments)
                }
            ),
                e.init.prototype = e,
                e.$super = this,
                e
        },
        create: function() {
            var t = this.extend();
            return t.init.apply(t, arguments),
                t
        },
        init: function() {},
        mixIn: function(t) {
            for (var e in t)
                t.hasOwnProperty(e) && (this[e] = t[e]);
            t.hasOwnProperty("toString") && (this.toString = t.toString)
        },
        clone: function() {
            return this.init.prototype.extend(this)
        }
    }
        , o = i.WordArray = s.extend({
        init: function(t, r) {
            t = this.words = t || [],
                this.sigBytes = r != e ? r : 4 * t.length
        },
        toString: function(t) {
            return (t || a).stringify(this)
        },
        concat: function(t) {
            var e = this.words
                , r = t.words
                , i = this.sigBytes;
            if (t = t.sigBytes,
                this.clamp(),
            i % 4)
                for (var n = 0; t > n; n++)
                    e[i + n >>> 2] |= (r[n >>> 2] >>> 24 - 8 * (n % 4) & 255) << 24 - 8 * ((i + n) % 4);
            else if (65535 < r.length)
                for (n = 0; t > n; n += 4)
                    e[i + n >>> 2] = r[n >>> 2];
            else
                e.push.apply(e, r);
            return this.sigBytes += t,
                this
        },
        clamp: function() {
            var e = this.words
                , r = this.sigBytes;
            e[r >>> 2] &= 4294967295 << 32 - 8 * (r % 4),
                e.length = t.ceil(r / 4)
        },
        clone: function() {
            var t = s.clone.call(this);
            return t.words = this.words.slice(0),
                t
        },
        random: function(e) {
            for (var r = [], i = 0; e > i; i += 4)
                r.push(4294967296 * t.random() | 0);
            return new o.init(r,e)
        }
    })
        , c = r.enc = {}
        , a = c.Hex = {
        stringify: function(t) {
            var e = t.words;
            t = t.sigBytes;
            for (var r = [], i = 0; t > i; i++) {
                var n = e[i >>> 2] >>> 24 - 8 * (i % 4) & 255;
                r.push((n >>> 4).toString(16)),
                    r.push((15 & n).toString(16))
            }
            return r.join("")
        },
        parse: function(t) {
            for (var e = t.length, r = [], i = 0; e > i; i += 2)
                r[i >>> 3] |= parseInt(t.substr(i, 2), 16) << 24 - 4 * (i % 8);
            return new o.init(r,e / 2)
        }
    }
        , f = c.Latin1 = {
        stringify: function(t) {
            var e = t.words;
            t = t.sigBytes;
            for (var r = [], i = 0; t > i; i++)
                r.push(String.fromCharCode(e[i >>> 2] >>> 24 - 8 * (i % 4) & 255));
            return r.join("")
        },
        parse: function(t) {
            for (var e = t.length, r = [], i = 0; e > i; i++)
                r[i >>> 2] |= (255 & t.charCodeAt(i)) << 24 - 8 * (i % 4);
            return new o.init(r,e)
        }
    }
        , h = c.Utf8 = {
        stringify: function(t) {
            try {
                return decodeURIComponent(escape(f.stringify(t)))
            } catch (e) {
                throw Error("Malformed UTF-8 data")
            }
        },
        parse: function(t) {
            return f.parse(unescape(encodeURIComponent(t)))
        }
    }
        , u = i.BufferedBlockAlgorithm = s.extend({
        reset: function() {
            this._data = new o.init,
                this._nDataBytes = 0
        },
        _append: function(t) {
            "string" == typeof t && (t = h.parse(t)),
                this._data.concat(t),
                this._nDataBytes += t.sigBytes
        },
        _process: function(e) {
            var r = this._data
                , i = r.words
                , n = r.sigBytes
                , s = this.blockSize
                , c = n / (4 * s)
                , c = e ? t.ceil(c) : t.max((0 | c) - this._minBufferSize, 0);
            if (e = c * s,
                n = t.min(4 * e, n),
                e) {
                for (var a = 0; e > a; a += s)
                    this._doProcessBlock(i, a);
                a = i.splice(0, e),
                    r.sigBytes -= n
            }
            return new o.init(a,n)
        },
        clone: function() {
            var t = s.clone.call(this);
            return t._data = this._data.clone(),
                t
        },
        _minBufferSize: 0
    });
    i.Hasher = u.extend({
        cfg: s.extend(),
        init: function(t) {
            this.cfg = this.cfg.extend(t),
                this.reset()
        },
        reset: function() {
            u.reset.call(this),
                this._doReset()
        },
        update: function(t) {
            return this._append(t),
                this._process(),
                this
        },
        finalize: function(t) {
            return t && this._append(t),
                this._doFinalize()
        },
        blockSize: 16,
        _createHelper: function(t) {
            return function(e, r) {
                return new t.init(r).finalize(e)
            }
        },
        _createHmacHelper: function(t) {
            return function(e, r) {
                return new p.HMAC.init(t,r).finalize(e)
            }
        }
    });
    var p = r.algo = {};
    return r
}(Math);
!function() {
    var t = CryptoJS
        , e = t.lib.WordArray;
    t.enc.Base64 = {
        stringify: function(t) {
            var e = t.words
                , r = t.sigBytes
                , i = this._map;
            t.clamp(),
                t = [];
            for (var n = 0; r > n; n += 3)
                for (var s = (e[n >>> 2] >>> 24 - 8 * (n % 4) & 255) << 16 | (e[n + 1 >>> 2] >>> 24 - 8 * ((n + 1) % 4) & 255) << 8 | e[n + 2 >>> 2] >>> 24 - 8 * ((n + 2) % 4) & 255, o = 0; 4 > o && r > n + .75 * o; o++)
                    t.push(i.charAt(s >>> 6 * (3 - o) & 63));
            if (e = i.charAt(64))
                for (; t.length % 4; )
                    t.push(e);
            return t.join("")
        },
        parse: function(t) {
            var r = t.length
                , i = this._map
                , n = i.charAt(64);
            n && (n = t.indexOf(n),
            -1 != n && (r = n));
            for (var n = [], s = 0, o = 0; r > o; o++)
                if (o % 4) {
                    var c = i.indexOf(t.charAt(o - 1)) << 2 * (o % 4)
                        , a = i.indexOf(t.charAt(o)) >>> 6 - 2 * (o % 4);
                    n[s >>> 2] |= (c | a) << 24 - 8 * (s % 4),
                        s++
                }
            return e.create(n, s)
        },
        _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
    }
}(),
    function(t) {
        function e(t, e, r, i, n, s, o) {
            return t = t + (e & r | ~e & i) + n + o,
            (t << s | t >>> 32 - s) + e
        }
        function r(t, e, r, i, n, s, o) {
            return t = t + (e & i | r & ~i) + n + o,
            (t << s | t >>> 32 - s) + e
        }
        function i(t, e, r, i, n, s, o) {
            return t = t + (e ^ r ^ i) + n + o,
            (t << s | t >>> 32 - s) + e
        }
        function n(t, e, r, i, n, s, o) {
            return t = t + (r ^ (e | ~i)) + n + o,
            (t << s | t >>> 32 - s) + e
        }
        for (var s = CryptoJS, o = s.lib, c = o.WordArray, a = o.Hasher, o = s.algo, f = [], h = 0; 64 > h; h++)
            f[h] = 4294967296 * t.abs(t.sin(h + 1)) | 0;
        o = o.MD5 = a.extend({
            _doReset: function() {
                this._hash = new c.init([1732584193, 4023233417, 2562383102, 271733878])
            },
            _doProcessBlock: function(t, s) {
                for (var o = 0; 16 > o; o++) {
                    var c = s + o
                        , a = t[c];
                    t[c] = 16711935 & (a << 8 | a >>> 24) | 4278255360 & (a << 24 | a >>> 8)
                }
                var o = this._hash.words
                    , c = t[s + 0]
                    , a = t[s + 1]
                    , h = t[s + 2]
                    , u = t[s + 3]
                    , p = t[s + 4]
                    , d = t[s + 5]
                    , l = t[s + 6]
                    , y = t[s + 7]
                    , _ = t[s + 8]
                    , v = t[s + 9]
                    , g = t[s + 10]
                    , B = t[s + 11]
                    , m = t[s + 12]
                    , x = t[s + 13]
                    , S = t[s + 14]
                    , k = t[s + 15]
                    , z = o[0]
                    , C = o[1]
                    , w = o[2]
                    , D = o[3]
                    , z = e(z, C, w, D, c, 7, f[0])
                    , D = e(D, z, C, w, a, 12, f[1])
                    , w = e(w, D, z, C, h, 17, f[2])
                    , C = e(C, w, D, z, u, 22, f[3])
                    , z = e(z, C, w, D, p, 7, f[4])
                    , D = e(D, z, C, w, d, 12, f[5])
                    , w = e(w, D, z, C, l, 17, f[6])
                    , C = e(C, w, D, z, y, 22, f[7])
                    , z = e(z, C, w, D, _, 7, f[8])
                    , D = e(D, z, C, w, v, 12, f[9])
                    , w = e(w, D, z, C, g, 17, f[10])
                    , C = e(C, w, D, z, B, 22, f[11])
                    , z = e(z, C, w, D, m, 7, f[12])
                    , D = e(D, z, C, w, x, 12, f[13])
                    , w = e(w, D, z, C, S, 17, f[14])
                    , C = e(C, w, D, z, k, 22, f[15])
                    , z = r(z, C, w, D, a, 5, f[16])
                    , D = r(D, z, C, w, l, 9, f[17])
                    , w = r(w, D, z, C, B, 14, f[18])
                    , C = r(C, w, D, z, c, 20, f[19])
                    , z = r(z, C, w, D, d, 5, f[20])
                    , D = r(D, z, C, w, g, 9, f[21])
                    , w = r(w, D, z, C, k, 14, f[22])
                    , C = r(C, w, D, z, p, 20, f[23])
                    , z = r(z, C, w, D, v, 5, f[24])
                    , D = r(D, z, C, w, S, 9, f[25])
                    , w = r(w, D, z, C, u, 14, f[26])
                    , C = r(C, w, D, z, _, 20, f[27])
                    , z = r(z, C, w, D, x, 5, f[28])
                    , D = r(D, z, C, w, h, 9, f[29])
                    , w = r(w, D, z, C, y, 14, f[30])
                    , C = r(C, w, D, z, m, 20, f[31])
                    , z = i(z, C, w, D, d, 4, f[32])
                    , D = i(D, z, C, w, _, 11, f[33])
                    , w = i(w, D, z, C, B, 16, f[34])
                    , C = i(C, w, D, z, S, 23, f[35])
                    , z = i(z, C, w, D, a, 4, f[36])
                    , D = i(D, z, C, w, p, 11, f[37])
                    , w = i(w, D, z, C, y, 16, f[38])
                    , C = i(C, w, D, z, g, 23, f[39])
                    , z = i(z, C, w, D, x, 4, f[40])
                    , D = i(D, z, C, w, c, 11, f[41])
                    , w = i(w, D, z, C, u, 16, f[42])
                    , C = i(C, w, D, z, l, 23, f[43])
                    , z = i(z, C, w, D, v, 4, f[44])
                    , D = i(D, z, C, w, m, 11, f[45])
                    , w = i(w, D, z, C, k, 16, f[46])
                    , C = i(C, w, D, z, h, 23, f[47])
                    , z = n(z, C, w, D, c, 6, f[48])
                    , D = n(D, z, C, w, y, 10, f[49])
                    , w = n(w, D, z, C, S, 15, f[50])
                    , C = n(C, w, D, z, d, 21, f[51])
                    , z = n(z, C, w, D, m, 6, f[52])
                    , D = n(D, z, C, w, u, 10, f[53])
                    , w = n(w, D, z, C, g, 15, f[54])
                    , C = n(C, w, D, z, a, 21, f[55])
                    , z = n(z, C, w, D, _, 6, f[56])
                    , D = n(D, z, C, w, k, 10, f[57])
                    , w = n(w, D, z, C, l, 15, f[58])
                    , C = n(C, w, D, z, x, 21, f[59])
                    , z = n(z, C, w, D, p, 6, f[60])
                    , D = n(D, z, C, w, B, 10, f[61])
                    , w = n(w, D, z, C, h, 15, f[62])
                    , C = n(C, w, D, z, v, 21, f[63]);
                o[0] = o[0] + z | 0,
                    o[1] = o[1] + C | 0,
                    o[2] = o[2] + w | 0,
                    o[3] = o[3] + D | 0
            },
            _doFinalize: function() {
                var e = this._data
                    , r = e.words
                    , i = 8 * this._nDataBytes
                    , n = 8 * e.sigBytes;
                r[n >>> 5] |= 128 << 24 - n % 32;
                var s = t.floor(i / 4294967296);
                for (r[(n + 64 >>> 9 << 4) + 15] = 16711935 & (s << 8 | s >>> 24) | 4278255360 & (s << 24 | s >>> 8),
                         r[(n + 64 >>> 9 << 4) + 14] = 16711935 & (i << 8 | i >>> 24) | 4278255360 & (i << 24 | i >>> 8),
                         e.sigBytes = 4 * (r.length + 1),
                         this._process(),
                         e = this._hash,
                         r = e.words,
                         i = 0; 4 > i; i++)
                    n = r[i],
                        r[i] = 16711935 & (n << 8 | n >>> 24) | 4278255360 & (n << 24 | n >>> 8);
                return e
            },
            clone: function() {
                var t = a.clone.call(this);
                return t._hash = this._hash.clone(),
                    t
            }
        }),
            s.MD5 = a._createHelper(o),
            s.HmacMD5 = a._createHmacHelper(o)
    }(Math),
    function() {
        var t = CryptoJS
            , e = t.lib
            , r = e.Base
            , i = e.WordArray
            , e = t.algo
            , n = e.EvpKDF = r.extend({
            cfg: r.extend({
                keySize: 4,
                hasher: e.MD5,
                iterations: 1
            }),
            init: function(t) {
                this.cfg = this.cfg.extend(t)
            },
            compute: function(t, e) {
                for (var r = this.cfg, n = r.hasher.create(), s = i.create(), o = s.words, c = r.keySize, r = r.iterations; o.length < c; ) {
                    a && n.update(a);
                    var a = n.update(t).finalize(e);
                    n.reset();
                    for (var f = 1; r > f; f++)
                        a = n.finalize(a),
                            n.reset();
                    s.concat(a)
                }
                return s.sigBytes = 4 * c,
                    s
            }
        });
        t.EvpKDF = function(t, e, r) {
            return n.create(r).compute(t, e)
        }
    }(),
CryptoJS.lib.Cipher || function(t) {
    var e = CryptoJS
        , r = e.lib
        , i = r.Base
        , n = r.WordArray
        , s = r.BufferedBlockAlgorithm
        , o = e.enc.Base64
        , c = e.algo.EvpKDF
        , a = r.Cipher = s.extend({
        cfg: i.extend(),
        createEncryptor: function(t, e) {
            return this.create(this._ENC_XFORM_MODE, t, e)
        },
        createDecryptor: function(t, e) {
            return this.create(this._DEC_XFORM_MODE, t, e)
        },
        init: function(t, e, r) {
            this.cfg = this.cfg.extend(r),
                this._xformMode = t,
                this._key = e,
                this.reset()
        },
        reset: function() {
            s.reset.call(this),
                this._doReset()
        },
        process: function(t) {
            return this._append(t),
                this._process()
        },
        finalize: function(t) {
            return t && this._append(t),
                this._doFinalize()
        },
        keySize: 4,
        ivSize: 4,
        _ENC_XFORM_MODE: 1,
        _DEC_XFORM_MODE: 2,
        _createHelper: function(t) {
            return {
                encrypt: function(e, r, i) {
                    return ("string" == typeof r ? l : d).encrypt(t, e, r, i)
                },
                decrypt: function(e, r, i) {
                    return ("string" == typeof r ? l : d).decrypt(t, e, r, i)
                }
            }
        }
    });
    r.StreamCipher = a.extend({
        _doFinalize: function() {
            return this._process(!0)
        },
        blockSize: 1
    });
    var f = e.mode = {}
        , h = function(e, r, i) {
        var n = this._iv;
        n ? this._iv = t : n = this._prevBlock;
        for (var s = 0; i > s; s++)
            e[r + s] ^= n[s]
    }
        , u = (r.BlockCipherMode = i.extend({
        createEncryptor: function(t, e) {
            return this.Encryptor.create(t, e)
        },
        createDecryptor: function(t, e) {
            return this.Decryptor.create(t, e)
        },
        init: function(t, e) {
            this._cipher = t,
                this._iv = e
        }
    })).extend();
    u.Encryptor = u.extend({
        processBlock: function(t, e) {
            var r = this._cipher
                , i = r.blockSize;
            h.call(this, t, e, i),
                r.encryptBlock(t, e),
                this._prevBlock = t.slice(e, e + i)
        }
    }),
        u.Decryptor = u.extend({
            processBlock: function(t, e) {
                var r = this._cipher
                    , i = r.blockSize
                    , n = t.slice(e, e + i);
                r.decryptBlock(t, e),
                    h.call(this, t, e, i),
                    this._prevBlock = n
            }
        }),
        f = f.CBC = u,
        u = (e.pad = {}).Pkcs7 = {
            pad: function(t, e) {
                for (var r = 4 * e, r = r - t.sigBytes % r, i = r << 24 | r << 16 | r << 8 | r, s = [], o = 0; r > o; o += 4)
                    s.push(i);
                r = n.create(s, r),
                    t.concat(r)
            },
            unpad: function(t) {
                t.sigBytes -= 255 & t.words[t.sigBytes - 1 >>> 2]
            }
        },
        r.BlockCipher = a.extend({
            cfg: a.cfg.extend({
                mode: f,
                padding: u
            }),
            reset: function() {
                a.reset.call(this);
                var t = this.cfg
                    , e = t.iv
                    , t = t.mode;
                if (this._xformMode == this._ENC_XFORM_MODE)
                    var r = t.createEncryptor;
                else
                    r = t.createDecryptor,
                        this._minBufferSize = 1;
                this._mode = r.call(t, this, e && e.words)
            },
            _doProcessBlock: function(t, e) {
                this._mode.processBlock(t, e)
            },
            _doFinalize: function() {
                var t = this.cfg.padding;
                if (this._xformMode == this._ENC_XFORM_MODE) {
                    t.pad(this._data, this.blockSize);
                    var e = this._process(!0)
                } else
                    e = this._process(!0),
                        t.unpad(e);
                return e
            },
            blockSize: 4
        });
    var p = r.CipherParams = i.extend({
        init: function(t) {
            this.mixIn(t)
        },
        toString: function(t) {
            return (t || this.formatter).stringify(this)
        }
    })
        , f = (e.format = {}).OpenSSL = {
        stringify: function(t) {
            var e = t.ciphertext;
            return t = t.salt,
                (t ? n.create([1398893684, 1701076831]).concat(t).concat(e) : e).toString(o)
        },
        parse: function(t) {
            t = o.parse(t);
            var e = t.words;
            if (1398893684 == e[0] && 1701076831 == e[1]) {
                var r = n.create(e.slice(2, 4));
                e.splice(0, 4),
                    t.sigBytes -= 16
            }
            return p.create({
                ciphertext: t,
                salt: r
            })
        }
    }
        , d = r.SerializableCipher = i.extend({
        cfg: i.extend({
            format: f
        }),
        encrypt: function(t, e, r, i) {
            i = this.cfg.extend(i);
            var n = t.createEncryptor(r, i);
            return e = n.finalize(e),
                n = n.cfg,
                p.create({
                    ciphertext: e,
                    key: r,
                    iv: n.iv,
                    algorithm: t,
                    mode: n.mode,
                    padding: n.padding,
                    blockSize: t.blockSize,
                    formatter: i.format
                })
        },
        decrypt: function(t, e, r, i) {
            return i = this.cfg.extend(i),
                e = this._parse(e, i.format),
                t.createDecryptor(r, i).finalize(e.ciphertext)
        },
        _parse: function(t, e) {
            return "string" == typeof t ? e.parse(t, this) : t
        }
    })
        , e = (e.kdf = {}).OpenSSL = {
        execute: function(t, e, r, i) {
            return i || (i = n.random(8)),
                t = c.create({
                    keySize: e + r
                }).compute(t, i),
                r = n.create(t.words.slice(e), 4 * r),
                t.sigBytes = 4 * e,
                p.create({
                    key: t,
                    iv: r,
                    salt: i
                })
        }
    }
        , l = r.PasswordBasedCipher = d.extend({
        cfg: d.cfg.extend({
            kdf: e
        }),
        encrypt: function(t, e, r, i) {
            return i = this.cfg.extend(i),
                r = i.kdf.execute(r, t.keySize, t.ivSize),
                i.iv = r.iv,
                t = d.encrypt.call(this, t, e, r.key, i),
                t.mixIn(r),
                t
        },
        decrypt: function(t, e, r, i) {
            return i = this.cfg.extend(i),
                e = this._parse(e, i.format),
                r = i.kdf.execute(r, t.keySize, t.ivSize, e.salt),
                i.iv = r.iv,
                d.decrypt.call(this, t, e, r.key, i)
        }
    })
}(),
    function() {
        for (var t = CryptoJS, e = t.lib.BlockCipher, r = t.algo, i = [], n = [], s = [], o = [], c = [], a = [], f = [], h = [], u = [], p = [], d = [], l = 0; 256 > l; l++)
            d[l] = 128 > l ? l << 1 : l << 1 ^ 283;
        for (var y = 0, _ = 0, l = 0; 256 > l; l++) {
            var v = _ ^ _ << 1 ^ _ << 2 ^ _ << 3 ^ _ << 4
                , v = v >>> 8 ^ 255 & v ^ 99;
            i[y] = v,
                n[v] = y;
            var g = d[y]
                , B = d[g]
                , m = d[B]
                , x = 257 * d[v] ^ 16843008 * v;
            s[y] = x << 24 | x >>> 8,
                o[y] = x << 16 | x >>> 16,
                c[y] = x << 8 | x >>> 24,
                a[y] = x,
                x = 16843009 * m ^ 65537 * B ^ 257 * g ^ 16843008 * y,
                f[v] = x << 24 | x >>> 8,
                h[v] = x << 16 | x >>> 16,
                u[v] = x << 8 | x >>> 24,
                p[v] = x,
                y ? (y = g ^ d[d[d[m ^ g]]],
                    _ ^= d[d[_]]) : y = _ = 1
        }
        var S = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54]
            , r = r.AES = e.extend({
            _doReset: function() {
                for (var t = this._key, e = t.words, r = t.sigBytes / 4, t = 4 * ((this._nRounds = r + 6) + 1), n = this._keySchedule = [], s = 0; t > s; s++)
                    if (r > s)
                        n[s] = e[s];
                    else {
                        var o = n[s - 1];
                        s % r ? r > 6 && 4 == s % r && (o = i[o >>> 24] << 24 | i[o >>> 16 & 255] << 16 | i[o >>> 8 & 255] << 8 | i[255 & o]) : (o = o << 8 | o >>> 24,
                            o = i[o >>> 24] << 24 | i[o >>> 16 & 255] << 16 | i[o >>> 8 & 255] << 8 | i[255 & o],
                            o ^= S[s / r | 0] << 24),
                            n[s] = n[s - r] ^ o
                    }
                for (e = this._invKeySchedule = [],
                         r = 0; t > r; r++)
                    s = t - r,
                        o = r % 4 ? n[s] : n[s - 4],
                        e[r] = 4 > r || 4 >= s ? o : f[i[o >>> 24]] ^ h[i[o >>> 16 & 255]] ^ u[i[o >>> 8 & 255]] ^ p[i[255 & o]]
            },
            encryptBlock: function(t, e) {
                this._doCryptBlock(t, e, this._keySchedule, s, o, c, a, i)
            },
            decryptBlock: function(t, e) {
                var r = t[e + 1];
                t[e + 1] = t[e + 3],
                    t[e + 3] = r,
                    this._doCryptBlock(t, e, this._invKeySchedule, f, h, u, p, n),
                    r = t[e + 1],
                    t[e + 1] = t[e + 3],
                    t[e + 3] = r
            },
            _doCryptBlock: function(t, e, r, i, n, s, o, c) {
                for (var a = this._nRounds, f = t[e] ^ r[0], h = t[e + 1] ^ r[1], u = t[e + 2] ^ r[2], p = t[e + 3] ^ r[3], d = 4, l = 1; a > l; l++)
                     var y = i[f >>> 24] ^ n[h >>> 16 & 255] ^ s[u >>> 8 & 255] ^ o[255 & p] ^ r[d++]
                         , _ = i[h >>> 24] ^ n[u >>> 16 & 255] ^ s[p >>> 8 & 255] ^ o[255 & f] ^ r[d++]
                         , v = i[u >>> 24] ^ n[p >>> 16 & 255] ^ s[f >>> 8 & 255] ^ o[255 & h] ^ r[d++]
                         , p = i[p >>> 24] ^ n[f >>> 16 & 255] ^ s[h >>> 8 & 255] ^ o[255 & u] ^ r[d++]
                         , f = y
                         , h = _
                         , u = v;
                y = (c[f >>> 24] << 24 | c[h >>> 16 & 255] << 16 | c[u >>> 8 & 255] << 8 | c[255 & p]) ^ r[d++],
                    _ = (c[h >>> 24] << 24 | c[u >>> 16 & 255] << 16 | c[p >>> 8 & 255] << 8 | c[255 & f]) ^ r[d++],
                    v = (c[u >>> 24] << 24 | c[p >>> 16 & 255] << 16 | c[f >>> 8 & 255] << 8 | c[255 & h]) ^ r[d++],
                    p = (c[p >>> 24] << 24 | c[f >>> 16 & 255] << 16 | c[h >>> 8 & 255] << 8 | c[255 & u]) ^ r[d++],
                    t[e] = y,
                    t[e + 1] = _,
                    t[e + 2] = v,
                    t[e + 3] = p
            },
            keySize: 8
        });
        t.AES = e._createHelper(r)
    }();

CryptoJS.pad.ZeroPadding = {
    pad: function(s, a) {
        var i = 4 * a;
        s.clamp(),
            s.sigBytes += i - (s.sigBytes % i || i)
    },
    unpad: function(s) {
        for (var a = s.words, i = s.sigBytes - 1; !(a[i >>> 2] >>> 24 - i % 4 * 8 & 255); )
            i--;
        s.sigBytes = i + 1
    }
};



function get_params(pwd){
    var o = CryptoJS.MD5(Math.random() + "").toString();
    password = pwd;
    t = CryptoJS.AES.encrypt(password, o, {
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.ZeroPadding
    });
    password_encode = t.ciphertext.toString(CryptoJS.enc.Base64);
    console.log(password_encode);
    encrypt_iv = t.iv.toString(CryptoJS.enc.Base64);
    encrypt_key = t.key.toString(CryptoJS.enc.Base64);
    console.log(encrypt_iv);
    console.log(encrypt_key);

    return [password_encode,encrypt_iv,encrypt_key];
}