flawopen.com/Schwachstellen/JavaScript Prototype Pollution

JavaScript Prototype Pollution

Grundbegriffe und Subsysteme

Object.prototype

Gemeinsamer Prototyp, den gewöhnliche Objekte erben. Seine Manipulation kann viele Objekte betreffen, aber nicht jedes JavaScript-Objekt und nicht jeden Realm.

__proto__

Veralteter Zugriff auf gewöhnlichen Objekten, der ihren Prototyp liest oder setzt. In JSON-Text ist dieselbe Schreibweise zunächst ein normaler Eigenschaftsname.

Rekursives Deep Merge

Kopierfunktion, die verschachtelte Schlüssel durchläuft und in ein anderes Objekt schreibt. Gefährlich, wenn nicht vertrauenswürdige Schlüssel prototypbezogene Eigenschaften oder unsichere Pfade auswählen.

CWE-1321

Unzureichend kontrollierte Änderung von Objekt-Prototypattributen. Die Schwachstelle ist die unkontrollierte Mutation; die spätere Auswirkung hängt vom erreichbaren Anwendungsverhalten ab.

Angriffsablauf Schritt für Schritt

Mechanismus und Ursache

Die JavaScript-Eigenschaftssuche folgt der Prototypkette. Ein verwundbares Merge oder ein Pfad-Setter kann nicht vertrauenswürdige Schlüssel wie __proto__ oder constructor.prototype zu einem Prototyp-Schreibzugriff führen lassen. Ein eigenes __proto__-Feld aus JSON.parse ist noch keine Pollution; weiterer Code muss es durch eine unsichere Zuweisung interpretieren. Eine Änderung am Zielprototyp betrifft dieses Ziel; eine Änderung an Object.prototype betrifft gewöhnliche Objekte, die ihn erben. Erst ein separates Gadget, das die geerbte Eigenschaft nutzt, erzeugt eine Sicherheitsauswirkung.

// VERWUNDBAR: angreifergesteuerte Schlüssel erreichen rekursive Schreibzugriffe
function merge(target, source) {
    for (const key in source) {
        const value = source[key];
        if (value && typeof value === 'object') {
            if (!target[key]) target[key] = {};
            merge(target[key], value);
        } else {
            target[key] = value;
        }
    }
    return target;
}
// JSON.parse erzeugt eine eigene __proto__-Dateneigenschaft; das unsichere Merge ist das Risiko.
const input = JSON.parse('{"__proto__": {"isAdmin": true}}');
merge({}, input);

// ABGESICHERT: nur die vom Endpunkt vorgesehenen Felder kopieren
const PROFILE_KEYS = new Set(['displayName', 'theme']);

function parseProfile(input) {
    if (!input || typeof input !== 'object' || Array.isArray(input)) {
        throw new TypeError('profile must be an object');
    }

    const profile = Object.create(null);
    for (const key of Object.keys(input)) {
        if (!PROFILE_KEYS.has(key)) continue;
        const value = input[key];
        if (typeof value !== 'string' || value.length > 80) {
            throw new TypeError('invalid profile field');
        }
        profile[key] = value;
    }
    return profile;
}

Angriffs- und Ausnutzungsablauf

• 1Eingabe: Eine Anfrage enthält einen unerwarteten Objektschlüssel wie {"__proto__": {"admin": true}}. JSON-Parsing allein verändert keinen Prototyp.
• 2Unsicherer Schreibzugriff: Ein generisches Merge oder ein Pfad-Setter verarbeitet den Schlüssel ohne Allowlist.
• 3Prototypzugriff: Je nach Codepfad kann der Schreibzugriff den Zielprototyp ändern oder einen gemeinsamen Prototyp erreichen.
• 4Auswirkungs-Gadget: Die Pollution beeinflusst eine sensible Entscheidung nur, wenn späterer Code einer geerbten Eigenschaft vertraut. Prüfen Sie das tatsächliche Gadget und den Autorisierungspfad.

Abwehrmaßnahmen und Präventionsregeln

• ✓Schema-Allowlists bevorzugen: Erzeugen Sie das Ziel nur aus Feldern, die der Endpunkt akzeptieren soll. Wenn ein generischer Pfadschreiber nötig ist, weisen Sie prototypbezogene Segmente auf jeder Ebene zurück.
• ✓Sichere Dictionaries verwenden: Speichern Sie beliebige Nutzerschlüssel in Map oder einem Object.create(null)-Dictionary; prüfen Sie Daten vor der Übergabe an APIs, die gewöhnliche Objekte erwarten.
• ✓Eigene Eigenschaften prüfen: Verwenden Sie Object.hasOwn(record, key) für sicherheitsrelevante Prüfungen; geerbte Standardwerte dürfen keine Aktionen autorisieren.
• ✓Runtime-Härtung als Defense in Depth einsetzen: Node.js --disable-proto=throw entfernt einen Angriffsweg, blockiert aber nicht constructor.prototype. Eingebaute Objekte einzufrieren kann Polyfills und Abhängigkeiten brechen; prüfen Sie die Kompatibilität und ersetzen Sie damit niemals sichere Schreibzugriffe.

Häufige Fragen

• MDN — JavaScript Prototype Pollution
• OWASP — Leitfaden gegen Prototype Pollution
• CWE-1321 — Unzureichend kontrollierte Änderung von Objekt-Prototypattributen
• MDN — Object.prototype.__proto__-Accessor