javascript逆向实战

浏览器开发逆向

前面一节我们了解了 JavaScript 的压缩、混淆等技术，现在越来越多的网站也已经应用了这些技术对其数据接口进行了保护，在做爬虫时如果我们遇到了这种情况，我们可能就不得不硬着头皮来去想方设法找出其中隐含的关键逻辑了，这个过程我们可以称之为 JavaScript 逆向。

既然我们要做 JavaScript 逆向，那少不了要用到浏览器的开发者工具，因为网页是在浏览器中加载的，所以多数的调试过程也是在浏览器中完成的。

工欲善其事，必先利其器。本节我们先来基于 Chrome 浏览器介绍一下浏览器开发者工具的使用。但由于开发者工具功能十分复杂，本节主要介绍对 JavaScript 逆向有一些帮助的功能，学会了这些，我们在做 JavaScript 逆向调试的过程会更加得心应手。

本节我们以一个示例网站 https://spa2.scrape.center/ 来做演示，用这个示例来介绍浏览器开发者工具各个面版的用法。

1. 面板介绍

首先我们用 Chrome 浏览器打开示例网站，页面如图所示：

接下来打开开发者工具，我们会看到类似图 xx 所示的结果。

这里可以看到多个面板标签，如 Elements、Console、Sources 等，这就是开发者工具的一个个面板，功能丰富而又强大，先对面板作下简单的介绍：

• Elements：元素面板，用于查看或修改当前网页 HTML 节点的属性、CSS 属性、监听事件等等，HTML 和 CSS 都可以即时修改和即时显示。
• Console：控制台面板，用于查看调试日志或异常信息。另外我们还可以在控制台输入 JavaScript 代码，方便调试。
• Sources：源代码面板，用于查看页面的 HTML 文件源代码、JavaScript 源代码、CSS 源代码，还可以在此面板对 JavaScript 代码进行调试，比如添加和修改 JavaScript 断点，观察 JavaScript 变量变化等。
• Network：网络面板，用于查看页面加载过程中的各个网络请求，包括请求、响应等各个详情。
• Performance：性能面板，用于记录和分析页面在运行时的所有活动，比如 CPU 占用情况，呈现页面性能分析结果，
• Memory：内存面板，用于记录和分析页面占用内存情况，如查看内存占用变化，查看 JavaScript 对象和 HTML 节点的内存分配。
• Application：应用面板，用于记录网站加载的所有资源信息，如存储、缓存、字体、图片等，同时也可以对一些资源进行修改和删除。
• Lighthouse：审核面板，用于分析网络应用和网页，收集现代性能指标并提供对开发人员最佳实践的意见。

了解了这些面板之后，我们来深入了解几个面板中对 JavaScript 调试很有帮助的功能。

2. 查看节点事件

之前我们是用 Elements 面板来审查页面的节点信息的，我们可以查看当前页面的 HTML 源代码及其在网页中对应的位置，查看某个条目的标题对应的页面源代码，如图所示。

点击右侧的 Styles 选项卡，可以看到对应节点的 CSS 样式，我们可以自行在这里增删样式，实时预览效果，这对网页开发十分有帮助。

在 Computed 选项卡中还可以看到当前节点的盒子模型，比如外边距、内边距等，还可以看到当前节点最终计算出的 CSS 的样式，如图所示。

接下来切换到右侧的 Event Listeners 选项卡，这里可以显示各个节点当前已经绑定的事件，都是 JavaScript 原生支持的，下面简单列举几个事件。

• change：HTML 元素改变时会触发的事件。
• click：用户点击 HTML 元素时会触发的事件。
• mouseover：用户在一个 HTML 元素上移动鼠标会触发的事件。
• mouseout：用户从一个 HTML 元素上移开鼠标会触发的事件。
• keydown：用户按下键盘按键会触发的事件。
• load：浏览器完成页面加载时会触发的事件。

通常，我们会给按钮绑定一个点击事件，它的处理逻辑一般是由 JavaScript 定义的，这样在我们点击按钮的时候，对应的 JavaScript 代码便会执行。比如在图 xx 中，我们选中切换到第 2 页的节点，右侧 Event Listeners 选项卡下会看到它绑定的事件。

这里有对应事件的代码位置，内容为一个 JavaScript 文件名称 chunk-vendors.77daf991.js，然后紧跟一个冒号，然后再跟了一个数字 7。所以对应的事件处理函数是定义在 chunk-vendors.77daf991.js 这个文件的第 7 行。点击这个代码位置，便会自动跳转 Sources 面板，打开对应的 chunk-vendors.77daf991.js 文件并跳转到对应的位置，如图所示。

所以，利用好 Event Listeners，我们可以轻松地找到各个节点绑定事件的处理方法所在的位置，帮我们在 JavaScript 逆向过程中找到一些突破口。

3. 代码美化

刚才我们已经通过 Event Listeners 找到了对应的事件处理方法所在的位置并成功跳转到了代码所在的位置。

但是，这部分代码似乎被压缩过了，可读性很差，根本没法阅读，这时候应该怎么办呢？

不用担心，Sources 面板提供了一个便捷好用的代码美化功能。我们点击代码面板左下角的格式化按钮，代码就会变成如图所示的样子。

此时会新出现一个叫作 chunk-vendors.77daf991.js:formatted 的选项卡，文件名后面加了 formatted 标识，代表这是被格式化的结果。我们会发现，原来代码在第 7 行，现在自动对应到了第 4445 行，而且对应的代码位置会高亮显示，代码可读性大大增强！

这个功能在调试过程中非常常用，用好这个功能会给我们的 JavaScript 调试过程带来极大的便利。

4. 断点调试

接下来介绍一个非常重要的功能 —— 断点调试。在调试代码的时候，我们可以在需要的位置上打断点，当对应事件触发时，浏览器就会自动停在断点的位置等待调试，此时我们可以选择单步调试，在面板中观察调用栈、变量值，以更好地追踪对应位置的执行逻辑。

那么断点怎么打呢？我们接着以上面的例子来说。首先单击如图所示的代码行号。

这时候行号处就出现了一个蓝色的箭头，这就证明断点已经添加好了，同时在右侧的 Breakpoints 选项卡下会出现我们添加的断点的列表。

由于我们知道这个断点是用来处理翻页按钮的点击事件的，所以可以在网页里面点击按钮试一下，比如点击第 2 页的按钮，这时候就会发现断点被触发了，如图所示。

这时候我们可以看到页面中显示了一个叫作 Paused in debugger 的提示，这说明浏览器执行到刚才我们设置断点的位置处就不再继续执行了，等待我们发号施令执行调试。

此时代码停在了第 4446 行，回调参数 e 就是对应的点击事件 MouseEvent 。在右侧的 Scope 面板处，可以观察到各个变量的值，比如在 Local 域下有当前方法的局部变量，我们可以在这里看到 MouseEvent 的各个属性，如图所示。

另外我们关注到有一个方法 o，它在 Jr 方法下面，所以切换到 Closure(Jr) 域可以查看它的定义及其接收的参数，如图所示。

我们可以看到，FunctionLocation 又指向了方法 o ，点击之后便又可以跳到指定位置，用同样的方式进行断点调试即可。

在 Scope 面板还有多个域，这里就不再展开介绍了。总之，通过 Scope 面板，我们可以看到当前执行环境下的变量的值和方法的定义，知道当前代码究竟执行了怎样的逻辑。

接下来切换到 Watch 面板，在这里可以自行添加想要查看的变量和方法，点击右上角的 + 号按钮，我们可以任意添加想要监听的对象，如图所示。

比如这里我们比较关注 o.apply 是一个怎样的方法，于是点击添加 o.apply，这里就会把对应的方法定义呈现出来，展开之后可以再点击 FunctionLocation 定位其源码位置。

我们还可以切换到 Console 面板，输入任意的 JavaScript 代码，便会执行、输出对应的结果，如图所示。

如果我们想看看变量 arguments 的第一个元素是什么，那么可以直接敲入 arguments[0]，便会输出对应的结果 MouseEvent，只要在当前上下文能访问到的变量都可以直接引用并输出。

此时我们还可以选择单步调试，这里有 3 个重要的按钮，如图所示。

这 3 个按钮都可以做单步调试，但功能不同。

• Step Over Next Function Call：逐语句执行
• Step Into Next Function Call：进入方法内部执行
• Step Out of Current Function：跳出当前方法

用得较多的是第一个，相当于逐行调试，比如点击 Step Over Next Function Call 这个按钮，就运行到了 4447 行，高亮的位置就变成了这一行，如图所示。

5. 观察调用栈

在调试的过程中，我们可能会跳到一个新的位置，比如点击上述 Step Over Next Function Call 几下，可能会跳到一个叫作 ct 的方法中，这时候我们也不知道发生了什么，如图所示。

那究竟是怎么跳过来的呢？我们可以观察一下右侧的 Call Stack 面板，就可以看到全部的调用过程了。比如它的上一步是 ot 方法，再上一步是 pt 方法，点击对应的位置也可以跳转到对应的代码位置，如图所示。

有时候调用栈是非常有用的，利用它我们可以回溯某个逻辑的执行流程，从而快速找到突破口。

6. 恢复 JavaScript 执行

在调试过程中，如果想快速跳到下一个断点或者让 JavaScript 代码运行下去，可以点击 Resume script execution 按钮，如图所示。

这时浏览器会直接执行到下一个断点的位置，从而避免陷入无穷无尽的调试中。

当然，如果没有其他断点了，浏览器就会恢复正常状态。比如这里我们就没有再设置其他断点了，浏览器直接运行并加载了下一页的数据，同时页面恢复正常，如图所示。

7. Ajax 断点

上面我们介绍了一些 DOM 节点的 Listener，通过 Listener 我们可以手动设置断点并进行调试。但其实针对这个例子，通过翻页的点击事件 Listener 是不太容易找到突破口的。

接下来我们再介绍一个方法 —— Ajax 断点，它可以在发生 Ajax 请求的时候触发断点。对于这个例子，我们的目标其实就是找到 Ajax 请求的那一部分逻辑，找出加密参数是怎么构造的。可以想到，通过 Ajax 断点，使页面在获取数据的时候停下来，我们就可以顺着找到构造 Ajax 请求的逻辑了。

怎么设置呢？

我们把之前的断点全部取消，切换到 Sources 面板下，然后展开 XHR/fetch Breakpoints，这里就可以设置 Ajax 断点，如图所示。

要设置断点，就要先观察 Ajax 请求。和之前一样，我们点击翻页按钮 2，在 Network 面板里面观察 Ajax 请求是怎样的，请求的 URL 如图所示。

可以看到 URL 里面包含 /api/movie 这样的内容，所以我们可以在刚才的 XHR/fetch Breakpoints 面板中添加拦截规则。点击 + 号，可以看到一行 Break when URL contains: 的提示，意思是当 Ajax 请求的 URL 包含填写的内容时，会进入断点停止，这里可以填写 /api/movie，如图所示。

这时候我们再点击翻页按钮 3，触发第 3 页的 Ajax 请求。会发现点击之后页面走到断点停下来了，如图所示。

格式化代码看一下，发现它停到了 Ajax 最后发送的那个时候，即底层的 XMLHttpRequest 的 send 方法，可是似乎还是找不到 Ajax 请求是怎么构造的。前面我们讲过调用栈 Call Stack，通过调用栈是可以顺着找到前序调用逻辑的，所以顺着调用栈一层层找，也可以找到构造 Ajax 请求的逻辑，最后会找到一个叫作 onFetchData 的方法，如图所示。

接下来切换到 onFetchData 方法并将代码格式化，可以看到如图所示的调用方法。

可以发现，可能使用了 axios 库发起了一个 Ajax 请求，还有 limit、offset、token 这 3 个参数，基本就能确定了，顺利找到了突破口！我们就不在此展开分析了，后文会有完整的分析实战。

因此在某些情况下，我们可以在比较容易地通过 Ajax 断点找到分析的突破口，这是一个常见的寻找 JavaScript 逆向突破口的方法。

要取消断点也很简单，只需要在 XHR/fetch Breakpoints 面板取消勾选即可，如图所示。

8. 改写 JavaScript 文件

我们知道，一个网页里面的 JavaScript 是从对应服务器上下载下来并在浏览器执行的。有时候，我们可能想要在调试的过程中对 JavaScript 做一些更改，比如说有以下需求：

• 发现 JavaScript 文件中包含很多阻挠调试的代码或者无效代码、干扰代码，想要将其删除。

• 调试到某处，想要加一行 console.log 输出一些内容，以便观察某个变量或方法在页面加载过程中的调用情况。在某些情况下，这种方法比打断点调试更方便。

• 调试过程遇到某个局部变量或方法，想要把它赋值给 window 对象以便全局可以访问或调用。

• 在调试的时候，得到的某个变量中可能包含一些关键的结果，想要加一些逻辑将这些结果转发到对应的目标服务器。

这时候我们可以试着在 Sources 面板中对 JavaScript 进行更改，但这种更改并不能长久生效，一旦刷新页面，更改就全都没有了。比如我们在 JavaScript 文件中写入一行 JavaScript 代码，然后保存，如图所示。

这时候可以发现 JavaScript 文件上出现了一个感叹号标志，提示我们做的更改是不会保存的。这时候重新刷新页面，再看一下更改的这个文件，如图所示。

有什么方法可以修改呢？其实有一些浏览器插件可以实现，比如 ReRes。在插件中，我们可以添加自定义的 JavaScript 文件，并配置 URL 映射规则，这样浏览器在加载某个在线 JavaScript 文件的时候就可以将内容替换成自定义的 JavaScript 文件了。另外，还有一些代理服务器也可以实现，比如 Charles、Fiddler，借助它们可以在加载 JavaScript 文件时修改对应 URL 的响应内容，以实现对 JavaScript 文件的修改。

其实浏览器的开发者工具已经原生支持这个功能了，即浏览器的 Overrides 功能，它在 Sources 面板左侧，如图所示。

我们可以在 Overrides 面板上选定一个本地的文件夹，用于保存需要更改的 JavaScript 文件，我们来实际操作一下。

首先，根据上文设置 Ajax 断点的方法，找到对应的构造 Ajax 请求的位置，根据一些网页开发知识，我们可以大体判断出 then 后面的回调方法接收的参数 a 中就包含了 Ajax 请求的结果，如图所示。

我们打算在 Ajax 请求成功获得 Response 的时候，在控制台输出 Response 的结果，也就是通过 console.log 输出变量 a。

再切回 Overrides 面板，点击 + 按钮，这时候浏览器会提示我们选择一个本地文件夹，用于存储要替换的 JavaScript 文件。这里我选定了一个我任意新建的文件夹 ChromeOverrides，注意，这时候可能会遇到如图所示的提示，如果没有问题，直接点击 “允许” 即可。

这时，在 Overrides 面板下就多了一个 ChromeOverrides 文件夹，用于存储所有我们想要更改的 JavaScript 文件，如图所示。

我们可以看到，现在所在的 JavaScript 选项卡是 chunk-19c920f8.012555a2.js:formatted，代码已经被格式化了。因为格式化后的代码是无法直接在浏览器中修改的，所以为了方便，我们可以将格式化后的文件复制到文本编辑器中，然后添加一行代码，修改如下：

	… }).then((function(a) { console.log(‘response’, a) // 添加一行代码 var e = a.data , s = e.results , n = e.count; t.loading = !1, …

接着把修改后的内容替换到原来的 JavaScript 文件中。这里要注意，切换到 chunk-19c920f8.012555a2.js 文件才能修改，直接替换 JavaScript 文件的所有内容即可，如图所示。

替换完毕之后保存，这时候再切换回 Overrides 面板，就可以发现成功生成了新的 JavaScript 文件，它用于替换原有的 JavaScript 文件，如图所示。

好，此时我们取消所有断点，然后刷新页面，就可以在控制台看到输出的 Reponse 结果了，如图所示。

正如我们所料，我们成功将变量 a 输出，其中的 data 字段就是 Ajax 的 Response 结果，证明改写 JavaScript 成功！而且刷新页面也不会丢失了。

我们还可以增加一些 JavaScript 逻辑，比如直接将变量 a 的结果通过 API 发送到远程服务器，并通过服务器将数据保存下来，也就完成了直接拦截 Ajax 请求并保存数据的过程了。

修改 JavaScript 文件有很多用途，此方案可以为我们进行 JavaScript 的逆向带来极大的便利。

Hook的用法

在 JavaScript 逆向的时候，我们经常需要追踪某些方法的堆栈调用情况。但在很多情况下，一些 JavaScript 的变量或者方法名经过混淆之后是非常难以捕捉的。上一节我们介绍了一些断点调试、调用栈查看等技巧，但仅仅凭借这些技巧还不足以应对多数 JavaScript 逆向。

本节我们再来介绍一个比较常用的 JavaScript 逆向技巧 —— Hook 技术。

1. Hook 技术

Hook 技术中文又叫作钩子技术，指在程序运行的过程中，对其中的某个方法进行重写，在原先的方法前后加入我们自定义的代码。相当于在系统没有调用该函数之前，钩子程序就先捕获该消息，得到控制权，这时钩子函数既可以加工处理（改变）该函数的执行行为，也可以强制结束消息的传递。

要对 JavaScript 代码进行 Hook 操作，就需要额外在页面中执行一些自定义的有关 Hook 逻辑的代码。那么问题来了？怎样才能在浏览器中方便地执行我们所期望执行的 JavaScript 代码呢？在这里推荐一个插件，叫作 Tampermonkey。这个插件的功能非常强大，利用它我们几乎可以在网页中执行任何 JavaScript 代码，实现我们想要的功能。

下面我们就来介绍一下这个插件的使用方法，并结合一个实际案例，介绍一下这个插件在 JavaScript Hook 中的用途。

2. Tampermonkey

Tampermonkey，中文也叫作 “油猴”，它是一款浏览器插件，支持 Chrome。利用它我们可以在浏览器加载页面时自动执行某些 JavaScript 脚本。由于执行的是 JavaScript，所以我们几乎可以在网页中完成任何我们想实现的效果，如自动爬虫、自动修改页面、自动响应事件等。

其实，Tampermonkey 的用途远远不止这些，只要我们想要的功能能用 JavaScript 实现，Tampermonkey 就可以帮我们做到。比如我们可以将 Tampermonkey 应用到 JavaScript 逆向分析中，去帮助我们更方便地分析一些 JavaScript 加密和混淆代码。

3. 安装

首先我们需要安装 Tampermonkey，这里我们使用的浏览器是 Chrome。直接在 Chrome 应用商店或者在 Tampermonkey 的官网 https://www.tampermonkey.net/ 下载安装即可。

安装完成之后，在 Chrome 浏览器的右上角会出现 Tampermonkey 的图标，这就代表安装成功了，如图所示。

4. 获取脚本

Tampermonkey 运行的是 JavaScript 脚本，每个网站都能有对应的脚本运行，不同的脚本能完成不同的功能。这些脚本我们可以自定义，也可以用已经写好的很多脚本，毕竟有些轮子有了，我们就不需要再去造了。

我们可以在 https://greasyfork.org/zh-CN/scripts 找到一些非常实用的脚本，如全网视频去广告、百度云全网搜索等，大家可以体验一下。

5. 脚本编写

除了使用别人已经写好的脚本，我们也可以自己编写脚本来实现想要的功能。编写脚本难不难呢？其实就是写 JavaScript 代码，只要懂一些 JavaScript 的语法就好了。另外我们需要遵循脚本的一些写作规范，其中就包括一些参数的设置。

下面我们就简单实现一个小的脚本。首先我们可以点击 Tampermonkey 插件图标，再点击 “管理面板” 按钮，打开脚本管理页面，如图所示。

脚本管理页面如图所示。

在这里显示了我们已经有的一些 Tampermonkey 脚本，包括我们自行创建的，也包括从第三方网站下载安装的。另外这里提供了编辑、调试、删除等管理功能，在这里可以方便地对脚本进行管理。

接下来我们来创建一个新的脚本，点击左侧的 “+” 号，会显示如图所示的页面。

初始化的代码如下：

	// ==UserScript== // @name New Userscript // @namespace http://tampermonkey.net/ // @version 0.1 // @description try to take over the world! // @author You // @match https://www.tampermonkey.net/documentation.php?ext=dhdg // @grant none // ==/UserScript== (function () { ; // Your code here… })();

在上面这段代码里，最前面是一些注释，它们非常有用，这部分内容叫作 UserScript Header ，我们可以在里面配置一些脚本的信息，如名称、版本、描述、生效站点等等。

下面简单介绍一下 UserScript Header 的一些参数定义。

• @name：脚本的名称，就是在控制面板显示的脚本名称。

• @namespace：脚本的命名空间。

• @version：脚本的版本，主要是做版本更新时用。

• @author：作者。

• @description：脚本描述。

• @homepage、 @homepageURL、 @website、@source：作者主页，用于在 Tampermonkey 选项页面上从脚本名称点击跳转。请注意，如果 @namespace 标记以 http:// 开头，此处也要一样。

• @icon、 @iconURL 、@defaulticon：低分辨率图标。

• @icon64 、 @icon64URL：64 × 64 高分辨率图标。

• @updateURL：检查更新的网址，需要定义 @version。

• @downloadURL：更新下载脚本的网址，如果定义成 none 就不会检查更新。

• @supportURL：报告问题的网址。

• @include：生效页面，可以配置多个，但注意这里并不支持 URL Hash。

  例如：

  	// @include http://www.tampermonkey.net/* // @include http://* // @include https://* // @include *

• @match：约等于 @include 标签，可以配置多个。

• @exclude：不生效页面，可配置多个，优先级高于 @include 和 @match。

• @require：附加脚本网址，相当于引入外部的脚本，这些脚本会在自定义脚本执行之前执行，比如引入一些必须的库，如 jQuery 等，这里可以支持配置多个 @require参数。

  例如：

  	// @require https://code.jquery.com/jquery-2.1.4.min.js // @require https://code.jquery.com/jquery-2.1.3.min.js#sha256=23456… // @require https://code.jquery.com/jquery-2.1.2.min.js#md5=34567...,sha256=6789…

• @resource：预加载资源，可通过 GM_getResourceURL 和 GM_getResourceText 读取。

• @connect：允许被 GM_xmlhttpRequest 访问的域名，每行 1 个。

• @run-at：脚本注入的时刻，如页面刚加载时，某个事件发生后等。

  • document-start：尽可能地早执行此脚本。
  • document-body：DOM 的 body 出现时执行。
  • document-end：DOMContentLoaded 事件发生时或发生后执行。
  • document-idle：DOMContentLoaded 事件发生后执行，即 DOM 加载完成之后执行，这是默认的选项。
  • context-menu：如果在浏览器上下文菜单（仅限桌面 Chrome 浏览器）中点击该脚本，则会注入该脚本。注意：如果使用此值，则将忽略所有 @include 和 @exclude 语句。

• @grant：用于添加 GM 函数到白名单，相当于授权某些 GM 函数的使用权限。

  例如：

  	// @grant GM_setValue // @grant GM_getValue // @grant GM_setClipboard // @grant unsafeWindow // @grant window.close // @grant window.focus

  如果没有定义过 @grant 选项，Tampermonkey 会猜测所需要的函数使用情况。

• @noframes：此标记使脚本在主页面上运行，但不会在 iframe 上运行。

• @nocompat：由于部分代码可能是为专门的浏览器所写，通过此标记，Tampermonkey 会知道脚本可以运行的浏览器。

  例如：

  	// @nocompat Chrome

  这样就指定了脚本只在 Chrome 浏览器中运行。

除此之外，Tampermonkey 还定义了一些 API，使得我们可以方便地完成某个操作。

• GM_log：将日志输出到控制台。
• GM_setValue：将参数内容保存到 Storage 中。
• GM_addValueChangeListener：为某个变量添加监听，当这个变量的值改变时，就会触发回调。
• GM_xmlhttpRequest：发起 Ajax 请求。
• GM_download：下载某个文件到磁盘。
• GM_setClipboard：将某个内容保存到粘贴板。

还有很多其他的 API，大家可以到 https://www.tampermonkey.net/documentation.php 查看更多的内容。

在 UserScript Header 下方是 JavaScript 函数和调用的代码，其中 'use strict' 标明代码使用 JavaScript 的严格模式。在严格模式下，可以消除 Javascript 语法的一些不合理、不严谨之处，减少一些怪异行为，如不能直接使用未声明的变量，这样可以保证代码的运行安全，同时提高编译器的效率，提高运行速度。在下方 // Your code here... 处就可以编写自己的代码了。

6. 实战分析

下面我们通过一个简单的 JavaScript 逆向案例来演示一下如何实现 JavaScript 的 Hook 操作，轻松找到某个方法执行的位置，从而快速定位逆向入口。

接下来我们来看一个简单的网站：https://login1.scrape.center/，这个网站的结构非常简单，就是一个用户名密码登录。但是不同的是，点击登录的时候，表单提交 POST 的内容并不是单纯的用户名和密码，而是一个加密后的 token。

页面如图所示。

我们输入用户名密码，都为 admin，点击登录按钮，观察一下网络请求的变化。

可以看到如下结果如图所示。

我们不需要关心 Response 的结果和状态，主要看 Request 的内容就好了。

可以看到，点击登录按钮时，发起了了一个 POST 请求，内容为：

	{“token”:”eyJ1c2VybmFtZSI6ImFkbWluIiwicGFzc3dvcmQiOiJhZG1pbiJ9”}

嗯，确实，没有诸如 username 和 password 的内容了，那怎么模拟登录呢？

模拟登录的前提当然就是找到当前 token 生成的逻辑了，那么问题来了，到底这个 token 和用户名、密码是什么关系呢？我们怎么来找寻其中的蛛丝马迹呢？

这里我们就可能思考了，本身输入的是用户名和密码，但提交的时候却变成了一个 token，经过观察并结合一些经验可以看出，token 的内容非常像 Base64 编码。这就代表，网站可能首先将用户名密码混为了一个新的字符串，然后经过了一次 Base64 编码，最后将其赋值为 token 来提交了。所以，初步观察我们可以得出这么多信息。

好，那就来验证一下吧！探究网站 JavaScript 代码里面是如何实现的。

首先我们看一下网站的源码，打开 Sources 面板，看起来都是 Webpack 打包之后的内容，经过了一些混淆，如图所示。

这么多混淆代码，总不能一点点扒着看吧？那么遇到这种情形，这怎么去找 token 的生成位置呢？

解决方法其实有两种，一种就是前文所讲的 Ajax 断点，另一种就是 Hook。

Ajax 断点

由于这个请求正好是一个 Ajax 请求，所以我们可以添加一个 XHR 断点监听，把 POST 的网址加到断点监听上面。在 Sources 面板右侧添加一个 XHR 断点，匹配内容就填当前域名就好了，如图所示。

这时候如果我们再次点击登录按钮，发起一次 Ajax 请求，就可以进入断点了，然后再看堆栈信息，就可以一步步找到编码的入口了。

再次点击登录按钮，页面就进入断点状态停下来了，结果如图所示。

一步步找，最后可以找到入口其实是在 onSubmit 方法那里。但实际上我们观察到，这里的断点的栈顶还包括了一些类似 async Promise 等无关的内容，而我们真正想找的是用户名和密码经过处理，再进行 Base64 编码的地方，这些请求的调用实际上和我们找寻的入口没有很大的关系。

另外，如果我们想找的入口位置并不伴随这一次 Ajax 请求，这个方法就没法用了。

所以下面我们再来看另一个方法 —— Hook。

Hook Function

所以这里介绍第二种可以快速定位入口的方法，那就是使用 Tampermonkey 自定义 JavaScript，实现某个 JavaScript 方法的 Hook。Hook 哪里呢？很明显，Hook Base64 编码的位置就好了。

那么这里就涉及一个小知识点：JavaScript 里面的 Base64 编码是怎么实现的？

没错，就是 btoa 方法，在 JavaScript 中该方法用于将字符串编码成 Base64 字符串，因此我们来 Hook btoa 方法就好了。

好，这里我们新建一个 Tampermonkey 脚本，内容如下：

// ==UserScript== // @name HookBase64 // @namespace https://login1.scrape.center/ // @version 0.1 // @description Hook Base64 encode function // @author Germey // @match https://login1.scrape.center/ // @grant none // ==/UserScript== (function () { ; function hook(object, attr) { var func = object[attr]; object[attr] = function () { console.log(“hooked”, object, attr); var ret = func.apply(object, arguments); debugger; return ret; }; } hook(window, “btoa”); })();

首先我们定义了一些 UserScript Header，包括 @name 和 @match 等，这里比较重要的就是 @name，表示脚本名称；另外一个就是 @match，它代表脚本生效的网址。

脚本的内容如上面代码所示。我们定义了一个 hook 方法，传入 object 和 attr 参数，意思就是 Hook object 对象的 attr 参数。例如我们如果想 Hook alert 方法，那就把 object 设置为 window，把 attr 设置为字符串 alert 。这里我们想要 Hook Base64 的编码方法，而在 JavaScript 中，Based64 编码是用 btoa 方法实现的，所以这里我们就只需要 Hook window 对象的 btoa 方法就好了。

那么 Hook 是怎么实现的呢？我们来看已下，首先一句 var func = object[attr]，相当于我们先把它赋值为一个变量，我们调用 func 方法就可以实现和原来相同的功能。接着，我们直接改写这个方法的定义，将 object[attr] 改写成一个新的方法，在新的方法中，通过 func.apply 方法又重新调用了原来的方法。这样我们就可以保证前后方法的执行效果是不受什么影响的，之前这个方法该干啥就还是干啥。

但是和之前不同的是，我们自定义方法之后，现在可以在 func 方法执行的前后，再加入自己的代码，如 console.log 将信息输出到控制台，debugger 进入断点等。在这个过程中，我们先临时保存下来了 func 方法，然后定义一个新的方法，接管程序控制权，在其中自定义我们想要的实现，同时在新的方法里面重新调回 func 方法，保证前后结果是不受影响的。所以，我们达到了在不影响原有方法效果的前提下，实现在方法前后自定义的功能，这就是 Hook 的过程。

最后，我们调用 hook 方法，传入 window 对象和 btoa 字符串，保存。

接下来刷新下页面，这时候我们就可以看到这个脚本在当前页面生效了，可以发现 Tempermonkey 插件面板提示了已经启用，同时在 Sources 面板下的 Page 选项卡可以观察到我们定义的 JavaScript 脚本被执行了，如图所示。

然后输入用户名、密码，点击提交，成功进入了断点模式停下来了，代码就卡在了我们自定义的 debugger 这一行代码的位置，如图所示。

成功 Hook 住了，这说明 JavaScript 代码在执行过程中调用到了 btoa 方法。

这时看一下控制台，如图所示。

这里也输出了 window 对象和 btoa 方法，验证正确。

这样，我们就顺利找到了 Base64 编码操作这个路口，然后看一下堆栈信息，也已经不会出现 async、Promise 这样的调用了，很清晰地呈现了 btoa 方法逐层调用的过程，非常清晰明了，如图所示。

另外再观察下 Local 面板，看看 arguments 变量是怎样的，如图所示。

可以说一目了然了，arguments 就是指传给 btoa 方法的参数，ret 就是 btoa 方法返回的结果，可以看到 arguments 就是 username 和 password 通过 JSON 序列化之后的字符串，经过 Base64 编码之后得到的值恰好就是 Ajax 请求参数 token 的值。

结果几乎也明了了，我们还可以通过调用栈找到 onSubmit 方法的处理源码：

	onSubmit: function() { var e = c.encode(JSON.stringify(this.form)); this.$http.post(a[“a”].state.url.root, { token: e }).then((function(e) { console.log(“data”, e) })) }

仔细看看，encode 方法其实就是调用了一下 btoa 方法，就是一个 Base64 编码的过程，答案其实已经很明了了。

当然我们还可以进一步打断点验证一下流程，比如在调用 encode 方法的一行打断点，如图所示。

打完断点之后，可以点击 Resume 按钮恢复 JavaScript 的执行，跳过当前 Tempermonkey 定义的断点位置，如图所示。

然后重新再点击登录按钮，可以看到这时候就停在了当前打断点的位置了，如图所示。

这时候可以在 Watch 面板下输入 this.form，验证此处是否为在表单中输入的用户名密码，如图所示。

没问题，然后逐步调试。我们还可以可以观察到，下一步就跳到了我们 Hook 的位置，这说明调用了 btoa 方法，如图所示。

返回的结果正好就是 token 的值。

所以，验证到这里，已经非常清晰了，整体逻辑就是对登录表单的用户名和密码进行了 JSON 序列化，然后调用了 encode 也就是 btoa 方法，并赋值为了 token 发起登录的 Ajax 请求，逆向完成。

我们通过 Tampermonkey 自定义 JavaScript 脚本的方式，实现了某个方法调用的 Hook，使得我们能快速定位到加密入口的位置，非常方便。

以后如果观察出一些门道，可以多使用这种方法来尝试，如 Hook encode 方法、decode 方法、stringify 方法、log 方法、alert 方法等，简单又高效。

模拟执行javascript

前面我们了解了一些 JavaScript 逆向的调试技巧，通过一些方法，我们可以找到一些突破口，进而找到关键的方法定义。

比如说，通过一些调试，我们找到了一个加密参数 token 是由某一个叫做 encrypt 方法产生的，如果里面的逻辑相对简单的话，那其实我们可以用 Python 完全重写一遍。但是现实情况往往不是这样的，一般来说，一些加密相关的方法通常会引用一些相关标准库，比如说 JavaScript 就有一个广泛使用的库，叫做 crypto-js，GitHub 仓库链接是：https://github.com/brix/crypto-js，这个库实现了很多主流的加密算法，包括对称加密、非对称加密、字符编码等等，比如对于 AES 加密，通常我们需要输入待加密文本和加密密钥，实现如下：

	const ciphertext = CryptoJS.AES.encrypt(message, key).toString();

对于这样的情况，我们其实就没法很轻易地完全重写一遍了，因为 Python 中并不一定有和 JavaScript 完全一样的类库。

那有什么解决办法吗？有的，既然 JavaScript 已经实现好了，那我用 Python 直接模拟执行这些 JavaScript 得到结果不就好了吗？

所以，本节我们就来了解下使用 Python 模拟执行 JavaScript 的解决方案。

1. 案例引入

这里我们先看一个和上文描述的情形非常相似的案例，链接是：https://spa7.scrape.center/，如图所示：

这是一个 NBA 球星网站，用卡片的形式展示了一些球星的基本信息，另外每一张卡片上其实都有一个加密字符串，这个加密字符串其实和球星的相关信息是有关联的，每个球星的 加密字符串也是不同的。

所以，这里我们要做的就是找出这个加密字符串的加密算法并用程序把加密字符串的生成过程模拟出来。

2. 准备工作

由于本节我们需要使用 Python 模拟执行 JavaScript，这里我们使用的库叫做 PyExecJS，我们使用 pip3 安装即可，命令如下：

	pip3 install pyexecjs

PyExecJS 是用于执行 JavaScript 的，但执行 JavaScript 的功能需要依赖一个 JavaScript 运行环境，所以除了安装好这个库之外，我们还需要安装一个 JavaScript 运行环境，个人比较推荐的是 Node.js，所以我们还需要安装下 Node.js，可以到 https://nodejs.org/ 下载安装。更加详细的安装和配置过程可以参考：https://setup.scrape.center/pyexecjs。

PyExecJS 库在运行时会检测本地 JavaScript 运行环境来实现 JavaScript 执行，做好如上准备工作之后， 接着我们运行代码检查一下运行环境：

	import execjs print(execjs.get().name)

运行结果类似如下：

	Node.js (V8)

如果你成功安装好 PyExecJS 库和 Node.js 的话，其结果就是 Node.js (V8)，当然如果你安装的是其他的 JavaScript 运行环境，结果也会有所不同。

3. 分析

接下来我们就对这个网站稍作分析，打开 Sources 面板，我们可以非常轻易地找到加密字符串的生成逻辑，如图所示：

首先声明了一个球员相关的列表，如：

	const players = [ { name: ‘凯文-杜兰特’, image: ‘durant.png’, birthday: ‘1988-09-29’, height: ‘208cm’, weight: ‘108.9KG’ } … ]

然后对于每一个球员，都把每个球员的信息调用了加密算法进行了加密，我们可以打个断点看下：

这里我们可以看到，getToken 方法的输入就是单个球员的信息，就是上述列表的一个元素对象，然后 this.key 就是一个固定的字符串。整个加密逻辑就是提取了球员的名字、生日、身高、体重，然后先 Base64 编码然后再进行 DES 加密，最后返回结果。

加密算法是怎么实现的呢？其实就是依赖了 crypto-js 库，使用了 CryptoJS 对象来实现的。

那 CryptoJS 这个对象是哪里来的呢？总不能凭空产生吧？其实这个网站就是直接引用了这个库，如图所示：

引用这个 JavaScript 文件之后，CryptoJS 就被注入到浏览器全局环境下了，因此我们就可以在别的方法里面直接使用 CryptoJS 对象里面的方法了。

4. 模拟调用

好，那既然这样，我们要怎么模拟呢？下面我们来实现下。

首先，我们要模拟的其实就是这个 getToken 方法，输入球员相关信息，得到最终的加密字符串，这里我们直接把 key 替换下，把 getToken 方法稍微改写如下：

function getToken(player) { let key = CryptoJS.enc.Utf8.parse(“fipFfVsZsTda94hJNKJfLoaqyqMZFFimwLt”); const { name, birthday, height, weight } = player; let base64Name = CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(name)); let encrypted = CryptoJS.DES.encrypt( ${base64Name}${birthday}${height}${weight}, key, { mode: CryptoJS.mode.ECB, padding: CryptoJS.pad.Pkcs7, } ); return encrypted.toString(); }

因为这个方法的模拟执行是需要 CryptoJS 这个对象的，如果我们直接调用这个方法肯定会报 CryptoJS 未定义的错误。

那怎么办呢？我们只需要再模拟执行下刚才看到的 crypto-js.min.js 不就好了吗？

OK，所以，我们需要模拟执行的内容就是两部分：

• 模拟运行 crypto-js.min.js 里面的 JavaScript，用于声明 CryptoJS 对象。
• 模拟运行 getToken 方法的定义，用于声明 getToken 方法。

好，接下来我们就把 crypto-js.min.js 里面的代码和上面 getToken 方法的代码复制一下，都粘贴到一个 JavaScript 文件里面，比如就叫做 crypto.js。

接下来我们就用 PyExecJS 模拟执行一下吧，代码如下：

	import execjs import json item = { ‘name’: ‘凯文-杜兰特’, ‘image’: ‘durant.png’, ‘birthday’: ‘1988-09-29’, ‘height’: ‘208cm’, ‘weight’: ‘108.9KG’ } file = ‘crypto.js’ node = execjs.get() ctx = node.compile(open(file).read()) js = f”getToken({json.dumps(item, ensure_ascii=False)})” print(js) result = ctx.eval(js) print(result)

这里我们单独定义了一位球员的信息，赋值为 item 变量。然后使用 execjs 的 get 方法获取了 JavaScript 执行环境，赋值为 node。

接着我们调用了 node 的 compile 方法，传入了刚才定义的 crypto.js 文件的文本内容，compile 方法会返回一个 JavaScript 的上下文对象，我们赋值为 ctx。执行到这里，其实就可以理解为，ctx 对象里面就执行过了 crypto-js.min.js，CryptoJS 就声明好了，然后也执行过了 getToken 的定义，所以 getToken 方法也定义好了，相当于完成了一些初始化的工作。

接着，我们只需要定义好我们想要执行的 JavaScript 代码就好了，我们定义了一个 js 变量，其实就是模拟调用了 getToken 方法并传入了球员信息，我们打印了下 js 变量的值，内容如下：

	getToken({“name”: “凯文-杜兰特”, “image”: “durant.png”, “birthday”: “1988-09-29”, “height”: “208cm”, “weight”: “108.9KG”})

其实这就是一个标准的 JavaScript 方法调用的写法而已。

接着我们调用 ctx 对象的 eval 方法并传入 js 变量，其实就是模拟执行了这句 JavaScript 代码，照理来说最终返回的就是加密字符串了。

然而，运行之后，我们可能看到这个报错：

	execjs._exceptions.ProgramError: ReferenceError: CryptoJS is not defined

很奇怪，CryptoJS 未定义？我们明明执行过 crypto-js.min.js 里面的内容了呀？

问题其实出在 crypto-js.min.js 里面，可以看到其里面声明了一个 JavaScript 的自执行方法，如图所示：

自执行方法什么意思呢？就是声明了一个方法，然后紧接着调用执行，我们可以看下这个例子：

	!(function (a, b) { console.log(“result”, a, b); })(1, 2);

这里我们先声明了一个 function，然后接收 a 和 b 两个参数，然后把内容输出出来，然后我们把这个 function 用小括号括起来，这其实就是一个方法，可以被直接调用的，怎么调用呢？后面再跟上对应的参数就好了，比如传入 1 和 2，执行结果如下：

	result 1 2

可以看到，这个自执行的方法就被执行了。

同理地，crypto-js.min.js 也符合这个格式，它接收 t 和 e 两个参数，t 就是 this，其实就是浏览器中的 window 对象，e 就是一个 function（用于定义 CryptoJS 的核心内容）。

我们再来观察下 crypto-js.min.js 开头的定义：

	“object” == typeof exports ? (module.exports = exports = e()) : “function” == typeof define && define.amd ? define([], e) : (t.CryptoJS = e());

在 Node.js 中，其实 exports 就是用来将一些对象的定义进行导出的，这里 "object" == typeof exports 其实结果就是 true，所以就执行了 module.exports = exports = e() 这段代码，这样就相当于把 e() 作为整体导出了，而这个 e() 其实就对应这后面的整个 function，function 里面定义了加密相关的各个实现，其实就指代整个加密算法库。

但是在浏览器中，其结果就不一样了，浏览器环境中并没有 exports 和 define 这两个对象。所以，上述代码在浏览器中最后执行的就是 t.CryptoJS = e() 这段代码，其实这里就是把 CryptoJS 对象挂载到 this 对象上面，而 this 就是浏览器中的全局 window 对象，后面就可以直接用了。如果我们把代码放在浏览器中运行，那是没有任何问题的。

然而，我们使用的 PyExecJS 是依赖于一个 Node.js 执行环境的，所以上述代码其实执行的是 module.exports = exports = e()，这里面并没有声明 CryptoJS 对象，也没有把 CryptoJS 挂载到全局对象里面，所以后面我们再调用 CryptoJS 就自然而然出现了未定义的错误了。

那怎么办呢？其实很简单，那我们直接声明一个 CryptoJS 变量，然后手动声明一下它的初始化不就好了吗？所以我们可以把代码稍作修改，改成如下内容：

	var CryptoJS; !(function (t, e) { CryptoJS = e(); “object” == typeof exports ? (module.exports = exports = e()) : “function” == typeof define && define.amd ? define([], e) : (t.CryptoJS = e()); })(this, function () { //… });

这里我们就首先声明了一个 CryptoJS 变量，然后直接给 CryptoJS 变量赋值给 e()，这样就完成了 CryptoJS 的初始化。

这样我们再重新运行刚才的 Python 脚本，就可以得到执行结果了：

	gQSfeqldQIJKAZHH9TzRX/exvIwb0j73b2cjXvy6PeZ3rGW6sQsL2w==

这样我们就成功得到加密字符串了，和示例网站上显示的是一模一样的，这样我们就成功模拟 JavaScript 的调用完成了某个加密算法的运行过程。

5. 总结

本节介绍了利用 PyExecJS 来模拟执行 JavaScript 的方法，结合一个案例来完成了整个的实现和问题排查的过程。本节内容还是比较重要的，以后我们如果需要模拟执行 JavaScript 就可以派得上用场。