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

---
 .../README.md                                 | 64 +++++++++----------
 1 file changed, 31 insertions(+), 33 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 6f0b8886d..08c861e66 100644
--- a/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
+++ b/src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md
@@ -33,15 +33,15 @@ employee1.__proto__
 ```
 ### Prototypes in JavaScript
 
-JavaScript stel die wysiging, toevoeging of verwydering van prototipe-attribuutte in staat tydens uitvoering. Hierdie buigsaamheid stel die dinamiese uitbreiding van klasfunksies in staat.
+JavaScript laat die wijziging, toevoeging of verwydering van prototipe-attribuutte tydens uitvoering toe. Hierdie buigsaamheid stel die dinamiese uitbreiding van klasfunksies in staat.
 
-Funksies soos `toString` en `valueOf` kan verander word om hul gedrag te verander, wat die aanpasbare aard van JavaScript se prototipe-stelsel demonstreer.
+Funksies soos `toString` en `valueOf` kan verander word om hul gedrag te verander, wat die aanpasbare aard van JavaScript se prototipesisteem demonstreer.
 
 ## Inheritance
 
 In prototipe-gebaseerde programmering word eienskappe/metodes geërf deur voorwerpe van klasse. Hierdie klasse word geskep deur eienskappe/metodes by 'n instansie van 'n ander klas of by 'n leë voorwerp te voeg.
 
-Daar moet op gelet word dat wanneer 'n eienskap by 'n voorwerp gevoeg word wat as die prototipe vir ander voorwerpe dien (soos `myPersonObj`), die geërfde voorwerpe toegang tot hierdie nuwe eienskap verkry. Hierdie eienskap word egter nie outomaties vertoon nie, tensy dit eksplisiet aangeroep word.
+Dit moet opgemerk word dat wanneer 'n eienskap by 'n voorwerp gevoeg word wat as die prototipe vir ander voorwerpe dien (soos `myPersonObj`), die erflike voorwerpe toegang tot hierdie nuwe eienskap verkry. Hierdie eienskap word egter nie outomaties vertoon nie, tensy dit eksplisiet aangeroep word.
 
 ## \_\_proto\_\_ pollution <a href="#id-0d0a" id="id-0d0a"></a>
 
@@ -76,7 +76,7 @@ car1.announce() // Outputs "Beep beep!"
 car1.__proto__.__proto__.isVehicle = true
 console.log(car1.isVehicle) // Outputs true
 ```
-## prototype besoedeling
+## prototype pollution
 
 Vir 'n scenario waar `__proto__` gebruik beperk is, is die aanpassing van 'n funksie se prototipe 'n alternatief:
 ```javascript
@@ -100,7 +100,7 @@ car1.constructor.prototype.isElectric = true
 ```
 Dit raak slegs voorwerpe wat van die `Vehicle` konstruktors gemaak is, en gee hulle die `beep`, `hasWheels`, `honk`, en `isElectric` eienskappe.
 
-Twee metodes om JavaScript voorwerpe globaal te beïnvloed deur prototype besoedeling sluit in:
+Twee metodes om JavaScript voorwerpe globaal te beïnvloed deur middel van prototipe besoedeling sluit in:
 
 1. Besoedeling van die `Object.prototype` direk:
 ```javascript
@@ -117,11 +117,11 @@ console.log("Hello!")
 ```
 Na hierdie operasies kan elke JavaScript-objek `goodbye` en `greet` metodes uitvoer.
 
-## Besoedeling van ander objek
+## Besmetting van ander objek
 
 ### Van 'n klas na Object.prototype
 
-In 'n scenario waar jy 'n **spesifieke objek kan besoedel** en jy moet **by `Object.prototype` kom**, kan jy daarna soek met iets soos die volgende kode:
+In 'n scenario waar jy **'n spesifieke objek kan besmet** en jy moet **by `Object.prototype` kom**, kan jy daarna soek met iets soos die volgende kode:
 ```javascript
 // From https://blog.huli.tw/2022/05/02/en/intigriti-revenge-challenge-author-writeup/
 
@@ -144,7 +144,7 @@ console.log(key1 + "." + key2)
 ```
 ### Array elements pollution
 
-Let daarop dat soos jy die eienskappe van voorwerpe in JS kan besoedel, as jy toegang het om 'n array te besoedel, kan jy ook **waardes van die array** besoedel wat **deur indekse** toeganklik is (let daarop dat jy nie waardes kan oorskryf nie, so jy moet indekse besoedel wat op een of ander manier gebruik word maar nie geskryf word nie).
+Let wel dat soos jy eienskappe van voorwerpe in JS kan besoedel, as jy toegang het om 'n array te besoedel, kan jy ook **waardes van die array** besoedel wat **deur indekse** toeganklik is (let wel dat jy nie waardes kan oorskryf nie, so jy moet indekse besoedel wat op een of ander manier gebruik word maar nie geskryf word nie).
 ```javascript
 c = [1, 2]
 a = []
@@ -154,9 +154,9 @@ b[0] //undefined
 b[1] //"yolo"
 c[1] // 2 -- not
 ```
-### Html element besoedeling
+### Html elements pollution
 
-Wanneer 'n HTML-element via JS gegenereer word, is dit moontlik om die **`innerHTML`** attribuut te **oorskryf** om **arbitraire HTML-kode** te skryf. [Idea en voorbeeld van hierdie skrywe](https://blog.huli.tw/2022/04/25/en/intigriti-0422-xss-challenge-author-writeup/).
+Wanneer 'n HTML-element via JS gegenereer word, is dit moontlik om die **`innerHTML`** attribuut te **oorskryf** om **arbitraire HTML-kode** te laat skryf. [Idea and example from this writeup](https://blog.huli.tw/2022/04/25/en/intigriti-0422-xss-challenge-author-writeup/).
 ```javascript
 // Create element
 devSettings["root"] = document.createElement('main')
@@ -171,9 +171,9 @@ settings[root][ownerDocument][body][innerHTML]="<svg onload=alert(document.domai
 
 ### Basiese Voorbeeld
 
-'n Prototype besoedeling gebeur weens 'n fout in die toepassing wat die oorskrywing van eienskappe op `Object.prototype` toelaat. Dit beteken dat aangesien die meeste voorwerpe hul eienskappe van `Object.prototype` aflei
+'n Prototipe besoedeling gebeur weens 'n fout in die aansoek wat toelaat dat eienskappe op `Object.prototype` oorgeskryf word. Dit beteken dat omdat die meeste voorwerpe hul eienskappe van `Object.prototype` aflei
 
-Die maklikste voorbeeld is om 'n waarde by 'n **onbepaalde attribuut van 'n voorwerp** te voeg wat gaan nagegaan word, soos:
+Die maklikste voorbeeld is om 'n waarde by 'n **onbepaalde eienskap van 'n voorwerp** te voeg wat gaan nagegaan word, soos:
 ```javascript
 if (user.admin) {
 ```
@@ -183,9 +183,9 @@ Object.prototype.isAdmin = true
 let user = {}
 user.isAdmin // true
 ```
-Die meganisme agter hierdie behels die manipulasie van eienskappe sodat, as 'n aanvaller beheer het oor sekere insette, hulle die prototipe van alle voorwerpe in die aansoek kan wysig. Hierdie manipulasie behels tipies die instelling van die `__proto__` eienskap, wat, in JavaScript, sinoniem is met die direkte wysiging van 'n voorwerp se prototipe.
+Die meganisme agter hierdie behels die manipulasie van eienskappe sodat, indien 'n aanvaller beheer het oor sekere insette, hulle die prototipe van alle voorwerpe in die aansoek kan wysig. Hierdie manipulasie behels tipies die instelling van die `__proto__` eienskap, wat, in JavaScript, sinoniem is met die direkte wysiging van 'n voorwerp se prototipe.
 
-Die toestande waaronder hierdie aanval suksesvol uitgevoer kan word, soos uiteengesit in 'n spesifieke [studie](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf), sluit in:
+Die toestande waaronder hierdie aanval suksesvol uitgevoer kan word, soos uiteengesit in 'n spesifieke [study](https://github.com/HoLyVieR/prototype-pollution-nsec18/blob/master/paper/JavaScript_prototype_pollution_attack_in_NodeJS.pdf), sluit in:
 
 - Om 'n rekursiewe samesmelting uit te voer.
 - Eienskappe te definieer op grond van 'n pad.
@@ -213,12 +213,12 @@ client-side-prototype-pollution.md
 
 ### CVE-2019–11358: Prototype besoedeling aanval deur jQuery $ .extend
 
-[Vir verdere besonderhede, kyk na hierdie artikel](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) In jQuery kan die `$ .extend` funksie lei tot prototype besoedeling as die diep kopie kenmerk verkeerdelik gebruik word. Hierdie funksie word algemeen gebruik om voorwerpe te kloon of eienskappe van 'n standaard voorwerp te meng. egter, wanneer verkeerd geconfigureer, kan eienskappe wat bedoel is vir 'n nuwe voorwerp aan die prototype toegeken word. Byvoorbeeld:
+[Vir verdere besonderhede, kyk na hierdie artikel](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7) In jQuery kan die `$ .extend` funksie lei tot prototype besoedeling as die diep kopie kenmerk verkeerdelik gebruik word. Hierdie funksie word algemeen gebruik om voorwerpe te kloon of eienskappe van 'n standaard voorwerp te meng. egter, wanneer verkeerd geconfigureer, kan eienskappe wat bedoel is vir 'n nuwe voorwerp aan die prototipe toegeken word. Byvoorbeeld:
 ```javascript
 $.extend(true, {}, JSON.parse('{"__proto__": {"devMode": true}}'))
 console.log({}.devMode) // Outputs: true
 ```
-Hierdie kwesbaarheid, geïdentifiseer as CVE-2019–11358, illustreer hoe 'n diep kopie per ongeluk die prototipe kan verander, wat kan lei tot potensiële sekuriteitsrisiko's, soos ongeoorloofde admin toegang as eienskappe soos `isAdmin` nagegaan word sonder behoorlike bestaan verifikasie.
+Hierdie kwesbaarheid, geïdentifiseer as CVE-2019–11358, illustreer hoe 'n diep kopie per ongeluk die prototipe kan verander, wat kan lei tot potensiële sekuriteitsrisiko's, soos ongeoorloofde admin-toegang as eienskappe soos `isAdmin` nagegaan word sonder behoorlike bestaansertifikasie.
 
 ### CVE-2018–3721, CVE-2019–10744: Prototipe besoedeling aanval deur lodash
 
@@ -226,16 +226,14 @@ Hierdie kwesbaarheid, geïdentifiseer as CVE-2019–11358, illustreer hoe 'n die
 
 [Lodash](https://www.npmjs.com/package/lodash) het soortgelyke prototipe besoedeling kwesbaarhede ondervind (CVE-2018–3721, CVE-2019–10744). Hierdie probleme is in weergawe 4.17.11 aangespreek.
 
-### Nog 'n tutoriaal met CVEs
+### Nog 'n tutoriaal met CVE's
 
-{{#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)
 
 ### Gereedskap om Prototipe Besoedeling te Detecteer
 
 - [**Server-Side-Prototype-Pollution-Gadgets-Scanner**](https://github.com/doyensec/Server-Side-Prototype-Pollution-Gadgets-Scanner): Burp Suite uitbreiding ontwerp om server-kant prototipe besoedeling kwesbaarhede in webtoepassings te detecteer en te analiseer. Hierdie hulpmiddel outomatiseer die proses van skandering van versoeke om potensiële prototipe besoedeling probleme te identifiseer. Dit benut bekende gadgets - metodes om prototipe besoedeling te benut om skadelike aksies uit te voer - met spesifieke fokus op Node.js biblioteke.
-- [**server-side-prototype-pollution**](https://github.com/portswigger/server-side-prototype-pollution): Hierdie uitbreiding identifiseer server kant prototipe besoedeling kwesbaarhede. Dit gebruik tegnieke wat beskryf word in die [server side prototype pollution](https://portswigger.net/research/server-side-prototype-pollution).
+- [**server-side-prototype-pollution**](https://github.com/portswigger/server-side-prototype-pollution): Hierdie uitbreiding identifiseer server-kant prototipe besoedeling kwesbaarhede. Dit gebruik tegnieke wat beskryf word in die [server side prototype pollution](https://portswigger.net/research/server-side-prototype-pollution).
 
 ### AST Prototipe Besoedeling in NodeJS
 
@@ -250,7 +248,7 @@ Die Handlebars sjabloon enjin is kwesbaar vir 'n prototipe besoedeling aanval. H
 Die eksploitasiestap benut die AST (Abstract Syntax Tree) wat deur Handlebars geproduseer word, volgens hierdie stappe:
 
 1. **Manipulasie van die Parser**: Aanvanklik, die parser, via die `NumberLiteral` node, afdwing dat waardes numeries is. Prototipe besoedeling kan dit omseil, wat die invoeging van nie-numeriese strings moontlik maak.
-2. **Hantering deur die Compiler**: Die compiler kan 'n AST Object of 'n string sjabloon verwerk. As `input.type` gelyk is aan `Program`, word die invoer as vooraf-geparseer beskou, wat benut kan word.
+2. **Hantering deur die Compiler**: Die compiler kan 'n AST Object of 'n string sjabloon verwerk. As `input.type` gelyk is aan `Program`, word die invoer as vooraf-geparseer beskou, wat uitgebuit kan word.
 3. **Inspuiting van Kode**: Deur manipulasie van `Object.prototype`, kan 'n mens arbitrêre kode in die sjabloon funksie inspuit, wat kan lei tot afstandkode-uitvoering.
 
 'n Voorbeeld wat die eksploitering van die Handlebars kwesbaarheid demonstreer:
@@ -281,13 +279,13 @@ const template = Handlebars.precompile(source)
 
 console.log(eval("(" + template + ")")["main"].toString())
 ```
-Hierdie kode demonstreer hoe 'n aanvaller willekeurige kode in 'n Handlebars-sjabloon kan inspuit.
+Hierdie kode demonstreer hoe 'n aanvaller arbitrêre kode in 'n Handlebars-sjabloon kan inspuit.
 
-**Buitelandse Verwysing**: 'n Probleem rakende prototipe besoedeling is in die 'flat' biblioteek gevind, soos hier beskryf: [Issue on GitHub](https://github.com/hughsk/flat/issues/105).
+**Buitelandse Verwysing**: 'n Probleem rakende prototipe besoedeling is in die 'flat' biblioteek gevind, soos hier gedetailleerd: [Issue on GitHub](https://github.com/hughsk/flat/issues/105).
 
 **Buitelandse Verwysing**: [Issue related to prototype pollution in the 'flat' library](https://github.com/hughsk/flat/issues/105)
 
-Voorbeeld van prototipe besoedeling eksploit in Python:
+Voorbeeld van prototipe besoedeling uitbuiting in Python:
 ```python
 import requests
 
@@ -334,21 +332,21 @@ requests.post(TARGET_URL + '/vulnerable', json = {
 # execute
 requests.get(TARGET_URL)
 ```
-### Voorkomingsmaatreëls
+### Voorkomende Maatreëls
 
-Om die risiko van prototipebesoedeling te verminder, kan die onderstaande strategieë toegepas word:
+Om die risiko van prototipe besoedeling te verminder, kan die onderstaande strategieë toegepas word:
 
-1. **Objek Immutabiliteit**: Die `Object.prototype` kan onwrikbaar gemaak word deur `Object.freeze` toe te pas.
+1. **Objek Immutabiliteit**: Die `Object.prototype` kan onveranderlik gemaak word deur `Object.freeze` toe te pas.
 2. **Invoer Validasie**: JSON-invoere moet streng gevalideer word teen die aansoek se skema.
-3. **Veilige Samevoegfunksies**: Die onveilige gebruik van rekursiewe samevoegfunksies moet vermy word.
+3. **Veilige Samevoeg Funksies**: Die onveilige gebruik van rekursiewe samevoeg funksies moet vermy word.
 4. **Prototipe-loos Objekte**: Objekte sonder prototipe eienskappe kan geskep word met `Object.create(null)`.
 5. **Gebruik van Map**: In plaas van `Object`, moet `Map` gebruik word om sleutel-waarde pare te stoor.
 6. **Biblioteek Opdaterings**: Sekuriteitsopdaterings kan ingesluit word deur gereeld biblioteke op te dateer.
-7. **Linter en Statiese Analise Gereedskap**: Gebruik gereedskap soos ESLint met toepaslike plugins om prototipebesoedeling kwesbaarhede te ontdek en te voorkom.
-8. **Kode Hersienings**: Implementeer deeglike kode hersienings om potensiële risiko's rakende prototipebesoedeling te identifiseer en te verhelp.
-9. **Sekuriteitsopleiding**: Onderwys ontwikkelaars oor die risiko's van prototipebesoedeling en beste praktyke vir die skryf van veilige kode.
+7. **Linter en Statiese Analise Gereedskap**: Gebruik gereedskap soos ESLint met toepaslike plugins om prototipe besoedeling kwesbaarhede te ontdek en te voorkom.
+8. **Kode Hersienings**: Implementeer deeglike kode hersienings om potensiële risiko's rakende prototipe besoedeling te identifiseer en te verhelp.
+9. **Sekuriteitsopleiding**: Onderwys ontwikkelaars oor die risiko's van prototipe besoedeling en beste praktyke vir die skryf van veilige kode.
 10. **Gebruik van Biblioteke met Versigtigheid**: Wees versigtig wanneer jy derdeparty-biblioteke gebruik. Evalueer hul sekuriteitsposisie en hersien hul kode, veral dié wat objekte manipuleer.
-11. **Runtime Beskerming**: Gebruik runtime beskermingsmeganismes soos om sekuriteitsgefokusde npm-pakkette te gebruik wat prototipebesoedeling aanvalle kan ontdek en voorkom.
+11. **Runtime Beskerming**: Gebruik runtime beskermingsmeganismes soos om sekuriteitsgefokusde npm-pakkette te gebruik wat prototipe besoedeling aanvalle kan ontdek en voorkom.
 
 ## Verwysings