Js逆向学习过程

Js 逆向-字段追踪

本文章是记录本人学习Js逆向的相关学习过程，后续会持续更新，欢迎大家点评指正。

点点数据

基本情况

在进行浏览器头部签名堆栈分析时，我们首先需要了解一些基本情况：

1. 页面地址：https://app.diandian.com/
2. 定位接口：https://api.diandian.com/pc/app/v1/user/favorite/app
3. 定位参数；请求载荷中的 k 值
4. 目的：通过堆栈追踪，定位到 k 值的前端生成方法

实战步骤

1.设置断点

在浏览器的 开发者工具-源代码 页面，添加 /pc/app/v1/user/favorite/app 接口到 XHR/提取断点 中，实现对该接口的调用进行 Debugger 调试（请求前调试）。

2.调试请求

重放请求后，代码将运行到 x.send(y) 位置。打开调用堆栈，查看 Promise.then 位置，点击 m.request 定位到请求位置打下断点。

3.分析请求参数

展开 t 中的 params 可以发现，此时请求参数中并没有我们要的 k 值。

4.追踪 then()方法

关注 o = o.then(m.shift(), m.shift());，这里马上要执行 then() 方法，其入参是两个 m.shift()。展开本地变量 m 查看其内容，发现其中是各种方法，点击蓝色链接跳转过去源代码，发现是各种请求拦截器。

5.设置请求头断点

因为我们需要定位的参数是请求头中的载荷，所以在 onRequest 方法位置打下断点。

6.深入方法 t(e)

调试多次后证实 k 是在 t(e) 这个方法执行之后生成的。鼠标放置到方法 t 上，点击蓝色链接进入方法 t(e)。

7.定位 k 值生成代码

在方法 I(e.url, e, r) 中，定位到了 k 值的生成代码段。同时发现，点点数据 Get 请求和 Post、Delete、Put 请求的 k 值，都是根据请求参数生成的。

生成 K 值的关键代码

以下是生成 k 值的关键代码段，这段代码说明了如何根据请求参数生成 k 值：

["/common/v1/config/basic", "/common/v1/config/system"].includes(e) || r.forEach((function(n) {
    if (e.includes(n.proxy)) {
        var path = e.replace(n.proxy, n.target);
        if ("get" === t.method) {
            t.paramsSerializer = function(e) {
                return _.a.stringify(e, {
                    arrayFormat: "repeat"
                })
            }
                ,
                t.params = h()(t.params, !1) || {};
            var r = h()(t.params, !1)
            , o = Object(y.a)(r, path, {
                s: n.s,
                k: n.k,
                l: n.l,
                d: n.d,
                sort: n.sort,
                num: n.num
            }, "get");
            t.params.k = o
        } else if ("post" === t.method || "delete" === t.method || "put" === t.method) {
            t.data = h()(t.data, !1) || {};
            var data = h()(t.data, !1)
            , d = Object(y.a)(data, path, {
                s: n.s,
                k: n.k,
                l: n.l,
                d: n.d,
                sort: n.sort,
                num: n.num
            }, "post");
            t.data.k = d
        }
    }
}

验证生成的 k 值

为了验证生成的 k 值是否正确，我们可以将上述代码段复制到控制台执行，并与 debugger 断点处的值进行对比：

// get
o = Object(y.a)(r, path, {
                            s: n.s,
                            k: n.k,
                            l: n.l,
                            d: n.d,
                            sort: n.sort,
                            num: n.num
                        }, "get");
'FUAUDh4QW0cEDhFYBx8ECU1WGlxAQBQOHg4dQRxZVBgdT1JPGRU='

// post
d = Object(y.a)(data, path, {
                            s: n.s,
                            k: n.k,
                            l: n.l,
                            d: n.d,
                            sort: n.sort,
                            num: n.num
                        }, "post");
'DE4UAQYRXEcFDRRfAB0fB01ZV1wMThQBGFdaX1JIVEdVTVlTDg=='

总结

堆栈定位是一种强大的技术，它比关键词定位更为实用，尤其是在关键词定位无法生效的情况下。通过逐步深入堆栈，我们可以精确地定位到关键代码段，这对于调试和分析浏览器请求至关重要。