某乎JS逆向

已于 2022-09-12 17:07:39 修改
阅读量419 收藏 2
点赞数
分类专栏： 实战案例 爬虫 文章标签： python javascript
于 2022-09-12 16:31:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fengku1/article/details/126800545
版权

本文讲的是获取话题广场的标题和用户的评论数据； 

1.找到对应的网址

首先我们打开网址进入话题广场，随便输入一个话题（例如:生活习惯），跳转到对应的页面；

 接下来我们就需要打开开发者工具，刷新网页找到哪个网址是我们需要请求的，结果发现找了一圈并没发现有用的网址对吧；

然后我们发现该话题下有很多内容，我们可以切换到网络->Fetch/XHR，在向下滑动发现Ajax有加载新的一个请求网址，点进去找到response看看返回的数据是不是我们要找的，如下：

 2.找到请求该网址需要解析什么数据

切换到表头我们发现请求网址链接如下:

看这个链接的构造topics应该就是话题广场的标指,19557781则为生活习惯这个话题所对应的编码,offset=20应该就是返回json数据起始为第20个,limit=10就是这个网址返回的json数据有10条 

接下来我们再看看请求头有什么数据，发现请求头除了常用cookie、useragent，还有一下几个参数：x-ab-pb,x-zse-93,x-zse-96,x-zst-81 

经过刷新几次后发现，我们要解析的数据就只有x-zst-96这个参数；

3.x-zst-96逆向

我们在全局搜索这个参数找到并跳转然后打住断点调试刷新，发现参数为“2.0_”+一个变量构成，接下来就可以一级一级往上去寻找；发现_这个变量是由T.signature赋值给他的；

 然后慢慢找到T的signature的方法实在哪里定义的，如下，鼠标放到该函数上面跳转；

跳转的函数如下，打上断点一步步调试找到上一级函数

最后一级一级找下去看这个参数是怎么加密的，接下来不过多讲解直接附上对应的js代码

const jsdom = require("jsdom");
const { JSDOM } = jsdom;
const dom = new JSDOM(`<!DOCTYPE html><p>Hello world</p>`);
window = dom.window;
document = window.document;
XMLHttpRequest = window.XMLHttpRequest;

	var exports = {}
	function t(e) {
        return (t = "function" == typeof Symbol && "symbol" == typeof Symbol.A ? function(e) {
            return typeof e
        }
        : function(e) {
            return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e
        }
        )(e)
    }
    Object.defineProperty(exports, "__esModule", {
        value: !0
    });
    var A = "2.0"
      , __g = {};
    function s() {}
    function i(e) {
        this.t = (2048 & e) >> 11,
        this.s = (1536 & e) >> 9,
        this.i = 511 & e,
        this.h = 511 & e
    }
    function h(e) {
        this.s = (3072 & e) >> 10,
        this.h = 1023 & e
    }
    function a(e) {
        this.a = (3072 & e) >> 10,
        this.c = (768 & e) >> 8,
        this.n = (192 & e) >> 6,
        this.t = 63 & e
    }
    function c(e) {
        this.s = e >> 10 & 3,
        this.i = 1023 & e
    }
    function n() {}
    function e(e) {
        this.a = (3072 & e) >> 10,
        this.c = (768 & e) >> 8,
        this.n = (192 & e) >> 6,
        this.t = 63 & e
    }
    function o(e) {
        this.h = (4095 & e) >> 2,
        this.t = 3 & e
    }
    function r(e) {
        this.s = e >> 10 & 3,
        this.i = e >> 2 & 255,
        this.t = 3 & e
    }
    s.prototype.e = function(e) {
        e.o = !1
    }
    ,
    i.prototype.e = function(e) {
        switch (this.t) {
        case 0:
            e.r[this.s] = this.i;
            break;
        case 1:
            e.r[this.s] = e.k[this.h]
        }
    }
    ,
    h.prototype.e = function(e) {
        e.k[this.h] = e.r[this.s]
    }
    ,
    a.prototype.e = function(e) {
        switch (this.t) {
        case 0:
            e.r[this.a] = e.r[this.c] + e.r[this.n];
            break;
        case 1:
            e.r[this.a] = e.r[this.c] - e.r[this.n];
            break;
        case 2:
            e.r[this.a] = e.r[this.c] * e.r[this.n];
            break;
        case 3:
            e.r[this.a] = e.r[this.c] / e.r[this.n];
            break;
        case 4:
            e.r[this.a] = e.r[this.c] % e.r[this.n];
            break;
        case 5:
            e.r[this.a] = e.r[this.c] == e.r[this.n];
            break;
        case 6:
            e.r[this.a] = e.r[this.c] >= e.r[this.n];
            break;
        case 7:
            e.r[this.a] = e.r[this.c] || e.r[this.n];
            break;
        case 8:
            e.r[this.a] = e.r[this.c] && e.r[this.n];
            break;
        case 9:
            e.r[this.a] = e.r[this.c] !== e.r[this.n];
            break;
        case 10:
            e.r[this.a] = t(e.r[this.c]);
            break;
        case 11:
            e.r[this.a] = e.r[this.c]in e.r[this.n];
            break;
        case 12:
            e.r[this.a] = e.r[this.c] > e.r[this.n];
            break;
        case 13:
            e.r[this.a] = -e.r[this.c];
            break;
        case 14:
            e.r[this.a] = e.r[this.c] < e.r[this.n];
            break;
        case 15:
            e.r[this.a] = e.r[this.c] & e.r[this.n];
            break;
        case 16:
            e.r[this.a] = e.r[this.c] ^ e.r[this.n];
            break;
        case 17:
            e.r[this.a] = e.r[this.c] << e.r[this.n];
            break;
        case 18:
            e.r[this.a] = e.r[this.c] >>> e.r[this.n];
            break;
        case 19:
            e.r[this.a] = e.r[this.c] | e.r[this.n];
            break;
        case 20:
            e.r[this.a] = !e.r[this.c]
        }
    }
    ,
    c.prototype.e = function(e) {
        e.Q.push(e.C),
        e.B.push(e.k),
        e.C = e.r[this.s],
        e.k = [];
        for (var t = 0; t < this.i; t++)
            e.k.unshift(e.f.pop());
        e.g.push(e.f),
        e.f = []
    }
    ,
    n.prototype.e = function(e) {
        e.C = e.Q.pop(),
        e.k = e.B.pop(),
        e.f = e.g.pop()
    }
    ,
    e.prototype.e = function(e) {
        switch (this.t) {
        case 0:
            e.u = e.r[this.a] >= e.r[this.c];
            break;
        case 1:
            e.u = e.r[this.a] <= e.r[this.c];
            break;
        case 2:
            e.u = e.r[this.a] > e.r[this.c];
            break;
        case 3:
            e.u = e.r[this.a] < e.r[this.c];
            break;
        case 4:
            e.u = e.r[this.a] == e.r[this.c];
            break;
        case 5:
            e.u = e.r[this.a] != e.r[this.c];
            break;
        case 6:
            e.u = e.r[this.a];
            break;
        case 7:
            e.u = !e.r[this.a]
        }
    }
    ,
    o.prototype.e = function(e) {
        switch (this.t) {
        case 0:
            e.C = this.h;
            break;
        case 1:
            e.u && (e.C = this.h);
            break;
        case 2:
            e.u || (e.C = this.h);
            break;
        case 3:
            e.C = this.h,
            e.w = null
        }
        e.u = !1
    }
    ,
    r.prototype.e = function(e) {
        switch (this.t) {
        case 0:
            for (var t = [], n = 0; n < this.i; n++)
                t.unshift(e.f.pop());
            e.r[3] = e.r[this.s](t[0], t[1]);
            break;
        case 1:
            for (var r = e.f.pop(), o = [], i = 0; i < this.i; i++)
                o.unshift(e.f.pop());
            e.r[3] = e.r[this.s][r](o[0], o[1]);
            break;
        case 2:
            for (var a = [], c = 0; c < this.i; c++)
                a.unshift(e.f.pop());
            e.r[3] = new e.r[this.s](a[0],a[1])
        }
    }
    ;
    var k = function(e) {
        for (var t = 66, n = [], r = 0; r < e.length; r++) {
            var o = 24 ^ e.charCodeAt(r) ^ t;
            n.push(String.fromCharCode(o)),
            t = o
        }
        return n.join("")
    };
    function Q(e) {
        this.t = (4095 & e) >> 10,
        this.s = (1023 & e) >> 8,
        this.i = 1023 & e,
        this.h = 63 & e
    }
    function C(e) {
        this.t = (4095 & e) >> 10,
        this.a = (1023 & e) >> 8,
        this.c = (255 & e) >> 6
    }
    function B(e) {
        this.s = (3072 & e) >> 10,
        this.h = 1023 & e
    }
    function f(e) {
        this.h = 4095 & e
    }
    function g(e) {
        this.s = (3072 & e) >> 10
    }
    function u(e) {
        this.h = 4095 & e
    }
    function w(e) {
        this.t = (3840 & e) >> 8,
        this.s = (192 & e) >> 6,
        this.i = 63 & e
    }
    function G() {
        this.r = [0, 0, 0, 0],
        this.C = 0,
        this.Q = [],
        this.k = [],
        this.B = [],
        this.f = [],
        this.g = [],
        this.u = !1,
        this.G = [],
        this.b = [],
        this.o = !1,
        this.w = null,
        this.U = null,
        this.F = [],
        this.R = 0,
        this.J = {
            0: s,
            1: i,
            2: h,
            3: a,
            4: c,
            5: n,
            6: e,
            7: o,
            8: r,
            9: Q,
            10: C,
            11: B,
            12: f,
            13: g,
            14: u,
            15: w
        }
    }
    Q.prototype.e = function(e) {
        switch (this.t) {
        case 0:
            e.f.push(e.r[this.s]);
            break;
        case 1:
            e.f.push(this.i);
            break;
        case 2:
            e.f.push(e.k[this.h]);
            break;
        case 3:
            e.f.push(k(e.b[this.h]))
        }
    }
    ,
    C.prototype.e = function(A) {
        switch (this.t) {
        case 0:
            var t = A.f.pop();
            A.r[this.a] = A.r[this.c][t];
            break;
        case 1:
            var s = A.f.pop()
              , i = A.f.pop();
            A.r[this.c][s] = i;
            break;
        case 2:
            var h = A.f.pop();
            A.r[this.a] = eval(h)
        }
    }
    ,
    B.prototype.e = function(e) {
        e.r[this.s] = k(e.b[this.h])
    }
    ,
    f.prototype.e = function(e) {
        e.w = this.h
    }
    ,
    g.prototype.e = function(e) {
        throw e.r[this.s]
    }
    ,
    u.prototype.e = function(e) {
        var t = this
          , n = [0];
        e.k.forEach(function(e) {
            n.push(e)
        });
        var r = function(r) {
            var o = new G;
            return o.k = n,
            o.k[0] = r,
            o.v(e.G, t.h, e.b, e.F),
            o.r[3]
        };
        r.toString = function() {
            return "() { [native code] }"
        }
        ,
        e.r[3] = r
    }
    ,
    w.prototype.e = function(e) {
        switch (this.t) {
        case 0:
            for (var t = {}, n = 0; n < this.i; n++) {
                var r = e.f.pop();
                t[e.f.pop()] = r
            }
            e.r[this.s] = t;
            break;
        case 1:
            for (var o = [], i = 0; i < this.i; i++)
                o.unshift(e.f.pop());
            e.r[this.s] = o
        }
    }
    ,
    G.prototype.D = function(e) {
        // console.log(window.atob(e));
        for (var t = window.atob(e), n = t.charCodeAt(0) << 8 | t.charCodeAt(1), r = [], o = 2; o < n + 2; o += 2)
            r.push(t.charCodeAt(o) << 8 | t.charCodeAt(o + 1));
        this.G = r;
        for (var i = [], a = n + 2; a < t.length; ) {
            var c = t.charCodeAt(a) << 8 | t.charCodeAt(a + 1)
              , s = t.slice(a + 2, a + 2 + c);
            i.push(s),
            a += c + 2
        }
        this.b = i
    }
    ,
    G.prototype.v = function(e, t, n) {
        for (t = t || 0,
        n = n || [],
        this.C = t,
        "string" == typeof e ? this.D(e) : (this.G = e,
        this.b = n),
        this.o = !0,
        this.R = Date.now(); this.o; ) {
            var r = this.G[this.C++];
            if ("number" != typeof r)
                break;
            var o = Date.now();
            if (500 < o - this.R)
                return;
            this.R = o;
            try {
                this.e(r)
            } catch (e) {
                this.U = e,
                this.w && (this.C = this.w)
            }
        }
    }
    ,
    G.prototype.e = function(e) {
        var t = (61440 & e) >> 12;
        new this.J[t](e).e(this)
    }
    ,
     (new G).v("AxjgB5MAnACoAJwBpAAAABAAIAKcAqgAMAq0AzRJZAZwUpwCqACQACACGAKcBKAAIAOcBagAIAQYAjAUGgKcBqFAuAc5hTSHZAZwqrAIGgA0QJEAJAAYAzAUGgOcCaFANRQ0R2QGcOKwChoANECRACQAsAuQABgDnAmgAJwMgAGcDYwFEAAzBmAGcSqwDhoANECRACQAGAKcD6AAGgKcEKFANEcYApwRoAAxB2AGcXKwEhoANECRACQAGAKcE6AAGgKcFKFANEdkBnGqsBUaADRAkQAkABgCnBagAGAGcdKwFxoANECRACQAGAKcGKAAYAZx+rAZGgA0QJEAJAAYA5waoABgBnIisBsaADRAkQAkABgCnBygABoCnB2hQDRHZAZyWrAeGgA0QJEAJAAYBJwfoAAwFGAGcoawIBoANECRACQAGAOQALAJkAAYBJwfgAlsBnK+sCEaADRAkQAkABgDkACwGpAAGAScH4AJbAZy9rAiGgA0QJEAJACwI5AAGAScH6AAkACcJKgAnCWgAJwmoACcJ4AFnA2MBRAAMw5gBnNasCgaADRAkQAkABgBEio0R5EAJAGwKSAFGACcKqAAEgM0RCQGGAYSATRFZAZzshgAtCs0QCQAGAYSAjRFZAZz1hgAtCw0QCQAEAAgB7AtIAgYAJwqoAASATRBJAkYCRIANEZkBnYqEAgaBxQBOYAoBxQEOYQ0giQKGAmQABgAnC6ABRgBGgo0UhD/MQ8zECALEAgaBxQBOYAoBxQEOYQ0gpEAJAoYARoKNFIQ/zEPkAAgChgLGgkUATmBkgAaAJwuhAUaCjdQFAg5kTSTJAsQCBoHFAE5gCgHFAQ5hDSCkQAkChgBGgo0UhD/MQ+QACAKGAsaCRQCOYGSABoAnC6EBRoKN1AUEDmRNJMkCxgFGgsUPzmPkgAaCJwvhAU0wCQFGAUaCxQGOZISPzZPkQAaCJwvhAU0wCQFGAUaCxQMOZISPzZPkQAaCJwvhAU0wCQFGAUaCxQSOZISPzZPkQAaCJwvhAU0wCQFGAkSAzRBJAlz/B4FUAAAAwUYIAAIBSITFQkTERwABi0GHxITAAAJLwMSGRsXHxMZAAk0Fw8HFh4NAwUABhU1EBceDwAENBcUEAAGNBkTGRcBAAFKAAkvHg4PKz4aEwIAAUsACDIVHB0QEQ4YAAsuAzs7AAoPKToKDgAHMx8SGQUvMQABSAALORoVGCQgERcCAxoACAU3ABEXAgMaAAsFGDcAERcCAxoUCgABSQAGOA8LGBsPAAYYLwsYGw8AAU4ABD8QHAUAAU8ABSkbCQ4BAAFMAAktCh8eDgMHCw8AAU0ADT4TGjQsGQMaFA0FHhkAFz4TGjQsGQMaFA0FHhk1NBkCHgUbGBEPAAFCABg9GgkjIAEmOgUHDQ8eFSU5DggJAwEcAwUAAUMAAUAAAUEADQEtFw0FBwtdWxQTGSAACBwrAxUPBR4ZAAkqGgUDAwMVEQ0ACC4DJD8eAx8RAAQ5GhUYAAFGAAAABjYRExELBAACWhgAAVoAQAg/PTw0NxcQPCQ5C3JZEBs9fkcnDRcUAXZia0Q4EhQgXHojMBY3MWVCNT0uDhMXcGQ7AUFPHigkQUwQFkhaAkEACjkTEQspNBMZPC0ABjkTEQsrLQ==");
     function b(e) {
         // console.log(e);
         // console.log(encodeURIComponent(e));
        return __g._encrypt(encodeURIComponent(e))
    };

 4.获取用户评论文本

那么我们接下来看看如何去获取话题下面的评论文本数据，我们找到一个话题点进去；拉到最下面的评论内容，

找到对应请求链接：请求 URL:https://www.zhihu.com/api/v4/comment_v5/answers/2220441405/root_comment?order_by=score&limit=20&offset=

 发现唯一一个需要解密的就是2220441405，我们可以发现该数据为上一级的token

 5.总结

那么到这里整个流程就结束了；

我们可以总结梳理一下；我们唯一需要进行解密的就是x-zse-96:这个参数，至于token可以从返回的json数据里面获取得到；

项目对应的链接地址：https://download.csdn.net/download/fengku1/86514094

fengku1
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
X_zse_96参数记录
qq_39393527的博客
03-27 689
最新知乎爬虫，x-zse-96参数反爬JS逆向
某乎登录流程x-zse-96
逆向
09-08 253
滑块， zse96
zhihu X-Zse-96参数逆向
最新发布
weixin_66580433的博客
05-24 1087
当某个条件符合时，进入try流程，返回真值。当条件不符合时，进入catch流程，返回假值并且不会抛出异常。查看结果发现返回数据长度，每次都一模一样，但是数据不一样。我们在本地环境中也重写random，对比本地和控制台的加密结果。参数一样，random返回值一样，但是结果不一样。肯定是有环境检测，本地环境中返回了一个假值。这两个在浏览器环境中是不存在的，本地才有。补完之后继续执行，发现加密值变化了，并且document的环境监测通过。可以在控制台中重写时间戳或加密值，再次执行加密，查看返回结果是否固定。
某乎x-zse-96参数逆向
Lzyydsb的博客
05-13 404
​ 直接跟进encrypt函数里发现跟进去后是在一个控制流里，往下滑观察可以看到很长的字符串，啊，该死的VMP，直接全扣补环境吧往下一直滑倒长字符串，然后把这个代码块全部扣下来​ 最后自己微调一下参数啥的就行，附一张成功截图。
知乎登录js逆向及文章爬取js逆向
weixin_45886778的博客
02-02 2384
知乎登录js逆向及文章爬取js逆向 **在此声明：**本文章仅仅用于学习交流，不得用于商业活动。 登录支持账号密码登录及知乎移动端软件扫码登录。 文章爬取是把原文章的原样近似爬取，包括图片，链接，及评论。同时支持实时热点爬取。 好久不更新文章了，现在不一样了，放假了。其实这个文章我好久之前就打算写，但是当时比较忙，就被搁置了，现在放假了，就继续来。要不就半途而废了。也浪费了以前的时间。废话不多说，我们直接开干。 知乎，中文互联网高质量的问答社区和创作者聚集的原创内容平台，于 2011 年 1 月正式上
知乎搜索信息获取(x-zse-96)参数JS逆向破解
AngrySnack的博客
02-17 1886
网站：aHR0cHM6Ly93d3cuemhpaHUuY29tLw== 1、网页抓包分析，找到返回数据接口与加密参数 可以看到search_v3这个就是返回参数的接口，复制对应的cURL(base)到postman进行重新请求 通过重复测试可以知道只需要三个参数就能获取到数据（x-zse-96、x-zse-93、cookie），其中x-zse-93为固定值、cookie为身份认证信息，只有x-zse-96为动态变化，下滑数据也能得到新的请求信息，验证x-zse-96为动态参数 2、加密参数破解 老一套
javascript逆向 猿人学 js混淆 回溯 逆向学习
03-12
猿人学JS混淆是一种常见的JavaScript混淆技术，通过对代码进行重构、变量名替换、函数调用转换等手段，使得代码难以直观理解，增加了阅读和分析的难度。 在进行JavaScript逆向学习时，首先需要通过反混淆技术将混淆...
js逆向实战之某麻将数据逆向
12-31
js逆向实战之某麻将数据逆向 在本篇文章中，我们将通过实际案例来演示 JavaScript 逆向技术在某麻将游戏数据逆向中的应用。 知识点1：JavaScript 逆向技术 JavaScript 逆向技术是指通过对 JavaScript 代码的分析...
某度翻译js逆向解析token实现js文件源码，点击即可获取最新token
07-30
某度翻译js逆向解析token实现js文件源码。某度翻译的翻译链接中需要上传加密token，本文件附带解密token的js文件一份。可以使用python调用jsexecute进行解析，或者改写成python代码获取最新token，为后续的爬虫任务...
某易云音乐js逆向资源
07-31
总之，"某易云音乐js逆向资源" 是一个涵盖JavaScript解析、Python爬虫技术和逆向工程实践的项目，提供了学习和开发音乐相关应用的机会，但同时也需要谨慎处理潜在的法律和道德问题。通过深入理解和应用这些知识，...
鬼鬼js调试工具 js逆向必备
06-18
**鬼鬼JS调试工具**是专门针对JavaScript代码进行逆向工程的一款强大工具，尤其对于JS逆向分析工作来说，它是不可或缺的辅助软件。在互联网安全领域，JavaScript逆向工程经常被用于理解恶意代码的行为，或者在开发...
simplezhihu-api：简易知乎API接口
02-08
simple知乎的静态api登录用了jwt，没有数据库开销练手项目，并且没有采用服务层重叠代码，都直接把代码放在控制器上
知乎x-zse-96 文件头 JS解密
03-07
知乎x-zse-96 文件头 JS解密
知乎API搜集
热门推荐
岁月如歌
03-10 1万+
搜集的知乎API
【Python】简单爬虫抓取知乎专栏文章标题和链接、存储进CSV
memcpy0的博客
08-18 3953
文章目录 今天突发奇想，想要爬取一下知乎专栏文章的标题和链接，看看某个作者到底在这大几百几千篇文章中写了什么。
JS逆向---获取某知名外卖平台数据（_token）
m0_61720747的博客
08-30 3836
JS逆向---获取知名外卖平台加密数据（_token） 本文将对一大家都用过的外卖平台的 _token参数进行逆向解析，源代码放在末尾，可自行使用。 下列文章分为四个部分： 第一步：找到主体加密函数 第二步：分析加密函数 第三步：调试、补充JS代码和伪装环境 第四步：调用程序............
JS逆向——借助playwright实现逆向
年轻就做四件事：挣钱存钱、见世面、交朋友、学本事。
06-02 2177
3.通过查看堆栈信息，我们可以找到参数由无到有的地方，e就是token，也是在这里生成的，其生成过程传入了this.$store.state.url.index跟a ，通过查看得知this.$store.state.url.index就是/api/movie而a就是页码*10。playwright支持js文件替换,/js/chunk-10192a00.243cb8b7.js是源文件路径，chunk.js是我们本地路径。这样加载js文件时会被替换我们本地的js.这样我们可以通过js注入来调用加密方法。
最新。Python抓取某大型文章网站 --- 仅供学习使用（解决最新js反爬2022.9）
weixin_51962852的博客
08-09 6549
Python爬虫爬取知乎文章(含js反爬) 最近的业务要求去写一个关于知乎的爬虫，在这记录一下在爬取过程中出现的问题以及解决方法 知乎链接：https://www.zhihu.com/ 众所周知，知乎是需要登录的。 登录以后，搜索一个关键字，我这里搜索 奥运会 在这里想要获取每一条内容的标题和第一条用户回答(就是点击阅读全文后的内容）： 而且想要获取多条，比如100条，需要怎么做呢？ 先看一下知乎展现内容容的机制，发现鼠标滚轮往下滑的时候，内容被一点一点加载出来了，这里显然是用的ajax加载。 知道了加
【2022-08-11】知乎x-zse-96参数分析
不愿意透露姓名的网友
07-28 622
进入某乎，然后进行搜索，抓包找到搜索接口然后看请求头，发现除了携带cookie，还有携带其他三个参数再次访问其他搜索词，发现只有x-zse-96是变化的，其他两个可以固定，因此我们来分析一下。
app逆向与js逆向
09-03
而js逆向主要是指对JavaScript代码的逆向工程，通过分析和解密JavaScript代码，获取其中的关键信息。在js逆向过程中，常用的工具包括查壳工具、加密解密工具、鬼鬼js加密浏览器、Python的execjs库等。可以通过这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值