From 42ced4f7c8e90156fce14d4205eb457af4e5d787 Mon Sep 17 00:00:00 2001
From: Translator <github-actions@github.com>
Date: Tue, 19 Aug 2025 22:04:11 +0000
Subject: [PATCH] Translated
 ['src/pentesting-web/deserialization/nodejs-proto-prototype-p

---
 .../README.md                                 | 54 +++++++++----------
 1 file changed, 26 insertions(+), 28 deletions(-)

diff --git a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
index 234fdf469..aeccf6619 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
@@ -9,7 +9,7 @@ Objekte in JavaScript sind im Wesentlichen Sammlungen von Schlüssel-Wert-Paaren
 // Run this in the developers tools console
 console.log(Object.create(null)) // This will output an empty object.
 ```
-Ein leeres Objekt ist einem leeren Wörterbuch ähnlich, dargestellt als `{}`.
+Ein leeres Objekt ist vergleichbar mit einem leeren Wörterbuch, dargestellt als `{}`.
 
 ### Funktionen und Klassen in JavaScript
 
@@ -56,7 +56,7 @@ this.model = model
 }
 var car1 = new Vehicle("Tesla Model S")
 ```
-Der Zugriff auf das Objektprototyp ist möglich über:
+Der Zugriff auf das Objekt-Prototyp ist möglich über:
 ```javascript
 car1.__proto__.__proto__
 Vehicle.__proto__.__proto__
@@ -102,7 +102,7 @@ Dies betrifft nur Objekte, die aus dem `Vehicle`-Konstruktor erstellt wurden, un
 
 Zwei Methoden, um JavaScript-Objekte global durch Prototyp-Verschmutzung zu beeinflussen, sind:
 
-1. Direkte Verschmutzung des `Object.prototype`:
+1. Direktes Verschmutzen des `Object.prototype`:
 ```javascript
 Object.prototype.goodbye = function () {
 console.log("Goodbye!")
@@ -142,7 +142,7 @@ console.log(key1 + "." + key2)
 }
 }
 ```
-### Array-Elemente-Verschmutzung
+### Array-Element-Verschmutzung
 
 Beachten Sie, dass Sie, da Sie Attribute von Objekten in JS verschmutzen können, wenn Sie Zugriff haben, um ein Array zu verschmutzen, auch **Werte des Arrays** zugänglich **über Indizes** verschmutzen können (beachten Sie, dass Sie Werte nicht überschreiben können, sodass Sie Indizes verschmutzen müssen, die irgendwie verwendet, aber nicht geschrieben werden).
 ```javascript
@@ -171,13 +171,13 @@ settings[root][ownerDocument][body][innerHTML]="<svg onload=alert(document.domai
 
 ### Einfaches Beispiel
 
-Eine Prototyp-Verschmutzung tritt aufgrund eines Fehlers in der Anwendung auf, der das Überschreiben von Eigenschaften auf `Object.prototype` ermöglicht. Das bedeutet, dass die meisten Objekte ihre Eigenschaften von `Object.prototype` ableiten.
+Eine Prototype-Verschmutzung tritt aufgrund eines Fehlers in der Anwendung auf, der das Überschreiben von Eigenschaften auf `Object.prototype` ermöglicht. Das bedeutet, dass die meisten Objekte ihre Eigenschaften von `Object.prototype` ableiten.
 
-Das einfachste Beispiel besteht darin, einen Wert zu einem **undefinierten Attribut eines Objekts** hinzuzufügen, das überprüft werden soll, wie:
+Das einfachste Beispiel ist, einen Wert zu einem **undefinierten Attribut eines Objekts** hinzuzufügen, das überprüft werden soll, wie:
 ```javascript
 if (user.admin) {
 ```
-Wenn das Attribut **`admin` undefiniert ist**, ist es möglich, eine PP auszunutzen und es mit etwas wie auf True zu setzen:
+Wenn das Attribut **`admin` undefiniert** ist, ist es möglich, eine PP auszunutzen und es mit etwas wie Folgendem auf True zu setzen:
 ```javascript
 Object.prototype.isAdmin = true
 let user = {}
@@ -213,7 +213,7 @@ client-side-prototype-pollution.md
 
 ### CVE-2019–11358: Prototype-Verschmutzungsangriff durch jQuery $ .extend
 
-[Für weitere Details siehe diesen Artikel](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) In jQuery kann die Funktion `$ .extend` zu einer Prototype-Verschmutzung führen, wenn die Deep-Copy-Funktion nicht ordnungsgemäß genutzt wird. Diese Funktion wird häufig zum Klonen von Objekten oder zum Zusammenführen von Eigenschaften aus einem Standardobjekt verwendet. Wenn sie jedoch falsch konfiguriert ist, können Eigenschaften, die für ein neues Objekt vorgesehen sind, stattdessen dem Prototyp zugewiesen werden. Zum Beispiel:
+[Für weitere Details siehe diesen Artikel](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) In jQuery kann die Funktion `$ .extend` zu Prototype-Verschmutzung führen, wenn die Deep-Copy-Funktionalität unsachgemäß genutzt wird. Diese Funktion wird häufig zum Klonen von Objekten oder zum Zusammenführen von Eigenschaften aus einem Standardobjekt verwendet. Wenn sie jedoch falsch konfiguriert ist, können Eigenschaften, die für ein neues Objekt vorgesehen sind, stattdessen dem Prototyp zugewiesen werden. Zum Beispiel:
 ```javascript
 $.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
 console.log({}.devMode) // Outputs: true
@@ -224,17 +224,15 @@ Diese Schwachstelle, identifiziert als CVE-2019–11358, zeigt, wie eine tiefe K
 
 [Für weitere Details siehe diesen Artikel](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7)
 
-[Lodash](https://www.npmjs.com/package/lodash) hatte ähnliche Prototyp-Verschmutzungsanfälligkeiten (CVE-2018–3721, CVE-2019–10744). Diese Probleme wurden in Version 4.17.11 behoben.
+[Lodash](https://www.npmjs.com/package/lodash) hatte ähnliche Schwachstellen in Bezug auf Prototyp-Verschmutzung (CVE-2018–3721, CVE-2019–10744). Diese Probleme wurden in Version 4.17.11 behoben.
 
 ### Ein weiteres Tutorial mit CVEs
 
-{{#ref}}
-https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2
-{{#endref}}
+- [https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2](https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2)
 
 ### Werkzeuge zur Erkennung von Prototyp-Verschmutzung
 
-- [**Server-Side-Prototype-Pollution-Gadgets-Scanner**](https://github.com/doyensec/Server-Side-Prototype-Pollution-Gadgets-Scanner): Burp Suite-Erweiterung, die entwickelt wurde, um serverseitige Prototyp-Verschmutzungsanfälligkeiten in Webanwendungen zu erkennen und zu analysieren. Dieses Tool automatisiert den Prozess des Scannens von Anfragen, um potenzielle Prototyp-Verschmutzungsprobleme zu identifizieren. Es nutzt bekannte Gadgets - Methoden zur Ausnutzung von Prototyp-Verschmutzung, um schädliche Aktionen auszuführen - mit besonderem Fokus auf Node.js-Bibliotheken.
+- [**Server-Side-Prototype-Pollution-Gadgets-Scanner**](https://github.com/doyensec/Server-Side-Prototype-Pollution-Gadgets-Scanner): Burp Suite-Erweiterung, die entwickelt wurde, um serverseitige Prototyp-Verschmutzungsanfälligkeiten in Webanwendungen zu erkennen und zu analysieren. Dieses Tool automatisiert den Prozess des Scannens von Anfragen, um potenzielle Probleme mit Prototyp-Verschmutzung zu identifizieren. Es nutzt bekannte Gadgets - Methoden zur Ausnutzung von Prototyp-Verschmutzung, um schädliche Aktionen auszuführen - und konzentriert sich insbesondere auf Node.js-Bibliotheken.
 - [**server-side-prototype-pollution**](https://github.com/portswigger/server-side-prototype-pollution): Diese Erweiterung identifiziert serverseitige Prototyp-Verschmutzungsanfälligkeiten. Sie verwendet Techniken, die in der [serverseitigen Prototyp-Verschmutzung](https://portswigger.net/research/server-side-prototype-pollution) beschrieben sind.
 
 ### AST Prototyp-Verschmutzung in NodeJS
@@ -249,8 +247,8 @@ Die Handlebars-Template-Engine ist anfällig für einen Prototyp-Verschmutzungsa
 
 Die Ausnutzung nutzt den AST (Abstract Syntax Tree), der von Handlebars erzeugt wird, und folgt diesen Schritten:
 
-1. **Manipulation des Parsers**: Zunächst erzwingt der Parser über den `NumberLiteral`-Knoten, dass Werte numerisch sind. Prototyp-Verschmutzung kann dies umgehen und das Einfügen von nicht-numerischen Zeichenfolgen ermöglichen.
-2. **Verarbeitung durch den Compiler**: Der Compiler kann ein AST-Objekt oder eine Zeichenfolgenvorlage verarbeiten. Wenn `input.type` gleich `Program` ist, wird die Eingabe als vorgeparst behandelt, was ausgenutzt werden kann.
+1. **Manipulation des Parsers**: Zunächst zwingt der Parser über den `NumberLiteral`-Knoten, dass Werte numerisch sind. Prototyp-Verschmutzung kann dies umgehen und das Einfügen von nicht-numerischen Zeichenfolgen ermöglichen.
+2. **Verarbeitung durch den Compiler**: Der Compiler kann ein AST-Objekt oder eine String-Vorlage verarbeiten. Wenn `input.type` gleich `Program` ist, wird die Eingabe als vorgeparst behandelt, was ausgenutzt werden kann.
 3. **Code-Injektion**: Durch Manipulation von `Object.prototype` kann beliebiger Code in die Template-Funktion injiziert werden, was zu einer Remote-Code-Ausführung führen kann.
 
 Ein Beispiel, das die Ausnutzung der Handlebars-Schwachstelle demonstriert:
@@ -283,11 +281,11 @@ console.log(eval("(" + template + ")")["main"].toString())
 ```
 Dieser Code zeigt, wie ein Angreifer beliebigen Code in eine Handlebars-Vorlage injizieren könnte.
 
-**Externe Referenz**: Ein Problem im Zusammenhang mit Prototype Pollution wurde in der 'flat'-Bibliothek gefunden, wie hier detailliert: [Issue on GitHub](https://github.com/hughsk/flat/issues/105).
+**Externer Verweis**: Ein Problem im Zusammenhang mit Prototypenverschmutzung wurde in der 'flat'-Bibliothek gefunden, wie hier detailliert: [Issue on GitHub](https://github.com/hughsk/flat/issues/105).
 
-**Externe Referenz**: [Issue im Zusammenhang mit Prototype Pollution in der 'flat'-Bibliothek](https://github.com/hughsk/flat/issues/105)
+**Externer Verweis**: [Issue im Zusammenhang mit Prototypenverschmutzung in der 'flat'-Bibliothek](https://github.com/hughsk/flat/issues/105)
 
-Beispiel für einen Prototype Pollution Exploit in Python:
+Beispiel für einen Prototypenverschmutzungs-Exploit in Python:
 ```python
 import requests
 
@@ -315,7 +313,7 @@ requests.get(TARGET_URL)
 ```
 #### Pug-Sicherheitsanfälligkeit
 
-Pug, ein weiterer Template-Engine, ist einem ähnlichen Risiko der Prototypenverschmutzung ausgesetzt. Detaillierte Informationen sind in der Diskussion über [AST Injection in Pug](https://blog.p6.is/AST-Injection/#Pug) verfügbar.
+Pug, eine weitere Template-Engine, ist einem ähnlichen Risiko der Prototypenverschmutzung ausgesetzt. Detaillierte Informationen sind in der Diskussion über [AST Injection in Pug](https://blog.p6.is/AST-Injection/#Pug) verfügbar.
 
 Beispiel für Prototypenverschmutzung in Pug:
 ```python
@@ -336,19 +334,19 @@ requests.get(TARGET_URL)
 ```
 ### Präventive Maßnahmen
 
-Um das Risiko der Prototyp-Verschmutzung zu verringern, können die unten aufgeführten Strategien angewendet werden:
+Um das Risiko der Prototype Pollution zu verringern, können die folgenden Strategien angewendet werden:
 
-1. **Objekt-Unveränderlichkeit**: Das `Object.prototype` kann durch Anwendung von `Object.freeze` unveränderlich gemacht werden.
+1. **Objekt-Immutabilität**: Das `Object.prototype` kann durch Anwendung von `Object.freeze` unveränderlich gemacht werden.
 2. **Eingangsvalidierung**: JSON-Eingaben sollten rigoros gegen das Schema der Anwendung validiert werden.
 3. **Sichere Merge-Funktionen**: Die unsichere Verwendung von rekursiven Merge-Funktionen sollte vermieden werden.
-4. **Prototyp-freie Objekte**: Objekte ohne Prototyp-Eigenschaften können mit `Object.create(null)` erstellt werden.
-5. **Verwendung von Map**: Anstelle von `Object` sollte `Map` zur Speicherung von Schlüssel-Wert-Paaren verwendet werden.
-6. **Bibliotheksaktualisierungen**: Sicherheitsupdates können durch regelmäßige Aktualisierungen von Bibliotheken integriert werden.
-7. **Linter und statische Analysetools**: Verwenden Sie Tools wie ESLint mit geeigneten Plugins, um Schwachstellen der Prototyp-Verschmutzung zu erkennen und zu verhindern.
-8. **Code-Überprüfungen**: Führen Sie gründliche Code-Überprüfungen durch, um potenzielle Risiken im Zusammenhang mit der Prototyp-Verschmutzung zu identifizieren und zu beheben.
-9. **Sicherheitsschulung**: Schulen Sie Entwickler über die Risiken der Prototyp-Verschmutzung und bewährte Praktiken zum Schreiben sicherer Codes.
+4. **Prototyplose Objekte**: Objekte ohne Prototyp-Eigenschaften können mit `Object.create(null)` erstellt werden.
+5. **Verwendung von Map**: Anstelle von `Object` sollte `Map` zum Speichern von Schlüssel-Wert-Paaren verwendet werden.
+6. **Bibliotheksupdates**: Sicherheitsupdates können durch regelmäßige Aktualisierungen von Bibliotheken integriert werden.
+7. **Linter und statische Analysetools**: Verwenden Sie Tools wie ESLint mit geeigneten Plugins, um Prototype Pollution-Schwachstellen zu erkennen und zu verhindern.
+8. **Code-Überprüfungen**: Führen Sie gründliche Code-Überprüfungen durch, um potenzielle Risiken im Zusammenhang mit Prototype Pollution zu identifizieren und zu beheben.
+9. **Sicherheitsschulung**: Schulen Sie Entwickler über die Risiken der Prototype Pollution und bewährte Praktiken für das Schreiben sicherer Codes.
 10. **Vorsicht bei der Verwendung von Bibliotheken**: Seien Sie vorsichtig bei der Verwendung von Drittanbieterbibliotheken. Bewerten Sie deren Sicherheitslage und überprüfen Sie deren Code, insbesondere bei denen, die Objekte manipulieren.
-11. **Laufzeitschutz**: Setzen Sie Laufzeitschutzmechanismen ein, wie die Verwendung von sicherheitsfokussierten npm-Paketen, die Angriffe durch Prototyp-Verschmutzung erkennen und verhindern können.
+11. **Laufzeitschutz**: Setzen Sie Laufzeitschutzmechanismen ein, wie die Verwendung von sicherheitsfokussierten npm-Paketen, die Prototype Pollution-Angriffe erkennen und verhindern können.
 
 ## Referenzen