关于python:JS-逆向百例Fiddler-插件-Hook-实战某创帮登录逆向

关注微信公众号：K 哥爬虫，QQ 交换群：808574309，继续分享爬虫进阶、JS/ 安卓逆向等技术干货！

申明

本文章中所有内容仅供学习交换，抓包内容、敏感网址、数据接口均已做脱敏解决，严禁用于商业用途和非法用处，否则由此产生的所有结果均与作者无关，若有侵权，请分割我立刻删除！

逆向指标

• 指标：某创帮登录接口
• 主页：aHR0cHM6Ly9tLndjYmNoaW5hLmNvbS9sb2dpbi9vdGhlci1sb2dpbi5odG1s
• 接口：aHR0cHM6Ly9tLndjYmNoaW5hLmNvbS9hcGkvbG9naW4vbG9naW4=

• 逆向参数：

  • Query String Parameters：rnd: 0.22465933864494048
  • Request Payload：password: "25D55AD283AA400AF464C76D713C07AD"

筹备工作

该站点的加密其实并不简单，间接搜寻加密参数也能够很快定位到加密代码，然而本文次要介绍应用 Fiddler 抓包软件，搭配插件，应用 Hook 的形式来定位加密地位，如果遇到加密参数搜寻不到，或者搜寻后果太多的状况，Hook 是比拟高效的办法，可能帮忙你疾速定位加密入口，无关 Hook 的具体常识，在 K 哥后期的文章有具体介绍：JS 逆向之 Hook，吃着火锅唱着歌，忽然就被麻匪劫了！

本文用到的抓包软件，可在 Fiddler 官网下载，官网提供了五个不同的版本 / 服务：

• Fiddler Everywhere：跨平台抓包软件，反对 MacOS、Windows 和 Linux，相当于 Classic 版本的改良增强版；
• Fiddler Classic：传统的 Fiddler，仅反对 Windows，个别 Windows 用户都是用的这个版本；
• Fiddler Jam：浏览器插件，免费，次要用于网站优化、平安故障排除等；
• Fiddler Cap：专为非技术用户而设计的轻量级抓包软件，仅反对 Windows；
• Fiddler Core：Fiddler 外围，可嵌入的 .NET 库，免费。

如果你是 MacOS 或者 Linux 用户，能够抉择 Fiddler Everywhere，如果你是 Windows 用户，倡议抉择 Fiddler Classic，抓包软件的应用办法，证书配置等等，这里不做介绍，网上有很多教程能够参考。

须要留神的是，Fiddler 自身没有 Hook 性能，须要本人编写插件，而且只有 Fiddler Classic 版本是反对插件的，能够参考 Fiddler Classic 插件编写文档，也就是说 MacOS 和 Linux 用户可能无奈通过 Fiddler 插件进行 Hook，然而不必放心，MacOS 和 Linux 用户能够通过编写浏览器插件的形式来进行 Hook，后续 K 哥也会写一篇实战文章来演示如何编写浏览器插件进行 Hook，敬请关注！

对于 Fiddler Classic 的 Hook 插件，曾经有大佬写好了，这里用到的是编程猫的插件，要求 Fiddler Classic 的版本必须 >= v4.6.3，除了 Hook 性能以外，还有 JS 调试、内存漫游、JSON 解析、常见数据加密解密等，插件能够在 K 哥爬虫公众号输出关键字【Fiddler 插件 】获取，装置办法在压缩包里也有，这里不再赘述。

逆向过程

抓包剖析

轻易输出一个账号密码，点击登陆，抓包定位到登录接口为 aHR0cHM6Ly9tLndjYmNoaW5hLmNvbS9hcGkvbG9naW4vbG9naW4=，POST 申请，Request Payload 里，明码 password 被加密解决了，此外，Query String Parameters 里还带有一个 rnd 的参数，每次申请都会扭转。那么 password 和 rnd 就是本次要逆向的指标。

参数逆向

password

咱们晓得在 JavaScript 中 JSON.stringify() 办法用于将 JavaScript 对象或值转换为 JSON 字符串，JSON.parse() 办法用于将一个 JSON 字符串转换为 JavaScript 对象，某些站点在向 web 服务器传输用户名明码时，会用到这两个办法，在本案例中，就用到了 JSON.stringify() 办法，针对该办法，咱们编写一个 Hook 脚本：

(function() {
    var stringify = JSON.stringify;
    JSON.stringify = function(params) {console.log("Hook JSON.stringify ——>", params);
        debugger;
        return stringify(params);
    }
})();

整个 Hook 脚本是一个 IIFE 立刻调用函数表达式（也叫自执行函数、立刻执行函数等），借助 Fiddler 插件，它能够在整个网页加载之前运行，首先定义了一个变量 stringify 保留原始 JSON.stringify 办法，而后重写 JSON.stringify 办法，遇到 JSON.stringify 办法就会执行 debugger 语句，会立刻断下，最初将接管到的参数返回给原始的 JSON.stringify 办法进行解决，确保数据失常传输。

将 Hook 脚本放到 Fiddler 插件里，F12 开启抓包，刷新网页，从新输出账号密码点击登录，就能够看到胜利断下：

此时的 password 曾经是加密后的了，想要定位到加密的中央，就须要看左边的 Call Stack，即调用栈，显示的是走到 JSON.stringify() 办法之前，顺次通过了哪些函数的解决，挨个往上调试，到 loginAction 办法时，能够看到变量 V 和 N 顺次为明文账号密码，而后通过了 a.hex_md5(N) 解决后，明码被加密解决了，清晰明了，这就是要害的加密入口函数。

跟进 a.hex_md5()，其实就是 hex_md5() 办法，由名称也能够看出是个简略的 MD5 加密，只不过前面把小写全副转为大写罢了，齐全能够应用 Python 来实现：

import hashlib


encrypted_password = hashlib.md5("12345678".encode('utf-8')).hexdigest().upper()
print(encrypted_password)

# 25D55AD283AA400AF464C76D713C07AD

为了练习 JS 代码的剥离，咱们将其加密代码剥离下来：

将整个 md5.js 文件里的代码复制下来，能够发现代码结尾有个 define 关键字，这种写法在 JavaScript 中叫做 AMD 标准，全称 Asynchronous Module Definition，即异步模块加载机制；结尾有个 module.exports = j，它提供了裸露接口的办法，不便在其余文件中调用，感兴趣的敌人能够自行百度理解，在本地调试过程中，间接删除 define 和结尾的 module.exports = j，而后应用语句 j.hex_md5() 调用即可。

rnd

这个 rnd 参数是间接跟在登录 URL 前面的，肯定是通过了某个办法将 rnd 参数与原始 URL 拼接在一起，所以咱们能够 Hook 这个登录 URL，在 URL 生成之后断下来，与 password 相似，编写如下 Hook 脚本：

(function () {
    var open = window.XMLHttpRequest.prototype.open;
    window.XMLHttpRequest.prototype.open = function (method, url, async) {if (url.indexOf("rnd") != -1) {debugger;}
        return open.apply(this, arguments);
    };
})();

XMLHttpRequest 对象用于在后盾与服务器替换数据，能够同步或异步地返回 Web 服务器的响应，而 XMLHttpRequest.open() 办法会初始化一个申请，根本语法为：XMLHttpRequest.open(method, url, async, user, password)，具体能够参考 MDN XMLHttpRequest.open()，其中的 url 参数就是发出请求的残缺的 url，这里有个原型对象 prototype，所有的 JavaScript 对象都会从一个 prototype 原型对象中继承属性和办法，具体能够参考菜鸟教程 JavaScript prototype 的介绍。

在以上 Hook 代码中，定义了一个变量 open 保留原始 XMLHttpRequest.open 办法，而后重写 XMLHttpRequest.open 办法，判断如果 rnd 字符串值在 URL 里首次呈现的地位不为 -1，即 URL 里蕴含 rnd 字符串，则执行 debugger 语句，会立刻断下。

同样的，将 Hook 脚本放到 Fiddler 插件里，F12 开启抓包，刷新网页，从新输出账号密码点击登录，就能够看到胜利断下：

和之前查找 password 加密入口一样的办法，仍然是查看左边的 Call Stack 调用栈，挨个往上调试，到 a 办法的时候，能够看到有一句 a.url = c.addUrlParam(a.url, "rnd", Math.random());，在 JavaScript 中 Math.random() 函数返回介于 0（蕴含）~ 1（不蕴含）之间的一个伪随机数，不难看出 rnd 的值就是一个随机数。

那么在 Python 中，介于 0（蕴含）~ 1（不蕴含）之间的一个伪随机数能够应用 random 模块来实现：

import random

random_number = random.uniform(0, 1)
print(random_number)

残缺代码

GitHub 关注 K 哥爬虫，继续分享爬虫相干代码！欢送 star！https://github.com/kgepachong/

以下只演示局部要害代码，不能间接运行！ 残缺代码仓库地址：https://github.com/kgepachong…

JavaScript 加密代码

function c(x, c) {
    x |= 128 << c % 32,
        x[(c + 64 >>> 9 << 4) + 14] = c;
    for (var a = 1732584193, _ = -271733879, y = -1732584194, d = 271733878, i = 0; i < x.length; i += 16) {
        var b = a
            , B = _
            , D = y
            , E = d;
        a = h(a, _, y, d, x[i + 0], 7, -680876936),
            d = h(d, a, _, y, x[i + 1], 12, -389564586),
            y = h(y, d, a, _, x[i + 2], 17, 606105819),
            _ = h(_, y, d, a, x[i + 3], 22, -1044525330),
            a = h(a, _, y, d, x[i + 4], 7, -176418897),
            d = h(d, a, _, y, x[i + 5], 12, 1200080426),
            y = h(y, d, a, _, x[i + 6], 17, -1473231341),
            _ = h(_, y, d, a, x[i + 7], 22, -45705983),
            a = h(a, _, y, d, x[i + 8], 7, 1770035416),
            d = h(d, a, _, y, x[i + 9], 12, -1958414417),
            y = h(y, d, a, _, x[i + 10], 17, -42063),
            _ = h(_, y, d, a, x[i + 11], 22, -1990404162),
            a = h(a, _, y, d, x[i + 12], 7, 1804603682),
            d = h(d, a, _, y, x[i + 13], 12, -40341101),
            y = h(y, d, a, _, x[i + 14], 17, -1502002290),
            _ = h(_, y, d, a, x[i + 15], 22, 1236535329),
            a = g(a, _, y, d, x[i + 1], 5, -165796510),
            d = g(d, a, _, y, x[i + 6], 9, -1069501632),
            y = g(y, d, a, _, x[i + 11], 14, 643717713),
            _ = g(_, y, d, a, x[i + 0], 20, -373897302),
            a = g(a, _, y, d, x[i + 5], 5, -701558691),
            d = g(d, a, _, y, x[i + 10], 9, 38016083),
            y = g(y, d, a, _, x[i + 15], 14, -660478335),
            _ = g(_, y, d, a, x[i + 4], 20, -405537848),
            a = g(a, _, y, d, x[i + 9], 5, 568446438),
            d = g(d, a, _, y, x[i + 14], 9, -1019803690),
            y = g(y, d, a, _, x[i + 3], 14, -187363961),
            _ = g(_, y, d, a, x[i + 8], 20, 1163531501),
            a = g(a, _, y, d, x[i + 13], 5, -1444681467),
            d = g(d, a, _, y, x[i + 2], 9, -51403784),
            y = g(y, d, a, _, x[i + 7], 14, 1735328473),
            _ = g(_, y, d, a, x[i + 12], 20, -1926607734),
            a = v(a, _, y, d, x[i + 5], 4, -378558),
            d = v(d, a, _, y, x[i + 8], 11, -2022574463),
            y = v(y, d, a, _, x[i + 11], 16, 1839030562),
            _ = v(_, y, d, a, x[i + 14], 23, -35309556),
            a = v(a, _, y, d, x[i + 1], 4, -1530992060),
            d = v(d, a, _, y, x[i + 4], 11, 1272893353),
            y = v(y, d, a, _, x[i + 7], 16, -155497632),
            _ = v(_, y, d, a, x[i + 10], 23, -1094730640),
            a = v(a, _, y, d, x[i + 13], 4, 681279174),
            d = v(d, a, _, y, x[i + 0], 11, -358537222),
            y = v(y, d, a, _, x[i + 3], 16, -722521979),
            _ = v(_, y, d, a, x[i + 6], 23, 76029189),
            a = v(a, _, y, d, x[i + 9], 4, -640364487),
            d = v(d, a, _, y, x[i + 12], 11, -421815835),
            y = v(y, d, a, _, x[i + 15], 16, 530742520),
            _ = v(_, y, d, a, x[i + 2], 23, -995338651),
            a = A(a, _, y, d, x[i + 0], 6, -198630844),
            d = A(d, a, _, y, x[i + 7], 10, 1126891415),
            y = A(y, d, a, _, x[i + 14], 15, -1416354905),
            _ = A(_, y, d, a, x[i + 5], 21, -57434055),
            a = A(a, _, y, d, x[i + 12], 6, 1700485571),
            d = A(d, a, _, y, x[i + 3], 10, -1894986606),
            y = A(y, d, a, _, x[i + 10], 15, -1051523),
            _ = A(_, y, d, a, x[i + 1], 21, -2054922799),
            a = A(a, _, y, d, x[i + 8], 6, 1873313359),
            d = A(d, a, _, y, x[i + 15], 10, -30611744),
            y = A(y, d, a, _, x[i + 6], 15, -1560198380),
            _ = A(_, y, d, a, x[i + 13], 21, 1309151649),
            a = A(a, _, y, d, x[i + 4], 6, -145523070),
            d = A(d, a, _, y, x[i + 11], 10, -1120210379),
            y = A(y, d, a, _, x[i + 2], 15, 718787259),
            _ = A(_, y, d, a, x[i + 9], 21, -343485551),
            a = C(a, b),
            _ = C(_, B),
            y = C(y, D),
            d = C(d, E)
    }
    return Array(a, _, y, d)
}

function a(q, c, a, x, s, t) {return C(y(C(C(c, q), C(x, t)), s), a)
}

function h(c, h, g, d, x, s, t) {return a(h & g | ~h & d, c, h, x, s, t)
}

function g(c, h, g, d, x, s, t) {return a(h & d | g & ~d, c, h, x, s, t)
}

function v(c, h, g, d, x, s, t) {return a(h ^ g ^ d, c, h, x, s, t)
}

function A(c, h, g, d, x, s, t) {return a(g ^ (h | ~d), c, h, x, s, t)
}

function _(a, h) {var g = b(a);
    g.length > 16 && (g = c(g, a.length * U));
    for (var v = Array(16), A = Array(16), i = 0; 16 > i; i++)
        v[i] = 909522486 ^ g[i],
            A[i] = 1549556828 ^ g[i];
    var _ = c(v.concat(b(h)), 512 + h.length * U);
    return c(A.concat(_), 640)
}

function C(x, c) {var a = (65535 & x) + (65535 & c)
        , h = (x >> 16) + (c >> 16) + (a >> 16);
    return h << 16 | 65535 & a
}

function y(c, a) {return c << a | c >>> 32 - a}

function b(c) {for (var a = Array(), h = (1 << U) - 1, i = 0; i < c.length * U; i += U)
        a[i >> 5] |= (c.charCodeAt(i / U) & h) << i % 32;
    return a
}

function B(c) {for (var a = "", h = (1 << U) - 1, i = 0; i < 32 * c.length; i += U)
        a += String.fromCharCode(c[i >> 5] >>> i % 32 & h);
    return a
}

function D(c) {for (var a = F ? "0123456789ABCDEF" : "0123456789abcdef", h = "", i = 0; i < 4 * c.length; i++)
        h += a.charAt(c[i >> 2] >> i % 4 * 8 + 4 & 15) + a.charAt(c[i >> 2] >> i % 4 * 8 & 15);
    return h
}

function E(c) {for (var a = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", h = "", i = 0; i < 4 * c.length; i += 3)
        for (var g = (c[i >> 2] >> 8 * (i % 4) & 255) << 16 | (c[i + 1 >> 2] >> 8 * ((i + 1) % 4) & 255) << 8 | c[i + 2 >> 2] >> 8 * ((i + 2) % 4) & 255, v = 0; 4 > v; v++)
            h += 8 * i + 6 * v > 32 * c.length ? S : a.charAt(g >> 6 * (3 - v) & 63);
    return h
}

var F = 0
    , S = ""
    , U = 8
    , j = {hex_md5: function (s) {return D(c(b(s), s.length * U)).toUpperCase()},
    b64_md5: function (s) {return E(c(b(s), s.length * U))
    },
    str_md5: function (s) {return B(c(b(s), s.length * U))
    },
    hex_hmac_md5: function (c, a) {return D(_(c, a))
    },
    b64_hmac_md5: function (c, a) {return E(_(c, a))
    },
    str_hmac_md5: function (c, a) {return B(_(c, a))
    }
};

function getSign(){var c = (new Date).getTime();
    var N = j.hex_md5(c).toUpperCase();
    return N
}

function getEncryptedPassword(password) {return j.hex_md5(password)
}

// 测试样例
// console.log(getEncryptedPassword("12345678"))
// console.log(getSign())

Python 登录要害代码

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import time
import random
import hashlib

import execjs
import requests


login_url = '脱敏解决，残缺代码关注 GitHub：https://github.com/kgepachong/crawler'


def get_enpwd_and_sign_by_javascript(password):
    with open('encrypt.js', 'r', encoding='utf-8') as f:
        encrypt_js = execjs.compile(f.read())
    encrypted_password = encrypt_js.call('getEncryptedPassword', password)
    sign = encrypt_js.call('getSign')
    return encrypted_password, sign


def get_enpwd_and_sign_by_python(password):
    timestamp = str(int(time.time() * 1000))
    encrypted_password = hashlib.md5(password.encode('utf-8')).hexdigest().upper()
    sign = hashlib.md5(timestamp.encode('utf-8')).hexdigest().upper()
    return encrypted_password, sign


def get_rnd():
    rnd = 'rnd' + str(random.uniform(0, 1))
    return rnd


def login(username, encrypted_password, sign, rnd):
    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
    }
    json = {
        "auth": {"timestamp": str(int(time.time() * 1000)),
            "sign": sign
        },
        "username": username,
        "password": encrypted_password
    }
    response = requests.post(url=login_url, params=rnd, json=json, headers=headers)
    print(response.json())


def main():
    username = input('请输出登录账号:')
    password = input('请输出登录明码:')
    # 通过 JavaScript 代码获取加密后的明码和 sign
    encrypted_password, sign = get_enpwd_and_sign_by_javascript(password)
    # 通过 Python 代码获取加密后的明码和 sign
    # encrypted_password, sign = get_enpwd_and_sign_by_python(password)
    rnd = get_rnd()
    login(username, encrypted_password, sign, rnd)


if __name__ == '__main__':
    main()