Ein kleiner und leicht verständlicher Ausflug in die Welt der JavaScript-Programmierung, um zu zeigen, wie extrem schwierig es ist, „bösartigen“ JavaScript-Code als solchen zu erkennen
Der im Moment wohl häufigste Weg, wie versucht wird, Ihnen Malware unterzujubeln, ist per E-Mail und arbeitet mit einem zweistufigen Verfahren:
Sie bekommen eine Mail mit einem Anhang, der im wesentlichen aus einem kleinen Programm geschrieben in JavaScript besteht. Lassen Sie diesen Code laufen, lädt er die zweite Stufe, das eigentliche Schadprogramm, direkt von irgendwoher aus dem Internet herunter und bringt es zur Ausführung.
Heute gängige Antiviren-Programme versagen mehr oder weniger beim Abwehren der ersten Stufe. Sie sind nur selten in der Lage zu erkennen, dass solcher JavaScript-Code im Prinzip „bösartig“ ist: Kein Alarm, keine Warnung, keine Blockade – der Code rutscht meistens einfach so durch!
Ich möchte Ihnen heute zeigen, warum das so ist.
Nehmen wir an, eine Software soll Ihren Computer davor schützen, dass via JavaScript der Text Hackerangriff! angezeigt wird. Das folgende völlig triviale einzeilige JavaScript-Programm tut genau das und darf also nicht zur Ausführung gelangen:
alert('Hackerangriff!');
Das sieht nach einer leichten Aufgabe aus für unser Schutzprogramm: Kommt der „gefährliche“ Text irgendwo im JavaScript-Code vor, und das hier ja offensichtlich der Fall, dann Ausführung blockieren.
Was ist aber mit folgendem Code, der genauso den fraglichen Text ausgibt, bei dem dieser aber schon nicht mehr einfach so im Programmtext zu finden ist:
alert('Hacker' + 'angriff!');
Wenn Sie nun finden, dass ein paar eingestreute Plus-Zeichen doch wohl für heutige Programme keine unüberwindbare Hürde darstellen, dann sehen wir weiter:
alert('!ffirgnarekcaH'.split('').reverse().join(''));
Sie ahnen vermutlich jetzt, wo das hinführt: JavaScript ist eine vollständige und mächtige Programmiersprache, und es gibt praktisch unendlich viele Möglichkeiten, via Code einen Text zusammenzubauen, und das ist natürlich ein grosses Problem.
Das Thema Künstliche Intelligenz ist zwar momentan in aller Munde, aber Programme, die andere Programme „lesen“ und dann sagen können, was die tun, sind noch in weiter Ferne. Heute gibt es praktisch nur einen generellen Weg, um herauszufinden, was JavaScript-Code tut: Man muss ihn ausführen, und es dürfte klar sein, dass es nicht einfach ist, das auf eine ungefährliche Art zu machen.
Wenn Hacker JavaScript-Code schreiben, der Trojaner auf Ihren Computer auf Ihren Computer laden soll, gehen sie vermutlich meistens so vor, dass sie den Code zunächst ganz normal schreiben, und ihn dann einem Programm übergeben, welches die „Verschleierung“ vollautomatisch erledigt.
Solche Programme nennt man auf Englisch obfuscators. Wie weit das gehen kann, sieht man an der Demo von jjencode. Diese macht aus unserer JavaScript-Zeile in der Originalversion das folgende, vollkommen korrekte JavaScript mit gleicher Funktion:
$=~[];$={___:++$,$$$$:(![]+"")[$],__$:++$,$_$_:(![]+"")[$],_$_:++$,$_$$:({}+"")[$],$$_$:($[$]+"")[$],_$$:++$,$$$_:(!""+"")[$],$__:++$,$_$:++$,$$__:({}+"")[$],$$_:++$,$$$:++$,$___:++$,$__$:++$};$.$_=($.$_=$+"")[$.$_$]+($._$=$.$_[$.__$])+($.$$=($.$+"")[$.__$])+((!$)+"")[$._$$]+($.__=$.$_[$.$$_])+($.$=(!""+"")[$.__$])+($._=(!""+"")[$._$_])+$.$_[$.$_$]+$.__+$._$+$.$;$.$$=$.$+(!""+"")[$._$$]+$.__+$._+$.$+$.$$;$.$=($.___)[$.$_][$.$_];$.$($.$($.$$+"\""+$.$_$_+(![]+"")[$._$_]+$.$$$_+"\\"+$.__$+$.$$_+$._$_+$.__+"(\\"+$.$__+$.___+"'\\"+$.__$+$.__$+$.___+$.$_$_+$.$$__+"\\"+$.__$+$.$_$+$._$$+$.$$$_+"\\"+$.__$+$.$$_+$._$_+$.$_$_+"\\"+$.__$+$.$_$+$.$$_+"\\"+$.__$+$.$__+$.$$$+"\\"+$.__$+$.$$_+$._$_+"\\"+$.__$+$.$_$+$.__$+$.$$$$+$.$$$$+"!'\\"+$.$__+$.___+");"+"\"")())();
Weil dieser Verschleierungs-Vorgang so einfach ist und voll automatisiert in den Mail-Versende-Prozess einbindbar, sind jeweils vom gleichen Trojaner-Downloader Dutzende, wenn nicht Hunderte, von Varianten im Umlauf!