JavaScript反调试，你要知道这六项实用技巧

在此之前，我一直都在研究JavaScript相关的反调试技巧。但是当我在网上搜索相关资料时，我发现网上并没有多少关于这方面的文章，而且就算有也是非常不完整的那种。所以在这篇文章中，我打算跟大家总结一下关于JavaScript反调试技巧方面的内容。值得一提的是，其中有些方法已经被网络犯罪分子广泛应用到恶意软件之中了。

成都创新互联公司是专业的秦淮网站建设公司，秦淮接单;提供网站设计、网站制作,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行秦淮网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

对于JavaScript来说，你只需要花一点时间进行调试和分析，你就能够了解到JavaScript代码段的功能逻辑。而我们所要讨论的内容，可以给那些想要分析你JavaScript代码的人增加一定的难度。不过我们的技术跟代码混淆无关，我们主要针对的是如何给代码主动调试增加困难。

本文所要介绍的技术方法大致如下：

  1. 检测未知的执行环境(我们的代码只想在浏览器中被执行);
  2. 检测调试工具(例如DevTools);
  3. 代码完整性控制;
  4. 流完整性控制;
  5. 反模拟;

简而言之，如果我们检测到了“不正常”的情况，程序的运行流程将会改变，并跳转到伪造的代码块，并“隐藏”真正的功能代码。

一、函数重定义

这是一种最基本也是最常用的代码反调试技术了。在JavaScript中，我们可以对用于收集信息的函数进行重定义。比如说，console.log()函数可以用来收集函数和变量等信息，并将其显示在控制台中。如果我们重新定义了这个函数，我们就可以修改它的行为，并隐藏特定信息或显示伪造的信息。

我们可以直接在DevTools中运行这个函数来了解其功能：

 
 
 
    
  
  
  
  1. console.log("HelloWorld"); 
    2. 
  
  
  
  2. var fake = function() {}; 
    3. 
  
  
  
  3. window['console']['log']= fake; 
    4. 
  
  
  
  4. console.log("Youcan't see me!"); 
    5.

运行后我们将会看到：

 
 
 
    
  
  
  
  1. VM48:1 Hello World 
    2.

你会发现第二条信息并没有显示，因为我们重新定义了这个函数，即“禁用”了它原本的功能。但是我们也可以让它显示伪造的信息。比如说这样：

 
 
 
    
  
  
  
  1. console.log("Normalfunction"); 
    2. 
  
  
  
  2. //First we save a reference to the original console.log function 
    3. 
  
  
  
  3. var original = window['console']['log']; 
    4. 
  
  
  
  4. //Next we create our fake function 
    5. 
  
  
  
  5. //Basicly we check the argument and if match we call original function with otherparam. 
    6. 
  
  
  
  6. // If there is no match pass the argument to the original function 
    7. 
  
  
  
  7. var fake = function(argument) { 
    8. 
  
  
  
  8.     if (argument === "Ka0labs") { 
    9. 
  
  
  
  9.         original("Spoofed!"); 
    10. 
  
  
  
  10.     } else { 
    11. 
  
  
  
  11.         original(argument); 
    12. 
  
  
  
  12.     } 
    13. 
  
  
  
  13. } 
    14. 
  
  
  
  14. // We redefine now console.log as our fake function 
    15. 
  
  
  
  15. window['console']['log']= fake; 
    16. 
  
  
  
  16. //Then we call console.log with any argument 
    17. 
  
  
  
  17. console.log("Thisis unaltered"); 
    18. 
  
  
  
  18. //Now we should see other text in console different to "Ka0labs" 
    19. 
  
  
  
  19. console.log("Ka0labs"); 
    20. 
  
  
  
  20. //Aaaand everything still OK 
    21. 
  
  
  
  21. console.log("Byebye!"); 
    22.

如果一切正常的话：

 
 
 
    
  
  
  
  1. Normal function 
    2. 
  
  
  
  2. VM117:11 This is unaltered 
    3. 
  
  
  
  3. VM117:9 Spoofed! 
    4. 
  
  
  
  4. VM117:11 Bye bye! 
    5.

实际上，为了控制代码的执行方式，我们还能够以更加聪明的方式来修改函数的功能。比如说，我们可以基于上述代码来构建一个代码段，并重定义eval函数。我们可以把JavaScript代码传递给eval函数，接下来代码将会被计算并执行。如果我们重定义了这个函数，我们就可以运行不同的代码了：

 
 
 
    
  
  
  
  1. //Just a normal eval  
    2. 
  
  
  
  2. eval("console.log('1337')");  
    3. 
  
  
  
  3. //Now we repat the process...  
    4. 
  
  
  
  4. var original = eval;  
    5. 
  
  
  
  5. var fake = function(argument) {  
    6. 
  
  
  
  6.     // If the code to be evaluated contains1337...  
    7. 
  
  
  
  7.     if (argument.indexOf("1337") !==-1) {  
    8. 
  
  
  
  8.         // ... we just execute a different code  
    9. 
  
  
  
  9.         original("for (i = 0; i < 10;i++) { console.log(i);}");  
    10. 
  
  
  
  10.     }  
    11. 
  
  
  
  11.     else {  
    12. 
  
  
  
  12.         original(argument);  
    13. 
  
  
  
  13.     }  
    14. 
  
  
  
  14. }  
    15. 
  
  
  
  15. eval= fake;  
    16. 
  
  
  
  16. eval("console.log('Weshould see this...')");  
    17. 
  
  
  
  17. //Now we should see the execution of a for loop instead of what is expected  
    18. 
  
  
  
  18. eval("console.log('Too1337 for you!')"); 
    19.

运行结果如下：

 
 
 
    
  
  
  
  1. 1337 
    2. 
  
  
  
  2. VM146:1We should see this… 
    3. 
  
  
  
  3. VM147:10 
    4. 
  
  
  
  4. VM147:11 
    5. 
  
  
  
  5. VM147:12 
    6. 
  
  
  
  6. VM147:13 
    7. 
  
  
  
  7. VM147:14 
    8. 
  
  
  
  8. VM147:15 
    9. 
  
  
  
  9. VM147:16 
    10. 
  
  
  
  10. VM147:17 
    11. 
  
  
  
  11. VM147:18 
    12. 
  
  
  
  12. VM147:19 
    13.

正如之前所说的那样，虽然这种方法非常巧妙，但这也是一种非常基础和常见的方法，所以比较容易被检测到。

二、断点

为了帮助我们了解代码的功能，JavaScript调试工具(例如DevTools)都可以通过设置断点的方式阻止脚本代码执行，而断点也是代码调试中最基本的了。

如果你研究过调试器或者x86架构，你可能会比较熟悉0xCC指令。在JavaScript中，我们有一个名叫debugger的类似指令。当我们在代码中声明了debugger函数后，脚本代码将会在debugger指令这里停止运行。比如说：

 
 
 
    
  
  
  
  1. console.log("Seeme!"); 
    2. 
  
  
  
  2. debugger; 
    3. 
  
  
  
  3. console.log("Seeme!"); 
    4.

很多商业产品会在代码中定义一个***循环的debugger指令，不过某些浏览器会屏蔽这种代码，而有些则不会。这种方法的主要目的就是让那些想要调试你代码的人感到厌烦，因为***循环意味着代码会不断地弹出窗口来询问你是否要继续运行脚本代码：

 
 
 
    
  
  
  
  1. setTimeout(function(){while (true) {eval("debugger") 
    2.

三、时间差异

这是一种从传统反逆向技术那里借鉴过来的基于时间的反调试技巧。当脚本在DevTools等工具环境下执行时，运行速度会非常慢(时间久)，所以我们就可以根据运行时间来判断脚本当前是否正在被调试。比如说，我们可以通过测量代码中两个设置点之间的运行时间，然后用这个值作为参考，如果运行时间超过这个值，说明脚本当前在调试器中运行。

演示代码如下：

 
 
 
    
  
  
  
  1. set Interval(function(){ 
    2. 
  
  
  
  2.   var startTime = performance.now(), check,diff; 
    3. 
  
  
  
  3.   for (check = 0; check < 1000; check++){ 
    4. 
  
  
  
  4.     console.log(check); 
    5. 
  
  
  
  5.     console.clear(); 
    6. 
  
  
  
  6.   } 
    7. 
  
  
  
  7.   diff = performance.now() - startTime; 
    8. 
  
  
  
  8.   if (diff > 200){ 
    9. 
  
  
  
  9.     alert("Debugger detected!"); 
    10. 
  
  
  
  10.   } 
    11. 
  
  
  
  11. },500); 
    12.

四、DevTools检测(Chrome)

这项技术利用的是div元素中的id属性，当div元素被发送至控制台(例如console.log(div))时，浏览器会自动尝试获取其中的元素id。如果代码在调用了console.log之后又调用了getter方法，说明控制台当前正在运行。

简单的概念验证代码如下：

 
 
 
    
  
  
  
  1. let div = document.createElement('div'); 
    2. 
  
  
  
  2. let loop = setInterval(() => { 
    3. 
  
  
  
  3.     console.log(div); 
    4. 
  
  
  
  4.     console.clear(); 
    5. 
  
  
  
  5. }); 
    6. 
  
  
  
  6. Object.defineProperty(div,"id", {get: () => { 
    7. 
  
  
  
  7.     clearInterval(loop); 
    8. 
  
  
  
  8.     alert("Dev Tools detected!"); 
    9. 
  
  
  
  9. }}); 
    10.

五、隐式流完整性控制

当我们尝试对代码进行反混淆处理时，我们首先会尝试重命名某些函数或变量，但是在JavaScript中我们可以检测函数名是否被修改过，或者说我们可以直接通过堆栈跟踪来获取其原始名称或调用顺序。

arguments.callee.caller可以帮助我们创建一个堆栈跟踪来存储之前执行过的函数，演示代码如下：

 
 
 
    
  
  
  
  1. function getCallStack() { 
    2. 
  
  
  
  2.     var stack = "#", total = 0, fn =arguments.callee; 
    3. 
  
  
  
  3.     while ( (fnfn = fn.caller) ) { 
    4. 
  
  
  
  4.         stackstack = stack + "" +fn.name; 
    5. 
  
  
  
  5.         total++ 
    6. 
  
  
  
  6.     } 
    7. 
  
  
  
  7.     return stack 
    8. 
  
  
  
  8. } 
    9. 
  
  
  
  9. function test1() { 
    10. 
  
  
  
  10.     console.log(getCallStack()); 
    11. 
  
  
  
  11. } 
    12. 
  
  
  
  12. function test2() { 
    13. 
  
  
  
  13.     test1(); 
    14. 
  
  
  
  14. } 
    15. 
  
  
  
  15. function test3() { 
    16. 
  
  
  
  16.     test2(); 
    17. 
  
  
  
  17. } 
    18. 
  
  
  
  18. function test4() { 
    19. 
  
  
  
  19.     test3(); 
    20. 
  
  
  
  20. } 
    21. 
  
  
  
  21. test4(); 
    22.

注意：源代码的混淆程度越强，这个技术的效果就越好。

六、代理对象

代理对象是目前JavaScript中最有用的一个工具，这种对象可以帮助我们了解代码中的其他对象，包括修改其行为以及触发特定环境下的对象活动。比如说，我们可以创建一个嗲哩对象并跟踪每一次document.createElemen调用，然后记录下相关信息：

 
 
 
    
  
  
  
  1. const handler = { // Our hook to keep the track 
    2. 
  
  
  
  2.     apply: function (target, thisArg, args){ 
    3. 
  
  
  
  3.         console.log("Intercepted a call tocreateElement with args: " + args); 
    4. 
  
  
  
  4.         return target.apply(thisArg, args) 
    5. 
  
  
  
  5.     } 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7.   
    8. 
  
  
  
  8. document.createElement= new Proxy(document.createElement, handler) // Create our proxy object withour hook ready to intercept 
    9. 
  
  
  
  9. document.createElement('div'); 
    10.

接下来，我们可以在控制台中记录下相关参数和信息：

 
 
 
    
  
  
  
  1. VM64:3 Intercepted a call to createElement with args: div 
    2.

我们可以利用这些信息并通过拦截某些特定函数来调试代码，但是本文的主要目的是为了介绍反调试技术，那么我们如何检测“对方”是否使用了代理对象呢?其实这就是一场“猫抓老鼠”的游戏，比如说，我们可以使用相同的代码段，然后尝试调用toString方法并捕获异常：

 
 
 
    
  
  
  
  1. //Call a "virgin" createElement: 
    2. 
  
  
  
  2. try { 
    3. 
  
  
  
  3.     document.createElement.toString(); 
    4. 
  
  
  
  4. }catch(e){ 
    5. 
  
  
  
  5.     console.log("I saw your proxy!"); 
    6. 
  
  
  
  6. } 
    7.

信息如下：

 
 
 
    
  
  
  
  1. "function createElement() { [native code] }" 
    2.

但是当我们使用了代理之后：

 
 
 
    
  
  
  
  1. //Then apply the hook 
    2. 
  
  
  
  2. consthandler = { 
    3. 
  
  
  
  3.     apply: function (target, thisArg, args){ 
    4. 
  
  
  
  4.         console.log("Intercepted a call tocreateElement with args: " + args); 
    5. 
  
  
  
  5.         return target.apply(thisArg, args) 
    6. 
  
  
  
  6.     } 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8. document.createElement= new Proxy(document.createElement, handler); 
    9. 
  
  
  
  9.   
    10. 
  
  
  
  10. //Callour not-so-virgin-after-that-party createElement 
    11. 
  
  
  
  11. try { 
    12. 
  
  
  
  12.     document.createElement.toString(); 
    13. 
  
  
  
  13. }catch(e) { 
    14. 
  
  
  
  14.     console.log("I saw your proxy!"); 
    15. 
  
  
  
  15. } 
    16.

没错，我们确实可以检测到代理：

 
 
 
    
  
  
  
  1. VM391:13 I saw your proxy! 
    2.

我们还可以添加toString方法：

 
 
 
    
  
  
  
  1. const handler = { 
    2. 
  
  
  
  2.     apply: function (target, thisArg, args){ 
    3. 
  
  
  
  3.         console.log("Intercepted a call tocreateElement with args: " + args); 
    4. 
  
  
  
  4.         return target.apply(thisArg, args) 
    5. 
  
  
  
  5.     } 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7. document.createElement= new Proxy(document.createElement, handler); 
    8. 
  
  
  
  8. document.createElement= Function.prototype.toString.bind(document.createElement); //Add toString 
    9. 
  
  
  
  9. //Callour not-so-virgin-after-that-party createElement 
    10. 
  
  
  
  10. try { 
    11. 
  
  
  
  11.     document.createElement.toString(); 
    12. 
  
  
  
  12. }catch(e) { 
    13. 
  
  
  
  13.     console.log("I saw your proxy!"); 
    14. 
  
  
  
  14. } 
    15.

现在我们就没办法检测到了：

 
 
 
    
  
  
  
  1. "function createElement() { [native code] }" 
    2.

就像我说的，这就是一场“猫抓老鼠“的游戏。

分享标题：JavaScript反调试，你要知道这六项实用技巧
标题网址：http://www.shufengxianlan.com/qtweb/news22/397722.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

移动网站建设知识

行业网站建设

成都导视系统设计　　 　成都网站优化　　 　金融行业网站建设方案　　 　公司logo设计　　 　四川國際商會　　 　一元广告　　 　网络整合营销　　 　云服务器　　 　成都IDC机房托管　　 　新津网站运维　　 　轻质隔墙板　　 　成都免费建站　　 　响应式报价　　 　成都光华电信机房　　 　托管服务器　　 　成都翻译公司　　 　彭州网站建设　　 　网站建设方案　　 　网站空间　　 　网站建设报价方案