房天下登录加密分析

最新推荐文章于 2021-08-12 10:23:51 发布
置顶 最新推荐文章于 2021-08-12 10:23:51 发布
阅读量811 收藏
点赞数
分类专栏： 爬虫
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wu0che28/article/details/85682087
版权

分析做研究使用,非用作商业使用

url="https://passport.fang.com/login.api"
data ={
    'uid': "13******5",
    'pwd': "c88cff40bfdhgfjhgj2cf78352b8ca78789cdf0b2350a51967b2bb32d4c5905860863b7f119e43c4e4727f8dd650e5b45dc633890f113c86400e5fcbf1f56b87c5631b05625d2abfb154e68sffghu657885720e39a0af67266ce901e7a8160f6dbe8e98a1846cefe60fbbd55ed5464d4a6296e82d2a2d663f21801768b1736e60f56bbeda",
    'service': "soufun-passport-web",
    'autologin': "1",
    }
# post 提交数据

PWD加密分析

  pwd: encryptedString(key_to_encode, that.password.val())

加密是通过RSA加密的,具体的如何实现,先看:

var key_to_encode = new RSAKeyPair("010001", "", "978C0A92D2173439707498F0944AA476B1B62595877DD6FA87F6E2AC6DCB3D0BF0B82857439C99B5091192BC134889DFF60C562EC54EFBA4FF2F9D55ADBCCEA4A2FBA80CB398ED501280A007C83AF30C3D1A142D6133C63012B90AB26AC60C898FB66EDC3192C3EC4FF66925A64003B72496099F4F09A9FB72A2CF9E4D770C41");

key_to_encode 返回的应该是公钥通过get https://passport.fang.com/?backurl=https://www1.fang.com/ 获得,从网站的分析来看,这个是应该是写死的,也保不齐哪一天网站会换一个公钥,直接替换掉也行.

加密代码:


function get_pwd(password){
function setMaxDigits(n) {
    maxDigits = n;
    ZERO_ARRAY = new Array(maxDigits);
    for (var t = 0; t < ZERO_ARRAY.length; t++)
        ZERO_ARRAY[t] = 0;
    bigZero = new BigInt;
    bigOne = new BigInt;
    bigOne.digits[0] = 1
}
function BigInt(n) {

    this.digits = typeof n == "boolean" && n == !0 ? null : ZERO_ARRAY.slice(0);
    this.isNeg = !1
}
function biFromDecimal(n) {
    for (var u = n.charAt(0) == "-", t = u ? 1 : 0, i, f, r; t < n.length && n.charAt(t) == "0"; )
        ++t;
    if (t == n.length)
        i = new BigInt;
    else {
        for (f = n.length - t,
                 r = f % dpl10,
             r == 0 && (r = dpl10),
                 i = biFromNumber(Number(n.substr(t, r))),
                 t += r; t < n.length; )
            i = biAdd(biMultiply(i, lr10), biFromNumber(Number(n.substr(t, dpl10)))),
                t += dpl10;
        i.isNeg = u
    }
    return i
}
function biCopy(n) {
    var t = new BigInt(!0);
    return t.digits = n.digits.slice(0),
        t.isNeg = n.isNeg,
        t
}
function biFromNumber(n) {
    var t = new BigInt, i;
    for (t.isNeg = n < 0,
             n = Math.abs(n),
             i = 0; n > 0; )
        t.digits[i++] = n & maxDigitVal,
            n = Math.floor(n / biRadix);
    return t
}
function reverseStr(n) {
    for (var i = "", t = n.length - 1; t > -1; --t)
        i += n.charAt(t);
    return i
}
function biToString(n, t) {
    var r = new BigInt, i, u;
    for (r.digits[0] = t,
             i = biDivideModulo(n, r),
             u = hexatrigesimalToChar[i[1].digits[0]]; biCompare(i[0], bigZero) == 1; )
        i = biDivideModulo(i[0], r),
            digit = i[1].digits[0],
            u += hexatrigesimalToChar[i[1].digits[0]];
    return (n.isNeg ? "-" : "") + reverseStr(u)
}
function biToDecimal(n) {
    var i = new BigInt, t, r;
    for (i.digits[0] = 10,
             t = biDivideModulo(n, i),
             r = String(t[1].digits[0]); biCompare(t[0], bigZero) == 1; )
        t = biDivideModulo(t[0], i),
            r += String(t[1].digits[0]);
    return (n.isNeg ? "-" : "") + reverseStr(r)
}
function digitToHex(n) {
    var t = "";
    for (i = 0; i < 4; ++i)
        t += hexToChar[n & 15],
            n >>>= 4;
    return reverseStr(t)
}
function biToHex(n) {
    for (var i = "", r = biHighIndex(n), t = biHighIndex(n); t > -1; --t)
        i += digitToHex(n.digits[t]);
    return i
}
function charToHex(n) {
    var t = 48
        , u = t + 9
        , i = 97
        , f = i + 25
        , r = 65;
    return n >= t && n <= u ? n - t : n >= r && n <= 90 ? 10 + n - r : n >= i && n <= f ? 10 + n - i : 0
}
function hexToDigit(n) {
    for (var t = 0, r = Math.min(n.length, 4), i = 0; i < r; ++i)
        t <<= 4,
            t |= charToHex(n.charCodeAt(i));
    return t
}
function biFromHex(n) {
    for (var i = new BigInt, u = n.length, t = u, r = 0; t > 0; t -= 4,
        ++r)
        i.digits[r] = hexToDigit(n.substr(Math.max(t - 4, 0), Math.min(t, 4)));
    return i
}
function biFromString(n, t) {
    var f = n.charAt(0) == "-", e = f ? 1 : 0, i = new BigInt, r = new BigInt, u;
    for (r.digits[0] = 1,
             u = n.length - 1; u >= e; u--) {
        var o = n.charCodeAt(u)
            , s = charToHex(o)
            , h = biMultiplyDigit(r, s);
        i = biAdd(i, h);
        r = biMultiplyDigit(r, t)
    }
    return i.isNeg = f,
        i
}
function biDump(n) {
    return (n.isNeg ? "-" : "") + n.digits.join(" ")
}
function biAdd(n, t) {
    var r, u, f, i;
    if (n.isNeg != t.isNeg)
        t.isNeg = !t.isNeg,
            r = biSubtract(n, t),
            t.isNeg = !t.isNeg;
    else {
        for (r = new BigInt,
                 u = 0,
                 i = 0; i < n.digits.length; ++i)
            f = n.digits[i] + t.digits[i] + u,
                r.digits[i] = f % biRadix,
                u = Number(f >= biRadix);
        r.isNeg = n.isNeg
    }
    return r
}
function biSubtract(n, t) {
    var r, f, u, i;
    if (n.isNeg != t.isNeg)
        t.isNeg = !t.isNeg,
            r = biAdd(n, t),
            t.isNeg = !t.isNeg;
    else {
        for (r = new BigInt,
                 u = 0,
                 i = 0; i < n.digits.length; ++i)
            f = n.digits[i] - t.digits[i] + u,
                r.digits[i] = f % biRadix,
            r.digits[i] < 0 && (r.digits[i] += biRadix),
                u = 0 - Number(f < 0);
        if (u == -1) {
            for (u = 0,
                     i = 0; i < n.digits.length; ++i)
                f = 0 - r.digits[i] + u,
                    r.digits[i] = f % biRadix,
                r.digits[i] < 0 && (r.digits[i] += biRadix),
                    u = 0 - Number(f < 0);
            r.isNeg = !n.isNeg
        } else
            r.isNeg = n.isNeg
    }
    return r
}
function biHighIndex(n) {
    for (var t = n.digits.length - 1; t > 0 && n.digits[t] == 0; )
        --t;
    return t
}
function biNumBits(n) {
    for (var i = biHighIndex(n), r = n.digits[i], u = (i + 1) * bitsPerDigit, t = u; t > u - bitsPerDigit; --t) {
        if ((r & 32768) != 0)
            break;
        r <<= 1
    }
    return t
}
function biMultiply(n, t) {
    for (var i = new BigInt, u, o = biHighIndex(n), s = biHighIndex(t), e, f, r = 0; r <= s; ++r) {
        for (u = 0,
                 f = r,
                 j = 0; j <= o; ++j,
                 ++f)
            e = i.digits[f] + n.digits[j] * t.digits[r] + u,
                i.digits[f] = e & maxDigitVal,
                u = e >>> biRadixBits;
        i.digits[r + o + 1] = u
    }
    return i.isNeg = n.isNeg != t.isNeg,
        i
}
function biMultiplyDigit(n, t) {
    var u, r, f, i;
    for (result = new BigInt,
             u = biHighIndex(n),
             r = 0,
             i = 0; i <= u; ++i)
        f = result.digits[i] + n.digits[i] * t + r,
            result.digits[i] = f & maxDigitVal,
            r = f >>> biRadixBits;
    return result.digits[1 + u] = r,
        result
}
function arrayCopy(n, t, i, r, u) {
    for (var o = Math.min(t + u, n.length), f = t, e = r; f < o; ++f,
        ++e)
        i[e] = n[f]
}
function biShiftLeft(n, t) {
    var e = Math.floor(t / bitsPerDigit), i = new BigInt, u, o, r, f;
    for (arrayCopy(n.digits, 0, i.digits, e, i.digits.length - e),
             u = t % bitsPerDigit,
             o = bitsPerDigit - u,
             r = i.digits.length - 1,
             f = r - 1; r > 0; --r,
             --f)
        i.digits[r] = i.digits[r] << u & maxDigitVal | (i.digits[f] & highBitMasks[u]) >>> o;
    return i.digits[0] = i.digits[r] << u & maxDigitVal,
        i.isNeg = n.isNeg,
        i
}
function biShiftRight(n, t) {
    var e = Math.floor(t / bitsPerDigit), i = new BigInt, u, o, r, f;
    for (arrayCopy(n.digits, e, i.digits, 0, n.digits.length - e),
             u = t % bitsPerDigit,
             o = bitsPerDigit - u,
             r = 0,
             f = r + 1; r < i.digits.length - 1; ++r,
             ++f)
        i.digits[r] = i.digits[r] >>> u | (i.digits[f] & lowBitMasks[u]) << o;
    return i.digits[i.digits.length - 1] >>>= u,
        i.isNeg = n.isNeg,
        i
}
function biMultiplyByRadixPower(n, t) {
    var i = new BigInt;
    return arrayCopy(n.digits, 0, i.digits, t, i.digits.length - t),
        i
}
function biDivideByRadixPower(n, t) {
    var i = new BigInt;
    return arrayCopy(n.digits, t, i.digits, 0, i.digits.length - t),
        i
}
function biModuloByRadixPower(n, t) {
    var i = new BigInt;
    return arrayCopy(n.digits, 0, i.digits, 0, t),
        i
}
function biCompare(n, t) {
    if (n.isNeg != t.isNeg)
        return 1 - 2 * Number(n.isNeg);
    for (var i = n.digits.length - 1; i >= 0; --i)
        if (n.digits[i] != t.digits[i])
            return n.isNeg ? 1 - 2 * Number(n.digits[i] > t.digits[i]) : 1 - 2 * Number(n.digits[i] < t.digits[i]);
    return 0
}
function biDivideModulo(n, t) {
    var a = biNumBits(n), s = biNumBits(t), v = t.isNeg, r, i, u, e, h, o, f, y, p;
    if (a < s)
        return n.isNeg ? (r = biCopy(bigOne),
            r.isNeg = !t.isNeg,
            n.isNeg = !1,
            t.isNeg = !1,
            i = biSubtract(t, n),
            n.isNeg = !0,
            t.isNeg = v) : (r = new BigInt,
            i = biCopy(n)),
            [r, i];
    for (r = new BigInt,
             i = n,
             u = Math.ceil(s / bitsPerDigit) - 1,
             e = 0; t.digits[u] < biHalfRadix; )
        t = biShiftLeft(t, 1),
            ++e,
            ++s,
            u = Math.ceil(s / bitsPerDigit) - 1;
    for (i = biShiftLeft(i, e),
             a += e,
             h = Math.ceil(a / bitsPerDigit) - 1,
             o = biMultiplyByRadixPower(t, h - u); biCompare(i, o) != -1; )
        ++r.digits[h - u],
            i = biSubtract(i, o);
    for (f = h; f > u; --f) {
        var c = f >= i.digits.length ? 0 : i.digits[f]
            , w = f - 1 >= i.digits.length ? 0 : i.digits[f - 1]
            , b = f - 2 >= i.digits.length ? 0 : i.digits[f - 2]
            , l = u >= t.digits.length ? 0 : t.digits[u]
            , k = u - 1 >= t.digits.length ? 0 : t.digits[u - 1];
        for (r.digits[f - u - 1] = c == l ? maxDigitVal : Math.floor((c * biRadix + w) / l),
                 y = r.digits[f - u - 1] * (l * biRadix + k),
                 p = c * biRadixSquared + (w * biRadix + b); y > p; )
            --r.digits[f - u - 1],
                y = r.digits[f - u - 1] * (l * biRadix | k),
                p = c * biRadix * biRadix + (w * biRadix + b);
        o = biMultiplyByRadixPower(t, f - u - 1);
        i = biSubtract(i, biMultiplyDigit(o, r.digits[f - u - 1]));
        i.isNeg && (i = biAdd(i, o),
            --r.digits[f - u - 1])
    }
    return i = biShiftRight(i, e),
        r.isNeg = n.isNeg != v,
    n.isNeg && (r = v ? biAdd(r, bigOne) : biSubtract(r, bigOne),
        t = biShiftRight(t, e),
        i = biSubtract(t, i)),
    i.digits[0] == 0 && biHighIndex(i) == 0 && (i.isNeg = !1),
        [r, i]
}
function biDivide(n, t) {
    return biDivideModulo(n, t)[0]
}
function biModulo(n, t) {
    return biDivideModulo(n, t)[1]
}
function biMultiplyMod(n, t, i) {
    return biModulo(biMultiply(n, t), i)
}
function biPow(n, t) {
    for (var r = bigOne, i = n; ; ) {
        if ((t & 1) != 0 && (r = biMultiply(r, i)),
            t >>= 1,
        t == 0)
            break;
        i = biMultiply(i, i)
    }
    return r
}
function biPowMod(n, t, i) {
    for (var f = bigOne, u = n, r = t; ; ) {
        if ((r.digits[0] & 1) != 0 && (f = biMultiplyMod(f, u, i)),
            r = biShiftRight(r, 1),
        r.digits[0] == 0 && biHighIndex(r) == 0)
            break;
        u = biMultiplyMod(u, u, i)
    }
    return f
}
function BarrettMu(n) {
    this.modulus = biCopy(n);
    this.k = biHighIndex(this.modulus) + 1;
    var t = new BigInt;
    t.digits[2 * this.k] = 1;
    this.mu = biDivide(t, this.modulus);
    this.bkplus1 = new BigInt;
    this.bkplus1.digits[this.k + 1] = 1;
    this.modulo = BarrettMu_modulo;
    this.multiplyMod = BarrettMu_multiplyMod;
    this.powMod = BarrettMu_powMod
}
function BarrettMu_modulo(n) {
    var r = biDivideByRadixPower(n, this.k - 1), u = biMultiply(r, this.mu), f = biDivideByRadixPower(u, this.k + 1), e = biModuloByRadixPower(n, this.k + 1), o = biMultiply(f, this.modulus), s = biModuloByRadixPower(o, this.k + 1), t = biSubtract(e, s), i;
    for (t.isNeg && (t = biAdd(t, this.bkplus1)),
             i = biCompare(t, this.modulus) >= 0; i; )
        t = biSubtract(t, this.modulus),
            i = biCompare(t, this.modulus) >= 0;
    return t
}
function BarrettMu_multiplyMod(n, t) {
    var i = biMultiply(n, t);
    return this.modulo(i)
}
function BarrettMu_powMod(n, t) {
    var u = new BigInt, r, i;
    for (u.digits[0] = 1,
             r = n,
             i = t; ; ) {
        if ((i.digits[0] & 1) != 0 && (u = this.multiplyMod(u, r)),
            i = biShiftRight(i, 1),
        i.digits[0] == 0 && biHighIndex(i) == 0)
            break;
        r = this.multiplyMod(r, r)
    }
    return u
}
function RSAKeyPair(n, t, i) {
    this.e = biFromHex(n);
    this.d = biFromHex(t);
    this.m = biFromHex(i);
    this.digitSize = 2 * biHighIndex(this.m) + 2;
    this.chunkSize = this.digitSize - 11;
    this.radix = 16;
    this.barrett = new BarrettMu(this.m)
}
function twoDigit(n) {
    return (n < 10 ? "0" : "") + String(n)
}
function encryptedString(n, t) {
    var e, o, s, h, c, i, f, u, v, l, y;
    if (n.chunkSize > n.digitSize - 11)
        return "Error";
    for (var a = [], p = t.length, r = 0; r < p; )
        a[r] = t.charCodeAt(r),
            r++;
    for (e = a.length,
             o = "",
             r = 0; r < e; r += n.chunkSize) {
        for (c = new BigInt,
                 s = 0,
                 f = r + n.chunkSize > e ? e % n.chunkSize : n.chunkSize,
                 u = [],
                 i = 0; i < f; i++)
            u[i] = a[r + f - 1 - i];
        for (u[f] = 0,
                 v = Math.max(8, n.digitSize - 3 - f),
                 i = 0; i < v; i++)
            u[f + 1 + i] = Math.floor(Math.random() * 254) + 1;
        for (u[n.digitSize - 2] = 2,
                 u[n.digitSize - 1] = 0,
                 h = 0; h < n.digitSize; ++s)
            c.digits[s] = u[h++],
                c.digits[s] += u[h++] << 8;
        l = n.barrett.powMod(c, n.e);
        y = n.radix == 16 ? biToHex(l) : biToString(l, n.radix);
        o += y + " "
    }
    return o.substring(0, o.length - 1)
}
function decryptedString(n, t) {
    for (var e = t.split(" "), i = "", r, u, o, f = 0; f < e.length; ++f)
        for (o = n.radix == 16 ? biFromHex(e[f]) : biFromString(e[f], n.radix),
                 u = n.barrett.powMod(o, n.d),
                 r = 0; r <= biHighIndex(u); ++r)
            i += String.fromCharCode(u.digits[r] & 255, u.digits[r] >> 8);
    return i.charCodeAt(i.length - 1) == 0 && (i = i.substring(0, i.length - 1)),
        i
}
var biRadixBase = 2, biRadixBits = 16, bitsPerDigit = biRadixBits, biRadix = 65536, biHalfRadix = biRadix >>> 1, biRadixSquared = biRadix * biRadix, maxDigitVal = biRadix - 1, maxInteger = 9999999999999998, maxDigits, ZERO_ARRAY, bigZero, bigOne, dpl10, lr10, hexatrigesimalToChar, hexToChar, highBitMasks, lowBitMasks;
setMaxDigits(20);
dpl10 = 15;
lr10 = biFromNumber(1e15);
hexatrigesimalToChar = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];
hexToChar = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
highBitMasks = [0, 32768, 49152, 57344, 61440, 63488, 64512, 65024, 65280, 65408, 65472, 65504, 65520, 65528, 65532, 65534, 65535];
lowBitMasks = [0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535];
setMaxDigits(129);
var key_to_encode = new RSAKeyPair("010001", "", "978C0A92D2173439707498F0944AA476B1B62595877DD6FA87F6E2AC6DCB3D0BF0B82857439C99B5091192BC134889DFF60C562EC54EFBA4FF2F9D55ADBCCEA4A2FBA80CB398ED501280A007C83AF30C3D1A142D6133C63012B90AB26AC60C898FB66EDC3192C3EC4FF66925A64003B72496099F4F09A9FB72A2CF9E4D770C41");
// console.log(encryptedString(key_to_encode,"111111111"))
    return encryptedString(key_to_encode,password)
}
YOYO__2018
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
网上管家婆
lingyuncelia的博客
08-18 180
// BarrettMu, a class for performing Barrett modular reduction computations in // JavaScript. // // Requires BigInt.js. // // Copyright 2004-2005 David Shapiro. // // You may use, re-use, abuse, copy, and modify this code to your liking, but // ple...
房天下解密（RSA）
最新发布
qq_51179608的博客
08-26 288
JS逆向之房天下RSA加密
【Python】模拟登陆房天下的总结
会飞的大象
10-10 775
【Python】requests模拟登陆房天下的总结 最近想爬取些与房价有关的数据，看了几个网站，感觉房天下包含的内容比较多，于是，先对房天下入手。为了保证后面数据爬取，想先模拟登陆获取cookies，维护一个cookies池来用，后续的爬取直接带cookies请求。 一，常规操作 ...
欧拉定理——PowMod ( HDU 5728 )(2016 Multi-University Training Contest 1 1006)
FeBr2的博客
07-22 483
题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=5728 分析： 题中有 k = ∑(m,i=1) φ(i∗n) mod 1000000007，即求和函数 sum(n, m) = ∑(m,i=1) φ(i∗n) mod 1000000007. 那么考虑将质因子p的贡献单独处理，可以得到 sum(n, m) = φ(p) × sum(n/p,
易语言-房天下js加密
06-26
在这个"易语言-房天下js加密"的主题中，我们主要关注的是如何使用易语言解析和处理房天下的JavaScript（js）加密逻辑。 在网页开发中，为了保护数据安全、防止恶意篡改或爬取，网站经常会采用各种加密技术。房天下...
京东登陆加密算法
06-10
京东登陆加密算法供学习参考24小时内删除,请勿用于非法之事，否则后果自负与作者无关
加密网络流量测量和分析.pdf
08-08
流量加密是目前互联网流量的主流方式，本报告分为三个方面讨论流量加密的问题: (1) 由于加密流量算法本身造成流量的随机性，因而直接针对加密流量的分类方法将失效；(2) 加密协议本身交互过程，导致非加密流量参与...
加密流量分析.pdf
02-23
迅猛增长的加密流量正不断改变着威胁形势。随着越来越多的企业实现全数字化，大量的服务和应 用都采用加密技术作为确保信息安全的首要方法。更具体地说，加密流量同比增长已超过 90%，对 流量进行加密的网站数量已...
加密分析程序CAP4说明
03-17
加密分析程序CAP4说明 经典密码学与现代密码学教材配套工具说明
使用RSA对前后台通信加解密
weixin_34310369的博客
10-27 339
2019独角兽企业重金招聘Python工程师标准>>> ...
JS逆向之RSA 房天下登录pwd加密参数
tiebanggg的博客
02-25 3968
项目前言 tiebanggg又来更新了，本文章仅供学习研究，如若侵犯到贵公司权益请联系344567536@qq.com第一时间进行删除；切忌用于一切非法途径，否则后果自行承担！ 项目描述 最近在巩固学校js逆向，为加深记忆就此写下文章进行记录。 本次地址：aHR0cHM6Ly9wYXNzcG9ydC5mYW5nLmNvbS8/YmFja3VybD1odHRwcyUzQSUyRiUyRnd3dy5mYW5nLmNvbSUyRmRlZmF1bHQuaHRt 废话不多说不整花里胡哨的，直接开干 *********
java rsa加密算法_java RSA加密算法
weixin_36341500的博客
02-12 326
/** RSA, a suite of routines for performing RSA public-key computations in JavaScript.* Copyright 1998-2005 David Shapiro.* Dave Shapiro* dave@ohdave.com* changed by Fuchun, 2010-05-06* fcrpg2005@gmai...
Python: 房天下小区数据爬取
Cyber的博客
09-20 4682
前言：之前是写了链家的爬虫，但是实际看下来数据质量不是特别好，所以想把房天下的小区数据也爬下来看看怎么样，但是实际爬取中，发现房天下的反爬技术要稍高一点，目前碰到的有： 1、自动检测ip地址，在正常网页中会跳转到新地址，request没办法，不过可以解析新地址并返回后重新连接，问题不大； 2、不同页面的布局也会不一样，这个目前没有好的解决办法，我目前是用try except来判断； 3、如果速度太...
房天下登录pwd加密破解
weixin_41586984的博客
03-05 710
前言 昨晚跟一个朋友讨论买房的事，现在的90后压力确实挺大的，想在一线城市扎根，但是光光首付就能把上一代人所有的积蓄都掏空，然后再把自己夫妻二人掏空，房贷、孩子上学，父母赡养等等，压力山大呀。看了下房天下上上海的二手房房价，想爬些数据，看到登录时密码是加了密的，加密属于简单，正在学习js逆向的同学可以练手。 一、分析网站 先登录发现pwd加密 然后看看直接全局搜寻pwd能否搜出来，是可以搜出来的，然后可以定位到这里，这这这这，这不是太明确了么，那我们直接打印that.password.val()，原来是密
使用scrapy框架实现,房天下网站全站爬取,详情,动态,评论,户型,图片.
小王子博客
04-15 7773
scrapy 实现代码,代码有点多,没有优化,,下面有链接,不懂得留言 Github全部代码,https://github.com/Agile929/scrapy_fang # -*- coding: utf-8 -*- import scrapy, json import math from lxml import etree from ..items import Dat...
API接口加密方式说明
师哥在这儿呢
04-11 8231
一,文档说明     本文挡适用于api接口开发人员,移动端开发人员,针对移动端请求API接口时加密方式以及加密规则进行说明二,加密方式     1.不采取非对称加密说明    好处：    相对于对称加密，非对称加密安全性远远高宇对称加密，能够保证在数据传输中数据被劫持之后不被破解。    缺点：    由于非对称加密 [ openssl rsa ]，密钥为1024bit时候最多值能加密117个...
【JS 逆向百例】房天下登录接口参数逆向
K哥爬虫
08-12 789
声明 本文章中所有内容仅供学习交流，严禁用于商业用途和非法用途，否则由此产生的一切后果均与作者无关，若有侵权，请联系我立即删除！ 逆向目标 目标：房天下账号密码登录 主页：https://passport.fang.com/ 接口：https://passport.fang.com/login.api 逆向参数： Form Data： pwd: 044b527dba64d1e82657668beae1d61e4d86643d231792c78d5c538461a146b01c8e28d98.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值