js Erfahrung beim Teilen von JavaScript-Anti-Debugging-Kenntnissen

In diesem Artikel möchte ich einige JavaScript-Anti-Debugging-Techniken zusammenfassen. Es ist erwähnenswert, dass einige dieser Methoden von Cyberkriminellen häufig in Malware eingesetzt werden.

Zuvor habe ich mich mit JavaScript-bezogenen Anti-Debugging-Techniken beschäftigt. Als ich jedoch im Internet nach relevanten Informationen suchte, stellte ich fest, dass es im Internet nicht viele Artikel zu diesem Thema gab und selbst wenn, dann waren sie sehr unvollständig. In diesem Artikel möchte ich daher einige JavaScript-Anti-Debugging-Techniken zusammenfassen. Es ist erwähnenswert, dass einige dieser Methoden von Cyberkriminellen häufig in Malware eingesetzt werden.

Für JavaScript müssen Sie nur ein wenig Zeit mit dem Debuggen und Analysieren verbringen, und Sie werden in der Lage sein, die Funktionslogik des JavaScript-Codesegments zu verstehen. Was wir besprechen werden, kann es für diejenigen schwieriger machen, die Ihren JavaScript-Code analysieren möchten. Unsere Technologie hat jedoch nichts mit Code-Verschleierung zu tun. Unser Hauptaugenmerk liegt darauf, das aktive Debuggen des Codes zu erschweren.

Die in diesem Artikel vorgestellten technischen Methoden sind ungefähr wie folgt:

1. Erkennen Sie unbekannte Ausführungsumgebungen (unser Code möchte nur im Browser ausgeführt werden); . Debugging-Tools (z. B. DevTools)

5 🎜 >Kurz gesagt: Wenn wir eine „abnormale“ Situation erkennen, ändert sich der laufende Ablauf des Programms und springt zum gefälschten Codeblock und „versteckt“ den echten Funktionscode.

1. Funktionsneudefinition

Dies ist eine der grundlegendsten und am häufigsten verwendeten Code-Anti-Debugging-Techniken. In JavaScript können wir Funktionen zum Sammeln von Informationen neu definieren. Mit der Funktion console.log() können beispielsweise Informationen wie Funktionen und Variablen gesammelt und in der Konsole angezeigt werden. Wenn wir diese Funktion neu definieren, können wir ihr Verhalten ändern und bestimmte Informationen ausblenden oder gefälschte Informationen anzeigen.

Wir können diese Funktion direkt in DevTools ausführen, um ihre Funktionalität zu verstehen:

Nach dem Ausführen sehen wir:

VM48:1 Hallo Welt

Sie werden feststellen, dass die zweite Meldung nicht angezeigt wird, weil wir diese Funktion neu definiert, also ihre ursprüngliche Funktion „deaktiviert“ haben. Wir können aber auch dafür sorgen, dass gefälschte Informationen angezeigt werden. Zum Beispiel:

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

Wenn alles normal ist:

Normale Funktion

VM117:11 Dies ist unverändert

VM117 :9 Gefälscht!

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:11 Tschüss!

Tatsächlich können wir die Funktionalität der Funktion auch auf intelligentere Weise ändern, um zu steuern, wie der Code ausgeführt wird. Beispielsweise können wir einen Codeausschnitt basierend auf dem obigen Code erstellen und die Bewertungsfunktion neu definieren. Wir können JavaScript-Code an die Eval-Funktion übergeben, und der Code wird ausgewertet und ausgeführt. Wenn wir diese Funktion neu definieren, können wir anderen Code ausführen:

Die Ergebnisse sind wie folgt:

1337

VM146 :1Das sollten wir sehen...

VM147:10

//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:11

VM147:12

VM147:13

VM147:14

VM147:15

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

Wie bereits erwähnt, ist diese Methode zwar sehr clever, aber auch eine sehr einfache und verbreitete Methode, sodass sie leichter zu erkennen ist.


2. Haltepunkte


Um uns zu helfen, die Funktion des Codes zu verstehen, können JavaScript-Debugging-Tools (wie DevTools) die Ausführung von Skriptcode verhindern, indem sie Haltepunkte setzen. Haltepunkte sind auch die grundlegendsten Elemente beim Code-Debuggen.

Wenn Sie Debugger oder x86-Architektur studiert haben, sind Sie möglicherweise mit der 0xCC-Anweisung vertraut. In JavaScript haben wir eine ähnliche Direktive namens debugger. Wenn wir die Debugger-Funktion im Code deklarieren, stoppt die Ausführung des Skriptcodes bei der Debugger-Anweisung. Zum Beispiel:

Viele kommerzielle Produkte definieren eine Endlosschleifen-Debugger-Anweisung im Code, aber einige Browser blockieren diesen Code und andere nicht. T. Der Hauptzweck dieser Methode besteht darin, Leute zu ärgern, die Ihren Code debuggen möchten, da die Endlosschleife dazu führt, dass der Code ständig ein Fenster öffnet, in dem Sie gefragt werden, ob Sie den Skriptcode weiter ausführen möchten:

3. Zeitunterschied

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

Dies ist eine zeitbasierte Anti-Debugging-Technik, die der traditionellen Anti-Reverse-Technologie entlehnt ist. Wenn das Skript in einer Tool-Umgebung wie DevTools ausgeführt wird, ist die Ausführungsgeschwindigkeit sehr langsam (es dauert lange), sodass wir anhand der Laufzeit beurteilen können, ob das Skript gerade debuggt wird. Beispielsweise können wir die Laufzeit zwischen zwei festgelegten Punkten im Code messen und diesen Wert dann als Referenz verwenden. Wenn die Laufzeit diesen Wert überschreitet, wird das Skript gerade im Debugger ausgeführt.

Der Democode lautet wie folgt:

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

4. DevTools-Erkennung (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实现区块链

Das obige ist der detaillierte Inhalt vonjs Erfahrung beim Teilen von JavaScript-Anti-Debugging-Kenntnissen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!