Manipulation durch clientseitiges AddOn auf eigener Webseite erkennen

Hier wäre "Client" richtiger gewesen.

Und es geht ja genau darum, dass die Webseite absolut keine Werbung enthält und dass die Manipulationen auf der Clientseite erkannt werden sollten. Allerdings ist es bisher unbekannt, welches AddOn oder Fremdsoftware das im Browser verursacht.

Hallo Michi (Namensvetter übrigens ;) ),

Der Gedanke ist ja so: Es gibt inzwischen etliche Webseiten, die Werbung enthalten und davon leben. Dort wird zunehmend auch erkannt, wenn z.B. AdBlocker im Browser aktiv sind und zeigen einem dann entweder den Mittelfinger, bis der AdBlocker deaktiviert wurde oder reduzieren ihr Angebot, zumindest aber geben diese Webseiten dann einen Hinweis ala "Du hast einen AdBlocker aktiviert und wir verdienen nichts mehr..."

Jetzt also den Gedanken völlig umkehren: Erkennen, dass ein AddOn Werbung einblendet, die auf der Webseite unerwünscht ist, weil diese werbefrei etc. ist. Dann eben einen Hinweis einblenden, dass das eben von der Webseite nicht gewollt ist und das auch (bei SSL) ein Sicherheitsrisiko darstellt.

Im Prinzip also irgendeine Methode, die vielleicht über eine Prüfsumme über den gesendeten Inhalt und dem tatsächlich im Browser angezeigten Inhalt eine Manipulation feststellt und dann wanrt... Aber keine Ahnung, vielleicht hab ich sogar just ne Lösung gefunden ;)

Grüße, Michael

Mir geht es ja ausschliesslich um einen Hinweis an den Browser zu schicken, dass die Webseite nicht dem entspricht, was der Server gesendet hat. Es ist natürlich klar, dass damit dem besucher nicht vorgeschrieben werden soll, was er darf oder nicht. Reicht ja, wenn das die AdBlocker-Blocker tun ;)

Danke MrTux,

im Prinzip gebe ich Dir vollkommen Recht. Mich irritierte vor allem an der ganzen Geschichte die Rückfrage eines Users, ob neuerdings Werbung auf der Webseite eingebaut sei. Ist natürlich nicht der Fall und erschwerend kam hinzu, dass der User nicht am eigenen PC saß, ergo dadurch verunsichert wurde. Eben diese Unsicherheit wurde instinktiv zunächst gegenüber dem Webseitenbetreiber geäussert und meine Überlegung war gleich: Wieviele User bekommen unwissendlich manipulierte Ansichten der Webseite angezeigt und sagen eben nichts?! Auch wenn ich einem derartigen AddOn keine bösen Absichten unterstellen will, so kann jedoch clientseitig eine Webseite derart manipuliert werden, dass z.B. Texte ihren Sinn verändern oder wie hier eben Werbung auf einer werbefreien Seite eingeblendet werden bzw. das Aussehen der Webseite stören.

Daher war auch mein nächster Gedanke: Vielleicht gibt es bereits irgendwelche Methoden, derartige Manipulationen zu erkennen und dazu fiel mir spontan ein, dass Checksummen über den gesendeten Inhalt und dem tatsächlich angezeigten Content verglichen werden könnten, zumindest als sehr rudimentäre Möglichkeit, um dem User ggf. einen entsprechenden Hinweis einzublenden...

Grüße, Michael

"Die betroffene Webseite" ist hier nahezu irrelevant, weil es im Prinzip jede Webseite betreffen kann. Du kannst davon ausgehen, dass die Webseite 100%ig keine Werbung oder Schadcode enthält und diese Werbung wurde auch auf keinem anderen PC gesehen. Es ist ein rein clientseitiges Problem, weil dort eben ein entsprechendes AddOn oder andere Fremdsoftware (vielleicht auch unerwünscht oder unbekannt) installiert wurde.

Stell Dir einfach mal vor, Du gehst auf eine Webseite namens "bestattungen.org" und irgendein AddOn sorgt dafür, dass in dem Text "Wir bieten Ihnen Bestattungen im Sarg oder in einer hochwertigen Urne aus Glaskeramik an" und das Wort "Urne" in dem Text wird mal eben durch "Urne" ausgetauscht. Das ist jetzt ein simples Beispiel, was aber m.E. veranschaulicht, worin das Problem liegen kann...

Grüße, Michael

??? Nett, wenn Du die Lösung siehst, ich nicht!

Ähm, irgendwie fühl ich mich jetzt ein wenig verschaukelt. Ein "nur theoretisch" ist gleichbedeutend mit "ja klar kann man, aber habe keine Lust drauf". Mag ja für Dich eine zufriedenstellende Lösung sein, ist es für mich aber nicht! Mag ja auch sein, dass es Dir egal ist, wenn Webseiten beliebig und unkontrollierbar manipulierbar sind, ich sehe darin durchaus eine Gefahr drin. Aber vielleicht hat auch nur einer von uns beiden nicht verstanden, wozu eigentlich das Internet gedacht ist.

Hallo eisbein und Danke für Deine Antwort ;)

Administrativ habe ich ja keinen Einfluss auf den Client, klar. Erzieherisch sollte das auch nicht sein, auch klar. Warum der Wunsch dennoch nur ein Wunsch bleiben sollte, ist nicht ganz nachvollziehbar. In der Praxis existiert bereits der umgekehrte Weg, nämlich wenn Ad-Blocker Werbung unterdrücken, melden dies manche Webseiten bzw. reagieren darauf.

Was mir evtl. schon weiterhelfen könnte: Du schriebst: "... besagte AddOns schfreiben den HTML-Code _vor_ dem Anzeigen um". Bedeutet das nicht im Umkehrschluss, dass wenn der Server tatsächlich eine Checksumme über den gesendeten Content bereit stellt und dann auf der Clientseite mittels Javascript im document.ready() ebenfalls eine Prüfsumme bildet und mit der gesendeten vergleicht, dass dann diese Manipulation feststellbar sein müsste? Mir fehlt es leider an der entscheidenen Info, welches AddOn beispielsweise derartige Werbung einblendet, um eben das testen zu können. Hast Du vielleicht noch etwas in der Richtung in Erinnerung?

Beim ersten Aufruf der Webseite wird der Content mit ausgeliefert, danach aber wird tatsächlich jeglicher weitere Content dynamisch nachgeladen. Ich habe leider keine infos vorliegen, ob die Veränderung nur beim ersten Aufruf der Webseite stattfand oder generell. Sollte das wirklich nur beim statischen Inhalt der Fall sein, dann wäre ja auch noch ein Workaround denkbar: Seite ausliefern und den Inhalt sofort dynamisch erneut nachladen. Das ginge immerhin blitzschnell und würde auf diese Weise das Crawlen der Webseite nicht unmöglich machen.

Texte als Grafiken zu übertragen bewirkt bei mir sicher auch nur ein Aufrollen der Fußnägel ;)

Grüße, Michael

Ich will es ja nicht unterbinden, sondern erkennen ;)

Nun, ich habe mich zwischenzeitlich auf die Suche gemacht und ein AddOn gefunden, das zunächst vom User gewollte Manipulationen im Quellcode einer Webseite vornimmt, eben genau das manuell macht, was offensichtlich die Software ebenso machte, die auf dem Client ungewollt oder zumindets unbewusst installiert wurde:

Request wird an den Server gesendet, HTML-Quellcode wird als Antwort gesendet, manipuliert und dann im Browser angezeigt.

Zusätzlich kann in dem AddOn eingestellt werden, dass der bereits im Browser angezeigte Quellcode auch zyklisch erneut manipuliert werden kann. Damit werden halt auch dynamisch nachgeladene Inhalte ebenso für die Manipulation erfasst.

Und genau da ist des Pudels Kern: Eine derartige Software kann sowohl für den User sichtbare Elemente verändern wie aber auch zunächst nicht Sichtbares, wie z.B. Links modifizieren oder eben Texte gegen Links austauschen etc. Wenn der User nicht weiss, dass ein beliebiges AddOn freiwillig oder auch nicht auf dem Client installiert ist, welches aufgerufene Webseiten manipuliert, muss dieser zunächst glauben, dass die webseite exakt so dargestellt wird, wie sie vom Server ausgeliefert wurde. Schliesslich kann er die Veränderungen ja nicht feststellen.

Hier sollte eben die Mimik einsetzen, die dem User ggf. anzeigt, dass die Webseite nicht so dargestellt wird, wie sie vom Server gesendet wurde.

Ja, Voraussetzung ist allemale, dass Javascript aktiviert ist (sonst könnten ja auch dynamische Inhalte nicht geladen werden). Bei den meisten Clients dürfte das auch der Fall sein, da fast keine Webseite mehr ohne Javascript auskommt.

Bisheriger Lösungsansatz sieht wie folgt aus:

Im Wesentlichen gibt es vor allem zwei HTML-Tags, die beliebte Ziele von Manipulationen sein dürften: P- und A-Tags. In HTML5 erlauben diese ein data-* -Attribut. Serverseitig werden bei diesen - wenn sie relevant sind - ein data-md5="value" mit auf den Weg gegeben, falls erforderlich eben auch bei anderen Elementen, also beliebig erweiterbar.

Clientseitig wird nach dem document.ready eine Funktion checkmanipulated() mit einem setTimeout oder setInterval aufgerufen, dass das Dokument auf Elemente mit dem Attribut data-md5 durchsucht, seinerseits das MD5 errechnet und mit dem angegebenen Wert vergleicht. Stellt es einen Unterschied fest oder stellt es fest, dass dieses Attribut gänzlich fehlt (weil irgendwo muss mindestens einmal eines vorkommen), dann meldet es dem User einen Hinweis ala "Es wurde festgestellt, dass die angezeigte Webseite nicht mit der vom Server gesendeten Webseite identisch ist!"

So, das ist jetzt ein sehr ins Unreine formulierter Gedankengang, der aber immer dann funktionieren dürfte, wenn auf dem Client keine Software installiert wurde, die genau dieses Verfahren torpedieren soll.

Ich werde das erstmal im stillen Kämmerlein ausprobieren und auf Tauglichkeit testen, dann trete ich auch gerne den Beweis an, dass "nur theoretisch" praktisch umsetzbar ist, wenn man das nur will.

@mrtux: Um Deine Frage zumindest hypotetisch zu beantworten: ich bin vor über 35 Jahren in die Softwareentwicklung eingestiegen, Schwerpunkte waren meist Datenbanken und Analysen. Vor rund 20 Jahren kamen dann alle möglichen Dinge rund ums Internet dazu. Bei der jetzigen Fragestellung geht es aber um ein Projekt, dessen Webseite ich vor knapp 16 Jahren aus dem Boden gestampft habe. Da hege ich also ein rein privates Interesse und da wird manches eben möglich, was man unter ökologischen Aspekten sonst vielleicht eher verwerfen würde.

Hier das funktionierende Ergebnis eines "_nur_ theoretisch möglichen" Test-Scripts, was exakt Manipulationen auf der Clientseite erkennt und meldet. Und es funktioniert tatsächlich auch praktisch! Es ist sicherlich fürchterlich rudimentär, aber lieber ein bisschen Sicherheit als absolut garkeine!

[code]
<html>
<head>
<title>Savepage-Test</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body>
<h3>Savepage-Test</h3>
<p>Dies ist ein beliebiger Text, der nicht gesichert ist und daher auch keine Prüfsumme enthält.</p>
<?php
echo p_save("Hingegen ist dieser Absatz mit einer Prüfsumme versehen, enthält jedoch kein Wort, welches manipuliert wird.");
echo p_save("Allerdings wird diese Zeile im Code verändert und löst eine Meldung aus, weil es das im AddOn definierte Schlüsselwort enthält...");

function p_save($text) {
$md5 = md5($text);
echo '<p data-md5="'.$md5.'">'.$text.'</p>';
}
?>
<br><br>
<input type="button" value="prüfen" onclick="checkmanipulated();">
<br>
</body>
<script>

function checkmanipulated(){
var a = document.querySelectorAll('[data-md5]');
for (var i in a) if (a.hasOwnProperty(i)) {
var m = md5(a[i].innerHTML);
var x = a[i].getAttribute('data-md5');
if (m != x) {
alert('Absatz '+i+ ': '+m+' - '+x);
break;
}
}
}

;(function(root, undefined) {
'use strict';

var NODE_JS = typeof(module) != 'undefined';
if(NODE_JS) {
root = global;
if(root.JS_MD5_TEST) {
root.navigator = { userAgent: 'Firefox'};
}
}
var ARRAY_BUFFER = !root.JS_MD5_TEST && typeof(ArrayBuffer) != 'undefined';
var HEX_CHARS = '0123456789abcdef'.split('');
var EXTRA = [128, 32768, 8388608, -2147483648];
var SHIFT = [0, 8, 16, 24];

var blocks = , buffer8;
if(ARRAY_BUFFER) {
var buffer = new ArrayBuffer(68);
buffer8 = new Uint8Array(buffer);
blocks = new Uint32Array(buffer);
}

var md5 = function(message) {
var notString = typeof(message) != 'string';
if(notString && message.constructor == ArrayBuffer) {
message = new Uint8Array(message);
}

var h0, h1, h2, h3, a, b, c, d, bc, da, code, first = true, end = false,
index = 0, i, start = 0, bytes = 0, length = message.length;
blocks[16] = 0;
do {
blocks = blocks[16];
blocks[16] = blocks[1] = blocks[2] = blocks[3] =
blocks[4] = blocks[5] = blocks[6] = blocks[7] =
blocks[8] = blocks[9] = blocks[10] = blocks[11] =
blocks[12] = blocks[13] = blocks[14] = blocks[15] = 0;
if(notString) {
if(ARRAY_BUFFER) {
for (i = start;index < length && i < 64; ++index) {
buffer8[i++] = message[index];
}
} else {
for (i = start;index < length && i < 64; ++index) {
blocks[i >> 2] |= message[index] << SHIFT[i++ & 3];
}
}
} else {
if(ARRAY_BUFFER) {
for (i = start;index < length && i < 64; ++index) {
code = message.charCodeAt(index);
if (code < 0x80) {
buffer8[i++] = code;
} else if (code < 0x800) {
buffer8[i++] = 0xc0 | (code >> 6);
buffer8[i++] = 0x80 | (code & 0x3f);
buffer8[i++] = 0xe0 | (code >> 12);
buffer8[i++] = 0x80 | ((code >> 6) & 0x3f);
buffer8[i++] = 0x80 | (code & 0x3f);
} else {
code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
buffer8[i++] = 0xf0 | (code >> 18);
buffer8[i++] = 0x80 | ((code >> 12) & 0x3f);
buffer8[i++] = 0x80 | ((code >> 6) & 0x3f);
buffer8[i++] = 0x80 | (code & 0x3f);
}
}
} else {
for (i = start;index < length && i < 64; ++index) {
code = message.charCodeAt(index);
if (code < 0x80) {
blocks[i >> 2] |= code << SHIFT[i++ & 3];
} else if (code < 0x800) {
blocks[i >> 2] |= (0xc0 | (code >> 6)) << SHIFT[i++ & 3];
blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
blocks[i >> 2] |= (0xe0 | (code >> 12)) << SHIFT[i++ & 3];
blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
} else {
code = 0x10000 + (((code & 0x3ff) << 10) | (message.charCodeAt(++index) & 0x3ff));
blocks[i >> 2] |= (0xf0 | (code >> 18)) << SHIFT[i++ & 3];
blocks[i >> 2] |= (0x80 | ((code >> 12) & 0x3f)) << SHIFT[i++ & 3];
blocks[i >> 2] |= (0x80 | ((code >> 6) & 0x3f)) << SHIFT[i++ & 3];
blocks[i >> 2] |= (0x80 | (code & 0x3f)) << SHIFT[i++ & 3];
}
}
}
}
bytes += i - start;
start = i - 64;
if(index == length) {
blocks[i >> 2] |= EXTRA[i & 3];
++index;
}
if(index > length && i < 56) {
blocks[14] = bytes << 3;
end = true;
}

if(first) {
a = blocks - 680876937;
a = (a << 7 | a >>> 25) - 271733879 << 0;
d = (-1732584194 ^ a & 2004318071) + blocks[1] - 117830708;
d = (d << 12 | d >>> 20) + a << 0;
c = (-271733879 ^ (d & (a ^ -271733879))) + blocks[2] - 1126478375;
c = (c << 17 | c >>> 15) + d << 0;
b = (a ^ (c & (d ^ a))) + blocks[3] - 1316259209;
b = (b << 22 | b >>> 10) + c << 0;
} else {
a = h0;
b = h1;
c = h2;
d = h3;
a += (d ^ (b & (c ^ d))) + blocks - 680876936;
a = (a << 7 | a >>> 25) + b << 0;
d += (c ^ (a & (b ^ c))) + blocks[1] - 389564586;
d = (d << 12 | d >>> 20) + a << 0;
c += (b ^ (d & (a ^ b))) + blocks[2] + 606105819;
c = (c << 17 | c >>> 15) + d << 0;
b += (a ^ (c & (d ^ a))) + blocks[3] - 1044525330;
b = (b << 22 | b >>> 10) + c << 0;
}

a += (d ^ (b & (c ^ d))) + blocks[4] - 176418897;
a = (a << 7 | a >>> 25) + b << 0;
d += (c ^ (a & (b ^ c))) + blocks[5] + 1200080426;
d = (d << 12 | d >>> 20) + a << 0;
c += (b ^ (d & (a ^ b))) + blocks[6] - 1473231341;
c = (c << 17 | c >>> 15) + d << 0;
b += (a ^ (c & (d ^ a))) + blocks[7] - 45705983;
b = (b << 22 | b >>> 10) + c << 0;
a += (d ^ (b & (c ^ d))) + blocks[8] + 1770035416;
a = (a << 7 | a >>> 25) + b << 0;
d += (c ^ (a & (b ^ c))) + blocks[9] - 1958414417;
d = (d << 12 | d >>> 20) + a << 0;
c += (b ^ (d & (a ^ b))) + blocks[10] - 42063;
c = (c << 17 | c >>> 15) + d << 0;
b += (a ^ (c & (d ^ a))) + blocks[11] - 1990404162;
b = (b << 22 | b >>> 10) + c << 0;
a += (d ^ (b & (c ^ d))) + blocks[12] + 1804603682;
a = (a << 7 | a >>> 25) + b << 0;
d += (c ^ (a & (b ^ c))) + blocks[13] - 40341101;
d = (d << 12 | d >>> 20) + a << 0;
c += (b ^ (d & (a ^ b))) + blocks[14] - 1502002290;
c = (c << 17 | c >>> 15) + d << 0;
b += (a ^ (c & (d ^ a))) + blocks[15] + 1236535329;
b = (b << 22 | b >>> 10) + c << 0;
a += (c ^ (d & (b ^ c))) + blocks[1] - 165796510;
a = (a << 5 | a >>> 27) + b << 0;
d += (b ^ (c & (a ^ b))) + blocks[6] - 1069501632;
d = (d << 9 | d >>> 23) + a << 0;
c += (a ^ (b & (d ^ a))) + blocks[11] + 643717713;
c = (c << 14 | c >>> 18) + d << 0;
b += (d ^ (a & (c ^ d))) + blocks - 373897302;
b = (b << 20 | b >>> 12) + c << 0;
a += (c ^ (d & (b ^ c))) + blocks[5] - 701558691;
a = (a << 5 | a >>> 27) + b << 0;
d += (b ^ (c & (a ^ b))) + blocks[10] + 38016083;
d = (d << 9 | d >>> 23) + a << 0;
c += (a ^ (b & (d ^ a))) + blocks[15] - 660478335;
c = (c << 14 | c >>> 18) + d << 0;
b += (d ^ (a & (c ^ d))) + blocks[4] - 405537848;
b = (b << 20 | b >>> 12) + c << 0;
a += (c ^ (d & (b ^ c))) + blocks[9] + 568446438;
a = (a << 5 | a >>> 27) + b << 0;
d += (b ^ (c & (a ^ b))) + blocks[14] - 1019803690;
d = (d << 9 | d >>> 23) + a << 0;
c += (a ^ (b & (d ^ a))) + blocks[3] - 187363961;
c = (c << 14 | c >>> 18) + d << 0;
b += (d ^ (a & (c ^ d))) + blocks[8] + 1163531501;
b = (b << 20 | b >>> 12) + c << 0;
a += (c ^ (d & (b ^ c))) + blocks[13] - 1444681467;
a = (a << 5 | a >>> 27) + b << 0;
d += (b ^ (c & (a ^ b))) + blocks[2] - 51403784;
d = (d << 9 | d >>> 23) + a << 0;
c += (a ^ (b & (d ^ a))) + blocks[7] + 1735328473;
c = (c << 14 | c >>> 18) + d << 0;
b += (d ^ (a & (c ^ d))) + blocks[12] - 1926607734;
b = (b << 20 | b >>> 12) + c << 0;
bc = b ^ c;
a += (bc ^ d) + blocks[5] - 378558;
a = (a << 4 | a >>> 28) + b << 0;
d += (bc ^ a) + blocks[8] - 2022574463;
d = (d << 11 | d >>> 21) + a << 0;
da = d ^ a;
c += (da ^ b) + blocks[11] + 1839030562;
c = (c << 16 | c >>> 16) + d << 0;
b += (da ^ c) + blocks[14] - 35309556;
b = (b << 23 | b >>> 9) + c << 0;
bc = b ^ c;
a += (bc ^ d) + blocks[1] - 1530992060;
a = (a << 4 | a >>> 28) + b << 0;
d += (bc ^ a) + blocks[4] + 1272893353;
d = (d << 11 | d >>> 21) + a << 0;
da = d ^ a;
c += (da ^ b) + blocks[7] - 155497632;
c = (c << 16 | c >>> 16) + d << 0;
b += (da ^ c) + blocks[10] - 1094730640;
b = (b << 23 | b >>> 9) + c << 0;
bc = b ^ c;
a += (bc ^ d) + blocks[13] + 681279174;
a = (a << 4 | a >>> 28) + b << 0;
d += (bc ^ a) + blocks - 358537222;
d = (d << 11 | d >>> 21) + a << 0;
da = d ^ a;
c += (da ^ b) + blocks[3] - 722521979;
c = (c << 16 | c >>> 16) + d << 0;
b += (da ^ c) + blocks[6] + 76029189;
b = (b << 23 | b >>> 9) + c << 0;
bc = b ^ c;
a += (bc ^ d) + blocks[9] - 640364487;
a = (a << 4 | a >>> 28) + b << 0;
d += (bc ^ a) + blocks[12] - 421815835;
d = (d << 11 | d >>> 21) + a << 0;
da = d ^ a;
c += (da ^ b) + blocks[15] + 530742520;
c = (c << 16 | c >>> 16) + d << 0;
b += (da ^ c) + blocks[2] - 995338651;
b = (b << 23 | b >>> 9) + c << 0;
a += (c ^ (b | ~d)) + blocks - 198630844;
a = (a << 6 | a >>> 26) + b << 0;
d += (b ^ (a | ~c)) + blocks[7] + 1126891415;
d = (d << 10 | d >>> 22) + a << 0;
c += (a ^ (d | ~b)) + blocks[14] - 1416354905;
c = (c << 15 | c >>> 17) + d << 0;
b += (d ^ (c | ~a)) + blocks[5] - 57434055;
b = (b << 21 | b >>> 11) + c << 0;
a += (c ^ (b | ~d)) + blocks[12] + 1700485571;
a = (a << 6 | a >>> 26) + b << 0;
d += (b ^ (a | ~c)) + blocks[3] - 1894986606;
d = (d << 10 | d >>> 22) + a << 0;
c += (a ^ (d | ~b)) + blocks[10] - 1051523;
c = (c << 15 | c >>> 17) + d << 0;
b += (d ^ (c | ~a)) + blocks[1] - 2054922799;
b = (b << 21 | b >>> 11) + c << 0;
a += (c ^ (b | ~d)) + blocks[8] + 1873313359;
a = (a << 6 | a >>> 26) + b << 0;
d += (b ^ (a | ~c)) + blocks[15] - 30611744;
d = (d << 10 | d >>> 22) + a << 0;
c += (a ^ (d | ~b)) + blocks[6] - 1560198380;
c = (c << 15 | c >>> 17) + d << 0;
b += (d ^ (c | ~a)) + blocks[13] + 1309151649;
b = (b << 21 | b >>> 11) + c << 0;
a += (c ^ (b | ~d)) + blocks[4] - 145523070;
a = (a << 6 | a >>> 26) + b << 0;
d += (b ^ (a | ~c)) + blocks[11] - 1120210379;
d = (d << 10 | d >>> 22) + a << 0;
c += (a ^ (d | ~b)) + blocks[2] + 718787259;
c = (c << 15 | c >>> 17) + d << 0;
b += (d ^ (c | ~a)) + blocks[9] - 343485551;
b = (b << 21 | b >>> 11) + c << 0;

if(first) {
h0 = a + 1732584193 << 0;
h1 = b - 271733879 << 0;
h2 = c - 1732584194 << 0;
h3 = d + 271733878 << 0;
first = false;
} else {
h0 = h0 + a << 0;
h1 = h1 + b << 0;
h2 = h2 + c << 0;
h3 = h3 + d << 0;
}
} while(!end);

if(FIREFOX) {
var hex = HEX_CHARS[(h0 >> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F];
hex += HEX_CHARS[(h0 >> 12) & 0x0F] + HEX_CHARS[(h0 >> 8) & 0x0F];
hex += HEX_CHARS[(h0 >> 20) & 0x0F] + HEX_CHARS[(h0 >> 16) & 0x0F];
hex += HEX_CHARS[(h0 >> 28) & 0x0F] + HEX_CHARS[(h0 >> 24) & 0x0F];
hex += HEX_CHARS[(h1 >> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F];
hex += HEX_CHARS[(h1 >> 12) & 0x0F] + HEX_CHARS[(h1 >> 8) & 0x0F];
hex += HEX_CHARS[(h1 >> 20) & 0x0F] + HEX_CHARS[(h1 >> 16) & 0x0F];
hex += HEX_CHARS[(h1 >> 28) & 0x0F] + HEX_CHARS[(h1 >> 24) & 0x0F];
hex += HEX_CHARS[(h2 >> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F];
hex += HEX_CHARS[(h2 >> 12) & 0x0F] + HEX_CHARS[(h2 >> 8) & 0x0F];
hex += HEX_CHARS[(h2 >> 20) & 0x0F] + HEX_CHARS[(h2 >> 16) & 0x0F];
hex += HEX_CHARS[(h2 >> 28) & 0x0F] + HEX_CHARS[(h2 >> 24) & 0x0F];
hex += HEX_CHARS[(h3 >> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F];
hex += HEX_CHARS[(h3 >> 12) & 0x0F] + HEX_CHARS[(h3 >> 8) & 0x0F];
hex += HEX_CHARS[(h3 >> 20) & 0x0F] + HEX_CHARS[(h3 >> 16) & 0x0F];
hex += HEX_CHARS[(h3 >> 28) & 0x0F] + HEX_CHARS[(h3 >> 24) & 0x0F];
return hex;
} else {
return HEX_CHARS[(h0 >> 4) & 0x0F] + HEX_CHARS[h0 & 0x0F] +
HEX_CHARS[(h0 >> 12) & 0x0F] + HEX_CHARS[(h0 >> 8) & 0x0F] +
HEX_CHARS[(h0 >> 20) & 0x0F] + HEX_CHARS[(h0 >> 16) & 0x0F] +
HEX_CHARS[(h0 >> 28) & 0x0F] + HEX_CHARS[(h0 >> 24) & 0x0F] +
HEX_CHARS[(h1 >> 4) & 0x0F] + HEX_CHARS[h1 & 0x0F] +
HEX_CHARS[(h1 >> 12) & 0x0F] + HEX_CHARS[(h1 >> 8) & 0x0F] +
HEX_CHARS[(h1 >> 20) & 0x0F] + HEX_CHARS[(h1 >> 16) & 0x0F] +
HEX_CHARS[(h1 >> 28) & 0x0F] + HEX_CHARS[(h1 >> 24) & 0x0F] +
HEX_CHARS[(h2 >> 4) & 0x0F] + HEX_CHARS[h2 & 0x0F] +
HEX_CHARS[(h2 >> 12) & 0x0F] + HEX_CHARS[(h2 >> 8) & 0x0F] +
HEX_CHARS[(h2 >> 20) & 0x0F] + HEX_CHARS[(h2 >> 16) & 0x0F] +
HEX_CHARS[(h2 >> 28) & 0x0F] + HEX_CHARS[(h2 >> 24) & 0x0F] +
HEX_CHARS[(h3 >> 4) & 0x0F] + HEX_CHARS[h3 & 0x0F] +
HEX_CHARS[(h3 >> 12) & 0x0F] + HEX_CHARS[(h3 >> 8) & 0x0F] +
HEX_CHARS[(h3 >> 20) & 0x0F] + HEX_CHARS[(h3 >> 16) & 0x0F] +
HEX_CHARS[(h3 >> 28) & 0x0F] + HEX_CHARS[(h3 >> 24) & 0x0F];
}
};

if(!root.JS_MD5_TEST && NODE_JS) {
var crypto = require('crypto');
var Buffer = require('buffer').Buffer;

module.exports = function(message) {
if(typeof(message) == 'string') {
if(message.length <= 80) {
return md5(message);
} else if(message.length <= 183 && !/[^\x00-\x7F]/.test(message)) {
return md5(message);
}
return crypto.createHash('md5').update(message, 'utf8').digest('hex');
}
if(message.constructor == ArrayBuffer) {
message = new Uint8Array(message);
}
if(message.length <= 370) {
return md5(message);
}
return crypto.createHash('md5').update(new Buffer(message)).digest('hex');
};
} else if(root) {
root.md5 = md5;
}
}(this));

</script>
</html>
[/code]

Also, abgesehen dass ich dafür jetzt selbst eine mögliche Lösung gefunden habe, formuliere ich das Risiko mal anders:

Stellt euch vor, ihr ruft eine Webseite xy auf, in der eine Kontonummer (IBAN/BIC) für z.B. Spenden oder Vorauskassen oder was auch immer steht.

Der Betrachter der Seite sieht diese IBAN/BIC, kopiert sich die heraus und geht damit ins Onlinebanking und überweist artig.

Eine x-beliebige Software hat aber zuvor den Quellcode der Webseite derart manipuliert, dass eine gefundene IBAN/BIC mal eben auf ein fremdes Konto zeigt. Der Besucher der Webseite erkennt diesen Unterschied _niemals_! Eine erfolgte Überweisung auf ein falsches Konto kann nur sehr problematisch zurückgeholt werden, aber wenn es richtige Ganoven sind, dann haben sie das Konto schon längst leergeräumt, so dass nichts mehr zu holen ist. Vor allem dauert es ewig, bis ein derartiger Trick überhaupt bemerkt wird!

Dasselbe trifft z.B. auf Links zum Registrieren und Logins zu. Diese können auf einfache Weise entsprechend manipuliert werden.

Mit dem Testscript hat der Server aber eine Möglichkeit an den Client übertragen, dass dieser die Manipulationen erkennen kann und den Betrachter der Webseite darauf hinweisen kann, dass der Inhalt der Webseite manipuliert wurde.

Das funktioniert zumindest solange, bis derartige AddOns, Viren/Trojaner dieses Prüfverfahren nicht kennen/erkennen und keine Gegenmaßnahmen ergreifen, z.B. ebenso das JS manipulieren oder zumindest die MD5 selbst auch ändern.

Mit nicht auf der Webseite vorhandene Werbung hat es angefangen, aber die Tragweite dürfte eine ganz andere sein. Schade, dass es niemand von den "nur rein theoretisch"-Spezialisten das verstanden haben.

Micha

Dafür ist das sicher nicht sicher genug ;) Aber immerhin offenbart es eine extreme Sicherheitslücke.

Siehe auch: http://www.regenbogenwald.de/blog/2015/05/09/extremes-betrugsrisiko-im- ...

Und da liegt doch schon eines der gravierensten Probleme! Die "Sicherheits-Spezialisten" schalten den Usern die Möglichkeiten aus, eine rudimentäre Sicherheit zu behalten und behaupten, es sei nur zu ihrem Besten. Aber niemand geht her und teilt den Usern mit, wie einfach es ist, an ihr Geld zu kommen, allein wenn man die Kontodaten im Browser manipuliert und mit NOSCRIPT wird ja auch noch empfohlen, dieses nicht überprüfbar zu machen.

Natürlich sehe ich noch keine Lösung, die wirklich greift, denn auch Javascript löst das Problem nicht! Es kann maximal nur helfen und das halte ich schon für einen kleinen Fortschritt. Auch eine Normierung von Prüfsummen im Quellcode und eine Verifizierung durch den Browser stellt keinen effektiven Schutz her, da niemand garantieren kann, dass der Browser dies korrekt durchführt (weil "diese Version" das nicht unterstützt, weil "diese Version" einen Bug hat oder auch weil der User gewollt oder ungewollt ein AddOn installiert hat oder eine Malware auf dem Rechner ist, die das wieder unterläuft.

Zu wissen, dass es ein massives Problem gibt, aber weder darüber zu informieren noch mehr zu tun als den Kopf in den Sand zu stecken und zu beten, dass es einen selbst nie betreffen möge, das ist vergleichbar mit der Erfindung des Autos, welche heute noch aus Holz gebaut und mit Scheiben aus Fensterglas wären, aber dafür standardmässig ein 3D-Homekino mit Dolby-Surround und digitalen Direktempfang von Kinoprogrammen haben. Tatsächlich fahren wir mit genau solchen Autos aber im Internet herum und jeder glaubt sicher in seinem rollenden Kino zu sein, weil eben noch nie was passiert ist (vielleicht auch nur, weil die anderen immer gebremst haben).

Eines Tages wird jemand mit entsprechend krimineller Energie sich diese klaffende Lücke zu Nutze machen und dann stehen die IT-Sicherheitsexperten mit offenem Mund da und beharren drauf, dass ihre Server die Daten schon richtig gesendet habe, der Arbeitgeber aber dennoch die ITler kündigen muss, weil die Umsätze allesamt auf ein Konto in Timbuktu gelandet sind.

Grüße, Micha

Da gebe ich Dir (leider) Recht, Eisbein (huch, kann man da nichts gegen tun? ;) ), ABER

Es gibt nur eine Handvoll verschiedener Browser und da wäre es schon ein Leichtes, wenn diese eine Möglichkeit einbauen würden, die dem Benutzer signalisiert, dass Inhalte manipuliert wurden (aus welchen Gründen auch immer) und evtl. auf Knopfdruck den originalen Inhalt markieren bzw wieder herstellen. Und zeitgleich im W3C definiert wird, dass bestimmte Inhalte mit XY serverseitig markiert werden können, die bei einer Veränderung eine bestimmte Aktion bewirken, z.B. dass ein Meldungsfenster aufgeht und den User informiert oder dieser Inhalt von vornherein für jeglichen Zugriff eines AddOns gesperrt wird, wenn dieser den Inhalt verändern will.

Was da eigentlich geschieht ist nahe dem §202 StGb, nur dass niemand es bemerkt...

Grüße, Micha

Das dürfte Beides nicht zutreffen. Das Erste: Genau das wäre ja gewollt: Alle Manipulationen sind bereits gelaufen und erst dann (hier durch Click eines Buttons, genauso aber zum Beispiel mit setTimeout angestossen bewusst erst ausgeführt, wenn die Manipulationen höchstwahrscheinlich bereits geschehen sind, um das auch feststellen zu können.

Und zum Zweiten: Einen Schritt nach dem anderen machen! Überhaupt zu erkennen ist das, was nach heutigen Stand der Dinge anzustreben ist. Dass mit dem "Anzeigen wie es gewollt ist" ist bei der immer noch herrschenden Vielfalt an Eigenwilligkeiten der Browser noch absolute Zukunftsmusik.

Micha