js expérience partage de compétences anti-débogage JavaScript

Dans cet article, je compte résumer avec vous quelques techniques d'anti-débogage JavaScript. Il convient de mentionner que certaines de ces méthodes ont été largement utilisées par les cybercriminels dans les logiciels malveillants. Les amis dans le besoin peuvent s'y référer

Avant cela, j'ai étudié les techniques anti-débogage liées à JavaScript. Mais lorsque j’ai recherché des informations pertinentes sur Internet, j’ai découvert qu’il n’y avait pas beaucoup d’articles à ce sujet sur Internet, et même s’il y en avait, ils étaient très incomplets. Ainsi, dans cet article, je compte résumer avec vous quelques techniques d’anti-débogage JavaScript. Il convient de mentionner que certaines de ces méthodes ont été largement utilisées par les cybercriminels dans le cadre de logiciels malveillants.

Pour JavaScript, il vous suffit de passer un peu de temps au débogage et à l'analyse, et vous serez en mesure de comprendre la logique fonctionnelle du segment de code JavaScript. Ce dont nous allons discuter peut rendre la tâche plus difficile pour ceux qui souhaitent analyser votre code JavaScript. Cependant, notre technologie n’a rien à voir avec l’obscurcissement du code. Notre objectif principal est de rendre le débogage actif du code plus difficile.

Les méthodes techniques présentées dans cet article sont à peu près les suivantes :

1. Détecter les environnements d'exécution inconnus (notre code ne veut être exécuté que dans le navigateur) ; . Détecter les outils de débogage (tels que DevTools) ;

3. Contrôle de l'intégrité du code

En bref, si nous détectons une situation « anormale », le déroulement du programme changera et passera au faux bloc de code et « cachera » le vrai code fonctionnel.

1. Redéfinition des fonctions

C'est l'une des techniques d'anti-débogage de code les plus basiques et les plus couramment utilisées. En JavaScript, nous pouvons redéfinir les fonctions utilisées pour collecter des informations. Par exemple, la fonction console.log() peut être utilisée pour collecter des informations telles que des fonctions et des variables et les afficher dans la console. Si nous redéfinissons cette fonction, nous pouvons modifier son comportement et masquer des informations spécifiques ou afficher de fausses informations.

Nous pouvons exécuter cette fonction directement dans DevTools pour comprendre ses fonctionnalités :

Après l'exécution, nous verrons :

VM48:1 Hello World

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

Vous constaterez que le deuxième message ne s'affiche pas car nous avons redéfini cette fonction, c'est-à-dire "désactivé" sa fonction d'origine. Mais on peut aussi lui faire afficher de fausses informations. Par exemple :

Si tout est normal :

Fonction normale

VM117:11 Ceci n'est pas modifié

console.log("Normalfunction");
//First we save a reference to the original console.log function
var original = window['console']['log'];
//Next we create our fake function
//Basicly we check the argument and if match we call original function with otherparam.
// If there is no match pass the argument to the original function
var fake = function(argument) {
  if (argument === "Ka0labs") {
    original("Spoofed!");
  } else {
    original(argument);
  }
}
// We redefine now console.log as our fake function
window['console']['log']= fake;
//Then we call console.log with any argument
console.log("Thisis unaltered");
//Now we should see other text in console different to "Ka0labs"
console.log("Ka0labs");
//Aaaand everything still OK
console.log("Byebye!");

VM117 :9 Spoofed !

VM117:11 Bye bye !

En fait, afin de contrôler la façon dont le code est exécuté, nous pouvons également modifier la fonctionnalité de la fonction de manière plus intelligente. Par exemple, nous pouvons créer un extrait de code basé sur le code ci-dessus et redéfinir la fonction eval. Nous pouvons transmettre du code JavaScript à la fonction eval, et le code sera évalué et exécuté. Si nous redéfinissons cette fonction, nous pouvons exécuter du code différent :

Les résultats sont les suivants :

1337

VM146 :1Nous devrions voir ça…

//Just a normal eval
eval("console.log('1337')");
//Now we repat the process...
var original = eval;
var fake = function(argument) {
  // If the code to be evaluated contains1337...
  if (argument.indexOf("1337") !==-1) {
    // ... we just execute a different code
    original("for (i = 0; i < 10;i++) { console.log(i);}");
  }
  else {
    original(argument);
  }
}
eval= fake;
eval("console.log(&#39;Weshould see this...&#39;)");
//Now we should see the execution of a for loop instead of what is expected
eval("console.log(&#39;Too1337 for you!&#39;)");

VM147:10

VM147:11

VM147:12

VM147:13

VM147:14

VM147:15
VM147 :16
VM147:17
VM147:18
VM147:19

Comme dit précédemment, bien que cette méthode soit très intelligente, c'est aussi une méthode très basique et courante, elle est donc plus facile à détecter. .


2. Points d'arrêt

Afin de nous aider à comprendre la fonction du code, les outils de débogage JavaScript (tels que DevTools) peuvent empêcher l'exécution du code de script en définissant des points d'arrêt. Les points d'arrêt sont également les éléments les plus élémentaires du débogage de code.

Si vous avez étudié les débogueurs ou l'architecture x86, vous connaissez peut-être l'instruction 0xCC. En JavaScript, nous avons une directive similaire appelée débogueur. Lorsque nous déclarons la fonction du débogueur dans le code, le code du script cessera de s'exécuter à l'instruction du débogueur. Par exemple :

De nombreux produits commerciaux définiront une instruction de débogueur de boucle infinie dans le code, mais certains navigateurs bloqueront ce code et d'autres le feront. t. Le but principal de cette méthode est d'ennuyer les personnes qui souhaitent déboguer votre code, car la boucle infinie signifie que le code affichera constamment une fenêtre vous demandant si vous souhaitez continuer à exécuter le code du script :

console.log("Seeme!");
debugger;
console.log("Seeme!");

3. Décalage horaire

Il s'agit d'une technique anti-débogage basée sur le temps empruntée à la technologie anti-retour traditionnelle. Lorsque le script est exécuté dans un environnement d'outils tel que DevTools, la vitesse d'exécution sera très lente (cela prend beaucoup de temps), nous pouvons donc juger si le script est actuellement en cours de débogage en fonction du temps d'exécution. Par exemple, nous pouvons mesurer le temps d'exécution entre deux points de consigne dans le code, puis utiliser cette valeur comme référence. Si le temps d'exécution dépasse cette valeur, le script est actuellement en cours d'exécution dans le débogueur.

setTimeout(function(){while (true) {eval("debugger")

Le code de démonstration est le suivant :

4. Détection DevTools (Chrome)

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

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

let p = document.createElement('p');
let loop = setInterval(() => {
  console.log(p);
  console.clear();
});
Object.defineProperty(p,"id", {get: () => {
  clearInterval(loop);
  alert("Dev Tools detected!");
}});

五、隐式流完整性控制

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

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

function getCallStack() {
  var stack = "#", total = 0, fn =arguments.callee;
  while ( (fn = fn.caller) ) {
    stack = stack + "" +fn.name;
    total++
  }
  return stack
}
function test1() {
  console.log(getCallStack());
}
function test2() {
  test1();
}
function test3() {
  test2();
}
function test4() {
  test3();
}
test4();

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

六、代理对象

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

const handler = { // Our hook to keep the track
  apply: function (target, thisArg, args){
    console.log("Intercepted a call tocreateElement with args: " + args);
    return target.apply(thisArg, args)
  }
}
 
document.createElement= new Proxy(document.createElement, handler) // Create our proxy object withour hook ready to intercept
document.createElement('p');

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

VM64:3 Intercepted a call to createElement with args: p

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

//Call a "virgin" createElement:
try {
  document.createElement.toString();
}catch(e){
  console.log("I saw your proxy!");
}

信息如下：

"function createElement() { [native code] }"

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

//Then apply the hook
consthandler = {
  apply: function (target, thisArg, args){
    console.log("Intercepted a call tocreateElement with args: " + args);
    return target.apply(thisArg, args)
  }
}
document.createElement= new Proxy(document.createElement, handler);
 
//Callour not-so-virgin-after-that-party createElement
try {
  document.createElement.toString();
}catch(e) {
  console.log("I saw your proxy!");
}

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

VM391:13 I saw your proxy!

我们还可以添加toString方法：

const handler = {
  apply: function (target, thisArg, args){
    console.log("Intercepted a call tocreateElement with args: " + args);
    return target.apply(thisArg, args)
  }
}
document.createElement= new Proxy(document.createElement, handler);
document.createElement= Function.prototype.toString.bind(document.createElement); //Add toString
//Callour not-so-virgin-after-that-party createElement
try {
  document.createElement.toString();
}catch(e) {
  console.log("I saw your proxy!");
}

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

"function createElement() { [native code] }"

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

上面是我整理给大家的，希望今后会对大家有帮助。

相关文章：

解决Vue.js 2.0 有时双向绑定img src属性失败的问题

iview table render集成switch开关的实例

JavaScript实现区块链

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!