Quelltexte mit Javascript schützen
Diebstahlschutz für Code
Schutz mit Einschränkungen
Quelltexte mit Javascript schützen
Jeder, der selbst entwickelt, kennt das Problem: Fremde klauen den Code, an dem man stundenlang gearbeitet hat, und geben ihn als den eigenen aus. Dem kann durch Codierung des Quelltextes abgeholfen werden.
Bei der Verschlüsselung von Quelltext gibt es mehrere Techniken, die von sehr einfach – und ebenso einfach zu entschlüsseln – bis sehr kompliziert reichen. Im Folgenden sollen einige Methoden vorgestellt werden, wobei zwischen Verschlüsselung des Javascript-Quelltextes und Verschlüsselung des gesamten Quellcodes (HTML, CSS, Javascript) unterschieden werden sollte. Je nach dem Einzelfall ist eine Variante eher für das eine beziehungsweise das andere geeignet.
Allgemein genommen funktionieren aber alle vorgestellten Techniken nach dem gleichen Prinzip: Der Code ist verschlüsselt in der Datei gespeichert, wird beim Aufruf der Seite entschlüsselt und in das Dokument geschrieben. Sieht man sich den Quelltext an, wird nur der originale, verschlüsselte Quelltext und nicht der entschlüsselte Code der Webseite angezeigt.
Da bei jeder Codierung beziehungsweise Decodierung letztlich ein für den Browser darstellbares Ergebnis entstehen muss, ist es im Grunde unmöglich, den Code so zu verschlüsseln, dass ihn in keinem Fall jemand knacken kann. Vielmehr ist es für relativ erfahrene Programmierer meist ein Leichtes, den Code zu enttarnen. Dennoch sollte bedacht werden, dass die meisten Code-Diebe schon allein beim Anblick von scheinbar wirren Schriftfetzen relativ schnell die Lust am Kopieren verlieren werden.
Einfache Varianten
Quelltexte mit Javascript schützen
Die einfachste aller Varianten ist das bloße Einfügen von Leerzeilen vor dem gesamten Quelltext. Sieht ein Code-Dieb nach dem Quelltext, wird er mit einer leeren Seite überrascht. Die meisten übersehen dabei die Scrollbars, die den weiter unten gelegenen Text verbergen.
Diese nächste Möglichkeit ist ebenfalls eine sehr einfache Angelegenheit. Das Ganze basiert darauf, dass dem Dieb der Zugriff auf den Quelltext verwehrt wird. Dazu müssen folgende Dinge getan werden:
– rechte Maustaste ausschalten (Kontexmenü)
– Menüleiste ausblenden beziehungsweise nicht für die eigentliche Datei verwendbar machen
– [Strg]-Taste verhindern (Shortcuts)
Die rechte Maustaste wird mit folgendem Skript blockiert:
...
Die Menüleiste wird am besten dadurch ausgeschaltet oder unschädlich gemacht, dass entweder ein neues Fenster geöffnet wird, welches diese nicht enthält (window.open(....... , ......., ?menubar=false?)), oder dass die Seite nur innerhalb eines Frames angezeigt werden kann:
if(self == top){window.location.href = 'frameset.htm';};
Das Ausschalten der [Strg]-Taste kann mit folgendem Skript hervorgerufen werden:
...
Beachten Sie, dass es zwar recht einfach umzusetzen und sicher auch recht hilfreich ist, diese Variante zu verwenden – in Programmiererkreisen gilt diese Methode jedoch als sehr unbeliebt. Von den meisten wird sie sogar gehasst, da sie den Zugriff auf andere wichtige Funktionen versperrt. Sie sollten diese Variante also mit Bedacht einsetzen.
Escape-Variante
Quelltexte mit Javascript schützen
Ein etwas bessere Variante ist das Verschlüsseln der Sonderzeichen mit Hilfe der Escape-Methode. Diese ersetzt sämtliche Sonderzeichen eines Strings durch deren Unicode-Zeichenfolgen. Der Quelltext wird zuvor mit dieser Methode verschlüsselt und in einer Variablen gespeichert. Codieren Sie:
alterText = 'abcdefg';
neuerText = escape(alterText);
Die Ausgabe wird wie folgt ohne weitere darzustellende Elemente in die Seite eingebunden. Mit der Unescape-Methode wird der Code wieder entschlüsselt. Die Variable versch enthält im Beispiel den codierten Quelltext:
Zeichenliste-Variante
Quelltexte mit Javascript schützen
Eine weitere Variante ist die Verschlüsselung aller Zeichen mit Hilfe einer Zeichenliste. Dazu wird zuvor ein String angelegt, der alle Zeichen in einer (beliebigen) Reihenfolge enthält. Außerdem müssen die Sonderzeichen (!, §, $, %, &, /, (, ), =, ?, …) und Steuerzeichen (\n, \t, \r, \b, \f, …) enthalten sein Das Prinzip ist dann wie folgt: Der zu codierende beziehungsweise decodierende String wird von vorn bis hinten durchlaufen.
Dabei wird zu jedem Zeichen die Stelle gesucht, an der dieses in der Zeichenliste enthalten ist. Durch eine eingegebene oder vorher gespeicherte Zahl wird die Stelle erhöht und statt des originalen Zeichens das Zeichen ausgegeben, das der neuen, erhöhten Stelle in der Zeichenliste entspricht. Zusätzlich kommt noch das Codieren durch die Escape-Variante hinzu. Diese ist unbedingt notwendig, da sonst Fehler auftreten können:
var liste = '1234567890ß´`qwertzuiopü+#äölkjhgfds\?ayxcvbnm'+ ',.>-<*~_:;|µ!\\?§$%&/()=?QWERTZUIOPÜÄÖLKJHGFDS'+ 'AYXCVBNM@\n\t\r\b\f';
var x = 122;
function codieren(s)
{
res = '';
for(i=0; i
a = s.substr(i,1);
b = liste.indexOf(a)+x;
while(b > liste.length){b = b-liste.length;}
res += liste.substr(b,1);
}
return(escape(res));
}
Zur Ausgabe wird statt dem Erhöhen der Stellenzahl diese einfach subtrahiert. Der zuvor codierte Quelltext wird wiederum in einer Variablen eingebunden. Außerdem wird eine Geheimzahl abgefragt. Diese bestimmt den Wert, um wie viele Stellen ein Zeichen subtrahiert werden soll:
Neben dem Vertauschen der Buchstaben durch einfaches Addieren beziehungsweise Subtrahieren gibt es eine Reihe weiterer Möglichkeiten. Fast alle mathematischen oder bitweisen Operatoren können hier zum Einsatz kommen.
Base-64-Variante
Quelltexte mit Javascript schützen
Eines der bekanntesten Verfahren zum Ver- und Entschlüsseln ist Base 64. Es wird unter anderem zum Beispiel bei HTTP-Passwörtern verwendet. Das Grundprinzip ist ähnlich der oben beschriebenen Variante mit Zeichenliste: Mit Hilfe eines Zeichensatzes werden die Buchstaben so verdreht, dass ein neuer String entsteht. Der Vorteil dabei ist, dass die resultierenden Strings meist kürzer als die originalen unverschlüsselten sind. Codiert wird wie folgt:
var base64s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcd'+ 'efghijklmnopqrstuvwxyz0123456789+/';
function encode(decStr)
{
var bits;
var dual;
var i = 0;
var encOut = '';
while(decStr.length >= i + 3)
{
bits = (decStr.charCodeAt(i++) & 0xff) <<16 | (decStr.charCodeAt(i++) & 0xff) <<8 | decStr.charCodeAt(i++) & 0xff;
encOut += base64s.charAt((bits & 0x00fc0000) >>18) + base64s.charAt( (bits & 0x0003f000) >>12) + base64s.charAt((bits & 0x00000fc0) >> 6) + base64s.charAt((bits & 0x0000003f));
}
if(decStr.length -i > 0 && decStr.length -i < 3)
{
dual = Boolean(decStr.length -i -1);
bits = ((decStr.charCodeAt(i++) & 0xff) <<16) | (dual ? (decStr.charCodeAt(i) & 0xff) <<8 : 0);
encOut += base64s.charAt((bits & 0x00fc0000) >>18) + base64s.charAt((bits & 0x0003f000) >>12) + (dual ? base64s.charAt((bits & 0x00000fc0) >>6) : '=') + '=';
}
return(encOut);
}
Der codierte String sollte zusätzlich noch mit escape() behandelt werden. Das Decodieren wird wie folgt vorgenommen:
var base64s = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabc'+ 'defghijklmnopqrstuvwxyz0123456789+/';
function decode(encStr)
{
var bits;
var decOut = ??;
var i = 0;
for(; i
bits = (base64s.indexOf(encStr.charAt(i)) & 0xff) <<18 | base64s.indexOf (encStr.charAt(i +1)) & 0xff) <<12 | (base64s.indexOf(encStr.charAt(i +2)) & 0xff) << 6 | base64s.indexOf(encStr.charAt(i +3)) & 0xff;
decOut += String.fromCharCode((bits & 0xff0000) >>16, (bits & 0xff00) >>8, bits & 0xff);
}
if(encStr.charCodeAt(i -2) == 61)
{
return(decOut.substring(0, decOut.length -2));
}
else if(encStr.charCodeAt(i -1) == 61)
{
return(decOut.substring(0, decOut.length -1));
}
else {return(decOut)};
}
Eine sehr sichere Variante der Verschlüsselung ist die Zuhilfenahme von Software, die speziell dafür ausgelegt ist, wie zum Beispiel der Windows Script Encoder von Microsoft.