Warum dieses Fundament so wichtig ist
Vielleicht hast du schon von „Prototype Pollution“ gelesen und gedacht: Das klingt kompliziert. Der Knackpunkt: Ohne ein solides Verständnis von Prototypen in JavaScript bleibt die Schwachstelle wirklich abstrakt. Deshalb starten wir ganz von vorne – so, dass du auch ohne Vorwissen in JavaScript mitkommst.
Am Ende dieses Beitrags wirst du verstehen:
- Was Prototypen sind.
- Wie JavaScript Eigenschaften sucht.
- Warum Änderungen an Prototypen globale Auswirkungen haben können.
Das ist die Grundlage, um im nächsten Teil zu verstehen, wie Angreifer dieses Verhalten missbrauchen.
Alles in JavaScript ist ein Objekt
In JavaScript (JS) dreht sich fast alles um Objekte.
Ein Objekt ist einfach eine Sammlung von Eigenschaften – quasi wie ein Wörterbuch oder ein kleines Datenpaket.
Beispiel:
const user = {
name: "Alice",
age: 30
};
Hier haben wir ein Objekt user mit zwei Eigenschaften: name und age.
Man kann darauf zugreifen wie so:
console.log(user.name); // "Alice"
console.log(user.age); // 30
Soweit nichts Magisches. Aber was passiert, wenn wir nach etwas fragen, das nicht im Objekt steht?
console.log(user.email); // undefined
Kein Problem – die Eigenschaft existiert nicht. Doch manche Dinge funktionieren trotzdem, obwohl wir sie nie definiert haben.
Woher kommt „toString“?
Jedes JS-Objekt versteht zum Beispiel den Befehl toString().
const user = { name: "Alice" };
console.log(user.toString());
// Ergebnis: "[object Object]"
Aber wir haben nie toString in user definiert.
Woher kommt das?
Antwort: Vom Prototypen.
Was ist ein Prototyp?
Ein Prototyp ist so etwas wie ein Bauplan oder eine Vorlage.
Stell dir vor: Jedes Objekt hat einen „geheimen Link“ auf ein anderes Objekt – seinen Prototypen.
Wenn du eine Eigenschaft abfragst:
- Schaut JS zuerst im Objekt selbst nach.
- Wenn es dort nichts findet, schaut es im Prototypen.
- Wenn auch dort nichts ist, geht es weiter zum Prototypen des Prototypen.
- Am Ende kommt
null– dann weiß JS: „gibt’s nicht“.
Das ist die sogenannte Prototype Chain (Prototypen-Kette).
Mini-Beispiel zur Prototype Chain
const user = { name: "Alice" };
console.log(user.hasOwnProperty("name")); // true
console.log(user.hasOwnProperty("toString")); // false
Warum?
nameist direkt im Objektuser.toStringnicht – aberusererbt es vom Object-Prototypen.
Also:
- Eigene Eigenschaften = im Objekt selbst.
- Geerbte Eigenschaften = aus dem Prototypen.
Vererbung ohne Klassen
In vielen Sprachen gibt es Klassen (z. B. in Java, C#, Python).
JavaScript hat lange Zeit keine echten Klassen gehabt. Stattdessen nutzt es dieses Prototypen-Modell für Vererbung.
Das bedeutet: Objekte können Eigenschaften von anderen Objekten „erben“, ohne dass man explizit eine Klasse definieren muss.
Prototypen sind überall
Ein paar Beispiele:
Arrays
const numbers = [1, 2, 3];
console.log(numbers.length); // 3
console.log(numbers.push); // Funktion: push()
length ist eine eigene Eigenschaft des Arrays.push (zum Hinzufügen von Elementen) kommt vom Array-Prototypen.
Funktionen
function greet() { return "Hi"; }
console.log(greet.call); // Funktion: call()
Auch Funktionen haben Prototypen – mit Eigenschaften wie call oder bind.
Warum das mächtig, aber auch gefährlich ist
Prototypen machen JavaScript sehr flexibel. Man kann Objekte im Nachhinein erweitern – selbst eingebaute Objekte wie Arrays oder Strings.
Beispiel:
Array.prototype.first = function() {
return this[0];
};
console.log([10, 20, 30].first()); // 10
Wir haben dem Array-Prototypen einfach eine neue Funktion first hinzugefügt – und plötzlich können alle Arrays diese Funktion nutzen.
Das ist cool, oder? Aber auch brandgefährlich.
Änderung am Prototyp wirkt global
Ein kleiner Test (nur zum Verständnis, nicht in echten Projekten machen!):
Object.prototype.isAdmin = true;
console.log({}.isAdmin); // true
console.log({ name: "Bob" }.isAdmin); // true
Wir haben Object.prototype eine neue Eigenschaft isAdmin gegeben.
Jetzt hat jedes Objekt in der gesamten Anwendung diese Eigenschaft.
Damit haben wir das wichtigste Sicherheitsproblem schon angerissen: Wenn jemand den Prototypen manipuliert, beeinflusst das alle Objekte, die von ihm erben.
Analogie: Stadtbibliothek
Stell dir vor, jedes Objekt in JavaScript ist wie ein Buch in einer Bibliothek.
- Manche Bücher haben eigene Notizen (eigene Eigenschaften).
- Wenn etwas fehlt, schauen wir im Katalog nach (Prototyp).
- Wenn es auch dort nicht steht, fragen wir beim Stadtarchiv (nächster Prototyp in der Chain).
Jetzt stell dir vor, jemand schreibt heimlich ins Stadtarchiv:
„Jedes Buch ist ab sofort ein Bestseller.“
Plötzlich denkt jeder, alle Bücher seien Bestseller – selbst wenn es gar nicht stimmt.
Genau so funktioniert Prototype Pollution.
Was du bis hier mitnehmen solltest
- Jedes JavaScript-Objekt hat einen Prototypen.
- Wenn du eine Eigenschaft suchst, schaut JS zuerst im Objekt selbst, dann im Prototypen – und so weiter (Prototype Chain).
- Änderungen am Prototypen wirken global auf alle Objekte, die davon erben.
- Das macht JS flexibel, aber auch anfällig für Missbrauch.
Schreibe einen Kommentar