Schützen Sie clientseitigen Code und bestätigen Sie die Authentizität der Datenerfassung
Inhalt
Es ist bekannt, dass für den effizienten Schutz von Webanwendungen und Websites JavaScript für die clientseitige Datenerfassung über den Browser erforderlich ist. Dies umfasst in der Regel die Eigenschaften des Geräts und des Browsers, die Nutzereinstellungen (Fingerabdruck) und Daten, die die Nutzerinteraktion mit den Geräten widerspiegeln, wie z. B. Mausbewegungen, Berührungen und Tastendrucke (Telemetrie).
Internetsicherheitsexperten und -anbieter verarbeiten Daten mithilfe verschiedener Erkennungsmethoden (von einfachen Regeln bis hin zu erweiterten KI-Modellen), um die Wahrscheinlichkeit zu überprüfen, dass eine legitime Anfrage von einem legitimen Gerät stammt, das von einem Menschen kontrolliert wird.
Die Kombination der verschiedenen Datenpunkte hilft auch bei der Differenzierung von Nutzern und bei der Bewertung ihrer Aktivitäten im Zeitverlauf. Dies ist das Kernprinzip, das Produkte für das Bot-Management und die Betrugserkennung verwenden, um Angriffe wie Credential Stuffing, Kontoübernahmen, die missbräuchliche Erstellung von Konten und Content Scraping zu erkennen.
Datenerfassungsintegrität
Die Gewährleistung der Authentizität und Integrität der Daten ist entscheidend für die genaue Bewertung der Nutzerinteraktion mit der Website und zur Kennzeichnung von Bedrohungen. Wie kann jemand die Authentizität und Integrität der Daten bestätigen, wenn er weiß, dass alles, was clientseitig ausgeführt wird, manipuliert werden könnte?
Bei der Ausführung von clientseitigem JavaScript-Code gibt es zwei Gründe, um sicherzustellen, dass der Code gut geschützt ist.
1. Der JavaScript-Code ist Teil des geistigen Eigentums eines Unternehmens. Er muss so gut wie möglich vor Cyberkriminellen und Wettbewerbern geschützt werden.
2. Die Datenintegrität ist für ein ordnungsgemäßes Verständnis der Umgebung und ihrer Risikofaktoren entscheidend. Geschützter JavaScript stellt sicher, dass die Daten vertrauenswürdig sind, da sie wirklich durch Ausführen des Skripts erfasst und nicht manipuliert oder umgewandelt wurden.
So schützen Sie clientseitigen Code und gewährleisten die Datenauthentizität
Wie bei allen anderen Aspekten der Sicherheit gibt es keine einzige Lösung, um das Problem anzugehen. In diesem Blogbeitrag stellen wir eine Reihe von Methoden vor, die Akamai zum Schutz von JavaScript-Code, zur Durchsetzung seiner Ausführung und zur Gewährleistung der Authentizität der erfassten Daten verwendet, darunter:
- Codeverschleierung
- Datenintegritätsprüfung
- VM-Verschleierung
- Einfügung von irreführendem und zusätzlichem Code
- JavaScript-Code-Rotation
- Dynamische Feldrotation
- JavaScript-Build-Pipeline und Datenvalidierung
Sollten Sie sich dazu entschließen, ähnliche Praktiken zum Schutz Ihres eigenen Codes zu befolgen, empfehlen wir, eine Kombination dieser Methoden zu verwenden, die auf den Anforderungen Ihres Teams, Ihrer Organisation und Ihres Tech-Stacks basiert.
Codeverschleierung
Die Verschleierung ist eine der am häufigsten verwendeten Methoden zum Schutz von JavaScript-Code. Durch die Verschleierung wird es schwieriger, dem Code zu folgen und ihn zu verstehen.
Aus soliden Entwicklungspraktiken lassen sich die Empfehlungen ableiten, dass die Benennungsfunktionen und -variablen so aussagekräftig wie möglich sind und dass der Code logisch strukturiert ist, um das Debuggen und die Wartung zu erleichtern. Obwohl dies eine wertvolle Praktik ist, um Zeit und Aufwand zu reduzieren, ist sauberer Code ein einfaches Ziel für Reverse Engineering.
Wenn die Verschleierung angewendet wird, werden diese guten Entwicklungspraktiken unterbrochen, und Variablen und Funktionen mit beschreibenden Namen werden durch zufällige ersetzt. Sie können neu angeordnet und kodiert werden. Einiges der Logik kann aufgeteilt oder neu strukturiert werden. Ein Webbrowser kann den Code weiterhin ohne Probleme ausführen, und das Ergebnis ist das gleiche. Wer versucht, den Code zurückzuentwickeln, wird jedoch eine größere Herausforderung haben.
Entwickler verwenden weiterhin gut strukturierten Code für Wartungs- und Erweiterungszwecke. Sobald eine neue Version bereit ist, wird der Code vor der Freigabe durch eine Verschleierungs-Engine ausgeführt. Verschiedene kostenlose/Open-Source- oder kommerzielle Produkte wie Code Beautify, JScrambler und Digital.ai stehen zur schnellen und einfachen Verschleierung von JavaScript-Code zur Verfügung.
Abbildung 1 zeigt ein Beispiel für eine einfache JavaScript-Funktion, die häufig beim Fingerabdruck verwendet wird und zur Extraktion verschiedener Gerätemerkmale dient, vor der Verschleierung.
function getDeviceInfo() {
return {
userAgent: navigator.userAgent,
hardwareConcurrency: navigator.hardwareConcurrency || "unknown",
screenOrientation: screen.orientation.type,
};
}
Abb. 1: Der ursprüngliche Code vor der Verschleierung
Sie können sehen, wie einfach es ist, den Code in seinem ursprünglichen Zustand zu verstehen. Selbst jemand mit begrenzten Programmierkenntnissen kann den beabsichtigten Zweck verstehen und verstehen, wie der Code sein Ziel erreicht.
Abbildung 2 zeigt dieselbe JavaScript-Funktion, nachdem sie über das Code Beautify-Onlinetool ausgeführt wurde.
(function(_0xbf521e,_0x43c80b){var _0x4ad763=_0x3e09,_0x18fc85=_0xbf521e();while(!![]){try{var_0x40d2a7=parseInt(_0x4ad763(0xfc))/(0x18d1+-0xe6d+-0xa63)+-parseInt(_0x4ad763(0xf6))/(0x2*-0x7e4+0x171a+-0x750)+-parseInt(_0x4ad763(0xfb))/(-0x2e7*-0xb+0x6b*0x1f+-0x2cdf)*(parseInt(_0x4ad763(0xef))/(0x40f*-0x4+-0x897+0x18d7))+-parseInt(_0x4ad763(0xf3))/(0x3*-0xb5f+0x462+0x1dc*0x10)*(parseInt(_0x4ad763(0xf0))/(-0xb87*-0x1+0x18e8+-0x3*0xc23))+-parseInt(_0x4ad763(0xfa))/(0x2258+0x8f7+-0x2b48)*(-parseInt(_0x4ad763(0xee))/(0x3e9+-0xe93+0xab2))+parseInt(_0x4ad763(0xf1))/(0x1*-0x81e+0x525*-0x5+0x4*0x878)+parseInt(_0x4ad763(0xed))/(-0x59*-0x1f+0x779+-0x6f*0x2a);if(_0x40d2a7===_0x43c80b)break;else _0x18fc85['push'](_0x18fc85['shift']());}catch(_0x4460fc){_0x18fc85['push'](_0x18fc85['shift']());}}}(_0x1950,-0x1f*-0x38cb+0x17f2fa+-0x10aebf));function getDeviceInfo(){var _0x7a196=_0x3e09,_0x52340e={'VEDsL':_0x7a196(0xf8)};return{'userAgent':navigator[_0x7a196(0xf4)],'hardwareConcurrency':navigator[_0x7a196(0xf2)+_0x7a196(0xfd)]||_0x52340e[_0x7a196(0xf5)],'screenOrientation':screen[_0x7a196(0xf9)+'n'][_0x7a196(0xf7)]};}function _0x3e09(_0x56cbb3,_0x1167d0){var _0xddc250=_0x1950();return _0x3e09=function(_0x363b57,_0x27d74c){_0x363b57=_0x363b57-(-0x6d9+0x1316*0x1+-0xb50);var _0x1b2eec=_0xddc250[_0x363b57];return _0x1b2eec;},_0x3e09(_0x56cbb3,_0x1167d0);}function _0x1950(){var _0x1d7105=['ncurrency','20162890GviEyp','2488DLGTpn','4rCTHCm','65154TKsGUe','7673175smCphy','hardwareCo','670lOXWEG','userAgent','VEDsL','1749116JlgXKK','type','unknown','orientatio','12971xihUJr','2027775PnQRTc','487370FufNiT'];_0x1950=function(){return _0x1d7105;};return _0x1950();}
Abb. 2: Verschleierter Code (anhand von Code Beautify)
Der verschleierte Code ist eindeutig schwerer zu verstehen, und sei es nur aufgrund der Länge. Der Code mag komplex aussehen, aber die Methoden zur Umkehr dieser einfacheren Verschleierungstechniken sind vorhanden und werden von Cyberkriminellen gut verstanden. Aber zumindest erhöht dies die Messlatte, um die am wenigsten raffinierten und am wenigsten sachkundigen Cyberkriminellen abzuwehren.
Die Hälfte des Kampfes innerhalb der Cybersicherheit besteht darin, den Angreifer zu erschöpfen und/oder Ziele innerhalb Ihres Unternehmens aufgrund der wahrgenommenen oder tatsächlichen Anstrengungen, die erforderlich sind, um einen erfolgreichen Angriff zu organisieren, unattraktiv zu machen.
Datenintegritätsprüfung
Wie wir gesehen haben, ist die Codeverschleierung ein guter Ausgangspunkt, aber sie allein reicht nicht aus, um motivierte Cyberkriminelle abzuschrecken, da es Methoden und Werkzeuge zur Entschleierung gibt, um den Code in sein ursprüngliches Format umzukehren. Zusätzlich zu den Verschleierungsmethoden kann die Implementierung weiterer Code- und Datenintegritätsprüfungsfunktionen die Integrität der erfassten Informationen weiter schützen.
Code- und Datenintegritätsprüfungen sind kleine Funktionen, die an verschiedenen Stellen im gesamten Code hinzugefügt werden, um zu überprüfen, ob der vom Skript erzeugte Output tatsächlich legitim ist. Die Prüfungen verwenden in der Regel mehrere Variablen, darunter den Output von existierenden JavaScript-Kernfunktionen sowie einen eindeutigen Seed, der für eine Nutzersitzung spezifisch ist, um einen sekundären Output zu erzeugen.
Abbildung 3 ist ein Beispiel für eine Funktion, die drei Variablen als Input verwendet, die Variablen in einer einfachen mathematischen Formel und einer Hash-Funktion verwendet und das Ergebnis zurückgibt. Die Variablen a und b könnten dem Output zweier Kernfunktionen entsprechen, und die Variablen c könnten ein einzigartiger Seed sein. In diesem Beispiel müssen alle Eigenschaften numerische Werte sein.
function IntegrityCheck(a, b, c) {
const mathResult = a + b * c;
const stringResult = String(mathResult);
let hash = 0;
for (let i = 0; i < stringResult.length; i++) {
hash = (hash * 31 + stringResult.charCodeAt(i)) >>> 0;
}
return hash;
}
Abb. 3: Beispiel für Code mit mehreren Variablen für Datenintegrität
Konkret können die Eigenschaften screen.colorDepth und navigator.hardwareConcurrency, die beide numerische Werte zurückgeben, als Variablen a und b in der einfachen Funktion in Abbildung 3 verwendet werden. Diese Funktion ist eigentlich nicht auf Eigenschaften beschränkt, die einen numerischen Wert zurückgeben, da jeder Wert gehasht und in eine Ganzzahl umgewandelt werden kann, bevor er der Integritätsprüfungsfunktion zugeführt wird. Es wurde nur für den Zweck unseres einfachen Beispiels so gemacht.
Um die vielen Möglichkeiten zu verdeutlichen: Eine Integritätsprüfung kann den Output der Kernfunktion hashen, wie im Beispiel in Abbildung 4 gezeigt.
import { createHash } from 'crypto';
function hashTwoVariables(a, b) {
const concatenatedString = String(a) + String(b);
const hash = createHash('sha256').update(concatenatedString).digest('hex');
return hash;
}
Abb. 4: Beispiel-Hash-Output
Es kann Dutzende solcher kleiner Funktionen geben, von denen jede verschiedene Vorgänge durchführt und verschiedene Outputs von Kernfunktionen verbraucht, die über den gesamten Code verteilt sind, um wichtige Datenpunkte zu schützen. Als abschließende Prüfung können Sie auch die gesamte Nutzlast „signieren“, einschließlich aller Fingerabdruck- und Verhaltensdaten sowie der Ergebnisse einzelner Integritätsprüfungsfunktionen. Eine Möglichkeit hierfür ist das Hashing der gesamten Nutzlast und der Vergleich des ursprünglichen Outputs. Wenn die Hashes auf beiden Seiten übereinstimmen, gilt die Nutzlast als sicher und unverändert.
VM-Verschleierung
Diese einfachen Integritätsprüfungsfunktionen können nicht offen gelassen oder mit einfachen Verschleierungsmethoden versteckt werden. Hier kommt die fortschrittlichere VM-Verschleierungstechnik ins Spiel, wodurch es für den Cyberkriminellen schwieriger wird, zu verstehen, was hinter den Kulissen passiert und wie eine gültige Nutzlast erzeugt werden kann.
Die VM-Verschleierung wandelt Code in Bytecode für virtuelle Maschinen um: Etwas, das eine Maschine interpretieren kann, aber bei dem Cyberkriminelle nicht so einfach Reverse Engineering durchführen können.
Mehrere Anbieter bieten VM-Verschleierungsmethoden an, aber die VM-Verschleierung unterstützt nicht immer alle Arten von Funktionslogik. Wenn Sie VM-Verschleierung verwenden, befolgen Sie die Richtlinien Ihres Anbieters, und testen Sie Ihren Code gründlich in Regressionstests.
Regressionstests sind eine gute Praxis im Allgemeinen, nicht nur für die VM-Verschleierung, und sollten als Teil Ihres Sicherheitsprotokolls implementiert werden. Sie sind jedoch insbesondere in Verbindung mit der VM-Verschleierung nützlich, da der komplexe Code-Output der Methode berücksichtigt wird.
Einfügung von irreführendem und zusätzlichem Code
Um es dem Cyberkriminellen, der versucht, den Code zurückzuentwickeln, noch schwieriger zu machen, kann eine zusätzliche Schicht Code hinzugefügt werden, der bezüglich der Kernlogik keinen echten Zweck erfüllt und nur als Ablenkung wirkt. Dies soll Cyberkriminelle in die Irre führen, sie frustrieren und dazu zwingen, ihre Angriffspläne aufzugeben.
Auf ähnliche Weise können Sie die Struktur der Integritätsprüfungsfunktionen ändern, um die Entschleierung und das Reverse Engineering zu erschweren. Eine Möglichkeit, dies zu erreichen, besteht darin, mehrere strukturell unterschiedliche, aber gleichwertige Funktionen zu entwickeln, die den gleichen Output erzeugen.
Eine funktionell identische, aber strukturell unterschiedliche Funktion führt nach der VM-Verschleierung zu einer anderen Codierung der Funktion, wodurch der Code für Reverse Engineering weitaus komplexer wird.
Abbildung 5 zeigt ein Beispiel für drei solche Funktionen, die immer den gleichen Output zurückgeben, aber alle etwas anders sind.
function IntegrityCheck_1(a, b) {
return a + b * 1;
}
function IntegrityCheck_2(a, b) {
return a + 0 + b;
}
function IntegrityCheck_3(a, b, c) {
return a + b + c * 0;
}
Abb. 5: Drei Beispiele für unterschiedlichen Code, der den gleichen Output erzielt
JavaScript-Code-Rotation
Irreführender Code, fortschrittliche Verschleierung und Integritätsprüfungen sind gut, aber Cyberkriminelle können sehr hartnäckig sein – und mit genügend Zeit, Mühe und den entsprechenden Fertigkeiten lässt sich jeder stagnierende Code zurückentwickeln. Das heißt, es sei denn, wir beschränken die Gültigkeit des Skripts.
Stellen Sie sich vor, Sie könnten Tausende eindeutiger Iterationen des gleichen funktional gleichwertigen Codes generieren, wobei jede Version eine andere Integritätsprüfungsfunktion für jede neue JavaScript-Code-Version enthält. Jede Iteration wird nur 10 bis 20 Minuten lang verwendet und ist auch nur so lange gültig. Es sind Steuerelemente vorhanden, die den Client zwingen, regelmäßig eine neue Iteration neu zu laden, wodurch ältere Iterationen schnell veraltet und ungültig werden.
Ziel dieser Methode ist es, den Cyberkriminellen mit Komplexität zu überlasten und seine Effizienz zu übertreffen, sodass er keine andere Option hat, als JavaScript über einen Browser auszuführen (ohne sich im Klaren darüber zu sein, was der Code macht).
Dynamische Feldrotation
Der Code ist möglicherweise schwer zu lesen und zu entschlüsseln, aber man kann oft seinen Zweck ableiten, indem man den Output und die gesammelten und gesendeten Daten untersucht. Einige der Informationen, die an den Server gesendet werden, sind möglicherweise offensichtlich, insbesondere in Bezug auf Details wie Geräte- und Browsereigenschaften.
Es wäre jedoch schwieriger, den Intent für Funktionen abzuleiten, die einfach einen booleschen Wert zurückgeben, oder für eine Integritätsprüfungsfunktion, die eine Ganzzahl zurückgibt.
Eine Möglichkeit, die Nutzlaststruktur weniger vorhersagbar und für die Cyberkriminellen verwirrender zu machen, besteht darin, die Feldnamen zu ändern, die für die Berichterstellung der einzelnen erfassten Daten verwendet werden, sowie ihre relative Position in der Nutzlast für jede Iteration.
Wie bereits erwähnt, verfügt jede JavaScript-Iteration über eine einzigartige Reihe von Code-Integritätsprüfungen. Darüber hinaus verwendet die Nutzlast verschiedene Feldnamen, und die Position eines bestimmten Datenpunkts ändert sich mit jeder Iteration.
Die Feldnamen und ihre Positionen werden zum Zeitpunkt der JavaScript-Erstellung basierend auf einem vordefinierten Algorithmus definiert. Diesen kann der Server, der die Daten verarbeitet, auch ausführen, um die verschiedenen Informationen abzurufen, die für eine genaue Bot- und Betrugserkennung am richtigen Ort wichtig sind.
Abbildung 6 zeigt, wie jedes Feld und seine Position von einer Iteration zur anderen variieren können. Die Feldnamen dürfen nicht aussagekräftig sein, damit sie so wenig offensichtlich wie möglich sind.
Payload Iteration #1
mx01: [user-agent]
mx02: [display-mode]
mx03: [hardconcur]
mx04: [pixelDepth]
mx05: [language]
mx06: [WebGL_Rend]
mx07: [intg_chck_1]
Payload Iteration #2
yw01: [display-mode]
yw02: [intg_chck_1]
yw03: [user-agent]
yw04: [pixelDepth]
yw05: [hardconcur]
yw06: [WebGL_Rend]
yw07: [language]
Payload Iteration #3
za01: [language]
za02: [WebGL_Rend]
za03: [hardconcur]
za04: [pixelDepth]
za05: [intg_chck_1]
za06: [user-agent]
za07: [display-mode]
Abb. 6: Beispiele für Feldnamen-Iterationen
Mit nur sieben Feldern im Output (wie im obigen Beispiel) ist es leicht, die Änderung von einer Iteration zu einer anderen zu erkennen, aber stellen Sie sich vor, dass Sie dies tun, wenn Hunderte von Datenpunkten gesammelt und zurückgegeben werden.
JavaScript-Build-Pipeline und Datenvalidierung
Die verschiedenen Methoden zum Schutz des JavaScript-Codes und zur Gewährleistung der Integrität der erfassten Daten erfordern die Entwicklung einer komplexen Build-Pipeline und eines Release-Prozesses. Zunächst aktualisieren Entwickler die rohe und gut formatierte JavaScript-Datei, testen die Funktionalität und führen Regressionstests durch.
Als Nächstes werden Entwickler einen Algorithmus verwenden, um Tausende von Iterationen zu generieren, die jeweils einzigartige Versionen mit unterschiedlichen Eigenschaften erstellen:
- Datenintegritätsprüfungsfunktionen, die die Datenpunkte des Kern-JavaScripts, der verwendeten mathematischen/Hash-Funktionen und ihrer relativen Position in der Gesamtlogik variieren
- Sätze von irreführendem oder ungenutztem Code
- Nutzlast-Outputfeldnamen
- Nutzlast-Outputfeldreihenfolgen
Sobald diese eindeutigen Komponenten generiert wurden, durchläuft die JavaScript-Dateiiteration die folgenden Prozesse:
- Verwenden einer VM, um die Datenintegritätsprüfung und andere kritische Funktionen zu verschleiern
- Verschleiern des Gesamtcodes
- Hochladen der Iteration auf den Webserver
Nachdem alle Iterationen generiert und hochgeladen wurden, muss der neue JavaScript-Satz in der Produktion aktiviert werden. Diese Änderung wird mit dem Server koordiniert, auf dem die Bot- und Betrugserkennungs-Engine ausgeführt wird, die die Daten empfängt. Sie muss einen Teil des im JavaScript-Build-System verwendeten Algorithmus ausführen, um Folgendes zu ermöglichen:
- Überprüfen, ob der Client die Nutzlast der aktuellen JavaScript-Iteration sendet und keine veraltete
- Analysieren der verschiedenen Felder der Nutzlast entsprechend der JavaScript-Iteration, mit der sie generiert wurde
- Validieren der Werte der Code-Integritätsprüfung, indem entsprechende Funktionen ausgeführt werden
Das Endprodukt mit der endgültigen Verschleierung muss in der gesamten Vorproduktion einer Ende-zu-Ende-Prüfung unterzogen werden, um sicherzustellen, dass alle Komponenten synchron arbeiten und das erwartete Ergebnis liefern. Dies erfordert die Erstellung eines recht komplexen Build-Workflows für JavaScript.
Wenn die Inhalte jedoch vor neugierigen Wettbewerbern und Cyberkriminellen geschützt werden müssen und sich ihre Outputs auf die Sicherheit der Nutzer im Internet und der von ihnen besuchten Websites auswirken, dann lohnt sich diese Maßnahme.
Fazit
Der clientseitige JavaScript-Code, der zum Sammeln von Fingerabdrücken und Telemetrie verwendet wird, sowie nutzerdefinierte Logik zur Erkennung von Bots und Betrug müssen gesichert werden. Es gibt mehrere Strategien zum Schutz des Codes und der Daten, aber die Implementierung von einer oder zwei bietet nur einen geringen Schutz vor den komplexesten Cyberkriminellen.
Die Sicherung des clientseitigen Codes und seiner Nutzlast erfordert eine komplexe Strategie, die mehrere Verteidigungsebenen und Technologien umfasst, darunter Code-Verschleierung, irreführender oder unbenutzter Code, Code-Integritätsprüffunktionen in Kombination mit VM-Verschleierung, Randomisierung der Nutzlaststruktur, um sie weniger vorhersehbar zu machen, und regelmäßige Aktualisierung des Codes.
Die Gleichung in Abbildung 7 fasst die Komplexität der Gesamtkombination von Strategien zusammen, die entwickelt werden müssen, um einen effizienten Schutz zu gewährleisten.
[JS Code obfuscation[
+ Misleading code
+ unused code
+ VM Obfuscation [code integrity check]
+ unique field names
+ field relative position shift]
x [Number of unique iterations]
+ Limited version validity (10 minutes)
+ Force JS reload]
Abb. 7: Gleichung für JavaScript-Schutzstrategien
Letztendlich zwingt diese Kombination den Client zur Ausführung von JavaScript, wodurch die Möglichkeit, die Daten zu manipulieren und die Erkennungs-Engine zu umgehen, reduziert wird. Um den Entwicklungsaufwand zu begrenzen, werden kommerzielle Lösungen für einige der komplexesten Schritte, wie z. B. die VM-Verschleierung, dringend empfohlen. Einige Strategien, wie Code-Integritätsprüfungen, irreführende Code-Snippets und mehrere Iterationen, sollten jedoch intern entwickelt und gepflegt werden, um Schutz zu bieten, falls ein Entschleierer, der von Cyberkriminellen entwickelt wurde, verfügbar wird.
