京东js加密 nloginpwd 破解

 

 

 

京东登录，有一个参数nloginpwd，是加密字段。

第一步：浏览器抓包

　　　　

 

第二部：搜索加密字段 js 代码

 

　　　　

 

第三部： 下断点

　　

　　2.

　　　

　　

 

 

 js代码：

var navigator = {};
var window = {};
var Base64 = {};
var ASN1 = {};
var Hex = {}; (function(a, b) {
if (typeof define === "function" && define.amd) {
    define(["exports"], b)
} else {
    if (typeof exports === "object" && typeof exports.nodeName !== "string") {
        b(module.exports)
    } else {
        b(a)
    }
}
})(this,
function(ap) {
var bE;
var n = 244837814094590;
var aV = ((n & 16777215) == 15715070);
function bf(z, t, L) {
    if (z != null) {
        if ("number" == typeof z) {
            this.fromNumber(z, t, L)
        } else {
            if (t == null && "string" != typeof z) {
                this.fromString(z, 256)
            } else {
                this.fromString(z, t)
            }
        }
    }
}
function bm() {
    return new bf(null)
}
function a7(bX, t, z, bW, bZ, bY) {
    while (--bY >= 0) {
        var L = t * this[bX++] + z[bW] + bZ;
        bZ = Math.floor(L / 67108864);
        z[bW++] = L & 67108863
    }
    return bZ
}
function a6(bX, b2, b3, bW, b0, t) {
    var bZ = b2 & 32767,
    b1 = b2 >> 15;
    while (--t >= 0) {
        var L = this[bX] & 32767;
        var bY = this[bX++] >> 15;
        var z = b1 * L + bY * bZ;
        L = bZ * L + ((z & 32767) << 15) + b3[bW] + (b0 & 1073741823);
        b0 = (L >>> 30) + (z >>> 15) + b1 * bY + (b0 >>> 30);
        b3[bW++] = L & 1073741823
    }
    return b0
}
function a5(bX, b2, b3, bW, b0, t) {
    var bZ = b2 & 16383,
    b1 = b2 >> 14;
    while (--t >= 0) {
        var L = this[bX] & 16383;
        var bY = this[bX++] >> 14;
        var z = b1 * L + bY * bZ;
        L = bZ * L + ((z & 16383) << 14) + b3[bW] + b0;
        b0 = (L >> 28) + (z >> 14) + b1 * bY;
        b3[bW++] = L & 268435455
    }
    return b0
}
if (aV && (navigator.appName == "Microsoft Internet Explorer")) {
    bf.prototype.am = a6;
    bE = 30
} else {
    if (aV && (navigator.appName != "Netscape")) {
        bf.prototype.am = a7;
        bE = 26
    } else {
        bf.prototype.am = a5;
        bE = 28
    }
}
bf.prototype.DB = bE;
bf.prototype.DM = ((1 << bE) - 1);
bf.prototype.DV = (1 << bE);
var bQ = 52;
bf.prototype.FV = Math.pow(2, bQ);
bf.prototype.F1 = bQ - bE;
bf.prototype.F2 = 2 * bE - bQ;
var a = "0123456789abcdefghijklmnopqrstuvwxyz";
var g = new Array();
var aH, E;
aH = "0".charCodeAt(0);
for (E = 0; E <= 9; ++E) {
    g[aH++] = E
}
aH = "a".charCodeAt(0);
for (E = 10; E < 36; ++E) {
    g[aH++] = E
}
aH = "A".charCodeAt(0);
for (E = 10; E < 36; ++E) {
    g[aH++] = E
}
function Y(t) {
    return a.charAt(t)
}
function aX(z, t) {
    var L = g[z.charCodeAt(t)];
    return (L == null) ? -1 : L
}
function d(z) {
    for (var t = this.t - 1; t >= 0; --t) {
        z[t] = this[t]
    }
    z.t = this.t;
    z.s = this.s
}
function h(t) {
    this.t = 1;
    this.s = (t < 0) ? -1 : 0;
    if (t > 0) {
        this[0] = t
    } else {
        if (t < -1) {
            this[0] = t + this.DV
        } else {
            this.t = 0
        }
    }
}
function bi(t) {
    var z = bm();
    z.fromInt(t);
    return z
}
function bI(bZ, z) {
    var bW;
    if (z == 16) {
        bW = 4
    } else {
        if (z == 8) {
            bW = 3
        } else {
            if (z == 256) {
                bW = 8
            } else {
                if (z == 2) {
                    bW = 1
                } else {
                    if (z == 32) {
                        bW = 5
                    } else {
                        if (z == 4) {
                            bW = 2
                        } else {
                            this.fromRadix(bZ, z);
                            return
                        }
                    }
                }
            }
        }
    }
    this.t = 0;
    this.s = 0;
    var bY = bZ.length,
    L = false,
    bX = 0;
    while (--bY >= 0) {
        var t = (bW == 8) ? bZ[bY] & 255 : aX(bZ, bY);
        if (t < 0) {
            if (bZ.charAt(bY) == "-") {
                L = true
            }
            continue
        }
        L = false;
        if (bX == 0) {
            this[this.t++] = t
        } else {
            if (bX + bW > this.DB) {
                this[this.t - 1] |= (t & ((1 << (this.DB - bX)) - 1)) << bX;
                this[this.t++] = (t >> (this.DB - bX))
            } else {
                this[this.t - 1] |= t << bX
            }
        }
        bX += bW;
        if (bX >= this.DB) {
            bX -= this.DB
        }
    }
    if (bW == 8 && (bZ[0] & 128) != 0) {
        this.s = -1;
        if (bX > 0) {
            this[this.t - 1] |= ((1 << (this.DB - bX)) - 1) << bX
        }
    }
    this.clamp();
    if (L) {
        bf.ZERO.subTo(this, this)
    }
}
function bA() {
    var t = this.s & this.DM;
    while (this.t > 0 && this[this.t - 1] == t) {--this.t
    }
}
function u(z) {
    if (this.s < 0) {
        return "-" + this.negate().toString(z)
    }
    var L;
    if (z == 16) {
        L = 4
    } else {
        if (z == 8) {
            L = 3
        } else {
            if (z == 2) {
                L = 1
            } else {
                if (z == 32) {
                    L = 5
                } else {
                    if (z == 4) {
                        L = 2
                    } else {
                        return this.toRadix(z)
                    }
                }
            }
        }
    }
    var bX = (1 << L) - 1,
    b0,
    t = false,
    bY = "",
    bW = this.t;
    var bZ = this.DB - (bW * this.DB) % L;
    if (bW-->0) {
        if (bZ < this.DB && (b0 = this[bW] >> bZ) > 0) {
            t = true;
            bY = Y(b0)
        }
        while (bW >= 0) {
            if (bZ < L) {
                b0 = (this[bW] & ((1 << bZ) - 1)) << (L - bZ);
                b0 |= this[--bW] >> (bZ += this.DB - L)
            } else {
                b0 = (this[bW] >> (bZ -= L)) & bX;
                if (bZ <= 0) {
                    bZ += this.DB; --bW
                }
            }
            if (b0 > 0) {
                t = true
            }
            if (t) {
                bY += Y(b0)
            }
        }
    }
    return t ? bY: "0"
}
function bC() {
    var t = bm();
    bf.ZERO.subTo(this, t);
    return t
}
function bB() {
    return (this.s < 0) ? this.negate() : this
}
function bN(t) {
    var L = this.s - t.s;
    if (L != 0) {
        return L
    }
    var z = this.t;
    L = z - t.t;
    if (L != 0) {
        return (this.s < 0) ? -L: L
    }
    while (--z >= 0) {
        if ((L = this[z] - t[z]) != 0) {
            return L
        }
    }
    return 0
}
function q(z) {
    var bW = 1,
    L;
    if ((L = z >>> 16) != 0) {
        z = L;
        bW += 16
    }
    if ((L = z >> 8) != 0) {
        z = L;
        bW += 8
    }
    if ((L = z >> 4) != 0) {
        z = L;
        bW += 4
    }
    if ((L = z >> 2) != 0) {
        z = L;
        bW += 2
    }
    if ((L = z >> 1) != 0) {
        z = L;
        bW += 1
    }
    return bW
}
function bt() {
    if (this.t <= 0) {
        return 0
    }
    return this.DB * (this.t - 1) + q(this[this.t - 1] ^ (this.s & this.DM))
}
function bv(L, z) {
    var t;
    for (t = this.t - 1; t >= 0; --t) {
        z[t + L] = this[t]
    }
    for (t = L - 1; t >= 0; --t) {
        z[t] = 0
    }
    z.t = this.t + L;
    z.s = this.s
}
function a2(L, z) {
    for (var t = L; t < this.t; ++t) {
        z[t - L] = this[t]
    }
    z.t = Math.max(this.t - L, 0);
    z.s = this.s
}
function s(b0, bW) {
    var z = b0 % this.DB;
    var t = this.DB - z;
    var bY = (1 << t) - 1;
    var bX = Math.floor(b0 / this.DB),
    bZ = (this.s << z) & this.DM,
    L;
    for (L = this.t - 1; L >= 0; --L) {
        bW[L + bX + 1] = (this[L] >> t) | bZ;
        bZ = (this[L] & bY) << z
    }
    for (L = bX - 1; L >= 0; --L) {
        bW[L] = 0
    }
    bW[bX] = bZ;
    bW.t = this.t + bX + 1;
    bW.s = this.s;
    bW.clamp()
}
function bT(bZ, bW) {
    bW.s = this.s;
    var bX = Math.floor(bZ / this.DB);
    if (bX >= this.t) {
        bW.t = 0;
        return
    }
    var z = bZ % this.DB;
    var t = this.DB - z;
    var bY = (1 << z) - 1;
    bW[0] = this[bX] >> z;
    for (var L = bX + 1; L < this.t; ++L) {
        bW[L - bX - 1] |= (this[L] & bY) << t;
        bW[L - bX] = this[L] >> z
    }
    if (z > 0) {
        bW[this.t - bX - 1] |= (this.s & bY) << t
    }
    bW.t = this.t - bX;
    bW.clamp()
}
function bs(z, bW) {
    var L = 0,
    bX = 0,
    t = Math.min(z.t, this.t);
    while (L < t) {
        bX += this[L] - z[L];
        bW[L++] = bX & this.DM;
        bX >>= this.DB
    }
    if (z.t < this.t) {
        bX -= z.s;
        while (L < this.t) {
            bX += this[L];
            bW[L++] = bX & this.DM;
            bX >>= this.DB
        }
        bX += this.s
    } else {
        bX += this.s;
        while (L < z.t) {
            bX -= z[L];
            bW[L++] = bX & this.DM;
            bX >>= this.DB
        }
        bX -= z.s
    }
    bW.s = (bX < 0) ? -1 : 0;
    if (bX < -1) {
        bW[L++] = this.DV + bX
    } else {
        if (bX > 0) {
            bW[L++] = bX
        }
    }
    bW.t = L;
    bW.clamp()
}
function bJ(z, bW) {
    var t = this.abs(),
    bX = z.abs();
    var L = t.t;
    bW.t = L + bX.t;
    while (--L >= 0) {
        bW[L] = 0
    }
    for (L = 0; L < bX.t; ++L) {
        bW[L + t.t] = t.am(0, bX[L], bW, L, 0, t.t)
    }
    bW.s = 0;
    bW.clamp();
    if (this.s != z.s) {
        bf.ZERO.subTo(bW, bW)
    }
}
function au(L) {
    var t = this.abs();
    var z = L.t = 2 * t.t;
    while (--z >= 0) {
        L[z] = 0
    }
    for (z = 0; z < t.t - 1; ++z) {
        var bW = t.am(z, t[z], L, 2 * z, 0, 1);
        if ((L[z + t.t] += t.am(z + 1, 2 * t[z], L, 2 * z + 1, bW, t.t - z - 1)) >= t.DV) {
            L[z + t.t] -= t.DV;
            L[z + t.t + 1] = 1
        }
    }
    if (L.t > 0) {
        L[L.t - 1] += t.am(z, t[z], L, 2 * z, 0, 1)
    }
    L.s = 0;
    L.clamp()
}
function a9(b3, b0, bZ) {
    var b9 = b3.abs();
    if (b9.t <= 0) {
        return
    }
    var b1 = this.abs();
    if (b1.t < b9.t) {
        if (b0 != null) {
            b0.fromInt(0)
        }
        if (bZ != null) {
            this.copyTo(bZ)
        }
        return
    }
    if (bZ == null) {
        bZ = bm()
    }
    var bX = bm(),
    z = this.s,
    b2 = b3.s;
    var b8 = this.DB - q(b9[b9.t - 1]);
    if (b8 > 0) {
        b9.lShiftTo(b8, bX);
        b1.lShiftTo(b8, bZ)
    } else {
        b9.copyTo(bX);
        b1.copyTo(bZ)
    }
    var b5 = bX.t;
    var L = bX[b5 - 1];
    if (L == 0) {
        return
    }
    var b4 = L * (1 << this.F1) + ((b5 > 1) ? bX[b5 - 2] >> this.F2: 0);
    var cc = this.FV / b4,
    cb = (1 << this.F1) / b4,
    ca = 1 << this.F2;
    var b7 = bZ.t,
    b6 = b7 - b5,
    bY = (b0 == null) ? bm() : b0;
    bX.dlShiftTo(b6, bY);
    if (bZ.compareTo(bY) >= 0) {
        bZ[bZ.t++] = 1;
        bZ.subTo(bY, bZ)
    }
    bf.ONE.dlShiftTo(b5, bY);
    bY.subTo(bX, bX);
    while (bX.t < b5) {
        bX[bX.t++] = 0
    }
    while (--b6 >= 0) {
        var bW = (bZ[--b7] == L) ? this.DM: Math.floor(bZ[b7] * cc + (bZ[b7 - 1] + ca) * cb);
        if ((bZ[b7] += bX.am(0, bW, bZ, b6, 0, b5)) < bW) {
            bX.dlShiftTo(b6, bY);
            bZ.subTo(bY, bZ);
            while (bZ[b7] < --bW) {
                bZ.subTo(bY, bZ)
            }
        }
    }
    if (b0 != null) {
        bZ.drShiftTo(b5, b0);
        if (z != b2) {
            bf.ZERO.subTo(b0, b0)
        }
    }
    bZ.t = b5;
    bZ.clamp();
    if (b8 > 0) {
        bZ.rShiftTo(b8, bZ)
    }
    if (z < 0) {
        bf.ZERO.subTo(bZ, bZ)
    }
}
function bh(t) {
    var z = bm();
    this.abs().divRemTo(t, null, z);
    if (this.s < 0 && z.compareTo(bf.ZERO) > 0) {
        t.subTo(z, z)
    }
    return z
}
function aT(t) {
    this.m = t
}
function aI(t) {
    if (t.s < 0 || t.compareTo(this.m) >= 0) {
        return t.mod(this.m)
    } else {
        return t
    }
}
function c(t) {
    return t
}
function V(t) {
    t.divRemTo(this.m, null, t)
}
function p(t, L, z) {
    t.multiplyTo(L, z);
    this.reduce(z)
}
function aF(t, z) {
    t.squareTo(z);
    this.reduce(z)
}
aT.prototype.convert = aI;
aT.prototype.revert = c;
aT.prototype.reduce = V;
aT.prototype.mulTo = p;
aT.prototype.sqrTo = aF;
function ab() {
    if (this.t < 1) {
        return 0
    }
    var t = this[0];
    if ((t & 1) == 0) {
        return 0
    }
    var z = t & 3;
    z = (z * (2 - (t & 15) * z)) & 15;
    z = (z * (2 - (t & 255) * z)) & 255;
    z = (z * (2 - (((t & 65535) * z) & 65535))) & 65535;
    z = (z * (2 - t * z % this.DV)) % this.DV;
    return (z > 0) ? this.DV - z: -z
}
function K(t) {
    this.m = t;
    this.mp = t.invDigit();
    this.mpl = this.mp & 32767;
    this.mph = this.mp >> 15;
    this.um = (1 << (t.DB - 15)) - 1;
    this.mt2 = 2 * t.t
}
function by(t) {
    var z = bm();
    t.abs().dlShiftTo(this.m.t, z);
    z.divRemTo(this.m, null, z);
    if (t.s < 0 && z.compareTo(bf.ZERO) > 0) {
        this.m.subTo(z, z)
    }
    return z
}
function bl(t) {
    var z = bm();
    t.copyTo(z);
    this.reduce(z);
    return z
}
function bV(t) {
    while (t.t <= this.mt2) {
        t[t.t++] = 0
    }
    for (var L = 0; L < this.m.t; ++L) {
        var z = t[L] & 32767;
        var bW = (z * this.mpl + (((z * this.mph + (t[L] >> 15) * this.mpl) & this.um) << 15)) & t.DM;
        z = L + this.m.t;
        t[z] += this.m.am(0, bW, t, L, 0, this.m.t);
        while (t[z] >= t.DV) {
            t[z] -= t.DV;
            t[++z]++
        }
    }
    t.clamp();
    t.drShiftTo(this.m.t, t);
    if (t.compareTo(this.m) >= 0) {
        t.subTo(this.m, t)
    }
}
function ac(t, z) {
    t.squareTo(z);
    this.reduce(z)
}
function bz(t, L, z) {
    t.multiplyTo(L, z);
    this.reduce(z)
}
K.prototype.convert = by;
K.prototype.revert = bl;
K.prototype.reduce = bV;
K.prototype.mulTo = bz;
K.prototype.sqrTo = ac;
function ad() {
    return ((this.t > 0) ? (this[0] & 1) : this.s) == 0
}
function am(b0, b1) {
    if (b0 > 4294967295 || b0 < 1) {
        return bf.ONE
    }
    var bZ = bm(),
    L = bm(),
    bY = b1.convert(this),
    bX = q(b0) - 1;
    bY.copyTo(bZ);
    while (--bX >= 0) {
        b1.sqrTo(bZ, L);
        if ((b0 & (1 << bX)) > 0) {
            b1.mulTo(L, bY, bZ)
        } else {
            var bW = bZ;
            bZ = L;
            L = bW
        }
    }
    return b1.revert(bZ)
}
function aG(L, t) {
    var bW;
    if (L < 256 || t.isEven()) {
        bW = new aT(t)
    } else {
        bW = new K(t)
    }
    return this.exp(L, bW)
}
bf.prototype.copyTo = d;
bf.prototype.fromInt = h;
bf.prototype.fromString = bI;
bf.prototype.clamp = bA;
bf.prototype.dlShiftTo = bv;
bf.prototype.drShiftTo = a2;
bf.prototype.lShiftTo = s;
bf.prototype.rShiftTo = bT;
bf.prototype.subTo = bs;
bf.prototype.multiplyTo = bJ;
bf.prototype.squareTo = au;
bf.prototype.divRemTo = a9;
bf.prototype.invDigit = ab;
bf.prototype.isEven = ad;
bf.prototype.exp = am;
bf.prototype.toString = u;
bf.prototype.negate = bC;
bf.prototype.abs = bB;
bf.prototype.compareTo = bN;
bf.prototype.bitLength = bt;
bf.prototype.mod = bh;
bf.prototype.modPowInt = aG;
bf.ZERO = bi(0);
bf.ONE = bi(1);
function f() {
    var t = bm();
    this.copyTo(t);
    return t
}
function b() {
    if (this.s < 0) {
        if (this.t == 1) {
            return this[0] - this.DV
        } else {
            if (this.t == 0) {
                return - 1
            }
        }
    } else {
        if (this.t == 1) {
            return this[0]
        } else {
            if (this.t == 0) {
                return 0
            }
        }
    }
    return ((this[1] & ((1 << (32 - this.DB)) - 1)) << this.DB) | this[0]
}
function bF() {
    return (this.t == 0) ? this.s: (this[0] << 24) >> 24
}
function ag() {
    return (this.t == 0) ? this.s: (this[0] << 16) >> 16
}
function aU(t) {
    return Math.floor(Math.LN2 * this.DB / Math.log(t))
}
function aZ() {
    if (this.s < 0) {
        return - 1
    } else {
        if (this.t <= 0 || (this.t == 1 && this[0] <= 0)) {
            return 0
        } else {
            return 1
        }
    }
}
function I(t) {
    if (t == null) {
        t = 10
    }
    if (this.signum() == 0 || t < 2 || t > 36) {
        return "0"
    }
    var bW = this.chunkSize(t);
    var L = Math.pow(t, bW);
    var bZ = bi(L),
    b0 = bm(),
    bY = bm(),
    bX = "";
    this.divRemTo(bZ, b0, bY);
    while (b0.signum() > 0) {
        bX = (L + bY.intValue()).toString(t).substr(1) + bX;
        b0.divRemTo(bZ, b0, bY)
    }
    return bY.intValue().toString(t) + bX
}
function av(b1, bY) {
    this.fromInt(0);
    if (bY == null) {
        bY = 10
    }
    var bW = this.chunkSize(bY);
    var bX = Math.pow(bY, bW),
    L = false,
    t = 0,
    b0 = 0;
    for (var z = 0; z < b1.length; ++z) {
        var bZ = aX(b1, z);
        if (bZ < 0) {
            if (b1.charAt(z) == "-" && this.signum() == 0) {
                L = true
            }
            continue
        }
        b0 = bY * b0 + bZ;
        if (++t >= bW) {
            this.dMultiply(bX);
            this.dAddOffset(b0, 0);
            t = 0;
            b0 = 0
        }
    }
    if (t > 0) {
        this.dMultiply(Math.pow(bY, t));
        this.dAddOffset(b0, 0)
    }
    if (L) {
        bf.ZERO.subTo(this, this)
    }
}
function aP(bW, L, bY) {
    if ("number" == typeof L) {
        if (bW < 2) {
            this.fromInt(1)
        } else {
            this.fromNumber(bW, bY);
            if (!this.testBit(bW - 1)) {
                this.bitwiseTo(bf.ONE.shiftLeft(bW - 1), ak, this)
            }
            if (this.isEven()) {
                this.dAddOffset(1, 0)
            }
            while (!this.isProbablePrime(L)) {
                this.dAddOffset(2, 0);
                if (this.bitLength() > bW) {
                    this.subTo(bf.ONE.shiftLeft(bW - 1), this)
                }
            }
        }
    } else {
        var z = new Array(),
        bX = bW & 7;
        z.length = (bW >> 3) + 1;
        L.nextBytes(z);
        if (bX > 0) {
            z[0] &= ((1 << bX) - 1)
        } else {
            z[0] = 0
        }
        this.fromString(z, 256)
    }
}
function aK() {
    var z = this.t,
    L = new Array();
    L[0] = this.s;
    var bW = this.DB - (z * this.DB) % 8,
    bX,
    t = 0;
    if (z-->0) {
        if (bW < this.DB && (bX = this[z] >> bW) != (this.s & this.DM) >> bW) {
            L[t++] = bX | (this.s << (this.DB - bW))
        }
        while (z >= 0) {
            if (bW < 8) {
                bX = (this[z] & ((1 << bW) - 1)) << (8 - bW);
                bX |= this[--z] >> (bW += this.DB - 8)
            } else {
                bX = (this[z] >> (bW -= 8)) & 255;
                if (bW <= 0) {
                    bW += this.DB; --z
                }
            }
            if ((bX & 128) != 0) {
                bX |= -256
            }
            if (t == 0 && (this.s & 128) != (bX & 128)) {++t
            }
            if (t > 0 || bX != this.s) {
                L[t++] = bX
            }
        }
    }
    return L
}
function bG(t) {
    return (this.compareTo(t) == 0)
}
function W(t) {
    return (this.compareTo(t) < 0) ? this: t
}
function bu(t) {
    return (this.compareTo(t) > 0) ? this: t
}
function aJ(z, bY, bW) {
    var L, bX, t = Math.min(z.t, this.t);
    for (L = 0; L < t; ++L) {
        bW[L] = bY(this[L], z[L])
    }
    if (z.t < this.t) {
        bX = z.s & this.DM;
        for (L = t; L < this.t; ++L) {
            bW[L] = bY(this[L], bX)
        }
        bW.t = this.t
    }