Bei JavaScript Prototype Pollution handelt es sich um eine JavaScript-Schwachstelle, mit der Properties zum globalen Prototype hinzugefügt werden können; keine Angst, wenn Ihnen dies nichts sagt, im Artikel werden auf die notwendigen JavaScript Grundlagen eingegangen. Diese Schwachstelle kann client-seitig für Cross-Site-Scripting und server-seitig im schlimmsten Fall für Remote-Code-Execution ausgenutzt werden.

Dieser Abschnitt beschreibt JavaScript-Grundlagen, wenn Sie sich mit JavaScript bereits auskennen, können Sie diesen Abschnitt problemlos überspringen.

Was ist ein Objekt in JavaScript?

Ein Objekt ist eigentlich nur eine Ansammlung von Properties, wobei Properties key:value Paare sind. Ein Objekt sieht wie folgt aus:

var exampleObject = {
    test: "value",
    exampelMethod: function() {
        //do something here
        console.log("test")
    }
}

Auf die Properties eines Objekts können wie folgt zugegriffen werden:

exampleObject.test

oder

exampleObject['test']

und die Methode eines Objekts kann wie folgt aufgerufen werden:

exampleObject.exampleMethod();

Beim Beispiel oben handelt es sich um ein explizit deklariertes Objekt, in JavaScript basiert allerdings fast alles im Hintergrund auf Objekten. Gelöst wird das ganze über den Prototype.

Was ist der JavaScript Prototype?

Beim Prototype handelt es sich um den Mechanismus, mit dem in JavaScript Elemente von Objekten an andere Objekte vererbt werden. Der Prototyp eines Objekts ist nichts anderes als ein weiteres Objekt, das ebenfalls einen eigenen Prototyp hat. Und da praktisch alles in JavaScript unter der Oberfläche ein Objekt ist, führt diese Kette letztlich zum obersten Object.prototype zurück, dessen Prototyp dann einfach der Wert null ist.

In der Praxis bedeutet das, dass JavaScript im Hintergrund folgendes macht, wenn auf ein Property mittels exampleObject.test oder exampleObject['test'] zugegriffen wird:

1. Die JavaScript-Engine sucht nach dem Property test in dem Objekt exampleObject.
2. Falls das Property vorhanden ist, wird es zurückgegeben. Ansonsten wird der Prototype des benutzerdefinierten Objekts genommen und in diesem nach dem Property gesucht. Diese Suche wird in der Prototype-Kette so lange fortgeführt, bis das Property gefunden wurde, oder bei obersten, also dem null, Prototype angelangt wird und dort wird dann undefined zurückgegeben.

Auf einem Objekt kann wie folgt auf den Prototype zugegriffen werden:

• __proto__
• constructor.prototype

Mit diesen Grundlagen sollten Sie nun in der Lage sein, JavaScript Prototype Pollution zu verstehen.

Prototype Pollution

Bei einer Prototype Pollution hat ein Angreifer das Ziel Object.prototype zu verändern. Da beinahe alle Elemente in JavaScript von Objekt erben, können damit beinahe alle Elemente angegriffen werden. In den meisten Fällen wird Prototype Pollution durch eine unsicher merge Funktion ausgelöst, die rekursiv Properties aus einer nicht vertrauenswürdigen Quelle übernimmt. Olivier Arteau beschreibt eine solche merge Funktion in seinem Paper Prototype pollution attack in NodeJS application wie folgt:

merge(target, source)
    foreach property of source
        if property exists and is an object on both the target and the source
            merge(target[property], source[property])
        else
            target[property] = source[property]

Für Prototype Pollution wird folgendes benötigt:

• Source, also der Ort, an dem die Pollution übergeben werden kann
  • URL
  • JSON
  • Web Message
  • Die Suche dafür ist manuell sehr aufwendig, vor allem wenn der JavaScript-Code minified wurde. Es wird empfohlen Tools wie den DOM Invader in Burp zu verwenden.
• Sink
  • Für DOM-XSS, eine JavaScript-Funktion oder ein DOM-Element, das JavaScript Code Ausführung erlaubt
• Gadget, ein Property, dass ohne Bereinigung an die Sink weitergegeben wird
  • Also das Element das Source und Sink verbindet

Auffinden von Prototype Pollution mit Burp DOM Invader

Beim DOM Invader handelt es sich um eine Erweiterung des im Burp mitgelieferten Chromium Browsers. Diese Erweiterung ist im Normalfall deaktiviert, da sie ungewünschte Nebenwirkungen haben kann. Sie kann wie folgt aktiviert werden:

Im Burp mitgelieferten Browser die Erweiterung mit dem Titel Burp Suite auswählen:

Und in dem sich öffnenden Fenster DOM Invader auswählen und aktivieren:

Sobald die Erweiterung aktiv ist, kann die Webseite, die auf Prototype Pollution untersucht werden soll, neu geladen werden. Damit wird der DOM Invader im Hintergrund richtig aufgesetzt. In den Developer Tools gibt es nun einen neuen Eintrag mit dem Titel DOM Invader. Wenn dieser Ausgewählt wird, werden die Resultate der Analyse des DOM Invaders angezeigt. Im untenstehenden Beispiel wurden zwei Prototype Pollution Möglichkeiten identifiziert:

Mittels Scan for gadgets kann nach Gadgets gesucht werden, die aus Prototype Pollution XSS machen. Dabei sieht das Scanning wie folgt aus:

Und das Resultat eines erfolgreichen Scans wie folgt:

Im einfachsten Fall kann einfach die Option Exploit ausgewählt werden und es wird ein alert(1) ausgeführt. Falls kein alert auftaucht sollte in der Konsole die Fehlermeldung anzeigt werden und mittels dem dort vorhandenen StackTrace landet man im JavaScript an dem Ort, an dem die Prototype Pollution schiefläuft. Von da kann man dann einfach die Payload analysieren und wie erwartet anpassen, so dass der alert ausgeführt wird.

Auffinden von Prototype Pollution von Hand

Die manuelle Suche nach JavaScript Prototype Pollution kann sehr aufwendig sein, vor allem dann, wenn der von der Webseite genutzte JavaScript Code minified wurde. Wie dafür vorgegangen werden kann, wurde in den Artikeln von Portswigger und Nikita Stupin besser und tiefergehend eingegangen, als dass es hier gemacht werden kann. Die Lektüre dieser Artikel ist sehr empfehlenswert, um das Wissen zu Prototype Pollution zu vertiefen. Insbesondere der Portswigger-Artikel ist empfehlenswert, da dort auch Labs angeboten werden, bei denen die gelernten Techniken direkt angewendet werden können.

Beispiele aus der Praxis

• Liste von client-side Prototype Pollution Proof-of-Concepts von BlackFan
• Reflected XSS in der HackerOne Webseite
• Remote-Code-Execution in Kibana
• Remote-Code-Execution in NodeJS (Talk)
• Artikel über das Vorgehen zur Entdeckung von Prototype Pollution von s1r1us

Gegenmassnahmen

Es gibt unterschiedliche Möglichkeiten, wie man sich gegen JavaScript Prototype Pollution schützen kann. Diese kommen jeweils mit unterschiedlichen Vor- und Nachteilen:

• Object mit Object.create(null) erstellen
  • Das so definierte Objekt hat keinen Prototype und erbt damit auch nicht von JavaScript Object
  • Problematisch ist, dass damit Standardfunktionen wie toString()nicht mehr verwendet werden können, da diese Standardfunktionen über das Object Prototype an benutzerdefinierte Objekte vererbt werden.
• Deny-List mit Begriffen wie zum Beispiel __proto__
  • Deny-Lists sind grundsätzlich meist eine schlechte Idee, da solche Listen oft durch das Verwenden einer anderen Syntax umgangen werden können.
• Object.freeze() verwenden
  • Damit kann Object Prototype nicht mehr verändert werden
  • Dies kann allerdings zu unerwarteten Problemen führen, wenn Abhängigkeiten den Object Prototype dennoch verändern möchten; alternativ kann Object.seal() verwendet werden, dann können keine neuen Properties mehr definiert werden, aber bestehende Properties können noch verändert werden.
• Da ein Angriffsweg via JSON ist, sollte das von Benutzern oder aus anderen unsicheren Quellen erhaltene JSON gegenüber einem vordefinierten JSON-Schema geprüft werden und alle Parameter, die nicht im Schema definiert sind, sollten verworfen werden.

Zusammenfassung

Bei JavaScript Prototype Pollution handelt es sich um eine komplexe Angriffsmöglichkeit, die in den schlimmsten Fällen zu XSS oder server-seitig sogar zu RCE führen können. Das Auffinden solcher Schwachstellen ist zwar manuell möglich, ist allerdings sehr aufwändig, da die meisten modernen Webseiten viel und meist minified JavaScript Code haben. Da Portswigger, die Hersteller von Burp, sich ausgiebig mit dem Thema beschäftigt haben, wird innerhalb von Burp allerdings gutes Tooling zur Identifizierung dieses Schwachstellen-Typs zur Verfügung gestellt. Für Entwickler bestehen unterschiedlichste Möglichkeiten mit verschiedenen Vor- und Nachteilen, um JavaScript-Code gegen Prototype Pollution zu härten.

Über die Autorin

Andrea Hauser hat ihren Bachelor of Science FHO in Informatik an der Hochschule für Technik Rapperswil abgeschlossen. Sie setzt sich im offensiven Bereich in erster Linie mit Web Application Security Testing und der Umsetzung von Social Engineering Kampagnen auseinander. Zudem ist sie in der Forschung zum Thema Deepfakes tätig. (ORCID 0000-0002-5161-8658)

Links

• https://blog.s1r1us.ninja/research/PP
• https://github.com/BlackFan/client-side-prototype-pollution
• https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf
• https://hackerone.com/reports/852613
• https://hackerone.com/reports/986386
• https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2
• https://portswigger.net/web-security/prototype-pollution/finding
• https://www.youtube.com/watch?v=LUsiFV3dsK8